ogc-na 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

ogc/na/annotate_schema.py

@@ -116,16 +116,16 @@ The resulting context will be printed to the standard output.
 from __future__ import annotations
 import argparse
 import dataclasses
-import functools
 import json
 import logging
+import re
 import sys
 from pathlib import Path
-from typing import Any, AnyStr
+from typing import Any, AnyStr, Callable
 from urllib.parse import urlparse, urljoin
 import yaml
 import requests
-from ogc.na.util import is_url, merge_dicts, load_yaml
+from ogc.na.util import is_url, merge_dicts, load_yaml, LRUCache
 
 try:
     from yaml import CLoader as YamlLoader, CDumper as YamlDumper
@@ -137,8 +137,11 @@ logger = logging.getLogger(__name__)
 ANNOTATION_CONTEXT = 'x-jsonld-context'
 ANNOTATION_ID = 'x-jsonld-id'
 ANNOTATION_TYPE = 'x-jsonld-type'
+ANNOTATION_PREFIXES = 'x-jsonld-prefixes'
 REF_ROOT_MARKER = '$_ROOT_/'
 
+context_term_cache = LRUCache(maxsize=20)
+
 
 @dataclasses.dataclass
 class AnnotatedSchema:
@@ -218,63 +221,95 @@ def resolve_ref(ref: str, fn_from: str | Path | None = None, url_from: str | Non
         return ref, None
 
 
-@functools.lru_cache(maxsize=20)
-def read_context_terms(file: Path | str = None, url: str = None) -> dict[str, str]:
+def read_context_terms(ctx: Path | str | dict) -> tuple[dict[str, str], dict[str, str], dict[str, str]]:
     """
     Reads all the terms from a JSON-LD context document.
 
-    :param file: file path to load
-    :param url: URL to load
+    :param ctx: file path (Path), URL (str) or dictionary (dict) to load
     :return: a dictionary with term -> URI mappings
     """
+
+    cached = context_term_cache.get(ctx)
+    if cached:
+        return cached
+
     context: dict[str, Any] | None = None
 
-    if file:
-        with open(file) as f:
+    if isinstance(ctx, Path):
+        with open(ctx) as f:
             context = json.load(f).get('@context')
-    elif url:
-        r = requests.get(url)
+    elif isinstance(ctx, str):
+        r = requests.get(ctx)
         r.raise_for_status()
         context = r.json().get('@context')
+    elif ctx:
+        context = ctx.get('@context')
 
     if not context:
-        return {}
+        return {}, {}, {}
 
-    result: dict[str, str] = {}
-    pending: dict[str, list] = {}
+    result: dict[str, str | tuple[str, str]] = {}
+    types: dict[str, str | tuple[str, str]] = {}
 
     vocab = context.get('@vocab')
 
+    def expand_uri(uri: str) -> str | tuple[str, str] | None:
+        if not uri:
+            return None
+
+        if ':' in uri:
+            # either URI or prefix:suffix
+            pref, suf = uri.split(':', 1)
+            if suf.startswith('//') or pref == 'urn':
+                # assume full URI
+                return uri
+            else:
+                # prefix:suffix -> add to pending for expansion
+                return pref, suf
+        elif vocab:
+            # append term_val to vocab to get URI
+            return f"{vocab}{term_id}"
+        else:
+            return uri
+
     for term, term_val in context.items():
         if not term.startswith("@"):
             # assume term
+            term_type = None
             if isinstance(term_val, str):
                 term_id = term_val
             elif isinstance(term_val, dict):
                 term_id = term_val.get('@id')
+                term_type = term_val.get('@type')
             else:
                 term_id = None
 
-            if term_id:
-                if ':' in term_id:
-                    # either URI or prefix:suffix
-                    pref, suf = term_id.split(':', 1)
-                    if suf.startswith('//'):
-                        # assume URI -> add to result
-                        result[term] = term_id
-                    else:
-                        # prefix:suffix -> add to pending for expansion
-                        pending[term] = [pref, suf]
-                elif vocab:
-                    # append term_val to vocab to get URI
-                    result[term] = f"{vocab}{term_id}"
+            expanded_id = expand_uri(term_id)
+            if expanded_id:
+                result[term] = expanded_id
+            expanded_type = expand_uri(term_type)
+            if expanded_type:
+                types[term] = expanded_type
 
-    for term, term_val in pending.items():
-        pref, suf = term_val
-        if pref in result:
-            result[term] = f"{result[pref]}{suf}"
+    prefixes = {}
 
-    return result
+    def expand_result(d: dict[str, str | tuple[str, str]]) -> dict[str, str]:
+        r = {}
+        for term, term_val in d.items():
+            if isinstance(term_val, str):
+                r[term] = term_val
+            else:
+                pref, suf = term_val
+                if pref in result:
+                    r[term] = f"{result[pref]}{suf}"
+                    prefixes[pref] = result[pref]
+        return r
+
+    expanded_types = expand_result(types)
+    expanded_terms = expand_result(result)
+
+    context_term_cache[ctx] = expanded_terms, prefixes, expanded_types
+    return expanded_terms, prefixes, expanded_types
 
 
 class SchemaAnnotator:
@@ -287,7 +322,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):
+                 follow_refs: bool = True, ref_root: Path | str | None = None,
+                 context: str | Path | dict | None = None):
         """
         :param fn: file path to load (root schema)
         :param url: URL to load (root schema)
@@ -297,6 +333,7 @@ class SchemaAnnotator:
         self.bundled_schema = None
         self.ref_root = Path(ref_root) if ref_root else None
         self._follow_refs = follow_refs
+        self._provided_context = context
 
         self._process_schema(fn, url)
 
@@ -309,19 +346,29 @@ class SchemaAnnotator:
 
         base_url = schema.get('$id', base_url)
 
-        if not context_fn:
-            terms = {}
-        elif base_url:
-            context_fn = urljoin(base_url, context_fn)
-            terms = read_context_terms(url=context_fn)
-        else:
-            context_fn = Path(fn).parent / context_fn
-            terms = read_context_terms(file=context_fn)
+        terms = {}
+        prefixes = {}
+        types = {}
+
+        if context_fn != self._provided_context or not (isinstance(context_fn, Path)
+                                                        and isinstance(self._provided_context, Path)
+                                                        and self._provided_context.resolve() == context_fn.resolve()):
+            # Only load the provided context if it's different from the schema-referenced one
+            terms, prefixes, types = read_context_terms(self._provided_context)
+
+        if context_fn:
+            if base_url:
+                context_fn = urljoin(base_url, str(context_fn))
+            else:
+                context_fn = Path(fn).parent / context_fn
+
+            for e in zip((terms, prefixes, types), read_context_terms(context_fn)):
+                e[0].update(e[1])
 
         def process_properties(obj: dict):
             properties: dict[str, dict] = obj.get('properties') if obj else None
-            if not properties:
-                return
+            if not isinstance(properties, dict):
+                raise ValueError('"properties" must be a dictionary')
 
             empty_properties = []
             for prop, prop_value in properties.items():
@@ -330,7 +377,9 @@ class SchemaAnnotator:
                     continue
                 if prop in terms:
                     prop_value[ANNOTATION_ID] = terms[prop]
-                if '$ref' in prop_value:
+                    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
@@ -346,13 +395,28 @@ class SchemaAnnotator:
 
             properties.update({p: {ANNOTATION_ID: terms[p]} for p in empty_properties if p in terms})
 
-        schema_type = schema.get('type')
+        def process_subschema(subschema):
+
+            schema_type = subschema.get('type')
+            if not schema_type and 'properties' in subschema:
+                schema_type = 'object'
+
+            if schema_type == 'object':
+                process_properties(subschema)
+            elif schema_type == 'array':
+                for k in ('prefixItems', 'items', 'contains'):
+                    process_properties(subschema.get(k))
 
-        if schema_type == 'object':
-            process_properties(schema)
-        elif schema_type == 'array':
-            for k in ('prefixItems', 'items', 'contains'):
-                process_properties(schema.get(k))
+            for defs_prop in ('$defs', 'definitions'):
+                defs_value = subschema.get(defs_prop)
+                if isinstance(defs_value, dict):
+                    for defs_entry in defs_value.values():
+                        process_subschema(defs_entry)
+
+        process_subschema(schema)
+
+        if prefixes:
+            schema[ANNOTATION_PREFIXES] = prefixes
 
         self.schemas[fn or url] = AnnotatedSchema(
             source=fn or url,
@@ -389,18 +453,43 @@ class ContextBuilder:
 
         base_url = schema.get('$id', base_url)
 
+        prefixes = schema.get(ANNOTATION_PREFIXES, {}).items()
+        rev_prefixes = {v: k for k, v in prefixes}
+
+        def compact_uri(uri: str) -> str:
+            if uri.startswith('@'):
+                # JSON-LD keyword
+                return uri
+            parts = urlparse(uri)
+            if parts.fragment:
+                pref, suf = uri.rsplit('#', 1)
+                pref += '#'
+            elif len(parts.path) > 1:
+                pref, suf = uri.rsplit('/', 1)
+                pref += '/'
+            else:
+                return uri
+
+            if pref in rev_prefixes:
+                return f"{rev_prefixes[pref]}:{suf}"
+            else:
+                return uri
+
         own_context = {}
 
+        if prefixes:
+            own_context.update(prefixes)
+
         def read_properties(where: dict):
             if not isinstance(where, dict):
                 return
             for prop, prop_val in where.get('properties', {}).items():
                 if isinstance(prop_val, dict) and ANNOTATION_ID in prop_val:
                     prop_context = {
-                        '@id': prop_val[ANNOTATION_ID]
+                        '@id': compact_uri(prop_val[ANNOTATION_ID])
                     }
                     if ANNOTATION_TYPE in prop_val:
-                        prop_context['@type'] = prop_val[ANNOTATION_TYPE]
+                        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)
@@ -459,6 +548,7 @@ def dump_annotated_schemas(annotator: SchemaAnnotator, subdir: Path | str = 'ann
     :param annotator: a `SchemaAnnotator` with the annotated schemas to read
     :param subdir: a name for the mirror directory
     :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()
     subdir = subdir if isinstance(subdir, Path) else Path(subdir)

ogc/na/ingest_json.py

@@ -50,6 +50,7 @@ from rdflib.namespace import Namespace, DefinedNamespace
 from ogc.na import util, profile
 from ogc.na.domain_config import UpliftConfigurationEntry, DomainConfiguration
 from ogc.na.provenance import ProvenanceMetadata, FileProvenanceMetadata, generate_provenance
+from ogc.na.input_filters import apply_input_filter
 
 logger = logging.getLogger(__name__)
 
@@ -393,7 +394,8 @@ def process_file(input_fn: str | Path,
         If False, no Turtle output will be generated.
     :param context_fn: YAML context filename. If None, will be autodetected:
         1. From a file with the same name but yml/yaml extension (test.json -> test.yml)
-        2. From a _json-context.yml/_json-context.yaml file in the same directory
+        2. From the domain_cfg
+        3. From a _json-context.yml/_json-context.yaml file in the same directory
     :param domain_cfg: domain configuration with uplift definition locations
     :param base: base URI for JSON-LD
     :param provenance_base_uri: base URI for provenance resources
@@ -436,8 +438,15 @@ def process_file(input_fn: str | Path,
     if not contexts:
         raise MissingContextException('No context file provided and one could not be discovered automatically')
 
-    with open(input_fn, 'r') as j:
-        input_data = json.load(j)
+    # Apply input filter of first context only (if any)
+    input_filters = contexts[0].get('input-filter')
+    if input_filters:
+        if not isinstance(input_filters, dict):
+            raise ValueError('input-filter must be an object')
+        input_data = apply_input_filter(input_fn, input_filters)
+    else:
+        with open(input_fn, 'r') as j:
+            input_data = json.load(j)
 
     provenance_metadata: ProvenanceMetadata | None = None
     if provenance_base_uri is not False:
@@ -635,7 +644,10 @@ def process(input_files: str | Path | Sequence[str | Path],
         logger.info("Input files: %s", input_files)
         remaining_fn: deque = deque()
         for input_file in input_files:
-            remaining_fn.extend(input_file.split(','))
+            if isinstance(input_file, str):
+                remaining_fn.extend(input_file.split(','))
+            else:
+                remaining_fn.append(input_file)
         while remaining_fn:
             fn = str(remaining_fn.popleft())
 
@@ -645,9 +657,6 @@ def process(input_files: str | Path | Sequence[str | Path],
                 remaining_fn.extend(filenames_from_context(fn, domain_config=domain_cfg) or [])
                 continue
 
-            if not re.match(r'.*\.json-?(ld)?$', fn):
-                logger.debug('File %s does not match, skipping', fn)
-                continue
             logger.info('File %s matches, processing', fn)
             try:
                 result.append(process_file(

ogc/na/input_filters/__init__.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from importlib import import_module
+from io import BytesIO
+from pathlib import Path
+from typing import Any, IO, TextIO
+
+
+def apply_input_filter(stream: IO | bytes | str | Path, filters: dict[str, dict]) -> dict[str, Any] | list:
+    filter_name, filter_conf = filters.popitem()
+    try:
+        filter_mod = import_module(f"ogc.na.input_filters.{filter_name}")
+    except ImportError:
+        raise ValueError(f'Cannot find input filter with name "{filter_name}"')
+
+    content: bytes | None = None
+    if isinstance(stream, Path) or isinstance(stream, str):
+        with open(stream, 'rb') as f:
+            content = f.read()
+    elif isinstance(stream, TextIO):
+        content = stream.read().encode('utf-8')
+    else:
+        content = stream.read()
+
+    return filter_mod.apply_filter(content, filter_conf)

ogc/na/input_filters/csv.py

@@ -0,0 +1,71 @@
+"""
+CSV Input filter for ingest_json.
+
+Returns CSV rows as a list. Values will always be strings (no type inference or coercion is performed).
+
+Configuration values:
+
+* `rows` (default: `dict`): type of elements in the result list:
+    * `dict`: elements will be dictionaries, with the keys taken from the `header-row`.
+    * `list`: each resulting row will be an array values.
+* `header-row` (default: `0`): if `rows` is `dict`, the (0-based) index of the header row. All rows before the
+    header row will be skipped.
+* `skip-rows` (default: `0`): number of rows to skip at the beginning of the file (apart from the header and pre-header
+    ones if `rows` is `dict`).
+* `delimiter` (default: `,`): field separator character
+* `quotechar` (default: `"`): char used to quote (enclose) field values
+* `skip-empty-rows` (default: `True`): whether to omit empty rows (i.e., those with no values) from the result
+* `trim-values` (default: `False`): whether to apply `.strip()` to the resulting values
+"""
+from __future__ import annotations
+
+import csv
+from io import BytesIO, TextIOWrapper, StringIO
+from typing import IO, Any
+
+from ogc.na import util
+
+DEFAULT_CONF = {
+    'rows': 'dict',
+    'header-row': 0,
+    'skip-rows': 0,
+    'delimiter': ',',
+    'quotechar': '"',
+    'skip-empty-rows': True,
+    'trim-values': False,
+}
+
+
+def apply_filter(content: bytes, conf: dict[str, Any] | None) -> dict[str, Any] | list:
+    conf = util.deep_update(DEFAULT_CONF, conf) if conf else DEFAULT_CONF
+
+    textio = StringIO(content.decode('utf-8'))
+    reader = csv.reader(textio, delimiter=conf['delimiter'], quotechar=conf['quotechar'])
+
+    headers = None
+    if conf['rows'] == 'dict':
+        header_row = max(conf['header-row'], 0)
+        # Skip to header row
+        for i in range(header_row):
+            next(reader, None)
+        headers = next(reader, [])
+        if not headers:
+            return []
+
+    # Skip requested rows
+    for i in range(conf['skip-rows']):
+        next(reader, None)
+
+    result = []
+    for row in reader:
+        if not row and conf['skip-empty-rows']:
+            # skip empty rows
+            continue
+        if conf['trim-values']:
+            row = [v.strip() for v in row]
+        if conf['rows'] == 'list':
+            result.append(row)
+        else:
+            result.append(dict(zip(headers, row)))
+
+    return result

ogc/na/profile.py

@@ -202,7 +202,7 @@ class ProfileRegistry:
             if isinstance(src, str) and src.startswith('sparql:'):
                 endpoint = src[len('sparql:'):]
                 logger.info("Fetching profiles from SPARQL endpoint %s", endpoint)
-                assert util.isurl(endpoint)
+                assert util.is_url(endpoint, http_only=True)
                 s = g.query(PROFILES_QUERY.replace('__SERVICE__', f"SERVICE <{endpoint}>")).graph
                 util.copy_triples(s, g)
             else:

ogc/na/util.py

@@ -7,7 +7,8 @@ import os.path
 import shlex
 from glob import glob
 from pathlib import Path
-from typing import Optional, Union, Any
+from time import time
+from typing import Optional, Union, Any, Mapping, Hashable
 
 import requests
 import rfc3987
@@ -18,6 +19,7 @@ from urllib.parse import urlparse
 from ogc.na.validation import ValidationReport
 
 import yaml
+
 try:
     from yaml import CLoader as YamlLoader, CSafeLoader as SafeYamlLoader, CDumper as YamlDumper
 except ImportError:
@@ -105,12 +107,12 @@ def validate(g: Graph, shacl_graph: Graph, extra: Optional[Graph] = None) -> Val
                                            advanced=True))
 
 
-def isurl(url: str, http_only: bool = False) -> bool:
+def is_url(url: str, http_only: bool = False) -> bool:
     """
     Checks whether a string is a valid URL.
 
     :param url: the input string
