fastabc 0.2.2__tar.gz → 4.6.0__tar.gz

{fastabc-0.2.2 → fastabc-4.6.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: fastabc
-Version: 0.2.2
-Summary: Initialize and create app|server
+Version: 4.6.0
+Summary: Base classes for FastAPI applications with Sanic compatibility layer
 License: MIT
 Author: Aleksandr Yurlov
 Author-email: sasha.yur@mail.ru
@@ -12,5 +12,7 @@ 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: fastapi (>=0.70.0,<0.71.0)
-Requires-Dist: uvicorn (>=0.15.0,<0.16.0)
+Provides-Extra: proxy
+Requires-Dist: fastapi (>=0.100.0)
+Requires-Dist: httpx (>=0.24.0) ; extra == "proxy"
+Requires-Dist: uvicorn (>=0.15.0)

fastabc-4.6.0/fastabc/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import typing as t
+
+from .baseclasses import Api, App
+
+__version__ = "4.6.0"
+__all__ = ["Api", "App"]
+
+
+def start_server(app: App, create_fn: t.Callable[[], App], **config) -> None:
+    if config.get("single_process", True):
+        return app.run_single(**config)
+
+    app.loader(create_fn, **config)
+    return app.run_single(**config)

fastabc-4.6.0/fastabc/baseclasses.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import typing as t
+from logging.config import dictConfig
+
+from fastapi import APIRouter, FastAPI
+
+from .structures import FastAPIConfig
+
+
+class AppConfig:
+    """Sanic-совместимая обёртка для app.config.
+
+    Хранит конфигурацию в upper-case как в Sanic и предоставляет метод update_config().
+    """
+
+    def __init__(self):
+        self._data: dict = {}
+
+    def update_config(self, config) -> None:
+        if hasattr(config, "to_dict"):
+            data = config.to_dict(uppercase=True) if self._supports_uppercase(config) else config.to_dict()
+            data = {k.upper(): v for k, v in data.items()}
+        elif isinstance(config, dict):
+            data = {k.upper(): v for k, v in config.items()}
+        else:
+            return
+        self._data.update(data)
+
+    @staticmethod
+    def _supports_uppercase(config) -> bool:
+        try:
+            return "uppercase" in inspect.signature(config.to_dict).parameters
+        except (ValueError, TypeError):
+            return False
+
+    def get(self, key: str, default=None):
+        return self._data.get(key.upper(), default)
+
+    def __getitem__(self, key: str):
+        return self._data[key.upper()]
+
+    def __setitem__(self, key: str, value):
+        self._data[key.upper()] = value
+
+    def __contains__(self, key: str) -> bool:
+        return key.upper() in self._data
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __repr__(self):
+        return repr(self._data)
+
+    def items(self):
+        return self._data.items()
+
+    def keys(self):
+        return self._data.keys()
+
+    def values(self):
+        return self._data.values()
+
+    def to_dict(self) -> dict:
+        return dict(self._data)
+
+
+class App(FastAPI):
+
+    def __init__(
+        self,
+        *args,
+        name: str | None = None,
+        log_config=None,
+        **kwargs,
+    ):
+        if name is not None and "title" not in kwargs:
+            kwargs["title"] = name
+        super().__init__(*args, **kwargs)
+        self._name = name or kwargs.get("title") or self.__class__.__name__
+        self.state.extensions = {}
+        self.state._config = AppConfig()
+
+        if log_config:
+            log_dict = log_config.to_dict() if hasattr(log_config, "to_dict") else log_config
+            if log_dict:
+                dictConfig(log_dict)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def loader(self, create_fn: t.Callable, **kwargs):
+        """Аналог Sanic AppLoader — сохраняет фабрику для multi-worker.
+        В single_process режиме не используется (start_server вызывает run_single напрямую).
+        """
+        self._create_fn = create_fn
+        self._create_kwargs = kwargs
+        return self
+
+    def run_single(self, **kwargs):
+        import uvicorn
+
+        config = self.make_startup_config(**kwargs)
+        uvicorn_config = {
+            "host": config.host,
+            "port": config.port,
+            "log_level": "debug" if config.debug else "info",
+        }
+
+        for key in ["workers", "reload", "access_log"]:
+            if key in config.extra:
+                uvicorn_config[key] = config.extra[key]
+
+        uvicorn.run(self, log_config=None, **uvicorn_config)
+
+    def make_startup_config(self, **kwargs) -> FastAPIConfig:
+        return FastAPIConfig.create(
+            {
+                "host": kwargs.pop("host", "0.0.0.0"),
+                "port": kwargs.pop("port", 8000),
+                "debug": kwargs.pop("debug", False),
+                **kwargs,
+            }
+        )
+
+    def exception(self, *exceptions: type[BaseException]):
+        """Регистрация handler-а исключений.
+
+        Принимает BaseException (как Sanic), но внутри маппит на Exception —
+        starlette не позволяет хэндлить не-Exception классы.
+        """
+        def decorator(handler: t.Callable):
+            for exc in exceptions:
+                target = exc if isinstance(exc, type) and issubclass(exc, Exception) else Exception
+                self.add_exception_handler(target, handler)
+            return handler
+        return decorator
+
+    @property
+    def extensions(self):
+        return self.state.extensions
+
+    @property
+    def config(self) -> AppConfig:
+        return self.state._config
+
+    def update_config(self, config) -> None:
+        """Устаревший метод — используйте app.config.update_config()."""
+        self.config.update_config(config)
+
+    def signal(self, event: str):
+        """Аналог Sanic app.signal() — для совместимости.
+
+        Маппит события:
+        - 'server.init.*', 'server.startup.*' → on_startup (FastAPI)
+        - 'server.shutdown.*' → on_shutdown (FastAPI)
+
+        Хендлер может иметь Sanic сигнатуру async def handler(app, loop) —
+        обёртка вызовет его с нашим app и текущим event loop.
+        """
+        def decorator(handler: t.Callable):
+            wrapped = self._wrap_signal_handler(handler)
+            if "shutdown" in event:
+                self.router.on_shutdown.append(wrapped)
+            elif "startup" in event or "init" in event:
+                self.router.on_startup.append(wrapped)
+            return handler
+        return decorator
+
+    def _wrap_signal_handler(self, handler: t.Callable) -> t.Callable:
+        try:
+            sig = inspect.signature(handler)
+            nargs = len([p for p in sig.parameters.values() if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)])
+        except (ValueError, TypeError):
+            nargs = 0
+
+        async def wrapper():
+            if nargs >= 2:
+                loop = asyncio.get_running_loop()
+                result = handler(self, loop)
+            elif nargs == 1:
+                result = handler(self)
+            else:
+                result = handler()
+            if inspect.isawaitable(result):
+                await result
+
+        return wrapper
+
+
+class Api(APIRouter):
+    def __init__(self, name: str = None, url_prefix: str = ""):
+        super().__init__(prefix=url_prefix)
+        self.name = name
+
+    def new_routes(self, routes: dict[str, type], strict: bool = True):
+        cache: dict[str, int] = {}
+
+        for url, resource in routes.items():
+            name = resource.__name__.lower()
+            cache[name] = cache.get(name, 0) + 1
+            resource_instance = resource()
+
+            route_name = name if cache.get(name, 0) <= 1 else f"{name}_{cache[name]}"
+
+            for method_name in ["get", "post", "put", "delete", "patch", "head", "options"]:
+                if hasattr(resource_instance, method_name):
+                    method = getattr(resource_instance, method_name)
+                    self.add_api_route(
+                        url, method, methods=[method_name.upper()], name=f"{route_name}_{method_name}"
+                    )
+        return self
+
+    def init_app(self, app: FastAPI):
+        app.include_router(self)
+        return self

