richapi 0.1.0__tar.gz → 0.2.1__tar.gz

{richapi-0.1.0 → richapi-0.2.1}/.gitignore

@@ -6,6 +6,7 @@ docs/source
 __pycache__/
 *.py[cod]
 *$py.class
+.python_version
 
 # C extensions
 *.so

{richapi-0.1.0 → richapi-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: richapi
-Version: 0.1.0
+Version: 0.2.1
 Summary: Find HTTPExceptions and turn them into documented responses!
 Project-URL: repository, https://github.com/ManiMozaffar/richapi
 Project-URL: Homepage, https://github.com/ManiMozaffar/richapi
@@ -8,8 +8,8 @@ Project-URL: Documentation, https://github.com/ManiMozaffar/richapi
 Project-URL: Source, https://github.com/ManiMozaffar/richapi
 License-Expression: MIT
 Requires-Python: >=3.9
-Requires-Dist: loguru>=0.7.2
-Requires-Dist: typer>=0.12.5
+Requires-Dist: fastapi>=0.105
+Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 
 ### Installation
@@ -28,6 +28,7 @@ See [documentation](https://manimozaffar.github.io/richapi/latest/) for more det
 
 RichAPI is designed to simplify FastAPI projects by automatically generating documented HTTP responses from HTTPException without extra effort! 🎉
 
+This project is inspired and completer version of [Kludex's Fast-Response project](https://github.com/Kludex/fastapi-responses)
 This package is planned to have more features for now that might be essential for any FastAPI project later.
 
 What would you see WITHOUT RichAPI:

{richapi-0.1.0 → richapi-0.2.1}/README.md

@@ -14,6 +14,7 @@ See [documentation](https://manimozaffar.github.io/richapi/latest/) for more det
 
 RichAPI is designed to simplify FastAPI projects by automatically generating documented HTTP responses from HTTPException without extra effort! 🎉
 
+This project is inspired and completer version of [Kludex's Fast-Response project](https://github.com/Kludex/fastapi-responses)
 This package is planned to have more features for now that might be essential for any FastAPI project later.
 
 What would you see WITHOUT RichAPI:

{richapi-0.1.0 → richapi-0.2.1}/docs/advance.md

@@ -34,3 +34,21 @@ class YourException(BaseHTTPException):
 ```
 
 Remember that the responsbility of raising and returning the correct data on FastAPI is not library responsibility, but the responsibility of the developer. The library is only responsible for generating the OpenAPI schema by looking at the functions and classes that are raising exceptions.
+
+### Finding exceptions in other modules
+
+By default, the library only looks at the FastAPI app module to search for exceptions.
+This is to avoid parsing countless dependency modules that are not related to the FastAPI app.
+But sometimes you may be using some other libraries that raises HTTPExceptions.
+For example using a third library for JWT authentication.
+
+In that case, you can simply pass the module name to the `parse_exceptions` function.
+
+```python
+from richapi import enrich_openapi
+from fastapi import FastAPI
+
+app = FastAPI()
+# add your routers ....
+app.openapi = enrich_openapi(app, ["your_module_name", "some-other-package"])
+```

{richapi-0.1.0 → richapi-0.2.1}/docs/conventions.md

@@ -1,4 +1,4 @@
-## Conventions
+# Conventions
 
 This is guideline for how to raise exceptions so that the library can generate the OpenAPI schema from them.
 
@@ -6,7 +6,7 @@ Since the library is a mini compiler using Abstract Syntax Tree and functions gl
 
 Keep in mind that if you don't follow these conventions, there would be alot false positive and false negative cases, and the library may not be able to extract the exceptions and their responses correctly.
 
-### Inherit from `richapi.BaseHTTPException`
+## Inherit from `richapi.BaseHTTPException`
 
 Exceptions are better to be very concrete, without having any dynamic data in them.
 So that using `raise Class` is enough to raise them.
@@ -23,7 +23,11 @@ class UserNotFound(BaseHTTPException):
 
 And then, only writing `raise UserNotFound` is enough to raise the exception. This is most ideal case.
 
-### Avoiding dynamic data in the constructor of the exceptions
+!!! info "Expected Behavior"
+
+    Library **MIGHT skip** adding the exception to the OpenAPI schema if it could not gather necessary and missing informations from the abstract syntax tree.
+
+## Avoiding dynamic data in the constructor of the exceptions and stringifying errors
 
 Exceptions should not have any dynamic data in them.
 For example the code below is NOT ideal:
@@ -35,9 +39,16 @@ error_message = f"User {user_id} is not allowed to perform this action"
 raise FooException(detail=error_message)
 ```
 
+This is not even a good practice to begin with, because ideally your RestAPI should not be aware of what text shown to the user. The error message should be handled by the client, not the server. There is a better way you can do to pass information to client about the error.
+Read the [advance usage](advance.md) section for more information.
+
 Since the library is using static analyzers to extract the exceptions, it is not possible to extract the dynamic data from the exceptions. (or rather very hard to do so)
 
-### Avoiding usage of magic methods
+!!! info "Expected Behavior"
+
+    Library **WILL add** the exception to the OpenAPI schema, but the detail of response won't be precisely shown and instead you will see `str` as the response type. However, if you follow this convention, library exactly show the string that you have written in the `detail` attribute of the exception as a **literal string type**.
+
+## Avoiding usage of magic methods
 
 Magic methods are implicit, therefore extracting them from the abstract syntax tree is exteremly hard and equal to rewriting the Python interpreter.
 
@@ -52,7 +63,11 @@ class Foo:
         raise HTTPException(status_code=400, detail="This is not allowed")
 ```
 
-### Keep it simple
+!!! info "Expected Behavior"
+
+    Library **WILL skip** adding the exception to the OpenAPI schema.
+
+## Keep it simple
 
 The ideal way to raise exceptions is to keep it simple from syntax point of view;
 
@@ -70,3 +85,7 @@ raise exc()(status_code=400, detail="This is not allowed")
 ```
 
 Keep it simple, keep the exception type next to raise keyword; without any dynamic data in the constructor. This help the library to extract the exceptions and their responses and guarantee that they are correctly compiled into the OpenAPI schema.
+
+!!! info "Expected Behavior"
+
+    Library **MIGHT skip** adding the exception to the OpenAPI schema depending on how complicated the exception raising is.

richapi-0.2.1/docs/implementation.md

@@ -0,0 +1,55 @@
+# Implementation detail
+
+Library is made of few components working together to generate the OpenAPI schema.
+
+## Exception Finder
+
+- **Input**: A function
+- **Output**: List of exception type with their `raise` abstract syntax tree nodes
+
+1. Check if this function was ever analyzed before, if yes, then skip.
+2. Get source code of the callable object.
+3. Parse the source code to AST.
+4. Start visiting every node in the callable.
+5. Track assigmnets to a variable.
+6. On visiting a node ...
+   1. If the node is a `raise` statement, then extract the exception type and return as output.
+   2. If a node is a `call` statement, then recursively visit the callable that is being called.
+   3. If a node is an `assign` statement, then track the variable name and the assigned value.
+   4. If a node is an `attribute` statement, then track the attribute name and the parent object. Might have to recursively visit the parent object.
+
+Note that the only way to extract the exception type is to use the tracked assigmnets with `eval` function so that the type is returned.
+That's why it's best to run the library on CLI rather than on the fly. To understand this better look at below code;
+
+```python
+
+def foo():
+    err = Exception
+    raise err
+```
+
+The only way that you can understand err is Exception is to keep tracking the assignments and then use `eval` to get the type. Running `eval("err")` will get you the type of the error which is a requirement to function properly.
+
+## FastAPI Excption Parser
+
+- **Input**: An excpetion with its `raise` AST node
+- **Output**: Json schema
+
+1. Check if the exception type already has a schema defined by itself.
+   - If yes, then simply construct the Json schema from that.
+   - If not, continue to the next step.
+2. Analyze and extract arg and kwargs from the `raise` AST node.
+3. Try to construct the exception schema from the arguments.
+4. Try to dynamically generate the schema using Pydantic.
+5. Return the schema if successfully generated, otherwise return None.
+
+## OpenAPI Generator
+
+- **Input**: FastAPI Module, Previous OpenAPI schema
+- **Output**: OpenAPI schema
+
+1. Iterating over all fastapi routers to analyze each at a time.
+2. Each router has few callable dependency. All callable dependencies are analyzed using `Exception Finder`.
+3. Result of the `Exception Finder` is passed to the `FastAPI Excption Parser` to get the Json schema.
+4. Using the Json schema, the OpenAPI schema is extended with new responses for that router.
+5. The result is cached so that the same router is not analyzed again.

{richapi-0.1.0 → richapi-0.2.1}/docs/index.md

@@ -8,8 +8,8 @@ pip install richapi
 
 ### Usage
 
-**RichAPI is designed to simplify FastAPI projects by automatically generating documented HTTP responses from HTTPException without extra effort! 🎉
-**
+RichAPI is designed to simplify FastAPI projects by automatically generating documented HTTP responses from HTTPException without extra effort! 🎉
+
 This package is planned to have more features for now that might be essential for any FastAPI project later.
 
 There are multiple way you can do that,

{richapi-0.1.0 → richapi-0.2.1}/mkdocs.yml

@@ -103,3 +103,4 @@ nav:
       - Welcome: index.md
       - Conventions: conventions.md
       - Advance Usage: advance.md
+      - Implemenetion Detail: implementation.md

{richapi-0.1.0 → richapi-0.2.1}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "richapi"
-version = "0.1.0"
+version = "0.2.1"
 description = "Find HTTPExceptions and turn them into documented responses!"
 readme = "README.md"
 requires-python = ">=3.9"
-dependencies = ["loguru>=0.7.2", "typer>=0.12.5"]
+dependencies = ["typer>=0.12", "fastapi>=0.105"]
 license = 'MIT'
 
 [project.urls]
@@ -44,7 +44,6 @@ dev-dependencies = [
     "mkdocstrings[python]>=0.25.1",
     "mkdocs-simple-hooks>=0.1.5",
     "mkdocs-material-extensions>=1.3.1",
-    "fastapi>=0.115.0",
     "mdx-truly-sane-lists>=1.3",
     "mike==2.0.0",
     "psutil>=6.0.0",

richapi-0.2.1/richapi/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

{richapi-0.1.0 → richapi-0.2.1}/richapi/exc_parser/compiler.py

@@ -60,7 +60,7 @@ def is_in_module(module: str, target_modules: list[str]) -> bool:
 
 def find_explicit_exceptions(
     func: Callable,
-    target_modules: Union[list[str], str],
+    target_modules: list[str],
     should_search_module_pred: Union[Callable[[str], bool], None] = None,
 ) -> List[Tuple[Optional[type[Exception]], ast.Raise]]:
     """
@@ -73,9 +73,6 @@ def find_explicit_exceptions(
             - The ast.Raise node
     """
 
-    if isinstance(target_modules, str):
-        target_modules = [target_modules]
-
     if should_search_module_pred is None:
 
         def should_search_module_pred_func(target):
@@ -83,21 +80,51 @@ def find_explicit_exceptions(
 
         should_search_module_pred = should_search_module_pred_func
 
+    return _find_explicit_expection_recursively(func, should_search_module_pred)
+
+
+def get_func_name(func: Callable) -> str:
+    return func.__name__ if hasattr(func, "__name__") else func.__str__()
+
+
+def _find_all_class_exceptions(
+    cls: type,
+    to_filter_predicate: Callable[[str], bool],
+    tree: Optional[ast.AST] = None,
+):
     try:
-        source = inspect.getsource(func)
-    except (OSError, TypeError):
-        raise Exception(func)
+        tree = tree or ast.parse(inspect.getsource(cls))
+    except Exception as error:
+        logger.exception(f"Failed to parse source code for {cls.__name__}.", exc_info=error)
+        return []
+
+    result = _find_explicit_expection_recursively(cls.__init__, to_filter_predicate, tree)
+    if hasattr(cls, "__call__"):
+        # Not sure if __call__ was called or init, so check for both
 
-    tree = ast.parse(source)
+        result.extend(
+            _find_explicit_expection_recursively(
+                cls.__call__,  # type: ignore
+                to_filter_predicate,
+                tree,
+            )
+        )
 
-    return _find_explicit_expection_recursively(func, tree, should_search_module_pred)
+    ExceptionFinder.visited = set()  # clean up memory
+    return result
+
+
+def is_absolutely_callable_object(obj: Callable) -> bool:
+    return (
+        inspect.isclass(type(obj)) and (not inspect.isfunction(obj)) and (not inspect.ismethod(obj))
+    )
 
 
 def _find_explicit_expection_recursively(
     func_obj: Callable,
-    expr: ast.AST,
     to_filter_predicate: Callable[[str], bool],
-):
+    tree: Optional[ast.AST] = None,
+) -> list[tuple[Optional[type[Exception]], ast.Raise]]:
     if func_obj in ExceptionFinder.visited:
         return []
 
@@ -108,9 +135,42 @@ def _find_explicit_expection_recursively(
     if module and to_filter_predicate(module.__name__) is False:
         return []
 
-    finder = ExceptionFinder(func_obj, to_filter_predicate)
-    finder.visit(expr)
+    if is_absolutely_callable_object(func_obj):
+        cls_module = inspect.getmodule(type(func_obj))
+        if cls_module and is_stdlib(cls_module.__name__):
+            return []
+        if cls_module and to_filter_predicate(cls_module.__name__) is False:
+            return []
+
+        return _find_all_class_exceptions(type(func_obj), to_filter_predicate, tree)
+
     ExceptionFinder.visited.add(func_obj)
+
+    if tree is None:
+        try:
+            source = inspect.getsource(func_obj)
+        except (OSError, TypeError) as error:
+            logger.exception(
+                f"Failed to get source code for {get_func_name(func_obj)}.",
+                exc_info=error,
+            )
+            return []
+
+        try:
+            tree = ast.parse(source)
+        except IndentationError as error:
+            logger.exception(
+                f"Failed to get source code for {get_func_name(func_obj)}.",
+                exc_info=error,
+            )
+            return []
+
+    finder = ExceptionFinder(func_obj, to_filter_predicate)
+    try:
+        finder.visit(tree)
+    except Exception as error:
+        logger.exception(f"Failed to analyze function {get_func_name(func_obj)}.", exc_info=error)
+
     return finder.exceptions
 
 
@@ -187,9 +247,7 @@ def _resolve_function_from_call_node(
     elif isinstance(node, ast.Attribute):
         attr_chain = _resolve_full_attribute_path(node)
         if attr_chain is None:
-            logger.debug(
-                f"Failed to get full attribute name: {ast.dump(node)} in {func.__name__}"
-            )
+            logger.debug(f"Failed to get full attribute name: {ast.dump(node)} in {func.__name__}")
             return None
 
         try:
@@ -209,12 +267,9 @@ def _resolve_function_from_call_node(
                 parent_attr = assignments.get(node_id, None)
 
             if parent_attr is None:
-                if (
-                    parent_part == "self"
-                ):  # don't need to log -> we already know this is class
+                if parent_part == "self":  # don't need to log -> we already know this is class
                     return None
 
-                print(attr_chain, parent_part)
                 logger.debug(
                     f"Failed to resolve parent attribute {parent_part} for parts {attr_chain}. Chain: {ast.dump(node)} for func {func.__name__}"
                 )
@@ -240,9 +295,7 @@ def _extract_node_name(
     Extract the exception name a node recursively.
     """
     if isinstance(node, ast.Call):
-        return _extract_node_name(
-            typing.cast(SupportedAstNodes, node.func), assignments
-        )
+        return _extract_node_name(typing.cast(SupportedAstNodes, node.func), assignments)
     elif isinstance(node, ast.Name):
         var_name = get_node_identifier(node)
         return assignments.get(var_name, var_name)
@@ -250,9 +303,7 @@ def _extract_node_name(
         return _resolve_full_attribute_path(node)
 
     elif isinstance(node, ast.Await):
-        return _extract_node_name(
-            typing.cast(SupportedAstNodes, node.value), assignments
-        )
+        return _extract_node_name(typing.cast(SupportedAstNodes, node.value), assignments)
 
     elif isinstance(
         node,
@@ -300,10 +351,8 @@ def is_stdlib(module_name: str) -> bool:
 class ExceptionFinder(ast.NodeVisitor):
     visited: set[Callable] = set()
 
-    def __init__(
-        self, func: Callable, should_search_module_pred: Callable[[str], bool]
-    ):
-        self.exceptions: List[Tuple[Optional[type[Exception]], ast.Raise]] = []
+    def __init__(self, func: Callable, should_search_module_pred: Callable[[str], bool]):
+        self.exceptions: list[tuple[Optional[type[Exception]], ast.Raise]] = []
         self.assignments: dict[NodeIdentifier, str] = {}
         self.func = func
         self.func_globals = func.__globals__
@@ -420,19 +469,24 @@ class ExceptionFinder(ast.NodeVisitor):
                 return
 
             source = inspect.getsource(module)
-            tree = ast.parse(source)
+            try:
+                tree = ast.parse(source)
+            except BaseException as error:
+                logger.exception(
+                    f"Failed to parse source code for {func_obj.__name__}.",
+                    exc_info=error,
+                )
+                self.generic_visit(node)
+                return
 
-            founded_func = _find_in_module(
+            founded_func_ast = _find_in_module(
                 tree,
-                lambda n: (
-                    isinstance(n, ast.AsyncFunctionDef)
-                    or isinstance(n, ast.FunctionDef)
-                )
+                lambda n: (isinstance(n, ast.AsyncFunctionDef) or isinstance(n, ast.FunctionDef))
                 and n.name == func_obj.__name__,
             )
-            if founded_func:
+            if founded_func_ast:
                 excs = _find_explicit_expection_recursively(
-                    func_obj, founded_func, self.should_search_module_pred
+                    func_obj, self.should_search_module_pred, founded_func_ast
                 )
                 self.exceptions.extend(excs)
             else:
@@ -455,9 +509,7 @@ class ExceptionFinder(ast.NodeVisitor):
             try:
                 caller_type = _exctact_type(caller_node_name, self.func_globals)
             except Exception:
-                logger.critical(
-                    f"Failed to resolve attribute chain: {caller_node_name}"
-                )
+                logger.critical(f"Failed to resolve attribute chain: {caller_node_name}")
                 self.generic_visit(node)
                 return
 
@@ -476,18 +528,26 @@ class ExceptionFinder(ast.NodeVisitor):
                 return
 
             source = inspect.getsource(module)
-            tree = ast.parse(source)
+            try:
+                tree = ast.parse(source)
+            except BaseException as error:
+                logger.exception(
+                    f"Failed to parse source code for {caller_type.__name__}.",
+                    exc_info=error,
+                )
+                self.generic_visit(node)
+                return
+
             cls_ast = _find_in_module(
                 tree,
-                lambda n: isinstance(n, ast.ClassDef)
-                and n.name == caller_type.__name__,
+                lambda n: isinstance(n, ast.ClassDef) and n.name == caller_type.__name__,
             )
             if cls_ast:
                 casted_cls_ast = typing.cast(ast.ClassDef, cls_ast)
-                submethod = _find_method_node_in_cls(casted_cls_ast, node.attr)
-                if submethod:
+                submethod_ast = _find_method_node_in_cls(casted_cls_ast, node.attr)
+                if submethod_ast:
                     excs = _find_explicit_expection_recursively(
-                        method_func, submethod, self.should_search_module_pred
+                        method_func, self.should_search_module_pred, submethod_ast
                     )
                     self.exceptions.extend(excs)
 

{richapi-0.1.0 → richapi-0.2.1}/richapi/exc_parser/openapi.py

@@ -44,12 +44,15 @@ def enrich_openapi(
 ) -> Callable:
     if target_module is None:
         target_module = _find_module_name_where_app_defined_in(app)
+
         if target_module is None or target_module == "__main__":
             raise BaseRichAPIException(
                 "Could not determine the module where the FastAPI instance was created.\n"
                 "Please provide the module name as a string or list of strings."
             )
 
+        target_module = target_module.split(".")[0]  # get the top-level module
+
     def _custom_openapi() -> dict:
         if app.openapi_schema:  # pragma: no cover
             return app.openapi_schema
@@ -72,6 +75,9 @@ def compile_openapi_from_fastapi(
         routes=app.routes,
     ),
 ) -> dict:
+    target_module = [target_module] if isinstance(target_module, str) else target_module
+    target_module.append("fastapi")
+
     openapi_schema = open_api_getter(app)
     for route in app.routes:
         if not isinstance(route, APIRoute):
@@ -209,6 +215,8 @@ def _fill_openapi_with_excpetions(
     route: APIRoute,
     exceptions: list[tuple[type[StarletteHTTPException], ast.Raise]],
 ) -> None:
+    added_schema_names = set()
+
     for exc, ast_node in exceptions:
         if hasattr(exc, "get_json_schema"):
             casted_exc = typing.cast(type[BaseHTTPException], exc)
@@ -216,9 +224,11 @@ def _fill_openapi_with_excpetions(
         else:
             schema = _extract_json_schema(ast_node, exc)
 
-        if schema is None:
+        if schema is None or schema.schema_name in added_schema_names:
             continue
 
+        added_schema_names.add(schema.schema_name)
+
         str_status_code = str(schema.status_code)
         component_schemas = api_schema.get("components", {}).get("schemas", {})
         if schema.schema_name not in component_schemas:
@@ -290,7 +300,7 @@ def flatten(to_be_flatten: list[list[T]]) -> list[T]:
 
 
 def _extract_starlette_exceptions(
-    route: APIRoute, target_module: Union[list[str], str]
+    route: APIRoute, target_module: list[str]
 ) -> list[tuple[type[StarletteHTTPException], ast.Raise]]:
     dependency_tree = build_dependency_tree(route.dependant)
     exceptions = flatten(

{richapi-0.1.0 → richapi-0.2.1}/richapi/exc_parser/protocol.py

@@ -27,12 +27,27 @@ class BaseHTTPException(HTTPException):
     @classmethod
     def get_json_schema(cls) -> HTTPExceptionSchema:
         value = _generic_json_schema_builder(cls)
-        assert (
-            value is not None
-        )  # should never happen because status code is always set
+        assert value is not None  # should never happen because status code is always set
         return value
 
 
+def try_to_camel_case(string: str) -> str:
+    final_str = string
+    if " " in final_str:  # with space
+        components = string.split(" ")
+        final_str = components[0] + "".join(x.title() for x in components[1:])
+
+    if "_" in final_str:  # snake case
+        components = string.split("_")
+        final_str = components[0] + "".join(x.title() for x in components[1:])
+
+    if "-" in final_str:  # kebab case
+        components = string.split("-")
+        final_str = components[0] + "".join(x.title() for x in components[1:])
+
+    return final_str
+
+
 def _generic_json_schema_builder(
     cls: type[Exception],
     detail: str | None = None,
@@ -51,6 +66,8 @@ def _generic_json_schema_builder(
 
     if detail is not None:
         detail_type = Literal[detail]  # type: ignore
+
+        name = f"{try_to_camel_case(detail)}Schema"
     else:
         detail_type = str
 

{richapi-0.1.0 → richapi-0.2.1}/tests/test_exc_raising_cases.py

@@ -1,5 +1,4 @@
 import logging
-import sys
 from functools import lru_cache
 
 from fastapi import Depends, FastAPI, HTTPException, status
@@ -10,12 +9,8 @@ from richapi.exc_parser.protocol import BaseHTTPException
 
 app = FastAPI()
 
-root = logging.getLogger()
-root.setLevel(logging.DEBUG)
 
-handler = logging.StreamHandler(sys.stdout)
-handler.setLevel(logging.DEBUG)
-root.addHandler(handler)
+logging.getLogger().addHandler(logging.StreamHandler())
 
 
 class FirstException(HTTPException): ...
@@ -104,12 +99,3 @@ def test_case():
     assert "407" in home_responses
     assert "408" in home_responses
     assert "409" in home_responses
-    schemas = openapi_json["components"]["schemas"]
-    assert "SecondExceptionErrorSchema" in schemas
-    assert "ThirdExceptionErrorSchema" in schemas
-    assert "FourthExceptionErrorSchema" in schemas
-    assert "FifthExceptionErrorSchema" in schemas
-    assert "SixthExceptionErrorSchema" in schemas
-    assert "NoNeedParanthesisErrorSchema" in schemas
-    assert "SeventhExceptionErrorSchema" in schemas
-    assert "EighthExceptionErrorSchema" in schemas

richapi-0.2.1/tests/test_fastapi_auth_functions.py

@@ -0,0 +1,30 @@
+import fastapi
+import fastapi.security
+
+from richapi.exc_parser.openapi import compile_openapi_from_fastapi
+
+app = fastapi.FastAPI()
+
+
+http_bearer = fastapi.security.HTTPBearer()
+
+
+def get_at_11(
+    token: fastapi.security.HTTPAuthorizationCredentials = fastapi.Depends(http_bearer),
+) -> str:
+    return "12312"
+
+
+@app.get("/refresh")
+async def refresh_token(
+    token_data: str = fastapi.Depends(get_at_11),
+) -> None:
+    pass
+
+
+def test_fastapi_call_detected():
+    openapi_json = compile_openapi_from_fastapi(
+        app, target_module="tests.test_fastapi_auth_functions"
+    )
+    home_responses = openapi_json["paths"]["/refresh"]["get"]["responses"]
+    assert "403" in home_responses

{richapi-0.1.0 → richapi-0.2.1}/uv.lock

@@ -327,19 +327,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/31/80/3a54838c3fb461f6fec263ebf3a3a41771bd05190238de3486aae8540c36/jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d", size = 133271 },
 ]
 
-[[package]]
-name = "loguru"
-version = "0.7.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "win32-setctime", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9e/30/d87a423766b24db416a46e9335b9602b054a72b96a88a241f2b09b560fa8/loguru-0.7.2.tar.gz", hash = "sha256:e671a53522515f34fd406340ee968cb9ecafbc4b36c679da03c18fd8d0bd51ac", size = 145103 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/0a/4f6fed21aa246c6b49b561ca55facacc2a44b87d65b8b92362a8e99ba202/loguru-0.7.2-py3-none-any.whl", hash = "sha256:003d71e3d3ed35f0f8984898359d65b79e5b21943f78af86aa5491210429b8eb", size = 62549 },
-]
-
 [[package]]
 name = "markdown"
 version = "3.7"
@@ -1071,13 +1058,12 @@ name = "richapi"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
-    { name = "loguru" },
+    { name = "fastapi" },
     { name = "typer" },
 ]
 
 [package.dev-dependencies]
 dev = [
-    { name = "fastapi" },
     { name = "httpx" },
     { name = "mdx-truly-sane-lists" },
     { name = "mike" },
@@ -1098,13 +1084,12 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "loguru", specifier = ">=0.7.2" },
-    { name = "typer", specifier = ">=0.12.5" },
+    { name = "fastapi", specifier = ">=0.105" },
+    { name = "typer", specifier = ">=0.12" },
 ]
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "fastapi", specifier = ">=0.115.0" },
     { name = "httpx", specifier = ">=0.27.2" },
     { name = "mdx-truly-sane-lists", specifier = ">=1.3" },
     { name = "mike", specifier = "==2.0.0" },
@@ -1326,15 +1311,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/38/b8/0aa69337651b3005f161f7f494e59188a1d8d94171666900d26d29d10f69/watchdog-5.0.3-py3-none-win_ia64.whl", hash = "sha256:49f4d36cb315c25ea0d946e018c01bb028048023b9e103d3d3943f58e109dd45", size = 79324 },
 ]
 
-[[package]]
-name = "win32-setctime"
-version = "1.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6b/dd/f95a13d2b235a28d613ba23ebad55191514550debb968b46aab99f2e3a30/win32_setctime-1.1.0.tar.gz", hash = "sha256:15cf5750465118d6929ae4de4eb46e8edae9a5634350c01ba582df868e932cb2", size = 3676 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0a/e6/a7d828fef907843b2a5773ebff47fb79ac0c1c88d60c0ca9530ee941e248/win32_setctime-1.1.0-py3-none-any.whl", hash = "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad", size = 3604 },
-]
-
 [[package]]
 name = "zipp"
 version = "3.20.2"

richapi-0.1.0/.python-version

@@ -1 +0,0 @@
-3.9.19

richapi-0.1.0/richapi/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"