ibm-watsonx-orchestrate 1.0.0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/config.py

@@ -0,0 +1,226 @@
+import os
+import logging
+import yaml
+from copy import deepcopy
+
+from ibm_watsonx_orchestrate.cli.commands.tools.types import RegistryType
+from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
+from enum import Enum
+
+# Section Headers
+AUTH_SECTION_HEADER = "auth"
+CONTEXT_SECTION_HEADER = "context"
+ENVIRONMENTS_SECTION_HEADER = "environments"
+PYTHON_REGISTRY_HEADER = "python_registry"
+
+# Option Names
+AUTH_MCSP_API_KEY_OPT = "wxo_mcsp_api_key"
+AUTH_MCSP_TOKEN_OPT = "wxo_mcsp_token"
+AUTH_MCSP_TOKEN_EXPIRY_OPT = "wxo_mcsp_token_expiry"
+CONTEXT_ACTIVE_ENV_OPT = "active_environment"
+PYTHON_REGISTRY_TYPE_OPT = "type"
+PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT = "test_package_version_override"
+ENV_WXO_URL_OPT = "wxo_url"
+ENV_IAM_URL_OPT = "iam_url"
+PROTECTED_ENV_NAME = "local"
+ENV_AUTH_TYPE = "auth_type"
+
+DEFAULT_LOCAL_SERVICE_URL = "http://localhost:4321"
+CHAT_UI_PORT = "3000"
+
+DEFAULT_CONFIG_FILE_FOLDER = f"{os.path.expanduser('~')}/.config/orchestrate"
+DEFAULT_CONFIG_FILE = "config.yaml"
+DEFAULT_CONFIG_FILE_CONTENT = {
+    CONTEXT_SECTION_HEADER: {CONTEXT_ACTIVE_ENV_OPT: None},
+    PYTHON_REGISTRY_HEADER: {
+        PYTHON_REGISTRY_TYPE_OPT: str(RegistryType.TESTPYPI),
+        PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT: None
+    },
+    ENVIRONMENTS_SECTION_HEADER: {
+        PROTECTED_ENV_NAME: {
+            ENV_WXO_URL_OPT: DEFAULT_LOCAL_SERVICE_URL
+        }
+    }
+}
+
+AUTH_CONFIG_FILE_FOLDER = f"{os.path.expanduser('~')}/.cache/orchestrate"
+AUTH_CONFIG_FILE = "credentials.yaml"
+AUTH_CONFIG_FILE_CONTENT = {
+    AUTH_SECTION_HEADER: {
+        PROTECTED_ENV_NAME: None
+    }
+}
+
+logger = logging.getLogger(__name__)
+
+
+def merge_configs(source: dict, destination: dict) -> dict:
+    if source:
+        merged_object = deepcopy(source)
+    else:
+        merged_object = {}
+
+    for key, value in destination.items():
+        if isinstance(value, dict):
+            node = merged_object.setdefault(key, {})
+            merged_object[key] = merge_configs(node, value)
+        else:
+            merged_object[key] = value
+    return merged_object
+
+
+def _check_if_default_config_file(folder, file):
+    return folder == DEFAULT_CONFIG_FILE_FOLDER and file == DEFAULT_CONFIG_FILE
+
+
+def _check_if_auth_config_file(folder, file):
+    return folder == AUTH_CONFIG_FILE_FOLDER and file == AUTH_CONFIG_FILE
+
+
+def clear_protected_env_credentials_token():
+    auth_cfg = Config(config_file_folder=AUTH_CONFIG_FILE_FOLDER, config_file=AUTH_CONFIG_FILE)
+    auth_cfg.delete(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT)
+
+
+class ConfigFileTypes(str, Enum):
+    AUTH = 'auth'
+    CONFIG = 'config'
+
+
+class Config:
+
+    def __init__(
+            self,
+            config_file_folder: str = DEFAULT_CONFIG_FILE_FOLDER,
+            config_file: str = DEFAULT_CONFIG_FILE,
+    ):
+        self.config_file_folder = config_file_folder
+        self.config_file = config_file
+        self.config_file_path = os.path.join(self.config_file_folder, self.config_file)
+        self.file_type = None
+
+        if _check_if_default_config_file(folder=self.config_file_folder, file=self.config_file):
+            self.file_type = ConfigFileTypes.CONFIG
+        elif _check_if_auth_config_file(folder=self.config_file_folder, file=self.config_file):
+            self.file_type = ConfigFileTypes.AUTH
+
+        # Check if config file already exists
+        if not os.path.exists(self.config_file_path):
+            self.create_config_file()
+
+        # Check if file has defaults
+        with open(self.config_file_path, 'r') as conf_file:
+            config_data = yaml_safe_load(conf_file) or {}
+            if self.file_type == ConfigFileTypes.CONFIG:
+                if not config_data.get(ENVIRONMENTS_SECTION_HEADER, {}).get(PROTECTED_ENV_NAME, False):
+                    logger.debug("Setting default config data")
+                    self.create_defaults(DEFAULT_CONFIG_FILE_CONTENT)
+
+                if not config_data.get(PYTHON_REGISTRY_HEADER, {}).get(PYTHON_REGISTRY_TYPE_OPT, False):
+                    self.create_defaults({
+                        PYTHON_REGISTRY_HEADER: DEFAULT_CONFIG_FILE_CONTENT.get(PYTHON_REGISTRY_HEADER, {})
+                    })
+
+            elif self.file_type == ConfigFileTypes.AUTH:
+                if PROTECTED_ENV_NAME not in set(config_data.get(AUTH_SECTION_HEADER, {}).keys()):
+                    logger.debug("Setting default credentials data")
+                    self.create_defaults(AUTH_CONFIG_FILE_CONTENT)
+
+    def create_config_file(self) -> None:
+        logger.info(f'Creating config file at location "{self.config_file_path}"')
+
+        os.makedirs(os.path.dirname(self.config_file_path), exist_ok=True)
+        open(self.config_file_path, 'a').close()
+
+    def create_defaults(self, default_content):
+        self.save(default_content)
+
+    def get_active_env(self):
+        return self.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
+
+    def get_active_env_config(self, option):
+        return self.read(ENVIRONMENTS_SECTION_HEADER, self.get_active_env()).get(option)
+
+    def read(self, section: str, option: str) -> any:
+        try:
+            with open(self.config_file_path, "r") as conf_file:
+                config_data = yaml.load(conf_file, Loader=yaml.SafeLoader)
+                if config_data is None:
+                    return None
+                return config_data[section][option]
+        except KeyError:
+            return None
+
+    def write(self, section: str, option: str, value: any) -> None:
+        obj = {section:
+                   {option: value}
+               }
+        self.save(obj)
+
+    def save(self, object: dict) -> None:
+        config_data = {}
+        try:
+            with open(self.config_file_path, 'r') as conf_file:
+                config_data = yaml_safe_load(conf_file) or {}
+        except FileNotFoundError:
+            pass
+
+        config_data = merge_configs(config_data, object)
+
+        with open(self.config_file_path, 'w') as conf_file:
+            yaml.dump(config_data, conf_file, allow_unicode=True)
+
+    def get(self, *args):
+        """
+        Accesses an item of arbitrary depth from the config file.
+        Takes an arbitrary number of args. Uses the args in order
+        as keys to access deeper sections of the config and then returning the last specified key.
+        """
+
+        config_data = {}
+        try:
+            with open(self.config_file_path, 'r') as conf_file:
+                config_data = yaml_safe_load(conf_file) or {}
+        except FileNotFoundError:
+            pass
+
+        if len(args) < 1:
+            return config_data
+
+        try:
+            nested_dict = config_data
+            for key in args[:-1]:
+                nested_dict = nested_dict[key]
+
+            return nested_dict[args[-1]]
+        except KeyError as e:
+            raise KeyError(f"Failed to get data from config. Key {e} not in {list(nested_dict.keys())}")
+
+    def delete(self, *args) -> None:
+        """
+        Deletes an item of arbitrary depth from the config file.
+        Takes an arbitrary number of args. Uses the args in order
+        as keys to access deeper sections of the config and then deleting the last specified key.
+        """
+        if len(args) < 1:
+            raise ValueError("Config.delete() requires at least one positional argument")
+
+        config_data = {}
+        try:
+            with open(self.config_file_path, 'r') as conf_file:
+                config_data = yaml_safe_load(conf_file) or {}
+        except FileNotFoundError:
+            pass
+
+        try:
+            deletion_data = deepcopy(config_data)
+            nested_dict = deletion_data
+            for key in args[:-1]:
+                nested_dict = nested_dict[key]
+
+            del (nested_dict[args[-1]])
+        except KeyError as e:
+            raise KeyError(f"Failed to delete from config. Key {e} not in {list(nested_dict.keys())}")
+
+        with open(self.config_file_path, 'w') as conf_file:
+            yaml.dump(deletion_data, conf_file, allow_unicode=True)