-    :param http_only: whether to only accept HTTP and HTTPS URL's as valid
+    :param http_only: whether to only accept HTTP and HTTPS URLs as valid
     :return: `True` if this is a valid URL, otherwise `False`
     """
     if not url:
@@ -159,7 +161,7 @@ def dump_yaml(content: Any, filename: str | Path | None = None,
 
     :param content: content to convert to YAML.
     :param filename: optional filename to dump the content into. If None, string content will be returned.
-    :param kwargs: other args to pass to yaml.dump
+    :param kwargs: other args to pass to `yaml.dump()`
     """
     kwargs.setdefault('sort_keys', False)
     if filename:
@@ -188,14 +190,6 @@ def merge_dicts(src: dict, dst: dict) -> dict:
     return dst
 
 
-def is_url(s: str) -> bool:
-    try:
-        url = urlparse(s)
-        return bool(url.scheme and url.netloc)
-    except ValueError:
-        return False
-
-
 def glob_list_split(s: str, exclude_dirs: bool = True, recursive: bool = False) -> list[str]:
     result = []
     for e in shlex.split(s):
@@ -206,3 +200,42 @@ def glob_list_split(s: str, exclude_dirs: bool = True, recursive: bool = False)
                 if not exclude_dirs or os.path.isfile(fn):
                     result.append(fn)
     return result
+
+
+class LRUCache:
+
+    def __init__(self, maxsize: int = 10):
+        self._cache: dict[Hashable, Any] = {}
+        self._last_access: dict[Hashable, float] = {}
+        self._maxsize = maxsize
+
+    def __contains__(self, item):
+        return item in self._cache
+
+    def __len__(self):
+        return len(self._cache)
+
+    def get(self, key, default=None):
+        if not isinstance(key, Hashable):
+            return default
+        return self._cache.get(key, default)
+
+    def __setitem__(self, key, value):
+        if not isinstance(key, Hashable):
+            return
+        if len(self._cache) >= self._maxsize and key not in self._cache:
+            key_to_remove = min(self._last_access, key=self._last_access.get)
+            del self._cache[key_to_remove]
+            del self._last_access[key_to_remove]
+        self._cache[key] = value
+        self._last_access[key] = time()
+
+
+def deep_update(orig_dict: dict, with_dict: dict, replace: bool = False) -> dict:
+    dest = orig_dict if replace else {**orig_dict}
+    for k, v in with_dict.items():
+        if isinstance(v, Mapping):
+            dest[k] = deep_update(orig_dict.get(k, {}), with_dict, replace)
+        else:
+            dest[k] = v
+    return dest

{ogc_na-0.1.2.dist-info → ogc_na-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ogc-na
-Version: 0.1.2
+Version: 0.1.4
 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.1.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+ogc/na/__init__.py,sha256=uzcNiJ3uKFNJ1HBfKxIwgAy2HMUFsLAe5RkrUg8ncac,464
+ogc/na/annotate_schema.py,sha256=qwbpiZgEoV9P0-kzgAR79_OiCKkJdlVZUCdFJ0JYZq4,21506
+ogc/na/domain_config.py,sha256=bnSyv2XF0x_v1VHF5N4jQkb7j_G2obdkzcSvWSv42Uw,12443
+ogc/na/download.py,sha256=2afrLyl4WsAlxkCgXsl47fs9mNKfDmhVpeT2iwNSoq0,3354
+ogc/na/ingest_json.py,sha256=VaXFHuIduezBjUZuBxiafuxbJy2L90KEPS3UXkUJ3Cg,31236
+ogc/na/profile.py,sha256=AkcWA52uueufK8XTyHTpVjFSp1bFKAZK7Gg3MmdGWdU,14461
+ogc/na/provenance.py,sha256=zm3RwfnjISQfTekYXu1-GlgezGcUJSbmptTkLcitcfs,5446
+ogc/na/update_vocabs.py,sha256=FdHwqpihZpDZiJJfRFywXLZCqZCsgGKmDgxwGGUlbus,17174
+ogc/na/util.py,sha256=88UIxEFeRa92lNmEZHC3Of1qZrkXOzvUrSiSMsPSyic,7331
+ogc/na/validation.py,sha256=FkXx1Pwot4ztg9Vv2LrODfYxpknG9-67BmY3Ep7avd4,3535
+ogc/na/input_filters/__init__.py,sha256=8i7Q9INCDYz5xAWzR6R4t4nWw2XAdrITT_LNML1hmR4,849
+ogc/na/input_filters/csv.py,sha256=teUu0KSB2PLGPGGUvpxy4yug22g3vgpSI77rR5HRa-o,2365
+ogc_na-0.1.4.dist-info/METADATA,sha256=J6CIO-SJYB31Wiw_5dq2yVG8mIlLux6lUiw_Sqy_-e8,3527
+ogc_na-0.1.4.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+ogc_na-0.1.4.dist-info/top_level.txt,sha256=Kvy3KhzcIhNPT4_nZuJCmS946ptRr_MDyU4IIhZJhCY,4
+ogc_na-0.1.4.dist-info/RECORD,,

ogc_na-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-ogc/na/__init__.py,sha256=uzcNiJ3uKFNJ1HBfKxIwgAy2HMUFsLAe5RkrUg8ncac,464
-ogc/na/annotate_schema.py,sha256=DX0dqgl_ql2PnSh85T_akZHpROOrIH_ZFSHZPg38c3Q,18165
-ogc/na/domain_config.py,sha256=bnSyv2XF0x_v1VHF5N4jQkb7j_G2obdkzcSvWSv42Uw,12443
-ogc/na/download.py,sha256=2afrLyl4WsAlxkCgXsl47fs9mNKfDmhVpeT2iwNSoq0,3354
-ogc/na/ingest_json.py,sha256=MoIQGcWgBLC4WKwWv0QbIWDbXVuEaXy_Oz9YhqQATXs,30863
-ogc/na/profile.py,sha256=34SiZ2H_RJZaQpMKd3GkuyYoGKUfp7BTuVd0lhJY8yw,14444
-ogc/na/provenance.py,sha256=zm3RwfnjISQfTekYXu1-GlgezGcUJSbmptTkLcitcfs,5446
-ogc/na/update_vocabs.py,sha256=FdHwqpihZpDZiJJfRFywXLZCqZCsgGKmDgxwGGUlbus,17174
-ogc/na/util.py,sha256=OSHEBKZfX3ZOwE-VBmAtg9udu4dP1iMhZEiCZZfq4Ac,6216
-ogc/na/validation.py,sha256=FkXx1Pwot4ztg9Vv2LrODfYxpknG9-67BmY3Ep7avd4,3535
-ogc_na-0.1.2.dist-info/METADATA,sha256=SAAD05QiTXEXq4Pyj4SAYF_UpO6NfBHaMJ3heYdwmHA,3527
-ogc_na-0.1.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-ogc_na-0.1.2.dist-info/top_level.txt,sha256=Kvy3KhzcIhNPT4_nZuJCmS946ptRr_MDyU4IIhZJhCY,4
-ogc_na-0.1.2.dist-info/RECORD,,