fastapi-boot 0.0.1__tar.gz

fastapi_boot-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [hfdy0935]
+
+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.

fastapi_boot-0.0.1/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: fastapi_boot
+Version: 0.0.1
+Summary: FastAPI development toolkit
+Author: hfdy0935
+Author-email: 
+Project-URL: Repository, https://github.com/hfdy0935/fastapi_boot
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: starlette<0.42.0,>=0.40.0
+Requires-Dist: pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0,>=1.7.4
+Requires-Dist: typing-extensions>=4.8.0
+
+# FastAPI Boot
+
+&emsp;&emsp;FastAPI Boot is a FastAPI development toolkit that aims to provide a **more convenient** and **declarative** approach to `routing`, `dependency` `injection`, `error handling`, and `middleware`.
+
+## Features
+
+-   **Declarative Routing**: Simplify the way you define routes with a clear and intuitive syntax.
+-   **Dependency Injection**: Manage dependencies effortlessly with a robust DI system that simplifies your application's architecture.
+-   **Error Handling**: Built-in support for error handling that makes it easy to define and handle exceptions across your API.
+-   **Middleware Support**: Integrate middleware with ease to add pre-processing and post-processing steps to your requests and responses.
+
+## Getting Started
+
+```bash
+pip install fatsapi-boot
+```
+
+## USAGE
+
+1. FBV(function based view)
+
+```py
+# FooController.py
+from fastapi_boot import Controller
+
+
+@Controller('/fbv', tags=['hello_world']).post('/foo')
+def _():
+    return 'Hello World'
+```
+
+```py
+# main.py
+import uvicorn
+from fastapi import FastAPI
+from fastapi_boot import provide_app
+
+app = FastAPI()
+provide_app(app) # scans dir automatically
+
+if __name__ == '__main__':
+    uvicorn.run('main:app', reload=True)
+```
+
+2. CBV(class based view)
+
+```py
+from dataclasses import asdict, dataclass
+from pydantic import BaseModel
+from fastapi_boot import Controller, Delete, Get, Post, Put, Req
+
+
+class Baz(BaseModel):
+    baz: str
+
+@dataclass
+class Baz1:
+    baz1: str
+
+
+@Controller('/base-cbv', tags=['2. base cbv'])
+class FirstController:
+
+    @Req('/f', methods=['GET'])
+    def f():
+        return True
+
+    @Get('/foo')
+    def get_foo(self):
+        return BaseResp(code=200, msg='success', data='foo')
+
+    @Post('/bar')
+    def post_bar(self, p: str = Query()):
+        return p
+
+    @Put('/baz')
+    def put_baz(self, baz: Baz, baz1: Baz1):
+        return dict(**baz.model_dump(), **asdict(baz1))
+```
+
+click <a href='https://github.com/hfdy0935/fastapi_boot/tree/main/exmaples' target="_blank">here</a> to get more examples.
+
+## APIS
+
+```py
+from fastapi_boot import (
+    Bean,
+    Inject,
+    Injectable,
+    ExceptionHandler,
+    OnAppProvided,
+    provide_app,
+    use_dep,
+    use_http_middleware,
+    use_ws_middleware,
+    HTTPMiddleware,
+    Controller,
+    Delete,
+    Get,
+    Head,
+    Options,
+    Patch,
+    Post,
+    Prefix,
+    Put,
+    Req,
+    Trace,
+    WS,
+    Autowired,
+    Component,
+    Repository,
+    Service,
+)
+
+```

fastapi_boot-0.0.1/README.md

