new nsett

def test(hostname='localhost', do_quit='no'):

    """ test driver"""

    _l = setup_logger(loglevel=logging.DEBUG, filename='nsett.log')

    _l = setup_logger(loglevel=logging.DEBUG, filename='nsett.log', console=False)

    ns = NseConnection(verbose=True, wait_callback=wait_callback)

    try:

        ns.connect(hostname)

    ns.send('listcoil'   )

    ns.clear() # clear resp queue

    res = {}

    ns.send('out current'   )

    print(ns.pop())

    #res['currents'] = parse_out(ns.pop())

    ns.send('out motor'   )

    print(ns.pop())

    #res['motors'] = parse_out(ns.pop())

    #print(json.dumps(res, indent=4))

    if do_quit == "quit":

        ns.send('quit', timeout=None)

"""

import sys

__version__  = "2.0"

__release__  = "b1"

__date__     = "Dec 20, 2024"

__release__  = "b2"

__date__     = "Jan 21, 2025"

def version(full=False):

    "get pysen version number"

import struct

import threading

import logging

import argparse

from   collections import deque

from ..iostrings import encode, decode

from ..misc import setup_logger_detail as setup_logger

def setup_logger(loglevel=logging.WARNING, filename=None, console=False):

    "setup logger"

    log_format=r'%(message)s'

    if loglevel<logging.INFO or filename is not None:

        log_format=r'%(levelname)s: %(funcName)s: %(message)s'

    logging.basicConfig(filename=filename, level=loglevel, format=log_format)

    log = logging.getLogger()

    if console: # logging to console

        tty  = logging.StreamHandler()

        form = logging.Formatter('%(message)s')

        tty.setLevel(logging.DEBUG)

        tty.setFormatter(form)

        log.addHandler(tty)

    return log

class NseConnection:

    """nse control program connection

    more description:

    nsett python equivalent

    """

        # wait for receving 'ack' from the server

        result = wait_loop(self._sock.recv   , self.CMD_LEN)

        # append ack result

        self._reply.append(decode(result, encoding='ascii'))

        self._reply.append(self.decode(result))

        # start receiving thread

        self._sock.send(encode(self._mode))

        self._sock.send(self.encode(self._mode))

        self._thread = self.start()

        time.sleep(0.1) # FIXME: hardcoded sleep time

        time.sleep(0.1) # FIXME (hardcoded sleep)

        self.send(f'say remote connection from "{self.id}"')

        self._connected = True

        #self._busy = True

        if self._verbose:

            print("---> " + messg, end='')

        self._sock.send(self._pid_s+encode(messg, encoding='ascii', errors='ignore'))

        self._sock.send(self._pid_s+self.encode(messg))

        if timeout:

            self.wait(timeout=timeout)

            self.wait_for_response(timeout=timeout)

    def pop(self):

        "return last response"

        "clear the response"

        return self._reply.clear()

    def wait(self, sleep_time=1, timeout=DEF_TIMEOUT):

    def wait_for_response(self, sleep_time=1, timeout=DEF_TIMEOUT):

        "wait for the server to respond"

        t0=time.time()

        dt=0

            try:

                msg = self._sock.recv(self.CMD_LEN)

                self._thread_busy.set() #

                msg = decode(msg, encoding='ascii', errors='replace')

                self.log.debug(msg)

                msg = self.decode(msg)

                self.log.debug(msg.strip())

                lines = msg.split('\n')

                for line in lines:

                    if not line:

                        self._thread_busy.clear()

                    elif response:

                        response.append(line)

            except (TimeoutError, socket.timeout):

                pass # ignore timeout error - wait for another one

            except (TimeoutError, socket.timeout):# as err:

                pass # ignore timeout error - wait for message

            except UnicodeDecodeError as err:

                self.log.error(err) #'%s' % str(err))

                self.log.error(err)

            except OSError as err:

                self.log.error(err) #'%s' % err)

                self._connected = False

                self.log.error(err)

                break

        self._connected = False

        self._thread_busy.clear()

        self.log.info('receive thread is finished')

def _test(hostname):

    "test function"

    setup_logger(level=logging.ERROR, filename='nsett.log')

    def wait(self):

        "run nsett - wait for thread to finish"

        self._thread.join()

    @staticmethod

    def decode(barray, errors='ignore'):

        "decode bytearray to strings"

        return barray.decode(encoding='ascii', errors=errors)

    @staticmethod

    def encode(string, errors='ignore'):

        "encode strings to bytearray"

        return string.encode(encoding='ascii', errors=errors)

def main():

    "main program (listener)"

    parser = argparse.ArgumentParser()

    parser.set_defaults(hostname='localhost', wait=False, logfile='nsett.log', command=None)

    parser.add_argument("hostname", nargs='?', help="set the hostname default is '%(default)s'")

    parser.add_argument("-w", "--wait", action='store_true', help="wait until Ctrl-C")

    parser.add_argument("-c", "--command", help="send command")

    parser.add_argument("--logfile", help="set log file name default is '%(default)s'")

    args = parser.parse_args()

    _log = setup_logger(loglevel=logging.DEBUG, filename=args.logfile, console=True)

    ns = NseConnection(verbose=False)

    ns.connect(hostname)

    ns.send('testmode on')

    ns.send('tau 1e-9')

    print(ns.pop())

    ns.connect(args.hostname)

    try:

        if args.command:

            ns.send(args.command)

        if args.wait:

            ns.wait()

    except KeyboardInterrupt:

        pass

    finally:

        ns.disconnect()

if __name__ == "__main__":

    _test('localhost')

    main()