xyberos-storage 0.1.0__tar.gz

xyberos_storage-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: xyberos-storage
+Version: 0.1.0
+Summary: Object storage plugin (RFC-0019, M9): S3, Azure Blob, GCS, OneDrive behind one ObjectStore contract
+License: Apache-2.0
+Keywords: xyberos,plugin,storage,s3,azure,gcs,onedrive
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+Provides-Extra: s3
+Requires-Dist: boto3; extra == "s3"
+Provides-Extra: azure
+Requires-Dist: azure-storage-blob; extra == "azure"
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage; extra == "gcs"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# xyberos-storage
+
+**Object storage plugin — RFC-0019, M9.** S3, Azure Blob, GCS, and OneDrive
+behind one `ObjectStore` contract (`list` / `upload` / `download`).
+
+## Install
+
+```bash
+pip install -e ./storage
+pip install xyberos-storage[s3]        # optional: boto3
+pip install xyberos-storage[azure]     # optional: azure-storage-blob
+pip install xyberos-storage[gcs]       # optional: google-cloud-storage
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_storage import StoragePlugin
+
+app = create_app()
+app.load_plugin(StoragePlugin(provider="s3", bucket="my-bucket"))  # or STORAGE_PROVIDER
+
+app.tools.execute("storage_list", None, prefix="data/")
+app.tools.execute("storage_upload", None, key="data/x.txt", file_path="x.txt")
+app.tools.execute("storage_download", None, key="data/x.txt", output_path="out.txt")
+```
+
+| Provider | Key / config |
+| -------- | ------------ |
+| `s3` | `STORAGE_BUCKET` + AWS creds (lazy boto3) |
+| `azure` | `AZURE_STORAGE_CONNECTION_STRING` + `STORAGE_CONTAINER` (lazy SDK) |
+| `gcs` | `STORAGE_BUCKET` + GCP creds (lazy SDK) |
+| `onedrive` | `ONEDRIVE_ACCESS_TOKEN` (Graph REST) |
+
+## Tools
+
+- `storage_list(prefix="")`
+- `storage_upload(key, file_path)`
+- `storage_download(key, output_path)`
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Fake clients / injectable transports — no cloud, no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — enterprise storage (M9).

xyberos_storage-0.1.0/README.md

@@ -0,0 +1,53 @@
+# xyberos-storage
+
+**Object storage plugin — RFC-0019, M9.** S3, Azure Blob, GCS, and OneDrive
+behind one `ObjectStore` contract (`list` / `upload` / `download`).
+
+## Install
+
+```bash
+pip install -e ./storage
+pip install xyberos-storage[s3]        # optional: boto3
+pip install xyberos-storage[azure]     # optional: azure-storage-blob
+pip install xyberos-storage[gcs]       # optional: google-cloud-storage
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_storage import StoragePlugin
+
+app = create_app()
+app.load_plugin(StoragePlugin(provider="s3", bucket="my-bucket"))  # or STORAGE_PROVIDER
+
+app.tools.execute("storage_list", None, prefix="data/")
+app.tools.execute("storage_upload", None, key="data/x.txt", file_path="x.txt")
+app.tools.execute("storage_download", None, key="data/x.txt", output_path="out.txt")
+```
+
+| Provider | Key / config |
+| -------- | ------------ |
+| `s3` | `STORAGE_BUCKET` + AWS creds (lazy boto3) |
+| `azure` | `AZURE_STORAGE_CONNECTION_STRING` + `STORAGE_CONTAINER` (lazy SDK) |
+| `gcs` | `STORAGE_BUCKET` + GCP creds (lazy SDK) |
+| `onedrive` | `ONEDRIVE_ACCESS_TOKEN` (Graph REST) |
+
+## Tools
+
+- `storage_list(prefix="")`
+- `storage_upload(key, file_path)`
+- `storage_download(key, output_path)`
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Fake clients / injectable transports — no cloud, no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — enterprise storage (M9).

