lightning-sdk 0.1.2__py3-none-any.whl → 0.1.46__py3-none-any.whl

lightning_sdk/cli/upload.py

@@ -1,38 +1,37 @@
 import concurrent.futures
 import json
 import os
+from pathlib import Path
 from typing import Dict, List, Optional
 
 from simple_term_menu import TerminalMenu
 from tqdm import tqdm
 
-from lightning_sdk.api import OrgApi, TeamspaceApi
 from lightning_sdk.api.utils import _get_cloud_url
 from lightning_sdk.cli.exceptions import StudioCliError
+from lightning_sdk.cli.studios_menu import _StudiosMenu
+from lightning_sdk.models import upload_model
 from lightning_sdk.studio import Studio
-from lightning_sdk.user import User
-from lightning_sdk.utils import _get_authed_user, skip_studio_init
+from lightning_sdk.utils.resolve import _get_authed_user, skip_studio_init
 
 
-class _Uploads:
+class _Uploads(_StudiosMenu):
+    """Upload files and folders to Lightning AI."""
+
     _studio_upload_status_path = "~/.lightning/studios/uploads"
 
-    def upload(self, path: str, studio: Optional[str] = None, remote_path: Optional[str] = None) -> None:
-        """Upload a file or folder to a studio.
+    def model(self, name: str, path: str = ".", cloud_account: Optional[str] = None) -> None:
+        """Upload a Model.
 
         Args:
-          path: The path to the file or directory you want to upload
-          studio: The name of the studio to upload to. Will show a menu for selection if not specified.
-            If provided, should be in the form of <TEAMSPACE-NAME>/<STUDIO-NAME>
-          remote_path: The path where the uploaded file should appear on your Studio.
-            Has to be within your Studio's home directory and will be relative to that.
-            If not specified, will use the file or directory name of the path you want to upload
-            and place it in your home directory.
-
+          name: The name of the Model you want to upload.
+            This should have the format <ORGANIZATION-NAME>/<TEAMSPACE-NAME>/<MODEL-NAME>.
+          path: The path to the file or directory you want to upload. Defaults to the current directory.
+          cloud_account: The name of the cloud account to store the Model in.
         """
-        if remote_path is None:
-            remote_path = os.path.basename(path)
+        upload_model(name, path, cloud_account=cloud_account)
 
+    def _resolve_studio(self, studio: Optional[str]) -> Studio:
         user = _get_authed_user()
         possible_studios = self._get_possible_studios(user)
 
@@ -52,19 +51,38 @@ class _Uploads:
                 "Please contact Lightning AI directly to resolve this issue."
             ) from e
 
-        print(f"Uploading to {selected_studio['teamspace']}/{selected_studio['name']}")
-        pairs = {}
-        if os.path.isdir(path):
-            for root, _, files in os.walk(path):
-                rel_root = os.path.relpath(root, path)
-                for f in files:
-                    pairs[os.path.join(root, f)] = os.path.join(remote_path, rel_root, f)
+        with skip_studio_init():
+            return Studio(**selected_studio)
 
-        else:
-            pairs[path] = remote_path
+    def folder(self, path: str, studio: Optional[str] = None, remote_path: Optional[str] = None) -> None:
+        """Upload a file or folder to a Studio.
 
-        with skip_studio_init():
-            selected_studio = Studio(**selected_studio)
+        Args:
+          path: The path to the file or directory you want to upload
+          studio: The name of the studio to upload to. Will show a menu for selection if not specified.
+            If provided, should be in the form of <TEAMSPACE-NAME>/<STUDIO-NAME>
+          remote_path: The path where the uploaded file should appear on your Studio.
+            Has to be within your Studio's home directory and will be relative to that.
+            If not specified, will use the file or directory name of the path you want to upload
+            and place it in your home directory.
+        """
+        if remote_path is None:
+            remote_path = os.path.basename(path)
+
+        if not Path(path).exists():
+            raise FileNotFoundError(f"The provided path does not exist: {path}.")
+        if not Path(path).is_dir():
+            raise StudioCliError(f"The provided path is not a folder: {path}. Use `lightning upload file` instead.")
+
+        selected_studio = self._resolve_studio(studio)
+
+        print(f"Uploading to {selected_studio.teamspace.name}/{selected_studio.name}")
+
+        pairs = {}
+        for root, _, files in os.walk(path):
+            rel_root = os.path.relpath(root, path)
+            for f in files:
+                pairs[os.path.join(root, f)] = os.path.join(remote_path, rel_root, f)
 
         upload_state = self._resolve_previous_upload_state(selected_studio, remote_path, pairs)
 
@@ -91,19 +109,42 @@ class _Uploads:
         )
         print(f"See your files at {studio_url}")
 
-    def _get_studio_from_interactive_menu(self, possible_studios: List[Dict[str, str]]) -> Dict[str, str]:
-        terminal_menu = self._prepare_terminal_menu_all_studios(possible_studios)
-        terminal_menu.show()
-        return possible_studios[terminal_menu.chosen_menu_index]
+    def file(self, path: str, studio: Optional[str] = None, remote_path: Optional[str] = None) -> None:
+        """Upload a file to a Studio.
+
+        Args:
+          path: The path to the file you want to upload
+          studio: The name of the studio to upload to. Will show a menu for selection if not specified.
+            If provided, should be in the form of <TEAMSPACE-NAME>/<STUDIO-NAME>
+          remote_path: The path where the uploaded file should appear on your Studio.
+            Has to be within your Studio's home directory and will be relative to that.
+            If not specified, will use the name of the file you want to upload
+            and place it in your home directory.
+        """
+        if remote_path is None:
+            remote_path = os.path.basename(path)
+
+        if Path(path).is_dir():
+            raise StudioCliError(f"The provided path is a folder: {path}. Use `lightning upload folder` instead.")
+        if not Path(path).exists():
+            raise FileNotFoundError(f"The provided path does not exist: {path}.")
+
+        selected_studio = self._resolve_studio(studio)
 
-    def _get_studio_from_name(self, studio: str, possible_studios: List[Dict[str, str]]) -> Dict[str, str]:
-        teamspace, name = studio.split("/", maxsplit=1)
-        for st in possible_studios:
-            if st["teamspace"] == teamspace and name == st["name"]:
-                return st
+        print(f"Uploading to {selected_studio.teamspace.name}/{selected_studio.name}")
 
-        print("Could not find Studio {studio}, please select it from the list:")
-        return self._get_studio_from_interactive_menu(possible_studios)
+        self._single_file_upload(selected_studio, path, remote_path, True)
+
+        studio_url = (
+            _get_cloud_url().replace(":443", "")
+            + "/"
+            + selected_studio.owner.name
+            + "/"
+            + selected_studio.teamspace.name
+            + "/studios/"
+            + selected_studio.name
+        )
+        print(f"See your file at {studio_url}")
 
     def _start_parallel_upload(
         self, executor: concurrent.futures.ThreadPoolExecutor, studio: Studio, upload_state: Dict[str, str]
@@ -125,57 +166,6 @@ class _Uploads:
         studio.upload_file(local_path, remote_path, progress_bar)
         return local_path
 
-    def _prepare_terminal_menu_all_studios(
-        self, possible_studios: List[Dict[str, str]], title: Optional[str] = None
-    ) -> TerminalMenu:
-        if title is None:
-            title = "Please select a Studio of the following studios:"
-
-        return TerminalMenu(
-            [f"{s['teamspace']}/{s['name']}" for s in possible_studios], title=title, clear_menu_on_exit=True
-        )
-
-    def _get_possible_studios(self, user: User) -> List[Dict[str, str]]:
-        teamspace_api = TeamspaceApi()
-        org_api = OrgApi()
-        user_api = user._user_api
-        possible_studios = []
-
-        user_api._get_organizations_for_authed_user()
-        memberships = user_api._get_all_teamspace_memberships(user_id=user.id)
-
-        teamspaces = {}
-        # get all teamspace memberships
-        for membership in memberships:
-            teamspace_id = membership.project_id
-
-            # get all studios for teamspace
-            all_studios = user._user_api._get_cloudspaces_for_user(user.id, teamspace_id)
-
-            for st in all_studios:
-                # populate teamspace info if necessary
-                if teamspace_id not in teamspaces:
-                    ts = teamspace_api._get_teamspace_by_id(teamspace_id)
-                    ts_name = ts.name
-
-                    # get organization if necessary
-                    if ts.owner_type == "organization":
-                        org_name = org_api._get_org_by_id(ts.owner_id).name
-                        user_name = None
-                    else:
-                        org_name = None
-
-                        # don't do a request if not necessary
-                        if ts.owner_id == user.id:
-                            user_name = user.name
-                        else:
-                            user_name = user_api._get_user_by_id(ts.owner_id).username
-
-                    teamspaces[teamspace_id] = {"user": user_name, "org": org_name, "teamspace": ts_name}
-                possible_studios.append({"name": st.name, **teamspaces[teamspace_id]})
-
-        return possible_studios
-
     def _dump_current_upload_state(self, studio: Studio, remote_path: str, state_dict: Dict[str, str]) -> None:
         """Dumps the current upload state so that we can safely resume later."""
         curr_path = os.path.abspath(

lightning_sdk/constants.py

@@ -1,3 +1,31 @@
 import os
+from uuid import uuid4
 
-_LIGHTNING_DEBUG = bool(int(os.getenv("LIGHTNING_DEBUG", "0")))
+_LIGHTNING_DEBUG = {
+    "": False,
+    "0": False,
+    "false": False,
+    "no": False,
+    "1": True,
+    "true": True,
+    "yes": True,
+}.get(os.getenv("LIGHTNING_DEBUG", "").lower(), False)
+
+
+class Store:
+    def __init__(self) -> None:
+        self._d = {}
+        # This is needed to ensure the ids are the same within created threads and processes.
+        self._list = [str(uuid4().hex) for _ in range(500)]
+
+    def __getitem__(self, key: str) -> str:
+        """Get item."""
+        if key in self._d:
+            return self._d[key]
+
+        value = self._list.pop(0) if self._list else str(uuid4().hex)
+        self._d[key] = value
+        return value
+
+
+__GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__ = Store()

lightning_sdk/deployment/__init__.py

@@ -0,0 +1,25 @@
+from lightning_sdk.api.deployment_api import (
+    AutoScaleConfig,
+    BasicAuth,
+    Env,
+    ExecHealthCheck,
+    HttpHealthCheck,
+    ReleaseStrategy,
+    RollingUpdateReleaseStrategy,
+    Secret,
+    TokenAuth,
+)
+from lightning_sdk.deployment.deployment import Deployment
+
+__all__ = [
+    "AutoScaleConfig",
+    "BasicAuth",
+    "Env",
+    "ExecHealthCheck",
+    "HttpHealthCheck",
+    "ReleaseStrategy",
+    "RollingUpdateReleaseStrategy",
+    "Secret",
+    "TokenAuth",
+    "Deployment",
+]

lightning_sdk/deployment/deployment.py

@@ -0,0 +1,389 @@
+import os
+from typing import Any, Dict, List, Optional, Union
+
+import requests
+
+from lightning_sdk.api import UserApi
+from lightning_sdk.api.deployment_api import (
+    Auth,
+    AutoScaleConfig,
+    BasicAuth,
+    DeploymentApi,
+    Env,
+    ExecHealthCheck,
+    HttpHealthCheck,
+    ReleaseStrategy,
+    Secret,
+    TokenAuth,
+    restore_auth,
+    restore_autoscale,
+    restore_env,
+    restore_health_check,
+    restore_release_strategy,
+    to_autoscaling,
+    to_endpoint,
+    to_spec,
+    to_strategy,
+)
+from lightning_sdk.lightning_cloud import login
+from lightning_sdk.lightning_cloud.openapi import V1Deployment
+from lightning_sdk.machine import Machine
+from lightning_sdk.organization import Organization
+from lightning_sdk.services.utilities import _get_cluster
+from lightning_sdk.teamspace import Teamspace
+from lightning_sdk.user import User
+from lightning_sdk.utils.resolve import _resolve_deprecated_cluster, _resolve_org, _resolve_teamspace, _resolve_user
+
+
+class Deployment:
+    """The Lightning AI Deployment.
+
+    Allows to fully control a deployment, including retrieving the status, making new release
+    and switching machine types, etc..
+
+    Args:
+        name: The name of the deployment.
+        teamspace: The teamspace in which you want to deploy.
+        org: The name of the organization owning the :param`teamspace` in case it is owned by an org
+        user: The name of the user owning the :param`teamspace` in case it is owned directly by a user instead of an org
+
+    Note:
+        Since a teamspace can either be owned by an org or by a user directly,
+        only one of the arguments can be provided.
+
+    """
+
+    def __init__(
+        self,
+        name: str,  # Only the name is required in case a deployment already exist.
+        teamspace: Optional[Union[str, Teamspace]] = None,
+        org: Optional[Union[str, Organization]] = None,
+        user: Optional[Union[str, User]] = None,
+    ) -> None:
+        self._request_session = None
+
+        self._auth = login.Auth()
+
+        try:
+            self._auth.authenticate()
+            if user is None:
+                self._user = User(name=UserApi()._get_user_by_id(self._auth.user_id).username)
+        except ConnectionError as e:
+            raise e
+
+        self._name = name
+        self._org = _resolve_org(org)
+        self._user = _resolve_user(user)
+        self._teamspace = _resolve_teamspace(
+            teamspace=teamspace, org=self._org, user=self._user if self._org is None else None
+        )
+        if self._teamspace is None:
+            raise ValueError("You need to pass a teamspace or an org for your deployment.")
+
+        self._deployment_api = DeploymentApi()
+        self._cloud_account = _get_cluster(client=self._deployment_api._client, project_id=self._teamspace.id)
+        self._is_created = False
+        deployment = self._deployment_api.get_deployment_by_name(name, self._teamspace.id)
+        if deployment:
+            self._is_created = True
+            self._deployment = deployment
+
+    def start(
+        self,
+        machine: Optional[Machine] = None,
+        environment: Optional[str] = None,
+        autoscale: Optional[AutoScaleConfig] = None,
+        ports: Optional[List[float]] = None,
+        release_strategy: Optional[ReleaseStrategy] = None,
+        entrypoint: Optional[str] = None,
+        command: Optional[str] = None,
+        env: Optional[List[Union[Env, Secret]]] = None,
+        spot: Optional[bool] = None,
+        replicas: Optional[int] = None,
+        health_check: Optional[Union[HttpHealthCheck, ExecHealthCheck]] = None,
+        auth: Optional[Union[BasicAuth, TokenAuth]] = None,
+        cloud_account: Optional[str] = None,
+        custom_domain: Optional[str] = None,
+        cluster: Optional[str] = None,  # deprecated in favor of cloud_account
+    ) -> None:
+        """The Lightning AI Deployment.
+
+        This method creates the first release of the deployment.
+        If a release already exists, it would raise a RuntimeError.
+
+        Args:
+            name: The name of the deployment.
+            machine: The machine used by the deployment replicas.
+            autoscale: The list of the metrics to autoscale on.
+            ports: The ports to reach your replica services.
+            environment: The environement used by the deployment. Currentely, only docker images.
+            release_strategy: The release strategy to use when changing core deployment specs.
+            entrypoint: The docker container entrypoint.
+            command: The docker container command.
+            env: The environements variables or secrets to use.
+            spot: Wether to use spot instances for the replicas.
+            replicas: The number of replicas to deploy with.
+            health_check: The health check config to know whether your service is ready to receive traffic.
+            auth: The auth config to protect your services. Only Basic and Token supported.
+            cloud_account: The name of the cloud account, the studio should be created on.
+                Doesn't matter when the studio already exists.
+            custom_domain: Whether your service would be referenced under a custom doamin.
+
+        Note:
+            Since a teamspace can either be owned by an org or by a user directly,
+            only one of the arguments can be provided.
+
+        """
+        if self._is_created:
+            raise RuntimeError("This deployment has already been started.")
+
+        cloud_account = _resolve_deprecated_cluster(cloud_account, cluster)
+
+        if cloud_account is None and self._cloud_account is not None:
+            print(f"No cloud account was provided, defaulting to {self._cloud_account.cluster_id}")
+            cloud_account = os.getenv("LIGHTNING_CLUSTER_ID") or self._cloud_account.cluster_id
+
+        self._deployment = self._deployment_api.create_deployment(
+            V1Deployment(
+                autoscaling=to_autoscaling(autoscale, replicas),
+                endpoint=to_endpoint(ports, auth, custom_domain),
+                name=self._name,
+                project_id=self._teamspace.id,
+                replicas=replicas,
+                spec=to_spec(
+                    cloud_account=cloud_account,
+                    command=command,
+                    entrypoint=entrypoint,
+                    env=env,
+                    environment=environment,
+                    spot=spot,
+                    machine=machine,
+                    health_check=health_check,
+                ),
+                strategy=to_strategy(release_strategy),
+            )
+        )
+        self._is_created = True
+
+    def update(
+        self,
+        # Changing those arguments create a new release
+        machine: Optional[Machine] = None,
+        environment: Optional[str] = None,
+        entrypoint: Optional[str] = None,
+        command: Optional[str] = None,
+        env: Optional[List[Union[Env, Secret]]] = None,
+        spot: Optional[bool] = None,
+        cloud_account: Optional[str] = None,
+        health_check: Optional[Union[HttpHealthCheck, ExecHealthCheck]] = None,
+        # Changing those arguments don't create a new release
+        min_replicas: Optional[int] = None,
+        max_replicas: Optional[int] = None,
+        name: Optional[str] = None,
+        ports: Optional[List[float]] = None,
+        release_strategy: Optional[ReleaseStrategy] = None,
+        replicas: Optional[int] = None,
+        auth: Optional[Union[BasicAuth, TokenAuth]] = None,
+        custom_domain: Optional[str] = None,
+        cluster: Optional[str] = None,  # deprecated in favor of cloud_account
+    ) -> None:
+        cloud_account = _resolve_deprecated_cluster(cloud_account, cluster)
+
+        self._deployment = self._deployment_api.update_deployment(
+            self._deployment,
+            name=name or self._name,
+            spot=spot,
+            replicas=replicas,
+            min_replicas=min_replicas,
+            max_replicas=max_replicas,
+            cloud_account=cloud_account,
+            machine=machine,
+            environment=environment,
+            entrypoint=entrypoint,
+            command=command,
+            ports=ports,
+            custom_domain=custom_domain,
+            auth=auth,
+            env=env,
+            health_check=health_check,
+            release_strategy=release_strategy,
+        )
+
+    def stop(self) -> None:
+        """All the deployment replicas will be stopped and all their traffic blocked."""
+        self._deployment = self._deployment_api.stop(self._deployment)
+
+    @property
+    def replicas(self) -> Optional[int]:
+        """The default number of replicas the release starts with."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.replicas
+        return None
+
+    @property
+    def min_replicas(self) -> Optional[int]:
+        """The minimum number of replicas."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.autoscaling.min_replicas
+        return None
+
+    @property
+    def max_replicas(self) -> Optional[int]:
+        """The maximum number of replicas."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.autoscaling.max_replicas
+        return None
+
+    @property
+    def ports(self) -> Optional[int]:
+        """The exposed ports on which you can reach your deployment."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return [int(p) for p in self._deployment.endpoint.ports]
+        return None
+
+    @property
+    def release_strategy(self) -> Optional[ReleaseStrategy]:
+        """The release strategy of the deployment."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return restore_release_strategy(self._deployment.strategy)
+        return None
+
+    @property
+    def readiness_probe(self) -> Optional[Union[HttpHealthCheck, ExecHealthCheck]]:
+        """The health check to validate the replicas are ready to receive traffic."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return restore_health_check(self._deployment.spec.readiness_probe)
+        return None
+
+    @property
+    def auth(self) -> Optional[Auth]:
+        """The authentification configuration of the deployment."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return restore_auth(self._deployment.endpoint.auth)
+        return None
+
+    @property
+    def autoscale(self) -> Optional[AutoScaleConfig]:
+        """The autoscaling configuration of the deployment."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return restore_autoscale(self._deployment.autoscaling)
+        return None
+
+    @property
+    def env(self) -> Optional[AutoScaleConfig]:
+        """The env configuration of the deployment."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return restore_env(self._deployment.spec.env)
+        return None
+
+    @property
+    def urls(self) -> Optional[List[str]]:
+        """The urls to reach the deployment."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.status.urls
+        return None
+
+    @property
+    def pending_replicas(self) -> Optional[List[str]]:
+        """The number of pending replicas."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.status.pending_replicas
+        return None
+
+    @property
+    def failing_replicas(self) -> Optional[List[str]]:
+        """The number of failing replicas."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.status.failing_replicas
+        return None
+
+    @property
+    def deleting_replicas(self) -> Optional[List[str]]:
+        """The number of deleting replicas."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.status.deleting_replicas
+        return None
+
+    @property
+    def cloud_account(self) -> Optional[str]:
+        """The cloud_account of the replicas."""
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+            return self._deployment.spec.cluster_id
+        return None
+
+    @property
+    def user(self) -> Optional[User]:
+        """The teamspace of the deployment."""
+        return self._user
+
+    @property
+    def teamspace(self) -> Optional[Teamspace]:
+        """The teamspace of the deployment."""
+        return self._teamspace
+
+    @property
+    def is_started(self) -> bool:
+        return self._is_created
+
+    @property
+    def _session(self) -> Any:
+        if self._request_session is None:
+            self._request_session = requests.Session()
+            self._request_session.headers.update(**self._get_auth_headers())
+        return self._request_session
+
+    def _get_auth_headers(self) -> Dict:
+        if self._deployment:
+            self._deployment = self._deployment_api.get_deployment_by_name(self._name, self._teamspace.id)
+
+        if self._deployment.endpoint.auth.user_api_key:
+            return {"Authorization": f"Bearer {self._auth.api_key}"}
+
+        # TODO: Add support for all auth
+        return {}
+
+    def _get_url(self, port: Optional[int] = None) -> Any:
+        urls = self.urls
+        if urls is None:
+            return None
+
+        if port is None:
+            return urls[0]
+
+        return None
+
+    def _prepare_url(self, path: str = "", port: Optional[int] = None) -> str:
+        url = self._get_url(port)
+        if url is None:
+            raise ValueError("The url wasn't properly defined")
+
+        if path.startswith("/"):
+            path = path[1:]
+
+        return f"{url}/{path}"
+
+    def get(self, path: str = "", port: Optional[int] = None, **kwargs: Any) -> Any:
+        return self._session.get(self._prepare_url(path, port), verify=False, **kwargs)
+
+    def post(self, path: str = "", port: Optional[int] = None, **kwargs: Any) -> Any:
+        return self._session.post(self._prepare_url(path, port), verify=False, **kwargs)
+
+    def put(self, path: str = "", port: Optional[int] = None, **kwargs: Any) -> Any:
+        return self._session.put(self._prepare_url(path, port), verify=False, **kwargs)
+
+    def delete(self, path: str = "", port: Optional[int] = None, **kwargs: Any) -> Any:
+        return self._session.delete(self._prepare_url(path, port), verify=False, **kwargs)