Repository: mtag-dev/squall (language: python)

Issue:
Remove Pydantic from dependencies



Discussion / hints:

Fix patch:
diff --git a/Makefile b/Makefile
index 05f88a3..2130dd4 100644
--- a/Makefile
+++ b/Makefile
@@ -4,21 +4,20 @@ install-dev:		## Install development dependencies
 
 test:			## Run unit tests
 	python ./scripts/docs.py verify-readme
-	export PYTHONPATH=./docs_src
-	pytest --cov=squall --cov=tests --cov=docs_src --cov-report=term-missing:skip-covered --cov-report=xml tests
+	pytest --cov=squall --cov=tests --cov-report=term-missing:skip-covered --cov-report=xml tests
 
 lint:			## Run lint checks
 	mypy squall
 	flake8 squall tests
 	black squall tests --check
-	isort squall tests docs_src scripts --check-only
+	isort squall tests scripts --check-only
 
 test-all: lint test	## Run unit tests and lint check
 
 format:			## Format code according to lint checks
-	autoflake --remove-all-unused-imports --recursive --remove-unused-variables --in-place docs_src squall tests scripts --exclude=__init__.py
-	black squall tests docs_src scripts
-	isort squall tests docs_src scripts
+	autoflake --remove-all-unused-imports --recursive --remove-unused-variables --in-place squall tests scripts --exclude=__init__.py
+	black squall tests scripts
+	isort squall tests scripts
 
 generate-readme:	## Generate README
 	python ./scripts/docs.py generate-readme
