indipyweb 0.0.2__tar.gz

indipyweb-0.0.2/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.

indipyweb-0.0.2/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: indipyweb
+Version: 0.0.2
+Summary: Web server to communicate to an INDI service.
+Keywords: indi,client,astronomy,instrument
+Author-email: Bernard Czenkusz <bernie@skipole.co.uk>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
+License-File: LICENSE
+Requires-Dist: indipyclient>=0.8.6
+Requires-Dist: litestar[standard]>=2.18.0
+Requires-Dist: litestar[mako]>=2.18.0
+Project-URL: Source, https://github.com/bernie-skipole/indipyweb
+
+# indipyweb
+Web server, providing browser client connections to an INDI service.
+
+This does not include the INDI server, this is an INDI client.
+
+Requires Python >=3.10 and a virtual environment with:
+
+pip install indipyweb
+
+Then to run the server:
+
+python -m indipyweb
+
+This will create a database file holding user information in the working directory, and will run a web server on localhost:8000. Connect with a browser, and initially use the default created user, with username admin and password password! - note the exclamation mark.
+
+This server will attempt to connect to an INDI service on localhost:7624, and the user browser should be able to view and set devices, vectors and member values.
+
+The package help is:
+
+    usage: indipyweb [options]
+
+    Web server to communicate to an INDI service.
+
+    options:
+      -h, --help   show this help message and exit
+      --port PORT  Listening port of the web server.
+      --host HOST  Hostname/IP of the web server.
+      --db DB      Folder where the database will be set.
+      --version    show program's version number and exit
+
+Having logged in as admin, choose edit and change your password, you can also choose the system setup to set web and INDI hosts, ports and a folder where any BLOBs sent by the INDI service will be saved. These values will be saved in the database file and read on startup.
+

indipyweb-0.0.2/README.md

@@ -0,0 +1,31 @@
+# indipyweb
+Web server, providing browser client connections to an INDI service.
+
+This does not include the INDI server, this is an INDI client.
+
+Requires Python >=3.10 and a virtual environment with:
+
+pip install indipyweb
+
+Then to run the server:
+
+python -m indipyweb
+
+This will create a database file holding user information in the working directory, and will run a web server on localhost:8000. Connect with a browser, and initially use the default created user, with username admin and password password! - note the exclamation mark.
+
+This server will attempt to connect to an INDI service on localhost:7624, and the user browser should be able to view and set devices, vectors and member values.
+
+The package help is:
+
+    usage: indipyweb [options]
+
+    Web server to communicate to an INDI service.
+
+    options:
+      -h, --help   show this help message and exit
+      --port PORT  Listening port of the web server.
+      --host HOST  Hostname/IP of the web server.
+      --db DB      Folder where the database will be set.
+      --version    show program's version number and exit
+
+Having logged in as admin, choose edit and change your password, you can also choose the system setup to set web and INDI hosts, ports and a folder where any BLOBs sent by the INDI service will be saved. These values will be saved in the database file and read on startup.

indipyweb-0.0.2/indipyweb/__main__.py

@@ -0,0 +1,69 @@
+
+
+import sys, argparse, pathlib, asyncio
+
+import uvicorn
+
+from .iclient import ipywebclient, version
+
+from .web.app import ipywebapp
+
+from .web.userdata import setupdbase, setconfig, getconfig, get_indiclient
+
+
+if sys.version_info < (3, 10):
+    raise ImportError('indipyweb requires Python >= 3.10')
+
+
+def readconfig():
+
+    parser = argparse.ArgumentParser(usage="indipyweb [options]",
+                                     description="Web server to communicate to an INDI service.")
+    parser.add_argument("--port", type=int, help="Listening port of the web server.")
+    parser.add_argument("--host", help="Hostname/IP of the web server.")
+    parser.add_argument("--db", help="Folder where the database will be set.")
+    parser.add_argument("--version", action="version", version=version)
+    args = parser.parse_args()
+
+
+    if args.db:
+        try:
+            dbfolder = pathlib.Path(args.db).expanduser().resolve()
+        except Exception:
+            print("Error: If given, the database folder should be an existing directory")
+            sys.exit(1)
+        else:
+            if not dbfolder.is_dir():
+                print("Error: If given, the database folder should be an existing directory")
+                sys.exit(1)
+    else:
+        dbfolder = pathlib.Path.cwd()
+
+    setupdbase(args.host, args.port, dbfolder)
+
+    # create the client, store it for later access with get_indiclient()
+    ipywebclient()
+
+    host = getconfig('host')
+    port = getconfig('port')
+    app = ipywebapp()
+
+    return app, host, port
+
+
+async def indipywebrun():
+    "Read the program arguments, setup the database and run the webserver"
+    app, host, port = readconfig()
+    config = uvicorn.Config(app=app, host=host, port=port, log_level="info")
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
+def main():
+    "Run the program"
+    asyncio.run(indipywebrun())
+
+
+if __name__ == "__main__":
+    # And run main
+    main()

indipyweb-0.0.2/indipyweb/iclient.py

@@ -0,0 +1,73 @@
+
+"""
+Provides ipywebclient, version
+"""
+
+import asyncio
+
+import indipyclient as ipc
+
+from .web.userdata import DEFINE_EVENT, MESSAGE_EVENT, get_indiclient, getconfig, setconfig, get_device_event, get_vector_event
+
+version = "0.0.2"
+
+
+
+def ipywebclient():
+    "Create and store an instance of IPyWebClient"
+
+    indihost = getconfig("indihost")
+    indiport = getconfig("indiport")
+    indiclient = IPyWebClient(indihost=indihost, indiport=indiport)
+    indiclient.BLOBfolder = getconfig("blobfolder")
+    setconfig("indiclient", indiclient)
+
+
+def do_startup():
+    """Start the client, called from Litestar app, the task is set into
+       the global config to ensure a strong reference to it remains"""
+    iclient = get_indiclient()
+    runclient = asyncio.create_task(iclient.asyncrun())
+    setconfig("runclient", runclient)
+
+async def do_shutdown():
+    "Stop the client, called from Litestar app"
+    iclient = get_indiclient()
+    iclient.shutdown()
+    await iclient.stopped.wait()
+
+
+class IPyWebClient(ipc.IPyClient):
+
+    async def rxevent(self, event):
+
+        if event.eventtype in ("Define", "Delete", "ConnectionMade", "ConnectionLost"):
+            DEFINE_EVENT.set()
+            DEFINE_EVENT.clear()
+        elif event.eventtype == "Message":
+            MESSAGE_EVENT.set()
+            MESSAGE_EVENT.clear()
+            if event.devicename:
+                dme = get_device_event(event.devicename)
+                dme.set()
+                dme.clear()
+
+        if event.eventtype == "Delete":
+            if event.devicename:
+                # set a message event, so if the device is deleted
+                # when client sends an updatemessages it forces a redirect
+                dme = get_device_event(event.devicename)
+                dme.set()
+                dme.clear()
+
+        if event.vector:
+           if event.eventtype == "TimeOut":
+               event.vector.user_string = "Response has timed out"
+               event.vector.state = 'Alert'
+               event.vector.timestamp = event.timestamp
+           else:
+               event.vector.user_string = ""
+           # set vector event when a vector is updated
+           ve = get_vector_event(event.devicename, event.vectorname)
+           ve.set()
+           ve.clear()

indipyweb-0.0.2/indipyweb/web/app.py

@@ -0,0 +1,391 @@
+"""
+Creates the main litestar app with the top level routes
+and authentication functions, including setting and testing cookies
+
+Note, edit routes are set under edit.edit_router
+
+"""
+
+import asyncio
+
+from os import listdir, remove
+from os.path import isfile, join
+
+from pathlib import Path
+
+from collections.abc import AsyncGenerator
+
+from asyncio.exceptions import TimeoutError
+
+from litestar import Litestar, get, post, Request
+from litestar.plugins.htmx import HTMXPlugin, HTMXTemplate, ClientRedirect, ClientRefresh
+from litestar.contrib.mako import MakoTemplateEngine
+from litestar.template.config import TemplateConfig
+from litestar.response import Template, Redirect, File
+from litestar.static_files import create_static_files_router
+from litestar.datastructures import Cookie, State
+
+from litestar.middleware import AbstractAuthenticationMiddleware, AuthenticationResult, DefineMiddleware
+from litestar.connection import ASGIConnection
+from litestar.exceptions import NotAuthorizedException, NotFoundException
+
+from litestar.response import ServerSentEvent, ServerSentEventMessage
+
+from . import userdata, edit, device, vector, setup
+
+from ..iclient import do_startup, do_shutdown
+
+
+# location of static files, for CSS and javascript
+STATICFILES = Path(__file__).parent.resolve() / "static"
+
+# location of template files
+TEMPLATEFILES = Path(__file__).parent.resolve() / "templates"
+
+
+class ShowInstruments:
+    """Iterate with instruments table whenever an instrument change happens."""
+
+    def __init__(self):
+        self.instruments = set()
+        self.connected = False
+        self.iclient = userdata.get_indiclient()
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        "Whenever there is a change in devices, return a ServerSentEventMessage message"
+        while True:
+            if self.iclient.stop:
+                raise StopAsyncIteration
+            if self.iclient.connected != self.connected:
+                self.connected = self.iclient.connected
+                return ServerSentEventMessage(event="newinstruments")
+            # get a set of instrument names for enabled devices
+            newinstruments = set(name for name,value in self.iclient.items() if value.enable)
+            if newinstruments == self.instruments:
+                # No change, wait, at most 5 seconds, for a DEFINE_EVENT
+                try:
+                    await asyncio.wait_for(userdata.DEFINE_EVENT.wait(), timeout=5.0)
+                except TimeoutError:
+                    pass
+                # either a DEFINE_EVENT has occurred, or 5 seconds since the last has passed
+                # so continue the while loop to check for any new devices
+                continue
+            # There has been a change, send a newinstruments to the users browser
+            self.instruments = newinstruments
+            return ServerSentEventMessage(event="newinstruments")
+
+
+# SSE Handler
+@get(path="/instruments", exclude_from_auth=True, sync_to_thread=False)
+def instruments() -> ServerSentEvent:
+    return ServerSentEvent(ShowInstruments())
+
+
+class ShowMessages:
+    """Iterate with messages whenever a message change happens."""
+
+    def __init__(self):
+        self.lasttimestamp = None
+        self.connected = False
+        self.iclient = userdata.get_indiclient()
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        "Whenever there is a new message, return a ServerSentEventMessage message"
+        while True:
+            if self.iclient.stop:
+                asyncio.sleep(2)
+                return ServerSentEventMessage(event="newmessage")
+
+            if self.iclient.connected != self.connected:
+                self.connected = self.iclient.connected
+                return ServerSentEventMessage(event="newmessage")
+            # get new message
+            if self.iclient.messages:
+                lasttimestamp = self.iclient.messages[0][0]
+                if (self.lasttimestamp is None) or (lasttimestamp != self.lasttimestamp):
+                    # a new message is received
+                    self.lasttimestamp = lasttimestamp
+                    return ServerSentEventMessage(event="newmessages")
+            elif self.lasttimestamp is not None:
+                # There are no self.iclient.messages, but self.lasttimestamp
+                # has a value, so there has been a change
+                self.lasttimestamp = None
+                return ServerSentEventMessage(event="newmessages")
+            # No change, wait, at most 5 seconds, for a MESSAGE_EVENT
+            try:
+                await asyncio.wait_for(userdata.MESSAGE_EVENT.wait(), timeout=5.0)
+            except TimeoutError:
+                pass
+            # either a MESSAGE_EVENT has occurred, or 5 seconds since the last has passed
+            # so continue the while loop to check for any new messages
+
+
+# SSE Handler
+@get(path="/messages", exclude_from_auth=True, sync_to_thread=False)
+def messages() -> ServerSentEvent:
+    return ServerSentEvent(ShowMessages())
+
+
+class LoggedInAuth(AbstractAuthenticationMiddleware):
+    """Checks if a logged-in cookie is present, and verifies it
+       If ok, returns an AuthenticationResult with the user, and the users
+       authorisation level. If not ok raises a NotAuthorizedException"""
+    async def authenticate_request(self, connection: ASGIConnection ) -> AuthenticationResult:
+        # retrieve the cookie
+        auth_cookie = connection.cookies
+        if not auth_cookie:
+            raise NotAuthorizedException()
+        token =  auth_cookie.get('token')
+        if not token:
+            raise NotAuthorizedException()
+        # the userdata.verify function looks up a dictionary of logged in users
+        userinfo = userdata.verify(token)
+        # If not verified, userinfo will be None
+        # If verified userinfo will be a userdata.UserInfo object
+        if userinfo is None:
+            raise NotAuthorizedException()
+        # Return an AuthenticationResult which will be
+        # made available to route handlers as request: Request[str, str, State]
+        return AuthenticationResult(user=userinfo.user, auth=userinfo.auth)
+
+
+def gotologin_error_handler(request: Request, exc: Exception) -> ClientRedirect|Redirect:
+    """If a NotAuthorizedException is raised, this handles it, and redirects
+       the caller to the login page"""
+    if request.htmx:
+        return ClientRedirect("/login")
+    return Redirect("/login")
+
+
+def gotonotfound_error_handler(request: Request, exc: Exception) -> ClientRedirect|Redirect:
+    """If a NotFoundException is raised, this handles it, and redirects
+       the caller to the not found page"""
+    if request.htmx:
+        return ClientRedirect("/notfound")
+    return Redirect("/notfound")
+
+
+@get("/notfound", exclude_from_auth=True)
+async def notfound(request: Request) -> Template:
+    "This is the public root page of your site"
+    iclient = userdata.get_indiclient()
+    # Check if user is looged in
+    loggedin = False
+    cookie = request.cookies.get('token', '')
+    if cookie:
+        userauth = userdata.getuserauth(cookie)
+        if userauth is not None:
+            loggedin = True
+    return Template("notfound.html", context={"hostname":userdata.connectedtext(),
+                                             "loggedin":loggedin})
+
+
+
+# Note, all routes with 'exclude_from_auth=True' do not have cookie checked
+# and are not authenticated
+
+@get("/", exclude_from_auth=True)
+async def publicroot(request: Request) -> Template:
+    "This is the public root page of your site"
+    iclient = userdata.get_indiclient()
+    # Check if user is looged in
+    loggedin = False
+    cookie = request.cookies.get('token', '')
+    if cookie:
+        userauth = userdata.getuserauth(cookie)
+        if userauth is not None:
+            loggedin = True
+    blobfolder = True if iclient.BLOBfolder else False
+
+    return Template("landing.html", context={"hostname":userdata.connectedtext(),
+                                             "instruments":None,
+                                             "messages":None,
+                                             "loggedin":loggedin,
+                                             "blobfolder":blobfolder})
+
+
+@get("/updateinstruments", exclude_from_auth=True)
+async def updateinstruments(request: Request) -> Template:
+    "Updates the instruments on the main public page"
+    iclient = userdata.get_indiclient()
+    instruments = list(name for name,value in iclient.items() if value.enable)
+    instruments.sort()
+    return HTMXTemplate(template_name="instruments.html", context={"instruments":instruments})
+
+
+@get("/updatemessages", exclude_from_auth=True)
+async def updatemessages() -> Template:
+    "Updates the messages on the main public page"
+    iclient = userdata.get_indiclient()
+    if iclient.stop:
+        return HTMXTemplate(template_name="messages.html", context={"messages":["Error: client application has stopped"]})
+    messages = list(iclient.messages)
+    messagelist = list(userdata.localtimestring(t) + "  " + m for t,m in messages)
+    messagelist.reverse()
+    return HTMXTemplate(template_name="messages.html", context={"messages":messagelist})
+
+
+@get("/login", exclude_from_auth=True)
+async def login_page(request: Request[str, str, State]) -> Template:
+    "Render the login page"
+    cookie = request.cookies.get('token')
+    # log the user out
+    if cookie:
+        userdata.logout(request.cookies['token'])
+    return Template("edit/login.html", context={"hostname":userdata.connectedtext()})
+
+
+@post("/login", exclude_from_auth=True)
+async def login(request: Request) -> Template|ClientRedirect:
+    """This is a handler for the login post, in which the caller is setting their
+       username and password into a form.
+       Checks the user has logged in correctly, and if so creates a logged-in cookie
+       for the caller and redirects the caller to / the root application page"""
+    form_data = await request.form()
+    username = form_data.get("username")
+    password = form_data.get("password")
+    # check these on the database of users, this checkuserpassword returns a userdata.UserInfo object
+    # if the user exists, and the password is correct, otherwise it returns None
+    userinfo = userdata.checkuserpassword(username, password)
+    if userinfo is None:
+        # sleep to force a time delay to annoy anyone trying to guess a password
+        await asyncio.sleep(1.0)
+        # unable to find a matching username/password
+        # returns an 'Invalid' template which the htmx javascript
+        # puts in the right place on the login page
+        return HTMXTemplate(None,
+                            template_str="<p id=\"result\" class=\"vanish\" style=\"color:red\">Invalid</p>")
+    # The user checks out ok, create a cookie for this user and set redirect to the /,
+    loggedincookie = userdata.createcookie(userinfo.user)
+    # redirect with the loggedincookie
+    response =  ClientRedirect("/")
+    response.set_cookie(key = 'token', value=loggedincookie)
+    return response
+
+
+@get("/logout")
+async def logout(request: Request[str, str, State]) -> Template:
+    "Logs the user out, and render the logout page"
+    cookie = request.cookies.get('token')
+    # log the user out
+    if cookie:
+        userdata.logout(request.cookies['token'])
+    return Template("edit/loggedout.html", context={"hostname":userdata.connectedtext()})
+
+
+@get("/blobs")
+async def blobs(request: Request[str, str, State]) -> Template:
+    "Shows a page of blob files"
+    iclient = userdata.get_indiclient()
+    blobfolder = iclient.BLOBfolder
+    if blobfolder:
+        blobfiles = [f for f in listdir(blobfolder) if isfile(join(blobfolder, f))]
+        blobfiles.sort()
+    else:
+        blobfiles = []
+    admin = True if request.auth == "admin" else False
+    context = {'blobfiles':blobfiles,
+               'admin':admin}
+    return Template("blobs.html", context=context)
+
+
+@get("/getblob/{blobfile:str}", media_type="application/octet")
+async def getblob(blobfile:str, request: Request[str, str, State]) -> File:
+    "Download a BLOB to the browser client"
+    iclient = userdata.get_indiclient()
+    blobfolder = iclient.BLOBfolder
+    if not blobfolder:
+        raise NotFoundException()
+    blobpath = iclient.BLOBfolder / blobfile
+    if not blobpath.is_file():
+        raise NotFoundException()
+    return File(
+        path=blobpath,
+        filename=blobfile
+        )
+
+@get("/delblob/{blobfile:str}")
+async def delblob(blobfile:str, request: Request[str, str, State]) -> ClientRefresh:
+    "Deletes a blob"
+    auth = request.auth
+    if auth != "admin":
+        raise NotAuthorizedException()
+    iclient = userdata.get_indiclient()
+    blobfolder = iclient.BLOBfolder
+    if not blobfolder:
+        raise NotFoundException()
+    blobpath = iclient.BLOBfolder / blobfile
+    if not blobpath.is_file():
+        raise NotFoundException()
+    remove(blobpath)
+    return ClientRefresh()
+
+
+
+@get(["/api", "/api/{device:str}", "/api/{device:str}/{vector:str}"], exclude_from_auth=True, sync_to_thread=False)
+def api(device:str="", vector:str="") -> dict:
+    iclient = userdata.get_indiclient()
+    if not device:
+        # return whole client dict
+        shot = iclient.snapshot()
+        return shot.dictdump()
+    deviceobj = iclient.get(device)
+    if deviceobj is None:
+        return {}
+    if vector:
+        vectorobj = deviceobj.data.get(vector)
+        if vectorobj is None:
+            return {}
+        shot = vectorobj.snapshot()
+        return shot.dictdump()
+    shot = deviceobj.snapshot()
+    return shot.dictdump()
+
+
+# This defines LoggedInAuth as middleware and also
+# excludes certain paths from authentication.
+# In this case it excludes all routes mounted at or under `/static*`
+# This allows CSS and javascript libraries to be placed there, which
+# therefore do not need authentication to be accessed
+auth_mw = DefineMiddleware(LoggedInAuth, exclude="static")
+
+
+def ipywebapp():
+    # Initialize the Litestar app with a Mako template engine and register the routes
+    iclient = userdata.get_indiclient()
+    app = Litestar(
+        route_handlers=[publicroot,
+                        updateinstruments,
+                        updatemessages,
+                        notfound,
+                        login_page,
+                        login,
+                        logout,
+                        instruments,
+                        messages,
+                        blobs,
+                        getblob,
+                        delblob,
+                        api,
+                        edit.edit_router,     # This router in edit.py deals with routes below /edit
+                        device.device_router, # This router in device.py deals with routes below /device
+                        vector.vector_router, # This router in vector.py deals with routes below /vector
+                        setup.setup_router,   # This router in setup.py deals with routes below /setup
+                        create_static_files_router(path="/static", directories=[STATICFILES]),
+                       ],
+        exception_handlers={ NotAuthorizedException: gotologin_error_handler, NotFoundException: gotonotfound_error_handler},
+        plugins=[HTMXPlugin()],
+        middleware=[auth_mw],
+        template_config=TemplateConfig(directory=TEMPLATEFILES,
+                                       engine=MakoTemplateEngine,
+                                      ),
+        on_startup=[do_startup],
+        on_shutdown=[do_shutdown]
+        )
+    return app