@dialecte/create 0.0.1

package/python/generate/extractors/children.py

@@ -0,0 +1,175 @@
+"""Extract child elements, choices, and text content from an XSD element."""
+from typing import Any
+
+from generate.extractors.constraints import extract_constraints
+from generate.extractors.facets import extract_facets
+from generate.ir import ChildDef, ChoiceGroup, TextContent
+def extract_children(xsd_elem: Any) -> tuple[list[str], bool, dict[str, ChildDef]]:
+    """Extract child element definitions from an XSD element's content model.
+
+    Returns:
+        (child_sequence, has_any_element, child_details)
+
+    xmlschema API:
+      XsdElement.type: XsdComplexType
+      XsdComplexType.content: XsdGroup (model group)
+      XsdGroup.iter_elements() → Iterator[XsdElement | XsdAnyElement]
+        Each yielded element has:
+          .local_name: str
+          .min_occurs: int
+          .max_occurs: int | None
+      Content wildcards:
+      XsdGroup — may contain XsdAnyElement children
+    """
+    return _extract_children_from_content(_get_content_model(xsd_elem))
+def extract_children_from_type(xsd_type: Any) -> tuple[list[str], bool, dict[str, ChildDef]]:
+    """Like ``extract_children`` but reads a complex type's content model directly.
+
+    Used by xsi:type expansion where children come from a substitutable type
+    (selected via ``xsi:type``) rather than the element's own declared type.
+    """
+    return _extract_children_from_content(getattr(xsd_type, 'content', None))
+def _extract_children_from_content(content: Any) -> tuple[list[str], bool, dict[str, ChildDef]]:
+    """Shared core: extract child definitions from a content model (XsdGroup)."""
+    sequence: list[str] = []
+    details: dict[str, ChildDef] = {}
+    any_child = False
+
+    if content is None:
+        return sequence, any_child, details
+
+    seen_names: set[str] = set()
+
+    for child in _iter_child_elements(content):
+        # Check if it's a wildcard (xs:any)
+        cls_name = type(child).__name__
+        if 'Any' in cls_name and 'Element' in cls_name:
+            any_child = True
+            continue
+
+        name = getattr(child, 'local_name', None)
+        if not name:
+            continue
+
+        if name in seen_names:
+            continue
+        seen_names.add(name)
+
+        min_occ = getattr(child, 'min_occurs', 0)
+        max_occ = getattr(child, 'max_occurs', None)  # None = unbounded
+
+        sequence.append(name)
+        details[name] = ChildDef(
+            required=min_occ > 0,
+            min_occurs=min_occ,
+            max_occurs=max_occ,
+            constraints=extract_constraints(child) or None,
+            facets=None,  # Rare: child text content facets
+        )
+
+    return sequence, any_child, details
+def extract_choices(xsd_elem: Any) -> list[ChoiceGroup]:
+    """Extract xs:choice groups from the content model.
+
+    xmlschema API:
+      XsdGroup.model: str ('sequence' | 'choice' | 'all')
+      XsdGroup is iterable — yields XsdElement | XsdGroup | XsdAnyElement
+    """
+    content = _get_content_model(xsd_elem)
+    if content is None:
+        return []
+
+    choices: list[ChoiceGroup] = []
+    _walk_groups_for_choices(content, choices)
+    return choices
+def extract_text_content(xsd_elem: Any) -> TextContent | None:
+    """Extract text content definition for elements with simple or mixed content.
+
+    xmlschema API:
+      XsdComplexType.has_simple_content() → bool
+      XsdComplexType.mixed: bool
+      XsdComplexType.content_type_label: str ('simple' | 'mixed' | 'element-only' | 'empty')
+    """
+    xsd_type = getattr(xsd_elem, 'type', None)
+    if xsd_type is None:
+        return None
+
+    has_simple = False
+    if callable(getattr(xsd_type, 'has_simple_content', None)):
+        has_simple = xsd_type.has_simple_content()
+    mixed = getattr(xsd_type, 'mixed', False)
+
+    if not has_simple and not mixed:
+        return None
+
+    # Find the simple type to extract facets from
+    facets_source = (
+        getattr(xsd_type, 'content', None)
+        or getattr(xsd_type, 'simple_type', None)
+        or getattr(xsd_type, 'base_type', None)
+    )
+
+    facets = extract_facets(facets_source)
+    return TextContent(facets=facets) if facets else TextContent()
+# --- Internal helpers ---
+def _get_content_model(xsd_elem: Any) -> Any:
+    """Get the content model (XsdGroup) from an element's type."""
+    xsd_type = getattr(xsd_elem, 'type', None)
+    if xsd_type is None:
+        return None
+    return getattr(xsd_type, 'content', None)
+def _iter_child_elements(content: Any):
+    """Iterate child elements from a content model.
+
+    xmlschema API:
+      XsdGroup.iter_elements() → yields XsdElement | XsdAnyElement
+    """
+    iter_fn = getattr(content, 'iter_elements', None)
+    if iter_fn and callable(iter_fn):
+        yield from iter_fn()
+def iter_child_elements(xsd_elem: Any):
+    """Public helper: iterate XsdElement children of an element for recursive walking."""
+    yield from _iter_named_child_elements(_get_content_model(xsd_elem))
+def iter_type_child_elements(xsd_type: Any):
+    """Public helper: iterate XsdElement children declared in a complex type's content."""
+    yield from _iter_named_child_elements(getattr(xsd_type, 'content', None))
+def _iter_named_child_elements(content: Any):
+    """Iterate non-wildcard XsdElement children of a content model."""
+    if content is None:
+        return
+    for child in _iter_child_elements(content):
+        cls_name = type(child).__name__
+        if 'Any' in cls_name and 'Element' in cls_name:
+            continue
+        yield child
+def _walk_groups_for_choices(group: Any, out: list[ChoiceGroup]) -> None:
+    """Recursively walk model groups to find xs:choice groups.
+
+    xmlschema API:
+      XsdGroup.model: str
+      XsdGroup is iterable (yields children)
+    """
+    model = getattr(group, 'model', None)
+    if model is None:
+        return
+
+    if model == 'choice':
+        options: list[str] = []
+        for item in group:
+            name = getattr(item, 'local_name', None)
+            if name:
+                options.append(name)
+            # Recurse into nested groups
+            if getattr(item, 'model', None) is not None:
+                _walk_groups_for_choices(item, out)
+        if options:
+            out.append(ChoiceGroup(
+                options=sorted(options),
+                min_occurs=getattr(group, 'min_occurs', 0),
+                max_occurs=getattr(group, 'max_occurs', None),
+            ))
+    else:
+        # sequence or all — recurse into nested groups
+        for item in group:
+            if getattr(item, 'model', None) is not None:
+                _walk_groups_for_choices(item, out)

package/python/generate/extractors/constraints.py

@@ -0,0 +1,154 @@
+"""Extract identity constraints (xs:unique, xs:key, xs:keyref) from XSD elements."""
+from typing import Any
+
+from generate.helpers import local_name
+from generate.ir import IdentityConstraint
+from generate.xpath_parser import parse_field, parse_selector
+def extract_constraints(xsd_elem: Any) -> list[IdentityConstraint]:
+    """Extract identity constraints from an XSD element.
+
+    Tries compiled constraint objects first, then raw XML fallback.
+
+    xmlschema API (compiled path):
+      XsdElement.identities: dict[str, XsdIdentity] — keys/uniques/keyrefs
+        XsdIdentity.selector: XsdSelector
+          XsdSelector.path: str
+        XsdIdentity.fields: list[XsdFieldSelector]
+          XsdFieldSelector.path: str
+        XsdUnique, XsdKey, XsdKeyref — subclasses
+        XsdKeyref.refer: XsdKey | XsdUnique
+          .refer.local_name: str
+
+    xmlschema API (raw XML fallback):
+      XsdElement.elem: Element — raw lxml/ET element
+      Scan for xs:key, xs:unique, xs:keyref tags
+    """
+    constraints: list[IdentityConstraint] = []
+    seen: set[tuple[str, str]] = set()
+
+    # Try compiled identities
+    for ic in _iter_identity_constraints(xsd_elem):
+        kind = _classify_constraint(ic)
+        if kind is None:
+            continue
+
+        name = getattr(ic, 'name', '') or ''
+        # Use local_name if it's a Clark QName
+        if name.startswith('{'):
+            name = local_name(name)
+
+        sig = (kind, name)
+        if sig in seen:
+            continue
+        seen.add(sig)
+
+        selector_xpath = _get_selector_path(ic)
+        field_xpaths = _get_field_paths(ic)
+
+        selector_paths = parse_selector(selector_xpath)
+        field_paths = [parse_field(fp) for fp in field_xpaths]
+
+        refer = None
+        if kind == 'keyref':
+            refer = _get_refer_name(ic)
+
+        constraints.append(IdentityConstraint(
+            kind=kind,
+            name=name,
+            selector=selector_paths,
+            fields=field_paths,
+            deep='//' in (selector_xpath or ''),
+            refer=refer,
+        ))
+
+    return constraints
+# --- Internal helpers ---
+def _iter_identity_constraints(xsd_elem: Any):
+    """Yield identity constraint objects from an element.
+
+    Checks multiple container shapes that xmlschema uses:
+      - .identities dict
+      - .identity_constraints dict
+      - .keys, .uniques, .keyrefs dicts/lists
+    """
+    # Preferred: .identities (xmlschema v2+)
+    identities = getattr(xsd_elem, 'identities', None)
+    if identities:
+        if hasattr(identities, 'values'):
+            yield from identities.values()
+        else:
+            yield from identities
+        return
+
+    # Alternative: .identity_constraints
+    ic_map = getattr(xsd_elem, 'identity_constraints', None)
+    if ic_map:
+        if hasattr(ic_map, 'values'):
+            yield from ic_map.values()
+        else:
+            yield from ic_map
+        return
+
+    # Separate containers
+    for attr_name in ('keys', 'uniques', 'keyrefs'):
+        container = getattr(xsd_elem, attr_name, None)
+        if container:
+            if hasattr(container, 'values'):
+                yield from container.values()
+            else:
+                yield from container
+def _classify_constraint(ic: Any) -> str | None:
+    """Determine if an identity constraint is 'unique', 'key', or 'keyref'."""
+    # Category attribute
+    category = getattr(ic, 'category', None)
+    if category:
+        cat = str(category).lower()
+        if 'key' in cat and 'ref' in cat:
+            return 'keyref'
+        if 'key' in cat:
+            return 'key'
+        if 'unique' in cat:
+            return 'unique'
+
+    # Class name fallback
+    cls_name = type(ic).__name__.lower()
+    if 'keyref' in cls_name:
+        return 'keyref'
+    if 'key' in cls_name:
+        return 'key'
+    if 'unique' in cls_name:
+        return 'unique'
+
+    return None
+def _get_selector_path(ic: Any) -> str:
+    """Get XPath selector path from a constraint."""
+    selector = getattr(ic, 'selector', None)
+    if selector is None:
+        return ''
+    path = getattr(selector, 'path', None)
+    if path:
+        return str(path)
+    # Fallback: selector might be string itself
+    return str(selector) if selector else ''
+def _get_field_paths(ic: Any) -> list[str]:
+    """Get XPath field paths from a constraint."""
+    fields = getattr(ic, 'fields', None)
+    if not fields:
+        return []
+    result = []
+    for f in fields:
+        path = getattr(f, 'path', None)
+        if path:
+            result.append(str(path))
+        elif isinstance(f, str):
+            result.append(f)
+    return result
+def _get_refer_name(ic: Any) -> str | None:
+    """Get the name of the referred key/unique for a keyref constraint."""
+    refer = getattr(ic, 'refer', None)
+    if refer is None:
+        return None
+    name = getattr(refer, 'local_name', None) or getattr(refer, 'name', None)
+    if name:
+        return local_name(str(name))
+    return str(refer)

