axi-control 0.1.1__tar.gz

axi_control-0.1.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.3
+Name: axi-control
+Version: 0.1.1
+Summary: Add your description here
+Requires-Dist: axicli
+Requires-Dist: flask>=3.1.2
+Requires-Dist: ipykernel>=7.1.0
+Requires-Dist: ipywidgets>=8.1.8
+Requires-Dist: platformdirs>=4.2.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+

axi_control-0.1.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["uv_build"]
+build-backend = "uv_build"
+
+[project]
+name = "axi-control"
+version = "0.1.1"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "axicli",
+    "flask>=3.1.2",
+    "ipykernel>=7.1.0",
+    "ipywidgets>=8.1.8",
+    "platformdirs>=4.2.0",
+]
+
+[project.scripts]
+axicontrol-server = "axi_control.cli:main"
+
+[tool.uv.workspace]
+members = ["axidraw"]
+
+[tool.uv]
+required-version = ">=0.7.0"
+
+[tool.uv.sources]
+axicli = { workspace = true }
+
+[tool.uv-ship]
+release-branch = false
+allow-dirty = false
+changelog-path = "CHANGELOG.md"
+date-first = true
+changelog-template = "- {message}"

axi_control-0.1.1/src/axi_control/__init__.py

@@ -0,0 +1,6 @@
+from . import utils as utils
+from .axicontroller import AxiController as AxiController
+from .routes import control as control
+from .routes import plotting as plotting
+from .routes import status as status
+from .servercontext import ServerContext as ServerContext

axi_control-0.1.1/src/axi_control/_axi_server.py

@@ -0,0 +1,145 @@
+# server.py
+
+import argparse
+import logging
+import os
+import signal
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from axidrawinternal.plot_utils_import import from_dependency_import
+from flask import Flask, g, request
+
+import axi_control as axc
+
+SRV_OPTS = 'config/srv_options.json'
+PID_FILE = Path('/tmp/axi_server.pid')
+
+LOCKED_ENDPOINTS = {
+    'nudge_x',
+    'nudge_y',
+    'home',
+    'move_xy',
+    'move_to',
+    'set_home',
+    'toggle_pen',
+    'cycle_pen',
+    'disable_motors',
+    'enable_motors',
+    'prime',
+    'motor_state',
+}
+
+
+# ---------- setup paths & logging ----------
+log_dir = Path(os.getcwd()) / 'logs'
+log_dir.mkdir(parents=True, exist_ok=True)
+
+timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+log_filename = log_dir / 'axiserver.log'
+plot_status_log_filename = log_dir / 'plot_status.log'
+
+logging.basicConfig(
+    filename=log_filename,
+    filemode='w',
+    level=logging.INFO,
+    format='%(asctime)s %(levelname)s: %(message)s',
+)
+
+# logging.getLogger('werkzeug').addFilter(axc.utils.RequestFilter())
+SKIP_LOG_PATHS = {}  # {'/log', '/axidraw_status', '/motor_state'}
+# ˆˆˆ these tend to be very frequent and clutter the access log. replaces above
+logging.getLogger('werkzeug').setLevel(logging.WARNING)
+ACCESS_LOGGER = logging.getLogger('axi_access')
+
+
+# ---------- app & controller ----------
+def create_app(artwork_root: str | None):
+    file_root = axc.utils.select_file_root(artwork_root)
+    app = Flask(__name__)
+    ad = axc.AxiController()
+    ebb_serial = from_dependency_import('plotink.ebb_serial')
+    ctx = axc.ServerContext(
+        ad=ad,
+        ebb_serial=ebb_serial,
+        file_root=file_root,
+        srv_opts_path=SRV_OPTS,
+        log_filename=log_filename,
+        plot_status_log_filename=plot_status_log_filename,
+    )
+
+    @app.before_request
+    def _lock_ad_access():
+        if request.endpoint in LOCKED_ENDPOINTS:
+            ctx.ad_lock.acquire()
+            g.ad_lock_acquired = True
+
+    @app.teardown_request
+    def _unlock_ad_access(_exc):
+        if getattr(g, 'ad_lock_acquired', False):
+            ctx.ad_lock.release()
+
+    @app.after_request
+    def _log_access(response):
+        if request.path in SKIP_LOG_PATHS:
+            return response
+        remote_addr = request.remote_addr or '-'
+        path = request.full_path.rstrip('?')
+        size = response.calculate_content_length()
+        size_text = size if size is not None else '-'
+        ACCESS_LOGGER.info(
+            '%s "%s %s" %s %s',
+            remote_addr,
+            request.method,
+            path,
+            response.status_code,
+            size_text,
+        )
+        return response
+
+    axc.control.register(app, ctx)
+    axc.status.register(app, ctx)
+    axc.plotting.register(app, ctx)
+    return app, ctx
+
+
+def cleanup(signum=None, frame=None):
+    logging.info('Cleaning up, signal=%s', signum)
+    PID_FILE.unlink(missing_ok=True)
+    sys.exit(0)
+
+
+# ---------- entry point ----------
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='AxiControl Flask server')
+    parser.add_argument(
+        '--dev',
+        action='store_true',
+        help='Skip hardware connection checks for local development',
+    )
+    parser.add_argument(
+        '--artwork-root',
+        default=None,
+        help='Root directory for artwork SVGs (overrides ARTWORK_ROOT).',
+    )
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    args = _parse_args()
+    app, ctx = create_app(args.artwork_root)
+    logging.info('Artwork root set to %s', ctx.file_root)
+
+    if not args.dev:
+        if not ctx.ad.connect():
+            logging.error('AxiController connection failed')
+            raise RuntimeError('AxiController connection failed')
+    # write PID only for the real server process
+    PID_FILE.write_text(str(os.getpid()))
+
+    # clean shutdown
+    signal.signal(signal.SIGTERM, cleanup)
+    signal.signal(signal.SIGINT, cleanup)
+
+    app.run(host='0.0.0.0', port=5050, threaded=True)

