flask_dependency 0.2.0__tar.gz

flask_dependency-0.2.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.3
+Name: flask_dependency
+Version: 0.2.0
+Summary: 
+Author: ventura94
+Author-email: arianventura94@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: flask (>=3.1.1,<4.0.0)
+Requires-Dist: pydantic[dotenv] (>=1.10.19,<2.0.0)
+Description-Content-Type: text/markdown
+
+## Flask Dependency
+
+Dependency injection is a powerful concept that allows you to manage and inject dependencies into your application
+components. In Flask, we can create a simple dependency injection system inspired by FastAPI's `Depends`.
+
+### Approach
+
+1. **Create a Dependency Class**: We'll define a class called `Depends` that will handle our dependencies. This class
+   will allow us to declare dependencies for specific route handlers.
+
+2. **Decorator for Dependency Resolution**: We'll create a decorator that inspects the function and resolves any
+   dependencies when called. This decorator will be applied to our route handlers.
+
+3. **Dependency Functions**: We'll define individual functions (similar to FastAPI's dependencies) that represent our
+   dependencies. These functions will be called automatically when needed.
+
+### Sample Code
+
+```python
+# app.py
+from flask import Flask, Blueprint
+from pydantic import BaseModel
+from flask_dependency import BackgroundTask, Depends, route, FormModel
+
+app = Flask(__name__)
+blueprint = Blueprint("example_blueprint", __name__)
+app.debug = True
+
+
+def sample_task(duration):
+    import time
+    time.sleep(duration)
+    return f"Slept for {duration} seconds"
+
+
+# Example Backgraund Task
+@route(blueprint, "/backgraund_task", methods=["POST"], endpoint="route_test")
+def route_test(background_task: BackgroundTask = Depends()):
+    background_task.run(sample_task, 1)
+    return {"message": "OK"}
+
+
+class InputModelForm(FormModel):
+    id: int
+    name: str
+
+
+class ResponseInputModelForm(BaseModel):
+    id: int
+    name: str
+
+    class Config:
+        orm_mode = True
+
+
+# Example Form
+@route(blueprint, "/example_form", methods=["POST"], endpoint="route_test", response_schema=ResponseInputModelForm)
+def route_test(input_data: InputModelForm = Depends()):
+    return {"message": "success"}
+
+
+app.register_blueprint(blueprint)
+```
+
+

flask_dependency-0.2.0/README.md

@@ -0,0 +1,64 @@
+## Flask Dependency
+
+Dependency injection is a powerful concept that allows you to manage and inject dependencies into your application
+components. In Flask, we can create a simple dependency injection system inspired by FastAPI's `Depends`.
+
+### Approach
+
+1. **Create a Dependency Class**: We'll define a class called `Depends` that will handle our dependencies. This class
+   will allow us to declare dependencies for specific route handlers.
+
+2. **Decorator for Dependency Resolution**: We'll create a decorator that inspects the function and resolves any
+   dependencies when called. This decorator will be applied to our route handlers.
+
+3. **Dependency Functions**: We'll define individual functions (similar to FastAPI's dependencies) that represent our
+   dependencies. These functions will be called automatically when needed.
+
+### Sample Code
+
+```python
+# app.py
+from flask import Flask, Blueprint
+from pydantic import BaseModel
+from flask_dependency import BackgroundTask, Depends, route, FormModel
+
+app = Flask(__name__)
+blueprint = Blueprint("example_blueprint", __name__)
+app.debug = True
+
+
+def sample_task(duration):
+    import time
+    time.sleep(duration)
+    return f"Slept for {duration} seconds"
+
+
+# Example Backgraund Task
+@route(blueprint, "/backgraund_task", methods=["POST"], endpoint="route_test")
+def route_test(background_task: BackgroundTask = Depends()):
+    background_task.run(sample_task, 1)
+    return {"message": "OK"}
+
+
+class InputModelForm(FormModel):
+    id: int
+    name: str
+
+
+class ResponseInputModelForm(BaseModel):
+    id: int
+    name: str
+
+    class Config:
+        orm_mode = True
+
+
+# Example Form
+@route(blueprint, "/example_form", methods=["POST"], endpoint="route_test", response_schema=ResponseInputModelForm)
+def route_test(input_data: InputModelForm = Depends()):
+    return {"message": "success"}
+
+
+app.register_blueprint(blueprint)
+```
+

flask_dependency-0.2.0/flask_dependency/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.1.3"
+
+from .background_task import BackgroundTask
+from .depends import Depends
+from .form import FormModel
+from .query import QueryModel
+from .route import route

flask_dependency-0.2.0/flask_dependency/background_task.py

@@ -0,0 +1,11 @@
+from concurrent.futures import ThreadPoolExecutor, Future
+from typing import Callable, Any
+
+
+class BackgroundTask:
+    def __init__(self, max_workers: int = 1):
+        self.executor = ThreadPoolExecutor(max_workers=max_workers)
+
+    def run(self, func: Callable, *args: Any, **kwargs: Any) -> Future:
+        future = self.executor.submit(func, *args, **kwargs)
+        return future

flask_dependency-0.2.0/flask_dependency/depends.py

