pdfbl.sequential 0.1.0rc0__py3-none-any.whl

pdfbl/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# (c) 2025 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/pdf-bl/pdfbl.sequential/graphs/contributors
+#
+# See LICENSE.rst for license information.
+#
+##############################################################################

pdfbl/sequential/__init__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# (c) 2025 Simon Billinge.
+# All rights reserved.
+#
+# File coded by: members of the Billinge Group and PDF beamline at NSLS-II.
+#
+# See GitHub contributions for a more detailed list of contributors.
+# https://github.com/pdf-bl/pdfbl.sequential/graphs/contributors
+#
+# See LICENSE.rst for license information.
+#
+##############################################################################
+"""Automated sequential refinements of PDF data."""
+
+# package version
+from pdfbl.sequential.version import __version__  # noqa
+
+# silence the pyflakes syntax checker
+assert __version__ or True
+
+# End of file

pdfbl/sequential/pdfadapter.py

@@ -0,0 +1,448 @@
+import json
+import tempfile
+import warnings
+from pathlib import Path
+from queue import Queue
+from typing import Literal
+
+import numpy
+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
+from scipy.optimize import least_squares
+
+
+class PDFAdapter:
+    """Adapter to expose PDF fitting interface. Designed to provide a
+    simplified PDF fitting interface for human users and AI agents.
+
+    Attributes
+    ----------
+    recipe : FitRecipe
+        The FitRecipe object managing the fitting process.
+
+    Methods
+    -------
+    initialize_profile(profile_path, qmin=None, qmax=None, xmin=None, xmax=None, dx=None)
+        Load and initialize the PDF profile from the given file path with
+        some optional parameters.
+    initialize_structures(structure_paths : list[str], run_parallel=True)
+        Load and initialize the structures from the given file paths, and
+        generate corresponding PDFGenerator objects.
+    initialize_contribution(equation_string=None)
+        Initialize the FitContribution object combining the PDF generators and
+        the profile.
+    initialize_recipe()
+        Initialize the FitRecipe object for the fitting process.
+    set_initial_variable_values(variable_name_to_value : dict)
+        Update parameter values from the provided dictionary.
+    refine_variables(variable_names: list[str])
+        Refine the parameters specified in the list and in that order.
+    get_variable_names()
+        Get the names of all variables in the recipe.
+    save_results(mode: str, filename: str=None)
+        Save the fitting results.
+    """  # noqa: E501
+
+    def __init__(self):
+        self.intermediate_results = {}
+        self.iter_count = 0
+
+    def monitor_intermediate_results(
+        self, key: str, step: int = 10, queue: Queue = None
+    ):
+        """Store an intermediate result during the fitting process.
+
+        Parameters
+        ----------
+        key : str
+            The key to identify the intermediate result.
+        step : int
+            The step interval to store the intermediate result.
+        queue : Queue
+            The queue to store the intermediate results.
+        """
+        if queue is None:
+            queue = Queue()
+        self.intermediate_results[(key, step)] = queue
+
+    def initialize_profile(
+        self,
+        profile_path: str,
+        qmin=None,
+        qmax=None,
+        xmin=None,
+        xmax=None,
+        dx=None,
+    ):
+        """Load and initialize the PDF profile from the given file path
+        with some optional parameters.
+
+        The target output, FitRecipe, requires a profile object, multiple
+        PDFGenerator objects, and a FitContribution object combining them. This
+        method initializes the profile object.
+
+        Parameters
+        ----------
+        profile_path : str
+            The path to the experimental PDF profile file.
+        qmin : float
+            The minimum Q value for PDF calculation. The default value is
+            the one parsed from the profile file.
+        qmax : float
+            The maximum Q value for PDF calculation. The default value is the
+            one parsed from the profile file.
+        xmin : float
+            The minimum r value for PDF calculation. The default value is the
+            one parsed from the profile file.
+        xmax : float
+            The maximum r value for PDF calculation. The default value is the
+            one parsed from the profile file.
+        dx : float
+            The r step size for PDF calculation. The default value is the
+            one parsed from the profile file.
+        """
+        profile = Profile()
+        parser = PDFParser()
+        parser.parseString(Path(profile_path).read_text())
+        profile.loadParsedData(parser)
+        if qmin:
+            profile.meta["qmin"] = qmin
+        if qmax:
+            profile.meta["qmax"] = qmax
+        profile.setCalculationRange(xmin=xmin, xmax=xmax, dx=dx)
+        self.profile = profile
+
+    def initialize_structures(
+        self, structure_paths: list[str], run_parallel=True
+    ):
+        """Load and initialize the structures from the given file paths,
+        and generate corresponding PDFGenerator objects.
+
+        The target output, FitRecipe, requires a profile object, multiple
+        PDFGenerator objects, and a FitContribution object combining them. This
+        method creates the PDFGenerator objects from the structure files.
+
+        Must be called after initialize_profile.
+
+        Parameters
+        ----------
+        structure_paths : list of str
+            The list of paths to the structure files (CIF format).
+
+        Notes
+        -----
+        Planned features:
+            - Support cif file manipulation.
+                - Add/Remove atoms.
+                - symmetry operations?
+        """
+        if isinstance(structure_paths, str):
+            structure_paths = [structure_paths]
+        structures = []
+        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):
+            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)
+            spacegroups.append(spacegroup)
+            pdfgenerator = PDFGenerator(f"G{i+1}")
+            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_string=None):
+        """Initialize the FitContribution object combining the PDF
+        generators and the profile.
+
+        The target output, FitRecipe, requires a profile object, multiple
+        PDFGenerator objects, and a FitContribution object combining them. This
+        method creates the FitContribution object combining the profile and PDF
+        generators.
+
+        Must be called after initialize_profile and initialize_structures.
+
+        Parameters
+        ----------
+        equation_string : str
+            The equation string defining the contribution. The default
+            equation will be generated based on the number of phases.
+            e.g.
+            for one phase: "s0*G1",
+            for two phases: "s0*(s1*G1+(1-s1)*G2)",
+            for three phases: "s0*(s1*G1+s2*G2+(1-(s1+s2))*G3)",
+            ...
+
+        Notes
+        -----
+        Planned features:
+            - Support registerFunction for custom equations.
+        """
+        contribution = FitContribution("pdfcontribution")
+        contribution.setProfile(self.profile)
+        for pdfgenerator in self.pdfgenerators:
+            contribution.addProfileGenerator(pdfgenerator)
+        number_of_phase = len(self.pdfgenerators)
+        if equation_string is None:
+            if number_of_phase == 1:
+                equation_string = "s0*G1"
+            else:
+                equation_string = (
+                    "s0*("
+                    + "+".join(
+                        [f"s{i+1}*G{i+1}" for i in range(number_of_phase - 1)]
+                    )
+                    + f"+(1-({'+'.join([f's{i+1}' for i in range(1, number_of_phase)])}))*G{number_of_phase}"  # noqa: E501
+                    + ")"
+                )
+        contribution.setEquation(equation_string)
+        self.contribution = contribution
+        return self.contribution
+
+    def initialize_recipe(
+        self,
+    ):
+        """Initialize the FitRecipe object for the fitting process.
+
+        The target output, FitRecipe, requires a profile object, multiple
+        PDFGenerator objects, and a FitContribution object combining them. This
+        method creates the FitRecipe object combining the profile, PDF
+        generators, and contribution.
+
+        Must be called after initialize_contribution.
+
+        Notes
+        -----
+        Planned features:
+            - support instructions to
+                - add variables
+                - constrain variables of the scatters
+                - change symmetry constraints
+        """
+        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=pname + f"_{i+1}", fixed=False)
+            if len(self.pdfgenerators) > 1:
+                recipe.addVar(
+                    getattr(self.contribution, f"s{i+1}"),
+                    name=f"s{i+1}",
+                    fixed=False,
+                )
+                recipe.restrain(f"s{i+1}", lb=0.0, ub=1.0)
+            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=par.name + f"_{i+1}", fixed=False)
+            for par in spacegroupparams.latpars:
+                recipe.addVar(par, name=par.name + f"_{i+1}", fixed=False)
+            for par in spacegroupparams.adppars:
+                recipe.addVar(par, name=par.name + f"_{i+1}", fixed=False)
+        recipe.addVar(self.contribution.s0, name="s0", fixed=False)
+        recipe.fix("all")
+        recipe.fithooks[0].verbose = 0
+        self.recipe = recipe
+
+    def set_initial_variable_values(self, variable_name_to_value: dict):
+        """Update parameter values from the provided dictionary.
+
+        Parameters
+        ----------
+        variable_name_to_value : dict
+            A dictionary mapping variable names to their new values.
+        """
+        for vname, vvalue in variable_name_to_value.items():
+            self.recipe._parameters[vname].setValue(vvalue)
+
+    def residual(self, p=[]):
+        """Wrapper for the recipe residual function to store
+        intermediate results if needed.
+
+        Parameters
+        ----------
+        p : list
+            List of parameter values.
+
+        Returns
+        -------
+        numpy.ndarray
+            The residual array.
+        """
+        residual = self.recipe.residual(p)
+        if self.intermediate_results is not None:
+            fitresults = FitResults(self.recipe)
+            for (key, step), values in self.intermediate_results.items():
+                if (self.iter_count % step) == 0:
+                    value = getattr(fitresults, key)
+                    values.put(value)
+        self.iter_count += 1
+        return residual
+
+    def refine_variables(self, variable_names: list[str]):
+        """Refine the parameters specified in the list and in that
+        order. Must be called after initialize_recipe.
+
+        Parameters
+        ----------
+        variable_names : list of str
+            The names of the variables to refine.
+        """
+        for vname in variable_names:
+            if vname not in self.recipe._parameters:
+                raise ValueError(
+                    f"Variable {vname} not found in the recipe. "
+                    "Please choose from the existing variables: "
+                    f"{list(self.recipe._parameters.keys())}"
+                )
+        for vname in variable_names:
+            self.recipe.free(vname)
+            least_squares(
+                self.residual,
+                self.recipe.values,
+                x_scale="jac",
+            )
+
+    def get_variable_names(self) -> list[str]:
+        """Get the names of all variables in the recipe.
+
+        Returns
+        -------
+        list of str
+            A list of variable names.
+        """
+        return list(self.recipe._parameters.keys())
+
+    def save_results(
+        self, mode: Literal["str", "dict"] = "str", filename=None
+    ):
+        """Save the fitting results. Must be called after
+        refine_variables.
+
+        Parameters
+        ----------
+        mode : str
+            The format to save the results. Options are:
+                "str" - Save results as a formatted text string.
+                "dict" - Save results as a JSON-compatible dictionary.
+        filename : str
+            The path to the output file. If None, results will not be saved to
+            a file.
+
+        Returns
+        -------
+        str or dict
+            The fitting results in the specified format.
+        """
+        fit_results = FitResults(self.recipe)
+        if mode == "str":
+            if filename is None:
+                tmp_directory = tempfile.TemporaryDirectory()
+                temp_file = Path(tmp_directory.name) / "data.txt"
+                filename = str(temp_file)
+            fit_results.saveResults(filename)
+            with open(filename, "r") as f:
+                results_str = f.read()
+            if filename is None:
+                tmp_directory.cleanup()
+            return results_str
+
+        elif mode == "dict":
+            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
+            if filename is not None:
+                with open(filename, "w") as f:
+                    json.dump(results_dict, f, indent=2)
+            return results_dict
+
+        else:
+            raise ValueError(
+                f"Unsupported mode: {mode}. Please use 'json' or 'txt'."
+            )

pdfbl/sequential/pdfbl_sequential_app.py

@@ -0,0 +1,25 @@
+import argparse
+
+from pdfbl.sequential import __version__
+
+
+def main():
+    """Entry point for the pdfbl-cli.
+
+    Examples
+    --------
+    >>> pdfbl-cli --version
+    """
+    parser = argparse.ArgumentParser(
+        description=(
+            "Scripts for running sequential PDF refinements "
+            "using diffpy.cmi automatically"
+        )
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"pdfbl.sequential {__version__}",
+        help="Show the version of pdfbl.sequential and exit.",
+    )
+    parser.parse_args()

pdfbl/sequential/sequential_cmi_runner.py

@@ -0,0 +1,557 @@
+import json
+import re
+import threading
+import time
+import warnings
+from pathlib import Path
+from queue import Queue
+from types import SimpleNamespace
+from typing import Literal
+
+from bg_mpl_stylesheets.styles import all_styles
+from diffpy.srfit.fitbase import FitResults
+from matplotlib import pyplot as plt
+from prompt_toolkit import PromptSession
+from prompt_toolkit.patch_stdout import patch_stdout
+
+from pdfbl.sequential.pdfadapter import PDFAdapter
+
+plt.style.use(all_styles["bg-style"])
+
+
+class SequentialCMIRunner:
+    def __init__(self):
+        self.input_files_known = []
+        self.input_files_completed = []
+        self.input_files_running = []
+        self.adapter = PDFAdapter()
+        self.visualization_data = {}
+
+    def _validate_inputs(self):
+        for path_name in [
+            "input_data_dir",
+            "output_result_dir",
+        ]:
+            if not Path(self.inputs[path_name]).exists():
+                raise FileNotFoundError(
+                    f"Path '{self.inputs[path_name]}' for "
+                    f"'{path_name}' does not exist. Please check the "
+                    "provided path."
+                )
+            if not Path(self.inputs[path_name]).is_dir():
+                raise NotADirectoryError(
+                    f"Path '{self.inputs[path_name]}' for "
+                    f"'{path_name}' is not a directory. Please check the "
+                    "provided path."
+                )
+        if not Path(self.inputs["structure_path"]).exists():
+            raise FileNotFoundError(
+                f"Structure file '{self.inputs['structure_path']}' does not "
+                "exist. Please check the provided path."
+            )
+        profile_files = list(Path(self.inputs["input_data_dir"]).glob("*"))
+        if len(profile_files) > 0:  # skip variable checking if no input files
+            for tmp_file_path in profile_files:
+                matches = re.findall(
+                    self.inputs["filename_order_pattern"], tmp_file_path.name
+                )
+                if len(matches) == 0:
+                    raise ValueError(
+                        f"Input file '{tmp_file_path}' does not match the "
+                        "filename order pattern. Please check the pattern "
+                        "or the input files."
+                    )
+            tmp_adatper = PDFAdapter()
+            tmp_adatper.initialize_profile(str(tmp_file_path))
+            tmp_adatper.initialize_structures([self.inputs["structure_path"]])
+            tmp_adatper.initialize_contribution()
+            tmp_adatper.initialize_recipe()
+            allowed_variable_names = list(
+                tmp_adatper.recipe._parameters.keys()
+            )
+            for var_name in self.inputs["refinable_variable_names"]:
+                if var_name not in allowed_variable_names:
+                    raise ValueError(
+                        f"Refinable variable '{var_name}' not found in the "
+                        "recipe. Please choose from the existing variables: "
+                        f"{allowed_variable_names}"
+                    )
+            for var_name in self.inputs.get("plot_variable_names", []):
+                if var_name not in allowed_variable_names:
+                    raise ValueError(
+                        f"Variable '{var_name}' is not found in the recipe. "
+                        "Please choose from the existing variables: "
+                        f"{allowed_variable_names}"
+                    )
+        else:
+            warnings.warn(
+                "No input profile files found in the input data directory. "
+                "Skipping variable name validation."
+            )
+        allowed_result_entry_names = [
+            "residual",
+            "contributions",
+            "restraints",
+            "chi2",
+            "reduced_chi2",
+        ]
+        for entry_name in self.inputs.get("plot_result_names", []):
+            if entry_name not in allowed_result_entry_names:
+                raise ValueError(
+                    f"Result entry '{entry_name}' is not a valid entry to "
+                    "plot. Please choose from the following entries: "
+                    f"{allowed_result_entry_names}"
+                )
+        for entry_name in self.inputs.get(
+            "plot_intermediate_result_names", []
+        ):
+            if entry_name not in allowed_result_entry_names:
+                raise ValueError(
+                    f"Intermediate result '{entry_name}' is not a valid "
+                    "entry to plot. Please choose from the following "
+                    "entries: "
+                    f"{allowed_result_entry_names}"
+                )
+
+    def load_inputs(
+        self,
+        input_data_dir,
+        structure_path,
+        output_result_dir="results",
+        filename_order_pattern=r"(\d+)K\.gr",
+        whether_plot_y=False,
+        whether_plot_ycalc=False,
+        plot_variable_names=None,
+        plot_result_names=None,
+        plot_intermediate_result_names=None,
+        refinable_variable_names=None,
+        initial_variable_values=None,
+        xmin=None,
+        xmax=None,
+        dx=None,
+        qmin=None,
+        qmax=None,
+        show_plot=True,
+    ):
+        """Load and validate input configuration for sequential PDF
+        refinement.
+
+        This method initializes the sequential CMI runner with input data,
+        structure information, and refinement parameters, and the plotting
+        configuration.
+
+        Parameters
+        ----------
+        input_data_dir : str
+            The path to the directory containing input PDF profile files.
+        structure_path : str
+            The path to the structure file (e.g., CIF format) used for
+            refinement.
+        output_result_dir : str
+            The path to the directory for storing refinement results.
+            Default is "results".
+        filename_order_pattern : str
+            The regular expression pattern to extract ordering information
+            from filenames.
+            Default is r"(\d+)K\.gr" to extract temperature values from
+            filenames.
+        refinable_variable_names : list of str
+            The list of variable names to refine.
+            Must exist in the recipe.
+            Default variable names are all possible variables that can
+            be created from the input structure and profile.
+        initial_variable_values : dict
+            The dictionary mapping variable names to their initial values.
+            Default is None.
+        xmin : float
+            The minimum x-value for the PDF profile.
+            Default is the value parsed from the input file.
+        xmax : float
+            The maximum x-value for the PDF profile.
+            Default is the value parsed from the input file.
+        dx : float
+            The step size for the PDF profile.
+            Default is the value parsed from the input file.
+        qmin : float
+            The minimum q-value for the PDF profile.
+            Default is the value parsed from the input file.
+        qmax : float
+            The maximum q-value for the PDF profile.
+            Default is the value parsed from the input file.
+        show_plot : bool
+            Whether to display plots during refinement. Default is True.
+        whether_plot_y : bool
+            Whether to plot the experimental PDF data (y). Default is False.
+        whether_plot_ycalc : bool
+            Whether to plot the calculated PDF data (ycalc). Default is False.
+        plot_variable_names : list of str
+            The list of variable names to plot during refinement.
+            Default is None.
+        plot_result_names : list of str
+            The list of fit result entries to plot.
+            Allowed values: "residual", "contributions", "restraints", "chi2",
+            "reduced_chi2". Default is None.
+        plot_intermediate_result_names : list of str
+            The list of intermediate result entries to plot during refinement.
+            Allowed values: "residual", "contributions", "restraints", "chi2",
+            "reduced_chi2". Default is None.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the input data directory, output result directory, or structure
+            file does not exist.
+        NotADirectoryError
+            If input_data_dir or output_result_dir is not a directory.
+        ValueError
+            If a refinable variable name is not found in the recipe, or if a
+            plot result name is not valid.
+
+        Examples
+        --------
+        >>> runner = SequentialCMIRunner()
+        >>> runner.load_inputs(
+        ...     input_data_dir="./data",
+        ...     structure_path="./structure.cif",
+        ...     output_result_dir="./results",
+        ...     refinable_variable_names=["a", "all"],
+        ...     plot_variable_names=["a"],
+        ...     plot_result_names=["chi2"],
+        ...     plot_intermediate_result_names=["residual"],
+        ... )
+        """  # noqa: W605
+        self.inputs = {
+            "input_data_dir": input_data_dir,
+            "structure_path": structure_path,
+            "output_result_dir": output_result_dir,
+            "filename_order_pattern": filename_order_pattern,
+            "xmin": xmin,
+            "xmax": xmax,
+            "dx": dx,
+            "qmin": qmin,
+            "qmax": qmax,
+            "refinable_variable_names": refinable_variable_names or [],
+            "initial_variable_values": initial_variable_values or {},
+            "whether_plot_y": whether_plot_y,
+            "whether_plot_ycalc": whether_plot_ycalc,
+            "plot_variable_names": plot_variable_names or [],
+            "plot_result_names": plot_result_names or [],
+            "plot_intermediate_result_names": plot_intermediate_result_names
+            or [],
+        }
+        self.show_plot = show_plot
+        self._validate_inputs()
+        self._initialize_plots()
+
+    def _initialize_plots(self):
+        whether_plot_y = self.inputs["whether_plot_y"]
+        whether_plot_ycalc = self.inputs["whether_plot_ycalc"]
+        plot_variable_names = self.inputs["plot_variable_names"]
+        plot_result_names = self.inputs["plot_result_names"]
+        plot_intermediate_result_names = self.inputs[
+            "plot_intermediate_result_names"
+        ]
+        if whether_plot_y and whether_plot_ycalc:
+            fig, _ = plt.subplots(2, 1)
+            label = ["ycalc", "y"]
+        elif whether_plot_ycalc or whether_plot_y:
+            fig, _ = plt.subplots()
+            if whether_plot_ycalc:
+                label = ["ycalc"]
+            else:
+                label = ["y"]
+        else:
+            fig = None
+        if fig:
+            axes = fig.axes
+            lines = []
+            for i in range(len(axes)):
+                (line,) = axes[i].plot(
+                    [],
+                    [],
+                    label=label[i],
+                    color=plt.rcParams["axes.prop_cycle"].by_key()["color"][i],
+                )
+                lines.append(line)
+                self.visualization_data[label[i]] = {
+                    "line": line,
+                    "xdata": Queue(),
+                    "ydata": Queue(),
+                }
+            fig.legend()
+        names = ["variables", "results", "intermediate_results"]
+        plot_tasks = [
+            plot_variable_names,
+            plot_result_names,
+            plot_intermediate_result_names,
+        ]
+        for i in range(len(plot_tasks)):
+            if plot_tasks[i] is not None:
+                self.visualization_data[names[i]] = {}
+                for var_name in plot_tasks[i]:
+                    fig, ax = plt.subplots()
+                    (line,) = ax.plot([], [], label=var_name, marker="o")
+                    self.visualization_data[names[i]][var_name] = {
+                        "line": line,
+                        "buffer": [],
+                        "ydata": Queue(),
+                    }
+                    fig.suptitle(f"{names[i].capitalize()}: {var_name}")
+        if plot_intermediate_result_names is not None:
+            for var_name in plot_intermediate_result_names:
+                self.adapter.monitor_intermediate_results(
+                    var_name,
+                    step=10,
+                    queue=self.visualization_data["intermediate_results"][
+                        var_name
+                    ]["ydata"],
+                )
+
+    def _update_plot(self):
+        for key, plot_pack in self.visualization_data.items():
+            if key in ["ycalc", "y"]:
+                if not plot_pack["xdata"].empty():
+                    line = plot_pack["line"]
+                    xdata = plot_pack["xdata"].get()
+                    ydata = plot_pack["ydata"].get()
+                    line.set_xdata(xdata)
+                    line.set_ydata(ydata)
+                    line.axes.relim()
+                    line.axes.autoscale_view()
+            elif (
+                key == "variables"
+                or key == "results"
+                or key == "intermediate_results"
+            ):
+                for _, data_pack in plot_pack.items():
+                    if not data_pack["ydata"].empty():
+                        line = data_pack["line"]
+                        buffer = data_pack["buffer"]
+                        new_y = data_pack["ydata"].get()
+                        buffer.append(new_y)
+                        xdata = list(range(1, len(buffer) + 1))
+                        ydata = buffer
+                        line.set_xdata(xdata)
+                        line.set_ydata(ydata)
+                        line.axes.relim()
+                        line.axes.autoscale_view()
+
+    def _check_for_new_data(self):
+        input_data_dir = self.inputs["input_data_dir"]
+        filename_order_pattern = self.inputs["filename_order_pattern"]
+        files = [file for file in Path(input_data_dir).glob("*")]
+        sorted_file = sorted(
+            files,
+            key=lambda file: int(
+                re.findall(filename_order_pattern, file.name)[0]
+            ),
+        )
+        if (
+            self.input_files_known
+            != sorted_file[: len(self.input_files_known)]
+        ):
+            raise RuntimeError(
+                "Wrong order to run sequential toolset is detected. "
+                "This is likely due to files appearing in the input directory "
+                "in the wrong order. Please restart the sequential toolset."
+            )
+        if self.input_files_known == sorted_file:
+            return
+        self.input_files_known = sorted_file
+        self.input_files_running = [
+            f
+            for f in self.input_files_known
+            if f not in self.input_files_completed
+        ]
+        print(f"{[str(f) for f in self.input_files_running]} detected.")
+
+    def set_start_input_file(
+        self, input_filename, input_filename_to_result_filename
+    ):
+        """Set the starting input file for sequential refinement and
+        continue the interrupted sequential refinement from that point.
+
+        Parameters
+        ----------
+        input_filename : str
+            The name of the input file to start from. This file must be in the
+            input data directory.
+        input_filename_to_result_filename : function
+            The function that takes an input filename and returns the
+            corresponding result filename. This is used to locate the last
+            result file for loading variable values.
+        """
+        self._check_for_new_data()
+        input_file_path = Path(self.inputs["input_data_dir"]) / input_filename
+        if input_file_path not in self.input_files_known:
+            raise ValueError(
+                f"Input file {input_filename} not found in known input files."
+            )
+        start_index = self.input_files_known.index(input_file_path)
+        self.input_files_completed = self.input_files_known[:start_index]
+        self.input_files_running = self.input_files_known[start_index:]
+        last_result_file = input_filename_to_result_filename(
+            self.input_files_completed[-1].name
+        )
+        last_result_file = (
+            Path(self.inputs["output_result_dir"]) / last_result_file
+        )
+        if not Path(last_result_file).exists():
+            raise FileNotFoundError(
+                f"Result file {last_result_file} not found. "
+                "Cannot load last result variable values. "
+                "Please check the provided function or use "
+                "an earlier input file."
+            )
+        last_result_variables_values = json.load(open(last_result_file, "r"))[
+            "variables"
+        ]
+        last_result_variables_values = {
+            name: pack["value"]
+            for name, pack in last_result_variables_values.items()
+        }
+        self.last_result_variables_values = last_result_variables_values
+        print(f"Starting from input file: {self.input_files_running[0].name}")
+
+    def _run_one_cycle(self, stop_event=SimpleNamespace(is_set=lambda: False)):
+        self._check_for_new_data()
+        xmin = self.inputs["xmin"]
+        xmax = self.inputs["xmax"]
+        dx = self.inputs["dx"]
+        qmin = self.inputs["qmin"]
+        qmax = self.inputs["qmax"]
+        structure_path = self.inputs["structure_path"]
+        output_result_dir = self.inputs["output_result_dir"]
+        initial_variable_values = self.inputs["initial_variable_values"]
+        refinable_variable_names = self.inputs["refinable_variable_names"]
+        if not self.input_files_running:
+            return None
+        for input_file in self.input_files_running:
+            if stop_event.is_set():
+                break
+            print(f"Processing {input_file.name}...")
+            self.adapter.initialize_profile(
+                str(input_file),
+                xmin=xmin,
+                xmax=xmax,
+                dx=dx,
+                qmin=qmin,
+                qmax=qmax,
+            )
+            self.adapter.initialize_structures([structure_path])
+            self.adapter.initialize_contribution()
+            self.adapter.initialize_recipe()
+            if not hasattr(self, "last_result_variables_values"):
+                self.last_result_variables_values = initial_variable_values
+            self.adapter.set_initial_variable_values(
+                self.last_result_variables_values
+            )
+            if refinable_variable_names is None:
+                refinable_variable_names = list(initial_variable_values.keys())
+            self.adapter.refine_variables(refinable_variable_names)
+            results = self.adapter.save_results(
+                filename=str(
+                    Path(output_result_dir) / f"{input_file.stem}_result.json"
+                ),
+                mode="dict",
+            )
+            self.last_result_variables_values = {
+                name: pack["value"]
+                for name, pack in results["variables"].items()
+            }
+            self.input_files_completed.append(input_file)
+            if "ycalc" in self.visualization_data:
+                xdata = self.adapter.recipe.pdfcontribution.profile.x
+                ydata = self.adapter.recipe.pdfcontribution.profile.ycalc
+                self.visualization_data["ycalc"]["xdata"].put(xdata)
+                self.visualization_data["ycalc"]["ydata"].put(ydata)
+            if "y" in self.visualization_data:
+                xdata = self.adapter.recipe.pdfcontribution.profile.x
+                ydata = self.adapter.recipe.pdfcontribution.profile.y
+                self.visualization_data["y"]["xdata"].put(xdata)
+                self.visualization_data["y"]["ydata"].put(ydata)
+            for var_name in self.visualization_data.get("variables", {}):
+                new_value = self.adapter.recipe._parameters[var_name].value
+                self.visualization_data["variables"][var_name]["ydata"].put(
+                    new_value
+                )
+            for entry_name in self.visualization_data.get("results", {}):
+                fit_results = FitResults(self.adapter.recipe)
+                entry_value = getattr(fit_results, entry_name)
+                self.visualization_data["results"][entry_name]["ydata"].put(
+                    entry_value
+                )
+            print("Completed!")
+        self.input_files_running = []
+
+    def run(self, mode: Literal["batch", "stream"]):
+        """Run the sequential refinement process in either batch or
+        streaming mode.
+
+        Parameters
+        ----------
+        mode : str
+            The mode to run the sequential refinement. Must be either "batch"
+            or "stream". In "batch" mode, the toolset will run through all
+            available input files once and then stop. In "stream" mode, the
+            runner will continuously monitor the input data directory for new
+            files and process them as they appear, until the user decides
+            to stop the process.
+        """
+        if mode == "batch":
+            self._run_one_cycle()
+            self._update_plot()
+        elif mode == "stream":
+            stop_event = threading.Event()
+            session = PromptSession()
+            if (self.visualization_data is not None) and self.show_plot:
+                plt.ion()
+                plt.pause(0.01)
+
+            def stream_loop():
+                while not stop_event.is_set():
+                    self._run_one_cycle(stop_event)
+                    stop_event.wait(1)  # Check for new data every 1s
+
+            def input_loop():
+                with patch_stdout():
+                    print("=== COMMANDS ===")
+                    print("Type STOP to exit")
+                    print("================")
+                    while not stop_event.is_set():
+                        cmd = session.prompt("> ")
+                        if cmd.strip() == "STOP":
+                            stop_event.set()
+                            print(
+                                "Stopping the streaming sequential toolset..."
+                            )
+                        else:
+                            print(
+                                "Unrecognized input. "
+                                "Please type 'STOP' to end."
+                            )
+                    visualization_data = {}
+                    for (
+                        category_name,
+                        data_pack,
+                    ) in self.visualization_data.items():
+                        for var_name, var_pack in data_pack.items():
+                            if "buffer" in var_pack:
+                                visualization_data[category_name] = {
+                                    var_name: var_pack["buffer"]
+                                }
+                    with open("visualization_data.json", "w") as f:
+                        json.dump(visualization_data, f, indent=2)
+
+            input_thread = threading.Thread(target=input_loop)
+            input_thread.start()
+            fit_thread = threading.Thread(target=stream_loop)
+            fit_thread.start()
+            while not stop_event.is_set():
+                self._update_plot()
+                plt.pause(0.01)
+                time.sleep(1)
+            fit_thread.join()
+            input_thread.join()
+        else:
+            raise ValueError(f"Unknown mode: {mode}")

pdfbl/sequential/version.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# (c) 2025 Simon Billinge.
+# All rights reserved.
+#
+# File coded by: members of the Billinge Group and PDF beamline at NSLS-II.
+#
+# See GitHub contributions for a more detailed list of contributors.
+# https://github.com/pdf-bl/pdfbl.sequential/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("pdfbl.sequential")
+except PackageNotFoundError:
+    __version__ = "unknown"

pdfbl_sequential-0.1.0rc0.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: pdfbl.sequential
+Version: 0.1.0rc0
+Summary: Automated sequential refinements of PDF data
+Author-email: Simon Billinge <sb2896@columbia.edu>
+Maintainer-email: Simon Billinge <sb2896@columbia.edu>
+Project-URL: Homepage, https://github.com/pdf-bl/pdfbl.sequential/
+Project-URL: Issues, https://github.com/pdf-bl/pdfbl.sequential/issues/
+Keywords: diffraction,PDF,X-ray,neutron,nsls-ii
+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.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: <3.15,>=3.12
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+License-File: AUTHORS.rst
+Requires-Dist: numpy
+Requires-Dist: diffpy.cmi
+Dynamic: license-file
+
+|Icon| |title|_
+===============
+
+.. |title| replace:: pdfbl.sequential
+.. _title: https://pdf-bl.github.io/pdfbl.sequential
+
+.. |Icon| image:: https://avatars.githubusercontent.com/pdf-bl
+        :target: https://pdf-bl.github.io/pdfbl.sequential
+        :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/pdf-bl/pdfbl.sequential/actions/workflows/matrix-and-codecov-on-merge-to-main.yml/badge.svg
+        :target: https://github.com/pdf-bl/pdfbl.sequential/actions/workflows/matrix-and-codecov-on-merge-to-main.yml
+
+.. |Codecov| image:: https://codecov.io/gh/pdf-bl/pdfbl.sequential/branch/main/graph/badge.svg
+        :target: https://codecov.io/gh/pdf-bl/pdfbl.sequential
+
+.. |Forge| image:: https://img.shields.io/conda/vn/conda-forge/pdfbl.sequential
+        :target: https://anaconda.org/conda-forge/pdfbl.sequential
+
+.. |PR| image:: https://img.shields.io/badge/PR-Welcome-29ab47ff
+        :target: https://github.com/pdf-bl/pdfbl.sequential/pulls
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/pdfbl.sequential
+        :target: https://pypi.org/project/pdfbl.sequential/
+
+.. |PythonVersion| image:: https://img.shields.io/pypi/pyversions/pdfbl.sequential
+        :target: https://pypi.org/project/pdfbl.sequential/
+
+.. |Tracking| image:: https://img.shields.io/badge/issue_tracking-github-blue
+        :target: https://github.com/pdf-bl/pdfbl.sequential/issues
+
+Automated sequential refinements of PDF data
+
+Scripts for running sequential PDF refinements using diffpy.cmi automatically
+
+For more information about the pdfbl.sequential library, please consult our `online documentation <https://pdf-bl.github.io/pdfbl.sequential>`_.
+
+Citation
+--------
+
+If you use pdfbl.sequential in a scientific publication, we would like you to cite this package as
+
+        pdfbl.sequential Package, https://github.com/pdf-bl/pdfbl.sequential
+
+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 ``pdfbl.sequential_env`` ::
+
+        conda create -n pdfbl.sequential_env pdfbl.sequential
+        conda activate pdfbl.sequential_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>`_.
+To install using ``pip`` into your ``pdfbl.sequential_env`` environment, type ::
+
+        pip install pdfbl.sequential
+
+If you prefer to install from sources, after installing the dependencies, obtain the source archive from
+`GitHub <https://github.com/pdf-bl/pdfbl.sequential/>`_. Once installed, ``cd`` into your ``pdfbl.sequential`` directory
+and run the following ::
+
+        pip install .
+
+This package also provides command-line utilities. To check the software has been installed correctly, type ::
+
+        pdfbl.sequential --version
+
+You can also type the following command to verify the installation. ::
+
+        python -c "import pdfbl.sequential; print(pdfbl.sequential.__version__)"
+
+
+To view the basic usage and available commands, type ::
+
+        pdfbl.sequential -h
+
+Examples
+--------
+
+To run a temperature sequential refinement, ::
+
+        from pdfbl.sequential.sequential_cmi_runner import SequentialCMIRunner
+        runner = SequentialCMIRunner()
+        runner.load_inputs(
+                input_data_dir="path/to/inputs",
+                output_result_dir="path/to/outputs",
+                structure_path="path/to/structure.cif",
+                filename_order_pattern=r"(\d+)K\.gr",  # regex pattern to extract the temperature from the filename
+        )
+        runner.run(mode="batch")  # or mode="stream" for running sequentially as data becomes available
+
+Getting Started
+---------------
+
+You may consult our `online documentation <https://pdf-bl.github.io/pdfbl.sequential>`_ 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/pdf-bl/pdfbl.sequential/issues>`_ and/or `submit a fix as a PR <https://github.com/pdf-bl/pdfbl.sequential/pulls>`_.
+
+Feel free to fork the project and contribute. To install pdfbl.sequential
+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/pdf-bl/pdfbl.sequential/blob/main/CODE-OF-CONDUCT.rst>`_.
+
+Contact
+-------
+
+For more information on pdfbl.sequential please visit the project `web-page <https://pdf-bl.github.io/>`_ or email Simon Billinge at sb2896@columbia.edu.
+
+Acknowledgements
+----------------
+
+``pdfbl.sequential`` is built and maintained with `scikit-package <https://scikit-package.github.io/scikit-package/>`_.

