diffpy.apps 0.1.0__py3-none-any.whl

diffpy/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# (c) 2026 The Trustees of Columbia University in the City of New York.
+# All rights reserved.
+#
+# File coded by: Billinge Group members and community contributors.
+#
+# See GitHub contributions for a more detailed list of contributors.
+# https://github.com/diffpy/diffpy.apps/graphs/contributors
+#
+# See LICENSE.rst for license information.
+#
+##############################################################################

diffpy/apps/__init__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# (c) 2026 diffpy.apps contributors.
+# All rights reserved.
+#
+# File coded by: Yuchen Xiao, Simon Billinge and members of the Billinge group.
+#
+# See GitHub contributions for a more detailed list of contributors.
+# https://github.com/diffpy/diffpy.apps/graphs/contributors
+#
+# See LICENSE.rst for license information.
+#
+##############################################################################
+"""User applications to help with tasks using diffpy packages."""
+
+# package version
+from diffpy.apps.version import __version__  # noqa
+
+# silence the pyflakes syntax checker
+assert __version__ or True
+
+# End of file

diffpy/apps/app_agentify.py

@@ -0,0 +1,35 @@
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+REPO_URL = "https://github.com/diffpy/cmi-agent-skills"
+DIR_NAME = "cmi-skill"
+
+
+def agentify(args):
+    agent = args.agent
+    system_flag = args.system
+    if agent == "claude":
+        skills_dir = ".claude/skills"
+    elif agent == "codex":
+        skills_dir = ".codex/skills"
+    if system_flag:
+        destination = Path().home() / skills_dir / DIR_NAME
+    else:
+        destination = Path().cwd() / skills_dir / DIR_NAME
+    if destination.exists() and not args.update:
+        raise FileExistsError(
+            f"Agentic skill {DIR_NAME} already exists at {destination}. "
+            "To overwrite, pass '--update' flag to update the skill"
+        )
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_path = Path(tmp)
+        subprocess.run(
+            ["git", "clone", REPO_URL, str(tmp_path)],
+            check=True,
+        )
+        if destination.exists():
+            shutil.rmtree(destination)
+        shutil.copytree(tmp_path / DIR_NAME, destination, dirs_exist_ok=True)
+    print(f"Agentic skill {DIR_NAME} has been deployed to {destination}")

diffpy/apps/app_runmacro.py