diff --git a/docs_src/additional_responses/tutorial001.py b/docs_src/additional_responses/tutorial001.py
deleted file mode 100644
index 6701ff6..0000000
--- a/docs_src/additional_responses/tutorial001.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from pydantic import Field, dataclasses
-from squall import Squall
-from squall.responses import JSONResponse
-
-
-@dataclasses.dataclass
-class Item:
-    id: str = Field(...)
-    value: str = Field(...)
-
-
-@dataclasses.dataclass
-class Message:
-    message: str = Field(...)
-
-
-app = Squall()
-
-
-@app.get("/items/{item_id}", response_model=Item, responses={404: {"model": Message}})
-async def read_item(item_id: str):
-    if item_id == "foo":
-        return {"id": "foo", "value": "there goes my hero"}
-    else:
-        return JSONResponse(status_code=404, content={"message": "Item not found"})
diff --git a/docs_src/additional_responses/tutorial002.py b/docs_src/additional_responses/tutorial002.py
deleted file mode 100644
index b62807d..0000000
--- a/docs_src/additional_responses/tutorial002.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Squall
-from squall.responses import FileResponse
-
-
-@dataclasses.dataclass
-class Item:
-    id: str = Field(...)
-    value: str = Field(...)
-
-
-app = Squall()
-
-
-@app.get(
-    "/items/{item_id}",
-    response_model=Item,
-    responses={
-        200: {
-            "content": {"image/png": {}},
-            "description": "Return the JSON item or an image.",
-        }
-    },
-)
-async def read_item(item_id: str, img: Optional[bool] = None):
-    if img:
-        return FileResponse("image.png", media_type="image/png")
-    else:
-        return {"id": "foo", "value": "there goes my hero"}
diff --git a/docs_src/additional_responses/tutorial003.py b/docs_src/additional_responses/tutorial003.py
deleted file mode 100644
index a6d44f1..0000000
--- a/docs_src/additional_responses/tutorial003.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from pydantic import Field, dataclasses
-from squall import Squall
-from squall.responses import JSONResponse
-
-
-@dataclasses.dataclass
-class Item:
-    id: str = Field(...)
-    value: str = Field(...)
-
-
-@dataclasses.dataclass
-class Message:
-    message: str = Field(...)
-
-
-app = Squall()
-
-
-@app.get(
-    "/items/{item_id}",
-    response_model=Item,
-    responses={
-        404: {"model": Message, "description": "The item was not found"},
-        200: {
-            "description": "Item requested by ID",
-            "content": {
-                "application/json": {
-                    "example": {"id": "bar", "value": "The bar tenders"}
-                }
-            },
-        },
-    },
-)
-async def read_item(item_id: str):
-    if item_id == "foo":
-        return {"id": "foo", "value": "there goes my hero"}
-    else:
-        return JSONResponse(status_code=404, content={"message": "Item not found"})
diff --git a/docs_src/additional_responses/tutorial004.py b/docs_src/additional_responses/tutorial004.py
deleted file mode 100644
index 6bfd2ee..0000000
--- a/docs_src/additional_responses/tutorial004.py
+++ /dev/null
@@ -1,33 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Squall
-from squall.responses import FileResponse
-
-
-@dataclasses.dataclass()
-class Item:
-    id: str = Field(...)
-    value: str = Field(...)
-
-
-responses = {
-    404: {"description": "Item not found"},
-    302: {"description": "The item was moved"},
-    403: {"description": "Not enough privileges"},
-}
-
-
-app = Squall()
-
-
-@app.get(
-    "/items/{item_id}",
-    response_model=Item,
-    responses={**responses, 200: {"content": {"image/png": {}}}},
-)
-async def read_item(item_id: str, img: Optional[bool] = None):
-    if img:
-        return FileResponse("image.png", media_type="image/png")
-    else:
-        return {"id": "foo", "value": "there goes my hero"}
diff --git a/docs_src/additional_status_codes/tutorial001.py b/docs_src/additional_status_codes/tutorial001.py
deleted file mode 100644
index 1a92be3..0000000
--- a/docs_src/additional_status_codes/tutorial001.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from typing import Optional
-
-from squall import Body, Squall, status
-from squall.responses import JSONResponse
-
-app = Squall()
-
-items = {"foo": {"name": "Fighters", "size": 6}, "bar": {"name": "Tenders", "size": 3}}
-
-
-@app.put("/items/{item_id}")
-async def upsert_item(
-    item_id: str, name: Optional[str] = Body(None), size: Optional[int] = Body(None)
-):
-    if item_id in items:
-        item = items[item_id]
-        item["name"] = name
-        item["size"] = size
-        return item
-    else:
-        item = {"name": name, "size": size}
-        items[item_id] = item
-        return JSONResponse(status_code=status.HTTP_201_CREATED, content=item)
diff --git a/docs_src/advanced_middleware/tutorial001.py b/docs_src/advanced_middleware/tutorial001.py
deleted file mode 100644
index 4d730f0..0000000
--- a/docs_src/advanced_middleware/tutorial001.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Squall
-from squall.middleware.httpsredirect import HTTPSRedirectMiddleware
-
-app = Squall()
-
-app.add_middleware(HTTPSRedirectMiddleware)
-
-
-@app.get("/")
-async def main():
-    return {"message": "Hello World"}
diff --git a/docs_src/advanced_middleware/tutorial002.py b/docs_src/advanced_middleware/tutorial002.py
deleted file mode 100644
index da3cd7d..0000000
--- a/docs_src/advanced_middleware/tutorial002.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall import Squall
-from squall.middleware.trustedhost import TrustedHostMiddleware
-
-app = Squall()
-
-app.add_middleware(
-    TrustedHostMiddleware, allowed_hosts=["example.com", "*.example.com"]
-)
-
-
-@app.get("/")
-async def main():
-    return {"message": "Hello World"}
diff --git a/docs_src/advanced_middleware/tutorial003.py b/docs_src/advanced_middleware/tutorial003.py
deleted file mode 100644
index 8ba4fa0..0000000
--- a/docs_src/advanced_middleware/tutorial003.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Squall
-from squall.middleware.gzip import GZipMiddleware
-
-app = Squall()
-
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-
-@app.get("/")
-async def main():
-    return "somebigcontent"
diff --git a/docs_src/async_sql_databases/tutorial001.py b/docs_src/async_sql_databases/tutorial001.py
deleted file mode 100644
index 05e91d3..0000000
--- a/docs_src/async_sql_databases/tutorial001.py
+++ /dev/null
@@ -1,65 +0,0 @@
-from typing import List
-
-import databases
-import sqlalchemy
-from pydantic import BaseModel
-from squall import Squall
-
-# SQLAlchemy specific code, as with any other app
-DATABASE_URL = "sqlite:///./test.db"
-# DATABASE_URL = "postgresql://user:password@postgresserver/db"
-
-database = databases.Database(DATABASE_URL)
-
-metadata = sqlalchemy.MetaData()
-
-notes = sqlalchemy.Table(
-    "notes",
-    metadata,
-    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
-    sqlalchemy.Column("text", sqlalchemy.String),
-    sqlalchemy.Column("completed", sqlalchemy.Boolean),
-)
-
-
-engine = sqlalchemy.create_engine(
-    DATABASE_URL, connect_args={"check_same_thread": False}
-)
-metadata.create_all(engine)
-
-
-class NoteIn(BaseModel):
-    text: str
-    completed: bool
-
-
-class Note(BaseModel):
-    id: int
-    text: str
-    completed: bool
-
-
-app = Squall()
-
-
-@app.on_event("startup")
-async def startup():
-    await database.connect()
-
-
-@app.on_event("shutdown")
-async def shutdown():
-    await database.disconnect()
-
-
-@app.get("/notes/", response_model=List[Note])
-async def read_notes():
-    query = notes.select()
-    return await database.fetch_all(query)
-
-
-@app.post("/notes/", response_model=Note)
-async def create_note(note: NoteIn):
-    query = notes.insert().values(text=note.text, completed=note.completed)
-    last_record_id = await database.execute(query)
-    return {**note.dict(), "id": last_record_id}
diff --git a/docs_src/background_tasks/tutorial001.py b/docs_src/background_tasks/tutorial001.py
deleted file mode 100644
index f79ad50..0000000
--- a/docs_src/background_tasks/tutorial001.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from squall import BackgroundTasks, Squall
-
-app = Squall()
-
-
-def write_notification(email: str, message=""):
-    with open("log.txt", mode="w") as email_file:
-        content = f"notification for {email}: {message}"
-        email_file.write(content)
-
-
-@app.post("/send-notification/{email}")
-async def send_notification(email: str, background_tasks: BackgroundTasks):
-    background_tasks.add_task(write_notification, email, message="some notification")
-    return {"message": "Notification sent in the background"}
diff --git a/docs_src/background_tasks/tutorial002.py b/docs_src/background_tasks/tutorial002.py
deleted file mode 100644
index e80ec42..0000000
--- a/docs_src/background_tasks/tutorial002.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from typing import Optional
-
-from squall import BackgroundTasks, Depends, Squall
-
-app = Squall()
-
-
-def write_log(message: str):
-    with open("log.txt", mode="a") as log:
-        log.write(message)
-
-
-def get_query(background_tasks: BackgroundTasks, q: Optional[str] = None):
-    if q:
-        message = f"found query: {q}\n"
-        background_tasks.add_task(write_log, message)
-    return q
-
-
-@app.post("/send-notification/{email}")
-async def send_notification(
-    email: str, background_tasks: BackgroundTasks, q: str = Depends(get_query)
-):
-    message = f"message to {email}\n"
-    background_tasks.add_task(write_log, message)
-    return {"message": "Message sent"}
diff --git a/docs_src/behind_a_proxy/tutorial001.py b/docs_src/behind_a_proxy/tutorial001.py
deleted file mode 100644
index fac6cc4..0000000
--- a/docs_src/behind_a_proxy/tutorial001.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Request, Squall
-
-app = Squall()
-
-
-@app.get("/app")
-def read_main(request: Request):
-    return {"message": "Hello World", "root_path": request.scope.get("root_path")}
diff --git a/docs_src/behind_a_proxy/tutorial002.py b/docs_src/behind_a_proxy/tutorial002.py
deleted file mode 100644
index cb5731c..0000000
--- a/docs_src/behind_a_proxy/tutorial002.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Request, Squall
-
-app = Squall(root_path="/api/v1")
-
-
-@app.get("/app")
-def read_main(request: Request):
-    return {"message": "Hello World", "root_path": request.scope.get("root_path")}
diff --git a/docs_src/behind_a_proxy/tutorial003.py b/docs_src/behind_a_proxy/tutorial003.py
deleted file mode 100644
index 672fff5..0000000
--- a/docs_src/behind_a_proxy/tutorial003.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from squall import Request, Squall
-
-app = Squall(
-    servers=[
-        {"url": "https://stag.example.com", "description": "Staging environment"},
-        {"url": "https://prod.example.com", "description": "Production environment"},
-    ],
-    root_path="/api/v1",
-)
-
-
-@app.get("/app")
-def read_main(request: Request):
-    return {"message": "Hello World", "root_path": request.scope.get("root_path")}
diff --git a/docs_src/behind_a_proxy/tutorial004.py b/docs_src/behind_a_proxy/tutorial004.py
deleted file mode 100644
index f5e17c4..0000000
--- a/docs_src/behind_a_proxy/tutorial004.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from squall import Request, Squall
-
-app = Squall(
-    servers=[
-        {"url": "https://stag.example.com", "description": "Staging environment"},
-        {"url": "https://prod.example.com", "description": "Production environment"},
-    ],
-    root_path="/api/v1",
-    root_path_in_servers=False,
-)
-
-
-@app.get("/app")
-def read_main(request: Request):
-    return {"message": "Hello World", "root_path": request.scope.get("root_path")}
diff --git a/docs_src/bigger_applications/__init__.py b/docs_src/bigger_applications/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/bigger_applications/app/__init__.py b/docs_src/bigger_applications/app/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/bigger_applications/app/dependencies.py b/docs_src/bigger_applications/app/dependencies.py
deleted file mode 100644
index 87d2d47..0000000
--- a/docs_src/bigger_applications/app/dependencies.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Header, HTTPException
-
-
-async def get_token_header(x_token: str = Header(...)):
-    if x_token != "fake-super-secret-token":
-        raise HTTPException(status_code=400, detail="X-Token header invalid")
-
-
-async def get_query_token(token: str):
-    if token != "jessica":
-        raise HTTPException(status_code=400, detail="No Jessica token provided")
diff --git a/docs_src/bigger_applications/app/internal/__init__.py b/docs_src/bigger_applications/app/internal/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/bigger_applications/app/internal/admin.py b/docs_src/bigger_applications/app/internal/admin.py
deleted file mode 100644
index a04681b..0000000
--- a/docs_src/bigger_applications/app/internal/admin.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from squall import Depends
-from squall.router import Router
-
-from ..dependencies import get_token_header
-
-router = Router(
-    prefix="/admin",
-    tags=["admin"],
-    dependencies=[Depends(get_token_header)],
-    responses={418: {"description": "I'm a teapot"}},
-)
-
-
-@router.post("/")
-async def update_admin():
-    return {"message": "Admin getting schwifty"}
diff --git a/docs_src/bigger_applications/app/main.py b/docs_src/bigger_applications/app/main.py
deleted file mode 100644
index caa5eeb..0000000
--- a/docs_src/bigger_applications/app/main.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# from squall import Depends, Squall
-#
-# from .dependencies import get_query_token
-# from .internal import admin
-# from .routers import items, users
-#
-# app = Squall(dependencies=[Depends(get_query_token)])
-#
-#
-# app.include_router(users.router)
-# app.include_router(items.router)
-# app.include_router(admin.router)
-#
-#
-# @app.get("/")
-# async def root():
-#     return {"message": "Hello Bigger Applications!"}
diff --git a/docs_src/bigger_applications/app/routers/__init__.py b/docs_src/bigger_applications/app/routers/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/bigger_applications/app/routers/items.py b/docs_src/bigger_applications/app/routers/items.py
deleted file mode 100644
index 8615753..0000000
--- a/docs_src/bigger_applications/app/routers/items.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from squall import Depends, HTTPException
-from squall.router import Router
-
-from ..dependencies import get_token_header
-
-router = Router(
-    prefix="/items",
-    tags=["items"],
-    dependencies=[Depends(get_token_header)],
-    responses={404: {"description": "Not found"}},
-)
-
-
-fake_items_db = {"plumbus": {"name": "Plumbus"}, "gun": {"name": "Portal Gun"}}
-
-
-@router.get("/")
-async def read_items():
-    return fake_items_db
-
-
-@router.get("/{item_id}")
-async def read_item(item_id: str):
-    if item_id not in fake_items_db:
-        raise HTTPException(status_code=404, detail="Item not found")
-    return {"name": fake_items_db[item_id]["name"], "item_id": item_id}
-
-
-@router.put(
-    "/{item_id}",
-    tags=["custom"],
-    responses={403: {"description": "Operation forbidden"}},
-)
-async def update_item(item_id: str):
-    if item_id != "plumbus":
-        raise HTTPException(
-            status_code=403, detail="You can only update the item: plumbus"
-        )
-    return {"item_id": item_id, "name": "The great Plumbus"}
diff --git a/docs_src/bigger_applications/app/routers/users.py b/docs_src/bigger_applications/app/routers/users.py
deleted file mode 100644
index 2ba6b26..0000000
--- a/docs_src/bigger_applications/app/routers/users.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from squall.router import Router
-
-router = Router()
-
-
-@router.get("/users/", tags=["users"])
-async def read_users():
-    return [{"username": "Rick"}, {"username": "Morty"}]
-
-
-@router.get("/users/me", tags=["users"])
-async def read_user_me():
-    return {"username": "fakecurrentuser"}
-
-
-@router.get("/users/{username}", tags=["users"])
-async def read_user(username: str):
-    return {"username": username}
diff --git a/docs_src/body/tutorial001.py b/docs_src/body/tutorial001.py
deleted file mode 100644
index 964b18b..0000000
--- a/docs_src/body/tutorial001.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Squall
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-
-
-app = Squall()
-
-
-@app.post("/items/")
-async def create_item(item: Item):
-    return item
diff --git a/docs_src/body/tutorial002.py b/docs_src/body/tutorial002.py
deleted file mode 100644
index d6f820f..0000000
--- a/docs_src/body/tutorial002.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Squall
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-
-
-app = Squall()
-
-
-@app.post("/items/")
-async def create_item(item: Item):
-    item_dict = item.dict()
-    if item.tax:
-        price_with_tax = item.price + item.tax
-        item_dict.update({"price_with_tax": price_with_tax})
-    return item_dict
diff --git a/docs_src/body/tutorial003.py b/docs_src/body/tutorial003.py
deleted file mode 100644
index 0658283..0000000
--- a/docs_src/body/tutorial003.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Squall
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-
-
-app = Squall()
-
-
-@app.put("/items/{item_id}")
-async def create_item(item_id: int, item: Item):
-    return {"item_id": item_id, **item.dict()}
diff --git a/docs_src/body/tutorial004.py b/docs_src/body/tutorial004.py
deleted file mode 100644
index 0a36309..0000000
--- a/docs_src/body/tutorial004.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Squall
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-
-
-app = Squall()
-
-
-@app.put("/items/{item_id}")
-async def create_item(item_id: int, item: Item, q: Optional[str] = None):
-    result = {"item_id": item_id, **item.dict()}
-    if q:
-        result.update({"q": q})
-    return result
diff --git a/docs_src/body_fields/tutorial001.py b/docs_src/body_fields/tutorial001.py
deleted file mode 100644
index 0e04ace..0000000
--- a/docs_src/body_fields/tutorial001.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Body, Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = Field(
-        None, title="The description of the item", max_len=300
-    )
-    price: float = Field(..., gt=0, description="The price must be greater than zero")
-    tax: Optional[float] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item = Body(..., embed=True)):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_multiple_params/tutorial001.py b/docs_src/body_multiple_params/tutorial001.py
deleted file mode 100644
index 74504a5..0000000
--- a/docs_src/body_multiple_params/tutorial001.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Path, Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(
-    *,
-    item_id: int = Path(..., title="The ID of the item to get", ge=0, le=1000),
-    q: Optional[str] = None,
-    item: Optional[Item] = None,
-):
-    results = {"item_id": item_id}
-    if q:
-        results.update({"q": q})
-    if item:
-        results.update({"item": item})
-    return results
diff --git a/docs_src/body_multiple_params/tutorial002.py b/docs_src/body_multiple_params/tutorial002.py
deleted file mode 100644
index c468320..0000000
--- a/docs_src/body_multiple_params/tutorial002.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-
-
-class User(BaseModel):
-    username: str
-    full_name: Optional[str] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item, user: User):
-    results = {"item_id": item_id, "item": item, "user": user}
-    return results
diff --git a/docs_src/body_multiple_params/tutorial003.py b/docs_src/body_multiple_params/tutorial003.py
deleted file mode 100644
index 66b4eef..0000000
--- a/docs_src/body_multiple_params/tutorial003.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Body, Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-
-
-@dataclasses.dataclass
-class User:
-    username: str = Field(...)
-    full_name: Optional[str] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(
-    item_id: int, item: Item, user: User, importance: int = Body(...)
-):
-    results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
-    return results
diff --git a/docs_src/body_multiple_params/tutorial004.py b/docs_src/body_multiple_params/tutorial004.py
deleted file mode 100644
index 57bcdc3..0000000
--- a/docs_src/body_multiple_params/tutorial004.py
+++ /dev/null
@@ -1,33 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Body, Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-
-
-class User(BaseModel):
-    username: str
-    full_name: Optional[str] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(
-    *,
-    item_id: int,
-    item: Item,
-    user: User,
-    importance: int = Body(..., gt=0),
-    q: Optional[str] = None
-):
-    results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/body_multiple_params/tutorial005.py b/docs_src/body_multiple_params/tutorial005.py
deleted file mode 100644
index 0a08e62..0000000
--- a/docs_src/body_multiple_params/tutorial005.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Body, Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item = Body(..., embed=True)):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_nested_models/tutorial001.py b/docs_src/body_nested_models/tutorial001.py
deleted file mode 100644
index da99b96..0000000
--- a/docs_src/body_nested_models/tutorial001.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: list = []
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_nested_models/tutorial002.py b/docs_src/body_nested_models/tutorial002.py
deleted file mode 100644
index 40d91e0..0000000
--- a/docs_src/body_nested_models/tutorial002.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: List[str] = []
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_nested_models/tutorial003.py b/docs_src/body_nested_models/tutorial003.py
deleted file mode 100644
index adbb7a1..0000000
--- a/docs_src/body_nested_models/tutorial003.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = set()
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_nested_models/tutorial004.py b/docs_src/body_nested_models/tutorial004.py
deleted file mode 100644
index 286a786..0000000
--- a/docs_src/body_nested_models/tutorial004.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Image(BaseModel):
-    url: str
-    name: str
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = []
-    image: Optional[Image] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_nested_models/tutorial005.py b/docs_src/body_nested_models/tutorial005.py
deleted file mode 100644
index 4a3cc48..0000000
--- a/docs_src/body_nested_models/tutorial005.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import BaseModel, HttpUrl
-from squall import Squall
-
-app = Squall()
-
-
-class Image(BaseModel):
-    url: HttpUrl
-    name: str
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = set()
-    image: Optional[Image] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_nested_models/tutorial006.py b/docs_src/body_nested_models/tutorial006.py
deleted file mode 100644
index 710fdfa..0000000
--- a/docs_src/body_nested_models/tutorial006.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from typing import List, Optional, Set
-
-from pydantic import BaseModel, HttpUrl
-from squall import Squall
-
-app = Squall()
-
-
-class Image(BaseModel):
-    url: HttpUrl
-    name: str
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = set()
-    images: Optional[List[Image]] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/body_nested_models/tutorial007.py b/docs_src/body_nested_models/tutorial007.py
deleted file mode 100644
index c9eab8c..0000000
--- a/docs_src/body_nested_models/tutorial007.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from typing import List, Optional, Set
-
-from pydantic import BaseModel, HttpUrl
-from squall import Squall
-
-app = Squall()
-
-
-class Image(BaseModel):
-    url: HttpUrl
-    name: str
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = set()
-    images: Optional[List[Image]] = None
-
-
-class Offer(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    items: List[Item]
-
-
-@app.post("/offers/")
-async def create_offer(offer: Offer):
-    return offer
diff --git a/docs_src/body_nested_models/tutorial008.py b/docs_src/body_nested_models/tutorial008.py
deleted file mode 100644
index 0539c1e..0000000
--- a/docs_src/body_nested_models/tutorial008.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel, HttpUrl
-from squall import Squall
-
-app = Squall()
-
-
-class Image(BaseModel):
-    url: HttpUrl
-    name: str
-
-
-@app.post("/images/multiple/")
-async def create_multiple_images(images: List[Image]):
-    return images
diff --git a/docs_src/body_nested_models/tutorial009.py b/docs_src/body_nested_models/tutorial009.py
deleted file mode 100644
index 610786c..0000000
--- a/docs_src/body_nested_models/tutorial009.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from typing import Dict
-
-from squall import Squall
-
-app = Squall()
-
-
-@app.post("/index-weights/")
-async def create_index_weights(weights: Dict[int, float]):
-    return weights
diff --git a/docs_src/body_updates/tutorial001.py b/docs_src/body_updates/tutorial001.py
deleted file mode 100644
index ae1be09..0000000
--- a/docs_src/body_updates/tutorial001.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from typing import List, Optional
-
-from pydantic import Field, dataclasses
-from squall import Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: Optional[str] = None
-    description: Optional[str] = None
-    price: Optional[float] = None
-    tax: float = 10.5
-    tags: List[str] = Field(default_factory=list)
-
-
-items = {
-    "foo": {"name": "Foo", "price": 50.2},
-    "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2},
-    "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []},
-}
-
-
-@app.get("/items/{item_id}", response_model=Item)
-async def read_item(item_id: str):
-    return items[item_id]
-
-
-@app.put("/items/{item_id}", response_model=Item)
-async def update_item(item_id: str, item: Item):
-    update_item_encoded = item
-    items[item_id] = update_item_encoded
-    return update_item_encoded
diff --git a/docs_src/body_updates/tutorial002.py b/docs_src/body_updates/tutorial002.py
deleted file mode 100644
index eee2c3e..0000000
--- a/docs_src/body_updates/tutorial002.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: Optional[str] = None
-    description: Optional[str] = None
-    price: Optional[float] = None
-    tax: float = 10.5
-    tags: List[str] = []
-
-
-items = {
-    "foo": {"name": "Foo", "price": 50.2},
-    "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2},
-    "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []},
-}
-
-
-@app.get("/items/{item_id}", response_model=Item)
-async def read_item(item_id: str):
-    return items[item_id]
-
-
-@app.patch("/items/{item_id}", response_model=Item)
-async def update_item(item_id: str, item: Item):
-    stored_item_data = items[item_id]
-    stored_item_model = Item(**stored_item_data)
-    update_data = item.dict(exclude_unset=True)
-    updated_item = stored_item_model.copy(update=update_data)
-    items[item_id] = updated_item
-    return updated_item
diff --git a/docs_src/conditional_openapi/tutorial001.py b/docs_src/conditional_openapi/tutorial001.py
deleted file mode 100644
index b97a94e..0000000
--- a/docs_src/conditional_openapi/tutorial001.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from pydantic import BaseSettings
-from squall import Squall
-
-
-class Settings(BaseSettings):
-    openapi_url: str = "/openapi.json"
-
-
-settings = Settings()
-
-app = Squall(openapi_url=settings.openapi_url)
-
-
-@app.get("/")
-def root():
-    return {"message": "Hello World"}
diff --git a/docs_src/cookie_params/tutorial001.py b/docs_src/cookie_params/tutorial001.py
deleted file mode 100644
index cedd6ef..0000000
--- a/docs_src/cookie_params/tutorial001.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from typing import Optional
-
-from squall import Cookie, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(ads_id: Optional[str] = Cookie(None)):
-    return {"ads_id": ads_id}
diff --git a/docs_src/cors/tutorial001.py b/docs_src/cors/tutorial001.py
deleted file mode 100644
index 88e9809..0000000
--- a/docs_src/cors/tutorial001.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from squall import Squall
-from squall.middleware.cors import CORSMiddleware
-
-app = Squall()
-
-origins = [
-    "http://localhost.mtag.dev",
-    "https://localhost.mtag.dev",
-    "http://localhost",
-    "http://localhost:8080",
-]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.get("/")
-async def main():
-    return {"message": "Hello World"}
diff --git a/docs_src/custom_request_and_route/tutorial001.py b/docs_src/custom_request_and_route/tutorial001.py
deleted file mode 100644
index 9aa7a4b..0000000
--- a/docs_src/custom_request_and_route/tutorial001.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import gzip
-from typing import Callable, List
-
-from squall import Body, Request, Response, Squall
-from squall.routing import APIRoute
-
-
-class GzipRequest(Request):
-    async def body(self) -> bytes:
-        if not hasattr(self, "_body"):
-            body = await super().body()
-            if "gzip" in self.headers.getlist("Content-Encoding"):
-                body = gzip.decompress(body)
-            self._body = body
-        return self._body
-
-
-class GzipRoute(APIRoute):
-    def get_route_handler(self) -> Callable:
-        original_route_handler = super().get_route_handler()
-
-        async def custom_route_handler(request: Request) -> Response:
-            request = GzipRequest(request.scope, request.receive)
-            return await original_route_handler(request)
-
-        return custom_route_handler
-
-
-app = Squall()
-app.router.route_class = GzipRoute
-
-
-@app.post("/sum")
-async def sum_numbers(numbers: List[int] = Body(...)):
-    return {"sum": sum(numbers)}
diff --git a/docs_src/custom_request_and_route/tutorial002.py b/docs_src/custom_request_and_route/tutorial002.py
deleted file mode 100644
index d73c006..0000000
--- a/docs_src/custom_request_and_route/tutorial002.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from typing import Callable, List
-
-from squall import Body, HTTPException, Request, Response, Squall
-from squall.exceptions import RequestPayloadValidationError
-from squall.routing import APIRoute
-
-
-class ValidationErrorLoggingRoute(APIRoute):
-    def get_route_handler(self) -> Callable:
-        original_route_handler = super().get_route_handler()
-
-        async def custom_route_handler(request: Request) -> Response:
-            try:
-                return await original_route_handler(request)
-            except RequestPayloadValidationError as exc:
-                body = await request.body()
-                detail = {"errors": exc.errors(), "body": body.decode()}
-                raise HTTPException(status_code=422, detail=detail)
-
-        return custom_route_handler
-
-
-app = Squall()
-app.router.route_class = ValidationErrorLoggingRoute
-
-
-@app.post("/")
-async def sum_numbers(numbers: List[int] = Body(...)):
-    return sum(numbers)
diff --git a/docs_src/custom_request_and_route/tutorial003.py b/docs_src/custom_request_and_route/tutorial003.py
deleted file mode 100644
index 938e13f..0000000
--- a/docs_src/custom_request_and_route/tutorial003.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import time
-from typing import Callable
-
-from squall import Request, Response, Router, Squall
-from squall.routing import APIRoute
-
-
-class TimedRoute(APIRoute):
-    def get_route_handler(self) -> Callable:
-        original_route_handler = super().get_route_handler()
-
-        async def custom_route_handler(request: Request) -> Response:
-            before = time.time()
-            response: Response = await original_route_handler(request)
-            duration = time.time() - before
-            response.headers["X-Response-Time"] = str(duration)
-            print(f"route duration: {duration}")
-            print(f"route response: {response}")
-            print(f"route response headers: {response.headers}")
-            return response
-
-        return custom_route_handler
-
-
-app = Squall()
-router = Router(route_class=TimedRoute)
-
-
-@app.get("/")
-async def not_timed():
-    return {"message": "Not timed"}
-
-
-@router.get("/timed")
-async def timed():
-    return {"message": "It's the time of my life"}
-
-
-app.include_router(router)
diff --git a/docs_src/custom_response/tutorial001b.py b/docs_src/custom_response/tutorial001b.py
deleted file mode 100644
index 976fc50..0000000
--- a/docs_src/custom_response/tutorial001b.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Squall
-from squall.responses import JSONResponse
-
-app = Squall()
-
-
-@app.get("/items/", response_class=JSONResponse)
-async def read_items():
-    return [{"item_id": "Foo"}]
diff --git a/docs_src/custom_response/tutorial002.py b/docs_src/custom_response/tutorial002.py
deleted file mode 100644
index 0fdd07c..0000000
--- a/docs_src/custom_response/tutorial002.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from squall import Squall
-from squall.responses import HTMLResponse
-
-app = Squall()
-
-
-@app.get("/items/", response_class=HTMLResponse)
-async def read_items():
-    return """
-    <html>
-        <head>
-            <title>Some HTML in here</title>
-        </head>
-        <body>
-            <h1>Look ma! HTML!</h1>
-        </body>
-    </html>
-    """
diff --git a/docs_src/custom_response/tutorial003.py b/docs_src/custom_response/tutorial003.py
deleted file mode 100644
index 43eacee..0000000
--- a/docs_src/custom_response/tutorial003.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from squall import Squall
-from squall.responses import HTMLResponse
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items():
-    html_content = """
-    <html>
-        <head>
-            <title>Some HTML in here</title>
-        </head>
-        <body>
-            <h1>Look ma! HTML!</h1>
-        </body>
-    </html>
-    """
-    return HTMLResponse(content=html_content, status_code=200)
diff --git a/docs_src/custom_response/tutorial004.py b/docs_src/custom_response/tutorial004.py
deleted file mode 100644
index acfeda1..0000000
--- a/docs_src/custom_response/tutorial004.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from squall import Squall
-from squall.responses import HTMLResponse
-
-app = Squall()
-
-
-def generate_html_response():
-    html_content = """
-    <html>
-        <head>
-            <title>Some HTML in here</title>
-        </head>
-        <body>
-            <h1>Look ma! HTML!</h1>
-        </body>
-    </html>
-    """
-    return HTMLResponse(content=html_content, status_code=200)
-
-
-@app.get("/items/", response_class=HTMLResponse)
-async def read_items():
-    return generate_html_response()
diff --git a/docs_src/custom_response/tutorial005.py b/docs_src/custom_response/tutorial005.py
deleted file mode 100644
index 7e4ae0a..0000000
--- a/docs_src/custom_response/tutorial005.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Squall
-from squall.responses import PlainTextResponse
-
-app = Squall()
-
-
-@app.get("/", response_class=PlainTextResponse)
-async def main():
-    return "Hello World"
diff --git a/docs_src/custom_response/tutorial006.py b/docs_src/custom_response/tutorial006.py
deleted file mode 100644
index f47ef0b..0000000
--- a/docs_src/custom_response/tutorial006.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Squall
-from squall.responses import RedirectResponse
-
-app = Squall()
-
-
-@app.get("/subdomain")
-async def redirect_typer():
-    return RedirectResponse("https://subdomain.example.com")
diff --git a/docs_src/custom_response/tutorial006b.py b/docs_src/custom_response/tutorial006b.py
deleted file mode 100644
index e2fce39..0000000
--- a/docs_src/custom_response/tutorial006b.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Squall
-from squall.responses import RedirectResponse
-
-app = Squall()
-
-
-@app.get("/squall", response_class=RedirectResponse)
-async def redirect_squall():
-    return "https://squall.mtag.dev"
diff --git a/docs_src/custom_response/tutorial006c.py b/docs_src/custom_response/tutorial006c.py
deleted file mode 100644
index 14cc738..0000000
--- a/docs_src/custom_response/tutorial006c.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Squall
-from squall.responses import RedirectResponse
-
-app = Squall()
-
-
-@app.get("/pydantic", response_class=RedirectResponse, status_code=302)
-async def redirect_pydantic():
-    return "https://pydantic-docs.helpmanual.io/"
diff --git a/docs_src/custom_response/tutorial007.py b/docs_src/custom_response/tutorial007.py
deleted file mode 100644
index 496586f..0000000
--- a/docs_src/custom_response/tutorial007.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from squall import Squall
-from squall.responses import StreamingResponse
-
-app = Squall()
-
-
-async def fake_video_streamer():
-    for i in range(10):
-        yield b"some fake video bytes"
-
-
-@app.get("/")
-async def main():
-    return StreamingResponse(fake_video_streamer())
diff --git a/docs_src/custom_response/tutorial008.py b/docs_src/custom_response/tutorial008.py
deleted file mode 100644
index 4dd010a..0000000
--- a/docs_src/custom_response/tutorial008.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from squall import Squall
-from squall.responses import StreamingResponse
-
-some_file_path = "large-video-file.mp4"
-app = Squall()
-
-
-@app.get("/")
-def main():
-    def iterfile():  # (1)
-        with open(some_file_path, mode="rb") as file_like:  # (2)
-            yield from file_like  # (3)
-
-    return StreamingResponse(iterfile(), media_type="video/mp4")
diff --git a/docs_src/custom_response/tutorial009.py b/docs_src/custom_response/tutorial009.py
deleted file mode 100644
index fc0904e..0000000
--- a/docs_src/custom_response/tutorial009.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from squall import Squall
-from squall.responses import FileResponse
-
-some_file_path = "large-video-file.mp4"
-app = Squall()
-
-
-@app.get("/")
-async def main():
-    return FileResponse(some_file_path)
diff --git a/docs_src/custom_response/tutorial009b.py b/docs_src/custom_response/tutorial009b.py
deleted file mode 100644
index 95476a5..0000000
--- a/docs_src/custom_response/tutorial009b.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from squall import Squall
-from squall.responses import FileResponse
-
-some_file_path = "large-video-file.mp4"
-app = Squall()
-
-
-@app.get("/", response_class=FileResponse)
-async def main():
-    return some_file_path
diff --git a/docs_src/custom_response/tutorial010.py b/docs_src/custom_response/tutorial010.py
deleted file mode 100644
index 83f7740..0000000
--- a/docs_src/custom_response/tutorial010.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Squall
-from squall.responses import ORJSONResponse
-
-app = Squall(default_response_class=ORJSONResponse)
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"item_id": "Foo"}]
diff --git a/docs_src/dataclasses/tutorial001.py b/docs_src/dataclasses/tutorial001.py
deleted file mode 100644
index 7561d66..0000000
--- a/docs_src/dataclasses/tutorial001.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from squall import Squall
-
-
-@dataclass
-class Item:
-    name: str
-    price: float
-    description: Optional[str] = None
-    tax: Optional[float] = None
-
-
-app = Squall()
-
-
-@app.post("/items/")
-async def create_item(item: Item):
-    return item
diff --git a/docs_src/dataclasses/tutorial002.py b/docs_src/dataclasses/tutorial002.py
deleted file mode 100644
index 93e6bb3..0000000
--- a/docs_src/dataclasses/tutorial002.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from dataclasses import dataclass, field
-from typing import List, Optional
-
-from squall import Squall
-
-
-@dataclass
-class Item:
-    name: str
-    price: float
-    tags: List[str] = field(default_factory=list)
-    description: Optional[str] = None
-    tax: Optional[float] = None
-
-
-app = Squall()
-
-
-@app.get("/items/next", response_model=Item)
-async def read_next_item():
-    return {
-        "name": "Island In The Moon",
-        "price": 12.99,
-        "description": "A place to be be playin' and havin' fun",
-        "tags": ["breater"],
-    }
diff --git a/docs_src/dataclasses/tutorial003.py b/docs_src/dataclasses/tutorial003.py
deleted file mode 100644
index 490cfda..0000000
--- a/docs_src/dataclasses/tutorial003.py
+++ /dev/null
@@ -1,55 +0,0 @@
-from dataclasses import field  # (1)
-from typing import List, Optional
-
-from pydantic.dataclasses import dataclass  # (2)
-from squall import Squall
-
-
-@dataclass
-class Item:
-    name: str
-    description: Optional[str] = None
-
-
-@dataclass
-class Author:
-    name: str
-    items: List[Item] = field(default_factory=list)  # (3)
-
-
-app = Squall()
-
-
-@app.post("/authors/{author_id}/items/", response_model=Author)  # (4)
-async def create_author_items(author_id: str, items: List[Item]):  # (5)
-    return {"name": author_id, "items": items}  # (6)
-
-
-@app.get("/authors/", response_model=List[Author])  # (7)
-def get_authors():  # (8)
-    return [  # (9)
-        {
-            "name": "Breaters",
-            "items": [
-                {
-                    "name": "Island In The Moon",
-                    "description": "A place to be be playin' and havin' fun",
-                },
-                {"name": "Holy Buddies"},
-            ],
-        },
-        {
-            "name": "System of an Up",
-            "items": [
-                {
-                    "name": "Salt",
-                    "description": "The kombucha mushroom people's favorite",
-                },
-                {"name": "Pad Thai"},
-                {
-                    "name": "Lonely Night",
-                    "description": "The mostests lonliest nightiest of allest",
-                },
-            ],
-        },
-    ]
diff --git a/docs_src/debugging/tutorial001.py b/docs_src/debugging/tutorial001.py
deleted file mode 100644
index 166cae1..0000000
--- a/docs_src/debugging/tutorial001.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import uvicorn
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/")
-def root():
-    a = "a"
-    b = "b" + a
-    return {"hello world": b}
-
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
diff --git a/docs_src/encoder/tutorial001.py b/docs_src/encoder/tutorial001.py
deleted file mode 100644
index 2ca3b94..0000000
--- a/docs_src/encoder/tutorial001.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Squall
-from squall.encoders import jsonable_encoder
-
-fake_db = {}
-
-
-class Item(BaseModel):
-    title: str
-    timestamp: datetime
-    description: Optional[str] = None
-
-
-app = Squall()
-
-
-@app.put("/items/{id}")
-def update_item(id: str, item: Item):
-    json_compatible_item_data = jsonable_encoder(item)
-    fake_db[id] = json_compatible_item_data
diff --git a/docs_src/events/tutorial001.py b/docs_src/events/tutorial001.py
deleted file mode 100644
index 4f41666..0000000
--- a/docs_src/events/tutorial001.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-items = {}
-
-
-@app.on_event("startup")
-async def startup_event():
-    items["foo"] = {"name": "Fighters"}
-    items["bar"] = {"name": "Tenders"}
-
-
-@app.get("/items/{item_id}")
-async def read_items(item_id: str):
-    return items[item_id]
diff --git a/docs_src/events/tutorial002.py b/docs_src/events/tutorial002.py
deleted file mode 100644
index 53bf1f0..0000000
--- a/docs_src/events/tutorial002.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.on_event("shutdown")
-def shutdown_event():
-    with open("log.txt", mode="a") as log:
-        log.write("Application shutdown")
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"name": "Foo"}]
diff --git a/docs_src/extending_openapi/tutorial001.py b/docs_src/extending_openapi/tutorial001.py
deleted file mode 100644
index 8fe0fee..0000000
--- a/docs_src/extending_openapi/tutorial001.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# from squall import Squall
-# from squall.openapi.utils import get_openapi
-#
-# app = Squall()
-#
-#
-# @app.get("/items/")
-# async def read_items():
-#     return [{"name": "Foo"}]
-#
-#
-# def custom_openapi():
-#     if app.openapi_schema:
-#         return app.openapi_schema
-#     openapi_schema = get_openapi(
-#         title="Custom title",
-#         version="2.5.0",
-#         description="This is a very custom OpenAPI schema",
-#         routes=app.routes,
-#     )
-#     openapi_schema.info.logo = {
-#         "url": "https://squall.mtag.dev/img/logo-margin/logo-teal.png"
-#     }
-#     app.openapi_schema = openapi_schema
-#     return app.openapi_schema
-#
-#
-# app.openapi = custom_openapi
diff --git a/docs_src/extending_openapi/tutorial002.py b/docs_src/extending_openapi/tutorial002.py
deleted file mode 100644
index 5f54535..0000000
--- a/docs_src/extending_openapi/tutorial002.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from squall import Squall
-from squall.openapi.docs import (
-    get_redoc_html,
-    get_swagger_ui_html,
-    get_swagger_ui_oauth2_redirect_html,
-)
-from squall.staticfiles import StaticFiles
-
-app = Squall(docs_url=None, redoc_url=None)
-
-app.add_route("/static", StaticFiles(directory="static"), name="static")
-
-
-@app.get("/docs", include_in_schema=False)
-async def custom_swagger_ui_html():
-    return get_swagger_ui_html(
-        openapi_url=app.openapi_url,
-        title=app.title + " - Swagger UI",
-        oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url,
-        swagger_js_url="/static/swagger-ui-bundle.js",
-        swagger_css_url="/static/swagger-ui.css",
-    )
-
-
-@app.get(app.swagger_ui_oauth2_redirect_url, include_in_schema=False)
-async def swagger_ui_redirect():
-    return get_swagger_ui_oauth2_redirect_html()
-
-
-@app.get("/redoc", include_in_schema=False)
-async def redoc_html():
-    return get_redoc_html(
-        openapi_url=app.openapi_url,
-        title=app.title + " - ReDoc",
-        redoc_js_url="/static/redoc.standalone.js",
-    )
-
-
-@app.get("/users/{username}")
-async def read_user(username: str):
-    return {"message": f"Hello {username}"}
diff --git a/docs_src/extra_data_types/tutorial001.py b/docs_src/extra_data_types/tutorial001.py
deleted file mode 100644
index ccff6ca..0000000
--- a/docs_src/extra_data_types/tutorial001.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from datetime import datetime, time
-from typing import Optional
-from uuid import UUID
-
-from squall import Body, Squall
-
-app = Squall()
-
-
-@app.put("/items/{item_id}")
-async def read_items(
-    item_id: UUID,
-    start_datetime: Optional[datetime] = Body(None),
-    end_datetime: Optional[datetime] = Body(None),
-    repeat_at: Optional[time] = Body(None),
-):
-    start_process = start_datetime
-    return {
-        "item_id": item_id,
-        "start_datetime": start_datetime,
-        "end_datetime": end_datetime,
-        "repeat_at": repeat_at,
-        "start_process": start_process,
-    }
diff --git a/docs_src/extra_models/tutorial001.py b/docs_src/extra_models/tutorial001.py
deleted file mode 100644
index 9ed2139..0000000
--- a/docs_src/extra_models/tutorial001.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel, EmailStr
-from squall import Squall
-
-app = Squall()
-
-
-class UserIn(BaseModel):
-    username: str
-    password: str
-    email: EmailStr
-    full_name: Optional[str] = None
-
-
-class UserOut(BaseModel):
-    username: str
-    email: EmailStr
-    full_name: Optional[str] = None
-
-
-class UserInDB(BaseModel):
-    username: str
-    hashed_password: str
-    email: EmailStr
-    full_name: Optional[str] = None
-
-
-def fake_password_hasher(raw_password: str):
-    return "supersecret" + raw_password
-
-
-def fake_save_user(user_in: UserIn):
-    hashed_password = fake_password_hasher(user_in.password)
-    user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
-    print("User saved! ..not really")
-    return user_in_db
-
-
-@app.post("/user/", response_model=UserOut)
-async def create_user(user_in: UserIn):
-    user_saved = fake_save_user(user_in)
-    return user_saved
diff --git a/docs_src/extra_models/tutorial002.py b/docs_src/extra_models/tutorial002.py
deleted file mode 100644
index a7d391e..0000000
--- a/docs_src/extra_models/tutorial002.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel, EmailStr
-from squall import Squall
-
-app = Squall()
-
-
-class UserBase(BaseModel):
-    username: str
-    email: EmailStr
-    full_name: Optional[str] = None
-
-
-class UserIn(UserBase):
-    password: str
-
-
-class UserOut(UserBase):
-    pass
-
-
-class UserInDB(UserBase):
-    hashed_password: str
-
-
-def fake_password_hasher(raw_password: str):
-    return "supersecret" + raw_password
-
-
-def fake_save_user(user_in: UserIn):
-    hashed_password = fake_password_hasher(user_in.password)
-    user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
-    print("User saved! ..not really")
-    return user_in_db
-
-
-@app.post("/user/", response_model=UserOut)
-async def create_user(user_in: UserIn):
-    user_saved = fake_save_user(user_in)
-    return user_saved
diff --git a/docs_src/extra_models/tutorial003.py b/docs_src/extra_models/tutorial003.py
deleted file mode 100644
index 3ce360b..0000000
--- a/docs_src/extra_models/tutorial003.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from typing import Union
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class BaseItem(BaseModel):
-    description: str
-    type: str
-
-
-class CarItem(BaseItem):
-    type = "car"
-
-
-class PlaneItem(BaseItem):
-    type = "plane"
-    size: int
-
-
-items = {
-    "item1": {"description": "All my friends drive a low rider", "type": "car"},
-    "item2": {
-        "description": "Music is my aeroplane, it's my aeroplane",
-        "type": "plane",
-        "size": 5,
-    },
-}
-
-
-@app.get("/items/{item_id}", response_model=Union[PlaneItem, CarItem])
-async def read_item(item_id: str):
-    return items[item_id]
diff --git a/docs_src/extra_models/tutorial004.py b/docs_src/extra_models/tutorial004.py
deleted file mode 100644
index d5b9694..0000000
--- a/docs_src/extra_models/tutorial004.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: str
-
-
-items = [
-    {"name": "Foo", "description": "There comes my hero"},
-    {"name": "Red", "description": "It's my aeroplane"},
-]
-
-
-@app.get("/items/", response_model=List[Item])
-async def read_items():
-    return items
diff --git a/docs_src/extra_models/tutorial005.py b/docs_src/extra_models/tutorial005.py
deleted file mode 100644
index c57b3f5..0000000
--- a/docs_src/extra_models/tutorial005.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from typing import Dict
-
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/keyword-weights/", response_model=Dict[str, float])
-async def read_keyword_weights():
-    return {"foo": 2.3, "bar": 3.4}
diff --git a/docs_src/first_steps/tutorial001.py b/docs_src/first_steps/tutorial001.py
deleted file mode 100644
index a63fc5d..0000000
--- a/docs_src/first_steps/tutorial001.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/")
-async def root():
-    return {"message": "Hello World"}
diff --git a/docs_src/first_steps/tutorial002.py b/docs_src/first_steps/tutorial002.py
deleted file mode 100644
index f1d3ecf..0000000
--- a/docs_src/first_steps/tutorial002.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-my_awesome_api = Squall()
-
-
-@my_awesome_api.get("/")
-async def root():
-    return {"message": "Hello World"}
diff --git a/docs_src/first_steps/tutorial003.py b/docs_src/first_steps/tutorial003.py
deleted file mode 100644
index 34954c7..0000000
--- a/docs_src/first_steps/tutorial003.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/")
-def root():
-    return {"message": "Hello World"}
diff --git a/docs_src/graphql/tutorial001.py b/docs_src/graphql/tutorial001.py
deleted file mode 100644
index 2f7b0ee..0000000
--- a/docs_src/graphql/tutorial001.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import strawberry
-from squall import Squall
-from strawberry.asgi import GraphQL
-
-
-@strawberry.type
-class User:
-    name: str
-    age: int
-
-
-@strawberry.type
-class Query:
-    @strawberry.field
-    def user(self) -> User:
-        return User(name="Patrick", age=100)
-
-
-schema = strawberry.Schema(query=Query)
-
-
-graphql_app = GraphQL(schema)
-
-app = Squall()
-app.add_route("/graphql", graphql_app)
-app.add_websocket_route("/graphql", graphql_app)
diff --git a/docs_src/handling_errors/tutorial001.py b/docs_src/handling_errors/tutorial001.py
deleted file mode 100644
index 2fd731e..0000000
--- a/docs_src/handling_errors/tutorial001.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from squall import HTTPException, Squall
-
-app = Squall()
-
-items = {"foo": "The Foo Wrestlers"}
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id: str):
-    if item_id not in items:
-        raise HTTPException(status_code=404, detail="Item not found")
-    return {"item": items[item_id]}
diff --git a/docs_src/handling_errors/tutorial002.py b/docs_src/handling_errors/tutorial002.py
deleted file mode 100644
index 616f911..0000000
--- a/docs_src/handling_errors/tutorial002.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from squall import HTTPException, Squall
-
-app = Squall()
-
-items = {"foo": "The Foo Wrestlers"}
-
-
-@app.get("/items-header/{item_id}")
-async def read_item_header(item_id: str):
-    if item_id not in items:
-        raise HTTPException(
-            status_code=404,
-            detail="Item not found",
-            headers={"X-Error": "There goes my error"},
-        )
-    return {"item": items[item_id]}
diff --git a/docs_src/handling_errors/tutorial003.py b/docs_src/handling_errors/tutorial003.py
deleted file mode 100644
index ce58bd9..0000000
--- a/docs_src/handling_errors/tutorial003.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from squall import Request, Squall
-from squall.responses import JSONResponse
-
-
-class UnicornException(Exception):
-    def __init__(self, name: str):
-        self.name = name
-
-
-app = Squall()
-
-
-@app.exception_handler(UnicornException)
-async def unicorn_exception_handler(request: Request, exc: UnicornException):
-    return JSONResponse(
-        status_code=418,
-        content={"message": f"Oops! {exc.name} did something. There goes a rainbow..."},
-    )
-
-
-@app.get("/unicorns/{name}")
-async def read_unicorn(name: str):
-    if name == "yolo":
-        raise UnicornException(name=name)
-    return {"unicorn_name": name}
diff --git a/docs_src/handling_errors/tutorial004.py b/docs_src/handling_errors/tutorial004.py
deleted file mode 100644
index 2055be0..0000000
--- a/docs_src/handling_errors/tutorial004.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from squall import HTTPException, Squall
-from squall.exceptions import RequestPayloadValidationError
-from squall.responses import PlainTextResponse
-from starlette.exceptions import HTTPException as StarletteHTTPException
-
-app = Squall()
-
-
-@app.exception_handler(StarletteHTTPException)
-async def http_exception_handler(request, exc):
-    return PlainTextResponse(str(exc.detail), status_code=exc.status_code)
-
-
-@app.exception_handler(RequestPayloadValidationError)
-async def validation_exception_handler(request, exc):
-    return PlainTextResponse(str(exc), status_code=400)
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id: int):
-    if item_id == 3:
-        raise HTTPException(status_code=418, detail="Nope! I don't like 3.")
-    return {"item_id": item_id}
diff --git a/docs_src/handling_errors/tutorial005.py b/docs_src/handling_errors/tutorial005.py
deleted file mode 100644
index 5656a55..0000000
--- a/docs_src/handling_errors/tutorial005.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from pydantic import Field, dataclasses
-from squall import Request, Squall, status
-from squall.exceptions import RequestPayloadValidationError
-from squall.responses import JSONResponse
-
-app = Squall()
-
-
-@app.exception_handler(RequestPayloadValidationError)
-async def validation_exception_handler(
-    request: Request, exc: RequestPayloadValidationError
-):
-    return JSONResponse(
-        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-        content={"detail": exc.errors(), "body": exc.body},
-    )
-
-
-@dataclasses.dataclass
-class Item:
-    title: str = Field(...)
-    size: int = Field(...)
-
-
-@app.post("/items/")
-async def create_item(item: Item):
-    return item
diff --git a/docs_src/handling_errors/tutorial006.py b/docs_src/handling_errors/tutorial006.py
deleted file mode 100644
index 7074220..0000000
--- a/docs_src/handling_errors/tutorial006.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from squall import HTTPException, Squall
-from squall.exception_handlers import (
-    http_exception_handler,
-    request_payload_validation_exception_handler,
-)
-from squall.exceptions import RequestPayloadValidationError
-from starlette.exceptions import HTTPException as StarletteHTTPException
-
-app = Squall()
-
-
-@app.exception_handler(StarletteHTTPException)
-async def custom_http_exception_handler(request, exc):
-    print(f"OMG! An HTTP error!: {repr(exc)}")
-    return await http_exception_handler(request, exc)
-
-
-@app.exception_handler(RequestPayloadValidationError)
-async def validation_exception_handler(request, exc):
-    print(f"OMG! The client sent invalid data!: {exc}")
-    return await request_payload_validation_exception_handler(request, exc)
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id: int):
-    if item_id == 3:
-        raise HTTPException(status_code=418, detail="Nope! I don't like 3.")
-    return {"item_id": item_id}
diff --git a/docs_src/header_params/tutorial001.py b/docs_src/header_params/tutorial001.py
deleted file mode 100644
index 4ec5749..0000000
--- a/docs_src/header_params/tutorial001.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from typing import Optional
-
-from squall import Header, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(user_agent: Optional[str] = Header(None)):
-    return {"User-Agent": user_agent}
diff --git a/docs_src/header_params/tutorial002.py b/docs_src/header_params/tutorial002.py
deleted file mode 100644
index 931a9f3..0000000
--- a/docs_src/header_params/tutorial002.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from typing import Optional
-
-from squall import Header, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(
-    strange_header: Optional[str] = Header(None, convert_underscores=False)
-):
-    return {"strange_header": strange_header}
diff --git a/docs_src/header_params/tutorial003.py b/docs_src/header_params/tutorial003.py
deleted file mode 100644
index 99d0eca..0000000
--- a/docs_src/header_params/tutorial003.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from typing import List, Optional
-
-from squall import Header, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(x_token: Optional[List[str]] = Header(None)):
-    return {"X-Token values": x_token}
diff --git a/docs_src/metadata/tutorial001.py b/docs_src/metadata/tutorial001.py
deleted file mode 100644
index 09ea2d1..0000000
--- a/docs_src/metadata/tutorial001.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from squall import Squall
-
-description = """
-ChimichangApp API helps you do awesome stuff. 🚀
-
-## Items
-
-You can **read items**.
-
-## Users
-
-You will be able to:
-
-* **Create users** (_not implemented_).
-* **Read users** (_not implemented_).
-"""
-
-app = Squall(
-    title="ChimichangApp",
-    description=description,
-    version="0.0.1",
-    terms_of_service="http://example.com/terms/",
-    contact={
-        "name": "Deadpoolio the Amazing",
-        "url": "http://x-force.example.com/contact/",
-        "email": "dp@x-force.example.com",
-    },
-    license_info={
-        "name": "Apache 2.0",
-        "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
-    },
-)
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"name": "Katana"}]
diff --git a/docs_src/metadata/tutorial002.py b/docs_src/metadata/tutorial002.py
deleted file mode 100644
index 374d5b1..0000000
--- a/docs_src/metadata/tutorial002.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall(openapi_url="/api/v1/openapi.json")
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"name": "Foo"}]
diff --git a/docs_src/metadata/tutorial003.py b/docs_src/metadata/tutorial003.py
deleted file mode 100644
index 175934c..0000000
--- a/docs_src/metadata/tutorial003.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall(docs_url="/documentation", redoc_url=None)
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"name": "Foo"}]
diff --git a/docs_src/metadata/tutorial004.py b/docs_src/metadata/tutorial004.py
deleted file mode 100644
index 9257be7..0000000
--- a/docs_src/metadata/tutorial004.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from squall import Squall
-
-tags_metadata = [
-    {
-        "name": "users",
-        "description": "Operations with users. The **login** logic is also here.",
-    },
-    {
-        "name": "items",
-        "description": "Manage items. So _fancy_ they have their own docs.",
-        "externalDocs": {
-            "description": "Items external docs",
-            "url": "https://squall.mtag.dev/",
-        },
-    },
-]
-
-app = Squall(openapi_tags=tags_metadata)
-
-
-@app.get("/users/", tags=["users"])
-async def get_users():
-    return [{"name": "Harry"}, {"name": "Ron"}]
-
-
-@app.get("/items/", tags=["items"])
-async def get_items():
-    return [{"name": "wand"}, {"name": "flying broom"}]
diff --git a/docs_src/middleware/tutorial001.py b/docs_src/middleware/tutorial001.py
deleted file mode 100644
index d45fac2..0000000
--- a/docs_src/middleware/tutorial001.py
+++ /dev/null
@@ -1,14 +0,0 @@
-import time
-
-from squall import Request, Squall
-
-app = Squall()
-
-
-@app.middleware("http")
-async def add_process_time_header(request: Request, call_next):
-    start_time = time.time()
-    response = await call_next(request)
-    process_time = time.time() - start_time
-    response.headers["X-Process-Time"] = str(process_time)
-    return response
diff --git a/docs_src/nosql_databases/tutorial001.py b/docs_src/nosql_databases/tutorial001.py
deleted file mode 100644
index 7b8cd35..0000000
--- a/docs_src/nosql_databases/tutorial001.py
+++ /dev/null
@@ -1,53 +0,0 @@
-from typing import Optional
-
-from couchbase import LOCKMODE_WAIT
-from couchbase.bucket import Bucket
-from couchbase.cluster import Cluster, PasswordAuthenticator
-from pydantic import BaseModel
-from squall import Squall
-
-USERPROFILE_DOC_TYPE = "userprofile"
-
-
-def get_bucket():
-    cluster = Cluster(
-        "couchbase://couchbasehost:8091?fetch_mutation_tokens=1&operation_timeout=30&n1ql_timeout=300"
-    )
-    authenticator = PasswordAuthenticator("username", "password")
-    cluster.authenticate(authenticator)
-    bucket: Bucket = cluster.open_bucket("bucket_name", lockmode=LOCKMODE_WAIT)
-    bucket.timeout = 30
-    bucket.n1ql_timeout = 300
-    return bucket
-
-
-class User(BaseModel):
-    username: str
-    email: Optional[str] = None
-    full_name: Optional[str] = None
-    disabled: Optional[bool] = None
-
-
-class UserInDB(User):
-    type: str = USERPROFILE_DOC_TYPE
-    hashed_password: str
-
-
-def get_user(bucket: Bucket, username: str):
-    doc_id = f"userprofile::{username}"
-    result = bucket.get(doc_id, quiet=True)
-    if not result.value:
-        return None
-    user = UserInDB(**result.value)
-    return user
-
-
-# Squall specific code
-app = Squall()
-
-
-@app.get("/users/{username}", response_model=User)
-def read_user(username: str):
-    bucket = get_bucket()
-    user = get_user(bucket=bucket, username=username)
-    return user
diff --git a/docs_src/path_operation_advanced_configuration/tutorial001.py b/docs_src/path_operation_advanced_configuration/tutorial001.py
deleted file mode 100644
index 46d7713..0000000
--- a/docs_src/path_operation_advanced_configuration/tutorial001.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/", operation_id="some_specific_id_you_define")
-async def read_items():
-    return [{"item_id": "Foo"}]
diff --git a/docs_src/path_operation_advanced_configuration/tutorial002.py b/docs_src/path_operation_advanced_configuration/tutorial002.py
deleted file mode 100644
index 87ecdfc..0000000
--- a/docs_src/path_operation_advanced_configuration/tutorial002.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from squall import Squall
-from squall.routing import APIRoute
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"item_id": "Foo"}]
-
-
-def use_route_names_as_operation_ids(app: Squall) -> None:
-    """
-    Simplify operation IDs so that generated API clients have simpler function
-    names.
-
-    Should be called only after all routes have been added.
-    """
-    for route in app.routes:
-        if isinstance(route, APIRoute):
-            route.operation_id = route.name  # in this case, 'read_items'
-
-
-use_route_names_as_operation_ids(app)
diff --git a/docs_src/path_operation_advanced_configuration/tutorial003.py b/docs_src/path_operation_advanced_configuration/tutorial003.py
deleted file mode 100644
index 03ec146..0000000
--- a/docs_src/path_operation_advanced_configuration/tutorial003.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/", include_in_schema=False)
-async def read_items():
-    return [{"item_id": "Foo"}]
diff --git a/docs_src/path_operation_advanced_configuration/tutorial004.py b/docs_src/path_operation_advanced_configuration/tutorial004.py
deleted file mode 100644
index 03f3d52..0000000
--- a/docs_src/path_operation_advanced_configuration/tutorial004.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import Field, dataclasses
-from squall import Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-    tags: Set[str] = Field(default_factory=list)
-
-
-@app.post("/items/", response_model=Item, summary="Create an item")
-async def create_item(item: Item):
-    """
-    Create an item with all the information:
-
-    - **name**: each item must have a name
-    - **description**: a long description
-    - **price**: required
-    - **tax**: if the item doesn't have tax, you can omit this
-    - **tags**: a set of unique tag strings for this item
-    \f
-    :param item: User input.
-    """
-    return item
diff --git a/docs_src/path_operation_advanced_configuration/tutorial005.py b/docs_src/path_operation_advanced_configuration/tutorial005.py
deleted file mode 100644
index ef3fe37..0000000
--- a/docs_src/path_operation_advanced_configuration/tutorial005.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/", openapi_extra={"x-aperture-labs-portal": "blue"})
-async def read_items():
-    return [{"item_id": "portal-gun"}]
diff --git a/docs_src/path_operation_advanced_configuration/tutorial006.py b/docs_src/path_operation_advanced_configuration/tutorial006.py
deleted file mode 100644
index 81dc33a..0000000
--- a/docs_src/path_operation_advanced_configuration/tutorial006.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from squall import Request, Squall
-
-app = Squall()
-
-
-def magic_data_reader(raw_body: bytes):
-    return {
-        "size": len(raw_body),
-        "content": {
-            "name": "Maaaagic",
-            "price": 42,
-            "description": "Just kiddin', no magic here. ✨",
-        },
-    }
-
-
-@app.post(
-    "/items/",
-    openapi_extra={
-        "requestBody": {
-            "content": {
-                "application/json": {
-                    "schema": {
-                        "required": ["name", "price"],
-                        "type": "object",
-                        "properties": {
-                            "name": {"type": "string"},
-                            "price": {"type": "number"},
-                            "description": {"type": "string"},
-                        },
-                    }
-                }
-            },
-            "required": True,
-        },
-    },
-)
-async def create_item(request: Request):
-    raw_body = await request.body()
-    data = magic_data_reader(raw_body)
-    return data
diff --git a/docs_src/path_operation_advanced_configuration/tutorial007.py b/docs_src/path_operation_advanced_configuration/tutorial007.py
deleted file mode 100644
index 958a292..0000000
--- a/docs_src/path_operation_advanced_configuration/tutorial007.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from typing import List
-
-import yaml
-from pydantic import Field, ValidationError, dataclasses
-from squall import HTTPException, Request, Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    tags: List[str] = Field(...)
-
-
-@app.post(
-    "/items/",
-    openapi_extra={
-        "requestBody": {
-            "content": {
-                "application/x-yaml": {"schema": Item.__pydantic_model__.schema()}
-            },
-            "required": True,
-        },
-    },
-)
-async def create_item(request: Request):
-    raw_body = await request.body()
-    try:
-        data = yaml.safe_load(raw_body)
-    except yaml.YAMLError:
-        raise HTTPException(status_code=422, detail="Invalid YAML")
-    try:
-        item = Item(**data)
-    except ValidationError as e:
-        raise HTTPException(status_code=422, detail=e.errors())
-    return item
diff --git a/docs_src/path_operation_configuration/tutorial001.py b/docs_src/path_operation_configuration/tutorial001.py
deleted file mode 100644
index 76e1d1c..0000000
--- a/docs_src/path_operation_configuration/tutorial001.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import BaseModel
-from squall import Squall, status
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = []
-
-
-@app.post("/items/", response_model=Item, status_code=status.HTTP_201_CREATED)
-async def create_item(item: Item):
-    return item
diff --git a/docs_src/path_operation_configuration/tutorial002.py b/docs_src/path_operation_configuration/tutorial002.py
deleted file mode 100644
index b924d6c..0000000
--- a/docs_src/path_operation_configuration/tutorial002.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = []
-
-
-@app.post("/items/", response_model=Item, tags=["items"])
-async def create_item(item: Item):
-    return item
-
-
-@app.get("/items/", tags=["items"])
-async def read_items():
-    return [{"name": "Foo", "price": 42}]
-
-
-@app.get("/users/", tags=["users"])
-async def read_users():
-    return [{"username": "johndoe"}]
diff --git a/docs_src/path_operation_configuration/tutorial003.py b/docs_src/path_operation_configuration/tutorial003.py
deleted file mode 100644
index a61baec..0000000
--- a/docs_src/path_operation_configuration/tutorial003.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = []
-
-
-@app.post(
-    "/items/",
-    response_model=Item,
-    summary="Create an item",
-    description="Create an item with all the information, name, description, price, tax and a set of unique tags",
-)
-async def create_item(item: Item):
-    return item
diff --git a/docs_src/path_operation_configuration/tutorial004.py b/docs_src/path_operation_configuration/tutorial004.py
deleted file mode 100644
index 251331f..0000000
--- a/docs_src/path_operation_configuration/tutorial004.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-    tags: Set[str] = []
-
-
-@app.post("/items/", response_model=Item, summary="Create an item")
-async def create_item(item: Item):
-    """
-    Create an item with all the information:
-
-    - **name**: each item must have a name
-    - **description**: a long description
-    - **price**: required
-    - **tax**: if the item doesn't have tax, you can omit this
-    - **tags**: a set of unique tag strings for this item
-    """
-    return item
diff --git a/docs_src/path_operation_configuration/tutorial005.py b/docs_src/path_operation_configuration/tutorial005.py
deleted file mode 100644
index 47d782c..0000000
--- a/docs_src/path_operation_configuration/tutorial005.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from typing import Optional, Set
-
-from pydantic import Field, dataclasses
-from squall import Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-    tags: Set[str] = Field(default_factory=list)
-
-
-@app.post(
-    "/items/",
-    response_model=Item,
-    summary="Create an item",
-    response_description="The created item",
-)
-async def create_item(item: Item):
-    """
-    Create an item with all the information:
-
-    - **name**: each item must have a name
-    - **description**: a long description
-    - **price**: required
-    - **tax**: if the item doesn't have tax, you can omit this
-    - **tags**: a set of unique tag strings for this item
-    """
-    return item
diff --git a/docs_src/path_operation_configuration/tutorial006.py b/docs_src/path_operation_configuration/tutorial006.py
deleted file mode 100644
index 4404fb9..0000000
--- a/docs_src/path_operation_configuration/tutorial006.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/", tags=["items"])
-async def read_items():
-    return [{"name": "Foo", "price": 42}]
-
-
-@app.get("/users/", tags=["users"])
-async def read_users():
-    return [{"username": "johndoe"}]
-
-
-@app.get("/elements/", tags=["items"], deprecated=True)
-async def read_elements():
-    return [{"item_id": "Foo"}]
diff --git a/docs_src/path_params/tutorial001.py b/docs_src/path_params/tutorial001.py
deleted file mode 100644
index fe66399..0000000
--- a/docs_src/path_params/tutorial001.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id):
-    return {"item_id": item_id}
diff --git a/docs_src/path_params/tutorial002.py b/docs_src/path_params/tutorial002.py
deleted file mode 100644
index 4e1d95b..0000000
--- a/docs_src/path_params/tutorial002.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id: int):
-    return {"item_id": item_id}
diff --git a/docs_src/path_params/tutorial003.py b/docs_src/path_params/tutorial003.py
deleted file mode 100644
index 868c911..0000000
--- a/docs_src/path_params/tutorial003.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/users/me")
-async def read_user_me():
-    return {"user_id": "the current user"}
-
-
-@app.get("/users/{user_id}")
-async def read_user(user_id: str):
-    return {"user_id": user_id}
diff --git a/docs_src/path_params/tutorial004.py b/docs_src/path_params/tutorial004.py
deleted file mode 100644
index 3d1064a..0000000
--- a/docs_src/path_params/tutorial004.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/files/{file_path:path}")
-async def read_file(file_path: str):
-    return {"file_path": file_path}
diff --git a/docs_src/path_params/tutorial005.py b/docs_src/path_params/tutorial005.py
deleted file mode 100644
index be426f2..0000000
--- a/docs_src/path_params/tutorial005.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from enum import Enum
-
-from squall import Squall
-
-
-class ModelName(str, Enum):
-    alexnet = "alexnet"
-    resnet = "resnet"
-    lenet = "lenet"
-
-
-app = Squall()
-
-
-@app.get("/models/{model_name}")
-async def get_model(model_name: ModelName):
-    if model_name == ModelName.alexnet:
-        return {"model_name": model_name, "message": "Deep Learning FTW!"}
-
-    if model_name.value == "lenet":
-        return {"model_name": model_name, "message": "LeCNN all the images"}
-
-    return {"model_name": model_name, "message": "Have some residuals"}
diff --git a/docs_src/path_params_numeric_validations/tutorial001.py b/docs_src/path_params_numeric_validations/tutorial001.py
deleted file mode 100644
index f0c9cdd..0000000
--- a/docs_src/path_params_numeric_validations/tutorial001.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from typing import Optional
-
-from squall import Path, Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_items(
-    item_id: int = Path(..., title="The ID of the item to get"),
-    q: Optional[str] = Query(None, alias="item-query"),
-):
-    results = {"item_id": item_id}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/path_params_numeric_validations/tutorial002.py b/docs_src/path_params_numeric_validations/tutorial002.py
deleted file mode 100644
index 4e5cf75..0000000
--- a/docs_src/path_params_numeric_validations/tutorial002.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall import Path, Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_items(
-    q: str, item_id: int = Path(..., title="The ID of the item to get")
-):
-    results = {"item_id": item_id}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/path_params_numeric_validations/tutorial003.py b/docs_src/path_params_numeric_validations/tutorial003.py
deleted file mode 100644
index a3b1417..0000000
--- a/docs_src/path_params_numeric_validations/tutorial003.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall import Path, Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_items(
-    *, item_id: int = Path(..., title="The ID of the item to get"), q: str
-):
-    results = {"item_id": item_id}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/path_params_numeric_validations/tutorial004.py b/docs_src/path_params_numeric_validations/tutorial004.py
deleted file mode 100644
index ecc135d..0000000
--- a/docs_src/path_params_numeric_validations/tutorial004.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall import Path, Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_items(
-    *, item_id: int = Path(..., title="The ID of the item to get", ge=1), q: str
-):
-    results = {"item_id": item_id}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/path_params_numeric_validations/tutorial005.py b/docs_src/path_params_numeric_validations/tutorial005.py
deleted file mode 100644
index c370d9f..0000000
--- a/docs_src/path_params_numeric_validations/tutorial005.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from squall import Path, Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_items(
-    *,
-    item_id: int = Path(..., title="The ID of the item to get", gt=0, le=1000),
-    q: str,
-):
-    results = {"item_id": item_id}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/path_params_numeric_validations/tutorial006.py b/docs_src/path_params_numeric_validations/tutorial006.py
deleted file mode 100644
index 0f5373d..0000000
--- a/docs_src/path_params_numeric_validations/tutorial006.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from squall import Path, Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_items(
-    *,
-    item_id: int = Path(..., title="The ID of the item to get", ge=0, le=1000),
-    q: str,
-    size: float = Query(..., gt=0, lt=10.5)
-):
-    results = {"item_id": item_id}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/python_types/tutorial001.py b/docs_src/python_types/tutorial001.py
deleted file mode 100644
index 0903943..0000000
--- a/docs_src/python_types/tutorial001.py
+++ /dev/null
@@ -1,6 +0,0 @@
-def get_full_name(first_name, last_name):
-    full_name = first_name.title() + " " + last_name.title()
-    return full_name
-
-
-print(get_full_name("john", "doe"))
diff --git a/docs_src/python_types/tutorial002.py b/docs_src/python_types/tutorial002.py
deleted file mode 100644
index c0857a1..0000000
--- a/docs_src/python_types/tutorial002.py
+++ /dev/null
@@ -1,6 +0,0 @@
-def get_full_name(first_name: str, last_name: str):
-    full_name = first_name.title() + " " + last_name.title()
-    return full_name
-
-
-print(get_full_name("john", "doe"))
diff --git a/docs_src/python_types/tutorial003.py b/docs_src/python_types/tutorial003.py
deleted file mode 100644
index d021d82..0000000
--- a/docs_src/python_types/tutorial003.py
+++ /dev/null
@@ -1,3 +0,0 @@
-def get_name_with_age(name: str, age: int):
-    name_with_age = name + " is this old: " + age
-    return name_with_age
diff --git a/docs_src/python_types/tutorial004.py b/docs_src/python_types/tutorial004.py
deleted file mode 100644
index 9400269..0000000
--- a/docs_src/python_types/tutorial004.py
+++ /dev/null
@@ -1,3 +0,0 @@
-def get_name_with_age(name: str, age: int):
-    name_with_age = name + " is this old: " + str(age)
-    return name_with_age
diff --git a/docs_src/python_types/tutorial005.py b/docs_src/python_types/tutorial005.py
deleted file mode 100644
index 08ab44a..0000000
--- a/docs_src/python_types/tutorial005.py
+++ /dev/null
@@ -1,2 +0,0 @@
-def get_items(item_a: str, item_b: int, item_c: float, item_d: bool, item_e: bytes):
-    return item_a, item_b, item_c, item_d, item_d, item_e
diff --git a/docs_src/python_types/tutorial006.py b/docs_src/python_types/tutorial006.py
deleted file mode 100644
index 87394ec..0000000
--- a/docs_src/python_types/tutorial006.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from typing import List
-
-
-def process_items(items: List[str]):
-    for item in items:
-        print(item)
diff --git a/docs_src/python_types/tutorial007.py b/docs_src/python_types/tutorial007.py
deleted file mode 100644
index 5b13f15..0000000
--- a/docs_src/python_types/tutorial007.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from typing import Set, Tuple
-
-
-def process_items(items_t: Tuple[int, int, str], items_s: Set[bytes]):
-    return items_t, items_s
diff --git a/docs_src/python_types/tutorial008.py b/docs_src/python_types/tutorial008.py
deleted file mode 100644
index 9fb1043..0000000
--- a/docs_src/python_types/tutorial008.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from typing import Dict
-
-
-def process_items(prices: Dict[str, float]):
-    for item_name, item_price in prices.items():
-        print(item_name)
-        print(item_price)
diff --git a/docs_src/python_types/tutorial009.py b/docs_src/python_types/tutorial009.py
deleted file mode 100644
index 6328a14..0000000
--- a/docs_src/python_types/tutorial009.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from typing import Optional
-
-
-def say_hi(name: Optional[str] = None):
-    if name is not None:
-        print(f"Hey {name}!")
-    else:
-        print("Hello World")
diff --git a/docs_src/python_types/tutorial010.py b/docs_src/python_types/tutorial010.py
deleted file mode 100644
index 468cffc..0000000
--- a/docs_src/python_types/tutorial010.py
+++ /dev/null
@@ -1,7 +0,0 @@
-class Person:
-    def __init__(self, name: str):
-        self.name = name
-
-
-def get_person_name(one_person: Person):
-    return one_person.name
diff --git a/docs_src/python_types/tutorial011.py b/docs_src/python_types/tutorial011.py
deleted file mode 100644
index 047b633..0000000
--- a/docs_src/python_types/tutorial011.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from datetime import datetime
-from typing import List, Optional
-
-from pydantic import BaseModel
-
-
-class User(BaseModel):
-    id: int
-    name = "John Doe"
-    signup_ts: Optional[datetime] = None
-    friends: List[int] = []
-
-
-external_data = {
-    "id": "123",
-    "signup_ts": "2017-06-01 12:22",
-    "friends": [1, "2", b"3"],
-}
-user = User(**external_data)
-print(user)
-# > User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]
-print(user.id)
-# > 123
diff --git a/docs_src/query_params/tutorial001.py b/docs_src/query_params/tutorial001.py
deleted file mode 100644
index db43a0d..0000000
--- a/docs_src/query_params/tutorial001.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]
-
-
-@app.get("/items/")
-async def read_item(skip: int = 0, limit: int = 10):
-    return fake_items_db[skip : skip + limit]
diff --git a/docs_src/query_params/tutorial002.py b/docs_src/query_params/tutorial002.py
deleted file mode 100644
index 3f2cf5f..0000000
--- a/docs_src/query_params/tutorial002.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from typing import Optional
-
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id: str, q: Optional[str] = None):
-    if q:
-        return {"item_id": item_id, "q": q}
-    return {"item_id": item_id}
diff --git a/docs_src/query_params/tutorial003.py b/docs_src/query_params/tutorial003.py
deleted file mode 100644
index b69019b..0000000
--- a/docs_src/query_params/tutorial003.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from typing import Optional
-
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_item(item_id: str, q: Optional[str] = None, short: bool = False):
-    item = {"item_id": item_id}
-    if q:
-        item.update({"q": q})
-    if not short:
-        item.update(
-            {"description": "This is an amazing item that has a long description"}
-        )
-    return item
diff --git a/docs_src/query_params/tutorial004.py b/docs_src/query_params/tutorial004.py
deleted file mode 100644
index 779507f..0000000
--- a/docs_src/query_params/tutorial004.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from typing import Optional
-
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/users/{user_id}/items/{item_id}")
-async def read_user_item(
-    user_id: int, item_id: str, q: Optional[str] = None, short: bool = False
-):
-    item = {"item_id": item_id, "owner_id": user_id}
-    if q:
-        item.update({"q": q})
-    if not short:
-        item.update(
-            {"description": "This is an amazing item that has a long description"}
-        )
-    return item
diff --git a/docs_src/query_params/tutorial005.py b/docs_src/query_params/tutorial005.py
deleted file mode 100644
index 2a3484b..0000000
--- a/docs_src/query_params/tutorial005.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_user_item(item_id: str, needy: str):
-    item = {"item_id": item_id, "needy": needy}
-    return item
diff --git a/docs_src/query_params/tutorial006.py b/docs_src/query_params/tutorial006.py
deleted file mode 100644
index e971e32..0000000
--- a/docs_src/query_params/tutorial006.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from typing import Optional
-
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-async def read_user_item(
-    item_id: str, needy: str, skip: int = 0, limit: Optional[int] = None
-):
-    item = {"item_id": item_id, "needy": needy, "skip": skip, "limit": limit}
-    return item
diff --git a/docs_src/query_params_str_validations/tutorial001.py b/docs_src/query_params_str_validations/tutorial001.py
deleted file mode 100644
index 590f929..0000000
--- a/docs_src/query_params_str_validations/tutorial001.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from typing import Optional
-
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: Optional[str] = None):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial002.py b/docs_src/query_params_str_validations/tutorial002.py
deleted file mode 100644
index 32fb70a..0000000
--- a/docs_src/query_params_str_validations/tutorial002.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from typing import Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: Optional[str] = Query(None, max_len=50)):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial003.py b/docs_src/query_params_str_validations/tutorial003.py
deleted file mode 100644
index 5d92407..0000000
--- a/docs_src/query_params_str_validations/tutorial003.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from typing import Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: Optional[str] = Query(None, min_len=3, max_len=50)):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial004.py b/docs_src/query_params_str_validations/tutorial004.py
deleted file mode 100644
index e344df9..0000000
--- a/docs_src/query_params_str_validations/tutorial004.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from typing import Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(
-    q: Optional[str] = Query(None, min_len=3, max_len=50, regex="^fixedquery$")
-):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial005.py b/docs_src/query_params_str_validations/tutorial005.py
deleted file mode 100644
index c12345d..0000000
--- a/docs_src/query_params_str_validations/tutorial005.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: str = Query("fixedquery", min_len=3)):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial006.py b/docs_src/query_params_str_validations/tutorial006.py
deleted file mode 100644
index 1adf239..0000000
--- a/docs_src/query_params_str_validations/tutorial006.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: str = Query(..., min_len=3)):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial007.py b/docs_src/query_params_str_validations/tutorial007.py
deleted file mode 100644
index 1c1850b..0000000
--- a/docs_src/query_params_str_validations/tutorial007.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from typing import Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: Optional[str] = Query(None, title="Query string", min_len=3)):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial008.py b/docs_src/query_params_str_validations/tutorial008.py
deleted file mode 100644
index 961301b..0000000
--- a/docs_src/query_params_str_validations/tutorial008.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from typing import Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(
-    q: Optional[str] = Query(
-        None,
-        title="Query string",
-        description="Query string for the items to search in the database that have a good match",
-        min_len=3,
-    )
-):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial009.py b/docs_src/query_params_str_validations/tutorial009.py
deleted file mode 100644
index 56e535a..0000000
--- a/docs_src/query_params_str_validations/tutorial009.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from typing import Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: Optional[str] = Query(None, alias="item-query")):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial010.py b/docs_src/query_params_str_validations/tutorial010.py
deleted file mode 100644
index 2df9201..0000000
--- a/docs_src/query_params_str_validations/tutorial010.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from typing import Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(
-    q: Optional[str] = Query(
-        None,
-        alias="item-query",
-        title="Query string",
-        description="Query string for the items to search in the database that have a good match",
-        min_len=3,
-        max_len=50,
-        regex="^fixedquery$",
-        deprecated=True,
-    )
-):
-    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-    if q:
-        results.update({"q": q})
-    return results
diff --git a/docs_src/query_params_str_validations/tutorial011.py b/docs_src/query_params_str_validations/tutorial011.py
deleted file mode 100644
index 110c453..0000000
--- a/docs_src/query_params_str_validations/tutorial011.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from typing import List, Optional
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: Optional[List[str]] = Query(None)):
-    return {"q": q}
diff --git a/docs_src/request_files/tutorial001.py b/docs_src/request_files/tutorial001.py
deleted file mode 100644
index 74942ef..0000000
--- a/docs_src/request_files/tutorial001.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall import File, Squall, UploadFile
-
-app = Squall()
-
-
-@app.post("/files/")
-async def create_file(file: bytes = File(...)):
-    return {"file_size": len(file)}
-
-
-@app.post("/uploadfile/")
-async def create_upload_file(file: UploadFile = File(...)):
-    return {"filename": file.filename}
diff --git a/docs_src/request_files/tutorial002.py b/docs_src/request_files/tutorial002.py
deleted file mode 100644
index 7610bc0..0000000
--- a/docs_src/request_files/tutorial002.py
+++ /dev/null
@@ -1,33 +0,0 @@
-from typing import List
-
-from squall import File, Squall, UploadFile
-from squall.responses import HTMLResponse
-
-app = Squall()
-
-
-@app.post("/files/")
-async def create_files(files: List[bytes] = File(...)):
-    return {"file_sizes": [len(file) for file in files]}
-
-
-@app.post("/uploadfiles/")
-async def create_upload_files(files: List[UploadFile] = File(...)):
-    return {"filenames": [file.filename for file in files]}
-
-
-@app.get("/")
-async def main():
-    content = """
-<body>
-<form action="/files/" enctype="multipart/form-data" method="post">
-<input name="files" type="file" multiple>
-<input type="submit">
-</form>
-<form action="/uploadfiles/" enctype="multipart/form-data" method="post">
-<input name="files" type="file" multiple>
-<input type="submit">
-</form>
-</body>
-    """
-    return HTMLResponse(content=content)
diff --git a/docs_src/request_forms/tutorial001.py b/docs_src/request_forms/tutorial001.py
deleted file mode 100644
index fb35749..0000000
--- a/docs_src/request_forms/tutorial001.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Form, Squall
-
-app = Squall()
-
-
-@app.post("/login/")
-async def login(username: str = Form(...), password: str = Form(...)):
-    return {"username": username}
diff --git a/docs_src/request_forms_and_files/tutorial001.py b/docs_src/request_forms_and_files/tutorial001.py
deleted file mode 100644
index 964e796..0000000
--- a/docs_src/request_forms_and_files/tutorial001.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from squall import File, Form, Squall, UploadFile
-
-app = Squall()
-
-
-@app.post("/files/")
-async def create_file(
-    file: bytes = File(...), fileb: UploadFile = File(...), token: str = Form(...)
-):
-    return {
-        "file_size": len(file),
-        "token": token,
-        "fileb_content_type": fileb.content_type,
-    }
diff --git a/docs_src/response_change_status_code/tutorial001.py b/docs_src/response_change_status_code/tutorial001.py
deleted file mode 100644
index fd1900c..0000000
--- a/docs_src/response_change_status_code/tutorial001.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall import Response, Squall, status
-
-app = Squall()
-
-tasks = {"foo": "Listen to the Bar Fighters"}
-
-
-@app.put("/get-or-create-task/{task_id}", status_code=200)
-def get_or_create_task(task_id: str, response: Response):
-    if task_id not in tasks:
-        tasks[task_id] = "This didn't exist before"
-        response.status_code = status.HTTP_201_CREATED
-    return tasks[task_id]
diff --git a/docs_src/response_cookies/tutorial001.py b/docs_src/response_cookies/tutorial001.py
deleted file mode 100644
index 4677c3a..0000000
--- a/docs_src/response_cookies/tutorial001.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from squall import Squall
-from squall.responses import JSONResponse
-
-app = Squall()
-
-
-@app.post("/cookie/")
-def create_cookie():
-    content = {"message": "Come to the dark side, we have cookies"}
-    response = JSONResponse(content=content)
-    response.set_cookie(key="fakesession", value="fake-cookie-session-value")
-    return response
diff --git a/docs_src/response_cookies/tutorial002.py b/docs_src/response_cookies/tutorial002.py
deleted file mode 100644
index 2239634..0000000
--- a/docs_src/response_cookies/tutorial002.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Response, Squall
-
-app = Squall()
-
-
-@app.post("/cookie-and-object/")
-def create_cookie(response: Response):
-    response.set_cookie(key="fakesession", value="fake-cookie-session-value")
-    return {"message": "Come to the dark side, we have cookies"}
diff --git a/docs_src/response_directly/tutorial001.py b/docs_src/response_directly/tutorial001.py
deleted file mode 100644
index 1ca8d07..0000000
--- a/docs_src/response_directly/tutorial001.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Squall
-from squall.encoders import jsonable_encoder
-from squall.responses import JSONResponse
-
-
-class Item(BaseModel):
-    title: str
-    timestamp: datetime
-    description: Optional[str] = None
-
-
-app = Squall()
-
-
-@app.put("/items/{id}")
-def update_item(id: str, item: Item):
-    json_compatible_item_data = jsonable_encoder(item)
-    return JSONResponse(content=json_compatible_item_data)
diff --git a/docs_src/response_directly/tutorial002.py b/docs_src/response_directly/tutorial002.py
deleted file mode 100644
index 2f3d1f4..0000000
--- a/docs_src/response_directly/tutorial002.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from squall import Response, Squall
-
-app = Squall()
-
-
-@app.get("/legacy/")
-def get_legacy_data():
-    data = """<?xml version="1.0"?>
-    <shampoo>
-    <Header>
-        Apply shampoo here.
-    </Header>
-    <Body>
-        You'll have to use soap here.
-    </Body>
-    </shampoo>
-    """
-    return Response(content=data, media_type="application/xml")
diff --git a/docs_src/response_headers/tutorial001.py b/docs_src/response_headers/tutorial001.py
deleted file mode 100644
index 7be0d6e..0000000
--- a/docs_src/response_headers/tutorial001.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Squall
-from squall.responses import JSONResponse
-
-app = Squall()
-
-
-@app.get("/headers/")
-def get_headers():
-    content = {"message": "Hello World"}
-    headers = {"X-Cat-Dog": "alone in the world", "Content-Language": "en-US"}
-    return JSONResponse(content=content, headers=headers)
diff --git a/docs_src/response_headers/tutorial002.py b/docs_src/response_headers/tutorial002.py
deleted file mode 100644
index b23529d..0000000
--- a/docs_src/response_headers/tutorial002.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Response, Squall
-
-app = Squall()
-
-
-@app.get("/headers-and-object/")
-def get_headers(response: Response):
-    response.headers["X-Cat-Dog"] = "alone in the world"
-    return {"message": "Hello World"}
diff --git a/docs_src/response_model/tutorial003.py b/docs_src/response_model/tutorial003.py
deleted file mode 100644
index f06f982..0000000
--- a/docs_src/response_model/tutorial003.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel, EmailStr
-from squall import Squall
-
-app = Squall()
-
-
-class UserIn(BaseModel):
-    username: str
-    password: str
-    email: EmailStr
-    full_name: Optional[str] = None
-
-
-class UserOut(BaseModel):
-    username: str
-    email: EmailStr
-    full_name: Optional[str] = None
-
-
-@app.post("/user/", response_model=UserOut)
-async def create_user(user: UserIn):
-    return user
diff --git a/docs_src/response_model/tutorial004.py b/docs_src/response_model/tutorial004.py
deleted file mode 100644
index 25524f5..0000000
--- a/docs_src/response_model/tutorial004.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: float = 10.5
-    tags: List[str] = []
-
-
-items = {
-    "foo": {"name": "Foo", "price": 50.2},
-    "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2},
-    "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []},
-}
-
-
-@app.get("/items/{item_id}", response_model=Item, response_model_exclude_unset=True)
-async def read_item(item_id: str):
-    return items[item_id]
diff --git a/docs_src/response_status_code/tutorial001.py b/docs_src/response_status_code/tutorial001.py
deleted file mode 100644
index dd1eaef..0000000
--- a/docs_src/response_status_code/tutorial001.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.post("/items/", status_code=201)
-async def create_item(name: str):
-    return {"name": name}
diff --git a/docs_src/response_status_code/tutorial002.py b/docs_src/response_status_code/tutorial002.py
deleted file mode 100644
index 80c0a0c..0000000
--- a/docs_src/response_status_code/tutorial002.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall, status
-
-app = Squall()
-
-
-@app.post("/items/", status_code=status.HTTP_201_CREATED)
-async def create_item(name: str):
-    return {"name": name}
diff --git a/docs_src/schema_extra_example/tutorial001.py b/docs_src/schema_extra_example/tutorial001.py
deleted file mode 100644
index 55cac8c..0000000
--- a/docs_src/schema_extra_example/tutorial001.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-
-    class Config:
-        schema_extra = {
-            "example": {
-                "name": "Foo",
-                "description": "A very nice Item",
-                "price": 35.4,
-                "tax": 3.2,
-            }
-        }
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/schema_extra_example/tutorial002.py b/docs_src/schema_extra_example/tutorial002.py
deleted file mode 100644
index f4c3520..0000000
--- a/docs_src/schema_extra_example/tutorial002.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel, Field
-from squall import Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str = Field(..., example="Foo")
-    description: Optional[str] = Field(None, example="A very nice Item")
-    price: float = Field(..., example=35.4)
-    tax: Optional[float] = Field(None, example=3.2)
-
-
-@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/schema_extra_example/tutorial003.py b/docs_src/schema_extra_example/tutorial003.py
deleted file mode 100644
index 26280b9..0000000
--- a/docs_src/schema_extra_example/tutorial003.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Body, Squall
-
-app = Squall()
-
-
-class Item(BaseModel):
-    name: str
-    description: Optional[str] = None
-    price: float
-    tax: Optional[float] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(
-    item_id: int,
-    item: Item = Body(
-        ...,
-        example={
-            "name": "Foo",
-            "description": "A very nice Item",
-            "price": 35.4,
-            "tax": 3.2,
-        },
-    ),
-):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/schema_extra_example/tutorial004.py b/docs_src/schema_extra_example/tutorial004.py
deleted file mode 100644
index fa155fb..0000000
--- a/docs_src/schema_extra_example/tutorial004.py
+++ /dev/null
@@ -1,53 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Body, Squall
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: str = Field(...)
-    description: Optional[str] = None
-    price: float = Field(...)
-    tax: Optional[float] = None
-
-
-@app.put("/items/{item_id}")
-async def update_item(
-    *,
-    item_id: int,
-    item: Item = Body(
-        ...,
-        examples={
-            "normal": {
-                "summary": "A normal example",
-                "description": "A **normal** item works correctly.",
-                "value": {
-                    "name": "Foo",
-                    "description": "A very nice Item",
-                    "price": 35.4,
-                    "tax": 3.2,
-                },
-            },
-            "converted": {
-                "summary": "An example with converted data",
-                "description": "Squall can convert price `strings` to actual `numbers` automatically",
-                "value": {
-                    "name": "Bar",
-                    "price": "35.4",
-                },
-            },
-            "invalid": {
-                "summary": "Invalid data is rejected with an error",
-                "value": {
-                    "name": "Baz",
-                    "price": "thirty five point four",
-                },
-            },
-        },
-    ),
-):
-    results = {"item_id": item_id, "item": item}
-    return results
diff --git a/docs_src/security/tutorial001.py b/docs_src/security/tutorial001.py
deleted file mode 100644
index 27757ae..0000000
--- a/docs_src/security/tutorial001.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Depends, Squall
-from squall.security import OAuth2PasswordBearer
-
-app = Squall()
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-
-@app.get("/items/")
-async def read_items(token: str = Depends(oauth2_scheme)):
-    return {"token": token}
diff --git a/docs_src/security/tutorial002.py b/docs_src/security/tutorial002.py
deleted file mode 100644
index 36b5087..0000000
--- a/docs_src/security/tutorial002.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Depends, Squall
-from squall.security import OAuth2PasswordBearer
-
-app = Squall()
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-
-class User(BaseModel):
-    username: str
-    email: Optional[str] = None
-    full_name: Optional[str] = None
-    disabled: Optional[bool] = None
-
-
-def fake_decode_token(token):
-    return User(
-        username=token + "fakedecoded", email="john@example.com", full_name="John Doe"
-    )
-
-
-async def get_current_user(token: str = Depends(oauth2_scheme)):
-    user = fake_decode_token(token)
-    return user
-
-
-@app.get("/users/me")
-async def read_users_me(current_user: User = Depends(get_current_user)):
-    return current_user
diff --git a/docs_src/security/tutorial003.py b/docs_src/security/tutorial003.py
deleted file mode 100644
index b180217..0000000
--- a/docs_src/security/tutorial003.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from squall import Depends, HTTPException, Squall, status
-from squall.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-
-fake_users_db = {
-    "johndoe": {
-        "username": "johndoe",
-        "full_name": "John Doe",
-        "email": "johndoe@example.com",
-        "hashed_password": "fakehashedsecret",
-        "disabled": False,
-    },
-    "alice": {
-        "username": "alice",
-        "full_name": "Alice Wonderson",
-        "email": "alice@example.com",
-        "hashed_password": "fakehashedsecret2",
-        "disabled": True,
-    },
-}
-
-app = Squall()
-
-
-def fake_hash_password(password: str):
-    return "fakehashed" + password
-
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-
-class User(BaseModel):
-    username: str
-    email: Optional[str] = None
-    full_name: Optional[str] = None
-    disabled: Optional[bool] = None
-
-
-class UserInDB(User):
-    hashed_password: str
-
-
-def get_user(db, username: str):
-    if username in db:
-        user_dict = db[username]
-        return UserInDB(**user_dict)
-
-
-def fake_decode_token(token):
-    # This doesn't provide any security at all
-    # Check the next version
-    user = get_user(fake_users_db, token)
-    return user
-
-
-async def get_current_user(token: str = Depends(oauth2_scheme)):
-    user = fake_decode_token(token)
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid authentication credentials",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-    return user
-
-
-async def get_current_active_user(current_user: User = Depends(get_current_user)):
-    if current_user.disabled:
-        raise HTTPException(status_code=400, detail="Inactive user")
-    return current_user
-
-
-@app.post("/token")
-async def login(form_data: OAuth2PasswordRequestForm = Depends()):
-    user_dict = fake_users_db.get(form_data.username)
-    if not user_dict:
-        raise HTTPException(status_code=400, detail="Incorrect username or password")
-    user = UserInDB(**user_dict)
-    hashed_password = fake_hash_password(form_data.password)
-    if not hashed_password == user.hashed_password:
-        raise HTTPException(status_code=400, detail="Incorrect username or password")
-
-    return {"access_token": user.username, "token_type": "bearer"}
-
-
-@app.get("/users/me")
-async def read_users_me(current_user: User = Depends(get_current_active_user)):
-    return current_user
diff --git a/docs_src/security/tutorial004.py b/docs_src/security/tutorial004.py
deleted file mode 100644
index 147267a..0000000
--- a/docs_src/security/tutorial004.py
+++ /dev/null
@@ -1,138 +0,0 @@
-from datetime import datetime, timedelta
-from typing import Optional
-
-from jose import JWTError, jwt
-from passlib.context import CryptContext
-from pydantic import BaseModel
-from squall import Depends, HTTPException, Squall, status
-from squall.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-
-# to get a string like this run:
-# openssl rand -hex 32
-SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-
-fake_users_db = {
-    "johndoe": {
-        "username": "johndoe",
-        "full_name": "John Doe",
-        "email": "johndoe@example.com",
-        "hashed_password": "$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW",
-        "disabled": False,
-    }
-}
-
-
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
-
-class TokenData(BaseModel):
-    username: Optional[str] = None
-
-
-class User(BaseModel):
-    username: str
-    email: Optional[str] = None
-    full_name: Optional[str] = None
-    disabled: Optional[bool] = None
-
-
-class UserInDB(User):
-    hashed_password: str
-
-
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-app = Squall()
-
-
-def verify_password(plain_password, hashed_password):
-    return pwd_context.verify(plain_password, hashed_password)
-
-
-def get_password_hash(password):
-    return pwd_context.hash(password)
-
-
-def get_user(db, username: str):
-    if username in db:
-        user_dict = db[username]
-        return UserInDB(**user_dict)
-
-
-def authenticate_user(fake_db, username: str, password: str):
-    user = get_user(fake_db, username)
-    if not user:
-        return False
-    if not verify_password(password, user.hashed_password):
-        return False
-    return user
-
-
-def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
-    to_encode = data.copy()
-    if expires_delta:
-        expire = datetime.utcnow() + expires_delta
-    else:
-        expire = datetime.utcnow() + timedelta(minutes=15)
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-
-async def get_current_user(token: str = Depends(oauth2_scheme)):
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Could not validate credentials",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-    try:
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        username: str = payload.get("sub")
-        if username is None:
-            raise credentials_exception
-        token_data = TokenData(username=username)
-    except JWTError:
-        raise credentials_exception
-    user = get_user(fake_users_db, username=token_data.username)
-    if user is None:
-        raise credentials_exception
-    return user
-
-
-async def get_current_active_user(current_user: User = Depends(get_current_user)):
-    if current_user.disabled:
-        raise HTTPException(status_code=400, detail="Inactive user")
-    return current_user
-
-
-@app.post("/token", response_model=Token)
-async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
-    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect username or password",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-    access_token = create_access_token(
-        data={"sub": user.username}, expires_delta=access_token_expires
-    )
-    return {"access_token": access_token, "token_type": "bearer"}
-
-
-@app.get("/users/me/", response_model=User)
-async def read_users_me(current_user: User = Depends(get_current_active_user)):
-    return current_user
-
-
-@app.get("/users/me/items/")
-async def read_own_items(current_user: User = Depends(get_current_active_user)):
-    return [{"item_id": "Foo", "owner": current_user.username}]
diff --git a/docs_src/security/tutorial005.py b/docs_src/security/tutorial005.py
deleted file mode 100644
index 7117e85..0000000
--- a/docs_src/security/tutorial005.py
+++ /dev/null
@@ -1,173 +0,0 @@
-from datetime import datetime, timedelta
-from typing import List, Optional
-
-from jose import JWTError, jwt
-from passlib.context import CryptContext
-from pydantic import BaseModel, ValidationError
-from squall import Depends, HTTPException, Security, Squall, status
-from squall.security import (
-    OAuth2PasswordBearer,
-    OAuth2PasswordRequestForm,
-    SecurityScopes,
-)
-
-# to get a string like this run:
-# openssl rand -hex 32
-SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-
-fake_users_db = {
-    "johndoe": {
-        "username": "johndoe",
-        "full_name": "John Doe",
-        "email": "johndoe@example.com",
-        "hashed_password": "$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW",
-        "disabled": False,
-    },
-    "alice": {
-        "username": "alice",
-        "full_name": "Alice Chains",
-        "email": "alicechains@example.com",
-        "hashed_password": "$2b$12$gSvqqUPvlXP2tfVFaWK1Be7DlH.PKZbv5H8KnzzVgXXbVxpva.pFm",
-        "disabled": True,
-    },
-}
-
-
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
-
-class TokenData(BaseModel):
-    username: Optional[str] = None
-    scopes: List[str] = []
-
-
-class User(BaseModel):
-    username: str
-    email: Optional[str] = None
-    full_name: Optional[str] = None
-    disabled: Optional[bool] = None
-
-
-class UserInDB(User):
-    hashed_password: str
-
-
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-oauth2_scheme = OAuth2PasswordBearer(
-    tokenUrl="token",
-    scopes={"me": "Read information about the current user.", "items": "Read items."},
-)
-
-app = Squall()
-
-
-def verify_password(plain_password, hashed_password):
-    return pwd_context.verify(plain_password, hashed_password)
-
-
-def get_password_hash(password):
-    return pwd_context.hash(password)
-
-
-def get_user(db, username: str):
-    if username in db:
-        user_dict = db[username]
-        return UserInDB(**user_dict)
-
-
-def authenticate_user(fake_db, username: str, password: str):
-    user = get_user(fake_db, username)
-    if not user:
-        return False
-    if not verify_password(password, user.hashed_password):
-        return False
-    return user
-
-
-def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
-    to_encode = data.copy()
-    if expires_delta:
-        expire = datetime.utcnow() + expires_delta
-    else:
-        expire = datetime.utcnow() + timedelta(minutes=15)
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-
-async def get_current_user(
-    security_scopes: SecurityScopes, token: str = Depends(oauth2_scheme)
-):
-    if security_scopes.scopes:
-        authenticate_value = f'Bearer scope="{security_scopes.scope_str}"'
-    else:
-        authenticate_value = f"Bearer"
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Could not validate credentials",
-        headers={"WWW-Authenticate": authenticate_value},
-    )
-    try:
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        username: str = payload.get("sub")
-        if username is None:
-            raise credentials_exception
-        token_scopes = payload.get("scopes", [])
-        token_data = TokenData(scopes=token_scopes, username=username)
-    except (JWTError, ValidationError):
-        raise credentials_exception
-    user = get_user(fake_users_db, username=token_data.username)
-    if user is None:
-        raise credentials_exception
-    for scope in security_scopes.scopes:
-        if scope not in token_data.scopes:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Not enough permissions",
-                headers={"WWW-Authenticate": authenticate_value},
-            )
-    return user
-
-
-async def get_current_active_user(
-    current_user: User = Security(get_current_user, scopes=["me"])
-):
-    if current_user.disabled:
-        raise HTTPException(status_code=400, detail="Inactive user")
-    return current_user
-
-
-@app.post("/token", response_model=Token)
-async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
-    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
-    if not user:
-        raise HTTPException(status_code=400, detail="Incorrect username or password")
-    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-    access_token = create_access_token(
-        data={"sub": user.username, "scopes": form_data.scopes},
-        expires_delta=access_token_expires,
-    )
-    return {"access_token": access_token, "token_type": "bearer"}
-
-
-@app.get("/users/me/", response_model=User)
-async def read_users_me(current_user: User = Depends(get_current_active_user)):
-    return current_user
-
-
-@app.get("/users/me/items/")
-async def read_own_items(
-    current_user: User = Security(get_current_active_user, scopes=["items"])
-):
-    return [{"item_id": "Foo", "owner": current_user.username}]
-
-
-@app.get("/status/")
-async def read_system_status(current_user: User = Depends(get_current_user)):
-    return {"status": "ok"}
diff --git a/docs_src/security/tutorial006.py b/docs_src/security/tutorial006.py
deleted file mode 100644
index e744507..0000000
--- a/docs_src/security/tutorial006.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall import Depends, Squall
-from squall.security import HTTPBasic, HTTPBasicCredentials
-
-app = Squall()
-
-security = HTTPBasic()
-
-
-@app.get("/users/me")
-def read_current_user(credentials: HTTPBasicCredentials = Depends(security)):
-    return {"username": credentials.username, "password": credentials.password}
diff --git a/docs_src/security/tutorial007.py b/docs_src/security/tutorial007.py
deleted file mode 100644
index 8f0dc69..0000000
--- a/docs_src/security/tutorial007.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import secrets
-
-from squall import Depends, HTTPException, Squall, status
-from squall.security import HTTPBasic, HTTPBasicCredentials
-
-app = Squall()
-
-security = HTTPBasic()
-
-
-def get_current_username(credentials: HTTPBasicCredentials = Depends(security)):
-    correct_username = secrets.compare_digest(credentials.username, "stanleyjobson")
-    correct_password = secrets.compare_digest(credentials.password, "swordfish")
-    if not (correct_username and correct_password):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect email or password",
-            headers={"WWW-Authenticate": "Basic"},
-        )
-    return credentials.username
-
-
-@app.get("/users/me")
-def read_current_user(username: str = Depends(get_current_username)):
-    return {"username": username}
diff --git a/docs_src/settings/app01/__init__.py b/docs_src/settings/app01/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/settings/app01/config.py b/docs_src/settings/app01/config.py
deleted file mode 100644
index defede9..0000000
--- a/docs_src/settings/app01/config.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from pydantic import BaseSettings
-
-
-class Settings(BaseSettings):
-    app_name: str = "Awesome API"
-    admin_email: str
-    items_per_user: int = 50
-
-
-settings = Settings()
diff --git a/docs_src/settings/app01/main.py b/docs_src/settings/app01/main.py
deleted file mode 100644
index bda8963..0000000
--- a/docs_src/settings/app01/main.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from squall import Squall
-
-from .config import settings
-
-app = Squall()
-
-
-@app.get("/info")
-async def info():
-    return {
-        "app_name": settings.app_name,
-        "admin_email": settings.admin_email,
-        "items_per_user": settings.items_per_user,
-    }
diff --git a/docs_src/settings/app02/__init__.py b/docs_src/settings/app02/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/settings/app02/config.py b/docs_src/settings/app02/config.py
deleted file mode 100644
index 9a78291..0000000
--- a/docs_src/settings/app02/config.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from pydantic import BaseSettings
-
-
-class Settings(BaseSettings):
-    app_name: str = "Awesome API"
-    admin_email: str
-    items_per_user: int = 50
diff --git a/docs_src/settings/app02/main.py b/docs_src/settings/app02/main.py
deleted file mode 100644
index a0f0e28..0000000
--- a/docs_src/settings/app02/main.py
+++ /dev/null
@@ -1,21 +0,0 @@
-# from functools import lru_cache
-#
-# from squall import Depends, Squall
-#
-# from .config import Settings
-#
-# app = Squall()
-#
-#
-# @lru_cache()
-# def get_settings():
-#     return Settings()
-#
-#
-# @app.get("/info")
-# async def info(settings: Settings = Depends(get_settings)):
-#     return {
-#         "app_name": settings.app_name,
-#         "admin_email": settings.admin_email,
-#         "items_per_user": settings.items_per_user,
-#     }
diff --git a/docs_src/settings/app03/__init__.py b/docs_src/settings/app03/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/settings/app03/config.py b/docs_src/settings/app03/config.py
deleted file mode 100644
index e1c3ee3..0000000
--- a/docs_src/settings/app03/config.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from pydantic import BaseSettings
-
-
-class Settings(BaseSettings):
-    app_name: str = "Awesome API"
-    admin_email: str
-    items_per_user: int = 50
-
-    class Config:
-        env_file = ".env"
diff --git a/docs_src/settings/app03/main.py b/docs_src/settings/app03/main.py
deleted file mode 100644
index 7c65448..0000000
--- a/docs_src/settings/app03/main.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from functools import lru_cache
-
-from squall import Depends, Squall
-
-from . import config
-
-app = Squall()
-
-
-@lru_cache()
-def get_settings():
-    return config.Settings()
-
-
-@app.get("/info")
-async def info(settings: config.Settings = Depends(get_settings)):
-    return {
-        "app_name": settings.app_name,
-        "admin_email": settings.admin_email,
-        "items_per_user": settings.items_per_user,
-    }
diff --git a/docs_src/settings/tutorial001.py b/docs_src/settings/tutorial001.py
deleted file mode 100644
index 0176e31..0000000
--- a/docs_src/settings/tutorial001.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from pydantic import BaseSettings
-from squall import Squall
-
-
-class Settings(BaseSettings):
-    app_name: str = "Awesome API"
-    admin_email: str
-    items_per_user: int = 50
-
-
-settings = Settings()
-app = Squall()
-
-
-@app.get("/info")
-async def info():
-    return {
-        "app_name": settings.app_name,
-        "admin_email": settings.admin_email,
-        "items_per_user": settings.items_per_user,
-    }
diff --git a/docs_src/sql_databases/__init__.py b/docs_src/sql_databases/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/sql_databases/sql_app/__init__.py b/docs_src/sql_databases/sql_app/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/sql_databases/sql_app/alt_main.py b/docs_src/sql_databases/sql_app/alt_main.py
deleted file mode 100644
index 4b0db81..0000000
--- a/docs_src/sql_databases/sql_app/alt_main.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from typing import List
-
-from sqlalchemy.orm import Session
-from squall import Depends, HTTPException, Request, Response, Squall
-
-from . import crud, models, schemas
-from .database import SessionLocal, engine
-
-models.Base.metadata.create_all(bind=engine)
-
-app = Squall()
-
-
-@app.middleware("http")
-async def db_session_middleware(request: Request, call_next):
-    response = Response("Internal server error", status_code=500)
-    try:
-        request.state.db = SessionLocal()
-        response = await call_next(request)
-    finally:
-        request.state.db.close()
-    return response
-
-
-# Dependency
-def get_db(request: Request):
-    return request.state.db
-
-
-@app.post("/users/", response_model=schemas.User)
-def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
-    db_user = crud.get_user_by_email(db, email=user.email)
-    if db_user:
-        raise HTTPException(status_code=400, detail="Email already registered")
-    return crud.create_user(db=db, user=user)
-
-
-@app.get("/users/", response_model=List[schemas.User])
-def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    users = crud.get_users(db, skip=skip, limit=limit)
-    return users
-
-
-@app.get("/users/{user_id}", response_model=schemas.User)
-def read_user(user_id: int, db: Session = Depends(get_db)):
-    db_user = crud.get_user(db, user_id=user_id)
-    if db_user is None:
-        raise HTTPException(status_code=404, detail="User not found")
-    return db_user
-
-
-@app.post("/users/{user_id}/items/", response_model=schemas.Item)
-def create_item_for_user(
-    user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
-):
-    return crud.create_user_item(db=db, item=item, user_id=user_id)
-
-
-@app.get("/items/", response_model=List[schemas.Item])
-def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    items = crud.get_items(db, skip=skip, limit=limit)
-    return items
diff --git a/docs_src/sql_databases/sql_app/crud.py b/docs_src/sql_databases/sql_app/crud.py
deleted file mode 100644
index 679acdb..0000000
--- a/docs_src/sql_databases/sql_app/crud.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from sqlalchemy.orm import Session
-
-from . import models, schemas
-
-
-def get_user(db: Session, user_id: int):
-    return db.query(models.User).filter(models.User.id == user_id).first()
-
-
-def get_user_by_email(db: Session, email: str):
-    return db.query(models.User).filter(models.User.email == email).first()
-
-
-def get_users(db: Session, skip: int = 0, limit: int = 100):
-    return db.query(models.User).offset(skip).limit(limit).all()
-
-
-def create_user(db: Session, user: schemas.UserCreate):
-    fake_hashed_password = user.password + "notreallyhashed"
-    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
-    db.add(db_user)
-    db.commit()
-    db.refresh(db_user)
-    return db_user
-
-
-def get_items(db: Session, skip: int = 0, limit: int = 100):
-    return db.query(models.Item).offset(skip).limit(limit).all()
-
-
-def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
-    db_item = models.Item(**item.dict(), owner_id=user_id)
-    db.add(db_item)
-    db.commit()
-    db.refresh(db_item)
-    return db_item
diff --git a/docs_src/sql_databases/sql_app/database.py b/docs_src/sql_databases/sql_app/database.py
deleted file mode 100644
index 45a8b9f..0000000
--- a/docs_src/sql_databases/sql_app/database.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-
-SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
-# SQLALCHEMY_DATABASE_URL = "postgresql://user:password@postgresserver/db"
-
-engine = create_engine(
-    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
-)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-Base = declarative_base()
diff --git a/docs_src/sql_databases/sql_app/main.py b/docs_src/sql_databases/sql_app/main.py
deleted file mode 100644
index c94c1bc..0000000
--- a/docs_src/sql_databases/sql_app/main.py
+++ /dev/null
@@ -1,55 +0,0 @@
-from typing import List
-
-from sqlalchemy.orm import Session
-from squall import Depends, HTTPException, Squall
-
-from . import crud, models, schemas
-from .database import SessionLocal, engine
-
-models.Base.metadata.create_all(bind=engine)
-
-app = Squall()
-
-
-# Dependency
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-
-@app.post("/users/", response_model=schemas.User)
-def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
-    db_user = crud.get_user_by_email(db, email=user.email)
-    if db_user:
-        raise HTTPException(status_code=400, detail="Email already registered")
-    return crud.create_user(db=db, user=user)
-
-
-@app.get("/users/", response_model=List[schemas.User])
-def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    users = crud.get_users(db, skip=skip, limit=limit)
-    return users
-
-
-@app.get("/users/{user_id}", response_model=schemas.User)
-def read_user(user_id: int, db: Session = Depends(get_db)):
-    db_user = crud.get_user(db, user_id=user_id)
-    if db_user is None:
-        raise HTTPException(status_code=404, detail="User not found")
-    return db_user
-
-
-@app.post("/users/{user_id}/items/", response_model=schemas.Item)
-def create_item_for_user(
-    user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
-):
-    return crud.create_user_item(db=db, item=item, user_id=user_id)
-
-
-@app.get("/items/", response_model=List[schemas.Item])
-def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    items = crud.get_items(db, skip=skip, limit=limit)
-    return items
diff --git a/docs_src/sql_databases/sql_app/models.py b/docs_src/sql_databases/sql_app/models.py
deleted file mode 100644
index 62d8ab4..0000000
--- a/docs_src/sql_databases/sql_app/models.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
-from sqlalchemy.orm import relationship
-
-from .database import Base
-
-
-class User(Base):
-    __tablename__ = "users"
-
-    id = Column(Integer, primary_key=True, index=True)
-    email = Column(String, unique=True, index=True)
-    hashed_password = Column(String)
-    is_active = Column(Boolean, default=True)
-
-    items = relationship("Item", back_populates="owner")
-
-
-class Item(Base):
-    __tablename__ = "items"
-
-    id = Column(Integer, primary_key=True, index=True)
-    title = Column(String, index=True)
-    description = Column(String, index=True)
-    owner_id = Column(Integer, ForeignKey("users.id"))
-
-    owner = relationship("User", back_populates="items")
diff --git a/docs_src/sql_databases/sql_app/schemas.py b/docs_src/sql_databases/sql_app/schemas.py
deleted file mode 100644
index 5165566..0000000
--- a/docs_src/sql_databases/sql_app/schemas.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel
-
-
-class ItemBase(BaseModel):
-    title: str
-    description: Optional[str] = None
-
-
-class ItemCreate(ItemBase):
-    pass
-
-
-class Item(ItemBase):
-    id: int
-    owner_id: int
-
-    class Config:
-        orm_mode = True
-
-
-class UserBase(BaseModel):
-    email: str
-
-
-class UserCreate(UserBase):
-    password: str
-
-
-class User(UserBase):
-    id: int
-    is_active: bool
-    items: List[Item] = []
-
-    class Config:
-        orm_mode = True
diff --git a/docs_src/sql_databases_peewee/__init__.py b/docs_src/sql_databases_peewee/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/sql_databases_peewee/sql_app/__init__.py b/docs_src/sql_databases_peewee/sql_app/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/sql_databases_peewee/sql_app/crud.py b/docs_src/sql_databases_peewee/sql_app/crud.py
deleted file mode 100644
index 56c5875..0000000
--- a/docs_src/sql_databases_peewee/sql_app/crud.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from . import models, schemas
-
-
-def get_user(user_id: int):
-    return models.User.filter(models.User.id == user_id).first()
-
-
-def get_user_by_email(email: str):
-    return models.User.filter(models.User.email == email).first()
-
-
-def get_users(skip: int = 0, limit: int = 100):
-    return list(models.User.select().offset(skip).limit(limit))
-
-
-def create_user(user: schemas.UserCreate):
-    fake_hashed_password = user.password + "notreallyhashed"
-    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
-    db_user.save()
-    return db_user
-
-
-def get_items(skip: int = 0, limit: int = 100):
-    return list(models.Item.select().offset(skip).limit(limit))
-
-
-def create_user_item(item: schemas.ItemCreate, user_id: int):
-    db_item = models.Item(**item.dict(), owner_id=user_id)
-    db_item.save()
-    return db_item
diff --git a/docs_src/sql_databases_peewee/sql_app/database.py b/docs_src/sql_databases_peewee/sql_app/database.py
deleted file mode 100644
index 6938fe8..0000000
--- a/docs_src/sql_databases_peewee/sql_app/database.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from contextvars import ContextVar
-
-import peewee
-
-DATABASE_NAME = "test.db"
-db_state_default = {"closed": None, "conn": None, "ctx": None, "transactions": None}
-db_state = ContextVar("db_state", default=db_state_default.copy())
-
-
-class PeeweeConnectionState(peewee._ConnectionState):
-    def __init__(self, **kwargs):
-        super().__setattr__("_state", db_state)
-        super().__init__(**kwargs)
-
-    def __setattr__(self, name, value):
-        self._state.get()[name] = value
-
-    def __getattr__(self, name):
-        return self._state.get()[name]
-
-
-db = peewee.SqliteDatabase(DATABASE_NAME, check_same_thread=False)
-
-db._state = PeeweeConnectionState()
diff --git a/docs_src/sql_databases_peewee/sql_app/main.py b/docs_src/sql_databases_peewee/sql_app/main.py
deleted file mode 100644
index 75be76a..0000000
--- a/docs_src/sql_databases_peewee/sql_app/main.py
+++ /dev/null
@@ -1,79 +0,0 @@
-import time
-from typing import List
-
-from squall import Depends, HTTPException, Squall
-
-from . import crud, database, models, schemas
-from .database import db_state_default
-
-database.db.connect()
-database.db.create_tables([models.User, models.Item])
-database.db.close()
-
-app = Squall()
-
-sleep_time = 10
-
-
-async def reset_db_state():
-    database.db._state._state.set(db_state_default.copy())
-    database.db._state.reset()
-
-
-def get_db(db_state=Depends(reset_db_state)):
-    try:
-        database.db.connect()
-        yield
-    finally:
-        if not database.db.is_closed():
-            database.db.close()
-
-
-@app.post("/users/", response_model=schemas.User, dependencies=[Depends(get_db)])
-def create_user(user: schemas.UserCreate):
-    db_user = crud.get_user_by_email(email=user.email)
-    if db_user:
-        raise HTTPException(status_code=400, detail="Email already registered")
-    return crud.create_user(user=user)
-
-
-@app.get("/users/", response_model=List[schemas.User], dependencies=[Depends(get_db)])
-def read_users(skip: int = 0, limit: int = 100):
-    users = crud.get_users(skip=skip, limit=limit)
-    return users
-
-
-@app.get(
-    "/users/{user_id}", response_model=schemas.User, dependencies=[Depends(get_db)]
-)
-def read_user(user_id: int):
-    db_user = crud.get_user(user_id=user_id)
-    if db_user is None:
-        raise HTTPException(status_code=404, detail="User not found")
-    return db_user
-
-
-@app.post(
-    "/users/{user_id}/items/",
-    response_model=schemas.Item,
-    dependencies=[Depends(get_db)],
-)
-def create_item_for_user(user_id: int, item: schemas.ItemCreate):
-    return crud.create_user_item(item=item, user_id=user_id)
-
-
-@app.get("/items/", response_model=List[schemas.Item], dependencies=[Depends(get_db)])
-def read_items(skip: int = 0, limit: int = 100):
-    items = crud.get_items(skip=skip, limit=limit)
-    return items
-
-
-@app.get(
-    "/slowusers/", response_model=List[schemas.User], dependencies=[Depends(get_db)]
-)
-def read_slow_users(skip: int = 0, limit: int = 100):
-    global sleep_time
-    sleep_time = max(0, sleep_time - 1)
-    time.sleep(sleep_time)  # Fake long processing request
-    users = crud.get_users(skip=skip, limit=limit)
-    return users
diff --git a/docs_src/sql_databases_peewee/sql_app/models.py b/docs_src/sql_databases_peewee/sql_app/models.py
deleted file mode 100644
index 46bdcd0..0000000
--- a/docs_src/sql_databases_peewee/sql_app/models.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import peewee
-
-from .database import db
-
-
-class User(peewee.Model):
-    email = peewee.CharField(unique=True, index=True)
-    hashed_password = peewee.CharField()
-    is_active = peewee.BooleanField(default=True)
-
-    class Meta:
-        database = db
-
-
-class Item(peewee.Model):
-    title = peewee.CharField(index=True)
-    description = peewee.CharField(index=True)
-    owner = peewee.ForeignKeyField(User, backref="items")
-
-    class Meta:
-        database = db
diff --git a/docs_src/sql_databases_peewee/sql_app/schemas.py b/docs_src/sql_databases_peewee/sql_app/schemas.py
deleted file mode 100644
index b715604..0000000
--- a/docs_src/sql_databases_peewee/sql_app/schemas.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from typing import Any, List, Optional
-
-import peewee
-from pydantic import BaseModel
-from pydantic.utils import GetterDict
-
-
-class PeeweeGetterDict(GetterDict):
-    def get(self, key: Any, default: Any = None):
-        res = getattr(self._obj, key, default)
-        if isinstance(res, peewee.ModelSelect):
-            return list(res)
-        return res
-
-
-class ItemBase(BaseModel):
-    title: str
-    description: Optional[str] = None
-
-
-class ItemCreate(ItemBase):
-    pass
-
-
-class Item(ItemBase):
-    id: int
-    owner_id: int
-
-    class Config:
-        orm_mode = True
-        getter_dict = PeeweeGetterDict
-
-
-class UserBase(BaseModel):
-    email: str
-
-
-class UserCreate(UserBase):
-    password: str
-
-
-class User(UserBase):
-    id: int
-    is_active: bool
-    items: List[Item] = []
-
-    class Config:
-        orm_mode = True
-        getter_dict = PeeweeGetterDict
diff --git a/docs_src/static_files/tutorial001.py b/docs_src/static_files/tutorial001.py
deleted file mode 100644
index 912c068..0000000
--- a/docs_src/static_files/tutorial001.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from squall import Squall
-from squall.staticfiles import StaticFiles
-
-app = Squall()
-
-app.mount("/static", StaticFiles(directory="static"), name="static")
diff --git a/docs_src/templates/static/styles.css b/docs_src/templates/static/styles.css
deleted file mode 100644
index dda2cdf..0000000
--- a/docs_src/templates/static/styles.css
+++ /dev/null
@@ -1,3 +0,0 @@
-h1 {
-    color: green;
-}
diff --git a/docs_src/templates/templates/item.html b/docs_src/templates/templates/item.html
deleted file mode 100644
index a70287e..0000000
--- a/docs_src/templates/templates/item.html
+++ /dev/null
@@ -1,9 +0,0 @@
-<html>
-<head>
-    <title>Item Details</title>
-    <link href="{{ url_for('static', path='/styles.css') }}" rel="stylesheet">
-</head>
-<body>
-    <h1>Item ID: {{ id }}</h1>
-</body>
-</html>
diff --git a/docs_src/templates/tutorial001.py b/docs_src/templates/tutorial001.py
deleted file mode 100644
index 9f7c111..0000000
--- a/docs_src/templates/tutorial001.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from squall import Request, Squall
-from squall.responses import HTMLResponse
-from squall.staticfiles import StaticFiles
-from squall.templating import Jinja2Templates
-
-app = Squall()
-
-app.add_route("/static", StaticFiles(directory="static"), name="static")
-
-
-templates = Jinja2Templates(directory="templates")
-
-
-@app.get("/items/{id}", response_class=HTMLResponse)
-async def read_item(request: Request, id: str):
-    return templates.TemplateResponse("item.html", {"request": request, "id": id})
diff --git a/docs_src/using_request_directly/tutorial001.py b/docs_src/using_request_directly/tutorial001.py
deleted file mode 100644
index 601d8ac..0000000
--- a/docs_src/using_request_directly/tutorial001.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Request, Squall
-
-app = Squall()
-
-
-@app.get("/items/{item_id}")
-def read_root(item_id: str, request: Request):
-    client_host = request.client.host
-    return {"client_host": client_host, "item_id": item_id}
diff --git a/docs_src/websockets/__init__.py b/docs_src/websockets/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/websockets/tutorial001.py b/docs_src/websockets/tutorial001.py
deleted file mode 100644
index 1e06439..0000000
--- a/docs_src/websockets/tutorial001.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from squall import Squall, WebSocket
-from squall.responses import HTMLResponse
-
-app = Squall()
-
-html = """
-<!DOCTYPE html>
-<html>
-    <head>
-        <title>Chat</title>
-    </head>
-    <body>
-        <h1>WebSocket Chat</h1>
-        <form action="" onsubmit="sendMessage(event)">
-            <input type="text" id="messageText" autocomplete="off"/>
-            <button>Send</button>
-        </form>
-        <ul id='messages'>
-        </ul>
-        <script>
-            var ws = new WebSocket("ws://localhost:8000/ws");
-            ws.onmessage = function(event) {
-                var messages = document.getElementById('messages')
-                var message = document.createElement('li')
-                var content = document.createTextNode(event.data)
-                message.appendChild(content)
-                messages.appendChild(message)
-            };
-            function sendMessage(event) {
-                var input = document.getElementById("messageText")
-                ws.send(input.value)
-                input.value = ''
-                event.preventDefault()
-            }
-        </script>
-    </body>
-</html>
-"""
-
-
-@app.get("/")
-async def get():
-    return HTMLResponse(html)
-
-
-@app.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket):
-    await websocket.accept()
-    while True:
-        data = await websocket.receive_text()
-        await websocket.send_text(f"Message text was: {data}")
diff --git a/docs_src/websockets/tutorial002.py b/docs_src/websockets/tutorial002.py
deleted file mode 100644
index 99fb92b..0000000
--- a/docs_src/websockets/tutorial002.py
+++ /dev/null
@@ -1,83 +0,0 @@
-from typing import Optional
-
-from squall import Cookie, Depends, Query, Squall, WebSocket, status
-from squall.responses import HTMLResponse
-
-app = Squall()
-
-html = """
-<!DOCTYPE html>
-<html>
-    <head>
-        <title>Chat</title>
-    </head>
-    <body>
-        <h1>WebSocket Chat</h1>
-        <form action="" onsubmit="sendMessage(event)">
-            <label>Item ID: <input type="text" id="itemId" autocomplete="off" value="foo"/></label>
-            <label>Token: <input type="text" id="token" autocomplete="off" value="some-key-token"/></label>
-            <button onclick="connect(event)">Connect</button>
-            <hr>
-            <label>Message: <input type="text" id="messageText" autocomplete="off"/></label>
-            <button>Send</button>
-        </form>
-        <ul id='messages'>
-        </ul>
-        <script>
-        var ws = null;
-            function connect(event) {
-                var itemId = document.getElementById("itemId")
-                var token = document.getElementById("token")
-                ws = new WebSocket("ws://localhost:8000/items/" + itemId.value + "/ws?token=" + token.value);
-                ws.onmessage = function(event) {
-                    var messages = document.getElementById('messages')
-                    var message = document.createElement('li')
-                    var content = document.createTextNode(event.data)
-                    message.appendChild(content)
-                    messages.appendChild(message)
-                };
-                event.preventDefault()
-            }
-            function sendMessage(event) {
-                var input = document.getElementById("messageText")
-                ws.send(input.value)
-                input.value = ''
-                event.preventDefault()
-            }
-        </script>
-    </body>
-</html>
-"""
-
-
-@app.get("/")
-async def get():
-    return HTMLResponse(html)
-
-
-async def get_cookie_or_token(
-    websocket: WebSocket,
-    session: Optional[str] = Cookie(None),
-    token: Optional[str] = Query(None),
-):
-    if session is None and token is None:
-        await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
-    return session or token
-
-
-@app.websocket("/items/{item_id}/ws")
-async def websocket_endpoint(
-    websocket: WebSocket,
-    item_id: str,
-    q: Optional[int] = None,
-    cookie_or_token: str = Depends(get_cookie_or_token),
-):
-    await websocket.accept()
-    while True:
-        data = await websocket.receive_text()
-        await websocket.send_text(
-            f"Session cookie or query token value is: {cookie_or_token}"
-        )
-        if q is not None:
-            await websocket.send_text(f"Query parameter q is: {q}")
-        await websocket.send_text(f"Message text was: {data}, for item ID: {item_id}")
diff --git a/docs_src/websockets/tutorial003.py b/docs_src/websockets/tutorial003.py
deleted file mode 100644
index 885fe83..0000000
--- a/docs_src/websockets/tutorial003.py
+++ /dev/null
@@ -1,83 +0,0 @@
-from typing import List
-
-from squall import Squall, WebSocket, WebSocketDisconnect
-from squall.responses import HTMLResponse
-
-app = Squall()
-
-html = """
-<!DOCTYPE html>
-<html>
-    <head>
-        <title>Chat</title>
-    </head>
-    <body>
-        <h1>WebSocket Chat</h1>
-        <h2>Your ID: <span id="ws-id"></span></h2>
-        <form action="" onsubmit="sendMessage(event)">
-            <input type="text" id="messageText" autocomplete="off"/>
-            <button>Send</button>
-        </form>
-        <ul id='messages'>
-        </ul>
-        <script>
-            var client_id = Date.now()
-            document.querySelector("#ws-id").textContent = client_id;
-            var ws = new WebSocket(`ws://localhost:8000/ws/${client_id}`);
-            ws.onmessage = function(event) {
-                var messages = document.getElementById('messages')
-                var message = document.createElement('li')
-                var content = document.createTextNode(event.data)
-                message.appendChild(content)
-                messages.appendChild(message)
-            };
-            function sendMessage(event) {
-                var input = document.getElementById("messageText")
-                ws.send(input.value)
-                input.value = ''
-                event.preventDefault()
-            }
-        </script>
-    </body>
-</html>
-"""
-
-
-class ConnectionManager:
-    def __init__(self):
-        self.active_connections: List[WebSocket] = []
-
-    async def connect(self, websocket: WebSocket):
-        await websocket.accept()
-        self.active_connections.append(websocket)
-
-    def disconnect(self, websocket: WebSocket):
-        self.active_connections.remove(websocket)
-
-    async def send_personal_message(self, message: str, websocket: WebSocket):
-        await websocket.send_text(message)
-
-    async def broadcast(self, message: str):
-        for connection in self.active_connections:
-            await connection.send_text(message)
-
-
-manager = ConnectionManager()
-
-
-@app.get("/")
-async def get():
-    return HTMLResponse(html)
-
-
-@app.websocket("/ws/{client_id}")
-async def websocket_endpoint(websocket: WebSocket, client_id: int):
-    await manager.connect(websocket)
-    try:
-        while True:
-            data = await websocket.receive_text()
-            await manager.send_personal_message(f"You wrote: {data}", websocket)
-            await manager.broadcast(f"Client #{client_id} says: {data}")
-    except WebSocketDisconnect:
-        manager.disconnect(websocket)
-        await manager.broadcast(f"Client #{client_id} left the chat")
diff --git a/pyproject.toml b/pyproject.toml
index a6f33e0..7313b85 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -40,9 +40,8 @@ classifiers = [
 ]
 dependencies = [
     "starlette ==0.16.0",
-    "pydantic >=1.8.2,<2.0.0",
     "orjson >=3.6.4,<4.0.0",
-    "apischema",
+    "apischema >=0.16.2,<1.0.0",
 ]
 readme = "README.md"
 requires-python = ">=3.9.0"
@@ -80,7 +79,8 @@ doc = [
     "mdx-include >=1.4.1,<2.0.0",
     "mkdocs-markdownextradata-plugin >=0.1.7,<0.3.0",
     "typer-cli >=0.0.12,<0.0.13",
-    "pyyaml >=5.3.1,<6.0.0"
+    "pyyaml >=5.3.1,<6.0.0",
+    "pydantic >=1.8.2,<2.0.0",
 ]
 dev = [
     "python-jose[cryptography] >=3.3.0,<4.0.0",
diff --git a/squall/exceptions.py b/squall/exceptions.py
index 62ab56c..125a6a6 100644
--- a/squall/exceptions.py
+++ b/squall/exceptions.py
@@ -1,7 +1,6 @@
-from typing import Any, Dict, Optional, Sequence, Tuple, Type
+from typing import Any, Dict, Optional, Sequence, Tuple
 
 from apischema.validation.errors import ValidationError
-from pydantic import BaseModel, create_model
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 
@@ -16,10 +15,6 @@ def __init__(
         self.headers = headers
 
 
-RequestErrorModel: Type[BaseModel] = create_model("Request")
-WebSocketErrorModel: Type[BaseModel] = create_model("WebSocket")
-
-
 class SquallError(RuntimeError):
     """A generic, Squall-specific error."""
 
diff --git a/squall/openapi/models.py b/squall/openapi/models.py
deleted file mode 100644
index 41422d1..0000000
--- a/squall/openapi/models.py
+++ /dev/null
@@ -1,406 +0,0 @@
-from enum import Enum
-from typing import Any, Callable, Dict, Iterable, List, Optional, Union
-
-from pydantic import AnyUrl, BaseModel, Field
-from squall.logger import logger
-
-try:
-    import email_validator  # type: ignore
-
-    assert email_validator  # make autoflake ignore the unused import
-    from pydantic import EmailStr
-except ImportError:  # pragma: no cover
-
-    class EmailStr(str):  # type: ignore
-        @classmethod
-        def __get_validators__(cls) -> Iterable[Callable[..., Any]]:
-            yield cls.validate
-
-        @classmethod
-        def validate(cls, v: Any) -> str:
-            logger.warning(
-                "email-validator not installed, email fields will be treated as str.\n"
-                "To install, run: pip install email-validator"
-            )
-            return str(v)
-
-
-class Contact(BaseModel):
-    name: Optional[str] = None
-    url: Optional[AnyUrl] = None
-    email: Optional[EmailStr] = None
-
-    class Config:
-        extra = "allow"
-
-
-class License(BaseModel):
-    name: str
-    url: Optional[AnyUrl] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Info(BaseModel):
-    title: str
-    description: Optional[str] = None
-    termsOfService: Optional[str] = None
-    contact: Optional[Contact] = None
-    license: Optional[License] = None
-    version: str
-
-    class Config:
-        extra = "allow"
-
-
-class ServerVariable(BaseModel):
-    enum: Optional[List[str]] = None
-    default: str
-    description: Optional[str] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Server(BaseModel):
-    url: Union[AnyUrl, str]
-    description: Optional[str] = None
-    variables: Optional[Dict[str, ServerVariable]] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Reference(BaseModel):
-    ref: str = Field(..., alias="$ref")
-
-
-class Discriminator(BaseModel):
-    propertyName: str
-    mapping: Optional[Dict[str, str]] = None
-
-
-class XML(BaseModel):
-    name: Optional[str] = None
-    namespace: Optional[str] = None
-    prefix: Optional[str] = None
-    attribute: Optional[bool] = None
-    wrapped: Optional[bool] = None
-
-    class Config:
-        extra = "allow"
-
-
-class ExternalDocumentation(BaseModel):
-    description: Optional[str] = None
-    url: AnyUrl
-
-    class Config:
-        extra = "allow"
-
-
-class Schema(BaseModel):
-    ref: Optional[str] = Field(None, alias="$ref")
-    title: Optional[str] = None
-    multipleOf: Optional[float] = None
-    maximum: Optional[float] = None
-    exclusiveMaximum: Optional[bool] = None
-    minimum: Optional[float] = None
-    exclusiveMinimum: Optional[bool] = None
-    maxLength: Optional[int] = Field(None, gte=0)
-    minLength: Optional[int] = Field(None, gte=0)
-    pattern: Optional[str] = None
-    maxItems: Optional[int] = Field(None, gte=0)
-    minItems: Optional[int] = Field(None, gte=0)
-    uniqueItems: Optional[bool] = None
-    maxProperties: Optional[int] = Field(None, gte=0)
-    minProperties: Optional[int] = Field(None, gte=0)
-    required: Optional[List[str]] = None
-    enum: Optional[List[Any]] = None
-    type: Optional[str] = None
-    allOf: Optional[List["Schema"]] = None
-    oneOf: Optional[List["Schema"]] = None
-    anyOf: Optional[List["Schema"]] = None
-    not_: Optional["Schema"] = Field(None, alias="not")
-    items: Optional["Schema"] = None
-    properties: Optional[Dict[str, "Schema"]] = None
-    additionalProperties: Optional[Union["Schema", Reference, bool]] = None
-    description: Optional[str] = None
-    format: Optional[str] = None
-    default: Optional[Any] = None
-    nullable: Optional[bool] = None
-    discriminator: Optional[Discriminator] = None
-    readOnly: Optional[bool] = None
-    writeOnly: Optional[bool] = None
-    xml: Optional[XML] = None
-    externalDocs: Optional[ExternalDocumentation] = None
-    example: Optional[Any] = None
-    deprecated: Optional[bool] = None
-
-    class Config:
-        extra: str = "allow"
-
-
-class Example(BaseModel):
-    summary: Optional[str] = None
-    description: Optional[str] = None
-    value: Optional[Any] = None
-    externalValue: Optional[AnyUrl] = None
-
-    class Config:
-        extra = "allow"
-
-
-class ParameterInType(Enum):
-    query = "query"
-    header = "header"
-    path = "path"
-    cookie = "cookie"
-
-
-class Encoding(BaseModel):
-    contentType: Optional[str] = None
-    headers: Optional[Dict[str, Union["Header", Reference]]] = None
-    style: Optional[str] = None
-    explode: Optional[bool] = None
-    allowReserved: Optional[bool] = None
-
-    class Config:
-        extra = "allow"
-
-
-class MediaType(BaseModel):
-    schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
-    example: Optional[Any] = None
-    examples: Optional[Dict[str, Union[Example, Reference]]] = None
-    encoding: Optional[Dict[str, Encoding]] = None
-
-    class Config:
-        extra = "allow"
-
-
-class ParameterBase(BaseModel):
-    description: Optional[str] = None
-    required: Optional[bool] = None
-    deprecated: Optional[bool] = None
-    # Serialization rules for simple scenarios
-    style: Optional[str] = None
-    explode: Optional[bool] = None
-    allowReserved: Optional[bool] = None
-    schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
-    example: Optional[Any] = None
-    examples: Optional[Dict[str, Union[Example, Reference]]] = None
-    # Serialization rules for more complex scenarios
-    content: Optional[Dict[str, MediaType]] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Parameter(ParameterBase):
-    name: str
-    in_: ParameterInType = Field(..., alias="in")
-
-
-class Header(ParameterBase):
-    pass
-
-
-class RequestBody(BaseModel):
-    description: Optional[str] = None
-    content: Dict[str, MediaType]
-    required: Optional[bool] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Link(BaseModel):
-    operationRef: Optional[str] = None
-    operationId: Optional[str] = None
-    parameters: Optional[Dict[str, Union[Any, str]]] = None
-    requestBody: Optional[Union[Any, str]] = None
-    description: Optional[str] = None
-    server: Optional[Server] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Response(BaseModel):
-    description: str
-    headers: Optional[Dict[str, Union[Header, Reference]]] = None
-    content: Optional[Dict[str, MediaType]] = None
-    links: Optional[Dict[str, Union[Link, Reference]]] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Operation(BaseModel):
-    tags: Optional[List[str]] = None
-    summary: Optional[str] = None
-    description: Optional[str] = None
-    externalDocs: Optional[ExternalDocumentation] = None
-    operationId: Optional[str] = None
-    parameters: Optional[List[Union[Parameter, Reference]]] = None
-    requestBody: Optional[Union[RequestBody, Reference]] = None
-    # Using Any for Specification Extensions
-    responses: Dict[str, Union[Response, Any]]
-    callbacks: Optional[Dict[str, Union[Dict[str, "PathItem"], Reference]]] = None
-    deprecated: Optional[bool] = None
-    security: Optional[List[Dict[str, List[str]]]] = None
-    servers: Optional[List[Server]] = None
-
-    class Config:
-        extra = "allow"
-
-
-class PathItem(BaseModel):
-    ref: Optional[str] = Field(None, alias="$ref")
-    summary: Optional[str] = None
-    description: Optional[str] = None
-    get: Optional[Operation] = None
-    put: Optional[Operation] = None
-    post: Optional[Operation] = None
-    delete: Optional[Operation] = None
-    options: Optional[Operation] = None
-    head: Optional[Operation] = None
-    patch: Optional[Operation] = None
-    trace: Optional[Operation] = None
-    servers: Optional[List[Server]] = None
-    parameters: Optional[List[Union[Parameter, Reference]]] = None
-
-    class Config:
-        extra = "allow"
-
-
-class SecuritySchemeType(Enum):
-    apiKey = "apiKey"
-    http = "http"
-    oauth2 = "oauth2"
-    openIdConnect = "openIdConnect"
-
-
-class SecurityBase(BaseModel):
-    type_: SecuritySchemeType = Field(..., alias="type")
-    description: Optional[str] = None
-
-    class Config:
-        extra = "allow"
-
-
-class APIKeyIn(Enum):
-    query = "query"
-    header = "header"
-    cookie = "cookie"
-
-
-class APIKey(SecurityBase):
-    type_ = Field(SecuritySchemeType.apiKey, alias="type")
-    in_: APIKeyIn = Field(..., alias="in")
-    name: str
-
-
-class HTTPBase(SecurityBase):
-    type_ = Field(SecuritySchemeType.http, alias="type")
-    scheme: str
-
-
-class HTTPBearer(HTTPBase):
-    scheme = "bearer"
-    bearerFormat: Optional[str] = None
-
-
-class OAuthFlow(BaseModel):
-    refreshUrl: Optional[str] = None
-    scopes: Dict[str, str] = {}
-
-    class Config:
-        extra = "allow"
-
-
-class OAuthFlowImplicit(OAuthFlow):
-    authorizationUrl: str
-
-
-class OAuthFlowPassword(OAuthFlow):
-    tokenUrl: str
-
-
-class OAuthFlowClientCredentials(OAuthFlow):
-    tokenUrl: str
-
-
-class OAuthFlowAuthorizationCode(OAuthFlow):
-    authorizationUrl: str
-    tokenUrl: str
-
-
-class OAuthFlows(BaseModel):
-    implicit: Optional[OAuthFlowImplicit] = None
-    password: Optional[OAuthFlowPassword] = None
-    clientCredentials: Optional[OAuthFlowClientCredentials] = None
-    authorizationCode: Optional[OAuthFlowAuthorizationCode] = None
-
-    class Config:
-        extra = "allow"
-
-
-class OAuth2(SecurityBase):
-    type_ = Field(SecuritySchemeType.oauth2, alias="type")
-    flows: OAuthFlows
-
-
-class OpenIdConnect(SecurityBase):
-    type_ = Field(SecuritySchemeType.openIdConnect, alias="type")
-    openIdConnectUrl: str
-
-
-SecurityScheme = Union[APIKey, HTTPBase, OAuth2, OpenIdConnect, HTTPBearer]
-
-
-class Components(BaseModel):
-    schemas: Optional[Dict[str, Union[Schema, Reference]]] = None
-    responses: Optional[Dict[str, Union[Response, Reference]]] = None
-    parameters: Optional[Dict[str, Union[Parameter, Reference]]] = None
-    examples: Optional[Dict[str, Union[Example, Reference]]] = None
-    requestBodies: Optional[Dict[str, Union[RequestBody, Reference]]] = None
-    headers: Optional[Dict[str, Union[Header, Reference]]] = None
-    securitySchemes: Optional[Dict[str, Union[SecurityScheme, Reference]]] = None
-    links: Optional[Dict[str, Union[Link, Reference]]] = None
-    # Using Any for Specification Extensions
-    callbacks: Optional[Dict[str, Union[Dict[str, PathItem], Reference, Any]]] = None
-
-    class Config:
-        extra = "allow"
-
-
-class Tag(BaseModel):
-    name: str
-    description: Optional[str] = None
-    externalDocs: Optional[ExternalDocumentation] = None
-
-    class Config:
-        extra = "allow"
-
-
-class OpenAPI(BaseModel):
-    openapi: str
-    info: Info
-    servers: Optional[List[Server]] = None
-    # Using Any for Specification Extensions
-    paths: Dict[str, Union[PathItem, Any]]
-    components: Optional[Components] = None
-    security: Optional[List[Dict[str, List[str]]]] = None
-    tags: Optional[List[Tag]] = None
-    externalDocs: Optional[ExternalDocumentation] = None
-
-    class Config:
-        extra = "allow"
-
-
-Schema.update_forward_refs()
-Operation.update_forward_refs()
-Encoding.update_forward_refs()
diff --git a/squall/responses.py b/squall/responses.py
index 68e80e3..c5a0330 100644
--- a/squall/responses.py
+++ b/squall/responses.py
@@ -3,7 +3,6 @@
 from typing import Any, Dict, List, Optional, Tuple
 
 import orjson
-from pydantic import BaseModel
 from squall.types import Receive, Scope, Send
 from starlette.responses import FileResponse as FileResponse  # noqa
 from starlette.responses import RedirectResponse as RedirectResponse  # noqa
@@ -16,9 +15,7 @@
 
 
 def default(obj: Any) -> Any:
-    if isinstance(obj, BaseModel):
-        return dict(obj)
-    elif isinstance(obj, decimal.Decimal):
+    if isinstance(obj, decimal.Decimal):
         return float(obj)
     elif isinstance(obj, set):
         return tuple(obj)


Test patch:
diff --git a/docs_src/app_testing/__init__.py b/docs_src/app_testing/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/app_testing/main.py b/docs_src/app_testing/main.py
deleted file mode 100644
index c78da18..0000000
--- a/docs_src/app_testing/main.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/")
-async def read_main():
-    return {"msg": "Hello World"}
diff --git a/docs_src/app_testing/main_b.py b/docs_src/app_testing/main_b.py
deleted file mode 100644
index 58f52f8..0000000
--- a/docs_src/app_testing/main_b.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from typing import Optional
-
-from pydantic import Field, dataclasses
-from squall import Header, HTTPException, Squall
-
-fake_secret_token = "coneofsilence"
-
-fake_db = {
-    "foo": {"id": "foo", "title": "Foo", "description": "There goes my hero"},
-    "bar": {"id": "bar", "title": "Bar", "description": "The bartenders"},
-}
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    id: str = Field(...)
-    title: str = Field(...)
-    description: Optional[str] = None
-
-
-@app.get("/items/{item_id}", response_model=Item)
-async def read_main(item_id: str, x_token: str = Header(...)):
-    if x_token != fake_secret_token:
-        raise HTTPException(status_code=400, detail="Invalid X-Token header")
-    if item_id not in fake_db:
-        raise HTTPException(status_code=404, detail="Item not found")
-    return fake_db[item_id]
-
-
-@app.post("/items/", response_model=Item)
-async def create_item(item: Item, x_token: str = Header(...)):
-    if x_token != fake_secret_token:
-        raise HTTPException(status_code=400, detail="Invalid X-Token header")
-    if item.id in fake_db:
-        raise HTTPException(status_code=400, detail="Item already exists")
-    fake_db[item.id] = item
-    return item
diff --git a/docs_src/app_testing/test_main.py b/docs_src/app_testing/test_main.py
deleted file mode 100644
index 08f4ecf..0000000
--- a/docs_src/app_testing/test_main.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall.testclient import TestClient
-
-from .main import app
-
-client = TestClient(app)
-
-
-def test_read_main():
-    response = client.get("/")
-    assert response.status_code == 200
-    assert response.json() == {"msg": "Hello World"}
diff --git a/docs_src/app_testing/test_main_b.py b/docs_src/app_testing/test_main_b.py
deleted file mode 100644
index 8259794..0000000
--- a/docs_src/app_testing/test_main_b.py
+++ /dev/null
@@ -1,65 +0,0 @@
-from squall.testclient import TestClient
-
-from .main_b import app
-
-client = TestClient(app)
-
-
-def test_read_item():
-    response = client.get("/items/foo", headers={"X-Token": "coneofsilence"})
-    assert response.status_code == 200
-    assert response.json() == {
-        "id": "foo",
-        "title": "Foo",
-        "description": "There goes my hero",
-    }
-
-
-def test_read_item_bad_token():
-    response = client.get("/items/foo", headers={"X-Token": "hailhydra"})
-    assert response.status_code == 400
-    assert response.json() == {"detail": "Invalid X-Token header"}
-
-
-def test_read_inexistent_item():
-    response = client.get("/items/baz", headers={"X-Token": "coneofsilence"})
-    assert response.status_code == 404
-    assert response.json() == {"detail": "Item not found"}
-
-
-def test_create_item():
-    response = client.post(
-        "/items/",
-        headers={"X-Token": "coneofsilence"},
-        json={"id": "foobar", "title": "Foo Bar", "description": "The Foo Barters"},
-    )
-    assert response.status_code == 200
-    assert response.json() == {
-        "id": "foobar",
-        "title": "Foo Bar",
-        "description": "The Foo Barters",
-    }
-
-
-def test_create_item_bad_token():
-    response = client.post(
-        "/items/",
-        headers={"X-Token": "hailhydra"},
-        json={"id": "bazz", "title": "Bazz", "description": "Drop the bazz"},
-    )
-    assert response.status_code == 400
-    assert response.json() == {"detail": "Invalid X-Token header"}
-
-
-def test_create_existing_item():
-    response = client.post(
-        "/items/",
-        headers={"X-Token": "coneofsilence"},
-        json={
-            "id": "foo",
-            "title": "The Foo ID Stealers",
-            "description": "There goes my stealer",
-        },
-    )
-    assert response.status_code == 400
-    assert response.json() == {"detail": "Item already exists"}
diff --git a/docs_src/app_testing/tutorial001.py b/docs_src/app_testing/tutorial001.py
deleted file mode 100644
index 491743c..0000000
--- a/docs_src/app_testing/tutorial001.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from squall import Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-@app.get("/")
-async def read_main():
-    return {"msg": "Hello World"}
-
-
-client = TestClient(app)
-
-
-def test_read_main():
-    response = client.get("/")
-    assert response.status_code == 200
-    assert response.json() == {"msg": "Hello World"}
diff --git a/docs_src/app_testing/tutorial002.py b/docs_src/app_testing/tutorial002.py
deleted file mode 100644
index ccad418..0000000
--- a/docs_src/app_testing/tutorial002.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from squall import Squall
-from squall.testclient import TestClient
-from squall.websockets import WebSocket
-
-app = Squall()
-
-
-@app.get("/")
-async def read_main():
-    return {"msg": "Hello World"}
-
-
-@app.websocket("/ws")
-async def websocket(websocket: WebSocket):
-    await websocket.accept()
-    await websocket.send_json({"msg": "Hello WebSocket"})
-    await websocket.close()
-
-
-def test_read_main():
-    client = TestClient(app)
-    response = client.get("/")
-    assert response.status_code == 200
-    assert response.json() == {"msg": "Hello World"}
-
-
-def test_websocket():
-    client = TestClient(app)
-    with client.websocket_connect("/ws") as websocket:
-        data = websocket.receive_json()
-        assert data == {"msg": "Hello WebSocket"}
diff --git a/docs_src/app_testing/tutorial003.py b/docs_src/app_testing/tutorial003.py
deleted file mode 100644
index f8daaec..0000000
--- a/docs_src/app_testing/tutorial003.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from squall import Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-items = {}
-
-
-@app.on_event("startup")
-async def startup_event():
-    items["foo"] = {"name": "Fighters"}
-    items["bar"] = {"name": "Tenders"}
-
-
-@app.get("/items/{item_id}")
-async def read_items(item_id: str):
-    return items[item_id]
-
-
-def test_read_items():
-    with TestClient(app) as client:
-        response = client.get("/items/foo")
-        assert response.status_code == 200
-        assert response.json() == {"name": "Fighters"}
diff --git a/docs_src/async_tests/__init__.py b/docs_src/async_tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/async_tests/main.py b/docs_src/async_tests/main.py
deleted file mode 100644
index 4deda0b..0000000
--- a/docs_src/async_tests/main.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from squall import Squall
-
-app = Squall()
-
-
-@app.get("/")
-async def root():
-    return {"message": "Tomato"}
diff --git a/docs_src/async_tests/test_main.py b/docs_src/async_tests/test_main.py
deleted file mode 100644
index 9f1527d..0000000
--- a/docs_src/async_tests/test_main.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import pytest
-from httpx import AsyncClient
-
-from .main import app
-
-
-@pytest.mark.anyio
-async def test_root():
-    async with AsyncClient(app=app, base_url="http://test") as ac:
-        response = await ac.get("/")
-    assert response.status_code == 200
-    assert response.json() == {"message": "Tomato"}
diff --git a/docs_src/settings/app02/test_main.py b/docs_src/settings/app02/test_main.py
deleted file mode 100644
index 6dc8d5e..0000000
--- a/docs_src/settings/app02/test_main.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# from squall.testclient import TestClient
-#
-# from .config import Settings
-# from .main import app, get_settings
-#
-# client = TestClient(app)
-#
-#
-# def get_settings_override():
-#     return Settings(admin_email="testing_admin@example.com")
-#
-#
-# app.dependency_overrides[get_settings] = get_settings_override
-#
-#
-# def test_app():
-#     response = client.get("/info")
-#     data = response.json()
-#     assert data == {
-#         "app_name": "Awesome API",
-#         "admin_email": "testing_admin@example.com",
-#         "items_per_user": 50,
-#     }
diff --git a/docs_src/sql_databases/sql_app/tests/__init__.py b/docs_src/sql_databases/sql_app/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/docs_src/sql_databases/sql_app/tests/test_sql_app.py b/docs_src/sql_databases/sql_app/tests/test_sql_app.py
deleted file mode 100644
index 2caa4ab..0000000
--- a/docs_src/sql_databases/sql_app/tests/test_sql_app.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from squall.testclient import TestClient
-
-from ..database import Base
-from ..main import app, get_db
-
-SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
-
-engine = create_engine(
-    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
-)
-TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-
-Base.metadata.create_all(bind=engine)
-
-
-def override_get_db():
-    try:
-        db = TestingSessionLocal()
-        yield db
-    finally:
-        db.close()
-
-
-app.dependency_overrides[get_db] = override_get_db
-
-client = TestClient(app)
-
-
-def test_create_user():
-    response = client.post(
-        "/users/",
-        json={"email": "deadpool@example.com", "password": "chimichangas4life"},
-    )
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert data["email"] == "deadpool@example.com"
-    assert "id" in data
-    user_id = data["id"]
-
-    response = client.get(f"/users/{user_id}")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert data["email"] == "deadpool@example.com"
-    assert data["id"] == user_id
diff --git a/pending_tests/main.py b/pending_tests/main.py
deleted file mode 100644
index 129ad46..0000000
--- a/pending_tests/main.py
+++ /dev/null
@@ -1,118 +0,0 @@
-from squall import (
-    Body,
-    Cookie,
-    Depends,
-    Squall,
-    File,
-    Form,
-    Header,
-    Path,
-    Query,
-    Security,
-)
-from squall.security import (
-    HTTPBasic,
-    OAuth2,
-    OAuth2PasswordBearer,
-    OAuth2PasswordRequestForm,
-)
-from pydantic import BaseModel
-from squall.responses import HTMLResponse, JSONResponse, PlainTextResponse
-from starlette.status import HTTP_202_ACCEPTED
-
-app = Squall()
-
-
-@app.get("/security")
-def get_security(sec=Security(HTTPBasic())):
-    return sec
-
-
-reusable_oauth2 = OAuth2(
-    flows={
-        "password": {
-            "tokenUrl": "token",
-            "scopes": {"read:user": "Read a User", "write:user": "Create a user"},
-        }
-    }
-)
-
-
-@app.get("/security/oauth2")
-def get_security_oauth2(sec=Security(reusable_oauth2, scopes=["read:user"])):
-    return sec
-
-
-@app.post("/token")
-def post_token(request_data: OAuth2PasswordRequestForm = Form(...)):
-    data = request_data.parse()
-    access_token = data.username + ":" + data.password
-    return {"access_token": access_token}
-
-
-class Item(BaseModel):
-    name: str
-    price: float
-    is_offer: bool
-
-
-class FakeDB:
-    def __init__(self):
-        self.data = {
-            "johndoe": {
-                "username": "johndoe",
-                "password": "shouldbehashed",
-                "first_name": "John",
-                "last_name": "Doe",
-            }
-        }
-
-
-class DBConnectionManager:
-    def __init__(self):
-        self.db = FakeDB()
-
-    def __call__(self):
-        return self.db
-
-
-connection_manager = DBConnectionManager()
-
-
-class TokenUserData(BaseModel):
-    username: str
-    password: str
-
-
-class UserInDB(BaseModel):
-    username: str
-    password: str
-    first_name: str
-    last_name: str
-
-
-def require_token(
-    token: str = Security(reusable_oauth2, scopes=["read:user", "write:user"])
-):
-    raw_token = token.replace("Bearer ", "")
-    # Never do this plaintext password usage in production
-    username, password = raw_token.split(":")
-    return TokenUserData(username=username, password=password)
-
-
-def require_user(
-    db: FakeDB = Depends(connection_manager),
-    user_data: TokenUserData = Depends(require_token),
-):
-    return db.data[user_data.username]
-
-
-class UserOut(BaseModel):
-    username: str
-    first_name: str
-    last_name: str
-
-
-@app.get("/dependency", response_model=UserOut)
-def get_dependency(user: UserInDB = Depends(require_user)):
-    return user
diff --git a/tests/test_duplicate_models_openapi.py b/tests/test_duplicate_models_openapi.py
index 2fced11..c13be95 100644
--- a/tests/test_duplicate_models_openapi.py
+++ b/tests/test_duplicate_models_openapi.py
@@ -1,24 +1,25 @@
-from pydantic import Field, dataclasses
+from dataclasses import dataclass, field
+
 from squall import Squall
 from squall.testclient import TestClient
 
 app = Squall()
 
 
-@dataclasses.dataclass
+@dataclass
 class Model:
     pass
 
 
-@dataclasses.dataclass
+@dataclass
 class Model2:
-    a: Model = Field(...)
+    a: Model = field()
 
 
-@dataclasses.dataclass
+@dataclass
 class Model3:
-    c: Model = Field(...)
-    d: Model2 = Field(...)
+    c: Model = field()
+    d: Model2 = field()
 
 
 @app.get("/", response_model=Model3)
@@ -37,12 +38,14 @@ def f():
                     "c": {"$ref": "#/components/schemas/Model"},
                     "d": {"$ref": "#/components/schemas/Model2"},
                 },
+                "required": ["c", "d"],
                 "additionalProperties": False,
             },
             "Model": {"type": "object", "additionalProperties": False},
             "Model2": {
                 "type": "object",
                 "properties": {"a": {"$ref": "#/components/schemas/Model"}},
+                "required": ["a"],
                 "additionalProperties": False,
             },
             "HTTPBadRequestError": {
diff --git a/tests/test_extra_routes.py b/tests/test_extra_routes.py
index f6c34dc..12d334d 100644
--- a/tests/test_extra_routes.py
+++ b/tests/test_extra_routes.py
@@ -1,6 +1,6 @@
+from dataclasses import dataclass, field
 from typing import Optional
 
-from pydantic import Field, dataclasses
 from squall import Squall
 from squall.responses import JSONResponse
 from squall.testclient import TestClient
@@ -8,9 +8,9 @@
 app = Squall()
 
 
-@dataclasses.dataclass
+@dataclass
 class Item:
-    name: str = Field(...)
+    name: str = field()
     price: Optional[float] = None
 
 
@@ -64,6 +64,7 @@ def trace_item(item_id: str):
                     "name": {"type": "string"},
                     "price": {"type": ["number", "null"], "default": None},
                 },