package/python/generate/extractors/docs.py

@@ -0,0 +1,32 @@
+"""Extract documentation string from an XSD element."""
+from typing import Any
+def extract_docs(xsd_elem: Any) -> str | None:
+    """Extract the first xs:documentation text from an XSD element's annotations.
+
+    xmlschema API:
+      XsdElement.annotation → XsdAnnotation | None
+      XsdAnnotation.documentation → list[XsdDocumentation]
+      XsdDocumentation.text → str
+    """
+    # Try .annotation (singular) first — xmlschema v2+
+    annotation = getattr(xsd_elem, 'annotation', None)
+    if annotation is not None:
+        docs = getattr(annotation, 'documentation', None)
+        if docs:
+            for doc in docs:
+                text = getattr(doc, 'text', None)
+                if text and text.strip():
+                    return text.strip()
+
+    # Fallback: .annotations (plural) — older xmlschema
+    annotations = getattr(xsd_elem, 'annotations', None)
+    if annotations:
+        for ann in annotations:
+            docs = getattr(ann, 'documentation', None)
+            if docs:
+                for doc in docs:
+                    text = getattr(doc, 'text', None)
+                    if text and text.strip():
+                        return text.strip()
+
+    return None

package/python/generate/extractors/facets.py

@@ -0,0 +1,168 @@
+"""Extract facets (validation constraints) from an XSD type, walking the base type chain."""
+from typing import Any
+
+from generate.helpers import get_facet_value, local_name, xsd_pattern_to_js
+from generate.ir import Facets
+def extract_facets(xsd_type: Any) -> Facets | None:
+    """Walk base type chain, collect all facets. Return None if empty.
+
+    xmlschema API used:
+      XsdSimpleType.facets: dict[str, XsdFacet]  — keyed by Clark-notation QName
+      XsdSimpleType.enumeration: iterable of values
+      XsdSimpleType.patterns: iterable of XsdPatternFacets
+      XsdSimpleType.base_type: XsdSimpleType | XsdComplexType | None
+      XsdFacet.value / .v / .min_value / .max_value — scalar facet value
+      XsdPatternFacets — iterable, each has .regexps or str()
+      XsdEnumerationFacets — iterable, each has .value or is str
+    """
+    if xsd_type is None:
+        return None
+
+    facets = Facets()
+    visited: set[int] = set()
+    queue: list[Any] = [xsd_type]
+
+    while queue:
+        current = queue.pop(0)
+        if current is None or id(current) in visited:
+            continue
+        visited.add(id(current))
+
+        _collect_facets_from_type(current, facets)
+
+        # Walk base type chain
+        base = getattr(current, 'base_type', None)
+        if base is not None:
+            queue.append(base)
+
+        # Walk union member types
+        member_types = getattr(current, 'member_types', None)
+        if member_types:
+            for mt in member_types:
+                if mt is not None and id(mt) not in visited:
+                    queue.append(mt)
+
+        # Walk simple_type (for complexType with simpleContent)
+        simple = getattr(current, 'simple_type', None)
+        if simple is not None and id(simple) not in visited:
+            queue.append(simple)
+
+    return None if facets.is_empty() else facets
+def _collect_facets_from_type(current: Any, facets: Facets) -> None:
+    """Read facets dict from a single type level and populate the Facets dataclass."""
+    raw_facets = getattr(current, 'facets', None)
+    if not raw_facets:
+        return
+
+    # Ensure it's dict-like
+    items = raw_facets.items() if hasattr(raw_facets, 'items') else []
+
+    for name, facet in items:
+        local = local_name(str(name))
+        match local:
+            case 'enumeration':
+                new_enums = _extract_enumeration(current, facet)
+                if new_enums:
+                    if facets.enumeration is None:
+                        facets.enumeration = new_enums
+                    else:
+                        existing = set(facets.enumeration)
+                        facets.enumeration.extend(v for v in new_enums if v not in existing)
+            case 'pattern':
+                new_patterns = _extract_patterns(current, facet)
+                if new_patterns:
+                    if facets.pattern is None:
+                        facets.pattern = new_patterns
+                    else:
+                        existing = set(facets.pattern)
+                        facets.pattern.extend(p for p in new_patterns if p not in existing)
+            case 'minLength':
+                if facets.min_length is None:
+                    facets.min_length = get_facet_value(facet)
+            case 'maxLength':
+                if facets.max_length is None:
+                    facets.max_length = get_facet_value(facet)
+            case 'length':
+                if facets.length is None:
+                    facets.length = get_facet_value(facet)
+            case 'minInclusive':
+                if facets.min_inclusive is None:
+                    facets.min_inclusive = get_facet_value(facet)
+            case 'maxInclusive':
+                if facets.max_inclusive is None:
+                    facets.max_inclusive = get_facet_value(facet)
+            case 'minExclusive':
+                if facets.min_exclusive is None:
+                    facets.min_exclusive = get_facet_value(facet)
+            case 'maxExclusive':
+                if facets.max_exclusive is None:
+                    facets.max_exclusive = get_facet_value(facet)
+            case 'totalDigits':
+                if facets.total_digits is None:
+                    facets.total_digits = get_facet_value(facet)
+            case 'fractionDigits':
+                if facets.fraction_digits is None:
+                    facets.fraction_digits = get_facet_value(facet)
+            case 'whiteSpace':
+                if facets.white_space is None:
+                    facets.white_space = get_facet_value(facet)
+def _extract_enumeration(xsd_type: Any, facet: Any) -> list[str]:
+    """Extract enumeration values from a type or its facet object.
+
+    xmlschema stores enumerations in multiple ways:
+      - XsdSimpleType.enumeration → list of values directly
+      - XsdEnumerationFacets → iterable, .values or .enumeration
+      - Fallback: scan raw elem for xs:enumeration value=...
+    """
+    # Direct enumeration property on the type
+    enum = getattr(xsd_type, 'enumeration', None)
+    if enum:
+        return [str(v) for v in enum]
+
+    # Facet object approaches
+    values = getattr(facet, 'values', None)
+    if values:
+        return [str(v) for v in values]
+
+    enum_list = getattr(facet, 'enumeration', None)
+    if enum_list:
+        result = []
+        for item in enum_list:
+            v = getattr(item, 'value', None)
+            result.append(str(v) if v is not None else str(item))
+        return result
+
+    # Raw XML fallback
+    elem = getattr(xsd_type, 'elem', None)
+    if elem is not None:
+        result = []
+        for child in elem.iter():
+            tag = getattr(child, 'tag', '')
+            if 'enumeration' in str(tag):
+                val = child.get('value')
+                if val is not None:
+                    result.append(val)
+        if result:
+            return result
+
+    return []
+def _extract_patterns(xsd_type: Any, facet: Any) -> list[str]:
+    """Extract regex pattern strings from a type or facet.
+
+    xmlschema API:
+      XsdPatternFacets.regexps: list[str] — the actual regex strings
+      XsdSimpleType.patterns: XsdPatternFacets — same object as facet dict entry
+    """
+    # XsdPatternFacets (the facet dict entry) has .regexps with actual regex strings
+    regexps = getattr(facet, 'regexps', None)
+    if regexps:
+        return [xsd_pattern_to_js(str(r)) for r in regexps]
+
+    # Fallback: via type.patterns property (same object, different access path)
+    patterns = getattr(xsd_type, 'patterns', None)
+    if patterns:
+        regexps = getattr(patterns, 'regexps', None)
+        if regexps:
+            return [xsd_pattern_to_js(str(r)) for r in regexps]
+
+    return []

