polyaxon 2.0.0rc49__py3-none-any.whl → 2.4.0rc1__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,
@@ -736,6 +750,58 @@ def stop(ctx, project, uid, yes):
     Printer.success("Run `{}` is being stopped ...".format(run_uuid))
 
 
+@ops.command()
+@click.option(*OPTIONS_PROJECT["args"], **OPTIONS_PROJECT["kwargs"])
+@click.option(*OPTIONS_RUN_UID["args"], **OPTIONS_RUN_UID["kwargs"])
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    default=False,
+    help="Automatic yes to prompts. "
+    'Assume "yes" as answer to all prompts and run non-interactively.',
+)
+@click.pass_context
+@clean_outputs
+def skip(ctx, project, uid, yes):
+    """Skip run.
+
+    Uses /docs/core/cli/#caching
+
+    Examples:
+
+    \b
+    $ polyaxon ops skip
+
+    \b
+    $ polyaxon ops skip --uid 8aac02e3a62a4f0aaa257c59da5eab80
+    """
+    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,
+    )
+    if not yes and not click.confirm(
+        "Are sure you want to stop " "run `{}`".format(run_uuid)
+    ):
+        Printer.print("Exiting without stopping run.")
+        sys.exit(0)
+
+    try:
+        polyaxon_client = RunClient(
+            owner=owner,
+            project=project_name,
+            run_uuid=run_uuid,
+            manual_exceptions_handling=True,
+        )
+        polyaxon_client.skip()
+    except (ApiException, HTTPError) as e:
+        handle_cli_error(e, message="Could not skip run `{}`.".format(run_uuid))
+        sys.exit(1)
+
+    Printer.success("Run `{}` is skipped.".format(run_uuid))
+
+
 @ops.command()
 @click.option(*OPTIONS_PROJECT["args"], **OPTIONS_PROJECT["kwargs"])
 @click.option(*OPTIONS_RUN_UID["args"], **OPTIONS_RUN_UID["kwargs"])
