barsukov 0.0.0__tar.gz

barsukov-0.0.0/.github/workflows/versioning.yml

@@ -0,0 +1,71 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package to PyPI
+
+on: 
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:     
+  build:
+    name: Build Distribution
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      
+      - name: Build release distribution
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: push-dists
+          path: dist/
+
+  pypi-publish:
+    name: Publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: build
+    runs-on: ubuntu-latest
+    
+    permissions:
+      id-token: write
+
+    environment:
+      name: pypi
+      url: https://pypi.org/p/barsukov
+      #
+      # ALTERNATIVE: if your GitHub Release name is the PyPI project version string
+      # ALTERNATIVE: exactly, uncomment the following line instead:
+      # url: https://pypi.org/project/YOURPROJECT/${{ github.event.release.name }}
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: push-dists
+          path: dist/
+
+      - name: Publish push-distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: ${{ secrets.PYPI_USERNAME }}
+          password: ${{ secrets.PYPI_PASSWORD }}
+          packages-dir: dist/

barsukov-0.0.0/.gitignore

@@ -0,0 +1,244 @@
+#logger files
+*_.txt
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.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/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+*.ipynb
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  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/
+
+#adding jetbrains .idea stuff
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser

barsukov-0.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+
+recursive-include src *.py

barsukov-0.0.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.2
+Name: barsukov
+Version: 0.0.0
+Summary: Experiment Automation Package
+Author-email: Igor Barsukov <igorb@ucr.edu>, Steven Castaneda <scast206@ucr.edu>
+Project-URL: Homepage, https://barsukov.ucr.edu
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pytz>=2014.10
+Requires-Dist: numpy>=1.0.0
+Requires-Dist: scipy>=0.9.0
+
+# Barsukov
+
+Barsukov is a Python library for experiment automation.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install barsukov.
+
+```bash
+pip install barsukov
+```
+
+## Usage
+
+```python
+#
+#
+#
+#
+#
+#
+#
+```
+
+## Contributing
+
+-
+-
+-
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

barsukov-0.0.0/README.md

@@ -0,0 +1,33 @@
+# Barsukov
+
+Barsukov is a Python library for experiment automation.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install barsukov.
+
+```bash
+pip install barsukov
+```
+
+## Usage
+
+```python
+#
+#
+#
+#
+#
+#
+#
+```
+
+## Contributing
+
+-
+-
+-
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

barsukov-0.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "barsukov"
+dynamic = ["version"]
+dependencies = [
+    "pytz>=2014.10",
+    "numpy>=1.0.0",
+    "scipy>=0.9.0",
+]
+authors = [
+    { name = "Igor Barsukov", email = "igorb@ucr.edu" },
+    { name = "Steven Castaneda", email = "scast206@ucr.edu" },
+]
+requires-python = ">=3.6"
+description = "Experiment Automation Package"
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://barsukov.ucr.edu"
+#Repository = <githublink>
+
+[tool.setuptools.packages.find]
+where = ["src"]

barsukov-0.0.0/setup.cfg

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

barsukov-0.0.0/src/barsukov/__init__.py

@@ -0,0 +1,18 @@
+# Modules:
+from . import time
+from . import data
+    
+
+# Objects/Functions:
+from .script import Script
+from .logger import Logger
+
+from .obj2file import *
+
+
+# Equipment Objects:
+from .exp.mwHP import mwHP
+
+__all__ = ["time", "data", "save_object", "load_object", "Script", "Logger", "mwHP"]
+
+

barsukov-0.0.0/src/barsukov/data/__init__.py

@@ -0,0 +1 @@
+from .fft import *

barsukov-0.0.0/src/barsukov/data/fft.py

@@ -0,0 +1,87 @@
+### BEGIN Dependencies ###
+import numpy as np
+import scipy as sp
+from barsukov.logger import debug    # Un-comment before implementing in pip
+### END Dependencies ###
+
+
+def fft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False, inverse=False):
+    ### Takes: x=list of real floats, y=list of data or list of lists of data. Data can be real or complex.
+    ### Returns: freqs, fft_y_norm, msg
+    ### This fft used to give wrong sign of the imaginary component because of the "wrong" definition of fft in np and sp
+    ### Now it has been corrected to the Mathematica definition of fft = int ... exp(2pi f t)
+    msg = ''
+    if equidistant_check:
+        diffs = np.diff(x)
+        if not np.allclose(diffs, diffs[0], rtol=equidistant_rel_error):
+            # x is not equidistant, must start interpolating
+            x,y = make_equidistant(x, y, step=None)
+            y = y.T
+            msg += debug('fft(x,y) made x,y equidistant.')
+
+    y = np.array(y)
+    #print(y)
+
+    if y.ndim == 1:
+        # y is 1D, treat it as a single column
+        n = len(y)  # Number of points in the column
+        if inverse is False: fft_y = np.fft.ifft(y) * n # np fft has the "wrong" imag sign
+        else: fft_y = np.fft.fft(y) # That's why fft and ifft are inverted in this code
+    else:
+        # y is 2D, treat it as multiple columns
+        n = y.shape[1]  # Number of points in each column
+        if inverse is False: fft_y = np.fft.ifft(y, axis=1) * n # np fft has the "wrong" imag sign
+        else: fft_y = np.fft.fft(y, axis=1) # That's why fft and ifft are inverted in this code
+
+    sample_spacing = ( x[-1] - x[0] ) / (n-1)
+    #print(n, sample_spacing, x[1] - x[0])
+    fft_y_norm = fft_y * sample_spacing # This normalizes FFT to mathematically correct
+    freqs = np.fft.fftfreq(n, d=sample_spacing)
+
+    if remove_negative_f is False:
+        sorted_indices = np.argsort(freqs)
+        freqs = freqs[sorted_indices]
+        if isinstance(fft_y_norm[0], (list, np.ndarray)):  # If fft_y_norm contains multiple columns
+            fft_y_norm = [x[sorted_indices] for x in fft_y_norm]
+        else:  # If fft_y_norm is a single column
+            fft_y_norm = fft_y_norm[sorted_indices]
+        msg += debug('fft(x,y) sorted negative and positive frequencies.')
+    else:
+        mask = freqs >= 0 # Boolean array with Falses for negative frequencies, effectively removing them
+        freqs = freqs[mask]
+        # If fft_y_norm contains multiple columns:
+        if isinstance(fft_y_norm[0], (list, np.ndarray)):
+            fft_y_norm = [x[mask] for x in fft_y_norm]
+        else:  # If fft_y_norm is a single column
+            fft_y_norm = fft_y_norm[mask]
+        msg += debug('fft(x,y) removed negative frequencies.')
+
+    msg += debug('freqs, fft_y_norm, msg = fft(x,y) is done.\nThe forward fft approximates the mathematically correct integral over ...exp(+i2pift).\nNow do not forget to apply np.abs(fft_y_norm), np.angle(fft_y_norm), fft_y_norm.real, fft_y_norm.imag')
+    return freqs, fft_y_norm, msg
+
+def ifft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False):
+    return fft(x, y, equidistant_check=equidistant_check, equidistant_rel_error=equidistant_rel_error, remove_negative_f=remove_negative_f, inverse=True)
+
+def make_equidistant(x, y, step=None):
+    ### Takes one column x and one or more columns y and makes them equidistant in x
+    ### Returns new_x, new_y. The number of points will likely change.
+    if step is None:
+        # Calculate the smallest difference between consecutive elements
+        min_step = np.min(np.diff(x))
+    else:
+        min_step = step
+    
+    # Generate the new equidistant x array
+    new_x = np.arange(x[0], x[-1] + min_step, min_step)
+    
+    if isinstance(y[0], (list, np.ndarray)):  # If y contains multiple columns
+        new_y = []
+        for y_column in y:
+            interpolation_function = sp.interpolate.interp1d(x, y_column, kind='linear', fill_value='extrapolate')
+            new_y.append(interpolation_function(new_x))
+        new_y = np.array(new_y).T  # Transpose to match the original structure
+    else:  # If y is a single column
+        interpolation_function = sp.interpolate.interp1d(x, y, kind='linear', fill_value='extrapolate')
+        new_y = interpolation_function(new_x)
+    
+    return new_x, new_y

barsukov-0.0.0/src/barsukov/exp/__init__.py

@@ -0,0 +1 @@
+from . import mwHP

barsukov-0.0.0/src/barsukov/exp/exp_utils.py

@@ -0,0 +1,136 @@
+### BEGIN Dependencies ###
+import numpy as np
+import sys
+from barsukov.time import *
+### END Dependencies
+
+
+### BEGIN Helper functions
+
+def log_in_eq(eq_obj, msg, log='default'): # FINISHED 2024/10/26
+    decorated_msg = str(eq_obj.msg_deco) + ' ' + msg
+    if eq_obj.logger is None:
+        if log=='no': return
+        else: print(time_stamp() + ' ' + decorated_msg)
+    else:
+        eq_obj.logger.log(decorated_msg, log)
+
+
+def initialize_gpib(eq_obj):
+    # Initializes a visa.open_resource(). Returns rm.open_resource(). Exits if error.
+    if eq_obj.rm is None: # eq_obj has no ResourceManager
+        if eq_obj.script is None:  # If there is no Script
+            eq_obj.log('Visa ResourceManager and Script have not been passed to me. I will attempt to initialize visa myself.', log='important')
+            try:
+                import pyvisa as visa
+                eq_obj.rm = visa.ResourceManager()
+                eq_obj.log('I just set my self.rm = visa.ResourceManager.', log='screen')
+            except:
+                eq_obj.log('I failed to initialize set my self.rm = visa.ResourceManager. I am sys-exiting.', log='important')
+                sys.exit()
+        else: # If there is a Script
+            if eq_obj.script.rm is None: # If Script has no ResourceManager
+                eq_obj.log('I see Script but it does not have rm. I am asking Script to initialize visa.ResourceManager and pass it to me.', log='important')
+                try: 
+                    eq_obj.rm = eq_obj.script.init_rm() # Script will try to init ResourceManager
+                    #print('eq_obj.rm initialized as ', eq_obj.rm)
+                except:
+                    eq_obj.log('Error while Script was initializing visa.ResourceManager. I am sys-exiting.', log='important')
+                    sys.exit()
+            else:
+                eq_obj.log('Script has visa.ResourceManager. I am grabbing it.', log='screen')
+                eq_obj.rm = eq_obj.script.rm
+            if eq_obj.rm is None: # Just to double check if rm is in fact there.
+                eq_obj.log('My last check showed that my self.rm is still None. I am sys-exiting.', log='important')
+                sys.exit()
+    # Now, we assume there is a resource manager
+    if (eq_obj.gpib is None) or (eq_obj.gpib_card is None):
+        eq_obj.log('GPIB card number or GPIB address is not set.', log='important')
+        sys.exit()
+    try:
+        #print(eq_obj.rm)
+        eq_obj.log('I am trying to rm.open_resource().', log='screen')
+        y = eq_obj.rm.open_resource(f'GPIB{eq_obj.gpib_card}::{eq_obj.gpib}')
+        #print('y=',y)
+        return y
+    except:
+        eq_obj.log(f'I could not initialize rm.open_resource() for GPIB {eq_obj.gpib_card}::{eq_obj.gpib}. Also check visa_rm, just in case.', log='important')
+        sys.exit()
+
+
+def eq_disconnect(eq_obj):
+    try:
+        eq_obj.rm.close()
+        eq_obj.rm.visalib._registry.clear()
+        eq_obj.log( f'Successfully disconnected GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='screen')
+    except:
+        eq_obj.log( f'Failed to disconnect GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='screen')
+
+
+def eq_reconnect(eq_obj):
+    try:
+        import pyvisa as visa
+        eq_obj.rm = visa.ResourceManager()
+        eq_obj.eq = initialize_gpib(eq_obj)
+        eq_obj.log( f'Successfully reconnected GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='screen')
+        eq_obj.log( f'Initialized: {eq_obj.identify()}', log='important' )
+    except: 
+        eq_obj.log(f'Failed to reconnect GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='important')
+
+### END Helper functions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### BEGIN Functions that are likely unnecessary
+
+def query_float(eq_obj, cmd):
+    ### Returns float or np.nan
+    try:
+        q = eq_obj.eq.query(cmd)
+        q = float(q) # Will it work with all equipment?
+        return q
+    except:
+        eq_obj.log(f'Error while quering: \"{cmd}\".', log='important')
+        return np.nan
+
+def write_float(eq_obj, cmd, value, digits, limits):
+    value_differs = ''
+    try:
+        value = float(value)
+        value_round = round(value, digits)
+        if value_round < limits[0]:
+            value_round = limits[0]
+        if value_round > limits[1]:
+            value_round = limits[1]
+        if value_round != value:
+            value_differs = f' But requested {value}.'
+        cmd = ''.join( [value_round if el is None else el for el in cmd] )
+        eq_obj.eq.write(cmd)
+        write_error = False
+        return write_error, value_differs
+    except:
+        write_error = True
+        eq_obj.log(f'Error while writing: \"{cmd}\".', log='important')
+        return write_error, value_differs
+
+### END Functions that are likely unnecessary