classapi 0.1.0__tar.gz

classapi-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: classapi
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi[standard]>=0.129.0
+
+# ClassApi
+ClassApi is a small convenience layer on top of FastAPI that enables class-based views (CBV). It preserves FastAPI's features (typing, dependencies, automatic docs) while letting you organize handlers as classes.
+
+**Key features**
+- Use `BaseView` as a base class for handlers (`get`, `post`, `put`, ...).
+- Support for `pre_process` and `pre_<method>` hooks to validate or transform requests.
+- Register route modules by module path (supports relative module paths like `.src.urls`).
+- Combined signatures from `pre_process` and the handler method are exposed to FastAPI for documentation and form generation.
+
+**Development setup (using `uv` helper)**
+1. Create a virtual environment:
+```bash
+python -m venv .venv
+```
+2. Use your `uv` helper to run `pip` inside the project environment and install dependencies:
+```bash
+uv run pip install fastapi uvicorn
+# or install from requirements: uv run pip install -r requirements.txt
+```
+
+**Quickstart**
+Create `main.py`:
+```py
+from classapi import ClassApi
+
+app = ClassApi()
+
+app.include_routers(".src.urls")
+```
+
+Example routes and views layout (tests/app_test/src):
+```py
+# tests/app_test/src/urls.py
+from .views import HelloWorldView
+
+urls = [
+	{"path": "/hello", "view": HelloWorldView}
+]
+
+# tests/app_test/src/views.py
+from classapi import View, Header, HTTPException
+from typing import Annotated
+
+class ValidateUser(BaseView):
+	def pre_process(self, jwt: Annotated[str | None, Header()] = None):
+		if jwt != "valid_jwt":
+			raise HTTPException(status_code=401, detail="Unauthorized")
+
+class HelloWorldView(ValidateUser, BaseView):
+	methods = ["GET"]
+
+	def get(self, name: str = "World"):
+		return {"Hello": name}
+```
+
+**Supported `urls` formats**
+- Dict entries: `{"path": "/x", "view": MyView, ...fastapi kwargs...}` — extra kwargs (e.g. `response_model`) are forwarded to `add_api_route`.
+- Tuple/list entries: `("/x", MyView)`.
+- You may use relative imports from the calling module: `app.include_routers(".src.urls")`.
+
+**`View` classes**
+- Define HTTP methods: `get`, `post`, `put`, `delete`, `patch`.
+- Limit exposed methods with `methods = ["GET"]` on the class.
+- Hooks:
+  - `pre_process(self, ...)` — runs before any handler.
+  - `pre_get(self, ...)`, `pre_post(...)`, ... — run before a specific handler.
+- Signatures from `pre_process`, `pre_<method>` and the handler itself are merged and exposed to FastAPI; annotate parameters with `Annotated[..., Header()]`, `Cookie()`, etc., to appear correctly in `/docs`.
+
+Example: header extraction in `pre_process`:
+```py
+def pre_process(self, jwt: Annotated[str|None, Header()] = None):
+	...
+```
+
+If you accidentally place `Annotated[...]` as a default (e.g. `jwt = Annotated[...]`), ClassApi attempts to normalize it so FastAPI recognizes the dependency. Still, annotate parameters properly when possible.
+
+**Running the app**
+- Use `uv` to run the app with reload during development:
+```bash
+uv run uvicorn tests.app_test.main:app --reload
+```
+or, if you use the helper script `test_init.py` at the repository root:
+```bash
+uv run .\test_init.py
+```
+
+**Debugging endpoint signatures**
+If docs don't show expected parameters, you can inspect endpoint signatures at runtime:
+```py
+for r in app.routes:
+	print(r.path, getattr(r.endpoint, '__signature__', None))
+```
+
+**Editor integration (VSCode / Pylance)**
+Pylance is a static analyzer and doesn't pick up runtime-generated signatures. To get editor hovers that match your runtime docs, create a `.pyi` stub next to your views module describing the public signatures (this does not change runtime behavior).
+
+**Contributing**
+- Open issues or PRs.
+- Add tests under `tests/` and run them with `pytest`.
+
+---
+If you want, I can generate a `views.pyi` stub for your views, add example tests, or add a minimal `pyproject.toml`. Which should I do next?

