psiapp 0.0.1__tar.gz

psiapp-0.0.1/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,37 @@
+name: Publish Python distribution to PyPI
+on: 
+  push:
+    tags:
+      - '[0-9].[0-9]+.[0-9]+'
+
+jobs:
+  pypi-publish:
+    name: Build and publish Python distribution to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/psiapp
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@main
+      - name: Setup Python 3.10
+        uses: actions/setup-python@v3
+        with:
+          python-version: "3.10"
+      - name: Install pypa/build
+        run: >-
+          python -m 
+          pip install 
+          build 
+          --user
+      - name: Build a binary wheel and a source tarball
+        run: >-
+          python -m 
+          build 
+          --sdist
+          --wheel
+          --outdir dist/
+      - name: Publish distribution to PyPI
+        if: startsWith(github.ref, 'refs/tags')
+        uses: pypa/gh-action-pypi-publish@release/v1

psiapp-0.0.1/.gitignore

@@ -0,0 +1,81 @@
+# Automatically generated by setuptools_scm
+psiapp/version.py
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/build/
+docs/source/gallery/
+docs/examples/
+docs/source/gen_modules/
+
+# PyBuilder
+target/
+
+
+# Vim global
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~
+
+
+__enamlcache__/
+sandbox/
+.ropeproject/
+.ipynb_checkpoints/

psiapp-0.0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 psiapp development team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

psiapp-0.0.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: psiapp
+Version: 0.0.1
+Summary: Tools for supporting experiment launchers using psiexperiment
+Author-email: Brad Buran <buran@ohsu.edu>
+Maintainer-email: Brad Buran <buran@ohsu.edu>
+Requires-Python: >=3.7
+License-File: LICENSE.txt
+Requires-Dist: enaml[qt6-pyside]>=0.13.0
+Dynamic: license-file

psiapp-0.0.1/psiapp/api.py

@@ -0,0 +1,6 @@
+from .experiment import load_experiments, Experiment, FrozenExperiment
+from .process_manager import ProcessManager
+
+import enaml
+with enaml.imports():
+    from .widgets import AddRemoveCombo, ExperimentSequence

psiapp-0.0.1/psiapp/experiment.enaml

@@ -0,0 +1,130 @@
+import logging
+log = logging.getLogger()
+
+from pathlib import Path
+
+from atom.api import Atom, Dict, Enum, List, Str, Value
+
+from psi.experiment.api import (paradigm_manager, ParadigmNotFound)
+
+
+class Experiment(Atom):
+
+    paradigm = Value()
+
+    preference = Str()
+
+    #: Plugins selected for load
+    plugins = List(Str())
+
+    #: Supplemental note to append based on the button clicked.
+    mode_notes = Dict()
+
+    def iter_selectable_plugins(self):
+        for plugin in self.paradigm.plugins:
+            if plugin.required:
+                continue
+            if plugin.info.get('hide', False):
+                continue
+            yield plugin
+
+    def _default_mode_notes(self):
+        return {}
+
+    def __init__(self, paradigm, plugins=None, preference=None, **kwargs):
+        if isinstance(paradigm, str):
+            paradigm = paradigm_manager.get_paradigm(paradigm)
+        self.paradigm = paradigm
+
+        # Make sure the plugins saved to the config file are valid plugins (we
+        # sometimes remove or rename plugins). If the plugin is no longer
+        # valid, remove it. If the plugin is required, remove it as a plugin
+        # that the user can select from in the GUI (since it automatically gets
+        # loaded).
+        plugins = set() if plugins is None else set(plugins)
+        valid_plugins = set(p.id for p in self.iter_selectable_plugins())
+        plugins = list(plugins & valid_plugins)
+
+        # We only save preference name, not the full path to the preference. We
+        # need to restore the full path to the preference by scanning through
+        # the list of avaialble preferences. This allows for portability across
+        # systems.
+        if preference is None:
+            preference = ''
+        else:
+            preference = Path(preference)
+            for valid_preference in paradigm.list_preferences():
+                if valid_preference.stem == preference.stem:
+                    preference = str(valid_preference)
+                    break
+            else:
+                log.warning('Invalid preference requested for %s: %s', paradigm,
+                            preference)
+                preference = ''
+
+        super().__init__(paradigm=paradigm, plugins=plugins,
+                         preference=preference, **kwargs)
+
+    def __getstate__(self):
+        state = super().__getstate__()
+        # Convert some keys to things that can be JSON-serialized. Don't save
+        # the full path to the preference because we want this to be portable
+        # across environments and installs.
+        state['preference'] = Path(state['preference']).name
+        state['paradigm'] = state['paradigm'].name
+        return state
+
+    def freeze(self, mode):
+        '''
+        Return experiment in which mode and ear are fixed. Used in running
+        sequences.
+
+        Parameters
+        ----------
+        mode : str
+            One of the modes the paradigm can be run under (e.g., 'run',
+            'ipsi', 'contra').
+
+        This is used for sequences where we may need to specify run mode (i.e.,
+        ipsi vs. contra).
+        '''
+        if mode is None:
+            mode = self.modes[0]
+        return FrozenExperiment(
+            paradigm=self.paradigm,
+            preference=self.preference,
+            plugins=self.plugins,
+            mode_notes=self.mode_notes,
+            mode=mode,
+        )
+
+
+class FrozenExperiment(Experiment):
+    '''
+    Subclass of Experiment in which we have frozen the ear and mode (used for
+    sequences).
+    '''
+    mode = Str()
+
+    #: If either, then ear will be drawn from what is selected.
+    ear = Enum('selected', 'left', 'right')
+
+
+def load_experiments(seq, experiment_class=Experiment):
+    '''
+    Helper function for loading experiments from JSON file
+    '''
+    experiments = []
+    for s in seq:
+        # Remove obsolete label argument from saved paradigms and
+        # legacy modes since we changed how this is handled (it was
+        # always a hack to put in the file).
+        s.pop('label', None)
+        s.pop('modes', None)
+        mode_notes = s.get('mode_notes', {})
+        s['mode_notes'] = {k.lower(): v for k, v in mode_notes.items()}
+        try:
+            experiments.append(experiment_class(**s))
+        except ParadigmNotFound:
+            pass
+    return experiments

psiapp-0.0.1/psiapp/process_manager.py

@@ -0,0 +1,146 @@
+import logging
+log = logging.getLogger(__name__)
+
+import os
+import subprocess
+import threading
+
+from atom.api import Atom, Bool, Float, List, Typed, Value
+from enaml.application import timed_call
+
+from psi.paradigms.core.websocket_mixins import WebsocketServerPlugin
+
+
+def synchronized(fn):
+    '''
+    Decorator that ensures lock is obtained before calling method
+    '''
+    def wrapped(self, *args, **kw):
+        with self.lock:
+            return fn(self, *args, **kw)
+    return wrapped
+
+
+class ProcessManager(Atom):
+    '''
+    Manager for running one or more psiexperiments in sequence
+    '''
+
+    #: List of commands the order they should be executed.
+    commands = List()
+
+    #: List of subprocesses that are currently open.
+    subprocesses = List()
+
+    #: Current active subprocess (we retain references to all subprocesses that
+    #: are currently open since we do not auto-close the GUI).
+    current_subprocess = Value()
+
+    #: Should experiments be auto-started?
+    autostart = Bool(False)
+
+    #: Used for communicating with experiments invoked by `psi`.
+    ws_server = Typed(WebsocketServerPlugin)
+
+    #: Used to track runtime of individual experiments.
+    exp_start_time = Float()
+
+    #: Duration of last experiment from experiment_start to experiment_end event.
+    duration = Float()
+
+    lock = Value()
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        # Set up a websocket server. Whenever clients (i.e., programs invoked
+        # by `psi`) connect they will be instructed to relay only a handful of
+        # events to keep load on the websocket low.
+        self.ws_server = WebsocketServerPlugin(
+            recv_cb=self.recv_cb,
+            connect_cb=self.connect_cb,
+        )
+        self.ws_server.start_thread()
+        log.error(self.ws_server.connected_uri)
+        self.lock = threading.Lock()
+        timed_call(1000, self.check_status)
+
+    def connect_cb(self):
+        events = ['plugins_started', 'experiment_start', 'experiment_end',
+                  'window_closed']
+        self.ws_server.send_message({
+            'command': 'websocket.set_event_filter',
+            'parameters': {'event_filter': '|'.join(events)},
+        })
+
+    def open_next_subprocess(self):
+        try:
+            cmd, env = self.commands.pop(0)
+        except IndexError:
+            log.info('No more commands queued')
+            return
+        process = subprocess.Popen(cmd, env=dict(os.environ, **env))
+        self.current_subprocess = {
+            'cmd': cmd,
+            'env': env,
+            'process': process,
+            'running': False,
+            'client_id': process.pid,
+            'state': None,
+        }
+        self.subprocesses.append(self.current_subprocess)
+
+    @synchronized
+    def recv_cb(self, message):
+        # Find which process the message is from.
+        for process in self.subprocesses:
+            if process['client_id'] == message['client_id']:
+                break
+        else:
+            raise ValueError(f'No process with client ID {process["client_id"]}')
+
+        if message['event'] == 'plugins_started':
+            process['state'] = 'connected'
+            # Start the subprocess if it is the first one in the list to run.
+            if self.autostart:
+                mesg = {'command': 'psi.show_window'}
+                self.ws_server.send_message(mesg, process['client_id'])
+                mesg = {'command': 'psi.controller.start'}
+                self.ws_server.send_message(mesg, process['client_id'])
+        elif message['event'] == 'experiment_start':
+            process['state'] = 'running'
+            self.exp_start_time = time.time()
+        elif message['event'] == 'experiment_end':
+            if process == self.current_subprocess:
+                self.current_subprocess = None
+            process['state'] = 'complete'
+            self.duration = round(time.time() - self.exp_start_time)
+            if message['info'].get('stop_reason') != '':
+                self.autostart = False
+                self.commands = []
+            # Now, start the next one if one exists.
+            if self.autostart:
+                self.open_next_subprocess()
+        elif message['event'] == 'window_closed':
+            # Window closed. Remove from the list of subprocesses.
+            if process == self.current_subprocess:
+                self.current_subprocess = None
+            self.subprocesses.remove(process)
+
+    @synchronized
+    def add_command(self, cmd, env):
+        log.info('Queueing command: %s', ' '.join(cmd))
+        self.commands.append((cmd, env))
+
+    @synchronized
+    def pause_sequence(self):
+        # TODO: What to do if we need to re-sequence an experiment?
+        self.autostart = False
+
+    @synchronized
+    def check_status(self):
+        self.subprocesses = [p for p in self.subprocesses if p['process'].poll() is None]
+        # This means the current subprocess has been closed.
+        if self.current_subprocess is not None:
+            if self.current_subprocess['process'].poll() is not None:
+                self.current_subprocess = None
+        timed_call(1000, self.check_status)

psiapp-0.0.1/psiapp/version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = 'g27f4fdb90'

psiapp-0.0.1/psiapp/widgets.enaml

@@ -0,0 +1,315 @@
+import logging
+log = logging.getLogger(__name__)
+
+from pathlib import Path
+
+from .experiment import Experiment
+
+from cftscal.plugins.widgets import AddItem
+
+from enaml.core.api import Conditional, Looper
+from enaml.layout.api import align, hbox, spacer, vbox
+from enaml.drag_drop import DragData, DropAction
+from enaml.stdlib.message_box import critical
+from enaml.styling import StyleSheet, Style, Setter
+from enaml.widgets.api import (
+    CheckBox, Container, Feature, Field, Form, HGroup, Label, ObjectCombo,
+    PopupView, PushButton, VGroup,
+)
+
+from psi.experiment.api import paradigm_manager
+
+
+enamldef AddParadigmPopup(PopupView): popup:
+
+    attr experiment_box
+    attr mode = 'classic'
+    attr paradigms
+    arrow_size = 20
+
+    Container:
+        constraints = [vbox(combo, hbox(spacer(0), pb_add))]
+        ObjectCombo: combo:
+            items = paradigms
+            to_string = lambda x: x.title
+        PushButton: pb_add:
+            text = 'OK'
+            clicked ::
+                exp = Experiment(paradigm=combo.selected)
+                if mode == 'sequence':
+                    exp = exp.freeze(exp.paradigm.info['modes'][0], 'selected')
+                seq = experiment_box.sequence[:]
+                seq.append(exp)
+                experiment_box.sequence = seq
+                popup.close()
+
+
+enamldef PluginPopup(PopupView): popup:
+    attr experiment
+    attr available_plugins
+    attr modes
+    arrow_size = 20
+    VGroup:
+        Form:
+            padding = 0
+            Looper:
+                iterable = modes
+                Label:
+                    text = f'{loop_item.capitalize()} note'
+                Field:
+                    text = experiment.mode_notes.get(loop_item, '')
+                    text ::
+                        experiment.mode_notes[loop_item] = text
+        Looper:
+            iterable = available_plugins
+            CheckBox:
+                checked = bool(loop_item.id in experiment.plugins)
+                checked ::
+                    if checked:
+                        if loop_item.id not in experiment.plugins:
+                            experiment.plugins.append(loop_item.id)
+                    else:
+                        experiment.plugins.remove(loop_item.id)
+                text = loop_item.title
+
+
+enamldef ExperimentSequence(Container): experiment_box:
+
+    attr start_enabled = True
+    attr save = True
+    attr mode = 'classic'
+    attr paradigm_type = 'ear'
+
+    attr sequence
+    attr edit_mode = False
+    attr settings
+    attr autostart = False
+
+    StyleSheet:
+        Style:
+            element = 'Container'
+            style_class = 'hover'
+            Setter:
+                field = 'background'
+                value = 'lightblue'
+
+    layout_constraints => ():
+        # Align the subwidgets vertically
+        widgets = self.visible_widgets()
+        subwidgets = [w.visible_widgets() for w in widgets]
+        return [
+            vbox(*widgets),
+            *[align('width', *c) for c in zip(*subwidgets)],
+            *[align('left', *c) for c in zip(*subwidgets)],
+        ]
+
+    Looper: exp_loop:
+        iterable << experiment_box.sequence
+
+        Container: row:
+            share_layout = True
+            style_class = ''
+
+            features << (Feature.DropEnabled | Feature.DragEnabled)
+
+            drag_start => ():
+                if not edit_mode:
+                    return
+                data = DragData()
+                data.supported_actions = DropAction.Copy
+                i = experiment_box.sequence.index(loop_item)
+                data.mime_data.set_data('text/plain', f'::experiment::{i}'.encode('utf-8'))
+                return data
+
+            drag_enter => (event):
+                if not edit_mode:
+                    return
+                if event.mime_data().has_format('text/plain'):
+                    data = event.mime_data().data('text/plain').decode('utf-8')
+                    if not data.startswith('::experiment::'):
+                        return
+                    else:
+                        self.style_class = 'hover'
+                        event.accept_proposed_action()
+
+            drag_leave => ():
+                self.style_class = ''
+
+            drop => (event):
+                if not edit_mode:
+                    return
+                self.style_class = ''
+                data = event.mime_data().data('text/plain').decode('utf-8')
+                i = int(data.rsplit('::', 1)[1])
+                j = experiment_box.sequence.index(loop_item)
+                sequence = experiment_box.sequence[:]
+                sequence.insert(j, sequence.pop(i))
+                experiment_box.sequence = sequence
+
+            layout_constraints => ():
+                widgets = self.visible_widgets()
+                return [
+                    hbox(*widgets),
+                    align('v_center', *widgets),
+                ]
+            padding = 0
+
+            PushButton:
+                name = 'remove_paradigm'
+                visible << edit_mode
+                constraints = [width == 30]
+                text = '-'
+                clicked ::
+                    seq = experiment_box.sequence[:]
+                    seq.remove(loop_item)
+                    experiment_box.sequence = seq
+
+            Label:
+                text = loop_item.paradigm.title
+
+            Conditional:
+                condition = experiment_box.mode == 'classic'
+
+                HGroup:
+                    padding = 0
+                    spacing = 0
+                    enabled << (experiment_box.start_enabled or edit_mode) and \
+                        settings.process_manager.current_subprocess is None
+
+                    Looper: mode_loop:
+                        attr experiment = loop_item
+                        iterable << loop_item.paradigm.info.get('modes', ['Run'])
+
+                        PushButton:
+                            text = loop_item.capitalize()
+                            clicked ::
+                                try:
+                                    settings.run_experiment(mode_loop.experiment,
+                                                            loop_item,
+                                                            save=save,
+                                                            autostart=autostart)
+                                except Exception as e:
+                                    log.exception(e)
+                                    critical(experiment_box, 'Error starting experiment', str(e))
+                                # Update the preferences in case new ones were created
+                                preferences.items = [str(p) for p in \
+                                                    mode_loop.experiment.paradigm.list_preferences()]
+
+            Conditional:
+                condition << (mode == 'sequence' and edit_mode)
+
+                ObjectCombo:
+                    items = loop_item.paradigm.info['modes']
+                    selected := loop_item.mode
+
+                Conditional:
+                    condition << (paradigm_type == 'ear')
+
+                    ObjectCombo:
+                        items = ['selected', 'left', 'right']
+                        selected := loop_item.ear
+
+                    Label:
+                        text = f'ear'
+
+            Conditional:
+                condition << (mode == 'sequence' and not edit_mode)
+
+                Conditional:
+                    condition << (paradigm_type == 'ear')
+
+                    Label:
+                        text = f'{loop_item.mode} {loop_item.ear} ear'
+
+                Conditional:
+                    condition << (paradigm_type != 'ear')
+
+                    Label:
+                        text = loop_item.mode
+
+            ObjectCombo: preferences:
+                items = [str(p) for p in loop_item.paradigm.list_preferences()]
+                selected := loop_item.preference
+                to_string = lambda x: Path(x).stem
+
+            PushButton:
+                attr plugins = [p for p in loop_item.paradigm.plugins \
+                                if not p.required and not p.info.get('hide', False)]
+                constraints = [width == 30]
+                text = '⚙'
+                clicked ::
+                    popup = PluginPopup(
+                        parent=self,
+                        experiment=loop_item,
+                        available_plugins=plugins,
+                        modes=loop_item.paradigm.info.get('modes', [])
+                    )
+                    popup.show()
+
+    Container:
+        padding = 0
+        layout_constraints => ():
+            return [
+                hbox(*self.visible_widgets()),
+                align('v_center', *self.visible_widgets()),
+            ]
+        PushButton: pb_add_seq:
+            visible << edit_mode
+            constraints = [width == 30]
+            text = '+'
+            clicked ::
+                popup = AddParadigmPopup(
+                    parent=self,
+                    paradigms=paradigm_manager.list_paradigms(paradigm_type),
+                    experiment_box=experiment_box,
+                    mode=experiment_box.mode
+                )
+                popup.show()
+
+        # A bit of a hack but enables us to ensure all columns lined up properly
+        Label:
+            pass
+        Label:
+            pass
+        Label:
+            pass
+        Label:
+            pass
+        Label:
+            pass
+
+
+enamldef AddRemoveCombo(Container): container:
+
+    alias items: combo.items
+    alias selected: combo.selected
+    alias remove_clicked: pb_remove.clicked
+
+    attr regex = '.*'
+    attr editable = True
+    attr removed
+
+    padding = 0
+
+    constraints << [hbox(combo, hbox(pb_add, pb_remove, spacing=0))] if editable else [hbox(combo)]
+
+    ObjectCombo: combo:
+        pass
+
+    PushButton: pb_add:
+        text = '+'
+        constraints = [width == 30]
+        visible << editable
+        clicked ::
+            popup = AddItem(parent=self, combo=combo, regex=regex)
+            popup.show()
+
+    PushButton: pb_remove:
+        text = '-'
+        constraints = [width == 30]
+        visible << editable
+        enabled << bool(combo.items)
+        clicked ::
+            items = combo.items[:]
+            items.remove(combo.selected)
+            combo.items = items

psiapp-0.0.1/psiapp.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: psiapp
+Version: 0.0.1
+Summary: Tools for supporting experiment launchers using psiexperiment
+Author-email: Brad Buran <buran@ohsu.edu>
+Maintainer-email: Brad Buran <buran@ohsu.edu>
+Requires-Python: >=3.7
+License-File: LICENSE.txt
+Requires-Dist: enaml[qt6-pyside]>=0.13.0
+Dynamic: license-file

psiapp-0.0.1/psiapp.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+.gitignore
+LICENSE.txt
+pyproject.toml
+.github/workflows/publish-to-pypi.yml
+psiapp/api.py
+psiapp/experiment.enaml
+psiapp/process_manager.py
+psiapp/version.py
+psiapp/widgets.enaml
+psiapp.egg-info/PKG-INFO
+psiapp.egg-info/SOURCES.txt
+psiapp.egg-info/dependency_links.txt
+psiapp.egg-info/requires.txt
+psiapp.egg-info/top_level.txt

psiapp-0.0.1/psiapp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

psiapp-0.0.1/psiapp.egg-info/requires.txt

@@ -0,0 +1 @@
+enaml[qt6-pyside]>=0.13.0

psiapp-0.0.1/psiapp.egg-info/top_level.txt

@@ -0,0 +1 @@
+psiapp

psiapp-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "psiapp"
+description = "Tools for supporting experiment launchers using psiexperiment"
+requires-python = ">=3.7"
+license = {file = "license.txt"}
+authors = [
+    {name = "Brad Buran", email="buran@ohsu.edu"},
+]
+maintainers = [
+    {name = "Brad Buran", email="buran@ohsu.edu"},
+]
+dependencies = [
+    "enaml[qt6-pyside] >=0.13.0",
+]
+dynamic = ["version"]
+
+[build-system]
+requires = ["setuptools>=61.2", "wheel", "setuptools_scm[toml]>=3.4.3"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+write_to = "psiapp/version.py"
+
+[tool.pytest.ini_options]
+markers = [
+    "slow: runs tests that will otherwise be skipped because they are slow"
+]

psiapp-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+