glyphsynth 0.1.0__py3-none-any.whl

glyphsynth/__init__.py

@@ -0,0 +1,9 @@
+from pyrollup import rollup
+
+from . import core
+from . import lib
+
+from .core import *
+from .lib import *
+
+__all__ = rollup(core, lib)

glyphsynth/cli/export.py

@@ -0,0 +1,53 @@
+from types import ModuleType
+from typing import Any, Literal
+
+from ..core.glyph import BaseGlyph
+
+
+def invoke_export(
+    path_cls: str, path_output: str, format: Literal["svg", "png"] | None
+):
+    print(
+        f"Exporting: modpath={path_cls}, path_output={path_output}, format={format}"
+    )
+
+    # get class to be imported
+    glyph_cls: type[BaseGlyph] = _get_glyph_cls(path_cls)
+
+    print(f"--- got glyph_cls: {glyph_cls}")
+
+    # instantiate glyph
+    glyph: BaseGlyph = glyph_cls()
+
+    # export glyph
+    glyph.export(path_output, format)
+
+
+def _get_glyph_cls(path_cls: str) -> type[BaseGlyph]:
+    modpath: str
+    cls_name: str
+
+    modpath, cls_name = _parse_path_cls(path_cls)
+
+    print(f"--- importing {cls_name} from {modpath}")
+
+    mod: ModuleType = __import__(modpath, fromlist=[cls_name])
+    glyph_cls: Any = getattr(mod, cls_name)
+
+    assert issubclass(glyph_cls, BaseGlyph)
+    return glyph_cls
+
+
+def _parse_path_cls(path_cls: str) -> tuple[str, str]:
+    """
+    Return modpath and class name.
+    """
+    modpath: str
+    cls_name: str
+
+    path_split: list[str] = path_cls.rsplit(".", maxsplit=1)
+    assert len(path_split) == 2, f"Invalid path_cls: {path_cls}"
+
+    modpath, cls_name = path_split
+
+    return (modpath, cls_name)

glyphsynth/cli/main.py

@@ -0,0 +1,51 @@
+from typing_extensions import Annotated
+from typing import Union, Literal
+
+import typer
+
+from .export import invoke_export
+
+
+app = typer.Typer(
+    add_completion=False, invoke_without_command=False, no_args_is_help=True
+)
+
+
+# Dummy callback required in order to allow having a single subcommand
+@app.callback()
+def main():
+    pass
+
+
+@app.command(no_args_is_help=True)
+def export(
+    path_cls: Annotated[
+        str,
+        typer.Argument(help="Path to Python class, e.g. my_pkg.my_mod.MyGlyph"),
+    ],
+    path_output: Annotated[
+        str,
+        typer.Argument(
+            help="Path to output file or folder; if folder, filename generated by class name"
+        ),
+    ],
+    format: Annotated[
+        str,
+        typer.Argument(
+            help='"svg" or "png", or leave empty to determine from filename if possible, defaulting to "svg"'
+        ),
+    ] = None,
+):
+    assert format in {"svg", "png", None}, f"Invalid format: {format}"
+    invoke_export(path_cls, path_output, format)
+
+
+def run():
+    """
+    Entry point of `glyphsynth` command.
+    """
+    app()
+
+
+if __name__ == "__main__":
+    run()

glyphsynth/core/__init__.py

@@ -0,0 +1,9 @@
+from pyrollup import rollup
+
+from . import glyph
+from . import graphics
+
+from .glyph import *
+from .graphics import *
+
+__all__ = rollup(glyph, graphics)

glyphsynth/core/glyph.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Self, TypeVar, get_args, cast
+
+from pydantic import BaseModel, ConfigDict
+
+from .graphics.graphics import (
+    GraphicsContainer,
+    BaseContainer,
+)
+from .graphics.properties import Properties
+
+__all__ = [
+    "BaseParams",
+    "BaseGlyph",
+    "EmptyParams",
+    "EmptyGlyph",
+]
+
+
+class IdFactory:
+    _cls_map: dict[type[BaseGlyph], int]
+
+    def __init__(self):
+        self.reset()
+
+    def get_id(self, glyph_cls: type[BaseGlyph]) -> int:
+        if glyph_cls not in self._cls_map:
+            self._cls_map[glyph_cls] = 0
+
+        self._cls_map[glyph_cls] += 1
+
+        return self._cls_map[glyph_cls]
+
+    def reset(self):
+        self._cls_map = dict()
+
+
+id_factory = IdFactory()
+
+
+class BaseParams(BaseModel):
+    """
+    Subclass this class to create parameters for a Glyph.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+# def __init_subclass__(cls):
+#    dataclass(frozen=True, kw_only=True)(cls)
+
+
+class EmptyParams(BaseParams):
+    pass
+
+
+class BaseGlyph[ParamsT: BaseParams](ABC, GraphicsContainer, BaseContainer):
+    """
+    Base class for a standalone or reusable glyph, sized in abstract
+    (user) units.
+    """
+
+    params: ParamsT
+    """
+    Instance of params with type as specified by typevar.
+    """
+
+    DefaultParams: type[ParamsT] | None = None
+    """
+    Subclass of ParamsT to use as defaults for this particular Glyph,
+    if no parameters provided during instantiation.
+    """
+
+    _params_cls: type[ParamsT]
+    """
+    Params class: the type parameter provided as ParamsT, or EmptyParams
+    if no type parameter provided.
+    """
+
+    def __init__(
+        self,
+        *,
+        glyph_id: str | None = None,
+        params: ParamsT | None = None,
+        properties: Properties | None = None,
+        size: tuple[float, float] | None = None,
+        parent: BaseGlyph | None = None,
+        insert: tuple[float, float] | None = None,
+    ):
+        """
+        :param parent: Parent glyph, or `None`{l=python} to create top-level glyph
+        :param glyph_id: Unique identifier, or `None`{l=python} to generate one
+        """
+
+        # if parent not provided, ensure insert/size_inst not provided
+        if parent is None:
+            assert insert is None
+
+        glyph_id = glyph_id or self._get_id()
+
+        super().__init__(glyph_id, properties, size)
+
+        # set params
+        self.params = params or type(self).params_cls()
+
+        # invoke subclass's init (e.g. set properties based on params)
+        self.init()
+
+        # invoke post-init since size_canon may be set in init()
+        self._init_post()
+
+        # invoke subclass's drawing logic
+        self.draw()
+
+        if parent is not None:
+            parent.insert_glyph(self, insert)
+
+    def __init_subclass__(cls: type[BaseGlyph]):
+        """
+        Populate _params_cls with the class representing the parameters for
+        this glyph. If not subscripted with a type arg by the subclass,
+        _params_cls is set to EmptyParams.
+        """
+
+        # note: pyright is not yet aware that the new style
+        #
+        # class BaseGlyph[ParamsT: BaseParams](...): ...
+        #
+        #   is equivalent to
+        #
+        # ParamsT = TypeVar("ParamsT", bound=BaseParams)
+        # class BaseGlyph(Generic[ParamsT], ...): ...
+        #
+        # since with the new style, Generic is not a base. Nonetheless
+        # __orig_bases__ is indeed defined here.
+        orig_bases = (
+            cls.__orig_bases__  # pyright: ignore[reportGeneralTypeIssues]
+        )
+
+        # get_args() returns tuple[Any, ...], but we know the type param
+        # should always be ParamsT
+        args: tuple[type[ParamsT]] = cast(
+            tuple[type[ParamsT]], get_args(orig_bases[0])
+        )
+
+        if len(args) > 0:
+            assert len(args) == 1
+
+            params_cls: type[ParamsT]
+
+            if isinstance(args[0], TypeVar):
+                # have a TypeVar, look up its bound
+                type_var = cast(TypeVar, args[0])
+                assert type_var.__bound__ is not None
+                params_cls = type_var.__bound__
+            else:
+                # already have a class
+                params_cls = args[0]
+
+            cls._params_cls = params_cls
+        else:
+            # set _params_cls with EmptyParams
+            cls._params_cls = EmptyParams
+
+        assert issubclass(cls._params_cls, BaseParams)
+
+    @property
+    def glyph_id(self) -> str:
+        """
+        A meaningful identifier to associate with this glyph. Also used as
+        base name (without extension) of file to write when no filename is
+        provided.
+        """
+        return self._id
+
+    @classmethod
+    @property
+    def params_cls(cls) -> type[ParamsT]:
+        """
+        Returns the {obj}`BaseParams` subclass with which this class is
+        parameterized, accounting for any default values provided by
+        the subclass.
+        """
+        return cls.DefaultParams or cls._params_cls
+
+    def insert_glyph(
+        self,
+        glyph: BaseGlyph,
+        insert: tuple[float, float] | None = None,
+    ) -> Self:
+        glyph._bind(self, insert)
+        return self
+
+    def init(self):
+        ...
+
+    @abstractmethod
+    def draw(self):
+        ...
+
+    # TODO_NEXT 2
+    # - move to subclass of BaseClass
+    #   - rename BaseClass -> _BaseClass?
+    # try:
+    # def draw_glyph[GlyphT: BaseGlyph, GlyphParamsT: BaseParams](self,
+    #    glyph_cls: type[GlyphT[GlyphParamsT]], params: GlyphParamsT) -> GlyphT[GlyphParamsT]:
+    #    return glyph_cls(parent=self, params=params)
+
+    def _get_id(self) -> str:
+        global id_factory
+        id_num: int = id_factory.get_id(type(self))
+        return f"{type(self).__name__}-{id_num}"
+
+
+class EmptyGlyph(BaseGlyph[EmptyParams]):
+    """
+    Glyph to use as an on-the-fly alternative to subclassing
+    {obj}`BaseGlyph`. It has an empty {obj}`BaseGlyph.draw`
+    implementation; the user can then add graphics objects
+    and other glyphs after creation.
+
+    Example:
+
+    ```python
+    glyph1 = MyGlyph1()
+    glyph2 = MyGlyph2()
+
+    # create an empty glyph with unspecified size
+    glyph = EmptyGlyph()
+
+    # insert a glyph
+    glyph.insert_glyph(glyph1)
+
+    # insert another glyph in a different position
+    glyph.insert_glyph(glyph2, (100, 100))
+    ```
+    """
+
+    def draw(self):
+        pass

glyphsynth/core/graphics/__init__.py

@@ -0,0 +1,15 @@
+from pyrollup import rollup
+
+from . import graphics, draw, export, container, properties
+
+from .graphics import *
+from .draw import *
+from .export import *
+from .container import *
+from .properties import *
+
+__all__ = rollup(graphics, draw, export, container, properties)
+
+# TODO: add types.py?
+# - Coordinate
+# - Box/Area

glyphsynth/core/graphics/container.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import logging
+
+from svgwrite.drawing import Drawing
+from svgwrite.container import SVG, Group
+
+from .properties import Properties
+
+
+__all__ = []
+
+
+class BaseContainer:
+    """
+    Container for drawing and manipulation of low-level graphics objects.
+
+    There are 2 SVG trees maintained:
+    1. Standalone glyph
+        drawing (root <svg>)
+            wrapper svg (if size provided)
+                canonical svg
+    2. Placement in parent glyph
+        svg-parent
+            svg-wrapper-placement (insert only)
+                group (w/transforms, e.g. rotation)
+                    svg-wrapper-scaling (width/height/viewbox only)
+                        svg-canonical
+    """
+
+    DefaultProperties: type[Properties] = Properties
+    """
+    Subclass of Properties with properties set as class attributes.
+    
+    May be subclassed in-place or assigned to an existing subclass.
+    For example, subclassing in-place:
+
+    ```python
+    class MyGlyph(BaseGlyph):
+
+        class DefaultProperties(Properties):
+            color: PropertyValue = "black"
+            stroke_width: PropertyValue = "10"
+        
+        ...
+    ```
+    """
+
+    properties: Properties
+    """
+    Properties automatically propagated to graphics objects in draw_*() APIs.
+    """
+
+    size_canon: tuple[float, float] | None = None
+    """
+    Canonical size in user units, as provided by concrete class either as class
+    attribute or upon creation in {obj}`BaseGlyph.init`.
+
+    Used to set a consistent size for drawing, invariant of the size 
+    passed upon instantiation.
+
+    May be `None`, in which case {obj}`BaseContainer.size`, 
+    {obj}`BaseContainer.width`, and {obj}`BaseContainer.height`
+    will return `None`.
+
+    Note that some {obj}`BaseGlyph` subclasses may require that 
+    this field is not `None`.
+    """
+
+    viewbox_canon: tuple[tuple[float, float], tuple[float, float]] | None = None
+
+    _id: str
+    """
+    Unique id for this container.
+    """
+
+    _size: tuple[float, float] | None = None
+    """
+    Instantiated size, set upon glyph creation. If `None`, not rescaled;
+    uses canonical size.
+    """
+
+    _drawing: Drawing
+    """
+    Drawing object, unique to each Glyph.
+    """
+
+    _svg: SVG
+    """
+    Canonical SVG container for all elements generated by this glyph.
+    """
+
+    _group: Group
+    """
+    Group to hold wrapper SVG container when added to a parent glyph.
+    Transformations are performed on this group rather than the <svg> itself
+    as <svg> does not support transformations in SVG 1.1.
+    """
+
+    _parent: BaseContainer | None = None
+    """
+    Parent container, or None if not inserted in another Glyph via
+    {obj}`Glyph.insert_glyph` or passing `parent` upon instantiation. 
+    In this case it has its own standalone Drawing, but may still be 
+    added as a child of another Glyph.
+
+    Only set when inserted as a child of another Glyph.
+    """
+
+    _insert: tuple[float, float] | None = None
+    """
+    Point at which this glyph is inserted in parent.
+
+    Only set when inserted as a child of another Glyph.
+    """
+
+    def __init__(
+        self,
+        id_: str,
+        properties: Properties | None,
+        size: tuple[float, float] | None,
+    ):
+        self._id = id_
+        self._size = size
+        self._drawing = Drawing()
+        self._group = self._drawing.g(id_=f"{self._id}-group")
+
+        self.properties = (
+            self.DefaultProperties() if properties is None else properties
+        )
+
+    @property
+    def has_size(self) -> bool:
+        try:
+            _ = self.size
+        except AssertionError:
+            return False
+
+        return True
+
+    # TODO: document: raises exception + add custom exception
+    @property
+    def size(self) -> tuple[float, float]:
+        s = self._size or self.size_canon
+        assert s is not None
+        return s
+
+    @property
+    def width(self) -> float:
+        return self.size[0]
+
+    @property
+    def height(self) -> float:
+        return self.size[1]
+
+    def _init_post(self):
+        # create canonical svg
+        self._svg: SVG = self._drawing.svg(
+            id_=self._id,
+            size=self.size_canon,
+            class_=type(self).__name__,
+        )
+
+        # set viewbox, if configured
+        if self.viewbox_canon is not None:
+            x, y = self.viewbox_canon[0]
+            w, h = self.viewbox_canon[1]
+            self._svg.viewbox(x, y, w, h)
+            self._svg.fit()
+
+        # add to drawing for standalone glyph
+        if self._size is None:
+            # no scaling needed, add svg directly
+            self._drawing.add(self._svg)
+            self._group.add(self._svg)
+        else:
+            # create wrapper svg and rescale
+            svg_wrapper: SVG = self._create_wrapper_scale()
+            self._drawing.add(svg_wrapper)
+            self._group.add(svg_wrapper)
+
+        # set top-level dimensions explicitly as larger SVGs
+        # are unexpectedly truncated when sized to 100% (default)
+        if self.has_size:
+            self._drawing["width"] = str(self.size[0])
+            self._drawing["height"] = str(self.size[1])
+
+    def _bind(
+        self,
+        parent: BaseContainer,
+        insert: tuple[float, float] | None,
+    ):
+        self._parent = parent
+        self._insert = insert
+
+        # add group to parent, using wrapper svg for placement
+        wrapper_insert: SVG = self._drawing.svg(
+            insert=self._insert,
+            id_=f"{self._id}-wrapper-insert",
+        )
+
+        wrapper_insert.add(self._group)
+        parent._svg.add(wrapper_insert)
+
+    def _create_wrapper_scale(self) -> SVG:
+        """
+        Create SVG wrapper for canonical SVG object to handle
+        placement/scaling.
+        """
+
+        wrapper_scale: SVG = self._drawing.svg(
+            size=self._size,
+            id_=f"{self._id}-wrapper-scale",
+        )
+        self._rescale_svg(wrapper_scale, self._size)
+        wrapper_scale.add(self._svg)
+
+        return wrapper_scale
+
+    def _rescale_svg(
+        self,
+        svg: SVG,
+        size: tuple[float, float] | tuple[str, str] | None,
+        set_size: bool = False,
+    ):
+        if size is not None:
+            if set_size:
+                svg["width"] = str(size[0])
+                svg["height"] = str(size[1])
+
+            if self.size_canon is None:
+                logging.warning(
+                    f"Rescaling glyph {self} which has no canonical size; viewbox will not be set, so results may be unexpected"
+                )
+            else:
+                svg.viewbox(
+                    0, 0, round(self.size_canon[0]), round(self.size_canon[1])
+                )
+                svg.fit()