fix(python-codegen): honor field @default + make ruff optional at gen time

Two consumer-facing gaps:

1. @default was ignored by the entity/value model generator — every field came out
   `Type | None = None`. Now a field's @default is rendered: an enum member
   (`Type.MEMBER`, UPPER_CASE) or a Python literal (bool/int/float/str), and a
   defaulted field is emitted non-Optional (`numerical_type: NumericalType =
   NumericalType.NONE`). Lets a generated model carry its real defaults instead of
   forcing the consumer to re-apply them downstream.

2. `metaobjects gen` hard-failed with "No module named ruff" when ruff wasn't
   installed — but ruff is a codegen-time formatter, not a runtime requirement of the
   emitted code. ruff_format now no-ops (returns valid-but-unformatted source) when
   ruff is absent, while still raising if ruff IS present and fails (a generator bug).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dmealing

server/python/src/metaobjects/codegen/format.py

@@ -4,11 +4,17 @@
 formatted — i.e. `ruff check`- and `ruff format`-clean for downstream consumers."""
 from __future__ import annotations
 
+import importlib.util
 import subprocess
 import sys
 
 _STDIN_NAME = "generated.py"
 
+#: ruff is a codegen-time convenience (import-sort + format), not a runtime requirement
+#: of the emitted code. When it's absent we emit valid-but-unformatted Python rather
+#: than hard-failing the whole ``gen``.
+_RUFF_AVAILABLE = importlib.util.find_spec("ruff") is not None
+
 
 def _run_ruff(args: list[str], source: str) -> str:
     proc = subprocess.run(
@@ -24,7 +30,12 @@ def _run_ruff(args: list[str], source: str) -> str:
 
 def ruff_format(source: str) -> str:
     """Sort imports then format *source*; return the canonical text.
-    Raises RuntimeError if ruff fails (e.g. a syntax error in emitted code)."""
+
+    A no-op (returns *source* unchanged) when ruff is not installed — the emitted
+    code is still valid Python, just unformatted. Still raises RuntimeError if ruff
+    IS present but fails (e.g. a syntax error in emitted code — that's a generator bug)."""
+    if not _RUFF_AVAILABLE:
+        return source
     sorted_src = _run_ruff(
         ["check", "--select", "I", "--fix", "--stdin-filename", _STDIN_NAME, "-"], source
     )

server/python/src/metaobjects/codegen/generators/entity_model.py

@@ -114,15 +114,32 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
         if ref:
             imports.add(f"from .{ref} import {ref}")
     required = field.attr(fc.FIELD_ATTR_REQUIRED) is True
+    default_raw = field.attr(fc.FIELD_ATTR_DEFAULT)
+    has_default = default_raw is not None
+    enum_type_name = type_name if shared is not None else None
 
     constraints = _validator_constraints(field)
     # Emit kwargs in a stable order so generated output is deterministic.
     _order = ["pattern", "ge", "le", "min_length", "max_length"]
     parts = [f"{k}={constraints[k]!r}" for k in _order if k in constraints]
     uses_field = bool(parts)
 
-    annotation = type_expr if required else f"{type_expr} | None"
-    if required and uses_field:
+    # @default — render an enum member (Type.MEMBER, UPPER_CASE) or a Python literal.
+    if has_default:
+        if enum_type_name is not None and not field_is_array(field):
+            default_expr = f"{enum_type_name}.{str(default_raw).upper()}"
+        else:
+            default_expr = repr(default_raw)
+    else:
+        default_expr = None
+
+    # A field is Optional only when it is neither required nor carries a @default.
+    annotation = type_expr if (required or has_default) else f"{type_expr} | None"
+    if has_default and uses_field:
+        assignment = f" = Field(default={default_expr}, {', '.join(parts)})"
+    elif has_default:
+        assignment = f" = {default_expr}"
+    elif required and uses_field:
         assignment = f" = Field({', '.join(parts)})"
     elif required:
         assignment = ""

server/python/tests/codegen/test_entity_model.py

@@ -72,3 +72,20 @@ def test_nested_object_array_imports_ref() -> None:
     out = render_entity_model(e)
     assert "from .PostBrief import PostBrief" in out
     assert "posts: list[PostBrief] | None = None" in out
+
+
+def test_field_default_is_emitted_as_literal() -> None:
+    """@default renders a Python-literal default and makes the field non-Optional."""
+    flag = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_BOOLEAN, "flag")
+    flag.set_attr(fc.FIELD_ATTR_DEFAULT, False)
+    n = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_INT, "n")
+    n.set_attr(fc.FIELD_ATTR_DEFAULT, 1)
+    c = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_DOUBLE, "c")
+    c.set_attr(fc.FIELD_ATTR_DEFAULT, 0.5)
+    s = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_STRING, "s")
+    s.set_attr(fc.FIELD_ATTR_DEFAULT, "approx")
+    out = render_entity_model(_entity("M", [flag, n, c, s]))
+    assert "flag: bool = False" in out
+    assert "n: int = 1" in out
+    assert "c: float = 0.5" in out
+    assert "s: str = 'approx'" in out

server/python/tests/codegen/test_format.py

@@ -17,3 +17,14 @@ def test_ruff_format_sorts_imports() -> None:
     src = "from .local import L\nimport os\n\nfrom pydantic import BaseModel\n"
     out = ruff_format(src)
     assert out.index("import os") < out.index("from pydantic") < out.index("from .local import L")
+
+
+def test_ruff_format_no_op_when_ruff_absent(monkeypatch) -> None:
+    """ruff is a codegen-time convenience, not a runtime requirement — when it's not
+    installed, ruff_format returns the source unformatted (still valid Python) rather
+    than crashing the whole gen run."""
+    import metaobjects.codegen.format as fmt
+
+    monkeypatch.setattr(fmt, "_RUFF_AVAILABLE", False)
+    messy = "x={'a':1}\n"
+    assert fmt.ruff_format(messy) == messy