datasluice 0.2.0__py3-none-any.whl

datasluice/__init__.py

@@ -0,0 +1,103 @@
+"""DataSluice — one Python interface for open-data discovery, extraction,
+format normalization, and pipeline integration.
+"""
+
+from datasluice._version import __version__
+from datasluice.application import (
+    CatalogResourceLocator,
+    DataSluice,
+    DirectResourceLocator,
+    OpenedResource,
+    Portal,
+    ResourceLocator,
+    resource_locator_from_dict,
+)
+from datasluice.domain import (
+    Artifact,
+    ArtifactProvenance,
+    CatalogCapabilities,
+    CredentialScope,
+    Dataset,
+    DetectionResult,
+    Digest,
+    HttpDownload,
+    License,
+    LocalFile,
+    ObjectStorage,
+    Organization,
+    Query,
+    QueryAccess,
+    Resource,
+    ResourceAccess,
+    Schema,
+    SearchResult,
+    StreamAccess,
+    SyncState,
+)
+from datasluice.exceptions import (
+    AdapterError,
+    AdapterNotFoundError,
+    AuthenticationError,
+    ChecksumMismatchError,
+    ConfigError,
+    DataSluiceError,
+    DownloadError,
+    FormatError,
+    NotFoundError,
+    OpenedResourceConsumedError,
+    PortalDetectionError,
+    PortalError,
+    RateLimitError,
+    ResourceResolutionError,
+    StateStoreError,
+    SyncStateConflictError,
+)
+
+__all__ = [
+    "__version__",
+    "DataSluice",
+    "Portal",
+    "OpenedResource",
+    "DirectResourceLocator",
+    "CatalogResourceLocator",
+    "ResourceLocator",
+    "resource_locator_from_dict",
+    # Domain models
+    "Dataset",
+    "Resource",
+    "Organization",
+    "License",
+    "Query",
+    "SearchResult",
+    "Artifact",
+    "ArtifactProvenance",
+    "CatalogCapabilities",
+    "CredentialScope",
+    "DetectionResult",
+    "Digest",
+    "HttpDownload",
+    "LocalFile",
+    "ObjectStorage",
+    "QueryAccess",
+    "ResourceAccess",
+    "Schema",
+    "StreamAccess",
+    "SyncState",
+    # Exceptions
+    "DataSluiceError",
+    "PortalError",
+    "AdapterError",
+    "AdapterNotFoundError",
+    "PortalDetectionError",
+    "AuthenticationError",
+    "RateLimitError",
+    "StateStoreError",
+    "SyncStateConflictError",
+    "NotFoundError",
+    "DownloadError",
+    "ChecksumMismatchError",
+    "FormatError",
+    "ConfigError",
+    "ResourceResolutionError",
+    "OpenedResourceConsumedError",
+]

datasluice/_uri.py

@@ -0,0 +1,77 @@
+"""URI display sanitizer: redact userinfo and sensitive query values (CR-07).
+
+Query-position API keys, bearer tokens, signed-URL signatures, and
+``user:password@`` userinfo routinely end up embedded inside URI strings
+that flow into log records and exception messages. The package
+:class:`datasluice.logging.RedactingFilter` only inspects named dict
+keys, so it cannot redact a secret buried inside a positional URL string.
+This module provides :func:`sanitize_uri` for every call site that needs
+a URI for human-facing display. The unsanitized URI is still used for
+actual I/O.
+"""
+
+from __future__ import annotations
+
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+_SENSITIVE_QUERY_KEYS = frozenset(
+    {
+        "api_key",
+        "apikey",
+        "token",
+        "access_token",
+        "refresh_token",
+        "secret",
+        "signature",
+        "credential",
+        "password",
+        "x-api-key",
+        "x-api-token",
+        "x-auth-token",
+    }
+)
+
+_REDACTED = "***"
+
+
+def sanitize_uri(uri: str) -> str:
+    """Return *uri* with userinfo and sensitive query values redacted for safe display.
+
+    Strips ``user:password@`` from the netloc (keeping host and port) and
+    replaces the value of every sensitive query parameter (``api_key``,
+    ``token``, ``signature``, …) with ``"***"``. The returned value is
+    suitable only for logs, exception text, and other human-facing display;
+    never reuse it for actual I/O, because the redaction discards
+    credentials the destination filesystem still needs.
+
+    Strings without a scheme are returned unchanged so this helper is safe to
+    call on path-like state keys, bare paths, or opaque identifiers.
+    """
+    try:
+        parts = urlsplit(uri)
+    except ValueError:
+        return uri
+    if not parts.scheme:
+        return uri
+    if parts.hostname is None:
+        netloc = parts.netloc.rsplit("@", 1)[-1]
+    else:
+        try:
+            port = parts.port
+        except ValueError:
+            port = None
+        hostname = parts.hostname
+        if ":" in hostname:
+            hostname = f"[{hostname}]"
+        netloc = hostname if port is None else f"{hostname}:{port}"
+    redacted: list[tuple[str, str]] = []
+    if parts.query:
+        try:
+            redacted = [
+                (name, _REDACTED if name.lower() in _SENSITIVE_QUERY_KEYS else value)
+                for name, value in parse_qsl(parts.query, keep_blank_values=True)
+            ]
+        except ValueError:
+            redacted = []
+    query = urlencode(redacted, doseq=True, safe="*")
+    return urlunsplit((parts.scheme, netloc, parts.path, query, parts.fragment))

datasluice/_version.py

@@ -0,0 +1,15 @@
+"""Version information for DataSluice, read from installed package metadata.
+
+Kept in a separate module to break a circular import with
+``transport/user_agent.py``. The value is derived from ``pyproject.toml``
+(the single source of truth, kept in sync with release tags by
+**release-please**) through ``importlib.metadata`` — there is no second
+copy of the version to keep in sync. Do NOT move it into ``__init__.py``.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("datasluice")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.0"