ogc-na 0.2.9__tar.gz → 0.2.11__tar.gz

{ogc_na-0.2.9 → ogc_na-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ogc_na
-Version: 0.2.9
+Version: 0.2.11
 Summary: OGC Naming Authority tools
 Author-email: Rob Atkinson <ratkinson@ogc.org>, Piotr Zaborowski <pzaborowski@ogc.org>, Alejandro Villar <avillar@ogc.org>
 Project-URL: Homepage, https://github.com/opengeospatial/ogc-na-tools/

{ogc_na-0.2.9 → ogc_na-0.2.11}/ogc/na/annotate_schema.py

@@ -323,7 +323,8 @@ class SchemaAnnotator:
 
     def __init__(self, fn: Path | str | None = None, url: str | None = None,
                  follow_refs: bool = True, ref_root: Path | str | None = None,
-                 context: str | Path | dict | None = None):
+                 context: str | Path | dict | None = None,
+                 ref_mapper: Callable[[str], str] | None = None):
         """
         :param fn: file path to load (root schema)
         :param url: URL to load (root schema)
@@ -334,9 +335,29 @@ class SchemaAnnotator:
         self.ref_root = Path(ref_root) if ref_root else None
         self._follow_refs = follow_refs
         self._provided_context = context
+        self._ref_mapper = ref_mapper
 
         self._process_schema(fn, url)
 
+    def _follow_ref(self, subschema, schema_fn: Path, schema_url: str, base_url: str | None):
+        if not isinstance(subschema, dict) or '$ref' not in subschema:
+            return
+
+        if self._ref_mapper:
+            subschema['$ref'] = self._ref_mapper(subschema['$ref'])
+
+        if not self._follow_refs:
+            return
+
+        ref_fn, ref_url = resolve_ref(subschema['$ref'], schema_fn, schema_url, base_url)
+        ref = ref_fn or ref_url
+
+        if ref in self.schemas:
+            logger.info(' >> Found $ref to already-processed schema: %s', ref)
+        else:
+            logger.info(' >> Found $ref to new schema: %s', ref)
+            self._process_schema(url=ref_url, fn=ref_fn)
+
     def _process_schema(self, fn: Path | str | None = None, url: str | None = None):
         contents, base_url = read_contents(fn, url)
         schema, is_json = load_json_yaml(contents)
@@ -381,24 +402,26 @@ class SchemaAnnotator:
                     prop_value[ANNOTATION_ID] = terms[prop]
                     if prop in types:
                         prop_value[ANNOTATION_TYPE] = types[prop]
-                if '$ref' in prop_value and self._follow_refs:
-
-                    ref_fn, ref_url = resolve_ref(prop_value['$ref'], fn, url, base_url)
-                    ref = ref_fn or ref_url
 
-                    if ref in self.schemas:
-                        logger.info(' >> Found $ref to already-processed schema: %s', ref)
-                    else:
-                        logger.info(' >> Found $ref to new schema: %s', prop_value['$ref'])
-                        if ref_url:
-                            self._process_schema(url=ref)
-                        else:
-                            self._process_schema(fn=ref)
+                process_subschema(prop_value)
 
             properties.update({p: {ANNOTATION_ID: terms[p]} for p in empty_properties if p in terms})
 
         def process_subschema(subschema):
 
+            if not subschema:
+                return
+
+            self._follow_ref(subschema, fn, url, base_url)
+
+            # Annotate oneOf, allOf, anyOf
+            for p in ('oneOf', 'allOf', 'anyOf'):
+                collection = subschema.get(p)
+                if collection and isinstance(collection, list):
+                    for entry in collection:
+                        process_subschema(entry)
+
+            # Annotate main schema
             schema_type = subschema.get('type')
             if not schema_type and 'properties' in subschema:
                 schema_type = 'object'
@@ -407,8 +430,9 @@ class SchemaAnnotator:
                 process_properties(subschema)
             elif schema_type == 'array':
                 for k in ('prefixItems', 'items', 'contains'):
-                    process_properties(subschema.get(k))
+                    process_subschema(subschema.get(k))
 
+            # Annotate $defs
             for defs_prop in ('$defs', 'definitions'):
                 defs_value = subschema.get(defs_prop)
                 if isinstance(defs_value, dict):
@@ -433,7 +457,7 @@ class ContextBuilder:
     """
 
     def __init__(self, fn: Path | str | None = None, url: str | None = None,
-                 compact: bool = True):
+                 compact: bool = True, ref_mapper: Callable[[str], str] | None = None):
         """
         :param fn: file to load the annotated schema from
         :param url: URL to load the annotated schema from
@@ -441,6 +465,7 @@ class ContextBuilder:
         self.context = {'@context': {}}
         self._parsed_schemas: dict[str | Path, dict] = {}
         self.compact = compact
+        self._ref_mapper = ref_mapper
 
         context = self._build_context(fn, url)
         self.context = {'@context': context}
@@ -482,7 +507,7 @@ class ContextBuilder:
         if prefixes:
             own_context.update(prefixes)
 
-        def read_properties(where: dict):
+        def read_properties(where: dict, into_context: dict):
             if not isinstance(where, dict):
                 return
             for prop, prop_val in where.get('properties', {}).items():
@@ -493,57 +518,56 @@ class ContextBuilder:
                     if ANNOTATION_TYPE in prop_val:
                         prop_context['@type'] = compact_uri(prop_val[ANNOTATION_TYPE])
 
-                    if '$ref' in prop_val:
-                        ref_fn, ref_url = resolve_ref(prop_val['$ref'], fn, url, base_url)
-                        prop_context['@context'] = self._build_context(ref_fn, ref_url)
+                    process_subschema(prop_val, prop_context.setdefault('@context', {}))
+
+                    if not prop_context['@context']:
+                        prop_context.pop('@context', None)
 
-                    if len(prop_context) == 1:
+                    if isinstance(prop_context, dict) and len(prop_context) == 1:
                         # shorten to just the id
                         prop_context = next(iter(prop_context.values()))
 
-                    own_context[prop] = prop_context
+                    into_context[prop] = prop_context
+
+        def process_subschema(ss, into_context: dict):
 
-        def process_subschema(ss):
             if isinstance(ss, dict):
                 if '$ref' in ss:
                     ref_fn, ref_url = resolve_ref(ss['$ref'], fn, url, base_url)
                     merge_dicts(self._build_context(ref_fn, ref_url), own_context)
-                else:
-                    read_properties(ss)
+                read_properties(ss, into_context)
 
-        for i in ('allOf', 'anyOf', 'oneOf'):
-            l = schema.get(i)
-            if isinstance(l, list):
-                for sub_schema in l:
-                    process_subschema(sub_schema)
+                for i in ('allOf', 'anyOf', 'oneOf'):
+                    l = ss.get(i)
+                    if isinstance(l, list):
+                        for sub_schema in l:
+                            process_subschema(sub_schema, into_context)
 
-        for i in ('$defs', 'definitions'):
-            d = schema.get(i)
-            if isinstance(d, dict):
-                for sub_schema in d.values():
-                    process_subschema(sub_schema)
+                for i in ('$defs', 'definitions'):
+                    d = ss.get(i)
+                    if isinstance(d, dict):
+                        for sub_schema in d.values():
+                            process_subschema(sub_schema, into_context)
 
-        read_properties(schema)
+        process_subschema(schema, own_context)
 
         if self.compact:
-            context_props = set(own_context.keys())
-            compact_context = {}
-            for prop, prop_val in own_context.items():
-                compact_context[prop] = prop_val
-                if not isinstance(prop_val, dict):
-                    continue
-                prop_context = prop_val.pop('@context', None)
-                if not isinstance(prop_context, dict):
-                    continue
-                for term, term_val in prop_context.items():
-                    if not term.startswith('@') and term in context_props:
-                        compact_context.setdefault(prop, {}).setdefault('@context', {})[term] = term_val
-                    else:
-                        compact_context[term] = term_val
-                if len(compact_context[prop]) == 1 and '@id' in compact_context[prop]:
-                    compact_context[prop] = compact_context[prop]['@id']
-
-            own_context = compact_context
+
+            def compact_branch(branch, existing_terms):
+
+                for term in list(branch.keys()):
+                    if term[0] == '@':
+                        # skip special terms
+                        continue
+                    if term in existing_terms and existing_terms[term] == branch[term]:
+                        # same term exists in ancestor -> delete
+                        del branch[term]
+
+                for term, term_value in branch.items():
+                    if isinstance(term_value, dict) and '@context' in term_value:
+                        compact_branch(term_value['@context'], {**existing_terms, **branch})
+
+            compact_branch(own_context, {})
 
         self._parsed_schemas[fn or url] = own_context
         return own_context

{ogc_na-0.2.9 → ogc_na-0.2.11}/ogc_na.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ogc-na
-Version: 0.2.9
+Version: 0.2.11
 Summary: OGC Naming Authority tools
 Author-email: Rob Atkinson <ratkinson@ogc.org>, Piotr Zaborowski <pzaborowski@ogc.org>, Alejandro Villar <avillar@ogc.org>
 Project-URL: Homepage, https://github.com/opengeospatial/ogc-na-tools/