@@ -814,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,
@@ -899,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,
@@ -942,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,
@@ -968,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
@@ -986,50 +1052,74 @@ def execute(ctx, project, uid, executor):
     $ polyaxon ops execute -uid 8aac02e3a62a4f0aaa257c59da5eab80
     """
 
-    def _execute_on_docker(response: V1Run):
+    Printer.warning(
+        "The `ops execute` command is experimental and might change in the future!"
+    )
+
+    def _execute_on_docker(response: V1Run, run_client: RunClient):
         from polyaxon._docker.executor import Executor
 
-        polyaxon_client.log_status(
+        run_client.log_status(
             V1Statuses.STARTING,
             reason="CliDockerExecutor",
             message="Operation is starting",
         )
         executor = Executor()
         if not executor.manager.check():
-            polyaxon_client.log_failed(
+            run_client.log_failed(
                 reason="CliDockerExecutor",
                 message="Docker is required to run this operation.",
             )
             raise Printer.error(
                 "Docker is required to run this command.", sys_exit=True
             )
-        polyaxon_client.log_status(
+        run_client.log_status(
             V1Statuses.RUNNING,
-            reason="CliK8SExecutor",
+            reason="CliDockerExecutor",
             message="Operation is running",
         )
-        result = executor.create_from_run(response, default_auth=not is_in_ce())
+        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:
-            polyaxon_client.log_succeeded(
+            run_client.log_succeeded(
                 reason="CliDockerExecutor", message="Operation was succeeded"
             )
         else:
-            polyaxon_client.log_failed(
+            run_client.log_failed(
                 reason="CliDockerExecutor",
-                message="Operation was failed.\n{}".format(result["message"]),
+                message="Operation failed.\n{}".format(result["message"]),
             )
 
-    def execute_on_k8s(response: V1Run):
+    def _execute_on_k8s(response: V1Run, run_client: RunClient):
         from polyaxon._k8s.executor.executor import Executor
 
-        polyaxon_client.log_status(
+        run_client.log_status(
             V1Statuses.STARTING,
             reason="CliK8SExecutor",
             message="Operation is starting",
         )
         if not settings.AGENT_CONFIG.namespace:
-            polyaxon_client.log_failed(
-                reason="CliDockerExecutor",
+            run_client.log_failed(
+                reason="CliK8SExecutor",
                 message="an agent config with defined namespace is required.",
             )
             raise Printer.error(
@@ -1038,51 +1128,76 @@ def execute(ctx, project, uid, executor):
 
         executor = Executor(namespace=settings.AGENT_CONFIG.namespace)
         if not executor.manager.get_version():
-            polyaxon_client.log_failed(
-                reason="CliDockerExecutor",
+            run_client.log_failed(
+                reason="CliK8SExecutor",
                 message="Kubernetes is required to run this operation.",
             )
             raise Printer.error(
                 "Kubernetes is required to run this command.", sys_exit=True
             )
-        polyaxon_client.log_status(
+        run_client.log_status(
             V1Statuses.RUNNING,
             reason="CliK8SExecutor",
             message="Operation is running",
         )
         executor.create_from_run(response, default_auth=not is_in_ce())
 
-    def _execute_on_local_process(response: V1Run):
-        from polyaxon.process.executor.executor import Executor
+    def _execute_on_local_process(response: V1Run, run_client: RunClient):
+        from polyaxon._local_process.executor import Executor
 
-        polyaxon_client.log_status(
+        run_client.log_status(
             V1Statuses.STARTING,
             reason="CliProcessExecutor",
             message="Operation is starting",
         )
         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,
@@ -1114,22 +1229,48 @@ def execute(ctx, project, uid, executor):
                 )
             settings.AGENT_CONFIG.set_default_artifacts_store()
 
-    polyaxon_client.log_status(
-        V1Statuses.SCHEDULED,
-        reason="CliExecutor",
-        message="Operation is pulled by CLI.",
-    )
-    if executor == RunnerKind.DOCKER:
-        _execute_on_docker(polyaxon_client.run_data)
-    elif executor == RunnerKind.K8S:
-        execute_on_k8s(polyaxon_client.run_data)
-    elif executor == RunnerKind.PROCESS:
-        _execute_on_local_process(polyaxon_client.run_data)
-    else:
+    def _prepare(response: V1Run, client: RunClient):
+        if response.status == V1Statuses.CREATED:
+            try:
+                client.approve()
+                client.refresh_data()
+            except (ApiException, HTTPError) as e:
+                handle_cli_error(
+                    e, message="Could not approve run `{}`.".format(response.uuid)
+                )
+                sys.exit(1)
+
+    def _execute(response: V1Run, client: RunClient):
+        if LifeCycle.is_done(response.status):
+            return
+        if response.status != V1Statuses.COMPILED:
+            Printer.error("Run must be compiled.", sys_exit=True)
+        client.log_status(
+            V1Statuses.SCHEDULED,
+            reason="CliExecutor",
+            message="Operation is pulled by CLI.",
+        )
+        if executor == RunnerKind.DOCKER:
+            _execute_on_docker(response, client)
+        elif executor == RunnerKind.K8S:
+            _execute_on_k8s(response, client)
+        elif executor == RunnerKind.PROCESS:
+            _execute_on_local_process(response, client)
+        else:
+            client.log_failed(
+                reason="CliExecutor",
+                message="Local executor is not supported {}.".format(executor),
+            )
+
+    try:
+        _prepare(polyaxon_client.run_data, polyaxon_client)
+        _execute(polyaxon_client.run_data, polyaxon_client)
+    except KeyboardInterrupt:
         polyaxon_client.log_failed(
             reason="CliExecutor",
-            message="Local executor is not supported {}.".format(executor),
+            message="Operation was canceled with `KeyboardInterrupt`.",
         )
+        sys.exit(1)
 
 
 @ops.command()
@@ -1180,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,
@@ -1248,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,
 #     )
 #
@@ -1340,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,
@@ -1386,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,
@@ -1445,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,
@@ -1550,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,
@@ -1710,9 +1851,12 @@ def artifacts(
     default=False,
     help="To set the run to failed if the upload fails.",
 )
+@click.option(
+    "--agent", "-ag", type=str, help="Optional, uuid reference of an agent to use."
+)
 @click.pass_context
 @clean_outputs
-def upload(ctx, project, uid, path_from, path_to, sync_failure):
+def upload(ctx, project, uid, path_from, path_to, sync_failure, agent):
     """Upload runs' artifacts.
 
     Uses /docs/core/cli/#caching
