drifTech-lib 0.2.7__tar.gz → 0.4.0__tar.gz

{driftech_lib-0.2.7 → driftech_lib-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drifTech-lib
-Version: 0.2.7
+Version: 0.4.0
 Summary: Common files/functions across most drifTech software
 Author: driftbluestone
 Author-email: driftbluestone <driftbluestone@gmail.com>

{driftech_lib-0.2.7 → driftech_lib-0.4.0}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "uv_build"
 
 [project]
 name = "drifTech-lib"
-version = "0.2.7"
+version = "0.4.0"
 description = "Common files/functions across most drifTech software"
 readme = "README.md"
 requires-python = ">=3.14"

{driftech_lib-0.2.7 → driftech_lib-0.4.0}/pyproject.toml.orig

@@ -8,7 +8,7 @@ build-backend = "uv_build"
 
 [project]
 name = "drifTech-lib"
-version = "0.2.7"
+version = "0.4.0"
 authors = [{name = "driftbluestone", email = "driftbluestone@gmail.com"}]
 description = "Common files/functions across most drifTech software"
 readme = "README.md"

{driftech_lib-0.2.7 → driftech_lib-0.4.0}/src/driftech_lib/ipc/client.py

@@ -4,9 +4,9 @@ __all__ = ["Connector"]
 
 class Connector:
     """
-    Inherit this class to overwrite the on_message() function
+    Inherit this class to overwrite the on_message() function.
 
-    run await Connector().start() to connect to DCM-core
+    Run `await Connector().start()` to initialize a connection.
     """
     def __init__(self, HOST, PORT):
         self.HOST = HOST
@@ -35,7 +35,7 @@ class Connector:
         """Background task to continuously read any data pushed by the server."""
         try:
             while True:
-                data = await reader.read(1024)
+                data = await reader.readline()
                 if not data:
                     logger.error("[DISCONNECTED] Server closed the connection.")
                     break
@@ -46,9 +46,7 @@ class Connector:
             logger.error(f"[ERROR] Reading error: {e}")
 
     async def on_message(self, message: bytes):
-        """
-        Override this function
-        """
+        """Override this function."""
         pass
 
     async def send_message(self, message: str | bytes):
@@ -57,7 +55,6 @@ class Connector:
         await self.command_queue.put(message)
 
     async def _send(self, writer: asyncio.StreamWriter):
-        loop = asyncio.get_running_loop()
         try:
             while True:
                 user_input: bytes = await self.command_queue.get()

driftech_lib-0.4.0/src/driftech_lib/ipc/server.py

@@ -0,0 +1,100 @@
+import asyncio, logging, sys
+logger = logging.getLogger("ipc:server")
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+__all__ = ["Server", "connections"]
+Port = int
+
+conn_count = 1
+connections: dict[Port, Server] = {}
+
+class Server:
+    """
+    Inherit this class to overwrite the on_message() function.
+
+    Run `await Server().start()` to initialize a server.
+    Do not apply class attributes when initializing,
+    they are only used for the connections,
+    which can be accessed within the `connections` dict.
+    """
+    def __init__(self, addr: str = None, port: int = None,
+                 reader: asyncio.StreamReader = None,
+                 writer: asyncio.StreamWriter = None):
+        
+        self.addr = addr
+        self.port = port
+        self.reader = reader
+        self.writer = writer
+        self.command_queue: asyncio.Queue[bytes] = asyncio.Queue(10)
+
+    async def start(self, HOST = "127.0.0.1", PORT = 8000):
+        server = await asyncio.start_server(self._interface, HOST, PORT)
+        logger.info(f"[LISTENING] Server is running on {HOST}:{PORT}")
+        async with server:
+            await server.serve_forever()
+
+    async def _interface(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
+        global conn_count
+        addr, port = writer.get_extra_info("peername")
+        logger.info(f"[CONNECTION] Connection opened for {addr} #{conn_count}")
+        conn_count += 1
+        try:
+            conn = self.__class__(addr, port, reader, writer)
+            connections[port] = conn
+            await conn._run()
+        except (asyncio.CancelledError, ConnectionResetError, BrokenPipeError, OSError):
+            conn_count -= 1
+            logger.info(f"[DISCONNECTED] Connection closed for {addr} #{conn_count-1}")
+        finally:
+            conn_count -= 1
+            logger.info(f"[DISCONNECTED] Connection closed for {addr} #{conn_count-1}")
+
+    async def _run(self):
+        listen_task = asyncio.create_task(self._listen())
+
+        await self._send()
+
+        listen_task.cancel()
+        self.writer.close()
+        await self.writer.wait_closed()
+
+    async def _listen(self):
+        try:
+            while True:
+                data = await self.reader.readline()
+                if not data:
+                    break
+                await self.on_message(data)
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"[ERROR] Reading error: {e}")
+
+    async def on_message(self):
+        """Override this function."""
+        pass
+
+    async def send_message(self, message: bytes):
+        if isinstance(message, str):
+            message = message.encode()
+        await self.command_queue.put(message)
+
+    async def _send(self):
+        try:
+            while True:
+                user_input: bytes = await self.command_queue.get()
+                message = user_input.strip()
+                
+                if not message:
+                    continue
+                    
+                if message.lower() == b"exit":
+                    logger.info("Closing connection...")
+                    break
+                    
+                self.writer.write(message)
+                await self.writer.drain()
+                
+        except Exception as e:
+            logger.error(f"Writing error: {e}")
+
+asyncio.run(Server().start())

driftech_lib-0.4.0/src/driftech_lib/logging.py

@@ -0,0 +1,123 @@
+import sys, time, inspect
+from pathlib import Path
+from collections.abc import Callable
+
+default_LoSs = {
+    "UNSET": 0,
+    "DEBUG": 10,
+    "INFO": 20,
+    "WARN": 30,
+    "ERROR": 40,
+    "FATAL": 50
+}
+
+class Logger:
+    def __init__(self,
+                 name: str,
+                 file: str | Path = None,
+                 reset_file_on_restart: bool = True,
+                 console = sys.stdout,
+                 min_console_severity: int = 0,
+                 min_file_severity: int = 0,
+                 time_format: str = "%Y-%m-%d %H:%M:%S",
+                 LoSs: dict[str, int] = default_LoSs,
+                 ):
+        self.reset_file_on_restart = reset_file_on_restart
+        self.name = name
+        self.console = console
+        self.file = file
+        self.time_format = time_format
+        self.LoSs = LoSs
+        self.RLoSs = {v: k for k, v in LoSs.items()}
+        self.min_console_severity = min_console_severity
+        self.min_file_severity = min_file_severity
+
+        if reset_file_on_restart and file:
+            with open(file, "w") as f:
+                f.write("")
+
+    def add_LoS(self, name: str, severity: int):
+        self.LoSs[name] = severity
+        self.RLoSs[severity] = name
+
+    def _premessage(self, severity):
+        tm = time.strftime(self.time_format)
+        return f"{tm} [{self.name}/{self.RLoSs[severity]}]: "
+
+    async def alog(self, severity: int, content: str, secondary: Callable = None, kwarg: str = None):
+        """Async compatible implementation of `log`"""
+        if isinstance(severity, str):
+            severity = self.LoSs[severity]
+
+        content = f"{self._premessage(severity)}{content}\n"
+
+        if secondary and inspect.iscoroutinefunction(secondary):
+            if kwarg:
+                await secondary(**{kwarg: content})
+            else:
+                await secondary(content)
+        elif secondary:
+            if kwarg:
+                secondary(**{kwarg: content})
+            else:
+                secondary(content)
+
+        if (severity >= self.min_console_severity) and (self.console):
+            self.console.write(content)
+            if inspect.iscoroutinefunction(self.console.flush):
+                await self.console.flush()
+            else:
+                self.console.flush()
+        
+        if (severity >= self.min_file_severity) and (self.file):
+            with open(self.file, "a") as file:
+                file.write(content)
+        
+    def log(self, severity: int, content: str, secondary: Callable = None, kwarg: str = None):
+        if isinstance(severity, str):
+            severity = self.LoSs[severity]
+
+        content = f"{self._premessage(severity)}{content}\n"
+            
+        if secondary:
+            if kwarg:
+                secondary(**{kwarg: content})
+            else:
+                secondary(content)
+        if (severity >= self.min_console_severity) and (self.console):
+            self.console.write(content)
+            self.console.flush()
+
+        if (severity >= self.min_file_severity) and (self.file):
+            with open(self.file, "a") as file:
+                file.write(content)
+
+    def debug(self, content: str, secondary: Callable = None, kwarg: str = None):
+        self.log(self.LoSs["DEBUG"], content, secondary, kwarg)
+
+    def info(self, content: str, secondary: Callable = None, kwarg: str = None):
+        self.log(self.LoSs["INFO"], content, secondary, kwarg)
+
+    def warn(self, content: str, secondary: Callable = None, kwarg: str = None):
+        self.log(self.LoSs["WARN"], content, secondary, kwarg)
+
+    def error(self, content: str, secondary: Callable = None, kwarg: str = None):
+        self.log(self.LoSs["ERROR"], content, secondary, kwarg)
+
+    def fatal(self, content: str, secondary: Callable = None, kwarg: str = None):
+        self.log(self.LoSs["FATAL"], content, secondary, kwarg)
+
+    async def adebug(self, content: str, secondary: Callable = None, kwarg: str = None):
+        await self.alog(self.LoSs["DEBUG"], content, secondary, kwarg)
+
+    async def ainfo(self, content: str, secondary: Callable = None, kwarg: str = None):
+        await self.alog(self.LoSs["INFO"], content, secondary, kwarg)
+
+    async def awarn(self, content: str, secondary: Callable = None, kwarg: str = None):
+        await self.alog(self.LoSs["WARN"], content, secondary, kwarg)
+
+    async def aerror(self, content: str, secondary: Callable = None, kwarg: str = None):
+        await self.alog(self.LoSs["ERROR"], content, secondary, kwarg)
+
+    async def afatal(self, content: str, secondary: Callable = None, kwarg: str = None):
+        await self.alog(self.LoSs["FATAL"], content, secondary, kwarg)

driftech_lib-0.2.7/src/driftech_lib/ipc/server.py

@@ -1,35 +0,0 @@
-import asyncio, logging
-logger = logging.getLogger("ipc:server")
-__all__ = ["start"]
-
-open_connections = 1
-
-async def start(HOST = "127.0.0.1", PORT = 8000):
-    server = await asyncio.start_server(interface, HOST, PORT)
-    logger.info(f"[LISTENING] Server is running on {HOST}:{PORT}")
-    async with server:
-        await server.serve_forever()
-
-async def interface(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
-    global open_connections
-    addr = writer.get_extra_info("peername")
-    logger.info(f"[CONNECTION] Connection opened for {addr} #{open_connections}")
-    open_connections += 1
-    try:
-        while True:
-            data = await reader.read(1024)
-            if not data:
-                break
-            logger.info(f"[{addr}] Received: {data.decode()}")
-            writer.write(b"Message processed")
-            await writer.drain()  # Ensure data is flushed to the network buffer
-    except (asyncio.CancelledError, ConnectionResetError, BrokenPipeError, OSError):
-        open_connections -= 1
-        logger.info(f"[DISCONNECTED] Connection closed for {addr} #{open_connections-1}")
-        writer.close()
-        await writer.wait_closed()
-    finally:
-        open_connections -= 1
-        logger.info(f"[DISCONNECTED] Connection closed for {addr} #{open_connections-1}")
-        writer.close()
-        await writer.wait_closed()