quarchpy 2.1.11.dev4__py3-none-any.whl → 2.2.17.dev1__py3-none-any.whl

quarchpy/connection_specific/connection_QPS.py

@@ -6,8 +6,10 @@ import subprocess
 import os
 import random
 import logging
+logger = logging.getLogger(__name__)
 import time
-
+import re
+from quarchpy.user_interface import user_interface
 
 class QpsInterface:
     def __init__(self, host='127.0.0.1', port=9822):
@@ -52,10 +54,35 @@ class QpsInterface:
         else:
             self.client.send( data )
 
-
-    def sendCmdVerbose(self, cmd, timeout=300):
+    def sendCommand(self, cmd, timeout=20, expectedResponse=True ):
         cmd = cmd + "\r\n"
+        logger.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:
+                    logger.warning("Command : " + str(cmd) + " Hit timeout during QPS read. timeout = " + str(timeout))
+                    break
+
+        pos = response.rfind('\r\n>')
+        if pos == -1:
+            logger.warning("Did not retrieve trailing '\\r\\n>' from QPS read, returned full response so far")
+            logger.warning("command : " + cmd.replace('\r\n', '\\r\\n'))
+            logger.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"
+        logger.debug("Sending cmd to QPS: "+str(cmd))
         self.send(cmd)
 
         start = time.time()
@@ -68,14 +95,14 @@ class QpsInterface:
             # 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))
+                    logger.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'))
+            logger.warning("Did not retrieve trailing '\\r\\n>' from QPS read, returned full response so far")
+            logger.warning("command : " + cmd.replace('\r\n','\\r\\n'))
+            logger.warning("returned : " + response.replace('\r\n','\\r\\n'))
             pos = len(str(response))
         return response[:pos]
 
@@ -83,7 +110,6 @@ class QpsInterface:
     def connect(self, targetDevice):
         cmd="$connect " + targetDevice
         retVal = self.sendCmdVerbose(cmd)
-        #print(cmd+" : "+retVal)
         time.sleep(0.3)
         return retVal
 
@@ -112,17 +138,31 @@ class QpsInterface:
         ipAddress = "TCP::" + ipAddress
 
         self.send("$scan " + ipAddress)
-        # logging.debug("Starting QPS IP Address Lookup")
+        # logger.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 getDeviceList(self, scan = True):
+    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:
-            devString = self.sendCmdVerbose('$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')
@@ -155,4 +195,49 @@ class QpsInterface:
         #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/connection_specific/connection_ReST.py

@@ -1,3 +1,7 @@
+import socket
+import logging
+logger = logging.getLogger(__name__)
+from time import time
 try:
     import httplib as httplib
 except ImportError:
@@ -13,20 +17,29 @@ class ReSTConn:
     def close(self):
         return True
 
-    def sendCommand(self, Command, expectedResponse = True):
+    def sendCommand(self, Command, expectedResponse = True, max_retries=2):
         Command = "/" + Command.replace(" ", "%20")
-        self.Connection.request("GET", Command)
-        if expectedResponse == True:
-            R2 = self.Connection.getresponse()
-            if R2.status == 200:
-                Result = R2.read()
-                Result = Result.decode()
-                Result = Result.strip('> \t\n\r')
-                self.Connection.close()
-                return Result
-            else:
-                print ("FAIL - Please power cycle the module!")
-                self.Connection.close()
-                return "FAIL: ", R1.status, R1.reason
-        else:
-            return None
+        for attempt in range(0, max_retries ):
+            try:
+                self.Connection.request("GET", Command)
+                if expectedResponse == True:
+                    R2 = self.Connection.getresponse()
+                    if R2.status == 200:
+                        Result = R2.read()
+                        Result = Result.decode()
+                        Result = Result.strip('> \t\n\r')
+                        self.Connection.close()
+                        return Result
+                    else:
+                        logger.error("FAIL - Please power cycle the module!")
+                        self.Connection.close()
+                        return "FAIL: ", R1.status, R1.reason
+                else:
+                    return None
+            except socket.timeout as e:
+                if attempt < max_retries:
+                    logger.warning("Socket timed out, retrying command...")
+                    time.sleep(0.1)
+                else:
+                    logger.error("Maximum number of retries reached on module at: "+self.ConnTarget+". Exiting.")
+                    raise e

