py-auth-fastapi 0.0.1__tar.gz

py_auth_fastapi-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Olatunji Jamaldeen]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py_auth_fastapi-0.0.1/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: py-auth-fastapi
+Version: 0.0.1
+Summary: FastAPI integration for py-auth-core.
+Author-email: Olatunji Jamaldeen Omotoyosi <jamaldeen.o@yahoo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jamaldeen09/py-auth
+Project-URL: Repository, https://github.com/jamaldeen09/py-auth
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi[standard]>=0.100.0
+Requires-Dist: py-auth-core>=0.0.1
+Dynamic: license-file
+
+# py-auth-fastapi
+
+**FastAPI integration for [py-auth-core](https://pypi.org/project/py-auth-core/).**
+
+Removes the boilerplate of wiring `py-auth-core` authentication into a FastAPI application down to a single line.
+
+[![PyPI version](https://img.shields.io/pypi/v/py-auth-fastapi.svg)](https://pypi.org/project/py-auth-fastapi/)
+[![Python versions](https://img.shields.io/pypi/pyversions/py-auth-fastapi.svg)](https://pypi.org/project/py-auth-fastapi/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Features
+
+- ✅ **One-liner setup** — Mounts as a standard FastAPI `APIRouter` with `app.include_router()`
+- ✅ **Automatic cookie handling** — Sets and clears session and CSRF cookies automatically
+- ✅ **Dependency injection** — Includes `get_current_session()` dependency factory for protecting endpoints
+- ✅ **Built-in error handling** — Converts `py-auth-core` errors into standard FastAPI `HTTPException` responses
+
+---
+
+## Installation
+
+```bash
+pip install py-auth-fastapi
+```
+
+---
+
+## Quick Start
+
+```python
+from fastapi import FastAPI, Depends
+from py_auth import PyAuth
+from py_auth_fastapi import PyAuthFastAPI
+
+# Initialize your PyAuth instance
+auth = PyAuth(...)
+
+app = FastAPI()
+
+# Mount auth router (prefix="/auth" and tags=["Authentication"] by default)
+auth_router = PyAuthFastAPI(auth)
+app.include_router(auth_router)
+
+# Protect routes using the session dependency
+@app.get("/protected")
+async def protected_route(session=Depends(auth_router.get_current_session())):
+    return {"message": f"Hello user {session['user_id']}"}
+```
+
+### Endpoints Registered
+
+- `POST /auth/signin` — Authenticates credentials and sets session & CSRF cookies
+- `POST /auth/signout` — Revokes session and deletes cookies
+- `GET  /auth/session` — Fetches current session and rotates CSRF token
+
+---
+
+## License
+
+[MIT](LICENSE)

py_auth_fastapi-0.0.1/README.md

@@ -0,0 +1,62 @@
+# py-auth-fastapi
+
+**FastAPI integration for [py-auth-core](https://pypi.org/project/py-auth-core/).**
+
+Removes the boilerplate of wiring `py-auth-core` authentication into a FastAPI application down to a single line.
+
+[![PyPI version](https://img.shields.io/pypi/v/py-auth-fastapi.svg)](https://pypi.org/project/py-auth-fastapi/)
+[![Python versions](https://img.shields.io/pypi/pyversions/py-auth-fastapi.svg)](https://pypi.org/project/py-auth-fastapi/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Features
+
+- ✅ **One-liner setup** — Mounts as a standard FastAPI `APIRouter` with `app.include_router()`
+- ✅ **Automatic cookie handling** — Sets and clears session and CSRF cookies automatically
+- ✅ **Dependency injection** — Includes `get_current_session()` dependency factory for protecting endpoints
+- ✅ **Built-in error handling** — Converts `py-auth-core` errors into standard FastAPI `HTTPException` responses
+
+---
+
+## Installation
+
+```bash
+pip install py-auth-fastapi
+```
+
+---
+
+## Quick Start
+
+```python
+from fastapi import FastAPI, Depends
+from py_auth import PyAuth
+from py_auth_fastapi import PyAuthFastAPI
+
+# Initialize your PyAuth instance
+auth = PyAuth(...)
+
+app = FastAPI()
+
+# Mount auth router (prefix="/auth" and tags=["Authentication"] by default)
+auth_router = PyAuthFastAPI(auth)
+app.include_router(auth_router)
+
+# Protect routes using the session dependency
+@app.get("/protected")
+async def protected_route(session=Depends(auth_router.get_current_session())):
+    return {"message": f"Hello user {session['user_id']}"}
+```
+
+### Endpoints Registered
+
+- `POST /auth/signin` — Authenticates credentials and sets session & CSRF cookies
+- `POST /auth/signout` — Revokes session and deletes cookies
+- `GET  /auth/session` — Fetches current session and rotates CSRF token
+
+---
+
+## License
+
+[MIT](LICENSE)

py_auth_fastapi-0.0.1/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "py-auth-fastapi"
+version = "0.0.1"
+authors = [
+  { name = "Olatunji Jamaldeen Omotoyosi", email = "jamaldeen.o@yahoo.com" },
+]
+description = "FastAPI integration for py-auth-core."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+dependencies = [
+    "fastapi[standard]>=0.100.0",
+    "py-auth-core>=0.0.1",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/jamaldeen09/py-auth"
+"Repository" = "https://github.com/jamaldeen09/py-auth"
+
+[tool.setuptools.packages.find]
+where = ["src"]

py_auth_fastapi-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_auth_fastapi-0.0.1/src/py_auth_fastapi/__init__.py

@@ -0,0 +1,8 @@
+"""
+py-auth-fastapi: FastAPI integration for py-auth.
+"""
+
+from .core import PyAuthFastAPI
+
+__all__ = ["PyAuthFastAPI"]
+__version__ = "0.0.1"

py_auth_fastapi-0.0.1/src/py_auth_fastapi/core.py

@@ -0,0 +1,121 @@
+from enum import Enum
+from typing import Any, List, Optional, Union
+from fastapi import APIRouter, Request, Response, Depends
+from py_auth import PyAuth
+from py_auth.schemas import CookieConfig
+from .utils import raise_auth_exception
+
+class PyAuthFastAPI(APIRouter):
+    def __init__(
+        self,
+        auth: PyAuth,
+        *,
+        prefix: str = "/auth",
+        tags: Optional[List[Union[str, Enum]]] = None,
+        **kwargs: Any,
+    ):
+        if tags is None:
+            tags = ["Authentication"]
+
+        super().__init__(prefix=prefix, tags=tags, **kwargs)
+        self.auth = auth
+        self._register_routes()
+
+    def _set_auth_cookie(
+        self, response: Response, cookie_config: CookieConfig, value: str
+    ):
+        """Reusable helper to apply cookie configurations dynamically."""
+        options = cookie_config["options"]
+        response.set_cookie(
+            key=cookie_config["name"],
+            value=value,
+            httponly=options.get("http_only"),
+            secure=options.get("secure"),
+            samesite=options.get("same_site"),
+            path=options.get("path"),
+            domain=options.get("domain"),
+            max_age=options.get("max_age"),
+            expires=options.get("expires"),
+        )
+
+    def _clear_auth_cookie(self, response: Response, cookie_config: CookieConfig):
+        """Reusable helper to clear auth cookies with matching attributes."""
+        options = cookie_config["options"]
+        response.delete_cookie(
+            key=cookie_config["name"],
+            path=options.get("path", "/"),
+            domain=options.get("domain"),
+            secure=options.get("secure", True),
+            httponly=options.get("http_only", False),
+            samesite=options.get("same_site", "lax"),
+        )
+
+    def get_current_session(self):
+        """Factory method returning a valid FastAPI dependency closure."""
+
+        async def dependency(request: Request):
+            session_token = request.cookies.get(
+                self.auth.cookies["session_token"]["name"]
+            )
+            csrf_token = request.cookies.get(self.auth.cookies["csrf_token"]["name"])
+            result = await self.auth.verify_session(session_token, csrf_token)
+
+            if result.get("error"):
+                raise_auth_exception(result["error"])
+
+            return result["data"]["session"]
+
+        return dependency
+
+    def _register_routes(self):
+        @self.post("/signin")
+        async def signin(request: Request, response: Response):
+            request_body = await request.json()
+            result = await self.auth.signin_with_credentials(request_body)
+
+            if result.get("error"):
+                raise_auth_exception(result["error"])
+
+            data = result["data"]
+            self._set_auth_cookie(
+                response, self.auth.cookies["session_token"], data["session_token"]
+            )
+            self._set_auth_cookie(
+                response, self.auth.cookies["csrf_token"], data["csrf_token"]
+            )
+
+            return {"success": True, "message": "You have successfully signed in."}
+
+        @self.post("/signout")
+        async def signout(
+            response: Response, session=Depends(self.get_current_session())
+        ):
+            session_id = session["id"]
+            await self.auth.signout(session_id)
+            self._clear_auth_cookie(response, self.auth.cookies["session_token"])
+            self._clear_auth_cookie(response, self.auth.cookies["csrf_token"])
+            return {"success": True, "message": "You have successfully signed out."}
+
+        @self.get("/session")
+        async def get_session(
+            response: Response, session=Depends(self.get_current_session())
+        ):
+            """Refreshes/fetches session data and rotates the CSRF token if needed."""
+            result = await self.auth.update_session_csrf_token(session["id"])
+
+            if result.get("error"):
+                raise_auth_exception(result["error"])
+
+            csrf_cookie = self.auth.cookies["csrf_token"]
+            self._set_auth_cookie(response, csrf_cookie, result["data"]["csrf_token"])
+
+            session_dict = {
+                "id": session.get("id", None),
+                "user_id": session.get("user_id", None),
+                "expires": session.get("expires", None),
+            }
+            return {
+                "success": True,
+                "message": "Session is active.",
+                "session": session_dict,
+            }

py_auth_fastapi-0.0.1/src/py_auth_fastapi/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.

py_auth_fastapi-0.0.1/src/py_auth_fastapi/utils.py

@@ -0,0 +1,18 @@
+from py_auth.schemas import AuthError
+from fastapi.exceptions import HTTPException
+
+def raise_auth_exception(error: AuthError):
+    """Helper to cleanly translate py-auth errors into FastAPI HTTPExceptions."""
+    status_code = error.get("status_code", 500)
+    message = error.get("message", "Something went wrong.")
+    code = error.get("code", "AUTH_ERROR")
+    details = error.get("details", {})
+
+    raise HTTPException(
+        status_code=status_code,
+        detail={
+            "success": False,
+            "message": message,
+            "error": {"status_code": status_code, "code": code, "details": details},
+        },
+    )

py_auth_fastapi-0.0.1/src/py_auth_fastapi.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: py-auth-fastapi
+Version: 0.0.1
+Summary: FastAPI integration for py-auth-core.
+Author-email: Olatunji Jamaldeen Omotoyosi <jamaldeen.o@yahoo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jamaldeen09/py-auth
+Project-URL: Repository, https://github.com/jamaldeen09/py-auth
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi[standard]>=0.100.0
+Requires-Dist: py-auth-core>=0.0.1
+Dynamic: license-file
+
+# py-auth-fastapi
+
+**FastAPI integration for [py-auth-core](https://pypi.org/project/py-auth-core/).**
+
+Removes the boilerplate of wiring `py-auth-core` authentication into a FastAPI application down to a single line.
+
+[![PyPI version](https://img.shields.io/pypi/v/py-auth-fastapi.svg)](https://pypi.org/project/py-auth-fastapi/)
+[![Python versions](https://img.shields.io/pypi/pyversions/py-auth-fastapi.svg)](https://pypi.org/project/py-auth-fastapi/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Features
+
+- ✅ **One-liner setup** — Mounts as a standard FastAPI `APIRouter` with `app.include_router()`
+- ✅ **Automatic cookie handling** — Sets and clears session and CSRF cookies automatically
+- ✅ **Dependency injection** — Includes `get_current_session()` dependency factory for protecting endpoints
+- ✅ **Built-in error handling** — Converts `py-auth-core` errors into standard FastAPI `HTTPException` responses
+
+---
+
+## Installation
+
+```bash
+pip install py-auth-fastapi
+```
+
+---
+
+## Quick Start
+
+```python
+from fastapi import FastAPI, Depends
+from py_auth import PyAuth
+from py_auth_fastapi import PyAuthFastAPI
+
+# Initialize your PyAuth instance
+auth = PyAuth(...)
+
+app = FastAPI()
+
+# Mount auth router (prefix="/auth" and tags=["Authentication"] by default)
+auth_router = PyAuthFastAPI(auth)
+app.include_router(auth_router)
+
+# Protect routes using the session dependency
+@app.get("/protected")
+async def protected_route(session=Depends(auth_router.get_current_session())):
+    return {"message": f"Hello user {session['user_id']}"}
+```
+
+### Endpoints Registered
+
+- `POST /auth/signin` — Authenticates credentials and sets session & CSRF cookies
+- `POST /auth/signout` — Revokes session and deletes cookies
+- `GET  /auth/session` — Fetches current session and rotates CSRF token
+
+---
+
+## License
+
+[MIT](LICENSE)

py_auth_fastapi-0.0.1/src/py_auth_fastapi.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/py_auth_fastapi/__init__.py
+src/py_auth_fastapi/core.py
+src/py_auth_fastapi/py.typed
+src/py_auth_fastapi/utils.py
+src/py_auth_fastapi.egg-info/PKG-INFO
+src/py_auth_fastapi.egg-info/SOURCES.txt
+src/py_auth_fastapi.egg-info/dependency_links.txt
+src/py_auth_fastapi.egg-info/requires.txt
+src/py_auth_fastapi.egg-info/top_level.txt

py_auth_fastapi-0.0.1/src/py_auth_fastapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_auth_fastapi-0.0.1/src/py_auth_fastapi.egg-info/requires.txt

@@ -0,0 +1,2 @@
+fastapi[standard]>=0.100.0
+py-auth-core>=0.0.1

py_auth_fastapi-0.0.1/src/py_auth_fastapi.egg-info/top_level.txt

@@ -0,0 +1 @@
+py_auth_fastapi