umarise-huggingface 0.1.0__tar.gz

umarise_huggingface-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: umarise-huggingface
+Version: 0.1.0
+Summary: Anchor every HuggingFace upload to Bitcoin. Zero-touch provenance for models and datasets.
+Author-email: Umarise <partners@umarise.com>
+License: Unlicense
+Project-URL: Homepage, https://umarise.com
+Project-URL: Documentation, https://umarise.com/api-reference
+Project-URL: Repository, https://github.com/AnchoringTrust/umarise-huggingface
+Keywords: umarise,huggingface,transformers,anchoring,bitcoin,proof-of-existence,opentimestamps,provenance,ai-audit,model-provenance,dataset-provenance
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security :: Cryptography
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: umarise-core-sdk>=1.1.0
+Requires-Dist: huggingface-hub>=0.20
+
+# umarise-huggingface
+
+**Anchor every HuggingFace upload to Bitcoin. Automatically.**
+
+`umarise-huggingface` intercepts `upload_file()` and `upload_folder()` to automatically compute a local SHA-256 hash and anchor it to Bitcoin via the Umarise Core API. No files are transmitted — only the hash.
+
+## Install
+
+```bash
+pip install umarise-huggingface
+export UMARISE_API_KEY=um_your_key_here
+```
+
+## Usage
+
+### Option 1: Auto-anchor (recommended)
+
+```python
+import umarise_huggingface
+from huggingface_hub import HfApi
+
+umarise_huggingface.enable()
+
+api = HfApi()
+api.upload_file(
+    path_or_fileobj="model.safetensors",
+    path_in_repo="model.safetensors",
+    repo_id="your-org/your-model",
+)
+# [umarise] ✓ Anchored your-org/your-model:model.safetensors → origin_id: abc123...
+```
+
+### Option 2: With transformers push_to_hub
+
+```python
+import umarise_huggingface
+umarise_huggingface.enable()
+
+# Works automatically with any push_to_hub call
+model.push_to_hub("your-org/your-model")
+tokenizer.push_to_hub("your-org/your-model")
+# Each file is automatically anchored
+```
+
+### Option 3: Explicit
+
+```python
+from umarise_huggingface import anchor_file, anchor_folder
+
+# Single file
+origin_id = anchor_file("model.safetensors")
+
+# Entire directory
+results = anchor_folder("./model_output/", pattern="*.safetensors")
+```
+
+## What happens
+
+1. You upload via HuggingFace Hub — upload proceeds normally
+2. SHA-256 is computed **locally** — bytes never leave your machine
+3. Hash is submitted to Umarise Core API → anchored to Bitcoin
+4. `origin_id` is printed to stderr
+5. Within ~2 hours, proof is confirmed on the Bitcoin blockchain
+
+## What this proves
+
+- ✓ This exact model/dataset existed no later than time T
+- ✓ The artifact was not modified after anchoring
+- ✓ Anyone can verify — no Umarise account needed
+
+## Verify
+
+```bash
+# Get the hash of your file
+shasum -a 256 model.safetensors
+
+# Verify against Umarise
+curl -s https://core.umarise.com/v1-core-verify \
+  -H 'Content-Type: application/json' \
+  -d '{"hash":"sha256:YOUR_HASH"}' | python3 -m json.tool
+```
+
+Or visit [verify-anchoring.org](https://verify-anchoring.org)
+
+## Design principles
+
+- **Never breaks your pipeline** — if anchoring fails, uploads continue normally
+- **Zero storage** — only the SHA-256 hash is sent to Umarise
+- **Vault-independent** — HuggingFace stores the data, Umarise stores the proof
+- **Independently verifiable** — no Umarise account needed to verify
+
+## Links
+
+- [Umarise](https://umarise.com)
+- [API Reference](https://umarise.com/api-reference)
+- [Anchoring Specification](https://anchoring-spec.org)
+- [umarise-wandb](https://pypi.org/project/umarise-wandb/)
+- [umarise-mlflow](https://pypi.org/project/umarise-mlflow/)
+
+## License
+
+[Unlicense](https://unlicense.org) — public domain.

umarise_huggingface-0.1.0/README.md

@@ -0,0 +1,102 @@
+# umarise-huggingface
+
+**Anchor every HuggingFace upload to Bitcoin. Automatically.**
+
+`umarise-huggingface` intercepts `upload_file()` and `upload_folder()` to automatically compute a local SHA-256 hash and anchor it to Bitcoin via the Umarise Core API. No files are transmitted — only the hash.
+
+## Install
+
+```bash
+pip install umarise-huggingface
+export UMARISE_API_KEY=um_your_key_here
+```
+
+## Usage
+
+### Option 1: Auto-anchor (recommended)
+
+```python
+import umarise_huggingface
+from huggingface_hub import HfApi
+
+umarise_huggingface.enable()
+
+api = HfApi()
+api.upload_file(
+    path_or_fileobj="model.safetensors",
+    path_in_repo="model.safetensors",
+    repo_id="your-org/your-model",
+)
+# [umarise] ✓ Anchored your-org/your-model:model.safetensors → origin_id: abc123...
+```
+
+### Option 2: With transformers push_to_hub
+
+```python
+import umarise_huggingface
+umarise_huggingface.enable()
+
+# Works automatically with any push_to_hub call
+model.push_to_hub("your-org/your-model")
+tokenizer.push_to_hub("your-org/your-model")
+# Each file is automatically anchored
+```
+
+### Option 3: Explicit
+
+```python
+from umarise_huggingface import anchor_file, anchor_folder
+
+# Single file
+origin_id = anchor_file("model.safetensors")
+
+# Entire directory
+results = anchor_folder("./model_output/", pattern="*.safetensors")
+```
+
+## What happens
+
+1. You upload via HuggingFace Hub — upload proceeds normally
+2. SHA-256 is computed **locally** — bytes never leave your machine
+3. Hash is submitted to Umarise Core API → anchored to Bitcoin
+4. `origin_id` is printed to stderr
+5. Within ~2 hours, proof is confirmed on the Bitcoin blockchain
+
+## What this proves
+
+- ✓ This exact model/dataset existed no later than time T
+- ✓ The artifact was not modified after anchoring
+- ✓ Anyone can verify — no Umarise account needed
+
+## Verify
+
+```bash
+# Get the hash of your file
+shasum -a 256 model.safetensors
+
+# Verify against Umarise
+curl -s https://core.umarise.com/v1-core-verify \
+  -H 'Content-Type: application/json' \
+  -d '{"hash":"sha256:YOUR_HASH"}' | python3 -m json.tool
+```
+
+Or visit [verify-anchoring.org](https://verify-anchoring.org)
+
+## Design principles
+
+- **Never breaks your pipeline** — if anchoring fails, uploads continue normally
+- **Zero storage** — only the SHA-256 hash is sent to Umarise
+- **Vault-independent** — HuggingFace stores the data, Umarise stores the proof
+- **Independently verifiable** — no Umarise account needed to verify
+
+## Links
+
+- [Umarise](https://umarise.com)
+- [API Reference](https://umarise.com/api-reference)
+- [Anchoring Specification](https://anchoring-spec.org)
+- [umarise-wandb](https://pypi.org/project/umarise-wandb/)
+- [umarise-mlflow](https://pypi.org/project/umarise-mlflow/)
+
+## License
+
+[Unlicense](https://unlicense.org) — public domain.

umarise_huggingface-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "umarise-huggingface"
+version = "0.1.0"
+description = "Anchor every HuggingFace upload to Bitcoin. Zero-touch provenance for models and datasets."
+readme = "README.md"
+license = {text = "Unlicense"}
+requires-python = ">=3.8"
+authors = [{name = "Umarise", email = "partners@umarise.com"}]
+keywords = [
+    "umarise", "huggingface", "transformers", "anchoring", "bitcoin",
+    "proof-of-existence", "opentimestamps", "provenance", "ai-audit",
+    "model-provenance", "dataset-provenance"
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Security :: Cryptography",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "umarise-core-sdk>=1.1.0",
+    "huggingface-hub>=0.20",
+]
+
+[project.urls]
+Homepage = "https://umarise.com"
+Documentation = "https://umarise.com/api-reference"
+Repository = "https://github.com/AnchoringTrust/umarise-huggingface"

umarise_huggingface-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

umarise_huggingface-0.1.0/umarise_huggingface/__init__.py

@@ -0,0 +1,19 @@
+"""
+umarise-huggingface: Anchor HuggingFace uploads to Bitcoin.
+
+Usage:
+    # Option 1: Auto-anchor (recommended)
+    import umarise_huggingface
+    umarise_huggingface.enable()
+    # All subsequent upload_file/upload_folder/push_to_hub calls are anchored
+
+    # Option 2: Explicit
+    from umarise_huggingface import anchor_file
+    origin_id = anchor_file("model.safetensors")
+"""
+
+from umarise_huggingface.anchor import anchor_file, anchor_folder
+from umarise_huggingface.hook import enable, disable
+
+__version__ = "0.1.0"
+__all__ = ["anchor_file", "anchor_folder", "enable", "disable"]

umarise_huggingface-0.1.0/umarise_huggingface/anchor.py

@@ -0,0 +1,105 @@
+"""
+Core anchoring functions for HuggingFace Hub uploads.
+
+Architecture:
+    upload_file() / push_to_hub() → HuggingFace Hub (unchanged)
+                                   → SHA-256 hash locally
+                                   → Hash submitted to Umarise Core API
+                                   → origin_id printed to stderr
+"""
+
+import hashlib
+import os
+import sys
+from typing import Optional
+
+
+def _hash_file(path: str) -> str:
+    """Compute SHA-256 of a local file."""
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _get_client(api_key: Optional[str] = None):
+    """Lazy-import UmariseCore."""
+    from umarise import UmariseCore
+    key = api_key or os.environ.get("UMARISE_API_KEY")
+    if not key:
+        raise RuntimeError(
+            "UMARISE_API_KEY not set. Export it or pass api_key= to enable()."
+        )
+    return UmariseCore(api_key=key)
+
+
+def anchor_file(
+    file_path: str,
+    api_key: Optional[str] = None,
+    repo_id: Optional[str] = None,
+) -> Optional[str]:
+    """
+    Anchor a single file to Bitcoin via Umarise.
+
+    Args:
+        file_path: Local path to the file.
+        api_key: Umarise API key (falls back to UMARISE_API_KEY).
+        repo_id: Optional HF repo ID for logging context.
+
+    Returns:
+        origin_id if successful, None otherwise.
+    """
+    try:
+        file_hash = _hash_file(file_path)
+        client = _get_client(api_key)
+        result = client.attest(f"sha256:{file_hash}")
+
+        origin_id = getattr(result, "origin_id", None) or "unknown"
+        proof_status = getattr(result, "proof_status", None) or "pending"
+
+        label = f"{repo_id}:{os.path.basename(file_path)}" if repo_id else os.path.basename(file_path)
+        print(
+            f"[umarise] ✓ Anchored {label} → {origin_id} ({proof_status})",
+            file=sys.stderr,
+        )
+        return origin_id
+
+    except Exception as e:
+        print(
+            f"[umarise] ⚠ Anchoring failed for {file_path}: {e}",
+            file=sys.stderr,
+        )
+        return None
+
+
+def anchor_folder(
+    folder_path: str,
+    api_key: Optional[str] = None,
+    repo_id: Optional[str] = None,
+    pattern: Optional[str] = None,
+) -> list:
+    """
+    Anchor all files in a folder to Bitcoin.
+
+    Args:
+        folder_path: Local directory path.
+        api_key: Umarise API key.
+        repo_id: Optional HF repo ID for logging context.
+        pattern: Optional glob pattern to filter files (e.g., "*.safetensors").
+
+    Returns:
+        List of (file_path, origin_id) tuples.
+    """
+    import fnmatch
+
+    results = []
+    for root, _, files in os.walk(folder_path):
+        for fname in files:
+            if pattern and not fnmatch.fnmatch(fname, pattern):
+                continue
+            fpath = os.path.join(root, fname)
+            origin_id = anchor_file(fpath, api_key=api_key, repo_id=repo_id)
+            results.append((fpath, origin_id))
+
+    return results

umarise_huggingface-0.1.0/umarise_huggingface/hook.py

@@ -0,0 +1,100 @@
+"""
+Auto-anchor hook for HuggingFace Hub.
+
+Monkey-patches huggingface_hub.HfApi methods to automatically
+anchor every uploaded file to Bitcoin via Umarise.
+
+Intercepted methods:
+    - upload_file()
+    - upload_folder()
+"""
+
+import os
+import sys
+from typing import Optional
+
+from umarise_huggingface.anchor import anchor_file, anchor_folder
+
+
+# Global state
+_original_upload_file = None
+_original_upload_folder = None
+_enabled = False
+
+
+def enable(api_key: Optional[str] = None):
+    """
+    Enable automatic anchoring for all HuggingFace Hub uploads.
+
+    Call once at the start of your script:
+        import umarise_huggingface
+        umarise_huggingface.enable()
+
+    Every subsequent upload_file() and upload_folder() call
+    will automatically anchor the uploaded files to Bitcoin.
+    """
+    global _original_upload_file, _original_upload_folder, _enabled
+
+    if _enabled:
+        return
+
+    from huggingface_hub import HfApi
+
+    _original_upload_file = HfApi.upload_file
+    _original_upload_folder = HfApi.upload_folder
+
+    _api_key = api_key
+
+    def _patched_upload_file(self, *args, **kwargs):
+        result = _original_upload_file(self, *args, **kwargs)
+
+        # Extract path_or_fileobj from args or kwargs
+        try:
+            path = kwargs.get("path_or_fileobj") or (args[0] if args else None)
+            repo_id = kwargs.get("repo_id") or (args[1] if len(args) > 1 else None)
+
+            if path and isinstance(path, str) and os.path.isfile(path):
+                anchor_file(path, api_key=_api_key, repo_id=repo_id)
+        except Exception as e:
+            print(f"[umarise] ⚠ auto_anchor error: {e}", file=sys.stderr)
+
+        return result
+
+    def _patched_upload_folder(self, *args, **kwargs):
+        result = _original_upload_folder(self, *args, **kwargs)
+
+        try:
+            folder_path = kwargs.get("folder_path") or (args[0] if args else None)
+            repo_id = kwargs.get("repo_id") or (args[1] if len(args) > 1 else None)
+
+            if folder_path and os.path.isdir(folder_path):
+                anchor_folder(folder_path, api_key=_api_key, repo_id=repo_id)
+        except Exception as e:
+            print(f"[umarise] ⚠ auto_anchor error: {e}", file=sys.stderr)
+
+        return result
+
+    HfApi.upload_file = _patched_upload_file
+    HfApi.upload_folder = _patched_upload_folder
+    _enabled = True
+
+    print("[umarise] ✓ HuggingFace auto-anchoring enabled", file=sys.stderr)
+
+
+def disable():
+    """Disable automatic anchoring."""
+    global _original_upload_file, _original_upload_folder, _enabled
+
+    if not _enabled:
+        return
+
+    from huggingface_hub import HfApi
+
+    if _original_upload_file:
+        HfApi.upload_file = _original_upload_file
+    if _original_upload_folder:
+        HfApi.upload_folder = _original_upload_folder
+
+    _original_upload_file = None
+    _original_upload_folder = None
+    _enabled = False

umarise_huggingface-0.1.0/umarise_huggingface.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: umarise-huggingface
+Version: 0.1.0
+Summary: Anchor every HuggingFace upload to Bitcoin. Zero-touch provenance for models and datasets.
+Author-email: Umarise <partners@umarise.com>
+License: Unlicense
+Project-URL: Homepage, https://umarise.com
+Project-URL: Documentation, https://umarise.com/api-reference
+Project-URL: Repository, https://github.com/AnchoringTrust/umarise-huggingface
+Keywords: umarise,huggingface,transformers,anchoring,bitcoin,proof-of-existence,opentimestamps,provenance,ai-audit,model-provenance,dataset-provenance
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security :: Cryptography
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: umarise-core-sdk>=1.1.0
+Requires-Dist: huggingface-hub>=0.20
+
+# umarise-huggingface
+
+**Anchor every HuggingFace upload to Bitcoin. Automatically.**
+
+`umarise-huggingface` intercepts `upload_file()` and `upload_folder()` to automatically compute a local SHA-256 hash and anchor it to Bitcoin via the Umarise Core API. No files are transmitted — only the hash.
+
+## Install
+
+```bash
+pip install umarise-huggingface
+export UMARISE_API_KEY=um_your_key_here
+```
+
+## Usage
+
+### Option 1: Auto-anchor (recommended)
+
+```python
+import umarise_huggingface
+from huggingface_hub import HfApi
+
+umarise_huggingface.enable()
+
+api = HfApi()
+api.upload_file(
+    path_or_fileobj="model.safetensors",
+    path_in_repo="model.safetensors",
+    repo_id="your-org/your-model",
+)
+# [umarise] ✓ Anchored your-org/your-model:model.safetensors → origin_id: abc123...
+```
+
+### Option 2: With transformers push_to_hub
+
+```python
+import umarise_huggingface
+umarise_huggingface.enable()
+
+# Works automatically with any push_to_hub call
+model.push_to_hub("your-org/your-model")
+tokenizer.push_to_hub("your-org/your-model")
+# Each file is automatically anchored
+```
+
+### Option 3: Explicit
+
+```python
+from umarise_huggingface import anchor_file, anchor_folder
+
+# Single file
+origin_id = anchor_file("model.safetensors")
+
+# Entire directory
+results = anchor_folder("./model_output/", pattern="*.safetensors")
+```
+
+## What happens
+
+1. You upload via HuggingFace Hub — upload proceeds normally
+2. SHA-256 is computed **locally** — bytes never leave your machine
+3. Hash is submitted to Umarise Core API → anchored to Bitcoin
+4. `origin_id` is printed to stderr
+5. Within ~2 hours, proof is confirmed on the Bitcoin blockchain
+
+## What this proves
+
+- ✓ This exact model/dataset existed no later than time T
+- ✓ The artifact was not modified after anchoring
+- ✓ Anyone can verify — no Umarise account needed
+
+## Verify
+
+```bash
+# Get the hash of your file
+shasum -a 256 model.safetensors
+
+# Verify against Umarise
+curl -s https://core.umarise.com/v1-core-verify \
+  -H 'Content-Type: application/json' \
+  -d '{"hash":"sha256:YOUR_HASH"}' | python3 -m json.tool
+```
+
+Or visit [verify-anchoring.org](https://verify-anchoring.org)
+
+## Design principles
+
+- **Never breaks your pipeline** — if anchoring fails, uploads continue normally
+- **Zero storage** — only the SHA-256 hash is sent to Umarise
+- **Vault-independent** — HuggingFace stores the data, Umarise stores the proof
+- **Independently verifiable** — no Umarise account needed to verify
+
+## Links
+
+- [Umarise](https://umarise.com)
+- [API Reference](https://umarise.com/api-reference)
+- [Anchoring Specification](https://anchoring-spec.org)
+- [umarise-wandb](https://pypi.org/project/umarise-wandb/)
+- [umarise-mlflow](https://pypi.org/project/umarise-mlflow/)
+
+## License
+
+[Unlicense](https://unlicense.org) — public domain.

umarise_huggingface-0.1.0/umarise_huggingface.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+umarise_huggingface/__init__.py
+umarise_huggingface/anchor.py
+umarise_huggingface/hook.py
+umarise_huggingface.egg-info/PKG-INFO
+umarise_huggingface.egg-info/SOURCES.txt
+umarise_huggingface.egg-info/dependency_links.txt
+umarise_huggingface.egg-info/requires.txt
+umarise_huggingface.egg-info/top_level.txt

umarise_huggingface-0.1.0/umarise_huggingface.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

umarise_huggingface-0.1.0/umarise_huggingface.egg-info/requires.txt

@@ -0,0 +1,2 @@
+umarise-core-sdk>=1.1.0
+huggingface-hub>=0.20

umarise_huggingface-0.1.0/umarise_huggingface.egg-info/top_level.txt

@@ -0,0 +1 @@
+umarise_huggingface