TEMdb-client 1.0.0__tar.gz

temdb_client-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: TEMdb_client
+Version: 1.0.0
+Author-email: Derrick Brittain <derrickb@alleninstitute.org>
+Requires-Dist: httpx
+Requires-Dist: tenacity
+Requires-Dist: pydantic
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

temdb_client-1.0.0/README.md

@@ -0,0 +1,2 @@
+# TEMdb_client
+A REST client to interface with TEMdb

temdb_client-1.0.0/TEMdb_client.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: TEMdb_client
+Version: 1.0.0
+Author-email: Derrick Brittain <derrickb@alleninstitute.org>
+Requires-Dist: httpx
+Requires-Dist: tenacity
+Requires-Dist: pydantic
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

temdb_client-1.0.0/TEMdb_client.egg-info/SOURCES.txt

@@ -0,0 +1,47 @@
+README.md
+pyproject.toml
+TEMdb_client.egg-info/PKG-INFO
+TEMdb_client.egg-info/SOURCES.txt
+TEMdb_client.egg-info/dependency_links.txt
+TEMdb_client.egg-info/requires.txt
+TEMdb_client.egg-info/top_level.txt
+temdb_client/__init__.py
+temdb_client/client.py
+temdb_client/exceptions.py
+temdb_client/models/__init__.py
+temdb_client/models/acquisition.py
+temdb_client/models/block.py
+temdb_client/models/cutting_session.py
+temdb_client/models/enum_schemas.py
+temdb_client/models/roi.py
+temdb_client/models/section.py
+temdb_client/models/specimen.py
+temdb_client/models/substrate.py
+temdb_client/models/task.py
+temdb_client/models/tile.py
+temdb_client/resources/__init__.py
+temdb_client/resources/acquisition.py
+temdb_client/resources/base.py
+temdb_client/resources/block.py
+temdb_client/resources/cutting_session.py
+temdb_client/resources/roi.py
+temdb_client/resources/section.py
+temdb_client/resources/specimen.py
+temdb_client/resources/substrate.py
+temdb_client/resources/task.py
+temdb_client/resources/sync_wrappers/__init__.py
+temdb_client/resources/sync_wrappers/acquisition.py
+temdb_client/resources/sync_wrappers/block.py
+temdb_client/resources/sync_wrappers/cutting_session.py
+temdb_client/resources/sync_wrappers/roi.py
+temdb_client/resources/sync_wrappers/section.py
+temdb_client/resources/sync_wrappers/specimen.py
+temdb_client/resources/sync_wrappers/substrate.py
+temdb_client/resources/sync_wrappers/task.py
+tests/test_acquisition.py
+tests/test_block.py
+tests/test_client.py
+tests/test_cutting_session.py
+tests/test_imaging_session.py
+tests/test_roi.py
+tests/test_specimen.py

temdb_client-1.0.0/TEMdb_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

temdb_client-1.0.0/TEMdb_client.egg-info/requires.txt

@@ -0,0 +1,7 @@
+httpx
+tenacity
+pydantic
+
+[test]
+pytest
+pytest-asyncio

temdb_client-1.0.0/TEMdb_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+temdb_client

temdb_client-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "TEMdb_client"
+version = "1.0.0"
+authors = [
+    { name="Derrick Brittain", email="derrickb@alleninstitute.org" }
+]
+dependencies = [
+    "httpx",
+    "tenacity",
+    "pydantic",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-asyncio"
+]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

temdb_client-1.0.0/setup.cfg

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

temdb_client-1.0.0/temdb_client/__init__.py

@@ -0,0 +1,11 @@
+from .client import create_client, AsyncTEMdbClient, SyncTEMdbClient
+from .exceptions import TEMdbClientError, NotFoundError
+
+__all__ = [
+    "create_client",
+    "SyncTEMdbClient",
+    "AsyncTEMdbClient",
+    "TEMdbClientError",
+    "NotFoundError",
+]
+__version__ = "0.1.0"

temdb_client-1.0.0/temdb_client/client.py

