makerrepo-cli 0.1.0__py3-none-any.whl

makerrepo_cli/cmds/aliase.py

@@ -0,0 +1,26 @@
+import click
+from click.core import Context
+
+CMD_ALIAS_MAP = {
+    "ls": "list",
+}
+
+
+class AliasedGroup(click.Group):
+    def get_command(self, ctx: Context, cmd_name: str):
+        if cmd_name in CMD_ALIAS_MAP:
+            cmd_name = CMD_ALIAS_MAP[cmd_name]
+        rv = click.Group.get_command(self, ctx, cmd_name)
+        if rv is not None:
+            return rv
+        matches = [x for x in self.list_commands(ctx) if x.startswith(cmd_name)]
+        if not matches:
+            return None
+        elif len(matches) == 1:
+            return click.Group.get_command(self, ctx, matches[0])
+        ctx.fail(f"Too many matches: {', '.join(sorted(matches))}")
+
+    def resolve_command(self, ctx: Context, args: list[str]):
+        # always return the full command name
+        _, cmd, args = super().resolve_command(ctx, args)
+        return cmd.name, cmd, args

makerrepo_cli/cmds/artifacts/capture_image.py

@@ -0,0 +1,231 @@
+import asyncio
+import base64
+import logging
+import os
+import pathlib
+import uuid
+from typing import Any
+
+from playwright.async_api import async_playwright
+from playwright.async_api import Browser
+from playwright.async_api import BrowserContext
+from playwright.async_api import Page
+
+
+DATA_FOLDER = pathlib.Path(__file__).parent.parent.parent / "data"
+DEFAULT_CONFIG = {
+    # Display options
+    "cadWidth": 1200,
+    "height": 1200,
+    "treeWidth": 0,
+    "theme": "light",
+    "glass": True,
+    "tools": False,
+    # Render options
+    "ambientIntensity": 1.0,
+    "directIntensity": 1.1,
+    "metalness": 0.3,
+    "roughness": 0.65,
+    "edgeColor": 0x707070,
+    # Viewer options
+    "ortho": True,
+    "control": "trackball",
+    "up": "Z",
+}
+DEFAULT_ARGS = (
+    "--no-sandbox",
+    "--disable-setuid-sandbox",
+    "--disable-dev-shm-usage",
+    "--use-gl=angle",
+    "--use-angle=swiftshader",
+    "--enable-webgl",
+    "--ignore-gpu-blocklist",
+    "--enable-unsafe-swiftshader",
+)
+
+
+class CADViewerService:
+    """Service class for loading and interacting with CAD viewer HTML using Playwright."""
+
+    def __init__(
+        self,
+        data_dir: pathlib.Path | None = None,
+        chrome_executable_path: pathlib.Path | None = None,
+        args: tuple[str, ...] | None = None,
+        logger: logging.Logger | None = None,
+    ):
+        if data_dir is None:
+            data_dir = DATA_FOLDER
+        self.data_dir = pathlib.Path(data_dir)
+        self.chrome_executable_path = chrome_executable_path
+        if self.chrome_executable_path is None:
+            self.chrome_executable_path = os.environ.get(
+                "PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH"
+            )
+        self.args = args
+        if self.args is None:
+            self.args = DEFAULT_ARGS
+        self.html_file = self.data_dir / "cad_viewer.html"
+        self.browser: Browser | None = None
+        self.context: BrowserContext | None = None
+        self.page: Page | None = None
+        self._playwright = None
+        self.logger = logger or logging.getLogger(__name__)
+
+    async def start(self):
+        """Start the Playwright browser and load the HTML file."""
+        self._playwright = await async_playwright().start()
+        self.logger.info(
+            "Starting CAD viewer service with executable_path=%s, args=%s",
+            self.chrome_executable_path,
+            self.args,
+        )
+        self.browser = await self._playwright.chromium.launch(
+            headless=True,
+            args=self.args,
+            executable_path=self.chrome_executable_path,
+        )
+        self.context = await self.browser.new_context()
+        self.page = await self.context.new_page()
+
+        # Set up message handler for postMessage from the page
+        async def handle_console(msg):
+            self.logger.info("Console: %s", msg)
+
+        self.page.on("console", handle_console)
+
+        # Load the HTML file
+        html_path = f"file://{self.html_file.absolute()}"
+        await self.page.goto(html_path, wait_until="networkidle")
+
+    async def load_cad_data(
+        self, data: dict[str, Any], config: dict[str, Any] | None = None
+    ):
+        """
+        Load CAD model data into the viewer.
+
+        Args:
+            data: CAD model data dictionary
+            config: Optional configuration dictionary
+        """
+        if self.page is None:
+            raise RuntimeError("Service not started. Call start() first.")
+
+        if config is None:
+            config = DEFAULT_CONFIG
+
+        message = {
+            "model": data["data"],
+            "config": config,
+        }
+
+        await self.page.evaluate(
+            """(data) => {
+                if (window.viewer && window.viewer.clear) {
+                    window.viewer.clear();
+                }
+                window.loadModel(data);
+            }""",
+            message,
+        )
+
+        # Wait for viewer to be ready and data to be processed
+        await asyncio.sleep(1.0)
+        await self.page.wait_for_function(
+            "window.viewer !== null && window.viewer !== undefined",
+            timeout=5 * 1_000,
+        )
+
+    async def take_screenshot(self) -> bytes:
+        """
+        Take a screenshot of the CAD viewer.
+
+        """
+        if self.page is None:
+            raise RuntimeError("Service not started. Call start() first.")
+
+        task_id = uuid.uuid4().hex
+        # Call getImage directly and wait for the promise to resolve
+        result = await self.page.evaluate(
+            """
+            async (filename) => {
+                if (!window.getImage) {
+                    throw new Error('getImage function not available');
+                }
+                return await window.getImage(filename);
+            }
+            """,
+            task_id,
+        )
+
+        if not isinstance(result, dict):
+            raise RuntimeError(f"Invalid screenshot response type: {type(result)}")
+
+        if "dataUrl" not in result:
+            raise RuntimeError(f"Unexpected screenshot response: {result}")
+
+        data_url = result["dataUrl"]
+        if not data_url.startswith("data:image"):
+            raise RuntimeError(f"Invalid screenshot data format: {data_url[:50]}...")
+
+        base64_data = data_url.split(",")[1]
+        return base64.b64decode(base64_data)
+
+    async def stop(self):
+        """Stop the browser and clean up resources."""
+        if self.page:
+            await self.page.close()
+        if self.context:
+            await self.context.close()
+        if self.browser:
+            await self.browser.close()
+        if self._playwright:
+            await self._playwright.stop()
+
+        self.page = None
+        self.context = None
+        self.browser = None
+        self._playwright = None
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.stop()
+
+
+async def main():
+    """Download model file and take a screenshot."""
+    import httpx
+
+    logger = logging.getLogger(__name__)
+    model_url = "https://makerrepo.com/r/fangpenlin/open-models/artifact/master/5081ffa2-d61f-4925-87e3-573ec291b53c/model.json"
+    output_path = pathlib.Path("model_screenshot.png")
+
+    logger.info("Downloading model from %s...", model_url)
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        response = await client.get(model_url)
+        response.raise_for_status()
+        model_data = response.json()
+
+    logger.info("Model downloaded successfully")
+    logger.info("Starting CAD viewer service...")
+
+    async with CADViewerService(logger=logger) as viewer:
+        logger.info("Loading CAD model data...")
+        await viewer.load_cad_data(model_data)
+
+        logger.info("Taking screenshot...")
+        screenshot_bytes = await viewer.take_screenshot()
+
+        # Save screenshot to file
+        output_path.write_bytes(screenshot_bytes)
+        logger.info("Screenshot saved to %s", output_path.absolute())
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    asyncio.run(main())

makerrepo_cli/cmds/artifacts/cli.py

@@ -0,0 +1,11 @@
+from ..aliase import AliasedGroup
+from ..cli import cli as root_cli
+
+
+@root_cli.group(
+    name="artifacts",
+    help="Operations for artifacts.",
+    cls=AliasedGroup,
+)
+def cli():
+    pass

makerrepo_cli/cmds/artifacts/main.py

@@ -0,0 +1,157 @@
+import logging
+import pathlib
+
+import click
+import rich
+from mr.artifacts.registry import collect
+from mr.artifacts.registry import Registry
+from mr.artifacts.utils import load_module
+from rich import box
+from rich.markup import escape
+from rich.padding import Padding
+from rich.table import Table
+
+from ..environment import Environment
+from ..environment import pass_env
+from .cli import cli
+from .utils import convert
+
+logger = logging.getLogger(__name__)
+TABLE_HEADER_STYLE = "yellow"
+TABLE_COLUMN_STYLE = "cyan"
+
+
+def collect_artifacts(module_spec: str) -> Registry:
+    registry = collect([load_module(module_spec)])
+    if not registry.artifacts:
+        logger.error("No artifacts found")
+    return registry
+
+
+@cli.command(name="list", help="List artifacts")
+@click.argument("MODULE")
+@pass_env
+def list_artifacts(env: Environment, module: str):
+    registry = collect_artifacts(module)
+
+    env.logger.info(
+        "Listing artifacts for [blue]%s[/]",
+        module,
+        extra={"markup": True, "highlighter": None},
+    )
+
+    table = Table(
+        title="Artifacts",
+        box=box.SIMPLE,
+        header_style=TABLE_HEADER_STYLE,
+        expand=True,
+    )
+    table.add_column("Module", style=TABLE_COLUMN_STYLE)
+    table.add_column("Name", style=TABLE_COLUMN_STYLE)
+    table.add_column("Sample", style=TABLE_COLUMN_STYLE)
+    for module, artifacts in registry.artifacts.items():
+        for i, (name, artifact) in enumerate(artifacts.items()):
+            table.add_row(
+                escape(module) if i == 0 else "", escape(name), str(artifact.sample)
+            )
+    rich.print(Padding(table, (1, 0, 0, 4)))
+
+
+@cli.command(help="View artifact")
+@click.argument("MODULE")
+@click.argument("ARTIFACTS", nargs=-1)
+@click.option(
+    "-p", "--port", help="OCP Viewer port to send the model data to", default=3939
+)
+@pass_env
+def view(env: Environment, module: str, artifacts: tuple[str, ...], port: int):
+    registry = collect_artifacts(module)
+    if not artifacts:
+        target_artifact = list(list(registry.artifacts.values())[0].values())[0]
+        logger.info(
+            "No artifacts provided, use the first one %s/%s",
+            target_artifact.module,
+            target_artifact.name,
+        )
+        target_artifacts = [target_artifact]
+    else:
+        if len(registry.artifacts) > 1:
+            raise ValueError("Unexpected more than one modules found")
+        module_artifacts = list(registry.artifacts.values())[0]
+        target_artifacts = [
+            module_artifacts[artifact_name] for artifact_name in artifacts
+        ]
+
+    # TODO: this is going to be a bit slow, provide a progress bar & cache?
+    realized_artifacts = [artifact.func() for artifact in target_artifacts]
+    # defer the import to make testing mocking much easier
+    from ocp_vscode import show
+
+    # TODO: pass in some args
+    show(realized_artifacts, port=port)
+
+
+@cli.command(help="Export artifact")
+@click.argument("MODULE")
+@pass_env
+def export(env: Environment, module: str):
+    registry = collect_artifacts(module)
+    # TODO:
+
+
+@cli.command(name="snapshot", help="Capture a snapshot from artifacts")
+@click.argument("MODULE")
+@click.argument("ARTIFACTS", nargs=-1)
+@click.option(
+    "-o",
+    "--output",
+    help="Output image file path",
+    default="snapshot.png",
+    type=click.Path(path_type=pathlib.Path),
+)
+@pass_env
+def snapshot(
+    env: Environment, module: str, artifacts: tuple[str, ...], output: pathlib.Path
+):
+    """Capture a screenshot from artifacts."""
+    import asyncio
+
+    from .capture_image import CADViewerService
+
+    registry = collect_artifacts(module)
+    if not artifacts:
+        target_artifact = list(list(registry.artifacts.values())[0].values())[0]
+        env.logger.info(
+            "No artifacts provided, use the first one %s/%s",
+            target_artifact.module,
+            target_artifact.name,
+        )
+        target_artifacts = [target_artifact]
+    else:
+        if len(registry.artifacts) > 1:
+            raise ValueError("Unexpected more than one modules found")
+        module_artifacts = list(registry.artifacts.values())[0]
+        target_artifacts = [
+            module_artifacts[artifact_name] for artifact_name in artifacts
+        ]
+
+    # Realize artifacts
+    realized_artifacts = [artifact.func() for artifact in target_artifacts]
+
+    # Convert to model data format using convert from utils
+    model_data = convert(realized_artifacts)
+
+    async def capture_snapshot():
+        env.logger.info("Starting CAD viewer service...")
+        async with CADViewerService(logger=env.logger) as viewer:
+            env.logger.info("Loading CAD model data...")
+            await viewer.load_cad_data(model_data.model_dump(mode="json"))
+
+            env.logger.info("Taking screenshot...")
+            screenshot_bytes = await viewer.take_screenshot()
+
+            # Save screenshot to file
+            output.write_bytes(screenshot_bytes)
+            env.logger.info("Screenshot saved to %s", output.absolute())
+
+    asyncio.run(capture_snapshot())

makerrepo_cli/cmds/artifacts/ocp_data_types.py

@@ -0,0 +1,72 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class Buffer(BaseModel):
+    shape: list[int]
+    dtype: str
+    buffer: str
+    codec: str
+
+
+class Instance(BaseModel):
+    vertices: Buffer
+    triangles: Buffer
+    normals: Buffer
+    edges: Buffer
+    obj_vertices: Buffer
+    face_types: Buffer
+    edge_types: Buffer
+    triangles_per_face: Buffer
+    segments_per_edge: Buffer
+
+
+class BoundingBox(BaseModel):
+    xmin: float
+    xmax: float
+    ymin: float
+    ymax: float
+    zmin: float
+    zmax: float
+
+
+class ShapeRef(BaseModel):
+    ref: int
+
+
+class Part(BaseModel):
+    id: str
+    type: str
+    subtype: str
+    name: str
+    shape: ShapeRef
+    state: list[int]
+    color: str
+    alpha: float
+    texture: Any | None = None
+    loc: list[list[float]]
+    renderback: bool
+    accuracy: Any | None = None
+    bb: BoundingBox | None = None
+
+
+class Shapes(BaseModel):
+    version: int
+    parts: list[Part]
+    loc: list[list[float]]
+    name: str
+    id: str
+    normal_len: int
+    bb: BoundingBox
+
+
+class OcpData(BaseModel):
+    instances: list[Instance]
+    shapes: Shapes
+
+
+class OcpPayload(BaseModel):
+    data: OcpData
+    type: str
+    count: int

makerrepo_cli/cmds/artifacts/utils.py

@@ -0,0 +1,31 @@
+from ocp_tessellate import OcpGroup
+from ocp_tessellate.convert import tessellate_group
+from ocp_tessellate.convert import to_ocpgroup
+from ocp_tessellate.utils import numpy_to_buffer_json
+
+from .ocp_data_types import OcpData
+from .ocp_data_types import OcpPayload
+
+
+def convert(*cad_objs, names=None) -> OcpPayload:
+    part_group, instances = to_ocpgroup(
+        *cad_objs,
+        names=names,
+    )
+    if len(part_group.objects) == 1 and isinstance(part_group.objects[0], OcpGroup):
+        loc = part_group.loc
+        part_group = part_group.objects[0]
+        part_group.loc = loc * part_group.loc
+    instances, shapes, mapping = tessellate_group(
+        group=part_group,
+        instances=instances,
+    )
+
+    data = numpy_to_buffer_json(
+        dict(instances=instances, shapes=shapes),
+    )
+    return OcpPayload(
+        data=OcpData.model_validate(data),
+        type="data",
+        count=part_group.count_shapes(),
+    )

makerrepo_cli/cmds/cli.py

@@ -0,0 +1,57 @@
+import logging
+import os
+
+import click
+from rich.logging import RichHandler
+
+from .environment import Environment
+from .environment import LOG_LEVEL_MAP
+from .environment import LogLevel
+from .environment import pass_env
+
+
+@click.group(help="Command line tools for MakerRepo")
+@click.option(
+    "-l",
+    "--log-level",
+    type=click.Choice(
+        list(map(lambda key: key.value, LOG_LEVEL_MAP.keys())), case_sensitive=False
+    ),
+    default=lambda: os.environ.get("LOG_LEVEL", "INFO"),
+)
+@click.option(
+    "--log-format",
+    type=str,
+    default="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    help="logging format (only used when rich log is disabled)",
+)
+@click.option(
+    "--disable-rich-log",
+    is_flag=True,
+    help="disable rich log handler",
+)
+@click.version_option(prog_name="mr", package_name="mr")
+@pass_env
+def cli(
+    env: Environment,
+    log_level: str,
+    log_format: str,
+    disable_rich_log: bool,
+):
+    env.log_level = LogLevel(log_level)
+
+    if disable_rich_log:
+        logging.basicConfig(
+            level=LOG_LEVEL_MAP[env.log_level],
+            format=log_format,
+            force=True,
+        )
+    else:
+        FORMAT = "%(message)s"
+        logging.basicConfig(
+            level=LOG_LEVEL_MAP[env.log_level],
+            format=FORMAT,
+            datefmt="[%X]",
+            handlers=[RichHandler()],
+            force=True,
+        )

makerrepo_cli/cmds/environment.py

@@ -0,0 +1,33 @@
+import dataclasses
+import enum
+import logging
+
+import click
+
+
+@enum.unique
+class LogLevel(enum.Enum):
+    VERBOSE = "verbose"
+    DEBUG = "debug"
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+    FATAL = "fatal"
+
+
+LOG_LEVEL_MAP = {
+    LogLevel.DEBUG: logging.DEBUG,
+    LogLevel.INFO: logging.INFO,
+    LogLevel.WARNING: logging.WARNING,
+    LogLevel.ERROR: logging.ERROR,
+    LogLevel.FATAL: logging.FATAL,
+}
+
+
+@dataclasses.dataclass
+class Environment:
+    log_level: LogLevel = LogLevel.INFO
+    logger: logging.Logger = logging.getLogger("mr")
+
+
+pass_env = click.make_pass_decorator(Environment, ensure=True)

makerrepo_cli/cmds/main.py

@@ -0,0 +1,7 @@
+from .artifacts import main  # no qa
+from .cli import cli
+
+__ALL__ = [cli]
+
+if __name__ == "__main__":
+    cli()

makerrepo_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: makerrepo-cli
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.3.1
+Requires-Dist: makerrepo>=0.2.0
+Requires-Dist: ocp-vscode>=3.0.1
+Requires-Dist: playwright>=1.58.0
+Requires-Dist: rich>=14.3.2
+Dynamic: license-file
+
+# makerrepo-cli
+
+Command line tool for MakerRepo

makerrepo_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+makerrepo_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+makerrepo_cli/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+makerrepo_cli/cmds/aliase.py,sha256=OQ-E171TpBfRoX9D93DqBqXJkAWdtikprJsjK_UyXyA,863
+makerrepo_cli/cmds/cli.py,sha256=iIGRynFXvebDIQ8_qGPc9tyMkUUvlIE9C_YtxABLhRg,1457
+makerrepo_cli/cmds/environment.py,sha256=Bdg7bU7AoUBA_podtv7Vse2zxvq7QoFHEH184Fj7SfU,662
+makerrepo_cli/cmds/main.py,sha256=mw9s-fWcQtobXUZdXJtbWVEvgx4-tdof3Cjb3o96ry0,120
+makerrepo_cli/cmds/artifacts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+makerrepo_cli/cmds/artifacts/capture_image.py,sha256=Ioww0R6hmXGxpFFuZbXT-wLEdXtlBnDKXOVDWlM28kU,7172
+makerrepo_cli/cmds/artifacts/cli.py,sha256=yutaVOJkT6NMMewYIcf-h9ytzKFGItXtHpcrrFABnro,202
+makerrepo_cli/cmds/artifacts/main.py,sha256=rYO8M3ouhVC7n8RRYaC7CrZHQVsOGDUwMjzQK3AUQMo,5050
+makerrepo_cli/cmds/artifacts/ocp_data_types.py,sha256=-YeAio5godIYcJPzoDIdu67MbqiJDMBkq8QcJJXQvMA,1175
+makerrepo_cli/cmds/artifacts/utils.py,sha256=ZSLfm-S2uYk7Y7mq2fhK2Ki4OC2C6O0bNCZ5nDFLLEo,943
+makerrepo_cli-0.1.0.dist-info/licenses/LICENSE,sha256=e1FWoucPP7MUG3AOBwb3R6PhN4N3KomjFLvu7CWar5Q,1072
+makerrepo_cli-0.1.0.dist-info/METADATA,sha256=hM9A_2yXPgyOPBUr1CgrJHjdagGUWxWz9htm4-GwA6U,405
+makerrepo_cli-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+makerrepo_cli-0.1.0.dist-info/entry_points.txt,sha256=Wcv5tkqI8NIiXZXJAZxTlVwy__9nT0ZfIktwNpPYjWE,95
+makerrepo_cli-0.1.0.dist-info/top_level.txt,sha256=0sONY8MHgWTad63qvsjR1KXe7OOCwF66pDWm6iITrNM,14
+makerrepo_cli-0.1.0.dist-info/RECORD,,

makerrepo_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

makerrepo_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+makerrepo-cli = makerrepo_cli.cmds.main:cli
+mr = makerrepo_cli.cmds.main:cli

makerrepo_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Launch Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

makerrepo_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+makerrepo_cli