quarchpy 2.2.1.dev6__py2.py3-none-any.whl → 2.2.3__py2.py3-none-any.whl

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

@@ -1,41 +1,39 @@
 *** What's New In Quarch Power Studio ***
 
-19th July 2024
+11th November 2024
 
-QPS version 1.42
-QIS version 1.44
+QPS version 1.44
+QIS version 1.46
 
 
 
 *** New Features ***
 
-QPS is now build against Java21.  The runtime is packaged in the installer so seperate Java install is not required in most cases
+Synthetic channels can now be disabled without deleting them (as with instrument channels)
 
-This 'What's new' dialog added, to call out the latest features!
+Added channel options to the CSV export dialog
 
-Annotations improvements: Hover-over displays their text. Hover over the Annotations tab text to highlight the annotation.  Vertical movement is enabled by default, to arrange them more easily
+Improved cursor controls and display
 
-Speed improvements when navigating through large datasets
+Instrument profiles now display their name and description information when loaded
 
-Modules with updated firmware available are now indicated to the user
+Synthetic channel for subtraction added
 
-Missing USB drivers are now highlighted to the user
+Channels can now have visibility disabled by default for a less cluttered view
 
-Statistics tab now has auto-ranging for units, to be more readable
+Added a simple user debug command to capture all logs
 
-The color of cursors can be changed, to make them more visible
-
-Summary data can now be collapsed to make it more readable
+Improved debug logging when loading traces
 
 
 *** Major Fixes ***
 
-Fixed issue where old trace data did not delete correctly
+Fixed loading of synthetic channel files for AC PAM
 
-Fixed issue where LAN devices could lose connection after a couple of hours of streaming
+Fixed failure to calculate statistics for very short regions
 
-Fixed issue where progress bar and notifications were both modal, locking access
+Fixed issue where stream start could take a second or so to begin showing data
 
-Touchpad horizontal two finger scrolling now works correctly
+Fixed bug where QIS debug logging did not work to console
 
-Multiple other exceptions trapped and handled
+Fixed bug where sparse user channels did not always export correctly to CSV

quarchpy/connection_specific/connection_QIS.py

@@ -1100,24 +1100,25 @@ class QisInterface:
         try:
             if sock == None:
                 sock = self.sock
-            
-            # Get the raw data
-            headerData = self.sendAndReceiveText(sock, sentText='stream text header', device=device)
+            count = 0
+            while(True):
+                if count > 5:
+                    break
+                count += 1
+                # Get the raw data
+                headerData = self.sendAndReceiveText(sock, sentText='stream text header', device=device)
 
-            # The XML can contain the cursor on the end!  Trap and remove it here TODO: Needs fixed in the command layer above
-            if ('\r\n>' in headerData):
-                headerData = headerData[:-1]
-            
-            # Check for no header (no stream started)
-            if('Header Not Available' in headerData):
-                logging.error(device + ' Stream header not available.' + self.host + ':' + str(self.port))
-                return None;
-                
-            # Check for XML format
-            if('?xml version=' not in headerData):
-                logging.error(device + ' Header not in XML form.' + self.host + ':' + str(self.port))
-                return None;
-                
+                # Check for no header (no stream started)
+                if('Header Not Available' in headerData):
+                    logging.error(device + ' Stream header not available.' + self.host + ':' + str(self.port))
+                    continue
+
+                # Check for XML format
+                if('?xml version=' not in headerData):
+                    logging.error(device + ' Header not in XML form.' + self.host + ':' + str(self.port))
+                    continue
+
+                break
             # Parse XML into structured format
             xml_root = ET.fromstring(headerData)            
             
@@ -1567,9 +1568,12 @@ class QisInterface:
             res = self.sendAndReceiveText(sock, cmd, device, readUntilCursor)
             if (betweenCommandDelay > 0):
                 time.sleep(betweenCommandDelay)
+
             # If ends with cursor get rid of it
-            if res[-1:] == '>':
-                res = res[:-3]  # remove last three chars - hopefully '\r\n>'
+            if res[-3:] == '\r\n>':
+                res = res[:-3]  # remove last three chars - '\r\n>'
+            elif res[-2:] == '\n>':
+                    res = res[:-2]  # remove last 2 chars - '\n>'
             return res
 
         else :
