polyaxon 2.1.0rc9__py3-none-any.whl → 2.6.0__py3-none-any.whl

polyaxon/_deploy/schemas/operators.py

@@ -4,11 +4,11 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class OperatorsConfig(BaseSchemaModel):
-    tfjob: Optional[bool]
-    pytorchjob: Optional[bool]
-    paddlejob: Optional[bool]
-    mpijob: Optional[bool]
-    mxjob: Optional[bool]
-    xgbjob: Optional[bool]
-    daskjob: Optional[bool]
-    rayjob: Optional[bool]
+    tfjob: Optional[bool] = None
+    pytorchjob: Optional[bool] = None
+    paddlejob: Optional[bool] = None
+    mpijob: Optional[bool] = None
+    mxjob: Optional[bool] = None
+    xgbjob: Optional[bool] = None
+    daskjob: Optional[bool] = None
+    rayjob: Optional[bool] = None

polyaxon/_deploy/schemas/proxy.py

@@ -6,11 +6,12 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class ProxyConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    use_in_ops: Optional[bool] = Field(alias="useInOps")
-    http_proxy: Optional[StrictStr] = Field(alias="httpProxy")
-    https_proxy: Optional[StrictStr] = Field(alias="httpsProxy")
-    no_proxy: Optional[StrictStr] = Field(alias="noProxy")
-    port: Optional[StrictInt]
-    host: Optional[StrictStr]
-    kind: Optional[StrictStr]
+    enabled: Optional[bool] = None
+    use_in_ops: Optional[bool] = Field(alias="useInOps", default=None)
+    http_proxy: Optional[StrictStr] = Field(alias="httpProxy", default=None)
+    https_proxy: Optional[StrictStr] = Field(alias="httpsProxy", default=None)
+    no_proxy: Optional[StrictStr] = Field(alias="noProxy", default=None)
+    port: Optional[StrictInt] = None
+    host: Optional[StrictStr] = None
+    protocol: Optional[StrictStr] = None
+    kind: Optional[StrictStr] = None

polyaxon/_deploy/schemas/rbac.py

@@ -4,4 +4,4 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class RBACConfig(BaseSchemaModel):
-    enabled: Optional[bool]
+    enabled: Optional[bool] = None

polyaxon/_deploy/schemas/root_user.py

@@ -1,12 +1,12 @@
 from typing import Optional
 
-from clipped.compact.pydantic import StrictStr, constr
+from clipped.compact.pydantic import NAME_REGEX, StrictStr, patter_constr
 from clipped.types.email import EmailStr
 
-from polyaxon._schemas.base import NAME_REGEX, BaseSchemaModel
+from polyaxon._schemas.base import BaseSchemaModel
 
 
 class RootUserConfig(BaseSchemaModel):
-    username: Optional[constr(regex=NAME_REGEX)]  # type: ignore[valid-type]
-    password: Optional[StrictStr]
-    email: Optional[EmailStr]
+    username: Optional[patter_constr(pattern=NAME_REGEX)] = None  # type: ignore[valid-type]
+    password: Optional[StrictStr] = None
+    email: Optional[EmailStr] = None

polyaxon/_deploy/schemas/security_context.py

@@ -1,27 +1,37 @@
 from typing import Optional
 
-from clipped.compact.pydantic import Field, StrictInt, StrictStr, root_validator
+from clipped.compact.pydantic import (
+    Field,
+    StrictInt,
+    StrictStr,
+    model_validator,
+    validation_after,
+)
 from clipped.config.schema import skip_partial
 
 from polyaxon._schemas.base import BaseSchemaModel
 
 
-def validate_security_context(user, group):
-    if any([user, group]) and not all([user, group]):
-        raise ValueError("Security context requires both `user` and `group` or none.")
-
-
 class SecurityContextConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    run_as_user: Optional[StrictInt] = Field(alias="runAsUser")
-    run_as_group: Optional[StrictInt] = Field(alias="runAsGroup")
-    fs_group: Optional[StrictInt] = Field(alias="fsGroup")
-    fs_group_change_policy: Optional[StrictStr] = Field(alias="fsGroupChangePolicy")
-    allow_privilege_escalation: Optional[bool] = Field(alias="allowPrivilegeEscalation")
-    run_as_non_root: Optional[bool] = Field(alias="runAsNonRoot")
+    enabled: Optional[bool] = None
+    run_as_user: Optional[StrictInt] = Field(alias="runAsUser", default=None)
+    run_as_group: Optional[StrictInt] = Field(alias="runAsGroup", default=None)
+    fs_group: Optional[StrictInt] = Field(alias="fsGroup", default=None)
+    fs_group_change_policy: Optional[StrictStr] = Field(
+        alias="fsGroupChangePolicy", default=None
+    )
+    allow_privilege_escalation: Optional[bool] = Field(
+        alias="allowPrivilegeEscalation", default=None
+    )
+    run_as_non_root: Optional[bool] = Field(alias="runAsNonRoot", default=None)
 
-    @root_validator
+    @model_validator(**validation_after)
     @skip_partial
     def validate_security_context(cls, values):
-        validate_security_context(values.get("run_as_user"), values.get("run_as_group"))
+        user = cls.get_value_for_key("run_as_user", values)
+        group = cls.get_value_for_key("run_as_group", values)
+        if any([user, group]) and not all([user, group]):
+            raise ValueError(
+                "Security context requires both `user` and `group` or none."
+            )
         return values

polyaxon/_deploy/schemas/service.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Optional
 
-from clipped.compact.pydantic import Extra, Field, StrictInt, StrictStr
+from clipped.compact.pydantic import Field, StrictInt, StrictStr
 
 from polyaxon._deploy.schemas.celery import CeleryConfig
 from polyaxon._deploy.schemas.service_types import ServiceTypes
@@ -9,114 +9,123 @@ from polyaxon._schemas.services import BaseServiceConfig
 
 
 class DeploymentService(BaseServiceConfig):
-    enabled: Optional[bool]
-    replicas: Optional[StrictInt]
-    concurrency: Optional[StrictInt]
-    per_core: Optional[bool] = Field(alias="perCore")
-    scheme: Optional[StrictStr]
+    enabled: Optional[bool] = None
+    replicas: Optional[StrictInt] = None
+    concurrency: Optional[StrictInt] = None
+    per_core: Optional[bool] = Field(alias="perCore", default=None)
+    scheme: Optional[StrictStr] = None
 
 
 class WorkerServiceConfig(DeploymentService):
-    celery: Optional[CeleryConfig]
+    celery: Optional[CeleryConfig] = None
 
 
 class AgentServiceConfig(DeploymentService):
-    instance: Optional[StrictStr]
-    token: Optional[StrictStr]
-    watch_cluster: Optional[bool] = Field(alias="watchCluster")
-    additional_namespaces: Optional[List[str]] = Field(alias="additionalNamespaces")
-    is_replica: Optional[bool] = Field(alias="isReplica")
+    instance: Optional[StrictStr] = None
+    token: Optional[StrictStr] = None
+    watch_cluster: Optional[bool] = Field(alias="watchCluster", default=None)
+    additional_namespaces: Optional[List[str]] = Field(
+        alias="additionalNamespaces", default=None
+    )
+    service_account_annotations: Optional[Dict] = Field(
+        alias="serviceAccountAnnotations", default=None
+    )
+    is_replica: Optional[bool] = Field(alias="isReplica", default=None)
 
 
 class OperatorServiceConfig(DeploymentService):
-    skip_crd: Optional[bool] = Field(alias="skipCRD")
+    skip_crd: Optional[bool] = Field(alias="skipCRD", default=None)
 
 
 class BaseService(BaseSchemaModel):
-    name: Optional[StrictStr]
-    type: Optional[ServiceTypes]
-    port: Optional[StrictInt]
-    target_port: Optional[StrictInt] = Field(alias="targetPort")
-    node_port: Optional[StrictInt] = Field(alias="nodePort")
-    annotations: Optional[Dict]
+    name: Optional[StrictStr] = None
+    type: Optional[ServiceTypes] = None
+    port: Optional[StrictInt] = None
+    target_port: Optional[StrictInt] = Field(alias="targetPort", default=None)
+    node_port: Optional[StrictInt] = Field(alias="nodePort", default=None)
+    annotations: Optional[Dict] = None
 
     class Config:
-        extra = Extra.allow
+        extra = "allow"
 
 
 class ApiServiceConfig(DeploymentService):
-    service: Optional[BaseService]
+    service: Optional[BaseService] = None
 
 
 class HooksConfig(DeploymentService):
-    load_fixtures: Optional[bool] = Field(alias="loadFixtures")
-    tables: Optional[bool] = Field(alias="tables")
-    sync_db: Optional[bool] = Field(alias="syncdb")
-    admin_user: Optional[bool] = Field(alias="adminUser")
+    load_fixtures: Optional[bool] = Field(alias="loadFixtures", default=None)
+    tables: Optional[bool] = Field(alias="tables", default=None)
+    sync_db: Optional[bool] = Field(alias="syncdb", default=None)
+    admin_user: Optional[bool] = Field(alias="adminUser", default=None)
+    default_org: Optional[bool] = Field(alias="defaultOrg", default=None)
 
 
 class ThirdPartyService(DeploymentService):
-    persistence: Optional[Dict]
+    persistence: Optional[Dict] = None
 
     class Config:
-        extra = Extra.allow
+        extra = "allow"
 
 
 class PostgresqlConfig(ThirdPartyService):
-    auth: Optional[Dict]
-    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge")
+    auth: Optional[Dict] = None
+    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge", default=None)
 
 
 class RedisConfig(ThirdPartyService):
-    image: Optional[Dict]  # type: ignore[assignment]
-    non_broker: Optional[bool] = Field(alias="nonBroker")
-    use_password: Optional[bool] = Field(alias="usePassword")
-    auth: Optional[Dict]
+    image: Optional[Dict] = None  # type: ignore[assignment]
+    non_broker: Optional[bool] = Field(alias="nonBroker", default=None)
+    use_password: Optional[bool] = Field(alias="usePassword", default=None)
+    auth: Optional[Dict] = None
 
 
 class RabbitmqConfig(ThirdPartyService):
-    auth: Optional[Dict]
+    auth: Optional[Dict] = None
 
 
 class ExternalService(BaseSchemaModel):
-    user: Optional[StrictStr]
-    password: Optional[StrictStr]
-    host: Optional[StrictStr]
-    port: Optional[StrictInt]
-    database: Optional[StrictStr]
-    use_password: Optional[bool] = Field(alias="usePassword")
-    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge")
-    pgbouncer: Optional[Dict]
-    options: Optional[Dict]
-    use_resolver: Optional[bool] = Field(alias="useResolver")
-    corporate_proxy: Optional[StrictStr] = Field(alias="corporateProxy")
+    user: Optional[StrictStr] = None
+    password: Optional[StrictStr] = None
+    host: Optional[StrictStr] = None
+    port: Optional[StrictInt] = None
+    database: Optional[StrictStr] = None
+    use_password: Optional[bool] = Field(alias="usePassword", default=None)
+    conn_max_age: Optional[StrictInt] = Field(alias="connMaxAge", default=None)
+    pgbouncer: Optional[Dict] = None
+    options: Optional[Dict] = None
+    use_resolver: Optional[bool] = Field(alias="useResolver", default=None)
+    corporate_proxy: Optional[StrictStr] = Field(alias="corporateProxy", default=None)
 
 
 class ExternalBackend(BaseSchemaModel):
-    enabled: Optional[bool]
-    backend: Optional[StrictStr]
-    options: Optional[Dict]
+    enabled: Optional[bool] = None
+    backend: Optional[StrictStr] = None
+    url: Optional[StrictStr] = None
+    options: Optional[Dict] = None
 
 
 class AuthServicesConfig(BaseSchemaModel):
-    github: Optional[ExternalBackend]
-    gitlab: Optional[ExternalBackend]
-    bitbucket: Optional[ExternalBackend]
-    google: Optional[ExternalBackend]
-    okta: Optional[ExternalBackend]
-    onelogin: Optional[ExternalBackend]
-    azuread: Optional[ExternalBackend]
+    github: Optional[ExternalBackend] = None
+    gitlab: Optional[ExternalBackend] = None
+    bitbucket: Optional[ExternalBackend] = None
+    google: Optional[ExternalBackend] = None
+    okta: Optional[ExternalBackend] = None
+    onelogin: Optional[ExternalBackend] = None
+    azuread: Optional[ExternalBackend] = None
 
 
 class ExternalServicesConfig(BaseSchemaModel):
-    redis: Optional[ExternalService]
-    rabbitmq: Optional[ExternalService]
-    postgresql: Optional[ExternalService]
-    gateway: Optional[ExternalService]
-    api: Optional[ExternalService]
-    transactions: Optional[ExternalBackend]
-    analytics: Optional[ExternalBackend]
-    metrics: Optional[ExternalBackend]
-    errors: Optional[ExternalBackend]
-    auth: Optional[AuthServicesConfig]
-    allowed_versions: Optional[List[StrictStr]] = Field(alias="allowedVersions")
+    redis: Optional[ExternalService] = None
+    rabbitmq: Optional[ExternalService] = None
+    postgresql: Optional[ExternalService] = None
+    gateway: Optional[ExternalService] = None
+    api: Optional[ExternalService] = None
+    transactions: Optional[ExternalBackend] = None
+    analytics: Optional[ExternalBackend] = None
+    metrics: Optional[ExternalBackend] = None
+    errors: Optional[ExternalBackend] = None
+    auth: Optional[AuthServicesConfig] = None
+    allowed_versions: Optional[List[StrictStr]] = Field(
+        alias="allowedVersions", default=None
+    )

polyaxon/_deploy/schemas/ssl.py

@@ -6,6 +6,6 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class SSLConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    secret_name: Optional[StrictStr] = Field(alias="secretName")
-    path: Optional[StrictStr]
+    enabled: Optional[bool] = None
+    secret_name: Optional[StrictStr] = Field(alias="secretName", default=None)
+    path: Optional[StrictStr] = None

polyaxon/_deploy/schemas/ui.py

@@ -6,9 +6,13 @@ from polyaxon._schemas.base import BaseSchemaModel
 
 
 class UIConfig(BaseSchemaModel):
-    enabled: Optional[bool]
-    offline: Optional[bool]
-    static_url: Optional[StrictStr] = Field(alias="staticUrl")
-    base_url: Optional[StrictStr] = Field(alias="baseUrl")
-    assets_version: Optional[StrictStr] = Field(alias="assetsVersion")
-    admin_enabled: Optional[bool] = Field(alias="adminEnabled")
+    enabled: Optional[bool] = None
+    offline: Optional[bool] = None
+    static_url: Optional[StrictStr] = Field(alias="staticUrl", default=None)
+    base_url: Optional[StrictStr] = Field(alias="baseUrl", default=None)
+    assets_version: Optional[StrictStr] = Field(alias="assetsVersion", default=None)
+    admin_enabled: Optional[bool] = Field(alias="adminEnabled", default=None)
+    single_url: Optional[bool] = Field(alias="singleUrl", default=None)
+    default_streams_url: Optional[StrictStr] = Field(
+        alias="defaultStreamsUrl", default=None
+    )

polyaxon/_docker/builder/builder.py

@@ -120,8 +120,11 @@ class DockerBuilder(DockerMixin):
         if not self.registries:
             return
         for registry in self.registries:
+            username = (
+                registry.username if hasattr(registry, "username") else registry.user
+            )
             self.docker.login(
-                username=registry.user,
+                username=username,
                 password=registry.password,
                 registry=registry.host_port,
                 reauth=True,

polyaxon/_docker/converter/base/containers.py

@@ -49,11 +49,8 @@ class ContainerMixin(BaseConverter):
         env: List[docker_types.V1EnvVar],
     ) -> List[docker_types.V1EnvVar]:
         def sanitize_env_dict(d: Dict):
-            return docker_types.V1EnvVar(
-                __root__={
-                    d_k: sanitize_value(d_v, handle_dict=False)
-                    for d_k, d_v in d.items()
-                }
+            return docker_types.V1EnvVar.make(
+                {d_k: sanitize_value(d_v, handle_dict=False) for d_k, d_v in d.items()}
             )
 
         results = []
@@ -63,8 +60,8 @@ class ContainerMixin(BaseConverter):
                 results.append(e)
             elif isinstance(e, tuple):
                 if e[1] is not None:
-                    e = docker_types.V1EnvVar(
-                        __root__=(e[0], sanitize_value(e[1], handle_dict=False))
+                    e = docker_types.V1EnvVar.make(
+                        (e[0], sanitize_value(e[1], handle_dict=False))
                     )
                 results.append(e)
             elif isinstance(e, docker_types.V1EnvVar):

polyaxon/_docker/converter/base/env_vars.py

@@ -42,7 +42,7 @@ class EnvMixin(BaseConverter):
             except (ValueError, TypeError) as e:
                 raise PolyaxonConverterError(e)
 
-        return docker_types.V1EnvVar(__root__=(name, value))
+        return docker_types.V1EnvVar.make((name, value))
 
     @staticmethod
     def _get_from_json_resource(
@@ -59,7 +59,7 @@ class EnvMixin(BaseConverter):
         except Exception as e:
             raise PolyaxonConverterError from e
 
-        return [docker_types.V1EnvVar(__root__=k) for k in (secret_value.items())]
+        return [docker_types.V1EnvVar.make(k) for k in (secret_value.items())]
 
     @classmethod
     def _get_env_from_json_resources(
@@ -82,10 +82,10 @@ class EnvMixin(BaseConverter):
         try:
             secret_value = orjson_loads(secret)
         except orjson.JSONDecodeError:
-            return docker_types.V1EnvVar(__root__=(key, secret))
+            return docker_types.V1EnvVar.make((key, secret))
 
         value = secret_value.get(key)
-        return docker_types.V1EnvVar(__root__=(key, value))
+        return docker_types.V1EnvVar.make((key, value))
 
     @classmethod
     def _get_items_from_json_resource(
@@ -104,7 +104,7 @@ class EnvMixin(BaseConverter):
         for item in resource.items:
             value = secret_value.get(item)
             if value:
-                items_from.append(docker_types.V1EnvVar(__root__=(item, value)))
+                items_from.append(docker_types.V1EnvVar.make((item, value)))
         return items_from
 
     @classmethod

polyaxon/_docker/converter/base/mounts.py

@@ -14,7 +14,7 @@ class MountsMixin(BaseConverter):
         volume = f"{host_path}:{mount_path}"
         if read_only:
             volume += ":ro"
-        return docker_types.V1VolumeMount(__root__=("-v", volume))
+        return docker_types.V1VolumeMount.make(("-v", volume))
 
     @staticmethod
     def _get_docker_mount(
@@ -23,7 +23,7 @@ class MountsMixin(BaseConverter):
         mount = f"type=tmpfs,destination={mount_path}"
         if read_only:
             mount += ",ro"
-        return docker_types.V1VolumeMount(__root__=("--mount", mount))
+        return docker_types.V1VolumeMount.make(("--mount", mount))
 
     @classmethod
     def _get_config_volume(cls) -> docker_types.V1VolumeMount:

polyaxon/_docker/docker_types.py

@@ -1,47 +1,72 @@
 from typing import Dict, List, Optional, Tuple, Union
 
-from clipped.compact.pydantic import Field
+from clipped.compact.pydantic import (
+    PYDANTIC_VERSION,
+    Field,
+    field_validator,
+    validation_always,
+)
 from clipped.utils.units import to_cpu_value, to_memory_bytes, to_unit_memory
 
-from polyaxon._schemas.base import BaseSchemaModel
+from polyaxon._schemas.base import BaseSchemaModel, RootModel
 
 
-class V1EnvVar(BaseSchemaModel):
-    __root__: Union[Tuple[str, str], Dict[str, str]]
+class V1EnvVar(RootModel):
+    if PYDANTIC_VERSION.startswith("2."):
+        root: Union[Tuple[str, str], Dict[str, str]]
+    else:
+        __root__: Union[Tuple[str, str], Dict[str, str]]
 
     def to_cmd(self):
-        if isinstance(self.__root__, tuple):
-            value = self.__root__
-        else:
-            value = self.__root__.items()
+        value = self.get_root()
         return [f"{value[0]}={value[1]}"]
 
 
-class V1VolumeMount(BaseSchemaModel):
-    __root__: Tuple[str, str]
+class V1VolumeMount(RootModel):
+    if PYDANTIC_VERSION.startswith("2."):
+        root: Tuple[str, str]
+    else:
+        __root__: Tuple[str, str]
 
     def to_cmd(self):
-        return list(self.__root__)
+        return list(self.get_root())
+
 
+ROOT_TYPE = Union[
+    int,
+    str,
+    List[Union[int, str]],
+    Tuple[Union[int, str], Union[int, str]],
+    Dict[Union[int, str], Union[Union[int, str], Union[int, str]]],
+]
 
-class V1ContainerPort(BaseSchemaModel):
-    __root__: Union[str, Tuple[str, str], Dict[str, str]]
+
+class V1ContainerPort(RootModel):
+    if PYDANTIC_VERSION.startswith("2."):
+        root: ROOT_TYPE
+    else:
+        __root__: ROOT_TYPE
 
     def to_cmd(self):
-        if isinstance(self.__root__, str):
-            return [self.__root__]
+        root = self.get_root()
+        if isinstance(root, (str, int)):
+            return [root]
 
-        if isinstance(self.__root__, tuple):
-            value = self.__root__
+        if isinstance(root, (list, tuple)):
+            value = root
         else:
-            value = self.__root__.items()
+            value = root.items()
         return list(value[0])
 
 
 class V1ResourceRequirements(BaseSchemaModel):
-    cpus: Optional[str]
-    memory: Optional[str]
-    gpus: Optional[str]
+    cpus: Optional[Union[str, float, int]] = None
+    memory: Optional[Union[str, float, int]] = None
+    gpus: Optional[str] = None
+
+    @field_validator("cpus", "memory", **validation_always)
+    def value_to_str(cls, v):
+        return str(v)
 
     @staticmethod
     def from_k8s_cpu(cpu: str) -> Union[str, float]:
@@ -68,15 +93,17 @@ class V1ResourceRequirements(BaseSchemaModel):
 
 
 class V1Container(BaseSchemaModel):
-    image: Optional[str]
-    name: Optional[str]
-    command: Optional[List[str]]
-    args: Optional[List[str]]
-    env: Optional[List[V1EnvVar]]
-    volume_mounts: Optional[List[V1VolumeMount]] = Field(alias="volumeMounts")
-    resources: Optional[V1ResourceRequirements]
-    ports: Optional[List[V1ContainerPort]]
-    working_dir: Optional[str] = Field(alias="workingDir")
+    image: Optional[str] = None
+    name: Optional[str] = None
+    command: Optional[List[str]] = None
+    args: Optional[List[str]] = None
+    env: Optional[List[V1EnvVar]] = None
+    volume_mounts: Optional[List[V1VolumeMount]] = Field(
+        alias="volumeMounts", default=None
+    )
+    resources: Optional[V1ResourceRequirements] = None
+    ports: Optional[List[V1ContainerPort]] = None
+    working_dir: Optional[str] = Field(alias="workingDir", default=None)
 
     def get_cmd_args(self):
         cmd_args = ["run", "--rm"]

polyaxon/_env_vars/getters/owner_entity.py

@@ -5,7 +5,7 @@ from clipped.utils.strings import validate_slug
 
 from polyaxon._constants.globals import DEFAULT
 from polyaxon._env_vars.getters.user import get_local_owner
-from polyaxon._utils.fqn_utils import get_entity_info
+from polyaxon._utils.fqn_utils import get_entity_info, split_owner_team_space
 from polyaxon.exceptions import PolyaxonClientException, PolyaxonSchemaError
 
 
@@ -31,6 +31,8 @@ def resolve_entity_info(entity: str, entity_name: str, is_cli: bool = False):
     if not owner:
         owner = settings.AUTH_CONFIG.username if settings.AUTH_CONFIG else None
 
+    owner, team = split_owner_team_space(owner)
+
     if not all([owner, entity_value]):
         message = "Please provide a valid {}.".format(entity_name)
         if is_cli:
@@ -49,4 +51,4 @@ def resolve_entity_info(entity: str, entity_name: str, is_cli: bool = False):
                 entity_name, entity_value
             )
         )
-    return owner, entity_value
+    return owner, team, entity_value

polyaxon/_env_vars/getters/project.py

@@ -7,7 +7,7 @@ from polyaxon._constants.globals import DEFAULT
 from polyaxon._env_vars.getters.user import get_local_owner
 from polyaxon._managers.project import ProjectConfigManager
 from polyaxon._utils.cache import get_local_project
-from polyaxon._utils.fqn_utils import get_entity_info
+from polyaxon._utils.fqn_utils import get_entity_info, split_owner_team_space
 from polyaxon.exceptions import PolyaxonClientException, PolyaxonSchemaError
 
 
@@ -52,6 +52,8 @@ def get_project_or_local(project=None, is_cli: bool = False):
     if not owner and (not settings.CLI_CONFIG or settings.CLI_CONFIG.is_community):
         owner = DEFAULT
 
+    owner, team = split_owner_team_space(owner)
+
     if not all([owner, project_name]):
         error_message = get_project_error_message(owner, project_name)
         if is_cli:
@@ -79,4 +81,4 @@ def get_project_or_local(project=None, is_cli: bool = False):
             sys.exit(1)
         else:
             raise PolyaxonSchemaError(error_message)
-    return owner, project_name
+    return owner, team, project_name

polyaxon/_env_vars/getters/run.py

@@ -37,9 +37,9 @@ def get_run_or_local(run_uuid=None, is_cli: bool = False):
 
 
 def get_project_run_or_local(project=None, run_uuid=None, is_cli: bool = True):
-    user, project_name = get_project_or_local(project, is_cli=is_cli)
+    owner, team, project_name = get_project_or_local(project, is_cli=is_cli)
     run_uuid = get_run_or_local(run_uuid, is_cli=is_cli)
-    return user, project_name, run_uuid
+    return owner, team, project_name, run_uuid
 
 
 def get_collect_artifacts(arg: Optional[bool] = None, default: Optional[bool] = None):
@@ -74,7 +74,10 @@ def get_run_info(run_instance: Optional[str] = None):
             "Could not get run info, "
             "please make sure this is run is correctly started by Polyaxon."
         )
+    return get_run_info_from_instance(run_instance)
 
+
+def get_run_info_from_instance(run_instance: str):
     parts = run_instance.split(".")
     if not len(parts) == 4:
         raise PolyaxonClientException(

polyaxon/_env_vars/keys.py

@@ -141,6 +141,7 @@ ENV_KEYS_PROXY_AUTH_USE_RESOLVER = "POLYAXON_PROXY_AUTH_USE_RESOLVER"
 ENV_KEYS_PROXY_HAS_FORWARD_PROXY = "POLYAXON_PROXY_HAS_FORWARD_PROXY"
 ENV_KEYS_PROXY_FORWARD_PROXY_PORT = "POLYAXON_PROXY_FORWARD_PROXY_PORT"
 ENV_KEYS_PROXY_FORWARD_PROXY_HOST = "POLYAXON_PROXY_FORWARD_PROXY_HOST"
+ENV_KEYS_PROXY_FORWARD_PROXY_PROTOCOL = "POLYAXON_PROXY_FORWARD_PROXY_PROTOCOL"
 ENV_KEYS_PROXY_FORWARD_PROXY_KIND = "POLYAXON_PROXY_FORWARD_PROXY_KIND"
 ENV_KEYS_UI_IN_SANDBOX = "POLYAXON_UI_IN_SANDBOX"
 ENV_KEYS_UI_ADMIN_ENABLED = "POLYAXON_UI_ADMIN_ENABLED"
@@ -148,6 +149,8 @@ ENV_KEYS_UI_ASSETS_VERSION = "POLYAXON_UI_ASSETS_VERSION"
 ENV_KEYS_UI_ENABLED = "POLYAXON_UI_ENABLED"
 ENV_KEYS_UI_OFFLINE = "POLYAXON_UI_OFFLINE"
 ENV_KEYS_UI_BASE_URL = "POLYAXON_UI_BASE_URL"
+ENV_KEYS_UI_SINGLE_URL = "POLYAXON_UI_SINGLE_URL"
+ENV_KEYS_UI_DEFAULT_STREAMS_URL = "POLYAXON_UI_DEFAULT_STREAMS_URL"
 ENV_KEYS_STATIC_URL = "POLYAXON_STATIC_URL"
 ENV_KEYS_DNS_USE_RESOLVER = "POLYAXON_DNS_USE_RESOLVER"
 ENV_KEYS_DNS_CUSTOM_CLUSTER = "POLYAXON_DNS_CUSTOM_CLUSTER"