richapi 0.2.1__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: richapi
-Version: 0.2.1
+Version: 0.3.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

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

@@ -4,9 +4,6 @@ This is guideline for how to use the library in more advanced ways.
 
 ### Customization of the OpenAPI schema
 
-Sometimes, your exceptions is more than 'details'.
-In that case, you can very explicitly define the exception JSON schema inside the exception class. You may even use Pydantic to define the schema dynamically so you don't need to write the schema manually.
-
 All you need to do, is to return type HTTPExceptionSchema correctly on the method `get_json_schema` of your exception class which you inherited from `BaseHTTPException`.
 
 Imagine you are writing an exception that is returning a user balance and a time to retry again a failed bank transaction, you can define the schema like this:
@@ -33,7 +30,7 @@ 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.
+If your intention is to have a custom response schema, then recommended way is to use [custom exception feature](index.md#customization-of-exception).
 
 ### Finding exceptions in other modules
 

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

@@ -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` or `richapi.RichHTTPException`
 
 Exceptions are better to be very concrete, without having any dynamic data in them.
 So that using `raise Class` is enough to raise them.
@@ -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.2.1 → richapi-0.3.1}/docs/index.md

@@ -46,6 +46,57 @@ with open("openapi.json") as open_api_json:
 
     I personally recommend the second way, because it is better to have it compiled and saved to file, because there are static analysis running on the OpanAPI generator and your source code which isn't very ideal to be running in production.
 
+### Customization of Exception
+
+Sometimes, your exceptions is more than 'details'. You may want to put some extra information for the client to understand and parse the error better. In that case, please follow these steps:
+
+1. Add the exception handler from richapi to your FastAPI app.
+2. Inhert from `richapi.RichHTTPException`, and make it a dataclass.
+3. To override status, simply set the `status_code` attribute on the class without type annotation.
+4. Raise that exception somewhere in your code and you'll see the schema on swagger!
+
+Example:
+
+```python
+import fastapi
+import fastapi.security
+from pydantic import BaseModel
+from pydantic.dataclasses import dataclass
+
+from richapi.exc_parser.handler import add_exc_handler
+from richapi.exc_parser.openapi import enrich_openapi
+from richapi.exc_parser.protocol import RichHTTPException
+
+app = fastapi.FastAPI()
+app.openapi = enrich_openapi(app)
+add_exc_handler(app)
+
+
+@dataclass
+class NotEnoughBalance(RichHTTPException):
+    """Custom exception for user balance"""
+
+    user_id: int
+    balance: float
+    status_code = 403
+
+
+class SuccessResponse(BaseModel):
+    balance: float
+
+
+@app.post("/payment")
+async def make_payment() -> SuccessResponse:
+    raise NotEnoughBalance(user_id=1, balance=0.5)
+```
+
+Final Result:
+![Screenshot](./images/custom-exception.png)
+
+### Conventions (VERY IMPORTANT)
+
+There are some conventions about how to raise exceptions and etc. You may read the [conventions](conventions.md) to know more about them. The way library works is that it is a mini compiler using Abstract Syntax Tree and functions global to extract exceptions and their responses, and then it generates the OpenAPI schema from them. So there are limitations to what it can do, and you may need to follow the conventions to get the best out of it. Anything that is not following the conventions MAY be ignored by the compiler, and there is no plan to support them in the future, because it is not possible to support all the ways you can raise exceptions in Python... To give you an example, you may download a source code from internet and then use 'eval' function to run it dynamically, and there is no way to know what exceptions you may raise in that code, so it is impossible to support all the ways you can raise exceptions in Python.
+
 ### Example
 
 Imagine this application;
@@ -105,7 +156,3 @@ What would you see WITHOUT RichAPI:
 
 After compiling OpenAPI WITH RichAPI (extended with all possible exceptions coming from your router):
 ![Screenshot](./images/with-richapi.png)
-
-### Conventions (VERY IMPORTANT)
-
-There are some conventions about how to raise exceptions and etc. You may read the [conventions](conventions.md) to know more about them. The way library works is that it is a mini compiler using Abstract Syntax Tree and functions global to extract exceptions and their responses, and then it generates the OpenAPI schema from them. So there are limitations to what it can do, and you may need to follow the conventions to get the best out of it. Anything that is not following the conventions MAY be ignored by the compiler, and there is no plan to support them in the future, because it is not possible to support all the ways you can raise exceptions in Python... To give you an example, you may download a source code from internet and then use 'eval' function to run it dynamically, and there is no way to know what exceptions you may raise in that code, so it is impossible to support all the ways you can raise exceptions in Python.

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

@@ -1,6 +1,6 @@
 [project]
 name = "richapi"
-version = "0.2.1"
+version = "0.3.1"
 description = "Find HTTPExceptions and turn them into documented responses!"
 readme = "README.md"
 requires-python = ">=3.9"

richapi-0.3.1/richapi/__init__.py

@@ -0,0 +1,11 @@
+from richapi.exc_parser.handler import add_exc_handler
+from richapi.exc_parser.openapi import enrich_openapi, load_openapi
+from richapi.exc_parser.protocol import BaseHTTPException, RichHTTPException
+
+__all__ = [
+    "enrich_openapi",
+    "load_openapi",
+    "BaseHTTPException",
+    "RichHTTPException",
+    "add_exc_handler",
+]

richapi-0.3.1/richapi/__version__.py

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

{richapi-0.2.1 → richapi-0.3.1}/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__)
 
@@ -88,17 +90,20 @@ 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,
 ):
     try:
         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)
+        cls_name = cls.__name__ if hasattr(cls, "__name__") else cls.__str__()
+        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)
+    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
 
@@ -110,13 +115,14 @@ def _find_all_class_exceptions(
             )
         )
 
-    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))
+        inspect.isclass(type(obj))
+        and (not inspect.isfunction(obj))
+        and (not inspect.ismethod(obj))
     )
 
 
@@ -126,25 +132,24 @@ def _find_explicit_expection_recursively(
     tree: Optional[ast.AST] = None,
 ) -> 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))
+        class_type: Union[type, Callable] = (
+            obj_type if (obj_type := type(func_obj)) is not type else func_obj
+        )
+
+        cls_module = inspect.getmodule(class_type)
         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)
+        return _find_all_class_exceptions(class_type, to_filter_predicate, tree)
 
     if tree is None:
         try:
@@ -169,8 +174,11 @@ def _find_explicit_expection_recursively(
     try:
         finder.visit(tree)
     except Exception as error:
-        logger.exception(f"Failed to analyze function {get_func_name(func_obj)}.", exc_info=error)
+        logger.exception(
+            f"Failed to analyze function {get_func_name(func_obj)}.", exc_info=error
+        )
 
+    ExceptionFinder.visited[func_obj] = finder.exceptions
     return finder.exceptions
 
 
@@ -220,12 +228,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.
@@ -234,7 +282,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)
@@ -242,50 +290,99 @@ 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)
         if attr_chain is None:
-            logger.debug(f"Failed to get full attribute name: {ast.dump(node)} in {func.__name__}")
-            return None
+            logger.debug(
+                f"Failed to get full attribute name: {ast.dump(node)} in {func.__name__}"
+            )
+            return []
 
         try:
             parts = attr_chain.split(".")
             parent_part = parts[0]
 
-            parent_attr = func_globals.get(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:
                 if parent_part in func.__annotations__:
-                    return func.__annotations__[parent_part]
+                    result = _retrieve_from_annotations(func, parent_part)
+                    return [] if result is None else [result]
 
                 parent_attr = getattr(builtins, 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:
-                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(
@@ -295,7 +392,9 @@ 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)
@@ -303,7 +402,9 @@ 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,
@@ -334,7 +435,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:
@@ -349,16 +462,29 @@ 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]]] = {}
+    # cached_assignments: dict[Callable, dict[NodeIdentifier, str]] = {}
 
-    def __init__(self, func: Callable, should_search_module_pred: Callable[[str], bool]):
+    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__}")
 
+    @classmethod
+    def clear_cache(cls):
+        cls.visited.clear()
+        # cls.cached_assignments.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):
         """
         Track assignments to variables that are exceptions or exception instances.
@@ -384,10 +510,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
@@ -440,7 +567,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))
@@ -452,47 +579,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_explicit_expection_recursively(
+                    func_obj, self.should_search_module_pred
                 )
+                self.exceptions.extend(_excs)
 
         self.generic_visit(node)
         return
@@ -507,9 +634,11 @@ 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.critical(
+                    f"Failed to resolve attribute chain: {caller_node_name}"
+                )
                 self.generic_visit(node)
                 return
 
@@ -523,7 +652,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
 
@@ -540,7 +669,8 @@ class ExceptionFinder(ast.NodeVisitor):
 
             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)

richapi-0.3.1/richapi/exc_parser/handler.py

@@ -0,0 +1,22 @@
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from pydantic import TypeAdapter
+from starlette.requests import Request
+from starlette.responses import Response
+
+from richapi.exc_parser.protocol import RichHTTPException
+
+
+async def _handle_rich_http_exception(request: Request, exc: Exception) -> Response:
+    assert isinstance(exc, RichHTTPException)
+
+    adapter = TypeAdapter(exc.__class__)
+    if exc._validate_arg_types:
+        adapter.validate_python(exc)
+
+    json_response = adapter.dump_python(exc)
+    return JSONResponse(content=json_response, status_code=exc.status_code)
+
+
+def add_exc_handler(app: FastAPI):
+    app.add_exception_handler(RichHTTPException, handler=_handle_rich_http_exception)

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

@@ -12,6 +12,9 @@ from fastapi.openapi.utils import get_openapi as _get_openapi
 from fastapi.routing import APIRoute
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
+from richapi.exc_parser.compiler import (
+    ExceptionFinder,
+)
 from richapi.exc_parser.compiler import (
     find_explicit_exceptions as _find_explicit_exceptions,
 )
@@ -88,6 +91,8 @@ def compile_openapi_from_fastapi(
 
             _fill_openapi_with_excpetions(openapi_schema, route, exceptions)
 
+    ExceptionFinder.clear_cache()
+
     return openapi_schema
 
 

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

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-from typing import Any, Literal
+from typing import Any, ClassVar, Literal
 
 from fastapi import HTTPException
-from pydantic import BaseModel, create_model
+from pydantic import BaseModel, TypeAdapter, create_model
+from pydantic.dataclasses import dataclass
 
 
 class HTTPExceptionSchema(BaseModel):
@@ -27,10 +28,38 @@ 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
 
 
+@dataclass
+class RichHTTPException(HTTPException):
+    status_code: ClassVar[int] = 422
+    """HTTP Status code to raise"""
+
+    _validate_arg_types: ClassVar[bool] = True
+    """Whether to run validation on arguements"""
+
+    @classmethod
+    def get_json_schema(cls) -> HTTPExceptionSchema:
+        adapter = TypeAdapter(cls)
+        schema = adapter.json_schema()
+        schema.pop("status_code", None)
+
+        schema_desc = cls.__doc__
+        if schema_desc == cls.__name__ + "()" or schema_desc is None:
+            schema_desc = "No description provided"
+
+        return HTTPExceptionSchema(
+            response_schema_json=schema,
+            schema_name=f"{cls.__name__}Schema",
+            status_code=cls.status_code,
+            schema_desc=schema_desc,
+        )
+
+
 def try_to_camel_case(string: str) -> str:
     final_str = string
     if " " in final_str:  # with space

richapi-0.3.1/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.1/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.1/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.1/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.1/tests/test_custom_exc.py

@@ -0,0 +1,52 @@
+import fastapi
+import fastapi.security
+import pytest
+from httpx import ASGITransport, AsyncClient
+from pydantic import BaseModel
+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 NotEnoughBalance(RichHTTPException):
+    """Custom exception for user balance"""
+
+    user_id: int
+    balance: float
+    status_code = 409
+
+
+class SuccessResponse(BaseModel):
+    balance: float
+
+
+@app.post("/payment")
+async def make_payment() -> SuccessResponse:
+    raise NotEnoughBalance(user_id=1, balance=0.5)
+
+
+def test_custom_exc_detected():
+    openapi_json = compile_openapi_from_fastapi(
+        app, target_module="tests.test_custom_exc"
+    )
+    home_responses = openapi_json["paths"]["/payment"]["post"]["responses"]
+    assert "409" in home_responses
+
+
+@pytest.mark.asyncio
+async def test_make_payment():
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as ac:
+        response = await ac.post("/payment")
+
+    assert response.status_code == 409
+    expected_response = {"user_id": 1, "balance": 0.5}
+    assert response.json() == expected_response

richapi-0.3.1/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.1/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 create_inner(self):
+        foo2()
+
+    def update_inner(self):
+        foo3()
+
+
+class PaymentOrchestrator:
+    service: PaymentService
+
+    def __init__(self, payment_service: PaymentService):
+        self.service = payment_service
+
+    def create_outer(self):
+        self.service.create_inner()
+        self.update_outer()
+
+    def update_outer(self):
+        self.service.update_inner()
+
+
+@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" in home_responses
+    assert "409" in home_responses

richapi-0.2.1/richapi/__init__.py

@@ -1,4 +0,0 @@
-from richapi.exc_parser.openapi import enrich_openapi, load_openapi
-from richapi.exc_parser.protocol import BaseHTTPException
-
-__all__ = ["enrich_openapi", "load_openapi", "BaseHTTPException"]

richapi-0.2.1/richapi/__version__.py

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