CLI command kedro viz build added

README.md

@@ -147,6 +147,12 @@ Options:
   -h, --help          Show this message and exit.
 ```
 
+To create a build directory of your local Kedro-Viz instance with static data from the command line, use the following command from the root folder of your Kedro project:
+
+```bash
+kedro viz build
+```
+
 ### Experiment Tracking usage
 
 To enable [experiment tracking](https://docs.kedro.org/en/stable/experiment_tracking/index.html) in Kedro-Viz, you need to add the Kedro-Viz `SQLiteStore` to your Kedro project.

RELEASE.md

@@ -5,8 +5,12 @@ Please follow the established format:
 - Use present tense (e.g. 'Add new feature')
 - Include the ID number for the related PR (or PRs) in parentheses
 -->
+
 # Upcoming Release
 
+## Major features and improvements
+- Add build command to the CLI using `kedro viz build` for creating build directory of local Kedro Viz instance with static data. (#1615)
+
 ## Bug fixes and other changes
 
 - Set Kedro Viz start method to spawn process while launching it from Jupyter Notebook. (#1696)

package/kedro_viz/integrations/deployment/__init__.py

@@ -0,0 +1,2 @@
+"""`kedro_viz.integrations.deployment` provides interface to
+integrate Kedro viz with deployers."""

package/kedro_viz/integrations/deployment/base_deployer.py

@@ -0,0 +1,110 @@
+"""`kedro_viz.integrations.deployment.base_deployer` defines
+creation of Kedro-viz build"""
+
+import abc
+import json
+import logging
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader
+from packaging.version import parse
+
+from kedro_viz import __version__
+from kedro_viz.api.rest.responses import save_api_responses_to_fs
+from kedro_viz.integrations.kedro import telemetry as kedro_telemetry
+
+_HTML_DIR = Path(__file__).parent.parent.parent.absolute() / "html"
+_METADATA_PATH = "api/deploy-viz-metadata"
+
+logger = logging.getLogger(__name__)
+
+
+class BaseDeployer(abc.ABC):
+    """A class to handle the creation of Kedro-viz build.
+
+    Attributes:
+        _path (str): build path name.
+        _fs (fsspec.filesystem): Filesystem for local/remote protocol.
+
+    Methods:
+        deploy_and_get_url(): Deploy Kedro-viz to cloud storage provider/local and return its URL.
+    """
+
+    def __init__(self):
+        self._path = None
+        self._fs = None
+
+    def _upload_api_responses(self):
+        """Write API responses to the build."""
+        save_api_responses_to_fs(self._path)
+
+    def _ingest_heap_analytics(self):
+        """Ingest heap analytics to index file in the build."""
+        project_path = Path.cwd().absolute()
+        heap_app_id = kedro_telemetry.get_heap_app_id(project_path)
+        heap_user_identity = kedro_telemetry.get_heap_identity()
+        should_add_telemetry = bool(heap_app_id) and bool(heap_user_identity)
+        html_content = (_HTML_DIR / "index.html").read_text(encoding="utf-8")
+        injected_head_content = []
+
+        env = Environment(loader=FileSystemLoader(_HTML_DIR))
+
+        if should_add_telemetry:
+            logger.debug("Ingesting heap analytics.")
+            telemetry_content = env.get_template("telemetry.html").render(
+                heap_app_id=heap_app_id, heap_user_identity=heap_user_identity
+            )
+            injected_head_content.append(telemetry_content)
+
+        injected_head_content.append("</head>")
+        html_content = html_content.replace("</head>", "\n".join(injected_head_content))
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_file_path = f"{temp_dir}/index.html"
+
+            with open(temp_file_path, "w", encoding="utf-8") as temp_index_file:
+                temp_index_file.write(html_content)
+
+            self._fs.put(temp_file_path, f"{self._path}/")
+
+    def _upload_static_files(self, html_dir: Path):
+        """Upload static HTML files to Build."""
+        logger.debug("Uploading static html files to %s.", self._path)
+        try:
+            self._fs.put(f"{str(html_dir)}/*", str(self._path), recursive=True)
+            self._ingest_heap_analytics()
+        except Exception as exc:  # pragma: no cover
+            logger.exception("Upload failed: %s ", exc)
+            raise exc
+
+    def _upload_deploy_viz_metadata_file(self):
+        """Create and write metadta file to api folder"""
+
+        logger.debug(
+            "Creating and Uploading deploy viz metadata file to %s.",
+            self._path,
+        )
+
+        try:
+            metadata = {
+                "timestamp": datetime.utcnow().strftime("%d.%m.%Y %H:%M:%S"),
+                "version": str(parse(__version__)),
+            }
+            with self._fs.open(f"{self._path}/{_METADATA_PATH}", "w") as metadata_file:
+                metadata_file.write(json.dumps(metadata))
+        except Exception as exc:  # pragma: no cover
+            logger.exception("Upload failed: %s ", exc)
+            raise exc
+
+    def deploy(self):
+        """Create and deploy all static files to local/remote file system"""
+
+        self._upload_api_responses()
+        self._upload_static_files(_HTML_DIR)
+        self._upload_deploy_viz_metadata_file()
+
+    @abc.abstractmethod
+    def deploy_and_get_url(self):
+        """Abstract method to deploy and return the URL."""

package/kedro_viz/integrations/deployment/deployer_factory.py

@@ -0,0 +1,18 @@
+"""`kedro_viz.integrations.deployment.deployer_factory` creates
+Kedro-viz deployer class instances"""
+
+from kedro_viz.integrations.deployment.local_deployer import LocalDeployer
+from kedro_viz.integrations.deployment.s3_deployer import S3Deployer
+
+
+class DeployerFactory:
+    """A class to handle creation of deployer class instances."""
+
+    @staticmethod
+    def create_deployer(platform, region=None, bucket_name=None):
+        """Instantiate Kedro-viz deployer classes"""
+        if platform == "s3":
+            return S3Deployer(region, bucket_name)
+        if platform == "local":
+            return LocalDeployer()
+        raise ValueError(f"Invalid platform '{platform}' specified")

package/kedro_viz/integrations/deployment/local_deployer.py

@@ -0,0 +1,38 @@
+"""`kedro_viz.integrations.deployment.base_deployer` defines
+creation of Kedro-viz build"""
+
+import logging
+from pathlib import Path
+
+import fsspec
+
+from kedro_viz import __version__
+from kedro_viz.integrations.deployment.base_deployer import BaseDeployer
+
+_BUILD_PATH = "build"
+_FILE_PROTOCOL = "file"
+
+logger = logging.getLogger(__name__)
+
+
+class LocalDeployer(BaseDeployer):
+    """A class to handle the creation of Kedro-viz build folder.
+
+    Attributes:
+        _build_path (str): build path name.
+        _local_fs (fsspec.filesystem): Filesystem for local file protocol.
+
+    Methods:
+        deploy_and_get_url(): The creation of Kedro-viz build folder.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._path = Path(_BUILD_PATH)
+        self._path.mkdir(parents=True, exist_ok=True)
+        self._fs = fsspec.filesystem(_FILE_PROTOCOL)
+
+    def deploy_and_get_url(self):
+        """Copy Kedro-viz to local build folder and return its URL."""
+        self.deploy()
+        return self._path

package/kedro_viz/integrations/deployment/s3_deployer.py

@@ -1,28 +1,19 @@
 """`kedro_viz.integrations.deployment.s3_deployer` defines
 deployment class for AWS S3"""
 
-import json
 import logging
-import tempfile
-from datetime import datetime
-from pathlib import Path
 
 import fsspec
-from jinja2 import Environment, FileSystemLoader
-from packaging.version import parse
 
 from kedro_viz import __version__
-from kedro_viz.api.rest.responses import save_api_responses_to_fs
-from kedro_viz.integrations.kedro import telemetry as kedro_telemetry
+from kedro_viz.integrations.deployment.base_deployer import BaseDeployer
 
-_HTML_DIR = Path(__file__).parent.parent.parent.absolute() / "html"
-_METADATA_PATH = "api/deploy-viz-metadata"
 _S3_PROTOCOL = "s3"
 
 logger = logging.getLogger(__name__)
 
 
-class S3Deployer:
+class S3Deployer(BaseDeployer):
     """A class to handle the deployment of Kedro-viz to AWS S3.
 
     Attributes:
@@ -42,79 +33,13 @@ def __init__(self, region, bucket_name):
             region (str): AWS region to deploy to.
             bucket_name (str): Name of the S3 bucket.
         """
+        super().__init__()
         self._region = region
         self._bucket_name = bucket_name
-        self._bucket_path = f"{_S3_PROTOCOL}://{bucket_name}"
-        self._remote_fs = fsspec.filesystem(_S3_PROTOCOL)
-
-    def _upload_api_responses(self):
-        """Upload API responses to S3."""
-        save_api_responses_to_fs(self._bucket_path)
-
-    def _ingest_heap_analytics(self):
-        """Ingest heap analytics to index file in the build folder."""
-        project_path = Path.cwd().absolute()
-        heap_app_id = kedro_telemetry.get_heap_app_id(project_path)
-        heap_user_identity = kedro_telemetry.get_heap_identity()
-        should_add_telemetry = bool(heap_app_id) and bool(heap_user_identity)
-        html_content = (_HTML_DIR / "index.html").read_text(encoding="utf-8")
-        injected_head_content = []
-
-        env = Environment(loader=FileSystemLoader(_HTML_DIR))
-
-        if should_add_telemetry:
-            logger.debug("Ingesting heap analytics.")
-            telemetry_content = env.get_template("telemetry.html").render(
-                heap_app_id=heap_app_id, heap_user_identity=heap_user_identity
-            )
-            injected_head_content.append(telemetry_content)
-
-        injected_head_content.append("</head>")
-        html_content = html_content.replace("</head>", "\n".join(injected_head_content))
-
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_file_path = f"{temp_dir}/index.html"
-
-            with open(temp_file_path, "w", encoding="utf-8") as temp_index_file:
-                temp_index_file.write(html_content)
-
-            self._remote_fs.put(temp_file_path, f"{self._bucket_path}/")
-
-    def _upload_static_files(self, html_dir: Path):
-        """Upload static HTML files to S3."""
-        logger.debug("Uploading static html files to %s.", self._bucket_path)
-        try:
-            self._remote_fs.put(f"{str(html_dir)}/*", self._bucket_path, recursive=True)
-            self._ingest_heap_analytics()
-        except Exception as exc:  # pragma: no cover
-            logger.exception("Upload failed: %s ", exc)
-            raise exc
-
-    def _upload_deploy_viz_metadata_file(self):
-        logger.debug(
-            "Creating and Uploading deploy viz metadata file to %s.",
-            self._bucket_path,
-        )
-
-        try:
-            metadata = {
-                "timestamp": datetime.utcnow().strftime("%d.%m.%Y %H:%M:%S"),
-                "version": str(parse(__version__)),
-            }
-            with self._remote_fs.open(
-                f"{self._bucket_path}/{_METADATA_PATH}", "w"
-            ) as metadata_file:
-                metadata_file.write(json.dumps(metadata))
-        except Exception as exc:  # pragma: no cover
-            logger.exception("Upload failed: %s ", exc)
-            raise exc
-
-    def _deploy(self):
-        self._upload_api_responses()
-        self._upload_static_files(_HTML_DIR)
-        self._upload_deploy_viz_metadata_file()
+        self._path = f"{_S3_PROTOCOL}://{bucket_name}"
+        self._fs = fsspec.filesystem(_S3_PROTOCOL)
 
     def deploy_and_get_url(self):
         """Deploy Kedro-viz to S3 and return its URL."""
-        self._deploy()
+        self.deploy()
         return f"http://{self._bucket_name}.s3-website.{self._region}.amazonaws.com"

package/kedro_viz/launchers/cli.py

@@ -13,7 +13,7 @@
 
 from kedro_viz import __version__
 from kedro_viz.constants import AWS_REGIONS, DEFAULT_HOST, DEFAULT_PORT
-from kedro_viz.integrations.deployment.s3_deployer import S3Deployer
+from kedro_viz.integrations.deployment.deployer_factory import DeployerFactory
 from kedro_viz.integrations.pypi import get_latest_version, is_running_outdated_version
 from kedro_viz.launchers.utils import (
     _check_viz_up,
@@ -238,7 +238,7 @@ def deploy(region, bucket_name):
         load_and_populate_data(Path.cwd(), ignore_plugins=True)
 
         # Start the deployment
-        deployer = S3Deployer(region, bucket_name)
+        deployer = DeployerFactory.create_deployer("s3", region, bucket_name)
         url = deployer.deploy_and_get_url()
 
         click.echo(
@@ -270,3 +270,30 @@ def deploy(region, bucket_name):
         )
     finally:
         viz_deploy_timer.terminate()
+
+
+@viz.command(context_settings={"help_option_names": ["-h", "--help"]})
+def build():
+    """Create build directory of local Kedro Viz instance with static data"""
+
+    try:
+        load_and_populate_data(Path.cwd(), ignore_plugins=True)
+        deployer = DeployerFactory.create_deployer("local")
+        url = deployer.deploy_and_get_url()
+
+        click.echo(
+            click.style(
+                "\u2728 Success! Kedro-Viz build files have been successfully added to the "
+                f"{url} directory.",
+                fg="green",
+            )
+        )
+
+    # pylint: disable=broad-exception-caught
+    except Exception as exc:  # pragma: no cover
+        click.echo(
+            click.style(
+                f"ERROR: Failed to build Kedro-Viz : {exc} ",
+                fg="red",
+            )
+        )