hcs-core 0.1.250__py3-none-any.whl → 0.1.316__py3-none-any.whl

hcs_core/ctxp/context.py

@@ -13,8 +13,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from .jsondot import dotdict
-from .profile_store import profile_store, fstore
+import json
+import re
+from typing import Any
+
+from . import jsondot
+from .profile_store import fstore, profile_store
 
 
 def _store() -> fstore:
@@ -25,11 +29,13 @@ def list() -> list:
     return _store().keys()
 
 
-def get(name: str, reload: bool = False, default=None) -> dotdict:
+def get(name: str, reload: bool = False, default=None) -> jsondot.dotdict:
     return _store().get(key=name, reload=reload, default=default)
 
 
 def set(name: str, data: dict):
+    if data is None or len(data) == 0:
+        return _store().delete(name)
     return _store().save(name, data)
 
 
@@ -43,3 +49,76 @@ def file(name: str):
 
 def clear():
     return _store().clear()
+
+
+class Context:
+    def __init__(self, name):
+        self.name = name
+        self._store = _store()
+        self._data = None
+        self._changed = False
+
+    def get(self, key: str, default=None):
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any):
+        existing = self._data.get(key)
+        if existing != value:
+            self._changed = True
+            self._data[key] = value
+        return self
+
+    def remove(self, key: str):
+        if key in self._data:
+            self._changed = True
+            del self._data[key]
+
+    def __enter__(self):
+        self._data = self._store.get(key=self.name, reload=False, default={})
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self._changed:
+            self._store.save(key=self.name, data=self.data)
+        return False
+
+    def apply_variables(self, object: any, additional_vars: dict = None):
+
+        mapping = self._data.copy()
+        if additional_vars:
+            mapping.update(additional_vars)
+
+        # The Python default Template.substitute has too many limitations...
+        def substitute(text: str):
+            pattern = re.compile(r".*\${(.+?)}.*")
+            while True:
+                m = pattern.match(text)
+                if not m:
+                    break
+                name = m.group(1)
+                text = text.replace("${" + name + "}", self.get(name))
+            return text
+
+        t = type(object)
+        try:
+            if t is str:
+                return substitute(object)
+
+            if t is dict:
+                text = json.dumps(object)
+                text = substitute(text)
+                return json.loads(text)
+
+            if t is jsondot.dotdict:
+                text = json.dumps(object)
+                text = substitute(text)
+                return jsondot.parse(text)
+        except KeyError as e:
+            raise Exception("Variable not defined in context") from e
+
+    def load_template(self, name: str):
+        # with open(name) as f:
+        #     text = f.read()
+        # return apply_variables(text)
+
+        tmpl = jsondot.load(name)
+        return self.apply_variables(tmpl)

hcs_core/ctxp/data_util.py

@@ -1,9 +1,10 @@
-from io import TextIOWrapper
-from os import path, chmod
-from typing import Tuple, Any
 import json
-import yaml
+import os
 import re
+from io import TextIOWrapper
+from os import chmod, path
+from typing import Any, Tuple
+
 from .util import CtxpException
 
 
@@ -23,9 +24,13 @@ def load_data_file(file, default=None, format="auto"):
         if format == "json":
             data = json.loads(text)
         elif format == "yaml" or format == "yml":
+            import yaml
+
             data = yaml.safe_load(text)
         else:
             try:
+                import yaml
+
                 data = yaml.safe_load(text)
             except Exception:
                 data = json.loads(text)
@@ -45,6 +50,8 @@ def load_data_file(file, default=None, format="auto"):
         if ext == ".yaml" or ext == ".yml" or format == "yml" or format == "yaml":
             if format != "auto" and format != "yaml" and format != "yml":
                 raise CtxpException(f"File extension does not match specified format. File={file}, format={format}")
+            import yaml
+
             data = yaml.safe_load(text)
             return default if data is None else data  # handle empty file
     return text
@@ -53,6 +60,8 @@ def load_data_file(file, default=None, format="auto"):
 def save_data_file(data, file_name: str, format: str = "yaml", file_mod: int = 0):
     with open(file_name, "w") as file:
         if format == "yaml":
+            import yaml
+
             # TODO
             # yaml.safe_dump(data, file, sort_keys=False)
             yaml.safe_dump(json.loads(json.dumps(data, default=vars)), file, sort_keys=False)
@@ -91,9 +100,7 @@ def strict_dict_to_class(data: dict, class_type):
             value = strict_dict_to_class(value, field_type)
             setattr(inst, field_name, value)
             continue
-        raise ValueError(
-            f"Field '{class_type.__name__}.{field_name}' has an incorrect type. Declared: {field_type}, actual: {type(value)}"
-        )
+        raise ValueError(f"Field '{class_type.__name__}.{field_name}' has an incorrect type. Declared: {field_type}, actual: {type(value)}")
     return inst
 
 
@@ -152,7 +159,15 @@ def deep_set_attr(obj: dict, path: str, value, raise_on_not_found: bool = True):
     try:
         for i in range(len(parts)):
             k = parts[i]
-            obj = _get_obj_attr(obj, k)
+            try:
+                sub_obj = _get_obj_attr(obj, k)
+            except KeyError:
+                if raise_on_not_found:
+                    raise
+                sub_obj = {}
+                obj[k] = sub_obj
+
+            obj = sub_obj
 
             if i == len(parts) - 2:
                 # found the one before the leaf.
@@ -244,22 +259,26 @@ def process_variables(obj: dict, fn_get_var=None, use_env: bool = True):
         fn_get_var = _fn_get_var
 
     if use_env:
-        import os
 
         prev_fn_get_var = fn_get_var
 
         def _fn_get_var_from_env(name: str):
             if not name.startswith("env."):
                 return prev_fn_get_var(name)
-            v = None
             actual_name = name[4:]
-            v = os.environ.get(actual_name, None)
-            if v:
-                return v, True
-            v, found = prev_fn_get_var(name)
-            if found:
-                return v
-            raise CtxpException(f"Environment variable '{actual_name}' is used in template, but not found. ")
+            if actual_name.endswith("?"):
+                # optional
+                actual_name = actual_name[:-1]
+                required = False
+            else:
+                # required
+                required = True
+
+            if actual_name not in os.environ:
+                if required:
+                    raise CtxpException(f"Environment variable '{actual_name}' is used in template, but not found. ")
+                return None, True
+            return os.environ[actual_name], True
 
         fn_get_var = _fn_get_var_from_env
 
@@ -320,9 +339,7 @@ def resolve_expression(expr, fn_get_value, referencing_attr_path) -> Tuple[Any,
                 f"Invalid variable value for expression. Expect list, actual {type(target_value).__name__}. attr_path={referencing_attr_path}, src_var_name={src_var_name}"
             )
         if not mapped_value.startswith(tmp_var_name + "."):
-            raise CtxpException(
-                f"Unsupported expression. attr_path={referencing_attr_path}, src_var_name={src_var_name}"
-            )
+            raise CtxpException(f"Unsupported expression. attr_path={referencing_attr_path}, src_var_name={src_var_name}")
         new_attr_path = mapped_value[len(tmp_var_name) + 1 :]
         ret = []
         for i in target_value:
@@ -375,6 +392,25 @@ def get_common_items(iter1, iter2):
     return common_items
 
 
+def get_delta(dict_base, dict_update):
+    delta = {}
+    for k, v2 in dict_update.items():
+        v1 = dict_base.get(k)
+        if not deep_equals(v1, v2):
+            delta[k] = v2
+    return delta
+
+
+def deep_equals(v1, v2):
+    if v1 is None and v2 is None:
+        return True
+    if v1 is None or v2 is None:
+        return False
+    if v1 == v2:
+        return True
+    return json.dumps(v1) == json.dumps(v2)
+
+
 def _evaluate(value, smart_search):
     # If we found an exact match, return 2 immediately
     if value == smart_search:

hcs_core/ctxp/dispatcher.py

@@ -0,0 +1,82 @@
+import logging
+from weakref import WeakSet
+
+log = logging.getLogger(__name__)
+
+
+class Dispatcher:
+    _registry: dict = {}
+
+    def register(self, key: str, fn: callable):
+        listeners = self._registry.get(key)
+        if not listeners:
+            listeners = WeakSet()
+            self._registry[key] = listeners
+        listeners.add(fn)
+        return self
+
+    def register_map(self, map: dict):
+        for k, v in map.items():
+            self.register(k, v)
+        return self
+
+    def unregister(self, key: str, fn: callable):
+        listeners = self._registry.get(key)
+        if listeners:
+            listeners.remove(fn)
+        return self
+
+    def unregister_map(self, map: dict):
+        for k, v in map.items():
+            self.unregister(k, v)
+        return self
+
+    def emit(self, key: str, *args, **kwargs):
+        listeners = self._registry.get(key)
+        if listeners:
+            copy = listeners.copy()
+            for fn in copy:
+                try:
+                    fn(*args, **kwargs)
+                except Exception as e:
+                    log.error(f"Error handling event: {key}", e)
+                    log.exception(e)
+        return self
+
+    def scope(self, events):
+        return StrictDispatcher(self, events)
+
+
+class StrictDispatcher:
+    def __init__(self, impl: Dispatcher, events: set):
+        self._impl = impl
+        self._events = events
+
+    def register(self, key: str, fn: callable):
+        self._validate(key)
+        self._impl.register(key, fn)
+        return self
+
+    def register_map(self, map: dict):
+        for k, v in map.items():
+            self.register(k, v)
+        return self
+
+    def unregister(self, key: str, fn: callable):
+        self._validate(key)
+        self._impl.unregister(key, fn)
+        return self
+
+    def unregister_map(self, map: dict):
+        for k, v in map.items():
+            self.unregister(k, v)
+        return self
+
+    def emit(self, key: str, *args, **kwargs):
+        self._validate(key)
+        self._impl.emit(key, *args, **kwargs)
+        return self
+
+    def _validate(self, key: str):
+        if key not in self._events:
+            raise Exception("Event is not in dispatcher scope: %s. The scoped events are: %s " % (key, self._events))

hcs_core/ctxp/duration.py

@@ -0,0 +1,65 @@
+# Utility for Java Duration interoperability
+
+import re
+
+PATTERN = "([-+]?)P(?:([-+]?[0-9]+)D)?(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?"
+
+# Examples
+
+# PT0.555S
+# PT9M15S
+# PT9H15M
+# PT555H
+# PT13320H
+
+
+def to_seconds(duration_string: str):
+    duration_string = duration_string.upper()
+
+    p = re.compile(PATTERN)
+    matcher = p.fullmatch(duration_string)
+    if matcher is None:
+        raise Exception("Unsupported duration format: %s" % duration_string)
+
+    if matcher.start(3) >= 0 and matcher.end(3) == matcher.start(3) + 1 and duration_string[matcher.start(3)] == "T":
+        raise Exception("Unsupported duration format: %s" % duration_string)
+
+    day_start = matcher.start(2)
+    day_end = matcher.end(2)
+    hour_start = matcher.start(4)
+    hour_end = matcher.end(4)
+    minute_start = matcher.start(5)
+    minute_end = matcher.end(5)
+    second_start = matcher.start(6)
+    second_end = matcher.end(6)
+
+    total_seconds = 0
+    if day_start >= 0:
+        days = int(duration_string[day_start:day_end])
+        total_seconds += days * 24 * 3600
+    if hour_start >= 0:
+        hours = int(duration_string[hour_start:hour_end])
+        total_seconds += hours * 3600
+    if minute_start >= 0:
+        minutes = int(duration_string[minute_start:minute_end])
+        total_seconds += minutes * 60
+    if second_start >= 0:
+        seconds = int(duration_string[second_start:second_end])
+        total_seconds += seconds
+
+    return total_seconds
+
+
+if __name__ == "__main__":
+    assert to_seconds("PT5S") == 5
+    assert to_seconds("PT5M") == 5 * 60
+    assert to_seconds("PT5H") == 5 * 3600
+    assert to_seconds("PT2M3S") == 2 * 60 + 3
+    assert to_seconds("PT2H3M") == 2 * 3600 + 3 * 60
+    assert to_seconds("PT2H3S") == 2 * 3600 + 3
+    assert to_seconds("PT2H3M4S") == 2 * 3600 + 3 * 60 + 4
+    assert to_seconds("P1D") == 1 * 24 * 60 * 60
+    assert to_seconds("P1DT1M") == 1 * 24 * 60 * 60 + 1 * 60
+    assert to_seconds("P1DT1S") == 1 * 24 * 60 * 60 + 1
+    assert to_seconds("P1DT1H1S") == 1 * 24 * 60 * 60 + 1 * 3600 + 1
+    print("SUCCESS")

hcs_core/ctxp/extension.py

@@ -13,16 +13,18 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import click
-import sys
 import subprocess
-from importlib import reload, import_module
-import pkg_resources
+import sys
+from importlib import import_module, reload
+from importlib.metadata import distributions
+
+import click
+
 from .util import CtxpException
 
 
 def ensure_extension(required: str, parent_module_name: str = None):
-    installed = {pkg.key for pkg in pkg_resources.working_set}  # pylint: disable=not-an-iterable
+    installed = {dist.metadata["Name"].lower() for dist in distributions()}
     if required in installed:
         return
 
@@ -43,4 +45,3 @@ def ensure_extension(required: str, parent_module_name: str = None):
         reload(m)
     else:
         import_module(required.replace("-", "_"))
-    reload(pkg_resources)

hcs_core/ctxp/fn_util.py

@@ -0,0 +1,57 @@
+import inspect
+import os
+import threading
+
+
+def debounce(graceful_seconds):
+    """
+    Delay a function call by graceful_seconds. If an additional call happens during this time,
+    the delay will be reset.
+    """
+
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            def call_impl():
+                wrapper._timer = None
+                return function(*args, **kwargs)
+
+            # Cancel existing timer, if any
+            if wrapper._timer is not None:
+                wrapper._timer.cancel()
+
+            # Schedule debounced run
+            wrapper._timer = threading.Timer(graceful_seconds, call_impl)
+            wrapper._timer.start()
+
+        wrapper._timer = None
+        return wrapper
+
+    return decorator
+
+
+def once(fn):
+    """
+    Raise exception if the function called more than once.
+    """
+
+    def wrapper(*args, **kwargs):
+        if wrapper._invoked:
+            raise Exception("Duplicated invocation: %s, %s" % (_get_caller_file(), fn.__name__))
+        wrapper._invoked = True
+        return fn(*args, **kwargs)
+
+    wrapper._invoked = False
+    return wrapper
+
+
+def _get_caller_file():
+    # first get the full filename (including path and file extension)
+    caller_frame = inspect.stack()[2]
+    caller_filename_full = caller_frame.filename
+
+    # now get rid of the directory (via basename)
+    # then split filename and extension (via splitext)
+    caller_filename_only = os.path.splitext(os.path.basename(caller_filename_full))[0]
+
+    # return both filename versions as tuple
+    return caller_filename_only

hcs_core/ctxp/fstore.py

@@ -13,16 +13,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import os
 import logging
-from os import path, listdir
-from typing import Any
+import os
+import shutil
 from collections.abc import Generator
+from os import listdir, path
+from typing import Any
+
 from . import jsondot
 from .jsondot import dotdict
-import yaml
-import shutil
-
 
 log = logging.getLogger(__name__)
 
@@ -30,12 +29,15 @@ log = logging.getLogger(__name__)
 def _validate_key(key: str):
     # if key.find(os.pathsep) >= 0:
     if key.find("/") >= 0 or key.find("\\") >= 0:
-        raise Exception("Invalid profile name: " + key)
+        raise Exception("Invalid key: " + key)
 
 
 def _load_yaml(file_name: str):
     if not os.path.exists(file_name):
         return
+
+    import yaml
+
     with open(file_name, "r") as file:
         ret = yaml.safe_load(file)
         return jsondot.dotify(ret)
@@ -120,21 +122,12 @@ class fstore:
 
         Args:
                 store_path (str): The path to store state files. If None, state will not be stored.
-        create (bool, optional): If store_path is specified, try creating it if not exist. Defaults to True.
-
-        Raises:
-                Exception: [description]
+                create (bool, optional): If store_path is specified, try creating it if not exist. Defaults to True.
         """
         if store_path:
-            store_path = path.realpath(store_path)
-            if not path.exists(store_path):
-                if create:
-                    os.makedirs(store_path)
-                else:
-                    raise Exception(f"Store path does not exist: {store_path}")
-            elif not os.path.isdir(store_path):
-                raise Exception(f"Store path is not a directory: {store_path}")
-            self._path = store_path
+            self._path = path.realpath(store_path)
+            self._create = create
+            self._path_checked = False
         else:
             self._path = None
         self._cache = {}
@@ -165,6 +158,23 @@ class fstore:
             return None
         return path.join(self._path, key)
 
+    def _ensure_dir(self):
+        if not self._path or self._path_checked:
+            return
+        if path.exists(self._path):
+            if not os.path.isdir(self._path):
+                raise Exception(f"Store path is not a directory: {self._path}")
+            else:
+                # Good.
+                self._path_checked = True
+                return
+        else:
+            if self._create:
+                os.makedirs(self._path, exist_ok=True)
+            else:
+                raise Exception(f"Store path does not exist: {self._path}")
+        self._path_checked = True
+
     def save(self, key: str, data: Any, format: str = "auto") -> Any:
         _validate_key(key)
 
@@ -178,6 +188,7 @@ class fstore:
 
         self._cache[key] = data
         if self._path:
+            self._ensure_dir()
             file_path = self._get_path(key)
             log.debug(f"Write {file_path}")
             if format == "json":
@@ -187,8 +198,10 @@ class fstore:
                     # TODO lock
                     outfile.write(str(data))
             elif format == "json-compact":
-                jsondot.save(data, file_path, format=False, lock=True)
-            elif format == "yaml":
+                jsondot.save(data=data, file=file_path, pretty=False, lock=True)
+            elif format == "yaml" or format == "yml":
+                import yaml
+
                 with open(file_path, "w", encoding="utf-8") as outfile:
                     # TODO lock
                     yaml.safe_dump(data, outfile)
@@ -208,12 +221,16 @@ class fstore:
 
     def keys(self) -> list[str]:
         if self._path:
+            if not os.path.exists(self._path):
+                return []
             return [f for f in listdir(self._path) if path.isfile(path.join(self._path, f))]
         return list(self._cache.keys())
 
     def children(self, depth: int = 0) -> list[str]:
         """List child stores"""
         if self._path:
+            if not os.path.exists(self._path):
+                return []
             if depth == 0:
                 return [f for f in listdir(self._path) if path.isdir(path.join(self._path, f))]
             else: