fustor-registry-client 0.1.7__tar.gz

fustor_registry_client-0.1.7/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: fustor-registry-client
+Version: 0.1.7
+Summary: Client for Fustor Registry service
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: fustor-common

fustor_registry_client-0.1.7/README.md

@@ -0,0 +1,41 @@
+# fustor-registry-client
+
+This package provides a Python client for interacting with the Fustor Registry service. It offers a convenient way to programmatically access and manage metadata, storage environments, data stores, users, API keys, and datasets within the Fustor platform.
+
+## Features
+
+*   **Registry Client**: A Python client for making requests to the Fustor Registry API.
+*   **Models**: Provides Pydantic data models for requests, responses, and other data structures used by the Fustor Registry API.
+
+## Installation
+
+This package is part of the Fustor monorepo and is typically installed in editable mode within the monorepo's development environment using `uv sync`.
+
+## Usage
+
+Developers can use this client to integrate with the Fustor Registry service from other Fustor components or external applications. It simplifies the process of interacting with the Registry's RESTful API.
+
+Example (conceptual):
+
+```python
+from fustor_registry_client.client import RegistryClient
+from fustor_registry_client.models import UserCreate, UserUpdate
+
+# Assuming RegistryClient is initialized with the Registry service URL
+client = RegistryClient(base_url="http://localhost:8101")
+
+# Example: Create a new user
+new_user = UserCreate(username="testuser", email="test@example.com", password="securepassword")
+created_user = client.create_user(new_user)
+print(f"Created user: {created_user.username}")
+
+# Example: Get a user by ID
+user = client.get_user(user_id=created_user.id)
+print(f"Retrieved user: {user.email}")
+```
+
+## Dependencies
+
+*   `httpx`: A next-generation HTTP client for Python.
+*   `pydantic`: For defining and validating data models.
+*   `fustor-common`: Provides foundational elements and shared components.

fustor_registry_client-0.1.7/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "fustor-registry-client"
+dynamic = ["version"]
+description = "Client for Fustor Registry service"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = [ "httpx>=0.27.0", "pydantic>=2.11.7", "fustor-common",]
+
+[build-system]
+requires = [ "setuptools>=61.0", "setuptools-scm>=8.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+root = "../.."
+version_scheme = "post-release"
+local_scheme = "dirty-tag"
+
+["project.urls"]
+Homepage = "https://github.com/excelwang/fustor/tree/master/packages/fustor_registry_client"
+"Bug Tracker" = "https://github.com/excelwang/fustor/issues"
+
+[tool.setuptools.packages.find]
+where = [ "src",]

fustor_registry_client-0.1.7/setup.cfg

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

fustor_registry_client-0.1.7/src/fustor_registry_client/client.py

@@ -0,0 +1,95 @@
+import httpx
+import os
+from typing import Optional, Dict, Any, List
+
+from fustor_common.models import TokenResponse, MessageResponse, DatastoreBase, ApiKeyBase
+from fustor_registry_client.models import ClientApiKeyResponse, ClientDatastoreConfigResponse
+
+class RegistryClient:
+    def __init__(self, base_url: str, token: Optional[str] = None, client: Optional[httpx.AsyncClient] = None):
+        self.base_url = base_url
+        self.headers = {}
+        if token:
+            self.headers["Authorization"] = f"Bearer {token}"
+        if client:
+            self.client = client
+            self.client.headers.update(self.headers)
+        else:
+            self.client = httpx.AsyncClient(base_url=self.base_url, headers=self.headers)
+
+    async def _request(self, method: str, path: str, **kwargs) -> Dict[str, Any]:
+        response = await self.client.request(method, path, **kwargs)
+        response.raise_for_status()
+        return response.json()
+
+    async def login(self, email: str, password: str) -> TokenResponse:
+        data = {"username": email, "password": password}
+        response = await self.client.post("/v1/auth/login", data=data)
+        response.raise_for_status()
+        return TokenResponse(**response.json())
+
+    async def list_datastores(self) -> List[DatastoreBase]:
+        response_data = await self._request("GET", "/v1/datastores/")
+        return [DatastoreBase(**data) for data in response_data]
+
+    async def create_datastore(self, name: str, meta: Optional[Dict] = None, visible: bool = False, allow_concurrent_push: bool = False, session_timeout_seconds: int = 30) -> DatastoreBase:
+        payload = {
+            "name": name,
+            "meta": meta,
+            "visible": visible,
+            "allow_concurrent_push": allow_concurrent_push,
+            "session_timeout_seconds": session_timeout_seconds
+        }
+        response_data = await self._request("POST", "/v1/datastores/", json=payload)
+        return DatastoreBase(**response_data)
+
+    async def get_datastore(self, datastore_id: int) -> DatastoreBase:
+        response_data = await self._request("GET", f"/v1/datastores/{datastore_id}")
+        return DatastoreBase(**response_data)
+
+    async def update_datastore(self, datastore_id: int, name: Optional[str] = None, meta: Optional[Dict] = None, visible: Optional[bool] = None, allow_concurrent_push: Optional[bool] = None, session_timeout_seconds: Optional[int] = None) -> DatastoreBase:
+        payload = {}
+        if name is not None: payload["name"] = name
+        if meta is not None: payload["meta"] = meta
+        if visible is not None: payload["visible"] = visible
+        if allow_concurrent_push is not None: payload["allow_concurrent_push"] = allow_concurrent_push
+        if session_timeout_seconds is not None: payload["session_timeout_seconds"] = session_timeout_seconds
+        response_data = await self._request("PUT", f"/v1/datastores/{datastore_id}", json=payload)
+        return DatastoreBase(**response_data)
+
+    async def delete_datastore(self, datastore_id: int) -> MessageResponse:
+        response_data = await self._request("DELETE", f"/v1/datastores/{datastore_id}")
+        return MessageResponse(**response_data)
+
+    async def list_api_keys(self) -> List[ApiKeyBase]:
+        response_data = await self._request("GET", "/v1/keys/")
+        return [ApiKeyBase(**data) for data in response_data]
+
+    async def create_api_key(self, name: str, datastore_id: int) -> ApiKeyBase:
+        payload = {"name": name, "datastore_id": datastore_id}
+        response_data = await self._request("POST", "/v1/keys/", json=payload)
+        return ApiKeyBase(**response_data)
+
+    async def get_api_key(self, key_id: int) -> ApiKeyBase:
+        # The original API doesn't have a GET /v1/keys/{key_id} endpoint.
+        # For now, we'll simulate by listing and filtering, or raise an error.
+        # A better approach would be to add this endpoint to the registry API.
+        raise NotImplementedError("GET /v1/keys/{key_id} is not implemented in the Registry API.")
+
+    async def delete_api_key(self, key_id: int) -> MessageResponse:
+        response_data = await self._request("DELETE", f"/v1/keys/{key_id}")
+        return MessageResponse(**response_data)
+
+    async def get_client_api_keys(self) -> List[ClientApiKeyResponse]:
+        response_data = await self._request("GET", "/client/api-keys")
+        return [ClientApiKeyResponse(**data) for data in response_data]
+
+    async def get_client_datastores_config(self) -> List[ClientDatastoreConfigResponse]:
+        response_data = await self._request("GET", "/client/datastores-config")
+        return [ClientDatastoreConfigResponse(**data) for data in response_data]
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.client.aclose()

fustor_registry_client-0.1.7/src/fustor_registry_client/models.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, ConfigDict
+from typing import List, Optional
+
+class ClientApiKeyResponse(BaseModel):
+    key: str
+    datastore_id: int
+    model_config = ConfigDict(from_attributes=True)
+
+class ClientDatastoreConfigResponse(BaseModel):
+    datastore_id: int
+    allow_concurrent_push: bool
+    session_timeout_seconds: int
+    model_config = ConfigDict(from_attributes=True)

fustor_registry_client-0.1.7/src/fustor_registry_client.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: fustor-registry-client
+Version: 0.1.7
+Summary: Client for Fustor Registry service
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: fustor-common

fustor_registry_client-0.1.7/src/fustor_registry_client.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/fustor_registry_client/__init__.py
+src/fustor_registry_client/client.py
+src/fustor_registry_client/models.py
+src/fustor_registry_client.egg-info/PKG-INFO
+src/fustor_registry_client.egg-info/SOURCES.txt
+src/fustor_registry_client.egg-info/dependency_links.txt
+src/fustor_registry_client.egg-info/requires.txt
+src/fustor_registry_client.egg-info/top_level.txt
+tests/test_client.py
+tests/test_registry_client_models.py

fustor_registry_client-0.1.7/src/fustor_registry_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fustor_registry_client-0.1.7/src/fustor_registry_client.egg-info/requires.txt

@@ -0,0 +1,3 @@
+httpx>=0.27.0
+pydantic>=2.11.7
+fustor-common

fustor_registry_client-0.1.7/src/fustor_registry_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+fustor_registry_client

fustor_registry_client-0.1.7/tests/test_client.py

@@ -0,0 +1,256 @@
+import pytest
+from fastapi import FastAPI, APIRouter, Depends, HTTPException, status
+from fastapi.testclient import TestClient
+from typing import List, Dict, Any, Optional
+from fustor_registry_client.client import RegistryClient
+from fustor_registry_client.models import ClientApiKeyResponse, ClientDatastoreConfigResponse
+from fustor_common.models import TokenResponse, MessageResponse, DatastoreBase, ApiKeyBase, Password, LoginRequest
+
+# --- Mock FastAPI App for Registry Service ---
+mock_app = FastAPI()
+mock_router_v1 = APIRouter(prefix="/v1")
+mock_client_router = APIRouter(prefix="/client")
+
+# Mock data
+MOCK_DATASTORES = {
+    1: {"name": "test_datastore_1", "visible": False, "meta": {}, "allow_concurrent_push": False, "session_timeout_seconds": 30},
+    2: {"name": "test_datastore_2", "visible": True, "meta": {"env": "prod"}, "allow_concurrent_push": True, "session_timeout_seconds": 60},
+}
+MOCK_API_KEYS = {
+    101: {"id": 101, "name": "api_key_1", "key": "key123", "datastore_id": 1},
+    102: {"id": 102, "name": "api_key_2", "key": "key456", "datastore_id": 2},
+}
+MOCK_USERS = {
+    "admin@example.com": {"password": "hashed_password", "token": "mock_jwt_token"},
+}
+
+import copy
+
+_INITIAL_MOCK_DATASTORES = {
+    1: {"name": "test_datastore_1", "visible": False, "meta": {}, "allow_concurrent_push": False, "session_timeout_seconds": 30},
+    2: {"name": "test_datastore_2", "visible": True, "meta": {"env": "prod"}, "allow_concurrent_push": True, "session_timeout_seconds": 60},
+}
+_INITIAL_MOCK_API_KEYS = {
+    101: {"id": 101, "name": "api_key_1", "key": "key123", "datastore_id": 1},
+    102: {"id": 102, "name": "api_key_2", "key": "key456", "datastore_id": 2},
+}
+_INITIAL_MOCK_USERS = {
+    "admin@example.com": {"password": "hashed_password", "token": "mock_jwt_token"},
+}
+
+@pytest.fixture(autouse=True)
+def reset_mock_data():
+    global MOCK_DATASTORES
+    global MOCK_API_KEYS
+    global MOCK_USERS
+
+    MOCK_DATASTORES = copy.deepcopy(_INITIAL_MOCK_DATASTORES)
+    MOCK_API_KEYS = copy.deepcopy(_INITIAL_MOCK_API_KEYS)
+    MOCK_USERS = copy.deepcopy(_INITIAL_MOCK_USERS)
+    yield
+
+# Mock Auth Endpoints
+from fastapi import Form
+@mock_router_v1.post("/auth/login", response_model=TokenResponse)
+async def mock_login(username: str = Form(), password: str = Form()):
+    if username == "admin@example.com" and password == "admin_password": # Simplified mock password check
+        return TokenResponse(access_token=MOCK_USERS[username]["token"], token_type="bearer")
+    raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username or password")
+
+# Mock Datastore Endpoints
+@mock_router_v1.get("/datastores/", response_model=List[DatastoreBase])
+async def mock_list_datastores():
+    return [DatastoreBase(**data) for data in MOCK_DATASTORES.values()]
+
+@mock_router_v1.post("/datastores/", response_model=DatastoreBase)
+async def mock_create_datastore(datastore: DatastoreBase):
+    new_id = max(MOCK_DATASTORES.keys()) + 1 if MOCK_DATASTORES else 1
+    datastore_data = datastore.model_dump()
+    datastore_data["id"] = new_id
+    MOCK_DATASTORES[new_id] = datastore_data
+    return DatastoreBase(**datastore_data)
+
+@mock_router_v1.get("/datastores/{datastore_id}", response_model=DatastoreBase)
+async def mock_get_datastore(datastore_id: int):
+    if datastore_id not in MOCK_DATASTORES:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Datastore not found")
+    return DatastoreBase(**MOCK_DATASTORES[datastore_id])
+
+@mock_router_v1.put("/datastores/{datastore_id}", response_model=DatastoreBase)
+async def mock_update_datastore(datastore_id: int, updated_data: Dict[str, Any]):
+    if datastore_id not in MOCK_DATASTORES:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Datastore not found")
+    MOCK_DATASTORES[datastore_id].update(updated_data)
+    return DatastoreBase(**MOCK_DATASTORES[datastore_id])
+
+@mock_router_v1.delete("/datastores/{datastore_id}", response_model=MessageResponse)
+async def mock_delete_datastore(datastore_id: int):
+    if datastore_id not in MOCK_DATASTORES:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Datastore not found")
+    del MOCK_DATASTORES[datastore_id]
+    return MessageResponse(message="Datastore deleted successfully")
+
+# Mock API Key Endpoints
+@mock_router_v1.get("/keys/", response_model=List[ApiKeyBase])
+async def mock_list_api_keys():
+    return [ApiKeyBase(**data) for data in MOCK_API_KEYS.values()]
+
+@mock_router_v1.post("/keys/", response_model=ApiKeyBase)
+async def mock_create_api_key(api_key: ApiKeyBase):
+    new_id = max(MOCK_API_KEYS.keys()) + 1 if MOCK_API_KEYS else 1
+    api_key_data = api_key.model_dump()
+    api_key_data["id"] = new_id
+    MOCK_API_KEYS[new_id] = api_key_data
+    return ApiKeyBase(**api_key_data)
+
+@mock_router_v1.delete("/keys/{key_id}", response_model=MessageResponse)
+async def mock_delete_api_key(key_id: int):
+    if key_id not in MOCK_API_KEYS:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="API Key not found")
+    del MOCK_API_KEYS[key_id]
+    return MessageResponse(message="API Key deleted successfully")
+
+# Mock Client Endpoints
+@mock_client_router.get("/api-keys", response_model=List[ClientApiKeyResponse])
+async def mock_get_client_api_keys():
+    return [ClientApiKeyResponse(key=data["key"], name=data["name"], datastore_id=data["datastore_id"]) for data in MOCK_API_KEYS.values()]
+
+@mock_client_router.get("/datastores-config", response_model=List[ClientDatastoreConfigResponse])
+async def mock_get_client_datastores_config():
+    configs = []
+    for ds_id, ds_data in MOCK_DATASTORES.items():
+        configs.append(ClientDatastoreConfigResponse(
+            datastore_id=ds_id,
+            allow_concurrent_push=ds_data["allow_concurrent_push"],
+            session_timeout_seconds=ds_data["session_timeout_seconds"]
+        ))
+    return configs
+
+mock_app.include_router(mock_router_v1)
+mock_app.include_router(mock_client_router)
+
+@pytest.fixture
+def test_client():
+    with TestClient(mock_app) as client:
+        yield client
+
+import httpx
+from httpx import Request, Response, AsyncBaseTransport
+
+class _ClientTransport(AsyncBaseTransport):
+    def __init__(self, test_client: TestClient):
+        self._test_client = test_client
+
+    async def handle_async_request(self, request: Request) -> Response:
+        method = request.method
+        url = str(request.url)
+        headers = dict(request.headers)
+        content = request.content
+
+        response = self._test_client.request(
+            method,
+            url,
+            headers=headers,
+            content=content,
+        )
+        return httpx.Response(
+            status_code=response.status_code,
+            headers=response.headers,
+            content=response.content,
+            request=request,
+        )
+
+@pytest.fixture
+def registry_client(test_client: TestClient):
+    transport = _ClientTransport(test_client)
+    async_client = httpx.AsyncClient(transport=transport, base_url="http://mock-registry")
+    return RegistryClient(base_url="http://mock-registry", client=async_client)
+
+@pytest.mark.asyncio
+async def test_login(registry_client):
+    token_response = await registry_client.login(email="admin@example.com", password="admin_password")
+    assert isinstance(token_response, TokenResponse)
+    assert token_response.access_token is not None
+    assert token_response.token_type == "bearer"
+
+    with pytest.raises(httpx.HTTPStatusError) as exc_info:
+        await registry_client.login(email="admin@example.com", password="wrong_password")
+    assert exc_info.value.response.status_code == status.HTTP_401_UNAUTHORIZED
+
+@pytest.mark.asyncio
+async def test_list_datastores(registry_client: RegistryClient):
+    datastores = await registry_client.list_datastores()
+    assert len(datastores) == len(MOCK_DATASTORES)
+    assert all(isinstance(ds, DatastoreBase) for ds in datastores)
+
+@pytest.mark.asyncio
+async def test_create_datastore(registry_client: RegistryClient):
+    new_datastore = await registry_client.create_datastore(name="new_ds", visible=True)
+    assert isinstance(new_datastore, DatastoreBase)
+    assert new_datastore.name == "new_ds"
+    assert new_datastore.visible == True
+    # Check if it's added to mock data (TestClient doesn't persist state across requests by default,
+    # but our mock app uses global MOCK_DATASTORES, so it will)
+    assert new_datastore.id in MOCK_DATASTORES
+
+@pytest.mark.asyncio
+async def test_get_datastore(registry_client: RegistryClient):
+    datastore = await registry_client.get_datastore(datastore_id=1)
+    assert isinstance(datastore, DatastoreBase)
+    assert datastore.name == "test_datastore_1"
+
+    with pytest.raises(httpx.HTTPStatusError) as exc_info:
+        await registry_client.get_datastore(datastore_id=999)
+    assert exc_info.value.response.status_code == status.HTTP_404_NOT_FOUND
+
+@pytest.mark.asyncio
+async def test_update_datastore(registry_client: RegistryClient):
+    updated_ds = await registry_client.update_datastore(datastore_id=1, name="updated_name", session_timeout_seconds=100)
+    assert isinstance(updated_ds, DatastoreBase)
+    assert updated_ds.name == "updated_name"
+    assert updated_ds.session_timeout_seconds == 100
+    assert MOCK_DATASTORES[1]["name"] == "updated_name"
+
+@pytest.mark.asyncio
+async def test_delete_datastore(registry_client: RegistryClient):
+    initial_count = len(MOCK_DATASTORES)
+    response = await registry_client.delete_datastore(datastore_id=1)
+    assert isinstance(response, MessageResponse)
+    assert response.message == "Datastore deleted successfully"
+    assert len(MOCK_DATASTORES) == initial_count - 1
+    assert 1 not in MOCK_DATASTORES
+
+@pytest.mark.asyncio
+async def test_list_api_keys(registry_client: RegistryClient):
+    api_keys = await registry_client.list_api_keys()
+    assert len(api_keys) == len(MOCK_API_KEYS)
+    assert all(isinstance(ak, ApiKeyBase) for ak in api_keys)
+
+@pytest.mark.asyncio
+async def test_create_api_key(registry_client: RegistryClient):
+    new_api_key = await registry_client.create_api_key(name="new_api_key", datastore_id=1)
+    assert isinstance(new_api_key, ApiKeyBase)
+    assert new_api_key.name == "new_api_key"
+    assert new_api_key.datastore_id == 1
+    assert new_api_key.id in MOCK_API_KEYS
+
+@pytest.mark.asyncio
+async def test_delete_api_key(registry_client: RegistryClient):
+    initial_count = len(MOCK_API_KEYS)
+    response = await registry_client.delete_api_key(key_id=101)
+    assert isinstance(response, MessageResponse)
+    assert response.message == "API Key deleted successfully"
+    assert len(MOCK_API_KEYS) == initial_count - 1
+    assert 101 not in MOCK_API_KEYS
+
+@pytest.mark.asyncio
+async def test_get_client_api_keys(registry_client: RegistryClient):
+    client_keys = await registry_client.get_client_api_keys()
+    assert len(client_keys) == len(MOCK_API_KEYS)
+    assert all(isinstance(ik, ClientApiKeyResponse) for ik in client_keys)
+
+@pytest.mark.asyncio
+async def test_get_client_datastores_config(registry_client: RegistryClient):
+    client_configs = await registry_client.get_client_datastores_config()
+    assert len(client_configs) == len(MOCK_DATASTORES)
+    assert all(isinstance(ic, ClientDatastoreConfigResponse) for ic in client_configs)

fustor_registry_client-0.1.7/tests/test_registry_client_models.py

@@ -0,0 +1,14 @@
+import pytest
+from pydantic import ValidationError
+from fustor_registry_client.models import ClientApiKeyResponse, ClientDatastoreConfigResponse
+
+def test_client_api_key_response():
+    response = ClientApiKeyResponse(key="test_key", datastore_id=1)
+    assert response.key == "test_key"
+    assert response.datastore_id == 1
+
+def test_client_datastore_config_response():
+    response = ClientDatastoreConfigResponse(datastore_id=1, allow_concurrent_push=True, session_timeout_seconds=60)
+    assert response.datastore_id == 1
+    assert response.allow_concurrent_push == True
+    assert response.session_timeout_seconds == 60