type-less 0.1.1__tar.gz

type_less-0.1.1/.github/workflows/release.yml

@@ -0,0 +1,20 @@
+on:
+  release:
+    types: [published]
+
+
+jobs:
+  pypi-publish:
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    environment: 
+      name: pypi
+      url: https://github.com
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pdm-project/setup-pdm@v4
+      - name: Publish package distributions to PyPI
+        run: pdm publish

type_less-0.1.1/.github/workflows/test.yml

@@ -0,0 +1,28 @@
+name: Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python 3.12
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.12"
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install uv
+        uv sync --dev
+        
+    - name: Run tests
+      run: |
+        uv run pytest

type_less-0.1.1/.gitignore

@@ -0,0 +1,8 @@
+.env
+node_modules
+dist
+.venv
+.pytest_cache
+.python-version
+.vite
+__pycache__

type_less-0.1.1/.pdm-python

@@ -0,0 +1 @@
+/home/runner/work/type-less/type-less/.venv/bin/python

type_less-0.1.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: type-less
+Version: 0.1.1
+Summary: Type less types with inferred return types
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Type-less
+
+Type less with automatic type inference for Python!  Inject function return types at runtime for code generation.
+
+## FastAPI Example
+
+```python
+@app.get("/user/me")
+def user_me():
+    return {
+        "id": 1,
+        "balance": 13.37,
+        "name": {
+            "first": "Testy",
+            "last": "McTestFace",
+        },
+    }
+```
+
+🚀 Generates Return Types:
+
+```python
+class UserMeReturnName(TypedDict):
+    first: str
+    last: str
+
+class UserMeReturn(TypedDict):
+    id: str
+    balance: str
+    name: UserMeReturnName
+```
+
+📋 OpenAPI Spec:
+
+<img src="docs/example.png" alt="OpenAPI Example" height="170">
+
+## Using in FastAPI Project
+
+Inject types before by hooking before setting up routes.  Types will be automatically generated when new routes are added.
+
+```python
+from type_less.inject import inject_fastapi_route_types
+from fastapi import FastAPI
+
+app = FastAPI()
+app = inject_fastapi_route_types(app)
+
+@app.get("/test")
+def test(request):
+    ...
+```
+
+## TODO:
+### Add Support:
+ * Nested class inference
+ * Deep function call / return inference
+### Better Way?:
+ * Possibly use pyre, mypy, or anything else to infer the type?

type_less-0.1.1/README.md

@@ -0,0 +1,58 @@
+# Type-less
+
+Type less with automatic type inference for Python!  Inject function return types at runtime for code generation.
+
+## FastAPI Example
+
+```python
+@app.get("/user/me")
+def user_me():
+    return {
+        "id": 1,
+        "balance": 13.37,
+        "name": {
+            "first": "Testy",
+            "last": "McTestFace",
+        },
+    }
+```
+
+🚀 Generates Return Types:
+
+```python
+class UserMeReturnName(TypedDict):
+    first: str
+    last: str
+
+class UserMeReturn(TypedDict):
+    id: str
+    balance: str
+    name: UserMeReturnName
+```
+
+📋 OpenAPI Spec:
+
+<img src="docs/example.png" alt="OpenAPI Example" height="170">
+
+## Using in FastAPI Project
+
+Inject types before by hooking before setting up routes.  Types will be automatically generated when new routes are added.
+
+```python
+from type_less.inject import inject_fastapi_route_types
+from fastapi import FastAPI
+
+app = FastAPI()
+app = inject_fastapi_route_types(app)
+
+@app.get("/test")
+def test(request):
+    ...
+```
+
+## TODO:
+### Add Support:
+ * Nested class inference
+ * Deep function call / return inference
+### Better Way?:
+ * Possibly use pyre, mypy, or anything else to infer the type?

type_less-0.1.1/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "type-less"
+version = "0.1.1"
+description = "Type less types with inferred return types"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+addopts = [
+    "--import-mode=importlib",
+]
+
+[dependency-groups]
+dev = [
+    "fastapi>=0.115.11",
+    "pytest>=8.3.5",
+]

type_less-0.1.1/src/type_less/__init__.py

@@ -0,0 +1,4 @@
+from .inference import guess_return_type
+from .inject import fill_type_hints
+
+__all__ = ["fill_type_hints", "guess_return_type"]

type_less-0.1.1/src/type_less/inference.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+import ast
+import inspect
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Literal,
+    Optional,
+    Tuple,
+    TypedDict,
+    Type,
+    Union,
+)
+import textwrap
+
+
+def _snake_case_to_capital_case(name: str) -> str:
+    return "".join(word.capitalize() for word in name.split("_"))
+
+
+def _sanitize_name(name: str) -> str:
+    return "".join(c if c.isalnum() else "" for c in name)
+
+
+def _get_module_type(func: Callable, name: str) -> Type:
+    import sys
+
+    # TODO: support types not at the root
+    module = sys.modules.get(func.__module__, None)
+    if hasattr(module, name):
+        result = getattr(module, name)
+        if isinstance(result, type):
+            return result
+        elif isinstance(result, Callable):
+            return guess_return_type(result)
+
+    return Any
+
+
+def guess_return_type(func: Callable, use_literals=True) -> Type:
+    """
+    Infer the return type of a Python function by analyzing its AST.
+    For dictionary returns, creates a TypedDict representation.
+
+    Args:
+        func: The function to analyze
+
+    Returns:
+        The inferred return type
+    """
+
+    # If annotations exist, return the return type
+    if hasattr(func, "__annotations__") and "return" in func.__annotations__:
+        return func.__annotations__["return"]
+
+    # Get function source code and create AST
+    try:
+        source = inspect.getsource(func)
+        source = textwrap.dedent(source)
+    except Exception:
+        return Any
+
+    module = ast.parse(source)
+
+    # Extract the function definition node
+    func_def = module.body[0]
+    if not isinstance(func_def, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        raise ValueError("Input is not a function definition")
+
+    # Create a symbol table for type analysis
+    symbol_table = {}
+
+    # Populate the symbol table with type hints from function annotations
+    if func_def.returns:
+        # If function has a return type annotation, use it directly
+        return _resolve_annotation(func_def.returns, {}, func)
+
+    # Gather type information from annotations and assignments
+    _analyze_function_body(func_def, symbol_table, func, use_literals)
+
+    # Find all return statements
+    return_types = []
+    for node in ast.walk(func_def):
+        if isinstance(node, ast.Return) and node.value:
+            return_type = _infer_expr_type(node.value, symbol_table, func, [], use_literals)
+            return_types.append(return_type)
+
+    # If we found return statements
+    if return_types:
+        if len(return_types) == 1:
+            return return_types[0]
+        else:
+            # Multiple return types - use Union
+            return Union[tuple(set(return_types))]
+
+    # Default to Any if no return statements or couldn't infer
+    return Any
+
+
+def _analyze_function_body(
+    func_def: ast.FunctionDef, symbol_table: dict[str, Type], func: Callable, use_literals: bool
+) -> None:
+    """Analyze function body to populate symbol table with type information"""
+    # First gather parameter types
+    for arg in func_def.args.args:
+        if arg.annotation:
+            symbol_table[arg.arg] = _resolve_annotation(arg.annotation, {}, func)
+
+    # Analyze assignments to track variable types
+    for node in ast.walk(func_def):
+        if isinstance(node, ast.Assign):
+            assigned_type = _infer_expr_type(node.value, symbol_table, func, [], use_literals)
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    symbol_table[target.id] = assigned_type
+        elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+            # Handle annotated assignments
+            symbol_table[node.target.id] = _resolve_annotation(
+                node.annotation, {}, func
+            )
+
+
+def _resolve_annotation(
+    annotation: ast.AST, type_context: dict[str, Any], func: Callable
+) -> Type:
+    """Resolve a type annotation AST node to a real type"""
+    if isinstance(annotation, ast.Name):
+        # Simple types like int, str, etc.
+        type_name = annotation.id
+        # Check Python's built-in types first
+        if type_name in __builtins__:
+            return __builtins__[type_name]
+
+        print(annotation.id)
+
+        # Otherwise check if it's imported
+        return _get_module_type(func, type_name)
+
+    elif isinstance(annotation, ast.Subscript):
+        # Handle generic types like list[int], dict[str, int], etc.
+        if isinstance(annotation.value, ast.Name):
+            base_type = annotation.value.id
+            if base_type == "List" or base_type == "list":
+                elem_type = _resolve_annotation(annotation.slice, type_context, func)
+                return list[elem_type]
+            elif base_type == "Dict" or base_type == "dict":
+                if isinstance(annotation.slice, ast.Tuple):
+                    key_type = _resolve_annotation(
+                        annotation.slice.elts[0], type_context, func
+                    )
+                    val_type = _resolve_annotation(
+                        annotation.slice.elts[1], type_context, func
+                    )
+                    return dict[key_type, val_type]
+                return Dict
+            elif base_type == "Set" or base_type == "set":
+                elem_type = _resolve_annotation(annotation.slice, type_context, func)
+                return set[elem_type]
+            elif base_type == "Tuple" or base_type == "tuple":
+                if isinstance(annotation.slice, ast.Tuple):
+                    elem_types = [
+                        _resolve_annotation(e, type_context, func)
+                        for e in annotation.slice.elts
+                    ]
+                    return tuple[tuple(elem_types)]
+                return Tuple
+            elif base_type == "Optional":
+                elem_type = _resolve_annotation(annotation.slice, type_context, func)
+                return Optional[elem_type]
+            elif base_type == "Union":
+                if isinstance(annotation.slice, ast.Tuple):
+                    elem_types = [
+                        _resolve_annotation(e, type_context, func)
+                        for e in annotation.slice.elts
+                    ]
+                    return Union[tuple(elem_types)]
+                return Union
+
+    # Fallback for unresolved or complex annotations
+    print("FAIL3")
+    return Any
+
+
+def _infer_expr_type(
+    node: ast.AST, symbol_table: dict[str, Type], func: Callable, nested_path: list[str], use_literals: bool
+) -> Type:
+    """Infer the type of an expression"""
+    if isinstance(node, ast.Dict):
+        # For dictionary literals, create a TypedDict
+        return _create_typed_dict_from_dict(node, symbol_table, func, nested_path, use_literals)
+
+    elif isinstance(node, ast.List):
+        # Handle list literals
+        if not node.elts:
+            return list[Any]
+        element_types = [
+            _infer_expr_type(elt, symbol_table, func, nested_path, use_literals) for elt in node.elts
+        ]
+        if len(set(element_types)) == 1:
+            return list[element_types[0]]
+        return list[Union[tuple(set(element_types))]]
+
+    elif isinstance(node, ast.Tuple):
+        # Handle tuple literals
+        if not node.elts:
+            return tuple[()]
+        element_types = [
+            _infer_expr_type(elt, symbol_table, func, nested_path, use_literals) for elt in node.elts
+        ]
+        return tuple[tuple(element_types)]
+
+    elif isinstance(node, ast.Set):
+        # Handle set literals
+        if not node.elts:
+            return set[Any]
+        element_types = [
+            _infer_expr_type(elt, symbol_table, func, nested_path, use_literals) for elt in node.elts
+        ]
+        if len(set(element_types)) == 1:
+            return set[element_types[0]]
+        return set[Union[tuple(set(element_types))]]
+
+    elif isinstance(node, ast.Constant):
+        # Handle literals
+        if use_literals:
+            return Literal[node.value]
+        else:
+            return type(node.value)
+
+    elif isinstance(node, ast.Name):
+        # Look up variable types in the symbol table
+        if node.id in symbol_table:
+            return symbol_table[node.id]
+
+        # Handle built-in types referenced by name
+        if node.id in __builtins__ and isinstance(__builtins__[node.id], type):
+            return __builtins__[node.id]
+
+        return _get_module_type(func, node.id)
+
+    elif isinstance(node, ast.Call):
+        # Handle function calls - this is complex, so we'll use a simplified approach
+        if isinstance(node.func, ast.Name):
+            func_name = node.func.id
+            # Handle some common built-in functions
+            if func_name == "int":
+                return int
+            elif func_name == "str":
+                return str
+            elif func_name == "float":
+                return float
+            elif func_name == "list":
+                return list[Any]
+            elif func_name == "dict":
+                return dict[Any, Any]
+            elif func_name == "set":
+                return set[Any]
+            elif func_name == "tuple":
+                return Tuple
+
+            return _get_module_type(func, func_name)
+
+        # For other function calls, we default to Any
+        return Any
+
+    elif isinstance(node, ast.BinOp):
+        # Handle binary operations
+        left_type = _infer_expr_type(node.left, symbol_table, func, nested_path, use_literals)
+        right_type = _infer_expr_type(node.right, symbol_table, func, nested_path, use_literals)
+
+        # String concatenation
+        if isinstance(node.op, ast.Add) and (left_type == str or right_type == str):
+            return str
+
+        # Numeric operations typically return numeric types
+        if isinstance(node.op, (ast.Add, ast.Sub, ast.Mult, ast.Div)):
+            if left_type == float or right_type == float:
+                return float
+            return int
+
+        return Any
+
+    elif isinstance(node, ast.Compare):
+        return bool
+
+    elif isinstance(node, ast.IfExp):
+        body_type = _infer_expr_type(node.body, symbol_table, func, nested_path, use_literals)
+        orelse_type = _infer_expr_type(node.orelse, symbol_table, func, nested_path, use_literals)
+        return body_type | orelse_type
+    
+    elif isinstance(node, ast.Attribute):
+        # Handle attribute access (e.g., obj.attr)
+        if isinstance(node.value, ast.Name) and node.value.id in symbol_table:
+            print(f"TRYYYY {node.value.id}")
+            # Get the type of the object
+            obj_type = symbol_table[node.value.id]
+            print(obj_type)
+            print(type(obj_type))
+            
+            # If the object has type annotations, try to get the attribute type
+            if hasattr(obj_type, "__annotations__") and node.attr in obj_type.__annotations__:
+                return obj_type.__annotations__[node.attr]
+            
+            # If the object is a class with class variables
+            if isinstance(obj_type, type):
+                if hasattr(obj_type, node.attr):
+                    attr_value = getattr(obj_type, node.attr)
+                    # If it's a Literal type or other type annotation
+                    if hasattr(attr_value, "__origin__") and attr_value.__origin__ is Literal:
+                        return attr_value
+                    # For regular attributes, infer their type
+                    return type(attr_value)
+        
+        # For other attribute access, default to Any
+        print("FAIL3,5")
+        return Any
+
+    # Default for complex or unknown expressions
+    print("FAIL4")
+    print(node)
+    print(type(node))
+    return Any
+
+
+def _create_typed_dict_from_dict(
+    dict_node: ast.Dict,
+    symbol_table: dict[str, Type],
+    func: Callable,
+    nested_path: list[str],
+    use_literals: bool,
+) -> Type:
+    """Create a TypedDict from a dictionary literal"""
+    # Check if all keys are string literals
+    field_types = {}
+    is_valid_typeddict = True
+
+    for i, key in enumerate(dict_node.keys):
+        if isinstance(key, ast.Constant) and isinstance(key.value, str):
+            value_type = _infer_expr_type(
+                dict_node.values[i], symbol_table, func, nested_path + [key.value], use_literals
+            )
+            field_types[key.value] = value_type
+        else:
+            is_valid_typeddict = False
+            break
+
+    if is_valid_typeddict and field_types:
+        # Create a dynamic TypedDict class
+        # Capitalize function name and remove underscores
+        class_name = f"{_snake_case_to_capital_case(func.__name__)}Return"
+
+        # Add nested path components
+        for component in nested_path:
+            class_name += _snake_case_to_capital_case(_sanitize_name(component))
+        return TypedDict(class_name, field_types)
+
+    # If not a valid TypedDict, return a regular Dict with inferred types
+    if dict_node.keys:
+        key_types = [
+            _infer_expr_type(key, symbol_table, func, nested_path + [key], use_literals)
+            for key in dict_node.keys
+        ]
+        value_types = [
+            _infer_expr_type(value, symbol_table, func, nested_path, use_literals)
+            for value in dict_node.values
+        ]
+
+        # Determine common types
+        if len(set(key_types)) == 1 and len(set(value_types)) == 1:
+            return dict[key_types[0], value_types[0]]
+        elif len(set(key_types)) == 1:
+            return dict[key_types[0], Union[tuple(set(value_types))]]
+        elif len(set(value_types)) == 1:
+            return dict[Union[tuple(set(key_types))], value_types[0]]
+        else:
+            return dict[Union[tuple(set(key_types))], Union[tuple(set(value_types))]]
+
+    return dict[Any, Any]

type_less-0.1.1/src/type_less/inject.py

@@ -0,0 +1,40 @@
+from .inference import guess_return_type
+from functools import wraps
+from typing import Callable, TypeVar
+
+
+def fill_type_hints(func: Callable, use_literals=False):
+    if not getattr(func, "__annotations__", None):
+        func.__annotations__ = {}
+
+    if not "return" in func.__annotations__:
+        func.__annotations__["return"] = guess_return_type(func, use_literals=use_literals)
+
+
+T = TypeVar("T")
+def fastapi_app_inject_types(app: T, use_literals=False) -> T:
+    """
+    Auto-injects return types into FastAPI untyped routes.
+
+    Can be run before or after route initialization
+    Arguments:
+        app: FastAPI Application
+    """
+    routes = getattr(app, 'routes', None)
+    if not type(routes) is list:
+        raise ValueError("Invalid app provided, no routes found.  Please be sure this is a FastAPI app.")
+    for route in routes:
+        endpoint = getattr(route, "endpoint", None)
+        if not endpoint:
+            raise ValueError(f"Route {route} is missing an endpoint function")
+        fill_type_hints(endpoint, use_literals=use_literals)
+    
+    # Auto-fill type hings 
+    app_add_route = app.router.add_api_route
+    @wraps(app_add_route)
+    def add_route_injected(path: str, func, *args, **kwargs):
+        fill_type_hints(func, use_literals=use_literals)
+        app_add_route(path=path, endpoint=func, *args, **kwargs)
+    app.router.add_api_route = add_route_injected
+
+    return app

type_less-0.1.1/tests/matching.py

@@ -0,0 +1,185 @@
+from typing import get_type_hints, get_origin, get_args, Literal, TypeVar, Union
+import types
+
+def is_equivalent_type(type1, type2):
+    """
+    Determine if two Python types are equivalent, handling complex nested types.
+    
+    This function compares two types for equivalence, including:
+    - Basic types (int, str, etc.)
+    - Generic types (List, Dict, etc.)
+    - Union types (Union[int, str], Optional[int], etc.)
+    - TypedDict types with nested structure
+    - Literal types
+    - TypeVar with constraints
+    - ForwardRef types
+    - Callable types
+    
+    Args:
+        type1: First type to compare
+        type2: Second type to compare
+        
+    Returns:
+        bool: True if types are equivalent, False otherwise
+    """
+    # Handle None type
+    if type1 is None and type2 is None:
+        return True
+    
+    # Handle direct equality (same type object)
+    if type1 is type2:
+        return True
+    
+    # Get origin types (for generics)
+    origin1 = get_origin(type1)
+    origin2 = get_origin(type2)
+    
+    # If one has origin and other doesn't, they're not equivalent
+    if (origin1 is None) != (origin2 is None):
+        return False
+    
+    # Special case for Optional and Union
+    if {origin1, origin2} <= {Union, types.UnionType}:
+        # Handle Optional[T] == Union[T, None]
+        args1 = get_args(type1)
+        args2 = get_args(type2)
+        
+        # Check if one is Optional (Union with None)
+        has_none1 = type(None) in args1
+        has_none2 = type(None) in args2
+        
+        if has_none1 != has_none2:
+            return False
+            
+        # Compare non-None args
+        non_none_args1 = [arg for arg in args1 if arg is not type(None)]
+        non_none_args2 = [arg for arg in args2 if arg is not type(None)]
+        
+        if len(non_none_args1) != len(non_none_args2):
+            return False
+            
+        # For Union, order doesn't matter
+        args2_remaining = set(non_none_args2)
+        for arg1 in non_none_args1:
+            for arg2 in args2_remaining:
+                if is_equivalent_type(arg1, arg2):
+                    args2_remaining.remove(arg2)
+                    break
+            else:
+                return False
+        return True
+    
+    # Get arguments of generic types
+    args1 = get_args(type1)
+    args2 = get_args(type2)
+    
+    # If number of args differs, types are not equivalent
+    if len(args1) != len(args2):
+        return False
+    
+    # Special handling for TypedDict
+    if hasattr(type1, "__annotations__") and hasattr(type2, "__annotations__"):
+        # Check if both are TypedDict
+        if hasattr(type1, "__total__") and hasattr(type2, "__total__"):
+            # Check if totality is the same
+            if type1.__total__ != type2.__total__:
+                return False
+            
+            # Get annotations
+            annotations1 = get_type_hints(type1)
+            annotations2 = get_type_hints(type2)
+            
+            # Check if keys match
+            if set(annotations1.keys()) != set(annotations2.keys()):
+                return False
+            
+            # Check if field types match
+            return all(is_equivalent_type(annotations1[key], annotations2[key]) for key in annotations1)
+    
+    # Handle Literal
+    if origin1 is Literal and origin2 is Literal:
+        # For Literal, order doesn't matter but values must be identical
+        return set(args1) == set(args2)
+    
+    # Handle Callable
+    if origin1 in {types.FunctionType, callable} and origin2 in {types.FunctionType, callable}:
+        if not args1 or not args2:
+            return True  # Callable without specified signature
+        
+        if len(args1) != 2 or len(args2) != 2:
+            return False
+        
+        # Compare parameter types
+        params1, return1 = args1
+        params2, return2 = args2
+        
+        # Handle Ellipsis in parameters
+        if params1 is Ellipsis or params2 is Ellipsis:
+            return is_equivalent_type(return1, return2)
+        
+        # If parameter counts differ, not equivalent
+        if len(params1) != len(params2):
+            return False
+        
+        # Check parameters and return type
+        return all(is_equivalent_type(p1, p2) for p1, p2 in zip(params1, params2)) and \
+               is_equivalent_type(return1, return2)
+    
+    # Handle basic types
+    if origin1 is None and origin2 is None:
+        if isinstance(type1, type) and isinstance(type2, type):
+            return type1 is type2 or type1 == type2
+        
+        # Handle TypeVar
+        if isinstance(type1, TypeVar) and isinstance(type2, TypeVar):
+            return (type1.__name__ == type2.__name__ and 
+                    type1.__constraints__ == type2.__constraints__ and
+                    type1.__bound__ == type2.__bound__ and
+                    type1.__covariant__ == type2.__covariant__ and
+                    type1.__contravariant__ == type2.__contravariant__)
+    
+    # For other generic types, check if all arguments are equivalent
+    # For tuples, order matters
+    return all(is_equivalent_type(arg1, arg2) for arg1, arg2 in zip(args1, args2))
+
+
+
+def validate_openapi_has_return_schema(openapi_spec: dict, path: str, method: Literal["get", "post", "put", "delete"]) -> bool:
+    """
+    Validates that the OpenAPI specification for a given endpoint matches the expected return type.
+    
+    Args:
+        openapi_spec: The OpenAPI specification dictionary
+        path: The API endpoint path
+        method: The HTTP method (get, post, put)
+        expected_type: The expected return type to validate against
+        
+    Returns:
+        bool: True if the OpenAPI schema matches the expected type, False otherwise
+    """
+    # Check if the OpenAPI spec exists
+    if not openapi_spec or "paths" not in openapi_spec:
+        return False
+    
+    # Check if the path exists in the spec
+    if path not in openapi_spec["paths"]:
+        return False
+    
+    # Check if the method exists for the path
+    path_spec = openapi_spec["paths"][path]
+    if method not in path_spec:
+        return False
+    
+    # Get the response schema
+    method_spec = path_spec[method]
+    if "responses" not in method_spec or "200" not in method_spec["responses"]:
+        return False
+    
+    response_spec = method_spec["responses"]["200"]
+    if "content" not in response_spec or "application/json" not in response_spec["content"]:
+        return False
+    
+    schema = response_spec["content"]["application/json"].get("schema") or {}
+    
+    # For now, just check if schema exists
+    return schema.get("$ref") is not None

type_less-0.1.1/tests/test_fastapi.py

@@ -0,0 +1,25 @@
+from fastapi import FastAPI
+from type_less.inject import fastapi_app_inject_types
+from .matching import validate_openapi_has_return_schema
+
+def test_fastapi_basic():
+    app = FastAPI()
+
+    @app.get("/root/before")
+    async def root_before():
+        return {"message": "Hello World"}
+
+    injected_app = fastapi_app_inject_types(app)
+
+    @app.get("/root/after")
+    async def root_after():
+        return {"message": "Hello World"}
+
+    assert type(app) == type(injected_app)
+
+    # Validate generated OpenAPI
+    openapi_spec = app.openapi()
+
+    assert openapi_spec is not None
+    assert not validate_openapi_has_return_schema(openapi_spec, "/root/before", "get")
+    assert validate_openapi_has_return_schema(openapi_spec, "/root/after", "get")

type_less-0.1.1/tests/test_return_types.py

@@ -0,0 +1,138 @@
+from type_less.inference import guess_return_type
+from typing import TypedDict, Literal, Union
+from .matching import is_equivalent_type
+
+
+def test_guess_return_type_dict():
+    def func():
+        return {"key": "value"}
+    
+    assert guess_return_type(func) == dict
+
+
+def test_guess_return_type_list():
+    def func():
+        return [1, 2, 3]
+    
+    assert guess_return_type(func, use_literals=False) == list[int]
+
+
+def test_guess_return_type_list_literals():
+    def func():
+        return [1, 2, 3]
+    
+    assert guess_return_type(func, use_literals=True) == list[Union[Literal[1], Literal[2], Literal[3]]]
+
+
+def test_guess_return_type_string():
+    def func():
+        return "hello world"
+    
+    assert guess_return_type(func, use_literals=False) == str
+
+
+def test_guess_return_type_int():
+    def func():
+        return 42
+    
+    assert guess_return_type(func, use_literals=False) == int
+
+
+def test_guess_return_type_float():
+    def func():
+        return 3.14
+    
+    assert guess_return_type(func, use_literals=False) == float
+
+
+def test_guess_return_type_bool():
+    def func():
+        return True
+    
+    assert guess_return_type(func, use_literals=False) == bool
+
+
+def test_guess_return_type_none():
+    def func():
+        return None
+    
+    assert guess_return_type(func, use_literals=False) == type(None)
+
+
+def test_guess_return_type_multiple_returns():
+    def func(x):
+        if x > 0:
+            return "positive"
+        else:
+            return "negative"
+
+    assert guess_return_type(func) == Literal["positive"] | Literal["negative"]
+
+def test_guess_return_type_dict():
+    def func(x):
+        return {
+            "name": "tester",
+            "age": 123,
+        }
+    
+    class FuncReturn(TypedDict):
+        name: str
+        age: int
+
+    assert is_equivalent_type(guess_return_type(func, use_literals=False), FuncReturn)
+
+
+def test_guess_return_type_complex_fuzzy():
+    def func(x):
+        if x > 10:
+            return {"result": "large"}
+        elif x > 0:
+            return {"result": "small"}
+        else:
+            return {"result": "negative"}
+    
+    class FuncReturn1(TypedDict):
+        result: str
+    class FuncReturn2(TypedDict):
+        result: str
+    class FuncReturn3(TypedDict):
+        result: str
+
+    assert is_equivalent_type(guess_return_type(func, use_literals=False), Union[FuncReturn1, FuncReturn2, FuncReturn3])
+
+
+def test_guess_return_type_complex_literals():
+    def func(x):
+        if x > 10:
+            return {"result": "large"}
+        elif x > 0:
+            return {"result": "small"}
+        else:
+            return {"result": "negative"}
+    
+    class FuncReturn1(TypedDict):
+        result: Literal["large"]
+    class FuncReturn2(TypedDict):
+        result: Literal["small"]
+    class FuncReturn3(TypedDict):
+        result: Literal["negative"]
+
+    assert is_equivalent_type(guess_return_type(func, use_literals=True), Union[FuncReturn1, FuncReturn2, FuncReturn3])
+
+
+class TestCat:
+    color: Literal["black", "orange"]
+    has_ears: bool
+
+def test_guess_return_type_follow_class_members():
+    class TheCatReturns(TypedDict):
+        color: Literal["black", "orange"]
+        has_ears: bool
+
+    def func(cat: TestCat):
+        return {
+            "color": cat.color,
+            "has_ears": cat.has_ears,
+        }
+    
+    assert is_equivalent_type(guess_return_type(func, use_literals=True), TheCatReturns)

type_less-0.1.1/uv.lock

@@ -0,0 +1,202 @@
+version = 1
+revision = 1
+requires-python = ">=3.12"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
+]
+
+[[package]]
+name = "anyio"
+version = "4.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "sniffio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/73/199a98fc2dae33535d6b8e8e6ec01f8c1d76c9adb096c6b7d64823038cde/anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a", size = 181126 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/eb/e7f063ad1fec6b3178a3cd82d1a3c4de82cccf283fc42746168188e1cdd5/anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a", size = 96041 },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.115.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b5/28/c5d26e5860df807241909a961a37d45e10533acef95fc368066c7dd186cd/fastapi-0.115.11.tar.gz", hash = "sha256:cc81f03f688678b92600a65a5e618b93592c65005db37157147204d8924bf94f", size = 294441 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/5d/4d8bbb94f0dbc22732350c06965e40740f4a92ca560e90bb566f4f73af41/fastapi-0.115.11-py3-none-any.whl", hash = "sha256:32e1541b7b74602e4ef4a0260ecaf3aadf9d4f19590bba3e1bf2ac4666aa2c64", size = 94926 },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
+]
+
+[[package]]
+name = "packaging"
+version = "24.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.10.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696 },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.27.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 },
+    { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 },
+    { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 },
+    { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 },
+    { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 },
+    { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 },
+    { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 },
+    { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 },
+    { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 },
+    { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 },
+    { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 },
+    { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064 },
+    { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046 },
+    { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092 },
+    { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709 },
+    { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273 },
+    { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027 },
+    { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888 },
+    { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738 },
+    { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138 },
+    { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025 },
+    { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633 },
+    { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404 },
+    { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130 },
+    { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946 },
+    { url = "https://files.pythonhosted.org/packages/a4/99/bddde3ddde76c03b65dfd5a66ab436c4e58ffc42927d4ff1198ffbf96f5f/pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130", size = 1834387 },
+    { url = "https://files.pythonhosted.org/packages/71/47/82b5e846e01b26ac6f1893d3c5f9f3a2eb6ba79be26eef0b759b4fe72946/pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee", size = 1990453 },
+    { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186 },
+]
+
+[[package]]
+name = "pytest"
+version = "8.3.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
+]
+
+[[package]]
+name = "starlette"
+version = "0.46.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/1b/52b27f2e13ceedc79a908e29eac426a63465a1a01248e5f24aa36a62aeb3/starlette-0.46.1.tar.gz", hash = "sha256:3c88d58ee4bd1bb807c0d1acb381838afc7752f9ddaec81bbe4383611d833230", size = 2580102 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/4b/528ccf7a982216885a1ff4908e886b8fb5f19862d1962f56a3fce2435a70/starlette-0.46.1-py3-none-any.whl", hash = "sha256:77c74ed9d2720138b25875133f3a2dae6d854af2ec37dceb56aef370c1d8a227", size = 71995 },
+]
+
+[[package]]
+name = "type-less"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "fastapi" },
+    { name = "pytest" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "fastapi", specifier = ">=0.115.11" },
+    { name = "pytest", specifier = ">=8.3.5" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+]