alterdb 0.2.2__tar.gz → 0.2.3__tar.gz

{alterdb-0.2.2 → alterdb-0.2.3}/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 All notable changes to Alter are documented here.
 
+## [0.2.3] — 2026-03-15
+
+### Bug Fixes
+
+#### `alter mcp` crashes with a cryptic `ModuleNotFoundError` when `mcp < 1.2.0` (Bug A)
+
+`alter mcp` calls `init_mcp()` which imports `FastMCP` from `mcp.server.fastmcp`. That
+submodule was introduced in `mcp 1.2.0`; older installations raise a bare
+`ModuleNotFoundError: No module named 'mcp.server.fastmcp'` with no indication of how
+to fix it.
+
+`init_mcp()` now wraps the import in a `try/except ImportError` and raises an
+`AlterError` with an actionable message:
+
+```
+'alter mcp' requires mcp>=1.2.0, but mcp==1.1.3 is installed.
+Upgrade with: pip install 'mcp>=1.2.0'
+```
+
+The error surfaces cleanly in the CLI (no "MCP server error:" prefix) because the CLI
+already handles `AlterError` separately from generic exceptions.
+
+A second guard wraps the cosmetic `_mcp_server.version` assignment in
+`try/except AttributeError` so that future changes to `mcp` internals do not break
+`alter mcp` startup.
+
+#### `alter apply` spuriously rewrites `datetime.now(timezone.utc)` defaults on Python 3.11+ (Bug B)
+
+When a model file contained a column with `default_factory=lambda: datetime.now(timezone.utc)`,
+running `alter apply` on Python 3.11+ would rewrite the line even though nothing had
+changed in the schema.
+
+Root cause: `_parse_field_kwargs` normalises kwargs via `ast.unparse`, and the Python
+`ast` module changed how it serialises zero-argument lambdas between versions —
+Python ≤ 3.10 produces `"lambda :"` (with a space after `lambda`), while Python 3.11+
+produces `"lambda:"` (no space). Because `ast.unparse` is applied to both the
+existing code and the freshly generated schema line, the comparison reached different
+sides of the `_DEFAULT_FACTORY_EQUIV` lookup depending on the Python version in use,
+causing the surgical patcher to believe a change was needed when there was none.
+
+Two-part fix in `generators/_surgical.py`:
+
+1. **`_norm_lambda_ws()` helper** — strips extraneous whitespace between `lambda` and
+   `:` for zero-argument lambdas (`re.sub(r"^lambda\s*:", "lambda:", s)`), making
+   lambda strings compare equal across Python versions.
+
+2. **Normalization applied consistently** — `_normalize_kw_for_eq` now calls
+   `_norm_lambda_ws` on `default_factory` values after the `_DEFAULT_FACTORY_EQUIV`
+   lookup, so both the existing-file side and the schema side are normalised before
+   comparison. The rebuild path in `_rebuild_field_line` applies the same
+   normalization when checking whether the existing value is canonically equivalent.
+
+The `_DEFAULT_FACTORY_EQUIV` dict value for `utcnow` was also corrected from
+`"lambda : datetime.now(timezone.utc)"` (with spurious space, matching old Python 3.10
+`ast.unparse` output) to `"lambda: datetime.now(timezone.utc)"` (canonical form) — the
+`_norm_lambda_ws` normalization then makes both forms match on all Python versions.
+
+---
+
 ## [0.2.2] — 2026-03-15
 
 ### Bug Fixes

