active-learning-step 2026.10.14__py2.py3-none-any.whl

active_learning_step/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+"""
+active_learning_step
+A SEAMM plug-in for Active Learning
+"""
+
+# Bring up the classes so that they appear to be directly in
+# the active_learning_step package.
+#
+# The library (committee, molecules, pool, selection) and the seamm-al command also
+# run in MLFF environments that have torch and xnn but not SEAMM, so the step's
+# classes are only imported when SEAMM is there.
+try:
+    import seamm  # noqa: F401
+except ImportError:
+    pass
+else:
+    from .active_learning import ActiveLearning  # noqa: F401, E501
+    from .active_learning_parameters import ActiveLearningParameters  # noqa: F401, E501
+    from .active_learning_step import ActiveLearningStep  # noqa: F401, E501
+    from .tk_active_learning import TkActiveLearning  # noqa: F401, E501
+
+    from .metadata import metadata  # noqa: F401
+
+# Handle versioneer
+from ._version import get_versions
+
+__author__ = "Paul Saxe"
+__email__ = "psaxe@molssi.org"
+versions = get_versions()
+__version__ = versions["version"]
+__git_revision__ = versions["full-revisionid"]
+del get_versions, versions

active_learning_step/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.18) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2026-10-14T06:21:42-0400",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "1644bd1a7793ed3ca65d488119b41a5d0a7d1180",
+ "version": "2026.10.14"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

active_learning_step/active_learning.py

@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+
+"""Non-graphical part of the Active Learning step in a SEAMM flowchart"""
+
+import logging
+from pathlib import Path
+import importlib.resources
+import pprint  # noqa: F401
+
+import active_learning_step
+import molsystem
+import seamm
+from seamm_util import ureg, Q_  # noqa: F401
+import seamm_util.printing as printing
+from seamm_util.printing import FormattedText as __
+
+# In addition to the normal logger, two logger-like printing facilities are
+# defined: "job" and "printer". "job" send output to the main job.out file for
+# the job, and should be used very sparingly, typically to echo what this step
+# will do in the initial summary of the job.
+#
+# "printer" sends output to the file "step.out" in this steps working
+# directory, and is used for all normal output from this step.
+
+logger = logging.getLogger(__name__)
+job = printing.getPrinter()
+printer = printing.getPrinter("Active Learning")
+
+# Add this module's properties to the standard properties
+path = importlib.resources.files("active_learning_step") / "data"
+csv_file = path / "properties.csv"
+if path.exists():
+    molsystem.add_properties_from_file(csv_file)
+
+
+class ActiveLearning(seamm.Node):
+    """
+    The non-graphical part of a Active Learning step in a flowchart.
+
+    Attributes
+    ----------
+    parser : configargparse.ArgParser
+        The parser object.
+
+    options : tuple
+        It contains a two item tuple containing the populated namespace and the
+        list of remaining argument strings.
+
+    subflowchart : seamm.Flowchart
+        A SEAMM Flowchart object that represents a subflowchart, if needed.
+
+    parameters : ActiveLearningParameters
+        The control parameters for Active Learning.
+
+    See Also
+    --------
+    TkActiveLearning,
+    ActiveLearning, ActiveLearningParameters
+    """
+
+    def __init__(
+        self, flowchart=None, title="Active Learning", extension=None, logger=logger
+    ):
+        """A step for Active Learning in a SEAMM flowchart.
+
+        You may wish to change the title above, which is the string displayed
+        in the box representing the step in the flowchart.
+
+        Parameters
+        ----------
+        flowchart: seamm.Flowchart
+            The non-graphical flowchart that contains this step.
+
+        title: str
+            The name displayed in the flowchart.
+        extension: None
+            Not yet implemented
+        logger : Logger = logger
+            The logger to use and pass to parent classes
+
+        Returns
+        -------
+        None
+        """
+        logger.debug(f"Creating Active Learning {self}")
+
+        super().__init__(
+            flowchart=flowchart,
+            title="Active Learning",
+            extension=extension,
+            module=__name__,
+            logger=logger,
+        )  # yapf: disable
+
+        self._metadata = active_learning_step.metadata
+        self.parameters = active_learning_step.ActiveLearningParameters()
+
+    @property
+    def version(self):
+        """The semantic version of this module."""
+        return active_learning_step.__version__
+
+    @property
+    def git_revision(self):
+        """The git version of this module."""
+        return active_learning_step.__git_revision__
+
+    def description_text(self, P=None):
+        """Create the text description of what this step will do.
+        The dictionary of control values is passed in as P so that
+        the code can test values, etc.
+
+        Parameters
+        ----------
+        P: dict
+            An optional dictionary of the current values of the control
+            parameters.
+        Returns
+        -------
+        str
+            A description of the current step.
+        """
+        if not P:
+            P = self.parameters.values_to_dict()
+
+        text = (
+            "Please replace this with a short summary of the "
+            "Active Learning step, including key parameters."
+        )
+
+        return self.header + "\n" + __(text, **P, indent=4 * " ").__str__()
+
+    def run(self):
+        """Run a Active Learning step.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        seamm.Node
+            The next node object in the flowchart.
+        """
+        next_node = super().run(printer)
+        # Get the values of the parameters, dereferencing any variables
+        P = self.parameters.current_values_to_dict(
+            context=seamm.flowchart_variables._data
+        )
+
+        # Print what we are doing
+        printer.important(__(self.description_text(P), indent=self.indent))
+
+        directory = Path(self.directory)
+        directory.mkdir(parents=True, exist_ok=True)
+
+        # Get the current system and configuration (ignoring the system...)
+        _, configuration = self.get_system_configuration(None)
+
+        # Results data
+        data = {}
+
+        # Temporary code just to print the parameters. You will need to change
+        # this!
+        for key in P:
+            print("{:>15s} = {}".format(key, P[key]))
+            printer.normal(
+                __(
+                    "{key:>15s} = {value}",
+                    key=key,
+                    value=P[key],
+                    indent=4 * " ",
+                    wrap=False,
+                    dedent=False,
+                )
+            )
+
+        # Analyze the results
+        self.analyze()
+        # Put any requested results into variables or tables
+        self.store_results(
+            configuration=configuration,
+            data=data,
+        )
+        # Add other citations here or in the appropriate place in the code.
+        # Add the bibtex to data/references.bib, and add a self.reference.cite
+        # similar to the above to actually add the citation to the references.
+
+        return next_node
+
+    def analyze(self, indent="", **kwargs):
+        """Do any analysis of the output from this step.
+
+        Also print important results to the local step.out file using
+        "printer".
+
+        Parameters
+        ----------
+        indent: str
+            An extra indentation for the output
+        """
+        printer.normal(
+            __(
+                "This is a placeholder for the results from the Active Learning step",
+                indent=4 * " ",
+                wrap=True,
+                dedent=False,
+            )
+        )