fastabc-4.6.0/fastabc/constants.py

@@ -0,0 +1,21 @@
+from enum import IntEnum
+
+HTTP_ERROR_CODE_MIN = 400
+HTTP_ERROR_CODE_MAX = 599
+
+
+class HTTP_CODE(IntEnum):  # noqa: N801
+    OK = 200
+    CREATED = 201
+    NO_CONTENT = 204
+    MOVED_PERMANENTLY = 301
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    CONFLICT = 409
+    INTERNAL_SERVER_ERROR = 500
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504

fastabc-4.6.0/fastabc/exceptions.py

@@ -0,0 +1,3 @@
+from jwt.exceptions import PyJWTError
+
+__all__ = ["PyJWTError"]

fastabc-4.6.0/fastabc/middlewares/__init__.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from .auth import basic_auth, jwt_protection
+from .headers import add_request_id, set_request_id
+from .logging import log_request, log_response
+from .proxy import redirect_trailing_slash, reverse_proxy
+
+
+__all__ = [
+    "basic_auth",
+    "jwt_protection",
+    "add_request_id",
+    "set_request_id",
+    "log_request",
+    "log_response",
+    "redirect_trailing_slash",
+    "reverse_proxy",
+]

fastabc-4.6.0/fastabc/middlewares/auth.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from base64 import b64decode
+from functools import partial
+from typing import Callable
+
+import jwt
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+from fastabc.middlewares.utils import check_secrets, unpack_basic_auth
+
+
+def basic_auth(secrets: dict | None = None):
+    """
+    Middleware factory for Basic Auth.
+    Parses Authorization header and stores credential in request.state.basic
+    """
+    get_credential = partial(check_secrets, secrets=secrets)
+
+    class BasicAuthMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: Callable) -> Response:
+            auth_header = request.headers.get("authorization", "")
+
+            if auth_header and auth_header.lower().startswith("basic "):
+                token = auth_header[6:]
+                if (data := unpack_basic_auth(token)) is not None:
+                    try:
+                        credential = get_credential(*str(b64decode(data), "utf-8").split(":"))
+                        if credential is not None:
+                            request.state.basic = credential
+                    except (ValueError, UnicodeDecodeError):
+                        pass
+
+            return await call_next(request)
+
+    return BasicAuthMiddleware
+
+
+def jwt_protection(secret: str, algorithm: str = "HS256"):
+    """
+    Middleware factory for JWT protection.
+    Parses Bearer token from Authorization header and stores decoded JWT in request.state.jwt
+    """
+
+    class JWTMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: Callable) -> Response:
+            auth_header = request.headers.get("authorization", "")
+
+            if auth_header and auth_header.lower().startswith("bearer "):
+                token = auth_header[7:]
+                try:
+                    request.state.jwt = jwt.decode(token, secret, algorithms=[algorithm])
+                except jwt.PyJWTError:
+                    pass
+
+            return await call_next(request)
+
+    return JWTMiddleware

