lager-cli 0.32.2__tar.gz → 0.32.4__tar.gz

{lager_cli-0.32.2/lager_cli.egg-info → lager_cli-0.32.4}/PKG-INFO

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

{lager_cli-0.32.2 → lager_cli-0.32.4}/__init__.py

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

{lager_cli-0.32.2 → lager_cli-0.32.4}/commands/utility/uninstall.py

@@ -603,7 +603,7 @@ def uninstall(ctx, box, ip, user, keep_config, keep_docker_images, remove_all, y
     click.echo("  - Docker containers (lager, pigpio)")
     click.echo("  - Docker network (lagernet)")
     if not keep_docker_images:
-        click.echo("  - Docker images (ALL unused images on the box, not only lager's)")
+        click.echo("  - Docker images (the lager image and dangling layers only)")
     click.echo("  - ~/box directory")
     if not keep_config:
         click.echo("  - /etc/lager directory (saved nets)")
@@ -707,10 +707,15 @@ def uninstall(ctx, box, ip, user, keep_config, keep_docker_images, remove_all, y
         run_ssh("docker network rm lagernet 2>/dev/null", "Removing lagernet network", allow_fail=True)
         click.echo()
 
-        # Remove Docker images (unless --keep-docker-images)
+        # Remove Docker images (unless --keep-docker-images). Scoped to the
+        # lager image plus dangling layers: 'prune -af' would also delete
+        # images belonging to any OTHER stopped container on the box (a
+        # management agent, a user's own services) — infrastructure this
+        # command cannot restore.
         click.secho("[Step 2/5] Cleaning Docker...", fg='cyan')
         if not keep_docker_images:
-            run_ssh("docker image prune -af 2>/dev/null", "Removing Docker images", allow_fail=True)
+            run_ssh("docker rmi -f lager 2>/dev/null", "Removing lager image", allow_fail=True)
+            run_ssh("docker image prune -f 2>/dev/null", "Removing dangling images", allow_fail=True)
             run_ssh("docker builder prune -af 2>/dev/null", "Clearing Docker build cache", allow_fail=True)
         else:
             click.echo("  Skipping Docker image removal (--keep-docker-images)")

{lager_cli-0.32.2 → lager_cli-0.32.4}/commands/utility/update.py

@@ -229,6 +229,15 @@ if test -f /etc/lager/.boxcfg-sudoers-v2 && sudo -n DEBIAN_FRONTEND=noninteracti
 else
   echo "LAGER_PROBE_BOXCFG_SUDOERS_OK=0"
 fi
+# Container liveness: 1 = the `lager` container is running, 0 = docker
+# answered and it is not, empty = docker itself didn't answer (unknown;
+# callers fail open). `docker ps` lists running containers only, and its
+# name filter is a substring match, so exact-match the name on our side.
+if _dps=$(docker ps --filter name=lager --format '{{.Names}}' 2>/dev/null); then
+  echo "LAGER_PROBE_LAGER_RUNNING=$(printf '%s\n' "$_dps" | grep -cx lager)"
+else
+  echo "LAGER_PROBE_LAGER_RUNNING="
+fi
 echo "LAGER_PROBE_ETC_VERSION=$(cat /etc/lager/version 2>/dev/null)"
 '''
     return script.replace('__BUILD_HASH_CMD__', _build_hash_shell_cmd())
@@ -249,6 +258,60 @@ def _parse_probe_output(stdout):
     return facts
 
 
+def _build_hash_mismatch(new_hash, stored_hash):
+    """True when the docker-build inputs changed relative to the last
+    successful build.
+
+    Both values must be non-empty: an empty new hash means the probe couldn't
+    measure the inputs, an empty stored hash means no successful build has
+    recorded one — in either case auto-invalidation is skipped rather than
+    guessed. A failed build stores the sentinel value 'FAILED' (never a real
+    sha256), which forces a mismatch — and therefore a clean rebuild — on the
+    next run.
+    """
+    return bool(new_hash) and bool(stored_hash) and new_hash != stored_hash
+
+
+def _rebuild_gate_verdict(facts, *, git_sync_confirmed, needs_pull,
+                          needs_flatten, hash_mismatch, force):
+    """Decide whether the update can stop before the container rebuild.
+
+    Returns:
+      'rebuild'        — source state demands the full stop/build/start path.
+      'container-down' — source is in sync but the lager container is not
+                         running (e.g. a previous update failed after the
+                         containers were removed): rebuild so the box comes
+                         back up, instead of falsely reporting success.
+      'skip'           — in sync and running; safe to early-exit.
+
+    The probe's LAGER_RUNNING fact is tri-state: '1' running, '0' definitely
+    not running, ''/absent unknown (the docker probe itself failed). Only a
+    definite '0' blocks the skip — unknown fails open, same philosophy as the
+    BuildKit preflight.
+    """
+    if not git_sync_confirmed or needs_pull or needs_flatten or hash_mismatch or force:
+        return 'rebuild'
+    if facts.get('LAGER_RUNNING', '') == '0':
+        return 'container-down'
+    return 'skip'
+
+
+def _deployed_version_stale(tree_version, etc_version_raw):
+    """True when the box tree's version differs from the last version a
+    successful update actually deployed (/etc/lager/version, `box|cli`
+    format — written only after a successful rebuild+restart).
+
+    Catches the tree-ahead-of-deploy state: an update that pulled and then
+    exited before the container stop (BuildKit preflight failure, an
+    interrupt in the pull->stop window) leaves the container serving the
+    previous build while git reads as in sync and the container as running.
+    Unknown on either side fails open (returns False) so legacy boxes with a
+    missing/empty version file don't rebuild forever.
+    """
+    deployed = (etc_version_raw or '').split('|', 1)[0].strip()
+    return bool(tree_version) and bool(deployed) and deployed != tree_version
+
+
 # Progress-bar denominator. 15 steps always run; 3 are conditional (flatten,
 # cached-image wipe, J-Link install). We use the max so the denominator never
 # jumps mid-flight — light paths simply finish below 18/18 and `finish()`
@@ -1082,7 +1145,7 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
     # any mutation (no git checkout, no udev install, no docker stop).
     # Exit codes:
     #   0 — already in sync, nothing to do
-    #   1 — would update (code, deps, or both)
+    #   1 — would update (code, deps, or a stopped container to bring back up)
     #   2 — could not determine state (network error, etc.)
     if check:
         if progress:
@@ -1096,15 +1159,24 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
         # reflect the tree that would be built — no extra round-trip needed.
         _check_new_hash = facts.get('BUILD_HASH_NEW', '')
         _check_stored_hash = facts.get('BUILD_HASH_STORED', '')
-        deps_will_change = (
-            bool(_check_new_hash) and bool(_check_stored_hash)
-            and _check_new_hash != _check_stored_hash
-        )
+        deps_will_change = _build_hash_mismatch(_check_new_hash, _check_stored_hash)
+        container_down = facts.get('LAGER_RUNNING', '') == '0'
 
         if not git_sync_confirmed:
             click.secho('Could not determine update state (git rev-list failed).', fg='red', err=True)
             ctx.exit(2)
 
+        # Only worth a look when everything else reads clean — any other
+        # divergence already forces the rebuild that would fix it. (Local
+        # import: a later `import re` in this function makes `re` local to
+        # the whole function, so the module-level binding is shadowed here.)
+        deploy_stale = False
+        if not container_down and commits_behind == 0 and commits_ahead == 0:
+            import re
+            _vp = re.match(r'^v?(\d+\.\d+\.\d+)$', target_version)
+            _tree_v = _vp.group(1) if _vp else _read_box_source_version(run_ssh_command_with_output)
+            deploy_stale = _deployed_version_stale(_tree_v, current_version_raw)
+
         if commits_behind == 0 and commits_ahead == 0:
             code_status = 'in sync'
         elif is_rollback:
@@ -1131,6 +1203,17 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
         if force:
             container_status = 'will restart (forced clean rebuild)'
             est = '~6 min (fresh build)'
+        elif container_down:
+            # Code may be fully in sync, but there is nothing serving it — a
+            # previous update likely failed after removing the containers.
+            container_status = 'NOT RUNNING (will rebuild and restart)'
+            est = '~6 min (fresh build possible)' if deps_will_change else '~90s (cached build)'
+        elif deploy_stale:
+            # In sync and running, but the container was deployed from an
+            # older version — a prior update pulled and stopped before the
+            # rebuild.
+            container_status = 'running a STALE build (will rebuild and restart)'
+            est = '~90s (cached build)'
         elif commits_behind == 0 and commits_ahead == 0 and not deps_will_change:
             container_status = 'no restart needed'
             est = '~5s'
@@ -1153,7 +1236,10 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
         click.echo(f'  Estimated:  {est}')
         click.echo()
 
-        will_change = force or commits_behind != 0 or commits_ahead != 0 or deps_will_change
+        will_change = (
+            force or commits_behind != 0 or commits_ahead != 0
+            or deps_will_change or container_down or deploy_stale
+        )
         if will_change:
             click.echo('Run without --check to apply.')
             ctx.exit(1)
@@ -1256,10 +1342,7 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
         new_build_hash = _read_build_hash(run_ssh_command_with_output)
     else:
         new_build_hash = facts.get('BUILD_HASH_NEW', '')
-    hash_mismatch = (
-        bool(new_build_hash) and bool(stored_build_hash)
-        and new_build_hash != stored_build_hash
-    )
+    hash_mismatch = _build_hash_mismatch(new_build_hash, stored_build_hash)
     # `--force` requests a clean rebuild: wipe the cached image and the
     # cargo/npm volumes so a prior failed/partial run can't leave a stale layer
     # or half-installed toolchain behind on the retry.
@@ -1573,17 +1656,24 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
     # but code is in sync); previously this branch ignored the hash and the
     # rebuild silently never happened.
     #
-    # `--force` deliberately skips this early-exit: a box whose previous update
-    # failed can read as "in sync" here (git fetched fine, hash matches) even
-    # though its container never came up, so the user needs a way to push the
-    # rebuild through regardless.
-    if (
-        git_sync_confirmed
-        and not needs_pull
-        and not needs_flatten
-        and not hash_mismatch
-        and not force
-    ):
+    # Source state alone is not enough to declare success: an update that
+    # failed after Step 8 (containers stopped and REMOVED) leaves a box that
+    # reads as "in sync" here — git pulled fine, the stored hash predates the
+    # failure — but has nothing running at all. Early-exiting then reports
+    # success on a dead box, so the verdict also requires the lager container
+    # to be running: 'container-down' falls through to the rebuild path below
+    # and brings the box back up. `--force` still skips the early-exit
+    # unconditionally.
+    _gate = _rebuild_gate_verdict(
+        facts,
+        git_sync_confirmed=git_sync_confirmed,
+        needs_pull=needs_pull,
+        needs_flatten=needs_flatten,
+        hash_mismatch=hash_mismatch,
+        force=force,
+    )
+    _box_v = ''  # assigned for real below whenever _gate stays 'skip'
+    if _gate == 'skip':
         import re as _re
 
         # Prefer the box's source-declared `__version__` over the CLI
@@ -1594,10 +1684,26 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
         _vp = _re.match(r'^v?(\d+\.\d+\.\d+)$', target_version)
         if _vp:
             _box_v = _vp.group(1)
+            _tree_v = _box_v
         else:
             _src_v = _read_box_source_version(run_ssh_command_with_output)
             _box_v = _src_v if _src_v else cli_version
-
+            # For the staleness check, only trust an actually-read source
+            # version — the cli_version fallback is a display default, and
+            # comparing it against the box would manufacture mismatches.
+            _tree_v = _src_v
+
+        # Liveness alone can't tell whether the RUNNING container was built
+        # from the code now in the tree: an update that pulled and then
+        # exited before the container stop (BuildKit preflight failure, an
+        # interrupt in the pull->stop window) leaves the old build serving
+        # while git reads in sync. The deployed-version record catches that;
+        # fall through and rebuild instead of stamping the new version onto
+        # a box still running the old one.
+        if _deployed_version_stale(_tree_v, facts.get('ETC_VERSION', '')):
+            _gate = 'stale-deploy'
+
+    if _gate == 'skip':
         # Reconcile /etc/lager/version on the box with the local cache.
         # Previously this branch only updated the local ~/.lager file, so if
         # the box's /etc/lager/version was stale (e.g. an earlier update
@@ -1624,6 +1730,25 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
         click.echo()
         ctx.exit(0)
 
+    if _gate in ('container-down', 'stale-deploy'):
+        if _gate == 'container-down':
+            _fall_msg = (
+                'Code is in sync but the lager container is not running '
+                '(a previous update may have failed mid-rebuild) — rebuilding '
+                'and restarting.'
+            )
+        else:
+            _fall_msg = (
+                'Code is in sync but the running container was deployed from '
+                'a previous version (a prior update may have stopped before '
+                'the rebuild) — rebuilding and restarting.'
+            )
+        if progress:
+            progress.pause()
+        click.echo(_fall_msg)
+        if progress:
+            progress.resume()
+
     # BuildKit preflight — run BEFORE the lock and the container stop below so a
     # box whose Docker can't build the image fails fast WITHOUT being taken
     # offline. box.Dockerfile uses a `# syntax=` directive and `RUN
@@ -1813,12 +1938,71 @@ def _update_logic(ctx, *, box, yes, version, verbose, check, force=False):
                     "`sudo apt-get install -y docker-buildx`), then re-run `lager update`.",
                     fg='yellow', err=True,
                 )
+            elif "failed to prepare extraction snapshot" in full_output or (
+                "parent snapshot" in full_output and "does not exist" in full_output
+            ):
+                click.secho(
+                    "Hint: the box's Docker build cache is corrupted (a cached snapshot "
+                    "references a parent that no longer exists). Clear it with: "
+                    f"ssh {ssh_host} 'docker builder prune -af' and re-run `lager update`. "
+                    "The next build runs cold and can take 10-15 minutes.",
+                    fg='yellow', err=True,
+                )
             elif "No space left on device" in full_output:
                 click.secho("Hint: Disk space is full on the box. Run: ssh lagerdata@[BOX_NAME] 'docker system prune -af'", fg='yellow', err=True)
             elif "network" in full_output.lower() and ("timeout" in full_output.lower() or "error" in full_output.lower()):
                 click.secho("Hint: Network issue during build. Check box internet connectivity.", fg='yellow', err=True)
             elif "permission denied" in full_output.lower():
                 click.secho("Hint: Permission issue. Check Docker daemon is running and user has access.", fg='yellow', err=True)
+
+        # Poison the stored build-inputs hash so the next run can't read this
+        # box as up to date: the sentinel never equals a recomputed sha256, so
+        # hash_mismatch fires on the retry, blocking the "already at version"
+        # early-exit and forcing a clean image wipe + rebuild. Deleting the
+        # file would NOT do this — _build_hash_mismatch requires both values
+        # non-empty. Best-effort: if the write fails, the liveness gate still
+        # catches the dead-container case.
+        try:
+            store_build_hash('FAILED')
+        except (subprocess.SubprocessError, OSError):
+            pass
+
+        # Step 8 already stopped and removed the containers, so exiting here
+        # would strand the box with no services — the state that previously
+        # made the next run report "already at version" on a dead box. Unless
+        # this run wiped the image (hash change / --force), the previous image
+        # is still tagged `lager` and its baked-in code matches what was
+        # running before the pull, so restart it: the box stays usable on its
+        # prior version while the operator deals with the build failure.
+        restarted = False
+        if not must_wipe_image:
+            click.echo()
+            click.secho('Restarting the box on its previous version...', fg='yellow', err=True)
+            try:
+                recover = run_ssh_command_with_output(
+                    'cd ~/box && chmod +x start_box.sh && LAGER_SKIP_BUILD=1 ./start_box.sh',
+                    timeout_secs=600,
+                )
+                # Exit 3 = container up but post-start installs failed; the
+                # box is serving, which is all this recovery promises.
+                restarted = recover.returncode in (0, 3)
+            except (subprocess.SubprocessError, OSError):
+                restarted = False
+            if restarted:
+                restarted = wait_for_box_ready(resolved_box, timeout_s=60)
+        if restarted:
+            click.secho(
+                'The update FAILED and was not applied. The box has been '
+                'restarted on its previous version.',
+                fg='yellow', err=True,
+            )
+        else:
+            click.secho(
+                'The update FAILED and the box was left with its services '
+                'stopped. Bring it back up manually with:',
+                fg='red', err=True,
+            )
+            click.echo(f'  ssh {ssh_host} "cd ~/box && ./start_box.sh"', err=True)
         ctx.exit(1)
     if verbose:
         click.secho('  Build complete', fg='green')

{lager_cli-0.32.2 → lager_cli-0.32.4}/deployment/scripts/setup_and_deploy_box.sh

@@ -1339,33 +1339,37 @@ print_info "Ensuring Docker service is enabled (for auto-start on boot)..."
 ssh $SSH_OPTS "${BOX_USER}@${BOX_IP}" "sudo systemctl enable docker >/dev/null 2>&1 || true"
 print_success "Docker service enabled"
 
-print_info "Stopping and removing all existing containers..."
-# Update restart policy first to prevent auto-restart, then force remove all containers
+print_info "Stopping and removing lager containers..."
+# Scoped to the containers this deployment owns (lager, pigpio, and the
+# legacy controller). A box may run third-party containers alongside lager
+# — a management agent, a user's own services — and removing containers we
+# did not create takes down infrastructure this script cannot restore.
+# Update restart policy first to prevent auto-restart, then force remove.
 ssh $SSH_OPTS "${BOX_USER}@${BOX_IP}" "
-    # Disable auto-restart on all containers first
-    docker update --restart=no \$(docker ps -aq) 2>/dev/null || true
-    # Stop all running containers
-    docker stop \$(docker ps -q) 2>/dev/null || true
-    # Remove all containers (running and stopped)
-    docker rm -f \$(docker ps -aq) 2>/dev/null || true
-    # Prune any leftover containers
-    docker container prune -f 2>/dev/null || true
+    for c in lager pigpio controller; do
+        docker update --restart=no \$c 2>/dev/null || true
+        docker stop \$c 2>/dev/null || true
+        docker rm -f \$c 2>/dev/null || true
+    done
     # Wait a moment for Docker to clean up
     sleep 2
 " 2>/dev/null || true
-print_success "All containers cleaned up"
+print_success "Lager containers cleaned up"
 
-print_info "Cleaning up Docker images and build cache to free disk space..."
+print_info "Cleaning up Docker build cache and dangling images..."
 echo ""
+# Dangling-only (no -a): 'prune -af' would also delete images belonging to
+# third-party containers stopped at this moment, which cannot be re-pulled
+# by this script.
 ssh $SSH_OPTS "${BOX_USER}@${BOX_IP}" "
-    echo 'Removing unused Docker images...'
-    docker image prune -af 2>/dev/null || true
+    echo 'Removing dangling Docker images...'
+    docker image prune -f 2>/dev/null || true
     echo 'Removing Docker build cache...'
     docker builder prune -af 2>/dev/null || true
     echo 'Cleanup complete'
 " 2>/dev/null || true
 echo ""
-print_success "Docker images and build cache cleaned up"
+print_success "Docker build cache and dangling images cleaned up"
 
 print_info "Checking available disk space..."
 ssh $SSH_OPTS "${BOX_USER}@${BOX_IP}" "df -h / | tail -n 1 | awk '{print \"Available: \" \$4 \" (\" \$5 \" used)\"}'" 2>/dev/null || true

{lager_cli-0.32.2 → lager_cli-0.32.4}/gateway_auth.py

@@ -99,6 +99,27 @@ def _token_expires_at(access_token):
         return 0.0
 
 
+def _refresh_margin(access_token):
+    """Refresh-ahead margin, capped at a quarter of the token's lifetime.
+
+    A fixed margin at least as large as the token lifetime would classify
+    every freshly issued token as already stale, turning each request into
+    a refresh round-trip — a refresh storm against servers issuing
+    short-lived tokens, with each refresh rotating the refresh-token
+    family and multiplying the chances of losing the session.
+    """
+    try:
+        payload_b64 = access_token.split('.')[1]
+        payload_b64 += '=' * (-len(payload_b64) % 4)
+        payload = json.loads(base64.urlsafe_b64decode(payload_b64))
+        lifetime = float(payload['exp']) - float(payload['iat'])
+    except (IndexError, KeyError, ValueError, TypeError):
+        return EXPIRY_MARGIN_SECONDS
+    if lifetime <= 0:
+        return EXPIRY_MARGIN_SECONDS
+    return min(EXPIRY_MARGIN_SECONDS, max(lifetime / 4.0, 1.0))
+
+
 def save_login(url, access_token, cookies):
     """Store a session: the bearer token plus whatever cookies the auth
     server set at login (typically an httpOnly refresh token)."""
@@ -121,20 +142,35 @@ def clear_login(url=None):
 
 
 def _refresh_access_token(url, entry):
-    """Ask the auth server for a fresh access token, or return None."""
+    """Ask the auth server for a fresh access token, or return None.
+
+    Retries once, but ONLY when the request never reached the server
+    (connection error): the server rotates the refresh token on every
+    successful refresh, so replaying the request after an ambiguous
+    failure (e.g. a read timeout) could trip the server's replay
+    detection and burn the whole session.
+    """
     cookies = entry.get('cookies') or {}
     if not cookies:
         return None
-    try:
-        resp = requests.post(
-            f'{url}/api/auth/refresh',
-            cookies=cookies,
-            timeout=AUTH_SERVER_TIMEOUT,
-        )
-        if resp.status_code != 200:
+    resp = None
+    for _ in range(2):
+        try:
+            resp = requests.post(
+                f'{url}/api/auth/refresh',
+                cookies=cookies,
+                timeout=AUTH_SERVER_TIMEOUT,
+            )
+            break
+        except requests.ConnectionError:
+            continue
+        except requests.RequestException:
             return None
+    if resp is None or resp.status_code != 200:
+        return None
+    try:
         access_token = resp.json().get('accessToken')
-    except (requests.RequestException, ValueError):
+    except ValueError:
         return None
     if not access_token:
         return None
@@ -145,14 +181,26 @@ def _refresh_access_token(url, entry):
 
 
 def access_token_for(url):
-    """Stored access token for an auth server, refreshed if near expiry."""
+    """Stored access token for an auth server, refreshed if near expiry.
+
+    A failed refresh is not immediately fatal: if the stored token has not
+    actually expired, return it anyway and let the gateway judge it — a
+    transient auth-server error should not fail a command whose token is
+    still valid.
+    """
     entry = _load_store().get('authServers', {}).get(url)
     if not entry:
         return None
     access_token = entry.get('accessToken')
-    if access_token and _token_expires_at(access_token) > time.time() + EXPIRY_MARGIN_SECONDS:
+    now = time.time()
+    if access_token and _token_expires_at(access_token) > now + _refresh_margin(access_token):
+        return access_token
+    refreshed = _refresh_access_token(url, entry)
+    if refreshed:
+        return refreshed
+    if access_token and _token_expires_at(access_token) > now:
         return access_token
-    return _refresh_access_token(url, entry)
+    return None
 
 
 def auth_headers_for_box(box_ip):

{lager_cli-0.32.2 → lager_cli-0.32.4/lager_cli.egg-info}/PKG-INFO

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

{lager_cli-0.32.2 → lager_cli-0.32.4}/lager_cli.egg-info/SOURCES.txt

@@ -374,6 +374,7 @@ tests/test_box_lager_imports.py
 tests/test_box_storage.py
 tests/test_gateway_auth.py
 tests/test_io_imports.py
+tests/test_update_gate.py
 vendor/__init__.py
 vendor/PyCRC/CRC16.py
 vendor/PyCRC/CRC16DNP.py