@@ -1728,7 +1872,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,
@@ -1743,7 +1887,7 @@ def upload(ctx, project, uid, path_from, path_to, sync_failure):
         )
         if is_file:
             response = client.upload_artifact(
-                filepath=path_from, path=path_to, overwrite=True
+                filepath=path_from, path=path_to, overwrite=True, agent=agent
             )
         else:
             response = client.upload_artifacts_dir(
@@ -1751,6 +1895,7 @@ def upload(ctx, project, uid, path_from, path_to, sync_failure):
                 path=path_to,
                 overwrite=True,
                 relative_to=path_from,
+                agent=agent,
             )
     except (
         ApiException,
@@ -1802,7 +1947,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,
@@ -1870,19 +2015,22 @@ 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)
-    get_dashboard(
-        dashboard_url=get_dashboard_url(subpath=subpath), url_only=url, yes=yes
+    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:
         from haupt.cli.viewer import sanitize_server_config, viewer
 
+        os.environ["POLYAXON_DASHBOARD_URL"] = dashboard_url
         server_config = sanitize_server_config(server_config)
         ctx.invoke(viewer, path=path, **server_config)
 
@@ -1920,7 +2068,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,
@@ -1953,8 +2101,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
@@ -1964,8 +2116,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:
@@ -1978,9 +2130,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:
@@ -2061,7 +2213,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
     )
 
@@ -2154,10 +2306,32 @@ def pull(
     help="Optional, to ignore the owner/project of the local "
     "run and use the owner/project provided or resolved from the current project.",
 )
+@click.option(
+    "--reset-uuid",
+    is_flag=True,
+    default=False,
+    help="Optional, to ignore the uuid of the local " "run and generate a new uuid.",
+)
+@click.option(
+    "--agent", "-ag", type=str, help="Optional, uuid reference of an agent to use."
+)
+@click.option("--name", "-n", type=str, help="Optional, a new name to set for the run.")
 @click.pass_context
 @clean_outputs
-def push(ctx, project, uid, all_runs, no_artifacts, clean, path, reset_project):
-    """Push an local run to a remove server.
+def push(
+    ctx,
+    project,
+    uid,
+    all_runs,
+    no_artifacts,
+    clean,
+    path,
+    reset_project,
+    reset_uuid,
+    agent,
+    name,
+):
+    """Push a local run (or all runs) to a remove server.
 
     Uses /docs/core/cli/#caching
 
@@ -2181,7 +2355,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
     )
 
@@ -2204,6 +2378,8 @@ def push(ctx, project, uid, all_runs, no_artifacts, clean, path, reset_project):
                 path=artifacts_path,
                 run_client=client,
                 reset_project=reset_project,
+                name=name,
+                reset_uuid=reset_uuid,
                 raise_if_not_found=True,
             )
         except Exception as e:
@@ -2220,6 +2396,7 @@ def push(ctx, project, uid, all_runs, no_artifacts, clean, path, reset_project):
                 path=artifacts_path,
                 upload_artifacts=not no_artifacts,
                 clean=clean,
+                agent=agent,
             )
             Printer.success(
                 f"Finished pushing offline run {uid} to {client.owner}/{client.project}"