pty-chi

.gitignore

@@ -150,3 +150,4 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+.aider*

Dockerfile

@@ -0,0 +1,20 @@
+#FROM python:3.12-slim-bullseye
+FROM pytorch/pytorch:2.7.0-cuda12.6-cudnn9-runtime
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the sources
+COPY . /src
+
+# Install & upgrade software
+RUN apt-get update && \
+    apt-get install -y git libqt5gui5 && \
+    rm -rf /var/lib/apt/lists/* && \
+    python3 -m pip install --root-user-action=ignore --no-cache-dir --upgrade pip && \
+    python3 -m pip install --root-user-action=ignore --no-cache-dir /src[globus,gui,ptychi] && \
+    rm -rf /src
+
+# Run ptychodus when the container launches
+#ENV QT_DEBUG_PLUGINS=1
+CMD ["python3", "-m", "ptychodus"]

README.rst

@@ -67,11 +67,11 @@ Developer Installation
    $ conda activate ptychodus
    $ pip install -e ./ptychodus
 
-* To install the `tike`_ backend:
+* To install the `pty-chi`_ backend:
 
 .. code-block:: shell
 
-   $ conda install -n ptychodus -c conda-forge tike
+   $ pip install ptychi
 
 * To install the `PtychoNN`_ backend:
 
@@ -93,6 +93,6 @@ Reporting Bugs
 Open a bug at https://github.com/AdvancedPhotonSource/ptychodus/issues.
 
 .. _`ptychodus`: https://github.com/AdvancedPhotonSource/ptychodus
-.. _`tike`: https://github.com/tomography/tike
+.. _`pty-chi`: https://github.com/AdvancedPhotonSource/pty-chi
 .. _`PtychoNN`: https://github.com/mcherukara/PtychoNN
 .. _`PvaPy`: https://github.com/epics-base/pvaPy

doc/api.rst

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+
+from pathlib import Path
+from ptychodus.model import ModelCore
+
+def main() -> int:
+    settings_file = Path("path/to/settings.ini")
+
+    with ModelCore(settings_file) as model:
+        input_product_api = model.workflow_api.create_product("new_product_name")
+        output_product_api = input_product_api.reconstruct_local()
+        output_product_api.save_product("/path/to/file.h5", file_type="HDF5")

doc/dist.rst

@@ -0,0 +1,36 @@
+Distribution Instructions
+=========================
+
+Python Package Index (PyPI)
+---------------------------
+
+From the ptychodus directory, create wheel in ./dist/
+
+.. code-block:: shell
+
+   $ python -m build .
+
+Upload to PyPI
+
+.. code-block:: shell
+
+   $ twine upload dist/*
+
+Docker
+------
+
+Build Docker image
+
+.. code-block:: shell
+
+   $ podman build -t ptychodus:latest .
+
+
+Run container
+
+.. code-block:: shell
+
+   $ xhost +local:podman
+   $ podman run -it --rm  -e "DISPLAY=$DISPLAY" -v "$HOME/.Xauthority:/root/.Xauthority:ro" --network host \
+         --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 python-ptychodus
+   $ xhost -local:podman

polaris.yaml

@@ -0,0 +1,40 @@
+engine:
+    type: HighThroughputEngine
+    max_workers_per_node: 1
+
+    # Un-comment to give each worker exclusive access to a single GPU
+    # available_accelerators: 4
+
+    strategy:
+        type: SimpleStrategy
+        max_idletime: 3600
+
+    address:
+        type: address_by_interface
+        ifname: bond0
+
+    provider:
+        type: PBSProProvider
+
+        launcher:
+            type: MpiExecLauncher
+            # Ensures 1 manger per node, work on all 64 cores
+            bind_cmd: --cpu-bind
+            overrides: --depth=64 --ppn 1
+
+        account: APSDataAnalysis
+        queue: preemptable
+        cpus_per_node: 32
+        select_options: ngpus=4
+
+        # e.g., "#PBS -l filesystems=home:grand:eagle\n#PBS -k doe"
+        scheduler_options: "#PBS -l filesystems=home:grand:eagle"
+
+        # Node setup: activate necessary conda environment and such
+        worker_init: "source ~/miniconda3/etc/profile.d/conda.sh; conda activate ptychodus",
+
+        walltime: 01:00:00
+        nodes_per_block: 1
+        init_blocks: 0
+        min_blocks: 0
+        max_blocks: 2

pyproject.toml

@@ -1,20 +1,23 @@
 [build-system]
-requires = ["setuptools>=64", "setuptools_scm>=8"]
+requires = ["setuptools>=64", "setuptools_scm[toml]>=8"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "ptychodus"
 description = "Ptychodus is a ptychography data analysis application."
 readme = "README.rst"
 requires-python = ">=3.10"
-license = {file = "LICENSE.txt"}
+license = {file = "LICENSE"}
 dependencies = [
-    "h5py",
+    "h5py>=3",
+    "hdf5plugin",
     "matplotlib",
     "numpy",
     "psutil",
+    "requests",
     "scikit-image",
     "scipy",
+    "tables",
     "tifffile",
     "watchdog",
 ]
@@ -24,10 +27,17 @@ dynamic = ["version"]
 ptychodus = "ptychodus.__main__:main"
 
 [project.optional-dependencies]
-globus = ["gladier", "gladier-tools"]
+globus = ["gladier", "gladier-tools>=0.5.4"]
 gui = ["PyQt5"]
 ptychonn = ["ptychonn==0.3.*,>=0.3.7"]
 tike = ["tike==0.25.*,>=0.25.3"]
+ptychi = ["ptychi==1.*"]
+
+[tool.setuptools.package-data]
+"ptychodus" = ["py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
 
 [tool.setuptools_scm]
 
@@ -44,6 +54,8 @@ module = [
     "hdf5plugin",
     "lightning.*",
     "parsl.*",
+    "ptychi.*",
+    "ptycho.*",
     "ptychonn.*",
     "pvaccess",
     "pvapy.*",
@@ -61,9 +73,11 @@ target-version = "py310"
 [tool.ruff.format]
 quote-style = "single"
 
-[tool.setuptools.package-data]
-"ptychodus" = ["py.typed"]
-
-[tool.setuptools.packages.find]
-where = ["src"]
+[tool.ruff.lint]
+select = [
+    "N",
+    "NPY",
+]
 
+[tool.pyright]
+pythonVersion = "3.10"

requirements-dev.txt

@@ -1,11 +1,13 @@
-h5py
+build
+h5py>=3
 hdf5plugin
 matplotlib
 mypy
 numpy
 psutil
 pyqt
 pyqt-stubs
+pytables
 pytest
 python>=3.10
 ruff
@@ -16,4 +18,3 @@ setuptools_scm>=8
 tifffile
 toml
 watchdog
-wheel

src/ptychodus/__init__.py

@@ -6,7 +6,7 @@
     pass
 
 try:
-    from .ptychodusAdImageProcessor import PtychodusAdImageProcessor
+    from .ptychodus_stream_processor import PtychodusAdImageProcessor
 except ModuleNotFoundError:
     pass
 

src/ptychodus/__main__.py

@@ -2,17 +2,20 @@
 
 from pathlib import Path
 import argparse
+import logging
 import sys
 
 from ptychodus.model import ModelCore
 import ptychodus
 
+logger = logging.getLogger(__name__)
 
-def versionString() -> str:
+
+def version_string() -> str:
     return f'{ptychodus.__name__.title()} ({ptychodus.__version__})'
 
 
-def verifyAllArgumentsParsed(parser: argparse.ArgumentParser, argv: list[str]) -> None:
+def verify_all_arguments_parsed(parser: argparse.ArgumentParser, argv: list[str]) -> None:
     if argv:
         parser.error('unrecognized arguments: %s' % ' '.join(argv))
 
@@ -79,61 +82,62 @@ def main() -> int:
         '-v',
         '--version',
         action='version',
-        version=versionString(),
+        version=version_string(),
     )
 
-    parsedArgs, unparsedArgs = parser.parse_known_args()
-    settingsFile = Path(parsedArgs.settings.name) if parsedArgs.settings else None
+    parsed_args, unparsed_args = parser.parse_known_args()
+    settings_file = Path(parsed_args.settings.name) if parsed_args.settings else None
 
-    with ModelCore(settingsFile, isDeveloperModeEnabled=parsedArgs.dev) as model:
-        if parsedArgs.patterns is not None:
-            patternsFilePath = Path(parsedArgs.patterns.name)
-            model.workflowAPI.importProcessedPatterns(patternsFilePath)
+    with ModelCore(settings_file, is_developer_mode_enabled=parsed_args.dev) as model:
+        if parsed_args.patterns is not None:
+            patterns_file_path = Path(parsed_args.patterns.name)
+            model.workflow_api.import_assembled_patterns(patterns_file_path)
 
-        if parsedArgs.batch is not None:
-            verifyAllArgumentsParsed(parser, unparsedArgs)
+        if parsed_args.batch is not None:
+            verify_all_arguments_parsed(parser, unparsed_args)
 
-            if parsedArgs.input is None or parsedArgs.output is None:
+            if parsed_args.input is None or parsed_args.output is None:
                 parser.error('Batch mode requires input and output arguments!')
                 return -1
 
-            action = parsedArgs.batch
-            inputFilePath = Path(parsedArgs.input.name)
-            outputFilePath = Path(parsedArgs.output.name)
-            fluorescenceInputFilePath: Path | None = None
-            fluorescenceOutputFilePath: Path | None = None
+            action = parsed_args.batch
+            input_file_path = Path(parsed_args.input.name)
+            output_file_path = Path(parsed_args.output.name)
+            fluorescence_input_file_path: Path | None = None
+            fluorescence_output_file_path: Path | None = None
 
-            if parsedArgs.fluorescence_input is not None:
-                fluorescenceInputFilePath = Path(parsedArgs.fluorescence_input.name)
+            if parsed_args.fluorescence_input is not None:
+                fluorescence_input_file_path = Path(parsed_args.fluorescence_input.name)
 
-            if parsedArgs.fluorescence_output is not None:
-                fluorescenceOutputFilePath = Path(parsedArgs.fluorescence_output.name)
+            if parsed_args.fluorescence_output is not None:
+                fluorescence_output_file_path = Path(parsed_args.fluorescence_output.name)
 
-            return model.batchModeExecute(
+            return model.batch_mode_execute(
                 action,
-                inputFilePath,
-                outputFilePath,
-                fluorescenceInputFilePath=fluorescenceInputFilePath,
-                fluorescenceOutputFilePath=fluorescenceOutputFilePath,
+                input_file_path,
+                output_file_path,
+                fluorescence_input_file_path=fluorescence_input_file_path,
+                fluorescence_output_file_path=fluorescence_output_file_path,
             )
 
         try:
             from PyQt5.QtWidgets import QApplication
         except ModuleNotFoundError:
+            logger.warning('PyQt5 not found.')
             return 0
 
         # QApplication expects the first argument to be the program name
-        app = QApplication(sys.argv[:1] + unparsedArgs)
-        verifyAllArgumentsParsed(parser, app.arguments()[1:])
+        app = QApplication(sys.argv[:1] + unparsed_args)
+        verify_all_arguments_parsed(parser, app.arguments()[1:])
 
         from ptychodus.view import ViewCore
 
-        view = ViewCore.createInstance(parsedArgs.dev)
+        view = ViewCore()
 
         from ptychodus.controller import ControllerCore
 
-        controller = ControllerCore(model, view)
-        controller.showMainWindow(versionString())
+        controller = ControllerCore(model, view, is_developer_mode_enabled=parsed_args.dev)
+        controller.show_main_window(version_string())
 
         return app.exec()