ogc-na 0.4.3__py3-none-any.whl → 0.5.4__py3-none-any.whl

ogc/na/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.3'
-__version_tuple__ = version_tuple = (0, 4, 3)
+__version__ = version = '0.5.4'
+__version_tuple__ = version_tuple = (0, 5, 4)
 
 __commit_id__ = commit_id = None

ogc/na/annotate_schema.py

@@ -135,13 +135,14 @@ import requests_cache
 
 from ogc.na.exceptions import ContextLoadError, SchemaLoadError
 from ogc.na.util import is_url, load_yaml, LRUCache, dump_yaml, \
-    merge_contexts, merge_dicts, dict_contains, JSON_LD_KEYWORDS
+    merge_contexts, merge_dicts, dict_contains, JSON_LD_KEYWORDS, UNDEFINED, prune_context
 
 logger = logging.getLogger(__name__)
 
 ANNOTATION_PREFIX = 'x-jsonld-'
 ANNOTATION_CONTEXT = f'{ANNOTATION_PREFIX}context'
 ANNOTATION_ID = f'{ANNOTATION_PREFIX}id'
+ANNOTATION_REVERSE = f'{ANNOTATION_PREFIX}reverse'
 ANNOTATION_PREFIXES = f'{ANNOTATION_PREFIX}prefixes'
 ANNOTATION_EXTRA_TERMS = f'{ANNOTATION_PREFIX}extra-terms'
 ANNOTATION_BASE = f'{ANNOTATION_PREFIX}base'
@@ -151,13 +152,6 @@ ANNOTATION_IGNORE_EXPAND = [ANNOTATION_CONTEXT, ANNOTATION_EXTRA_TERMS, ANNOTATI
 
 CURIE_TERMS = '@id', '@type', '@index'
 
-class Undefined:
-
-    def __bool__(self):
-        return False
-
-UNDEFINED = Undefined()
-
 context_term_cache = LRUCache(maxsize=20)
 requests_session = requests_cache.CachedSession('ogc.na.annotate_schema', backend='memory', expire_after=180)
 
@@ -180,6 +174,10 @@ class ReferencedSchema:
     is_json: bool = False
     anchors: dict[str, Any] = dataclasses.field(default_factory=dict)
 
+    @property
+    def full_ref(self):
+        return f"{self.location}#{self.fragment}" if self.fragment else self.location
+
 
 @dataclasses.dataclass
 class ResolvedContext:
@@ -187,10 +185,17 @@ class ResolvedContext:
     prefixes: dict[str, str] = dataclasses.field(default_factory=dict)
 
 
+@dataclasses.dataclass
+class SchemaLevelEntry:
+    subschema: dict[str, Any]
+    from_schema: ReferencedSchema
+    parent_prop_schema: ReferencedSchema = None
+
+
 class SchemaResolver:
 
     def __init__(self, working_directory=Path()):
-        self.working_directory = working_directory.resolve()
+        self.working_directory = working_directory.absolute()
         self._schema_cache: dict[str | Path, Any] = {}
 
     @staticmethod
@@ -198,6 +203,8 @@ class SchemaResolver:
         ref = re.sub('^#', '', ref)
         if anchors and ref in anchors:
             return anchors[ref]
+        if not ref.startswith('/'):
+             raise ValueError(f'Invalid anchor reference: #{ref}')
         return jsonpointer.resolve_pointer(schema, ref)
 
     @staticmethod
@@ -243,15 +250,15 @@ class SchemaResolver:
 
         if isinstance(location, Path):
             if location.is_absolute():
-                location = location.resolve()
+                location = location.absolute()
             elif not from_schema:
-                location = self.working_directory.joinpath(location).resolve()
+                location = self.working_directory.joinpath(location).absolute()
             elif from_schema.full_contents.get('$id'):
                 location = urljoin(from_schema.full_contents['$id'], str(location))
             elif not isinstance(from_schema.location, Path):
                 location = urljoin(from_schema.location, str(location))
             else:
-                location = from_schema.location.resolve().parent.joinpath(location).resolve()
+                location = from_schema.location.absolute().parent.joinpath(location).absolute()
 
         if location is None:
             raise ValueError(f'Unexpected ref type {type(ref).__name__}')
@@ -259,11 +266,11 @@ class SchemaResolver:
         return location, fragment
 
     def resolve_schema(self, ref: str | Path, from_schema: ReferencedSchema | None = None,
-                       force_contents: dict | str | None = None) -> ReferencedSchema | None:
+                       force_contents: dict | str | None = None, return_none_on_loop=True) -> ReferencedSchema | None:
         chain = from_schema.chain + [from_schema] if from_schema else []
         try:
             schema_source, fragment = self.resolve_ref(ref, from_schema)
-            if from_schema:
+            if from_schema and return_none_on_loop:
                 for ancestor in from_schema.chain:
                     if (not schema_source or ancestor.location == schema_source) and ancestor.fragment == fragment:
                         return None
@@ -280,7 +287,6 @@ class SchemaResolver:
                                         ref=ref,
                                         is_json=from_schema.is_json,
                                         anchors=from_schema.anchors)
-
             if force_contents:
                 is_json = False
                 if isinstance(force_contents, str):
@@ -290,6 +296,8 @@ class SchemaResolver:
                         raise SchemaLoadError('Error loading schema from string contents') from e
                 else:
                     contents = force_contents
+            elif from_schema and schema_source == from_schema.location:
+                contents, is_json = from_schema.full_contents, from_schema.is_json
             else:
                 contents, is_json = self.load_contents(schema_source)
             anchors = SchemaResolver._find_anchors(contents)
@@ -375,7 +383,7 @@ def resolve_ref(ref: str, fn_from: str | Path | None = None, url_from: str | Non
         return None, urljoin(base_url, ref)
     else:
         fn_from = fn_from if isinstance(fn_from, Path) else Path(fn_from)
-        ref = (fn_from.resolve().parent / ref).resolve()
+        ref = (fn_from.absolute().parent / ref).absolute()
         return ref, None
 
 
@@ -402,11 +410,6 @@ def resolve_context(ctx: Path | str | dict | list, expand_uris=True) -> Resolved
                     prefix_uri = term_val if isinstance(term_val, str) else term_val.get('@id')
                     prefixes[prefix] = prefix_uri
                     return f"{prefix_uri}{localpart}"
-            elif '@vocab' in c and vocab is UNDEFINED:
-                # look for @vocab unless it has been overridden (e.g. set to null) somewhere down the chain
-                vocab = c['@vocab']
-                if isinstance(vocab, str):
-                    return f"{c['@vocab']}{curie}"
 
         return curie
 
@@ -523,7 +526,7 @@ class SchemaAnnotator:
         if default_context and (context_fn != default_context
                                 or not (isinstance(context_fn, Path)
                                         and isinstance(default_context, Path)
-                                        and default_context.resolve() == context_fn.resolve())):
+                                        and default_context.absolute() == context_fn.absolute())):
             # Only load the provided context if it's different from the schema-referenced one
             resolved_default_context = resolve_context(default_context)
             context, prefixes = attrgetter('context', 'prefixes')(resolved_default_context)
@@ -538,29 +541,16 @@ class SchemaAnnotator:
         updated_refs: set[int] = set()
 
         def find_prop_context(prop, context_stack) -> dict | None:
-            vocab = UNDEFINED
             for ctx in reversed(context_stack):
-                if vocab is UNDEFINED and '@vocab' in ctx:
-                    vocab = ctx.get('@vocab')
                 if prop in ctx:
                     prop_ctx = ctx[prop]
                     if isinstance(prop_ctx, str):
-                        if vocab and ':' not in prop_ctx and prop_ctx not in JSON_LD_KEYWORDS:
-                            prop_ctx = f"{vocab}{prop_ctx}"
                         return {'@id': prop_ctx}
-                    elif '@id' not in prop_ctx and '@reverse' not in prop_ctx and not vocab:
+                    elif '@id' not in prop_ctx and '@reverse' not in prop_ctx:
                         raise ValueError(f'Missing @id for property {prop} in context {json.dumps(ctx, indent=2)}')
                     else:
                         result = {k: v for k, v in prop_ctx.items() if k in JSON_LD_KEYWORDS}
-                        if vocab:
-                            prop_id = result.get('@id')
-                            if not prop_id:
-                                result['@id'] = f"{vocab}{prop}"
-                            elif ':' not in prop_id and prop_id not in JSON_LD_KEYWORDS:
-                                result['@id'] = f"{vocab}{prop_id}"
                         return result
-                elif isinstance(vocab, str):
-                    return {'@id': f"{ctx['@vocab']}{prop}"}
 
         def process_properties(obj: dict, context_stack: list[dict[str, Any]],
                                from_schema: ReferencedSchema, level) -> Iterable[str]:
@@ -664,7 +654,9 @@ class SchemaAnnotator:
                 schema_type = 'object'
 
             if schema_type == 'object':
-                used_terms.update(process_properties(subschema, context_stack, from_schema, level + 1))
+                new_terms = process_properties(subschema, context_stack, from_schema, level + 1)
+                if not in_defs:
+                    used_terms.update(new_terms)
             elif schema_type == 'array':
                 for k in ('prefixItems', 'items', 'contains'):
                     new_terms = process_subschema(subschema.get(k), context_stack, from_schema, level + 1,
@@ -762,103 +754,92 @@ class ContextBuilder:
         # store processed $defs and definitions to avoid parsing them twice
         processed_refs = set()
 
-        def read_properties(subschema: dict, from_schema: ReferencedSchema,
-                            onto_context: dict, schema_path: list[str]) -> dict | None:
-            if schema_path:
-                schema_path_str = '/' + '/'.join(schema_path)
-            else:
-                schema_path_str = ''
-            if not isinstance(subschema, dict):
-                return None
-            if subschema.get('type', 'object') != 'object':
-                return None
-            for prop, prop_val in subschema.get('properties', {}).items():
-                full_property_path = schema_path + [prop]
-                full_property_path_str = f"{schema_path_str}/{prop}"
-                self.visited_properties.setdefault(full_property_path_str, None)
-                if from_schema == root_schema:
-                    self._missed_properties.setdefault(full_property_path_str, True)
-                if not isinstance(prop_val, dict):
-                    continue
-                prop_context = {'@context': {}}
-                for term, term_val in prop_val.items():
-                    if term == ANNOTATION_BASE:
-                        prop_context.setdefault('@context', {})['@base'] = term_val
-                    elif term.startswith(ANNOTATION_PREFIX) and term not in ANNOTATION_IGNORE_EXPAND:
-                        if term == ANNOTATION_ID:
-                            self.visited_properties[full_property_path_str] = term_val
-                            self._missed_properties[full_property_path_str] = False
-                        prop_context['@' + term[len(ANNOTATION_PREFIX):]] = term_val
-
-                if isinstance(prop_context.get('@id'), str) or isinstance(prop_context.get('@reverse'), str):
-                    prop_id_value = prop_context.get('@id', prop_context.get('@reverse'))
-                    self.visited_properties[full_property_path_str] = prop_id_value
-                    self._missed_properties[full_property_path_str] = False
-                    if prop_id_value in ('@nest', '@graph'):
-                        merge_contexts(onto_context, process_subschema(prop_val, from_schema, full_property_path))
-                    else:
-                        merge_contexts(prop_context['@context'],
-                                       process_subschema(prop_val, from_schema, full_property_path))
-                    if prop not in onto_context or isinstance(onto_context[prop], str):
-                        onto_context[prop] = prop_context
-                    else:
-                        merge_contexts(onto_context[prop], prop_context)
-                else:
-                    merge_contexts(onto_context, process_subschema(prop_val, from_schema, full_property_path))
+        PropertyContexts = dict[str, list[dict[str, Any]]]
 
         imported_prefixes: dict[str | Path, dict[str, str]] = {}
         imported_extra_terms: dict[str | Path, dict[str, str]] = {}
 
-        cached_schema_contexts = {}
+        cached_schema_entries = {}
 
-        def process_subschema(subschema: dict, from_schema: ReferencedSchema,
-                              schema_path: list[str]) -> dict:
+        pending_subschemas = deque()
 
-            onto_context = {}
+        def merge_property_contexts(existing: dict[str, list[SchemaLevelEntry]],
+                                    new: dict[str, list[SchemaLevelEntry]]):
+            if new:
+                for prop, entries in new.items():
+                    existing.setdefault(prop, []).extend(entries)
+            return existing
 
-            if not isinstance(subschema, dict):
-                return {}
+        def process_subschema_level(subschema: dict, from_schema: ReferencedSchema,
+                                    schema_path: list[str], is_vocab=False,
+                                    local_refs_only=False) -> dict[str, list[SchemaLevelEntry]]:
 
-            for key in (ANNOTATION_BASE, ANNOTATION_VOCAB):
-                top_level_value = subschema.get(key)
-                if top_level_value:
-                    onto_context[f"@{key[len(ANNOTATION_PREFIX):]}"] = top_level_value
+            level_entries: dict[str, list[SchemaLevelEntry]] = {}
 
-            read_properties(subschema, from_schema, onto_context, schema_path)
+            if not isinstance(subschema, dict):
+                return {}
 
             if '$ref' in subschema:
                 ref = subschema['$ref']
-                ref_path_str = f"{from_schema.location}{ref}"
-                processed_refs.add(ref_path_str)
-                referenced_schema = self.schema_resolver.resolve_schema(ref, from_schema)
-                if referenced_schema:
-                    ref_ctx = copy.deepcopy(cached_schema_contexts.get(ref_path_str))
-                    if ref_ctx is None:
-                        ref_ctx = process_subschema(referenced_schema.subschema, referenced_schema, schema_path)
-                    merge_contexts(onto_context, ref_ctx)
+                if not local_refs_only or ref.startswith('#'):
+                    ref_path_str = f"{from_schema.location}{ref}"
+                    referenced_schema = self.schema_resolver.resolve_schema(ref, from_schema)
+                    if referenced_schema and not referenced_schema.full_ref == from_schema.full_ref:
+                        full_ref = referenced_schema.full_ref
+                        if full_ref in cached_schema_entries:
+                            ref_entries = cached_schema_entries[ref_path_str]
+                        else:
+                            print('resolving', full_ref)
+                            ref_entries = process_subschema_level(
+                                referenced_schema.subschema,
+                                referenced_schema, schema_path,
+                                is_vocab=is_vocab, local_refs_only=local_refs_only)
+                            cached_schema_entries[ref_path_str] = ref_entries
+                        merge_property_contexts(
+                            level_entries,
+                            ref_entries
+                        )
 
             for i in ('allOf', 'anyOf', 'oneOf'):
                 l = subschema.get(i)
                 if isinstance(l, list):
                     for idx, sub_subschema in enumerate(l):
-                        merge_contexts(onto_context, process_subschema(sub_subschema, from_schema, schema_path))
+                        merge_property_contexts(
+                            level_entries,
+                            process_subschema_level(sub_subschema, from_schema,
+                                                    schema_path, is_vocab=is_vocab))
 
             for i in ('prefixItems', 'items', 'contains', 'then', 'else', 'additionalProperties'):
                 l = subschema.get(i)
                 if isinstance(l, dict):
-                    merge_contexts(onto_context, process_subschema(l, from_schema, schema_path))
+                    merge_property_contexts(
+                        level_entries,
+                        process_subschema_level(l, from_schema,
+                                                schema_path, is_vocab=is_vocab))
 
             for pp_k, pp in subschema.get('patternProperties', {}).items():
                 if isinstance(pp, dict):
-                    merge_contexts(onto_context, process_subschema(pp, from_schema, schema_path + [pp_k]))
+                    merge_property_contexts(
+                        level_entries,
+                        process_subschema_level(pp, from_schema,
+                                                schema_path + [pp_k],
+                                                is_vocab=is_vocab))
 
             if ANNOTATION_EXTRA_TERMS in subschema:
                 for extra_term, extra_term_context in subschema[ANNOTATION_EXTRA_TERMS].items():
-                    if extra_term not in onto_context:
+                    if extra_term not in level_entries:
                         if isinstance(extra_term_context, dict):
-                            extra_term_context = {f"@{k[len(ANNOTATION_PREFIX):]}": v
-                                                  for k, v in extra_term_context.items()}
-                        onto_context[extra_term] = extra_term_context
+                            level_entries.setdefault(extra_term, []).insert(
+                                0,
+                                SchemaLevelEntry(subschema=extra_term_context,
+                                                 from_schema=from_schema)
+                            )
+
+            if subschema_properties := subschema.get('properties'):
+                for prop_name, prop_schema in subschema_properties.items():
+                    level_entries.setdefault(prop_name, []).append(
+                        SchemaLevelEntry(subschema=prop_schema, from_schema=from_schema)
+                    )
 
             if from_schema:
                 current_ref = f"{from_schema.location}{from_schema.ref}"
@@ -877,10 +858,68 @@ class ContextBuilder:
                 if isinstance(sub_prefixes, dict):
                     prefixes.update({k: v for k, v in sub_prefixes.items() if k not in prefixes})
 
-            cached_schema_contexts[f"{from_schema.location}#{from_schema.fragment}"] = onto_context
+            cached_schema_entries[f"{from_schema.location}#{from_schema.fragment}"] = level_entries
+            return level_entries
+
+        def process_subschema(subschema: dict, onto_context: dict, from_schema: ReferencedSchema,
+                              property_path: list, is_vocab=False, local_refs_only=False) -> dict:
+
+            if not isinstance(subschema, dict):
+                return {}
+
+            for key in (ANNOTATION_BASE, ANNOTATION_VOCAB):
+                top_level_value = subschema.get(key)
+                if top_level_value:
+                    onto_context[f"@{key[len(ANNOTATION_PREFIX):]}"] = top_level_value
+            is_vocab = is_vocab or bool(onto_context.get('@vocab'))
+
+            level_props = process_subschema_level(subschema, from_schema, property_path,
+                                                  is_vocab=is_vocab, local_refs_only=local_refs_only)
+            for prop_name, prop_entries in level_props.items():
+                prop_context = {}
+                for prop_entry in prop_entries:
+                    if isinstance(prop_entry.subschema, dict):
+                        prop_context.update({'@' + k[len(ANNOTATION_PREFIX):]: v
+                                             for k, v in prop_entry.subschema.items()
+                                             if k.startswith(ANNOTATION_PREFIX)})
+
+                new_prop_path = property_path + [prop_name]
+
+                if '@id' in prop_context:
+                    prop_uri = prop_context['@id']
+                    visited_str = prop_uri
+                elif '@reverse' in prop_context:
+                    prop_uri = prop_context['@reverse']
+                    visited_str = '^' + prop_uri
+                elif is_vocab:
+                    prop_uri = prop_name
+                    visited_str = '@vocab'
+                else:
+                    # Allow bubbling of local subproperties
+                    pending_subschemas.extend(
+                        (entry.subschema, onto_context,
+                         entry.from_schema, new_prop_path, is_vocab, True)
+                        for entry in prop_entries
+                    )
+                    continue
+
+                onto_context[prop_name] = prop_context
+
+                if prop_uri:
+                    prop_path_str = '/'.join(new_prop_path)
+                    pending_subschemas.extend(
+                        (entry.subschema, prop_context.setdefault('@context', {}),
+                         entry.from_schema, new_prop_path, is_vocab, False)
+                        for entry in prop_entries
+                    )
+                    self.visited_properties[prop_path_str] = visited_str
+                    self._missed_properties[prop_path_str] = False
+
             return onto_context
 
-        merge_contexts(own_context, process_subschema(root_schema.subschema, root_schema, []))
+        pending_subschemas.append((root_schema.subschema, own_context, root_schema, [], False, False))
+        while pending_subschemas:
+            process_subschema(*pending_subschemas.popleft())
 
         for imported_et in imported_extra_terms.values():
             for term, v in imported_et.items():
@@ -900,6 +939,8 @@ class ContextBuilder:
             else:
                 del prefixes[prefix]
 
+        prune_context(own_context)
+
         if compact:
 
             def compact_uri(uri: str) -> str:
@@ -992,11 +1033,11 @@ def dump_annotated_schema(schema: AnnotatedSchema, subdir: Path | str = 'annotat
     :param root_dir: root directory for computing relative paths to schemas
     :param output_fn_transform: optional callable to transform the output path
     """
-    wd = (Path(root_dir) if root_dir else Path()).resolve()
+    wd = (Path(root_dir) if root_dir else Path()).absolute()
     subdir = subdir if isinstance(subdir, Path) else Path(subdir)
     path = schema.source
     if isinstance(path, Path):
-        output_fn = path.resolve().relative_to(wd)
+        output_fn = path.absolute().relative_to(wd)
     else:
         parsed = urlparse(str(path))
         output_fn = parsed.path

ogc/na/download.py

@@ -20,6 +20,7 @@ def download_file(url: str,
                   dest: str | Path,
                   object_diff: bool = True,
                   ignore_diff_errors: bool = True):
+    logger.info('Downloading %s to %s', url, dest)
     if not isinstance(dest, Path):
         dest = Path(dest)
     r = requests.get(url)
@@ -30,12 +31,15 @@ def download_file(url: str,
             newcontent = util.load_yaml(content=r.content)
             oldcontent = util.load_yaml(filename=dest)
             overwrite = newcontent != oldcontent
+            if overwrite:
+                logger.info('Contents have changed, existing file will be overwritten')
         except Exception as e:
             if ignore_diff_errors:
                 logger.warning('Error when loading content for diff: %s', str(e))
             else:
                 raise
     if overwrite:
+        logger.info('Saving %s', dest)
         dest.parent.mkdir(parents=True, exist_ok=True)
         with open(dest, 'wb') as f:
             f.write(r.content)

ogc/na/util.py

@@ -28,6 +28,15 @@ try:
 except ImportError:
     from yaml import Loader as YamlLoader, SafeLoader as SafeYamlLoader, Dumper as YamlDumper
 
+
+class _Undefined:
+
+    def __bool__(self):
+        return False
+
+
+UNDEFINED = _Undefined()
+
 JSON_LD_KEYWORDS = {
     '@base',
     '@container',
@@ -329,6 +338,8 @@ def merge_contexts(a: dict, b: dict, fix_nest=True) -> dict[str, Any]:
                 a[term] = va
             if isinstance(vb, str):
                 vb = {'@id': vb}
+            if vb and isinstance(vb.get('@id'), _Undefined) and '@id' in va:
+                vb['@id'] = va['@id']
             if vb:
                 for vb_term, vb_term_val in vb.items():
                     if vb_term != '@context':
@@ -368,6 +379,19 @@ def merge_contexts(a: dict, b: dict, fix_nest=True) -> dict[str, Any]:
     return a
 
 
+def prune_context(c: Any):
+    if isinstance(c, list):
+        for entry in c:
+            prune_context(entry)
+    elif isinstance(c, dict):
+        for k in list(c.keys()):
+            v = c[k]
+            if k == '@id' and isinstance(v, _Undefined):
+                del c[k]
+            else:
+                prune_context(v)
+
+
 def dict_contains(greater: dict, smaller: dict):
     for k, v in smaller.items():
         if k not in greater:
@@ -408,4 +432,4 @@ def _main():
 
 
 if __name__ == '__main__':
-    _main()
+    _main()

{ogc_na-0.4.3.dist-info → ogc_na-0.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ogc_na
-Version: 0.4.3
+Version: 0.5.4
 Summary: OGC Naming Authority tools
 Author-email: Rob Atkinson <ratkinson@ogc.org>, Piotr Zaborowski <pzaborowski@ogc.org>, Alejandro Villar <avillar@ogc.org>
 License-Expression: Apache-2.0

{ogc_na-0.4.3.dist-info → ogc_na-0.5.4.dist-info}/RECORD

@@ -1,8 +1,8 @@
 ogc/na/__init__.py,sha256=uzcNiJ3uKFNJ1HBfKxIwgAy2HMUFsLAe5RkrUg8ncac,464
-ogc/na/_version.py,sha256=bmI9ViMEsJ1Rjce-6ExwiNh2B7sZKTyBkze4k8NsTrU,704
-ogc/na/annotate_schema.py,sha256=MYXYzmFDua0DjOxccmGTAFHDS3T7U01jNv-u001ytj4,44584
+ogc/na/_version.py,sha256=OrfVZdCDQ-QC6dUnxdROooJjwvLfeDMedTBstpAdSBU,704
+ogc/na/annotate_schema.py,sha256=r-4gZgXD6L7ay2e41dqwFqOsVXiqEFEHomDhlN4Zoug,45938
 ogc/na/domain_config.py,sha256=ORzITa1rTrD1MQdpWYrIVW5SwSa9lJd3hnyHIxNgiIU,13947
-ogc/na/download.py,sha256=2afrLyl4WsAlxkCgXsl47fs9mNKfDmhVpeT2iwNSoq0,3354
+ogc/na/download.py,sha256=PmmCRMQm5ikNAttqbmieOLc5r0MgsGxJyRjVGjnueR4,3558
 ogc/na/exceptions.py,sha256=cwvnq79ih90T9lfwJww0zOx_QwuICaUvlo3Mc8m8ouA,85
 ogc/na/gsp.py,sha256=KGa2G9i8kPefYTHNPUDoXnNyF7Tiwt8K__Ew_Qa7eeg,6048
 ogc/na/ingest_json.py,sha256=tCqQLxudnI7aIG9XslGm0tdvbfIY68HPrtgYfKtWO4A,37889
@@ -10,14 +10,14 @@ ogc/na/models.py,sha256=nGV8EALtXvmBtkUbu0FA4KOgwNUqQGWIDuMo7UGOKP8,652
 ogc/na/profile.py,sha256=T7nesbm7azF2ijF60UenJnQQKjIgJlnJ3pUbGT5nYgM,16511
 ogc/na/provenance.py,sha256=BXiyF6zuRhCz7s_6-m8VtM1DduVo1sA6_2xCLxSM0qQ,6365
 ogc/na/update_vocabs.py,sha256=9um_Qn3Si6yQ20qLYsFhiaXcxA2ryzduvYprNb252-U,21370
-ogc/na/util.py,sha256=Ztju3g1YuguUDbk4n2RJfCrl_IIzNAj7linfy24T6VA,12067
+ogc/na/util.py,sha256=xUIIMjqQZvwlxIwsV2WL1vkC7Y-S0F685ap0gH1TryQ,12607
 ogc/na/validation.py,sha256=5xjHH55NZKM8HtUk8XgVzm8W5ZlZY00u_qsWfXK_8dM,3732
 ogc/na/input_filters/__init__.py,sha256=AhE7n_yECwxFKwOM3Jc0ft96TtF5i_Z-fHrS4HYOjaE,1179
 ogc/na/input_filters/csv.py,sha256=nFfB1XQF_QApcGGzMqEvzD_b3pBtCtsfUECsZ9UGE6s,2616
 ogc/na/input_filters/xlsx.py,sha256=X9EpFgC9WwHQD8iUJRGdaDYfgiLKjXPdhTVhDmNPAQ0,2730
 ogc/na/input_filters/xml.py,sha256=9qYjp_w5JLInFM48zB15IYH9eTafjp1Aqd_8kfuW3aA,2074
-ogc_na-0.4.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ogc_na-0.4.3.dist-info/METADATA,sha256=kdSKsp_WMZhKj6lKJAg85TnyPf7sXzHVvfuGRij2bPA,3917
-ogc_na-0.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ogc_na-0.4.3.dist-info/top_level.txt,sha256=Kvy3KhzcIhNPT4_nZuJCmS946ptRr_MDyU4IIhZJhCY,4
-ogc_na-0.4.3.dist-info/RECORD,,
+ogc_na-0.5.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ogc_na-0.5.4.dist-info/METADATA,sha256=-_s_Wn13oRr6Yzzn6Hkou2hgTkjnahLkV1_91ZhgexE,3917
+ogc_na-0.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ogc_na-0.5.4.dist-info/top_level.txt,sha256=Kvy3KhzcIhNPT4_nZuJCmS946ptRr_MDyU4IIhZJhCY,4
+ogc_na-0.5.4.dist-info/RECORD,,