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

datamint/__init__.py

@@ -7,19 +7,17 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .dataset.dataset import DatamintDataset as Dataset
     from .apihandler.api_handler import APIHandler
-    from .experiment import Experiment
     from .api.client import Api
 else:
     import lazy_loader as lazy
 
     __getattr__, __dir__, __all__ = lazy.attach(
         __name__,
-        submodules=['dataset', "dataset.dataset", "apihandler.api_handler", "experiment"],
+        submodules=['dataset', "dataset.dataset", "apihandler.api_handler"],
         submod_attrs={
             "dataset.dataset": ["DatamintDataset"],
             "dataset": ['Dataset'],
             "apihandler.api_handler": ["APIHandler"],
-            "experiment": ["Experiment"],
             "api.client": ["Api"],
         },
     )

datamint/api/__init__.py

@@ -1,3 +0,0 @@
-from .client import Api
-
-__all__ = ['Api']

datamint/api/base_api.py

@@ -1,9 +1,9 @@
 import logging
-from typing import Any, Generator, AsyncGenerator, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING
+from collections.abc import Generator, AsyncGenerator
 import httpx
 from dataclasses import dataclass
 from datamint.exceptions import DatamintException, ResourceNotFoundError
-from datamint.types import ImagingData
 import aiohttp
 import json
 from PIL import Image
@@ -14,15 +14,17 @@ import gzip
 import contextlib
 import asyncio
 from medimgkit.format_detection import GZIP_MIME_TYPES, DEFAULT_MIME_TYPE, guess_typez, guess_extension
+from datamint.utils.env import ensure_asyncio_loop
 
 if TYPE_CHECKING:
     from datamint.api.client import Api
+    from datamint.types import ImagingData
 
 logger = logging.getLogger(__name__)
 
-# Generic type for entities
 _PAGE_LIMIT = 5000
 
+
 @dataclass
 class ApiConfig:
     """Configuration for API client.
@@ -32,18 +34,30 @@ class ApiConfig:
         api_key: Optional API key for authentication.
         timeout: Request timeout in seconds.
         max_retries: Maximum number of retries for requests.
+        port: Optional port number for the API server.
+        verify_ssl: Whether to verify SSL certificates. Default is True.
+            Set to False only in development environments with self-signed certificates.
+            Can also be a path to a CA bundle file.
     """
     server_url: str
     api_key: str | None = None
     timeout: float = 30.0
     max_retries: int = 3
+    port: int | None = None
+    verify_ssl: bool | str = True
 
     @property
     def web_app_url(self) -> str:
         """Get the base URL for the web application."""
-        if self.server_url.startswith('http://localhost:3001'):
+        base_url = self.server_url
+
+        # Add port to base_url if specified
+        if self.port is not None:
+            base_url = f"{self.server_url.rstrip('/')}:{self.port}"
+
+        if base_url.startswith('http://localhost'):
             return 'http://localhost:3000'
-        if self.server_url.startswith('https://stagingapi.datamint.io'):
+        if base_url.startswith('https://stagingapi.datamint.io'):
             return 'https://staging.datamint.io'
         return 'https://app.datamint.io'
 
@@ -61,22 +75,173 @@ class BaseApi:
             client: Optional HTTP client instance. If None, a new one will be created.
         """
         self.config = config
-        self.client = client or self._create_client()
+        self._owns_client = client is None  # Track if we created the client
+        self.client = client or BaseApi._create_client(config)
         self.semaphore = asyncio.Semaphore(20)
         self._api_instance: 'Api | None' = None  # Injected by Api class
+        self._aiohttp_connector: aiohttp.TCPConnector | None = None
+        self._aiohttp_session: aiohttp.ClientSession | None = None
+        ensure_asyncio_loop()
+        
 
-    def _create_client(self) -> httpx.Client:
-        """Create and configure HTTP client with authentication and timeouts."""
-        headers = None
-        if self.config.api_key:
-            headers = {"apikey": self.config.api_key}
+    @staticmethod
+    def _create_client(config: ApiConfig) -> httpx.Client:
+        """Create and configure HTTP client with authentication and timeouts.
+
+        The client is designed to be long-lived and reused across multiple requests.
+        It maintains connection pooling for improved performance.
+        """
+        headers = {"apikey": config.api_key, 'Authorization': f"Bearer {config.api_key}"} if config.api_key else None
+
+        # Add port to base_url if specified
+        base_url = config.server_url.rstrip('/').strip()
+        if config.port is not None:
+            # if the port is already in the URL, replace it
+            if ':' in base_url.split('//')[-1]:
+                parts = base_url.rsplit(':', 1)
+                # confirm parts[1] is numeric
+                if parts[1].isdigit():
+                    base_url = f"{parts[0]}:{config.port}"
+                else:
+                    logger.warning(f"Invalid port detected in server_url: {config.server_url}")
+            else:
+                base_url = f"{base_url}:{config.port}"
 
         return httpx.Client(
-            base_url=self.config.server_url,
+            base_url=base_url,
             headers=headers,
-            timeout=self.config.timeout
+            timeout=config.timeout,
+            verify=config.verify_ssl,
+            limits=httpx.Limits(
+                max_keepalive_connections=5,
+                max_connections=20,
+                keepalive_expiry=8
+            )
         )
 
+    def _raise_ssl_error(self, original_error: Exception) -> None:
+        """Raise a more helpful SSL certificate error with troubleshooting guidance.
+
+        Args:
+            original_error: The original SSL-related exception
+
+        Raises:
+            DatamintException: With helpful troubleshooting information
+        """
+        error_msg = (
+            f"SSL Certificate verification failed: {original_error}\n\n"
+            "This typically happens when Python cannot verify the SSL certificate of the Datamint API.\n\n"
+            "Quick fixes:\n"
+            "1. Upgrade certifi:\n"
+            "   pip install --upgrade certifi\n\n"
+            "2. Set environment variables:\n"
+            "   export SSL_CERT_FILE=$(python -m certifi)\n"
+            "   export REQUESTS_CA_BUNDLE=$(python -m certifi)\n\n"
+            "3. Or disable SSL verification (development only):\n"
+            "   api = Api(verify_ssl=False)\n\n"
+            "For more help, see: https://github.com/SonanceAI/datamint-python-api#-ssl-certificate-troubleshooting"
+        )
+        raise DatamintException(error_msg) from original_error
+
+    def _create_aiohttp_connector(self, force_close: bool = False) -> aiohttp.TCPConnector:
+        """Create aiohttp connector with SSL configuration.
+
+        Args:
+            force_close: Whether to force close connections (disable keep-alive)
+
+        Returns:
+            Configured TCPConnector for aiohttp sessions.
+        """
+        import ssl
+        import certifi
+
+        limit = 20
+        ttl_dns_cache = 300
+
+        if self.config.verify_ssl is False:
+            # Disable SSL verification (not recommended for production)
+            return aiohttp.TCPConnector(ssl=False, limit=limit, ttl_dns_cache=ttl_dns_cache, force_close=force_close)
+        elif isinstance(self.config.verify_ssl, str):
+            # Use custom CA bundle
+            ssl_context = ssl.create_default_context(cafile=self.config.verify_ssl)
+            return aiohttp.TCPConnector(ssl=ssl_context, limit=limit, ttl_dns_cache=ttl_dns_cache, force_close=force_close)
+        else:
+            # Use certifi's CA bundle (default behavior)
+            ssl_context = ssl.create_default_context(cafile=certifi.where())
+            return aiohttp.TCPConnector(ssl=ssl_context, limit=limit, ttl_dns_cache=ttl_dns_cache, force_close=force_close)
+
+    def _get_aiohttp_session(self) -> aiohttp.ClientSession:
+        """Get or create a shared aiohttp session for this API instance.
+
+        Creating/closing a new TLS connection for each upload can cause intermittent
+        connection shutdown timeouts in long-running processes (notably notebooks).
+        Reusing a single session keeps connections healthy and avoids excessive churn.
+        """
+        if self._aiohttp_session is not None and not self._aiohttp_session.closed:
+            return self._aiohttp_session
+
+        # (Re)create connector and session
+        self._aiohttp_connector = self._create_aiohttp_connector(force_close=False)
+        timeout = aiohttp.ClientTimeout(total=self.config.timeout)
+        self._aiohttp_session = aiohttp.ClientSession(connector=self._aiohttp_connector, timeout=timeout)
+        return self._aiohttp_session
+
+    def _close_aiohttp_session(self) -> None:
+        """Close the shared aiohttp session if it exists.
+
+        This is best-effort; in environments with a running loop we rely on
+        `nest_asyncio` (enabled via `ensure_asyncio_loop`) to allow nested runs.
+        """
+        if self._aiohttp_session is None or self._aiohttp_session.closed:
+            return
+
+        ensure_asyncio_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        try:
+            loop.run_until_complete(self._aiohttp_session.close())
+        except RuntimeError:
+            # If we're in an environment where the loop is running and not patched,
+            # fall back to scheduling the close.
+            try:
+                loop.create_task(self._aiohttp_session.close())
+            except Exception as e:
+                logger.info(f"Unable to schedule aiohttp session close: {e}")
+                pass
+        finally:
+            self._aiohttp_session = None
+            self._aiohttp_connector = None
+
+    def close(self) -> None:
+        """Close the HTTP client and release resources.
+
+        Should be called when the API instance is no longer needed.
+        Only closes the client if it was created by this instance.
+        """
+        # Close shared aiohttp session regardless of httpx client ownership.
+        self._close_aiohttp_session()
+        if self._owns_client and self.client is not None:
+            self.client.close()
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - ensures client is closed."""
+        self.close()
+
+    def __del__(self):
+        """Destructor - ensures client is closed when instance is garbage collected."""
+        try:
+            self.close()
+        except Exception:
+            pass  # Ignore errors during cleanup
+
     def _stream_request(self, method: str, endpoint: str, **kwargs):
         """Make streaming HTTP request with error handling.
 
@@ -120,21 +285,15 @@ class BaseApi:
         """
         url = endpoint.lstrip('/')  # Remove leading slash for httpx
 
-        try:
+        if logger.isEnabledFor(logging.DEBUG):
             curl_command = self._generate_curl_command({"method": method,
                                                         "url": url,
                                                         "headers": self.client.headers,
                                                         **kwargs}, fail_silently=True)
             logger.debug(f'Equivalent curl command: "{curl_command}"')
-            response = self.client.request(method, url, **kwargs)
-            response.raise_for_status()
-            return response
-        except httpx.HTTPStatusError as e:
-            logger.error(f"HTTP error {e.response.status_code} for {method} {endpoint}: {e.response.text}")
-            raise
-        except httpx.RequestError as e:
-            logger.error(f"Request error for {method} {endpoint}: {e}")
-            raise
+        response = self.client.request(method, url, **kwargs)
+        self._check_errors_response_httpx(response, url=url)
+        return response
 
     def _generate_curl_command(self,
                                request_args: dict,
@@ -201,7 +360,7 @@ class BaseApi:
             raise
 
     @staticmethod
-    def get_status_code(e: httpx.HTTPStatusError | aiohttp.ClientResponseError) -> int:
+    def get_status_code(e: httpx.HTTPError | aiohttp.ClientError) -> int:
         if hasattr(e, 'response') and e.response is not None:
             # httpx.HTTPStatusError
             return e.response.status_code
@@ -218,27 +377,70 @@ class BaseApi:
                          status_code: int) -> bool:
         return BaseApi.get_status_code(e) == status_code
 
-    def _check_errors_response(self,
-                               response: httpx.Response | aiohttp.ClientResponse,
-                               url: str):
+    def _check_errors_response_httpx(self,
+                                     response: httpx.Response,
+                                     url: str):
+        response_json = None
         try:
+            try:
+                response_json = response.json()
+            except Exception:
+                pass
             response.raise_for_status()
-        except (httpx.HTTPStatusError, aiohttp.ClientResponseError) as e:
-            logger.error(f"HTTP error occurred: {e}")
+        except httpx.ConnectError as e:
+            if "CERTIFICATE_VERIFY_FAILED" in str(e) or "certificate verify failed" in str(e).lower():
+                self._raise_ssl_error(e)
+            raise
+        except httpx.HTTPError as e:
+            error_msg = f"{getattr(e, 'message', str(e))} | {getattr(response, 'text', '')}"
+            if response_json:
+                error_msg = f"{error_msg} | {response_json}"
+            try:
+                e.message = error_msg
+            except Exception:
+                logger.debug("Unable to set message attribute on exception")
+                pass
+
+            logger.error(f"HTTP error {response.status_code} for {url}: {error_msg}")
+            status_code = response.status_code
+            if status_code in (400, 404):
+                if ' not found' in error_msg.lower() or 'Not Found' in error_msg:
+                    # Will be caught by the caller and properly initialized:
+                    raise ResourceNotFoundError('unknown', {})
+            raise
+        return response_json
+
+    async def _check_errors_response_aiohttp(self,
+                                             response: aiohttp.ClientResponse,
+                                             url: str):
+        response_json = None
+        try:
+            try:
+                response_json = await response.json()
+            except Exception:
+                logger.debug("Failed to parse JSON from error response")
+                pass
+            response.raise_for_status()
+        except aiohttp.ClientError as e:
+            error_msg = str(getattr(e, 'message', e))
+            # log the raw response for debugging
             status_code = BaseApi.get_status_code(e)
-            if status_code >= 500 and status_code < 600:
-                logger.error(f"Error in request to {url}: {e}")
-            if status_code >= 400 and status_code < 500:
-                if isinstance(e, aiohttp.ClientResponseError):
-                    # aiohttp.ClientResponse does not have .text or .json() methods directly
-                    error_msg = e.message
-                else:
-                    error_msg = e.response.text
-                logger.info(f"Error response: {error_msg}")
-                if ' not found' in error_msg.lower():
+            # Try to extract detailed message from JSON response
+            if response_json:
+                error_msg = f"{error_msg} | {response_json}"
+
+            logger.error(f"HTTP error {status_code} for {url}: {error_msg}")
+            try:
+                e.message = error_msg
+            except Exception:
+                logger.debug("Unable to set message attribute on exception")
+                pass
+            if status_code in (400, 404):
+                if ' not found' in error_msg.lower() or 'Not Found' in error_msg:
                     # Will be caught by the caller and properly initialized:
                     raise ResourceNotFoundError('unknown', {})
             raise
+        return response_json
 
     @contextlib.asynccontextmanager
     async def _make_request_async(self,
@@ -268,9 +470,10 @@ class BaseApi:
         """
 
         if session is None:
-            async with aiohttp.ClientSession() as temp_session:
-                async with self._make_request_async(method, endpoint, temp_session, **kwargs) as resp:
-                    yield resp
+            session = self._get_aiohttp_session()
+
+            async with self._make_request_async(method, endpoint, session, **kwargs) as resp:
+                yield resp
             return
 
         url = f"{self.config.server_url.rstrip('/')}/{endpoint.lstrip('/')}"
@@ -279,7 +482,13 @@ class BaseApi:
         if self.config.api_key:
             headers['apikey'] = self.config.api_key
 
-        timeout = aiohttp.ClientTimeout(total=self.config.timeout)
+        if 'timeout' in kwargs:
+            timeout = kwargs.pop('timeout')
+            # Ensure timeout is a ClientTimeout object
+            if isinstance(timeout, (int, float)):
+                timeout = aiohttp.ClientTimeout(total=timeout)
+        else:
+            timeout = aiohttp.ClientTimeout(total=self.config.timeout)
 
         response = None
         curl_cmd = self._generate_curl_command(
@@ -296,10 +505,17 @@ class BaseApi:
                     timeout=timeout,
                     **kwargs
                 )
-                self._check_errors_response(response, url=url)
+                data = await self._check_errors_response_aiohttp(response, url=url)
+                if data is None:
+                    data = await response.json()
+                logger.debug(f"Successful {method} request to {endpoint}: {data}")
                 yield response
+            except aiohttp.ClientConnectorCertificateError as e:
+                self._raise_ssl_error(e)
             except aiohttp.ClientError as e:
-                logger.error(f"Request error for {method} {endpoint}: {e}")
+                # Check for SSL errors in other client errors
+                if "certificate" in str(e).lower() or "ssl" in str(e).lower():
+                    self._raise_ssl_error(e)
                 raise
             finally:
                 if response is not None:
@@ -345,9 +561,13 @@ class BaseApi:
         """
         offset = 0
         total_fetched = 0
-        params = dict(kwargs.get('params', {}))
-        # Ensure kwargs carries our params reference so mutations below take effect
-        kwargs['params'] = params
+
+        use_json_pagination = method.upper() == 'POST' and 'json' in kwargs and isinstance(kwargs['json'], dict)
+
+        if not use_json_pagination:
+            params = dict(kwargs.get('params', {}))
+            # Ensure kwargs carries our params reference so mutations below take effect
+            kwargs['params'] = params
 
         while True:
             if limit is not None and total_fetched >= limit:
@@ -358,8 +578,12 @@ class BaseApi:
                 remaining = limit - total_fetched
                 page_limit = min(_PAGE_LIMIT, remaining)
 
-            params['offset'] = offset
-            params['limit'] = page_limit
+            if use_json_pagination:
+                kwargs['json']['offset'] = str(offset)
+                kwargs['json']['limit'] = str(page_limit)
+            else:
+                params['offset'] = offset
+                params['limit'] = page_limit
 
             response = self._make_request(method=method,
                                           endpoint=endpoint,
@@ -412,7 +636,7 @@ class BaseApi:
     def convert_format(bytes_array: bytes,
                        mimetype: str | None = None,
                        file_path: str | None = None
-                       ) -> ImagingData | bytes:
+                       ) -> 'ImagingData | bytes':
         """ Convert the bytes array to the appropriate format based on the mimetype.
 
         Args:
@@ -430,6 +654,8 @@ class BaseApi:
             >>> dicom = BaseApi.convert_format(dicom_bytes)
 
         """
+        import pydicom
+
         if mimetype is None:
             mimetype, ext = BaseApi._determine_mimetype(bytes_array)
             if mimetype is None:
@@ -449,15 +675,21 @@ class BaseApi:
             return bytes_array
         elif mimetype.endswith('nifti'):
             try:
-                return nib.Nifti1Image.from_stream(content_io)
+                ndata = nib.Nifti1Image.from_stream(content_io)
+                ndata.get_fdata()  # force loading before IO is closed
+                return ndata
             except Exception as e:
                 if file_path is not None:
-                    return nib.load(file_path)
+                    ndata = nib.load(file_path)
+                    ndata.get_fdata()  # force loading before IO is closed
+                    return ndata
                 raise e
         elif mimetype in GZIP_MIME_TYPES:
             # let's hope it's a .nii.gz
             with gzip.open(content_io, 'rb') as f:
-                return nib.Nifti1Image.from_stream(f)
+                ndata = nib.Nifti1Image.from_stream(f)
+                ndata.get_fdata()  # force loading before IO is closed
+                return ndata
 
         raise ValueError(f"Unsupported mimetype: {mimetype}")
 

datamint/api/client.py

@@ -1,19 +1,21 @@
-from typing import Optional
 from .base_api import ApiConfig, BaseApi
 from .endpoints import (ProjectsApi, ResourcesApi, AnnotationsApi,
-                        ChannelsApi, UsersApi, DatasetsInfoApi, ModelsApi,
-                        AnnotationSetsApi
+                        ChannelsApi, UsersApi, DatasetsInfoApi,
+                        AnnotationSetsApi, DeployModelApi
                         )
+from .endpoints.models_api import ModelsApi
 import datamint.configs
 from datamint.exceptions import DatamintException
+import logging
 
+_LOGGER = logging.getLogger(__name__)
 
 class Api:
     """Main API client that provides access to all endpoint handlers."""
     DEFAULT_SERVER_URL = 'https://api.datamint.io'
     DATAMINT_API_VENV_NAME = datamint.configs.ENV_VARS[datamint.configs.APIKEY_KEY]
 
-    _API_MAP : dict[str, type[BaseApi]] = {
+    _API_MAP: dict[str, type[BaseApi]] = {
         'projects': ProjectsApi,
         'resources': ResourcesApi,
         'annotations': AnnotationsApi,
@@ -22,21 +24,26 @@ class Api:
         'datasets': DatasetsInfoApi,
         'models': ModelsApi,
         'annotationsets': AnnotationSetsApi,
+        'deploy': DeployModelApi,
     }
 
     def __init__(self,
                  server_url: str | None = None,
-                 api_key: Optional[str] = None,
+                 api_key: str | None = None,
                  timeout: float = 60.0, max_retries: int = 2,
-                 check_connection: bool = True) -> None:
+                 check_connection: bool = True,
+                 verify_ssl: bool | str = True) -> None:
         """Initialize the API client.
 
         Args:
-            base_url: Base URL for the API
+            server_url: Base URL for the API
             api_key: Optional API key for authentication
             timeout: Request timeout in seconds
             max_retries: Maximum number of retry attempts
-            client: Optional HTTP client instance
+            check_connection: Whether to check connection on initialization
+            verify_ssl: Whether to verify SSL certificates. Default is True.
+                Set to False only in development environments with self-signed certificates.
+                Can also be a path to a CA bundle file for custom certificate verification.
         """
         if server_url is None:
             server_url = datamint.configs.get_value(datamint.configs.APIURL_KEY)
@@ -53,10 +60,28 @@ class Api:
             server_url=server_url,
             api_key=api_key,
             timeout=timeout,
-            max_retries=max_retries
+            max_retries=max_retries,
+            verify_ssl=verify_ssl
+        )
+        self.high_config = ApiConfig(
+            server_url=server_url,
+            api_key=api_key,
+            timeout=timeout*5,
+            max_retries=max_retries,
+            verify_ssl=verify_ssl,
+        )
+        self.mlflow_config = ApiConfig(
+            server_url=server_url,
+            api_key=api_key,
+            timeout=timeout,
+            max_retries=max_retries,
+            port=5000,
+            verify_ssl=verify_ssl
         )
         self._client = None
-        self._endpoints = {}
+        self._highclient = None
+        self._mlclient = None
+        self._endpoints: dict[str, BaseApi] = {}
         if check_connection:
             self.check_connection()
 
@@ -65,12 +90,45 @@ class Api:
             self.projects.get_list(limit=1)
         except Exception as e:
             raise DatamintException("Error connecting to the Datamint API." +
-                                    f" Please check your api_key and/or other configurations. {e}")
+                                    f" Please check your api_key and/or other configurations.") from e
 
-    def _get_endpoint(self, name: str):
+    def close(self) -> None:
+        """Close underlying HTTP clients and any shared aiohttp sessions.
+
+        Recommended for notebooks / long-running processes.
+        """
+        # Close per-endpoint resources (aiohttp sessions, etc.)
+        for endpoint in list(self._endpoints.values()):
+            try:
+                endpoint.close()
+            except Exception as e:
+                _LOGGER.warning(f"Error closing endpoint {endpoint}: {e}")
+                pass
+
+        # Close shared httpx clients owned by this Api
+        for client in (self._client, self._highclient, self._mlclient):
+            try:
+                if client is not None:
+                    client.close()
+            except Exception as e:
+                _LOGGER.info(f"Error closing client {client}: {e}")
+
+    def _get_endpoint(self, name: str, is_mlflow: bool = False):
+        if is_mlflow:
+            if self._mlclient is None:
+                self._mlclient = BaseApi._create_client(self.mlflow_config)
+            client = self._mlclient
+        elif name in ['resources', 'annotations']:
+            if self._highclient is None:
+                self._highclient = BaseApi._create_client(self.high_config)
+            client = self._highclient
+        else:
+            if self._client is None:
+                self._client = BaseApi._create_client(self.config)
+            client = self._client
         if name not in self._endpoints:
             api_class = self._API_MAP[name]
-            endpoint = api_class(self.config, self._client)
+            endpoint = api_class(self.config, client)
             # Inject this API instance into the endpoint so it can inject into entities
             endpoint._api_instance = self
             self._endpoints[name] = endpoint
@@ -108,3 +166,8 @@ class Api:
     @property
     def annotationsets(self) -> AnnotationSetsApi:
         return self._get_endpoint('annotationsets')
+
+    @property
+    def deploy(self) -> DeployModelApi:
+        """Access deployment management endpoints."""
+        return self._get_endpoint('deploy', is_mlflow=True)

datamint/api/endpoints/__init__.py

@@ -6,8 +6,8 @@ from .projects_api import ProjectsApi
 from .resources_api import ResourcesApi
 from .users_api import UsersApi
 from .datasetsinfo_api import DatasetsInfoApi
-from .models_api import ModelsApi
 from .annotationsets_api import AnnotationSetsApi
+from .deploy_model_api import DeployModelApi
 
 __all__ = [
     'AnnotationsApi',
@@ -16,6 +16,6 @@ __all__ = [
     'ResourcesApi',
     'UsersApi',
     'DatasetsInfoApi',
-    'ModelsApi',
     'AnnotationSetsApi',
+    'DeployModelApi',
 ]