@@ -0,0 +1,298 @@
+import inspect
+from collections import OrderedDict
+from pathlib import Path
+
+import yaml
+from textx import metamodel_from_str
+
+from diffpy.apps.pdfadapter import PDFAdapter
+
+grammar = r"""
+Program:
+    commands*=Command
+    variable=VariableBlock?
+;
+
+Command:
+    LoadCommand | SetCommand | CreateCommand | SaveCommand
+;
+
+LoadCommand:
+    'load' component=ID name=ID 'from' source=STRING
+;
+
+SetCommand:
+    'set' name=ID attribute=ID 'as' value+=Value[eolterm]
+    | 'set' name=ID 'as' value+=Value[eolterm]
+;
+
+CreateCommand:
+    'create' 'equation' 'variables' value+=Value[eolterm]
+;
+
+SaveCommand:
+    'save' 'to' source=STRING
+;
+
+VariableBlock:
+    'variables:' '---' content=/[\s\S]*?(?=---)/ '---'
+;
+
+Value:
+    STRICTFLOAT | INT | STRING | RawValue
+;
+
+RawValue:
+    /[^\s]+/
+;
+
+
+Comment: /#[^\n]*/;
+"""
+
+
+class MacroParser:
+    def __init__(self):
+        self.pdfadapter = PDFAdapter()
+        self.meta_model = metamodel_from_str(grammar)
+        self.meta_model.register_obj_processors(
+            {
+                "SetCommand": self.set_command_processor,
+                "LoadCommand": self.load_command_processor,
+                "VariableBlock": self.parameter_block_processor,
+                "CreateCommand": self.create_command_processor,
+                "SaveCommand": self.save_command_processor,
+            }
+        )
+        # key: method_name.argument_name
+        # value: argument_value
+        self.inputs = {}
+        # key: structure name or profile name set in the macro
+        # value: 'structure' or 'profile'
+        self.variables = OrderedDict()
+
+    def parse(self, code):
+        self.meta_model.model_from_str(code)
+
+    def input_as_list(self, key, value):
+        if key in self.inputs:
+            if not isinstance(self.inputs[key], list):
+                self.inputs[key] = [self.inputs[key]]
+            else:
+                self.inputs[key].append(value)
+        else:
+            if isinstance(value, list):
+                self.inputs[key] = value
+            else:
+                self.inputs[key] = [value]
+
+    def load_command_processor(self, command):
+        if command.component == "structure":
+            # TODO: support multiple structures input in the future
+            if (
+                self.inputs.get("initialize_structures.structure_paths")
+                is not None
+            ):
+                raise ValueError(
+                    "Multiple structures are not supported by `runmacro` yet. "
+                    "Please use python script instead."
+                )
+            key = "initialize_structures.structure_paths"
+            variable = "structure"
+        elif command.component == "profile":
+            if self.inputs.get("initialize_profile.profile_path") is not None:
+                raise ValueError(
+                    "Multiple profiles are not supported by `runmacro`. "
+                    "Please use python script instead."
+                )
+            key = "initialize_profile.profile_path"
+            variable = "profile"
+        else:
+            raise ValueError(
+                f"Unknown component type: {command.component} "
+                "Please use 'structure' or 'profile'."
+            )
+        source_path = Path(command.source)
+        if not source_path.exists():
+            raise FileNotFoundError(
+                f"{command.component} {source_path} not found. "
+                "Please ensure the path is correct and the file exists."
+            )
+        self.inputs[key] = str(source_path)
+        self.variables[command.name] = variable
+        if variable == "structure":
+            self.input_as_list("initialize_structures.names", command.name)
+
+    def set_command_processor(self, command):
+        if command.name == "equation":
+            key = "initialize_contribution.equation"
+        elif command.name in self.variables:
+            if self.variables[command.name] == "structure":
+                if command.attribute == "spacegroup":
+                    key = "initialize_structures.spacegroups"
+                else:
+                    key = "initialize_structures." + command.attribute
+            elif self.variables[command.name] == "profile":
+                key = "initialize_profile." + command.attribute
+            else:
+                raise ValueError(
+                    f"Unknown variable type for name: {command.name}. "
+                    "This is an internal error. Please report this issue to "
+                    "the developers."
+                )
+        else:
+            raise ValueError(
+                f"Unknown name in set command: {command.name}. "
+                "Please ensure that it is typed correctly as 'equation' or "
+                "it matches a previously loaded structure or "
+                "profile. "
+            )
+        self.input_as_list(key, command.value)
+
+    def parameter_block_processor(self, variable_block):
+        self.inputs["set_initial_variable_values.variable_name_to_value"] = {}
+        self.inputs["refine_variables.variable_names"] = []
+        parameters = yaml.safe_load(variable_block.content)
+        if not isinstance(parameters, list):
+            raise ValueError(
+                "Parameter block should contain a list of parameters. "
+                "Please use the following format:\n"
+                "- param1  # use default initial value\n"
+                "- param2: initial_value\n"
+            )
+        for item in parameters:
+            if isinstance(item, str):
+                self.inputs["refine_variables.variable_names"].append(
+                    item.replace(".", "_")
+                )
+            elif isinstance(item, dict):
+                pname, pvalue = list(item.items())[0]
+                self.inputs[
+                    "set_initial_variable_values.variable_name_to_value"
+                ][pname.replace(".", "_")] = pvalue
+                self.inputs["refine_variables.variable_names"].append(
+                    pname.replace(".", "_")
+                )
+            else:
+                raise ValueError(
+                    "Variables block items are not correctly formatted. "
+                    "Please use the following format:\n"
+                    "- param1  # use default initial value\n"
+                    "- param2: initial_value\n"
+                )
+
+    def create_command_processor(self, command):
+        self.inputs["add_contribution_variables.variable_names"] = (
+            command.value
+        )
+
+    def save_command_processor(self, command):
+        self.inputs["save_results.result_path"] = command.source
+
+    def required_args(self, func):
+        sig = inspect.signature(func)
+        return [
+            name
+            for name, p in sig.parameters.items()
+            if p.default is inspect.Parameter.empty
+            and p.kind
+            in (
+                inspect.Parameter.POSITIONAL_ONLY,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY,
+            )
+        ]
+
+    def call_pdfadapter_method(self, method_name, function_requirement):
+        func = getattr(self.pdfadapter, method_name)
+        required_arguments = self.required_args(func)
+        arguments = {
+            key.split(".")[1]: value
+            for key, value in self.inputs.items()
+            if key.startswith(method_name)
+        }
+        if not all(arg in arguments for arg in required_arguments):
+            missing_args = [
+                arg for arg in required_arguments if arg not in arguments
+            ]
+            if function_requirement == "required":
+                raise ValueError(
+                    "Missing required arguments for function "
+                    f"'{method_name}' {', '.join(missing_args)}. "
+                    "Please provide these arguments in the macro file."
+                )
+            elif function_requirement == "optional":
+                print(
+                    "Missing required arguments for function "
+                    f"'{method_name}' {', '.join(missing_args)}. "
+                    "This function will be skipped. "
+                    "Please provide these arguments in the macro file "
+                    "to activate this function."
+                )
+                return
+        func(**arguments)
+
+    def preprocess(self):
+        methods_to_call = [
+            ("initialize_profile", "required"),
+            ("initialize_structures", "required"),
+            ("initialize_contribution", "required"),
+            ("initialize_recipe", "required"),
+            ("add_contribution_variables", "optional"),
+            ("set_initial_variable_values", "optional"),
+        ]
+        for method in methods_to_call:
+            self.call_pdfadapter_method(*method)
+
+    def run(self):
+        methods_to_call = [
+            ("refine_variables", "required"),
+            ("save_results", "optional"),
+        ]
+        for method in methods_to_call:
+            self.call_pdfadapter_method(*method)
+        return self.pdfadapter.get_results()
+
+
+def runmacro(args):
+    dpin_path = Path(args.file)
+    if not dpin_path.exists():
+        raise FileNotFoundError(
+            f"{str(dpin_path)} not found. Please check if this file "
+            "exists and provide the correct path to it."
+        )
+    dsl_code = dpin_path.read_text()
+    parser = MacroParser()
+    parser.parse(dsl_code)
+    parser.preprocess()
+    return parser.run()
+
+
+if __name__ == "__main__":
+    parser = MacroParser()
+    code = f"""
+load structure G1 from "{str(Path(__file__).parents[3] / "tests/data/Ni.cif")}"
+load profile exp_ni from "{str(Path(__file__).parents[3] / "tests/data/Ni.gr")}"
+
+set G1 spacegroup as auto
+set exp_ni q_range as 0.1 25
+set exp_ni calculation_range as 1.5 50 0.01
+create equation variables s0
+set equation as "s0*G1"
+save to "results.json"
+
+variables:
+---
+- G1.a: 3.52
+- s0: 0.4
+- G1.Uiso_0: 0.005
+- G1.delta2: 2
+- qdamp: 0.04
+- qbroad: 0.02
+---
+"""  # noqa: E501
+    parser.parse(code)
+    parser.preprocess()
+    recipe = parser.pdfadapter.recipe
+    for pname, param in recipe._parameters.items():
+        print(f"{pname}: {param.value}")

diffpy/apps/apps.py

@@ -0,0 +1,81 @@
+import argparse
+
+from diffpy.apps.app_agentify import agentify
+from diffpy.apps.app_runmacro import runmacro
+from diffpy.apps.version import __version__  # noqa
+
+
+class DiffpyHelpFormatter(argparse.RawDescriptionHelpFormatter):
+    """Format subcommands without showing an extra placeholder entry."""
+
+    def _format_action(self, action):
+        if isinstance(action, argparse._SubParsersAction):
+            return "".join(
+                self._format_action(subaction)
+                for subaction in self._iter_indented_subactions(action)
+            )
+        return super()._format_action(action)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="diffpy.apps",
+        description=(
+            "User applications to help with tasks using diffpy packages\n\n"
+            "For more information, visit: "
+            "https://github.com/diffpy/diffpy.apps/"
+        ),
+        formatter_class=DiffpyHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"diffpy.apps {__version__}",
+    )
+    apps_parsers = parser.add_subparsers(
+        title="Available applications",
+        dest="application",
+    )
+    # runmacro application
+    runmacro_parser = apps_parsers.add_parser(
+        "runmacro",
+        help="Run a macro `<.dp-in>` file",
+    )
+    runmacro_parser.add_argument(
+        "file",
+        type=str,
+        help="Path to the  `<.dp-in>` macro file to be run",
+    )
+    runmacro_parser.set_defaults(func=runmacro)
+    # agentify application
+    agentify_parser = apps_parsers.add_parser(
+        "agentify",
+        help="Deploy diffpy.cmi agentic skills in the local environment.",
+    )
+    agentify_parser.add_argument(
+        "--agent",
+        help="The agent to use for the agentic skill.",
+        default="claude",
+        choices=["claude", "codex"],
+    )
+    agentify_parser.add_argument(
+        "--update",
+        action="store_true",
+        help="When set, update the existing agentic skill.",
+    )
+    agentify_parser.add_argument(
+        "--system",
+        action="store_true",
+        help="When set, deploy the agentic skill to the system directory.",
+    )
+    agentify_parser.set_defaults(func=agentify)
+    args = parser.parse_args()
+    if args.application is None:
+        parser.print_help()
+    else:
+        args.func(args)
+
+
+if __name__ == "__main__":
+    main()

diffpy/apps/pdfadapter.py

@@ -0,0 +1,341 @@
+import json
+import warnings
+from pathlib import Path
+
+import numpy
+from scipy.optimize import least_squares
+
+from diffpy.srfit.fitbase import (
+    FitContribution,
+    FitRecipe,
+    FitResults,
+    Profile,
+)
+from diffpy.srfit.pdf import PDFGenerator, PDFParser
+from diffpy.srfit.structure import constrainAsSpaceGroup
+from diffpy.structure.parsers import getParser
+
+
+class PDFAdapter:
+    """Build and configure a PDF fitting workflow backed by
+    diffpy.srfit.
+
+    The adapter assembles the profile, structure generators, contribution,
+    and recipe objects required for a PDF refinement, then exposes the fit
+    results in a JSON-compatible dictionary.
+
+    Public methods
+    --------------
+    initialize_profile(profile_path: str, q_range=None, calculation_range=None)
+        Load the experimental PDF profile.
+    initialize_structures(
+        structure_paths: list[str], run_parallel=True, spacegroups=None,
+        names=None
+    )
+        Load structures and create PDFGenerator objects for them.
+    initialize_contribution(equation_string=None)
+        Create the FitContribution from the loaded profile and generators.
+    initialize_recipe()
+        Create the FitRecipe for the current contribution.
+    set_initial_variable_values(variable_name_to_value: dict)
+        Set recipe parameter values by name.
+    get_results()
+        Return the current fit results as a JSON-compatible dictionary.
+    """
+
+    def initialize_profile(
+        self,
+        profile_path: str,
+        q_range=None,
+        calculation_range=None,
+    ):
+        """Load the experimental PDF profile.
+
+        Parameters
+        ----------
+        profile_path : str
+            The path to the experimental PDF profile file.
+        q_range : sequence of float, optional
+            The two-element sequence containing qmin and qmax. When omitted,
+            the values parsed from the profile file are used.
+        calculation_range : list or tuple of three floats, optional
+            The three-element sequence or mapping defining xmin, xmax, and dx
+            for the calculation range. When omitted, the range parsed from the
+            profile file is used.
+        """
+        profile = Profile()
+        parser = PDFParser()
+        parser.parseString(Path(profile_path).read_text())
+        profile.loadParsedData(parser)
+        if q_range is not None:
+            profile.meta["qmin"] = q_range[0]
+            profile.meta["qmax"] = q_range[1]
+        if calculation_range is not None:
+            if isinstance(calculation_range, (list, tuple)):
+                calculation_range = {
+                    "xmin": calculation_range[0],
+                    "xmax": calculation_range[1],
+                    "dx": calculation_range[2],
+                }
+            profile.setCalculationRange(**calculation_range)
+        self.profile = profile
+
+    def initialize_structures(
+        self,
+        structure_paths: list[str],
+        run_parallel=True,
+        spacegroups=None,
+        names=None,
+    ):
+        """Load structures and create PDFGenerator objects for them.
+
+        This method should be called after initialize_profile.
+
+        Parameters
+        ----------
+        structure_paths : list of str
+            The paths to structure files in CIF format.
+        run_parallel : bool
+            If True, enable generator parallelization when the optional
+            dependencies are available.
+        spacegroups : list of str or None
+            The space groups are inferred from the parsed CIF
+            files when available and otherwise default to "P1". They will be
+            used to impose symmetry constraints on the structure parameters
+            during fitting.
+        names : list of str or None
+            The names assigned to the generators. Missing names default to
+            "G1", "G2", and so on.
+        """
+        if isinstance(structure_paths, str):
+            structure_paths = [structure_paths]
+        structures = []
+        have_spacegroups = False
+        if spacegroups is not None:
+            if len(spacegroups) != len(structure_paths):
+                raise ValueError(
+                    f"spacegroups list {spacegroups} must match "
+                    f"structure_paths list {structure_paths}. "
+                    "Please provide a space group for each structure or set "
+                    "spacegroups to None to infer them automatically."
+                )
+            else:
+                have_spacegroups = True
+        if not have_spacegroups:
+            spacegroups = []
+        pdfgenerators = []
+        if run_parallel:
+            try:
+                import multiprocessing
+                from multiprocessing import Pool
+
+                import psutil
+
+                syst_cores = multiprocessing.cpu_count()
+                cpu_percent = psutil.cpu_percent()
+                avail_cores = numpy.floor(
+                    (100 - cpu_percent) / (100.0 / syst_cores)
+                )
+                ncpu = int(numpy.max([1, avail_cores]))
+                pool = Pool(processes=ncpu)
+                self.pool = pool
+            except ImportError:
+                warnings.warn(
+                    "\nYou don't appear to have the necessary packages for "
+                    "parallelization. Proceeding without parallelization."
+                )
+                run_parallel = False
+        for i, structure_path in enumerate(structure_paths):
+            name = names[i] if names and i < len(names) else f"G{i+1}"
+            stru_parser = getParser("cif")
+            structure = stru_parser.parse(Path(structure_path).read_text())
+            sg = getattr(stru_parser, "spacegroup", None)
+            spacegroup = sg.short_name if sg is not None else "P1"
+            structures.append(structure)
+            if not have_spacegroups:
+                spacegroups.append(spacegroup)
+            else:
+                if spacegroups[i] == "auto":
+                    spacegroups[i] = spacegroup
+            pdfgenerator = PDFGenerator(name)
+            pdfgenerator.setStructure(structure)
+            if run_parallel:
+                pdfgenerator.parallel(ncpu=ncpu, mapfunc=self.pool.map)
+            pdfgenerators.append(pdfgenerator)
+        self.spacegroups = spacegroups
+        self.pdfgenerators = pdfgenerators
+
+    def initialize_contribution(self, equation=None):
+        """Create the FitContribution from the loaded profile and
+        generators.
+
+        This method should be called after initialize_profile and
+        initialize_structures.
+
+        Parameters
+        ----------
+        equation : list of str, optional
+            The list of a single equation passed to
+            FitContribution.setEquation.
+
+        Returns
+        -------
+        FitContribution
+            The configured contribution object.
+        """
+        equation = equation[0] if equation is not None else None
+        contribution = FitContribution("pdfcontribution")
+        contribution.setProfile(self.profile)
+        for pdfgenerator in self.pdfgenerators:
+            contribution.addProfileGenerator(pdfgenerator)
+        contribution.setEquation(equation)
+        self.contribution = contribution
+        return self.contribution
+
+    def initialize_recipe(
+        self,
+    ):
+        """Create the FitRecipe for the current contribution.
+
+        This method should be called after initialize_contribution. The
+        recipe includes shared qdamp and qbroad variables, per-generator
+        delta1 and delta2 variables, and structure parameters
+        constrained by the space group.
+        """
+
+        recipe = FitRecipe()
+        recipe.addContribution(self.contribution)
+        qdamp = recipe.newVar("qdamp", fixed=False, value=0.04)
+        qbroad = recipe.newVar("qbroad", fixed=False, value=0.02)
+        for i, (pdfgenerator, spacegroup) in enumerate(
+            zip(self.pdfgenerators, self.spacegroups)
+        ):
+            for pname in [
+                "delta1",
+                "delta2",
+            ]:
+                par = getattr(pdfgenerator, pname)
+                recipe.addVar(
+                    par, name=f"{pdfgenerator.name}_{pname}", fixed=False
+                )
+            recipe.constrain(pdfgenerator.qdamp, qdamp)
+            recipe.constrain(pdfgenerator.qbroad, qbroad)
+            stru_parset = pdfgenerator.phase
+            spacegroupparams = constrainAsSpaceGroup(stru_parset, spacegroup)
+            for par in spacegroupparams.xyzpars:
+                recipe.addVar(
+                    par, name=f"{pdfgenerator.name}_{par.name}", fixed=False
+                )
+            for par in spacegroupparams.latpars:
+                recipe.addVar(
+                    par, name=f"{pdfgenerator.name}_{par.name}", fixed=False
+                )
+            for par in spacegroupparams.adppars:
+                recipe.addVar(
+                    par, name=f"{pdfgenerator.name}_{par.name}", fixed=False
+                )
+        recipe.fithooks[0].verbose = 0
+        self.recipe = recipe
+
+    def add_contribution_variables(self, variable_names):
+        """Add contribution parameters to the recipe.
+
+        Parameters
+        ----------
+        variable_names : list of str
+            The names of the variables to be added to the recipe.
+            e.g. 's0' for scale factor.
+        """
+        for var_name in variable_names:
+            self.recipe.addVar(
+                getattr(self.contribution, var_name),
+                name=var_name,
+                fixed=False,
+            )
+
+    def refine_variables(self, variable_names):
+        """Refine the specified variables.
+
+        Parameters
+        ----------
+        variable_names : list of str
+            The names of the variables to be refined.
+        """
+        self.recipe.fix("all")
+        for var in variable_names:
+            self.recipe.free(var)
+            least_squares(self.recipe.residual, self.recipe.values)
+
+    def set_initial_variable_values(self, variable_name_to_value: dict):
+        """Set recipe parameter values by name.
+
+        Parameters
+        ----------
+        variable_name_to_value : dict
+            Mapping from recipe variable names to new values.
+        """
+        for vname, vvalue in variable_name_to_value.items():
+            self.recipe._parameters[vname].setValue(vvalue)
+
+    def get_results(self):
+        """Return the current fit results as a JSON-compatible
+        dictionary.
+
+        Returns
+        -------
+        dict
+            Residual statistics, variable values, constraints, the covariance
+            matrix, and a certainty flag.
+        """
+        fit_results = FitResults(self.recipe)
+        results_dict = {}
+        results_dict["residual"] = fit_results.residual
+        results_dict["contributions"] = (
+            fit_results.residual - fit_results.penalty
+        )
+        results_dict["restraints"] = fit_results.penalty
+        results_dict["chi2"] = fit_results.chi2
+        results_dict["reduced_chi2"] = fit_results.rchi2
+        results_dict["rw"] = fit_results.rw
+        # variables
+        results_dict["variables"] = {}
+        for name, val, unc in zip(
+            fit_results.varnames, fit_results.varvals, fit_results.varunc
+        ):
+            results_dict["variables"][name] = {
+                "value": val,
+                "uncertainty": unc,
+            }
+        # fixed variables
+        results_dict["fixed_variables"] = {}
+        if fit_results.fixednames is not None:
+            for name, val in zip(
+                fit_results.fixednames, fit_results.fixedvals
+            ):
+                results_dict["fixed_variables"][name] = {"value": val}
+        # constraints
+        results_dict["constraints"] = {}
+        if fit_results.connames and fit_results.showcon:
+            for con in fit_results.conresults.values():
+                for i, loc in enumerate(con.conlocs):
+                    names = [obj.name for obj in loc]
+                    name = ".".join(names)
+                    val = con.convals[i]
+                    unc = con.conuncs[i]
+                    results_dict["constraints"][name] = {
+                        "value": val,
+                        "uncertainty": unc,
+                    }
+        # covariance matrix
+        results_dict["covariance_matrix"] = fit_results.cov.tolist()
+        # certainty
+        certain = True
+        for con in fit_results.conresults.values():
+            if (con.dy == 1).all():
+                certain = False
+        results_dict["certain"] = certain
+        return results_dict
+
+    def save_results(self, result_path):
+        with open(result_path, "w") as f:
+            json.dump(self.get_results(), f, indent=4)

diffpy/apps/version.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# (c) 2026 diffpy.apps contributors.
+# All rights reserved.
+#
+# File coded by: Yuchen Xiao, Simon Billinge and members of the Billinge group.
+#
+# See GitHub contributions for a more detailed list of contributors.
+# https://github.com/diffpy/diffpy.apps/graphs/contributors  # noqa: E501
+#
+# See LICENSE.rst for license information.
+#
+##############################################################################
+"""Definition of __version__."""
+
+#  We do not use the other three variables, but can be added back if needed.
+#  __all__ = ["__date__", "__git_commit__", "__timestamp__", "__version__"]
+
+# obtain version information
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("diffpy.apps")
+except PackageNotFoundError:
+    __version__ = "unknown"

diffpy_apps-0.1.0.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: diffpy.apps
+Version: 0.1.0
+Summary: User applications to help with tasks using diffpy packages
+Author-email: Yuchen Xiao <yx2924@columbia.edu>, Simon Billinge <sbillinge@ucsb.edu>
+Maintainer-email: Yuchen Xiao <yx2924@columbia.edu>, Simon Billinge <sbillinge@ucsb.edu>
+Project-URL: Homepage, https://github.com/diffpy/diffpy.apps/
+Project-URL: Issues, https://github.com/diffpy/diffpy.apps/issues/
+Keywords: diffraction,PDF,X-ray,neutron
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+License-File: AUTHORS.rst
+Requires-Dist: numpy
+Dynamic: license-file
+
+|Icon| |title|_
+===============
+
+.. |title| replace:: diffpy.apps
+.. _title: https://diffpy.github.io/diffpy.apps
+
+.. |Icon| image:: https://avatars.githubusercontent.com/diffpy
+        :target: https://diffpy.github.io/diffpy.apps
+        :height: 100px
+
+|PyPI| |Forge| |PythonVersion| |PR|
+
+|CI| |Codecov| |Black| |Tracking|
+
+.. |Black| image:: https://img.shields.io/badge/code_style-black-black
+        :target: https://github.com/psf/black
+
+.. |CI| image:: https://github.com/diffpy/diffpy.apps/actions/workflows/matrix-and-codecov-on-merge-to-main.yml/badge.svg
+        :target: https://github.com/diffpy/diffpy.apps/actions/workflows/matrix-and-codecov-on-merge-to-main.yml
+
+.. |Codecov| image:: https://codecov.io/gh/diffpy/diffpy.apps/branch/main/graph/badge.svg
+        :target: https://codecov.io/gh/diffpy/diffpy.apps
+
+.. |Forge| image:: https://img.shields.io/conda/vn/conda-forge/diffpy.apps
+        :target: https://anaconda.org/conda-forge/diffpy.apps
+
+.. |PR| image:: https://img.shields.io/badge/PR-Welcome-29ab47ff
+        :target: https://github.com/diffpy/diffpy.apps/pulls
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/diffpy.apps
+        :target: https://pypi.org/project/diffpy.apps/
+
+.. |PythonVersion| image:: https://img.shields.io/pypi/pyversions/diffpy.apps
+        :target: https://pypi.org/project/diffpy.apps/
+
+.. |Tracking| image:: https://img.shields.io/badge/issue_tracking-github-blue
+        :target: https://github.com/diffpy/diffpy.apps/issues
+
+User applications to help with tasks using diffpy packages. Currently it
+contains
+
+- `runmacro`: A runner for DiffPy macro files.
+- `agentify`: A deployer for diffpy.cmi agentic skills.
+
+For more information about the diffpy.apps library, please consult our `online documentation <https://diffpy.github.io/diffpy.apps>`_.
+
+Citation
+--------
+
+If you use diffpy.apps in a scientific publication, we would like you to cite this package as
+
+        diffpy.apps Package, https://github.com/diffpy/diffpy.apps
+
+Installation
+------------
+
+The preferred method is to use `Miniconda Python
+<https://docs.conda.io/projects/miniconda/en/latest/miniconda-install.html>`_
+and install from the "conda-forge" channel of Conda packages.
+
+To add "conda-forge" to the conda channels, run the following in a terminal. ::
+
+        conda config --add channels conda-forge
+
+We want to install our packages in a suitable conda environment.
+The following creates and activates a new environment named ``diffpy.apps_env`` ::
+
+        conda create -n diffpy.apps_env diffpy.apps python=3.13
+        conda activate diffpy.apps_env
+
+The output should print the latest version displayed on the badges above.
+
+If the above does not work, you can use ``pip`` to download and install the latest release from
+`Python Package Index <https://pypi.python.org>`_.
+
+You still need to install some of its dependencies from ``conda`` ::
+
+        git clone https://github.com/diffpy/diffpy.apps.git
+        cd diffpy.apps
+        conda activate diffpy.apps_env
+        conda install --file requirements/conda.txt
+
+
+To install using ``pip`` into your ``diffpy.apps_env`` environment, type ::
+
+        pip install diffpy.apps
+
+If you prefer to install from sources, after installing the dependencies, obtain the source archive from
+`GitHub <https://github.com/diffpy/diffpy.apps/>`_. Once installed, ``cd`` into your ``diffpy.apps`` directory
+and run the following ::
+
+        pip install .
+
+This package also provides command-line utilities. To check the software has been installed correctly, type ::
+
+        diffpy.apps --version
+
+You can also type the following command to verify the installation. ::
+
+        python -c "import diffpy.apps; print(diffpy.apps.__version__)"
+
+
+To view the basic usage and available commands, type ::
+
+        diffpy.apps -h
+
+Getting Started
+---------------
+
+You may consult our `online documentation <https://diffpy.github.io/diffpy.apps>`_ for tutorials and API references.
+
+Support and Contribute
+----------------------
+
+If you see a bug or want to request a feature, please `report it as an issue <https://github.com/diffpy/diffpy.apps/issues>`_ and/or `submit a fix as a PR <https://github.com/diffpy/diffpy.apps/pulls>`_.
+
+Feel free to fork the project and contribute. To install diffpy.apps
+in a development mode, with its sources being directly used by Python
+rather than copied to a package directory, use the following in the root
+directory ::
+
+        pip install -e .
+
+To ensure code quality and to prevent accidental commits into the default branch, please set up the use of our pre-commit
+hooks.
+
+1. Install pre-commit in your working environment by running ``conda install pre-commit``.
+
+2. Initialize pre-commit (one time only) ``pre-commit install``.
+
+Thereafter your code will be linted by black and isort and checked against flake8 before you can commit.
+If it fails by black or isort, just rerun and it should pass (black and isort will modify the files so should
+pass after they are modified). If the flake8 test fails please see the error messages and fix them manually before
+trying to commit again.
+
+Improvements and fixes are always appreciated.
+
+Before contributing, please read our `Code of Conduct <https://github.com/diffpy/diffpy.apps/blob/main/CODE-OF-CONDUCT.rst>`_.
+
+Contact
+-------
+
+For more information on diffpy.apps please visit the project `web-page <https://diffpy.github.io/>`_ or email the maintainers ``Yuchen Xiao(yx2924@columbia.edu) and Simon Billinge(sbillinge@ucsb.edu)``.
+
+Acknowledgements
+----------------
+
+``diffpy.apps`` is built and maintained with `scikit-package <https://scikit-package.github.io/scikit-package/>`_.

diffpy_apps-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+diffpy/__init__.py,sha256=A_tOI_1lETnfUo1dOfJIONN5aofysoAQ_ZGsYxsAfMI,525
+diffpy/apps/__init__.py,sha256=XsuN1OGd0KAO2ultaC3sMepmjS0S29E0DmC7m1iGgJs,720
+diffpy/apps/app_agentify.py,sha256=MiqRXEkFoNGl108ig9iMzmKe1RWS7oBylX-dfAx1M_0,1151
+diffpy/apps/app_runmacro.py,sha256=4I0mOToOcaroRyIDV_vJr7vkCtkPapCp5zhJYWjTbyQ,10144
+diffpy/apps/apps.py,sha256=xJ161akAKLj9ZwdpfYOQ0jgtsABfcq6YaZi_Y3toowc,2394
+diffpy/apps/pdfadapter.py,sha256=HxiROGXmj1I5_gNDx5xrswsNwiDDMFZd5X6H-oS43RE,12732
+diffpy/apps/version.py,sha256=_B5JoKsrDgIoVd7YfbUt_QnZbFto9XFOgZFRYfu0XgA,898
+diffpy_apps-0.1.0.dist-info/licenses/AUTHORS.rst,sha256=FGOWUsPNZ9m4ss1MD_wVMRR4tDpgqQeGnQdtTnq4u64,199
+diffpy_apps-0.1.0.dist-info/licenses/LICENSE.rst,sha256=BnJcVQf_9vCrIUVdJ3LxMD5S3cjQjuiOeyGReFV8bqQ,1533
+diffpy_apps-0.1.0.dist-info/METADATA,sha256=jq6Vy5Cq_pI6L-MRazvddroi4Qt5z_p3ElYKw-VfqSM,6957
+diffpy_apps-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+diffpy_apps-0.1.0.dist-info/entry_points.txt,sha256=JXWRMH9NTZLJrtVkw6hVOrFJjCbR1y71ey7Dnv-40iU,89
+diffpy_apps-0.1.0.dist-info/top_level.txt,sha256=34qLZyi9mxikpHepVDTMHrrNbe8VoOuz3ShYeiWA7KA,7
+diffpy_apps-0.1.0.dist-info/RECORD,,

diffpy_apps-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

diffpy_apps-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+diffpy.app = diffpy.apps.apps:main
+diffpy.apps = diffpy.apps.apps:main

diffpy_apps-0.1.0.dist-info/licenses/AUTHORS.rst

@@ -0,0 +1,10 @@
+Authors
+=======
+
+Yuchen Xiao, Simon Billinge and members of the Billinge group
+
+Contributors
+------------
+
+For a list of contributors, visit
+https://github.com/diffpy/diffpy.apps/graphs/contributors

diffpy_apps-0.1.0.dist-info/licenses/LICENSE.rst

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, diffpy.apps contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

diffpy_apps-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+diffpy