samgis_core 3.0.6__tar.gz → 3.0.9__tar.gz

{samgis_core-3.0.6 → samgis_core-3.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: samgis_core
-Version: 3.0.6
+Version: 3.0.9
 Summary: SamGIS CORE
 License: MIT
 Author: alessandro trinca tornidor

{samgis_core-3.0.6 → samgis_core-3.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "samgis_core"
-version = "3.0.6"
+version = "3.0.9"
 description = "SamGIS CORE"
 authors = ["alessandro trinca tornidor <alessandro@trinca.tornidor.com>"]
 license = "MIT license"
@@ -8,7 +8,7 @@ readme = "README.md"
 
 [metadata]
 name = "samgis_core"
-version = "3.0.6"
+version = "3.0.9"
 
 [tool.poetry.urls]
 Source = "https://gitlab.com/aletrn/samgis_core"
@@ -37,6 +37,7 @@ optional = true
 mpld3 = "^0.5.10"
 pytest = "^8.2.2"
 pytest-cov = "^5.0.0"
+rasterio = "^1.3.10"
 
 [build-system]
 requires = ["poetry-core"]

samgis_core-3.0.9/samgis_core/utilities/frontend_builder.py

@@ -0,0 +1,150 @@
+import os
+import subprocess
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from samgis_core import app_logger
+from samgis_core.utilities.type_hints import ListStr
+
+
+load_dotenv()
+root_folder = Path(globals().get("__file__", "./_")).absolute().parent.parent.parent
+env_project_root_folder = os.getenv("PROJECT_ROOT_FOLDER", str(root_folder))
+env_input_css_path = os.getenv("INPUT_CSS_PATH")
+
+
+def assert_envs(envs_list: ListStr) -> None:
+    """
+    Assert env variables are not empty.
+
+    Args:
+        envs_list: list of env variables
+
+    Returns:
+
+    """
+    for current_env in envs_list:
+        try:
+            assert current_env is not None and current_env != ""
+        except AssertionError as aex:
+            app_logger.error(f"error on assertion for current_env: {current_env}.")
+            raise aex
+
+
+def read_std_out_err(std_out_err: str, output_type: str, command: ListStr) -> None:
+    """
+    Capture the standard output or standard error content for a given system command pipe.
+
+    Args:
+        std_out_err: str
+        output_type: output type (stdout or stderr)
+        command: command executed
+
+    Returns:
+
+    """
+    output = std_out_err.split("\n")
+    app_logger.info(f"output type:{output_type} for command:{' '.join(command)}.")
+    for line in iter(output):
+        app_logger.info(f"output_content_home stdout:{line.strip()}.")
+    app_logger.info("########")
+
+
+def run_command(commands_list: ListStr, capture_output: bool = True, text: bool = True, check: bool = True) -> None:
+    """
+    Run a system command and capture its output.
+    See https://docs.python.org/3.11/library/subprocess.html#subprocess.run for more details
+
+    Args:
+        commands_list: list of single string commands
+        capture_output: if true, stdout and stderr will be captured
+        text: if true, capture stdout and stderr as strings
+        check: If check is true, and the process exits with a non-zero exit code, a CalledProcessError exception will
+               be raised. Attributes of that exception hold the arguments, the exit code, and stdout and stderr if they
+               were captured.
+
+    Returns:
+
+    """
+    try:
+        output_content_home = subprocess.run(
+            commands_list,
+            capture_output=capture_output,
+            text=text,
+            check=check
+        )
+        read_std_out_err(output_content_home.stdout, "stdout", commands_list)
+        read_std_out_err(output_content_home.stderr, "stderr", commands_list)
+    except Exception as ex:
+        app_logger.error(f"ex:{ex}.")
+        raise ex
+
+
+def build_frontend(
+        project_root_folder: str | Path,
+        input_css_path: str | Path,
+        output_dist_folder: Path = root_folder / "static" / "dist",
+        index_page_filename: str = "index.html",
+        output_css_filename: str = "output.css",
+        force_build: bool = False,
+    ) -> bool:
+    """
+    Build a static [Vue js](https://vuejs.org/), [tailwindcss](https://tailwindcss.com/) frontend.
+    If force_build is False, the function also check if index_page_filename and output_css_filename already exists:
+    in this case skip the build.
+
+    Args:
+        project_root_folder: Project folder that contains the static frontend
+        input_css_path: file path pointing to the input css file
+        output_dist_folder: dist folder path where to write the frontend bundle
+        index_page_filename: index html filename
+        output_css_filename: output css filename
+        force_build: useful to skip the frontend build
+
+    Returns:
+        state of the build (True in case of build completed, False in case of build skipped)
+
+    """
+    assert_envs([
+        str(project_root_folder),
+        str(input_css_path)
+    ])
+    project_root_folder = Path(project_root_folder)
+    index_html_pathfile = Path(output_dist_folder) / index_page_filename
+    output_css_pathfile = Path(output_dist_folder) / output_css_filename
+    if not force_build and output_css_pathfile.is_file() and index_html_pathfile.is_file():
+        app_logger.info("frontend ok, build_frontend not necessary...")
+        return False
+
+    # install deps
+    os.chdir(project_root_folder / "static")
+    current_folder = os.getcwd()
+    app_logger.info(f"current_folder:{current_folder}, install pnpm...")
+    run_command(["which", "npm"])
+    run_command(["npm", "install", "-g", "npm", "pnpm"])
+    app_logger.info(f"install pnpm dependencies...")
+    run_command(["pnpm", "install"])
+
+    # build frontend dist and assert for its correct build
+    output_css = str(output_dist_folder / output_css_filename)
+    output_index_html = str(output_dist_folder / index_page_filename)
+    output_dist_folder = str(output_dist_folder)
+    app_logger.info(f"pnpm: build '{output_dist_folder}'...")
+    run_command(["pnpm", "build"])
+    app_logger.info(f"pnpm: ls -l {output_index_html}:")
+    run_command(["ls", "-l", output_index_html])
+    cmd = ["pnpm", "tailwindcss", "-i", str(input_css_path), "-o", output_css]
+    app_logger.info(f"pnpm: {' '.join(cmd)}...")
+    run_command(["pnpm", "tailwindcss", "-i", str(input_css_path), "-o", output_css])
+    app_logger.info(f"pnpm: ls -l {output_css}:")
+    run_command(["ls", "-l", output_css])
+    app_logger.info(f"end!")
+    return True
+
+
+if __name__ == '__main__':
+    build_frontend(
+        project_root_folder=Path(env_project_root_folder),
+        input_css_path=Path(env_input_css_path)
+    )

samgis_core-3.0.9/samgis_core/utilities/update_requirements_txt.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+import structlog
+
+from samgis_core.utilities import session_logger
+
+
+session_logger.setup_logging(json_logs=False, log_level="INFO")
+logger = structlog.stdlib.get_logger(__name__)
+
+
+def get_dependencies_freeze() -> dict:
+    """get a 'freeze.txt'-like dict of 'name':'version' metadata about installed packages."""
+    from importlib import metadata
+    return {dist.metadata["name"]: dist.version for dist in metadata.distributions()}
+
+
+def get_requirements_txt(requirements_no_versions_filename: str | Path, requirements_output_filename: str | Path):
+    """
+    Write on disk a requirements.txt file with an updated list of dependencies from installed python packages.
+
+    Args:
+        requirements_no_versions_filename: full path of input requirements filename with no specified versions
+        requirements_output_filename: full path of output requirements.txt filename
+
+    Returns:
+
+    """
+    logger.info("start requirements.txt update...")
+    freeze_dict = get_dependencies_freeze()
+    logger.debug(f"freeze_dict:{freeze_dict}.")
+    with open(requirements_no_versions_filename) as req_src:
+        packages_no_requirements = req_src.read().split("\n")
+        requirements_output = {
+            name: version for name, version in sorted(freeze_dict.items()) if name in packages_no_requirements
+        }
+    logger.info(f"requirements to write:{requirements_output}.")
+    with open(requirements_output_filename, "w") as dst:
+        out = ""
+        for name, version in requirements_output.items():
+            out += f"{name}=={version}\n"
+        logger.debug(f"output requirements content:\n{out}!")
+        dst.write(out)
+    logger.info(f"written requirements to file:{requirements_output_filename}!")

{samgis_core-3.0.6 → samgis_core-3.0.9}/samgis_core/utilities/utilities.py

@@ -140,6 +140,18 @@ def apply_coords(coords: ndarray, embedding: EmbeddingPILImage):
 
 
 def normalize_array(arr: ndarray, new_h: int | float = 255., type_normalization: str = "int") -> ndarray:
+    """
+    Normalize numpy array between 0 and 'new_h' value. Default dtype of output array is int
+
+
+    Args:
+        arr: input numpy array
+        new_h: max value of output array
+        type_normalization: default dtype of output array
+
+    Returns:
+        numpy array
+    """
     arr = arr.astype(float)
     arr_max = np.nanmax(arr)
     arr_min = np.nanmin(arr)