ibm_watsonx_orchestrate/cli/main.py

@@ -0,0 +1,32 @@
+import typer
+
+from ibm_watsonx_orchestrate.cli.commands.connections.connections_command import connections_app
+from ibm_watsonx_orchestrate.cli.commands.login.login_command import login_app
+from ibm_watsonx_orchestrate.cli.commands.settings.settings_command import settings_app
+from ibm_watsonx_orchestrate.cli.commands.tools.tools_command import tools_app
+from ibm_watsonx_orchestrate.cli.commands.agents.agents_command import agents_app
+from ibm_watsonx_orchestrate.cli.commands.server.server_command import server_app
+from ibm_watsonx_orchestrate.cli.commands.chat.chat_command import chat_app
+from ibm_watsonx_orchestrate.cli.commands.models.models_command import models_app
+from ibm_watsonx_orchestrate.cli.commands.environment.environment_command import environment_app
+from ibm_watsonx_orchestrate.cli.commands.channels.channels_command import channel_app
+from ibm_watsonx_orchestrate.cli.commands.knowledge_bases.knowledge_bases_command import knowledge_bases_app
+
+app = typer.Typer(
+    no_args_is_help=True,
+    pretty_exceptions_enable=False
+)
+app.add_typer(login_app)
+app.add_typer(environment_app, name="env", help='Add, remove, or select the activate env other commands will interact with (either your local server or a production instance)')
+app.add_typer(tools_app, name="tools", help='Interact with the tools in your active env')
+app.add_typer(agents_app, name="agents", help='Interact with the agents in your active env')
+app.add_typer(connections_app, name="connections", help='Interact with the agents in your active env')
+app.add_typer(server_app, name="server", help='Manipulate your local wxo lite server [requires docker pull credentials]')
+app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local list wxo lite server [requires docker pull credentials]')
+app.add_typer(models_app, name="models", help='List the available large language models (llms) that can be used in your agent definitions')
+app.add_typer(settings_app, name="settings", help='Configure the settings for your active env')
+app.add_typer(channel_app, name="channels")
+app.add_typer(knowledge_bases_app, name="knowledge-bases")
+
+if __name__ == "__main__":
+    app()

