scpipy 0.1.0__tar.gz

scpipy-0.1.0/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: scpipy
+Version: 0.1.0
+Summary: Python SCPI I/O library with built-in client and server.

scpipy-0.1.0/README.md

@@ -0,0 +1,31 @@
+SCPIpy
+======
+
+A python package for support of the Standard Commands for Programmable Instruments (SCPI) that allows you to create a server and an asynchronous client.
+
+Descirption
+-----------
+
+The package provides (almost) full support for the SCPI standard for server creation, which simplifies the process of writing your code.
+
+“Full support” refers to all standard functionality (except for status registry at this time), including a command parser that constructs an AST tree.
+
+In addition, this package allows you to implement asynchronous communication with another SCPI server, since we have an asynchronous wrapper for pyVISA.
+
+Requirements
+------------
+
+- Python (3.10+)
+- VISA (or pyvisa-py for client)
+
+Installation
+------------
+
+Using pip:
+
+    $ pip install scpipy
+
+Documentation
+-------------
+
+The documentation can be read online at https://scpipy.readthedocs.org

scpipy-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scpipy"
+version = "0.1.0"
+description = "Python SCPI I/O library with built-in client and server."
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]

scpipy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scpipy-0.1.0/setup.py

@@ -0,0 +1,3 @@
+import setuptools
+
+setuptools.setup()

scpipy-0.1.0/src/scpipy/client/__init__.py

@@ -0,0 +1 @@
+from scpipy.client.client import Client

scpipy-0.1.0/src/scpipy/client/client.py

@@ -0,0 +1,136 @@
+import asyncio
+import contextlib
+import pyvisa
+
+
+from scpipy.client.exceptions import ClientConnectionError
+from scpipy.client.worker import Worker
+
+
+class Client:
+    def __init__(
+        self,
+        resource: str,
+        *,
+        backend: str | None = None,
+        open_timeout: int = 5000,
+        io_timeout: int = 5000,
+        read_termination: str = '\n',
+        write_termination: str = '\n',
+        encoding: str = 'utf-8',
+        chunk_size: int = 1024 * 1024,
+        queue_size: int = 0,
+    ):
+        self._resource = resource
+        self._backend = backend
+        self._open_timeout = open_timeout
+        self._io_timeout = io_timeout
+        self._read_termination = read_termination
+        self._write_termination = write_termination
+        self._encoding = encoding
+        self._chunk_size = chunk_size
+        self._queue_size = queue_size
+
+        self._rm: pyvisa.ResourceManager | None = None
+        self._instrument: pyvisa.resources.MessageBasedResource | None = None
+        self._worker: Worker | None = None
+
+        self._started = False
+        self._closed = False
+
+    async def connect(self):
+        if self._started:
+            return
+        if self._closed:
+            raise ClientConnectionError('Client is already closed')
+
+        try:
+            if self._backend:
+                self._rm = await asyncio.to_thread(
+                    pyvisa.ResourceManager, self._backend
+                )
+            else:
+                self._rm = await asyncio.to_thread(pyvisa.ResourceManager)
+
+            self._instrument = await asyncio.to_thread(
+                self._rm.open_resource,
+                self._resource,
+                open_timeout=self._open_timeout,
+                resource_pyclass=pyvisa.resources.MessageBasedResource,
+            )
+
+            self._instrument.timeout = self._io_timeout
+            self._instrument.read_termination = self._read_termination
+            self._instrument.write_termination = self._write_termination
+            self._instrument.chunk_size = self._chunk_size
+            self._instrument.encoding = self._encoding
+
+            self._worker = Worker(
+                self._instrument, queue_size=self._queue_size
+            )
+            self._worker.start()
+            self._started = True
+
+        except pyvisa.errors.VisaIOError as exc:
+            await self._cleanup_connect_error()
+            raise ClientConnectionError(
+                f'Failed to connect to {self._resource}: {exc}'
+            ) from exc
+        except Exception:
+            await self._cleanup_connect_error()
+            raise
+
+    async def close(self):
+        if self._closed:
+            return
+
+        try:
+            if self._worker is not None:
+                await self._worker.close()
+        finally:
+            self._worker = None
+            self._instrument = None
+
+            if self._rm is not None:
+                await asyncio.to_thread(self._rm.close)
+                self._rm = None
+
+            self._started = False
+            self._closed = True
+
+    async def __aenter__(self) -> 'Client':
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
+
+    async def write(self, command: str) -> int:
+        worker = self._get_worker()
+        return await worker.write(command)
+
+    async def read(self) -> str:
+        worker = self._get_worker()
+        return await worker.read()
+
+    async def query(self, command: str) -> str:
+        worker = self._get_worker()
+        return await worker.query(command)
+
+    def _get_worker(self) -> Worker:
+        if not self._started or self._worker is None:
+            raise ClientConnectionError('Client is not connected')
+        if self._closed:
+            raise ClientConnectionError('Client is already closed')
+        return self._worker
+
+    async def _cleanup_connect_error(self):
+        self._worker = None
+        self._instrument = None
+
+        if self._rm is not None:
+            with contextlib.suppress(Exception):
+                await asyncio.to_thread(self._rm.close)
+            self._rm = None
+
+        self._started = False