+                "required": ["name"],
                 "additionalProperties": False,
             },
             "ValidationError": {
diff --git a/tests/test_filter_pydantic_sub_model.py b/tests/test_filter_pydantic_sub_model.py
deleted file mode 100644
index e0a084f..0000000
--- a/tests/test_filter_pydantic_sub_model.py
+++ /dev/null
@@ -1,159 +0,0 @@
-# from typing import Optional
-#
-# import pytest
-# from pydantic import Field, ValidationError, dataclasses, validator
-# from squall import Depends, Squall
-# from squall.testclient import TestClient
-#
-# app = Squall()
-#
-#
-# @dataclasses.dataclass
-# class ModelB:
-#     username: str
-#
-#
-# @dataclasses.dataclass
-# class ModelC(ModelB):
-#     password: str
-#
-#
-# @dataclasses.dataclass
-# class ModelA:
-#     name: str = Field(...)
-#     description: Optional[str] = None
-#     model_b: ModelB = Field(...)
-#
-#     @validator("name")
-#     def lower_username(cls, name: str, values):
-#         if not name.endswith("A"):
-#             raise ValueError("name must end in A")
-#         return name
-#
-#
-# async def get_model_c() -> ModelC:
-#     return ModelC(username="test-user", password="test-password")
-#
-#
-# @app.get("/model/{name}", response_model=ModelA)
-# async def get_model_a(name: str, model_c=Depends(get_model_c)):
-#     return {"name": name, "description": "model-a-desc", "model_b": model_c}
-#
-#
-# client = TestClient(app)
-#
-#
-# openapi_schema = {
-#     "openapi": "3.0.2",
-#     "info": {"title": "Squall", "version": "0.1.0"},
-#     "paths": {
-#         "/model/{name}": {
-#             "get": {
-#                 "summary": "Get Model A",
-#                 "operationId": "get_model_a_model__name__get",
-#                 "parameters": [
-#                     {
-#                         "required": True,
-#                         "schema": {"title": "Name", "type": "string"},
-#                         "name": "name",
-#                         "in": "path",
-#                     }
-#                 ],
-#                 "responses": {
-#                     "200": {
-#                         "description": "Successful Response",
-#                         "content": {
-#                             "application/json": {
-#                                 "schema": {"$ref": "#/components/schemas/ModelA"}
-#                             }
-#                         },
-#                     },
-#                     "422": {
-#                         "description": "Validation Error",
-#                         "content": {
-#                             "application/json": {
-#                                 "schema": {
-#                                     "$ref": "#/components/schemas/HTTPValidationError"
-#                                 }
-#                             }
-#                         },
-#                     },
-#                 },
-#             }
-#         }
-#     },
-#     "components": {
-#         "schemas": {
-#             "HTTPValidationError": {
-#                 "title": "HTTPValidationError",
-#                 "type": "object",
-#                 "properties": {
-#                     "detail": {
-#                         "title": "Detail",
-#                         "type": "array",
-#                         "items": {"$ref": "#/components/schemas/ValidationError"},
-#                     }
-#                 },
-#             },
-#             "ModelA": {
-#                 "title": "ModelA",
-#                 "required": ["name", "model_b"],
-#                 "type": "object",
-#                 "properties": {
-#                     "name": {"title": "Name", "type": "string"},
-#                     "description": {"title": "Description", "type": "string"},
-#                     "model_b": {"$ref": "#/components/schemas/ModelB"},
-#                 },
-#             },
-#             "ModelB": {
-#                 "title": "ModelB",
-#                 "required": ["username"],
-#                 "type": "object",
-#                 "properties": {"username": {"title": "Username", "type": "string"}},
-#             },
-#             "ValidationError": {
-#                 "title": "ValidationError",
-#                 "required": ["loc", "msg", "type"],
-#                 "type": "object",
-#                 "properties": {
-#                     "loc": {
-#                         "title": "Location",
-#                         "type": "array",
-#                         "items": {"type": "string"},
-#                     },
-#                     "msg": {"title": "Message", "type": "string"},
-#                     "type": {"title": "Error Type", "type": "string"},
-#                 },
-#             },
-#         }
-#     },
-# }
-#
-#
-# def test_openapi_schema():
-#     response = client.get("/openapi.json")
-#     assert response.status_code == 200, response.text
-#     assert response.json() == openapi_schema
-#
-#
-# def test_filter_sub_model():
-#     response = client.get("/model/modelA")
-#     assert response.status_code == 200, response.text
-#     assert response.json() == {
-#         "name": "modelA",
-#         "description": "model-a-desc",
-#         "model_b": {"username": "test-user", "password": "test-password"},
-#     }
-#
-#
-# def test_validator_is_cloned():
-#     with pytest.raises(ValidationError) as err:
-#         client.get("/model/modelX")
-#
-#     assert err.value.errors() == [
-#         {
-#             "loc": ("response", "name"),
-#             "msg": "name must end in A",
-#             "type": "value_error",
-#         }
-#     ]
diff --git a/tests/test_get_request_body.py b/tests/test_get_request_body.py
index 406e50e..7f99aa4 100644
--- a/tests/test_get_request_body.py
+++ b/tests/test_get_request_body.py
@@ -1,15 +1,16 @@
-from pydantic import Field, dataclasses
+from dataclasses import dataclass, field
+
 from squall import Squall
 from squall.testclient import TestClient
 
 app = Squall()
 
 
-@dataclasses.dataclass
+@dataclass
 class Product:
-    name: str = Field(...)
+    name: str = field()
+    price: float = field()
     description: str = None  # type: ignore
-    price: float = Field(...)
 
 
 @app.get("/product")
@@ -29,9 +30,10 @@ async def create_item(product: Product):
                 "type": "object",
                 "properties": {
                     "name": {"type": "string"},
-                    "description": {"type": "string"},
                     "price": {"type": "number"},
+                    "description": {"type": "string"},
                 },
+                "required": ["name", "price"],
                 "additionalProperties": False,
             },
             "ValidationError": {
diff --git a/tests/test_inherited_custom_class.py b/tests/test_inherited_custom_class.py
index 1defa88..7c7ae11 100644
--- a/tests/test_inherited_custom_class.py
+++ b/tests/test_inherited_custom_class.py
@@ -1,7 +1,7 @@
 import uuid
+from dataclasses import dataclass
 
 import pytest
-from pydantic import dataclasses
 from squall import Squall
 from squall.testclient import TestClient
 
@@ -42,18 +42,13 @@ def return_fast_uuid():
     return {"fast_uuid": asyncpg_uuid}
 
 
-class Config:
-    arbitrary_types_allowed = True
-
-
-@dataclasses.dataclass(config=Config)
+@dataclass
 class SomeCustomClass:
     a_uuid: MyUuid
 
 
 @app.get("/get_custom_class")
 def return_some_user():
-    # Test that the fix also works for custom pydantic classes
     return SomeCustomClass(a_uuid=MyUuid("b8799909-f914-42de-91bc-95c819218d01"))
 
 
@@ -64,12 +59,10 @@ def return_some_user():
 def test_dt():
     with client:
         response_simple = client.get("/fast_uuid")
-        response_pydantic = client.get("/get_custom_class")
+        response_class = client.get("/get_custom_class")
 
     assert response_simple.json() == {
         "fast_uuid": "a10ff360-3b1e-4984-a26f-d3ab460bdb51"
     }
 
-    assert response_pydantic.json() == {
-        "a_uuid": "b8799909-f914-42de-91bc-95c819218d01"
-    }
+    assert response_class.json() == {"a_uuid": "b8799909-f914-42de-91bc-95c819218d01"}
diff --git a/tests/test_invalid_path_param.py b/tests/test_invalid_path_param.py
index 4258a4f..c9fefae 100644
--- a/tests/test_invalid_path_param.py
+++ b/tests/test_invalid_path_param.py
@@ -1,7 +1,6 @@
 from typing import Dict, List, Tuple
 
 import pytest
-from pydantic import BaseModel
 from squall import Squall
 
 
@@ -9,7 +8,7 @@ def test_invalid_sequence():
     with pytest.raises(AssertionError):
         app = Squall()
 
-        class Item(BaseModel):
+        class Item:
             title: str
 
         @app.get("/items/{id}")
@@ -21,7 +20,7 @@ def test_invalid_tuple():
     with pytest.raises(AssertionError):
         app = Squall()
 
-        class Item(BaseModel):
+        class Item:
             title: str
 
         @app.get("/items/{id}")
@@ -33,7 +32,7 @@ def test_invalid_dict():
     with pytest.raises(AssertionError):
         app = Squall()
 
-        class Item(BaseModel):
+        class Item:
             title: str
 
         @app.get("/items/{id}")
diff --git a/tests/test_invalid_sequence_param.py b/tests/test_invalid_sequence_param.py
index 02ca530..7bc772f 100644
--- a/tests/test_invalid_sequence_param.py
+++ b/tests/test_invalid_sequence_param.py
@@ -1,7 +1,6 @@
 from typing import Dict, List, Optional, Tuple
 
 import pytest
-from pydantic import BaseModel
 from squall import Query, Squall
 
 
@@ -9,7 +8,7 @@ def test_invalid_sequence():
     with pytest.raises(AssertionError):
         app = Squall()
 
-        class Item(BaseModel):
+        class Item:
             title: str
 
         @app.get("/items/")
@@ -21,7 +20,7 @@ def test_invalid_tuple():
     with pytest.raises(AssertionError):
         app = Squall()
 
-        class Item(BaseModel):
+        class Item:
             title: str
 
         @app.get("/items/")
@@ -33,7 +32,7 @@ def test_invalid_dict():
     with pytest.raises(AssertionError):
         app = Squall()
 
-        class Item(BaseModel):
+        class Item:
             title: str
 
         @app.get("/items/")
@@ -45,7 +44,7 @@ def test_invalid_simple_dict():
     with pytest.raises(AssertionError):
         app = Squall()
 
-        class Item(BaseModel):
+        class Item:
             title: str
 
         @app.get("/items/")
diff --git a/tests/test_request_body_parameters_media_type.py b/tests/test_request_body_parameters_media_type.py
index 64f2d7e..7f231c2 100644
--- a/tests/test_request_body_parameters_media_type.py
+++ b/tests/test_request_body_parameters_media_type.py
@@ -1,7 +1,5 @@
-import typing
+from dataclasses import dataclass
 
-import pytest
-from pydantic import BaseModel
 from squall import Body, Squall
 from squall.testclient import TestClient
 
@@ -12,50 +10,27 @@
 
 # NOTE: These are not valid JSON:API resources
 # but they are fine for testing requestBody with custom media_type
-class Product(BaseModel):
+@dataclass
+class Product:
     name: str
     price: float
 
 
-class Shop(BaseModel):
-    name: str
-
-
 @app.post("/products")
 async def create_product(data: Product = Body(..., media_type=media_type, embed=True)):
     pass  # pragma: no cover
 
 
-@app.post("/shops")
-async def create_shop(
-    data: Shop = Body(..., media_type=media_type),
-    included: typing.List[Product] = Body([], media_type=media_type),
-):
-    pass  # pragma: no cover
-
-
 create_product_request_body = {
     "content": {
-        "application/vnd.api+json": {
-            "schema": {"$ref": "#/components/schemas/Body_create_product_products_post"}
-        }
+        "application/vnd.api+json": {"schema": {"$ref": "#/components/schemas/Product"}}
     },
-    "required": True,
-}
-
-create_shop_request_body = {
-    "content": {
-        "application/vnd.api+json": {
-            "schema": {"$ref": "#/components/schemas/Body_create_shop_shops_post"}
-        }
-    },
-    "required": True,
+    "required": None,
 }
 
 client = TestClient(app)
 
 
-@pytest.mark.skip("Fix OpenAPI required")
 def test_openapi_schema():
     response = client.get("/openapi.json")
     assert response.status_code == 200, response.text
@@ -64,7 +39,3 @@ def test_openapi_schema():
         openapi_schema["paths"]["/products"]["post"]["requestBody"]
         == create_product_request_body
     )