ibm_watsonx_orchestrate/client/agents/agent_client.py

@@ -0,0 +1,46 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from typing_extensions import List
+from ibm_watsonx_orchestrate.client.utils import is_local_dev
+
+
+class AgentClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for Native Agent endpoint
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.base_endpoint = "/orchestrate/agents" if is_local_dev(self.base_url) else "/agents"
+
+
+    def create(self, payload: dict) -> dict:
+        return self._post(self.base_endpoint, data=payload)
+
+    def get(self) -> dict:
+        return self._get(self.base_endpoint)
+
+    def update(self, agent_id: str, data: dict) -> dict:
+        return self._patch(f"{self.base_endpoint}/{agent_id}", data=data)
+
+    def delete(self, agent_id: str) -> dict:
+        return self._delete(f"{self.base_endpoint}/{agent_id}")
+    
+    def get_draft_by_name(self, agent_name: str) -> List[dict]:
+        return self.get_drafts_by_names([agent_name])
+
+    def get_drafts_by_names(self, agent_names: List[str]) -> List[dict]:
+        formatted_agent_names = [f"names={x}" for x  in agent_names]
+        return self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_names)}")
+    
+    def get_draft_by_id(self, agent_id: str) -> List[dict]:
+        if agent_id is None:
+            return ""
+        else:
+            try:
+                agent = self._get(f"{self.base_endpoint}/{agent_id}")
+                return agent
+            except ClientAPIException as e:
+                if e.response.status_code == 404 and "not found with the given name" in e.response.text:
+                    return ""
+                raise(e)
+
+    

