quarchpy 2.2.5__py2.py3-none-any.whl → 2.2.6__py2.py3-none-any.whl

quarchpy/connection_specific/QPS/win-amd64/scriptCommands.txt

@@ -1,7 +1,7 @@
 QPS Command Summary
 Copyright (c) Quarch Ltd
-QPS v1.44
-Generated: 12 Nov 2024
+QPS v1.44.2
+Generated: 14 Jan 2025
 
 
 *** Commands ***
@@ -774,7 +774,7 @@ To indicate the end marker of an interval then set the value to 'endSeq'; eg : m
 Command: $stream export
 Description: Saves to a given format
 Version: 2
-See also: $save csv
+See also: $save csv, $stream import
 Arguments
 Argument: file
 Description: The file path to save the export
@@ -814,6 +814,60 @@ Argument file is optional and if not specified then a file name is assigned and
 If no fileType file is specified then the following is assigned: .../path to recording directory/fileType+Export+yyyyMMddHHmmss.fileType
 By default all channels are exported but can be filtered using argument "channel"
 
+Command: $stream import
+Description: Imports from a given format
+Version: 2
+See also: $stream export
+Arguments
+Argument: file
+Description: The file path to be imported
+Index: 0
+Type: STRING
+Default value: NONE
+Argument: fileType
+Description: File type; eg CSV
+Index: 1
+Type: STRING
+Default value: csv
+Argument: delimiter
+Description: Value separator; eg ,
+Index: 2
+Type: STRING
+Default value: ,
+Acceptable values: ["\t", ";", ",", " "]
+Argument: minTime
+Description: The minimum time value; eg 100mS. The default value of 0nS indicates reading from the start
+Index: 3
+Type: STRING
+Default value: 0nS
+Argument: maxTime
+Description: The maximum time value; eg 800mS. The default value of -1nS indicates reading to the end
+Index: 4
+Type: STRING
+Default value: -1nS
+Argument: offsetTime
+Description: The offset time value; eg 10mS. The default value of 0nS indicates there is no offset
+Index: 5
+Type: STRING
+Default value: 0nS
+Argument: channels
+Description: List of channels to import; eg "voltage:5v,current:12v" with the default set to "all"
+Index: 6
+Type: STRING
+Default value: all
+Argument: timeFormat
+Description: Time format ["elapsed", "unix"]. The default is "elapsed"
+Index: 7
+Type: STRING
+Default value: elapsed
+Acceptable values: [elapsed, unix]
+Notes:
+The file must contain an extension that matches the one specified in fileType. This is used as a check.
+Examples:
+$stream import file="C:\Temp\data.csv"
+$stream import file="C:\Temp\data.csv" channels="voltage:12v,current:12v"
+$stream import file="C:\Temp\data.csv" channels="voltage:12v,current:12v" minTime=1S maxTime=10S
+
 Command: $stream read
 Description: Reads data between from a given start time and either end time or number of records
 Version: 2
@@ -1072,6 +1126,8 @@ $stream data add ~ Adds a channel/group value at a specified time
 
 $stream export ~ Saves to a given format
 
+$stream import ~ Imports from a given format
+
 $stream read ~ Reads data between from a given start time and either end time or number of records
 
 $stream record ~ Starts streaming

quarchpy/connection_specific/QPS/win-amd64/whats-new.txt

@@ -1,39 +1,31 @@
 *** What's New In Quarch Power Studio ***
 
-11th November 2024
+14th January 2025
 
-QPS version 1.44
-QIS version 1.46
+QPS version 1.45
+QIS version 1.47
 
 
 
 *** New Features ***
 
-Synthetic channels can now be disabled without deleting them (as with instrument channels)
+Improved help menu links and additional documentation
 
-Added channel options to the CSV export dialog
+Data valid synthetic channel for AC compliance testing
 
-Improved cursor controls and display
+Improved import speed for custom user data
 
-Instrument profiles now display their name and description information when loaded
+Reduced time from start stream, until data is first displayed
 
-Synthetic channel for subtraction added
+Added notification for locked devices that are open in other applications
 
-Channels can now have visibility disabled by default for a less cluttered view
-
-Added a simple user debug command to capture all logs
-
-Improved debug logging when loading traces
+Improved checking of analysis files when loading
 
 
 *** Major Fixes ***
 
-Fixed loading of synthetic channel files for AC PAM
-
-Fixed failure to calculate statistics for very short regions
-
-Fixed issue where stream start could take a second or so to begin showing data
+Fixed issues with window resizing on multiple monitors
 
-Fixed bug where QIS debug logging did not work to console
+Improved thread cycling which reduced performance
 
-Fixed bug where sparse user channels did not always export correctly to CSV
+Fixed duplicate logging lines

quarchpy/connection_specific/connection_QPS.py

@@ -200,11 +200,12 @@ class QpsInterface:
 
         """
         #print("Open recording at file : \""+str(file_path)+"\"")
-        self.sendCmdVerbose("$open recording qpsFile=\""+str(file_path)+"\"",timeout=cmdTimeout)
+        notLoadingMessageStartTime=None
         loadingStarted=False
         message=""
-        startTime=time.time()
-        notLoadingMessageStartTime=None
+
+        openResponse = self.sendCmdVerbose("$open recording qpsFile=\""+str(file_path)+"\"",timeout=cmdTimeout)
+        #print(openResponse)
         while(1):
             update=self.sendCmdVerbose("$progress check task=\"open recording\"",timeout=cmdTimeout)
             #print(update)
@@ -216,6 +217,9 @@ class QpsInterface:
                 if found > 99.9: # This will catch the case we have 99.9999% or 100% loaded. recording with less that 1mill records auto return 100%
                     message = "Passed, Recording opened, loading detected and complete."
                     break
+            elif "Initialising main chart" in update:
+                loadingStarted = True
+                user_interface.progressBar(found, 100)
             elif "Chart window is open but no loading is in progress." in update:
                 if loadingStarted == True:
                     # Loading started and has now ended, so we can exit the loop.

quarchpy/connection_specific/connection_QPS.py.bak

@@ -0,0 +1,242 @@
+import sys
+import socket
+import time
+import datetime
+import subprocess
+import os
+import random
+import logging
+import time
+import re
+from quarchpy.user_interface import user_interface
+
+class QpsInterface:
+    def __init__(self, host='127.0.0.1', port=9822):
+        self.host = host
+        self.port = port
+        
+        self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.client.settimeout(5)
+        self.client.connect((host, port))
+
+        self.client.settimeout(None)
+        time.sleep(1)
+        self.recv()
+        time.sleep(1)
+
+        # Not blocking qps socket so scripts can continue if no read - 22/06
+        self.client.setblocking(False)
+
+
+    def recv(self):
+        try:
+            if sys.hexversion >= 0x03000000:
+                response = self.client.recv(4096)
+                i = 0
+                for b in response:                                          # end buffer on first \0 character/value
+                    if b > 0:
+                        i += 1
+                    else:
+                        break;
+
+                return response[:i].decode('utf-8', "ignore")
+            else:
+                return self.client.recv(4096)
+        except Exception as e:
+            # Catching socket timeout caused from non blocking socket
+            return ""
+
+
+    def send(self, data):
+        if sys.hexversion >= 0x03000000:
+            self.client.send( data.encode() )
+        else:
+            self.client.send( data )
+
+    def sendCommand(self, cmd, timeout=20, expectedResponse=True ):
+        cmd = cmd + "\r\n"
+        logging.debug("Sending cmd to QPS: " + str(cmd))
+        self.send(cmd)
+
+        start = time.time()
+        response = self.recv().strip()
+        while response.rfind('\r\n>') == -1:  # If true then the resposnse is large and multi packeted
+            time.sleep(0.1)
+            t_response = self.recv().strip()
+            # Add current response to new response
+            response += t_response
+            # Keep reading from the socket if there's stuff that was retreived
+            if len(str(t_response)) == 0:
+                if time.time() - start > timeout:
+                    logging.warning("Command : " + str(cmd) + " Hit timeout during QPS read. timeout = " + str(timeout))
+                    break
+
+        pos = response.rfind('\r\n>')
+        if pos == -1:
+            logging.warning("Did not retrieve trailing '\\r\\n>' from QPS read, returned full response so far")
+            logging.warning("command : " + cmd.replace('\r\n', '\\r\\n'))
+            logging.warning("returned : " + response.replace('\r\n', '\\r\\n'))
+            pos = len(str(response))
+        return response[:pos]
+
+    def sendCmdVerbose(self, cmd, timeout=20):
+        cmd = cmd + "\r\n"
+        logging.debug("Sending cmd to QPS: "+str(cmd))
+        self.send(cmd)
+
+        start = time.time()
+        response = self.recv().strip()
+        while response.rfind('\r\n>') == -1: #If true then the resposnse is large and multi packeted
+            time.sleep(0.1)
+            t_response = self.recv().strip()
+            # Add current response to new response
+            response += t_response
+            # Keep reading from the socket if there's stuff that was retreived
+            if len(str(t_response)) == 0:
+                if time.time() - start > timeout:
+                    logging.warning("Command : "+str(cmd)+ " Hit timeout during QPS read. timeout = " +str(timeout))
+                    break
+
+        pos = response.rfind('\r\n>')
+        if pos == -1:
+            logging.warning("Did not retrieve trailing '\\r\\n>' from QPS read, returned full response so far")
+            logging.warning("command : " + cmd.replace('\r\n','\\r\\n'))
+            logging.warning("returned : " + response.replace('\r\n','\\r\\n'))
+            pos = len(str(response))
+        return response[:pos]
+
+
+    def connect(self, targetDevice):
+        cmd="$connect " + targetDevice
+        retVal = self.sendCmdVerbose(cmd)
+        time.sleep(0.3)
+        return retVal
+
+
+    def disconnect(self, targetDevice):
+        self.sendCmdVerbose("$disconnect")
+
+    def closeConnection(self, conString=None):
+        if conString is None:
+           return self.sendCmdVerbose("close")
+        else:
+            return self.sendCmdVerbose(conString+" close")
+    def scanIP(self, ipAddress, sleep=10):
+        """
+        Triggers QPS to look at a specific IP address for a quarch module
+
+        Parameters
+        ----------
+        QpsConnection : QpsInterface
+            The interface to the instance of QPS you would like to use for the scan.
+        ipAddress : str
+            The IP address of the module you are looking for eg '192.168.123.123'
+        sleep : int, optional
+            This optional variable sleeps to allow the network to scan for the module before allowing new commands to be sent to QPS.
+        """
+        ipAddress = "TCP::" + ipAddress
+
+        self.send("$scan " + ipAddress)
+        # logging.debug("Starting QPS IP Address Lookup")
+        time.sleep(
+            sleep)  # Time must be allowed for QPS to Scan. If another scan request is sent it will time out and throw an error.
+
+    def get_list_details(self, sock=None):
+        if sock == None:
+            sock = self.sock
+        devString = self.sendCmdVerbose("$module list details")
+        #devString = self.sendAndReceiveText(sock, '$list details')
+        devString = devString.replace('>', '')
+        devString = devString.replace(r'\d+\) ', '')
+        devString = devString.split('\r\n')
+        devString = [x for x in devString if x]  # remove empty elements
+        return devString
+
+    def getDeviceList(self, scan = True, ipAddress = None):
+        deviceList = []
+        scanWait = 2
+        foundDevices = "1"
+        foundDevices2 = "2"
+        if scan:
+            if ipAddress == None:
+                devString = self.sendCmdVerbose('$scan')
+            else:
+                devString = self.sendCmdVerbose('$module scan tcp::' + ipAddress)
+            time.sleep(scanWait)
+            while foundDevices not in foundDevices2:
+                foundDevices = self.sendCmdVerbose('$list')
+                time.sleep(scanWait)
+                foundDevices2 = self.sendCmdVerbose('$list')
+        else:
+            foundDevices = self.sendCmdVerbose('$list')
+
+        response = self.sendCmdVerbose( "$list" )
+
+        time.sleep(2)
+
+        response2 = self.sendCmdVerbose( "$list" )
+
+        while (response != response2):
+            response = response2
+            response2 = self.sendCmdVerbose( "$list" )
+            time.sleep(1)
+        if "no device" in response.lower() or "no module" in response.lower():
+            return [response.strip()]
+        #check if a response was received and the first char was a digit
+        if( len(response) > 0 and response[0].isdigit ):
+            sa = response.split()
+            for s in sa:
+                #checks for invalid chars
+                if( ")" not in s and ">" not in s ):
+                    #append to list if conditions met
+                    deviceList.append( s )
+
+        #return list of devices
+        return deviceList
+
+
+    def open_recording(self, file_path, cmdTimeout=5, pollInterval=3, startOpenTimout=5):
+        """
+
+        """
+        #print("Open recording at file : \""+str(file_path)+"\"")
+        notLoadingMessageStartTime=None
+        loadingStarted=False
+        message=""
+
+        openResponse = self.sendCmdVerbose("$open recording qpsFile=\""+str(file_path)+"\"",timeout=cmdTimeout)
+        print(openResponse)
+        while(1):
+            update=self.sendCmdVerbose("$progress check task=\"open recording\"",timeout=cmdTimeout)
+            #print(update)
+            m = re.search(r'\d+(\.\d+)?%', update)
+            if m: # A percentage was found
+                loadingStarted=True
+                found = float(m.group(0)[:-1])
+                user_interface.progressBar(found,100)
+                if found > 99.9: # This will catch the case we have 99.9999% or 100% loaded. recording with less that 1mill records auto return 100%
+                    message = "Passed, Recording opened, loading detected and complete."
+                    break
+            elif "Initialising main chart" in update:
+                loadingStarted = True
+                user_interface.progressBar(found, 100)
+            elif "Chart window is open but no loading is in progress." in update:
+                if loadingStarted == True:
+                    # Loading started and has now ended, so we can exit the loop.
+                    message="Passed, Recording opened, loading detected and complete."
+                    break
+                else: # QPS has not started loading a recording.
+                    if notLoadingMessageStartTime == None:
+                        # Start a timer from now so that if loading doesn't take place between now and a timeout value,
+                        # we exit, stating that no loading started within the desired time.
+                        notLoadingMessageStartTime = time.time()
+                    elif time.time() - notLoadingMessageStartTime> startOpenTimout:
+                        message = "No detection that QPS started loading the recording within " + str(startOpenTimout) + "s."
+                        break
+
+            time.sleep(pollInterval) #Sleep pollInterval time, so we are not hammering QPS for updates while its busy loading.
+        time.sleep(1) #sleep outside the loop as there is a
+        return message
+
+
+    

quarchpy/docs/CHANGES.rst

@@ -14,6 +14,23 @@ Change Log
 ----------
 
 
+2.2.6
+-----
+- New QPS 1.45 and QIS 1.47
+
+2.2.5
+-----
+- Minor Bug fix and removal of redundant jar
+
+2.2.4
+-----
+- Update to Java libraries to run QPS
+- Removal of depracated libs saveing space
+
+2.2.3
+-----
+- Minor bug fix
+
 2.2.2
 -----
 - New QPS 1.44 and QIS 1.46

quarchpy/docs/_build/html/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
-# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 728531a2223f2f7123e8b75a57668a42
+# This file records the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 110145e8a0549736b0b782ab1449dcb9
 tags: 645f666f9bcd5a90fca523b33c5a78b7

quarchpy/docs/_build/html/.buildinfo.bak

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 728531a2223f2f7123e8b75a57668a42
+tags: 645f666f9bcd5a90fca523b33c5a78b7