@@ -1638,15 +1642,42 @@ class QisInterface:
                 logging.warning(res[0])
             # If reading until a cursor comes back then keep reading until a cursor appears or max tries exceeded
             if readUntilCursor:
+                import xml.etree.ElementTree as ET
+
                 maxReads = 1000
                 count = 1
-                # check for cursor at end of read and if not there read again
-                while res[-1:] != self.cursor:
-                    res+= self.receiveText(sock) #TODO Confirm this works with multi response CMD Like a $get stats on a large stream with many annos. test with py2 and py3
-                    #res.extend(self.rxBytes(sock))
+                is_xml = False
+
+                while True:
+
+                    # Determine if the response is XML based on its start
+                    if count == 1:  # Only check this on the first read
+                        if res.startswith("<?xml"):  # Likely XML if it starts with '<'
+                            is_xml = True
+                        elif res.startswith("<XmlResponse"):
+                            is_xml = True
+
+
+                    if is_xml:
+                        # Try to parse the XML to check if it's complete
+                        try:
+                            ET.fromstring(res[:-1])  # If it parses, the response is complete
+                            return res[:-1]  # Exit the loop, valid XML received
+                        except ET.ParseError:
+                            pass  # Keep reading until XML is complete
+                    else:
+                        # Handle normal strings
+                        if res[-1:] == self.cursor:  # If the last character is '>', stop reading
+                            break
+
+                    # Receive more data
+                    res += self.receiveText(sock)
+
+                    # Increment count and check for max reads
                     count += 1
                     if count >= maxReads:
-                        raise Exception(' Count = Error: max reads exceeded before cursor returned')
+                        raise Exception('Count = Error: max reads exceeded before response was complete')
+
             return res
 
         except Exception as e:

quarchpy/debug/simple_terminal.py

@@ -4,7 +4,7 @@ Feel free to expand and add your own features to this.
 
 ########### VERSION HISTORY ###########
 
-26/11/2020 - Stuart Boon     - First Version
+26/11/2020 - Stuart Boon  - First Version
 
 ########### INSTRUCTIONS ###########
 Select the module you would like to talk to.

quarchpy/device/quarchPPM.py

@@ -1,16 +1,22 @@
 from .device import quarchDevice
 import logging
+import xml.etree.ElementTree as ET
 from quarchpy.user_interface.user_interface import printText
 
+
 class quarchPPM(quarchDevice):
-    def __init__(self, originObj):
+    def __init__(self, originObj, skipDefaultSyntheticChannels=False):
 
         self.connectionObj = originObj.connectionObj
         self.ConString = originObj.ConString
         self.ConType = originObj.ConType
+        self.fixture_definition = self.sendCommand("fix:chan:xml?")
+        self.default_channels = None
         numb_colons = self.ConString.count(":")
         if numb_colons == 1:
             self.ConString = self.ConString.replace(':', '::')
+        if not skipDefaultSyntheticChannels and self.ConType[:3].upper() == "QIS":
+            self.create_default_synthetic_channels()
  
     def startStream(self, fileName='streamData.txt', fileMaxMB=200000, streamName ='Stream With No Name', streamDuration = None, streamAverage = None, releaseOnData = False, separator=",", inMemoryData = None):
         return self.connectionObj.qis.startStream(self.ConString, fileName, fileMaxMB, streamName, streamAverage, releaseOnData, separator, streamDuration, inMemoryData)
@@ -27,9 +33,12 @@ class quarchPPM(quarchDevice):
     def waitStop(self):
         return self.connectionObj.qis.waitStop()
 
-    def streamResampleMode(self, streamCom):
+    def streamResampleMode(self, streamCom, group=None):
         if streamCom.lower() == "off" or streamCom[0:-2].isdigit():
-            retVal = self.connectionObj.qis.sendAndReceiveCmd(cmd="stream mode resample " + streamCom.lower(),
+            cmd = "stream mode resample " + streamCom.lower()
+            if group is not None:
+                cmd = "stream mode resample group " + str(group) + " " + streamCom.lower()
+            retVal = self.connectionObj.qis.sendAndReceiveCmd(cmd=cmd,
                                                               device=self.ConString)
             if "fail" in retVal.lower():
                 logging.error(retVal)
@@ -65,3 +74,96 @@ class quarchPPM(quarchDevice):
         if "OFF" in powerState or "PULLED" in powerState:  # PULLED comes from PAM
             # Power Up
             printText("\n Turning the outputs on:"), myModule.sendCommand("run:power up"), "!"
+
+    '''
+    Parses the fixture XML and extracts the synthetic channels specified by the instrument defaults.
+    This function reads the fixture XML structure and looks for channels under the SyntheticChannels node,
+    extracting the relevant information (number, function, enable status, etc.).
+    '''
+
+    def parse_synthetic_channels_from_instrument(self):
+        # Parse the XML data from the fixture_definition (which is an XML string) to get the root element
+        root = ET.fromstring(self.fixture_definition)
+
+        # Initialize an empty list to hold all parsed synthetic channels
+        synthetic_channels = []
+
+        # Loop over each 'Channel' element found within 'SyntheticChannels' in the XML tree
+        for channel in root.findall(".//SyntheticChannels/Channel"):
+            # Extract values of interest from each channel, using XPath queries to find the relevant parameters
+            number = channel.find(".//Param[Name='Number']/Value")
+            function = channel.find(".//Param[Name='Function']/Value")
+            enable = channel.find(".//Param[Name='Enable']/Value")
+            enabled_by_default = channel.find(".//Param[Name='EnabledByDefault']/Value")
+            visible_by_default = channel.find(".//Param[Name='VisibleByDefault']/Value")
+
+            # Convert values from XML to appropriate data types (number is an integer, others are strings or booleans)
+            number = int(number.text) if number is not None else 0
+            function = function.text if function is not None else ""
+            enable = enable.text.lower() == 'true' if enable is not None else False
+            enabled_by_default = enabled_by_default.text.lower() == 'true' if enabled_by_default is not None else False
+            visible_by_default = visible_by_default.text.lower() == 'true' if visible_by_default is not None else False
+
+            # Create an instance of the SyntheticChannel class with the extracted information
+            synthetic_channel = SyntheticChannel(number, function, enable, enabled_by_default, visible_by_default)
+
+            # Append the newly created SyntheticChannel object to the list of channels
+            synthetic_channels.append(synthetic_channel)
+
+        # Return the list of synthetic channels extracted from the XML
+        return synthetic_channels
+
+    '''
+    Sends the set of synthetic channels to the device.
+    This method iterates through the list of synthetic channels and sends the appropriate
+    commands to a QIS/QPS-based device to create the channels. 
+    '''
+
+    def send_synthetic_channels(self, channels):
+        # Loop through each channel in the provided list of channels
+        for channel in channels:
+            # Send a command to the device to create a stream with the channel's function
+            result = self.sendCommand("stream create channel " + channel.function)
+
+            # If the command result is not "OK", raise an exception with an error message
+            if result != "OK":
+                raise Exception(f"Command failed for channel {channel.number}: {channel.function} = {result}")
+
+    '''
+    Creates the default synthetic channels based on the fixture XML.
+    This method first parses the synthetic channels from the instrument and sends them to the device.
+    '''
+
+    def create_default_synthetic_channels(self):
+        # The fixture XML and synthetic channels are only parsed once per connection.
+        # If the fixture is replaced or changed, this info should be refreshed via an API call.
+        # This stores the default channels in the class for later use to avoid re-parsing multiple times.
+        self.default_channels = self.parse_synthetic_channels_from_instrument()
+
+        # Sends the parsed default synthetic channels to the device.
+        # This could be part of the device initialization process, with an option to skip it using a flag.
+        self.send_synthetic_channels(self.default_channels)
+
+        # The following commented-out example shows how to manually send a command for a specific synthetic channel.
+        # Example: This command calculates the RMS current for the neutral line.
+        # self.sendCommand("stream create channel chan(Neutral_RMS,A) rms(100ms,chan(Neutral,A))")
+
+'''
+Class representing a SyntheticChannel.
+Each synthetic channel is characterized by a number, function, enable status, 
+whether it's enabled by default, and whether it's visible by default.
+'''
+
+class SyntheticChannel:
+    def __init__(self, number, function, enable, enabled_by_default, visible_by_default):
+        self.number = number  # The unique number identifier for the synthetic channel
+        self.function = function  # The function or behavior of the channel (e.g., RMS calculation)
+        self.enable = enable  # Whether the channel is currently enabled
+        self.enabled_by_default = enabled_by_default  # Whether the channel is enabled by default
+        self.visible_by_default = visible_by_default  # Whether the channel is visible by default
+
+    def __repr__(self):
+        # Provide a readable string representation of the synthetic channel, useful for debugging or logging
+        return (f"SyntheticChannel(Number={self.number}, Function='{self.function}', "
+                f"Enable={self.enable}, EnabledByDefault={self.enabled_by_default}, "
+                f"VisibleByDefault={self.visible_by_default})")

quarchpy/device/quarchQPS.py

@@ -1,5 +1,4 @@
 from quarchpy.device import quarchDevice
-from quarchpy.qps import toQpsTimeStamp
 from quarchpy.utilities.Version import Version
 from quarchpy.user_interface.user_interface import requestDialog
 import os, time, datetime, sys, logging
@@ -35,7 +34,7 @@ class quarchQPS(quarchDevice):
         directory - str - desired stream dir
         unserInput=True - if a failure occurs userInput=True allows user to rectify problem with user input. set to False if user interaction is not available (automating).
         """
-        time.sleep(1)  # TODO remove this sleep once script->QPS timeing issue resolved. This works fine in the meantime
+        #time.sleep(1)  # TODO remove this sleep once script->QPS timeing issue resolved. This works fine in the meantime
         return quarchStream(self.quarchDevice, directory, unserInput)
 
 
@@ -198,8 +197,9 @@ class quarchStream:
             raise Exception(command_response)
         return (command_response)
 
+
     def addAnnotation(self, title, annotationTime=0, extraText="", yPos="", titleColor="", annotationColor="",
-                      annotationType="", annotationGroup=""):
+                      annotationType="", timeFormat="unix"):
         """
                     Adds a custom annotation to stream with given parameters.
 
@@ -215,9 +215,9 @@ class quarchStream:
                         The color of the text next to the annotation in hex format 000000 to FFFFFF
                     annotationColor : str, optional
                         The color of the annotation marker in hex format 000000 to FFFFFF
-                    annotationGroup : str, optional
-                        The group the annotation belongs to
-                    annotationTime : int, optional
+                    annotationType : str, optional
+                        The group the annotation belongs to, annotation comment or any custom group the user has made.
+                    timeFormat : str, optional
                         The time in milliseconds after the start of the stream at which the annotation should be placed. 0 will plot the annotation live at the most recent sample
 
                     Returns
@@ -226,62 +226,56 @@ class quarchStream:
 
                         The response text from QPS. "ok" if annotation successfully added
             """
-        annotationTime = str(annotationTime)
+
         annotationType = annotationType.lower()
+        annotationTime = str(annotationTime)
+
+        if (annotationTime[0].isalpha() or annotationTime[-1].isalpha()):
+            timeFormat="elapsed"
+            if annotationTime.startswith("e"): #Old format allowed e to be used to pass elapsed time in seconds "e2" -> 2s + elapsed
+                annotationTime=annotationTime[1:]+"s"
+
+        elif annotationTime=="0":
+            annotationTime=current_milli_time()
+            timeFormat="unix"
+
         if annotationType == "" or annotationType == "annotation":
             annotationType = "annotate"
         elif annotationType == "comment":
             pass  # already in the correct format for command
-        else:
-            retString = "Fail annotationType must be 'annotation' or 'comment'"
-            logging.warning(retString)
-            return retString
+        # else: # QPS now supports custom types passed as annotationType rather than annotation group.
+        #     retString = "Fail annotationType must be 'annotation' or 'comment'"
+        #     logging.warning(retString)
+        #     return retString
+
+        title = title.replace("\n", "\\n")
+        cmd="$stream annotation add "+" time="+str(annotationTime)+ " text=\""+title+"\""
+        if extraText!="":
+            extraText = extraText.replace("\n", "\\n")
+            cmd+=" extraText=\"" +str(extraText)+"\""
+        if yPos!= "":
+            cmd+=" yPos="+str(yPos)
+        if type!="":
+            cmd+=" type="+ str(annotationType)
+        if annotationColor!="":
+            cmd+=" colour="+str(annotationColor)
+        if titleColor!="":
+            cmd+=" textColour="+str(titleColor)
+        if timeFormat!="":
+            cmd+=" timeFormat="+str(timeFormat)
+
+        return self.connectionObj.qps.sendCmdVerbose(cmd)
 
-        # If the function has already been passed the XML string to give to QPS
-        if ("<<" in title.replace(" ", "")):
-            annotationString = str(title)
-        else:
-            annotationString = "<"
-
-            if annotationTime == "0":
-                # Use current time
-                annotationTime = qpsNowStr()
-            elif (annotationTime.startswith("e")):
-                pass
-            else:
-                # Convert timestamp to QPS format
-                # annotationTime = toQpsTimeStamp(annotationTime)
-                annotationTime = str(annotationTime)
-
-            if title != "":
-                annotationString += "<text>" + str(title) + "</text>"
-            if extraText != "":
-                annotationString += "<extraText>" + str(extraText) + "</extraText>"
-            if yPos != "":
-                annotationString += "<yPos>" + str(yPos) + "</yPos>"
-            if titleColor != "":
-                annotationString += "<textColor>" + str(titleColor) + "</textColor>"
-            if annotationColor != "":
-                annotationString += "<color>" + str(annotationColor) + "</color>"
-            if annotationGroup != "":
-                annotationString += "<userType>" + str(annotationGroup) + "</userType>"
-            annotationString += ">"
-
-        # command is sent on newline so \n needs to be chnaged to \\n which is changed back just before printing in qps.
-        annotationString = annotationString.replace("\n", "\\n")
-        logging.debug("Time sending to QPS:" + str(annotationTime))
-        return self.connectionObj.qps.sendCmdVerbose(
-            "$" + annotationType + " " + str(annotationTime) + " " + annotationString)
 
     def addComment(self, title, commentTime=0, extraText="", yPos="", titleColor="", commentColor="", annotationType="",
-                   annotationGroup=""):
+                   annotationGroup="", timeFormat="unix"):
         # Comments are just annotations that do not affect the statistics grid.
         # This function was kept to be backwards compatible and is a simple pass through to add annotation.
         if annotationType == "":
             annotationType = "comment"
         return self.addAnnotation(title=title, annotationTime=commentTime, extraText=extraText, yPos=yPos,
                                   titleColor=titleColor, annotationColor=commentColor, annotationType=annotationType,
-                                  annotationGroup=annotationGroup)
+                                  annotationGroup=annotationGroup, timeFormat=timeFormat)
 
     def saveCSV(self, filePath, linesPerFile=None, cr=None, delimiter=None, timeout=60):
         """
@@ -378,7 +372,7 @@ class quarchStream:
         self.hideChannel("smclk:digital")
         self.hideChannel("smdat:digital")
 
-    # function to add a data point the the stream
+    # function to add a data point to the stream
     # time value will default to current time if none passed
     def addDataPoint(self, channelName, groupName, dataValue, dataPointTime=0, timeFormat="unix"):
         '''
@@ -386,13 +380,14 @@ class quarchStream:
         groupName - str
         dataValue - int/float value of the data point
         dataPointTime=0 - time of the data point
-        timeFormat="unix" - the format of the given time
+        timeFormat="unix" - the format of the given time ["elapsed"|"unix"]
         '''
         if dataPointTime == None or dataPointTime == 0:
             dataPointTime = qpsNowStr()
         else:
-            dataPointTime = toQpsTimeStamp(dataPointTime)
-
+            dataPointTime = int(dataPointTime)
+        logging.warning("$stream data add " + channelName + " " + groupName + " " + str(dataPointTime) + " " + str(
+                dataValue) + " " + timeFormat)
         self.connectionObj.qps.sendCmdVerbose(
             "$stream data add " + channelName + " " + groupName + " " + str(dataPointTime) + " " + str(
                 dataValue) + " " + timeFormat)