tina4-python 3.13.46__tar.gz → 3.13.48__tar.gz

{tina4_python-3.13.46 → tina4_python-3.13.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.46
+Version: 3.13.48
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.46 → tina4_python-3.13.48}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.46"
+version = "3.13.48"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.46 → tina4_python-3.13.48}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.46"
+__version__ = "3.13.48"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.46 → tina4_python-3.13.48}/tina4_python/core/router.py

@@ -219,18 +219,17 @@ class Router:
         """Register a global middleware class applied to every route.
 
         Equivalent to decorating every handler with @middleware(middleware_class).
+        Delegates to the single ``Middleware`` global registry that the request
+        dispatcher actually consults — mirrors PHP ``Router::use`` ->
+        ``Middleware::use``, Ruby ``Router.use`` -> ``Middleware.use`` and the
+        Node equivalent. (Before #55 this wrote to a private ``Router._global_middleware``
+        list that nothing read, so globals registered via ``Router.use`` never ran.)
 
         Args:
             middleware_class: A class with before_*/after_* static methods.
         """
-        from tina4_python.core import middleware as _mw_module  # avoid circular import
-        if hasattr(_mw_module, "register_global"):
-            _mw_module.register_global(middleware_class)
-        else:
-            # Fallback: store in a module-level list the dispatcher can pick up.
-            if not hasattr(cls, "_global_middleware"):
-                cls._global_middleware = []
-            cls._global_middleware.append(middleware_class)
+        from tina4_python.core.middleware import Middleware  # avoid circular import
+        Middleware.use(middleware_class)
 
     @classmethod
     def get(cls, path: str, handler, middleware: list = None, swagger_meta: dict = None, template: str = None, **options) -> "RouteRef":

{tina4_python-3.13.46 → tina4_python-3.13.48}/tina4_python/core/server.py

@@ -127,10 +127,19 @@ def _auto_discover(root_dir: str = "src"):
                 importlib.import_module(module_name)
                 _discovered_mtimes[module_name] = current_mtime
                 Log.debug(f"Loaded: {module_name}")
-            elif current_mtime > _discovered_mtimes.get(module_name, 0.0):
-                # Changed module — re-execute so edits to an existing route
-                # take effect in-process. Scope guard: only ever evict a module
-                # that lives under our discovery package. Deleting a
+            elif module_name not in _discovered_mtimes:
+                # Already in sys.modules but NEVER recorded by discovery — it was
+                # imported TRANSITIVELY (e.g. `from src.x import y` pulled it in
+                # before the walk reached its file). Record its current mtime as
+                # the baseline WITHOUT re-importing. Re-importing here would
+                # del+re-add a fresh module object, while the earlier importer
+                # keeps the STALE one — module-level singletons would silently
+                # diverge (issue #53). We only ever reload a module WE loaded.
+                _discovered_mtimes[module_name] = current_mtime
+            elif current_mtime > _discovered_mtimes[module_name]:
+                # Changed since WE loaded it — re-execute so edits to an existing
+                # route take effect in-process. Scope guard: only ever evict a
+                # module that lives under our discovery package. Deleting a
                 # tina4_python.* / third-party module would break shared
                 # singletons and class identity — never do that here.
                 if module_name == root_pkg or module_name.startswith(root_pkg + "."):
@@ -1322,6 +1331,28 @@ def _middleware_500(response: Response, mw_inst, method_name: str, error: Except
     })
 
 
+def _effective_middleware(route: dict) -> list:
+    """Resolve the middleware that actually runs for a route.
+
+    Global middleware (registered via ``Middleware.use`` / ``Router.use``) runs
+    on EVERY route, BEFORE the route's own middleware, in registration order.
+    The list is deduped (by class) so a class that is both global and attached
+    to the route runs once. This is the fix for issue #55 — globals were
+    registered into ``Middleware._global_middleware`` but the dispatcher only
+    ever iterated ``route["middleware"]``, so global middleware never ran.
+    Mirrors the PHP/Ruby/Node dispatchers, which already fold globals in.
+    """
+    from tina4_python.core.middleware import Middleware
+    resolved = []
+    seen = set()
+    for mw in list(Middleware.get_global()) + list(route.get("middleware", [])):
+        key = mw if isinstance(mw, type) else type(mw)
+        if key not in seen:
+            seen.add(key)
+            resolved.append(mw)
+    return resolved
+
+
 def _run_before_middleware(request: Request, response: Response, route: dict) -> tuple[Request, Response, bool]:
     """Run class-based before_* middleware methods. Returns (request, response, skip_handler).
 
@@ -1338,7 +1369,7 @@ def _run_before_middleware(request: Request, response: Response, route: dict) ->
     before_* that sets status >= 400 also short-circuits the handler.
     """
     skip = False
-    for _mw_cls in route.get("middleware", []):
+    for _mw_cls in _effective_middleware(route):
         if _is_function_middleware(_mw_cls):
             continue  # Handled by the continuation wrapper instead
         _mw_inst = _mw_cls() if isinstance(_mw_cls, type) else _mw_cls
@@ -1378,7 +1409,7 @@ def _run_after_middleware(request: Request, response: Response, route: dict) ->
     Resilience (M2): each after_* call is wrapped — a method that THROWS is
     logged and converted to a clean 500; remaining after_* still run.
     """
-    for _mw_cls in route.get("middleware", []):
+    for _mw_cls in _effective_middleware(route):
         if _is_function_middleware(_mw_cls):
             continue
         _mw_inst = _mw_cls() if isinstance(_mw_cls, type) else _mw_cls

{tina4_python-3.13.46 → tina4_python-3.13.48}/tina4_python/i18n/__init__.py

@@ -9,10 +9,27 @@ Simple key-based translations loaded from JSON files.
     _("greeting")  # "Hello" or "Bonjour" depending on locale
 """
 import os
+import re
 import json
 from pathlib import Path
 
 
+_PLACEHOLDER = re.compile(r"\{(\w+)\}")
+
+
+def _interpolate(template: str, params: dict) -> str:
+    """Substitute {name} placeholders from params.
+
+    Partial + literal-leftover: a placeholder present in params is replaced; a
+    missing or malformed placeholder ({x.y}, {n:d}, a lone brace) is left
+    untouched. Never raises -- a bad template must not crash t().
+    """
+    return _PLACEHOLDER.sub(
+        lambda m: str(params[m.group(1)]) if m.group(1) in params else m.group(0),
+        template,
+    )
+
+
 class I18n:
     """Internationalization support with JSON translation files.
 
@@ -61,12 +78,11 @@ class I18n:
         if value is None:
             value = key
 
-        # Interpolate
+        # Interpolate {placeholder} tokens. Partial substitution: each token
+        # present in kwargs is replaced; a missing or malformed placeholder is
+        # left literal. Never raises (a bad template must not crash t()).
         if kwargs:
-            try:
-                value = value.format(**kwargs)
-            except (KeyError, IndexError):
-                pass
+            value = _interpolate(value, kwargs)
 
         return value
 
@@ -86,9 +102,10 @@ class I18n:
         if locale:
             old = self._current_locale
             self.locale = locale
-            result = self.t(key, **(params or {}))
-            self.locale = old
-            return result
+            try:
+                return self.t(key, **(params or {}))
+            finally:
+                self.locale = old
         return self.t(key, **(params or {}))
 
     def load_translations(self, locale: str) -> dict:
@@ -183,28 +200,50 @@ class I18n:
 
     @staticmethod
     def _flatten(data: dict, prefix: str = "") -> dict:
-        """Flatten nested dict with leaf-key aliasing.
+        """Flatten a nested dict to dot-paths, then add leaf-key aliases.
 
-        {"nav": {"home": "Home"}} → {"nav.home": "Home", "home": "Home"}
+        {"nav": {"home": "Home"}} -> {"nav.home": "Home", "home": "Home"}
 
-        Both the full dot-path AND the leaf key are stored, so templates
-        can use either ``t("home")`` or ``t("nav.home")``.  If two
-        sections define the same leaf key, the full dot-path always works
-        and the leaf key keeps whichever value was seen first.
+        Two passes so the alias rule is correct:
+        1. Flatten to full dot-path keys only.
+        2. Add each leaf key as a shortcut ONLY if it is not already present.
+
+        So the FIRST dot-path wins on a leaf-key collision, and an explicit
+        top-level flat key is never overwritten by a derived alias. (The old
+        single-pass recursive merge was last-wins and could clobber an
+        explicit flat key -- silent data loss.)
         """