@@ -0,0 +1,31 @@
+from typing import Any, Callable, Optional
+
+from flask import g
+
+
+class Depends:
+    def __init__(self, dependency: Optional[Callable[..., Any]] = None, cache: bool = True):
+        self.dependency = dependency
+        self.cache_key = f"_depends_cache_{id(dependency)}"
+        self.cache = cache
+
+    def __call__(self):
+        if not hasattr(g, self.cache_key) or not self.cache:
+            result = self.dependency()
+            if hasattr(result, "__enter__") and hasattr(result, "__exit__"):
+                with result as ctx_result:
+                    setattr(g, self.cache_key, ctx_result)
+                    return ctx_result
+            setattr(g, self.cache_key, result)
+            return result
+        return getattr(g, self.cache_key)
+
+    def exists(self) -> bool:
+        print(hasattr(g, self.cache_key))
+        return bool(hasattr(g, self.cache_key))
+
+    @classmethod
+    def attach_dependency(cls, dependency_instance: Any) -> Any:
+        instance = cls(type(dependency_instance))
+        setattr(g, instance.cache_key, dependency_instance)
+        return dependency_instance

flask_dependency-0.2.0/flask_dependency/exceptions/unprocessable_content.py

@@ -0,0 +1,22 @@
+from pydantic import ValidationError
+
+
+class UnprocessableContent(Exception):
+    def __init__(
+            self,
+            error: ValidationError,
+            message: str = "Unprocessable Content",
+            status_code: int = 422,
+    ):
+        super().__init__(error)
+        self.error = error
+        self.message = message
+        self.status_code = status_code
+        self.error_details = self.get_error_details()
+
+    def get_error_details(self):
+        error_messages = []
+        for error in self.error.errors():
+            field = ".".join(str(loc) for loc in error["loc"])
+            error_messages.append(f"{field} {error['msg']}")
+        return error_messages

flask_dependency-0.2.0/flask_dependency/form.py

@@ -0,0 +1,17 @@
+import json
+
+from .exceptions.unprocessable_content import UnprocessableContent
+from flask import request
+from pydantic import BaseModel, ValidationError
+
+
+class FormModel(BaseModel):
+    def __init__(self):
+        data = request.get_json()
+        try:
+            if isinstance(data, (str, bytes, bytearray)):
+                super().__init__(**json.loads(data))
+            if isinstance(data, dict):
+                super().__init__(**data)
+        except ValidationError as exc:
+            raise UnprocessableContent(message="Invalid Input Data", error=exc)

flask_dependency-0.2.0/flask_dependency/inject.py

@@ -0,0 +1,32 @@
+from inspect import signature
+from types import UnionType
+from typing import get_origin, get_args
+
+from .depends import Depends
+
+
+def inject(func):
+    sig = signature(func)
+    params = sig.parameters
+
+    def wrapper(*args, **kwargs):
+        for name, param in params.items():
+            if isinstance(param.default, Depends):
+                if param.default.dependency:
+                    kwargs[name] = param.default()
+                else:
+                    if get_origin(param.annotation) is UnionType:
+                        possible_types = get_args(param.annotation)
+                    else:
+                        possible_types = (param.annotation,)
+                    if len(possible_types) == 1:
+                        kwargs[name] = Depends(possible_types[0])()
+                    else:
+                        for dep_type in possible_types:
+                            depends = Depends(dep_type)
+                            if depends.exists():
+                                kwargs[name] = depends()
+                                break
+        return func(*args, **kwargs)
+
+    return wrapper

flask_dependency-0.2.0/flask_dependency/query.py

@@ -0,0 +1,17 @@
+import json
+
+from .exceptions.unprocessable_content import UnprocessableContent
+from flask import request
+from pydantic import BaseModel, ValidationError
+
+
+class QueryModel(BaseModel):
+    def __init__(self):
+        data = request.args
+        try:
+            if isinstance(data, (str, bytes, bytearray)):
+                super().__init__(**json.loads(data))
+            if isinstance(data, dict):
+                super().__init__(**data)
+        except ValidationError as e:
+            raise UnprocessableContent(message="Invalid Query Data", error=e)

flask_dependency-0.2.0/flask_dependency/route.py

@@ -0,0 +1,37 @@
+from functools import wraps
+from typing import List, Literal, Type
+
+from flask import Blueprint
+from pydantic import BaseModel
+
+from .depends import Depends
+from .inject import inject
+from .validate_schema import validate_schema
+
+
+def route(
+        blueprint: Blueprint,
+        rule: str,
+        endpoint: str,
+        methods: List[Literal["GET", "POST", "PUT", "PATCH", "DELETE"]],
+        response_schema: Type[BaseModel] = None,
+        status_code_response: int = 200,
+        dependencies: List[Depends] = None,
+):
+    def decorator(func):
+        func = inject(func)
+
+        @wraps(func)
+        @blueprint.route(rule, methods=methods, endpoint=endpoint)
+        def wrapper(*args, **kwargs):
+
+            if dependencies:
+                [_() for _ in dependencies]
+            data_response = func(*args, **kwargs)
+            if response_schema:
+                data_response = validate_schema(response_schema, data_response).dict()
+            return data_response, status_code_response
+
+        return wrapper
+
+    return decorator

flask_dependency-0.2.0/flask_dependency/validate_schema.py

@@ -0,0 +1,11 @@
+from typing import Type, Any, Dict
+
+from pydantic import BaseModel
+
+
+def validate_schema(schema: Type[BaseModel], data: Any) -> BaseModel:
+    if isinstance(data, str):
+        return schema.parse_raw(data)
+    if isinstance(data, Dict):
+        return schema(**data)
+    return schema.from_orm(data)

flask_dependency-0.2.0/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "flask_dependency"
+version = "0.2.0"
+description = ""
+authors = ["ventura94 <arianventura94@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+flask = "^3.1.1"
+pydantic = { version = "^1.10.19", extras = ["dotenv"] }
+
+[tool.poetry.group.tests.dependencies]
+pytest = "^8.2.2"
+httpx = "^0.27.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"