zenml-nightly 0.66.0.dev20240928__py3-none-any.whl → 0.68.1.dev20241102__py3-none-any.whl

zenml/zen_server/deploy/base_provider.py

@@ -14,7 +14,7 @@
 """Base ZenML server provider class."""
 
 from abc import ABC, abstractmethod
-from typing import ClassVar, Generator, List, Optional, Tuple, Type
+from typing import ClassVar, Generator, Optional, Tuple, Type
 
 from pydantic import ValidationError
 
@@ -28,9 +28,9 @@ from zenml.services import (
     ServiceEndpointHealthMonitorConfig,
 )
 from zenml.zen_server.deploy.deployment import (
-    ServerDeployment,
-    ServerDeploymentConfig,
-    ServerDeploymentStatus,
+    LocalServerDeployment,
+    LocalServerDeploymentConfig,
+    LocalServerDeploymentStatus,
 )
 from zenml.zen_server.deploy.exceptions import (
     ServerDeploymentConfigurationError,
@@ -48,21 +48,21 @@ class BaseServerProvider(ABC):
     """
 
     TYPE: ClassVar[ServerProviderType]
-    CONFIG_TYPE: ClassVar[Type[ServerDeploymentConfig]] = (
-        ServerDeploymentConfig
+    CONFIG_TYPE: ClassVar[Type[LocalServerDeploymentConfig]] = (
+        LocalServerDeploymentConfig
     )
 
     @classmethod
     def register_as_provider(cls) -> None:
         """Register the class as a server provider."""
-        from zenml.zen_server.deploy.deployer import ServerDeployer
+        from zenml.zen_server.deploy.deployer import LocalServerDeployer
 
-        ServerDeployer.register_provider(cls)
+        LocalServerDeployer.register_provider(cls)
 
     @classmethod
     def _convert_config(
-        cls, config: ServerDeploymentConfig
-    ) -> ServerDeploymentConfig:
+        cls, config: LocalServerDeploymentConfig
+    ) -> LocalServerDeploymentConfig:
         """Convert a generic server deployment config into a provider specific config.
 
         Args:
@@ -86,9 +86,9 @@ class BaseServerProvider(ABC):
 
     def deploy_server(
         self,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         timeout: Optional[int] = None,
-    ) -> ServerDeployment:
+    ) -> LocalServerDeployment:
         """Deploy a new ZenML server.
 
         Args:
@@ -101,17 +101,15 @@ class BaseServerProvider(ABC):
             The newly created server deployment.
 
         Raises:
-            ServerDeploymentExistsError: If a deployment with the same name
-                already exists.
+            ServerDeploymentExistsError: If a deployment already exists.
         """
         try:
-            self._get_service(config.name)
+            self._get_service()
         except KeyError:
             pass
         else:
             raise ServerDeploymentExistsError(
-                f"ZenML server deployment with name '{config.name}' already "
-                f"exists"
+                f"Local {self.TYPE.value} ZenML server deployment already exists"
             )
 
         # convert the generic deployment config to a provider specific
@@ -122,9 +120,9 @@ class BaseServerProvider(ABC):
 
     def update_server(
         self,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         timeout: Optional[int] = None,
-    ) -> ServerDeployment:
+    ) -> LocalServerDeployment:
         """Update an existing ZenML server deployment.
 
         Args:
@@ -137,14 +135,13 @@ class BaseServerProvider(ABC):
             The updated server deployment.
 
         Raises:
-            ServerDeploymentNotFoundError: If a deployment with the given name
-                doesn't exist.
+            ServerDeploymentNotFoundError: If a deployment doesn't exist.
         """
         try:
-            service = self._get_service(config.name)
+            service = self._get_service()
         except KeyError:
             raise ServerDeploymentNotFoundError(
-                f"ZenML server deployment with name '{config.name}' was not "
+                f"The local {self.TYPE.value} ZenML server deployment was not "
                 f"found"
             )
 
@@ -155,19 +152,19 @@ class BaseServerProvider(ABC):
 
         if old_config == config:
             logger.info(
-                f"The {config.name} ZenML server is already configured with "
-                f"the same parameters."
+                f"The local {self.TYPE.value} ZenML server is already "
+                "configured with the same parameters."
             )
             service = self._start_service(service, timeout)
         else:
-            logger.info(f"Updating the {config.name} ZenML server.")
+            logger.info(f"Updating the local {self.TYPE.value} ZenML server.")
             service = self._update_service(service, config, timeout)
 
         return self._get_deployment(service)
 
     def remove_server(
         self,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         timeout: Optional[int] = None,
     ) -> None:
         """Tears down and removes all resources and files associated with a ZenML server deployment.
@@ -179,24 +176,23 @@ class BaseServerProvider(ABC):
                 by the provider is used.
 
         Raises:
-            ServerDeploymentNotFoundError: If a deployment with the given name
-                doesn't exist.
+            ServerDeploymentNotFoundError: If a deployment doesn't exist.
         """
         try:
-            service = self._get_service(config.name)
+            service = self._get_service()
         except KeyError:
             raise ServerDeploymentNotFoundError(
-                f"ZenML server deployment with name '{config.name}' was not "
+                f"The local {self.TYPE.value} ZenML server deployment was not "
                 f"found"
             )
 
-        logger.info(f"Removing the {config.name} ZenML server.")
+        logger.info(f"Shutting down the local {self.TYPE.value} ZenML server.")
         self._delete_service(service, timeout)
 
     def get_server(
         self,
-        config: ServerDeploymentConfig,
-    ) -> ServerDeployment:
+        config: LocalServerDeploymentConfig,
+    ) -> LocalServerDeployment:
         """Retrieve information about a ZenML server deployment.
 
         Args:
@@ -206,32 +202,21 @@ class BaseServerProvider(ABC):
             The server deployment.
 
         Raises:
-            ServerDeploymentNotFoundError: If a deployment with the given name
-                doesn't exist.
+            ServerDeploymentNotFoundError: If a deployment doesn't exist.
         """
         try:
-            service = self._get_service(config.name)
+            service = self._get_service()
         except KeyError:
             raise ServerDeploymentNotFoundError(
-                f"ZenML server deployment with name '{config.name}' was not "
+                f"The local {self.TYPE.value} ZenML server deployment was not "
                 f"found"
             )
 
         return self._get_deployment(service)
 
-    def list_servers(self) -> List[ServerDeployment]:
-        """List all server deployments managed by this provider.
-
-        Returns:
-            The list of server deployments.
-        """
-        return [
-            self._get_deployment(service) for service in self._list_services()
-        ]
-
     def get_server_logs(
         self,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         follow: bool = False,
         tail: Optional[int] = None,
     ) -> Generator[str, bool, None]:
@@ -246,14 +231,13 @@ class BaseServerProvider(ABC):
             A generator that can be accessed to get the service logs.
 
         Raises:
-            ServerDeploymentNotFoundError: If a deployment with the given name
-                doesn't exist.
+            ServerDeploymentNotFoundError: If a deployment doesn't exist.
         """
         try:
-            service = self._get_service(config.name)
+            service = self._get_service()
         except KeyError:
             raise ServerDeploymentNotFoundError(
-                f"ZenML server deployment with name '{config.name}' was not "
+                f"The local {self.TYPE.value} ZenML server deployment was not "
                 f"found"
             )
 
@@ -261,7 +245,7 @@ class BaseServerProvider(ABC):
 
     def _get_deployment_status(
         self, service: BaseService
-    ) -> ServerDeploymentStatus:
+    ) -> LocalServerDeploymentStatus:
         """Get the status of a server deployment from its service.
 
         Args:
@@ -279,14 +263,14 @@ class BaseServerProvider(ABC):
             url = service.endpoint.status.uri
         connected = url is not None and gc.store_configuration.url == url
 
-        return ServerDeploymentStatus(
+        return LocalServerDeploymentStatus(
             url=url,
             status=service.status.state,
             status_message=service.status.last_error,
             connected=connected,
         )
 
-    def _get_deployment(self, service: BaseService) -> ServerDeployment:
+    def _get_deployment(self, service: BaseService) -> LocalServerDeployment:
         """Get the server deployment associated with a service.
 
         Args:
@@ -297,7 +281,7 @@ class BaseServerProvider(ABC):
         """
         config = self._get_deployment_config(service)
 
-        return ServerDeployment(
+        return LocalServerDeployment(
             config=config,
             status=self._get_deployment_status(service),
         )
@@ -306,7 +290,7 @@ class BaseServerProvider(ABC):
     @abstractmethod
     def _get_service_configuration(
         cls,
-        server_config: ServerDeploymentConfig,
+        server_config: LocalServerDeploymentConfig,
     ) -> Tuple[
         ServiceConfig,
         ServiceEndpointConfig,
@@ -324,7 +308,7 @@ class BaseServerProvider(ABC):
     @abstractmethod
     def _create_service(
         self,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         timeout: Optional[int] = None,
     ) -> BaseService:
         """Create, start and return a service instance for a ZenML server deployment.
@@ -343,7 +327,7 @@ class BaseServerProvider(ABC):
     def _update_service(
         self,
         service: BaseService,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         timeout: Optional[int] = None,
     ) -> BaseService:
         """Update an existing service instance for a ZenML server deployment.
@@ -411,12 +395,9 @@ class BaseServerProvider(ABC):
         """
 
     @abstractmethod
-    def _get_service(self, server_name: str) -> BaseService:
+    def _get_service(self) -> BaseService:
         """Get the service instance associated with a ZenML server deployment.
 
-        Args:
-            server_name: The server deployment name.
-
         Returns:
             The service instance.
 
@@ -424,18 +405,10 @@ class BaseServerProvider(ABC):
             KeyError: If the server deployment is not found.
         """
 
-    @abstractmethod
-    def _list_services(self) -> List[BaseService]:
-        """Get all service instances for all deployed ZenML servers.
-
-        Returns:
-            A list of service instances.
-        """
-
     @abstractmethod
     def _get_deployment_config(
         self, service: BaseService
-    ) -> ServerDeploymentConfig:
+    ) -> LocalServerDeploymentConfig:
         """Recreate the server deployment config from a service instance.
 
         Args:

zenml/zen_server/deploy/{local → daemon}/__init__.py

@@ -11,10 +11,10 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
-"""ZenML Server Local Deployment."""
+"""ZenML Server Local Daemon Deployment."""
 
-from zenml.zen_server.deploy.local.local_provider import LocalServerProvider
+from zenml.zen_server.deploy.daemon.daemon_provider import DaemonServerProvider
 
 __all__ = [
-    "LocalServerProvider",
+    "DaemonServerProvider",
 ]

zenml/zen_server/deploy/{local/local_provider.py → daemon/daemon_provider.py}

@@ -11,10 +11,10 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
-"""Zen Server local provider implementation."""
+"""Zen Server daemon provider implementation."""
 
 import shutil
-from typing import ClassVar, List, Optional, Tuple, Type, cast
+from typing import ClassVar, Optional, Tuple, Type, cast
 from uuid import uuid4
 
 from zenml import __version__
@@ -32,24 +32,24 @@ from zenml.services import (
     ServiceEndpointProtocol,
 )
 from zenml.zen_server.deploy.base_provider import BaseServerProvider
-from zenml.zen_server.deploy.deployment import ServerDeploymentConfig
-from zenml.zen_server.deploy.local.local_zen_server import (
-    LOCAL_ZENML_SERVER_DEFAULT_TIMEOUT,
+from zenml.zen_server.deploy.daemon.daemon_zen_server import (
+    DAEMON_ZENML_SERVER_DEFAULT_TIMEOUT,
     ZEN_SERVER_HEALTHCHECK_URL_PATH,
-    LocalServerDeploymentConfig,
-    LocalZenServer,
-    LocalZenServerConfig,
+    DaemonServerDeploymentConfig,
+    DaemonZenServer,
+    DaemonZenServerConfig,
 )
+from zenml.zen_server.deploy.deployment import LocalServerDeploymentConfig
 
 logger = get_logger(__name__)
 
 
-class LocalServerProvider(BaseServerProvider):
-    """Local ZenML server provider."""
+class DaemonServerProvider(BaseServerProvider):
+    """Daemon ZenML server provider."""
 
-    TYPE: ClassVar[ServerProviderType] = ServerProviderType.LOCAL
-    CONFIG_TYPE: ClassVar[Type[ServerDeploymentConfig]] = (
-        LocalServerDeploymentConfig
+    TYPE: ClassVar[ServerProviderType] = ServerProviderType.DAEMON
+    CONFIG_TYPE: ClassVar[Type[LocalServerDeploymentConfig]] = (
+        DaemonServerDeploymentConfig
     )
 
     @staticmethod
@@ -68,7 +68,7 @@ class LocalServerProvider(BaseServerProvider):
         except ImportError:
             # Unable to import the ZenML Server dependencies.
             raise RuntimeError(
-                "The local ZenML server provider is unavailable because the "
+                "The local daemon ZenML server provider is unavailable because the "
                 "ZenML server requirements seems to be unavailable on your machine. "
                 "This is probably because ZenML was installed without the optional "
                 "ZenML Server dependencies. To install the missing dependencies "
@@ -78,7 +78,7 @@ class LocalServerProvider(BaseServerProvider):
     @classmethod
     def _get_service_configuration(
         cls,
-        server_config: ServerDeploymentConfig,
+        server_config: LocalServerDeploymentConfig,
     ) -> Tuple[
         ServiceConfig,
         ServiceEndpointConfig,
@@ -92,12 +92,12 @@ class LocalServerProvider(BaseServerProvider):
         Returns:
             The service, service endpoint and endpoint monitor configuration.
         """
-        assert isinstance(server_config, LocalServerDeploymentConfig)
+        assert isinstance(server_config, DaemonServerDeploymentConfig)
         return (
-            LocalZenServerConfig(
-                root_runtime_path=LocalZenServer.config_path(),
+            DaemonZenServerConfig(
+                root_runtime_path=DaemonZenServer.config_path(),
                 singleton=True,
-                name=server_config.name,
+                name=ServerProviderType.DAEMON.value,
                 blocking=server_config.blocking,
                 server=server_config,
             ),
@@ -115,10 +115,10 @@ class LocalServerProvider(BaseServerProvider):
 
     def _create_service(
         self,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         timeout: Optional[int] = None,
     ) -> BaseService:
-        """Create, start and return the local ZenML server deployment service.
+        """Create, start and return the local daemon ZenML server deployment service.
 
         Args:
             config: The server deployment configuration.
@@ -131,16 +131,16 @@ class LocalServerProvider(BaseServerProvider):
         Raises:
             RuntimeError: If a local service is already running.
         """
-        assert isinstance(config, LocalServerDeploymentConfig)
+        assert isinstance(config, DaemonServerDeploymentConfig)
 
         if timeout is None:
-            timeout = LOCAL_ZENML_SERVER_DEFAULT_TIMEOUT
+            timeout = DAEMON_ZENML_SERVER_DEFAULT_TIMEOUT
 
         self.check_local_server_dependencies()
-        existing_service = LocalZenServer.get_service()
+        existing_service = DaemonZenServer.get_service()
         if existing_service:
             raise RuntimeError(
-                f"A local ZenML server with name '{existing_service.config.name}' "
+                f"A local daemon ZenML server with name '{existing_service.config.name}' "
                 f"is already running. Please stop it first before starting a "
                 f"new one."
             )
@@ -156,7 +156,7 @@ class LocalServerProvider(BaseServerProvider):
                 config=monitor_cfg,
             ),
         )
-        service = LocalZenServer(
+        service = DaemonZenServer(
             uuid=uuid4(), config=service_config, endpoint=endpoint
         )
         service.start(timeout=timeout)
@@ -165,10 +165,10 @@ class LocalServerProvider(BaseServerProvider):
     def _update_service(
         self,
         service: BaseService,
-        config: ServerDeploymentConfig,
+        config: LocalServerDeploymentConfig,
         timeout: Optional[int] = None,
     ) -> BaseService:
-        """Update the local ZenML server deployment service.
+        """Update the local daemon ZenML server deployment service.
 
         Args:
             service: The service instance.
@@ -180,7 +180,7 @@ class LocalServerProvider(BaseServerProvider):
             The updated service instance.
         """
         if timeout is None:
-            timeout = LOCAL_ZENML_SERVER_DEFAULT_TIMEOUT
+            timeout = DAEMON_ZENML_SERVER_DEFAULT_TIMEOUT
 
         (
             new_config,
@@ -209,7 +209,7 @@ class LocalServerProvider(BaseServerProvider):
         service: BaseService,
         timeout: Optional[int] = None,
     ) -> BaseService:
-        """Start the local ZenML server deployment service.
+        """Start the local daemon ZenML server deployment service.
 
         Args:
             service: The service instance.
@@ -220,7 +220,7 @@ class LocalServerProvider(BaseServerProvider):
             The updated service instance.
         """
         if timeout is None:
-            timeout = LOCAL_ZENML_SERVER_DEFAULT_TIMEOUT
+            timeout = DAEMON_ZENML_SERVER_DEFAULT_TIMEOUT
 
         service.start(timeout=timeout)
         return service
@@ -230,7 +230,7 @@ class LocalServerProvider(BaseServerProvider):
         service: BaseService,
         timeout: Optional[int] = None,
     ) -> BaseService:
-        """Stop the local ZenML server deployment service.
+        """Stop the local daemon ZenML server deployment service.
 
         Args:
             service: The service instance.
@@ -241,7 +241,7 @@ class LocalServerProvider(BaseServerProvider):
             The updated service instance.
         """
         if timeout is None:
-            timeout = LOCAL_ZENML_SERVER_DEFAULT_TIMEOUT
+            timeout = DAEMON_ZENML_SERVER_DEFAULT_TIMEOUT
 
         service.stop(timeout=timeout)
         return service
@@ -251,26 +251,23 @@ class LocalServerProvider(BaseServerProvider):
         service: BaseService,
         timeout: Optional[int] = None,
     ) -> None:
-        """Remove the local ZenML server deployment service.
+        """Remove the local daemon ZenML server deployment service.
 
         Args:
             service: The service instance.
             timeout: The timeout in seconds to wait until the service is
                 removed.
         """
-        assert isinstance(service, LocalZenServer)
+        assert isinstance(service, DaemonZenServer)
 
         if timeout is None:
-            timeout = LOCAL_ZENML_SERVER_DEFAULT_TIMEOUT
+            timeout = DAEMON_ZENML_SERVER_DEFAULT_TIMEOUT
 
         service.stop(timeout)
-        shutil.rmtree(LocalZenServer.config_path())
+        shutil.rmtree(DaemonZenServer.config_path())
 
-    def _get_service(self, server_name: str) -> BaseService:
-        """Get the local ZenML server deployment service.
-
-        Args:
-            server_name: The server deployment name.
+    def _get_service(self) -> BaseService:
+        """Get the local daemon ZenML server deployment service.
 
         Returns:
             The service instance.
@@ -278,31 +275,15 @@ class LocalServerProvider(BaseServerProvider):
         Raises:
             KeyError: If the server deployment is not found.
         """
-        service = LocalZenServer.get_service()
+        service = DaemonZenServer.get_service()
         if service is None:
-            raise KeyError("The local ZenML server is not deployed.")
-
-        if service.config.name != server_name:
-            raise KeyError(
-                "The local ZenML server is deployed but with a different name."
-            )
+            raise KeyError("The local daemon ZenML server is not deployed.")
 
         return service
 
-    def _list_services(self) -> List[BaseService]:
-        """Get all service instances for all deployed ZenML servers.
-
-        Returns:
-            A list of service instances.
-        """
-        service = LocalZenServer.get_service()
-        if service:
-            return [service]
-        return []
-
     def _get_deployment_config(
         self, service: BaseService
-    ) -> ServerDeploymentConfig:
+    ) -> LocalServerDeploymentConfig:
         """Recreate the server deployment configuration from a service instance.
 
         Args:
@@ -311,8 +292,8 @@ class LocalServerProvider(BaseServerProvider):
         Returns:
             The server deployment configuration.
         """
-        server = cast(LocalZenServer, service)
+        server = cast(DaemonZenServer, service)
         return server.config.server
 
 
-LocalServerProvider.register_as_provider()
+DaemonServerProvider.register_as_provider()