@@ -0,0 +1,115 @@
+# FastAPI Boot
+
+  FastAPI Boot is a FastAPI development toolkit that aims to provide a **more convenient** and **declarative** approach to `routing`, `dependency` `injection`, `error handling`, and `middleware`.
+
+## Features
+
+-   **Declarative Routing**: Simplify the way you define routes with a clear and intuitive syntax.
+-   **Dependency Injection**: Manage dependencies effortlessly with a robust DI system that simplifies your application's architecture.
+-   **Error Handling**: Built-in support for error handling that makes it easy to define and handle exceptions across your API.
+-   **Middleware Support**: Integrate middleware with ease to add pre-processing and post-processing steps to your requests and responses.
+
+## Getting Started
+
+```bash
+pip install fatsapi-boot
+```
+
+## USAGE
+
+1. FBV(function based view)
+
+```py
+# FooController.py
+from fastapi_boot import Controller
+
+
+@Controller('/fbv', tags=['hello_world']).post('/foo')
+def _():
+    return 'Hello World'
+```
+
+```py
+# main.py
+import uvicorn
+from fastapi import FastAPI
+from fastapi_boot import provide_app
+
+app = FastAPI()
+provide_app(app) # scans dir automatically
+
+if __name__ == '__main__':
+    uvicorn.run('main:app', reload=True)
+```
+
+2. CBV(class based view)
+
+```py
+from dataclasses import asdict, dataclass
+from pydantic import BaseModel
+from fastapi_boot import Controller, Delete, Get, Post, Put, Req
+
+
+class Baz(BaseModel):
+    baz: str
+
+@dataclass
+class Baz1:
+    baz1: str
+
+
+@Controller('/base-cbv', tags=['2. base cbv'])
+class FirstController:
+
+    @Req('/f', methods=['GET'])
+    def f():
+        return True
+
+    @Get('/foo')
+    def get_foo(self):
+        return BaseResp(code=200, msg='success', data='foo')
+
+    @Post('/bar')
+    def post_bar(self, p: str = Query()):
+        return p
+
+    @Put('/baz')
+    def put_baz(self, baz: Baz, baz1: Baz1):
+        return dict(**baz.model_dump(), **asdict(baz1))
+```
+
+click <a href='https://github.com/hfdy0935/fastapi_boot/tree/main/exmaples' target="_blank">here</a> to get more examples.
+
+## APIS
+
+```py
+from fastapi_boot import (
+    Bean,
+    Inject,
+    Injectable,
+    ExceptionHandler,
+    OnAppProvided,
+    provide_app,
+    use_dep,
+    use_http_middleware,
+    use_ws_middleware,
+    HTTPMiddleware,
+    Controller,
+    Delete,
+    Get,
+    Head,
+    Options,
+    Patch,
+    Post,
+    Prefix,
+    Put,
+    Req,
+    Trace,
+    WS,
+    Autowired,
+    Component,
+    Repository,
+    Service,
+)
+
+```

fastapi_boot-0.0.1/fastapi_boot/DI.py

