label-studio-sdk 0.0.32__py3-none-any.whl → 1.0.0__py3-none-any.whl

label_studio_sdk/client.py

@@ -1,455 +1,183 @@
-""" .. include::../docs/client.md
-"""
+# This file was auto-generated by Fern from our API Definition.
+
 import os
+import typing
+
+import httpx
+
+from .actions.client import ActionsClient, AsyncActionsClient
+from .annotations.client import AnnotationsClient, AsyncAnnotationsClient
+from .core.api_error import ApiError
+from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .environment import LabelStudioEnvironment
+from .export_storage.client import AsyncExportStorageClient, ExportStorageClient
+from .files.client import AsyncFilesClient, FilesClient
+from .import_storage.client import AsyncImportStorageClient, ImportStorageClient
+from .ml.client import AsyncMlClient, MlClient
+from .predictions.client import AsyncPredictionsClient, PredictionsClient
+from .projects.client import AsyncProjectsClient, ProjectsClient
+from .tasks.client import AsyncTasksClient, TasksClient
+from .users.client import AsyncUsersClient, UsersClient
+from .views.client import AsyncViewsClient, ViewsClient
+from .webhooks.client import AsyncWebhooksClient, WebhooksClient
+
+
+class LabelStudio:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
+
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
+
+    environment : LabelStudioEnvironment
+        The environment to use for requests from the client. from .environment import LabelStudioEnvironment
+
 
-import json
-import warnings
-import logging
-import requests
 
-from typing import Optional
-from pydantic import BaseModel, constr, root_validator
-from requests.adapters import HTTPAdapter
-from types import SimpleNamespace
+        Defaults to LabelStudioEnvironment.DEFAULT
 
-logger = logging.getLogger(__name__)
 
-MAX_RETRIES = 3
-TIMEOUT = (10.0, 180.0)
-HEADERS = {}
-LABEL_STUDIO_DEFAULT_URL = 'http://localhost:8080'
 
+    api_key : typing.Optional[str]
+    timeout : typing.Optional[float]
+        The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
 
-class ClientCredentials(BaseModel):
-    email: Optional[str] = None
-    password: Optional[str] = None
-    api_key: Optional[constr()] = None
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
 
-    @root_validator(pre=True, allow_reuse=True)
-    def either_key_or_email_password(cls, values):
-        assert (
-            'email' in values or 'api_key' in values
-        ), 'At least one of email or api_key should be included'
-        assert (
-            'email' not in values or 'password' in values
-        ), 'Provide both email and password for login auth'
-        return values
+    httpx_client : typing.Optional[httpx.Client]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
 
+    Examples
+    --------
+    from label_studio_sdk.client import LabelStudio
+
+    client = LabelStudio(
+        api_key="YOUR_API_KEY",
+    )
+    """
 
-class Client(object):
     def __init__(
         self,
-        url: str = None,
-        api_key: str = None,
-        credentials=None,
-        session=None,
-        extra_headers: dict = None,
-        cookies: dict = None,
-        oidc_token=None,
-        versions=None,
-        make_request_raise=True,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: LabelStudioEnvironment = LabelStudioEnvironment.DEFAULT,
+        api_key: typing.Optional[str] = os.getenv("LABEL_STUDIO_API_KEY"),
+        timeout: typing.Optional[float] = None,
+        follow_redirects: typing.Optional[bool] = True,
+        httpx_client: typing.Optional[httpx.Client] = None
     ):
-        """Initialize the client. Do this before using other Label Studio SDK classes and methods in your script.
-
-        Parameters
-        ----------
-        url: str
-            Label Studio host address.
-            Example: http://localhost:8080
-        api_key: str
-            User token for the API. You can find this on your user account page in Label Studio.
-        credentials: ClientCredentials
-            User email and password or api_key.
-        session: requests.Session()
-            If None, a new one is created.
-        extra_headers: dict
-            Additional headers that will be passed to each http request
-        cookies: dict
-            Cookies that will be passed to each http request.
-        oidc_token: str
-            Bearer token for proxy authentication - in case the server is behind an authenticating proxy.
-        versions: dict
-            Versions of Label Studio components for the connected instance
-        make_request_raise: bool
-            If true, make_request will raise exceptions on request errors
-        """
-        if not url:
-            url = os.getenv('LABEL_STUDIO_URL', LABEL_STUDIO_DEFAULT_URL)
-        self.url = url.rstrip('/')
-        self.make_request_raise = make_request_raise
-        self.session = session or self.get_session()
-
-        # set api key or get it using credentials (username and password)
-        if api_key is None and credentials is None:
-            api_key = os.getenv('LABEL_STUDIO_API_KEY')
-
-        if api_key is not None:
-            credentials = ClientCredentials(api_key=api_key)
-        self.api_key = (
-            credentials.api_key
-            if credentials.api_key
-            else self.get_api_key(credentials)
+        _defaulted_timeout = timeout if timeout is not None else 60 if httpx_client is None else None
+        if api_key is None:
+            raise ApiError(
+                body="The client must be instantiated be either passing in api_key or setting LABEL_STUDIO_API_KEY"
+            )
+        self._client_wrapper = SyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            api_key=api_key,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            else httpx.Client(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
+            if follow_redirects is not None
+            else httpx.Client(timeout=_defaulted_timeout),
+            timeout=_defaulted_timeout,
         )
+        self.annotations = AnnotationsClient(client_wrapper=self._client_wrapper)
+        self.users = UsersClient(client_wrapper=self._client_wrapper)
+        self.actions = ActionsClient(client_wrapper=self._client_wrapper)
+        self.views = ViewsClient(client_wrapper=self._client_wrapper)
+        self.files = FilesClient(client_wrapper=self._client_wrapper)
+        self.projects = ProjectsClient(client_wrapper=self._client_wrapper)
+        self.ml = MlClient(client_wrapper=self._client_wrapper)
+        self.predictions = PredictionsClient(client_wrapper=self._client_wrapper)
+        self.tasks = TasksClient(client_wrapper=self._client_wrapper)
+        self.import_storage = ImportStorageClient(client_wrapper=self._client_wrapper)
+        self.export_storage = ExportStorageClient(client_wrapper=self._client_wrapper)
+        self.webhooks = WebhooksClient(client_wrapper=self._client_wrapper)
 
-        # set headers
-        self.headers = {'Authorization': f'Token {self.api_key}'}
-        if oidc_token:
-            self.headers.update({'Proxy-Authorization': f'Bearer {oidc_token}'})
-        if extra_headers:
-            self.headers.update(extra_headers)
-
-        # set cookies
-        self.cookies = cookies
-
-        # set versions from /version endpoint
-        self.versions = versions if versions else self.get_versions()
-        self.is_enterprise = 'label-studio-enterprise-backend' in self.versions
-
-    def get_versions(self):
-        """Call /version api and get all Label Studio component versions
-
-        Returns
-        -------
-        dict with Label Studio component names and their versions
-
-        """
-        self.versions = self.make_request('GET', '/api/version').json()
-        return self.versions
-
-    def get_api_key(self, credentials: ClientCredentials):
-        login_url = self.get_url("/user/login")
-        # Retrieve and set the CSRF token first
-        self.session.get(login_url)
-        csrf_token = self.session.cookies.get('csrftoken', None)
-        login_data = dict(**credentials.dict(), csrfmiddlewaretoken=csrf_token)
-        self.session.post(
-            login_url,
-            data=login_data,
-            headers=dict(Referer=self.url),
-            cookies=self.cookies,
-        ).raise_for_status()
-        api_key = (
-            self.session.get(self.get_url("/api/current-user/token"))
-            .json()
-            .get("token")
-        )
-        return api_key
-
-    def check_connection(self):
-        """Call Label Studio /health endpoint to check the connection to the server.
-
-        Returns
-        -------
-        dict
-            Status string like "UP"
-        """
-        response = self.make_request('GET', '/health')
-        return response.json()
-
-    def get_projects(self, **query_params):
-        """List all projects in Label Studio.
-
-        Returns
-        -------
-        list or `label_studio_sdk.project.Project` instances
-
-        """
-        return self.list_projects(**query_params)
-
-    def delete_project(self, project_id: int):
-        """Delete a project in Label Studio.
-
-        Returns
-        -------
-        dict
-            Status string
-        """
-        response = self.make_request('DELETE', f'/api/projects/{project_id}/')
-        return response
-
-    def delete_all_projects(self):
-        """Deletes all projects in Label Studio.
-
-        Returns
-        -------
-        List
-            List of (dict) status strings
-        """
-        responses = []
-        project_ids = [project.get_params()['id'] for project in self.list_projects()]
-        for project_id in project_ids:
-            response = self.delete_project(project_id)
-            responses.append(response)
-        return responses
-
-    def list_projects(self, **query_params):
-        """List all projects in Label Studio.
-
-        Returns
-        -------
-        list or `label_studio_sdk.project.Project` instances
-
-        """
-        from .project import Project
-
-        params = {'page_size': 10000000}
-        params.update(query_params)
-        response = self.make_request('GET', '/api/projects', params=params)
-        if response.status_code == 200:
-            projects = []
-            for data in response.json()['results']:
-                project = Project._create_from_id(
-                    client=self, project_id=data['id'], params=data
-                )
-                projects.append(project)
-                logger.debug(
-                    f'Project {project.id} "{project.get_params().get("title")}" is retrieved'
-                )
-            return projects
-
-    def create_project(self, **kwargs):
-        return self.start_project(**kwargs)
-
-    def start_project(self, **kwargs):
-        """Create a new project instance.
-
-        Parameters
-        ----------
-        kwargs:
-            Parameters for `project.start_project(**kwargs)`
-
-        Returns
-        -------
-        `label_studio_sdk.project.Project`
-
-        """
-        from .project import Project
-
-        project = Project(
-            url=self.url,
-            api_key=self.api_key,
-            session=self.session,
-            versions=self.versions,
-        )
-        project.start_project(**kwargs)
-        return project
-
-    def get_project(self, id):
-        """Return project SDK object by ID existed in Label Studio
-
-        Parameters
-        ----------
-        id: int
-            Project ID for the project you want to retrieve.
-
-        Returns
-        -------
-        `label_studio_sdk.project.Project`
-
-        """
-        from .project import Project
-
-        return Project.get_from_id(self, id)
-
-    def get_users(self):
-        """Return all users from the current organization account
-
-        Parameters
-        ----------
-
-        Returns
-        -------
-        list of `label_studio_sdk.users.User`
-
-        """
-        from .users import User
-
-        response = self.make_request('GET', '/api/users')
-        users = []
-        for user_data in response.json():
-            user_data['client'] = self
-            users.append(User(**user_data))
-        return users
-
-    def create_user(self, user, exist_ok=True):
-        """Create a new user
-
-        Parameters
-        ----------
-        user: User or dict
-            User instance, you can initialize it this way:
-            User(username='x', email='x@x.xx', first_name='X', last_name='Z')
-        exist_ok: bool
-            True by default, it won't print error if user exists and exist_ok=True
-
-        Returns
-        -------
-        `label_studio_sdk.users.User`
-            Created user
-
-        """
-        from .users import User
-
-        payload = (
-            {
-                'username': user.username if user.username else user.email,
-                'email': user.email,
-                'first_name': user.first_name,
-                'last_name': user.last_name,
-                'phone': user.phone,
-            }
-            if isinstance(user, User)
-            else user
-        )
 
-        response = self.make_request(
-            'POST', '/api/users', json=payload, raise_exceptions=False
-        )
-        user_data = response.json()
-        user_data['client'] = self
-
-        if response.status_code < 400:
-            return User(**user_data)
-        else:
-            if 'already exists' in response.text and exist_ok is True:
-                return None
-            logger.error('Create user error: ' + str(response.json()))
-            return None
-
-    def get_workspaces(self):
-        """Return all workspaces from the current organization account
-
-        Parameters
-        ----------
-
-        Returns
-        -------
-        list of `label_studio_sdk.workspaces.Workspace`
-
-        """
-        from .workspaces import Workspace
-
-        assert (
-            self.is_enterprise
-        ), "Workspaces are available only for Enterprise instance of Label Studio"
-
-        response = self.make_request('GET', '/api/workspaces')
-        workspaces = []
-        for workspace_data in response.json():
-            workspace_data['client'] = self
-            workspaces.append(Workspace(**workspace_data))
-        return workspaces
-
-    def get_session(self):
-        """Create a session with requests.Session()
-
-        Returns
-        -------
-        request.Session
-
-        """
-        session = requests.Session()
-        session.headers.update(HEADERS)
-        session.mount('http://', HTTPAdapter(max_retries=MAX_RETRIES))
-        session.mount('https://', HTTPAdapter(max_retries=MAX_RETRIES))
-        return session
-
-    def get_url(self, suffix):
-        """Get the URL of the Label Studio server
-
-        Returns
-        -------
-        String with the URL
-
-        """
-        return f'{self.url}/{suffix.lstrip("/")}'
-
-    def make_request(self, method, url, *args, **kwargs):
-        """Make a request with an API key to Label Studio instance
-
-        Parameters
-        ----------
-        method: str
-            HTTP method like POST, PATCH, GET, DELETE.
-        url: str
-            URL of the API endpoint that you want to make a request to.
-
-        args
-            session.request(*args)
-        kwargs
-            session.request(*kwargs)
-
-        Returns
-        -------
-        Response object for the relevant endpoint.
-
-        """
-        if 'timeout' not in kwargs:
-            kwargs['timeout'] = TIMEOUT
-
-        raise_exceptions = self.make_request_raise
-        if 'raise_exceptions' in kwargs:  # kwargs have higher priority
-            raise_exceptions = kwargs.pop('raise_exceptions')
-
-        logger.debug(f'{method}: {url} with args={args}, kwargs={kwargs}')
-        response = self.session.request(
-            method,
-            self.get_url(url),
-            headers=self.headers,
-            cookies=self.cookies,
-            *args,
-            **kwargs,
-        )
+class AsyncLabelStudio:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
 
-        if raise_exceptions:
-            if response.status_code >= 400:
-                self.log_response_error(response)
-                response.raise_for_status()
-
-        return response
-
-    def log_response_error(self, response):
-        try:
-            content = json.dumps(json.loads(response.content), indent=2)
-        except:
-            content = response.text
-
-        logger.error(
-            f'\n--------------------------------------------\n'
-            f'Request URL: {response.url}\n'
-            f'Response status code: {response.status_code}\n'
-            f'Response content:\n{content}\n\n'
-            f'SDK error traceback:'
-        )
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
 
-    def sync_storage(self, storage_type, storage_id):
-        """Synchronize Cloud Storage.
-
-        Parameters
-        ----------
-        storage_type: string
-            Specify the type of the storage container.
-        storage_id: int
-            Specify the storage ID of the storage container.
-
-        Returns
-        -------
-        dict:
-            containing the same fields as in the original storage request and:
-
-        id: int
-            Storage ID
-        type: str
-            Type of storage
-        created_at: str
-            Creation time
-        last_sync: str
-            Time last sync finished, can be empty.
-        last_sync_count: int
-            Number of tasks synced in the last sync
-        """
-
-        response = self.make_request(
-            "POST", f"/api/storages/{storage_type}/{str(storage_id)}/sync"
+    environment : LabelStudioEnvironment
+        The environment to use for requests from the client. from .environment import LabelStudioEnvironment
+
+
+
+        Defaults to LabelStudioEnvironment.DEFAULT
+
+
+
+    api_key : typing.Optional[str]
+    timeout : typing.Optional[float]
+        The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
+
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
+
+    httpx_client : typing.Optional[httpx.AsyncClient]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+
+    Examples
+    --------
+    from label_studio_sdk.client import AsyncLabelStudio
+
+    client = AsyncLabelStudio(
+        api_key="YOUR_API_KEY",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: LabelStudioEnvironment = LabelStudioEnvironment.DEFAULT,
+        api_key: typing.Optional[str] = os.getenv("LABEL_STUDIO_API_KEY"),
+        timeout: typing.Optional[float] = None,
+        follow_redirects: typing.Optional[bool] = True,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None
+    ):
+        _defaulted_timeout = timeout if timeout is not None else 60 if httpx_client is None else None
+        if api_key is None:
+            raise ApiError(
+                body="The client must be instantiated be either passing in api_key or setting LABEL_STUDIO_API_KEY"
+            )
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            api_key=api_key,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            else httpx.AsyncClient(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
+            if follow_redirects is not None
+            else httpx.AsyncClient(timeout=_defaulted_timeout),
+            timeout=_defaulted_timeout,
         )
-        return response.json()
+        self.annotations = AsyncAnnotationsClient(client_wrapper=self._client_wrapper)
+        self.users = AsyncUsersClient(client_wrapper=self._client_wrapper)
+        self.actions = AsyncActionsClient(client_wrapper=self._client_wrapper)
+        self.views = AsyncViewsClient(client_wrapper=self._client_wrapper)
+        self.files = AsyncFilesClient(client_wrapper=self._client_wrapper)
+        self.projects = AsyncProjectsClient(client_wrapper=self._client_wrapper)
+        self.ml = AsyncMlClient(client_wrapper=self._client_wrapper)
+        self.predictions = AsyncPredictionsClient(client_wrapper=self._client_wrapper)
+        self.tasks = AsyncTasksClient(client_wrapper=self._client_wrapper)
+        self.import_storage = AsyncImportStorageClient(client_wrapper=self._client_wrapper)
+        self.export_storage = AsyncExportStorageClient(client_wrapper=self._client_wrapper)
+        self.webhooks = AsyncWebhooksClient(client_wrapper=self._client_wrapper)
+
+
+def _get_base_url(*, base_url: typing.Optional[str] = None, environment: LabelStudioEnvironment) -> str:
+    if base_url is not None:
+        return base_url
+    elif environment is not None:
+        return environment.value
+    else:
+        raise Exception("Please pass in either base_url or environment to construct the client")

label_studio_sdk/converter/__init__.py

@@ -0,0 +1,7 @@
+# try is used here to import this file in setup.py and don't break the setup process
+try:
+    from .converter import Converter
+except ModuleNotFoundError as e:
+    print(e)
+
+__version__ = "0.0.59.dev"

label_studio_sdk/converter/audio.py

@@ -0,0 +1,56 @@
+import os
+import io
+import logging
+import json
+
+
+from .utils import get_audio_duration, ensure_dir, download, get_annotator
+
+
+logger = logging.getLogger(__name__)
+
+
+def convert_to_asr_json_manifest(
+    input_data, output_dir, data_key, project_dir, upload_dir, download_resources
+):
+    audio_dir_rel = "audio"
+    output_audio_dir = os.path.join(output_dir, audio_dir_rel)
+    ensure_dir(output_dir), ensure_dir(output_audio_dir)
+    output_file = os.path.join(output_dir, "manifest.json")
+    with io.open(output_file, mode="w") as fout:
+        for item in input_data:
+            audio_path = item["input"][data_key]
+            try:
+                audio_path = download(
+                    audio_path,
+                    output_audio_dir,
+                    project_dir=project_dir,
+                    upload_dir=upload_dir,
+                    return_relative_path=True,
+                    download_resources=download_resources,
+                )
+                duration = get_audio_duration(
+                    os.path.join(output_audio_dir, os.path.basename(audio_path))
+                )
+            except:
+                logger.info(
+                    "Unable to download {image_path} or get audio duration. The item {item} will be skipped".format(
+                        image_path=audio_path, item=item
+                    ),
+                    exc_info=True,
+                )
+                continue
+
+            for texts in iter(item["output"].values()):
+                if len(texts) > 0 and "text" in texts[0]:
+                    break
+
+            transcript = texts[0]["text"][0]
+            metadata = {
+                "audio_filepath": audio_path,
+                "duration": duration,
+                "text": transcript,
+                "annotator": get_annotator(item, default=""),
+            }
+            json.dump(metadata, fout)
+            fout.write("\n")