@@ -0,0 +1,347 @@
+import httpx
+import logging
+import asyncio
+from typing import Dict, Any, Optional, Union, List, cast
+
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception_type,
+)
+
+from .resources.specimen import SpecimenResource
+from .resources.block import BlockResource
+from .resources.cutting_session import CuttingSessionResource
+from .resources.substrate import SubstrateResource
+from .resources.task import AcquisitionTaskResource
+from .resources.roi import ROIResource
+from .resources.acquisition import AcquisitionResource
+from .resources.section import SectionResource
+
+from .resources.sync_wrappers import (
+    SyncAcquisitionResourceWrapper,
+    SyncSpecimenResourceWrapper,
+    SyncBlockResourceWrapper,
+    SyncCuttingSessionResourceWrapper,
+    SyncSubstrateResourceWrapper,
+    SyncAcquisitionTaskResourceWrapper,
+    SyncROIResourceWrapper,
+    SyncSectionResourceWrapper,
+)
+
+from .exceptions import TEMdbClientError, NotFoundError
+
+
+class AsyncTEMdbClient:
+    """Asynchronous client for interacting with the TEMdb API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_version: str = "v2",
+        api_key: Optional[str] = None,
+        timeout: float = 30.0,
+        debug: bool = False,
+    ):
+        """Initialize the async client."""
+        self.raw_base_url = base_url
+        self.api_version = api_version
+        self.api_url = f"{base_url}/api/{api_version}"
+        self.api_key = api_key
+        self.timeout = timeout
+
+        self.logger = logging.getLogger("temdb_client.async")
+        level = logging.DEBUG if debug else logging.INFO
+        self.logger.setLevel(level)
+
+        headers = {}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        self._http_client = httpx.AsyncClient(
+            base_url=self.api_url,
+            headers=headers,
+            timeout=timeout,
+        )
+
+        self.logger.info(
+            f"Async TEMdb client initialized: {base_url} (API v{api_version})"
+        )
+
+        self._specimen = SpecimenResource(self._async_request, self.api_url)
+        self._block = BlockResource(self._async_request, self.api_url)
+        self._cutting_session = CuttingSessionResource(
+            self._async_request, self.api_url
+        )
+        self._substrate = SubstrateResource(self._async_request, self.api_url)
+        self._acquisition_task = AcquisitionTaskResource(
+            self._async_request, self.api_url
+        )
+        self._roi = ROIResource(self._async_request, self.api_url)
+        self._acquisition = AcquisitionResource(self._async_request, self.api_url)
+        self._section = SectionResource(self._async_request, self.api_url)
+
+    @property
+    def specimen(self) -> SpecimenResource:
+        """Access specimen-related async operations."""
+        return self._specimen
+
+    @property
+    def block(self) -> BlockResource:
+        """Access block-related async operations."""
+        return self._block
+
+    @property
+    def cutting_session(self) -> CuttingSessionResource:
+        """Access cutting session-related async operations."""
+        return self._cutting_session
+
+    @property
+    def substrate(self) -> SubstrateResource:
+        """Access substrate-related async operations."""
+        return self._substrate
+
+    @property
+    def acquisition_task(self) -> AcquisitionTaskResource:  # Renamed property
+        """Access acquisition task-related async operations."""
+        return self._acquisition_task
+
+    @property
+    def roi(self) -> ROIResource:
+        """Access ROI-related async operations."""
+        return self._roi
+
+    @property
+    def acquisition(self) -> AcquisitionResource:
+        """Access acquisition-related async operations."""
+        return self._acquisition
+
+    @property
+    def section(self) -> SectionResource:
+        """Access section-related async operations."""
+        return self._section
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=4, max=10),
+        retry=retry_if_exception_type(httpx.RequestError),
+    )
+    async def _async_request(
+        self, method: str, endpoint: str, **kwargs
+    ) -> Union[Dict[str, Any], List[Any]]:
+        """Make an async HTTP request to the API."""
+        self.logger.debug(f"Async Request: {method} {endpoint}")
+        try:
+            response = await self._http_client.request(method, endpoint, **kwargs)
+            response.raise_for_status()
+            if response.status_code == 204:
+                return {}
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            self.logger.error(
+                f"HTTP error: {e.response.status_code} - {e.response.text}"
+            )
+            if e.response.status_code == 404:
+                raise NotFoundError(f"Resource not found: {endpoint}") from e
+            raise TEMdbClientError(
+                f"HTTP {e.response.status_code}: {e.response.text}"
+            ) from e
+        except httpx.RequestError as e:
+            self.logger.error(f"Request failed: {str(e)}")
+            raise TEMdbClientError(f"Request failed: {str(e)}") from e
+        except Exception as e:
+            self.logger.exception(
+                f"An unexpected error occurred during request to {endpoint}"
+            )
+            raise TEMdbClientError(f"Unexpected error: {str(e)}") from e
+
+    async def health_check(self) -> Dict[str, Any]:
+        """Check if the API is available."""
+        try:
+            result = await self._async_request("GET", "/health")
+            self.logger.info(f"Async Health check: {result.get('status', 'unknown')}")
+            return cast(Dict[str, Any], result)
+        except Exception as e:
+            self.logger.error(f"Async Health check failed: {str(e)}")
+            raise
+
+    async def get_api_info(self) -> Dict[str, Any]:
+        """Get API information."""
+        result = await self._async_request("GET", "/")
+        return cast(Dict[str, Any], result)
+
+    async def close(self) -> None:
+        """Close the async client and release resources."""
+        self.logger.info("Closing async TEMdb client")
+        await self._http_client.aclose()
+
+    async def __aenter__(self) -> "AsyncTEMdbClient":
+        """Allow using client as async context manager."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Close client when exiting async context manager."""
+        await self.close()
+
+
+class SyncTEMdbClient:
+    """Synchronous client for interacting with the TEMdb API (wraps AsyncTEMdbClient)."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_version: str = "v2",
+        api_key: Optional[str] = None,
+        timeout: float = 30.0,
+        debug: bool = False,
+    ):
+        """Initialize the sync client."""
+        self._async_client = AsyncTEMdbClient(
+            base_url, api_version, api_key, timeout, debug
+        )
+        self.logger = logging.getLogger("temdb_client.sync")
+        level = logging.DEBUG if debug else logging.INFO
+        self.logger.setLevel(level)
+        self.logger.info(
+            f"Sync TEMdb client initialized (wrapping async): {base_url} (API v{api_version})"
+        )
+
+        self._acquisition = SyncAcquisitionResourceWrapper(
+            self._async_client.acquisition
+        )
+        self._specimen = SyncSpecimenResourceWrapper(self._async_client.specimen)
+        self._block = SyncBlockResourceWrapper(self._async_client.block)
+        self._cutting_session = SyncCuttingSessionResourceWrapper(
+            self._async_client.cutting_session
+        )
+        self._substrate = SyncSubstrateResourceWrapper(self._async_client.substrate)
+        self._acquisition_task = SyncAcquisitionTaskResourceWrapper(
+            self._async_client.acquisition_task
+        )
+        self._roi = SyncROIResourceWrapper(self._async_client.roi)
+        self._section = SyncSectionResourceWrapper(self._async_client.section)
+
+    @property
+    def acquisition(self) -> SyncAcquisitionResourceWrapper:
+        """Access acquisition-related sync operations."""
+        return self._acquisition
+
+    @property
+    def specimen(self) -> SyncSpecimenResourceWrapper:
+        """Access specimen-related sync operations."""
+        return self._specimen
+
+    @property
+    def block(self) -> SyncBlockResourceWrapper:
+        """Access block-related sync operations."""
+        return self._block
+
+    @property
+    def cutting_session(self) -> SyncCuttingSessionResourceWrapper:
+        """Access cutting session-related sync operations."""
+        return self._cutting_session
+
+    @property
+    def substrate(self) -> SyncSubstrateResourceWrapper:
+        """Access substrate-related sync operations."""
+        return self._substrate
+
+    @property
+    def acquisition_task(self) -> SyncAcquisitionTaskResourceWrapper:
+        """Access acquisition task-related sync operations."""
+        return self._acquisition_task
+
+    @property
+    def roi(self) -> SyncROIResourceWrapper:
+        """Access ROI-related sync operations."""
+        return self._roi
+
+    @property
+    def section(self) -> SyncSectionResourceWrapper:
+        """Access section-related sync operations."""
+        return self._section
+
+    def health_check(self) -> Dict[str, Any]:
+        """Check if the API is available."""
+        self.logger.info("Running sync health check...")
+        try:
+            return asyncio.run(self._async_client.health_check())
+        except Exception as e:
+            self.logger.error(f"Sync Health check failed: {str(e)}")
+            raise
+
+    def get_api_info(self) -> Dict[str, Any]:
+        """Get API information."""
+        self.logger.info("Getting sync API info...")
+        return asyncio.run(self._async_client.get_api_info())
+
+    def close(self) -> None:
+        """Close the client and release resources."""
+        self.logger.info("Closing sync TEMdb client (and underlying async client)")
+        asyncio.run(self._async_client.close())
+
+    def __enter__(self) -> "SyncTEMdbClient":
+        """Allow using client as sync context manager."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Close client when exiting sync context manager."""
+        self.close()
+
+
+def create_client(
+    base_url: str,
+    api_version: str = "v2",
+    api_key: Optional[str] = None,
+    timeout: float = 30.0,
+    debug: bool = False,
+    async_mode: bool = True,
+) -> Union[AsyncTEMdbClient, SyncTEMdbClient]:
+    """
+    Factory function to create either an async or sync TEMdb client.
+
+    Args:
+        base_url: Base URL of the TEMdb API (e.g., "http://localhost:8000").
+        api_version: API version string (default: "v2").
+        api_key: Optional API key for authentication.
+        timeout: Request timeout in seconds.
+        debug: Enable debug logging for the client.
+        async_mode: If True (default), returns AsyncTEMdbClient. If False, returns SyncTEMdbClient.
+
+    Returns:
+        An instance of AsyncTEMdbClient or SyncTEMdbClient.
+    """
+    if async_mode:
+        return AsyncTEMdbClient(base_url, api_version, api_key, timeout, debug)
+    else:
+        return SyncTEMdbClient(base_url, api_version, api_key, timeout, debug)
+
+
+if __name__ == "__main__":
+    # Example usage
+    client = create_client("http://localhost:8000", async_mode=False)
+    try:
+        info = client.get_api_info()
+        print("API Info:", info)
+    finally:
+        client.close()
+
+    # with context manager
+    with create_client("http://localhost:8000", async_mode=False) as client:
+        try:
+            info = client.get_api_info()
+            print("API Info:", info)
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Example usage of async client
+    async def main():
+        async with create_client("http://localhost:8000", async_mode=True) as client:
+            try:
+                info = await client.get_api_info()
+                print("API Info:", info)
+            except Exception as e:
+                print(f"Error: {e}")
+
+    asyncio.run(main())