quarchpy/connection_specific/connection_TCP.py

@@ -14,7 +14,7 @@ class TCPConn:
         self.Connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         #Sets buffer size
         self.BufferSize = 4096
-        #Opens the ocnnection
+        #Opens the connection
         self.Connection.connect((self.ConnTarget, TCP_PORT))
 
     def close(self):

quarchpy/connection_specific/connection_Telnet.py

@@ -1,15 +1,21 @@
-import telnetlib
+from telnetlib import Telnet
 import time
+#from telnetlib3 import Telnet
+
 
 class TelnetConn:
     def __init__(self, ConnTarget):
         self.ConnTarget = ConnTarget
-        self.Connection = telnetlib.Telnet(self.ConnTarget)
+        self.Connection = Telnet(self.ConnTarget)
         time.sleep(1)
         self.Connection.read_very_eager()
 
     def close(self):
         self.Connection.close()
+        # The closed device reports as in use if a connection is opened to it within 0.05s.
+        # This happens during scanning as rest detects the device and shows it as "in use" Putting a sleep here
+        #  allows time for the connection to be close,
+        time.sleep(0.15)
         return True
 
     def sendCommand(self, Command, expectedResponse = True):

quarchpy/connection_specific/connection_USB.py

@@ -4,6 +4,7 @@ import time
 import os
 import sys
 import logging
+logger = logging.getLogger(__name__)
 import platform
 import inspect
 import ctypes
@@ -104,7 +105,7 @@ def USB(SerID = ''):
 
     if quarchDevice == None:
         if SerID.lower() != "list":
-            logging.critical('Quarch device ' + SerID + ' not found!')
+            logger.critical('Quarch device ' + SerID + ' not found!')
         return None
     else:
         QquarchDevice = TQuarchUSB_IF( context )
@@ -218,18 +219,18 @@ class TQuarchUSB_IF:
         try:
             self.Manufacturer = self.connection.getManufacturer()
         except Exception as e:
-            logging.debug(e)
+            logger.debug(e)
             self.Manufacturer = "Error"
 
         try:
             self.Product = self.connection.getProduct()
         except Exception as e:
-            logging.debug(e)
+            logger.debug(e)
             self.Product = "Error"
         try:
             self.SerialNumber = self.connection.getSerialNumber()
         except Exception as e:
-            logging.debug(e)
+            logger.debug(e)
             self.SerialNumber = "Error"
         self.VenderId = self.connection.device_descriptor.idVendor
         self.ProductId = self.connection.device_descriptor.idProduct
@@ -371,7 +372,7 @@ class TQuarchUSB_IF:
 
     def SendCommand( self, command ):
         if self.isOpen == 0:
-            logging.debug(os.path.basename(__file__) + ".SendCommand: Device is not open, cannot send!")
+            logger.debug(os.path.basename(__file__) + ".SendCommand: Device is not open, cannot send!")
             self.lastError = 'RunCommand: Device Not Open'
             return -1
         try:
@@ -382,14 +383,14 @@ class TQuarchUSB_IF:
                 self.lastWriteByteCount = self.deviceHandle.bulkWrite( endpoint= self.QCmdEP, data= command + pad, timeout=self.timeout )
             return self.lastWriteByteCount
         except:
-            logging.error(os.path.basename(__file__) + ".SendCommand: Exception during bulkWrite process")
+            logger.error(os.path.basename(__file__) + ".SendCommand: Exception during bulkWrite process")
             return -1
 
     def BulkReadEPTout( self, ep, n, timeOut ):
         try:
             return self.deviceHandle.bulkRead( ep, n, timeOut )
         except:
-            logging.error(os.path.basename(__file__) + ".BulkReadEPTout: Exception during bulkRead process")
+            logger.error(os.path.basename(__file__) + ".BulkReadEPTout: Exception during bulkRead process")
             return ''
 
     def BulkReadEP( self, ep, n ):
@@ -473,7 +474,7 @@ class TQuarchUSB_IF:
                 retLineStr = self.deviceHandle.bulkRead( self.QCmdEP, self.QCmdEPSize, timeout )
             # Exception can be due to device connection lost, or a temporary glitch that we can recover from
             except Exception as ex:
-                logging.error(os.path.basename(__file__) + ".FetchCmdReplyTOut: bulkRead exception (" + str(ex) + ") during response read: " + response)
+                logger.error(os.path.basename(__file__) + ".FetchCmdReplyTOut: bulkRead exception (" + str(ex) + ") during response read: " + response)
                 
                 # Run a cleanup process and see if we can recover the response
                 flushed_response = self.clean_and_flush_stuck_usb_comms ()
@@ -512,10 +513,10 @@ class TQuarchUSB_IF:
         # Transmit the command
         length = self.SendCommand( command )
         if  length == -1:
-            logging.error(os.path.basename(__file__) + ".RunCommand: SendCommand failed for command: " + command)
+            logger.error(os.path.basename(__file__) + ".RunCommand: SendCommand failed for command: " + command)
             return ''
         elif (length != 64):
-            logging.error(os.path.basename(__file__) + ".RunCommand: Unexpected number of bytes reported as sent")
+            logger.error(os.path.basename(__file__) + ".RunCommand: Unexpected number of bytes reported as sent")
 
         if expectedResponse:
             # Read all the data back
@@ -548,7 +549,6 @@ class TQuarchUSB_IF:
     def GetLastError(self):
         return self.lastError
 
-
     #
     # Helper to return serial number
     #
@@ -585,9 +585,8 @@ class TQuarchUSB_IF:
                 
         return retString
 
-
     def DebugDump( self ):
-        if self.connection == None:
+        if self.connection is None:
             self.lastError = 'DebugDump: device Not Assigned'
             return 0
 

quarchpy/connection_specific/jdk_jres/fix_permissions.py

@@ -0,0 +1,60 @@
+import os
+import subprocess
+import platform
+
+import quarchpy_binaries
+
+
+def main():
+
+    # Check the current OS
+    current_os = platform.system()
+    if current_os != "Windows":
+        print("Fixing Permissions")
+        # Check the current OS
+        current_os = platform.system()
+        # JRE path
+        java_path = quarchpy_binaries.get_jre_home()
+    
+        # Ensure the jres folder has the required permissions
+        subprocess.call(['chmod', '-R', '+rwx', java_path])
+
+
+def find_java_permissions():
+    # Check the current OS
+    current_os = platform.system()
+    # JRE path
+    java_path = quarchpy_binaries.get_jre_home()
+
+    # OS dependency
+    if current_os in "Windows":
+        java_path = os.path.join(java_path,"bin","java.exe")
+    elif current_os in "Linux":
+        java_path = java_path + "/bin/java"
+    elif current_os in "Darwin":
+        java_path = java_path + "/bin/java"
+    else:  # default to windows
+        java_path = java_path + "\\bin\\java"
+
+    # Get the file status
+    st = os.stat(java_path)
+    # Extract the file permissions from the file status
+    permissions = st.st_mode
+    # Convert the file permissions to octal representation
+    permissions_octal = oct(permissions)
+    # Print the octal representation of the file permissions
+    message=("Permissions of file at {}: {}".format(java_path, permissions_octal))
+
+    execute_permissions = True
+    if int(permissions_octal[-3]) % 2 ==0:
+        execute_permissions = False
+    if int(permissions_octal[-2]) % 2 ==0:
+        execute_permissions = False
+    if int(permissions_octal[-1]) % 2 ==0:
+        execute_permissions = False
+
+    return execute_permissions, message
+
+
+if __name__ == "__main__":
+    main()

quarchpy/connection_specific/mDNS.py

@@ -0,0 +1,139 @@
+import platform  # For getting the operating system name
+import subprocess  # For executing a shell command
+import logging
+logger = logging.getLogger(__name__)
+from zeroconf import Zeroconf
+
+
+def ping(host):
+    """
+    Returns True if host (str) responds to a ping request.
+    """
+    # Option for the number of packets as a function of
+    param = '-n' if platform.system().lower() == 'windows' else '-c'
+
+    # Building the command. Ex: "ping -c 1 google.com"
+    command = ['ping', param, '1', host]
+
+    # Execute the ping command and capture the output and return code
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+    # Check the return code and output to determine the result
+    if result.returncode == 0 and ("destination host unreachable" not in str(result.stdout).lower()):
+        return True  # Ping successful
+    else:
+        return False  # Ping failed
+
+
+class MyListener:
+    """
+    MyListener class to handle service updates, removals, and additions in Zeroconf
+    """
+
+    _instance = None
+
+    @classmethod
+    def get_instance(cls):
+        """
+        Get an instance of MyListener class. If none exists, create one.
+        """
+        if cls._instance is None:
+            cls._instance = MyListener()
+        return cls._instance
+
+    def __init__(self):
+        """
+        Initialize MyListener instance.
+        """
+        self.found_devices = {}
+        self.mdns_service_running = False
+        self.zeroconf = None
+        self.target_conn = None
+
+    def update_service(self, zc, type_, name):
+        """
+        Handle service update event.
+        """
+        info = zc.get_service_info(type_, name)
+        if "Quarch:" in str(info):
+            # decode the incoming properties from mdns
+            decoded_properties = {key.decode('utf-8'): value.decode('utf-8') for key, value in info.properties.items()}
+            decoded_ip = ".".join(str(byte) for byte in info.addresses[0])
+            self.get_instance().add_device(decoded_properties, decoded_ip)
+
+    def remove_service(self, zc, type_, name):
+        """
+        Handle service removal event.
+        """
+        return None
+
+    def add_service(self, zc, type_, name):
+        """
+        Handle service addition event.
+        """
+        logger.debug("Adding service: " + name)
+        info = zc.get_service_info(type_, name)
+        # Log the service name
+        if "Quarch:" in str(info):
+            # decode the incoming properties from mdns
+            decoded_properties ={}
+            for key, value in info.properties.items():
+                decoded_properties[ key.decode('utf-8')]=value.decode('utf-8')
+                pass
+            #decoded_properties = {key.decode('utf-8'): value.decode('utf-8') for key, value in info.properties.items()}
+            decoded_ip = ".".join(str(byte) for byte in info.addresses[0])
+            self.get_instance().add_device(decoded_properties, decoded_ip)
+
+    def add_device(self, properties_dict, ip_address):
+        """
+        Add a device to the found devices dictionary.
+        """
+        logger.debug("Adding device: " +str(ip_address)+"\n"+str(properties_dict))
+        qtl_num = "QTL" + properties_dict['86'] if '86' in properties_dict else None
+        # Check if module contains REST connection
+        if '84' in properties_dict:
+            # Check the user specified connection type
+            if self.get_instance().target_conn == "all" or self.get_instance().target_conn == "rest":
+                if properties_dict['84'] == '80':
+                    # print("Rest connection exists for device: " + qtl_num)
+                    # Updates the found devices dict
+                    self.get_instance().update_device_dict(device_dict={"REST:" + ip_address: qtl_num})
+        # Check if module contains TCP connection
+        if '85' in properties_dict:
+            # Check the user specified connection type
+            if self.get_instance().target_conn == "all" or self.get_instance().target_conn == "tcp":
+                if properties_dict['85'] == "9760":
+                    # print("TCP connection exists for device: " + qtl_num)
+                    # Updates the found devices dict
+                    self.get_instance().update_device_dict(device_dict={"TCP:" + ip_address: qtl_num})
+
+    def update_device_dict(self, device_dict):
+        """
+        Update the found devices dictionary.
+        """
+        self.get_instance().found_devices.update(device_dict)
+
+    def get_found_devices(self):
+        """
+        Get the found devices and perform ping check.
+        """
+        temp_dict = self.get_instance().found_devices
+        remove_device = False
+        for key, value in list(temp_dict.items()):
+            can_ping = ping(key[key.index(":") + 1:])
+            if not can_ping:
+                remove_device=True # Remove the device if it can't be pinged
+            elif self.get_instance().target_conn not in key.lower() and self.get_instance().target_conn.lower() != "all":
+                remove_device = True # or if its of the wrong connection type.
+            if remove_device:
+                del self.get_instance().found_devices[key]
+        logger.debug("Returning found devices "+str(self.get_instance().found_devices))
+        return self.get_instance().found_devices
+
+    def get_zeroconf(self):
+        """
+        Get the Zeroconf instance. If none exists, create one.
+        """
+        if self.get_instance().zeroconf is None:
+            self.get_instance().zeroconf = Zeroconf()
+        return self.get_instance().zeroconf

quarchpy/connection_specific/serial/rfc2217.py

@@ -9,7 +9,7 @@
 #
 # SPDX-License-Identifier:    BSD-3-Clause
 
-# TODO:
+
 # - setting control line -> answer is not checked (had problems with one of the
 #   severs). consider implementing a compatibility mode flag to make check
 #   conditional
@@ -59,6 +59,7 @@
 # the order of the options is not relevant
 
 import logging
+logger = logging.getLogger(__name__)
 import socket
 import struct
 import threading
@@ -570,7 +571,6 @@ class Serial(SerialBase):
             # process options now, directly altering self
             for option, values in urlparse.parse_qs(parts.query, True).items():
                 if option == 'logging':
-                    logging.basicConfig()   # XXX is that good to call it here?
                     self.logger = logging.getLogger('pySerial.rfc2217')
                     self.logger.setLevel(LOGGER_LEVELS[values[0]])
                     self.logger.debug('enabled logging')

quarchpy/connection_specific/serial/tools/list_ports_common.py

@@ -103,7 +103,4 @@ def list_links(devices):
             links.append(device)
     return links
 
-# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-# test
-if __name__ == '__main__':
-    print(ListPortInfo('dummy'))
+

quarchpy/connection_specific/serial/tools/list_ports_linux.py

@@ -98,9 +98,3 @@ def comports(include_links=False):
     return [info
             for info in [SysFS(d) for d in devices]
             if info.subsystem != "platform"]    # hide non-present internal serial ports
-
-# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-# test
-if __name__ == '__main__':
-    for port, desc, hwid in sorted(comports()):
-        print("{}: {} [{}]".format(port, desc, hwid))

quarchpy/connection_specific/serial/tools/list_ports_osx.py

@@ -137,7 +137,7 @@ def get_int_property(device_type, property, cf_number_type):
 
 
 def IORegistryEntryGetName(device):
-    pathname = ctypes.create_string_buffer(100)  # TODO: Is this ok?
+    pathname = ctypes.create_string_buffer(100)
     iokit.IOObjectGetClass(device, ctypes.byref(pathname))
     return pathname.value
 
@@ -253,8 +253,3 @@ def comports(include_links=False):
                 info.apply_usb_info()
             ports.append(info)
     return ports
-
-# test
-if __name__ == '__main__':
-    for port, desc, hwid in sorted(comports()):
-        print("{}: {} [{}]".format(port, desc, hwid))

quarchpy/connection_specific/serial/tools/list_ports_posix.py

@@ -110,8 +110,3 @@ also add the naming scheme of the serial ports and with a bit luck you can get
 this module running...
 """.format(sys.platform, os.name, serial.VERSION))
     raise ImportError("Sorry: no implementation for your platform ('{}') available".format(os.name))
-
-# test
-if __name__ == '__main__':
-    for port, desc, hwid in sorted(comports()):
-        print("{}: {} [{}]".format(port, desc, hwid))

quarchpy/connection_specific/serial/tools/list_ports_windows.py

@@ -297,9 +297,3 @@ def iterate_comports():
 def comports(include_links=False):
     """Return a list of info objects about serial ports"""
     return list(iterate_comports())
-
-# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-# test
-if __name__ == '__main__':
-    for port, desc, hwid in sorted(comports()):
-        print("{}: {} [{}]".format(port, desc, hwid))

quarchpy/connection_specific/serial/urlhandler/protocol_alt.py

@@ -49,7 +49,3 @@ def serial_class_for_url(url):
         raise ValueError('class {!r} is not an instance of Serial'.format(class_name))
     return (''.join([parts.netloc, parts.path]), cls)
 
-# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-if __name__ == '__main__':
-    s = serial.serial_for_url('alt:///dev/ttyS0?class=PosixPollSerial')
-    print(s)

quarchpy/connection_specific/serial/urlhandler/protocol_hwgrep.py

@@ -82,8 +82,3 @@ class Serial(serial.Serial):
         else:
             raise serial.SerialException('no ports found matching regexp {!r}'.format(url))
 
-# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-if __name__ == '__main__':
-    s = Serial(None)
-    s.port = 'hwgrep://ttyS0'
-    print(s)