classapi-0.1.0/README.md

@@ -0,0 +1,102 @@
+# ClassApi
+ClassApi is a small convenience layer on top of FastAPI that enables class-based views (CBV). It preserves FastAPI's features (typing, dependencies, automatic docs) while letting you organize handlers as classes.
+
+**Key features**
+- Use `BaseView` as a base class for handlers (`get`, `post`, `put`, ...).
+- Support for `pre_process` and `pre_<method>` hooks to validate or transform requests.
+- Register route modules by module path (supports relative module paths like `.src.urls`).
+- Combined signatures from `pre_process` and the handler method are exposed to FastAPI for documentation and form generation.
+
+**Development setup (using `uv` helper)**
+1. Create a virtual environment:
+```bash
+python -m venv .venv
+```
+2. Use your `uv` helper to run `pip` inside the project environment and install dependencies:
+```bash
+uv run pip install fastapi uvicorn
+# or install from requirements: uv run pip install -r requirements.txt
+```
+
+**Quickstart**
+Create `main.py`:
+```py
+from classapi import ClassApi
+
+app = ClassApi()
+
+app.include_routers(".src.urls")
+```
+
+Example routes and views layout (tests/app_test/src):
+```py
+# tests/app_test/src/urls.py
+from .views import HelloWorldView
+
+urls = [
+	{"path": "/hello", "view": HelloWorldView}
+]
+
+# tests/app_test/src/views.py
+from classapi import View, Header, HTTPException
+from typing import Annotated
+
+class ValidateUser(BaseView):
+	def pre_process(self, jwt: Annotated[str | None, Header()] = None):
+		if jwt != "valid_jwt":
+			raise HTTPException(status_code=401, detail="Unauthorized")
+
+class HelloWorldView(ValidateUser, BaseView):
+	methods = ["GET"]
+
+	def get(self, name: str = "World"):
+		return {"Hello": name}
+```
+
+**Supported `urls` formats**
+- Dict entries: `{"path": "/x", "view": MyView, ...fastapi kwargs...}` — extra kwargs (e.g. `response_model`) are forwarded to `add_api_route`.
+- Tuple/list entries: `("/x", MyView)`.
+- You may use relative imports from the calling module: `app.include_routers(".src.urls")`.
+
+**`View` classes**
+- Define HTTP methods: `get`, `post`, `put`, `delete`, `patch`.
+- Limit exposed methods with `methods = ["GET"]` on the class.
+- Hooks:
+  - `pre_process(self, ...)` — runs before any handler.
+  - `pre_get(self, ...)`, `pre_post(...)`, ... — run before a specific handler.
+- Signatures from `pre_process`, `pre_<method>` and the handler itself are merged and exposed to FastAPI; annotate parameters with `Annotated[..., Header()]`, `Cookie()`, etc., to appear correctly in `/docs`.
+
+Example: header extraction in `pre_process`:
+```py
+def pre_process(self, jwt: Annotated[str|None, Header()] = None):
+	...
+```
+
+If you accidentally place `Annotated[...]` as a default (e.g. `jwt = Annotated[...]`), ClassApi attempts to normalize it so FastAPI recognizes the dependency. Still, annotate parameters properly when possible.
+
+**Running the app**
+- Use `uv` to run the app with reload during development:
+```bash
+uv run uvicorn tests.app_test.main:app --reload
+```
+or, if you use the helper script `test_init.py` at the repository root:
+```bash
+uv run .\test_init.py
+```
+
+**Debugging endpoint signatures**
+If docs don't show expected parameters, you can inspect endpoint signatures at runtime:
+```py
+for r in app.routes:
+	print(r.path, getattr(r.endpoint, '__signature__', None))
+```
+
+**Editor integration (VSCode / Pylance)**
+Pylance is a static analyzer and doesn't pick up runtime-generated signatures. To get editor hovers that match your runtime docs, create a `.pyi` stub next to your views module describing the public signatures (this does not change runtime behavior).
+
+**Contributing**
+- Open issues or PRs.
+- Add tests under `tests/` and run them with `pytest`.
+
+---
+If you want, I can generate a `views.pyi` stub for your views, add example tests, or add a minimal `pyproject.toml`. Which should I do next?