package/python/generate/extractors/namespace.py

@@ -0,0 +1,59 @@
+"""Extract Namespace from an XSD element."""
+from typing import Any
+
+from generate.helpers import local_name, namespace_uri
+from generate.ir import Namespace
+def extract_namespace(xsd_elem: Any) -> Namespace:
+    """Build a Namespace from an XsdElement.
+
+    Uses:
+      - xsd_elem.target_namespace → URI
+      - xsd_elem.schema.namespaces → prefix lookup
+      - xsd_elem.prefixed_name fallback
+
+    xmlschema API:
+      XsdComponent.target_namespace: str
+      XMLSchemaBase.namespaces: dict[str, str] (prefix → uri)
+    """
+    uri = getattr(xsd_elem, 'target_namespace', '') or ''
+    prefix = _resolve_prefix(xsd_elem, uri)
+    return Namespace(prefix=prefix, uri=uri)
+def extract_attr_namespace(xsd_attr: Any) -> Namespace | None:
+    """Build a Namespace for an XsdAttribute, or None if it's in the element's own namespace.
+
+    A namespace-qualified attribute has a non-empty target_namespace that differs
+    from its parent element's target_namespace.
+
+    xmlschema API:
+      XsdAttribute.target_namespace: str
+      XsdAttribute.qualified: bool
+      XsdAttribute.name: str (Clark notation '{uri}local')
+    """
+    name = getattr(xsd_attr, 'name', '') or ''
+    attr_ns = namespace_uri(name)
+
+    if not attr_ns:
+        return None
+
+    uri = attr_ns
+    prefix = _resolve_prefix(xsd_attr, uri)
+    if not prefix:
+        return None
+    return Namespace(prefix=prefix, uri=uri)
+def _resolve_prefix(component: Any, uri: str) -> str:
+    """Find the prefix for a namespace URI by walking up to the schema's namespace map."""
+    if not uri:
+        return ''
+
+    schema = getattr(component, 'schema', None)
+    if schema is None:
+        return ''
+
+    namespaces = getattr(schema, 'namespaces', {}) or {}
+    for pfx, ns_uri in namespaces.items():
+        if ns_uri == uri and not pfx:
+            return ''
+    for pfx, ns_uri in namespaces.items():
+        if ns_uri == uri and pfx:
+            return pfx
+    return ''