xyberos_storage-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xyberos-storage"
+version = "0.1.0"
+description = "Object storage plugin (RFC-0019, M9): S3, Azure Blob, GCS, OneDrive behind one ObjectStore contract"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+dependencies = ["xyberos>=1.0"]
+keywords = ["xyberos", "plugin", "storage", "s3", "azure", "gcs", "onedrive"]
+
+[project.optional-dependencies]
+s3 = ["boto3"]
+azure = ["azure-storage-blob"]
+gcs = ["google-cloud-storage"]
+test = ["pytest"]
+
+[project.entry-points."xyberos.plugins"]
+storage = "xyberos_storage.plugin:plugin"
+
+[tool.setuptools]
+packages = ["xyberos_storage"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

xyberos_storage-0.1.0/setup.cfg

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

xyberos_storage-0.1.0/tests/test_adapters.py

@@ -0,0 +1,137 @@
+"""Tests for the object store adapters (fake clients / transports, no network)."""
+
+from __future__ import annotations
+
+import pytest
+from xyberos.exceptions.provider import ProviderError
+
+from xyberos_storage import AzureBlobStore, GcsStore, OneDriveStore, S3Store
+
+
+class _FakeS3Client:
+    def __init__(self):
+        self.objects: dict[str, bytes] = {}
+
+    def get_paginator(self, _name):
+        return self
+
+    def paginate(self, **kwargs):
+        prefix = kwargs.get("Prefix", "")
+        return [
+            {"Contents": [{"Key": key} for key in self.objects if key.startswith(prefix)]}
+        ]
+
+    def put_object(self, **kwargs):
+        self.objects[kwargs["Key"]] = kwargs["Body"]
+
+    def get_object(self, **kwargs):
+        return {"Body": __import__("io").BytesIO(self.objects[kwargs["Key"]])}
+
+
+def test_s3_roundtrip():
+    client = _FakeS3Client()
+    store = S3Store("bucket", client=client)
+    store.upload("dir/a.txt", b"hello")
+    assert store.list("dir/") == ["dir/a.txt"]
+    assert store.download("dir/a.txt") == b"hello"
+
+
+class _FakeStream:
+    def __init__(self, data):
+        self._data = data
+
+    def readall(self):
+        return self._data
+
+
+class _FakeBlob:
+    def __init__(self, name):
+        self.name = name
+        self.data = b""
+
+    def download_blob(self):
+        return _FakeStream(self.data)
+
+
+class _FakeContainer:
+    def __init__(self):
+        self.blobs: dict[str, _FakeBlob] = {}
+
+    def list_blobs(self, name_starts_with=""):
+        return [b for name, b in self.blobs.items() if name.startswith(name_starts_with)]
+
+    def upload_blob(self, name, data, **kwargs):
+        blob = _FakeBlob(name)
+        blob.data = data
+        self.blobs[name] = blob
+
+    def get_blob_client(self, name):
+        return self.blobs[name]
+
+
+class _FakeAzure:
+    def get_container_client(self, _name):
+        return self._container
+
+
+def test_azure_roundtrip():
+    container = _FakeContainer()
+    service = _FakeAzure()
+    service._container = container
+    store = AzureBlobStore(container="c", client=service)
+    store.upload("a.txt", b"hi")
+    assert store.list() == ["a.txt"]
+    assert store.download("a.txt") == b"hi"
+
+
+def test_gcs_roundtrip():
+    blobs: dict[str, bytes] = {}
+
+    class _FakeBlobGcs:
+        def __init__(self, name):
+            self.name = name
+            self._data = b""
+
+        def upload_from_string(self, data):
+            blobs[self.name] = data
+
+        def download_as_bytes(self):
+            return blobs[self.name]
+
+    class _FakeBucket:
+        def list_blobs(self, prefix=""):
+            return [_FakeBlobGcs(name) for name in blobs if name.startswith(prefix)]
+
+        def blob(self, name):
+            if name not in blobs:
+                blobs[name] = b""
+            return _FakeBlobGcs(name)
+
+    class _FakeGcsClient:
+        def bucket(self, _name):
+            return _FakeBucket()
+
+    store = GcsStore("bucket", client=_FakeGcsClient())
+    store.upload("k.txt", b"data")
+    assert store.list() == ["k.txt"]
+    assert store.download("k.txt") == b"data"
+
+
+def test_onedrive_roundtrip():
+    def request(method, url, **kwargs):
+        if url.endswith(":/children"):
+            return 200, {"value": [{"name": "a.txt"}]}
+        if method == "PUT":
+            return 201, {"name": "a.txt"}
+        return 200, b"content"
+
+    store = OneDriveStore(access_token="tok", request=request)
+    assert store.list() == ["a.txt"]
+    assert store.upload("a.txt", b"data") == "a.txt"
+    assert store.download("a.txt") == b"content"
+
+
+def test_onedrive_requires_token():
+    store = OneDriveStore(access_token=None, request=lambda *a, **k: (200, {}))
+    with pytest.raises(ProviderError, match="ONEDRIVE_ACCESS_TOKEN"):
+        store.list()

xyberos_storage-0.1.0/tests/test_plugin.py

@@ -0,0 +1,52 @@
+"""Tests for loading the storage plugin into a Xyberos app."""
+
+from __future__ import annotations
+
+from xyberos import create_app
+
+from xyberos_storage import StoragePlugin
+
+
+class _FakeS3Client:
+    def __init__(self):
+        self.objects: dict[str, bytes] = {}
+
+    def get_paginator(self, _name):
+        return self
+
+    def paginate(self, **kwargs):
+        prefix = kwargs.get("Prefix", "")
+        return [{"Contents": [{"Key": k} for k in self.objects if k.startswith(prefix)]}]
+
+    def put_object(self, **kwargs):
+        self.objects[kwargs["Key"]] = kwargs["Body"]
+
+    def get_object(self, **kwargs):
+        return {"Body": __import__("io").BytesIO(self.objects[kwargs["Key"]])}
+
+
+def test_plugin_registers_and_executes(tmp_path):
+    from xyberos_storage import S3Store
+
+    client = _FakeS3Client()
+    app = create_app()
+    # Build the plugin but swap in a store with the fake client.
+    plugin = StoragePlugin(provider="s3", bucket="bucket")
+    store = S3Store("bucket", client=client)
+    plugin._provider = "s3"
+    # Replace the plugin's object_store with the fake-backed one for the test.
+    plugin.object_store = lambda: store  # type: ignore[method-assign]
+    app.load_plugin(plugin)
+
+    assert "storage_list" in app.tools.names
+
+    src = tmp_path / "src.txt"
+    src.write_bytes(b"hello")
+    app.tools.execute("storage_upload", None, key="dir/a.txt", file_path=str(src))
+    assert app.tools.execute("storage_list", None, prefix="dir/") == ["dir/a.txt"]
+
+    out = tmp_path / "out.txt"
+    assert app.tools.execute("storage_download", None, key="dir/a.txt", output_path=str(out)) == str(out)
+    assert out.read_bytes() == b"hello"
+
+    app.unload_plugin("storage")

xyberos_storage-0.1.0/xyberos_storage/__init__.py

@@ -0,0 +1,7 @@
+"""Object storage plugin (RFC-0019, M9)."""
+
+from .adapters import AzureBlobStore, GcsStore, OneDriveStore, S3Store
+from .contract import ObjectStore
+from .plugin import StoragePlugin
+
+__all__ = ["AzureBlobStore", "GcsStore", "ObjectStore", "OneDriveStore", "S3Store", "StoragePlugin"]

xyberos_storage-0.1.0/xyberos_storage/adapters.py

@@ -0,0 +1,196 @@
+"""Object store adapters: S3, Azure Blob, GCS, OneDrive.
+
+S3 / Azure / GCS lazy-import their SDK and accept an injectable client for
+tests; OneDrive uses the Microsoft Graph REST API with an injectable transport.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+from typing import Any
+
+from xyberos.exceptions.provider import ProviderError
+
+from .http import RequestTransport, default_request
+
+
+class S3Store:
+    """AWS S3 (lazy ``boto3``)."""
+
+    name = "s3"
+
+    def __init__(
+        self,
+        bucket: str,
+        *,
+        client: Any | None = None,
+        region: str | None = None,
+    ) -> None:
+        self._bucket = bucket
+        self._client = client
+        self._region = region or os.getenv("AWS_REGION") or os.getenv("AWS_DEFAULT_REGION")
+
+    def list(self, prefix: str = "") -> list[str]:
+        client = self._get_client()
+        keys: list[str] = []
+        paginator = client.get_paginator("list_objects_v2")
+        for page in paginator.paginate(Bucket=self._bucket, Prefix=prefix):
+            for obj in page.get("Contents", []):
+                keys.append(obj["Key"])
+        return keys
+
+    def upload(self, key: str, data: bytes) -> str:
+        self._get_client().put_object(Bucket=self._bucket, Key=key, Body=data)
+        return key
+
+    def download(self, key: str) -> bytes:
+        response = self._get_client().get_object(Bucket=self._bucket, Key=key)
+        return response["Body"].read()
+
+    def _get_client(self) -> Any:
+        if self._client is not None:
+            return self._client
+        try:
+            boto3 = importlib.import_module("boto3")
+        except ImportError as exc:
+            raise ProviderError(
+                "the 'boto3' package is required for S3; install with 'pip install xyberos-storage[s3]'"
+            ) from exc
+        kwargs = {"service_name": "s3"}
+        if self._region:
+            kwargs["region_name"] = self._region
+        self._client = boto3.client(**kwargs)
+        return self._client
+
+
+class AzureBlobStore:
+    """Azure Blob Storage (lazy ``azure-storage-blob``)."""
+
+    name = "azure"
+
+    def __init__(self, connection_string: str | None = None, *, container: str, client: Any | None = None) -> None:
+        self._connection_string = connection_string or os.getenv("AZURE_STORAGE_CONNECTION_STRING")
+        self._container = container
+        self._client = client
+
+    def _container_client(self) -> Any:
+        if self._client is not None:
+            return self._client.get_container_client(self._container)
+        try:
+            azure_blob = importlib.import_module("azure.storage.blob")
+        except ImportError as exc:
+            raise ProviderError(
+                "the 'azure-storage-blob' package is required; install with "
+                "'pip install xyberos-storage[azure]'"
+            ) from exc
+        if not self._connection_string:
+            raise ProviderError("Azure Blob requires AZURE_STORAGE_CONNECTION_STRING")
+        return azure_blob.BlobServiceClient.from_connection_string(self._connection_string).get_container_client(self._container)
+
+    def list(self, prefix: str = "") -> list[str]:
+        container = self._container_client()
+        return [blob.name for blob in container.list_blobs(name_starts_with=prefix)]
+
+    def upload(self, key: str, data: bytes) -> str:
+        self._container_client().upload_blob(key, data, overwrite=True)
+        return key
+
+    def download(self, key: str) -> bytes:
+        blob = self._container_client().get_blob_client(key)
+        return blob.download_blob().readall()
+
+
+class GcsStore:
+    """Google Cloud Storage (lazy ``google-cloud-storage``)."""
+
+    name = "gcs"
+
+    def __init__(self, bucket: str, *, client: Any | None = None) -> None:
+        self._bucket = bucket
+        self._client = client
+
+    def _get_bucket(self) -> Any:
+        if self._client is not None:
+            return self._client.bucket(self._bucket)
+        try:
+            storage = importlib.import_module("google.cloud.storage")
+        except ImportError as exc:
+            raise ProviderError(
+                "the 'google-cloud-storage' package is required; install with "
+                "'pip install xyberos-storage[gcs]'"
+            ) from exc
+        return storage.Client().bucket(self._bucket)
+
+    def list(self, prefix: str = "") -> list[str]:
+        return [blob.name for blob in self._get_bucket().list_blobs(prefix=prefix)]
+
+    def upload(self, key: str, data: bytes) -> str:
+        blob = self._get_bucket().blob(key)
+        blob.upload_from_string(data)
+        return key
+
+    def download(self, key: str) -> bytes:
+        blob = self._get_bucket().blob(key)
+        return blob.download_as_bytes()
+
+
+class OneDriveStore:
+    """Microsoft OneDrive via the Graph REST API (injectable transport)."""
+
+    name = "onedrive"
+    base_url = "https://graph.microsoft.com/v1.0"
+
+    def __init__(
+        self,
+        access_token: str | None = None,
+        *,
+        request: RequestTransport | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._access_token = access_token if access_token is not None else os.getenv("ONEDRIVE_ACCESS_TOKEN")
+        self._request = request or default_request
+        self._timeout = timeout
+
+    def list(self, prefix: str = "") -> list[str]:
+        status, body = self._request(
+            "GET",
+            f"{self.base_url}/me/drive/root:{prefix}:/children",
+            headers=self._headers(),
+            timeout=self._timeout,
+        )
+        self._check(status, body)
+        return [item.get("name") for item in body.get("value", [])]
+
+    def upload(self, key: str, data: bytes) -> str:
+        status, body = self._request(
+            "PUT",
+            f"{self.base_url}/me/drive/root:/{key}:/content",
+            raw_body=data,
+            headers=self._headers(),
+            timeout=self._timeout,
+        )
+        self._check(status, body)
+        return key
+
+    def download(self, key: str) -> bytes:
+        status, body = self._request(
+            "GET",
+            f"{self.base_url}/me/drive/root:/{key}:/content",
+            headers=self._headers(),
+            timeout=self._timeout,
+        )
+        self._check(status, body)
+        return body.encode("utf-8") if isinstance(body, str) else body
+
+    def _headers(self) -> dict[str, str]:
+        if not self._access_token:
+            raise ProviderError("OneDrive requires an access token (set ONEDRIVE_ACCESS_TOKEN)")
+        return {"Authorization": f"Bearer {self._access_token}"}
+
+    @staticmethod
+    def _check(status: int, body: Any) -> None:
+        if 200 <= status < 300:
+            return
+        message = body if isinstance(body, str) else str(body)
+        raise ProviderError(f"OneDrive API returned HTTP {status}: {message[:200]}")

xyberos_storage-0.1.0/xyberos_storage/contract.py

@@ -0,0 +1,24 @@
+"""The ObjectStore contract (RFC-0019, M9)."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ObjectStore(Protocol):
+    """Anything that lists, uploads and downloads objects by key."""
+
+    name: str
+
+    def list(self, prefix: str = "") -> list[str]:
+        """Return the object keys under ``prefix``."""
+        ...
+
+    def upload(self, key: str, data: bytes) -> str:
+        """Store ``data`` under ``key``; return the key."""
+        ...
+
+    def download(self, key: str) -> bytes:
+        """Return the bytes stored under ``key``."""
+        ...

xyberos_storage-0.1.0/xyberos_storage/http.py

@@ -0,0 +1,91 @@
+"""A tiny stdlib HTTP helper (no third-party deps).
+
+``default_request`` performs one HTTP request with ``urllib`` and returns
+``(status, body)`` where ``body`` is parsed JSON when the response is JSON,
+otherwise raw text. Injectable so tests run without a network.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable
+
+#: (method, url, *, json_body, raw_body, headers, query, timeout) -> (status, body)
+RequestTransport = Callable[..., tuple[int, Any]]
+RawRequestTransport = Callable[..., tuple[int, bytes]]
+
+
+def default_request(
+    method: str,
+    url: str,
+    *,
+    json_body: Any = None,
+    raw_body: bytes | None = None,
+    headers: dict[str, str] | None = None,
+    query: dict[str, Any] | None = None,
+    timeout: float = 30.0,
+) -> tuple[int, Any]:
+    """Send one request and return ``(status, parsed_json_or_text)``."""
+    request = _build(method, url, json_body=json_body, raw_body=raw_body, headers=headers, query=query)
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            raw = response.read()
+            content_type = response.headers.get("Content-Type", "")
+    except urllib.error.HTTPError as exc:
+        return exc.code, exc.read().decode("utf-8", errors="replace")
+
+    text = raw.decode("utf-8", errors="replace")
+    if "application/json" in content_type or text.lstrip().startswith("{"):
+        try:
+            return 200, json.loads(text)
+        except json.JSONDecodeError:
+            return 200, text
+    return 200, text
+
+
+def default_raw_request(
+    method: str,
+    url: str,
+    *,
+    json_body: Any = None,
+    raw_body: bytes | None = None,
+    headers: dict[str, str] | None = None,
+    query: dict[str, Any] | None = None,
+    timeout: float = 30.0,
+) -> tuple[int, bytes]:
+    """Send one request and return ``(status, raw_bytes)``."""
+    request = _build(method, url, json_body=json_body, raw_body=raw_body, headers=headers, query=query)
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return int(getattr(response, "status", 200)), response.read()
+    except urllib.error.HTTPError as exc:
+        return exc.code, exc.read()
+
+
+def _build(
+    method: str,
+    url: str,
+    *,
+    json_body: Any,
+    raw_body: bytes | None,
+    headers: dict[str, str] | None,
+    query: dict[str, Any] | None,
+) -> urllib.request.Request:
+    final_url = url
+    if query:
+        separator = "&" if "?" in url else "?"
+        final_url = url + separator + urllib.parse.urlencode(query)
+
+    data: bytes | None = None
+    request_headers = dict(headers or {})
+    if raw_body is not None:
+        data = raw_body
+    elif json_body is not None:
+        data = json.dumps(json_body).encode("utf-8")
+        request_headers.setdefault("Content-Type", "application/json")
+    return urllib.request.Request(
+        final_url, data=data, headers=request_headers, method=method
+    )

xyberos_storage-0.1.0/xyberos_storage/plugin.py

@@ -0,0 +1,114 @@
+"""Storage plugin entry point (RFC-0019, M9)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, cast
+
+from xyberos.contracts import Plugin, Tool
+from xyberos.tools import FunctionTool
+
+from .adapters import AzureBlobStore, GcsStore, OneDriveStore, S3Store
+from .contract import ObjectStore
+from .http import RequestTransport
+
+
+def _pop_tool(registry: Any, name: str) -> None:
+    unregister = getattr(registry, "unregister", None)
+    if callable(unregister):
+        unregister(name)
+        return
+    store = getattr(registry, "_tools", None)
+    if isinstance(store, dict):
+        cast(dict[str, Any], store).pop(name, None)
+
+
+class StoragePlugin(Plugin):
+    """Registers object-storage tools backed by a configured provider."""
+
+    def __init__(
+        self,
+        provider: str | None = None,
+        *,
+        env_prefix: str = "STORAGE",
+        bucket: str | None = None,
+        container: str | None = None,
+        access_token: str | None = None,
+        request: RequestTransport | None = None,
+    ) -> None:
+        self._provider = (provider or os.getenv(f"{env_prefix}_PROVIDER") or "s3").lower()
+        self._bucket = bucket
+        self._container = container or os.getenv(f"{env_prefix}_CONTAINER", "default")
+        self._access_token = access_token
+        self._request = request
+
+    @property
+    def name(self) -> str:
+        return "storage"
+
+    def object_store(self) -> ObjectStore:
+        name = self._provider
+        if name == "s3":
+            bucket = self._bucket or os.getenv("STORAGE_BUCKET") or os.getenv("S3_BUCKET")
+            if not bucket:
+                raise ValueError("s3 provider requires a bucket (STORAGE_BUCKET)")
+            return S3Store(bucket)
+        if name == "azure":
+            return AzureBlobStore(container=self._container)
+        if name == "gcs":
+            bucket = self._bucket or os.getenv("STORAGE_BUCKET") or os.getenv("GCS_BUCKET")
+            if not bucket:
+                raise ValueError("gcs provider requires a bucket (STORAGE_BUCKET)")
+            return GcsStore(bucket)
+        if name == "onedrive":
+            return OneDriveStore(self._access_token, request=self._request)
+        raise ValueError(f"unknown storage provider '{name}' (s3 | azure | gcs | onedrive)")
+
+    def tools(self) -> list[Tool]:
+        store = self.object_store()
+
+        def _list(prefix: str = "") -> list[str]:
+            return store.list(prefix)
+
+        def _upload(key: str, file_path: str) -> str:
+            data = Path(file_path).read_bytes()
+            return store.upload(key, data)
+
+        def _download(key: str, output_path: str) -> str:
+            data = store.download(key)
+            path = Path(output_path)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(data)
+            return str(path)
+
+        return [
+            FunctionTool("storage_list", _list, description=f"List objects via {self._provider}."),
+            FunctionTool("storage_upload", _upload, description=f"Upload a file to {self._provider}."),
+            FunctionTool("storage_download", _download, description=f"Download an object from {self._provider}."),
+        ]
+
+    def register(self, kernel: object) -> None:
+        try:
+            tools = self.tools()
+        except ValueError as exc:
+            logger = getattr(kernel, "logger", None)
+            if logger is not None and callable(getattr(logger, "warning", None)):
+                logger.warning("storage plugin not configured: %s", exc)
+            return
+        registry = kernel.resolve("tools")
+        for tool in tools:
+            registry.register(tool)
+
+    def unregister(self, kernel: object) -> None:
+        try:
+            tools = self.tools()
+        except ValueError:
+            return  # never configured -> nothing was registered
+        registry = kernel.resolve("tools")
+        for tool in tools:
+            _pop_tool(registry, tool.name)
+
+
+#: Auto-discovered by ``app.load_entry_points()``.
+plugin = StoragePlugin()

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

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: xyberos-storage
+Version: 0.1.0
+Summary: Object storage plugin (RFC-0019, M9): S3, Azure Blob, GCS, OneDrive behind one ObjectStore contract
+License: Apache-2.0
+Keywords: xyberos,plugin,storage,s3,azure,gcs,onedrive
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+Provides-Extra: s3
+Requires-Dist: boto3; extra == "s3"
+Provides-Extra: azure
+Requires-Dist: azure-storage-blob; extra == "azure"
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage; extra == "gcs"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# xyberos-storage
+
+**Object storage plugin — RFC-0019, M9.** S3, Azure Blob, GCS, and OneDrive
+behind one `ObjectStore` contract (`list` / `upload` / `download`).
+
+## Install
+
+```bash
+pip install -e ./storage
+pip install xyberos-storage[s3]        # optional: boto3
+pip install xyberos-storage[azure]     # optional: azure-storage-blob
+pip install xyberos-storage[gcs]       # optional: google-cloud-storage
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_storage import StoragePlugin
+
+app = create_app()
+app.load_plugin(StoragePlugin(provider="s3", bucket="my-bucket"))  # or STORAGE_PROVIDER
+
+app.tools.execute("storage_list", None, prefix="data/")
+app.tools.execute("storage_upload", None, key="data/x.txt", file_path="x.txt")
+app.tools.execute("storage_download", None, key="data/x.txt", output_path="out.txt")
+```
+
+| Provider | Key / config |
+| -------- | ------------ |
+| `s3` | `STORAGE_BUCKET` + AWS creds (lazy boto3) |
+| `azure` | `AZURE_STORAGE_CONNECTION_STRING` + `STORAGE_CONTAINER` (lazy SDK) |
+| `gcs` | `STORAGE_BUCKET` + GCP creds (lazy SDK) |
+| `onedrive` | `ONEDRIVE_ACCESS_TOKEN` (Graph REST) |
+
+## Tools
+
+- `storage_list(prefix="")`
+- `storage_upload(key, file_path)`
+- `storage_download(key, output_path)`
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Fake clients / injectable transports — no cloud, no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — enterprise storage (M9).

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

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+tests/test_adapters.py
+tests/test_plugin.py
+xyberos_storage/__init__.py
+xyberos_storage/adapters.py
+xyberos_storage/contract.py
+xyberos_storage/http.py
+xyberos_storage/plugin.py
+xyberos_storage.egg-info/PKG-INFO
+xyberos_storage.egg-info/SOURCES.txt
+xyberos_storage.egg-info/dependency_links.txt
+xyberos_storage.egg-info/entry_points.txt
+xyberos_storage.egg-info/requires.txt
+xyberos_storage.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

xyberos_storage-0.1.0/xyberos_storage.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[xyberos.plugins]
+storage = xyberos_storage.plugin:plugin

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

@@ -0,0 +1,13 @@
+xyberos>=1.0
+
+[azure]
+azure-storage-blob
+
+[gcs]
+google-cloud-storage
+
+[s3]
+boto3
+
+[test]
+pytest

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

@@ -0,0 +1 @@
+xyberos_storage