datamint 2.3.2__py3-none-any.whl → 2.3.3__py3-none-any.whl

datamint/api/base_api.py

@@ -1,27 +1,28 @@
 import logging
-from typing import Any, Generator, AsyncGenerator, Sequence
+from typing import Any, Generator, AsyncGenerator, Sequence, TYPE_CHECKING
 import httpx
 from dataclasses import dataclass
 from datamint.exceptions import DatamintException, ResourceNotFoundError
+from datamint.types import ImagingData
 import aiohttp
 import json
-import pydicom.dataset
 from PIL import Image
 import cv2
 import nibabel as nib
-from nibabel.filebasedimages import FileBasedImage as nib_FileBasedImage
 from io import BytesIO
 import gzip
 import contextlib
 import asyncio
-from medimgkit.format_detection import GZIP_MIME_TYPES
+from medimgkit.format_detection import GZIP_MIME_TYPES, DEFAULT_MIME_TYPE, guess_typez, guess_extension
+
+if TYPE_CHECKING:
+    from datamint.api.client import Api
 
 logger = logging.getLogger(__name__)
 
 # Generic type for entities
 _PAGE_LIMIT = 5000
 
-
 @dataclass
 class ApiConfig:
     """Configuration for API client.
@@ -37,6 +38,15 @@ class ApiConfig:
     timeout: float = 30.0
     max_retries: int = 3
 
+    @property
+    def web_app_url(self) -> str:
+        """Get the base URL for the web application."""
+        if self.server_url.startswith('http://localhost:3001'):
+            return 'http://localhost:3000'
+        if self.server_url.startswith('https://stagingapi.datamint.io'):
+            return 'https://staging.datamint.io'
+        return 'https://app.datamint.io'
+
 
 class BaseApi:
     """Base class for all API endpoint handlers."""
@@ -53,6 +63,7 @@ class BaseApi:
         self.config = config
         self.client = client or self._create_client()
         self.semaphore = asyncio.Semaphore(20)
+        self._api_instance: 'Api | None' = None  # Injected by Api class
 
     def _create_client(self) -> httpx.Client:
         """Create and configure HTTP client with authentication and timeouts."""
@@ -399,10 +410,30 @@ class BaseApi:
 
     @staticmethod
     def convert_format(bytes_array: bytes,
-                       mimetype: str,
+                       mimetype: str | None = None,
                        file_path: str | None = None
-                       ) -> pydicom.dataset.Dataset | Image.Image | cv2.VideoCapture | bytes | nib_FileBasedImage:
-        """ Convert the bytes array to the appropriate format based on the mimetype."""
+                       ) -> ImagingData | bytes:
+        """ Convert the bytes array to the appropriate format based on the mimetype.
+
+        Args:
+            bytes_array: Raw file content bytes
+            mimetype: Optional MIME type of the content
+            file_path: deprecated
+
+        Returns:
+            Converted content in appropriate format (pydicom.Dataset, PIL Image, cv2.VideoCapture, ...)
+
+        Example:
+            >>> fpath = 'path/to/file.dcm'
+            >>> with open(fpath, 'rb') as f:
+            ...     dicom_bytes = f.read()
+            >>> dicom = BaseApi.convert_format(dicom_bytes)
+
+        """
+        if mimetype is None:
+            mimetype, ext = BaseApi._determine_mimetype(bytes_array)
+            if mimetype is None:
+                raise ValueError("Could not determine mimetype from content.")
         content_io = BytesIO(bytes_array)
         if mimetype.endswith('/dicom'):
             return pydicom.dcmread(content_io)
@@ -429,3 +460,30 @@ class BaseApi:
                 return nib.Nifti1Image.from_stream(f)
 
         raise ValueError(f"Unsupported mimetype: {mimetype}")
+
+    @staticmethod
+    def _determine_mimetype(content: bytes,
+                            declared_mimetype: str | None = None) -> tuple[str | None, str | None]:
+        """Infer MIME type and file extension from content and optional declared type.
+
+        Args:
+            content: Raw file content bytes
+            declared_mimetype: Optional MIME type declared by the source
+
+        Returns:
+            Tuple of (inferred_mimetype, file_extension)
+        """
+        # Determine mimetype from file content
+        mimetype_list, ext = guess_typez(content, use_magic=True)
+        mimetype = mimetype_list[-1]
+
+        # get mimetype from resource info if not detected
+        if declared_mimetype is not None:
+            if mimetype is None:
+                mimetype = declared_mimetype
+                ext = guess_extension(mimetype)
+            elif mimetype == DEFAULT_MIME_TYPE:
+                mimetype = declared_mimetype
+                ext = guess_extension(mimetype)
+
+        return mimetype, ext

datamint/api/client.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from .base_api import ApiConfig
+from .base_api import ApiConfig, BaseApi
 from .endpoints import (ProjectsApi, ResourcesApi, AnnotationsApi,
                         ChannelsApi, UsersApi, DatasetsInfoApi, ModelsApi,
                         AnnotationSetsApi
@@ -13,7 +13,7 @@ class Api:
     DEFAULT_SERVER_URL = 'https://api.datamint.io'
     DATAMINT_API_VENV_NAME = datamint.configs.ENV_VARS[datamint.configs.APIKEY_KEY]
 
-    _API_MAP = {
+    _API_MAP : dict[str, type[BaseApi]] = {
         'projects': ProjectsApi,
         'resources': ResourcesApi,
         'annotations': AnnotationsApi,
@@ -70,7 +70,10 @@ class Api:
     def _get_endpoint(self, name: str):
         if name not in self._endpoints:
             api_class = self._API_MAP[name]
-            self._endpoints[name] = api_class(self.config, self._client)
+            endpoint = api_class(self.config, self._client)
+            # Inject this API instance into the endpoint so it can inject into entities
+            endpoint._api_instance = self
+            self._endpoints[name] = endpoint
         return self._endpoints[name]
 
     @property

datamint/api/dto/__init__.py

@@ -1,5 +1,9 @@
 from datamint.apihandler.dto import annotation_dto
-from datamint.apihandler.dto.annotation_dto import AnnotationType, CreateAnnotationDto, Geometry, BoxGeometry
+from datamint.apihandler.dto.annotation_dto import (
+    AnnotationType, CreateAnnotationDto,
+    Geometry, BoxGeometry, LineGeometry,
+    CoordinateSystem
+)
 
 __all__ = [
     "annotation_dto",
@@ -7,4 +11,8 @@ __all__ = [
     "CreateAnnotationDto",
     "Geometry",
     "BoxGeometry",
-]
+    "LineGeometry",
+    "CoordinateSystem"
+    "LineGeometry",
+    "CoordinateSystem"
+]

datamint/api/endpoints/annotations_api.py

@@ -7,7 +7,7 @@ from .models_api import ModelsApi
 from datamint.entities.annotation import Annotation
 from datamint.entities.resource import Resource
 from datamint.entities.project import Project
-from datamint.apihandler.dto.annotation_dto import AnnotationType, CreateAnnotationDto, LineGeometry, BoxGeometry, CoordinateSystem, Geometry
+from datamint.api.dto import AnnotationType, CreateAnnotationDto, LineGeometry, BoxGeometry, CoordinateSystem, Geometry
 import numpy as np
 import os
 import aiohttp
@@ -31,15 +31,21 @@ MAX_NUMBER_DISTINCT_COLORS = 2048  # Maximum number of distinct colors in a segm
 class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotation]):
     """API handler for annotation-related endpoints."""
 
-    def __init__(self, config: ApiConfig, client: httpx.Client | None = None) -> None:
+    def __init__(self,
+                 config: ApiConfig,
+                 client: httpx.Client | None = None,
+                 models_api=None,
+                 resources_api=None) -> None:
         """Initialize the annotations API handler.
 
         Args:
             config: API configuration containing base URL, API key, etc.
             client: Optional HTTP client instance. If None, a new one will be created.
         """
+        from .resources_api import ResourcesApi
         super().__init__(config, Annotation, 'annotations', client)
-        self._models_api = ModelsApi(config, client=client)
+        self._models_api = ModelsApi(config, client=client) if models_api is None else models_api
+        self._resources_api = ResourcesApi(config, client=client, annotations_api=self) if resources_api is None else resources_api
 
     def get_list(self,
                  resource: str | Resource | None = None,
@@ -377,7 +383,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
 
         annotations = [annotation_dto] if isinstance(annotation_dto, CreateAnnotationDto) else annotation_dto
         annotations = [ann.to_dict() if isinstance(ann, CreateAnnotationDto) else ann for ann in annotations]
-        resource_id = resource.id if isinstance(resource, Resource) else resource
+        resource_id = self._entid(resource)
         respdata = self._make_request('POST',
                                       f'{self.endpoint_base}/{resource_id}/annotations',
                                       json=annotations).json()
@@ -467,7 +473,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                     raise ValueError(f"AI model with name '{ai_model_name}' not found. ")
                 raise ValueError(f"AI model with name '{ai_model_name}' not found. " +
                                  f"Available models: {available_models}")
-            model_id = model_id['id']
+            model_id = model_id['name']
 
         # Handle NIfTI files specially - upload as single volume
         if isinstance(file_path, str) and (file_path.endswith('.nii') or file_path.endswith('.nii.gz')):
@@ -780,6 +786,37 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
             img_bytes.seek(0)
             yield img_bytes
 
+    def create_image_classification(self,
+                                    resource: str | Resource,
+                                    identifier: str,
+                                    value: str,
+                                    imported_from: str | None = None,
+                                    model_id: str | None = None,
+                                    ) -> str:
+        """
+        Create an image-level classification annotation.
+
+        Args:
+            resource: The resource unique id or Resource instance.
+            identifier: The annotation identifier/label.
+            value: The classification value.
+            imported_from: The imported from source value.
+            model_id: The model unique id.
+
+        Returns:
+            The id of the created annotation.
+        """
+        annotation_dto = CreateAnnotationDto(
+            type=AnnotationType.CATEGORY,
+            identifier=identifier,
+            scope='image',
+            value=value,
+            imported_from=imported_from,
+            model_id=model_id
+        )
+
+        return self.create(resource, annotation_dto)            
+
     def add_line_annotation(self,
                             point1: tuple[int, int] | tuple[float, float, float],
                             point2: tuple[int, int] | tuple[float, float, float],
@@ -903,7 +940,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
 
     def download_file(self,
                       annotation: str | Annotation,
-                      fpath_out: str | Path | None = None) -> bytes:
+                      fpath_out: str | os.PathLike | None = None) -> bytes:
         """
         Download the segmentation file for a given resource and annotation.
 
@@ -923,7 +960,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
 
         resp = self._make_request('GET', f'/annotations/{resource_id}/annotations/{annotation_id}/file')
         if fpath_out:
-            with open(str(fpath_out), 'wb') as f:
+            with open(fpath_out, 'wb') as f:
                 f.write(resp.content)
         return resp.content
 
@@ -1028,3 +1065,6 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         respdata = resp.json()
         if isinstance(respdata, dict) and 'error' in respdata:
             raise DatamintException(respdata['error'])
+
+    def _get_resource(self, ann: Annotation) -> Resource:
+        return self._resources_api.get_by_id(ann.resource_id)

datamint/api/endpoints/projects_api.py

@@ -30,7 +30,8 @@ class ProjectsApi(CRUDEntityApi[Project]):
         """
         response = self._get_child_entities(project, 'resources')
         resources_data = response.json()
-        return [Resource(**item) for item in resources_data]
+        resources = [Resource(**item) for item in resources_data]
+        return resources
 
     def create(self,
                name: str,
@@ -148,47 +149,48 @@ class ProjectsApi(CRUDEntityApi[Project]):
         self._make_entity_request('POST', project_id, add_path='resources',
                                   json={'resource_ids_to_add': resources_ids, 'all_files_selected': False})
 
-    def download(self, project: str | Project,
-                 outpath: str,
-                 all_annotations: bool = False,
-                 include_unannotated: bool = False,
-                 ) -> None:
-        """Download a project by its id.
-
-        Args:
-            project: The project id or Project instance.
-            outpath: The path to save the project zip file.
-            all_annotations: Whether to include all annotations in the downloaded dataset,
-                even those not made by the provided project.
-            include_unannotated: Whether to include unannotated resources in the downloaded dataset.
-        """
-        from tqdm.auto import tqdm
-        params = {'all_annotations': all_annotations}
-        if include_unannotated:
-            params['include_unannotated'] = include_unannotated
-
-        project_id = self._entid(project)
-        with self._stream_entity_request('GET', project_id,
-                                         add_path='annotated_dataset',
-                                         params=params) as response:
-            total_size = int(response.headers.get('content-length', 0))
-            if total_size == 0:
-                total_size = None
-            with tqdm(total=total_size, unit='B', unit_scale=True) as progress_bar:
-                with open(outpath, 'wb') as file:
-                    for data in response.iter_bytes(1024):
-                        progress_bar.update(len(data))
-                        file.write(data)
+    # def download(self, project: str | Project,
+    #              outpath: str,
+    #              all_annotations: bool = False,
+    #              include_unannotated: bool = False,
+    #              ) -> None:
+    #     """Download a project by its id.
+
+    #     Args:
+    #         project: The project id or Project instance.
+    #         outpath: The path to save the project zip file.
+    #         all_annotations: Whether to include all annotations in the downloaded dataset,
+    #             even those not made by the provided project.
+    #         include_unannotated: Whether to include unannotated resources in the downloaded dataset.
+    #     """
+    #     from tqdm.auto import tqdm
+    #     params = {'all_annotations': all_annotations}
+    #     if include_unannotated:
+    #         params['include_unannotated'] = include_unannotated
+
+    #     project_id = self._entid(project)
+    #     with self._stream_entity_request('GET', project_id,
+    #                                      add_path='annotated_dataset',
+    #                                      params=params) as response:
+    #         total_size = int(response.headers.get('content-length', 0))
+    #         if total_size == 0:
+    #             total_size = None
+    #         with tqdm(total=total_size, unit='B', unit_scale=True) as progress_bar:
+    #             with open(outpath, 'wb') as file:
+    #                 for data in response.iter_bytes(1024):
+    #                     progress_bar.update(len(data))
+    #                     file.write(data)
 
     def set_work_status(self,
-                        resource: str | Resource,
                         project: str | Project,
+                        resource: str | Resource,
                         status: Literal['opened', 'annotated', 'closed']) -> None:
         """
         Set the status of a resource.
 
         Args:
-            annotation: The annotation unique id or an annotation object.
+            project: The project unique id or a project object.
+            resource: The resource unique id or a resource object.
             status: The new status to set.
         """
         resource_id = self._entid(resource)

datamint/api/endpoints/resources_api.py

@@ -1,9 +1,8 @@
 from typing import Any, Optional, Sequence, TypeAlias, Literal, IO
 from ..base_api import ApiConfig, BaseApi
-from ..entity_base_api import EntityBaseApi, CreatableEntityApi, DeletableEntityApi
-from .annotations_api import AnnotationsApi
-from .projects_api import ProjectsApi
+from ..entity_base_api import CreatableEntityApi, DeletableEntityApi
 from datamint.entities.resource import Resource
+from datamint.entities.project import Project
 from datamint.entities.annotation import Annotation
 from datamint.exceptions import DatamintException, ResourceNotFoundError
 import httpx
@@ -23,10 +22,9 @@ import asyncio
 import aiohttp
 from pathlib import Path
 import nest_asyncio  # For running asyncio in jupyter notebooks
-import cv2
 from PIL import Image
-from nibabel.filebasedimages import FileBasedImage as nib_FileBasedImage
 import io
+from datamint.types import ImagingData
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -54,17 +52,25 @@ def _open_io(file_path: str | Path | IO, mode: str = 'rb') -> IO:
 class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
     """API handler for resource-related endpoints."""
 
-    def __init__(self, config: ApiConfig, client: Optional[httpx.Client] = None) -> None:
+    def __init__(self,
+                 config: ApiConfig,
+                 client: Optional[httpx.Client] = None,
+                 annotations_api=None,
+                 projects_api=None
+                 ) -> None:
         """Initialize the resources API handler.
 
         Args:
             config: API configuration containing base URL, API key, etc.
             client: Optional HTTP client instance. If None, a new one will be created.
         """
+        from .annotations_api import AnnotationsApi
+        from .projects_api import ProjectsApi
         super().__init__(config, Resource, 'resources', client)
         nest_asyncio.apply()
-        self.annotations_api = AnnotationsApi(config, client)
-        self.projects_api = ProjectsApi(config, client)
+        self.annotations_api = AnnotationsApi(
+            config, client, resources_api=self) if annotations_api is None else annotations_api
+        self.projects_api = ProjectsApi(config, client) if projects_api is None else projects_api
 
     def get_list(self,
                  status: Optional[ResourceStatus] = None,
@@ -710,21 +716,6 @@ class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
             # This should not happen with single file uploads, but handle it just in case
             raise DatamintException(f"Unexpected return from upload_resources: {type(result)} | {result}")
 
-    def _determine_mimetype(self,
-                            content,
-                            resource: str | Resource) -> tuple[str | None, str | None]:
-        # Determine mimetype from file content
-        mimetype_list, ext = guess_typez(content, use_magic=True)
-        mimetype = mimetype_list[-1]
-
-        # get mimetype from resource info if not detected
-        if mimetype is None or mimetype == DEFAULT_MIME_TYPE:
-            if not isinstance(resource, Resource):
-                resource = self.get_by_id(resource)
-            mimetype = resource.mimetype or mimetype
-
-        return mimetype, ext
-
     async def _async_download_file(self,
                                    resource: str | Resource,
                                    save_path: str | Path,
@@ -761,8 +752,8 @@ class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
                     f.write(data_bytes)
 
                 # Determine mimetype from file content
-                mimetype, ext = self._determine_mimetype(content=data_bytes,
-                                                         resource=resource)
+                mimetype, ext = BaseApi._determine_mimetype(content=data_bytes,
+                                                            declared_mimetype=resource.mimetype if isinstance(resource, Resource) else None)
 
                 # Generate final path with extension if needed
                 if mimetype is not None and mimetype != DEFAULT_MIME_TYPE:
@@ -850,7 +841,7 @@ class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
                                save_path: Optional[str] = None,
                                auto_convert: bool = True,
                                add_extension: bool = False
-                               ) -> bytes | pydicom.Dataset | Image.Image | cv2.VideoCapture | nib_FileBasedImage | tuple[Any, str]:
+                               ) -> ImagingData | tuple[ImagingData, str] | bytes:
         """
         Download a resource file.
 
@@ -888,8 +879,8 @@ class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
             mimetype = None
             ext = None
             if auto_convert or add_extension:
-                mimetype, ext = self._determine_mimetype(content=response.content,
-                                                         resource=resource)
+                mimetype, ext = BaseApi._determine_mimetype(content=response.content,
+                                                            declared_mimetype=resource.mimetype if isinstance(resource, Resource) else None)
             if auto_convert:
                 if mimetype is None:
                     _LOGGER.warning("Could not determine mimetype. Returning a bytes array.")
@@ -997,6 +988,12 @@ class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
                  resource: str | Resource,
                  tags: Sequence[str],
                  ):
+        """
+        Set tags for a resource, IMPORTANT: This replaces all existing tags.
+        Args:
+            resource: The resource unique id or Resource object.
+            tags: The tags to set.
+        """
         data = {'tags': tags}
         resource_id = self._entid(resource)
 
@@ -1005,3 +1002,53 @@ class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
                                              add_path='tags',
                                              json=data)
         return response
+
+    # def get_projects(self, resource: Resource) -> Sequence[Project]:
+    #     """
+    #     Get all projects this resource belongs to.
+
+    #     Args:
+    #         resource: The Resource instance.
+
+    #     Returns:
+    #         List of Project instances
+    #     """
+    #     resource._ensure_attr('projects')
+    #     proj_ids = [p['id'] for p in resource.projects]
+    #     return [proj for proj in self.projects_api.get_all() if proj.id in proj_ids]
+
+    def add_tags(self,
+                 resource: str | Resource,
+                 tags: Sequence[str],
+                 ):
+        """
+        Add tags to a resource, IMPORTANT: This appends to existing tags.
+        Args:
+            resource: The resource unique id or Resource object.
+            tags: The tags to add.
+        """
+        if isinstance(resource, str):
+            resource = self.get_by_id(resource)
+        old_tags = resource.tags if resource.tags is not None else []
+        return self.set_tags(resource, old_tags + list(tags))
+
+    def bulk_delete(self, entities: Sequence[str | Resource]) -> None:
+        """Delete multiple entities. Faster than deleting them one by one.
+
+        Args:
+            entities: Sequence of unique identifiers for the entities to delete or the entity instances themselves.
+
+        Raises:
+            httpx.HTTPStatusError: If deletion fails or any entity not found
+        """
+        from math import ceil
+
+        resources_ids = [self._entid(ent) for ent in entities]
+        if len(resources_ids) == 0:
+            return
+        batch_size = 200
+        for i in range(0, ceil(len(resources_ids)/batch_size)):
+            batch_ids = resources_ids[i*batch_size:(i+1)*batch_size]
+            self._make_request('DELETE',
+                               f'{self.endpoint_base}',
+                               params={'resource_ids': ','.join(batch_ids)})

datamint/api/entity_base_api.py

@@ -1,7 +1,6 @@
 from typing import Any, TypeVar, Generic, Type, Sequence
 import logging
 import httpx
-from dataclasses import dataclass
 from datamint.entities.base_entity import BaseEntity
 from datamint.exceptions import DatamintException, ResourceNotFoundError
 import aiohttp
@@ -37,9 +36,14 @@ class EntityBaseApi(BaseApi, Generic[T]):
             client: Optional HTTP client instance. If None, a new one will be created.
         """
         super().__init__(config, client)
-        self.entity_class = entity_class
+        self.__entity_class = entity_class
         self.endpoint_base = endpoint_base.strip('/')
 
+    def _init_entity_obj(self, **kwargs) -> T:
+        obj = self.__entity_class(**kwargs)
+        obj._api = self
+        return obj
+
     @staticmethod
     def _entid(entity: BaseEntity | str) -> str:
         return entity if isinstance(entity, str) else entity.id
@@ -117,7 +121,7 @@ class EntityBaseApi(BaseApi, Generic[T]):
         for resp, items in items_gen:
             all_items.extend(items)
 
-        return [self.entity_class(**item) for item in all_items]
+        return [self._init_entity_obj(**item) for item in all_items]
 
     def get_all(self, limit: int | None = None) -> Sequence[T]:
         """Get all entities with optional pagination and filtering.
@@ -143,7 +147,7 @@ class EntityBaseApi(BaseApi, Generic[T]):
             httpx.HTTPStatusError: If the entity is not found or request fails.
         """
         response = self._make_entity_request('GET', entity_id)
-        return self.entity_class(**response.json())
+        return self._init_entity_obj(**response.json())
 
     async def _create_async(self, entity_data: dict[str, Any]) -> str | Sequence[str | dict]:
         """Create a new entity.
@@ -177,42 +181,6 @@ class EntityBaseApi(BaseApi, Generic[T]):
                                              add_path=child_entity_name)
         return response
 
-    # def bulk_create(self, entities_data: list[dict[str, Any]]) -> list[T]:
-    #     """Create multiple entities in a single request.
-
-    #     Args:
-    #         entities_data: List of dictionaries containing entity data
-
-    #     Returns:
-    #         List of created entity instances
-
-    #     Raises:
-    #         httpx.HTTPStatusError: If bulk creation fails
-    #     """
-    #     payload = {'items': entities_data}  # Common bulk API format
-    #     response = self._make_request('POST', f'/{self.endpoint_base}/bulk', json=payload)
-    #     data = response.json()
-
-    #     # Handle response format - may be direct list or wrapped
-    #     items = data if isinstance(data, list) else data.get('items', [])
-    #     return [self.entity_class(**item) for item in items]
-
-    # def count(self, **params: Any) -> int:
-    #     """Get the total count of entities matching the given filters.
-
-    #     Args:
-    #         **params: Query parameters for filtering
-
-    #     Returns:
-    #         Total count of matching entities
-
-    #     Raises:
-    #         httpx.HTTPStatusError: If the request fails
-    #     """
-    #     response = self._make_request('GET', f'/{self.endpoint_base}/count', params=params)
-    #     data = response.json()
-    #     return data.get('count', 0) if isinstance(data, dict) else data
-
 
 class DeletableEntityApi(EntityBaseApi[T]):
     """Extension of EntityBaseApi for entities that support soft deletion.
@@ -221,7 +189,7 @@ class DeletableEntityApi(EntityBaseApi[T]):
     retrieval and restoration of such entities.
     """
 
-    def delete(self, entity: str | BaseEntity) -> None:
+    def delete(self, entity: str | T) -> None:
         """Delete an entity.
 
         Args:
@@ -232,7 +200,7 @@ class DeletableEntityApi(EntityBaseApi[T]):
         """
         self._make_entity_request('DELETE', entity)
 
-    def bulk_delete(self, entities: Sequence[str | BaseEntity]) -> None:
+    def bulk_delete(self, entities: Sequence[str | T]) -> None:
         """Delete multiple entities.
 
         Args:
@@ -264,7 +232,7 @@ class DeletableEntityApi(EntityBaseApi[T]):
             httpx.HTTPStatusError: If deletion fails or entity not found
         """
         async with self._make_entity_request_async('DELETE', entity,
-                                              session=session) as resp:
+                                                   session=session) as resp:
             await resp.text()  # Consume response to complete request
 
     # def get_deleted(self, **kwargs) -> Sequence[T]: