envlib 0.1.0__tar.gz → 0.1.2__tar.gz

{envlib-0.1.0 → envlib-0.1.2}/.gitignore

@@ -116,4 +116,8 @@ data/*
 
 # Test config files
 /envlib/tests/*.toml
-/envlib/tests/*.yml
+/envlib/tests/*.yml
+# AI-assistant tool state
+/.claude/
+/.antigravity/
+/.antigravitycli/

envlib-0.1.2/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: envlib
+Version: 0.1.2
+Summary: The environmental library
+Project-URL: Documentation, https://envlib.github.io/envlib/
+Project-URL: Source, https://github.com/envlib/envlib
+Author-email: mullenkamp <mullenkamp1@gmail.com>
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Requires-Dist: booklet>=0.12.6
+Requires-Dist: cfdb>=0.9.1
+Requires-Dist: ebooklet>=0.10.0
+Requires-Dist: pyproj
+Requires-Dist: shapely>=2.0
+Requires-Dist: urllib3
+Description-Content-Type: text/markdown
+
+# envlib
+
+<p align="center">
+    <em>A distributed catalogue for environmental data</em>
+</p>
+
+[![build](https://github.com/envlib/envlib/workflows/Build/badge.svg)](https://github.com/envlib/envlib/actions)
+[![codecov](https://codecov.io/gh/envlib/envlib/branch/main/graph/badge.svg)](https://codecov.io/gh/envlib/envlib)
+[![PyPI version](https://badge.fury.io/py/envlib.svg)](https://badge.fury.io/py/envlib)
+
+---
+
+**Documentation**: <a href="https://envlib.github.io/envlib/" target="_blank">https://envlib.github.io/envlib/</a>
+
+**Source Code**: <a href="https://github.com/envlib/envlib" target="_blank">https://github.com/envlib/envlib</a>
+
+---
+
+## Overview
+
+envlib is a distributed database and catalogue for environmental datasets — gridded model output and station time series alike. Datasets are stored as [cfdb](https://github.com/mullenkamp/cfdb) files on S3-compatible object storage, hosted by whoever owns the data; envlib provides the shared layer on top: standardized metadata, controlled vocabularies, deterministic identifiers, and a catalogue you can query to discover and open any registered dataset.
+
+## Key features
+
+- **Distributed by design** — the catalogue is an index, not a data silo: each dataset stays on its owner's storage, and one catalogue can span many owners.
+- **Standardized metadata** — eleven identity fields (drawing on [ODM2](http://vocabulary.odm2.org/), [CF conventions](https://cfconventions.org/), and lessons from tethys) describe what every dataset *is*, validated against controlled vocabularies at creation time.
+- **Deterministic, permanent identifiers** — a dataset's identity metadata hashes to stable ids (`dataset_id`, `dataset_version_id`, `station_id`), so the same data gets the same id everywhere, forever.
+- **Queryable catalogue** — filter by any identity field, spatial extent (including across the antimeridian), and time range; browse what a catalogue holds with `cat.variables`, `cat.owners`, and friends.
+- **CF standard names derived for you** — envlib curates the mapping from its variables to CF `standard_name`s and applies it automatically at registration.
+- **cfdb storage** — every dataset version is a [cfdb](https://github.com/mullenkamp/cfdb) file: chunked, compressed, partially readable, S3-syncable.
+
+## Installation
+
+```bash
+pip install envlib
+```
+
+## Quick example
+
+```python
+import envlib
+
+# The public envlib catalogue — zero config, no credentials
+# (until it's hosted: Catalogue(remotes=['https://.../catalogue.rcg']))
+cat = envlib.Catalogue()
+
+# What's in it?
+cat.variables       # ['precipitation', 'streamflow', 'temperature']
+cat.owners          # ['ecan', 'ecmwf', 'niwa']
+
+# Find the latest version of each matching dataset
+results = cat.query(
+    variable='temperature',
+    feature='atmosphere',
+    bbox=[166, -47, 179, -34],
+    start_date='2020-01-01',
+)
+
+# Open one as a cfdb dataset and read it
+ds = results[0].open()
+temp = ds['temperature']
+```
+
+Producing data is the same library in the other direction: build a cfdb file, attach `envlib.Metadata`, and `cat.publish(...)` it — see the [documentation](https://envlib.github.io/envlib/) for the full guide.
+
+Changes between releases are tracked in the [changelog](https://envlib.github.io/envlib/changelog/).
+
+## Development
+
+### Setup environment
+
+We use [UV](https://docs.astral.sh/uv/) to manage the development environment and production build.
+
+```bash
+uv sync
+```
+
+### Run unit tests
+
+You can run all the tests with:
+
+```bash
+uv run pytest
+```
+
+### Format the code
+
+Execute the following commands to apply linting and check typing:
+
+```bash
+uv run ruff check .
+uv run black --check --diff .
+uv run mypy --install-types --non-interactive envlib
+```
+
+To auto-format:
+
+```bash
+uv run black .
+uv run ruff check --fix .
+```
+
+## License
+
+This project is licensed under the terms of the Apache Software License 2.0.

envlib-0.1.2/README.md

@@ -0,0 +1,105 @@
+# envlib
+
+<p align="center">
+    <em>A distributed catalogue for environmental data</em>
+</p>
+
+[![build](https://github.com/envlib/envlib/workflows/Build/badge.svg)](https://github.com/envlib/envlib/actions)
+[![codecov](https://codecov.io/gh/envlib/envlib/branch/main/graph/badge.svg)](https://codecov.io/gh/envlib/envlib)
+[![PyPI version](https://badge.fury.io/py/envlib.svg)](https://badge.fury.io/py/envlib)
+
+---
+
+**Documentation**: <a href="https://envlib.github.io/envlib/" target="_blank">https://envlib.github.io/envlib/</a>
+
+**Source Code**: <a href="https://github.com/envlib/envlib" target="_blank">https://github.com/envlib/envlib</a>
+
+---
+
+## Overview
+
+envlib is a distributed database and catalogue for environmental datasets — gridded model output and station time series alike. Datasets are stored as [cfdb](https://github.com/mullenkamp/cfdb) files on S3-compatible object storage, hosted by whoever owns the data; envlib provides the shared layer on top: standardized metadata, controlled vocabularies, deterministic identifiers, and a catalogue you can query to discover and open any registered dataset.
+
+## Key features
+
+- **Distributed by design** — the catalogue is an index, not a data silo: each dataset stays on its owner's storage, and one catalogue can span many owners.
+- **Standardized metadata** — eleven identity fields (drawing on [ODM2](http://vocabulary.odm2.org/), [CF conventions](https://cfconventions.org/), and lessons from tethys) describe what every dataset *is*, validated against controlled vocabularies at creation time.
+- **Deterministic, permanent identifiers** — a dataset's identity metadata hashes to stable ids (`dataset_id`, `dataset_version_id`, `station_id`), so the same data gets the same id everywhere, forever.
+- **Queryable catalogue** — filter by any identity field, spatial extent (including across the antimeridian), and time range; browse what a catalogue holds with `cat.variables`, `cat.owners`, and friends.
+- **CF standard names derived for you** — envlib curates the mapping from its variables to CF `standard_name`s and applies it automatically at registration.
+- **cfdb storage** — every dataset version is a [cfdb](https://github.com/mullenkamp/cfdb) file: chunked, compressed, partially readable, S3-syncable.
+
+## Installation
+
+```bash
+pip install envlib
+```
+
+## Quick example
+
+```python
+import envlib
+
+# The public envlib catalogue — zero config, no credentials
+# (until it's hosted: Catalogue(remotes=['https://.../catalogue.rcg']))
+cat = envlib.Catalogue()
+
+# What's in it?
+cat.variables       # ['precipitation', 'streamflow', 'temperature']
+cat.owners          # ['ecan', 'ecmwf', 'niwa']
+
+# Find the latest version of each matching dataset
+results = cat.query(
+    variable='temperature',
+    feature='atmosphere',
+    bbox=[166, -47, 179, -34],
+    start_date='2020-01-01',
+)
+
+# Open one as a cfdb dataset and read it
+ds = results[0].open()
+temp = ds['temperature']
+```
+
+Producing data is the same library in the other direction: build a cfdb file, attach `envlib.Metadata`, and `cat.publish(...)` it — see the [documentation](https://envlib.github.io/envlib/) for the full guide.
+
+Changes between releases are tracked in the [changelog](https://envlib.github.io/envlib/changelog/).
+
+## Development
+
+### Setup environment
+
+We use [UV](https://docs.astral.sh/uv/) to manage the development environment and production build.
+
+```bash
+uv sync
+```
+
+### Run unit tests
+
+You can run all the tests with:
+
+```bash
+uv run pytest
+```
+
+### Format the code
+
+Execute the following commands to apply linting and check typing:
+
+```bash
+uv run ruff check .
+uv run black --check --diff .
+uv run mypy --install-types --non-interactive envlib
+```
+
+To auto-format:
+
+```bash
+uv run black .
+uv run ruff check --fix .
+```
+
+## License
+
+This project is licensed under the terms of the Apache Software License 2.0.

{envlib-0.1.0 → envlib-0.1.2}/envlib/__init__.py

@@ -4,6 +4,6 @@ from envlib import vocabularies
 from envlib.catalogue import Catalogue, DatasetRef
 from envlib.metadata import Metadata, ValidationError, compute_station_id
 
-__version__ = '0.1.0'
+__version__ = '0.1.2'
 
 __all__ = ['Catalogue', 'DatasetRef', 'Metadata', 'ValidationError', 'compute_station_id', 'vocabularies']

{envlib-0.1.0 → envlib-0.1.2}/envlib/catalogue.py

@@ -10,7 +10,6 @@ is the authoritative metadata store; RCG entries are a derived index.
 from __future__ import annotations
 
 import datetime
-import json
 import os
 import pathlib
 import re
@@ -18,12 +17,10 @@ import urllib.parse
 import warnings
 from hashlib import blake2b
 
-import booklet
 import cfdb
 import ebooklet
 import pyproj
 import shapely
-import urllib3
 
 from envlib import vocabularies
 from envlib.metadata import (
@@ -34,9 +31,10 @@ from envlib.metadata import (
     compute_station_id,
 )
 
-# The hardcoded public RCG URL. None until the public commons is hosted —
-# overridable (and currently only usable) via the env var below.
-PUBLIC_RCG_URL: str | None = None
+# The public envlib commons catalogue (read-only, credential-less HTTPS; a
+# custom domain fronting the hosting bucket, so the URL outlives any bucket
+# move). The env var below overrides it (stand-ins, testing, mirrors).
+PUBLIC_RCG_URL: str | None = 'https://b2.envlib.xyz/file/envlib/envlib-commons/catalogue'
 PUBLIC_RCG_ENV_VAR = 'ENVLIB_PUBLIC_RCG_URL'
 DEFAULT_CACHE_DIR = '~/.envlib/cache'
 
@@ -48,10 +46,20 @@ _FULL_CIRCLE_DEG = 360.0
 
 _QUERYABLE_FIELDS = frozenset(IDENTITY_FIELDS) | {'license', 'dataset_type', 'dataset_version_id', 'dataset_id'}
 
-# Errors that indicate the remote endpoint is unreachable (offline), as opposed
-# to a well-formed remote answer like 404: urllib3 raises MaxRetryError and
-# friends (all HTTPError subclasses) on DNS/connect/timeout failures.
-_OFFLINE_ERRORS = (urllib3.exceptions.HTTPError, ConnectionError, TimeoutError)
+
+def _raise_on_push_failure(result, context: str):
+    """ebooklet's push() returns a PushResult; result.failures maps failed
+    keys to error strings (the pending changes are retained by ebooklet for
+    retry). A partial failure must never pass silently: publish/deregister
+    would claim success while the remote is not fully updated."""
+    if result.failures:
+        msg = (
+            f'{context}: the push partially failed and the remote was NOT fully updated. '
+            f'Failed keys: {result.failures}. The pending changes are retained - fix the '
+            'cause (see the ebooklet operations guide, docs/ops.md, for the recovery '
+            'recipes) and retry.'
+        )
+        raise RuntimeError(msg)
 
 
 def _public_rcg_url() -> str | None:
@@ -200,12 +208,6 @@ def _bbox_within_radius(stored, lon: float, lat: float, radius_km: float) -> boo
 # Dataset validation + State Metadata extraction
 
 
-def _sys_dataset_type(ds) -> str:
-    # cfdb 0.9.0 has no public dataset_type property (and open_edataset always
-    # returns the EGrid class), so the sys-metadata slot is the reliable source.
-    return ds._sys_meta.dataset_type.value
-
-
 def _coord_by_axis(ds, axis: str):
     for coord in ds.coords:
         ax = coord.axis
@@ -227,7 +229,7 @@ def _reproject_points(points, crs) -> list:
 
 def _extract_state(ds, meta: Metadata) -> dict:
     """Extract State Metadata (bbox, time range, steps, dataset_type) from an open dataset."""
-    dataset_type = _sys_dataset_type(ds)
+    dataset_type = ds.dataset_type
     crs = ds.crs
 
     time_coord = ds.get('time') if 'time' in ds.coord_names else None
@@ -368,7 +370,7 @@ def _decide_standard_name(ds, meta: Metadata) -> dict:
 
 
 def _validate_dataset(ds, *, validate_cv: bool) -> dict:
-    """Validate an open cfdb dataset against envlib requirements; extract everything.
+    """Validate an open cfdb file against envlib requirements; extract everything.
 
     Returns {'metadata', 'dataset_version_id', 'dataset_id', 'state', 'standard_name'}.
     Raises ValidationError on any failure. Never modifies the dataset.
@@ -402,7 +404,7 @@ def _validate_dataset(ds, *, validate_cv: bool) -> dict:
                 msg = f'declared ancillary variable {name!r} is not a data variable in the dataset.'
                 raise ValidationError(msg)
 
-    if _sys_dataset_type(ds) == 'ts_ortho':
+    if ds.dataset_type == 'ts_ortho':
         _check_stations(ds)
 
     state = _extract_state(ds, meta)
@@ -443,7 +445,7 @@ def _apply_derived_attrs(ds, result: dict) -> bool:
 
 
 class DatasetRef:
-    """A catalogue entry: metadata plus how to open the dataset."""
+    """A catalogue entry: one dataset version's metadata, plus how to open its cfdb file."""
 
     def __init__(self, dataset_version_id: str, entry: dict, cache_dir: pathlib.Path):
         self._dataset_id = dataset_version_id
@@ -473,7 +475,7 @@ class DatasetRef:
         return repr(self.metadata)
 
     def open(self, file_path=None, access_key_id=None, access_key=None):
-        """Open the dataset as a cfdb EDataset (read-only).
+        """Open this dataset version's cfdb file as a read-only EDataset.
 
         Entries never store credentials. Public-HTTPS datasets open via their
         ``data_url`` with no credentials; for private buckets inject
@@ -516,6 +518,13 @@ class Catalogue:
     to re-pull after new registrations. When a remote is unreachable and a
     previously pulled local index exists, the catalogue degrades to the cached
     copy (with a warning) instead of failing.
+
+    Example:
+        >>> cat = Catalogue(remotes=['https://s3.example.com/bucket/catalogue.rcg'])
+        >>> cat.variables
+        ['streamflow', 'temperature']
+        >>> refs = cat.query(variable='temperature', feature='atmosphere')
+        >>> ds = refs[0].open()
     """
 
     def __init__(self, remotes=None, cache: str = DEFAULT_CACHE_DIR, *, include_public: bool = False):
@@ -527,7 +536,7 @@ class Catalogue:
             public = _public_rcg_url()
             if public is None:
                 msg = (
-                    'the public envlib RCG is not hosted yet — pass remotes=[...] '
+                    'no public envlib RCG is configured — pass remotes=[...] '
                     f'or set the {PUBLIC_RCG_ENV_VAR} environment variable.'
                 )
                 raise ValueError(msg)
@@ -558,23 +567,34 @@ class Catalogue:
         for source in self._sources:
             path = self._rcg_cache_path(source)
             try:
-                with ebooklet.open_rcg(source, path, flag='r') as rcg:
+                # offline='auto': ebooklet falls back to the cached local index
+                # (with its own UserWarning) ONLY on transport-level
+                # unreachability. Everything else raises typed: a broken store
+                # (RemoteIntegrityError), an incompatible format
+                # (UnsupportedFormatError - pre-0.10 this was silently
+                # mislabeled "not readable yet" by a blanket ValueError catch),
+                # and unreachable-with-no-cache (OfflineError) all propagate.
+                with ebooklet.open_rcg(source, path, flag='r', offline='auto') as rcg:
                     source_entries = {k: v for k, v in rcg.items() if _HEX24_RE.fullmatch(str(k))}
-            except ValueError as err:
-                # ebooklet raises ValueError when the RCG does not exist on the
-                # remote yet (and no local copy exists) — the bootstrap case: a
-                # producer constructs the Catalogue before the first publish
-                # creates the RCG. Treat as an empty source, loudly.
-                warnings.warn(f'RCG source not readable yet ({err}); treating as empty.', stacklevel=2)
-                source_entries = {}
-            except _OFFLINE_ERRORS as err:
-                if not path.exists():
-                    raise
+            except ebooklet.UUIDMismatchError as err:
+                # The local cache identifies a DIFFERENT database than the
+                # remote - the remote was likely deleted and recreated.
+                # Distinct from the bootstrap case: the fix is deleting the
+                # stale cache file, so say so instead of a generic warning.
                 warnings.warn(
-                    f'RCG remote unreachable ({err!r}); operating offline from the cached index at {path}.',
+                    f'RCG source identity mismatch ({err}); the remote was likely deleted and '
+                    f'recreated. Delete the stale cache at {path} to adopt the new remote. '
+                    'Treating this source as empty for now.',
                     stacklevel=2,
                 )
-                source_entries = _read_cached_index(path)
+                source_entries = {}
+            except ebooklet.RemoteMissingError as err:
+                # The RCG does not exist on the remote yet (and no local copy
+                # exists) — the bootstrap case: a producer constructs the
+                # Catalogue before the first publish creates the RCG. Treat as
+                # an empty source, loudly.
+                warnings.warn(f'RCG source not readable yet ({err}); treating as empty.', stacklevel=2)
+                source_entries = {}
             for key, entry in source_entries.items():
                 entries.setdefault(key, entry)  # first configured source wins on duplicates
         self._entries = entries
@@ -770,13 +790,13 @@ class Catalogue:
             first_time = eds.attrs.get('envlib_dataset_version_id') is None
             result = _validate_dataset(eds, validate_cv=first_time)
             _apply_derived_attrs(eds, result)
-            eds.push()
+            _raise_on_push_failure(eds.push(), 'publish: pushing the dataset data')
 
         self._upsert_entry(rcg_remote_conn, member_conn, result)
         return result
 
     def register(self, remote_conn, rcg_remote_conn, **open_kwargs) -> dict:
-        """Register an already-remote cfdb dataset in the catalogue (no data push).
+        """Register an already-remote cfdb file in the catalogue (no data push).
 
         ``remote_conn`` must be writable (credentials): first registration
         writes the self-identification attrs (and any auto-populated
@@ -788,7 +808,7 @@ class Catalogue:
             first_time = eds.attrs.get('envlib_dataset_version_id') is None
             result = _validate_dataset(eds, validate_cv=first_time)
             if _apply_derived_attrs(eds, result):
-                eds.push()
+                _raise_on_push_failure(eds.push(), 'register: pushing the self-identification attrs')
 
         self._upsert_entry(rcg_remote_conn, member_conn, result)
         return result
@@ -820,8 +840,7 @@ class Catalogue:
                 target_conn = entry.get('remote_conn') or {}
                 target = (target_conn.get('endpoint_url'), target_conn.get('bucket'), target_conn.get('db_key'))
                 # list() first: fetching entries while iterating keys() would
-                # deadlock on the underlying booklet thread lock (see
-                # _read_cached_index).
+                # deadlock on the underlying booklet thread lock.
                 for other_key in list(rcg.keys()):
                     if other_key == dataset_version_id or not _HEX24_RE.fullmatch(str(other_key)):
                         continue
@@ -847,7 +866,7 @@ class Catalogue:
                 with member_conn.open('w') as session:
                     session.delete_remote()
             del rcg[dataset_version_id]
-            rcg.changes().push()
+            _raise_on_push_failure(rcg.changes().push(), 'deregister: pushing the catalogue entry removal')
         self.refresh()
 
     # -- entry construction ----------------------------------------------------
@@ -871,7 +890,7 @@ class Catalogue:
 
             user_meta['modified_at'] = now
             rcg.add(member_conn, key=dataset_version_id, user_meta=user_meta)
-            rcg.changes().push()
+            _raise_on_push_failure(rcg.changes().push(), 'publish/register: pushing the catalogue entry')
         self.refresh()
 
 
@@ -937,34 +956,3 @@ def _created_at(ref: DatasetRef) -> datetime.datetime:
     if value is None:
         return datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)
     return _parse_iso(value)
-
-
-def _read_cached_index(path: pathlib.Path) -> dict:
-    """Offline fallback: read a previously pulled RCG index directly with booklet.
-
-    Booklet files are self-describing (serializers stored in-file), so entries
-    decode without parameters. envlib entries are keyed by 24-hex dataset_ids;
-    everything else (ebooklet-internal keys) is skipped. Values that fail to
-    decode as entry dicts are skipped too.
-    """
-    entries: dict = {}
-    with booklet.open(path, 'r') as blt:
-        # materialize keys() BEFORE fetching: booklet's keys() generator holds
-        # the file's thread lock across yields, so a get() inside the loop
-        # deadlocks (single-threaded) — found via the hung offline test.
-        for key in list(blt.keys()):
-            key_str = key.decode() if isinstance(key, bytes) else str(key)
-            if not _HEX24_RE.fullmatch(key_str):
-                continue
-            try:
-                value = blt[key]
-            except (KeyError, ValueError):
-                continue
-            if isinstance(value, bytes):
-                try:
-                    value = json.loads(value)
-                except ValueError:
-                    continue
-            if isinstance(value, dict) and 'remote_conn' in value:
-                entries[key_str] = value
-    return entries

{envlib-0.1.0 → envlib-0.1.2}/envlib/metadata.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import math
 import re
+from collections.abc import Mapping
 from hashlib import blake2b
 from typing import cast
 
@@ -503,7 +504,7 @@ class Metadata:
         return out
 
     @classmethod
-    def from_attrs(cls, attrs, *, validate_cv: bool = True) -> Metadata:
+    def from_attrs(cls, attrs: Mapping, *, validate_cv: bool = True) -> Metadata:
         """Rebuild Metadata from ``envlib_``-prefixed attrs (``ds.attrs`` or a dict).
 
         Non-envlib keys are ignored. When ``envlib_dataset_version_id`` /

{envlib-0.1.0 → envlib-0.1.2}/envlib/vocabularies/__init__.py

@@ -293,7 +293,7 @@ def _refresh_variable(target_dir: pathlib.Path) -> dict:
     }
 
 
-def refresh(field: str | None = None, _target_dir=None) -> dict:
+def refresh(field: str | None = None, _target_dir: str | pathlib.Path | None = None) -> dict:
     """Refresh upstream-sourced vocabularies from their APIs.
 
     Fetches the ODM2 variablename list and/or the current CF standard-name table

{envlib-0.1.0 → envlib-0.1.2}/pyproject.toml

@@ -11,9 +11,9 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-  "cfdb>=0.9.0",
-  "ebooklet>=0.9.1",
-  "booklet>=0.12.5",
+  "cfdb>=0.9.1",
+  "ebooklet>=0.10.0",
+  "booklet>=0.12.6",
   "pyproj",
   "shapely>=2.0",
   "urllib3",
@@ -31,6 +31,7 @@ dev = [
   "mkdocstrings[python]",
   "types-shapely>=2.1.0.20260630",
   "numpy>=2.2.6",
+  "tomli>=2.4.1 ; python_full_version < '3.11'",
 ]
 
 [tool.pytest.ini_options]
@@ -130,8 +131,8 @@ requires = ["hatchling>=1.26.1"]
 build-backend = "hatchling.build"
 
 [project.urls]
-Documentation = "https://mullenkamp.github.io/envlib/"
-Source = "https://github.com/envlib"
+Documentation = "https://envlib.github.io/envlib/"
+Source = "https://github.com/envlib/envlib"
 
 [tool.hatch.build.targets.sdist]
 include = [

envlib-0.1.0/PKG-INFO

@@ -1,75 +0,0 @@
-Metadata-Version: 2.4
-Name: envlib
-Version: 0.1.0
-Summary: The environmental library
-Project-URL: Documentation, https://mullenkamp.github.io/envlib/
-Project-URL: Source, https://github.com/envlib
-Author-email: mullenkamp <mullenkamp1@gmail.com>
-License-File: LICENSE
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
-Requires-Dist: booklet>=0.12.5
-Requires-Dist: cfdb>=0.9.0
-Requires-Dist: ebooklet>=0.9.1
-Requires-Dist: pyproj
-Requires-Dist: shapely>=2.0
-Requires-Dist: urllib3
-Description-Content-Type: text/markdown
-
-# envlib
-
-<p align="center">
-    <em>The environmental library</em>
-</p>
-
-[![build](https://github.com/envlib/workflows/Build/badge.svg)](https://github.com/envlib/actions)
-[![codecov](https://codecov.io/gh/mullenkamp/envlib/branch/main/graph/badge.svg)](https://codecov.io/gh/mullenkamp/envlib)
-[![PyPI version](https://badge.fury.io/py/envlib.svg)](https://badge.fury.io/py/envlib)
-
----
-
-**Source Code**: <a href="https://github.com/envlib" target="_blank">https://github.com/envlib</a>
-
----
-## Overview
-envlib is a distributed database and catalogue for environmental data. It uses controlled vocabulary and standarized metadata to make it easy for users to query and access data. It uses cfdb as the backend. The metadata structure is based on tethysts.
-
-
-## Development
-
-### Setup environment
-
-We use [UV](https://docs.astral.sh/uv/) to manage the development environment and production build. 
-
-```bash
-uv sync
-```
-
-### Run unit tests
-
-You can run all the tests with:
-
-```bash
-uv run pytest
-```
-
-### Format the code
-
-Execute the following commands to apply linting and check typing:
-
-```bash
-uv run ruff check .
-uv run black --check --diff .
-uv run mypy --install-types --non-interactive envlib
-```
-
-To auto-format:
-
-```bash
-uv run black .
-uv run ruff check --fix .
-```
-
-## License
-
-This project is licensed under the terms of the Apache Software License 2.0.

envlib-0.1.0/README.md

@@ -1,57 +0,0 @@
-# envlib
-
-<p align="center">
-    <em>The environmental library</em>
-</p>
-
-[![build](https://github.com/envlib/workflows/Build/badge.svg)](https://github.com/envlib/actions)
-[![codecov](https://codecov.io/gh/mullenkamp/envlib/branch/main/graph/badge.svg)](https://codecov.io/gh/mullenkamp/envlib)
-[![PyPI version](https://badge.fury.io/py/envlib.svg)](https://badge.fury.io/py/envlib)
-
----
-
-**Source Code**: <a href="https://github.com/envlib" target="_blank">https://github.com/envlib</a>
-
----
-## Overview
-envlib is a distributed database and catalogue for environmental data. It uses controlled vocabulary and standarized metadata to make it easy for users to query and access data. It uses cfdb as the backend. The metadata structure is based on tethysts.
-
-
-## Development
-
-### Setup environment
-
-We use [UV](https://docs.astral.sh/uv/) to manage the development environment and production build. 
-
-```bash
-uv sync
-```
-
-### Run unit tests
-
-You can run all the tests with:
-
-```bash
-uv run pytest
-```
-
-### Format the code
-
-Execute the following commands to apply linting and check typing:
-
-```bash
-uv run ruff check .
-uv run black --check --diff .
-uv run mypy --install-types --non-interactive envlib
-```
-
-To auto-format:
-
-```bash
-uv run black .
-uv run ruff check --fix .
-```
-
-## License
-
-This project is licensed under the terms of the Apache Software License 2.0.