diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f3435b4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,73 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +pip-wheel-metadata/ +share/python-wheels/ + +# Virtual environments +venv/ +ENV/ +env/ +.venv/ +.ENV/ + +# IDEs and editors +.vscode/ +.idea/ + +# Unit test / coverage +.coverage +.coverage.* +.pytest_cache/ +htmlcov/ +.tox/ +.nox/ +.cache/ +nosetests.xml +coverage.xml + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Pyre +.pyre/ + +# MyPy +.mypy_cache/ + +# Jupyter +.ipynb_checkpoints/ + +# SQLite +*.sqlite3 +*.db + +# macOS +.DS_Store + +# Logs +*.log + +# Editor temp files +*~ diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..ad9c975 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +fastapi +uvicorn +strawberry-graphql +starlette \ No newline at end of file diff --git a/tutorial1/intro.py b/tutorial1/intro.py index d60a7f2..53288ff 100644 --- a/tutorial1/intro.py +++ b/tutorial1/intro.py @@ -1,16 +1,24 @@ from fastapi import FastAPI -import graphene -from starlette.graphql import GraphQLApp +import strawberry +from strawberry.fastapi import GraphQLRouter -class calculator(graphene.ObjectType): - concat=graphene.String(a=graphene.String(),b=graphene.String()) - add=graphene.String(a=graphene.Int(),b=graphene.Int()) - def resolve_concat(self,info,a,b): - return a+" "+b - def resolve_add(self,info,a,b): - return a+b +@strawberry.type +class calculator: -app=FastAPI() -app.add_route("/",GraphQLApp(schema=graphene.Schema(query=calculator))) - + @strawberry.field + def concat(self, a: str, b: str) -> str: + return a + " " + b + + @strawberry.field + def add(self, a: int, b: int) -> int: + return a + b + + +schema = strawberry.Schema(query=calculator) + +graphql_app = GraphQLRouter(schema) + +app = FastAPI() + +app.include_router(graphql_app, prefix="/graphql") diff --git a/tutorial2/usecase1.py b/tutorial2/usecase1.py index 747c51c..41acd77 100644 --- a/tutorial2/usecase1.py +++ b/tutorial2/usecase1.py @@ -1,15 +1,26 @@ -import graphene +import strawberry from fastapi import FastAPI -from starlette.graphql import GraphQLApp -course_name="computer sience" -course_time_year=1 -class course(graphene.ObjectType): - name= graphene.String() - duration=graphene.Int() - def resolve_name(self,info): +from strawberry.fastapi import GraphQLRouter + +course_name = "computer science" +course_time_year = 1 + + +@strawberry.type +class Query: + @strawberry.field + def name(self) -> str: return course_name - def resolve_duration(self,into): + + @strawberry.field + def duration(self) -> int: return course_time_year -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=course))) -print(graphene.Schema(query=course)) \ No newline at end of file + + +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) \ No newline at end of file diff --git a/tutorial2/usecase2.py b/tutorial2/usecase2.py index b4f3efb..978dc1f 100644 --- a/tutorial2/usecase2.py +++ b/tutorial2/usecase2.py @@ -1,13 +1,8 @@ -import graphene +import strawberry from fastapi import FastAPI -from graphene.types.objecttype import ObjectType -from starlette.graphql import GraphQLApp -from graphene import ObjectType as ot -from graphene import String as st -from graphene import Int as int -from graphene import List as li - -data=[ +from strawberry.fastapi import GraphQLRouter + +data = [ { "name": "Roni", "city": "Cologne", @@ -27,15 +22,24 @@ } ] -class students(ot): - name=st() - city=st() - country=st() - -class person(ot): - student=li(students) - def resolve_student(self,info): - return data -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=person))) -print(graphene.Schema(query=person)) +@strawberry.type +class Student: + name: str + city: str + country: str + + +@strawberry.type +class Query: + @strawberry.field + def student(self) -> list[Student]: + return [Student(**d) for d in data] + + +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) diff --git a/tutorial3/main.py b/tutorial3/main.py index c669573..29722f4 100644 --- a/tutorial3/main.py +++ b/tutorial3/main.py @@ -1,9 +1,13 @@ -import graphene +import strawberry from fastapi import FastAPI -from starlette.graphql import GraphQLApp -from mapping import query +from strawberry.fastapi import GraphQLRouter +from .mapping import Query -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=query))) -print(graphene.Schema(query=query)) \ No newline at end of file +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) \ No newline at end of file diff --git a/tutorial3/mapping.py b/tutorial3/mapping.py index aa630aa..99b7497 100644 --- a/tutorial3/mapping.py +++ b/tutorial3/mapping.py @@ -1,8 +1,10 @@ -import graphene -from schema import courses -from data import read_data +import strawberry +from .schema import Course +from .data import read_data -class query(graphene.ObjectType): - course=graphene.List(courses) - def resolve_course(self,info): - return read_data() \ No newline at end of file + +@strawberry.type +class Query: + @strawberry.field + def course(self) -> list[Course]: + return [Course(**c) for c in read_data()] diff --git a/tutorial3/schema.py b/tutorial3/schema.py index 92cb5bb..e465222 100644 --- a/tutorial3/schema.py +++ b/tutorial3/schema.py @@ -1,6 +1,8 @@ -import graphene +import strawberry -class courses(graphene.ObjectType): - name=graphene.String() - level=graphene.String() - duration_in_year=graphene.Int() \ No newline at end of file + +@strawberry.type +class Course: + name: str + level: str + duration_in_year: int diff --git a/tutorial4/data.py b/tutorial4/data.py index f2fa423..cb3d20f 100644 --- a/tutorial4/data.py +++ b/tutorial4/data.py @@ -1,12 +1,21 @@ import csv +from pathlib import Path + + def read_file(): - with open("data.csv")as f1: - data=csv.reader(f1,delimiter=",") - li=[] - i=0 + file_path = Path(__file__).resolve().parent / "data.csv" + with open(file_path) as f1: + data = csv.reader(f1, delimiter=",") + li = [] + i = 0 for row in data: - if(i>0): - li.append({"name":row[0],"city":row[1],"designation":row[2],"experience_in_year":row[3]}) - i=i+1 - f1.close() - return(li) \ No newline at end of file + if i > 0: + li.append({ + "name": row[0], + "city": row[1], + "designation": row[2], + "experience_in_year": row[3], + }) + i += 1 + + return li \ No newline at end of file diff --git a/tutorial4/main.py b/tutorial4/main.py index 5020e36..29722f4 100644 --- a/tutorial4/main.py +++ b/tutorial4/main.py @@ -1,8 +1,13 @@ -import graphene +import strawberry from fastapi import FastAPI -from starlette.graphql import GraphQLApp -from mapping import query +from strawberry.fastapi import GraphQLRouter +from .mapping import Query -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=query))) -print(graphene.Schema(query=query)) \ No newline at end of file + +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) \ No newline at end of file diff --git a/tutorial4/mapping.py b/tutorial4/mapping.py index 75d5684..fe2c6eb 100644 --- a/tutorial4/mapping.py +++ b/tutorial4/mapping.py @@ -1,8 +1,10 @@ -import graphene -from schema import emp -from data import read_file +import strawberry +from .schema import Employee +from .data import read_file -class query(graphene.ObjectType): - employee=graphene.List(emp) - def resolve_employee(self,info): - return read_file() \ No newline at end of file + +@strawberry.type +class Query: + @strawberry.field + def employee(self) -> list[Employee]: + return [Employee(**e) for e in read_file()] \ No newline at end of file diff --git a/tutorial4/schema.py b/tutorial4/schema.py index 6d784f5..c48ba83 100644 --- a/tutorial4/schema.py +++ b/tutorial4/schema.py @@ -1,7 +1,9 @@ -import graphene +import strawberry -class emp(graphene.ObjectType): - name=graphene.String() - city=graphene.String() - designation=graphene.String() - experience_in_year=graphene.String() \ No newline at end of file + +@strawberry.type +class Employee: + name: str + city: str + designation: str + experience_in_year: str \ No newline at end of file diff --git a/tutorial5/data.py b/tutorial5/data.py index 46855a5..130c63b 100644 --- a/tutorial5/data.py +++ b/tutorial5/data.py @@ -1,29 +1,25 @@ -data=data=[ -{ - "city":"kolkata", - "temperature":"34" -}, -{ - "city":"mumbai", - "temperature":"29" -}, -{ - "city":"chennai", - "temperature":"38" -}, -{ - "city":"banglore", - "temperature":"24" -}, -{ - "city":"pune", - "temperature":"30" -}, -{ - "city":"hyderabad", - "temperature":"32" -}, +data = [ + { + "city": "kolkata", + "temperature": "34", + }, + { + "city":"chennai", + "temperature":"38" + }, + { + "city":"banglore", + "temperature":"24" + }, + { + "city":"pune", + "temperature":"30" + }, + { + "city":"hyderabad", + "temperature":"32" + }, ] def read_data(): - return data \ No newline at end of file + return data diff --git a/tutorial5/main.py b/tutorial5/main.py index e3fb8b8..c97f51f 100644 --- a/tutorial5/main.py +++ b/tutorial5/main.py @@ -1,9 +1,13 @@ +import strawberry from fastapi import FastAPI -import graphene -from graphene.types import schema -from starlette.graphql import GraphQLApp -from mapping import query - -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=query))) -print(graphene.Schema(query=query)) +from strawberry.fastapi import GraphQLRouter +from .mapping import Query + + +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) diff --git a/tutorial5/mapping.py b/tutorial5/mapping.py index 22b979d..32b06a5 100644 --- a/tutorial5/mapping.py +++ b/tutorial5/mapping.py @@ -1,18 +1,17 @@ -import graphene -from schema import weather -from data import read_data - -class query(graphene.ObjectType): - city_temp=graphene.Field(weather,city=graphene.String()) - def resolve_city_temp(self,info,city): - data=read_data() - for row in data: - if row["city"]==city: - return row - return { - "city":city, - "temperature":"not found in the sequence" - } +import strawberry +from .schema import Weather +from .data import read_data - \ No newline at end of file +@strawberry.type +class Query: + @strawberry.field + def city_temp(self, city: str) -> Weather: + data = read_data() + for row in data: + if row["city"] == city: + return Weather(**row) + return Weather( + city=city, + temperature="not found in the sequence" + ) diff --git a/tutorial5/schema.py b/tutorial5/schema.py index c8b0f1c..e8dc0de 100644 --- a/tutorial5/schema.py +++ b/tutorial5/schema.py @@ -1,6 +1,7 @@ -import graphene +import strawberry -class weather(graphene.ObjectType): - city=graphene.String() - temperature=graphene.String() \ No newline at end of file +@strawberry.type +class Weather: + city: str + temperature: str \ No newline at end of file diff --git a/tutorial6/main.py b/tutorial6/main.py index 41d256a..950161b 100644 --- a/tutorial6/main.py +++ b/tutorial6/main.py @@ -1,18 +1,12 @@ -import graphene +import strawberry from fastapi import FastAPI -from starlette.graphql import GraphQLApp +from strawberry.fastapi import GraphQLRouter +from .mapping import Query -class myquery(graphene.ObjectType): - class Meta: - name="typefrommetaclass1" - description="description from metaclass1" - hello=graphene.String(description="hello string") - bye=graphene.String(description="bye string") - def resolve_hello(self,info): - - return "hello world!!!" - def resolve_bye(self,info): - return "good bye!!" -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=myquery))) -print(graphene.Schema(query=myquery)) \ No newline at end of file +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) diff --git a/tutorial6/mapping.py b/tutorial6/mapping.py new file mode 100644 index 0000000..da685bf --- /dev/null +++ b/tutorial6/mapping.py @@ -0,0 +1,12 @@ +import strawberry + + +@strawberry.type +class Query: + @strawberry.field(description="hello string") + def hello(self) -> str: + return "hello world!!!" + + @strawberry.field(description="bye string") + def bye(self) -> str: + return "good bye!!" diff --git a/tutorial7/main.py b/tutorial7/main.py index 1b3632c..0a308f9 100644 --- a/tutorial7/main.py +++ b/tutorial7/main.py @@ -1,32 +1,12 @@ -import graphene +import strawberry from fastapi import FastAPI -from starlette.graphql import GraphQLApp +from strawberry.fastapi import GraphQLRouter +from .mapping import Query -class player(graphene.Interface): - name=graphene.String() - country=graphene.String() +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) -class footballplayer(graphene.ObjectType): - class Meta: - interfaces=(player,) - position=graphene.String() +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") -class cricketplayer(graphene.ObjectType): - class Meta: - interfaces=(player,) - battingorder=graphene.Int() - -class query(graphene.ObjectType): - class Meta: - name="interfacequery" - description="implements field type from interface" - fplayer=graphene.Field(footballplayer,description="coming from football player interface") - def resolve_fplayer(self,info): - return {"name":"player1","country":"Spain","position":"Central Back"} - cplayer=graphene.Field(cricketplayer,description="coming from cricket player interface") - def resolve_cplayer(self,info): - return {"name":"player2","country":"India","battingorder":1} - -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=query))) -print(graphene.Schema(query=query)) +print(schema) diff --git a/tutorial7/mapping.py b/tutorial7/mapping.py new file mode 100644 index 0000000..1d29e0a --- /dev/null +++ b/tutorial7/mapping.py @@ -0,0 +1,28 @@ +import strawberry + + +@strawberry.interface +class Player: + name: str + country: str + + +@strawberry.type +class FootballPlayer(Player): + position: str + + +@strawberry.type +class CricketPlayer(Player): + battingorder: int + + +@strawberry.type +class Query: + @strawberry.field(description="coming from football player interface") + def fplayer(self) -> FootballPlayer: + return FootballPlayer(name="player1", country="Spain", position="Central Back") + + @strawberry.field(description="coming from cricket player interface") + def cplayer(self) -> CricketPlayer: + return CricketPlayer(name="player2", country="India", battingorder=1) diff --git a/tutorial8/data.py b/tutorial8/data.py index bc9f977..cc2159c 100644 --- a/tutorial8/data.py +++ b/tutorial8/data.py @@ -26,7 +26,7 @@ }, { "name":"virat", - "country":"indian", + "country":"india", "battingorder":2 }, { diff --git a/tutorial8/main.py b/tutorial8/main.py index 5020e36..950161b 100644 --- a/tutorial8/main.py +++ b/tutorial8/main.py @@ -1,8 +1,12 @@ -import graphene +import strawberry from fastapi import FastAPI -from starlette.graphql import GraphQLApp -from mapping import query +from strawberry.fastapi import GraphQLRouter +from .mapping import Query -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=query))) -print(graphene.Schema(query=query)) \ No newline at end of file +schema = strawberry.Schema(query=Query) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) diff --git a/tutorial8/mapping.py b/tutorial8/mapping.py index c135d11..4418358 100644 --- a/tutorial8/mapping.py +++ b/tutorial8/mapping.py @@ -1,17 +1,16 @@ -import graphene -from schema import footballplayer,cricketplayer -from data import read_data +import strawberry +from .schema import FootballPlayer, CricketPlayer +from .data import read_data -class query(graphene.ObjectType): - class Meta: - name="interfacequery" - description="list with interface" - fplayer=graphene.List(footballplayer,description="list object type implements interface") - def resolve_fplayer(self,info): - data=read_data() - return data[0]["footballplayer"] - - cplayer=graphene.List(cricketplayer,description="list object type implements interface") - def resolve_cplayer(self,info): - data=read_data() - return data[0]["cricketplayer"] \ No newline at end of file + +@strawberry.type +class Query: + @strawberry.field(description="list object type implements interface") + def fplayer(self) -> list[FootballPlayer]: + data = read_data() + return [FootballPlayer(**p) for p in data[0]["footballplayer"]] + + @strawberry.field(description="list object type implements interface") + def cplayer(self) -> list[CricketPlayer]: + data = read_data() + return [CricketPlayer(**p) for p in data[0]["cricketplayer"]] \ No newline at end of file diff --git a/tutorial8/schema.py b/tutorial8/schema.py index 7854627..b6adfef 100644 --- a/tutorial8/schema.py +++ b/tutorial8/schema.py @@ -1,15 +1,17 @@ -import graphene +import strawberry -class player(graphene.Interface): - name=graphene.String() - country=graphene.String() -class footballplayer(graphene.ObjectType): - class Meta: - interfaces=(player,) - position=graphene.String() +@strawberry.interface +class Player: + name: str + country: str -class cricketplayer(graphene.ObjectType): - class Meta: - interfaces=(player,) - battingorder=graphene.Int() \ No newline at end of file + +@strawberry.type +class FootballPlayer(Player): + position: str + + +@strawberry.type +class CricketPlayer(Player): + battingorder: int \ No newline at end of file diff --git a/tutorial9/data.py b/tutorial9/data.py index 1ebef3f..a3fc66f 100644 --- a/tutorial9/data.py +++ b/tutorial9/data.py @@ -1,4 +1,4 @@ -data=data=[ +data = [ { "footballplayer":[ { @@ -30,7 +30,7 @@ }, { "name":"virat", - "country":"indian", + "country":"india", "battingorder":2, "type":"cricketplayer" }, @@ -52,5 +52,7 @@ } ] + + def read_data(): return data \ No newline at end of file diff --git a/tutorial9/main.py b/tutorial9/main.py index 50b5426..c2a6866 100644 --- a/tutorial9/main.py +++ b/tutorial9/main.py @@ -1,9 +1,13 @@ -from schema import cricketplayer, footballplayer, invalid -import graphene +import strawberry from fastapi import FastAPI -from starlette.graphql import GraphQLApp -from mapping import query +from strawberry.fastapi import GraphQLRouter +from .mapping import Query +from .schema import FootballPlayer, CricketPlayer, Invalid -app=FastAPI() -app.add_route("/graphql",GraphQLApp(schema=graphene.Schema(query=query,types=[footballplayer,cricketplayer,invalid]))) -print(graphene.Schema(query=query)) +schema = strawberry.Schema(query=Query, types=[FootballPlayer, CricketPlayer, Invalid]) +graphql_app = GraphQLRouter(schema) + +app = FastAPI() +app.include_router(graphql_app, prefix="/graphql") + +print(schema) diff --git a/tutorial9/mapping.py b/tutorial9/mapping.py index 1955a27..24c73e6 100644 --- a/tutorial9/mapping.py +++ b/tutorial9/mapping.py @@ -1,17 +1,18 @@ -import graphene -from graphene import String -from schema import player -from data import read_data +import strawberry +from .schema import FootballPlayer, CricketPlayer, Invalid, Player +from .data import read_data -class query(graphene.ObjectType): - player=graphene.List(player,required=True,playertype=String(required=True)) - def resolve_player(self,info,playertype): - data=read_data() - if playertype=="fplayer": - return data[0]["footballplayer"] - elif playertype=="cplayer": - return data[0]["cricketplayer"] + +@strawberry.type +class Query: + @strawberry.field + def player(self, playertype: str) -> list[Player]: + data = read_data() + if playertype == "fplayer": + return [FootballPlayer(**p) for p in data[0]["footballplayer"]] + elif playertype == "cplayer": + return [CricketPlayer(**p) for p in data[0]["cricketplayer"]] else: - return data[0]["invalid"] - + return [Invalid(**p) for p in data[0]["invalid"]] + diff --git a/tutorial9/schema.py b/tutorial9/schema.py index 2299a3d..92ad498 100644 --- a/tutorial9/schema.py +++ b/tutorial9/schema.py @@ -1,30 +1,23 @@ -import graphene -from graphene import String -class player(graphene.Interface): - name=String() - country=String() - type=String() - @classmethod - def resolve_type(cls, instance, info): - if(instance["type"]=="footballplayer"): - return footballplayer - elif(instance["type"]=="cricketplayer"): - return cricketplayer - else: - return invalid - - -class footballplayer(graphene.ObjectType): - class Meta: - interfaces=(player,) - position=String() - -class cricketplayer(graphene.ObjectType): - class Meta: - interfaces=(player,) - battingorder=String() - -class invalid(graphene.ObjectType): - class Meta: - interfaces=(player,) - invalid_data=String() +import strawberry + + +@strawberry.interface +class Player: + name: str + country: str + type: str + + +@strawberry.type +class FootballPlayer(Player): + position: str + + +@strawberry.type +class CricketPlayer(Player): + battingorder: int + + +@strawberry.type +class Invalid(Player): + invalid_data: str diff --git a/youtube-playlist.txt b/youtube-playlist.txt new file mode 100644 index 0000000..d6b5986 --- /dev/null +++ b/youtube-playlist.txt @@ -0,0 +1 @@ +playlist: https://www.youtube.com/playlist?list=PLI8raxzYtfGxVDsdOBuJvRjMK8n0ffWVb