-    assert (
-        openapi_schema["paths"]["/shops"]["post"]["requestBody"]
-        == create_shop_request_body
-    )
diff --git a/tests/test_schema_extra_examples.py b/tests/test_schema_extra_examples.py
index d225a41..aa41c59 100644
--- a/tests/test_schema_extra_examples.py
+++ b/tests/test_schema_extra_examples.py
@@ -1,15 +1,12 @@
-from pydantic import dataclasses
+from dataclasses import dataclass
+
 from squall import Body, Cookie, Header, Path, Query, Squall
 from squall.testclient import TestClient
 
 app = Squall()
 
 
-class Config:
-    schema_extra = {"example": {"data": "Data in schema_extra"}}
-
-
-@dataclasses.dataclass(config=Config)
+@dataclass
 class Item:
     data: str
 
@@ -861,9 +858,9 @@ def test_openapi_schema():
     """
     Test that example overrides work:
 
-    * pydantic model schema_extra is included
-    * Body(example={}) overrides schema_extra in pydantic model
-    * Body(examples{}) overrides Body(example={}) and schema_extra in pydantic model
+    * model schema_extra is included
+    * Body(example={}) overrides schema_extra in model
+    * Body(examples{}) overrides Body(example={}) and schema_extra in model
     """
     response = client.get("/openapi.json")
     assert response.status_code == 200, response.text