active_learning_step/active_learning_parameters.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+"""
+Control parameters for the Active Learning step in a SEAMM flowchart
+"""
+
+import logging
+import seamm
+import pprint  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+class ActiveLearningParameters(seamm.Parameters):
+    """
+    The control parameters for Active Learning.
+
+    You need to replace the "time" entry in dictionary below these comments with the
+    definitions of parameters to control this step. The keys are parameters for the
+    current plugin,the values are dictionaries as outlined below.
+
+    Examples
+    --------
+    ::
+
+        parameters = {
+            "time": {
+                "default": 100.0,
+                "kind": "float",
+                "default_units": "ps",
+                "enumeration": tuple(),
+                "format_string": ".1f",
+                "description": "Simulation time:",
+                "help_text": ("The time to simulate in the dynamics run.")
+            },
+        }
+
+    parameters : {str: {str: str}}
+        A dictionary containing the parameters for the current step.
+        Each key of the dictionary is a dictionary that contains the
+        the following keys:
+
+    parameters["default"] :
+        The default value of the parameter, used to reset it.
+
+    parameters["kind"] : enum()
+        Specifies the kind of a variable. One of  "integer", "float", "string",
+        "boolean", or "enum"
+
+        While the "kind" of a variable might be a numeric value, it may still have
+        enumerated custom values meaningful to the user. For instance, if the parameter
+        is a convergence criterion for an optimizer, custom values like "normal",
+        "precise", etc, might be adequate. In addition, any parameter can be set to a
+        variable of expression, indicated by having "$" as the first character in the
+        field. For example, $OPTIMIZER_CONV.
+
+    parameters["default_units"] : str
+        The default units, used for resetting the value.
+
+    parameters["enumeration"] : tuple
+        A tuple of enumerated values.
+
+    parameters["format_string"] : str
+        A format string for "pretty" output.
+
+    parameters["description"] : str
+        A short string used as a prompt in the GUI.
+
+    parameters["help_text"] : str
+        A longer string to display as help for the user.
+
+    See Also
+    --------
+    ActiveLearning, TkActiveLearning, ActiveLearningParameters, ActiveLearningStep
+    """
+
+    parameters = {
+        "time": {
+            "default": 100.0,
+            "kind": "float",
+            "default_units": "ps",
+            "enumeration": tuple(),
+            "format_string": ".1f",
+            "description": "Simulation time:",
+            "help_text": ("The time to simulate in the dynamics run."),
+        },
+        # # Results handling ... uncomment if needed
+        # "results": {
+        #     "default": {},
+        #     "kind": "dictionary",
+        #     "default_units": "",
+        #     "enumeration": tuple(),
+        #     "format_string": "",
+        #     "description": "results",
+        #     "help_text": "The results to save to variables or in tables.",
+        # },
+    }
+
+    def __init__(self, defaults={}, data=None):
+        """
+        Initialize the parameters, by default with the parameters defined above
+
+        Parameters
+        ----------
+        defaults: dict
+            A dictionary of parameters to initialize. The parameters
+            above are used first and any given will override/add to them.
+        data: dict
+            A dictionary of keys and a subdictionary with value and units
+            for updating the current, default values.
+
+        Returns
+        -------
+        None
+        """
+
+        logger.debug("ActiveLearningParameters.__init__")
+
+        super().__init__(
+            defaults={**ActiveLearningParameters.parameters, **defaults}, data=data
+        )

active_learning_step/active_learning_step.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+
+import active_learning_step
+
+
+class ActiveLearningStep(object):
+    """Helper class needed for the stevedore integration.
+
+    This must provide a `description()` method that returns a dict containing a
+    description of this node, and `create_node()` and `create_tk_node()` methods
+    for creating the graphical and non-graphical nodes.
+
+    The dictionary for the description is the class variable just below these
+    comments. The felds are as follows:
+
+        my_description : {str, str}
+            A human-readable description of this step. It can be
+            several lines long, and needs to be clear to non-expert users.
+            It contains the following keys: description, group, name.
+
+        my_description["description"] : tuple
+            A description of the Active Learning step. It must be
+            clear to non-experts.
+
+        my_description["group"] : str
+            Which group in the menus to put this step. If the group does
+            not exist it will be created. Common groups are "Building",
+            "Control", "Custom", "Data", and "Simulations".
+
+        my_description["name"] : str
+            The name of this step, to be displayed in the menus.
+    """
+
+    my_description = {
+        "description": "An interface for Active Learning",
+        "group": "Simulations",
+        "name": "Active Learning",
+    }
+
+    def __init__(self, flowchart=None, gui=None):
+        """Initialize this helper class, which is used by
+        the application via stevedore to get information about
+        and create node objects for the flowchart
+        """
+        pass
+
+    def create_node(self, flowchart=None, **kwargs):
+        """Create and return the new node object.
+
+        Parameters
+        ----------
+        flowchart: seamm.Node
+            A non-graphical SEAMM node
+
+        **kwargs : keyword arguments
+            Various keyword arguments such as title, namespace or
+            extension representing the title displayed in the flowchart,
+            the namespace for the plugins of a subflowchart and
+            the extension, respectively.
+
+        Returns
+        -------
+        ActiveLearning
+        """
+
+        return active_learning_step.ActiveLearning(flowchart=flowchart, **kwargs)
+
+    def create_tk_node(self, canvas=None, **kwargs):
+        """Create and return the graphical Tk node object.
+
+        Parameters
+        ----------
+        canvas : tk.Canvas
+            The Tk Canvas widget
+
+        **kwargs : keyword arguments
+            Various keyword arguments such as tk_flowchart, node, x, y, w, h
+            representing a graphical flowchart object, a non-graphical node for
+            a step, and dimensions of the graphical node.
+
+        Returns
+        -------
+        TkActiveLearning
+        """
+
+        return active_learning_step.TkActiveLearning(canvas=canvas, **kwargs)
+
+    def description(self):
+        """Return a description of what this step does.
+
+        Returns
+        -------
+        description : dict(str, str)
+        """
+        return ActiveLearningStep.my_description