python-statemachine 3.0.0__py3-none-any.whl → 3.1.1__py3-none-any.whl

{python_statemachine-3.0.0.dist-info → python_statemachine-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-statemachine
-Version: 3.0.0
+Version: 3.1.1
 Summary: Python Finite State Machines made easy.
 Project-URL: homepage, https://github.com/fgmacedo/python-statemachine
 Author-email: Fernando Macedo <fgmacedo@gmail.com>
@@ -23,7 +23,7 @@ Classifier: Topic :: Home Automation
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.9
 Provides-Extra: diagrams
-Requires-Dist: pydot>=2.0.0; extra == 'diagrams'
+Requires-Dist: pydot>=4.0.1; extra == 'diagrams'
 Description-Content-Type: text/markdown
 
 # Python StateMachine
@@ -105,16 +105,23 @@ True
 
 ```
 
-Generate a diagram:
+Generate a diagram or get a text representation with f-strings:
 
 ```py
->>> # This example will only run on automated tests if dot is present
->>> getfixture("requires_dot_installed")
->>> img_path = "docs/images/readme_trafficlightmachine.png"
->>> sm._graph().write_png(img_path)
+>>> print(f"{sm:md}")
+| State  | Event | Guard | Target |
+| ------ | ----- | ----- | ------ |
+| Green  | Cycle |       | Yellow |
+| Yellow | Cycle |       | Red    |
+| Red    | Cycle |       | Green  |
+<BLANKLINE>
 
 ```
 
+```python
+sm._graph().write_png("traffic_light.png")
+```
+
 ![](https://raw.githubusercontent.com/fgmacedo/python-statemachine/develop/docs/images/readme_trafficlightmachine.png)
 
 Parameters are injected into callbacks automatically — the library inspects the
@@ -373,7 +380,7 @@ There's a lot more to explore:
 - **`prepare_event`** callback — inject custom data into all callbacks
 - **Observer pattern** — register external listeners to watch events and state changes
 - **Django integration** — auto-discover state machines in Django apps with `MachineMixin`
-- **Diagram generation** — from the CLI, at runtime, or in Jupyter notebooks
+- **Diagram generation** — via f-strings (`f"{sm:mermaid}"`), CLI, Sphinx directive, or Jupyter
 - **Dictionary-based definitions** — create state machines from data structures
 - **Internationalization** — error messages in multiple languages
 

python_statemachine-3.1.1.dist-info/RECORD

@@ -0,0 +1,58 @@
+statemachine/__init__.py,sha256=6QmaIOvUXefWn7Ur1IFrqnM8ehtcwtnPrvRE44ELq4w,445
+statemachine/callbacks.py,sha256=mY_RAl86240vG2C94ij6AdD7CgsIM8mr0wvpSAMAPv0,14644
+statemachine/configuration.py,sha256=5tTx4-_cXnu6apxdvUfhfhDe6zym9BJynqQ-lrIxnls,6018
+statemachine/dispatcher.py,sha256=xvA1Kf1xGQivHTpaGm_HC22vqAmE_tTm9LQwyVLRWLE,7841
+statemachine/event.py,sha256=d_Ky5ph30Os305BceN4x-rftZH-h8G1U5ei34-66lnI,7669
+statemachine/event_data.py,sha256=7_hoE0cp-0uW71Kk3erO3eYM6anTT5X3slGMcehIGIo,3111
+statemachine/events.py,sha256=11GyX8GYpsSwvW0v1b4zHUGhzKRoqNjQYtuDj8NvqOM,1212
+statemachine/exceptions.py,sha256=gXFvDsEtIxKdcGrRG9mwDgXqFQDXfw8v66_VXaQgGr4,1305
+statemachine/factory.py,sha256=HQc2Hn1irg96Rkygn2E21YAxFV5PRYiXYh4tTKVWBbc,14706
+statemachine/graph.py,sha256=r-8L7jXab1_VLtVu-Ig8bpe4Szo-r6WDFTdbfcepyZM,1981
+statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
+statemachine/invoke.py,sha256=ydYBzP5pi67r9GYmDd6fT169MZkLM4lgpYcbuSyX3Ok,24874
+statemachine/mixins.py,sha256=8qxZZfBwVdFcr3oPFVWHGzgmAubH6VgQus5x3c6VEE0,1706
+statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
+statemachine/orderedset.py,sha256=PjbegcS7WPJAzC7jQ411_JrFJYEz6mmLRsAZ7aI9BWc,2543
+statemachine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/registry.py,sha256=onT8U5QgYlCSJxgxvi_TY1c1oDetHykOwnyiFk5qoN0,756
+statemachine/signature.py,sha256=N8Vt4X3YOA-NB8oidPAbYZxBgqZm6GYAiuHxBWb1l1s,9922
+statemachine/spec_parser.py,sha256=Io0J5D9s-nu2YdgUlr2cSethGfCS0pSLNmxMCXdwMqQ,8307
+statemachine/state.py,sha256=Sb25t3tAyUfUEP9B8FS7wf_kPaCugVnHeGP0OAOqZWo,15441
+statemachine/statemachine.py,sha256=K2f-MwRkvpnq_9vs7NlqeTkCaeX1eepSZl7XPAUF3V4,19977
+statemachine/states.py,sha256=kWo7y95ikXxNmcf_-J2UoMIwd3NaIdxpHMfoHr3cQ_Y,4934
+statemachine/transition.py,sha256=x9hhxIEyQ7tqsvaXkHg1bVO5hMAjemgHfZhyuypHoOY,6936
+statemachine/transition_list.py,sha256=6NAyOGEgoGOzTYiLfPM21CBVI1tPO63ZIwbaZlqOPI4,4376
+statemachine/transition_mixin.py,sha256=XGGd2J4DnFrqIpeej3QFDOuqI0CAiYwnIb8-_9DpemA,2993
+statemachine/utils.py,sha256=taCgrsRDcQQLweyq607AVZyI0NMukRP-HGpO8TiVNgk,1527
+statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/contrib/timeout.py,sha256=VXkdLpxNeUKihkbtLv8XTWdG-meQlSFtxJfcxXgV8Uw,2251
+statemachine/contrib/weighted.py,sha256=jcKkm25df6NnzBzuss1-ewDEasZ_CyME03xgJXrwcso,6866
+statemachine/contrib/diagram/__init__.py,sha256=NaVy7LWly8fTJNxjaXoRlWdYQ7cwbuNQPN0BMW6ATrI,7532
+statemachine/contrib/diagram/__main__.py,sha256=iPpiz09xKqtAjrhONS99OYp6R2dQ6Anbhw1qPIN8ELo,80
+statemachine/contrib/diagram/extract.py,sha256=RmjsTpOkbQxwYS_m5BS1VWisef5vHtTRmmwe_Dq3wMk,9891
+statemachine/contrib/diagram/formatter.py,sha256=SeNKdt5jzKIDNUPHD0xZQ0cb_zsQbwrucoZtMVXL0og,4758
+statemachine/contrib/diagram/model.py,sha256=ZspysRy8WbJn4VDYkjoYe0mtao2dT9i6T005ehW5BxA,1498
+statemachine/contrib/diagram/sphinx_ext.py,sha256=HcEXU-aYz8da02XPkZKpF5HDF0XPBGGg9FCz8MtI1C8,10338
+statemachine/contrib/diagram/renderers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/contrib/diagram/renderers/dot.py,sha256=jzKBXJ_m9olnQLXu8SXbFgtdvbFyt5Ukr5uZNjXU0X8,19913
+statemachine/contrib/diagram/renderers/mermaid.py,sha256=jY6cUW9A_P8xLHISrSijx3GlpIl_Gnj3SgayspYq7DI,13526
+statemachine/contrib/diagram/renderers/table.py,sha256=iIdWnVgV7_PY8piSC-WWbEixZSksqXTOujAk6jrO7FQ,3736
+statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/engines/async_.py,sha256=Wtm3GRm2y9gWTevdPkJgnpY7RzZ97HVewWtwgDenoeU,22552
+statemachine/engines/base.py,sha256=bVPYyl_AWWzfjFWiLnDiofdOyb40pojr2qu--C4MHvQ,37993
+statemachine/engines/sync.py,sha256=F_bt4z1KLLcFCP77E9SNWDJMWiMTexE0iOU2XAd_x5A,9153
+statemachine/io/__init__.py,sha256=1J_oVSWrWmx9bLrGU-YoWyO-YYbO6T9Z6vUAnerKe3Q,8739
+statemachine/io/scxml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/io/scxml/actions.py,sha256=M1fAsuf0gJlnpMWXgoxCwpOk2MQSh8wBvtupp38T9n8,22491
+statemachine/io/scxml/invoke.py,sha256=raRStlMBOfxto6KIkCbi3jJ3UQ3QfuT0ezn4B48A670,8443
+statemachine/io/scxml/parser.py,sha256=zggZwu0rHZNWDaJTHD2XC3MrCy_bi4CNHStfWE9NHgU,16582
+statemachine/io/scxml/processor.py,sha256=_hjW4VTuzbPK2q5a7dp2kYMBcbRBZFbjz-wJKSZLI8I,9467
+statemachine/io/scxml/schema.py,sha256=xNpW_nkS2Z_hye5p1WLr8VhuM85Nic2HqRLCnoFN3ss,3927
+statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=MZpydlIX__YjJZw2-zBEVNjuUqLEt6AYYWfrq8Rff90,5338
+statemachine/locale/hi_IN/LC_MESSAGES/statemachine.po,sha256=LLaDkTU0GZaataEWl35ap1SDgsJkdEr-0_u8gg5q7kI,7948
+statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=z-phNrS8soB26B67yz3f6eYB-KpcXX0MZEBWJqsztgg,5814
+statemachine/locale/zh_CN/LC_MESSAGES/statemachine.po,sha256=nxhwoPj23VjI_4O3r3hKjoc3H5rGox7gbdY-wzWFm6A,5369
+python_statemachine-3.1.1.dist-info/METADATA,sha256=EdRvT7EegYFkRrnnT5PR6yPD4oksBzb9112dPFO1a4w,12249
+python_statemachine-3.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_statemachine-3.1.1.dist-info/licenses/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
+python_statemachine-3.1.1.dist-info/RECORD,,

statemachine/__init__.py

@@ -8,7 +8,7 @@ from .statemachine import TModel
 
 __author__ = """Fernando Macedo"""
 __email__ = "fgmacedo@gmail.com"
-__version__ = "3.0.0"
+__version__ = "3.1.1"
 
 __all__ = [
     "StateChart",

statemachine/configuration.py

@@ -0,0 +1,170 @@
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Dict
+from typing import Mapping
+from typing import MutableSet
+
+from .exceptions import InvalidStateValue
+from .i18n import _
+from .orderedset import OrderedSet
+
+_SENTINEL = object()
+
+if TYPE_CHECKING:
+    from .state import State
+
+
+class Configuration:
+    """Encapsulates the dual representation of the active state configuration.
+
+    Internally, ``current_state_value`` is either a scalar (single active state)
+    or an ``OrderedSet`` (parallel regions).  This class hides that detail behind
+    a uniform interface for reading, mutating, and caching the resolved
+    ``OrderedSet[State]``.
+    """
+
+    __slots__ = (
+        "_instance_states",
+        "_model",
+        "_state_field",
+        "_states_map",
+        "_cached",
+        "_cached_value",
+    )
+
+    def __init__(
+        self,
+        instance_states: "Mapping[str, State]",
+        model: Any,
+        state_field: str,
+        states_map: "Dict[Any, State]",
+    ):
+        self._instance_states = instance_states
+        self._model = model
+        self._state_field = state_field
+        self._states_map = states_map
+        self._cached: "OrderedSet[State] | None" = None
+        self._cached_value: Any = _SENTINEL
+
+    # -- Raw value (persisted on the model) ------------------------------------
+
+    @property
+    def value(self) -> Any:
+        """The raw state value stored on the model (scalar or ``OrderedSet``)."""
+        return getattr(self._model, self._state_field, None)
+
+    @value.setter
+    def value(self, val: Any):
+        if val is None:
+            self._write_to_model(OrderedSet())
+        elif isinstance(val, MutableSet):
+            self._write_to_model(OrderedSet(val) if not isinstance(val, OrderedSet) else val)
+        else:
+            self._write_to_model(OrderedSet([val]))
+
+    @property
+    def values(self) -> OrderedSet[Any]:
+        """The set of raw state values currently active."""
+        return self._read_from_model()
+
+    # -- Resolved states -------------------------------------------------------
+
+    @property
+    def states(self) -> "OrderedSet[State]":
+        """The set of currently active :class:`State` instances (cached)."""
+        raw = self.value
+        # Snapshot the cache fields locally — another thread may call
+        # ``_invalidate()`` between the freshness check and the return,
+        # so reading ``self._cached`` twice would risk returning ``None``.
+        cached = self._cached
+        cached_value = self._cached_value
+        if cached is not None and cached_value is raw:
+            return cached
+        if raw is None:
+            return OrderedSet()
+
+        # Normalize inline (avoid second getattr via _read_from_model)
+        values = raw if isinstance(raw, MutableSet) else (raw,)
+        result = OrderedSet(self._instance_states[self._states_map[v].id] for v in values)
+        self._cached = result
+        self._cached_value = raw
+        return result
+
+    @states.setter
+    def states(self, new_configuration: "OrderedSet[State]"):
+        self._write_to_model(OrderedSet(s.value for s in new_configuration))
+
+    # -- Incremental mutation (used by the engine) -----------------------------
+
+    def add(self, state: "State"):
+        """Add *state* to the configuration (copy-on-write for thread safety)."""
+        # Copy so we never mutate the OrderedSet still held by concurrent
+        # readers or by the cache identity check. ``_read_from_model`` may
+        # return the same ref stored on the model.
+        values = OrderedSet(self._read_from_model())
+        values.add(state.value)
+        self._write_to_model(values)
+
+    def discard(self, state: "State"):
+        """Remove *state* from the configuration (copy-on-write for thread safety)."""
+        values = OrderedSet(self._read_from_model())
+        values.discard(state.value)
+        self._write_to_model(values)
+
+    # -- Deprecated v2 compat --------------------------------------------------
+
+    @property
+    def current_state(self) -> "State | OrderedSet[State]":
+        """Resolve the current state with validation.
+
+        Unlike ``states`` (which returns an empty set for ``None``), this
+        raises ``InvalidStateValue`` when the value is ``None`` or not
+        found in ``states_map`` — matching the v2 ``current_state`` contract.
+        """
+        csv = self.value
+        if csv is None:
+            raise InvalidStateValue(
+                csv,
+                _(
+                    "There's no current state set. In async code, "
+                    "did you activate the initial state? "
+                    "(e.g., `await sm.activate_initial_state()`)"
+                ),
+            )
+        try:
+            config = self.states
+            if len(config) == 1:
+                return next(iter(config))
+            return config
+        except KeyError as err:
+            raise InvalidStateValue(csv) from err
+
+    # -- Internal: model boundary ----------------------------------------------
+
+    def _read_from_model(self) -> OrderedSet:
+        """Normalize: model value → always ``OrderedSet``."""
+        raw = self.value
+        if raw is None:
+            return OrderedSet()
+        if isinstance(raw, OrderedSet):
+            return raw
+        if isinstance(raw, MutableSet):
+            return OrderedSet(raw)
+        return OrderedSet([raw])
+
+    def _write_to_model(self, values: OrderedSet):
+        """Denormalize: ``OrderedSet`` → ``None | scalar | OrderedSet`` for model."""
+        self._invalidate()
+        if len(values) == 0:
+            raw = None
+        elif len(values) == 1:
+            raw = next(iter(values))
+        else:
+            raw = values
+        if raw is not None and not isinstance(raw, MutableSet) and raw not in self._states_map:
+            raise InvalidStateValue(raw)
+        setattr(self._model, self._state_field, raw)
+
+    def _invalidate(self):
+        self._cached = None
+        self._cached_value = _SENTINEL

statemachine/contrib/diagram/__init__.py

@@ -0,0 +1,237 @@
+import importlib
+from urllib.parse import quote
+from urllib.request import urlopen
+
+from .extract import extract
+from .formatter import formatter as formatter
+from .renderers.dot import DotRenderer
+from .renderers.dot import DotRendererConfig
+from .renderers.mermaid import MermaidRenderer
+from .renderers.mermaid import MermaidRendererConfig
+
+
+class DotGraphMachine:
+    """Backwards-compatible facade that uses the extract + render pipeline.
+
+    Maintains the same public API and class-level customization attributes
+    as the original monolithic DotGraphMachine.
+    """
+
+    graph_rankdir = "LR"
+    """
+    Direction of the graph. Defaults to "LR" (option "TB" for top bottom)
+    http://www.graphviz.org/doc/info/attrs.html#d:rankdir
+    """
+
+    font_name = "Helvetica"
+    """Graph font face name"""
+
+    state_font_size = "10"
+    """State font size"""
+
+    state_active_penwidth = 2
+    """Active state external line width"""
+
+    state_active_fillcolor = "turquoise"
+
+    transition_font_size = "9"
+    """Transition font size"""
+
+    def __init__(self, machine):
+        self.machine = machine
+
+    def _build_config(self) -> DotRendererConfig:
+        return DotRendererConfig(
+            graph_rankdir=self.graph_rankdir,
+            font_name=self.font_name,
+            state_font_size=self.state_font_size,
+            state_active_penwidth=self.state_active_penwidth,
+            state_active_fillcolor=self.state_active_fillcolor,
+            transition_font_size=self.transition_font_size,
+        )
+
+    def get_graph(self):
+        ir = extract(self.machine)
+        renderer = DotRenderer(config=self._build_config())
+        return renderer.render(ir)
+
+    def __call__(self):
+        return self.get_graph()
+
+
+class MermaidGraphMachine:
+    """Facade for generating Mermaid stateDiagram-v2 source from a state machine."""
+
+    direction = "LR"
+    active_fill = "#40E0D0"
+    active_stroke = "#333"
+
+    def __init__(self, machine):
+        self.machine = machine
+
+    def _build_config(self) -> MermaidRendererConfig:
+        return MermaidRendererConfig(
+            direction=self.direction,
+            active_fill=self.active_fill,
+            active_stroke=self.active_stroke,
+        )
+
+    def get_mermaid(self) -> str:
+        ir = extract(self.machine)
+        renderer = MermaidRenderer(config=self._build_config())
+        return renderer.render(ir)
+
+    def __call__(self) -> str:
+        return self.get_mermaid()
+
+
+def quickchart_write_svg(sm, path: str):
+    """
+    If the default dependency of GraphViz installed locally doesn't work for you. As an option,
+    you can generate the image online from the output of the `dot` language,
+    using one of the many services available.
+
+    To get the **dot** representation of your state machine is as easy as follows:
+
+    >>> from tests.examples.order_control_machine import OrderControl
+    >>> sm = OrderControl()
+    >>> print(sm._graph().to_string())  # doctest: +ELLIPSIS
+    digraph OrderControl {
+    ...
+    }
+
+    To give you an example, we included this method that will serialize the dot, request the graph
+    to https://quickchart.io, and persist the result locally as an ``.svg`` file.
+
+
+    .. warning::
+        Quickchart is an external graph service that supports many formats to generate diagrams.
+
+        By using this method, you should trust http://quickchart.io.
+
+        Please read https://quickchart.io/documentation/faq/ for more information.
+
+    >>> quickchart_write_svg(sm, "docs/images/oc_machine_processing.svg")  # doctest: +SKIP
+
+    """
+    dot_representation = sm._graph().to_string()
+
+    url = f"https://quickchart.io/graphviz?graph={quote(dot_representation)}"
+
+    response = urlopen(url)
+    data = response.read()
+
+    with open(path, "wb") as f:
+        f.write(data)
+
+
+def _find_sm_class(module):
+    """Find the first StateChart subclass defined in a module."""
+    import inspect
+
+    from statemachine.statemachine import StateChart
+
+    for _name, obj in inspect.getmembers(module, inspect.isclass):
+        if (
+            issubclass(obj, StateChart)
+            and obj is not StateChart
+            and obj.__module__ == module.__name__
+        ):
+            return obj
+    return None
+
+
+def import_sm(qualname):
+    from statemachine.statemachine import StateChart
+
+    module_name, class_name = qualname.rsplit(".", 1)
+    module = importlib.import_module(module_name)
+    smclass = getattr(module, class_name, None)
+    if smclass is not None and isinstance(smclass, type) and issubclass(smclass, StateChart):
+        return smclass
+
+    # qualname may be a module path without a class name — try importing
+    # the whole path as a module and find the first StateChart subclass.
+    try:
+        module = importlib.import_module(qualname)
+    except ImportError as err:
+        raise ValueError(f"{class_name} is not a subclass of StateMachine") from err
+
+    smclass = _find_sm_class(module)
+    if smclass is None:
+        raise ValueError(f"No StateMachine subclass found in module {qualname!r}")
+
+    return smclass
+
+
+def write_image(qualname, out, events=None, fmt=None):
+    """
+    Given a `qualname`, that is the fully qualified dotted path to a StateMachine
+    classes, imports the class and generates a dot graph using the `pydot` lib.
+    Writes the graph representation to the filename 'out' that will
+    open/create and truncate such file and write on it a representation of
+    the graph defined by the statemachine, in the format specified by
+    the extension contained in the out path (out.ext).
+
+    If `events` is provided, the machine is instantiated and each event is sent
+    before rendering, so the diagram highlights the current active state.
+
+    If `fmt` is provided, it overrides the output format (any registered text
+    format such as ``"mermaid"``, ``"dot"``, ``"md"``, ``"rst"``).
+    Use ``out="-"`` to write to stdout.
+    """
+    import sys
+
+    smclass = import_sm(qualname)
+
+    if events:
+        machine = smclass()
+        for event_name in events:
+            machine.send(event_name)
+    else:
+        machine = smclass
+
+    if fmt is not None:
+        text = formatter.render(machine, fmt)
+        if out == "-":
+            sys.stdout.write(text)
+        else:
+            with open(out, "w") as f:
+                f.write(text)
+    else:
+        graph = DotGraphMachine(machine).get_graph()
+        if out == "-":
+            sys.stdout.buffer.write(graph.create_svg())  # type: ignore[attr-defined]
+        else:
+            out_extension = out.rsplit(".", 1)[1]
+            graph.write(out, format=out_extension)
+
+
+def main(argv=None):
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        usage="%(prog)s [OPTION] <class_path> <out>",
+        description="Generate diagrams for StateMachine classes.",
+    )
+    parser.add_argument(
+        "class_path", help="A fully-qualified dotted path to the StateMachine class."
+    )
+    parser.add_argument(
+        "out",
+        help="File to generate the image using extension as the output format.",
+    )
+    parser.add_argument(
+        "--events",
+        nargs="+",
+        help="Instantiate the machine and send these events before rendering.",
+    )
+    parser.add_argument(
+        "--format",
+        choices=formatter.supported_formats(),
+        default=None,
+        help="Output as text format instead of Graphviz image.",
+    )
+
+    args = parser.parse_args(argv)
+    write_image(qualname=args.class_path, out=args.out, events=args.events, fmt=args.format)

statemachine/contrib/diagram/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from . import main
+
+if __name__ == "__main__":
+    sys.exit(main())