@@ -0,0 +1,268 @@
+import time
+from collections.abc import Callable
+from inspect import Parameter, _empty, signature,isclass
+from typing import Annotated, Generic, TypeVar, get_args, get_origin, no_type_check, overload
+
+from fastapi_boot.const import NameDepRecord, TypeDepRecord, app_store, dep_store
+from fastapi_boot.model import AppRecord, DependencyNotFoundException, InjectFailException
+from fastapi_boot.util import get_call_filename
+
+T = TypeVar('T')
+
+# ------------------------------------------------------- public ------------------------------------------------------ #
+
+
+def _inject(app_record: AppRecord, tp: type[T], name: str | None = None) -> T:
+    """inject dependency by type or name
+
+    Args:
+        app_record (AppRecord)
+        tp (type[T])
+        name (str | None)
+
+    Returns:
+        T: instance
+    """
+    start = time.time()
+    while True:
+        if res := dep_store.inject_by_type(tp) if name is None else dep_store.inject_by_name(name, tp):
+            return res
+        time.sleep(app_record.inject_retry_step)
+        if time.time() - start > app_record.inject_timeout:
+            name_info=f"with name '{name}'" if name is not None else ''
+            raise DependencyNotFoundException(f"Dependency '{tp}' {name_info} not found")
+
+
+def inject_params_deps(app_record: AppRecord, params: list[Parameter]):
+    """find dependencies of params
+    Args:
+        app_record (AppRecord)
+        params (list[Parameter]): param list without self
+    """
+    params_dict = {}
+    for param in params:
+        # 1. with default
+        if param.default != _empty:
+            params_dict.update({param.name: param.default})
+        else:
+            # 2. no default
+            if param.annotation == _empty:
+                # 2.1 not annotation
+                raise InjectFailException(
+                    f'The annotation of param {param.name} is missing, add an annotation or give it a default value'
+                )
+            # 2.2. with annotation
+            if get_origin(param.annotation) == Annotated:
+                # 2.2.1 Annotated
+                tp, name, *_ = get_args(param.annotation)
+                if isinstance(name, str):
+                    # 2.2.1.1 name is str, as dependency's name to _inject
+                    params_dict.update({param.name: _inject(app_record, tp, name)})
+                else:
+                    # 2.2.1.2 name is not str
+                    params_dict.update({param.name: _inject(app_record, tp)})
+            else:
+                # 2.2.2 other
+                params_dict.update({param.name: _inject(app_record, param.annotation)})
+    return params_dict
+
+
+# ------------------------------------------------------- Bean ------------------------------------------------------- #
+
+
+def collect_bean(app_record: AppRecord, func: Callable, name: str | None = None):
+    """
+    1. run function decorated by Bean decorator
+    2. add the result to deps_store
+
+    Args:
+        app_record (AppRecord)
+        func (Callable): func
+        name (str | None, optional): name of dep
+    """
+    params: list[Parameter] = list(signature(func).parameters.values())
+    return_annotations = signature(func).return_annotation
+    instance = func(**inject_params_deps(app_record, params))
+    tp = return_annotations if return_annotations != _empty else type(instance)
+    if name is None:
+        dep_store.add_dep_by_type(TypeDepRecord(tp, instance))
+    else:
+        dep_store.add_dep_by_name(NameDepRecord(tp, instance, name))
+
+
+@overload
+def Bean(value: str): ...
+@overload
+def Bean(value: Callable[..., T]): ...
+@no_type_check
+def Bean(value: str | Callable[..., T]) -> Callable[..., T]:
+    """A decorator, will collect the return value of the func decorated by Bean
+    # Example
+    1. collect by `type`
+    ```python
+    @dataclass
+    class Foo:
+        bar: str
+
+    @Bean
+    def _():
+        return Foo('baz')
+    ```
+
+    2. collect by `name`
+    ```python
+    class User(BaseModel):
+        name: str = Field(max_length=20)
+        age: int = Field(gt=0)
+
+    @Bean('user1')
+    def _():
+        return User(name='zs', age=20)
+
+    @Bean('user2)
+    def _():
+        return User(name='zs', age=21)
+    ```
+    """
+    app_record = app_store.get(get_call_filename())
+
+    if callable(value):
+        collect_bean(app_record, value)
+        return value
+    else:
+
+        def wrapper(func: Callable[..., T]) -> Callable[..., T]:
+            collect_bean(app_record, func, value)
+            return func
+
+        return wrapper
+
+
+# ---------------------------------------------------- Injectable ---------------------------------------------------- #
+def inject_init_deps_and_get_instance(app_record: AppRecord, cls: type[T]) -> T:
+    """_inject cls's __init__ params and get params deps"""
+    old_params = list(signature(cls.__init__).parameters.values())[1:]  # self
+    new_params = [
+        i for i in old_params if i.kind not in (Parameter.VAR_KEYWORD, Parameter.VAR_POSITIONAL)
+    ]  # *args、**kwargs
+    return cls(**inject_params_deps(app_record, new_params))
+
+
+def collect_dep(app_record: AppRecord, cls: type, name: str | None = None):
+    """init class decorated by Inject decorator and collect it's instance as dependency"""
+    if hasattr(cls.__init__, '__globals__'):
+        cls.__init__.__globals__[cls.__name__] = cls  # avoid error when getting cls in __init__ method
+    instance = inject_init_deps_and_get_instance(app_record, cls)
+    if name is None:
+        dep_store.add_dep_by_type(TypeDepRecord(cls, instance))
+    else:
+        dep_store.add_dep_by_name(NameDepRecord(cls, instance, name))
+
+
+@overload
+def Injectable(value: str): ...
+@overload
+def Injectable(value: type[T]): ...
+
+
+@no_type_check
+def Injectable(value: str | type[T]) -> type[T]:
+    """decorate a class and collect it's instance as a dependency
+    # Example
+    ```python
+    @Injectable
+    class Foo:...
+
+    @Injectable('bar1')
+    class Bar:...
+    ```
+
+    """
+    app_record = app_store.get((get_call_filename()))
+    if isclass(value):
+        collect_dep(app_record, value)
+        return value
+    else:
+
+        def wrapper(cls: type[T]):
+            collect_dep(app_record, cls, value)
+            return cls
+
+        return wrapper
+
+
+# ------------------------------------------------------ Inject ------------------------------------------------------ #
+class AtUsable(type):
+    """support @"""
+
+    def __matmul__(self: type['Inject'], other: type[T]) -> T:
+        filename = get_call_filename()
+        app_record = app_store.get(filename)
+        return _inject(app_record, other, self.latest_named_deps_record.get(filename))
+
+    def __rmatmul__(self: type['Inject'], other: type[T]) -> T:
+        filename = get_call_filename()
+        app_record = app_store.get(filename)
+        return _inject(app_record, other, self.latest_named_deps_record.get(filename))
+
+
+class Inject(Generic[T], metaclass=AtUsable):
+    """inject dependency anywhere
+    # Example
+    - inject by **type**
+    ```python
+    a = Inject(Foo)
+    b = Inject @ Foo
+    c = Foo @ Inject
+
+    @Injectable
+    class Bar:
+        a = Inject(Foo)
+        b = Inject @ Foo
+        c = Foo @ Inject
+
+        def __init__(self,ia: Foo, ic: Foo):
+            self.ia = ia
+            self.ib = Inject @ Foo
+            self.ic = ic
+    ```
+
+    - inject by **name**
+    ```python
+    a = Inject(Foo, 'foo1')
+    b = Inject.Qualifier('foo2') @ Foo
+    c = Foo @ Inject.Qualifier('foo3')
+
+    @Injectable
+    class Bar:
+        a = Inject(Foo, 'foo1')
+        b = Inject.Qualifier('foo2') @ Foo
+        c = Foo @ Inject.Qualifier('foo3')
+
+        def __init__(self,ia: Annotated[Foo, 'foo1'], ic: Annotated[Foo, 'foo3']):
+            self.ia = ia
+            self.ib = Inject.Qualifier('foo2') @ Foo
+            self.ic = ic
+    ```
+    """
+
+    latest_named_deps_record: dict[str, str | None] = {}
+
+    def __new__(cls, tp: type[T], name: str | None = None) -> T:
+        """Inject(Type, name = None)"""
+        filename = get_call_filename()
+        cls.latest_named_deps_record.update({filename: name})
+        app_record = app_store.get(filename)
+        res = _inject(app_record, tp, name)
+        cls.latest_named_deps_record.update({filename: None})  # set name None
+        return res
+
+    @classmethod
+    def Qualifier(cls, name: str) -> type['Inject']:
+        """Inject.Qualifier(name)"""
+        filename = get_call_filename()
+
+        class Cls(cls):
+            latest_named_deps_record: dict[str, str] = {filename: name}
+
+        return Cls

