lager-cli 0.46.0__tar.gz → 0.46.2__tar.gz

{lager_cli-0.46.0/lager_cli.egg-info → lager_cli-0.46.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lager-cli
-Version: 0.46.0
+Version: 0.46.2
 Summary: Lager CLI - Box and Docker connectivity
 Home-page: https://github.com/lagerdata/lager
 Author: Lager Data

{lager_cli-0.46.0 → lager_cli-0.46.2}/__init__.py

@@ -7,4 +7,4 @@ Lager CLI
 A Command Line Interface for Lager Data
 """
 
-__version__ = '0.46.0'
+__version__ = '0.46.2'

{lager_cli-0.46.0 → lager_cli-0.46.2}/commands/box/nets.py

@@ -422,6 +422,33 @@ def canonical_instrument(instrument):
     return _INSTRUMENT_ALIASES.get(instrument, instrument)
 
 
+# Pins whose rejection has a better answer than "pick another channel". On a
+# U3 these four are the fixed high-voltage analog inputs, so a user reaching
+# for gpio there wants an adc net on the SAME physical pins, under the name
+# they carry in analog mode. The scanner stopped advertising them as gpio
+# (box/lager/http_handlers/usb_scanner.py), and this is what turns the
+# resulting rejection into a next step rather than a dead end. Raw DIO
+# numbers are included because the U3 drivers accept either spelling.
+_U3_HV_PINS = {"FIO0", "FIO1", "FIO2", "FIO3", "0", "1", "2", "3"}
+
+
+def _channel_rejection_hint(instrument, role, channel):
+    """An extra line for channel rejections that have a specific remedy.
+
+    Returns None when the generic "here are the valid channels" line is the
+    whole story, which is the case for every instrument but the U3.
+    """
+    if (canonical_instrument(instrument) == "LabJack_U3"
+            and role == "gpio"
+            and str(channel).upper() in _U3_HV_PINS):
+        return (
+            "FIO0-FIO3 on a LabJack U3 are fixed high-voltage analog inputs "
+            "and are never digital I/O. Read them with an adc net on "
+            "AIN0-AIN3, the same physical pins."
+        )
+    return None
+
+
 # Chips that can run in exactly one mode at a time, across ALL roles. The
 # canonical case is the FT232H: one physical channel, hardware-multiplexed
 # between MPSSE (spi/i2c/gpio/debug) and async-serial (uart). Once the user
@@ -1325,6 +1352,18 @@ def add_cmd(ctx, name, role, channel, address, box, jlink_script, openocd_config
                     f"The channel '{channel}' is not valid for role '{role}' on the instrument at {address}.",
                     fg="red",
                 )
+                # Naming what IS valid, the way the role rejection below
+                # does. Both lines stay on stdout with the one above them:
+                # cli/setup.py pins only click>=8.1.2, and 8.2's CliRunner
+                # stopped folding stderr into result.output, so moving them
+                # would change what every existing CLI test can see.
+                click.secho(
+                    f"Valid {role} channels for {instrument}: "
+                    f"{', '.join(str(ch) for ch in role_chans)}"
+                )
+                hint = _channel_rejection_hint(instrument, role, channel)
+                if hint:
+                    click.secho(hint, fg="yellow")
                 ctx.exit(1)
 
     # ─────────── unique net name (regardless of type) ────────────────
@@ -2040,7 +2079,13 @@ def create_batch_cmd(ctx: click.Context, json_file, box: str | None) -> None:
     # net never need the scan.
     _instrument_cache: list | None = None
 
-    def _get_instrument_from_address(address: str, fallback_instrument: str = "Unknown") -> str:
+    def _get_scanned_device(address: str) -> dict | None:
+        """The scanned record for *address*, or None when it is not present.
+
+        Shares the one lazy scan with _get_instrument_from_address. A batch
+        run against a box that is down, or naming hardware that is unplugged,
+        gets None here and keeps its pre-0.46.1 behavior.
+        """
         nonlocal _instrument_cache
         if _instrument_cache is None:
             try:
@@ -2049,11 +2094,19 @@ def create_batch_cmd(ctx: click.Context, json_file, box: str | None) -> None:
                 _instrument_cache = []
         for inst in _instrument_cache:
             if inst.get("address") == address:
-                return inst.get("name", "Unknown")
-        return fallback_instrument
+                return inst
+        return None
+
+    def _get_instrument_from_address(address: str, fallback_instrument: str = "Unknown") -> str:
+        inst = _get_scanned_device(address)
+        return inst.get("name", "Unknown") if inst else fallback_instrument
 
     # Validate and normalize each net in the batch
     normalized_nets = []
+    # Channel rejections are collected, not raised in the loop: _save_nets_batch
+    # is all-or-nothing, so telling the user about record 3 and hiding record 7
+    # would cost them a second run to find the next one.
+    channel_errors: list[str] = []
 
     for i, net_data in enumerate(nets_data):
         if not isinstance(net_data, dict):
@@ -2080,8 +2133,47 @@ def create_batch_cmd(ctx: click.Context, json_file, box: str | None) -> None:
             "pin": net_data["channel"],
             "instrument": instrument
         }
+
+        # Reject a channel the present hardware does not offer, the way
+        # `nets add` does. Deliberately narrow:
+        #
+        #   * only when the device is actually in the scan. This command is
+        #     built to provision a box whose instruments are absent or named
+        #     by bare IP, and _get_instrument_from_address already falls back
+        #     to "Unknown" for those. Rejecting what we cannot see would break
+        #     that, fleet-wide, for hardware unrelated to the U3.
+        #   * never for uart, whose channels are per-device tty paths rather
+        #     than the static list (see uart_channel_paths).
+        #
+        # What it does catch is the case this exists for: a hand-written
+        # record naming a pin the instrument cannot drive, which used to be
+        # saved without complaint and fail at first use.
+        batch_role = normalized_net["role"]
+        if batch_role != "uart":
+            dev = _get_scanned_device(net_data["address"])
+            role_chans = (dev.get("channels") or {}).get(batch_role) if dev else None
+            if isinstance(role_chans, list) and role_chans:
+                if str(net_data["channel"]) not in [str(ch) for ch in role_chans]:
+                    detail = (
+                        f"Net {i+1} ('{net_data['name']}'): channel "
+                        f"'{net_data['channel']}' is not valid for role "
+                        f"'{batch_role}' on {instrument}. Valid: "
+                        f"{', '.join(str(ch) for ch in role_chans)}"
+                    )
+                    hint = _channel_rejection_hint(
+                        instrument, batch_role, net_data["channel"])
+                    if hint:
+                        detail = f"{detail}\n    {hint}"
+                    channel_errors.append(detail)
+
         normalized_nets.append(normalized_net)
 
+    if channel_errors:
+        for detail in channel_errors:
+            click.secho(detail, fg="red", err=True)
+        click.secho("No nets were saved.", fg="red", err=True)
+        ctx.exit(1)
+
     # Use batch save for better performance
     _save_nets_batch(ctx, resolved_box, normalized_nets)
 

{lager_cli-0.46.0 → lager_cli-0.46.2}/commands/utility/exec_.py

@@ -16,6 +16,7 @@ import platform
 from pathlib import Path
 import click
 from ...config import get_devenv_json, write_lager_json, LAGER_CONFIG_FILE_NAME, get_global_config_file_path, devenv_config_list, expand_devenv_path
+from ...context.ci_detection import get_ci_environment, is_container_ci
 from ...core.param_types import EnvVarType
 
 
@@ -150,6 +151,81 @@ def _run_command_local(section, path, cmd_to_run, mount, extra_args, debug, inte
         return 1
 
 
+# Config keys that only apply when we start a container. A .lager is shared between a
+# developer's machine and CI, so carrying these is normal and not worth a warning on every
+# CI run -- they are reported under --verbose instead.
+_DOCKER_ONLY_CONFIG_KEYS = ('network', 'ports', 'platform', 'macaddr', 'hostname',
+                            'volumes', 'user', 'group')
+
+
+def _warn_docker_only_options(section, mount, volumes, user, group, debug):
+    """
+    Name the options that cannot take effect when the command runs in place.
+
+    Flags passed on the command line are warned about unconditionally: the caller asked
+    for something this path cannot do. Config keys are quieter, for the reason above.
+    """
+    ignored = []
+    if mount:
+        ignored.append('--mount')
+    if volumes:
+        ignored.append('--volume')
+    if user:
+        ignored.append('--user')
+    if group:
+        ignored.append('--group')
+
+    if ignored:
+        click.secho(
+            f'Warning: {", ".join(ignored)} ignored: the command runs in the current '
+            f'container, so there is nothing to start.',
+            fg='yellow', err=True)
+
+    if debug:
+        from_config = [key for key in _DOCKER_ONLY_CONFIG_KEYS if section.get(key)]
+        if from_config:
+            click.echo(
+                f'Ignoring container-only .lager keys: {", ".join(from_config)}', err=True)
+
+
+def _run_command_container(section, cmd_to_run, extra_args, debug, env):
+    """
+    Run a command in place, without starting a container.
+
+    A container-based CI job already runs inside the devenv image: the shell, the
+    toolchain and the checkout are all there. There is also no Docker inside that job
+    container, so starting one is not an option even if it were wanted.
+
+    Deliberately does not chdir. The Docker path sets `-w <mount_dir>` because it bind-mounts
+    the checkout to that path; here the checkout is wherever the CI system put it, and the
+    caller's working directory is already correct.
+    """
+    # `or`, not a .get default: a .lager may carry an explicit empty shell, and handing
+    # that to subprocess.run raises rather than reporting anything useful.
+    shell = section.get('shell') or '/bin/bash'
+    full_command = ' '.join((cmd_to_run, *extra_args)).strip()
+
+    child_env = os.environ.copy()
+    for env_var in (*devenv_config_list(section.get('environment')), *env):
+        name, _, value = str(env_var).partition('=')
+        child_env[name] = value
+
+    if debug:
+        click.echo(f'Command: {full_command}', err=True)
+        click.echo(f'Running in the current container ({shell})', err=True)
+
+    try:
+        proc = subprocess.run([shell, '-c', full_command], check=False, env=child_env)
+        return proc.returncode
+    except FileNotFoundError:
+        click.secho(f'Error: shell `{shell}` not found in this container', fg='red', err=True)
+        click.echo('Set DEVENV `shell` in .lager to a shell the image provides.', err=True)
+        return 1
+    except PermissionError:
+        click.secho(f'Error: permission denied running `{shell}`', fg='red', err=True)
+        return 1
+
+
 @click.command(name='exec', context_settings={"ignore_unknown_options": True},
                short_help="Run a saved command in a local docker container")
 @click.pass_context
@@ -192,6 +268,10 @@ def exec_(ctx, cmd_name, extra_args, command, save_as, warn, env, passenv, mount
 
     section = data['DEVENV']
 
+    # Captured before the defaulting below, which always resolves a uid/gid: the
+    # in-container path warns about what the caller actually asked for, not the default.
+    requested_user, requested_group = user, group
+
     # Precedence: CLI flag wins, then .lager config, then the current uid/gid.
     if user is None:
         user = section.get('user')
@@ -248,9 +328,20 @@ def exec_(ctx, cmd_name, extra_args, command, save_as, warn, env, passenv, mount
                 ctx.exit(1)
             click.echo(f'Saved command: {save_as}')
 
+    debug = ctx.obj.debug or verbose
+
+    # Under container-based CI the job is already running inside the devenv image, so the
+    # command runs in place. Starting a container from in there would need a Docker the job
+    # container does not have. LAGER_CI_OVERRIDE forces this back to the Docker path.
+    if is_container_ci(get_ci_environment()):
+        _warn_docker_only_options(section, mount, volumes, requested_user, requested_group, debug)
+        # passenv needs no argument here: the child inherits our environment already.
+        returncode = _run_command_container(section, cmd_to_run, extra_args, debug, env)
+        ctx.exit(returncode)
+
     # Run the command locally in Docker
     returncode = _run_command_local(
         section, path, cmd_to_run, mount, extra_args,
-        ctx.obj.debug or verbose, interactive, tty, user, group, env, passenv, volumes
+        debug, interactive, tty, user, group, env, passenv, volumes
     )
     ctx.exit(returncode)

{lager_cli-0.46.0 → lager_cli-0.46.2/lager_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lager-cli
-Version: 0.46.0
+Version: 0.46.2
 Summary: Lager CLI - Box and Docker connectivity
 Home-page: https://github.com/lagerdata/lager
 Author: Lager Data