axi_control-0.1.1/src/axi_control/axicontroller.py

@@ -0,0 +1,271 @@
+import logging
+import time
+from pathlib import Path
+
+from axidrawinternal.plot_utils_import import from_dependency_import
+from pyaxidraw.axidraw import AxiDraw
+
+from . import utils
+
+ebb_motion = from_dependency_import('plotink.ebb_motion')
+logger = logging.getLogger(__name__)
+
+SCRIPT_PATH = Path(__file__).resolve()
+repo_path = SCRIPT_PATH.parent.parent.parent
+
+
+class AxiController(AxiDraw):
+    def __init__(self):
+        self._force_cli_api = False
+        self._forced_total_mm = None
+        super().__init__(user_message_fun=logger.info)
+
+        setattr(self.options, 'units', 0)  # set the default right away
+
+    def set_defaults(self):
+        super().set_defaults()
+        self.plot_status.progress.enable = False
+        self.plot_status.progress.dry_run = False
+        self.plot_status.progress.total = 0
+        self.plot_status.progress.last = 0
+        self.plot_status.progress.p_bar = None
+        self.plot_status.progress.sub_bar = None
+        if self._force_cli_api:
+            self.plot_status.cli_api = True
+            self.options.progress = True
+            if self._forced_total_mm is not None:
+                self.plot_status.progress.total = self._forced_total_mm
+
+    def _estimate_total_mm(self, file) -> float | None:
+        self.plot_setup(file)
+        time.sleep(0.2)
+        self.options.mode = 'plot'
+        self.options.preview = True
+        self.options.rendering = 0
+        self.options.digest = 0
+        self.options.progress = False
+        self.options.progress_no_dry_run = True
+        self._force_cli_api = False
+        self.plot_status.cli_api = False
+        self.apply_srv_options()
+        try:
+            self.plot_run()
+        except Exception as exc:
+            logger.warning('Estimate failed: %s', exc)
+            return None
+        total_inch = self.plot_status.stats.down_travel_inch + self.plot_status.stats.up_travel_inch
+        return 25.4 * total_inch
+
+    def plot_file(
+        self,
+        file,
+        enable_progress: bool = False,
+        allow_estimate: bool = True,
+        return_output: bool = False,
+    ):
+        total_mm = None
+        if enable_progress and allow_estimate:
+            total_mm = self._estimate_total_mm(file)
+
+        self.plot_setup(file)
+        time.sleep(0.5)  # Wait half second
+        self.options.mode = 'plot'
+        self.options.preview = False
+        self.options.digest = 0
+        self.options.progress_no_dry_run = True
+        self._force_cli_api = enable_progress
+        self.plot_status.cli_api = enable_progress
+        self.options.progress = enable_progress
+        self._forced_total_mm = total_mm if total_mm is not None else None
+        logger.info(
+            'Plot start: progress=%s cli_api=%s preview=%s digest=%s mode=%s estimate=%s',
+            self.options.progress,
+            self.plot_status.cli_api,
+            self.options.preview,
+            self.options.digest,
+            self.options.mode,
+            allow_estimate,
+        )
+        self.apply_srv_options()
+        output_svg = self.plot_run(output=return_output)
+        if return_output:
+            return output_svg, self.plot_status.stopped
+        return None
+
+    def resume_plot(self, svg_input, enable_progress: bool = False):
+        self.plot_setup(svg_input)
+        time.sleep(0.5)  # Wait half second
+        self.options.mode = 'res_plot'
+        self.options.preview = False
+        self.options.digest = 0
+        self.options.progress_no_dry_run = True
+        self._force_cli_api = enable_progress
+        self.plot_status.cli_api = enable_progress
+        self.options.progress = enable_progress
+        logger.info(
+            'Resume start: progress=%s cli_api=%s preview=%s digest=%s mode=%s',
+            self.options.progress,
+            self.plot_status.cli_api,
+            self.options.preview,
+            self.options.digest,
+            self.options.mode,
+        )
+        self.apply_srv_options()
+        output_svg = self.plot_run(output=True)
+        return output_svg, self.plot_status.stopped
+
+    def apply_srv_options(self, srv_options: dict = None):
+        if srv_options is None:
+            file = repo_path / 'config' / 'srv_options.json'
+            srv_options = utils.load_srv_options(file)
+
+        for k, v in srv_options.items():
+            if hasattr(self.options, k):
+                if k == 'units':
+                    unit_map = {'mm': 2, 'cm': 1, 'in': 0}
+                    v = unit_map.get(v, 0)
+
+                setattr(self.options, k, v)
+
+    def motor_state(self):
+        temp_connected = False
+        try:
+            if not self.connected or self.plot_status.port is None:
+                self.serial_connect()
+                temp_connected = True
+            if self.plot_status.port is None:
+                return None
+            res = ebb_motion.query_enable_motors(self.plot_status.port, False)
+            if not res or res[0] is None or res[1] is None:
+                return None
+            return res[0] > 0 and res[1] > 0
+        except Exception:
+            return None
+        finally:
+            if temp_connected:
+                self.disconnect()
+
+    def _util(self, func, **kwargs):
+        self.plot_setup()
+        self.options.mode = 'manual'
+        self.options.manual_cmd = func
+
+        for k, v in kwargs.items():
+            if v is not None:
+                if hasattr(self.options, k):
+                    setattr(self.options, k, v)
+
+        self.apply_srv_options()
+        self.plot_run()
+
+    def util_motors_on(self):
+        self._util('enable_xy')
+
+    def util_motors_off(self):
+        self._util('disable_xy')
+
+    def util_cycle(self):
+        self.i_pendown()
+        self.i_delay(500)
+        self.i_penup()
+        # self.disconnect()
+
+    def util_toggle(self):
+        self.i_penup() if not self.i_current_pen() else self.i_pendown()
+        # self.disconnect()
+
+    def util_align(self):
+        self.plot_setup()
+        self.options.mode = 'align'
+        self.apply_srv_options()
+        self.plot_run()
+
+    def util_home(self):
+        self._util('walk_home')
+
+    def util_nudge_x(self, dist, unit='mm'):
+        if unit == 'in':
+            self._util('walk_x', dist=dist)
+        elif unit == 'mm':
+            self._util('walk_mmx', dist=dist)
+        else:
+            raise ValueError('Invalid unit for walk_x: use "mm" or "in"')
+
+    def util_nudge_y(self, dist, unit='mm'):
+        if unit == 'in':
+            self._util('walk_y', dist=dist)
+        elif unit == 'mm':
+            self._util('walk_mmy', dist=dist)
+        else:
+            raise ValueError('Invalid unit for walk_y: use "mm" or "in"')
+
+    ############ Interactive commands
+    def _iactive(self, func, *args, **kwargs) -> None:
+        if not self.options.mode == 'interactive':
+            print('Switching to interactive mode...')
+            self.interactive()
+
+        self.apply_srv_options()
+
+        if not self.connected:
+            print('Connecting to AxiDraw device...')
+            self.connect()
+            if not self.connected:
+                raise ConnectionError('Could not connect to AxiDraw device.')
+
+        self.update()  # when options are changed after connect
+        res = func(*args, **kwargs)
+        return res
+
+        # self.disconnect()
+
+    def i_goto(self, x_target: float, y_target: float) -> None:
+        return self._iactive(self.goto, x_target=x_target, y_target=y_target)
+
+    def i_moveto(self, x_target: float, y_target: float) -> None:
+        return self._iactive(self.moveto, x_target=x_target, y_target=y_target)
+
+    def i_lineto(self, x_target: float, y_target: float) -> None:
+        return self._iactive(self.lineto, x_target=x_target, y_target=y_target)
+
+    def i_go(self, delta_x: float, delta_y: float) -> None:
+        return self._iactive(self.go, delta_x, delta_y)
+
+    def i_move(self, delta_x: float, delta_y: float) -> None:
+        return self._iactive(self.move, delta_x, delta_y)
+
+    def i_line(self, delta_x: float, delta_y: float) -> None:
+        return self._iactive(self.line, delta_x=delta_x, delta_y=delta_y)
+
+    def i_penup(self) -> None:
+        return self._iactive(self.penup)
+
+    def i_pendown(self) -> None:
+        return self._iactive(self.pendown)
+
+    def i_draw_path(self, vertex_list) -> None:
+        return self._iactive(self.draw_path, vertex_list=vertex_list)
+
+    def i_delay(self, time_ms) -> None:
+        return self._iactive(self.delay, time_ms=time_ms)
+
+    def i_block(self) -> None:
+        return self._iactive(self.block)
+
+    def i_current_pos(self) -> None:
+        return self._iactive(self.current_pos)
+
+    def i_turtle_pos(self) -> None:
+        return self._iactive(self.turtle_pos)
+
+    def i_current_pen(self) -> None:
+        return self._iactive(self.current_pen)
+
+    def i_turtle_pen(self) -> None:
+        return self._iactive(self.turtle_pen)
+
+    def i_usb_command(self) -> None:
+        return self._iactive(self.usb_command)
+
+    def i_usb_query(self) -> None:
+        return self._iactive(self.usb_query)

axi_control-0.1.1/src/axi_control/cli.py

@@ -0,0 +1,196 @@
+import argparse
+import logging
+import os
+import signal
+import sys
+from pathlib import Path
+
+import platformdirs
+from axidrawinternal.plot_utils_import import from_dependency_import
+from flask import Flask, g, request
+
+import axi_control as axc
+
+APP_NAME = "axi-control"
+APP_AUTHOR = "AxiControl"
+PID_FILE = Path("/tmp/axi_server.pid")
+
+LOCKED_ENDPOINTS = {
+    "nudge_x",
+    "nudge_y",
+    "home",
+    "move_xy",
+    "move_to",
+    "set_home",
+    "toggle_pen",
+    "cycle_pen",
+    "disable_motors",
+    "enable_motors",
+    "prime",
+    "motor_state",
+}
+
+
+def create_app(artwork_root: str | None, srv_opts_path: Path, log_filename: Path, plot_status_log_filename: Path):
+    file_root = axc.utils.select_file_root(artwork_root)
+    app = Flask(__name__)
+    ad = axc.AxiController()
+    ebb_serial = from_dependency_import("plotink.ebb_serial")
+    ctx = axc.ServerContext(
+        ad=ad,
+        ebb_serial=ebb_serial,
+        file_root=file_root,
+        srv_opts_path=srv_opts_path,
+        log_filename=log_filename,
+        plot_status_log_filename=plot_status_log_filename,
+    )
+
+    @app.before_request
+    def _lock_ad_access():
+        if request.endpoint in LOCKED_ENDPOINTS:
+            ctx.ad_lock.acquire()
+            g.ad_lock_acquired = True
+
+    @app.teardown_request
+    def _unlock_ad_access(_exc):
+        if getattr(g, "ad_lock_acquired", False):
+            ctx.ad_lock.release()
+
+    @app.after_request
+    def _log_access(response):
+        if request.path in SKIP_LOG_PATHS:
+            return response
+        remote_addr = request.remote_addr or "-"
+        path = request.full_path.rstrip("?")
+        size = response.calculate_content_length()
+        size_text = size if size is not None else "-"
+        ACCESS_LOGGER.info(
+            "%s \"%s %s\" %s %s",
+            remote_addr,
+            request.method,
+            path,
+            response.status_code,
+            size_text,
+        )
+        return response
+
+    axc.control.register(app, ctx)
+    axc.status.register(app, ctx)
+    axc.plotting.register(app, ctx)
+    return app, ctx
+
+
+def cleanup(signum=None, frame=None):
+    logging.info("Cleaning up, signal=%s", signum)
+    PID_FILE.unlink(missing_ok=True)
+    sys.exit(0)
+
+
+def _resolve_dir(cli_value: str | None, env_var: str | None, fallback: Path) -> Path:
+    if cli_value:
+        return Path(cli_value).expanduser().resolve()
+    if env_var:
+        return Path(env_var).expanduser().resolve()
+    return fallback
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="AxiControl Flask server")
+    parser.add_argument(
+        "--dev",
+        action="store_true",
+        help="Skip hardware connection checks for local development",
+    )
+    parser.add_argument(
+        "--artwork-root",
+        default=None,
+        help="Root directory for artwork SVGs (overrides ARTWORK_ROOT).",
+    )
+    parser.add_argument(
+        "--config-dir",
+        default=None,
+        help="Directory to store configuration (overrides AXI_CONTROL_CONFIG_DIR).",
+    )
+    parser.add_argument(
+        "--log-dir",
+        default=None,
+        help="Directory to store logs (overrides AXI_CONTROL_LOG_DIR).",
+    )
+    parser.add_argument(
+        "--srv-options",
+        default=None,
+        help="Path to srv_options.json (overrides AXI_CONTROL_SRV_OPTIONS).",
+    )
+    parser.add_argument(
+        "--host",
+        default="0.0.0.0",
+        help="Host to bind the server.",
+    )
+    parser.add_argument(
+        "--port",
+        default=5050,
+        type=int,
+        help="Port to bind the server.",
+    )
+    return parser.parse_args()
+
+
+SKIP_LOG_PATHS = {}
+logging.getLogger("werkzeug").setLevel(logging.WARNING)
+ACCESS_LOGGER = logging.getLogger("axi_access")
+
+
+def main() -> None:
+    args = _parse_args()
+
+    config_dir = _resolve_dir(
+        args.config_dir,
+        os.environ.get("AXI_CONTROL_CONFIG_DIR"),
+        Path(platformdirs.user_config_dir(APP_NAME, APP_AUTHOR)),
+    )
+    log_dir = _resolve_dir(
+        args.log_dir,
+        os.environ.get("AXI_CONTROL_LOG_DIR"),
+        Path(platformdirs.user_log_dir(APP_NAME, APP_AUTHOR)),
+    )
+    config_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    srv_opts_path = args.srv_options or os.environ.get("AXI_CONTROL_SRV_OPTIONS")
+    if srv_opts_path:
+        srv_opts_path = Path(srv_opts_path).expanduser().resolve()
+    else:
+        srv_opts_path = config_dir / "srv_options.json"
+
+    axc.utils.ensure_srv_options(srv_opts_path)
+
+    log_filename = log_dir / "axiserver.log"
+    plot_status_log_filename = log_dir / "plot_status.log"
+
+    logging.basicConfig(
+        filename=log_filename,
+        filemode="a",
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s: %(message)s",
+    )
+
+    app, ctx = create_app(args.artwork_root, srv_opts_path, log_filename, plot_status_log_filename)
+    logging.info("Artwork root set to %s", ctx.file_root)
+    logging.info("Using srv_options at %s", srv_opts_path)
+    logging.info("Logs directory set to %s", log_dir)
+
+    if not args.dev:
+        if not ctx.ad.connect():
+            logging.error("AxiController connection failed")
+            raise RuntimeError("AxiController connection failed")
+
+    PID_FILE.write_text(str(os.getpid()))
+
+    signal.signal(signal.SIGTERM, cleanup)
+    signal.signal(signal.SIGINT, cleanup)
+
+    app.run(host=args.host, port=args.port, threaded=True)
+
+
+if __name__ == "__main__":
+    main()