tsapython 3.0.0__tar.gz → 3.0.1__tar.gz

{tsapython-3.0.0 → tsapython-3.0.1}/PKG-INFO

@@ -1,13 +1,18 @@
 Metadata-Version: 2.4
 Name: tsapython
-Version: 3.0.0
+Version: 3.0.1
 Summary: An UNOFFICIAL Python API for the tinySA series of devices
+Keywords: tinysa,spectrum analyzer,rf,sdr,serial,ultra
 Author: LC-Linkous
 Author-email: LC-Linkous <L.C.Linkous@gmail.com>
 License-Expression: GPL-2.0-only
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Environment :: Console
 Requires-Dist: numpy>=2.2.6
 Requires-Dist: pyserial>=3.5
 Requires-Dist: matplotlib>=3.10.5 ; extra == 'plotting'
@@ -15,6 +20,8 @@ Requires-Dist: pyqt5 ; sys_platform == 'linux' and extra == 'plotting'
 Requires-Dist: pytest>=8.0 ; extra == 'test'
 Requires-Dist: pytest-cov>=5.0 ; extra == 'test'
 Requires-Python: >=3.10
+Project-URL: Changelog, https://github.com/LC-Linkous/tinySA_python/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/LC-Linkous/tinySA_python
 Project-URL: Issues, https://github.com/LC-Linkous/tinySA_python/issues
 Project-URL: Repository, https://github.com/LC-Linkous/tinySA_python
 Provides-Extra: plotting

tsapython-3.0.1/pyproject.toml

@@ -0,0 +1,97 @@
+[project]
+name = "tsapython"
+version = "3.0.1"
+authors = [
+    { name = "LC-Linkous", email = "L.C.Linkous@gmail.com" }
+]
+description = "An UNOFFICIAL Python API for the tinySA series of devices"
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = ["tinysa", "spectrum analyzer", "rf", "sdr", "serial", "ultra"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering",
+    "Environment :: Console",
+]
+dependencies = [
+    "numpy>=2.2.6",
+    "pyserial>=3.5",
+]
+license = "GPL-2.0-only"
+license-files = ["LICENSE*"]
+
+[project.optional-dependencies]
+plotting = [
+    "matplotlib>=3.10.5",
+    'pyqt5 ; platform_system == "Linux"',
+]
+test = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/LC-Linkous/tinySA_python"
+"Repository" = "https://github.com/LC-Linkous/tinySA_python"
+"Issues" = "https://github.com/LC-Linkous/tinySA_python/issues"
+"Changelog" = "https://github.com/LC-Linkous/tinySA_python/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["uv_build>=0.8.11,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+markers = [
+    "hardware: tests that require a physically connected tinySA device (deselect with -m 'not hardware')",
+]
+# PEP 735 dependency group used by `uv sync` and CI. The [project.optional-dependencies]
+# test extra above is kept for `pip install -e ".[test]"` compatibility.
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.6",
+    "mypy>=1.11",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+# Blocking ruleset: F (pyflakes: real bugs -- unused imports, undefined
+# names), E9 (syntax errors), and W (whitespace hygiene; the pre-existing
+# findings were autofixed when W was enabled). Full E remains a deferred
+# cleanup pass: ~70 findings, mostly line-length (E501) and None/bool
+# comparison style (E711/E712), which touch code lines and deserve their
+# own reviewed commit rather than riding along here.
+select = ["E9", "F", "W"]
+
+[tool.mypy]
+# No python_version pin: numpy's bundled stubs use PEP 695 `type` statements,
+# which mypy rejects when the analysis version is pinned below 3.12. mypy runs
+# on CI's 3.12 environment; actual 3.10/3.11 compatibility is enforced by the
+# test matrix, which runs the real interpreter versions.
+files = ["src/tsapython"]
+# The package ships a py.typed marker, which promises downstream type-checkers
+# that the inline annotations are real. These settings are what make that
+# promise true -- every def in the shipped package must be annotated, or CI
+# fails. Tests and examples are deliberately not gated.
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+
+[[tool.mypy.overrides]]
+# pyserial ships no type stubs; treat its interface as dynamically typed rather
+# than failing the import.
+module = "serial.*"
+ignore_missing_imports = true
+

{tsapython-3.0.0 → tsapython-3.0.1}/src/tsapython/__init__.py

@@ -7,4 +7,4 @@ __version__ = "2.0.0"
 # In __init__.py
 from .core import tinySA
 
-__all__ = ["tinySA"]
+__all__ = ["tinySA"]

tsapython-3.0.1/src/tsapython/_commands/__init__.py

@@ -0,0 +1 @@
+# tsapython command mixins (internal). Not a public API.

{tsapython-3.0.0 → tsapython-3.0.1}/src/tsapython/_commands/acquisition.py

@@ -11,57 +11,61 @@
 #   Author(s): Lauren Linkous
 ##--------------------------------------------------------------------------------------------------\
 
-class AcquisitionMixin:
-    def data(self, val=0):
-        # dumps the trace data. 
+from collections.abc import Iterator
+
+from .._host import MixinHost
+
+class AcquisitionMixin(MixinHost):
+    def data(self, val: int = 0) -> bytearray | None:
+        # dumps the trace data.
         # usage: data [0-2]
         # 0=temp value, 1=stored trace, 2=measurement
         # example return: bytearray(b'-8.671875e+01\r\n... -8.337500e+01\r\n-8.237500e+01\r')
-        
+
         #explicitly allowed vals
         accepted_vals = [0,1,2]
         #check input
         if val in accepted_vals:
             writebyte = 'data '+str(val)+'\r\n'
-            msgbytes = self.tinySA_serial(writebyte, printBool=False)  
+            msgbytes = self.tinySA_serial(writebyte, printBool=False)
             if val == 0:
-                self.print_message("returning temp value data") 
+                self.print_message("returning temp value data")
             elif val == 1:
-                self.print_message("returning stored trace data") 
+                self.print_message("returning stored trace data")
             elif val == 2:
-                self.print_message("returning measurement data") 
+                self.print_message("returning measurement data")
         else:
             self.print_message("ERROR: data() takes vals [0-2]")
             msgbytes = self.error_byte_return()
         return msgbytes
 
-    def get_temporary_data(self):
+    def get_temporary_data(self) -> bytearray | None:
         # alias func for data()
         return self.data(val=0)
 
-    def get_stored_trace_data(self):
+    def get_stored_trace_data(self) -> bytearray | None:
         # alias func for data()
         return self.data(val=1)
 
-    def dump_measurement_data(self):
+    def dump_measurement_data(self) -> bytearray | None:
         # alias func for data()
         return self.data(val=2)
 
-    def frequencies(self):
+    def frequencies(self) -> bytearray | None:
         # gets the frequencies used by the last sweep
         # usage: frequencies
         # example return: bytearray(b'1500000000\r\n... \r\n3000000000\r')
 
         writebyte = 'frequencies\r\n'
-        msgbytes = self.tinySA_serial(writebyte, printBool=False) 
+        msgbytes = self.tinySA_serial(writebyte, printBool=False)
         self.print_message("getting frequencies from the last sweep")
         return msgbytes
 
-    def get_last_freqs(self):
+    def get_last_freqs(self) -> bytearray | None:
         # get frequencies of last sweep
         return self.frequencies()
 
-    def hop(self, start, stop, inc, outmask=None):
+    def hop(self, start: int, stop: int, inc: int, outmask: int | None = None) -> bytearray | None:
         # this is a measurement, maybe a sample measurement. format looks like hop freqval integer
         # usage: hop {start(Hz)} {stop(Hz)} {step(Hz) | points} [outmask]
         # outmask: 1 is frequency, 2 is level
@@ -74,40 +78,40 @@ class AcquisitionMixin:
             elif outmask ==None:
                 writebyte = 'hop ' + str(start) + ' ' + str(stop) + ' ' + str(inc) + '\r\n'
 
-            msgbytes = self.tinySA_serial(writebyte, printBool=False) 
+            msgbytes = self.tinySA_serial(writebyte, printBool=False)
             self.print_message("sampling over frequency range")
             return msgbytes
 
-        else: 
+        else:
             self.print_message("hop() takes arguments start=Int, stop=Int, inc=Int, outmask=None|Int")
 
         return None
 
-    def get_sample_pts(self, start, stop, pts):
+    def get_sample_pts(self, start: int, stop: int, pts: int) -> bytearray | None:
         # alias for hop()
         return self.hop(start, stop, pts, outmask=1)
 
-    def pause(self):
+    def pause(self) -> bytearray | None:
         # pauses the sweeping in either input or output mode
         # usage: pause
         # example return: ''
 
         writebyte = 'pause\r\n'
-        msgbytes = self.tinySA_serial(writebyte, printBool=False) 
+        msgbytes = self.tinySA_serial(writebyte, printBool=False)
         self.print_message("pausing tinySA device")
-        return msgbytes 
+        return msgbytes
 
-    def resume(self):
+    def resume(self) -> bytearray | None:
         # resumes the sweeping in either input or output mode
         # usage: resume
         # example return: ''
 
         writebyte = 'resume\r\n'
-        msgbytes = self.tinySA_serial(writebyte, printBool=False) 
+        msgbytes = self.tinySA_serial(writebyte, printBool=False)
         self.print_message("resuming sweep")
-        return msgbytes 
+        return msgbytes
 
-    def scan(self, start, stop, pts=250, outmask=None):
+    def scan(self, start: int, stop: int, pts: int = 250, outmask: int | None = None) -> bytearray | None:
         # Performs a scan and optionally outputs the measured data.
         # usage: scan {start(Hz)} {stop(Hz)} [points] [outmask]
             # where the outmask is a binary OR of:
@@ -117,21 +121,21 @@ class AcquisitionMixin:
         if (0<=start) and (start < stop) and (pts <= self.maxPoints):
             if outmask == None:
                 writebyte = 'scan '+str(start)+' '+str(stop)+' '+str(pts)+'\r\n'
-            else: 
+            else:
                  writebyte = 'scan '+str(start)+' '+str(stop)+' '+str(pts)+ ' '+str(outmask)+'\r\n'
             msgbytes = self.tinySA_serial(writebyte, printBool=False)
-            self.print_message("scanning...")           
+            self.print_message("scanning...")
         else:
             self.print_message("ERROR: scan takes START STOP PTS OUTMASK as args. Check doc for format and limits")
             msgbytes = self.error_byte_return()
         return msgbytes
 
-    def scan_raw(self, start, stop, pts=250, unbuf=1):
-        # performs a scan of unlimited amount of points 
+    def scan_raw(self, start: int, stop: int, pts: int = 250, unbuf: int = 1) -> bytearray | None:
+        # performs a scan of unlimited amount of points
         # and sends the data in binary form
         # usage: scanraw {start(Hz)} {stop(Hz)} [points] [unbuffered]
             # The measured data is sent as:
-            #  '{' ('x' MSB LSB)*points '}' 
+            #  '{' ('x' MSB LSB)*points '}'
             #  where the 16 bit data is scaled by 32 & shifted based on device.
             # the README has examples for processing
 
@@ -140,7 +144,7 @@ class AcquisitionMixin:
                 writebyte = 'scanraw '+str(start)+' '+str(stop)+' '+str(pts)+ ' '+str(unbuf)+'\r\n'
 
                 # write out to serial, get message back, clean up, return
-                self.print_message("scanning...")  
+                self.print_message("scanning...")
                 msgbytes = self.tinySA_serial(writebyte, printBool=False, pts=pts) #pts added for error checking
                 return msgbytes
             else:
@@ -151,7 +155,7 @@ class AcquisitionMixin:
             msgbytes = self.error_byte_return()
         return msgbytes
 
-    def continuous_scanraw(self, start, stop, pts=250, unbuf=1, count=None):
+    def continuous_scanraw(self, start: int, stop: int, pts: int = 250, unbuf: int = 1, count: int | None = None) -> "Iterator[bytearray | None]":
         # Continuous SCANRAW acquisition.
         #
         # The tinySA returns exactly ONE binary frame per scanraw call (it does
@@ -189,26 +193,26 @@ class AcquisitionMixin:
             yield frame
             emitted += 1
 
-    def config_sweep(self, argName=None, val=None): 
+    def config_sweep(self, argName: int | float | str | None = None, val: int | float | str | None = None) -> bytearray | None:
             # split call for SWEEP
             # Set sweep boundaries.
-            # Sweep without arguments lists the current sweep 
-            # settings. The frequencies specified should be 
-            # within the permissible range. The sweep commands 
-            # apply both to input and output modes        
-            # usage: 
-            # sweep [(start|stop|center|span|cw {frequency}) | 
+            # Sweep without arguments lists the current sweep
+            # settings. The frequencies specified should be
+            # within the permissible range. The sweep commands
+            # apply both to input and output modes
+            # usage:
+            # sweep [(start|stop|center|span|cw {frequency}) |
             #   ({start(Hz)} {stop(Hz)} [0..290])]
             # EXAMPLES:
             # sweep start {frequency}: sets the start frequency of the sweep.
             # sweep stop {frequency}: sets the stop frequency of the sweep.
             # sweep center {frequency}: sets the center frequency of the sweep.
             # sweep span {frequency}: sets the span of the sweep.
-            # sweep cw {frequency}: sets the continuous wave frequency (zero span sweep). 
-            # # example return:  b'' 
+            # sweep cw {frequency}: sets the continuous wave frequency (zero span sweep).
+            # # example return:  b''
 
         # explicitly allowed vals
-        accepted_table_args = ["start", "stop", "center", 
+        accepted_table_args = ["start", "stop", "center",
                                "span", "cw"]
 
         if (argName==None) and (val==None):
@@ -216,7 +220,7 @@ class AcquisitionMixin:
             writebyte = 'sweep\r\n'
             msgbytes = self.tinySA_serial(writebyte, printBool=False)
 
-        elif (argName in accepted_table_args): 
+        elif (argName in accepted_table_args):
             if val == None:
                 #error
                 self.print_message("ERROR: sweep " + str(argName) + " needs a value")
@@ -233,40 +237,41 @@ class AcquisitionMixin:
 
         return msgbytes
 
-    def get_sweep_params(self):
-        # alias for config_sweep() 
+    def get_sweep_params(self) -> bytearray | None:
+        # alias for config_sweep()
         return self.config_sweep()
 
-    def set_sweep_start(self, val):
-        # alias for config_sweep() 
+    def set_sweep_start(self, val: int | float | str) -> bytearray | None:
+        # alias for config_sweep()
         return self.config_sweep("start", val)
 
-    def set_sweep_stop(self, val):
-        # alias for config_sweep() 
+    def set_sweep_stop(self, val: int | float | str) -> bytearray | None:
+        # alias for config_sweep()
         return self.config_sweep("stop", val)
 
-    def set_sweep_center(self, val):
-        # alias for config_sweep() 
+    def set_sweep_center(self, val: int | float | str) -> bytearray | None:
+        # alias for config_sweep()
         return self.config_sweep("center", val)
 
-    def set_sweep_span(self, val):
-        # alias for config_sweep() 
+    def set_sweep_span(self, val: int | float | str) -> bytearray | None:
+        # alias for config_sweep()
         return self.config_sweep("span", val)
 
-    def set_sweep_cw(self, val):
-        # alias for config_sweep() 
-        return self.config_sweep("cw", val)   
+    def set_sweep_cw(self, val: int | float | str) -> bytearray | None:
+        # alias for config_sweep()
+        return self.config_sweep("cw", val)
 
-    def run_sweep(self, startVal=None, stopVal=None, pts=250):
+    def run_sweep(self, startVal: int | float | str | None = None, stopVal: int | float | str | None = None, pts: int | None = 250) -> bytearray | None:
             # split call for SWEEP
             # Execute sweep.
-            # The frequencies specified should be 
-            # within the permissible range. The sweep commands 
-            # apply both to input and output modes        
-            # usage: 
-            # sweep [(start|stop|center|span|cw {frequency}) | 
+            # The frequencies specified should be
+            # within the permissible range. The sweep commands
+            # apply both to input and output modes
+            # usage:
+            # sweep [(start|stop|center|span|cw {frequency}) |
             #   ({start(Hz)} {stop(Hz)} [0..290])]
-            # # example return:  
+            # # example return:
+        msgbytes: bytearray | None
         if (startVal==None) or (stopVal==None):
             self.print_message("ERROR: sweep start and stop need non-empty values")
             msgbytes = self.error_byte_return()
@@ -279,56 +284,56 @@ class AcquisitionMixin:
             writebyte = 'sweep '+str(startVal)+' '+str(stopVal)+' '+str(pts)+'\r\n'
             msgbytes = self.tinySA_serial(writebyte, printBool=False)
 
-        return msgbytes 
+        return msgbytes
 
-    def sweep_time(self, val):
+    def sweep_time(self, val: int | float | str) -> bytearray | None:
         # sets the sweeptime
         # usage: sweep {time(Seconds)}the time
         # specified may end in a letter where
         # m=mili and u=micro
         # example return:  b''
-        
-        
+
+
         # needs some error checking
 
         writebyte = 'sweeptime '+str(val)+'\r\n'
-        msgbytes = self.tinySA_serial(writebyte, printBool=False)   
+        msgbytes = self.tinySA_serial(writebyte, printBool=False)
         self.print_message("sweeptime set to " + str(val))
         return msgbytes
 
-    def trigger(self, val, freq=None):
+    def trigger(self, val: int | float | str | None, freq: int | float | str | None = None) -> bytearray | None:
         # sets the trigger type or level
         # usage: trigger auto|normal|single|{level(dBm)}
         # the trigger level is always set in dBm and is the only numerical input
-        # example return:  
+        # example return:
         # #explicitly allowed vals
-        accepted_vals =  ["auto", "normal", "single"]        
+        accepted_vals =  ["auto", "normal", "single"]
 
         if str(val) in accepted_vals:
             writebyte = 'trigger ' + str(val) +'\r\n'
-            msgbytes = self.tinySA_serial(writebyte, printBool=False) 
+            msgbytes = self.tinySA_serial(writebyte, printBool=False)
             self.print_message("setting trigger to " + str(val))
         elif val==None and isinstance(freq,int):
             writebyte = 'trigger ' + str(freq) +'\r\n'
-            msgbytes = self.tinySA_serial(writebyte, printBool=False) 
+            msgbytes = self.tinySA_serial(writebyte, printBool=False)
             self.print_message("setting trigger level (dBm) to " + str(freq))
         else:
             self.print_message("ERROR: trigger takes inputs auto|normal|single|{level(dBm)}")
             msgbytes = self.error_byte_return()
         return msgbytes
 
-    def trigger_auto(self):
+    def trigger_auto(self) -> bytearray | None:
         # alias for trigger
         return self.trigger("auto")
 
-    def trigger_normal(self):
+    def trigger_normal(self) -> bytearray | None:
         # alias for trigger
-        return self.trigger("normal")    
+        return self.trigger("normal")
 
-    def trigger_single(self):
+    def trigger_single(self) -> bytearray | None:
         # alias for trigger
         return self.trigger("single")
 
-    def trigger_level(self, val):
+    def trigger_level(self, val: int | float | str) -> bytearray | None:
         # alias for trigger
-        return self.trigger(None, val)
+        return self.trigger(None, val)