fastabc-4.6.0/fastabc/middlewares/headers.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Callable
+from uuid import uuid4
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+def add_request_id(generator: Callable[[], str] | None = None, override: bool = False):
+    """
+    Middleware factory for adding request ID to request.state.
+    If X-Request-ID header exists and override=False, uses header value.
+    Otherwise generates new ID using generator function.
+    """
+    id_generator = generator if generator is not None else lambda: str(uuid4())
+
+    class RequestIdMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: Callable) -> Response:
+            request_id = request.headers.get("x-request-id")
+
+            if request_id and not override:
+                request.state.request_id = request_id
+            else:
+                request.state.request_id = id_generator()
+
+            return await call_next(request)
+
+    return RequestIdMiddleware
+
+
+def set_request_id():
+    """
+    Middleware factory for setting X-Request-ID header in response.
+    Copies request_id from request.state to response headers.
+    """
+
+    class SetRequestIdMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: Callable) -> Response:
+            response = await call_next(request)
+
+            if hasattr(request.state, "request_id"):
+                response.headers["x-request-id"] = request.state.request_id
+            elif "x-request-id" in request.headers:
+                response.headers["x-request-id"] = request.headers["x-request-id"]
+
+            return response
+
+    return SetRequestIdMiddleware

fastabc-4.6.0/fastabc/middlewares/logging.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import typing as t
+from json import dumps
+from logging import Logger
+from time import monotonic
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+from fastabc.middlewares.utils import parse_user
+
+
+def log_request(logger: Logger, get_user: t.Callable[[t.Optional[str]], t.Optional[str]] | None = None):
+    """
+    Middleware factory for logging incoming requests.
+    Logs IP, method, URI, user-agent, user, and request-id.
+    """
+    get_user_callback = get_user if get_user is not None else parse_user
+
+    class LogRequestMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: t.Callable) -> Response:
+            request.state.start_time = monotonic()
+
+            # Extract token from Authorization header
+            auth_header = request.headers.get("authorization", "")
+            token = None
+            if auth_header.lower().startswith("bearer "):
+                token = auth_header[7:]
+
+            request.state.user = get_user_callback(token)
+
+            result = {
+                "ip": request.client.host if request.client else None,
+                "method": request.method,
+                "uri": request.url.path,
+                "user_agent": request.headers.get("user-agent"),
+                "user": getattr(request.state, "user", None),
+                "request-id": getattr(request.state, "request_id", None),
+            }
+
+            logger.info(dumps(result))
+
+            return await call_next(request)
+
+    return LogRequestMiddleware
+
+
+def log_response(logger: Logger):
+    """
+    Middleware factory for logging responses.
+    Logs IP, method, URI, user, status, time, and request-id.
+    """
+
+    class LogResponseMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: t.Callable) -> Response:
+            response = await call_next(request)
+
+            end_time = None
+            if hasattr(request.state, "start_time"):
+                end_time = round((monotonic() - request.state.start_time) * 1000)
+
+            result = {
+                "ip": request.client.host if request.client else None,
+                "method": request.method,
+                "uri": request.url.path,
+                "user": getattr(request.state, "user", None),
+                "status": response.status_code,
+                "time": f"{end_time}ms" if end_time is not None else "",
+                "request-id": getattr(request.state, "request_id", None),
+            }
+
+            if 400 <= response.status_code <= 599:
+                # Note: Can't easily get response body in BaseHTTPMiddleware
+                # Would need to use raw ASGI middleware for that
+                result["error"] = True
+
+            logger.info(dumps(result))
+
+            return response
+
+    return LogResponseMiddleware