classapi-0.1.0/classapi/__init__.py

@@ -0,0 +1,2 @@
+from .classapi import ClassApi, BaseView
+from fastapi import *

classapi-0.1.0/classapi/classapi.py

@@ -0,0 +1,270 @@
+import fastapi as _fastapi
+
+class ClassApi(_fastapi.FastAPI):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("title", "ClassApi (FastAPI with class-based views)")
+        super().__init__(*args, **kwargs)
+
+    def include_routers(self, path_file, prefix: str = ""):
+        import os
+        import importlib
+        import inspect
+        #search the "list" url in the file and include it in the app
+        # Support three forms:
+        # - absolute module path: "package.module"
+        # - path with leading slash or slashes: "/package/module" -> "package.module"
+        # - relative module path starting with dot: ".src.urls" (resolved gainst caller package)
+        module = None
+        if path_file.startswith("/"):
+            module_path = path_file.lstrip("/").replace("/", ".")
+            module = importlib.import_module(module_path)
+        elif path_file.startswith("."):
+            # find caller package to perform relative import
+            frm = inspect.currentframe()
+            try:
+                caller = frm.f_back
+                package = None
+                if caller is not None:
+                    package = caller.f_globals.get("__package__") or caller.f_globals.get("__name__")
+                if not package:
+                    raise ImportError("cannot resolve relative import: caller package unknown")
+                module = importlib.import_module(path_file, package=package)
+            finally:
+                del frm
+        else:
+            module = importlib.import_module(path_file.replace("/", "."))
+        
+        urls = getattr(module, "urls", [])
+        print(f"Included routes from {path_file}: {urls}")
+        for i in urls:
+            # support two formats for route entries:
+            # - dict: {"path": "/x", "view": ViewClass, ...fastapi kwargs...}
+            # - list/tuple: ["/x", ViewClass]
+            route_kwargs = {}
+            if isinstance(i, dict):
+                path = prefix + i.get("path", "")
+                view = i["view"]
+                # extra keys become kwargs forwarded to add_api_route
+                route_kwargs = {k: v for k, v in i.items() if k not in ("path", "view")}
+            elif isinstance(i, (list, tuple)) and len(i) >= 2:
+                path = prefix + i[0]
+                view = i[1]
+            else:
+                raise AssertionError("Route entries must be dict or (path, view) tuple/list")
+
+            assert issubclass(view, BaseView), f"View class {view} must inherit from View base class"
+            assert type(path) == str, f"Path must be a string, got {type(path)}"
+            print(f"Adding route: {path} -> {view} with {route_kwargs}")
+            view()._add_route(self, path=path, **route_kwargs)
+            
+
+
+class BaseView:
+    methods = []
+
+    def pre_process(self, *args, **kwargs):
+        pass
+
+    def pre_get(self,  *args, **kwargs):
+        pass
+
+    def pre_post(self,  *args, **kwargs):
+        pass
+
+    def pre_put(self,  *args, **kwargs):
+        pass
+
+    def pre_delete(self,  *args, **kwargs):
+        pass
+
+    def pre_patch(self,  *args, **kwargs):
+        pass
+
+    def _add_route(self, app: _fastapi.FastAPI, path: str = "/", **kwargs):
+        """Register handlers on `app` forwarding any FastAPI-compatible kwargs.
+
+        `kwargs` are passed directly to `app.add_api_route`, so you can provide
+        `response_model`, `dependencies`, `status_code`, etc.
+        """
+        # create FastAPI-compatible endpoint wrappers that preserve the
+        # original method signature (excluding `self`) by setting
+        # `__signature__` on the wrapper. FastAPI uses that for dependency
+        # injection and parameter parsing.
+        def _make_endpoint(method_name, http_methods):
+            import inspect
+            func = getattr(self, method_name)
+            sig_func = inspect.signature(func)
+            params_func = list(sig_func.parameters.values())
+            if params_func and params_func[0].name == "self":
+                params_func = params_func[1:]
+            # exclude *args and **kwargs from the public signature
+            params_func = [p for p in params_func if p.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)]
+
+            # gather pre handlers: specific pre_<method> and general pre_process
+            pre_specific = getattr(self, f"pre_{method_name}", None)
+            pre_general = getattr(self, "pre_process", None)
+
+            params_pre_specific = []
+            params_pre_general = []
+            if pre_specific is not None:
+                sig_pre = inspect.signature(pre_specific)
+                params_pre_specific = list(sig_pre.parameters.values())
+                if params_pre_specific and params_pre_specific[0].name == "self":
+                    params_pre_specific = params_pre_specific[1:]
+                # exclude *args and **kwargs from the public signature
+                params_pre_specific = [p for p in params_pre_specific if p.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)]
+                # also filter accidental plain 'args'/'kwargs' parameters
+                params_pre_specific = [p for p in params_pre_specific if p.name not in ("args", "kwargs")]
+            if pre_general is not None:
+                sig_pre_g = inspect.signature(pre_general)
+                params_pre_general = list(sig_pre_g.parameters.values())
+                if params_pre_general and params_pre_general[0].name == "self":
+                    params_pre_general = params_pre_general[1:]
+                # exclude *args and **kwargs from the public signature
+                params_pre_general = [p for p in params_pre_general if p.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)]
+                # also filter accidental plain 'args'/'kwargs' parameters
+                params_pre_general = [p for p in params_pre_general if p.name not in ("args", "kwargs")]
+
+            # merge params: general pre, specific pre, then func params; skip duplicates by name
+            seen = set()
+            merged = []
+            for p in params_pre_general + params_pre_specific + params_func:
+                if p.name not in seen:
+                    merged.append(p)
+                    seen.add(p.name)
+
+            # Reorder merged params to satisfy Python's parameter ordering rules:
+            # positional-only, positional-or-keyword, var-positional, keyword-only, var-keyword
+            posonly = []
+            pos_or_kw = []
+            var_pos = None
+            kw_only = []
+            var_kw = None
+            for p in merged:
+                if p.kind == inspect.Parameter.POSITIONAL_ONLY:
+                    posonly.append(p)
+                elif p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
+                    pos_or_kw.append(p)
+                elif p.kind == inspect.Parameter.VAR_POSITIONAL:
+                    if var_pos is None:
+                        var_pos = p
+                elif p.kind == inspect.Parameter.KEYWORD_ONLY:
+                    kw_only.append(p)
+                elif p.kind == inspect.Parameter.VAR_KEYWORD:
+                    if var_kw is None:
+                        var_kw = p
+
+                # Ensure parameters without defaults come before those with defaults
+                def split_by_default(params):
+                    no_def = [p for p in params if p.default is inspect._empty]
+                    has_def = [p for p in params if p.default is not inspect._empty]
+                    return no_def + has_def
+
+                posonly = split_by_default(posonly)
+                pos_or_kw = split_by_default(pos_or_kw)
+                kw_only = split_by_default(kw_only)
+
+                ordered = posonly + pos_or_kw
+            if var_pos is not None:
+                ordered.append(var_pos)
+            ordered += kw_only
+            if var_kw is not None:
+                ordered.append(var_kw)
+
+            # normalize parameters: if a parameter has no annotation but its default
+            # is an `Annotated[T, metadata...]` object (commonly used incorrectly
+            # as a default), extract the annotation and the first metadata item
+            # (e.g. Header()) and set them on the parameter so FastAPI detects it.
+            import typing
+            normalized = []
+            for p in ordered:
+                ann = p.annotation
+                default = p.default
+                if (ann is inspect._empty and default is not inspect._empty
+                        and typing.get_origin(default) is typing.Annotated):
+                    args = typing.get_args(default)
+                    if args:
+                        new_ann = args[0]
+                        new_default = args[1] if len(args) > 1 else inspect._empty
+                        p = inspect.Parameter(p.name, p.kind, default=new_default, annotation=new_ann)
+                normalized.append(p)
+
+            new_sig = inspect.Signature(parameters=normalized)
+
+            def endpoint(**kwargs):
+                # call general pre_process with its subset
+                if pre_general is not None:
+                    pre_g_kwargs = {k: v for k, v in kwargs.items() if k in {p.name for p in params_pre_general}}
+                    pre_general(**pre_g_kwargs)
+                # call specific pre_<method> with its subset
+                if pre_specific is not None:
+                    pre_s_kwargs = {k: v for k, v in kwargs.items() if k in {p.name for p in params_pre_specific}}
+                    pre_specific(**pre_s_kwargs)
+                # call actual handler with its subset
+                func_kwargs = {k: v for k, v in kwargs.items() if k in {p.name for p in params_func}}
+                return func(**func_kwargs)
+
+            endpoint.__signature__ = new_sig
+            endpoint.__name__ = f"{self.__class__.__name__}_{method_name}_endpoint"
+            return endpoint
+
+        if hasattr(self, "get") and ("GET" in self.methods or "get" in self.methods):
+            app.add_api_route(path, _make_endpoint("get", ["GET"]), methods=["GET"], **kwargs)
+        if hasattr(self, "post") and ("POST" in self.methods or "post" in self.methods):
+            app.add_api_route(path, _make_endpoint("post", ["POST"]), methods=["POST"], **kwargs)
+        if hasattr(self, "put") and ("PUT" in self.methods or "put" in self.methods):
+            app.add_api_route(path, _make_endpoint("put", ["PUT"]), methods=["PUT"], **kwargs)
+        if hasattr(self, "delete") and ("DELETE" in self.methods or "delete" in self.methods):
+            app.add_api_route(path, _make_endpoint("delete", ["DELETE"]), methods=["DELETE"], **kwargs)
+        if hasattr(self, "patch") and ("PATCH" in self.methods or "patch" in self.methods):
+            app.add_api_route(path, _make_endpoint("patch", ["PATCH"]), methods=["PATCH"], **kwargs)
+
+
+    def _post(self, *args, **kwargs):
+        self.pre_process(*args, **kwargs)
+        self.pre_post(*args, **kwargs)
+        return self.post(*args, **kwargs)
+
+    def _get(self,  *args, **kwargs):
+        self.pre_process(*args, **kwargs)
+        self.pre_get(*args, **kwargs)
+        return self.get(*args, **kwargs)
+
+    def _put(self,  *args, **kwargs):
+        self.pre_process(*args, **kwargs)
+        self.pre_put(*args, **kwargs)
+        return self.put(*args, **kwargs)
+
+    def _delete(self,  *args, **kwargs):
+        self.pre_process(*args, **kwargs)
+        self.pre_delete(*args, **kwargs)
+        return self.delete(*args, **kwargs)
+
+    def _patch(self,  *args, **kwargs):
+        self.pre_process(*args, **kwargs)
+        self.pre_patch(*args, **kwargs)
+        return self.patch(*args, **kwargs)
+
+    def post(self,  *args):
+        return 
+    
+    def get(self,  *args):
+        return
+    
+    def put(self,  *args):
+        return
+    
+    def delete(self,  *args):
+        return
+    
+    def patch(self,  *args):
+        return
+
+def include(directory: str):
+    import os
+    import importlib
+    #search the "list" url in the file and include it in the app
+    for file in os.listdir(directory):
+        if file.endswith(".py") and file != "__init__.py":
+            module_name = file[:-3]
+            module = importlib.import_module(f"{directory.replace('/', '.')}.{module_name}")