pdfbl_sequential-0.1.0rc0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pdfbl/__init__.py,sha256=OQGLzzFXqkhKIP-uxtsAEhZw30U9Eq14fnMwnCUjA3M,530
+pdfbl/sequential/__init__.py,sha256=NV4nr2fA5UsHHjotDZ3pOWZ39ItmQzk-mO6RdBs4gqQ,702
+pdfbl/sequential/pdfadapter.py,sha256=SqKvBKNJuJC5fHw2ATBfNEn0paSpRqI1wii2IWidNhc,16716
+pdfbl/sequential/pdfbl_sequential_app.py,sha256=6KDYfBAjbRky_9ooigGJTbGOfgDRmBN5pyoexaTxATU,572
+pdfbl/sequential/sequential_cmi_runner.py,sha256=SixfeEvUwuZBA0oZ0P27bXZ66adzPOIi-dU8X9SSHGc,23405
+pdfbl/sequential/version.py,sha256=2rmXHJH9IzYhXpzq9dCsYzIHOT1oC4U10Wd00mmj-wg,894
+pdfbl_sequential-0.1.0rc0.dist-info/licenses/AUTHORS.rst,sha256=2jH0ypi3P2ZuJgv9KZEblYiQTPHyu9cT_jVkYj9ip4I,200
+pdfbl_sequential-0.1.0rc0.dist-info/licenses/LICENSE.rst,sha256=r0DOaoezNuZvD3yiowak4UhhTqTQDxeYhAzt6gOG3jM,1523
+pdfbl_sequential-0.1.0rc0.dist-info/METADATA,sha256=sbJuY4Ir7LVTVhWhet_QM4HX8r9oymQJe_AmW9mtYKY,7298
+pdfbl_sequential-0.1.0rc0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+pdfbl_sequential-0.1.0rc0.dist-info/entry_points.txt,sha256=EwyheFjtkSEpCt-ndET1mpPzMjwp7p-KcYruJYQWB_0,80
+pdfbl_sequential-0.1.0rc0.dist-info/top_level.txt,sha256=rhhQf1P9sizprwJb29Jj8FH2WUgYMxp4viI8aIGRBh0,6
+pdfbl_sequential-0.1.0rc0.dist-info/RECORD,,

pdfbl_sequential-0.1.0rc0.dist-info/WHEEL

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

pdfbl_sequential-0.1.0rc0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pdfbl-sequential = pdfbl.sequential.pdfbl_sequential_app:main

pdfbl_sequential-0.1.0rc0.dist-info/licenses/AUTHORS.rst

@@ -0,0 +1,10 @@
+Authors
+=======
+
+members of the Billinge Group and PDF beamline at NSLS-II
+
+Contributors
+------------
+
+For a list of contributors, visit
+https://github.com/pdf-bl/pdfbl.sequential/graphs/contributors

pdfbl_sequential-0.1.0rc0.dist-info/licenses/LICENSE.rst

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Simon Billinge.
+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.

pdfbl_sequential-0.1.0rc0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pdfbl