Feature: Workflow module implementation

Pipfile

@@ -10,20 +10,20 @@ requests = "*"
 cerberus = "*"
 defusedxml = "*"
 xmltodict = "*"
-jinja2 = "*"
 python-dotenv = "*"
+pydantic = "*"
 
 [dev-packages]
 pytest = "*"
 mypy = "*"
 pylint = "*"
 flake8 = "*"
 black = {extras = ["d"], version = "*"}
-var-dump = "*"
 types-pyyaml = "*"
 types-requests = "*"
 pytest-cov = "*"
 coveralls = "*"
+icecream = "*"
 
 [requires]
 python_version = "3.11"

chk/console/main.py

@@ -1,10 +1,8 @@
 """Commands"""
 
 import typing
-from os import environ
 
 import click
-from dotenv import load_dotenv
 
 import chk.modules.fetch as fetch_executor
 import chk.modules.validate as validate_executor
@@ -30,12 +28,10 @@ def combine_initial_variables(external_vars: str, **kwargs: typing.Any) -> dict:
     """Reads a json string and converts to dict, and combines with env and dotenv
     variables"""
 
-    load_dotenv()
+    return load_variables_as_dict(external_vars, **kwargs)
 
-    return load_variables_as_dict(external_vars, **kwargs) | {"_ENV": dict(environ)}
 
-
-def after_hook(resp: object) -> None:
+def after_hook(resp: dict) -> None:
     """Saves custom data from commands to global context bus
 
     Args:

chk/infrastructure/document.py

@@ -1,9 +1,11 @@
 """
 Base document and utility
 """
+
 import dataclasses
 
 import cerberus
+from pydantic import BaseModel, Field
 
 from chk.infrastructure.file_loader import FileContext
 
@@ -18,11 +20,22 @@ class VersionedDocument:
     version: str = dataclasses.field(default_factory=str)
 
 
+class VersionedDocumentV2(BaseModel):
+    """
+    versioned document entity
+    """
+
+    context: tuple = Field(default_factory=tuple)
+    version: str = Field(default_factory=str)
+
+
 class VersionedDocumentSupport:
     """DocumentVersionSupport"""
 
     @staticmethod
-    def validate_with_schema(schema: dict, doc: VersionedDocument) -> bool:
+    def validate_with_schema(
+        schema: dict, doc: VersionedDocument | VersionedDocumentV2
+    ) -> bool:
         """Validate a document with given schema
 
         Args:

chk/infrastructure/file_loader.py

@@ -1,11 +1,14 @@
 """
 File loader utility
 """
+
+from __future__ import annotations
+
 import hashlib
-from typing import NamedTuple
+import json
 from pathlib import Path
+from typing import NamedTuple
 
-import json
 import yaml
 
 from chk.infrastructure.typing_extras import JsonDecodingError
@@ -81,7 +84,7 @@ class FileContext(NamedTuple):
     filepath_hash: str = ""
 
     @staticmethod
-    def from_file(file: str, **kwarg: dict) -> "FileContext":
+    def from_file(file: str, **kwarg: dict) -> FileContext:
         FileLoader.is_file_ok(file)
         absolute_path = str(Path(file).absolute())
         fpath_hash = hashlib.sha256(absolute_path.encode("utf-8")).hexdigest()
@@ -95,31 +98,48 @@ def from_file(file: str, **kwarg: dict) -> "FileContext":
             arguments=kwarg["arguments"] if "arguments" in kwarg else {},
         )
 
+    @property
+    def filepath_as_path(self) -> Path:
+        """Get filepath as Path"""
 
-class PathFrom:
-    """Utility to expand to full path"""
+        return Path(self.filepath)
 
-    def __init__(self, base: Path):
-        self.base = base.absolute().parent
+    @property
+    def filepath_base_as_path(self) -> Path:
+        """Get filepath parent or base as Path"""
 
-    def absolute(self, target: str) -> str:
-        """Find absolute in comparison to base URL"""
+        return Path(self.filepath).absolute().parent
 
-        if target.startswith("./") or target.startswith("../"):
-            if self.base.exists():
-                to_path = self.base
 
-                target_path_sp = target.split("/")
-                for part in target_path_sp:
-                    if part == "..":
-                        to_path = to_path.parent
-                    else:
-                        to_path = Path(str(to_path) + "/" + part)
+def generate_abs_path(base_: str, target_: str) -> str:
+    """Generate absolute path in comparison to base path
+    Args:
+        base_: str, base path to calculate from
+        target_: str, file path that need absolute path
 
-                return str(to_path)
-            raise ValueError("Invalid base path.")
+    Returns:
+        Absolute path for given filepath
+    """
+
+    base = Path(base_)
+    base_abs = base.absolute().parent if base.is_file() else base.absolute()
+
+    if not base_abs.exists():
+        raise ValueError("Invalid base path.")
+    if not (target_.startswith("./") or target_.startswith("../")):
         raise ValueError("Invalid target path.")
 
+    to_path = base_abs
+    target_path_sp = target_.split("/")
+
+    for part in target_path_sp:
+        if part == "..":
+            to_path = to_path.parent
+        else:
+            to_path = to_path / part
+
+    return str(to_path)
+
 
 class ExecuteContext(NamedTuple):
     """Information storage for execution context"""

chk/infrastructure/helper.py

@@ -1,7 +1,9 @@
 """
 Helper functions module
 """
+
 import ast
+import re
 from collections.abc import Callable
 from typing import Any
 
@@ -157,6 +159,16 @@ def to_auto(var: str) -> Any:
 
         return var
 
+    @staticmethod
+    def try_dict(to_dict: Any, say_exception: bool = False) -> dict | Any:
+        try:
+            return dict(to_dict)
+        except ValueError as ex:
+            if say_exception:
+                raise ex
+            else:
+                return to_dict
+
 
 def formatter(message: object, cb: Callable = str, dump: bool = True) -> str:
     """Format message with given callback
@@ -175,3 +187,16 @@ def formatter(message: object, cb: Callable = str, dump: bool = True) -> str:
         click.echo(printable)
 
     return printable
+
+
+def slugify(string: str) -> str:
+    """Make slug out of string"""
+
+    if not isinstance(string, str):
+        raise TypeError("slugify: only string value supported.")
+
+    string = string.lower().strip()
+    string = re.sub(r"[^\w\s-]", "", string)
+    string = re.sub(r"[\s_-]+", "-", string)
+    string = re.sub(r"-{2,}", "", string)
+    return string