indipyserver 0.0.1__tar.gz

indipyserver-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 bernie-skipole
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

indipyserver-0.0.1/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: indipyserver
+Version: 0.0.1
+Summary: Server for the INDI protocol.
+Keywords: indi,server,astronomy,instrument,remote,control
+Author-email: Bernard Czenkusz <bernie@skipole.co.uk>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
+License-File: LICENSE
+Project-URL: Documentation, https://indipyserver.readthedocs.io
+Project-URL: Source, https://github.com/bernie-skipole/indipyserver
+
+# indipyserver
+Server for the INDI protocol, written in Python
+
+This package provides an IPyServer class used to serve the INDI protocol on a port.
+
+INDI - Instrument Neutral Distributed Interface.
+
+See https://en.wikipedia.org/wiki/Instrument_Neutral_Distributed_Interface
+
+Drivers controlling instrumentation can be written, typically using the IPyDriver class from the associated indipydriver package, this server opens a port to which an INDI client can connect.
+
+You would create a script something like:
+
+
+    import asyncio
+    from indipyserver import IPyServer
+    import ... your own modules creating driver1, driver2 ...
+
+    server = IPyServer(driver1, driver2, host="localhost", port=7624, maxconnections=5)
+    asyncio.run(server.asyncrun())
+
+A connected client can then control all the drivers. The above illustrates multiple drivers can be served, however it could equally be one or none at all.
+
+
+## Third party drivers
+
+IPyServer can also run third party INDI drivers created with other languages or tools, using an add_exdriver method to include executable drivers.
+
+For example, using drivers available from indilib:
+
+    import asyncio
+    from indipyserver import IPyServer
+
+    server = IPyServer(host="localhost", port=7624, maxconnections=5)
+
+    server.add_exdriver("indi_simulator_telescope")
+    server.add_exdriver("indi_simulator_ccd")
+    asyncio.run(server.asyncrun())
+
+
+Please note: The author has no relationship with indilib, these indipyserver and indipydriver packages are independently developed implementations. However they were developed with reference to the INDI version 1.7 specification, and are intended to interwork with other implementations that also meets that spec.
+
+
+## Networked instruments
+
+IPyServer also has an add_remote method which can be used to add connections to remote servers, creating a tree network of servers:
+
+    import asyncio
+    from indipyserver import IPyServer
+    import ... your own modules creating DriverA, DriverB ...
+
+    server = IPyServer(DriverA, DriverB, host="localhost", port=7624, maxconnections=5)
+
+    server.add_remote(host="nameofserverB", port=7624, blob_enable=True)
+    server.add_remote(host="nameofserverC", port=7624, blob_enable=True)
+
+    asyncio.run(server.asyncrun())
+
+
+![INDI Network](https://github.com/bernie-skipole/indipyserver/raw/main/docs/source/usage/images/rem2.png)
+
+With such a layout, the client can control all the instruments.
+
+Drivers made with indipydriver, third party executable drivers and remote connections can all be served together.
+
+Further documentation can be found at:
+
+https://indipyserver.readthedocs.io/en/latest/index.html
+

indipyserver-0.0.1/README.md

@@ -0,0 +1,68 @@
+# indipyserver
+Server for the INDI protocol, written in Python
+
+This package provides an IPyServer class used to serve the INDI protocol on a port.
+
+INDI - Instrument Neutral Distributed Interface.
+
+See https://en.wikipedia.org/wiki/Instrument_Neutral_Distributed_Interface
+
+Drivers controlling instrumentation can be written, typically using the IPyDriver class from the associated indipydriver package, this server opens a port to which an INDI client can connect.
+
+You would create a script something like:
+
+
+    import asyncio
+    from indipyserver import IPyServer
+    import ... your own modules creating driver1, driver2 ...
+
+    server = IPyServer(driver1, driver2, host="localhost", port=7624, maxconnections=5)
+    asyncio.run(server.asyncrun())
+
+A connected client can then control all the drivers. The above illustrates multiple drivers can be served, however it could equally be one or none at all.
+
+
+## Third party drivers
+
+IPyServer can also run third party INDI drivers created with other languages or tools, using an add_exdriver method to include executable drivers.
+
+For example, using drivers available from indilib:
+
+    import asyncio
+    from indipyserver import IPyServer
+
+    server = IPyServer(host="localhost", port=7624, maxconnections=5)
+
+    server.add_exdriver("indi_simulator_telescope")
+    server.add_exdriver("indi_simulator_ccd")
+    asyncio.run(server.asyncrun())
+
+
+Please note: The author has no relationship with indilib, these indipyserver and indipydriver packages are independently developed implementations. However they were developed with reference to the INDI version 1.7 specification, and are intended to interwork with other implementations that also meets that spec.
+
+
+## Networked instruments
+
+IPyServer also has an add_remote method which can be used to add connections to remote servers, creating a tree network of servers:
+
+    import asyncio
+    from indipyserver import IPyServer
+    import ... your own modules creating DriverA, DriverB ...
+
+    server = IPyServer(DriverA, DriverB, host="localhost", port=7624, maxconnections=5)
+
+    server.add_remote(host="nameofserverB", port=7624, blob_enable=True)
+    server.add_remote(host="nameofserverC", port=7624, blob_enable=True)
+
+    asyncio.run(server.asyncrun())
+
+
+![INDI Network](https://github.com/bernie-skipole/indipyserver/raw/main/docs/source/usage/images/rem2.png)
+
+With such a layout, the client can control all the instruments.
+
+Drivers made with indipydriver, third party executable drivers and remote connections can all be served together.
+
+Further documentation can be found at:
+
+https://indipyserver.readthedocs.io/en/latest/index.html

indipyserver-0.0.1/indipyserver/__init__.py

@@ -0,0 +1,9 @@
+
+import sys
+
+from .ipyserver import IPyServer
+
+if sys.version_info < (3, 11):
+    raise ImportError('indipyserver requires Python >= 3.11')
+
+version = "0.0.1"

indipyserver-0.0.1/indipyserver/exdriver.py

@@ -0,0 +1,314 @@
+
+import asyncio, copy
+
+import xml.etree.ElementTree as ET
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+# All xml data sent from the driver should be contained in one of the following tags
+TAGS = (b'message',
+        b'delProperty',
+        b'defSwitchVector',
+        b'setSwitchVector',
+        b'defLightVector',
+        b'setLightVector',
+        b'defTextVector',
+        b'setTextVector',
+        b'defNumberVector',
+        b'setNumberVector',
+        b'defBLOBVector',
+        b'setBLOBVector',
+        b'getProperties'       # for snooping
+       )
+
+# Note these are strings, as they are used for checking xmldata.tag values
+
+DEFTAGS = ( 'defSwitchVector',
+            'defLightVector',
+            'defTextVector',
+            'defNumberVector',
+            'defBLOBVector'
+          )
+
+
+NEWTAGS = ('newTextVector',
+           'newNumberVector',
+           'newSwitchVector',
+           'newBLOBVector'
+          )
+
+# _STARTTAGS is a tuple of ( b'<defTextVector', ...  ) data received will be tested to start with such a starttag
+_STARTTAGS = tuple(b'<' + tag for tag in TAGS)
+
+# _ENDTAGS is a tuple of ( b'</defTextVector>', ...  ) data received will be tested to end with such an endtag
+_ENDTAGS = tuple(b'</' + tag + b'>' for tag in TAGS)
+
+
+class ExVector:
+
+    def __init__(self, name, deftag):
+        "Object which only holds a name and vectortype"
+        self.name = name
+        self.vectortype = deftag[3:]
+
+
+class ExDriver:
+
+    def __init__(self, program, *args, debug_enable=False):
+        "Executes a third party indi driver, communicates by stdin stdout"
+
+        self.program = program
+        self.args = args
+        self.debug_enable = debug_enable
+        self.proc = None
+
+        # An object for communicating is set when this driver is added to the server
+        self._commsobj = None
+
+        # This dictionary will be populated with devicename:{vectorname:vector}
+        # where vector is an ExVector object
+        self.devicenames = {}
+
+        self.snoopall = False           # gets set to True if it is snooping everything
+        self.snoopdevices = set()       # gets set to a set of device names
+        self.snoopvectors = set()       # gets set to a set of (devicename,vectorname) tuples
+
+        self._remainder = b""    # Used to store intermediate data
+        self._stop = False       # Gets set to True to stop communications
+
+
+    def shutdown(self):
+        self._stop = True
+        if self._commsobj is not None:
+            self._commsobj.shutdown()
+        if self.proc is not None:
+            self.proc.terminate()
+
+
+    def __contains__(self, item):
+        "So a devicename can easily be checked if it is in this driver"
+        return item in self.devicenames
+
+
+    async def _readdata(self, root):
+        """Called from communications object with received xmldata
+           and sends it towards the driver"""
+
+        if self._stop:
+            return
+
+        if root.tag == "enableBLOB":
+            return
+
+        if root.tag == "getProperties":
+            await self.xml_to_ext(root)
+            return
+
+        devicename = root.get("device")
+        propertyname = root.get("name")
+
+        if root.tag in NEWTAGS:
+            if devicename is None:
+                # invalid
+                return
+            if devicename in self.devicenames:
+                await self.xml_to_ext(root)
+                return
+            else:
+                # not for this driver
+                return
+
+        # so not in NEWTAGS
+        # Check if this driver is snooping on this device/vector
+        if self.snoopall:
+            await self.xml_to_ext(root)
+        elif devicename and (devicename in self.snoopdevices):
+            await self.xml_to_ext(root)
+        elif devicename and propertyname and ((devicename, propertyname) in self.snoopvectors):
+            await self.xml_to_ext(root)
+
+
+    async def xml_to_ext(self, root):
+        "Pass data to the external driver"
+
+        binarydata = ET.tostring(root)
+
+        # log the received data
+        if logger.isEnabledFor(logging.DEBUG) and self.debug_enable:
+            logger.debug(f"RX:: {binarydata.decode('utf-8')}")
+
+        binarydata += b"\n"
+        self.proc.stdin.write(binarydata)
+        await self.proc.stdin.drain()
+
+
+
+    async def _run_tx(self):
+        "Get data from driver and send it towards the server"
+        try:
+            # get block of xml.etree.ElementTree data
+            # from self._xmlinput and append it to self.writerque
+            while not self._stop:
+                txdata = await self._xmlinput()
+                if txdata is None:
+                    return
+                # get block of xml.etree.ElementTree data
+                devicename = txdata.get("device")
+                if devicename and txdata.tag in DEFTAGS:
+                    # its a definition
+                    if devicename not in self.devicenames:
+                        self.devicenames[devicename] = {}
+                    vectorname = txdata.get("name")
+                    if vectorname:
+                        if vectorname not in self.devicenames[devicename]:
+                            # add this vector to the self.devicenames[devicename] dictionary
+                            self.devicenames[devicename][vectorname] = ExVector(vectorname, txdata.tag)
+                # check for a getProperties being sent, record what is being snooped
+                if txdata.tag == "getProperties":
+                    vectorname = txdata.get("name")
+                    if devicename is None:
+                        self.snoopall = True
+                    elif vectorname is None:
+                        self.snoopdevices.add(devicename)
+                    else:
+                        self.snoopvectors.add((devicename,vectorname))
+
+                # transmit this data towards the server
+                await self._commsobj.run_tx(txdata)
+
+                if logger.isEnabledFor(logging.DEBUG) and self.debug_enable:
+                    binarydata = ET.tostring(txdata)
+                    logger.debug(f"TX:: {binarydata.decode('utf-8')}")
+
+        except Exception:
+            logger.exception("Exception report from ExDriver._run_tx")
+            raise
+
+
+    async def _xmlinput(self):
+        """get data from driver, parse it, and return it as xml.etree.ElementTree object
+           Returns None if stop flags arises"""
+        message = b''
+        messagetagnumber = None
+        while not self._stop:
+            data = await self._datainput()
+            # data is either None, or binary data ending in b">"
+            if data is None:
+                return
+            if self._stop:
+                return
+            if not message:
+                # data is expected to start with <tag, first strip any newlines
+                data = data.strip()
+                for index, st in enumerate(_STARTTAGS):
+                    if data.startswith(st):
+                        messagetagnumber = index
+                        break
+                    elif st in data:
+                        # remove any data prior to a starttag
+                        positionofst = data.index(st)
+                        data = data[positionofst:]
+                        messagetagnumber = index
+                        break
+                else:
+                    # data does not start with a recognised tag, so ignore it
+                    # and continue waiting for a valid message start
+                    continue
+                # set this data into the received message
+                message = data
+                # either further children of this tag are coming, or maybe its a single tag ending in "/>"
+                if message.endswith(b'/>'):
+                    # the message is complete, handle message here
+                    try:
+                        root = ET.fromstring(message.decode("us-ascii"))
+                    except Exception:
+                        # failed to parse the message, continue at beginning
+                        message = b''
+                        messagetagnumber = None
+                        continue
+                    # xml datablock done, return it
+                    return root
+                # and read either the next message, or the children of this tag
+                continue
+            # To reach this point, the message is in progress, with a messagetagnumber set
+            # keep adding the received data to message, until an endtag is reached
+            message += data
+            if message.endswith(_ENDTAGS[messagetagnumber]):
+                # the message is complete, handle message here
+                try:
+                    root = ET.fromstring(message.decode("us-ascii"))
+                except Exception:
+                    # failed to parse the message, continue at beginning
+                    message = b''
+                    messagetagnumber = None
+                    continue
+                # xml datablock done, return it
+                return root
+            # so message is in progress, with a messagetagnumber set
+            # but no valid endtag received yet, so continue the loop
+
+
+    async def _datainput(self):
+        """Waits for binary string of data ending in > from the driver
+           Returns None if stop flags arises"""
+        remainder = self._remainder
+        if b">" in remainder:
+            # This returns with binary data ending in > as long
+            # as there are > characters in self._remainder
+            binarydata, self._remainder = remainder.split(b'>', maxsplit=1)
+            binarydata += b">"
+            return binarydata
+        # As soon as there are no > characters left in self._remainder
+        # get more data from the driver
+        while not self._stop:
+            await asyncio.sleep(0)
+            indata = await self.proc.stdout.read(100)
+            if not indata:
+                await asyncio.sleep(0.02)
+                continue
+            remainder += indata
+            if b">" in indata:
+                binarydata, self._remainder = remainder.split(b'>', maxsplit=1)
+                binarydata += b">"
+                return binarydata
+
+
+    async def _run_err(self):
+        """gets binary string of data from exdriver proc.stderr
+           and logs it to logging.error."""
+
+        while not self._stop:
+            bindata = await self.proc.stderr.readline()
+            if not bindata:
+                await asyncio.sleep(0.02)
+                continue
+            logger.error(bindata.decode('utf-8'))
+
+
+    async def asyncrun(self):
+        "Runs the external driver"
+
+        self._stop = False
+
+        try:
+
+            self.proc = await asyncio.create_subprocess_exec(self.program,
+                                                             *self.args,
+                                                       stdin=asyncio.subprocess.PIPE,
+                                                       stdout=asyncio.subprocess.PIPE,
+                                                       stderr=asyncio.subprocess.PIPE)
+
+            # wait for external program to start
+            await asyncio.sleep(0.1)
+            # send a getProperties into the driver
+            await self._readdata( ET.fromstring("""<getProperties version="1.7" />""") )
+
+            async with asyncio.TaskGroup() as tg:
+                tg.create_task( self._run_tx() )           # Get data from driver and send it towards the server
+                tg.create_task( self._run_err() )          # data from exdriver proc.stderr and logs it to logging.error
+        except Exception:
+            logger.exception("Driver shutdown")
+        finally:
+            self._stop = True