+        flat = I18n._flatten_paths(data, prefix)
+        result = dict(flat)
+        for full_key, value in flat.items():
+            leaf = full_key.rsplit(".", 1)[-1]
+            if leaf not in result:
+                result[leaf] = value
+        return result
+
+    @staticmethod
+    def _flatten_paths(data: dict, prefix: str = "") -> dict:
+        """Flatten a nested dict to dot-path keys only (no leaf aliasing)."""
         result = {}
         for key, value in data.items():
             full_key = f"{prefix}.{key}" if prefix else key
             if isinstance(value, dict):
-                result.update(I18n._flatten(value, full_key))
+                result.update(I18n._flatten_paths(value, full_key))
             else:
-                str_value = str(value)
-                result[full_key] = str_value
-                # Also store the leaf key as a shortcut (first-wins on conflict)
-                if key not in result:
-                    result[key] = str_value
+                result[full_key] = I18n._coerce_scalar(value)
         return result
 
+    @staticmethod
+    def _coerce_scalar(value) -> str:
+        """Render a non-string locale scalar JSON-natively (true/false/null)."""
+        if value is True:
+            return "true"
+        if value is False:
+            return "false"
+        if value is None:
+            return "null"
+        return str(value)
+
     @staticmethod
     def _resolve(key: str, translations: dict) -> str | None:
         return translations.get(key)

{tina4_python-3.13.46 → tina4_python-3.13.48}/tina4_python/migration/runner.py

@@ -332,59 +332,137 @@ def _normalize_quotes(sql: str) -> str:
 
 
 def _split_statements(sql: str, delimiter: str = ";") -> list[str]:
-    """Split SQL into individual statements.
-
-    Handles:
-    - Line comments (-- ...)
-    - Block comments (/* ... */)
-    - Empty statements
-    - Stored procedure blocks delimited by $$ or //
-      Example:
-          CREATE TRIGGER foo $$ BEGIN ... END $$;
-          CREATE PROCEDURE bar // BEGIN ... END //;
+    """Split SQL into individual statements with a single-pass, quote- and
+    comment-aware scanner.
+
+    The split decision is made character by character so the delimiter only ever
+    fires in real statement position. This is the fix for issue #54: the old
+    implementation split on ``delimiter`` BEFORE stripping ``-- …`` line comments,
+    so a ``;`` *inside* a line comment fragmented one statement into several
+    broken pieces. A scanner that knows where it is — code, comment, or string —
+    cannot make that mistake.
+
+    Handled, in priority order, only when NOT already inside a stored-proc block:
+
+    - **Stored-procedure blocks** delimited by ``$$`` or ``//`` are kept intact
+      (their inner ``;`` never splits). A ``//`` preceded by ``:`` is a URL
+      scheme (``https://…``), not a block delimiter, so it is left alone.
+    - **Block comments** ``/* … */`` are stripped.
+    - **Line comments** ``-- …`` are stripped to end of line (the newline is
+      kept, so line structure survives). A ``;`` here never splits.
+    - **String literals** — single-quoted ``'…'`` and double-quoted identifiers
+      ``"…"`` — are copied verbatim, honouring the SQL doubled-quote escape
+      (``''`` / ``""``). A ``;``, ``--`` or ``/*`` inside a literal is data, not
+      a delimiter or comment, so it is preserved untouched.
+    - The **delimiter** ends a statement only when reached outside all of the
+      above. Empty statements are dropped; each kept statement is trimmed.
+
+    Smart/curly quotes are normalized to straight ASCII first. Mirrors the
+    tina4-php ``Migration::splitStatements`` scanner for cross-framework parity.
     """
     # Normalize smart/curly quotes to straight ASCII first, so SQL pasted from
     # an editor/doc (which converts " → “ ” and ' → ‘ ’) actually runs.
     sql = _normalize_quotes(sql)
 
-    # Extract blocks delimited by $$ or // first, replacing them with placeholders
-    blocks: list[str] = []
-
-    def _save_block(m):
-        blocks.append(m.group(0))
-        return f"__BLOCK_{len(blocks) - 1}__"
-
-    # Match $$ ... $$ or // ... // blocks (stored procedures, triggers, etc.).
-    # The `//` delimiters must NOT be preceded by a colon, so a URL scheme
-    # (`https://…`) or other `://` literal inside a migration is never captured
-    # as an opaque stored-proc block (it would otherwise swallow everything
-    # between two `//` occurrences and skip statement splitting/cleaning).
-    processed = re.sub(r"\$\$(.*?)\$\$", _save_block, sql, flags=re.DOTALL)
-    processed = re.sub(r"(?<!:)//(.*?)(?<!:)//", _save_block, processed, flags=re.DOTALL)
-
-    # Remove block comments (but not inside stored proc blocks)
-    clean = re.sub(r"/\*.*?\*/", "", processed, flags=re.DOTALL)
-
-    statements = []
-    for stmt in clean.split(delimiter):
-        # Remove line comments and blank lines
-        lines = []
-        for line in stmt.split("\n"):
-            stripped = line.strip()
-            if stripped and not stripped.startswith("--"):
-                # Remove inline comments (-- after SQL)
-                comment_pos = line.find("--")
-                if comment_pos >= 0:
-                    line = line[:comment_pos]
-                lines.append(line)
-        cleaned = "\n".join(lines).strip()
-
-        # Restore block placeholders
-        for i, block in enumerate(blocks):
-            cleaned = cleaned.replace(f"__BLOCK_{i}__", block)
-
-        if cleaned:
-            statements.append(cleaned)
+    statements: list[str] = []
+    current: list[str] = []
+    n = len(sql)
+    dlen = len(delimiter)
+    i = 0
+    in_dollar_block = False
+    in_slash_block = False
+
+    while i < n:
+        ch = sql[i]
+
+        # $$ … $$ stored-proc block (toggle in/out).
+        if not in_slash_block and ch == "$" and i + 1 < n and sql[i + 1] == "$":
+            current.append("$$")
+            i += 2
+            in_dollar_block = not in_dollar_block
+            continue
+
+        # // … // stored-proc block (toggle). The `//` must NOT be preceded by a
+        # colon, so a URL scheme (`https://…`) or any `://` literal is never
+        # treated as a block delimiter (it would otherwise swallow everything
+        # between two `//` occurrences and skip statement splitting).
+        if (not in_dollar_block and ch == "/" and i + 1 < n and sql[i + 1] == "/"
+                and not (i > 0 and sql[i - 1] == ":")):
+            current.append("//")
+            i += 2
+            in_slash_block = not in_slash_block
+            continue
+
+        # Inside a stored-proc block: consume verbatim (inner ; never splits).
+        if in_dollar_block or in_slash_block:
+            current.append(ch)
+            i += 1
+            continue
+
+        # Block comment /* … */ — stripped.
+        if ch == "/" and i + 1 < n and sql[i + 1] == "*":
+            end = sql.find("*/", i + 2)
+            i = (end + 2) if end != -1 else n
+            continue
+
+        # Line comment -- … — stripped to end of line; the newline is left for
+        # the next iteration so line structure (and statement boundaries on the
+        # NEXT line) survive. A ';' inside the comment is NOT a delimiter.
+        if ch == "-" and i + 1 < n and sql[i + 1] == "-":
+            end = sql.find("\n", i + 2)
+            i = end if end != -1 else n
+            continue
+
+        # Single-quoted string literal — '' escapes a quote. Copied verbatim so a
+        # ';' / '--' / '/*' inside the value is data, not a delimiter/comment.
+        if ch == "'":
+            current.append("'")
+            i += 1
+            while i < n:
+                if sql[i] == "'" and i + 1 < n and sql[i + 1] == "'":
+                    current.append("''")
+                    i += 2
+                elif sql[i] == "'":
+                    current.append("'")
+                    i += 1
+                    break
+                else:
+                    current.append(sql[i])
+                    i += 1
+            continue
+
+        # Double-quoted identifier — "" escapes a quote. Same verbatim handling.
+        if ch == '"':
+            current.append('"')
+            i += 1
+            while i < n:
+                if sql[i] == '"' and i + 1 < n and sql[i + 1] == '"':
+                    current.append('""')
+                    i += 2
+                elif sql[i] == '"':
+                    current.append('"')
+                    i += 1
+                    break
+                else:
+                    current.append(sql[i])
+                    i += 1
+            continue
+
+        # Statement delimiter — only reached outside blocks/comments/strings.
+        if delimiter and sql.startswith(delimiter, i):
+            stmt = "".join(current).strip()
+            if stmt:
+                statements.append(stmt)
+            current = []
+            i += dlen
+            continue
+
+        current.append(ch)
+        i += 1
+
+    stmt = "".join(current).strip()
+    if stmt:
+        statements.append(stmt)
     return statements
 
 

{tina4_python-3.13.46 → tina4_python-3.13.48}/tina4_python/scss/__init__.py

@@ -131,6 +131,9 @@ def _compile(scss: str) -> str:
     # 6. Resolve @extend
     scss = _resolve_extends(scss, placeholders)
 
+    # 6.5. Resolve #{ ... } interpolation (before $var substitution + nesting).
+    scss = _resolve_interpolation(scss, variables)
+
     # 7. Substitute variables
     scss = _substitute_variables(scss, variables)
 
@@ -171,6 +174,27 @@ def _substitute_variables(scss: str, variables: dict) -> str:
     return scss
 
 
+def _resolve_interpolation(scss: str, variables: dict) -> str:
+    """Resolve SCSS ``#{ ... }`` interpolation.
+
+    Each ``#{ expr }`` is replaced by its resolved inner text: a ``$variable``
+    inside the braces resolves to its value, anything else is inlined verbatim
+    (trimmed). This lets a value carry a variable inside a string context the
+    plain ``$var`` substitution can't reach — e.g. ``calc(100% - #{$gap})`` ->
+    ``calc(100% - 20px)`` — and lets a variable appear in a selector
+    (``.icon-#{$name}`` -> ``.icon-home``). Run BEFORE nested-rule flattening so
+    the literal ``{``/``}`` never confuse the block matcher. The inner cannot
+    contain braces (interpolation is a leaf expression), so ``[^{}]*`` is safe.
+    """
+    def _resolve(m):
+        inner = m.group(1).strip()
+        for name in sorted(variables.keys(), key=len, reverse=True):
+            inner = inner.replace(f"${name}", variables[name])
+        return inner
+
+    return re.sub(r'#\{([^{}]*)\}', _resolve, scss)
+
+
 def _extract_mixins(scss: str, mixins: dict) -> str:
     """Extract @mixin definitions."""
     pattern = re.compile(

{tina4_python-3.13.46 → tina4_python-3.13.48}/tina4_python/swagger/__init__.py

@@ -39,23 +39,11 @@ v3.13.42 — configurability for external/public APIs:
 import json
 import os
 import re
-import functools
 
 
 # ── Decorators ─────────────────────────────────────────────────
 # These attach metadata to route handlers for Swagger generation.
 
-# Every swagger attr a decorator may need to carry forward when it wraps a
-# handler that another decorator already annotated.
-_SWAGGER_ATTRS = (
-    "_swagger_description", "_swagger_detail", "_swagger_params", "_swagger_query",
-    "_swagger_summary", "_swagger_tags", "_swagger_example", "_swagger_example_content_type",
-    "_swagger_example_response", "_swagger_example_responses", "_swagger_deprecated",
-    "_swagger_model", "_swagger_model_list",
-    "_swagger_security", "_swagger_request_schema", "_swagger_response_schemas",
-)
-
-
 # ── Configuration registry ─────────────────────────────────────
 # Process-wide registries for security schemes and reusable component schemas
 # declared programmatically (Swagger.add_security_scheme / Swagger.add_schema).
@@ -65,13 +53,6 @@ _REGISTERED_SCHEMES: dict[str, dict] = {}
 _REGISTERED_SCHEMAS: dict[str, dict] = {}
 
 
-def _carry(fn, wrapper):
-    """Copy any already-set swagger attrs from fn onto wrapper (idempotent)."""
-    for attr in _SWAGGER_ATTRS:
-        if hasattr(fn, attr) and not hasattr(wrapper, attr):
-            setattr(wrapper, attr, getattr(fn, attr))
-
-
 def description(text: str = "", detail: str = "", params: dict | None = None,
                 query: dict | None = None):
     """Add a description, optional detail body, and parameter docs to a route.
@@ -99,19 +80,12 @@ def description(text: str = "", detail: str = "", params: dict | None = None,
             fn._swagger_params = params
         if query:
             fn._swagger_query = query
-
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_description = text
-        if detail:
-            wrapper._swagger_detail = detail
-        if params:
-            wrapper._swagger_params = params
-        if query:
-            wrapper._swagger_query = query
-        _carry(fn, wrapper)
-        return wrapper
+        # No wrapper: annotate the handler in place and return the SAME object.
+        # @get is innermost and registers this exact object, so every stacked
+        # decorator must land its metadata here. A wrapper would be registered
+        # by nothing (the outer decorators never reach the router) and silently
+        # drop all metadata except the decorator adjacent to @get.
+        return fn
     return decorator
 
 
@@ -119,12 +93,7 @@ def summary(text: str):
     """Add a short summary to a route handler."""
     def decorator(fn):
         fn._swagger_summary = text
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_summary = text
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -140,12 +109,7 @@ def tags(tag_list):
 
     def decorator(fn):
         fn._swagger_tags = tag_list
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_tags = tag_list
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -160,13 +124,7 @@ def example(data: dict | list, content_type: str = "application/json"):
     def decorator(fn):
         fn._swagger_example = data
         fn._swagger_example_content_type = content_type
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_example = data
-        wrapper._swagger_example_content_type = content_type
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -198,13 +156,7 @@ def example_response(status_or_data, data=None):
         responses[status_code] = body
         fn._swagger_example_responses = responses
         fn._swagger_example_response = body
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_example_responses = responses
-        wrapper._swagger_example_response = body
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -212,12 +164,7 @@ def deprecated():
     """Mark a route as deprecated."""
     def decorator(fn):
         fn._swagger_deprecated = True
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_deprecated = True
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -257,12 +204,7 @@ def security(scheme_or_reqs="bearerAuth", scopes=None):
     reqs = _normalize_security(scheme_or_reqs, scopes)
     def decorator(fn):
         fn._swagger_security = reqs
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_security = reqs
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -274,12 +216,7 @@ def request_schema(name: str, content_type: str = "application/json"):
     """
     def decorator(fn):
         fn._swagger_request_schema = (name, content_type)
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_request_schema = (name, content_type)
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -294,12 +231,7 @@ def response_schema(name: str, status: int = 200, is_list: bool = False):
         existing = dict(getattr(fn, "_swagger_response_schemas", {}) or {})
         existing[int(status)] = (name, bool(is_list))
         fn._swagger_response_schemas = existing
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_response_schemas = existing
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator