openral-cli 0.1.0__py3-none-any.whl

openral_cli/prompt.py

@@ -0,0 +1,128 @@
+"""``openral prompt`` CLI adapter.
+
+Publishes a one-shot ``openral_msgs/PromptStamped`` onto
+``/openral/prompt_in/cli`` and exits. The ``prompt_router_node``
+(``packages/openral_prompt_router``) fans the message out onto
+``/openral/prompt`` after stamping ``{"source": "cli", "priority": 100}``
+onto ``metadata_json``; the F4 reasoner consumes ``/openral/prompt``.
+
+Wire shape:
+
+* QoS: ``RELIABLE + VOLATILE + KEEP_LAST=10`` (matches the router's
+  subscription so the message survives a one-shot publish-and-exit
+  even if the router was a hair late to subscribe).
+* ``metadata_json``: ``{"source_cli": true}`` — minimal; the router
+  appends the canonical ``source`` / ``priority`` fields.
+
+``rclpy`` is imported lazily inside the typer command so ``openral --help``
+stays sub-second even when ROS is not sourced.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+
+import typer
+
+__all__ = ["prompt_command"]
+
+
+def prompt_command(
+    text: str = typer.Argument(..., help='Prompt text, e.g. "pick the red cube"'),
+    topic: str = typer.Option(
+        "/openral/prompt_in/cli",
+        help="ROS topic to publish on; defaults to the prompt-router's CLI input.",
+    ),
+    wait_s: float = typer.Option(
+        1.0,
+        help=(
+            "Seconds to wait after publish before exiting. Gives the prompt-router "
+            "time to receive on a fresh DDS discovery; 0 exits immediately."
+        ),
+    ),
+    discovery_wait_s: float = typer.Option(
+        5.0,
+        help=(
+            "Seconds to spin waiting for the prompt-router to discover the publisher "
+            "before giving up and publishing anyway. Cold-boot deploys with stale "
+            "Fast-DDS shared-memory remnants need 10-15 s; the default 5 s matches "
+            "the interactive use case where the launch has been up for a while."
+        ),
+    ),
+) -> None:
+    """Publish a one-shot PromptStamped on the prompt-router CLI input topic.
+
+    Requires a sourced ROS 2 install. Exits 0 on success, 2 when
+    ``rclpy`` / ``openral_msgs`` are not importable (after pointing
+    the user at ``just ros2-build`` + ``source install/setup.bash``).
+
+    Example::
+
+        openral prompt "pick the red cube"
+    """
+    try:
+        import rclpy  # noqa: PLC0415  # reason: heavy ROS dep deferred
+        from openral_msgs.msg import (  # noqa: PLC0415  # reason: heavy ROS dep deferred
+            PromptStamped,
+        )
+        from rclpy.qos import (  # noqa: PLC0415
+            QoSDurabilityPolicy,
+            QoSHistoryPolicy,
+            QoSProfile,
+            QoSReliabilityPolicy,
+        )
+    except ImportError as exc:
+        typer.echo(
+            f"openral prompt: cannot import rclpy / openral_msgs ({exc!s}). "
+            "Run `just ros2-build` then `source install/setup.bash` first.",
+            err=True,
+        )
+        raise typer.Exit(code=2) from exc
+
+    rclpy.init()
+    try:
+        node = rclpy.create_node("openral_cli_prompt")
+        qos = QoSProfile(
+            history=QoSHistoryPolicy.KEEP_LAST,
+            depth=10,
+            reliability=QoSReliabilityPolicy.RELIABLE,
+            durability=QoSDurabilityPolicy.VOLATILE,
+        )
+        pub = node.create_publisher(PromptStamped, topic, qos)
+
+        msg = PromptStamped()
+        msg.header.stamp = node.get_clock().now().to_msg()
+        msg.header.frame_id = "openral_cli_prompt"
+        msg.text = text
+        msg.metadata_json = json.dumps({"source_cli": True}, sort_keys=True)
+
+        # Spin until a subscriber matches so the one-shot publish is
+        # not delivered into the void. 0.5 s was too tight on hosts
+        # where the shared-memory transport falls back to UDP
+        # discovery (we saw `RTPS_TRANSPORT_SHM Error: Failed init_port`
+        # on this box, which adds ~1 s before UDP picks up the
+        # prompt_router subscription). 5 s covers normal interactive
+        # use; cold-boot deploys (where the prompt is sent within the
+        # same shell session as the launch start) can need 10-15 s,
+        # exposed via ``--discovery-wait-s``.
+        deadline = time.monotonic() + discovery_wait_s
+        while time.monotonic() < deadline and pub.get_subscription_count() == 0:
+            rclpy.spin_once(node, timeout_sec=0.05)
+        n_subs = pub.get_subscription_count()
+        if n_subs == 0:
+            typer.echo(
+                f"openral prompt: no subscriber on {topic} after {discovery_wait_s:.1f} s; "
+                "is the launch up?",
+                err=True,
+            )
+        pub.publish(msg)
+        typer.echo(
+            f"openral prompt: published on {topic} text={text!r} (matched_subs={n_subs})",
+        )
+
+        if wait_s > 0:
+            time.sleep(wait_s)
+        node.destroy_node()
+    finally:
+        rclpy.shutdown()

openral_cli/robot.py

@@ -0,0 +1,301 @@
+"""``openral robot vendor-urdf <id>`` — expand an upstream xacro to a flat URDF.
+
+The flat, committed URDF means end users need no xacro tooling at runtime.
+The xacro-only arms (ur5e/ur10e/rizon4) ship a ``XACRO_PATH`` in
+``robot_descriptions``; we let ``robot_descriptions``' ``yourdfpy`` loader run
+``xacrodoc`` to expand every ``${…}`` substitution, then serialize the resulting
+flat URDF with a provenance header. ``openarm`` ships only MJCF upstream, so its
+flattened URDF is cloned separately and passed as a ``file:`` upstream; the
+``--rename`` hook strips the ``openarm_`` joint/link prefix to the OpenRAL HAL
+convention (``left_joint1..7`` / ``right_joint1..7``).
+
+**Portable mesh refs.** The yourdfpy round-trip absolutizes every mesh
+``filename`` into the vendoring machine's ``robot_descriptions`` cache — paths
+that resolve nowhere else, which once broke collision lowering for the whole
+xacro fleet in CI (empty ACMs). For ``rd:`` upstreams the round-trip output is
+therefore post-processed by :func:`_portable_mesh_refs`: cache-absolute paths
+become ``rd:<module>:<path-relative-to-repository>`` refs, expanded at load
+time by ``openral_safety.urdf_lowering`` through the same pinned clone.
+
+**Raw-text mode** (``raw_text=True``). The same yourdfpy round-trip also
+mangles ``package://`` mesh paths, which is fatal for already-flat upstream
+URDFs that ship relative or ``package://`` meshes (so100/so101/gr1/h1). For
+those we copy the upstream text verbatim and apply joint-name renames with
+``re.sub`` directly on the raw XML — preserving every mesh path byte-for-byte.
+The renames target **joint names only** (``<joint name="X"`` and any
+``joint="X"`` mimic/transmission references); link names are never touched. A
+:class:`list` of ``(pattern, repl)`` pairs is applied in order, so so100/so101
+take six numeric renames and gr1/h1 take one ``_joint``-suffix strip.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from pathlib import Path
+from typing import cast
+
+_PROVENANCE = (
+    "<!-- Vendored by `openral robot vendor-urdf {id}` from {src}. Upstream license applies. -->\n"
+)
+
+# SO-ARM numeric-joint → semantic HAL-name map, applied by joint NUMBER (the
+# upstream so100/so101 URDFs name joints "1".."6"; the SO-ARM motor convention
+# and the manifest use these semantic names). Both follower arms share the map.
+_SO_ARM_JOINT_NAMES: tuple[str, ...] = (
+    "shoulder_pan",  # 1
+    "shoulder_lift",  # 2
+    "elbow_flex",  # 3
+    "wrist_flex",  # 4
+    "wrist_roll",  # 5
+    "gripper",  # 6
+)
+
+# Per-robot raw-text joint renames (regex pattern, replacement), applied in
+# order. Patterns are scoped to the joint-name context so no <link …> is hit:
+#  * so100/so101: rewrite ``name="N"`` (only ever a <joint> in these URDFs;
+#    links are semantic, transmissions are ``N_trans`` / ``motorN``).
+#  * gr1/h1: strip the ``_joint`` suffix from every ``name="…_joint"`` (no link
+#    ends in ``_joint`` in either URDF — verified).
+#  * gr1 also collapses ``*_elbow_pitch`` → ``*_elbow`` to match the manifest's
+#    HAL joint name (the upstream URDF spells the single-DoF elbow joint
+#    ``*_elbow_pitch_joint``; the manifest/control contract calls it ``*_elbow``).
+#    Applied AFTER the ``_joint`` strip; link-safe (no ``*_elbow_pitch`` link
+#    exists — only the two ``*_elbow_pitch_joint`` joints — verified).
+_RAW_RENAMES: dict[str, list[tuple[str, str]]] = {
+    "so100_follower": [
+        (rf'name="{n}"', f'name="{sem}"') for n, sem in enumerate(_SO_ARM_JOINT_NAMES, start=1)
+    ],
+    "so101_follower": [
+        (rf'name="{n}"', f'name="{sem}"') for n, sem in enumerate(_SO_ARM_JOINT_NAMES, start=1)
+    ],
+    "gr1": [
+        (r'name="([^"]*)_joint"', r'name="\1"'),
+        (r'name="(left|right)_elbow_pitch"', r'name="\1_elbow"'),
+    ],
+    "h1": [(r'name="([^"]*)_joint"', r'name="\1"')],
+}
+
+# Joint-name normalization to the OpenRAL HAL convention. openarm: strip the
+# "openarm_" prefix so joints become left_joint1..7 / right_joint1..7.
+_RENAME: dict[str, tuple[str, str]] = {"openarm": (r'"openarm_', '"')}
+
+# A ``(pattern, repl)`` rename is a 2-tuple; named to satisfy the magic-value lint.
+_PAIR_LEN = 2
+
+
+def _model_to_xml(model: object) -> str:
+    """Serialize a loaded ``yourdfpy.URDF`` to a pretty-printed flat URDF string.
+
+    yourdfpy ≥0.0.56 exposes ``write_xml_string()`` returning the serialized URDF
+    as ASCII ``bytes`` on a single line (verified against the installed package —
+    it wraps ``lxml.etree.tostring``; its ``**kwargs`` forwarding is broken so we
+    cannot pass ``pretty_print`` through it). We re-parse and pretty-print via lxml
+    so the committed file is human-reviewable + git-diffable.
+    """
+    from lxml import etree
+
+    # ``write_xml_string`` is the public serializer in yourdfpy ≥0.0.56; one line.
+    raw = model.write_xml_string()  # type: ignore[attr-defined] # reason: yourdfpy.URDF has no stubs
+    root = etree.fromstring(raw if isinstance(raw, bytes) else raw.encode("utf-8"))
+    pretty: bytes = etree.tostring(root, pretty_print=True, xml_declaration=True, encoding="utf-8")
+    return pretty.decode("utf-8")
+
+
+def _load_model(upstream: str) -> object:
+    """Load an upstream description into a ``yourdfpy.URDF``.
+
+    ``rd:<module>`` resolves through ``robot_descriptions`` (xacro expanded via
+    ``xacrodoc``); ``file:<path>`` loads an already-flat URDF directly.
+    """
+    if upstream.startswith("file:"):
+        import yourdfpy
+
+        path = Path(upstream[len("file:") :])
+        # build_scene_graph/build_collision_scene_graph are off so an
+        # upstream that references missing meshes still parses for re-export.
+        return yourdfpy.URDF.load(
+            str(path),
+            build_scene_graph=False,
+            build_collision_scene_graph=False,
+            load_meshes=False,
+            load_collision_meshes=False,
+        )
+    from robot_descriptions.loaders.yourdfpy import load_robot_description
+
+    module = upstream[len("rd:") :] if upstream.startswith("rd:") else upstream
+    return load_robot_description(module)  # expands xacro via xacrodoc
+
+
+def vendor_urdf(
+    robot_id: str,
+    *,
+    upstream: str,
+    out_dir: Path,
+    rename: tuple[str, str] | Sequence[tuple[str, str]] | None = None,
+    raw_text: bool = False,
+) -> Path:
+    """Expand ``upstream`` to a flat URDF at ``out_dir/<robot_id>.urdf``.
+
+    Args:
+        robot_id: OpenRAL robot id; names the output file and selects the
+            default rename rule.
+        upstream: ``rd:<robot_descriptions module>`` for xacro arms, or
+            ``file:<path>`` for an already-flat upstream URDF (openarm).
+        out_dir: Directory to write ``<robot_id>.urdf`` into (created if absent).
+        rename: A ``(pattern, repl)`` pair, or a sequence of them, applied with
+            ``re.sub`` in order. ``None`` selects the per-robot default
+            (``_RAW_RENAMES[robot_id]`` in raw-text mode, else ``_RENAME``).
+        raw_text: When ``True``, copy the already-flat upstream URDF text
+            verbatim and apply ``rename`` directly to the raw XML — no yourdfpy
+            round-trip — so ``package://`` / relative mesh paths are preserved
+            byte-for-byte. Only valid for ``file:`` / ``rd:`` URDFs that are
+            already flat (so100/so101/gr1/h1). Mutually exclusive with xacro
+            expansion: the upstream must contain no ``${…}``.
+
+    Returns:
+        Path to the written URDF.
+
+    Example:
+        >>> from pathlib import Path
+        >>> import tempfile
+        >>> d = Path(tempfile.mkdtemp())
+        >>> # vendor-urdf needs the optional `lowering` group (yourdfpy/xacrodoc):
+        >>> out = vendor_urdf(  # doctest: +SKIP
+        ...     "ur5e", upstream="rd:ur5e_description", out_dir=d
+        ... )
+        >>> out.name  # doctest: +SKIP
+        'ur5e.urdf'
+    """
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out = out_dir / f"{robot_id}.urdf"
+    if raw_text:
+        xml = _read_raw_text(upstream)
+        renames = _resolve_renames(robot_id, rename, default=_RAW_RENAMES.get(robot_id))
+        for pat, repl in renames:
+            xml = re.sub(pat, repl, xml)
+        # Preserve the upstream's exact bytes apart from the renamed joint names
+        # and the inserted provenance comment — including its newline style — so
+        # the only diff vs upstream is the joint renames (gate: lowering must
+        # stay byte-identical, mesh paths verbatim). newline="" disables write-side
+        # newline translation (Path.write_text gained the kwarg only in 3.13).
+        with out.open("w", encoding="utf-8", newline="") as fh:
+            fh.write(_with_provenance_raw(xml, id=robot_id, src=upstream))
+        return out
+    model = _load_model(upstream)
+    xml = _model_to_xml(model)
+    if upstream.startswith("rd:"):
+        xml = _portable_mesh_refs(xml, module=upstream[len("rd:") :])
+    default = [_RENAME[robot_id]] if robot_id in _RENAME else None
+    renames = _resolve_renames(robot_id, rename, default=default)
+    for pat, repl in renames:
+        xml = re.sub(pat, repl, xml)
+    out.write_text(_with_provenance(xml, id=robot_id, src=upstream))
+    return out
+
+
+def _portable_mesh_refs(xml: str, *, module: str) -> str:
+    """Rewrite cache-absolutized mesh paths to portable ``rd:<module>:<relpath>`` refs.
+
+    The yourdfpy round-trip resolves every mesh ``filename`` to an absolute path
+    inside the vendoring machine's ``robot_descriptions`` clone
+    (``~/.cache/robot_descriptions/<repo>/…``) — paths that exist nowhere else, so
+    committing them breaks collision lowering on every other host (CI's re-lower
+    then finds no meshes and emits an empty ACM). Rewrite them to
+    ``rd:<module>:<path-relative-to-repository>``, which
+    ``openral_safety.urdf_lowering`` expands at load time through the same pinned
+    ``robot_descriptions`` clone on any machine.
+    """
+    import importlib
+
+    mod = importlib.import_module(f"robot_descriptions.{module}")
+    repo = str(Path(mod.REPOSITORY_PATH))
+    return xml.replace(f'filename="{repo}/', f'filename="rd:{module}:')
+
+
+def _resolve_renames(
+    robot_id: str,
+    rename: tuple[str, str] | Sequence[tuple[str, str]] | None,
+    *,
+    default: list[tuple[str, str]] | None,
+) -> list[tuple[str, str]]:
+    """Normalize the ``rename`` argument to a flat list of ``(pattern, repl)``.
+
+    A bare ``(pattern, repl)`` pair (two strings) is wrapped into a one-element
+    list; a sequence of pairs is passed through; ``None`` falls back to the
+    per-robot ``default``.
+    """
+    if rename is None:
+        return list(default) if default else []
+    # A bare ``(pattern, repl)`` is a 2-tuple of strings; a sequence of such pairs
+    # is anything else iterable. ``_PAIR_LEN`` names the 2 to satisfy PLR2004.
+    if (
+        isinstance(rename, tuple)
+        and len(rename) == _PAIR_LEN
+        and all(isinstance(x, str) for x in rename)
+    ):
+        return [cast("tuple[str, str]", rename)]
+    return list(cast("Sequence[tuple[str, str]]", rename))
+
+
+def _read_raw_text(upstream: str) -> str:
+    """Read an already-flat upstream URDF's text verbatim (no XML round-trip).
+
+    ``file:<path>`` reads that path; ``rd:<module>`` resolves the cached
+    upstream ``.urdf`` via ``robot_descriptions`` and reads it directly. The
+    upstream must already be flat — raising if any ``${…}`` xacro substitution
+    survives, since raw-text mode does no expansion.
+    """
+    if upstream.startswith("file:"):
+        path = Path(upstream[len("file:") :])
+    elif upstream.startswith("rd:"):
+        import importlib
+
+        module = importlib.import_module(f"robot_descriptions.{upstream[len('rd:') :]}")
+        path = Path(module.URDF_PATH)
+    else:
+        raise ValueError(f"raw_text mode needs a 'file:' or 'rd:' upstream, got {upstream!r}")
+    # newline="" disables universal-newline translation so an upstream that uses
+    # CRLF (e.g. gr1) is preserved verbatim rather than silently rewritten to LF.
+    # (Path.read_text gained a newline kwarg only in 3.13; open() is the 3.12 path.)
+    with path.open("r", encoding="utf-8", newline="") as fh:
+        text = fh.read()
+    if "${" in text:
+        raise ValueError(f"raw_text mode requires a flat URDF; {path} still has '${{…}}' xacro")
+    return text
+
+
+def _with_provenance_raw(xml: str, *, id: str, src: str) -> str:
+    """Insert the provenance comment into a raw-text URDF, preserving its bytes.
+
+    Unlike :func:`_with_provenance` (which rewrites the XML declaration emitted
+    by the yourdfpy round-trip), this keeps the upstream document verbatim and
+    only inserts the provenance comment on the line *after* the declaration (or
+    at the top if there is none), matching the document's own newline style so
+    the diff vs upstream is exactly the renamed joint names plus this comment.
+    """
+    nl = "\r\n" if "\r\n" in xml else "\n"
+    header = _PROVENANCE.format(id=id, src=src).rstrip("\n")
+    decl_match = re.match(r"^\s*<\?xml[^>]*\?>[ \t]*\r?\n?", xml)
+    if decl_match:
+        return xml[: decl_match.end()] + header + nl + xml[decl_match.end() :]
+    return header + nl + xml
+
+
+def _with_provenance(xml: str, *, id: str, src: str) -> str:
+    """Prepend the provenance comment without breaking XML well-formedness.
+
+    An XML declaration (``<?xml …?>``) must be byte 0 of the document — a
+    comment may not precede it. When the serialized URDF leads with one, the
+    provenance comment is inserted on the line *after* the declaration; otherwise
+    it goes at the top.
+    """
+    header = _PROVENANCE.format(id=id, src=src)
+    decl_match = re.match(r"^\s*<\?xml[^>]*\?>\s*\n?", xml)
+    if decl_match:
+        # The provenance comment carries a non-ASCII em-dash, so normalize the
+        # declared encoding to UTF-8 (yourdfpy emits ``encoding='ASCII'``) to
+        # keep the document well-formed.
+        body = xml[decl_match.end() :]
+        return '<?xml version="1.0" encoding="utf-8"?>\n' + header + body
+    return header + xml