diff --git a/tests/test_serialize_response.py b/tests/test_serialize_response.py
index 2056d4d..789f60f 100644
--- a/tests/test_serialize_response.py
+++ b/tests/test_serialize_response.py
@@ -1,7 +1,7 @@
+from dataclasses import dataclass, field
 from typing import List, Optional
 
 import pytest
-from pydantic import Field, dataclasses
 from squall import Squall
 from squall.exceptions import ResponsePayloadValidationError
 from squall.testclient import TestClient
@@ -9,9 +9,9 @@
 app = Squall()
 
 
-@dataclasses.dataclass
+@dataclass
 class Item:
-    name: str = Field(...)
+    name: str = field()
     price: Optional[float] = None
     owner_ids: Optional[List[int]] = None
 
diff --git a/tests/test_validate_response_recursive.py b/tests/test_validate_response_recursive.py
index 7b89861..ff9f810 100644
--- a/tests/test_validate_response_recursive.py
+++ b/tests/test_validate_response_recursive.py
@@ -1,34 +1,28 @@
+from dataclasses import dataclass, field
 from typing import List
 
-from pydantic import Field, dataclasses
 from squall import Squall
 from squall.testclient import TestClient
 
 app = Squall()
 
 
-@dataclasses.dataclass
+@dataclass
 class RecursiveItem:
-    sub_items: List["RecursiveItem"] = Field(default_factory=list)
-    name: str = Field(...)
+    name: str = field()
+    sub_items: List["RecursiveItem"] = field(default_factory=list)
 
 
-RecursiveItem.__pydantic_model__.update_forward_refs()
-
-
-@dataclasses.dataclass
+@dataclass
 class RecursiveSubitemInSubmodel:
-    sub_items2: List["RecursiveItemViaSubmodel"] = Field(default_factory=list)
-    name: str = Field(...)
+    name: str = field()
+    sub_items2: List["RecursiveItemViaSubmodel"] = field(default_factory=list)
 
 
-@dataclasses.dataclass
+@dataclass
 class RecursiveItemViaSubmodel:
-    sub_items1: List[RecursiveSubitemInSubmodel] = Field(default_factory=list)
-    name: str = Field(...)
-
-
-RecursiveSubitemInSubmodel.__pydantic_model__.update_forward_refs()
+    name: str = field()
+    sub_items1: List[RecursiveSubitemInSubmodel] = field(default_factory=list)
 
 
 @app.get("/items/recursive", response_model=RecursiveItem)