fastapi_boot-0.0.1/fastapi_boot/__init__.py

@@ -0,0 +1,18 @@
+from .DI import Bean
+from .DI import Inject
+from .DI import Inject as Autowired
+from .DI import Injectable
+from .DI import Injectable as Component
+from .DI import Injectable as Repository
+from .DI import Injectable as Service
+from .helper import (
+    ExceptionHandler,
+    OnAppProvided,
+    provide_app,
+    use_dep,
+    use_http_middleware,
+    use_ws_middleware,
+    HTTPMiddleware,
+)
+from .routing import Controller, Delete, Get, Head, Options, Patch, Post, Prefix, Put, Req, Trace
+from .routing import WebSocket as WS

fastapi_boot-0.0.1/fastapi_boot/const.py

@@ -0,0 +1,120 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+from fastapi import FastAPI
+
+from fastapi_boot.model import AppNotFoundException, AppRecord, DependencyDuplicatedException
+
+T = TypeVar('T')
+
+# ---------------------------------------------------- constant ---------------------------------------------------- #
+# use_dep placeholder
+REQ_DEP_PLACEHOLDER = "fastapi_boot___dependency_placeholder"
+
+
+# route record's key in controller
+CONTROLLER_ROUTE_RECORD = "fastapi_boot___controller_route_record"
+
+# prefix of use_dep params in endpoint
+USE_DEP_PREFIX_IN_ENDPOINT = 'fastapi_boot__use_dep_prefix'
+
+
+# use_middleware placeholder
+USE_MIDDLEWARE_FIELD_PLACEHOLDER = 'fastapi_boot__use_middleware_field_placeholder'
+
+
+class BlankPlaceholder: ...
+
+
+# PRIORITY OF EXCEPTION_HANDLER
+EXCEPTION_HANDLER_PRIORITY = 1
+
+
+# ------------------------------------------------------- store ------------------------------------------------------ #
+
+
+@dataclass
+class TypeDepRecord(Generic[T]):
+    tp: type[T]
+    value: T
+
+
+@dataclass
+class NameDepRecord(Generic[T], TypeDepRecord[T]):
+    name: str
+
+
+class DependencyStore(Generic[T]):
+    def __init__(self):
+        self.type_deps: dict[type[T], TypeDepRecord[T]] = {}
+        self.name_deps: dict[str, NameDepRecord[T]] = {}
+
+    def add_dep_by_type(self, dep: TypeDepRecord[T]):
+        if dep.tp in self.type_deps:
+            raise DependencyDuplicatedException(f'Dependency {dep.tp} duplicated')
+        self.type_deps.update({dep.tp: dep})
+
+    def add_dep_by_name(self, dep: NameDepRecord[T]):
+        if self.name_deps.get(dep.name):
+            raise DependencyDuplicatedException(f'Dependency name {dep.name} duplicated')
+        self.name_deps.update({dep.name: dep})
+
+    def inject_by_type(self, tp: type[T]) -> T | None:
+        if res := self.type_deps.get(tp):
+            return res.value
+
+    def inject_by_name(self, name: str, tp: type[T]) -> T | None:
+        if find := self.name_deps.get(name):
+            if find.tp == tp:
+                return find.value
+
+    def clear(self):
+        self.type_deps.clear()
+        self.name_deps.clear()
+
+
+class AppStore(Generic[T]):
+    def __init__(self):
+        self.app_dic: dict[str, AppRecord] = {}
+
+    def add(self, path: str, app_record: AppRecord):
+        self.app_dic.update({path: app_record})
+
+    def get(self, path: str) -> AppRecord:
+        path = path[0].upper() + path[1:]
+        for k, v in self.app_dic.items():
+            if path.startswith(k):
+                return v
+        raise AppNotFoundException(f'Can"t find app of "{path}"')
+
+    def clear(self):
+        self.app_dic.clear()
+
+
+class TaskStore:
+    def __init__(self):
+        # will be called after the app becomes available
+        self.late_tasks: dict[str, list[tuple[Callable[[FastAPI], None], int]]] = {}
+
+    def add_late_task(self, path: str, task: Callable[[FastAPI], None], priority: int):
+        if curr_tasks := self.late_tasks.get(path):
+            self.late_tasks.update({path: [*curr_tasks, (task, priority)]})
+        else:
+            self.late_tasks.update({path: [(task, priority)]})
+            
+
+    def run_late_tasks(self):
+        for path, late_tasks in self.late_tasks.items():
+            app = app_store.get(path).app
+            late_tasks.sort(key=lambda x: x[1], reverse=True)
+            for record in late_tasks:
+                record[0](app)
+
+    def clear(self):
+        self.late_tasks.clear()
+
+
+dep_store = DependencyStore()
+app_store = AppStore()
+task_store = TaskStore()