classapi-0.1.0/classapi.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: classapi
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi[standard]>=0.129.0
+
+# ClassApi
+ClassApi is a small convenience layer on top of FastAPI that enables class-based views (CBV). It preserves FastAPI's features (typing, dependencies, automatic docs) while letting you organize handlers as classes.
+
+**Key features**
+- Use `BaseView` as a base class for handlers (`get`, `post`, `put`, ...).
+- Support for `pre_process` and `pre_<method>` hooks to validate or transform requests.
+- Register route modules by module path (supports relative module paths like `.src.urls`).
+- Combined signatures from `pre_process` and the handler method are exposed to FastAPI for documentation and form generation.
+
+**Development setup (using `uv` helper)**
+1. Create a virtual environment:
+```bash
+python -m venv .venv
+```
+2. Use your `uv` helper to run `pip` inside the project environment and install dependencies:
+```bash
+uv run pip install fastapi uvicorn
+# or install from requirements: uv run pip install -r requirements.txt
+```
+
+**Quickstart**
+Create `main.py`:
+```py
+from classapi import ClassApi
+
+app = ClassApi()
+
+app.include_routers(".src.urls")
+```
+
+Example routes and views layout (tests/app_test/src):
+```py
+# tests/app_test/src/urls.py
+from .views import HelloWorldView
+
+urls = [
+	{"path": "/hello", "view": HelloWorldView}
+]
+
+# tests/app_test/src/views.py
+from classapi import View, Header, HTTPException
+from typing import Annotated
+
+class ValidateUser(BaseView):
+	def pre_process(self, jwt: Annotated[str | None, Header()] = None):
+		if jwt != "valid_jwt":
+			raise HTTPException(status_code=401, detail="Unauthorized")
+
+class HelloWorldView(ValidateUser, BaseView):
+	methods = ["GET"]
+
+	def get(self, name: str = "World"):
+		return {"Hello": name}
+```
+
+**Supported `urls` formats**
+- Dict entries: `{"path": "/x", "view": MyView, ...fastapi kwargs...}` — extra kwargs (e.g. `response_model`) are forwarded to `add_api_route`.
+- Tuple/list entries: `("/x", MyView)`.
+- You may use relative imports from the calling module: `app.include_routers(".src.urls")`.
+
+**`View` classes**
+- Define HTTP methods: `get`, `post`, `put`, `delete`, `patch`.
+- Limit exposed methods with `methods = ["GET"]` on the class.
+- Hooks:
+  - `pre_process(self, ...)` — runs before any handler.
+  - `pre_get(self, ...)`, `pre_post(...)`, ... — run before a specific handler.
+- Signatures from `pre_process`, `pre_<method>` and the handler itself are merged and exposed to FastAPI; annotate parameters with `Annotated[..., Header()]`, `Cookie()`, etc., to appear correctly in `/docs`.
+
+Example: header extraction in `pre_process`:
+```py
+def pre_process(self, jwt: Annotated[str|None, Header()] = None):
+	...
+```
+
+If you accidentally place `Annotated[...]` as a default (e.g. `jwt = Annotated[...]`), ClassApi attempts to normalize it so FastAPI recognizes the dependency. Still, annotate parameters properly when possible.
+
+**Running the app**
+- Use `uv` to run the app with reload during development:
+```bash
+uv run uvicorn tests.app_test.main:app --reload
+```
+or, if you use the helper script `test_init.py` at the repository root:
+```bash
+uv run .\test_init.py
+```
+
+**Debugging endpoint signatures**
+If docs don't show expected parameters, you can inspect endpoint signatures at runtime:
+```py
+for r in app.routes:
+	print(r.path, getattr(r.endpoint, '__signature__', None))
+```
+
+**Editor integration (VSCode / Pylance)**
+Pylance is a static analyzer and doesn't pick up runtime-generated signatures. To get editor hovers that match your runtime docs, create a `.pyi` stub next to your views module describing the public signatures (this does not change runtime behavior).
+
+**Contributing**
+- Open issues or PRs.
+- Add tests under `tests/` and run them with `pytest`.
+
+---
+If you want, I can generate a `views.pyi` stub for your views, add example tests, or add a minimal `pyproject.toml`. Which should I do next?

classapi-0.1.0/classapi.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+classapi/__init__.py
+classapi/classapi.py
+classapi.egg-info/PKG-INFO
+classapi.egg-info/SOURCES.txt
+classapi.egg-info/dependency_links.txt
+classapi.egg-info/requires.txt
+classapi.egg-info/top_level.txt

classapi-0.1.0/classapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

classapi-0.1.0/classapi.egg-info/requires.txt

@@ -0,0 +1 @@
+fastapi[standard]>=0.129.0

classapi-0.1.0/classapi.egg-info/top_level.txt

@@ -0,0 +1 @@
+classapi

classapi-0.1.0/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "classapi"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi[standard]>=0.129.0",
+]

classapi-0.1.0/setup.cfg

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