omop-semantics 0.2.0__tar.gz → 0.2.2__tar.gz

omop_semantics-0.2.2/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.3
+Name: omop-semantics
+Version: 0.2.2
+Summary: Define, validate, and use schema-backed semantic conventions for OMOP CDM
+Author: gkennos
+Author-email: gkennos <georgina.kennedy@unsw.edu.au>
+Requires-Dist: ipykernel>=7.2.0
+Requires-Dist: linkml>=1.11.1
+Requires-Dist: linkml-runtime>=1.11.1
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: ruamel-yaml>=0.18.17
+Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: urllib3>=2.7.0
+Requires-Dist: ipython>=8.0 ; extra == 'dev'
+Requires-Dist: pytest>=9.0.3 ; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.8 ; extra == 'dev'
+Requires-Dist: ruff>=0.4 ; extra == 'dev'
+Requires-Dist: rich>=13.0 ; extra == 'dev'
+Requires-Dist: tornado>=6.5.5 ; extra == 'dev'
+Requires-Dist: pygments>=2.20.0 ; extra == 'dev'
+Requires-Dist: mkdocs-material>=9.7.6 ; extra == 'docs'
+Requires-Dist: mkdocstrings-python>=2.0.1 ; extra == 'docs'
+Requires-Dist: mkdocs>=1.6.1 ; extra == 'docs'
+Requires-Dist: mkdocs-mermaid2-plugin>=1.2.3 ; extra == 'docs'
+Requires-Dist: pygments>=2.20.0 ; extra == 'docs'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://australiancancerdatanetwork.github.io/omop-semantics/
+Project-URL: Repository, https://github.com/AustralianCancerDataNetwork/omop-semantics
+Project-URL: Issues, https://github.com/AustralianCancerDataNetwork/omop-semantics/issues
+Provides-Extra: dev
+Provides-Extra: docs
+Description-Content-Type: text/markdown
+
+# omop-semantics
+
+**omop-semantics** is a Python library for defining and managing **semantic conventions on top of OMOP CDM**.
+
+It gives you a structured, versioned, portable layer for describing which OMOP concepts are valid in a given context, how they map to CDM row shapes, and what fallback concepts to use when a mapping cannot be completed. Conventions are authored in YAML, validated against schemas, and exposed as typed Python objects — not scattered across ETL code, SQL, or documentation.
+
+---
+
+## Three runtime surfaces
+
+- **Value-set runtime**  
+  Stable named concept ids for application logic:  
+  `from omop_semantics.runtime.default_valuesets import runtime`
+
+- **Template/profile runtime**  
+  Compiled semantic templates and CDM profiles via `OmopSemanticEngine`.
+
+- **Fallback concepts**  
+  Canonical unknown and default concepts with reason codes:  
+  `from omop_semantics.unknowns import UNKNOWN`
+
+---
+
+## Key properties
+
+- **Portable** — no database or vocabulary graph required
+- **Versionable** — conventions are tracked in git alongside code
+- **Extensible** — add project-specific definitions on top of the shipped ones
+- **Integrates with pipelines** — drives ETL logic, validation, and documentation from a single source
+
+---
+
+## When to use this
+
+Use **omop-semantics** if you:
+
+- have project-specific rules about which OMOP concepts are valid,
+- need consistent concept groupings across ETL and analytics,
+- want semantic conventions to be explicit, testable, and versioned,
+- are working in domains like oncology where OMOP alone is too permissive.
+
+---
+
+## Docs
+
+- [Usage](docs/usage.md) — loading paths and code patterns
+- [Data Model](docs/data-model.md) — profiles, templates, and semantic objects
+- [Schema & Instances](docs/schema-and-instances.md) — authoring assets and file organisation
+- [Fallback Concepts](docs/unknowns.md) — the shipped unknown and default concepts
+- [Internals](docs/internals.md) — package structure and load-time behaviour

omop_semantics-0.2.2/README.md

