superannotate 4.6.0__tar.gz → 4.6.1.dev1__tar.gz

{superannotate-4.6.0/src/superannotate.egg-info → superannotate-4.6.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: superannotate
-Version: 4.6.0
+Version: 4.6.1.dev1
 Summary: Python SDK to SuperAnnotate platform
 Home-page: https://github.com/superannotateai/superannotate-python-sdk
 Author: SuperAnnotate AI

{superannotate-4.6.0 → superannotate-4.6.1.dev1}/src/superannotate/__init__.py

@@ -2,7 +2,7 @@ import logging
 import os
 import sys
 
-__version__ = "4.6.0"
+__version__ = "4.6.1dev1"
 
 
 os.environ.update({"sa_version": __version__})
@@ -15,10 +15,12 @@ from lib.core import PACKAGE_VERSION_UPGRADE
 from lib.core import PACKAGE_VERSION_INFO_MESSAGE
 from lib.core import PACKAGE_VERSION_MAJOR_UPGRADE
 from lib.core.exceptions import AppException
+from lib.core.exceptions import SAAuthError
 from lib.core.exceptions import FileChangedError
 from superannotate.lib.app.input_converters import export_annotation
 from superannotate.lib.app.input_converters import import_annotation
 from superannotate.lib.app.interface.sdk_interface import SAClient
+from superannotate.lib.app.interface.sdk_interface import SAORGClient
 from superannotate.lib.app.interface.sdk_interface import ItemContext
 
 SESSIONS = {}
@@ -27,10 +29,12 @@ SESSIONS = {}
 __all__ = [
     "__version__",
     "SAClient",
+    "SAORGClient",
     "ItemContext",
     # Utils
     "enums",
     "AppException",
+    "SAAuthError",
     "FileChangedError",
     "import_annotation",
     "export_annotation",

superannotate-4.6.1.dev1/src/superannotate/lib/app/interface/base_interface.py

@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+import functools
+import json
+import logging
+import os
+import platform
+import sys
+from collections.abc import Iterable
+from collections.abc import Sized
+from inspect import signature
+from pathlib import Path
+from types import FunctionType
+
+import lib.core as constants
+from lib.app.interface.types import validate_arguments
+from lib.core import CONFIG
+from lib.core import CREDENTIALS_NOT_FOUND_ERROR
+from lib.core import INVALID_CREDENTIALS_ERROR
+from lib.core import INVALID_TOKEN_ERROR
+from lib.core import setup_logging
+from lib.core.entities.base import ConfigEntity
+from lib.core.exceptions import AppException
+from lib.core.exceptions import SAAuthError
+from lib.infrastructure.controller import BaseController
+from lib.infrastructure.utils import extract_project_folder_inputs
+from lib.infrastructure.validators import wrap_error
+from mixpanel import Mixpanel
+from pydantic import ValidationError
+
+logger = logging.getLogger("sa")
+
+
+class BaseInterfaceFacade:
+    """Credential resolution, shared by every facade.
+
+    What a token has to resolve to is the facade's own business - named by its
+    CONTROLLER_CLASS rather than configured through this __init__: SAClient needs a
+    team, SAORGClient needs an organization key.
+    """
+
+    #: The controller class this facade drives. Named for the class, not the
+    #: instance: `self.controller` is the built one.
+    CONTROLLER_CLASS: type[BaseController]
+
+    @validate_arguments
+    def __init__(
+        self,
+        # Plain str, not TokenStr: the token's shape is checked by ConfigEntity in
+        # _resolve_config, so a malformed one is reported as the credential failure it
+        # is (SAAuthError) rather than as a generic bad argument.
+        token: str | None = None,
+        config_path: str | None = None,
+        team_id: int | None = None,
+        *,
+        config: dict | None = None,
+    ):
+        resolved = self._resolve_config(token, config_path, config)
+        if team_id is not None:
+            # An explicit team_id wins over whatever the config source provided.
+            resolved.TEAM_ID = team_id
+        setup_logging(resolved.LOGGING_LEVEL, resolved.LOGGING_PATH)
+        self.controller = self.CONTROLLER_CLASS(resolved)
+
+    @classmethod
+    def _resolve_config(
+        cls,
+        token: str | None,
+        config_path: str | None,
+        settings: dict | None = None,
+    ) -> ConfigEntity:
+        """Resolve credentials and settings.
+
+        Credentials come from the first source that carries them: the ``token``
+        argument, a config file, inline ``settings``, then the environment and the
+        default config files. Inline settings are applied over whatever that produced,
+        so a caller can configure a client - another backend, bigger chunks - without
+        writing a file for it.
+
+        Shared by every facade's ``__init__`` (``SAClient``, ``SAORGClient``).
+        """
+        settings = cls._validated_settings(settings)
+        try:
+            if token:
+                config = ConfigEntity(**{**settings, "SA_TOKEN": token})
+            elif config_path:
+                config = cls._merge_settings(
+                    cls._resolve_config_from_path(config_path), settings
+                )
+            elif "SA_TOKEN" in settings:
+                config = ConfigEntity(**settings)
+            else:
+                config = cls._merge_settings(
+                    cls._resolve_config_from_env_or_files(), settings
+                )
+        except ValidationError as e:
+            raise SAAuthError(wrap_error(e))
+        if not config:
+            raise SAAuthError(INVALID_CREDENTIALS_ERROR)
+        return config
+
+    @staticmethod
+    def _validated_settings(settings: dict | None) -> dict:
+        """Inline settings, with anything the SDK has no such setting for rejected.
+
+        ConfigEntity ignores what it does not recognise, so a mistyped key would
+        otherwise be dropped without a word - and a mistyped SA_TOKEN would send the
+        client off to authenticate as whatever the environment happens to hold.
+        """
+        if not settings:
+            return {}
+        known = set(ConfigEntity.model_fields) | {
+            field.alias
+            for field in ConfigEntity.model_fields.values()
+            if field.alias is not None
+        }
+        unknown = sorted(set(settings) - known)
+        if unknown:
+            raise AppException(
+                f"Unknown configuration: {', '.join(unknown)}. "
+                f"Available: {', '.join(sorted(known))}."
+            )
+        return dict(settings)
+
+    @staticmethod
+    def _merge_settings(config: ConfigEntity, settings: dict) -> ConfigEntity:
+        """``config`` with inline settings applied over it."""
+        if not settings:
+            return config
+        return ConfigEntity(**{**config.model_dump(by_alias=True), **settings})
+
+    @classmethod
+    def _resolve_config_from_path(cls, config_path: str) -> ConfigEntity:
+        """A config file the caller named explicitly (``.ini`` or ``.json``)."""
+        path = Path(config_path).expanduser()
+        if not path.is_file() or not os.access(path, os.R_OK):
+            raise AppException(f"SuperAnnotate config file {config_path} not found.")
+        if path.suffix == ".json":
+            return cls._retrieve_configs_from_json(path)
+        return cls._retrieve_configs_from_ini(path)
+
+    @classmethod
+    def _resolve_config_from_env_or_files(cls) -> ConfigEntity:
+        """No token or config path given: ``SA_TOKEN``, then the default config files."""
+        config = cls._retrieve_configs_from_env()
+        if config:
+            return config
+        if Path(constants.CONFIG_INI_FILE_LOCATION).exists():
+            return cls._retrieve_configs_from_ini(constants.CONFIG_INI_FILE_LOCATION)
+        if Path(constants.CONFIG_JSON_FILE_LOCATION).exists():
+            return cls._retrieve_configs_from_json(constants.CONFIG_JSON_FILE_LOCATION)
+        raise SAAuthError(CREDENTIALS_NOT_FOUND_ERROR)
+
+    @staticmethod
+    def _retrieve_configs_from_json(path: Path | str) -> ConfigEntity:
+        with open(path) as json_file:
+            json_data = json.load(json_file)
+        token = json_data["token"]
+        try:
+            config = ConfigEntity(SA_TOKEN=token)
+        except ValidationError:
+            raise SAAuthError(INVALID_TOKEN_ERROR)
+        host = json_data.get("main_endpoint")
+        verify_ssl = json_data.get("ssl_verify")
+        team_id = json_data.get("team_id")
+        if team_id is not None:
+            config.TEAM_ID = int(team_id)
+        if host:
+            config.API_URL = host
+        if verify_ssl:
+            config.VERIFY_SSL = verify_ssl
+        return config
+
+    @staticmethod
+    def _retrieve_configs_from_ini(path: Path | str) -> ConfigEntity:
+        import configparser
+
+        config_parser = configparser.ConfigParser()
+        config_parser.optionxform = str
+        config_parser.read(path)
+        config_data = {}
+        for key in config_parser["DEFAULT"]:
+            config_data[key.upper()] = config_parser["DEFAULT"][key]
+        return ConfigEntity(**config_data)
+
+    @staticmethod
+    def _retrieve_configs_from_env() -> ConfigEntity | None:
+        token = os.environ.get("SA_TOKEN")
+        if not token:
+            return None
+        config = ConfigEntity(**dict(os.environ))
+        host = os.environ.get("SA_URL")
+        verify_ssl = not os.environ.get("SA_SSL", "True").lower() in ("false", "f", "0")
+        if host:
+            config.API_URL = host
+        if verify_ssl:
+            config.VERIFY_SSL = verify_ssl
+        return config
+
+
+class Tracker:
+    def get_mp_instance(self, client, explicit_credentials: bool = False) -> Mixpanel:
+        # client may have no .controller yet (e.g. __init__ failed before setting one).
+        controller = getattr(client, "controller", None)
+        if controller is not None:
+            api_url = controller.config["SA_URL"]
+        elif explicit_credentials:
+            api_url = constants.BACKEND_URL
+        else:
+            api_url = os.environ.get("SA_URL", constants.BACKEND_URL)
+        if api_url == constants.BACKEND_URL:
+            mp_token = "ca95ed96f80e8ec3be791e2d3097cf51"
+        else:
+            mp_token = "e741d4863e7e05b1a45833d01865ef0d"
+        return Mixpanel(mp_token)
+
+    @staticmethod
+    def get_default_payload(team_name, user_email, auth_type) -> dict:
+        """Built fresh per event: a cached dict would be shared between callers, and
+        would freeze sa_version and SA_ENV as they were on the first tracked call.
+        """
+        return {
+            "SDK": True,
+            "Team": team_name,
+            "User Email": user_email,
+            "Auth Type": auth_type,
+            "Version": os.environ["sa_version"],
+            "Python version": platform.python_version(),
+            "Python interpreter type": platform.python_implementation(),
+            "Env": os.environ.get("SA_ENV", "N/A"),
+        }
+
+    def __init__(self, function):
+        self.function = function
+        functools.update_wrapper(self, function)
+
+    @staticmethod
+    def _metrics_disabled() -> bool:
+        """Whether the caller turned telemetry off.
+
+        Read per call: a Tracker is built while its class is being created, so a value
+        captured in __init__ would ignore anything set after ``import superannotate``.
+        """
+        return os.environ.get("SA_SKIP_METRICS", "False").lower() in ("true", "1", "t")
+
+    @staticmethod
+    def extract_arguments(function, *args, **kwargs) -> dict:
+        bound_arguments = signature(function).bind(*args, **kwargs)
+        bound_arguments.apply_defaults()
+        return dict(bound_arguments.arguments)
+
+    @staticmethod
+    def default_parser(function_name: str, kwargs: dict) -> tuple:
+        properties = {}
+        for key, value in kwargs.items():
+            if key == "self":
+                continue
+            if key == "token":
+                properties["sa_token"] = str(bool(value))
+            elif key == "config_path":
+                properties[key] = str(bool(value))
+            elif value is None:
+                properties[key] = value
+            elif key == "project":
+                properties.update(extract_project_folder_inputs(value))
+            elif isinstance(value, (str, int, float, bool)):
+                properties[key] = value
+            elif isinstance(value, dict):
+                properties[key] = list(value.keys())
+            elif isinstance(value, Sized):
+                properties[key] = len(value)
+            elif isinstance(value, Iterable):
+                properties[key] = "N/A"
+            else:
+                properties[key] = str(value)
+        return function_name, properties
+
+    def _track(
+        self,
+        user_id: str,
+        event_name: str,
+        data: dict,
+        *,
+        client,
+        explicit_credentials: bool = False,
+    ):
+        if "pytest" in sys.modules:
+            return
+        self.get_mp_instance(client, explicit_credentials).track(
+            user_id, event_name, data
+        )
+
+    @classmethod
+    def _failure_reason(
+        cls, function_name: str, success: bool, error: BaseException | None
+    ):
+        """The original error message, for the "Auth Failure" event property.
+
+        Scoped to __init__ auth/credential failures only.
+        """
+        if success or function_name != "__init__" or error is None:
+            return None
+        return str(error) if isinstance(error, SAAuthError) else None
+
+    def _track_method(
+        self,
+        instance,
+        args,
+        kwargs,
+        success: bool,
+        error: BaseException | None = None,
+    ):
+        # Before anything is gathered: building the payload reads controller.team_name,
+        # which fetches the team from the backend. A caller who turned metrics off
+        # should not pay for a request that is never sent.
+        if self._metrics_disabled():
+            return
+        try:
+            function_name = self.function.__name__ if self.function else ""
+            arguments = self.extract_arguments(self.function, *args, **kwargs)
+            event_name, properties = self.default_parser(function_name, arguments)
+
+            # instance is args[0] - the actual object the call was made on, captured
+            # locally per call (see __call__), not shared/mutable state. It has no
+            # .controller yet when __init__ fails before setting one.
+            controller = getattr(instance, "controller", None)
+            user_email = team_name = auth_type = None
+            if controller is not None:
+                user_email = controller.current_user.email
+                auth_type = controller.token_context.scope.label
+                team_name = controller.team_name
+            elif instance is None:
+                return
+
+            properties["Success"] = success
+            properties["Class"] = instance.__class__.__name__
+            if error:
+                properties["Failure Reason"] = self._failure_reason(
+                    function_name, success, error
+                )
+            default = self.get_default_payload(
+                team_name=team_name, user_email=user_email, auth_type=auth_type
+            )
+            self._track(
+                user_email or "",
+                event_name,
+                {**default, **properties, **CONFIG.get_current_session().data},
+                client=instance,
+                explicit_credentials=bool(
+                    arguments.get("token") or arguments.get("config_path")
+                ),
+            )
+        except BaseException:
+            logger.debug("Skipped telemetry for this call.", exc_info=True)
+
+    def __get__(self, obj, owner=None):
+        if obj is not None:
+            tmp = functools.partial(self.__call__, obj)
+            functools.update_wrapper(tmp, self.function)
+            return tmp
+        return self
+
+    def __call__(self, *args, **kwargs):
+        success = True
+        error = None
+        # The instance the call is bound to (set by __get__ via functools.partial) -
+        # captured locally here, per call, rather than read back from shared state.
+        instance = args[0] if args else None
+        try:
+            result = self.function(*args, **kwargs)
+        except BaseException as e:
+            # BaseException, not Exception: a KeyboardInterrupt used to skip this and
+            # leave the call reported as a success.
+            success = False
+            error = e
+            raise
+        else:
+            return result
+        finally:
+            self._track_method(
+                instance, args=args, kwargs=kwargs, success=success, error=error
+            )
+
+
+class TrackableMeta(type):
+    def __new__(mcs, name, bases, attrs):
+        for attr_name, attr_value in attrs.items():
+            if isinstance(
+                attr_value, FunctionType
+            ) and not attr_value.__name__.startswith("_"):
+                attrs[attr_name] = Tracker(validate_arguments(attr_value))
+        if "__init__" in attrs:
+            attrs["__init__"] = Tracker(validate_arguments(attrs["__init__"]))
+        tmp = super().__new__(mcs, name, bases, attrs)
+        return tmp

{superannotate-4.6.0 → superannotate-4.6.1.dev1}/src/superannotate/lib/app/interface/sdk_interface.py

@@ -32,7 +32,8 @@ from pydantic import ValidationError
 from pydantic import TypeAdapter
 
 import lib.core as constants
-from lib.infrastructure.controller import Controller
+from lib.infrastructure.controller import OrgController
+from lib.infrastructure.controller import TeamController
 from lib.app.helpers import get_annotation_paths
 from lib.app.helpers import get_name_url_duplicated_from_csv
 from lib.app.helpers import wrap_error as wrap_validation_errors
@@ -67,6 +68,8 @@ from lib.core.enums import CustomFieldEntityEnum
 from lib.core.enums import ProjectType
 from lib.core.enums import ClassTypeEnum
 from lib.core.exceptions import AppException
+from lib.core.exceptions import SAAuthError
+from lib.core import INVALID_TEAM_ID_ERROR
 from lib.core.types import PriorityScoreEntity
 from lib.infrastructure.annotation_adapter import BaseMultimodalAnnotationAdapter
 from lib.infrastructure.annotation_adapter import MultimodalSmallAnnotationAdapter
@@ -141,7 +144,7 @@ class ItemContext:
 
     def __init__(
         self,
-        controller: Controller,
+        controller: TeamController,
         project: ProjectEntity,
         folder: FolderEntity,
         item: BaseItemEntity,
@@ -301,10 +304,41 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
     :param config_path: path to config file
     :type config_path: path-like (str or Path)
 
+    :param team_id: the team to operate in. Required for an Organization API key, which
+        is not bound to a team; for any other key it is optional and, when given, must
+        match the team the key grants access to.
+    :type team_id: int
+
+    :param config: configuration applied on creation, instead of or on top of a config
+        file. Keys are a config file's keys - ``SA_TOKEN``, ``SA_URL``, ``SA_TEAM_ID``,
+        ``VERIFY_SSL``, ``LOGGING_LEVEL``, ``LOGGING_PATH``, ``ANNOTATION_CHUNK_SIZE``,
+        ``ITEM_CHUNK_SIZE``, ``MAX_THREAD_COUNT``, ``MAX_COROUTINE_COUNT`` - and an
+        unrecognised one is an error rather than silently ignored. Explicit ``token``
+        and ``team_id`` arguments win over the same keys here.
+    :type config: dict
+
+    Request Example:
+    ::
+
+        sa = SAClient(config={"SA_TOKEN": "<API key>", "SA_URL": "<host>"})
     """
 
-    def __init__(self, token: str | None = None, config_path: str | None = None):
-        super().__init__(token, config_path)
+    CONTROLLER_CLASS = TeamController
+
+    def __init__(
+        self,
+        token: str | None = None,
+        config_path: str | None = None,
+        team_id: int | None = None,
+        *,
+        config: dict | None = None,
+    ):
+        super().__init__(token, config_path, team_id=team_id, config=config)
+
+    @property
+    def team_id(self) -> int:
+        """The team this client operates in."""
+        return self.controller.team_id
 
     def get_project_by_id(self, project_id: int):
         """Returns the project metadata
@@ -6135,3 +6169,78 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
         logger.info(
             f"Successfully removed {success} users(s) out of the {len(users)} provided from the project {project.name}."
         )
+
+
+class SAORGClient(BaseInterfaceFacade, metaclass=TrackableMeta):
+    """Create SAORGClient instance to authorize SDK in an organization scope.
+    In case of no argument has been provided, SA_TOKEN environmental variable
+    will be checked or $HOME/.superannotate/config.ini will be used.
+
+    Requires an Organization API key.
+
+    :param token: Organization API key
+    :type token: str
+
+    :param config_path: path to config file
+    :type config_path: str
+
+    :param config: configuration applied on creation, instead of or on top of a config
+        file. Keys are a config file's keys - ``SA_TOKEN``, ``SA_URL``, ``SA_TEAM_ID``,
+        ``VERIFY_SSL``, ``LOGGING_LEVEL``, ``LOGGING_PATH``, ``ANNOTATION_CHUNK_SIZE``,
+        ``ITEM_CHUNK_SIZE``, ``MAX_THREAD_COUNT``, ``MAX_COROUTINE_COUNT`` - and an
+        unrecognised one is an error rather than silently ignored. Explicit ``token``
+        and ``team_id`` arguments win over the same keys here.
+    :type config: dict
+    """
+
+    CONTROLLER_CLASS = OrgController
+
+    def __init__(
+        self,
+        token: str | None = None,
+        config_path: str | None = None,
+        *,
+        config: dict | None = None,
+    ):
+        super().__init__(token, config_path, config=config)
+
+    def get_team_client(self, team_id: int) -> SAClient:
+        """Returns a normal SAClient backed by the organization token, with team context returned.
+
+        :param team_id: ID of the team to operate in.
+        :type team_id: int
+
+        :return: a team-scoped client exposing the full team-level SDK surface. The
+            team is fixed at construction; team_id is available as a read-only
+            property.
+        :rtype: SAClient
+
+        Request Example:
+        ::
+
+            team_client = org_client.get_team_client(team_id=12345)
+            team_client.list_projects(name__contains="My Project")
+        """
+        # The whole configuration this client was built with, re-pointed at one team.
+        # Passing the token alone would rebuild the config from defaults and lose
+        # API_URL with it, which means silently moving to production.
+        try:
+            return SAClient(config={**self.controller.config, "SA_TEAM_ID": team_id})
+        except SAAuthError:
+            raise AppException(INVALID_TEAM_ID_ERROR)
+
+    def list_teams(self) -> list[dict]:
+        """Returns the teams in the given organization. Must use Organization API Key for this function.
+
+        :return: the organization's teams; an empty list if it has none.
+        :rtype: list of dicts
+
+        Request Example:
+        ::
+
+            org_client.list_teams()
+        """
+        response = self.controller.list_teams()
+        return BaseSerializer.serialize_iterable(
+            response.data or [], by_alias=True, exclude_unset=True
+        )

{superannotate-4.6.0 → superannotate-4.6.1.dev1}/src/superannotate/lib/core/__init__.py

@@ -18,16 +18,29 @@ from lib.core.enums import UserRole
 
 CONFIG = Config()
 BACKEND_URL = "https://api.superannotate.com"
-HOME_PATH = expanduser("~/.superannotate")
+#: Where the SDK keeps its config. The display form keeps the "~": a message shown to
+#: a user should name the file, not spell out their home directory.
+HOME_DISPLAY_PATH = "~/.superannotate"
+HOME_PATH = expanduser(HOME_DISPLAY_PATH)
 
-CONFIG_JSON_PATH = f"{HOME_PATH}/config.json"
-CONFIG_INI_PATH = f"{HOME_PATH}/config.ini"
-CONFIG_JSON_FILE_LOCATION = CONFIG_JSON_PATH
-CONFIG_INI_FILE_LOCATION = CONFIG_INI_PATH
+CONFIG_JSON_FILE_LOCATION = f"{HOME_PATH}/config.json"
+CONFIG_INI_FILE_LOCATION = f"{HOME_PATH}/config.ini"
+CONFIG_INI_DISPLAY_PATH = f"{HOME_DISPLAY_PATH}/config.ini"
 
 LOG_FILE_LOCATION = f"{HOME_PATH}/logs"
 DEFAULT_LOGGING_LEVEL = "INFO"
 
+INVALID_TOKEN_ERROR = "Invalid token."
+INVALID_TEAM_ID_ERROR = "Invalid team id provided."
+INVALID_CREDENTIALS_ERROR = "Invalid credentials provided."
+INVALID_TEAM_CONTEXT = (
+    'Team context not provided. An Organization API key requires a "team_id".'
+)
+CREDENTIALS_NOT_FOUND_ERROR = (
+    "Credentials not found: SA_TOKEN environment variable is not set and "
+    f"config file '{CONFIG_INI_DISPLAY_PATH}' was not found."
+)
+
 
 def setup_logging(level=DEFAULT_LOGGING_LEVEL, file_path=LOG_FILE_LOCATION):
     logger = logging.getLogger("sa")

{superannotate-4.6.0 → superannotate-4.6.1.dev1}/src/superannotate/lib/core/entities/__init__.py

@@ -2,6 +2,8 @@ from lib.core.entities.base import BaseItemEntity
 from lib.core.entities.base import ConfigEntity
 from lib.core.entities.base import SubSetEntity
 from lib.core.entities.classes import AnnotationClassEntity
+from lib.core.entities.context import TokenContext
+from lib.core.entities.context import TokenScope
 from lib.core.entities.folder import FolderEntity
 from lib.core.entities.integrations import IntegrationEntity
 from lib.core.entities.items import CategoryEntity
@@ -16,6 +18,7 @@ from lib.core.entities.multimodal_form import FormModel
 from lib.core.entities.multimodal_form import generate_classes_from_form
 from lib.core.entities.project import AttachmentEntity
 from lib.core.entities.project import CustomFieldEntity
+from lib.core.entities.project import OrgTeamEntity
 from lib.core.entities.project import ProjectEntity
 from lib.core.entities.project import SettingEntity
 from lib.core.entities.project import StepEntity
@@ -30,6 +33,8 @@ from lib.core.entities.work_managament import WMProjectUserEntity
 __all__ = [
     # base
     "ConfigEntity",
+    "TokenContext",
+    "TokenScope",
     "SettingEntity",
     "SubSetEntity",
     "CustomFieldEntity",
@@ -49,12 +54,12 @@ __all__ = [
     "WorkflowEntity",
     "CategoryEntity",
     "WMProjectUserEntity",
-    "ConfigEntity",
     "StepEntity",
     "FolderEntity",
     "S3FileEntity",
     "AnnotationClassEntity",
     "TeamEntity",
+    "OrgTeamEntity",
     "UserEntity",
     "IntegrationEntity",
     "PROJECT_ITEM_ENTITY_MAP",