AutoPumping 0.1.0__tar.gz

autopumping-0.1.0/AutoPumping.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: AutoPumping
+Version: 0.1.0
+Summary: A tool to automate pumping of vacuum systems
+Author-email: Cameron Devine <cameron.devine@alleninstitute.org>
+License-Expression: BSD-3-Clause
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Requires-Dist: networkx
+Requires-Dist: nicegui
+Requires-Dist: pyvis
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: bump-my-version; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: jsonschema2md; extra == "docs"
+Dynamic: license-file
+
+# Auto Pumping
+
+This Python package is meant to provide a generic system for automating high-vacuum pumping systems.
+
+## Config
+
+To support arbitrary pumping systems, a configuration file format was created where all valid valve, pump, and stage[^1] transition can be enumerated. Using this configuration file, the safety of any given valve transition can be evaluated, and the system automated. This configuration file format is documented [here](docs/config.md).
+
+## Solver
+
+To support automated pumping of the vacuum system a solver was implemented using the information in the configuration file. This information is used to build a directed graph of all valid pumping system states where discretized pressure is included. After this directed graph is built, Dijkstra's algorithm is used for find the optimal method for pumping or venting the system, or reaching any other state. The built graph can be viewed by running: `python -m auto_pumping -c config/config.yaml network`.
+
+## UI
+
+A NiceGUI based UI is also included. It is automatically built based on the configuration file. A dummy pumping system is available as an example and can be run with: `python -m auto_pumping -c config/config.yaml run`.
+
+## Getting Started
+
+To implement automated pumping for your system subclass the `AutoPumping` class and define the following methods:
+
+* `get_valve_state(valve)`
+* `actuate_valve(valve, state)`
+* `get_pump_state(pump)`
+* `set_pump(pump, state)`
+* `get_pump_current(pump)`
+* `get_pump_voltage(pump)`
+* `get_pump_flow(pump)`
+* `get_pump_speed(pump)`
+* `get_gauge_pressure(gauge)`
+* `get_stage_position()`
+* `move_stage(position)`
+
+If you would like to add more fields to the configuration file for your specific hardware, subclass the `Config` class and set the `AutoPumping.CONFIG_CLASS` variable to your new config class.
+
+To allow the system to be easily started, you can use the provided `main()` function. Simply run `main(<your_auto_pumping_subclass>)`, for example:
+
+```python
+from auto_pumping.__main__ import main
+
+
+if __name__ == "__main__":
+    main(<your_auto_pumping_subclass>)
+```
+
+Finally, a diagram can be added to the UI by setting the `AutoPumping.DIAGRAM_PATH` variable to the path to a diagram image of your system.
+
+[^1]: this library was originally written for a custom microscope system.

autopumping-0.1.0/AutoPumping.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+AutoPumping.egg-info/PKG-INFO
+AutoPumping.egg-info/SOURCES.txt
+AutoPumping.egg-info/dependency_links.txt
+AutoPumping.egg-info/requires.txt
+AutoPumping.egg-info/top_level.txt
+auto_pumping/__init__.py
+auto_pumping/__main__.py
+auto_pumping/config.py
+auto_pumping/dummy.py
+auto_pumping/executor.py
+auto_pumping/graph.py
+auto_pumping/safety.py
+auto_pumping/ui.py
+test/test_config.py
+test/test_executor.py
+test/test_graph.py
+test/test_ui.py

autopumping-0.1.0/AutoPumping.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

autopumping-0.1.0/AutoPumping.egg-info/requires.txt

@@ -0,0 +1,12 @@
+pydantic
+pyyaml
+networkx
+nicegui
+pyvis
+
+[dev]
+pytest
+bump-my-version
+
+[docs]
+jsonschema2md

autopumping-0.1.0/AutoPumping.egg-info/top_level.txt

@@ -0,0 +1 @@
+auto_pumping

autopumping-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Allen Institute
+
+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.

autopumping-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: AutoPumping
+Version: 0.1.0
+Summary: A tool to automate pumping of vacuum systems
+Author-email: Cameron Devine <cameron.devine@alleninstitute.org>
+License-Expression: BSD-3-Clause
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Requires-Dist: networkx
+Requires-Dist: nicegui
+Requires-Dist: pyvis
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: bump-my-version; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: jsonschema2md; extra == "docs"
+Dynamic: license-file
+
+# Auto Pumping
+
+This Python package is meant to provide a generic system for automating high-vacuum pumping systems.
+
+## Config
+
+To support arbitrary pumping systems, a configuration file format was created where all valid valve, pump, and stage[^1] transition can be enumerated. Using this configuration file, the safety of any given valve transition can be evaluated, and the system automated. This configuration file format is documented [here](docs/config.md).
+
+## Solver
+
+To support automated pumping of the vacuum system a solver was implemented using the information in the configuration file. This information is used to build a directed graph of all valid pumping system states where discretized pressure is included. After this directed graph is built, Dijkstra's algorithm is used for find the optimal method for pumping or venting the system, or reaching any other state. The built graph can be viewed by running: `python -m auto_pumping -c config/config.yaml network`.
+
+## UI
+
+A NiceGUI based UI is also included. It is automatically built based on the configuration file. A dummy pumping system is available as an example and can be run with: `python -m auto_pumping -c config/config.yaml run`.
+
+## Getting Started
+
+To implement automated pumping for your system subclass the `AutoPumping` class and define the following methods:
+
+* `get_valve_state(valve)`
+* `actuate_valve(valve, state)`
+* `get_pump_state(pump)`
+* `set_pump(pump, state)`
+* `get_pump_current(pump)`
+* `get_pump_voltage(pump)`
+* `get_pump_flow(pump)`
+* `get_pump_speed(pump)`
+* `get_gauge_pressure(gauge)`
+* `get_stage_position()`
+* `move_stage(position)`
+
+If you would like to add more fields to the configuration file for your specific hardware, subclass the `Config` class and set the `AutoPumping.CONFIG_CLASS` variable to your new config class.
+
+To allow the system to be easily started, you can use the provided `main()` function. Simply run `main(<your_auto_pumping_subclass>)`, for example:
+
+```python
+from auto_pumping.__main__ import main
+
+
+if __name__ == "__main__":
+    main(<your_auto_pumping_subclass>)
+```
+
+Finally, a diagram can be added to the UI by setting the `AutoPumping.DIAGRAM_PATH` variable to the path to a diagram image of your system.
+
+[^1]: this library was originally written for a custom microscope system.

autopumping-0.1.0/README.md

@@ -0,0 +1,47 @@
+# Auto Pumping
+
+This Python package is meant to provide a generic system for automating high-vacuum pumping systems.
+
+## Config
+
+To support arbitrary pumping systems, a configuration file format was created where all valid valve, pump, and stage[^1] transition can be enumerated. Using this configuration file, the safety of any given valve transition can be evaluated, and the system automated. This configuration file format is documented [here](docs/config.md).
+
+## Solver
+
+To support automated pumping of the vacuum system a solver was implemented using the information in the configuration file. This information is used to build a directed graph of all valid pumping system states where discretized pressure is included. After this directed graph is built, Dijkstra's algorithm is used for find the optimal method for pumping or venting the system, or reaching any other state. The built graph can be viewed by running: `python -m auto_pumping -c config/config.yaml network`.
+
+## UI
+
+A NiceGUI based UI is also included. It is automatically built based on the configuration file. A dummy pumping system is available as an example and can be run with: `python -m auto_pumping -c config/config.yaml run`.
+
+## Getting Started
+
+To implement automated pumping for your system subclass the `AutoPumping` class and define the following methods:
+
+* `get_valve_state(valve)`
+* `actuate_valve(valve, state)`
+* `get_pump_state(pump)`
+* `set_pump(pump, state)`
+* `get_pump_current(pump)`
+* `get_pump_voltage(pump)`
+* `get_pump_flow(pump)`
+* `get_pump_speed(pump)`
+* `get_gauge_pressure(gauge)`
+* `get_stage_position()`
+* `move_stage(position)`
+
+If you would like to add more fields to the configuration file for your specific hardware, subclass the `Config` class and set the `AutoPumping.CONFIG_CLASS` variable to your new config class.
+
+To allow the system to be easily started, you can use the provided `main()` function. Simply run `main(<your_auto_pumping_subclass>)`, for example:
+
+```python
+from auto_pumping.__main__ import main
+
+
+if __name__ == "__main__":
+    main(<your_auto_pumping_subclass>)
+```
+
+Finally, a diagram can be added to the UI by setting the `AutoPumping.DIAGRAM_PATH` variable to the path to a diagram image of your system.
+
+[^1]: this library was originally written for a custom microscope system.

autopumping-0.1.0/auto_pumping/__init__.py

@@ -0,0 +1,116 @@
+from abc import ABC, abstractmethod
+from .safety import SafetyMachine
+from .graph import PumpingGraph
+from .config import Config
+from .executor import PlanExecutor
+from .ui import UI
+
+
+class AutoPumping(ABC):
+    CONFIG_CLASS = Config
+    DIAGRAM_PATH = None
+
+    def __init__(self, config, ui=True):
+        self._config = config
+        self._safety_machine = SafetyMachine(config, self)
+        self._pumping_graph = PumpingGraph(config)
+        self._plan_executor = PlanExecutor(self)
+        self._ui = None
+        if ui:
+            self._ui = UI(config, self, diagram=self.DIAGRAM_PATH)
+
+    def run(self):
+        if self._ui is None:
+            raise RuntimeError("UI is not enabled for this instance.")
+        self._ui.run()
+
+    def auto(self, **goal_state_data):
+        self._plan_executor.execute_plan(
+            list(self._pumping_graph.make_plan(self._get_state(), **goal_state_data))
+        )
+
+    def cancel(self):
+        self._plan_executor.cancel()
+
+    @property
+    def plan(self):
+        return self._plan_executor.plan
+
+    def _get_state(self):
+        return {
+            "valves": {
+                valve: self.get_valve_state(valve) for valve in self._config.valves
+            },
+            "pumps": {pump: self.get_pump_state(pump) for pump in self._config.pumps},
+            "stage": self.get_stage_position(),
+            "gauges": {gauge: self._pumping_graph._get_gauge_range(gauge, self.get_gauge_pressure(gauge)) for gauge in self._config.gauges},
+        }
+
+    @classmethod
+    def from_config_file(cls, config_file):
+        config = cls.CONFIG_CLASS.load_file(config_file)
+        return cls(config)
+
+    @abstractmethod
+    def get_valve_state(self, valve):
+        pass
+
+    def _actuate_valve(self, valve, state):
+        if self._safety_machine.can_actuate_valve(valve, state):
+            self.actuate_valve(valve, state)
+            self._safety_machine.record_valve_change(valve)
+            return True
+        return False
+
+    @abstractmethod
+    def actuate_valve(self, valve, state):
+        pass
+
+    @abstractmethod
+    def get_pump_state(self, pump):
+        pass
+
+    def _set_pump(self, pump, state):
+        if self._safety_machine.can_set_pump(pump, state):
+            self.set_pump(pump, state)
+            self._safety_machine.record_pump_change(pump)
+            return True
+        return False
+
+    @abstractmethod
+    def set_pump(self, pump, state):
+        pass
+
+    @abstractmethod
+    def get_pump_current(self, pump):
+        pass
+
+    @abstractmethod
+    def get_pump_voltage(self, pump):
+        pass
+
+    @abstractmethod
+    def get_pump_flow(self, pump):
+        pass
+
+    @abstractmethod
+    def get_pump_speed(self, pump):
+        pass
+
+    @abstractmethod
+    def get_gauge_pressure(self, gauge):
+        pass
+
+    @abstractmethod
+    def get_stage_position(self):
+        pass
+
+    def _move_stage(self, position):
+        if self._safety_machine.can_move_stage(position):
+            self.move_stage(position)
+            return True
+        return False
+
+    @abstractmethod
+    def move_stage(self, position):
+        pass

autopumping-0.1.0/auto_pumping/__main__.py

@@ -0,0 +1,35 @@
+import argparse
+from .dummy import DummyPumping
+
+
+def build_parser(system_class):
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        required=True,
+        help="Path to the configuration file.",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Sub-command help")
+    network_parser = subparsers.add_parser("network", help="Draw the network graph.")
+    network_parser.add_argument(
+        "--output", "-o", type=str, help="Output file for the network graph."
+    )
+    run_parser = subparsers.add_parser("run", help="Run the pumping system.")
+
+    return parser
+
+
+def main(system_class):
+    parser = build_parser(system_class)
+    args = parser.parse_args()
+    system = system_class.from_config_file(args.config)
+    if args.command == "network":
+        system._pumping_graph.draw(args.output)
+    elif args.command == "run":
+        system.run()
+
+
+if __name__ == "__main__":
+    main(DummyPumping)