tina4-python 3.13.89__tar.gz → 3.13.91__tar.gz

{tina4_python-3.13.89 → tina4_python-3.13.91}/PKG-INFO

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

{tina4_python-3.13.89 → tina4_python-3.13.91}/pyproject.toml

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

{tina4_python-3.13.89 → tina4_python-3.13.91}/tina4_python/cli/__init__.py

@@ -1766,7 +1766,9 @@ def _sample_literal(field_type: str) -> str:
 
 def _emit_model_test(model: str, table: str, fields: list) -> None:
     """model → real SQLite roundtrip (create / read back / missing → None)."""
-    fields = fields or [("name", "string")]
+    # Reuse the single DEFAULT_FIELDS constant rather than re-stating the literal,
+    # so the co-emitted test can never describe a shape the model does not have.
+    fields = fields or list(DEFAULT_FIELDS)
     payload = ", ".join(f'"{fname}": {_sample_literal(ftype)}' for fname, ftype in fields)
     # Assert a STRING field round-trips (type-safe); else just the id round-trips
     # (avoids datetime/bool/float equality pitfalls on the read-back).
@@ -2615,7 +2617,7 @@ def _gen_form(name: str, flags: dict = None):
     tina4python generate form Product --fields "name:string,price:float"
     """
     flags = flags or {}
-    fields = _parse_fields(flags.get("fields", ""))
+    fields = _fields_or_default(flags.get("fields", ""))
     table = _to_table(name)
     route_name = table + "s"
 
@@ -2637,7 +2639,7 @@ def _gen_form(name: str, flags: dict = None):
 
     # Build form fields
     field_html = ""
-    for fname, ftype in (fields or [("name", "string")]):
+    for fname, ftype in fields:
         itype = input_types.get(ftype, "text")
         label = fname.replace("_", " ").title()
         step = ' step="0.01"' if ftype in ("float", "numeric", "decimal") else ""

{tina4_python-3.13.89 → tina4_python-3.13.91}/tina4_python/dev_admin/__init__.py

@@ -2041,9 +2041,19 @@ async def _api_metrics(request, response):
 
 
 async def _api_metrics_full(request, response):
-    """Full analysis — AST-based, cached 60s."""
-    from tina4_python.dev_admin.metrics import full_analysis
-    return response(full_analysis())
+    """Full analysis — from the tina4 CLI metrics engine, else the local module.
+
+    The engine (ADR-0002) resolves imports to real file paths, so it is the only
+    source with usable coupling data. It returns None when it is absent or too
+    old to emit a field the dashboard renders, and we fall back rather than
+    serve a payload with holes in it.
+    """
+    from tina4_python.dev_admin.metrics import full_analysis, resolve_scan_target
+    from tina4_python.dev_admin.metrics_engine import engine_analysis
+
+    root, scan_mode = resolve_scan_target()
+    from_engine = engine_analysis(root, scan_mode)
+    return response(from_engine if from_engine is not None else full_analysis())
 
 
 async def _api_metrics_file(request, response):

{tina4_python-3.13.89 → tina4_python-3.13.91}/tina4_python/dev_admin/metrics.py

@@ -23,6 +23,18 @@ _last_scan_root: str = ""
 # ── Quick Metrics ──────────────────────────────────────────────
 
 
+def _is_code_line(line: str) -> bool:
+    """True for a line that counts toward LOC: not blank, not a comment.
+
+    The single definition of the rule. It used to be restated at each file-level
+    call site while function LOC ignored it entirely and returned a raw line
+    span, so `loc` meant two different things in one payload - see
+    _function_loc.
+    """
+    stripped = line.strip()
+    return bool(stripped) and not stripped.startswith("#")
+
+
 def _resolve_root(root: str = "src") -> str:
     """Pick the right directory to scan.
 
@@ -41,6 +53,23 @@ def _resolve_root(root: str = "src") -> str:
     return framework_dir
 
 
+def resolve_scan_target(root: str = "src") -> tuple[str, str]:
+    """Return (directory to scan, scan_mode) for any metrics producer.
+
+    The CLI engine is language-agnostic and cannot know which directory holds a
+    framework package, so root resolution and the "framework" label stay here -
+    shared by this module and the engine adapter so the two never disagree about
+    what was measured.
+    """
+    resolved = _resolve_root(root)
+    framework_dir = str(Path(__import__("tina4_python").__file__).parent)
+    resolved_path = Path(resolved)
+    scanning_framework = (
+        resolved_path == Path(framework_dir) or str(resolved_path).startswith(framework_dir)
+    )
+    return resolved, "framework" if scanning_framework else "project"
+
+
 def quick_metrics(root: str = "src") -> dict:
     """Scan project files and return instant metrics."""
     root = _resolve_root(root)
@@ -224,7 +253,7 @@ def full_analysis(root: str = "src") -> dict:
         except ValueError:
             rel_path = (str(f.relative_to(root_path.parent)) if root_path.parent != f else f.name).replace("\\", "/")
         lines = source.splitlines()
-        loc = sum(1 for l in lines if l.strip() and not l.strip().startswith("#"))
+        loc = sum(1 for l in lines if _is_code_line(l))
 
         # Extract imports for coupling analysis
         imports = _extract_imports(tree, rel_path)
@@ -491,7 +520,7 @@ def file_detail(file_path: str) -> dict:
 
     functions.sort(key=lambda x: x["complexity"], reverse=True)
 
-    loc = sum(1 for l in lines if l.strip() and not l.strip().startswith("#"))
+    loc = sum(1 for l in lines if _is_code_line(l))
     classes = sum(1 for n in ast.walk(tree) if isinstance(n, ast.ClassDef))
     imports = _extract_imports(tree, file_path)
 
@@ -526,13 +555,37 @@ def file_detail(file_path: str) -> dict:
 # ── AST Helpers ────────────────────────────────────────────────
 
 
+def _own_body_nodes(node: ast.AST):
+    """Yield the nodes belonging to this function's OWN body.
+
+    Nested function and class definitions are skipped: they are reported as
+    functions in their own right, so counting their decision points here too
+    would charge one branch to two different functions. That over-count grew
+    with nesting depth - an IIFE-style wrapper or a registrar that defines
+    twenty inner handlers absorbed the entire file's complexity and sat at the
+    top of the offenders list while the real hot spots hid below it.
+
+    A lambda is NOT skipped. Lambdas are never listed as separate functions, so
+    their decision points would simply vanish; they stay with the function that
+    encloses them.
+    """
+    stack = list(ast.iter_child_nodes(node))
+    while stack:
+        child = stack.pop()
+        if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            continue
+        yield child
+        stack.extend(ast.iter_child_nodes(child))
+
+
 def _cyclomatic_complexity(node: ast.AST) -> int:
     """Calculate cyclomatic complexity for a function/method node.
 
     CC = 1 + number of decision points (if/elif/for/while/except/and/or/assert)
+    in the function's own body. Nested functions are measured separately.
     """
     cc = 1
-    for child in ast.walk(node):
+    for child in _own_body_nodes(node):
         if isinstance(child, (ast.If, ast.IfExp)):
             cc += 1
         elif isinstance(child, ast.For):
@@ -553,9 +606,18 @@ def _cyclomatic_complexity(node: ast.AST) -> int:
 
 
 def _function_loc(node: ast.AST, lines: list) -> int:
-    """Count lines of code in a function."""
+    """Count lines of CODE in a function, by the same rule as file-level LOC.
+
+    This returned `end_lineno - lineno + 1` - a raw line span - while the
+    docstring claimed lines of code and every file-level LOC excluded blanks and
+    comments. So a function's LOC and its file's LOC were different units sitting
+    side by side in the dashboard, and the maintainability index (which divides
+    by LOC) penalised a well-commented function for its comments.
+    """
     if hasattr(node, "end_lineno") and node.end_lineno:
-        return node.end_lineno - node.lineno + 1
+        span = lines[node.lineno - 1:node.end_lineno]
+        # Floor of 1: a one-line body must never report 0.
+        return max(1, sum(1 for l in span if _is_code_line(l)))
     # Fallback: count indented lines
     start = node.lineno - 1
     count = 1

tina4_python-3.13.91/tina4_python/dev_admin/metrics_engine.py

@@ -0,0 +1,108 @@
+"""Code metrics from the tina4 CLI engine (ADR-0002).
+
+The metrics engine now lives in the Rust CLI: one tree-sitter implementation
+covering every language, instead of a hand-rolled AST walker per framework. This
+adapter shells out to it and reshapes the payload into the dashboard's contract.
+
+It returns None whenever the CLI cannot supply a COMPLETE payload - no binary on
+PATH, a non-zero exit, unparseable JSON, or an older CLI whose engine predates a
+field the dashboard renders. The caller then falls back to the in-framework
+module, so a stale CLI degrades quietly instead of blanking the chart.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+# The dashboard reads these at the top level; the CLI nests them under "summary"
+# because its own text report and the --fail-on gate group them there.
+_SUMMARY_KEYS = (
+    "files_analyzed",
+    "total_functions",
+    "avg_complexity",
+    "avg_maintainability",
+)
+
+# Fields the dashboard renders that a pre-3.8.59 engine does not emit. Checking
+# for the DATA is honest where checking a version string is not: a user may run
+# any CLI build, and the payload tells us what it can actually do.
+_REQUIRED_FILE_KEYS = ("path", "loc", "avg_complexity", "maintainability", "has_tests")
+_REQUIRED_FUNCTION_KEYS = ("name", "file", "line", "complexity", "loc")
+
+_TIMEOUT_SECONDS = 60
+
+
+def engine_path() -> str | None:
+    """Absolute path to the tina4 CLI binary, or None when it is not installed."""
+    return shutil.which("tina4")
+
+
+def engine_analysis(root: str, scan_mode: str = "project") -> dict | None:
+    """Run `tina4 metrics --json` over root and adapt it to the dashboard shape.
+
+    The framework passes --path and owns scan_mode: it knows where its own
+    package lives, and the engine is deliberately language-agnostic, so root
+    resolution stays on this side of the boundary.
+    """
+    binary = engine_path()
+    if binary is None:
+        return None
+
+    try:
+        proc = subprocess.run(
+            [binary, "metrics", "--path", str(root), "--json"],
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+    if proc.returncode != 0 or not proc.stdout.strip():
+        return None
+
+    try:
+        payload = json.loads(proc.stdout)
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+    return adapt_payload(payload, root, scan_mode)
+
+
+def adapt_payload(payload: dict, root: str, scan_mode: str = "project") -> dict | None:
+    """Flatten the engine payload into the dashboard contract, or None if short.
+
+    Split out from engine_analysis so the reshaping is testable without a
+    subprocess - the shaping is where the contract actually lives.
+    """
+    if not isinstance(payload, dict):
+        return None
+
+    summary = payload.get("summary")
+    file_metrics = payload.get("file_metrics")
+    functions = payload.get("most_complex_functions")
+    if not isinstance(summary, dict) or not isinstance(file_metrics, list):
+        return None
+    if not isinstance(functions, list):
+        return None
+
+    if any(key not in summary for key in _SUMMARY_KEYS):
+        return None
+    if file_metrics and any(key not in file_metrics[0] for key in _REQUIRED_FILE_KEYS):
+        return None
+    if functions and any(key not in functions[0] for key in _REQUIRED_FUNCTION_KEYS):
+        return None
+
+    result = {key: summary[key] for key in _SUMMARY_KEYS}
+    result["file_metrics"] = file_metrics
+    result["most_complex_functions"] = functions[:15]
+    result["dependency_graph"] = payload.get("dependency_graph") or {}
+    # The framework decides these two - the engine always reports "project"
+    # because it cannot know which directory is a framework package.
+    result["scan_mode"] = scan_mode
+    result["scan_root"] = str(Path(root).resolve())
+    result["engine"] = "tina4-cli"
+    return result