richapi 0.3.0__tar.gz → 0.3.2__tar.gz

{richapi-0.3.0 → richapi-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: richapi
-Version: 0.3.0
+Version: 0.3.2
 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

{richapi-0.3.0 → richapi-0.3.2}/docs/conventions.md

@@ -89,3 +89,29 @@ Keep it simple, keep the exception type next to raise keyword; without any dynam
 !!! info "Expected Behavior"
 
     Library **MIGHT skip** adding the exception to the OpenAPI schema depending on how complicated the exception raising is.
+
+## Always Provide Type Annotations For Class/Instance Attributes And Function Arguments
+
+To enable accurate type resolution during static analysis, always provide type annotations for your variables, function parameters, and return types. Without type annotations, it's nearly impossible for the library to infer types correctly, which may lead to false positives or negatives. That stands for class attributes and function arguments.
+
+Example:
+
+```Python hl_lines="6 12"
+class Foo:
+    def foo(self) -> None:
+        raise HTTPException(status_code=400, detail="This is not allowed")
+
+class Baz:
+    foo: Foo # this is very important to have type annotations for class/instance attributes
+
+    def __init__(self, foo: Foo):
+        self.foo = foo
+
+    def foo(self) -> None:
+        # if you don't type annotate, RichAPI doesn't have any idea about the type of self.fo
+        self.foo.foo()
+```
+
+!!! info "Expected Behavior"
+
+    Library **WILL skip** adding exceptions to the OpenAPI schema if it cannot resolve types due to missing annotations.

{richapi-0.3.0 → richapi-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "richapi"
-version = "0.3.0"
+version = "0.3.2"
 description = "Find HTTPExceptions and turn them into documented responses!"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -19,6 +19,7 @@ build-backend = "hatchling.build"
 
 [tool.pytest.ini_options]
 asyncio_default_fixture_loop_scope = "session"
+addopts = "--log-level=DEBUG -v"
 
 [tool.pyright]
 typeCheckingMode = "standard"

richapi-0.3.2/richapi/__version__.py

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

{richapi-0.3.0 → richapi-0.3.2}/richapi/exc_parser/compiler.py

@@ -4,9 +4,11 @@ import inspect
 import logging
 import sysconfig
 import typing
-from functools import lru_cache
 from importlib.util import find_spec
-from typing import Callable, List, NewType, Optional, Tuple, Union
+from types import ModuleType
+from typing import Annotated, Callable, Generic, List, NewType, Optional, Tuple, Union
+
+import typing_extensions
 
 logger = logging.getLogger(__name__)
 
@@ -58,6 +60,22 @@ def is_in_module(module: str, target_modules: list[str]) -> bool:
     return False
 
 
+def _get_tree(obj: Callable):
+    to_search = obj
+    if is_absolutely_callable_object(obj):
+        to_search: Union[type, Callable] = (
+            obj_type if (obj_type := type(obj)) is not type else obj
+        )
+
+    try:
+        tree = ast.parse(inspect.getsource(to_search))
+        return tree
+    except Exception as error:
+        obj_name = obj.__name__ if hasattr(obj, "__name__") else obj.__str__()
+        logger.debug(f"Failed to parse source code for {obj_name}", exc_info=error)
+        return None
+
+
 def find_explicit_exceptions(
     func: Callable,
     target_modules: list[str],
@@ -80,7 +98,15 @@ def find_explicit_exceptions(
 
         should_search_module_pred = should_search_module_pred_func
 
-    return _find_explicit_expection_recursively(func, should_search_module_pred)
+    module = inspect.getmodule(func)
+    if module is None or _should_be_visited(module, should_search_module_pred) is False:
+        return []
+
+    tree = _get_tree(func)
+    if tree is None:
+        return []
+
+    return _find_explicit_expection_recursively(func, should_search_module_pred, tree)
 
 
 def get_func_name(func: Callable) -> str:
@@ -88,32 +114,57 @@ def get_func_name(func: Callable) -> str:
 
 
 def _find_all_class_exceptions(
-    cls: type,
+    cls: Union[type, Callable],
     to_filter_predicate: Callable[[str], bool],
-    tree: Optional[ast.AST] = None,
 ):
+    cls_module = inspect.getmodule(cls)
+    if cls_module and is_stdlib(cls_module.__name__):
+        return []
+    if cls_module and to_filter_predicate(cls_module.__name__) is False:
+        return []
+
     try:
-        tree = tree or ast.parse(inspect.getsource(cls))
+        cls_tree = ast.parse(inspect.getsource(cls))
     except Exception as error:
-        logger.exception(
-            f"Failed to parse source code for {cls.__name__}.", exc_info=error
+        cls_name = cls.__name__ if hasattr(cls, "__name__") else cls.__str__()
+        logger.info(
+            f"Failed to parse source code for {cls_name}.__init__", exc_info=error
         )
         return []
 
-    result = _find_explicit_expection_recursively(
-        cls.__init__, to_filter_predicate, tree
+    init_tree = _find_in_module(
+        cls_tree,
+        lambda n: (
+            isinstance(n, ast.AsyncFunctionDef) or isinstance(n, ast.FunctionDef)
+        )
+        and n.name == "__init__",
     )
-    if hasattr(cls, "__call__"):
-        # Not sure if __call__ was called or init, so check for both
 
+    result: list[tuple[Optional[type[Exception]], ast.Raise]] = []
+    if init_tree is not None:
         result.extend(
             _find_explicit_expection_recursively(
-                cls.__call__,  # type: ignore
-                to_filter_predicate,
-                tree,
+                cls.__init__, to_filter_predicate, init_tree
+            )
+        )
+
+    if hasattr(cls, "__call__"):
+        # Not sure if __call__ was called or init, so check for both
+        call_tree = _find_in_module(
+            cls_tree,
+            lambda n: (
+                isinstance(n, ast.AsyncFunctionDef) or isinstance(n, ast.FunctionDef)
             )
+            and n.name == "__call__",
         )
 
+        if call_tree is not None:
+            result.extend(
+                _find_explicit_expection_recursively(
+                    getattr(cls, "__call__"), to_filter_predicate, call_tree
+                )
+            )
+
     return result
 
 
@@ -128,47 +179,20 @@ def is_absolutely_callable_object(obj: Callable) -> bool:
 def _find_explicit_expection_recursively(
     func_obj: Callable,
     to_filter_predicate: Callable[[str], bool],
-    tree: Optional[ast.AST] = None,
+    tree: ast.AST,
 ) -> list[tuple[Optional[type[Exception]], ast.Raise]]:
     if func_obj in ExceptionFinder.visited:
-        return []
+        return ExceptionFinder.visited[func_obj]
 
     module = inspect.getmodule(func_obj)
-    if module and is_stdlib(module.__name__):
-        return []
-
-    if module and to_filter_predicate(module.__name__) is False:
+    if module is None or _should_be_visited(module, to_filter_predicate) is False:
         return []
 
     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 []
+        class_type: Union[type, Callable] = (
+            obj_type if (obj_type := type(func_obj)) is not type else func_obj
+        )
+        return _find_all_class_exceptions(class_type, to_filter_predicate)
 
     finder = ExceptionFinder(func_obj, to_filter_predicate)
     try:
@@ -178,6 +202,7 @@ def _find_explicit_expection_recursively(
             f"Failed to analyze function {get_func_name(func_obj)}.", exc_info=error
         )
 
+    ExceptionFinder.visited[func_obj] = finder.exceptions
     return finder.exceptions
 
 
@@ -227,12 +252,52 @@ def _resolve_full_attribute_path(node: ast.AST) -> Union[str, None]:
     return None
 
 
-def _resolve_function_from_call_node(
+def _retrieve_from_annotations(func: Callable, var_name: str) -> Optional[type]:
+    result = func.__annotations__.get(var_name, None)
+    if result is None:
+        return None
+
+    origin = typing.get_origin(result)
+    if origin is Annotated:
+        return result.__origin__
+    elif origin is not None and origin != Generic:
+        return origin
+    return result
+
+
+def _resolve_type_from_assigment(
+    resolved_value: Union[str, type, None],
+    assignments: dict[NodeIdentifier, str],
+    func: Callable,
+):
+    if resolved_value is None:
+        return None
+
+    # because assigment are stored as string
+    # ! A string type could be also called like str("Foo").lower() so we fallback to parent_attr in case it remains as string
+
+    if isinstance(resolved_value, str):
+        resolved_value = func.__globals__.get(resolved_value, resolved_value)
+
+    if isinstance(resolved_value, str):
+        resolved_value = assignments.get(NodeIdentifier(resolved_value), resolved_value)
+
+    if isinstance(resolved_value, str):
+        resolved_value = (
+            _retrieve_from_annotations(func, resolved_value) or resolved_value
+        )
+
+    if isinstance(resolved_value, str):  # last fallback
+        resolved_value = _exctact_type(resolved_value, func.__globals__)
+
+    return resolved_value
+
+
+def _resolve_functions_from_call_node(
     call_node: ast.Call,
-    func_globals: dict,
     func: Callable,
     assignments: dict[NodeIdentifier, str],
-):
+) -> list[type]:
     """
     Attempt to resolve the function object from a call node.
     Handles both simple function calls and method calls.
@@ -241,7 +306,7 @@ def _resolve_function_from_call_node(
 
     if isinstance(node, ast.Name):
         # Simple function call: func()
-        value = func_globals.get(node.id, None)
+        value = func.__globals__.get(node.id, None)
 
         if value is None:
             value = getattr(builtins, node.id, None)
@@ -249,7 +314,9 @@ def _resolve_function_from_call_node(
         if value is None:
             logger.debug(f"Function '{node.id}' not found in {func.__name__}")
 
-        return value
+        if value is not None:
+            return [value]
+        return []
 
     elif isinstance(node, ast.Attribute):
         attr_chain = _resolve_full_attribute_path(node)
@@ -257,46 +324,85 @@ def _resolve_function_from_call_node(
             logger.debug(
                 f"Failed to get full attribute name: {ast.dump(node)} in {func.__name__}"
             )
-            return None
+            return []
 
         try:
             parts = attr_chain.split(".")
             parent_part = parts[0]
 
-            parent_attr = func_globals.get(parent_part, None)
-
-            if parent_attr is None:
-                if parent_part in func.__annotations__:
-                    return func.__annotations__[parent_part]
-
-                parent_attr = getattr(builtins, parent_part, None)
+            parent_attr = func.__globals__.get(parent_part, None)
 
             if parent_attr is None:
                 node_id = NodeIdentifier(parent_part)
                 parent_attr = assignments.get(node_id, None)
 
+            if parent_attr is None and parent_part in func.__annotations__:
+                parent_attr = _retrieve_from_annotations(func, parent_part)
+
             if parent_attr is None:
-                if (
-                    parent_part == "self"
-                ):  # don't need to log -> we already know this is class
-                    return None
+                # use case where you're calling self.foo.do_something(), where self.foo is a class attribute that is a class itself
+                if parent_part == "self" or parent_part == "cls":
+                    property_name = parts[1]
+                    # ['class_name', 'method_name']
+                    qual_names = func.__qualname__.split(".")
+                    # ['class_name']
+                    func_name_index = qual_names.index(func.__name__)
+                    # 'class_name'
+                    cls_name = qual_names[func_name_index - 1]
+                    # class_name (type)
+                    cls: Union[Callable, None] = func.__globals__.get(cls_name, None)
+
+                    if cls is None:
+                        logger.debug(
+                            f"Failed to resolve parent class {cls} for parts {attr_chain}. Chain: {ast.dump(node)} for func {func.__name__}"
+                        )
+                        return []
+                    attr_class = _retrieve_from_annotations(cls, property_name)
+                    if attr_class is None:  # part of convention
+                        return []
+
+                    results: list[type] = []
+                    try:
+                        obj = getattr(attr_class, "__init__", None)
+                        if obj is not None:
+                            results.append(obj)
+                    except Exception:
+                        pass
+
+                    for attr in parts[2:]:
+                        try:
+                            obj = getattr(attr_class, attr, None)
+
+                            if obj is not None:
+                                results.append(obj)
+                        except Exception:
+                            break
+
+                    return results
 
                 logger.debug(
                     f"Failed to resolve parent attribute {parent_part} for parts {attr_chain}. Chain: {ast.dump(node)} for func {func.__name__}"
                 )
-                return None
+                return []
 
+            parent_attr = _resolve_type_from_assigment(parent_attr, assignments, func)
+            results: list[type] = []
             for attr in parts[1:]:
                 try:
                     obj = getattr(parent_attr, attr, None)
+                    if obj is not None:
+                        results.append(obj)
+
                 except Exception:
                     break
 
-                return obj
+            return results
 
         except Exception:
             logger.exception(f"Failed to resolve attribute chain: {attr_chain}")
-            return None
+            return []
+
+    return []
 
 
 def _extract_node_name(
@@ -349,7 +455,19 @@ def _exctact_type(var_tyep: str, func_globals: dict) -> Optional[type]:
         logger.exception(f"Failed to resolve variable type: {var_tyep}")
 
 
-@lru_cache
+def _should_be_visited(
+    module: ModuleType,
+    should_search_module_pred: Callable[[str], bool],
+):
+    if (
+        is_stdlib(module.__name__)
+        or should_search_module_pred(module.__name__) is False
+    ):
+        return False
+
+    return True
+
+
 def is_stdlib(module_name: str) -> bool:
     """Check if a given module is part of the Python standard library."""
     try:
@@ -364,17 +482,26 @@ def is_stdlib(module_name: str) -> bool:
 
 
 class ExceptionFinder(ast.NodeVisitor):
-    visited: set[Callable] = set()
+    visited: dict[Callable, 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.cached_assignments[func] = self.assignments
         self.func = func
-        self.func_globals = func.__globals__
         self.should_search_module_pred = should_search_module_pred
-        logger.info(f"Analyzing function {func.__name__}")
+        logger.debug(f"Analyzing function {func.__name__}")
+
+    @classmethod
+    def clear_cache(cls):
+        cls.visited.clear()
+
+    def _should_be_visited(
+        self, module: ModuleType
+    ) -> typing_extensions.TypeGuard[ModuleType]:
+        return _should_be_visited(module, self.should_search_module_pred)
 
     def visit_Assign(self, node):
         """
@@ -401,10 +528,11 @@ class ExceptionFinder(ast.NodeVisitor):
 
         for target in targets:
             if isinstance(target, ast.Name):
-                var_identifier = get_node_identifier(target)
-                var_name = _extract_node_name(value, self.assignments)
-                if var_name is not None:
-                    self.assignments[var_identifier] = var_name
+                var_name = get_node_identifier(target)
+                var_result = _extract_node_name(value, self.assignments)
+
+                if var_result is not None:
+                    self.assignments[var_name] = var_result
 
                 else:
                     # no need to log here. it would be very spammy
@@ -457,7 +585,7 @@ class ExceptionFinder(ast.NodeVisitor):
             logger.debug(f"Failed to get exception name: {ast.dump(node)}")
             return
 
-        exc_type = _exctact_type(exc_variable_name, self.func_globals)
+        exc_type = _exctact_type(exc_variable_name, self.func.__globals__)
 
         if exc_type:
             self.exceptions.append((exc_type, node))
@@ -469,50 +597,47 @@ class ExceptionFinder(ast.NodeVisitor):
         """
         Handle function calls and recursively analyze called functions.
         """
-        func_obj = _resolve_function_from_call_node(
-            node, self.func_globals, self.func, self.assignments
-        )
-        if func_obj and inspect.isfunction(func_obj):
-            module = inspect.getmodule(func_obj)
-            if not module:
-                self.generic_visit(node)
-                return
-
-            if (
-                is_stdlib(module.__name__)
-                or self.should_search_module_pred(module.__name__) is False
-            ):
-                self.generic_visit(node)
-                return
-
-            source = inspect.getsource(module)
-            try:
-                tree = ast.parse(source)
-            except BaseException as error:
-                logger.exception(
-                    f"Failed to parse source code for {func_obj.__name__}.",
-                    exc_info=error,
+        func_objs = _resolve_functions_from_call_node(node, self.func, self.assignments)
+        for func_obj in func_objs:
+            if inspect.isfunction(func_obj):
+                module = inspect.getmodule(func_obj)
+                if module is None or self._should_be_visited(module) is False:
+                    continue
+
+                source = inspect.getsource(module)
+                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_ast = _find_in_module(
+                    tree,
+                    lambda n: (
+                        isinstance(n, ast.AsyncFunctionDef)
+                        or isinstance(n, ast.FunctionDef)
+                    )
+                    and n.name == func_obj.__name__,
                 )
-                self.generic_visit(node)
-                return
+                if founded_func_ast:
+                    excs = _find_explicit_expection_recursively(
+                        func_obj, self.should_search_module_pred, founded_func_ast
+                    )
+                    self.exceptions.extend(excs)
+                else:
+                    logger.debug(
+                        f"Failed to find function {func_obj.__name__} in module {module.__name__}"
+                    )
 
-            founded_func_ast = _find_in_module(
-                tree,
-                lambda n: (
-                    isinstance(n, ast.AsyncFunctionDef)
-                    or isinstance(n, ast.FunctionDef)
-                )
-                and n.name == func_obj.__name__,
-            )
-            if founded_func_ast:
-                excs = _find_explicit_expection_recursively(
-                    func_obj, self.should_search_module_pred, founded_func_ast
-                )
-                self.exceptions.extend(excs)
-            else:
-                logger.debug(
-                    f"Failed to find function {func_obj.__name__} in module {module.__name__}"
+            elif inspect.isclass(func_obj):
+                _excs = _find_all_class_exceptions(
+                    func_obj, self.should_search_module_pred
                 )
+                self.exceptions.extend(_excs)
 
         self.generic_visit(node)
         return
@@ -527,11 +652,9 @@ class ExceptionFinder(ast.NodeVisitor):
                 return
 
             try:
-                caller_type = _exctact_type(caller_node_name, self.func_globals)
+                caller_type = _exctact_type(caller_node_name, self.func.__globals__)
             except Exception:
-                logger.critical(
-                    f"Failed to resolve attribute chain: {caller_node_name}"
-                )
+                logger.debug(f"Failed to resolve attribute chain: {caller_node_name}")
                 self.generic_visit(node)
                 return
 
@@ -545,7 +668,7 @@ class ExceptionFinder(ast.NodeVisitor):
                 return
 
             module = inspect.getmodule(caller_type)
-            if not module:
+            if module is None or self._should_be_visited(module) is False:
                 self.generic_visit(node)
                 return
 

{richapi-0.3.0 → richapi-0.3.2}/richapi/exc_parser/openapi.py

@@ -51,7 +51,8 @@ def enrich_openapi(
         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."
+                "Please provide the module name as a string or list of strings.\n"
+                "Example: enrich_openapi(app, target_module='src')\n"
             )
 
         target_module = target_module.split(".")[0]  # get the top-level module
@@ -91,7 +92,7 @@ def compile_openapi_from_fastapi(
 
             _fill_openapi_with_excpetions(openapi_schema, route, exceptions)
 
-    ExceptionFinder.visited.clear()
+    ExceptionFinder.clear_cache()
 
     return openapi_schema
 

richapi-0.3.2/tests/app/foo1.py

@@ -0,0 +1,10 @@
+from richapi.exc_parser.protocol import BaseHTTPException
+
+
+class HTTP500Error(BaseHTTPException):
+    status_code = 500
+    detail = "Internal Server Error"
+
+
+def raise_exc():
+    raise HTTP500Error

richapi-0.3.2/tests/test_builder_pattern.py

@@ -0,0 +1,68 @@
+import fastapi
+import fastapi.security
+from pydantic.dataclasses import dataclass
+
+from richapi.exc_parser.handler import add_exc_handler
+from richapi.exc_parser.openapi import compile_openapi_from_fastapi, enrich_openapi
+from richapi.exc_parser.protocol import RichHTTPException
+
+app = fastapi.FastAPI()
+app.openapi = enrich_openapi(app)
+add_exc_handler(app)
+
+
+@dataclass
+class Exception1(RichHTTPException):
+    status_code = 409
+
+
+@dataclass
+class Exception2(RichHTTPException):
+    status_code = 408
+
+
+@dataclass
+class Exception3(RichHTTPException):
+    status_code = 407
+
+
+def foo1():
+    raise Exception1()
+
+
+def foo2():
+    raise Exception2()
+
+
+def foo3():
+    raise Exception3()
+
+
+class PaymentService:
+    def foo(self):
+        foo1()
+        return self
+
+    def create(self):
+        foo2()
+        return self
+
+    def update(self):
+        foo3()
+        return self
+
+
+@app.post("/payment")
+async def make_payment():
+    PaymentService().foo().create().update()
+
+
+def test_class_is_detected():
+    openapi_json = compile_openapi_from_fastapi(
+        app, target_module="tests.test_builder_pattern"
+    )
+    home_responses = openapi_json["paths"]["/payment"]["post"]["responses"]
+    print(home_responses)
+    assert "408" in home_responses
+    assert "407" in home_responses
+    assert "409" in home_responses

richapi-0.3.2/tests/test_class.py

@@ -0,0 +1,72 @@
+import fastapi
+import fastapi.security
+from pydantic.dataclasses import dataclass
+
+from richapi.exc_parser.handler import add_exc_handler
+from richapi.exc_parser.openapi import compile_openapi_from_fastapi, enrich_openapi
+from richapi.exc_parser.protocol import RichHTTPException
+
+app = fastapi.FastAPI()
+app.openapi = enrich_openapi(app)
+add_exc_handler(app)
+
+
+@dataclass
+class Exception1(RichHTTPException):
+    status_code = 409
+
+
+@dataclass
+class Exception2(RichHTTPException):
+    status_code = 408
+
+
+@dataclass
+class Exception3(RichHTTPException):
+    status_code = 407
+
+
+def foo1():
+    raise Exception1()
+
+
+def foo2():
+    raise Exception2()
+
+
+def foo3():
+    raise Exception3()
+
+
+class PaymentService:
+    def __init__(self):
+        foo1()
+
+    def create(self):
+        foo2()
+
+    def update(self):
+        foo3()
+
+
+def make_payment_dep():
+    obj = PaymentService()
+    return obj
+
+
+@app.post("/payment")
+async def make_payment(
+    obj2: PaymentService = fastapi.Depends(make_payment_dep),
+):
+    obj = PaymentService()
+    obj.create()
+    obj2.update()
+
+
+def test_class_is_detected():
+    openapi_json = compile_openapi_from_fastapi(app, target_module="tests.test_class")
+    home_responses = openapi_json["paths"]["/payment"]["post"]["responses"]
+    print(home_responses)
+    assert "408" in home_responses
+    assert "407" in home_responses
+    assert "409" in home_responses

richapi-0.3.2/tests/test_compiler.py

@@ -0,0 +1,12 @@
+from typing import Annotated
+
+from richapi.exc_parser.compiler import _retrieve_from_annotations
+
+
+def foo(value: Annotated[int, Annotated[str, str]]): ...
+
+
+def test_get_from_annotated():
+    result = _retrieve_from_annotations(foo, "value")
+    print(type(result))
+    assert result is int

richapi-0.3.2/tests/test_import_from_other_module.py

@@ -0,0 +1,20 @@
+import fastapi
+import fastapi.security
+
+from richapi.exc_parser.openapi import compile_openapi_from_fastapi, enrich_openapi
+from tests.app import foo1 as FooService
+
+app = fastapi.FastAPI()
+app.openapi = enrich_openapi(app)
+
+
+@app.post("/payment")
+async def make_payment():
+    FooService.raise_exc()
+
+
+def test_class_is_detected():
+    openapi_json = compile_openapi_from_fastapi(app, target_module="tests")
+    home_responses = openapi_json["paths"]["/payment"]["post"]["responses"]
+    print(home_responses)
+    assert "500" in home_responses

richapi-0.3.2/tests/test_instance_attr_call.py

@@ -0,0 +1,82 @@
+import logging
+
+import fastapi
+import fastapi.security
+from pydantic.dataclasses import dataclass
+
+from richapi.exc_parser.openapi import compile_openapi_from_fastapi, enrich_openapi
+from richapi.exc_parser.protocol import RichHTTPException
+
+logging.getLogger().addHandler(logging.StreamHandler())
+
+app = fastapi.FastAPI()
+app.openapi = enrich_openapi(app, target_module="tests.test_instance_attr_call")
+
+
+@dataclass
+class Exception1(RichHTTPException):
+    status_code = 409
+
+
+@dataclass
+class Exception2(RichHTTPException):
+    status_code = 408
+
+
+@dataclass
+class Exception3(RichHTTPException):
+    status_code = 407
+
+
+def foo1():
+    raise Exception1()
+
+
+def foo2():
+    raise Exception2()
+
+
+def foo3():
+    raise Exception3()
+
+
+class PaymentService:
+    def __init__(self):
+        foo1()
+
+    def foo2(self):
+        foo2()
+
+    def foo3(self):
+        foo3()
+
+
+class PaymentOrchestrator:
+    service: PaymentService
+
+    def __init__(self, payment_service: PaymentService):
+        self.service = payment_service
+
+    def create_outer(self):
+        self.service.foo2()
+        self.update_outer()
+
+    def update_outer(self):
+        self.service.foo3()
+
+
+@app.post("/payment")
+async def make_payment():
+    obj = PaymentOrchestrator(payment_service=PaymentService())
+    obj.create_outer()
+
+
+def test_class_is_detected():
+    openapi_json = compile_openapi_from_fastapi(
+        app, target_module="tests.test_instance_attr_call"
+    )
+    home_responses = openapi_json["paths"]["/payment"]["post"]["responses"]
+    print(home_responses)
+    assert "408" in home_responses
+    assert "407" not in home_responses
+    assert "409" in home_responses

richapi-0.3.0/richapi/__version__.py

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