{alterdb-0.2.2 → alterdb-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alterdb
-Version: 0.2.2
+Version: 0.2.3
 Summary: Visual schema design for SQLModel and SQLAlchemy. Edit your database as a diagram, write it back as code.
 Project-URL: Homepage, https://github.com/chimi-labs/alter
 Project-URL: Repository, https://github.com/chimi-labs/alter

{alterdb-0.2.2 → alterdb-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alterdb"
-version = "0.2.2"
+version = "0.2.3"
 description = "Visual schema design for SQLModel and SQLAlchemy. Edit your database as a diagram, write it back as code."
 license = "MIT"
 license-files = ["LICENSE"]

{alterdb-0.2.2 → alterdb-0.2.3}/src/alter/generators/_surgical.py

@@ -280,9 +280,15 @@ _DEFAULT_FACTORY_EQUIV: dict[str, str] = {
     # modern lambda form.  Treat both as semantically identical so existing
     # hand-written code is never touched unless the field actually changes.
     #
-    # NOTE: the canonical form uses the exact string produced by ast.unparse(),
-    # which inserts a space between "lambda" and ":" (i.e. "lambda :").
-    "datetime.utcnow": "lambda : datetime.now(timezone.utc)",
+    # NOTE: ast.unparse() output for zero-argument lambdas varies by version:
+    # Python <=3.10 produces "lambda :" (with space before colon);
+    # Python 3.11+   produces "lambda:"  (no space).
+    # _parse_field_kwargs uses ast.unparse on BOTH the existing and generated
+    # sides, so the raw strings here may differ by a single space depending on
+    # the interpreter.  _normalize_kw_for_eq() normalises this via
+    # _norm_lambda_ws() after the dict lookup, so the value stored here only
+    # needs to be recognisable — the no-space form (3.11 canonical) is used.
+    "datetime.utcnow": "lambda: datetime.now(timezone.utc)",
     # uuid4 (from `from uuid import uuid4`) and uuid.uuid4 (from `import uuid`)
     # are semantically identical.  Treat them as equal so existing hand-written
     # code using the direct-import form is never touched.
@@ -290,6 +296,22 @@ _DEFAULT_FACTORY_EQUIV: dict[str, str] = {
 }
 
 
+def _norm_lambda_ws(s: str) -> str:
+    """Normalise zero-argument lambda whitespace for cross-version compat.
+
+    ``ast.unparse()`` output for ``lambda: …`` differs between Python versions:
+    * Python <=3.10: ``"lambda : expr"`` (space before colon)
+    * Python  3.11+: ``"lambda: expr"``  (no space)
+
+    Both sides of an equality comparison go through ``ast.unparse`` (via
+    ``_parse_field_kwargs``), so we must normalise before comparing to avoid
+    spurious rewrites depending on which Python is running.
+    """
+    if s.startswith("lambda"):
+        return re.sub(r"^lambda\s*:", "lambda:", s)
+    return s
+
+
 def _normalize_kw_for_eq(kw: dict[str, str]) -> dict[str, str]:
     """Normalise mutable-default equivalents to a single canonical form.
 
@@ -301,6 +323,10 @@ def _normalize_kw_for_eq(kw: dict[str, str]) -> dict[str, str]:
     ``datetime.utcnow`` → ``lambda: datetime.now(timezone.utc)``) so that
     fields using the deprecated form are not spuriously rewritten just because
     the generator produces the modern form.
+
+    Finally normalises zero-argument lambda whitespace via ``_norm_lambda_ws``
+    so that ``"lambda :"`` (Python <=3.10 ast.unparse) and ``"lambda:"``
+    (Python 3.11+) compare as equal.
     """
     result = dict(kw)
     for (old_key, old_val), (new_key, new_val) in _MUTABLE_DEFAULT_EQUIV.items():
@@ -309,7 +335,8 @@ def _normalize_kw_for_eq(kw: dict[str, str]) -> dict[str, str]:
             result[new_key] = new_val
     if "default_factory" in result:
         val = result["default_factory"]
-        result["default_factory"] = _DEFAULT_FACTORY_EQUIV.get(val, val)
+        val = _DEFAULT_FACTORY_EQUIV.get(val, val)
+        result["default_factory"] = _norm_lambda_ws(val)
     return result
 
 
@@ -458,10 +485,14 @@ def _rebuild_field_line(
             val = new_kw[key]
             if key.startswith("__pos_"):
                 merged.append(val)  # positional
-            elif key == "default_factory" and _DEFAULT_FACTORY_EQUIV.get(existing_val) == val:
+            elif key == "default_factory" and (
+                (_canon := _DEFAULT_FACTORY_EQUIV.get(existing_val)) is not None
+                and _norm_lambda_ws(_canon) == _norm_lambda_ws(val)
+            ):
                 # The existing value is a known equivalent of what the generator
                 # produces (e.g. datetime.utcnow ↔ lambda: datetime.now(timezone.utc),
-                # uuid4 ↔ uuid.uuid4).
+                # uuid4 ↔ uuid.uuid4).  Normalise lambda whitespace on both sides
+                # for Python 3.10/3.11 ast.unparse compat.
                 # Preserve the user's original form so we don't introduce noisy diffs.
                 merged.append(f"default_factory={existing_val}")
             elif existing_val == val and key in existing_raw:

{alterdb-0.2.2 → alterdb-0.2.3}/src/alter/mcp_server.py

@@ -128,10 +128,24 @@ def init_mcp(alter_file_path: Path) -> None:
     global _staging, _path
     _path = alter_file_path
     _staging = StagingManager(alter_file_path)
-    from mcp.server.fastmcp import FastMCP  # noqa: PLC0415
+    try:
+        from mcp.server.fastmcp import FastMCP  # noqa: PLC0415
+    except ImportError:
+        import importlib.metadata as _meta  # noqa: PLC0415
+        try:
+            _ver = _meta.version("mcp")
+        except _meta.PackageNotFoundError:
+            _ver = "unknown"
+        raise AlterError(
+            f"'alter mcp' requires mcp>=1.2.0, but mcp=={_ver} is installed. "
+            f"Upgrade with: pip install 'mcp>=1.2.0'"
+        ) from None
     from alter import __version__  # noqa: PLC0415
     real_mcp = FastMCP("Alter")
-    real_mcp._mcp_server.version = __version__
+    try:
+        real_mcp._mcp_server.version = __version__
+    except AttributeError:
+        pass  # mcp internals changed — version label is cosmetic, not critical
     mcp._init_real(real_mcp)