fastabc-4.6.0/fastabc/middlewares/proxy.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import Callable
+
+import httpx
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import RedirectResponse, Response
+
+
+def redirect_trailing_slash(path: str):
+    """
+    Middleware factory for redirecting path without trailing slash to path with slash.
+
+    Args:
+        path: Exact path to match (e.g., "/webapp")
+
+    Example:
+        app.add_middleware(redirect_trailing_slash("/webapp"))
+
+        Request: GET /webapp?startapp=xxx
+        Redirect: GET /webapp/?startapp=xxx (307 redirect)
+    """
+
+    class RedirectTrailingSlashMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: Callable) -> Response:
+            if request.url.path == path:
+                url = path + "/"
+                if request.url.query:
+                    url = f"{url}?{request.url.query}"
+                return RedirectResponse(url=url, status_code=307)
+            return await call_next(request)
+
+    return RedirectTrailingSlashMiddleware
+
+
+def reverse_proxy(path_prefix: str, target_url: str, strip_prefix: bool = False):
+    """
+    Middleware factory for reverse proxying requests to another service.
+
+    Args:
+        path_prefix: URL prefix to intercept (e.g., "/webapp/")
+        target_url: Target service URL (e.g., "http://localhost:3000")
+        strip_prefix: If True, removes path_prefix from proxied URL
+
+    Example:
+        app.add_middleware(reverse_proxy("/webapp/", "http://localhost:3000"))
+
+        Request: GET /webapp/index.html
+        Proxied: GET http://localhost:3000/webapp/index.html (strip_prefix=False)
+        Proxied: GET http://localhost:3000/index.html (strip_prefix=True)
+    """
+    target = target_url.rstrip("/")
+
+    class ReverseProxyMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next: Callable) -> Response:
+            path = request.url.path
+
+            if not path.startswith(path_prefix):
+                return await call_next(request)
+
+            # Build target URL
+            if strip_prefix:
+                proxy_path = path[len(path_prefix.rstrip("/")):]
+            else:
+                proxy_path = path
+
+            proxy_url = f"{target}{proxy_path}"
+            if request.url.query:
+                proxy_url = f"{proxy_url}?{request.url.query}"
+
+            # Forward headers (excluding hop-by-hop)
+            headers = {
+                k: v for k, v in request.headers.items()
+                if k.lower() not in ("host", "connection", "keep-alive", "transfer-encoding")
+            }
+
+            # Read body for non-GET requests
+            body = None
+            if request.method in ("POST", "PUT", "PATCH"):
+                body = await request.body()
+
+            try:
+                async with httpx.AsyncClient(timeout=30.0) as client:
+                    response = await client.request(
+                        method=request.method,
+                        url=proxy_url,
+                        headers=headers,
+                        content=body,
+                    )
+
+                # Filter response headers
+                response_headers = {
+                    k: v for k, v in response.headers.items()
+                    if k.lower() not in ("content-encoding", "content-length", "transfer-encoding")
+                }
+
+                return Response(
+                    content=response.content,
+                    status_code=response.status_code,
+                    headers=response_headers,
+                    media_type=response.headers.get("content-type"),
+                )
+
+            except httpx.ConnectError:
+                return Response(
+                    content=b"Proxy target unavailable",
+                    status_code=502,
+                    media_type="text/plain",
+                )
+            except httpx.TimeoutException:
+                return Response(
+                    content=b"Proxy target timeout",
+                    status_code=504,
+                    media_type="text/plain",
+                )
+
+    return ReverseProxyMiddleware