package/python/generate/globals.py

@@ -0,0 +1,99 @@
+"""Inject explicitly mapped global attributes from the schema into target elements.
+
+Reads ``attribute-mapping.json`` from the same directory as the entry XSD.
+Format::
+
+    {
+      "ElementName": {
+        "prefix:localName": "namespace-uri",
+        ...
+      }
+    }
+
+The key ``prefix:localName`` becomes the attribute key in ``attr_sequence`` and
+``attributes``. The namespace URI is used to look up the global ``xs:attribute``
+declaration in ``schema.maps.attributes`` via Clark notation ``{uri}localName``.
+
+No heuristics — only explicitly declared mappings are injected.
+Pattern mirrors ``orphans.py``.
+"""
+import json
+from pathlib import Path
+from typing import Any
+
+from generate.extractors.facets import extract_facets
+from generate.extractors.namespace import extract_attr_namespace
+from generate.ir import AttributeDef, ElementDef
+
+
+def load_attr_mapping(entry_path: Path) -> dict[str, dict[str, str]]:
+    """Read attribute-mapping.json from the same directory as the entry XSD.
+
+    Returns empty dict if the file does not exist.
+    """
+    mapping_file = entry_path.parent / 'attribute-mapping.json'
+    if not mapping_file.exists():
+        return {}
+    with open(mapping_file) as f:
+        return json.load(f)
+
+
+def inject_mapped_attributes(
+    schema: Any,
+    elements: dict[str, ElementDef],
+    mapping: dict[str, dict[str, str]],
+) -> int:
+    """Inject global attributes into elements as declared in the mapping.
+
+    For each ``(element_name, attr_key, ns_uri)`` in the mapping:
+    - Looks up the global attr in ``schema.maps.attributes`` by Clark name ``{ns_uri}local``.
+    - Builds an ``AttributeDef`` from the global attr declaration.
+    - Injects into ``element.attributes[attr_key]`` and ``element.attr_sequence``.
+    - Idempotent: skips if key already present.
+
+    Returns total number of attributes injected.
+    """
+    maps = getattr(schema, 'maps', None)
+    global_attrs = getattr(maps, 'attributes', None) if maps else {}
+
+    injected = 0
+
+    for element_name, attr_entries in mapping.items():
+        elem = elements.get(element_name)
+        if elem is None:
+            continue
+
+        for key, ns_uri in attr_entries.items():
+            if key in elem.attributes:
+                continue  # already present
+
+            # Derive local name from key (strip prefix if present)
+            local = key.split(':', 1)[-1]
+            clark = f'{{{ns_uri}}}{local}'
+            xsd_attr = global_attrs.get(clark)
+            if xsd_attr is None:
+                continue  # not found in schema — skip silently
+
+            attr_ns = extract_attr_namespace(xsd_attr)
+            fixed = getattr(xsd_attr, 'fixed', None)
+            default = getattr(xsd_attr, 'default', None) if fixed is None else None
+            use = getattr(xsd_attr, 'use', 'optional')
+            attr_type = getattr(xsd_attr, 'type', None)
+
+            elem.attributes[key] = AttributeDef(
+                required=use == 'required',
+                default=default,
+                fixed=fixed,
+                namespace=attr_ns,
+                facets=extract_facets(attr_type),
+            )
+            elem.attr_sequence.append(key)
+            injected += 1
+
+        if any(k in elem.attr_sequence for k in attr_entries):
+            elem.attr_sequence.sort()
+
+    return injected
+
+
+    return injected