scpipy-0.1.0/src/scpipy/client/exceptions.py

@@ -0,0 +1,10 @@
+class ClientTimeoutError(Exception):
+    pass
+
+
+class ClientConnectionError(Exception):
+    pass
+
+
+class ClientStopped(Exception):
+    pass

scpipy-0.1.0/src/scpipy/client/models.py

@@ -0,0 +1,17 @@
+import asyncio
+import dataclasses
+import enum
+
+
+class OperationType(enum.Enum):
+    WRITE = enum.auto()
+    READ = enum.auto()
+    QUERY = enum.auto()
+    CLOSE = enum.auto()
+
+
+@dataclasses.dataclass(slots=True)
+class QueueItem:
+    type: OperationType
+    value: str | None
+    future: asyncio.Future

scpipy-0.1.0/src/scpipy/client/worker.py

@@ -0,0 +1,150 @@
+import asyncio
+import contextlib
+import pyvisa
+
+from scpipy.client.exceptions import ClientConnectionError, ClientStopped
+from scpipy.client.models import QueueItem, OperationType
+
+
+class Worker:
+
+    def __init__(
+        self,
+        instrument: pyvisa.resources.MessageBasedResource,
+        *,
+        queue_size: int = 0,
+    ):
+        self._instrument = instrument
+        self._queue: asyncio.Queue[QueueItem] = asyncio.Queue(
+            maxsize=queue_size
+        )
+        self._task: asyncio.Task[None] | None = None
+        self._closing = False
+        self._closed = False
+
+    def start(self):
+        if self._task is not None:
+            return
+        self._task = asyncio.create_task(
+            self._run(), name='scpipy-client-worker'
+        )
+
+    async def write(self, command: str) -> int:
+        result = await self._submit(OperationType.WRITE, command)
+        return int(result)
+
+    async def read(self) -> str:
+        result = await self._submit(OperationType.READ, None)
+        return str(result)
+
+    async def query(self, command: str) -> str:
+        result = await self._submit(OperationType.QUERY, command)
+        return str(result)
+
+    async def close(self):
+        if self._closed or self._closing:
+            return
+
+        self._closing = True
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[int | str | None] = loop.create_future()
+
+        await self._queue.put(QueueItem(OperationType.CLOSE, None, future))
+
+        try:
+            await future
+        finally:
+            if self._task is not None:
+                with contextlib.suppress(asyncio.CancelledError):
+                    await self._task
+
+            self._closed = True
+            self._closing = False
+
+    async def _submit(
+        self,
+        op: OperationType,
+        value: str | None,
+    ) -> int | str | None:
+        if self._closed:
+            raise ClientConnectionError('Client is already closed')
+        if self._closing:
+            raise ClientConnectionError('Client is closing')
+        if self._task is None:
+            raise ClientConnectionError('Client worker is not started')
+
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[int | str | None] = loop.create_future()
+        await self._queue.put(QueueItem(op, value, future))
+        return await future
+
+    async def _run(self):
+        try:
+            while True:
+                item = await self._queue.get()
+                try:
+                    if item.type is OperationType.CLOSE:
+                        await asyncio.to_thread(self._sync_close)
+                        if not item.future.done():
+                            item.future.set_result(None)
+                        break
+
+                    result = await self._execute_item(item)
+
+                    if not item.future.done():
+                        item.future.set_result(result)
+
+                except asyncio.CancelledError:
+                    raise
+                except pyvisa.errors.VisaIOError as exc:
+                    if not item.future.done():
+                        item.future.set_exception(exc)
+                except Exception as exc:
+                    if not item.future.done():
+                        item.future.set_exception(exc)
+                finally:
+                    self._queue.task_done()
+
+        except asyncio.CancelledError:
+            raise
+        finally:
+            self._fail_pending_operations(ClientStopped())
+            self._closed = True
+
+    async def _execute_item(self, item: QueueItem) -> int | str:
+        match (item.type):
+            case OperationType.WRITE:
+                if item.value is None:
+                    raise ValueError('Write operation requires command')
+                return await asyncio.to_thread(
+                    self._instrument.write, item.value
+                )
+
+            case OperationType.READ:
+                return await asyncio.to_thread(self._instrument.read)
+
+            case OperationType.QUERY:
+                if item.value is None:
+                    raise ValueError('Query operation requires command')
+                return await asyncio.to_thread(
+                    self._instrument.query, item.value
+                )
+
+            case _:
+                raise ValueError(f'Unsupported operation type: {item.type}')
+
+    def _sync_close(self):
+        self._instrument.close()
+
+    def _fail_pending_operations(self, exc: Exception):
+        while True:
+            try:
+                item = self._queue.get_nowait()
+            except asyncio.QueueEmpty:
+                break
+
+            try:
+                if not item.future.done():
+                    item.future.set_exception(exc)
+            finally:
+                self._queue.task_done()

scpipy-0.1.0/src/scpipy/server/__init__.py

@@ -0,0 +1,3 @@
+from scpipy.server.server import Server
+from scpipy.server.routing import Router
+from scpipy.server.context import Context

scpipy-0.1.0/src/scpipy/server/builtin_router.py

@@ -0,0 +1,14 @@
+from scpipy.server.context import Context
+from scpipy.server.routing import Router
+
+builtin_router = Router()
+
+
+@builtin_router.register('*CLS')
+def clear_errors(context: Context):
+    context.clear_errors()
+
+
+@builtin_router.register('SYSTem:ERRor[:NEXT]?')
+def system_error(context: Context) -> str:
+    return context.get_error()

scpipy-0.1.0/src/scpipy/server/context.py

@@ -0,0 +1,18 @@
+from scpipy.shared.errors import (
+    ErrorQueue,
+    ScpiError,
+)
+
+
+class Context:
+    def __init__(self, error_queue_size: int = 100):
+        self.error_queue = ErrorQueue(error_queue_size)
+
+    def push_error(self, error: ScpiError):
+        self.error_queue.put(error)
+
+    def get_error(self) -> str:
+        return str(self.error_queue.get())
+
+    def clear_errors(self):
+        self.error_queue.clear()

scpipy-0.1.0/src/scpipy/server/dispatcher.py

@@ -0,0 +1,103 @@
+import asyncio
+
+from scpipy.server.exceptions import RouteNotFound
+from scpipy.server.routing import Router, Route
+from scpipy.server.context import Context
+
+from scpipy.shared.parser import Parser, ParseError
+from scpipy.shared.ast import Command, Node
+from scpipy.shared.errors import ScpiException, DefaultScpiErrors
+
+
+class Dispatcher:
+    def __init__(self, router: Router, terminator: str):
+        self._router = router
+        self._terminator = terminator
+
+        self._parser = Parser()
+
+    async def _dispatch(self, context: Context, data: bytes) -> bytes | None:
+        line = data.decode()
+
+        try:
+            commands = self._parser.parse(line)
+        except ParseError:
+            raise ScpiException(DefaultScpiErrors.SYNTAX_ERROR.value)
+
+        responses = []
+
+        for command in commands:
+            response = await self._dispatch_command(context, command)
+            if response is not None:
+                responses.append(response)
+
+        if not responses:
+            return None
+
+        payload = ';'.join(responses) + self._terminator
+        return payload.encode()
+
+    async def _dispatch_command(
+        self, context: Context, command: Command
+    ) -> str | None:
+        try:
+            route = self._route(command)
+        except RouteNotFound:
+            raise ScpiException(DefaultScpiErrors.COMMAND_HEADER_ERROR.value)
+
+        args = [arg.value for arg in command.args]
+
+        try:
+            result = route.handler(context, *args)
+        except TypeError:
+            raise ScpiException(DefaultScpiErrors.DATA_TYPE_ERROR.value)
+
+        if asyncio.iscoroutine(result):
+            result = await result
+
+        if result is None:
+            return None
+
+        return str(result)
+
+    def _route(self, command: Command) -> Route:
+        for route in self._router.routes.values():
+            if self._match_command(command, route.pattern):
+                return route
+
+        raise RouteNotFound
+
+    def _match_command(self, command: Command, pattern: Command) -> bool:
+        if command.common != pattern.common:
+            return False
+
+        if command.query != pattern.query:
+            return False
+
+        return self._match_nodes(command.nodes, pattern.nodes)
+
+    def _match_nodes(
+        self, nodes: list[Node], pattern_nodes: list[Node]
+    ) -> bool:
+        node_index = 0
+
+        for pattern_node in pattern_nodes:
+            if node_index >= len(nodes):
+                return pattern_node.optional
+
+            if self._match_node(nodes[node_index], pattern_node):
+                node_index += 1
+            elif not pattern_node.optional:
+                return False
+
+        return node_index == len(nodes)
+
+    @staticmethod
+    def _match_node(node: Node, pattern: Node) -> bool:
+        if node.short != pattern.short:
+            return False
+
+        node_arg = node.arg.value if node.arg is not None else None
+        pattern_arg = pattern.arg.value if pattern.arg is not None else None
+
+        return node_arg == pattern_arg

scpipy-0.1.0/src/scpipy/server/exceptions.py

@@ -0,0 +1,14 @@
+class ConfigureException(Exception):
+    pass
+
+
+class AlreadyStarted(Exception):
+    pass
+
+
+class LogicException(Exception):
+    pass
+
+
+class RouteNotFound(Exception):
+    pass

scpipy-0.1.0/src/scpipy/server/routing.py

@@ -0,0 +1,68 @@
+import dataclasses
+from collections.abc import Callable, Iterable
+
+from scpipy.server.exceptions import RouteNotFound
+
+from scpipy.shared.parser import Parser
+from scpipy.shared.ast import Command
+
+
+@dataclasses.dataclass
+class Route:
+    command: str
+    handler: Callable
+
+    pattern: Command = dataclasses.field(init=False)
+
+    def __post_init__(self):
+        parser = Parser()
+        commands = parser.parse(self.command)
+
+        if len(commands) != 1:
+            raise ValueError('Route must contain exactly one command')
+
+        self.pattern = commands[0]
+
+
+class Router:
+    def __init__(self):
+        self._routes: dict[str, Route] = {}
+
+    @property
+    def routes(self) -> dict[str, Route]:
+        return self._routes
+
+    def route(self, command: str) -> Route:
+        target = self.routes.get(command)
+        if target is None:
+            raise RouteNotFound
+
+        return target
+
+    def register(self, command: str):
+        def wrapper(func: Callable):
+            self._add_route(command, func)
+
+        return wrapper
+
+    def include_router(self, routers: 'Router' | Iterable['Router']):
+        if isinstance(routers, Router):
+            routers = [routers]
+
+        for router in routers:
+            for route in router.routes.values():
+                if route.command in self.routes.keys():
+                    raise ValueError('Route already registered')
+
+                self._add_route(route.command, route.handler)
+
+    def _add_route(self, command: str, handler: Callable):
+        route = Route(command=command, handler=handler)
+
+        if any(
+            existing.pattern == route.pattern
+            for existing in self._routes.values()
+        ):
+            raise ValueError('Route already registered')
+
+        self._routes[command] = route

scpipy-0.1.0/src/scpipy/server/server.py

@@ -0,0 +1,163 @@
+import asyncio
+
+from collections.abc import Iterable
+
+from . import exceptions
+from . import dispatcher
+from scpipy.server.routing import Router
+from scpipy.server.context import Context
+from scpipy.server.builtin_router import builtin_router
+
+from scpipy.shared.errors import ScpiException
+
+
+class Server:
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        terminator: str = '\n',
+        error_queue_size: int = 100,
+        shared_context: bool = False,
+    ):
+        self._host: str = host
+        self._port: int = port
+
+        self._server: asyncio.Server | None = None
+        self._stop_event: asyncio.Event = asyncio.Event()
+
+        self._client_tasks: set[asyncio.Task] = set()
+        self._client_writers: set[asyncio.StreamWriter] = set()
+
+        self._router = builtin_router
+        self._dispatcher = dispatcher.Dispatcher(self._router, terminator)
+
+        self._error_queue_size = error_queue_size
+
+        self._context = None
+        if shared_context:
+            self._context = self._create_context()
+
+    def include_router(self, routers: Router | Iterable[Router]):
+        self._router.include_router(routers)
+
+    def run(self):
+        if self._host is None or self._port is None:
+            raise exceptions.ConfigureException(
+                'Host or port was not configured'
+            )
+
+        if self._server is not None:
+            raise exceptions.AlreadyStarted('Server already started')
+
+        self._stop_event.clear()
+        asyncio.run(self._listen())
+
+    def stop(self):
+        self._stop_event.set()
+
+    async def _listen(self):
+        self._server = await asyncio.start_server(
+            self._handle_client, self._host, self._port
+        )
+
+        await self._wait_stop()
+        await self._close()
+        await self._close_writers()
+        await self._close_tasks()
+
+    async def _wait_stop(self):
+        await self._stop_event.wait()
+
+    async def _handle_client(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ):
+        if self._dispatcher is None:
+            raise exceptions.LogicException('Dispatcher was not configured')
+
+        context = self._get_context()
+
+        task = asyncio.current_task()
+        self._init_client(writer, task)
+
+        try:
+            while not self._stop_event.is_set():
+                data = await reader.readline()
+                if not data:
+                    break
+
+                try:
+                    response = await self._dispatcher._dispatch(context, data)
+                except ScpiException as exc:
+                    context.push_error(exc.error)
+                    continue
+
+                if response:
+                    writer.write(response)
+                    await writer.drain()
+
+        except asyncio.CancelledError:
+            raise
+        finally:
+            await self._close_client(writer, task)
+
+    def _init_client(
+        self, writer: asyncio.StreamWriter, task: asyncio.Task | None
+    ):
+        if task is not None:
+            self._client_tasks.add(task)
+        self._client_writers.add(writer)
+
+    async def _close_client(
+        self, writer: asyncio.StreamWriter, task: asyncio.Task | None
+    ):
+        self._client_writers.discard(writer)
+
+        if task is not None:
+            self._client_tasks.discard(task)
+
+        writer.close()
+        try:
+            await writer.wait_closed()
+        except Exception:
+            pass
+
+    async def _close(self):
+        if self._server is None:
+            raise exceptions.LogicException('Server cleaned up before')
+
+        self._server.close()
+        await self._server.wait_closed()
+        self._server = None
+
+    async def _close_writers(self):
+        writers = list(self._client_writers)
+        for writer in writers:
+            writer.close()
+
+        if writers:
+            await asyncio.gather(
+                *(writer.wait_closed() for writer in writers),
+                return_exceptions=True
+            )
+
+    async def _close_tasks(self):
+        tasks = list(self._client_tasks)
+        for task in tasks:
+            task.cancel()
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    def _get_context(self) -> Context:
+        if self._shared_context():
+            assert self._context is not None
+            return self._context
+
+        return self._create_context()
+
+    def _create_context(self) -> Context:
+        return Context(error_queue_size=self._error_queue_size)
+
+    def _shared_context(self) -> bool:
+        return self._context is not None

scpipy-0.1.0/src/scpipy/shared/__init__.py

@@ -0,0 +1 @@
+from scpipy.shared.parser import Parser

scpipy-0.1.0/src/scpipy/shared/ast.py

@@ -0,0 +1,23 @@
+import dataclasses
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Argument:
+    value: str
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Node:
+    short: str
+    full: str
+    arg: Argument | None = None
+    optional: bool = False
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Command:
+    nodes: list[Node]
+    args: list[Argument] = dataclasses.field(default_factory=list)
+    query: bool = False
+    root_node: bool = False
+    common: bool = False

scpipy-0.1.0/src/scpipy/shared/errors.py

@@ -0,0 +1,48 @@
+import collections
+import dataclasses
+import enum
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class ScpiError:
+    code: int
+    message: str
+
+    def __str__(self) -> str:
+        return f'{self.code},"{self.message}"'
+
+
+class DefaultScpiErrors(enum.Enum):
+    NO_ERROR = ScpiError(0, 'No error')
+    SYNTAX_ERROR = ScpiError(-102, 'Syntax error')
+    DATA_TYPE_ERROR = ScpiError(-104, 'Data type error')
+    COMMAND_HEADER_ERROR = ScpiError(-110, 'Command header error')
+    QUEUE_OVERFLOW = ScpiError(-350, 'Queue overflow')
+
+
+class ScpiException(Exception):
+    def __init__(self, error: ScpiError):
+        self.error = error
+        super().__init__(str(error))
+
+
+class ErrorQueue:
+    def __init__(self, max_size: int):
+        self.__queue = collections.deque(maxlen=max_size)
+
+    def get(self) -> str:
+        if not self.__queue:
+            return str(DefaultScpiErrors.NO_ERROR.value)
+
+        return str(self.__queue.popleft())
+
+    def put(self, item: ScpiError):
+        if len(self.__queue) == self.__queue.maxlen:
+            self.__queue.pop()
+            self.__queue.append(DefaultScpiErrors.QUEUE_OVERFLOW.value)
+            return
+
+        self.__queue.append(item)
+
+    def clear(self):
+        self.__queue.clear()

scpipy-0.1.0/src/scpipy/shared/exceptions.py

@@ -0,0 +1,2 @@
+class ParseError(Exception):
+    pass

scpipy-0.1.0/src/scpipy/shared/parser.py

@@ -0,0 +1,205 @@
+import re
+
+from scpipy.shared.ast import Argument, Command, Node
+from scpipy.shared.exceptions import ParseError
+from scpipy.shared.utils import (
+    format_scpi_full_keyword,
+    format_scpi_short_keyword,
+)
+
+_NODE_TOKEN_RE = re.compile(r'^([A-Z*]+)(\d+)?$')
+
+
+class Parser:
+    def parse(self, line: str) -> list[Command]:
+        result = []
+        scope_nodes = []
+
+        for command in self._split_block(line):
+            parsed = self._parse_command(command, scope_nodes)
+
+            if parsed.common:
+                scope_nodes = []
+            else:
+                scope_nodes = parsed.nodes[:-1]
+
+            result.append(parsed)
+
+        return result
+
+    def _parse_command(self, command: str, scope_nodes: list[Node]) -> Command:
+        if not (command := command.strip()):
+            raise ParseError('Empty command')
+
+        common = command.startswith('*')
+        rooted = common or command.startswith(':')
+
+        if rooted and not common:
+            command = command[1:]
+
+        header, args = self._split_node_and_args(command)
+        args = self._build_args(args)
+
+        query = header.endswith('?')
+        if query:
+            header = header[:-1]
+
+        if common:
+            nodes = [self._build_node(header, optional=False)]
+        else:
+            local_nodes = self._parse_header_nodes(header)
+
+            if rooted or not scope_nodes:
+                nodes = local_nodes
+            else:
+                nodes = scope_nodes + local_nodes
+
+        return Command(
+            nodes=nodes,
+            args=args,
+            query=query,
+            root_node=rooted,
+            common=common,
+        )
+
+    @staticmethod
+    def _split_block(line: str) -> list[str]:
+        line = line.strip()
+        if not line:
+            raise ParseError('Empty line')
+
+        return [
+            command.strip() for command in line.split(';') if command.strip()
+        ]
+
+    @classmethod
+    def _parse_header_nodes(cls, header: str) -> list[Node]:
+        parts = cls._split_nodes(header)
+        nodes = []
+        for node in parts:
+            nodes.extend(cls._parse_node_part(node))
+        return nodes
+
+    @staticmethod
+    def _split_nodes(command: str) -> list[str]:
+        command = command.strip()
+        if not command:
+            raise ParseError('Command must contain at least one node')
+
+        nodes = []
+        current = ''
+        in_brackets = False
+
+        for character in command:
+            if character == '[':
+                if in_brackets:
+                    raise ParseError('Invalid bracket usage')
+                in_brackets = True
+            elif character == ']':
+                if not in_brackets:
+                    raise ParseError('Invalid bracket usage')
+                in_brackets = False
+            elif character == ':' and not in_brackets:
+                node = current.strip()
+                if node:
+                    nodes.append(node)
+                current = ''
+                continue
+
+            current += character
+
+        if in_brackets:
+            raise ParseError('Invalid bracket usage')
+
+        last_node = current.strip()
+        if last_node:
+            nodes.append(last_node)
+
+        if not nodes:
+            raise ParseError('Command must contain at least one node')
+
+        return nodes
+
+    @classmethod
+    def _parse_node_part(cls, line: str) -> list[Node]:
+        line = line.strip()
+        if not line:
+            raise ParseError('Invalid node')
+
+        if '[:' not in line:
+            if '[' in line or ']' in line:
+                raise ParseError('Invalid bracket usage')
+            return [cls._build_node(line, optional=False)]
+
+        required_node, optional_node = cls._split_optional_node(line)
+
+        nodes: list[Node] = []
+        if required_node:
+            nodes.append(cls._build_node(required_node, optional=False))
+        nodes.append(cls._build_node(optional_node, optional=True))
+        return nodes
+
+    @staticmethod
+    def _split_optional_node(line: str) -> tuple[str, str]:
+        if not line.endswith(']'):
+            raise ParseError('Invalid bracket usage')
+
+        body = line[:-1]
+        required_node, optional_node = body.split('[:', 1)
+
+        required_node = required_node.strip()
+        optional_node = optional_node.strip()
+
+        if not optional_node:
+            raise ParseError('Invalid node')
+
+        return required_node, optional_node
+
+    @classmethod
+    def _build_node(cls, token: str, optional: bool) -> Node:
+        keyword, arg = cls._split_node(token)
+        arg = cls._build_arg(arg) if arg is not None else None
+
+        return Node(
+            short=format_scpi_short_keyword(keyword),
+            full=format_scpi_full_keyword(keyword),
+            arg=arg,
+            optional=optional,
+        )
+
+    @staticmethod
+    def _build_arg(value: str) -> Argument:
+        return Argument(value=value)
+
+    @classmethod
+    def _build_args(cls, args: list[str]) -> list[Argument]:
+        return [cls._build_arg(arg) for arg in args]
+
+    @staticmethod
+    def _split_node(node: str) -> tuple[str, str | None]:
+        node = node.strip()
+        if not node:
+            raise ParseError('Invalid node')
+
+        match = _NODE_TOKEN_RE.fullmatch(node.upper())
+        if not match:
+            raise ParseError('Invalid node')
+
+        keyword = match.group(1)
+        arg = match.group(2)
+        return keyword, arg
+
+    @staticmethod
+    def _split_node_and_args(line: str) -> tuple[str, list[str]]:
+        line = line.strip()
+        if not line:
+            raise ParseError('Empty command')
+
+        parts = line.split(maxsplit=1)
+        node = parts[0]
+
+        if len(parts) == 1:
+            return node, []
+
+        args = [arg.strip() for arg in parts[1].split(',') if arg.strip()]
+        return node, args

scpipy-0.1.0/src/scpipy/shared/utils.py

@@ -0,0 +1,14 @@
+def scpi_short_length(keyword: str) -> int:
+    if len(keyword) < 4:
+        return len(keyword)
+    return 3 if keyword[3] in 'aeiouAEIOU' else 4
+
+
+def format_scpi_short_keyword(keyword: str) -> str:
+    n = scpi_short_length(keyword)
+    return keyword[:n].upper()
+
+
+def format_scpi_full_keyword(keyword: str) -> str:
+    n = scpi_short_length(keyword)
+    return keyword[:n].upper() + keyword[n:].lower()

scpipy-0.1.0/src/scpipy.egg-info/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: scpipy
+Version: 0.1.0
+Summary: Python SCPI I/O library with built-in client and server.

scpipy-0.1.0/src/scpipy.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+README.md
+pyproject.toml
+setup.py
+src/scpipy/__init__.py
+src/scpipy.egg-info/PKG-INFO
+src/scpipy.egg-info/SOURCES.txt
+src/scpipy.egg-info/dependency_links.txt
+src/scpipy.egg-info/top_level.txt
+src/scpipy/client/__init__.py
+src/scpipy/client/client.py
+src/scpipy/client/exceptions.py
+src/scpipy/client/models.py
+src/scpipy/client/worker.py
+src/scpipy/server/__init__.py
+src/scpipy/server/builtin_router.py
+src/scpipy/server/context.py
+src/scpipy/server/dispatcher.py
+src/scpipy/server/exceptions.py
+src/scpipy/server/routing.py
+src/scpipy/server/server.py
+src/scpipy/shared/__init__.py
+src/scpipy/shared/ast.py
+src/scpipy/shared/errors.py
+src/scpipy/shared/exceptions.py
+src/scpipy/shared/parser.py
+src/scpipy/shared/utils.py

scpipy-0.1.0/src/scpipy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scpipy-0.1.0/src/scpipy.egg-info/top_level.txt

@@ -0,0 +1 @@
+scpipy