ibm_watsonx_orchestrate/client/agents/assistant_agent_client.py

@@ -0,0 +1,38 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from typing_extensions import List
+
+
+class AssistantAgentClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for Assistant Agent endpoint
+    """
+    def create(self, payload: dict) -> dict:
+        return self._post("/assistants/watsonx", data=payload)
+
+    def get(self) -> dict:
+        return self._get("/assistants/watsonx")
+
+    def update(self, agent_id: str, data: dict) -> dict:
+        return self._patch(f"/assistants/watsonx/{agent_id}", data=data)
+
+    def delete(self, agent_id: str) -> dict:
+        return self._delete(f"/assistants/watsonx/{agent_id}")
+    
+    def get_draft_by_name(self, agent_name: str) -> List[dict]:
+        return self.get_drafts_by_names([agent_name])
+
+    def get_drafts_by_names(self, agent_names: List[str]) -> List[dict]:
+        formatted_agent_names = [f"names={x}" for x  in agent_names]
+        return self._get(f"/assistants/watsonx?{'&'.join(formatted_agent_names)}")
+    
+    def get_draft_by_id(self, agent_id: str) -> List[dict]:
+        if agent_id is None:
+            return ""
+        else:
+            try:
+                agent = self._get(f"/assistants/watsonx/{agent_id}")
+                return agent
+            except ClientAPIException as e:
+                if e.response.status_code == 404 and "Assistant not found" in e.response.text:
+                    return ""
+                raise(e)

ibm_watsonx_orchestrate/client/agents/external_agent_client.py

@@ -0,0 +1,38 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from typing_extensions import List
+
+class ExternalAgentClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for External Agent endpoint
+    """
+
+    def create(self, payload: dict) -> dict:
+        return self._post("/agents/external-chat", data=payload)
+
+    def get(self) -> dict:
+        return self._get("/agents/external-chat")
+
+    def update(self, agent_id: str, data: dict) -> dict:
+        return self._patch(f"/agents/external-chat/{agent_id}", data=data)
+
+    def delete(self, agent_id: str) -> dict:
+        return self._delete(f"/agents/external-chat/{agent_id}")
+    
+    def get_draft_by_name(self, agent_name: str) -> List[dict]:
+        return self.get_drafts_by_names([agent_name])
+
+    def get_drafts_by_names(self, agent_names: List[str]) -> List[dict]:
+        formatted_agent_names = [f"names={x}" for x  in agent_names]
+        return self._get(f"/agents/external-chat?{'&'.join(formatted_agent_names)}&include_hidden=true")
+    
+    def get_draft_by_id(self, agent_id: str) -> List[dict]:
+        if agent_id is None:
+            return ""
+        else:
+            try:
+                agent = self._get(f"/agents/external-chat/{agent_id}")
+                return agent
+            except ClientAPIException as e:
+                if e.response.status_code == 404 and "not found with the given name" in e.response.text:
+                    return ""
+                raise(e)

ibm_watsonx_orchestrate/client/analytics/llm/analytics_llm_client.py