openral_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: openral-cli
+Version: 0.1.0
+Summary: OpenRAL command-line tool
+License: Apache-2.0
+Requires-Python: <3.13,>=3.12
+Requires-Dist: opencv-python-headless<5,>=4.9
+Requires-Dist: openral-core
+Requires-Dist: openral-detect
+Requires-Dist: openral-observability[dashboard]
+Requires-Dist: openral-rskill
+Requires-Dist: openral-sensors
+Requires-Dist: openral-sim
+Requires-Dist: pyudev>=0.24.4
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# openral-cli
+
+OpenRAL command-line tool
+
+Part of [**OpenRAL**](https://github.com/OpenRAL/openral) — the open Robot
+Abstraction Layer for vision-language-action robotics. This package is one
+member of the OpenRAL Python workspace; see the architecture overview and the
+eight-layer model in the project docs.
+
+- **Docs:** https://openral.github.io/openral/
+- **Source:** https://github.com/OpenRAL/openral
+- **License:** Apache-2.0
+
+> All OpenRAL workspace packages move in lockstep at `0.1.x` until the first
+> public release.

openral_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+openral_cli/__init__.py,sha256=m3UphUxCyvMi46_Hk0z9TUEHUJsEzvaCupzu_g3uq8Q,128
+openral_cli/_hf_publish.py,sha256=OKAdqRPF0DLutocQAzBACrP3-ND0DxiYqY56xPmBams,4649
+openral_cli/_rskill_doc_validator.py,sha256=Qx4CqXEuMkZY4fLozLMMe4i_qidEe94StJItFPxXiqg,22578
+openral_cli/_rskill_intel.py,sha256=iLyn1qSZdtf2PlECE9xEo8M6lzL9NjH_xJCpffs3gmk,13203
+openral_cli/_rskill_readme.py,sha256=cHmeTYUGxyBWOXXoZtTs1oCCOwcEeG0UVC-_C3yF1g0,9368
+openral_cli/_rskill_scaffolder.py,sha256=bQV53SyIt8lojETTsDnmq4HohBTOFT7-Hfw-EbRcuNw,10122
+openral_cli/autodetect.py,sha256=olVg6UMLvxXvu24HSgQvgNbzEYEEcQ6JIHqo8bbm-1k,16521
+openral_cli/check.py,sha256=Fjfla9BFfQDnrjkl8-_YN4YKpyNLjabhe6dhvaL98v8,14892
+openral_cli/collision.py,sha256=6g-C4FrqnKvLMTKD_J6M-8FywpxZ92mDYiXd-6R6mEw,15685
+openral_cli/dataset.py,sha256=1ayK3DHmjHJn8TXZV2ucaX04ru-gdVcyllZkxMBzgtk,15451
+openral_cli/deploy_sim.py,sha256=Wp1CXJpRBa59HPWkvWUMmEPzOWL2mLS0Jcbtq5I39Y4,125143
+openral_cli/install.py,sha256=HKxuxwIcm6yf9JFwGK6XpCpHkOgPRVnta3MzfHE34Gk,14793
+openral_cli/main.py,sha256=ExGdLcmP2YLZik15K7fux5jojKdq3CXsjbItSR1FxkI,158280
+openral_cli/prompt.py,sha256=FH6mCLRNUDwsobY11vv8CG-j6qwwwXHd26z4jqMj308,4794
+openral_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openral_cli/robot.py,sha256=3axrbc1lcnynDd4ns5ncUA3gf3ByVA9kuebRgvtgNEo,14069
+openral_cli-0.1.0.dist-info/METADATA,sha256=q3NT7VxZigWtgG0aQgesvI_ZdJzVB7KzAOxwoBvUkQ0,1034
+openral_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+openral_cli-0.1.0.dist-info/entry_points.txt,sha256=MA7LRsTMvTgm_JLd-6QjU9tRzWaNipFGZlyaFNLGNIU,49
+openral_cli-0.1.0.dist-info/RECORD,,

openral_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

openral_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+openral = openral_cli.main:app