polyaxon 2.1.8__py3-none-any.whl → 2.2.0__py3-none-any.whl

polyaxon/_cli/operations.py

@@ -21,7 +21,11 @@ from clipped.utils.versions import compare_versions
 from urllib3.exceptions import HTTPError
 
 from polyaxon import settings
-from polyaxon._cli.dashboard import get_dashboard, get_dashboard_url
+from polyaxon._cli.dashboard import (
+    get_dashboard,
+    get_dashboard_url,
+    get_project_subpath_url,
+)
 from polyaxon._cli.errors import handle_cli_error, is_in_ce
 from polyaxon._cli.options import (
     OPTIONS_NAME,
@@ -47,7 +51,7 @@ from polyaxon.api import (
     REWRITE_SERVICES_V1,
     SERVICES_V1,
 )
-from polyaxon.client import RunClient, V1Run, get_run_logs
+from polyaxon.client import RunClient, V1Run, V1RunSettings, get_run_logs
 from polyaxon.exceptions import (
     ApiException,
     PolyaxonClientException,
@@ -82,6 +86,14 @@ DEFAULT_EXCLUDE = [
 ]
 
 
+def get_op_agent_host(runSettings: V1RunSettings):
+    host_kwargs = {}
+    if runSettings and runSettings.agent and runSettings.agent.url:
+        host_kwargs["host"] = runSettings.agent.url
+
+    return host_kwargs
+
+
 def handle_run_statuses(status, conditions, table):
     if not conditions:
         return False
@@ -286,7 +298,7 @@ def ls(
             else:
                 Printer.warning(f"Skipping run {uid}, offline data not found.")
     else:
-        owner, project_name = get_project_or_local(
+        owner, _, project_name = get_project_or_local(
             project or ctx.obj.get("project"), is_cli=True
         )
 
@@ -431,7 +443,7 @@ def get(ctx, project, uid, offline, path, output):
             sys.exit(1)
         run_data = RunConfigManager.read_from_path(offline_path)
     else:
-        owner, project_name, run_uuid = get_project_run_or_local(
+        owner, team, project_name, run_uuid = get_project_run_or_local(
             project or ctx.obj.get("project"),
             uid,
             is_cli=True,
@@ -456,7 +468,9 @@ def get(ctx, project, uid, offline, path, output):
             )
             if output:
                 run_url = get_dashboard_url(
-                    subpath="{}/{}/runs/{}".format(owner, project_name, run_uuid)
+                    subpath="{}/runs/{}".format(
+                        get_project_subpath_url(owner, team, project_name), run_uuid
+                    )
                 )
                 config["url"] = run_url
                 handle_output(config, output)
@@ -529,7 +543,7 @@ def delete(ctx, project, uid, yes, offline, path):
         return
 
     # Resume normal flow
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -624,7 +638,7 @@ def update(ctx, project, uid, name, description, tags, offline, path):
             )
             sys.exit(1)
     else:
-        owner, project_name, run_uuid = get_project_run_or_local(
+        owner, _, project_name, run_uuid = get_project_run_or_local(
             project or ctx.obj.get("project"),
             uid or ctx.obj.get("run_uuid"),
             is_cli=True,
@@ -663,7 +677,7 @@ def approve(ctx, project, uid):
     \b
     $ polyaxon ops approve --uid 8aac02e3a62a4f0aaa257c59da5eab80
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -710,7 +724,7 @@ def stop(ctx, project, uid, yes):
     \b
     $ polyaxon ops stop --uid 8aac02e3a62a4f0aaa257c59da5eab80
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -762,7 +776,7 @@ def skip(ctx, project, uid, yes):
     \b
     $ polyaxon ops skip --uid 8aac02e3a62a4f0aaa257c59da5eab80
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -866,7 +880,7 @@ def restart(
     if polyaxonfile:
         content = OperationSpecification.read(polyaxonfile, is_preset=True).to_json()
 
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -951,7 +965,7 @@ def resume(
     if polyaxonfile:
         content = OperationSpecification.read(polyaxonfile, is_preset=True).to_json()
 
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -994,7 +1008,7 @@ def invalidate(ctx, project, uid):
     \b
     $ polyaxon ops invalidate --uid 8aac02e3a62a4f0aaa257c59da5eab80
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1020,7 +1034,7 @@ def invalidate(ctx, project, uid):
     "--executor",
     "-exc",
     type=str,
-    help="The local executor to use, possible values are: docker, k8s, process.",
+    help="The executor to use, possible values are: docker, k8s, process.",
 )
 @click.pass_context
 @clean_outputs
@@ -1129,7 +1143,7 @@ def execute(ctx, project, uid, executor):
         executor.create_from_run(response, default_auth=not is_in_ce())
 
     def _execute_on_local_process(response: V1Run, run_client: RunClient):
-        from polyaxon.process.executor.executor import Executor
+        from polyaxon._local_process.executor import Executor
 
         run_client.log_status(
             V1Statuses.STARTING,
@@ -1138,27 +1152,52 @@ def execute(ctx, project, uid, executor):
         )
         executor = Executor()
         if not executor.manager.check():
-            raise Printer.error("Conda is required to run this command.", sys_exit=True)
-
-        # def _check_conda():
-        #     from polyaxon._deploy.operators.conda import CondaOperator
-        #
-        #     conda = CondaOperator()
-        #     if not conda.check():
-        #         raise Printer.error("Conda is required to run this command.", sys_exit=True)
-        #
-        #     envs = conda.execute(["env", "list", "--json"], is_json=True)
-        #     env_names = [os.path.basename(env) for env in envs["envs"]]
-        #     if conda_env not in env_names:
-        #         raise Printer.error(
-        #             "Conda env `{}` is not installed.".format(conda_env), sys_exit=True
-        #         )
-        #
-        #     cmd_bash, cmd_args = specification.run.get_container_cmd()
-        #     cmd_args = ["source activate {}".format(conda_env)] + cmd_args
-        #     subprocess.Popen(cmd_bash + [" && ".join(cmd_args)], close_fds=True)
-
-    owner, project_name, run_uuid = get_project_run_or_local(
+            run_client.log_failed(
+                reason="CliProcessExecutor",
+                message="Local process can't be used to run this operation.",
+            )
+            raise Printer.error(
+                "Local process can't be used to run this operation.", sys_exit=True
+            )
+
+        run_client.log_status(
+            V1Statuses.RUNNING,
+            reason="CliProcessExecutor",
+            message="Operation is running",
+        )
+
+        if V1RunKind.has_pipeline(response.kind):
+            has_children = True
+            while has_children:
+                pipeline_runs = run_client.list_children(
+                    query="status:created", sort="created_at", limit=1
+                )
+                if pipeline_runs.results:
+                    current_run_client = RunClient(
+                        owner=owner,
+                        project=project_name,
+                        run_uuid=pipeline_runs.results[0].uuid,
+                        manual_exceptions_handling=True,
+                    )
+                    current_run_client.refresh_data()
+                    _prepare(current_run_client.run_data, current_run_client)
+                    _execute(current_run_client.run_data, current_run_client)
+                else:
+                    has_children = False
+            return
+        else:
+            result = executor.create_from_run(response, default_auth=not is_in_ce())
+        if result["status"] == V1Statuses.SUCCEEDED:
+            run_client.log_succeeded(
+                reason="CliProcessExecutor", message="Operation was succeeded"
+            )
+        else:
+            run_client.log_failed(
+                reason="CliProcessExecutor",
+                message="Operation failed.\n{}".format(result["message"]),
+            )
+
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1282,7 +1321,7 @@ def statuses(ctx, project, uid, watch, offline, path):
             sys.exit(1)
         return
 
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1350,7 +1389,7 @@ def statuses(ctx, project, uid, watch, offline, path):
 #             )
 #             sys.exit(1)
 #
-#     owner, project_name, run_uuid = get_project_run_or_local(
+#     owner, team, project_name, run_uuid = get_project_run_or_local(
 #         ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True,
 #     )
 #
@@ -1442,7 +1481,7 @@ def logs(ctx, project, uid, follow, hide_time, all_containers, all_info, offline
             sys.exit(1)
         return
 
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1488,7 +1527,7 @@ def inspect(ctx, project, uid):
     \b
     $ polyaxon ops inspect -p acme/project -uid 8aac02e3a62a4f0aaa257c59da5eab80
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1547,7 +1586,7 @@ def shell(ctx, project, uid, command, pod, container):
     """
     from polyaxon._vendor.shell_pty import PseudoTerminal
 
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1652,7 +1691,7 @@ def artifacts(
     \b
     $ polyaxon ops artifacts -uid 8aac02e3a62a4f0aaa257c59da5eab80 -l-kind model -l-kind env --path="this/path"
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1830,7 +1869,7 @@ def upload(ctx, project, uid, path_from, path_to, sync_failure):
     \b
     $ polyaxon ops upload -uid 8aac02e3a62a4f0aaa257c59da5eab80 --path-to="path/to/upload/to"
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1904,7 +1943,7 @@ def transfer(ctx, project, uid, to_project):
     \b
     $ polyaxon ops transfer -p acme/foobar -uid 8aac02e3a62a4f0aaa257c59da5eab80 -to=dest-project
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, _, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -1972,13 +2011,16 @@ def dashboard(ctx, project, uid, yes, url, offline, path, server_config):
             sys.exit(1)
         run_data = RunConfigManager.read_from_path(offline_path)
         owner, project_name, run_uuid = run_data.owner, run_data.project, run_data.uuid
+        team = None
     else:
-        owner, project_name, run_uuid = get_project_run_or_local(
+        owner, team, project_name, run_uuid = get_project_run_or_local(
             project or ctx.obj.get("project"),
             uid or ctx.obj.get("run_uuid"),
             is_cli=True,
         )
-    subpath = "{}/{}/runs/{}".format(owner, project_name, run_uuid)
+    subpath = "{}/runs/{}".format(
+        get_project_subpath_url(owner, team, project_name), run_uuid
+    )
     dashboard_url = get_dashboard_url(subpath=subpath)
     get_dashboard(dashboard_url=dashboard_url, url_only=url, yes=yes)
     if offline:
@@ -2022,7 +2064,7 @@ def service(ctx, project, uid, yes, external, url):
     You can open the service embedded in Polyaxon UI or using the real service URL,
     please use the `--external` flag.
     """
-    owner, project_name, run_uuid = get_project_run_or_local(
+    owner, team, project_name, run_uuid = get_project_run_or_local(
         project or ctx.obj.get("project"),
         uid or ctx.obj.get("run_uuid"),
         is_cli=True,
@@ -2055,8 +2097,12 @@ def service(ctx, project, uid, yes, external, url):
 
     wait_for_running_condition(client)
 
+    host_kwargs = get_op_agent_host(client.settings)
     run_url = get_dashboard_url(
-        subpath="{}/{}/runs/{}/service".format(owner, project_name, run_uuid)
+        subpath="{}/runs/{}/service".format(
+            get_project_subpath_url(owner, team, project_name), run_uuid
+        ),
+        **host_kwargs,
     )
 
     namespace = client.run_data.settings.namespace
@@ -2066,8 +2112,8 @@ def service(ctx, project, uid, yes, external, url):
     if rewrite_path:
         service_endpoint = REWRITE_EXTERNAL_V1 if is_external else REWRITE_SERVICES_V1
 
-    service_subpath = "{}/{}/{}/runs/{}/".format(
-        namespace, owner, project_name, run_uuid
+    service_subpath = "{}/{}/runs/{}/".format(
+        get_project_subpath_url(namespace, team, owner), project_name, run_uuid
     )
     port = 80
     if client.settings and client.settings.agent:
@@ -2080,9 +2126,9 @@ def service(ctx, project, uid, yes, external, url):
     if port:
         service_subpath = "{}{}/".format(service_subpath, port)
 
+    host_kwargs = get_op_agent_host(client.settings)
     external_run_url = get_dashboard_url(
-        base=service_endpoint,
-        subpath=service_subpath,
+        base=service_endpoint, subpath=service_subpath, **host_kwargs
     )
 
     if url:
@@ -2163,7 +2209,7 @@ def pull(
     \b
     $ polyaxon ops pull -a
     """
-    owner, project_name = get_project_or_local(
+    owner, _, project_name = get_project_or_local(
         project or ctx.obj.get("project"), is_cli=True
     )
 
@@ -2283,7 +2329,7 @@ def push(ctx, project, uid, all_runs, no_artifacts, clean, path, reset_project):
     \b
     $ polyaxon ops push -uid 8aac02e3a62a4f0aaa257c59da5eab80 --reset-project -p send-to-project
     """
-    owner, project_name = get_project_or_local(
+    owner, _, project_name = get_project_or_local(
         project or ctx.obj.get("project"), is_cli=True
     )
 

polyaxon/_cli/project_versions.py

@@ -12,7 +12,7 @@ from clipped.utils.responses import get_meta_response
 from clipped.utils.validation import validate_tags
 from urllib3.exceptions import HTTPError
 
-from polyaxon._cli.dashboard import get_dashboard_url
+from polyaxon._cli.dashboard import get_dashboard_url, get_project_subpath_url
 from polyaxon._cli.errors import handle_cli_error
 from polyaxon._contexts.paths import get_offline_base_path
 from polyaxon._schemas.lifecycle import V1ProjectVersionKind
@@ -170,6 +170,7 @@ def list_project_versions(
 
 def register_project_version(
     owner: str,
+    team: Optional[str],
     project_name: str,
     version: str,
     kind: V1ProjectVersionKind,
@@ -209,7 +210,9 @@ def register_project_version(
     Printer.print(
         "You can view this version on Polyaxon UI: {}".format(
             get_dashboard_url(
-                subpath="{}/{}/{}s/{}".format(owner, project_name, kind, version)
+                subpath="{}/{}s/{}".format(
+                    get_project_subpath_url(owner, team, project_name), kind, version
+                )
             )
         )
     )
@@ -217,6 +220,7 @@ def register_project_version(
 
 def copy_project_version(
     owner: str,
+    team: Optional[str],
     project_name: str,
     version: str,
     kind: V1ProjectVersionKind,
@@ -261,8 +265,10 @@ def copy_project_version(
     Printer.print(
         "You can view this version on Polyaxon UI: {}".format(
             get_dashboard_url(
-                subpath="{}/{}/{}s/{}".format(
-                    owner, to_project or project_name, kind, _version.name
+                subpath="{}/{}s/{}".format(
+                    get_project_subpath_url(owner, team, to_project or project_name),
+                    kind,
+                    _version.name,
                 )
             )
         )
@@ -271,6 +277,7 @@ def copy_project_version(
 
 def get_project_version(
     owner: str,
+    team: Optional[str],
     project_name: str,
     kind: V1ProjectVersionKind,
     version: str,
@@ -288,6 +295,17 @@ def get_project_version(
     try:
         response = polyaxon_client.get_version(kind, version)
         get_version_details(response, content_callback)
+        Printer.print(
+            "You can view this version on Polyaxon UI: {}".format(
+                get_dashboard_url(
+                    subpath="{}/{}s/{}".format(
+                        get_project_subpath_url(owner, team, project_name),
+                        kind,
+                        version,
+                    )
+                )
+            )
+        )
     except (ApiException, HTTPError) as e:
         handle_cli_error(
             e,
@@ -470,13 +488,16 @@ def stage_project_version(
 
 def open_project_version_dashboard(
     owner: str,
+    team: Optional[str],
     project_name: str,
     kind: V1ProjectVersionKind,
     version: str,
     url: str,
     yes: bool = False,
 ):
-    subpath = "{}/{}/{}s/{}".format(owner, project_name, kind, version)
+    subpath = "{}/{}s/{}".format(
+        get_project_subpath_url(owner, team, project_name), kind, version
+    )
 
     artifact_url = get_dashboard_url(subpath=subpath)
     if url:

polyaxon/_cli/projects.py

@@ -8,7 +8,7 @@ from clipped.utils.responses import get_meta_response
 from clipped.utils.validation import validate_tags
 from urllib3.exceptions import HTTPError
 
-from polyaxon._cli.dashboard import get_dashboard_url
+from polyaxon._cli.dashboard import get_dashboard_url, get_project_subpath_url
 from polyaxon._cli.errors import handle_cli_error
 from polyaxon._cli.init import init as init_project
 from polyaxon._cli.options import OPTIONS_NAME, OPTIONS_OWNER, OPTIONS_PROJECT
@@ -19,6 +19,7 @@ from polyaxon._env_vars.getters.user import get_local_owner
 from polyaxon._managers.project import ProjectConfigManager
 from polyaxon._utils import cache
 from polyaxon._utils.cache import get_local_project
+from polyaxon._utils.fqn_utils import get_owner_team_space
 from polyaxon.client import ProjectClient, V1Project
 from polyaxon.exceptions import ApiException
 from polyaxon.logger import clean_outputs
@@ -74,7 +75,7 @@ def create(ctx, name, description, tags, public, init):
             command_help="project create",
             sys_exit=True,
         )
-    owner, project_name = resolve_entity_info(
+    owner, team, project_name = resolve_entity_info(
         name or ctx.obj.get("project"), is_cli=True, entity_name="project"
     )
 
@@ -90,7 +91,9 @@ def create(ctx, name, description, tags, public, init):
         project_config = V1Project(
             name=project_name, description=description, tags=tags, is_public=public
         )
-        polyaxon_client = ProjectClient(owner=owner, manual_exceptions_handling=True)
+        polyaxon_client = ProjectClient(
+            owner=get_owner_team_space(owner, team), manual_exceptions_handling=True
+        )
         _project = polyaxon_client.create(project_config)
         config = polyaxon_client.client.sanitize_for_serialization(_project)
         cache.cache(config_manager=ProjectConfigManager, config=config)
@@ -103,7 +106,9 @@ def create(ctx, name, description, tags, public, init):
     Printer.success("Project `{}` was created successfully.".format(_project.name))
     Printer.print(
         "You can view this project on Polyaxon UI: {}".format(
-            get_dashboard_url(subpath="{}/{}".format(owner, _project.name))
+            get_dashboard_url(
+                subpath=get_project_subpath_url(owner, team, _project.name)
+            )
         )
     )
 
@@ -195,7 +200,7 @@ def get(ctx, _project):
     \b
     $ polyaxon project get -p owner/project
     """
-    owner, project_name = get_project_or_local(
+    owner, team, project_name = get_project_or_local(
         _project or ctx.obj.get("project"), is_cli=True
     )
 
@@ -214,6 +219,13 @@ def get(ctx, _project):
             project=project_name,
         )
         get_entity_details(polyaxon_client.project_data, "Project")
+        Printer.print(
+            "You can view this project on Polyaxon UI: {}".format(
+                get_dashboard_url(
+                    subpath=get_project_subpath_url(owner, team, project_name)
+                )
+            )
+        )
     except (ApiException, HTTPError) as e:
         handle_cli_error(
             e, message="Could not get project `{}`.".format(project_name), sys_exit=True
@@ -237,7 +249,7 @@ def delete(ctx, _project, yes):
 
     Uses /docs/core/cli/#caching
     """
-    owner, project_name = get_project_or_local(
+    owner, _, project_name = get_project_or_local(
         _project or ctx.obj.get("project"), is_cli=True
     )
 
@@ -300,7 +312,7 @@ def update(ctx, _project, name, description, tags, private):
     \b
     $ polyaxon update --tags="foo, bar"
     """
-    owner, project_name = get_project_or_local(
+    owner, _, project_name = get_project_or_local(
         _project or ctx.obj.get("project"), is_cli=True
     )
 
@@ -357,10 +369,12 @@ def update(ctx, _project, name, description, tags, private):
 @clean_outputs
 def dashboard(ctx, _project, yes, url):
     """Open this project's dashboard details in browser."""
-    owner, project_name = get_project_or_local(
+    owner, team, project_name = get_project_or_local(
         _project or ctx.obj.get("project"), is_cli=True
     )
-    project_url = get_dashboard_url(subpath="{}/{}".format(owner, project_name))
+    project_url = get_dashboard_url(
+        subpath=get_project_subpath_url(owner, team, project_name)
+    )
     if url:
         Printer.header("The dashboard is available at: {}".format(project_url))
         sys.exit(0)

polyaxon/_cli/run.py

@@ -10,10 +10,11 @@ from clipped.utils import git as git_utils
 from clipped.utils.validation import validate_tags
 from urllib3.exceptions import HTTPError
 
-from polyaxon._cli.dashboard import get_dashboard_url
+from polyaxon._cli.dashboard import get_dashboard_url, get_project_subpath_url
 from polyaxon._cli.errors import handle_cli_error
 from polyaxon._cli.operations import approve
 from polyaxon._cli.operations import execute as run_execute
+from polyaxon._cli.operations import get_op_agent_host
 from polyaxon._cli.operations import logs as run_logs
 from polyaxon._cli.operations import shell as run_shell
 from polyaxon._cli.operations import statuses
@@ -30,6 +31,7 @@ from polyaxon._polyaxonfile import check_polyaxonfile
 from polyaxon._runner.kinds import RunnerKind
 from polyaxon._schemas.lifecycle import ManagedBy
 from polyaxon._utils import cache
+from polyaxon._utils.fqn_utils import get_owner_team_space
 from polyaxon.client import RunClient
 from polyaxon.exceptions import ApiException
 from polyaxon.logger import clean_outputs
@@ -43,6 +45,7 @@ def _run(
     ctx,
     name: str,
     owner: str,
+    team: Optional[str],
     project_name: str,
     description: str,
     tags: List[str],
@@ -61,11 +64,14 @@ def _run(
         owner=owner, project=project_name, manual_exceptions_handling=True
     )
 
+    owner_team = get_owner_team_space(owner, team)
+    project_url = get_project_subpath_url(owner, team, project_name)
+
     def get_instance_info(r):
         rn = (
             f"[white]{r.name}[/white]@[white]{r.uuid}[/white]"
             if r.name
-            else "[white]{r.uuid}[/white]"
+            else f"[white]{r.uuid}[/white]"
         )
         return f"[white]{owner}[/white]/[white]{project_name}[/white]:{rn}"
 
@@ -93,8 +99,9 @@ def _run(
                 meta_info=meta_info,
                 pending=pending,
             )
+            host_kwargs = get_op_agent_host(response.settings)
             run_url = get_dashboard_url(
-                subpath="{}/{}/runs/{}".format(owner, project_name, response.uuid)
+                subpath="{}/runs/{}".format(project_url, response.uuid), **host_kwargs
             )
             if output:
                 response_data = polyaxon_client.client.sanitize_for_serialization(
@@ -125,26 +132,38 @@ def _run(
 
     def execute_run_locally(run_uuid: str):
         ctx.obj = {
-            "project": "{}/{}".format(owner, project_name),
+            "project": "{}/{}".format(owner_team, project_name),
             "run_uuid": run_uuid,
             "executor": executor,
         }
         ctx.invoke(run_execute)
 
     def watch_run_statuses(run_uuid: str):
-        ctx.obj = {"project": "{}/{}".format(owner, project_name), "run_uuid": run_uuid}
+        ctx.obj = {
+            "project": "{}/{}".format(owner_team, project_name),
+            "run_uuid": run_uuid,
+        }
         ctx.invoke(statuses, watch=True)
 
     def watch_run_logs(run_uuid: str):
-        ctx.obj = {"project": "{}/{}".format(owner, project_name), "run_uuid": run_uuid}
+        ctx.obj = {
+            "project": "{}/{}".format(owner_team, project_name),
+            "run_uuid": run_uuid,
+        }
         ctx.invoke(run_logs)
 
     def start_run_shell(run_uuid: str):
-        ctx.obj = {"project": "{}/{}".format(owner, project_name), "run_uuid": run_uuid}
+        ctx.obj = {
+            "project": "{}/{}".format(owner_team, project_name),
+            "run_uuid": run_uuid,
+        }
         ctx.invoke(run_shell)
 
     def upload_run(run_uuid: str):
-        ctx.obj = {"project": "{}/{}".format(owner, project_name), "run_uuid": run_uuid}
+        ctx.obj = {
+            "project": "{}/{}".format(owner_team, project_name),
+            "run_uuid": run_uuid,
+        }
         ctx.invoke(
             run_upload, path_to=upload_to, path_from=upload_from, sync_failure=True
         )
@@ -555,13 +574,14 @@ def run(
         Printer.print("Please customize the specification or disable the template!")
         sys.exit(1)
 
-    owner, project_name = get_project_or_local(project, is_cli=True)
+    owner, team, project_name = get_project_or_local(project, is_cli=True)
     tags = validate_tags(tags, validate_yaml=True)
 
     _run(
         ctx=ctx,
         name=name,
         owner=owner,
+        team=team,
         project_name=project_name,
         description=description,
         tags=tags,