@@ -0,0 +1,50 @@
+import logging
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient
+
+logger = logging.getLogger(__name__)
+
+
+class AnalyticsLLMUpsertToolIdentifier(str, Enum):
+    LANGFUSE = 'langfuse'
+
+
+class AnalyticsLLMResponse(BaseModel):
+    status: str
+
+
+class AnalyticsLLMConfig(BaseModel):
+    model_config = ConfigDict(extra='allow')
+    project_id: str = 'default'
+    host_uri: str
+    tool_identifier: AnalyticsLLMUpsertToolIdentifier = AnalyticsLLMUpsertToolIdentifier.LANGFUSE
+    mask_pii: bool = False
+    config_json: dict
+
+class AnalyticsLLMClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for Analytics LLM Endpoint
+    """
+    def create(self):
+        raise RuntimeError('unimplemented')
+
+    def get(self, project_id: Optional[str] = None) -> AnalyticsLLMConfig:
+        params = {}
+        if project_id:
+            params['project_id'] = project_id
+
+        response = self._get(f"/analytics/llm", params=params)
+
+        return AnalyticsLLMConfig.model_validate(response)
+
+    def update(self, request: AnalyticsLLMConfig) -> AnalyticsLLMResponse:
+        response = self._put('/analytics/llm', request.model_dump())
+        return AnalyticsLLMResponse.model_validate(response)
+
+    def delete(self) -> AnalyticsLLMResponse:
+        response = self._delete('/analytics/llm')
+        return AnalyticsLLMResponse.model_validate(response)

ibm_watsonx_orchestrate/client/base_api_client.py

@@ -0,0 +1,113 @@
+import json
+
+import requests
+from abc import ABC, abstractmethod
+from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator
+
+
+class ClientAPIException(requests.HTTPError):
+
+    def __init__(self, *args, request=..., response=...):
+        super().__init__(*args, request=request, response=response)
+
+    def __repr__(self):
+        status = self.response.status_code
+        resp = self.response.text
+        try:
+            resp = json.dumps(resp).get('detail', None)
+        except:
+            pass
+        return f"ClientAPIException(status_code={status}, message={resp})"
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class BaseAPIClient:
+
+    def __init__(self, base_url: str, api_key: str = None, is_local: bool = False, authenticator: MCSPAuthenticator = None):
+        self.base_url = base_url.rstrip("/")  # remove trailing slash
+        self.api_key = api_key
+        self.authenticator = authenticator
+
+        # api path can be re-written by api proxy when deployed
+        # TO-DO: re-visit this when shipping to production
+        self.is_local = is_local
+
+        if not self.is_local:
+            self.base_url = f"{self.base_url}/v1/orchestrate"
+
+    def _get_headers(self) -> dict:
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        elif self.authenticator:
+            headers["Authorization"] = f"Bearer {self.authenticator.token_manager.get_token()}"
+        return headers
+
+    def _get(self, path: str, params: dict = None, data=None) -> dict:
+
+        url = f"{self.base_url}{path}"
+        response = requests.get(url, headers=self._get_headers(), params=params, data=data)
+        self._check_response(response)
+        return response.json()
+
+    def _post(self, path: str, data: dict = None, files: dict = None) -> dict:
+        url = f"{self.base_url}{path}"
+        response = requests.post(url, headers=self._get_headers(), json=data, files=files)
+        self._check_response(response)
+        return response.json() if response.text else {}
+    
+    def _post_form_data(self, path: str, data: dict = None, files: dict = None) -> dict:
+        url = f"{self.base_url}{path}"
+        # Use data argument instead of json so data is encoded as application/x-www-form-urlencoded
+        response = requests.post(url, headers=self._get_headers(), data=data, files=files)
+        self._check_response(response)
+        return response.json() if response.text else {}
+
+    def _put(self, path: str, data: dict = None) -> dict:
+
+        url = f"{self.base_url}{path}"
+        response = requests.put(url, headers=self._get_headers(), json=data)
+        self._check_response(response)
+        return response.json() if response.text else {}
+
+    def _patch(self, path: str, data: dict = None) -> dict:
+        url = f"{self.base_url}{path}"
+        response = requests.patch(url, headers=self._get_headers(), json=data)
+        self._check_response(response)
+        return response.json() if response.text else {}
+    
+    def _patch_form_data(self, path: str, data: dict = None, files = None) -> dict:
+        url = f"{self.base_url}{path}"
+        response = requests.patch(url, headers=self._get_headers(), data=data, files=files)
+        self._check_response(response)
+        return response.json() if response.text else {}
+
+    def _delete(self, path: str, data=None) -> dict:
+        url = f"{self.base_url}{path}"
+        response = requests.delete(url, headers=self._get_headers(), json=data)
+        self._check_response(response)
+        return response.json() if response.text else {}
+
+    def _check_response(self, response: requests.Response):
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as e:
+            raise ClientAPIException(request=e.request, response=e.response)
+
+    @abstractmethod
+    def create(self, *args, **kwargs):
+        raise NotImplementedError("create method of the client must be implemented")
+
+    @abstractmethod
+    def delete(self, *args, **kwargs):
+        raise NotImplementedError("delete method of the client must be implemented")
+
+    @abstractmethod
+    def update(self, *args, **kwargs):
+        raise NotImplementedError("update method of the client must be implemented")
+
+    @abstractmethod
+    def get(self, *args, **kwargs):
+        raise NotImplementedError("get method of the client must be implemented")

ibm_watsonx_orchestrate/client/base_service_instance.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+
+class BaseServiceInstance(ABC):
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def _create_token(self) -> str:
+        raise NotImplementedError("_create_token must be implemented")

ibm_watsonx_orchestrate/client/client.py

@@ -0,0 +1,71 @@
+import copy
+import logging
+from typing import Any, cast
+
+from ibm_watsonx_orchestrate.client.client_errors import NoCredentialsProvided, ClientError
+from ibm_watsonx_orchestrate.client.credentials import Credentials
+from ibm_watsonx_orchestrate.client.service_instance import ServiceInstance
+from ibm_watsonx_orchestrate.client.local_service_instance import LocalServiceInstance
+from ibm_watsonx_orchestrate.client.utils import is_local_dev
+
+
+class Client:
+    """The main class of ibm_watsonx_orchestrate. The very heart of the module. Client contains objects that manage the service reasources.
+
+    To explore how to use Client, refer to:
+     - :ref:`Setup<setup>` - to check correct initialization of Client for a specific environment.
+     - :ref:`Core<core>` - to explore core properties of an Client object.
+
+    :param url: URL of the service
+    :type url: str
+
+    :param credentials: credentials used to connect with the service
+    :type credentials: Credentials
+
+    **Example**
+
+    .. code-block:: python
+
+        from ibm_watsonx_orchestrate import Client, Credentials
+
+        credentials = Credentials(
+            url = "<url>",
+            api_key = "<api_key>"
+        )
+
+        client = Client(credentials, space_id="<space_id>")
+
+        client.models.list()
+        client.deployments.get_details()
+
+        client.set.default_project("<project_id>")
+
+        ...
+
+    """
+
+    def __init__(
+        self,
+        credentials: Credentials | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if credentials is None:
+            raise TypeError("Client() missing 1 required argument: 'credentials'")
+
+        self.credentials = copy.deepcopy(credentials)
+
+        self.token: str | None = None
+        if credentials is None:
+            raise NoCredentialsProvided()
+        if self.credentials.url is None:
+            raise ClientError("No URL Provided")
+        if not self.credentials.url.startswith("https://"):
+            if not is_local_dev(self.credentials.url):
+                raise ClientError("Invalid URL Format. URL must start stil 'https://'")
+        if self.credentials.url[-1] == "/":
+            self.credentials.url = self.credentials.url.rstrip("/")
+
+        if not is_local_dev(self.credentials.url):
+            self.service_instance: ServiceInstance = ServiceInstance(self)
+        else:
+            self.service_instance: LocalServiceInstance = LocalServiceInstance(self)