metaobjects 0.24.5__tar.gz → 1.0.0__tar.gz

{metaobjects-0.24.5 → metaobjects-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metaobjects
-Version: 0.24.5
+Version: 1.0.0
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.24.5 → metaobjects-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.24.5"
+version = "1.0.0"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.24.5 → metaobjects-1.0.0}/src/metaobjects/__init__.py

@@ -35,6 +35,7 @@ from .meta.core.object.object_extract import (
     extract_schema_for,
 )
 from .meta.core.object.value_object import ValueObject
+from .naming import resolve_column_name
 
 # Module-level shortcuts: the 99% case for callers who don't need a
 # long-lived loader. Signatures + docstrings come straight from the
@@ -58,6 +59,7 @@ __all__ = [
     "load_directory",
     "load_uris",
     "load_string",
+    "resolve_column_name",
     # Runtime object model (Phase A)
     "ValueObject",
     "MetaObjectAware",

{metaobjects-0.24.5 → metaobjects-1.0.0}/src/metaobjects/agent_context/scaffold.py

@@ -80,31 +80,112 @@ class Manifest:
 # The sentinel a port stamps when it cannot resolve its own installed version.
 _UNRESOLVED_VERSION = "0.0.0"
 
-_RELEASE_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)$")
-
-
-def _release_series(version: object) -> tuple[int, int] | None:
-    """Ordered release coordinate ``(minor, patch)``, or ``None`` when not orderable.
-
-    The MAJOR is deliberately dropped. It is a per-registry constant, not information:
-    npm/PyPI/NuGet ship ``0.<m>.<p>`` and Maven Central the same ``<m>.<p>`` on its
-    historical major ``7``, so minor.patch IS the shared release coordinate across all
-    four ports.
-
-    ``None`` means "not orderable, so nudge", and deliberately covers prereleases
-    (``0.24.5-rc.1``), build metadata (``0.24.5+abc``) and the ``0.0.0`` sentinel. Each
-    must keep nudging: an RC-scaffolded context against a final release is still worth
-    refreshing, and an unknown install must never assert "in sync".
+#: A release with an optional PRE-RELEASE segment, in either spelling one ecosystem uses.
+#: npm/NuGet/Maven write ``1.0.0-rc.5``; PEP 440 writes ``1.0.0rc5``. Both are the SAME
+#: release, and comparing their SPELLINGS is what made the nudge unsatisfiable — see
+#: ``_same_release``.
+_PRERELEASE_RE = re.compile(
+    r"^(\d+)\.(\d+)\.(\d+)"       # release
+    r"(?:-?([A-Za-z]+)\.?(\d+)?)?$"  # optional pre-release: -rc.5 | rc5 | -beta | b2
+)
+
+
+#: PEP 440 abbreviates the pre-release labels that npm spells out, and normalizing to ONE
+#: of them is what makes `1.1.0-beta.2` and `1.1.0b2` the same release. Only the spellings
+#: PEP 440 itself defines as equivalent — this is a rename table, not a similarity guess.
+_PEP440_LABEL_ALIASES = {
+    "a": "alpha",
+    "b": "beta",
+    "c": "rc",
+    "pre": "rc",
+    "preview": "rc",
+}
+
+
+def _release_coordinate(version: object) -> tuple[int, int, int, str, int] | None:
+    """``(major, minor, patch, pre_label, pre_number)`` for a version in ANY ecosystem
+    spelling.
+
+    The MAJOR is INFORMATION on this port, and both helpers here used to drop it. That
+    reduction is correct on the JVM and only there: Maven Central carries a historical
+    major of npm-major + 7 by design, so ``7.24.1`` and ``0.24.1`` genuinely name one
+    release and the coordinate must ignore the major to see it. Nothing of the kind holds
+    here — ``generatedBy`` is stamped by the Node CLI (an npm version) and
+    :func:`installed_metaobjects_version` reads the PyPI distribution version, and npm and
+    PyPI share the major by policy. Dropping it made ``1.0.0`` and ``2.0.0`` compare EQUAL,
+    and made a ``0.25.0``-stamped context read as NEWER than a ``1.0.0`` install — so the
+    1.0 upgrade, the single upgrade this advisory exists to catch, produced no nudge.
+
+    The pre-release label is lower-cased and its separators dropped, so ``-rc.5``,
+    ``rc5`` and ``-RC5`` all reduce to ``("rc", 5)``. A final release sorts ABOVE every
+    pre-release of the same number, which is what ``("", 0)`` vs ``("rc", 5)`` gives under
+    tuple ordering only because ``""`` < ``"rc"`` — so finals carry a sentinel label that
+    sorts last instead.
+
+    ``None`` means "not orderable, so nudge": the ``0.0.0`` unresolved-install sentinel,
+    build metadata, or anything this cannot parse. Those must never assert "in sync".
     """
     if not isinstance(version, str):
         return None
     v = version.strip()
     if v == _UNRESOLVED_VERSION:
         return None
-    m = _RELEASE_RE.match(v)
+    m = _PRERELEASE_RE.match(v)
     if m is None:
         return None
-    return int(m.group(2)), int(m.group(3))
+    label = _PEP440_LABEL_ALIASES.get((m.group(4) or "").lower(), (m.group(4) or "").lower())
+    number = int(m.group(5)) if m.group(5) is not None else 0
+    # A FINAL release is newer than every pre-release of the same number. "~" sorts above
+    # every ASCII letter, so the sentinel does that with plain tuple comparison.
+    return (
+        int(m.group(1)),
+        int(m.group(2)),
+        int(m.group(3)),
+        label if label else "~",
+        number,
+    )
+
+
+def _same_release(generated_by: object, current_version: str) -> bool:
+    """True when two version strings name the SAME release in different spellings.
+
+    The nudge compared spellings, so on the 1.0 RC line it could never be satisfied: the
+    canonical scaffolder is the Node CLI (ADR-0033), which stamps npm's ``1.0.0-rc.5``,
+    while this port reports PEP 440's ``1.0.0rc5``. Those are one release written two
+    ways, ``==`` says otherwise, and the remedy re-runs the scaffolder, which re-stamps
+    the same npm string — so the advisory fires on every invocation, forever, including
+    when the context is perfectly in sync. That is issue #347 with a different pair of
+    ecosystems; the fix for it reasoned about ORDERING and never about spelling.
+
+    Deliberately narrow. Only two versions that parse as the same release coordinate are
+    equal; anything unparseable (including the ``0.0.0`` sentinel) still nudges, and an
+    ``rc.4`` context against an ``rc.5`` install is a REAL difference and still nudges.
+    """
+    stamped = _release_coordinate(generated_by)
+    installed = _release_coordinate(current_version)
+    return stamped is not None and stamped == installed
+
+
+def _release_series(version: object) -> tuple[int, int, int] | None:
+    """Ordered release coordinate ``(major, minor, patch)``, or ``None`` when not orderable.
+
+    Derived from :func:`_release_coordinate` rather than parsed again. These two functions
+    used to answer the same grammar with two different regexes — differential-checked
+    identical over 200k inputs, which is the good outcome of a coin flip, not a guarantee.
+    The ordering coordinate simply IS the equality coordinate restricted to FINAL releases,
+    and saying so in code means the two cannot drift apart.
+
+    ``None`` means "not orderable, so nudge", and deliberately covers prereleases
+    (``0.24.5-rc.1``, ``1.0.0rc5``), build metadata (``0.24.5+abc``) and the ``0.0.0``
+    sentinel. Each must keep nudging: an RC-scaffolded context against a final release is
+    still worth refreshing, and an unknown install must never assert "in sync".
+    """
+    coord = _release_coordinate(version)
+    # A pre-release carries a real label; a final carries the "~" sentinel. Only finals are
+    # orderable here, which is what the previous release-only regex enforced by construction.
+    if coord is None or coord[3] != "~":
+        return None
+    return coord[0], coord[1], coord[2]
 
 
 def _context_is_ahead_of_install(generated_by: object, current_version: str) -> bool:
@@ -141,16 +222,19 @@ def agent_context_staleness(
     is in sync — and a one-line advisory message otherwise. Pure + advisory:
     never raises, never blocks, never writes.
 
-    The comparison is **exact equality** first: ANY drift nudges (a re-scaffold is
-    cheap + idempotent), so this is not a semver compare — a prerelease or
-    build-metadata difference is still a reason to refresh. See
-    ``_context_is_ahead_of_install`` for the ONE case that is exempt.
+    ANY REAL drift nudges (a re-scaffold is cheap + idempotent), so this is not a semver
+    compare — an ``rc.4`` context against an ``rc.5`` install is still a reason to
+    refresh. Two exemptions, both for cases where nudging can never be SATISFIED:
+    ``_same_release`` (one release, two ecosystem spellings) and
+    ``_context_is_ahead_of_install`` (a port legitimately behind the npm scaffolder).
     """
     if manifest is None:
         return None  # no agent context here → nothing to nudge
     generated_by = manifest.get("generatedBy")
     if generated_by == current_version:
         return None  # in sync
+    if _same_release(generated_by, current_version):
+        return None  # one release, two ecosystem spellings — see below
     if _context_is_ahead_of_install(generated_by, current_version):
         return None  # scaffolded by a NEWER release than this install — see below
     frm = generated_by if generated_by else "an older MetaObjects"

{metaobjects-0.24.5 → metaobjects-1.0.0}/src/metaobjects/apidocs/builder.py

@@ -4,7 +4,7 @@ This is the ACCURATE-BY-CONSTRUCTION half of the api-docs pipeline: every
 documented symbol name comes from the :mod:`metaobjects.apidocs.naming` seam (never
 re-concatenated here — the SAME seam the real generators delegate to), and every
 inclusion decision comes from an applies-predicate that REUSES the corresponding
-generator's own gate helpers (``emits_instance_artifacts`` / ``_primary_source_rdb``
+generator's own gate helpers (``emits_instance_artifacts`` / ``primary_rdb_source``
 + source kind / ``resolve_payload_vo`` / format check / ``is_tph_subtype``) rather
 than re-implementing the gate. The result is that what this builder documents ==
 what the generators emit, by SHARING the single source of truth.
@@ -47,9 +47,9 @@ from metaobjects.codegen.generators.payload_vo_generator import (
     is_field_required,
     resolve_payload_vo,
 )
-from metaobjects.codegen.generators.router_generator import _primary_source_rdb
 from metaobjects.codegen.generators.tph_plan import is_tph_subtype
 from metaobjects.codegen.instance_artifacts import emits_instance_artifacts, is_abstract
+from metaobjects.source_resolution import primary_rdb_source
 from metaobjects.meta.core.field import field_constants as fc
 from metaobjects.meta.core.field.meta_field import MetaField
 from metaobjects.meta.core.object.meta_object import MetaObject
@@ -91,7 +91,7 @@ def _is_writable_table_entity(obj: MetaObject, object_index: dict[str, MetaObjec
         return False
     if is_tph_subtype(obj):
         return False
-    src = _primary_source_rdb(obj)
+    src = primary_rdb_source(obj)
     if src is None:
         return False
     return src.effective_kind() == SOURCE_KIND_TABLE
@@ -261,7 +261,13 @@ class PythonApiModelBuilder:
         add("PUT " + item, "update (PUT alias)")
         add("DELETE " + item, "delete")
 
-        # M:N traversal — GET /<source-plural>/{id}/<relation>.
+        # M:N traversal — GET /<source-plural>/{id}/<relation>. `docs` has no
+        # `GenConfig`/`--column-naming` of its own (see `cli.py`'s docs handler) and
+        # this loop reads only `.target_entity` / `.relation_name` off the
+        # descriptor — never a physical column/table name — so resolving it under
+        # the port default here changes nothing observable; threading a naming
+        # strategy through would mean inventing a config seam this command doesn't
+        # have, for a value nothing here would read.
         for d in resolve_m2m_descriptors(entity, object_index):
             target = object_index.get(d.target_entity)
             target_name = target.name if target is not None else d.target_entity