@@ -0,0 +1,50 @@
+# omop-semantics
+
+**omop-semantics** is a Python library for defining and managing **semantic conventions on top of OMOP CDM**.
+
+It gives you a structured, versioned, portable layer for describing which OMOP concepts are valid in a given context, how they map to CDM row shapes, and what fallback concepts to use when a mapping cannot be completed. Conventions are authored in YAML, validated against schemas, and exposed as typed Python objects — not scattered across ETL code, SQL, or documentation.
+
+---
+
+## Three runtime surfaces
+
+- **Value-set runtime**  
+  Stable named concept ids for application logic:  
+  `from omop_semantics.runtime.default_valuesets import runtime`
+
+- **Template/profile runtime**  
+  Compiled semantic templates and CDM profiles via `OmopSemanticEngine`.
+
+- **Fallback concepts**  
+  Canonical unknown and default concepts with reason codes:  
+  `from omop_semantics.unknowns import UNKNOWN`
+
+---
+
+## Key properties
+
+- **Portable** — no database or vocabulary graph required
+- **Versionable** — conventions are tracked in git alongside code
+- **Extensible** — add project-specific definitions on top of the shipped ones
+- **Integrates with pipelines** — drives ETL logic, validation, and documentation from a single source
+
+---
+
+## When to use this
+
+Use **omop-semantics** if you:
+
+- have project-specific rules about which OMOP concepts are valid,
+- need consistent concept groupings across ETL and analytics,
+- want semantic conventions to be explicit, testable, and versioned,
+- are working in domains like oncology where OMOP alone is too permissive.
+
+---
+
+## Docs
+
+- [Usage](docs/usage.md) — loading paths and code patterns
+- [Data Model](docs/data-model.md) — profiles, templates, and semantic objects
+- [Schema & Instances](docs/schema-and-instances.md) — authoring assets and file organisation
+- [Fallback Concepts](docs/unknowns.md) — the shipped unknown and default concepts
+- [Internals](docs/internals.md) — package structure and load-time behaviour

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "omop-semantics"
-version = "0.2.0"
-description = "Add your description here"
+version = "0.2.2"
+description = "Define, validate, and use schema-backed semantic conventions for OMOP CDM"
 readme = "README.md"
 authors = [
     { name = "gkennos", email = "georgina.kennedy@unsw.edu.au" }
@@ -23,7 +23,7 @@ omop-semantics = "omop_semantics:main"
 [project.optional-dependencies]
 dev = [
   "ipython>=8.0",
-  "pytest>=7.0",
+  "pytest>=9.0.3",
   "pytest-cov>=4.0",
   "mypy>=1.8",
   "ruff>=0.4",
@@ -45,6 +45,9 @@ build-backend = "uv_build"
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 
+[tool.pyright]
+ignore = ["src/omop_semantics/schema/generated_models"]
+
 [project.urls]
 Homepage = "https://australiancancerdatanetwork.github.io/omop-semantics/"
 Repository = "https://github.com/AustralianCancerDataNetwork/omop-semantics"

omop_semantics-0.2.2/src/omop_semantics/__init__.py

@@ -0,0 +1,46 @@
+"""
+Top-level exports for `omop_semantics`.
+
+Import from the package root for:
+
+- fallback concepts and reason codes via ``UNKNOWN``
+- path helpers via ``BASE_DIR``, ``SCHEMA_DIR``, and ``INSTANCE_DIR``
+
+For runtime access, use the dedicated subpackages:
+
+- ``from omop_semantics.runtime.default_valuesets import runtime``
+- ``from omop_semantics.runtime import OmopSemanticEngine``
+"""
+
+from .unknowns import UNKNOWN, UnknownValue, UnknownReason
+from .utils.paths import BASE_DIR, SCHEMA_DIR, INSTANCE_DIR
+
+__all__ = [
+    # unknowns — stable public surface
+    "UNKNOWN",
+    "UnknownValue",
+    "UnknownReason",
+    # path helpers
+    "BASE_DIR",
+    "SCHEMA_DIR",
+    "INSTANCE_DIR",
+    "main",
+]
+
+
+def main(argv: "list[str] | None" = None) -> int:
+    """Console entry point (``omop-semantics``).
+
+    Subcommands:
+      gen-models   (re)generate the committed pydantic models from the LinkML schema.
+    """
+    import sys
+
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == "gen-models":
+        from omop_semantics.schema.codegen import cli as gen_models_cli
+
+        return gen_models_cli(argv[1:])
+
+    print("usage: omop-semantics gen-models [--check] [--out DIR]", file=sys.stderr)
+    return 2

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/src/omop_semantics/runtime/__init__.py

@@ -1,9 +1,9 @@
 """
-Primary typed runtime exports for templates, profiles, and semantic inspection.
+Public runtime exports for `omop_semantics`.
 
-The `runtime` package is the preferred entrypoint for shape-aware semantics
-work. The most commonly used downstream compatibility surface for stable named
-ids remains `omop_semantics.runtime.default_valuesets`.
+Use this package when you need compiled templates, profile inspection, or
+low-level YAML loading helpers. For the default named-id surface, import
+``runtime`` from ``omop_semantics.runtime.default_valuesets``.
 """
 
 from .instance_loader import load_registry_fragment, merge_registry_fragments, load_symbol_module

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/src/omop_semantics/runtime/instance_loader.py

@@ -80,6 +80,18 @@ def merge_instance_files(
         "groups": merged_groups
     }
 
+def needs_profile_interpolation(path: Path) -> bool:
+    """Return True if any registry member in the file uses a string cdm_profile reference."""
+    data = yaml_loader.load_as_dict(str(path))
+    if not isinstance(data, dict):
+        return False
+    for group in data.get("groups", []) or []:
+        for member in (group.get("registry_members") or []):
+            if isinstance(member.get("cdm_profile"), str):
+                return True
+    return False
+
+
 def merge_registry_fragments(fragments: Sequence[RegistryFragment]) -> RegistryFragment:
     groups: list[RegistryGroup] = []
 

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/src/omop_semantics/runtime/renderers.py

@@ -243,11 +243,11 @@ def render_registry_group(group: RegistryGroup) -> Html:
         ],
     )
 
+    notes = f"<p><em>{h(group.notes)}</em></p>" if group.notes else ""
     return Html(
         f"<h3>{h(group.name)} ({h(group.role)})</h3>"
         f"{html}"
-        f"<p><em>{h(group.notes)}</em></p>" if group.notes else
-        f"<h3>{h(group.name)} ({h(group.role)})</h3>{html}"
+        f"{notes}"
     )
 
 def render_registry_fragment(fragment: RegistryFragment) -> Html:

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/src/omop_semantics/runtime/resolver.py

@@ -2,6 +2,7 @@ from omop_semantics.schema.generated_models.omop_semantic_registry import (
     OmopConcept,
     OmopGroup,
     OmopEnum,
+    OmopValueSet,
     RegistryFragment,
     RegistryGroup,
     OmopSemanticObject,
@@ -11,7 +12,6 @@ from omop_semantics.schema.generated_models.omop_semantic_registry import (
 from pathlib import Path
 from dataclasses import dataclass
 from typing import Iterable, TypedDict, Optional, Set
-from pydantic import ValidationError
 from .renderers import render_semantic_object, render_profile_object, Html, tr, h, table, as_list, render_compiled_templates
 from .instance_loader import (
     load_profiles,
@@ -19,6 +19,7 @@ from .instance_loader import (
     merge_instance_files,
     merge_registry_fragments,
     load_symbol_module,
+    needs_profile_interpolation,
 )
 from omop_semantics.utils.paths import INSTANCE_DIR
 
@@ -64,12 +65,10 @@ class OmopSemanticResolver:
     - OmopConcept resolves to its single concept_id
     - OmopEnum resolves to the set of concept_ids of its members
     - OmopGroup resolves to the anchor (parent) concept_ids of the group
+    - OmopValueSet resolves to the union of its members' resolved concept_ids
 
-    This library is not database-backed so the resolved group hierarchies
-    need to be resolved in downstream logic.
-
-    TODO: allow this class to extended with full resolution logic without
-    introducing dependencies on database connections or external services. 
+    This library is not database-backed, so descendant expansion and vocabulary
+    graph traversal belong in downstream logic rather than in this resolver.
     """
     def resolve(self, obj: OmopSemanticObject) -> set[int]:
         """
@@ -112,6 +111,13 @@ class OmopSemanticResolver:
                 if parent.concept_id is not None
             }
 
+        if isinstance(obj, OmopValueSet):
+            # A value set composes other semantic objects; resolve to the UNION of its members.
+            ids: set[int] = set()
+            for member in (obj.members or []):
+                ids |= self.resolve(member)
+            return ids
+
         raise TypeError(f"Unsupported semantic object: {type(obj)}")
 
 class OmopTemplateRuntime:
@@ -362,22 +368,29 @@ class OmopRegistryRuntime:
         """
         if self._compiled_by_name is None:
             self.compile_index()
-        if self._compiled_by_name is None:
-            raise RuntimeError("No compiled templates available")
         return self._compiled_by_name[name]
     
     def get_runtime(self, name: str) -> RuntimeTemplate:
+        """
+        Retrieve a compiled template and wrap it as a `RuntimeTemplate`.
+
+        This is the most ergonomic lookup when you want attribute access such
+        as `tpl.cdm_profile` or `tpl.entity_concept_ids`.
+        """
         c = self.get(name)
         return RuntimeTemplate.from_compiled(c)
 
     def by_role_runtime(self, role: str) -> list[RuntimeTemplate]:
+        """Return all compiled templates for a role as `RuntimeTemplate` objects."""
         return [RuntimeTemplate.from_compiled(c) for c in self.by_role(role)]
 
     def allows_concept(self, template_name: str, concept_id: int) -> bool:
+        """Return `True` if `concept_id` is allowed in the template's entity slot."""
         tpl = self.get(template_name)
         return concept_id in tpl["entity_concept_ids"]
 
     def allows_value(self, template_name: str, concept_id: int) -> bool:
+        """Return `True` if `concept_id` is allowed in the template's value slot."""
         tpl = self.get(template_name)
         values = tpl["value_concept_ids"]
         return values is not None and concept_id in values
@@ -398,8 +411,6 @@ class OmopRegistryRuntime:
         """
         if self._compiled_by_role is None:
             self.compile_index()
-        if self._compiled_by_role is None:
-            raise RuntimeError("No compiled templates available")
         return self._compiled_by_role.get(role, [])
 
     def compile_all(self, role: str | None = None) -> list[CompiledTemplate]:
@@ -418,9 +429,7 @@ class OmopRegistryRuntime:
         """
         if self._compiled_by_name is None:
             self.compile_index()
-        if self._compiled_by_name is None:
-            raise RuntimeError("Template compilation failed")
-        if role is None or self._compiled_by_role is None:
+        if role is None:
             return list(self._compiled_by_name.values())
         return self._compiled_by_role.get(role, [])
     
@@ -982,8 +991,8 @@ class OmopSemanticEngine:
       - the registry runtime (indexed, compiled templates),
       - and the optional semantic profile runtime (symbolic/profile view).
 
-    It is intended to be the main object used by ETL pipelines, query builders,
-    and documentation/rendering layers.
+    It is the main high-level entrypoint for shipped registry instance files,
+    ETL routing, and documentation/rendering layers.
     """
 
     def __init__(
@@ -1038,20 +1047,30 @@ class OmopSemanticEngine:
         cls,
         registry_paths: Iterable[Path],
         profile_paths: Iterable[Path] = (),
+        *,
+        profiles_path: Path | None = None,
     ) -> "OmopSemanticEngine":
         """
         Construct a semantic engine from YAML registry and profile files.
 
         Multiple registry fragments are merged into a single runtime registry.
-        Profile YAML files are loaded and merged into a single symbolic profile
-        namespace for documentation and inspection.
+        Profile YAML files are loaded into a symbolic profile namespace for
+        documentation and inspection.
+
+        Registry files that store ``cdm_profile`` as a string name (e.g.
+        ``observation_simple``) are automatically expanded against the CDM
+        profile catalogue before validation.
 
         Parameters
         ----------
         registry_paths
             Paths to registry fragment YAML files.
         profile_paths
-            Optional paths to profile/symbol YAML files.
+            Optional paths to symbolic profile/group YAML files that should be
+            exposed through ``profile_runtime``.
+        profiles_path
+            Path to the CDM profile catalogue YAML. Defaults to the shipped
+            ``profiles.yaml`` when not provided.
 
         Returns
         -------
@@ -1060,17 +1079,16 @@ class OmopSemanticEngine:
         """
         fragments: list[RegistryFragment] = []
         profile_objects: dict[str, dict] = {}
-        cdm_profiles = load_profiles(INSTANCE_DIR / "profiles.yaml")
+        cdm_profiles = load_profiles(profiles_path or INSTANCE_DIR / "profiles.yaml")
 
         for p in registry_paths:
-            try:
-                fragments.append(load_registry_fragment(p))
-            except ValidationError:
-                # Shipped registry instance files often refer to cdm_profile by
-                # name and need interpolation against the profile catalogue
-                # before they conform to RegistryFragment.
+            if needs_profile_interpolation(p):
+                # File uses string-named cdm_profile references; expand them
+                # against the catalogue before validating as RegistryFragment.
                 interpolated = merge_instance_files([p], cdm_profiles)
                 fragments.append(RegistryFragment.model_validate(interpolated))
+            else:
+                fragments.append(load_registry_fragment(p))
 
         for p in profile_paths:
             profile_objects.update(load_symbol_module(p))

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/src/omop_semantics/runtime/value_sets.py

@@ -1,16 +1,3 @@
-from dataclasses import dataclass
-from omop_semantics.schema.generated_models.omop_named_sets import (
-    OmopConcept, 
-    OmopGroup, 
-    OmopEnum, 
-    OmopSemanticObject, 
-    CDMSemanticUnits,
-    CDMValueSet,
-    CDMValueSets
-)
-from abc import ABC
-from .renderers import tr, table, h, Html
-
 """
 Runtime accessors for OMOP semantic value sets.
 
@@ -40,8 +27,20 @@ as a pure read-only semantic access layer.
 """
 
 from abc import ABC
+from dataclasses import dataclass
 from typing import Mapping
 
+from omop_semantics.schema.generated_models.omop_named_sets import (
+    OmopConcept,
+    OmopGroup,
+    OmopEnum,
+    OmopSemanticObject,
+    CDMSemanticUnits,
+    CDMValueSet,
+    CDMValueSets,
+)
+from .renderers import tr, table, h, Html
+
 class _RuntimeLabelledConcepts(ABC):
     """
     Thin shared base for runtime objects that expose a label -> concept_id mapping.
@@ -67,7 +66,10 @@ class _RuntimeLabelledConcepts(ABC):
     def __getattr__(self, label: str) -> int:
         if label.startswith("_"):
             raise AttributeError(label)
-        return self._by_label[label]
+        try:
+            return self._by_label[label]
+        except KeyError:
+            raise AttributeError(label) from None
 
     def __repr__(self) -> str:
         labels = ", ".join(self.labels)
@@ -234,10 +236,10 @@ class RuntimeSemanticUnit:
             for value in labelled_item.values():
                 try:
                     return getattr(value, name)
-                except AttributeError:
+                except KeyError:
                     pass
 
-        raise AttributeError(name)
+        raise KeyError(name)
 
     def __repr__(self) -> str:
         parts = []
@@ -404,7 +406,7 @@ def compile_valuesets(defs: CDMValueSets) -> RuntimeValueSets:
     for vs in defs.valuesets:
         members = {
             (unit.name or "[unlabelled]"): RuntimeSemanticUnit(unit)
-            for unit in vs.members
+            for unit in vs.semantic_units
         }
 
         compiled[vs.valueset_name] = RuntimeValueSet(
@@ -485,7 +487,7 @@ def interpolate_valuesets(
     for vs in raw["valuesets"]:
         resolved_members: list[CDMSemanticUnits] = []
 
-        for name in vs["members"]:
+        for name in vs["semantic_units"]:
             if name not in semantic_index:
                 raise KeyError(f"Unknown semantic unit referenced in valuesets.yaml: {name}")
 
@@ -516,7 +518,7 @@ def interpolate_valuesets(
         valuesets.append(
             CDMValueSet(
                 valueset_name=vs["name"],
-                members=resolved_members,
+                semantic_units=resolved_members,
             )
         )
 

omop_semantics-0.2.2/src/omop_semantics/schema/codegen.py

@@ -0,0 +1,107 @@
+"""In-code generation of the committed pydantic models from the LinkML schema.
+
+Replaces the removed ``runtime/utils.py::generate_pydantic_from_linkml`` (which shelled out to
+``uv run gen-pydantic``). Uses the LinkML :class:`PydanticGenerator` API directly, so the generation
+options live in code (single source of truth) and the output is reproducible against the pinned
+linkml version - no remembered CLI flags.
+
+CLI (wired via ``omop-semantics`` console script)::
+
+    omop-semantics gen-models           # (re)write the committed modules
+    omop-semantics gen-models --check   # exit non-zero if committed models are stale
+    omop-semantics gen-models --out DIR # write elsewhere (e.g. a temp dir)
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+
+from linkml.generators.pydanticgen import PydanticGenerator
+
+from omop_semantics.utils.paths import BASE_DIR
+
+# Repo root (.../omop-semantics). Generation runs with cwd here and passes repo-root-relative schema
+# paths, so the ``source_file`` stamp baked into each module is portable (not machine-specific).
+REPO_ROOT = BASE_DIR.parent.parent
+GENERATED_DIR = BASE_DIR / "schema" / "generated_models"
+
+# Empty-list-for-multivalued behaviour.
+#   False -> linkml >=1.11 default: optional multivalued slots default to ``None``.
+#   True  -> pre-1.11 style: default ``[]`` plus a ``treat_empty_lists_as_none`` serializer.
+# The runtime reads these collections defensively (``x or []``), so ``None`` is safe; we adopt the
+# current toolchain default. Change in ONE place if the project ever wants the old style back.
+EMPTY_LIST_FOR_MULTIVALUED = False
+
+# Generated module -> source schema, as paths RELATIVE TO REPO_ROOT.
+# ``omop_semantic_registry`` is the primary runtime module: its schema imports the full tree
+# (registry -> core/omop_templates -> omop_base + omop_profiles), so one regen covers all of them.
+# ``template_set`` is intentionally excluded: it is imported nowhere (vestigial).
+GEN_TARGETS: dict[str, str] = {
+    "omop_semantic_registry": "src/omop_semantics/schema/configuration/registry/omop_semantic_registry.yaml",
+    "omop_named_sets": "src/omop_semantics/schema/configuration/core/omop_named_sets.yaml",
+}
+
+
+@contextmanager
+def _chdir(path: Path):
+    prev = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(prev)
+
+
+def render_module(schema_rel: str) -> str:
+    """Return the generated pydantic module source for one schema (path relative to REPO_ROOT)."""
+    with _chdir(REPO_ROOT):
+        return PydanticGenerator(
+            schema_rel,
+            empty_list_for_multivalued_slots=EMPTY_LIST_FOR_MULTIVALUED,
+        ).serialize()
+
+
+def generate_models(out_dir: Path | None = None) -> list[Path]:
+    """Generate every committed pydantic module. Returns the written paths."""
+    target_dir = out_dir or GENERATED_DIR
+    target_dir.mkdir(parents=True, exist_ok=True)
+    written: list[Path] = []
+    for module, schema_rel in GEN_TARGETS.items():
+        path = target_dir / f"{module}.py"
+        path.write_text(render_module(schema_rel))
+        written.append(path)
+    return written
+
+
+def check_models() -> list[str]:
+    """Return the names of any committed modules that differ from a fresh generation."""
+    return [
+        module
+        for module, schema_rel in GEN_TARGETS.items()
+        if (GENERATED_DIR / f"{module}.py").read_text() != render_module(schema_rel)
+    ]
+
+
+def cli(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="omop-semantics gen-models",
+        description="Generate the committed pydantic models from the LinkML schema.",
+    )
+    parser.add_argument("--out", type=Path, default=None,
+                        help="Output directory (default: the committed generated_models dir).")
+    parser.add_argument("--check", action="store_true",
+                        help="Do not write; exit 1 if committed models differ from a fresh generation.")
+    args = parser.parse_args(argv)
+
+    if args.check:
+        drift = check_models()
+        for module in drift:
+            print(f"DRIFT: {module}.py is out of sync - run `omop-semantics gen-models`", file=sys.stderr)
+        return 1 if drift else 0
+
+    for path in generate_models(args.out):
+        print(f"wrote {path}")
+    return 0

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/src/omop_semantics/schema/configuration/core/omop_named_sets.yaml

@@ -12,7 +12,7 @@ classes:
   CDMValueSet:
     slots:
       - valueset_name
-      - members
+      - semantic_units
   CDMSemanticUnits:
     slots:
       - name
@@ -41,7 +41,7 @@ slots:
     required: true
   name:
     range: string
-  members:
+  semantic_units:
     range: CDMSemanticUnits
     multivalued: true
     required: true

{omop_semantics-0.2.0 → omop_semantics-0.2.2}/src/omop_semantics/schema/configuration/core/omop_profiles.yaml

@@ -39,4 +39,5 @@ enums:
       measurement:
       drug_exposure:
       procedure_occurrence:
-      condition_occurrence:
+      condition_occurrence:
+      device_exposure: