socx-cli 0.1.0__py3-none-any.whl

src/socx/core/_uid.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from weakref import WeakValueDictionary
+from typing import ClassVar
+from threading import RLock
+
+
+class _UIDMeta(type):
+    __lock: ClassVar[RLock] = RLock()
+    __uid_map: ClassVar[dict[str, int]] = {}
+    __handles: ClassVar[dict[int, object]] = WeakValueDictionary()
+
+    def __call__(cls, *args, **kwargs) -> _UIDMeta:
+        inst = super().__call__(*args, **kwargs)
+        inst.__uid = cls._next_uid(inst)
+        cls.__handles[inst.__uid] = inst
+        return inst
+
+    def ref(cls) -> _UIDMeta:
+        return cls.__uid
+
+    @classmethod
+    def dref(cls, handle) -> _UIDMeta:
+        return cls.__handles.get(handle)
+
+    def _next_uid(cls, inst) -> int:
+        name = inst.__class__.__name__
+        with cls.__lock:
+            if name not in cls.__uid_map:
+                cls.__uid_map[name] = 0
+            rv = cls.__uid_map[name]
+            cls.__uid_map[name] += 1
+        return rv
+
+
+

src/socx/core/mixins.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from dataclasses import field
+from dataclasses import dataclass
+
+from ._uid import _UIDMeta
+
+
+class TypedPtrMixin(metaclass=_UIDMeta):
+    """
+    It is probably very unsafe in context of software-security, use this
+    for ez compute and lazy eval but using it in an object that also encrypts
+    ur password would probably be a rly bad idea.
+
+    Anyway I dont even think I need this I just thought it would be cool to
+    write so I did lol.
+    """
+
+    @property
+    def ref(self) -> int:
+        return _UIDMeta.ref(self)
+
+    @classmethod
+    def dref(cls, ref: int) -> TypedPtrMixin:
+        return _UIDMeta.dref(ref)
+
+
+@dataclass  # cuz a true alpha man never implements __repr__ themselves
+class UIDMixin(TypedPtrMixin):
+    """
+    A mixin class that generates unique instance ids for instances of the same
+    class.
+    """
+
+    uid: int = field(init=False, default=property(lambda self: self.ref))

src/socx/formatter.py

@@ -0,0 +1,61 @@
+import re
+import abc
+from typing import override
+from dataclasses import dataclass
+from jinja2 import Environment
+
+from dynaconf.utils.boxing import DynaBox
+
+from .parser import SymbolTable
+
+
+@dataclass
+class Formatter(abc.ABC):
+    @abc.abstractmethod
+    def format(
+        self, tokens: dict[str, DynaBox], matches: list[re.Match]
+    ) -> str:
+        """Format matches as text."""
+        ...
+
+
+class SystemVerilogFormatter(Formatter):
+    @override
+    def format(
+        self,
+        tokens: dict[str, DynaBox],
+        matches: list[re.Match],
+        sym_table: SymbolTable,
+    ) -> str:
+        state = True
+        env = Environment()
+        base = None
+        scope = None
+        header = ""
+        footer = ""
+        output = ""
+
+        for match in matches:
+            name = match.lastgroup
+            tok = tokens[name]
+
+            if tok.starts_scope:
+                output += header if state else footer
+                scope = match.expand(r"\g<device>_\g<mem>")
+                header = match.expand(tok.subst)
+                footer = match.expand(tok.scope_ender)
+                if scope and base and not state:
+                    template = env.from_string(output)
+                    output = template.render(base=base)
+                state = not state
+                base = None
+
+            if base is None:
+                base = match.group("addr")
+
+            output += match.expand(tok.subst)
+
+        output += footer
+        template = env.from_string(output)
+        output = template.render(base=base)
+        return output

src/socx/log.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+
+import os
+import logging
+from weakref import proxy
+from typing import Final, NewType
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+__all__ = (
+    # types
+    "Level",
+    # API
+    "log",
+    "info",
+    "warn",
+    "error",
+    "fatal",
+    "debug",
+    "warning",
+    "exception",
+    "critical",
+    "level",
+    "set_level",
+    "has_handlers",
+    "add_handler",
+    "get_handler",
+    "remove_handler",
+    "get_handler_names",
+    "add_filter",
+    "remove_filter",
+    "is_enabled_for",
+    # defaults
+    "DEFAULT_LEVEL",
+    "DEFAULT_FORMAT",
+    "DEFAULT_HANDLERS",
+    "DEFAULT_TIME_FORMAT",
+)
+
+Level: NewType = NewType("Level", int | str)
+"""
+Union type definition of `int | str` for annotating level arguments.
+"""
+
+DEFAULT_LEVEL: Final[Level] = os.environ.get("SOCX_VERBOSITY", logging.WARN)
+"""
+Default logger level, a.k.a verbosity.
+"""
+
+DEFAULT_FORMAT: Final[str] = os.environ.get("SOCX_LOG_FORMAT", "%(message)s")
+"""
+Default logger message format.
+"""
+
+DEFAULT_TIME_FORMAT: Final[str] = os.environ.get("SOCX_TIME_FORMAT", "[%X]")
+"""
+Default logger date format logs.
+"""
+
+DEFAULT_CHILD_FORMAT: Final[str] = os.environ.get(
+    "SOCX_LOG_FORMAT",
+    "%(asctime)s %(levelname)5s - %(filename)5s:%(lineno)-4d - %(message)s",
+)
+"""
+Default logger message format.
+"""
+
+DEFAULT_CHILD_FORMATTER: Final[str] = logging.Formatter(
+    DEFAULT_CHILD_FORMAT, DEFAULT_TIME_FORMAT
+)
+"""
+Default logger message format.
+"""
+
+DEFAULT_HANDLERS: Final[list[logging.Handler]] = [
+    RichHandler(
+        level=DEFAULT_LEVEL,
+        console=Console(tab_size=4, markup=True, force_terminal=True),
+        show_time=True,
+        show_level=True,
+        rich_tracebacks=False,
+        omit_repeated_times=False,
+        tracebacks_word_wrap=False,
+        tracebacks_show_locals=False,
+        log_time_format=DEFAULT_TIME_FORMAT,
+        tracebacks_theme="monokai",
+        locals_max_string=None,
+        locals_max_length=None,
+    ),
+]
+"""
+Default logging handlers of this module's default `logger`.
+"""
+
+
+def _get_logger() -> logging.Logger:
+    logging.basicConfig(
+        level=DEFAULT_LEVEL,
+        format=DEFAULT_FORMAT,
+        datefmt=DEFAULT_TIME_FORMAT,
+        handlers=DEFAULT_HANDLERS,
+    )
+    return logging.getLogger(__package__.partition(".")[0])
+
+
+_logger = _get_logger()
+
+
+def get_logger(name: str, filename: str | None = None) -> logging.Logger:
+    """
+    Get a pretty printing log handler.
+
+    Parameters
+    ----------
+    name: str
+        Name of the logger.
+
+    filename: str
+        Specifies that a FileHandler be created, using the specified filename
+
+    Returns
+    -------
+    A pretty printing logging.Logger instance.
+
+    """
+    rv = _logger.getChild(name)
+    if filename is not None:
+        handler = logging.FileHandler(
+            filename=filename, mode="w", encoding="utf-8"
+        )
+        handler.setFormatter(DEFAULT_CHILD_FORMATTER)
+        rv.addHandler(handler)
+    return rv
+
+
+def log(level: Level, msg: str, *args, **kwargs) -> None:
+    _logger.log(msg, *args, **kwargs)
+
+
+def info(msg: str, *args, **kwargs) -> None:
+    _logger.info(msg, *args, **kwargs)
+
+
+def warn(msg: str, *args, **kwargs) -> None:
+    _logger.warn(msg, *args, **kwargs)
+
+
+def error(msg: str, *args, **kwargs) -> None:
+    _logger.error(msg, *args, **kwargs)
+
+
+def fatal(msg: str, *args, **kwargs) -> None:
+    _logger.fatal(msg, *args, **kwargs)
+
+
+def debug(msg: str, *args, **kwargs) -> None:
+    _logger.debug(msg, *args, **kwargs)
+
+
+def warning(msg: str, *args, **kwargs) -> None:
+    _logger.warning(msg, *args, **kwargs)
+
+
+def exception(msg: str, *args, **kwargs) -> None:
+    _logger.exception(msg, *args, **kwargs)
+
+
+def critical(msg: str, *args, **kwargs) -> None:
+    _logger.critical(msg, *args, **kwargs)
+
+
+def level() -> str:
+    return _logger.getEffectiveLevel()
+
+
+def set_level(level: Level) -> None:
+    _logger.setLevel(level)
+
+
+def has_handlers() -> None:
+    _logger.hasHandlers()
+
+
+def add_handler(handler: logging.Handler) -> None:
+    _logger.addHandler(handler)
+
+
+def get_handler(name: str) -> logging.Handler:
+    return logging.getHandlerByName(name)
+
+
+def remove_handler(handler: logging.Handler) -> None:
+    _logger.removeHandler(handler)
+
+
+def get_handler_names() -> logging.Handlers:
+    return logging.getHandlerNames()
+
+
+def add_filter(filter: logging.Filter) -> None:  # noqa: A002
+    _logger.addFilter(filter)
+
+
+def remove_filter(filter: logging.Filter) -> None:  # noqa: A002
+    _logger.removeFilter(filter)
+
+
+def is_enabled_for(level: Level) -> bool:
+    if isinstance(level, str):
+        level = logging.getLevelName(level)
+    return _logger.isEnabledFor(level)
+
+logger = proxy(_logger)
+"""
+Default logging handler.
+
+Can be used for default logging when no custom behavior is required.
+
+If custom logging is needed, use `get_logger` method to get a custom handler
+instead.
+"""

src/socx/memory.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import typing as t
+import dataclasses as dc
+
+import rich as rich
+import rich.table as table
+
+
+@dc.dataclass(frozen=True)
+class MemorySegment:
+    origin: int
+    """
+    Origin/Base address of the address space.
+    """
+
+    length: int
+    """
+    Length/Size of the address space in bytes.
+    """
+
+    end: int
+    """
+    End/Highest memory address of the address space.
+    """
+
+
+@dc.dataclass(frozen=True)
+class DynamicSymbol:
+    name: str
+    """
+    Name identifier aliased with the symbol.
+    """
+
+    addr: int
+    """
+    Symbol start address in the relevant address space.
+    """
+
+    length: int
+    """
+    Total byte length symbol takes up in memory address space.
+    """
+
+    index: int
+    """
+    Index of symbol in symbol table.
+    """
+
+
+@dc.dataclass
+class SymbolTable(t.TypedDict):
+    device: str
+    """
+    Name identifier of the device associated with the address space.
+    """
+
+    segment: MemorySegment
+    """
+    Address space memory adress specification.
+    """
+
+    symbols: tuple[DynamicSymbol, ...] | None = None
+    """
+    Tuple listing of all dynamic symbols associated with the device and their
+    mapping within the address space.
+    """
+
+
+@table.dataclass
+class RichSymTable:
+    device: str
+    """
+    Name identifier of the device associated with the address space.
+    """
+
+    segment: MemorySegment
+    """
+    Address space memory adress specification.
+    """
+
+    symbols: tuple[DynamicSymbol, ...] | None = None
+    """
+    Tuple listing of all dynamic symbols associated with the device and their
+    mapping within the address space.
+    """

src/socx/parser.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+__all__ = ("Parser", "LstParser", "parse")
+
+
+import re as re
+import abc as abc
+import json as json
+import typing as t
+import pathlib as pathlib
+import dataclasses as dc
+from pathlib import Path as Path
+
+import rich as rich
+import click as click
+from dynaconf.utils.boxing import DynaBox
+
+from .console import console as console
+from .config import settings as settings
+from .memory import SymbolTable as SymbolTable
+from .memory import MemorySegment as MemorySegment
+from .memory import DynamicSymbol as DynamicSymbol
+from .tokenizer import Tokenizer as Tokenizer
+from .tokenizer import LstTokenizer as LstTokenizer
+from .validators import PathValidator as PathValidator
+
+
+class Parser(abc.ABC):
+    @abc.abstractmethod
+    def parse(self) -> None:
+        """Start the parser."""
+        ...
+
+    @property
+    @abc.abstractmethod
+    def lang(self) -> DynaBox:
+        """Return the 'lang' configuration of the parser's source language."""
+        ...
+
+
+@dc.dataclass
+class LstParser(Parser):
+    """
+    Parses .lst files to functions definitions represented as a
+    python object.
+
+    See DynamicSymbol, MemorySegment, SymbolTable.
+    """
+
+    options: dict[str, str] | None = None
+    includes: set[pathlib.Path] | None = None
+    excludes: set[pathlib.Path] | None = None
+    source_dir: pathlib.Path | None = None
+    target_dir: pathlib.Path | None = None
+
+    def __init__(
+        self: t.Self,
+        options: dict[str, str] | None = None,
+        includes: set[pathlib.Path] | None = None,
+        excludes: set[pathlib.Path] | None = None,
+        source_dir: pathlib.Path | None = None,
+        target_dir: pathlib.Path | None = None,
+    ) -> None:
+        """
+        Initialize the parser.
+
+        Parameters
+        ----------
+        source_dir
+            Source directory from which sources are included and parsed by the
+            parser.
+        target_dir
+            Target directory to which parsed sources will be saved with as
+            configured in convert.toml
+        options
+            Options for handling the conversion operation. See `convert.toml`
+            for additional info.
+        """
+        if options is None:
+            options = self.cfg.options
+        if includes is None:
+            includes = self.cfg.includes
+        if excludes is None:
+            excludes = self.cfg.excludes
+        if source_dir is None:
+            source_dir = self.cfg.source
+        if target_dir is None:
+            target_dir = self.cfg.target
+        self.options = options
+        self.includes = includes
+        self.excludes = excludes
+        self.source_dir = source_dir
+        self.target_dir = target_dir
+        self.includes = PathValidator._extract_includes(
+            self.source_dir, includes, excludes
+        )
+        self.sym_table = SymbolTable()
+
+    @property
+    def cfg(self) -> DynaBox:
+        return settings.convert[self.lang]
+
+    @property
+    def lang(self) -> DynaBox:
+        return "lst"
+
+    def parse(self) -> None:
+        """Parse the sources according to initialization configuration."""
+        self._parse_sym_table()
+
+    def _parse_sym_table(self: t.Self) -> SymbolTable:
+        memory_map = {}
+        base_addr_file = self.cfg.base_addr_map
+        base_addr_path = pathlib.Path(self.source_dir) / base_addr_file
+        field_names = tuple([field.name for field in dc.fields(MemorySegment)])
+        base_addr_map = json.loads(base_addr_path.read_text())
+        for name in field_names:
+            for device_field, value in base_addr_map.items():
+                if name not in device_field:
+                    continue
+                device = str(device_field).removesuffix(f"_{name}")
+                if device not in memory_map:
+                    memory_map[device] = {}
+                memory_map[device][name] = int(value, self.cfg.base_addr_base)
+        self.sym_table.clear()
+        for device in memory_map:
+            if all(name in memory_map[device] for name in field_names):
+                space = MemorySegment(**dict(memory_map[device].items()))
+                self.sym_table[device] = (space, None)
+        self.sym_table = self.sym_table
+        return self.sym_table
+
+    def __hash__(self) -> int:
+        return hash(tuple(self.includes))
+
+
+@click.pass_context
+def parse(ctx: click.Context) -> SymbolTable:
+    src = ctx.source_dir if hasattr(ctx, "source_dir") else None
+    target = ctx.target_dir if hasattr(ctx, "target_dir") else None
+    parser = LstParser(src, target)
+    parser.parse()
+    table = parser.sym_table
+    rich.print(parser)
+    rich.print(table)
+    return table
+
+
+def write(ctx: click.Context) -> None:
+    for asm in ctx.mods:
+        output_file = ctx.output / asm.file.with_suffix(".sv")
+        output_file.write_text(asm.to_sv())
+        print(f"SystemVerilog output successfuly written to {output_file}")

src/socx/reader.py

@@ -0,0 +1,47 @@
+import abc
+from typing import override
+from pathlib import Path
+from dataclasses import dataclass
+
+from .validators import PathValidator
+
+
+@dataclass
+class Reader(abc.ABC):
+    """
+    Reads input from one or more sources.
+
+    Attributes
+    ----------
+    source: Path
+        Source of input to read from.
+
+    includes: set[Path]
+        Names or patterns to include in the reading list.
+
+    exludes: set[Path]
+        Names or patterns to exclude from the reading list.
+    """
+
+    source: Path | None = None
+    includes: set[Path] | None = None
+    excludes: set[Path] | None = None
+
+    @abc.abstractmethod
+    def read(self) -> dict[Path, str]:
+        """Read text from one or more sources into a dictionary."""
+        ...
+
+
+@dataclass
+class FileReader(Reader):
+    @override
+    def read(self) -> dict[Path, str]:
+        return {path: path.read_text() for path in self.paths}
+
+    @property
+    def paths(self) -> set[Path]:
+        return PathValidator._extract_includes(
+            src=self.source, includes=self.includes, excludes=self.excludes
+        )
+

src/socx/regression/__init__.py

@@ -0,0 +1,14 @@
+__all__ = (
+    "Test",
+    "TestStatus",
+    "TestCommand",
+    "Regression",
+    "RegressionStatus",
+)
+
+from .test import Test as Test
+from .test import Status as TestStatus
+from .test import Command as TestCommand
+
+from .regression import Status as RegressionStatus
+from .regression import Regression as Regression