vfWorks 0.0.1.dev5__tar.gz → 0.0.2b1__tar.gz

{vfworks-0.0.1.dev5 → vfworks-0.0.2b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vfWorks
-Version: 0.0.1.dev5
+Version: 0.0.2b1
 Summary: vfWorks - your gateway to valid model (re-)use.
 Home-page: 
 Author: Jan Gladiné & Bert Van Acker

{vfworks-0.0.1.dev5 → vfworks-0.0.2b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vfWorks"
-version = "0.0.1.dev5"
+version = "0.0.2b1"
 description = "vfWorks - your gateway to valid model (re-)use."
 readme = "README.md"
 requires-python = ">=3.11"

{vfworks-0.0.1.dev5 → vfworks-0.0.2b1}/vfWorks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vfWorks
-Version: 0.0.1.dev5
+Version: 0.0.2b1
 Summary: vfWorks - your gateway to valid model (re-)use.
 Home-page: 
 Author: Jan Gladiné & Bert Van Acker

{vfworks-0.0.1.dev5 → vfworks-0.0.2b1}/vfworks/metamodels/monitors.py

@@ -6,11 +6,11 @@
 # * vfWorks can not be copied and/or distributed without the express
 # * permission of Bert Van Acker
 # **************************************************************************************
-from vfworks.metamodels.common import *
-from vfworks.utils.constants import *
-import importlib.util
-import os
-from pathlib import Path
+from vfworks.metamodels.common import *
+from vfworks.utils.constants import *
+import importlib.util
+import os
+from pathlib import Path
 
 class Monitor(baseElement):
 
@@ -46,6 +46,11 @@ class Monitor(baseElement):
             """Setup the monitor, including loading any custom validation hooks."""
             self._load_custom_validation_hook(packageLocation=packageLocation)
 
+    def set_valid(self):
+        for observe in self.observes:
+            self.spec_status[observe.feature] = StatusType.VALID
+        self._status = StatusType.VALID
+
     @property
     def packageName(self):
         return self._packageName
@@ -169,16 +174,16 @@ class Monitor(baseElement):
 
         return global_is_valid
 
-    def _load_custom_validation_hook(self, packageLocation=None):
-        """Private helper to locate and bind custom vector validation scripts."""
-        package_root = Path(os.getcwd()) if packageLocation is None else Path(packageLocation)
-        custom_script_path = package_root / "Resources" / "monitors" / f"{self._custom_code_file}"
-
-        # Check if the user wrote a custom plugin matching this monitor type
-        if custom_script_path.exists():
-            try:
-                # Load the file dynamically as a Python module
-                spec = importlib.util.spec_from_file_location(self.name, custom_script_path)
+    def _load_custom_validation_hook(self, packageLocation=None):
+        """Private helper to locate and bind custom vector validation scripts."""
+        package_root = Path(os.getcwd()) if packageLocation is None else Path(packageLocation)
+        custom_script_path = package_root / "Resources" / "monitors" / f"{self._custom_code_file}"
+
+        # Check if the user wrote a custom plugin matching this monitor type
+        if custom_script_path.exists():
+            try:
+                # Load the file dynamically as a Python module
+                spec = importlib.util.spec_from_file_location(self.name, custom_script_path)
                 custom_module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(custom_module)
 

vfworks-0.0.2b1/vfworks/metamodels/process.py

@@ -0,0 +1,103 @@
+#***************************************************************************************
+# * Copyright (C) 2024-present Bert Van Acker (UAntwerpen) <Bert.VanAcker@uantwerpen.be>
+# *
+# * This file is part of the vfWorks project.
+# *
+# * vfWorks can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# **************************************************************************************
+from vfworks.metamodels.common import *
+from vfworks.utils.constants import *
+import importlib.util
+import os
+from pathlib import Path
+
+class Process(baseElement):
+
+    def __init__(self, name='tbd', description='tbd', verbose=False):
+        super().__init__(name=name, description=description, verbose=verbose)
+
+        self._tasks = []
+
+    @property
+    def tasks(self):
+        return self._tasks
+
+    @tasks.setter
+    def tasks(self, task_list):
+        self._tasks = task_list
+
+
+
+class Task(baseElement):
+
+    def __init__(self, name='tbd', description='tbd',reference="Processes/train.py", verbose=False):
+        super().__init__(name=name, description=description, verbose=verbose)
+
+        self._input_artefacts = []
+        self._output_artefacts = []
+
+    @property
+    def input_artefacts(self):
+        return self._input_artefacts
+
+    @input_artefacts.setter
+    def input_artefacts(self, artefact_list):
+        self._input_artefacts = artefact_list
+
+    @property
+    def output_artefacts(self):
+        return self._output_artefacts
+
+    @output_artefacts.setter
+    def output_artefacts(self, artefact_list):
+        self._output_artefacts = artefact_list
+
+    def execute(self):
+        # Placeholder for task execution logic
+        pass
+
+    def _load_custom_task_executor(self, reference):
+        """Private helper to locate and bind custom vector validation scripts."""
+        package_root = Path(os.getcwd()) if packageLocation is None else Path(packageLocation)
+        custom_script_path = package_root / "Resources" / "monitors" / f"{self._custom_code_file}"
+
+        # Check if the user wrote a custom plugin matching this monitor type
+        if custom_script_path.exists():
+            try:
+                # Load the file dynamically as a Python module
+                spec = importlib.util.spec_from_file_location(self.name, custom_script_path)
+                custom_module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(custom_module)
+
+                # Look for our standardized function name contract
+                if hasattr(custom_module, self.name):
+                    self.execute = getattr(custom_module, self.name)
+                    print(f"Successfully bound custom execution function for '{self.name}'")
+                else:
+                    print(
+                        f"Found custom script '{self._custom_code_file}.py', but it is missing '{self.name}'. "
+                        f"Falling back to default built-in validation rules.",
+                        level="warning"
+                    )
+            except Exception as e:
+                print(f"Failed to compile custom monitor plugin '{self.name}': {str(e)}")
+        else:
+            # No custom script found; perfectly fine, it will use default built-in value.validate_point rules
+            print(f"No custom override found for '{self._custom_code_file}'. Running baseline configurations.")
+
+class Artefact(baseElement):
+
+    def __init__(self, name='tbd', description='tbd',type='tbd',reference='tbd', verbose=False):
+        super().__init__(name=name, description=description, verbose=verbose)
+
+        self._type = type
+        self._reference = reference
+
+    @property
+    def reference(self):
+        return self._reference
+
+    @reference.setter
+    def reference(self,ref):
+        self._reference = ref

{vfworks-0.0.1.dev5 → vfworks-0.0.2b1}/vfworks/metamodels/validity_frame.py

@@ -9,6 +9,7 @@
 import os
 import json
 import logging
+import re
 from pathlib import Path
 from vfworks.package.PackageManager import PackageManager
 from vfworks.metamodels.knowledge_graph import KnowledgeGraph
@@ -18,7 +19,8 @@ from vfworks.metamodels.specification import *
 from vfworks.metamodels.experiment import *
 from vfworks.metamodels.properties import *
 from vfworks.metamodels.common import *
-from vfworks.utils.constants import StatusType
+from vfworks.metamodels.process import *
+from vfworks.utils.constants import StatusType, MonitorTime
 from vfworks.logging.logger import *
 from vfworks.utils.model.modelLoader import *
 import networkx as nx
@@ -26,7 +28,7 @@ import matplotlib.pyplot as plt
 from termcolor import colored
 
 class ValidityFrame(baseElement):
-    def __init__(self, name='tbd',description='tbd',config=None,loadExistingVF=False,VFPackage=None, location=None,verbose=False):
+    def __init__(self, name='tbd',description='tbd',config=None,loadExistingVF=False,VFPackage=None, location=None,verbose=False,unzipDirectory=None):
         super().__init__(name=name, description=description, verbose=verbose)
 
         # VF_BLDC HIGH-LEVEL STRUCTURE
@@ -37,7 +39,12 @@ class ValidityFrame(baseElement):
         self._model_loader = ModelLoader(name="VF_model_loader", validityFrame=self)
 
         # PACKAGE AND LOGGER
-        self._package_manager = PackageManager(verbose=verbose, packageName=VFPackage, packageLocation=location)
+        # VFPackage can be a package directory or a zipped package (.vf), which is unzipped to a working copy
+        self._log_handler = None
+        self._package_manager = PackageManager(verbose=verbose, packageName=VFPackage, packageLocation=location, unzipDirectory=unzipDirectory)
+        archive = self._package_manager.archive
+        if loadExistingVF and archive is not None and not archive.is_file():
+            raise FileNotFoundError(f"Zipped validity frame package {archive} does not exist!")
         if config is None:
             self.config = self._package_manager.init_config()
         else:
@@ -239,6 +246,7 @@ class ValidityFrame(baseElement):
                 file_handler = logging.FileHandler(Path("..") / log_file)  #LOAD FROM FOLDER LEVEL (e.g. in processes)
             file_handler.setFormatter(formatter)
             logger.addHandler(file_handler)
+            self._log_handler = file_handler
         else:
             console_handler = logging.StreamHandler()
             console_handler.setFormatter(formatter)
@@ -387,6 +395,132 @@ class ValidityFrame(baseElement):
         with open(file_name, 'w') as f:
             json.dump(graph_dict, f)
 
+    def architecture_graph(self):
+        """
+        Build an architecture graph payload from the metadata and operational state.
+        """
+
+        def humanize(name):
+            return re.sub(r'(?<!^)(?=[A-Z])', ' ', str(name)).strip()
+
+        def normalize(value):
+            return getattr(value, 'value', value)
+
+        model_structure = self.activeModelStructure
+        if model_structure is None and self.modelStructures:
+            model_structure = self.modelStructures[0]
+
+        if model_structure is None:
+            component = {
+                "id": self.GUID,
+                "name": self.name,
+                "inputs": [],
+                "outputs": [],
+                "ai_architecture": {
+                    "pattern": "unknown",
+                    "models": [],
+                    "flow": []
+                }
+            }
+        else:
+            inputs = []
+            for inport in model_structure.inports:
+                input_entry = {
+                    "id": f"input_{inport.name}",
+                    "name": inport.name,
+                    "datatype": normalize(inport.datatype),
+                    "dimensions": None,
+                    "shape": [],
+                    "unit": None if normalize(inport.unit) in (None, "-", "UNIT_none") else normalize(inport.unit),
+                    "description": inport.description
+                }
+                if "image" in inport.name.lower() or "image" in inport.description.lower():
+                    input_entry["format"] = "image"
+                inputs.append(input_entry)
+
+            outputs = []
+            has_confidence_output = False
+            for outport in model_structure.outports:
+                output_entry = {
+                    "id": f"output_{outport.name}",
+                    "name": outport.name,
+                    "datatype": normalize(outport.datatype),
+                    "dimensions": None,
+                    "shape": [],
+                    "unit": None if normalize(outport.unit) in (None, "-", "UNIT_none") else normalize(outport.unit),
+                    "description": outport.description
+                }
+                if outport.min != 0 or outport.max != 0:
+                    output_entry["value_range"] = {"min": outport.min, "max": outport.max}
+                if outport.name.lower() == "confidence":
+                    has_confidence_output = True
+                outputs.append(output_entry)
+
+            model_entry = {
+                "id": f"model_{model_structure.name}",
+                "name": humanize(model_structure.name),
+                "type": normalize(model_structure.modelType),
+                "reference": model_structure.modelRef
+            }
+
+            flow = []
+            for input_entry in inputs:
+                flow.append({"from": input_entry["id"], "to": model_entry["id"]})
+            for output_entry in outputs:
+                flow.append({"from": model_entry["id"], "to": output_entry["id"]})
+
+            component = {
+                "id": model_structure.name,
+                "name": humanize(model_structure.name),
+                "inputs": inputs,
+                "outputs": outputs,
+                "ai_architecture": {
+                    "pattern": "single_model_with_confidence_output" if has_confidence_output else "single_model",
+                    "models": [model_entry],
+                    "flow": flow
+                }
+            }
+
+        monitors = []
+        default_target = model_structure.inports[0].name if model_structure and model_structure.inports else "model"
+        for monitor in self.runtime_monitors:
+            if monitor.type == MonitorTime.DATA_VALIDATION:
+                target = "dataset"
+            elif monitor.type == MonitorTime.MODEL_VALIDATION:
+                target = "model"
+            elif monitor.type == MonitorTime.RUN_TIME:
+                observed_features = [spec.feature for spec in (monitor.observes or [])]
+                if any("odd" in feature.lower() for feature in observed_features) or "odd" in monitor.name.lower() or "odd" in monitor.description.lower():
+                    target = "environment"
+                else:
+                    target = default_target
+            else:
+                target = default_target
+
+            monitors.append({
+                "name": monitor.name,
+                "target": target,
+                "description": monitor.description,
+                "observes": [spec.feature for spec in (monitor.observes or [])]
+            })
+
+        return {
+            "component": component,
+            "monitors": monitors
+        }
+
+    def export_architecture_json(self, file_name="architecture.json"):
+        """
+        Export the architecture graph payload to a JSON file.
+        """
+        architecture = self.architecture_graph()
+        output_path = Path(file_name)
+        if not output_path.is_absolute():
+            output_path = self.package_manager.package_root / output_path
+
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(architecture, f, indent=2)
+
     # ------------------------------------------------------------------------------------------------------------------
     #                                           IMPORT/EXPORT FUNCTIONS
     # -----------------------------------------------------------------------------------------------------------------
@@ -396,6 +530,30 @@ class ValidityFrame(baseElement):
         self._processes.object2json(package_root / "Processes" / "Processes.json")
         self._experiments.object2json(package_root / "Experiments" / "Experiments.json")
         self._operational.object2json(package_root / "Operational" / "Operational.json")
+        # keep the zipped package (.vf) in sync with its unzipped working copy
+        if packageName is None and self.package_manager.archive is not None:
+            self.package_manager.zip()
+
+    def zip(self, archive=None):
+        """
+        Export the validity frame and zip its package into a .vf archive.
+        Defaults to the archive the validity frame was loaded from.
+        """
+        self.export()
+        if archive is None and self.package_manager.archive is not None:
+            return self.package_manager.archive
+        return self.package_manager.zip(archive=archive)
+
+    def close(self):
+        """
+        Release the log file and the unzipped working copy of a zipped package (.vf).
+        Changes made after the last export()/zip() are not written to the archive.
+        """
+        if self._log_handler is not None:
+            self.logger.removeHandler(self._log_handler)
+            self._log_handler.close()
+            self._log_handler = None
+        self.package_manager.close()
 
 
 class MetaData(baseElement):
@@ -639,6 +797,26 @@ class Processes(baseElement):
         with open(fileName, 'w', encoding='utf-8') as f:
             f.write(data)
 
+    def json2object(self, fileName):
+        """
+           Function to generate object from a json file
+        """
+        # --- read stored requirements ---
+        available = False
+        try:
+            f = open(fileName)
+            data = json.load(f)
+            available = True
+        except:
+            print(colored('ERROR: ', 'red'), colored('Stored operational data cannot be read!', 'black'))
+
+        if available:
+            for process in data["_processes"]:
+                _process = Process(name=process["_name"], description=process["_description"], processType=process["_processType"], custom_code_file=process["_custom_code_file"])
+                _process.GUID = process["_GUID"]
+                _process.timestamp = process["_timestamp"]
+                self.addProcess(_process)
+
 class Experiments(baseElement):
     def __init__(self, name='tbd',description='tbd',experiments=None,verbose=False):
         super().__init__(name=name, description=description, verbose=verbose)