zenml-nightly 0.80.0.dev20250326__py3-none-any.whl → 0.80.0.dev20250328__py3-none-any.whl

zenml/VERSION

@@ -1 +1 @@
-0.80.0.dev20250326
+0.80.0.dev20250328

zenml/cli/project.py

@@ -50,10 +50,14 @@ def list_projects(ctx: click.Context, /, **kwargs: Any) -> None:
     with console.status("Listing projects...\n"):
         projects = client.list_projects(**kwargs)
         if projects:
+            try:
+                active_project = [client.active_project]
+            except Exception:
+                active_project = []
             cli_utils.print_pydantic_models(
                 projects,
                 exclude_columns=["id", "created", "updated"],
-                active_models=[Client().active_project],
+                active_models=active_project,
                 show_active=not is_sorted_or_filtered(ctx),
             )
         else:
@@ -75,11 +79,18 @@ def list_projects(ctx: click.Context, /, **kwargs: Any) -> None:
     required=False,
     help="The display name of the project.",
 )
+@click.option(
+    "--set-default",
+    "set_default",
+    is_flag=True,
+    help="Set this project as the default project.",
+)
 @click.argument("project_name", type=str, required=True)
 def register_project(
     project_name: str,
     set_project: bool = False,
     display_name: Optional[str] = None,
+    set_default: bool = False,
 ) -> None:
     """Register a new project.
 
@@ -87,12 +98,13 @@ def register_project(
         project_name: The name of the project to register.
         set_project: Whether to set the project as active.
         display_name: The display name of the project.
+        set_default: Whether to set the project as the default project.
     """
     check_zenml_pro_project_availability()
     client = Client()
     with console.status("Creating project...\n"):
         try:
-            client.create_project(
+            project = client.create_project(
                 project_name,
                 description="",
                 display_name=display_name,
@@ -105,26 +117,51 @@ def register_project(
         client.set_active_project(project_name)
         cli_utils.declare(f"The active project has been set to {project_name}")
 
+    if set_default:
+        client.update_user(
+            name_id_or_prefix=client.active_user.id,
+            updated_default_project_id=project.id,
+        )
+        cli_utils.declare(
+            f"The default project has been set to {project.name}"
+        )
+
 
 @project.command("set")
 @click.argument("project_name_or_id", type=str, required=True)
-def set_project(project_name_or_id: str) -> None:
+@click.option(
+    "--default",
+    "default",
+    is_flag=True,
+    help="Set this project as the default project.",
+)
+def set_project(project_name_or_id: str, default: bool = False) -> None:
     """Set the active project.
 
     Args:
         project_name_or_id: The name or ID of the project to set as active.
+        default: Whether to set the project as the default project.
     """
     check_zenml_pro_project_availability()
     client = Client()
     with console.status("Setting project...\n"):
         try:
-            client.set_active_project(project_name_or_id)
+            project = client.set_active_project(project_name_or_id)
             cli_utils.declare(
                 f"The active project has been set to {project_name_or_id}"
             )
         except Exception as e:
             cli_utils.error(str(e))
 
+    if default:
+        client.update_user(
+            name_id_or_prefix=client.active_user.id,
+            updated_default_project_id=project.id,
+        )
+        cli_utils.declare(
+            f"The default project has been set to {project.name}"
+        )
+
 
 @project.command("describe")
 @click.argument("project_name_or_id", type=str, required=False)

zenml/client.py

@@ -235,7 +235,7 @@ class ClientConfiguration(FileSyncModel):
         else:
             raise RuntimeError(
                 "No active project is configured. Run "
-                "`zenml project set PROJECT_NAME` to set the active "
+                "`zenml project set <NAME>` to set the active "
                 "project."
             )
 
@@ -876,6 +876,7 @@ class Client(metaclass=ClientMetaClass):
         old_password: Optional[str] = None,
         updated_is_admin: Optional[bool] = None,
         updated_metadata: Optional[Dict[str, Any]] = None,
+        updated_default_project_id: Optional[UUID] = None,
         active: Optional[bool] = None,
     ) -> UserResponse:
         """Update a user.
@@ -891,6 +892,7 @@ class Client(metaclass=ClientMetaClass):
                 update.
             updated_is_admin: Whether the user should be an admin.
             updated_metadata: The new metadata for the user.
+            updated_default_project_id: The new default project ID for the user.
             active: Use to activate or deactivate the user.
 
         Returns:
@@ -928,6 +930,9 @@ class Client(metaclass=ClientMetaClass):
         if updated_metadata is not None:
             user_update.user_metadata = updated_metadata
 
+        if updated_default_project_id is not None:
+            user_update.default_project_id = updated_default_project_id
+
         return self.zen_store.update_user(
             user_id=user.id, user_update=user_update
         )
@@ -1154,7 +1159,7 @@ class Client(metaclass=ClientMetaClass):
         if not project:
             raise RuntimeError(
                 "No active project is configured. Run "
-                "`zenml project set PROJECT_NAME` to set the active "
+                "`zenml project set <NAME>` to set the active "
                 "project."
             )
 

zenml/config/global_config.py

@@ -113,7 +113,7 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
             global config.
         store: Store configuration.
         active_stack_id: The ID of the active stack.
-        active_project_name: The name of the active project.
+        active_project_id: The ID of the active project.
     """
 
     user_id: uuid.UUID = Field(default_factory=uuid.uuid4)
@@ -123,7 +123,7 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
     version: Optional[str] = None
     store: Optional[SerializeAsAny[StoreConfiguration]] = None
     active_stack_id: Optional[uuid.UUID] = None
-    active_project_name: Optional[str] = None
+    active_project_id: Optional[uuid.UUID] = None
 
     _zen_store: Optional["BaseZenStore"] = None
     _active_project: Optional["ProjectResponse"] = None
@@ -393,15 +393,15 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
         if ENV_ZENML_SERVER in os.environ:
             return
         active_project, active_stack = self.zen_store.validate_active_config(
-            self.active_project_name,
+            self.active_project_id,
             self.active_stack_id,
             config_name="global",
         )
         if active_project:
-            self.active_project_name = active_project.name
+            self.active_project_id = active_project.id
             self._active_project = active_project
         else:
-            self.active_project_name = None
+            self.active_project_id = None
             self._active_project = None
 
         self.set_active_stack(active_stack)
@@ -730,7 +730,7 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
         Returns:
             The project that was set active.
         """
-        self.active_project_name = project.name
+        self.active_project_id = project.id
         self._active_project = project
         # Sanitize the global configuration to reflect the new project
         self._sanitize_config()
@@ -751,35 +751,35 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
         Returns:
             The model of the active project.
         """
-        project_name = self.get_active_project_name()
+        project_id = self.get_active_project_id()
 
         if self._active_project is not None:
             return self._active_project
 
         project = self.zen_store.get_project(
-            project_name_or_id=project_name,
+            project_name_or_id=project_id,
         )
         return self.set_active_project(project)
 
-    def get_active_project_name(self) -> str:
-        """Get the name of the active project.
+    def get_active_project_id(self) -> UUID:
+        """Get the ID of the active project.
 
         Returns:
-            The name of the active project.
+            The ID of the active project.
 
         Raises:
             RuntimeError: If the active project is not set.
         """
-        if self.active_project_name is None:
+        if self.active_project_id is None:
             _ = self.zen_store
-            if self.active_project_name is None:
+            if self.active_project_id is None:
                 raise RuntimeError(
                     "No project is currently set as active. Please set the "
-                    "active project using the `zenml project set` CLI "
+                    "active project using the `zenml project set <NAME>` CLI "
                     "command."
                 )
 
-        return self.active_project_name
+        return self.active_project_id
 
     def get_active_stack_id(self) -> UUID:
         """Get the ID of the active stack.

zenml/integrations/databricks/__init__.py

@@ -34,11 +34,14 @@ class DatabricksIntegration(Integration):
     REQUIREMENTS_IGNORED_ON_UNINSTALL = ["numpy", "pandas"]
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(
+        cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -47,8 +50,8 @@ class DatabricksIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return cls.REQUIREMENTS + \
-            NumpyIntegration.get_requirements(target_os=target_os) + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            NumpyIntegration.get_requirements(target_os=target_os, python_version=python_version) + \
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/deepchecks/__init__.py

@@ -58,11 +58,14 @@ class DeepchecksIntegration(Integration):
         from zenml.integrations.deepchecks import materializers  # noqa
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(
+        cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -70,7 +73,7 @@ class DeepchecksIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return cls.REQUIREMENTS + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/evidently/__init__.py

@@ -60,11 +60,14 @@ class EvidentlyIntegration(Integration):
     REQUIREMENTS_IGNORED_ON_UNINSTALL = ["tenacity", "pandas"]
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(
+        cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -72,7 +75,7 @@ class EvidentlyIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return cls.REQUIREMENTS + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/facets/__init__.py

@@ -31,11 +31,14 @@ class FacetsIntegration(Integration):
         from zenml.integrations.facets import materializers  # noqa
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(
+        cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -43,5 +46,5 @@ class FacetsIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return cls.REQUIREMENTS + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)
 

zenml/integrations/feast/__init__.py

@@ -46,11 +46,13 @@ class FeastIntegration(Integration):
         return [FeastFeatureStoreFlavor]
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -58,5 +60,5 @@ class FeastIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return cls.REQUIREMENTS + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)
 

zenml/integrations/great_expectations/__init__.py

@@ -53,11 +53,13 @@ class GreatExpectationsIntegration(Integration):
         return [GreatExpectationsDataValidatorFlavor]
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -65,4 +67,4 @@ class GreatExpectationsIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return cls.REQUIREMENTS + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)

zenml/integrations/huggingface/__init__.py

@@ -37,11 +37,13 @@ class HuggingfaceIntegration(Integration):
         from zenml.integrations.huggingface import services
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Defines platform specific requirements for the integration.
 
         Args:
             target_os: The target operating system.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -59,7 +61,7 @@ class HuggingfaceIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return requirements + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/integration.py

@@ -133,11 +133,16 @@ class Integration(metaclass=IntegrationMeta):
         return True
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(
+        cls,
+        target_os: Optional[str] = None,
+        python_version: Optional[str] = None,
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator.py

@@ -238,7 +238,7 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                         )
                     if kubernetes_context != active_context:
                         logger.warning(
-                            f"{msg}the Kubernetes context "
+                            f"{msg}the Kubernetes context "  # nosec
                             f"'{kubernetes_context}' configured for the "
                             f"Kubernetes orchestrator is not the same as the "
                             f"active context in the local Kubernetes "

zenml/integrations/langchain/materializers/openai_embedding_materializer.py

@@ -13,21 +13,17 @@
 #  permissions and limitations under the License.
 """Implementation of the Langchain OpenAI embedding materializer."""
 
-import sys
-from typing import TYPE_CHECKING, Any, ClassVar, Tuple, Type
+from typing import Any, ClassVar, Tuple, Type
+
+from langchain_community.embeddings import (
+    OpenAIEmbeddings,
+)
 
 from zenml.enums import ArtifactType
 from zenml.materializers.cloudpickle_materializer import (
     CloudpickleMaterializer,
 )
 
-if TYPE_CHECKING and sys.version_info < (3, 8):
-    OpenAIEmbeddings = Any
-else:
-    from langchain_community.embeddings import (
-        OpenAIEmbeddings,
-    )
-
 
 class LangchainOpenaiEmbeddingMaterializer(CloudpickleMaterializer):
     """Materializer for Langchain OpenAI Embeddings."""

zenml/integrations/langchain/materializers/vector_store_materializer.py

@@ -13,19 +13,15 @@
 #  permissions and limitations under the License.
 """Implementation of the langchain vector store materializer."""
 
-import sys
-from typing import TYPE_CHECKING, Any, ClassVar, Tuple, Type
+from typing import Any, ClassVar, Tuple, Type
+
+from langchain.vectorstores.base import VectorStore
 
 from zenml.enums import ArtifactType
 from zenml.materializers.cloudpickle_materializer import (
     CloudpickleMaterializer,
 )
 
-if TYPE_CHECKING and sys.version_info < (3, 8):
-    VectorStore = Any
-else:
-    from langchain.vectorstores.base import VectorStore
-
 
 class LangchainVectorStoreMaterializer(CloudpickleMaterializer):
     """Handle langchain vector store objects."""

zenml/integrations/llama_index/materializers/document_materializer.py

@@ -25,12 +25,8 @@
 #     from zenml.metadata.metadata_types import MetadataType
 
 
-# if TYPE_CHECKING and sys.version_info < (3, 8):
-#     Document = Any
-#     LCDocument = Any
-# else:
-#     from langchain.docstore.document import Document as LCDocument
-#     from llama_index.readers.schema.base import Document
+# from langchain.docstore.document import Document as LCDocument
+# from llama_index.readers.schema.base import Document
 
 
 # class LlamaIndexDocumentMaterializer(LangchainDocumentMaterializer):

zenml/integrations/llama_index/materializers/gpt_index_materializer.py

@@ -34,13 +34,8 @@
 # DEFAULT_FILENAME = "index.json"
 # DEFAULT_FAISS_FILENAME = "faiss_index.json"
 
-# if TYPE_CHECKING and sys.version_info < (3, 8):
-#     BaseGPTIndex = Any
-#     GPTFaissIndex = Any
-#     T = TypeVar("T", bound=Any)
-# else:
-#     from llama_index.indices.base import BaseGPTIndex
-#     from llama_index.indices.vector_store import GPTFaissIndex
+# from llama_index.indices.base import BaseGPTIndex
+# from llama_index.indices.vector_store import GPTFaissIndex
 
 #     T = TypeVar("T", bound=BaseGPTIndex[Any])
 

zenml/integrations/mlflow/__init__.py

@@ -16,6 +16,7 @@
 The MLflow integrations currently enables you to use MLflow tracking as a
 convenient way to visualize your experiment runs within the MLflow UI.
 """
+from packaging import version
 from typing import List, Type, Optional
 
 from zenml.integrations.constants import MLFLOW
@@ -45,17 +46,21 @@ class MlflowIntegration(Integration):
     ]
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(
+        cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
         """
         from zenml.integrations.numpy import NumpyIntegration
         from zenml.integrations.pandas import PandasIntegration
+        
 
         reqs = [
             "mlflow>=2.1.1,<2.21.0",
@@ -71,7 +76,13 @@ class MlflowIntegration(Integration):
             # downgrade will not happen.
             "pydantic>=2.8.0,<2.9.0",
         ]
-        if sys.version_info.minor >= 12:
+
+        if python_version:
+            version_minor = version.parse(python_version).minor
+        else:
+            version_minor = sys.version_info.minor
+
+        if version_minor >= 12:
             logger.debug(
                 "The MLflow integration on Python 3.12 and above is not yet "
                 "fully supported: The extra dependencies 'mlserver' and "
@@ -83,8 +94,8 @@ class MlflowIntegration(Integration):
                 "mlserver-mlflow>=1.3.3",
             ])
 
-        reqs.extend(NumpyIntegration.get_requirements(target_os=target_os))
-        reqs.extend(PandasIntegration.get_requirements(target_os=target_os))
+        reqs.extend(NumpyIntegration.get_requirements(target_os=target_os, python_version=python_version))
+        reqs.extend(PandasIntegration.get_requirements(target_os=target_os, python_version=python_version))
         return reqs
 
     @classmethod

zenml/integrations/seldon/__init__.py

@@ -53,11 +53,13 @@ class SeldonIntegration(Integration):
         return [SeldonModelDeployerFlavor]
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -65,5 +67,5 @@ class SeldonIntegration(Integration):
         from zenml.integrations.numpy import NumpyIntegration
 
         return cls.REQUIREMENTS + \
-            NumpyIntegration.get_requirements(target_os=target_os)
+            NumpyIntegration.get_requirements(target_os=target_os, python_version=python_version)
 

zenml/integrations/tensorboard/__init__.py

@@ -25,11 +25,13 @@ class TensorBoardIntegration(Integration):
     REQUIREMENTS = []
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Defines platform specific requirements for the integration.
 
         Args:
             target_os: The target operating system.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.

zenml/integrations/tensorflow/__init__.py

@@ -41,11 +41,13 @@ class TensorflowIntegration(Integration):
         from zenml.integrations.tensorflow import materializers  # noqa
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Defines platform specific requirements for the integration.
 
         Args:
             target_os: The target operating system.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -60,7 +62,6 @@ class TensorflowIntegration(Integration):
                 "tensorflow>=2.12,<2.15",
                 "tensorflow_io>=0.24.0",
             ]
-        if sys.version_info.minor == 8:
-            requirements.append("typing-extensions>=4.6.1")
+
         return requirements