fastabc-4.6.0/fastabc/middlewares/utils.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import base64
+import re
+import typing as t
+from types import MappingProxyType
+
+
+def unpack_basic_auth(token: str) -> str | None:
+    if not token:
+        return None
+    if token.startswith("Basic "):
+        token = token[6:]
+    try:
+        return base64.b64decode(token).decode("utf-8")
+    except Exception:
+        return None
+
+
+def check_secrets(login: str, password: str, secrets: dict | None = None) -> MappingProxyType | None:
+    if secrets is None:
+        return None
+    if login in secrets and secrets[login] == password:
+        return MappingProxyType({"username": login, "password": password})
+    return None
+
+
+def parse_user(token: str | None) -> dict | None:
+    if token is None:
+        return None
+
+    try:
+        import jwt
+        payload = jwt.decode(token, options={"verify_signature": False})
+        uid = payload.get("sub") or payload.get("user_id") or payload.get("id")
+        return {"uid": uid, **payload} if uid else None
+    except Exception:
+        return None

{fastabc-0.2.2 → fastabc-4.6.0}/fastabc/structures.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass, replace, field
+from dataclasses import dataclass, field, replace
 
 
 @dataclass
@@ -29,4 +29,4 @@ class FastAPIConfig:
             "debug": self.debug,
             "access_log": self.access_log,
             **self.extra
-        }
+        }

fastabc-4.6.0/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "fastabc"
+version = "4.6.0"
+description = "Base classes for FastAPI applications with Sanic compatibility layer"
+authors = ["Aleksandr Yurlov <sasha.yur@mail.ru>"]
+license = "MIT"
+packages = [
+    { include = "fastabc" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+fastapi = ">=0.100.0"
+uvicorn = ">=0.15.0"
+httpx = { version = ">=0.24.0", optional = true }
+
+[tool.poetry.extras]
+proxy = ["httpx"]
+
+[tool.poetry.group.dev.dependencies]
+build = "^1.2.2.post1"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

fastabc-0.2.2/fastabc/__init__.py

@@ -1,11 +0,0 @@
-from .baseclasses import App, Api
-
-__version__ = "4.2.0"
-__all__ = ["Api", "App"]
-
-
-def start_server(create_fn, **config):
-    app_instance = App()
-    app = app_instance.loader(create_fn, **config)
-    import uvicorn
-    uvicorn.run(app, host=config.get("host", "0.0.0.0"), port=config.get("port", 8000))

fastabc-0.2.2/fastabc/baseclasses.py

@@ -1,46 +0,0 @@
-import typing as t
-from fastapi import FastAPI, APIRouter
-from .structures import FastAPIConfig
-
-class App:
-    def __init__(self, *args, lifespan: t.Optional[t.Callable] = None, **kwargs):
-        if lifespan:
-            kwargs["lifespan"] = lifespan
-        self.app = FastAPI(*args, **kwargs)
-        self.extensions = {}
-
-    def loader(self, create_fn: t.Callable[[FastAPI], FastAPI], **kwargs):
-        self.app = create_fn(self.app, **kwargs)
-        return self.app
-
-    def run_single(self, **kwargs):
-        import uvicorn
-        config = self.make_startup_config(**kwargs)
-        uvicorn.run(self.app, host=config.host, port=config.port, debug=config.debug)
-
-    def make_startup_config(self, **kwargs) -> FastAPIConfig:
-        return FastAPIConfig.create({
-            "host": kwargs.pop("host", "0.0.0.0"),
-            "port": kwargs.pop("port", 8000),
-            "debug": kwargs.pop("debug", False),
-            **kwargs,
-        })
-
-
-class Api:
-    def __init__(self, name: str, url_prefix: str = ""):
-        self.router = APIRouter(prefix=url_prefix)
-        self.name = name
-
-    def new_routes(self, routes: t.Dict[str, t.Type]):
-        for url, resource in routes.items():
-            resource_instance = resource()
-            for method_name in ["get", "post", "put", "delete"]:
-                if hasattr(resource_instance, method_name):
-                    method = getattr(resource_instance, method_name)
-                    self.router.add_api_route(url, method, methods=[method_name.upper()])
-        return self
-
-    def init_app(self, app: FastAPI):
-        app.include_router(self.router)
-        return self

fastabc-0.2.2/pyproject.toml

@@ -1,21 +0,0 @@
-[tool.poetry]
-name = "fastabc"
-version = "0.2.2"
-description = "Initialize and create app|server"
-authors = ["Aleksandr Yurlov <sasha.yur@mail.ru>"]
-license = "MIT"
-
-[tool.poetry.dependencies]
-python = "^3.10"
-fastapi = "^0.70.0"
-uvicorn = "^0.15.0"
-
-[tool.poetry.scripts]
-fastapi_abc = "fastapi_abc.__init__:start_server"
-
-[tool.poetry.group.dev.dependencies]
-build = "^1.2.2.post1"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"