temdb_client-1.0.0/temdb_client/exceptions.py

@@ -0,0 +1,5 @@
+class TEMdbClientError(Exception):
+    pass
+
+class NotFoundError(TEMdbClientError):
+    pass

temdb_client-1.0.0/temdb_client/models/acquisition.py

@@ -0,0 +1,122 @@
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+from .enum_schemas import AcquisitionStatus
+
+
+class StorageLocation(BaseModel):
+    location_type: str
+    base_path: str
+    is_current: bool
+    date_added: datetime
+    metadata: Dict[str, Any]
+
+    class Config:
+        extra = "allow"
+
+
+class StorageLocationCreate(BaseModel):
+    location_type: str
+    base_path: str
+    metadata: Dict[str, Any]
+
+    class Config:
+        extra = "allow"
+
+
+class LensCorrectionModel(BaseModel):
+    id: int
+    type: str
+    class_name: str
+    data_string: str
+
+    class Config:
+        extra = "allow"
+
+
+class Calibration(BaseModel):
+    pixel_size: float
+    rotation_angle: float
+    lens_model: Optional[LensCorrectionModel] = None
+    aperture_centroid: Optional[List[float]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class HardwareParams(BaseModel):
+    scope_id: str
+    camera_model: str
+    camera_serial: str
+    camera_bit_depth: int
+    media_type: str
+
+    class Config:
+        extra = "allow"
+
+
+class AcquisitionParams(BaseModel):
+    magnification: int
+    spot_size: int
+    exposure_time: int
+    tile_size: List[int]
+    tile_overlap: float
+    saved_bit_depth: int
+
+    class Config:
+        extra = "allow"
+
+
+class AcquisitionBase(BaseModel):
+    hardware_settings: Optional[HardwareParams] = None
+    acquisition_settings: Optional[AcquisitionParams] = None
+    calibration_info: Optional[Calibration] = None
+    status: Optional[AcquisitionStatus] = None
+    tilt_angle: Optional[float] = None
+    lens_correction: Optional[bool] = None
+    end_time: Optional[datetime] = None
+    storage_locations: Optional[List[StorageLocation]] = None
+    montage_set_name: Optional[str] = None
+    sub_region: Optional[Dict[str, int]] = None
+    replaces_acquisition_id: Optional[int] = None
+    montage_id: Optional[str] = None
+    acquisition_id: Optional[str] = None
+    roi_id: Optional[int] = None
+    acquisition_task_id: Optional[str] = None
+    specimen_id: Optional[str] = None
+
+    class Config:
+        extra = "allow"
+
+
+class AcquisitionCreate(AcquisitionBase):
+    montage_id: str = Field(...)
+    acquisition_id: str = Field(...)
+    roi_id: int = Field(...)
+    acquisition_task_id: str = Field(...)
+    hardware_settings: HardwareParams = Field(...)
+    acquisition_settings: AcquisitionParams = Field(...)
+    tilt_angle: float = Field(...)
+    lens_correction: bool = Field(...)
+
+    status: AcquisitionStatus = AcquisitionStatus.IMAGING
+
+
+class AcquisitionUpdate(AcquisitionBase):
+    calibration_info: Optional[Dict[str, Any]] = None
+
+
+class AcquisitionResponse(AcquisitionBase):
+    acquisition_id: str = Field(...)
+    montage_id: str = Field(...)
+    specimen_id: str = Field(...)
+    roi_id: int = Field(...)
+    acquisition_task_id: str = Field(...)
+    hardware_settings: HardwareParams
+    acquisition_settings: AcquisitionParams
+    status: AcquisitionStatus
+    start_time: datetime
+
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None

temdb_client-1.0.0/temdb_client/models/block.py

@@ -0,0 +1,40 @@
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+
+class BlockBase(BaseModel):
+    microCT_info: Optional[Dict[str, Any]] = Field(
+        None, description="MicroCT information of block"
+    )
+
+    class Config:
+        extra = "allow"
+
+
+class BlockCreate(BlockBase):
+    block_id: str = Field(
+        ..., description="Unique human-readable identifier for the block"
+    )
+    specimen_id: str = Field(
+        ..., description="Human-readable identifier of the parent specimen"
+    )
+    microCT_info: Dict[str, Any] = Field(
+        ..., description="MicroCT information of block"
+    )
+
+
+class BlockUpdate(BlockBase):
+    pass
+
+
+class BlockResponse(BlockBase):
+
+    block_id: str = Field(
+        ..., description="Unique human-readable identifier for the block"
+    )
+    specimen_id: str = Field(
+        ..., description="Human-readable identifier of the parent specimen"
+    )
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None

temdb_client-1.0.0/temdb_client/models/cutting_session.py

@@ -0,0 +1,45 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+
+class CuttingSessionBase(BaseModel):
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    operator: Optional[str] = None
+    sectioning_device: Optional[str] = None
+    media_type: Optional[str] = None
+    knife_id: Optional[str] = None
+    block_id: Optional[str] = None
+    specimen_id: Optional[str] = None
+
+    class Config:
+        extra = "allow"
+
+
+class CuttingSessionCreate(CuttingSessionBase):
+    cutting_session_id: str = Field(..., description="ID of cutting session")
+    start_time: datetime = Field(..., description="Time when cutting session started")
+    sectioning_device: str = Field(..., description="Device used for sectioning")
+    media_type: str = Field(
+        ..., description="Type of substrate the sections are placed upon"
+    )
+    block_id: str = Field(
+        ..., description="ID of block cutting session is associated with"
+    )
+
+
+class CuttingSessionUpdate(CuttingSessionBase):
+    pass
+
+
+class CuttingSessionResponse(CuttingSessionBase):
+    cutting_session_id: str = Field(..., description="Unique ID of cutting session")
+    specimen_id: str = Field(..., description="Human-readable ID of specimen")
+    block_id: str = Field(..., description="Human-readable ID of block")
+    start_time: datetime
+    sectioning_device: str
+    media_type: str
+
+    created_at: datetime
+    updated_at: Optional[datetime] = None