jwbmisc 0.0.1__tar.gz → 0.0.3__tar.gz

{jwbmisc-0.0.1/src/jwbmisc.egg-info → jwbmisc-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jwbmisc
-Version: 0.0.1
+Version: 0.0.3
 Summary: Misc util functions of jwb
 Author-email: Joachim Bargsten <jw@bargsten.org>
 License:                                  Apache License
@@ -212,7 +212,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyyaml
 Requires-Dist: more-itertools
-Requires-Dist: keyring
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest>=7; extra == "dev"
@@ -220,6 +219,8 @@ Requires-Dist: setuptools_scm; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pytest-env; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: keepercommander; extra == "dev"
+Requires-Dist: keyring; extra == "dev"
 Provides-Extra: build
 Requires-Dist: build; extra == "build"
 Requires-Dist: twine; extra == "build"

{jwbmisc-0.0.1 → jwbmisc-0.0.3}/pyproject.toml

@@ -25,7 +25,6 @@ authors = [{ name = "Joachim Bargsten", email = "jw@bargsten.org" }]
 dependencies = [
     "pyyaml",
     "more-itertools",
-    "keyring"
 ]
 
 [project.urls]
@@ -40,6 +39,8 @@ dev = [
     "mypy",
     "pytest-env",
     "pytest-mock",
+    "keepercommander",
+    "keyring"
 ]
 build = [
     "build",

jwbmisc-0.0.3/src/jwbmisc/__init__.py

@@ -0,0 +1,25 @@
+from .passwd import get_pass
+from .string import jinja_replace
+from .exec import run_cmd
+from .json import jsonc_loads, jsonc_read, ndjson_read, ndjson_write, resilient_loads
+from .fs import fzf, find_root
+from .util import goo, ask, confirm, randomsuffix, qw, split_host
+
+__all__ = [
+    "get_pass",
+    "jinja_replace",
+    "run_cmd",
+    "jsonc_loads",
+    "jsonc_read",
+    "ndjson_read",
+    "ndjson_write",
+    "resilient_loads",
+    "fzf",
+    "find_root",
+    "goo",
+    "ask",
+    "confirm",
+    "randomsuffix",
+    "qw",
+    "split_host",
+]

{jwbmisc-0.0.1 → jwbmisc-0.0.3}/src/jwbmisc/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.1'
-__version_tuple__ = version_tuple = (0, 0, 1)
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)
+
+__commit_id__ = commit_id = 'g75f9cb167'

jwbmisc-0.0.3/src/jwbmisc/exec.py

@@ -0,0 +1,50 @@
+import subprocess as sp
+import os
+
+
+def run_cmd(
+    cmd,
+    env=None,
+    capture=False,
+    stdin=None,
+    contains_sensitive_data=False,
+    timeout=20,
+    decode=True,
+    dry_run=False,
+):
+    if env is None:
+        env = {}
+    env = {**os.environ, **env}
+    env.pop("__PYVENV_LAUNCHER__", None)
+
+    if stdin is not None:
+        stdin = stdin.encode("utf-8")
+
+    cmd = [str(v) for v in cmd]
+
+    if dry_run:
+        print(cmd)
+        if capture:
+            return ("", "")
+        return
+
+    try:
+        res = sp.run(
+            cmd,
+            capture_output=capture,
+            env=env,
+            check=True,
+            timeout=timeout,
+            input=stdin,
+        )
+    except sp.CalledProcessError as ex:
+        redacted_bytes = "<redacted>".encode("utf-8")
+        out = redacted_bytes if contains_sensitive_data else ex.output
+        err = redacted_bytes if contains_sensitive_data else ex.stderr
+        raise sp.CalledProcessError(ex.returncode, ex.cmd, out, err) from None
+
+    if not capture:
+        return None
+    if decode:
+        return (res.stdout.decode("utf-8"), res.stderr.decode("utf-8"))
+    return (res.stdout, res.stderr)

jwbmisc-0.0.3/src/jwbmisc/fs.py

@@ -0,0 +1,28 @@
+import subprocess as sp
+from collections.abc import Iterable
+from pathlib import Path
+
+
+def fzf(entries: Iterable[str]):
+    process = sp.Popen(
+        ["fzf", "+m"],
+        stdout=sp.PIPE,
+        stdin=sp.PIPE,
+        encoding="utf-8",
+    )
+
+    stdout, _ = process.communicate(input="\n".join(entries) + "\n")
+    return stdout.strip()
+
+
+def find_root(start, req):
+    p = Path(start).absolute()
+    if p.is_file():
+        p = p.parent
+
+    while p.parent != p:
+        files = {f.name for f in p.iterdir()}
+        if req <= files:
+            return p
+        p = p.parent
+    return None

jwbmisc-0.0.3/src/jwbmisc/json.py

@@ -0,0 +1,46 @@
+import re
+from typing import Any
+import json
+from pathlib import Path
+import gzip
+
+
+def jsonc_loads(data: str):
+    data = re.sub(r"//.*$", "", data, flags=re.MULTILINE)
+    data = re.sub(r"/\*.*?\*/", "", data, flags=re.DOTALL)
+    return json.loads(data)
+
+
+def jsonc_read(f: str | Path):
+    f = Path(f)
+    open_fn = gzip.open if f.suffix.lower() == ".gz" else open
+    with open_fn(f, "rt", encoding="utf-8") as fd:
+        return jsonc_loads(fd.read())
+
+
+def ndjson_read(f: str | Path):
+    f = Path(f)
+    open_fn = gzip.open if f.suffix.lower() == ".gz" else open
+    with open_fn(f, "rt", encoding="utf-8") as fd:
+        for line in fd:
+            line = line.strip()
+            if line and not line.startswith("#"):
+                yield json.loads(line)
+
+
+def ndjson_write(data: list[Any], f: str | Path):
+    f = Path(f)
+    open_fn = gzip.open if f.suffix.lower() == ".gz" else open
+    with open_fn(f, "wb") as fd:
+        for record in data:
+            blob = (json.dumps(record) + "\n").encode("utf-8")
+            fd.write(blob)
+
+
+def resilient_loads(data):
+    if not data:
+        return None
+    try:
+        return json.loads(data)
+    except Exception:
+        return None

jwbmisc-0.0.3/src/jwbmisc/keeper.py

@@ -0,0 +1,137 @@
+import json
+from keepercommander import vault as keeper_vault
+from keepercommander import api
+from time import sleep
+from keepercommander.params import KeeperParams
+from keepercommander.config_storage import loader
+import os
+from .util import ask
+from pathlib import Path
+import webbrowser
+from keepercommander.auth import login_steps
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+
+class _MinimalKeeperUI:
+    def __init__(self):
+        self.waiting_for_sso_data_key = False
+
+    def on_sso_redirect(self, step):
+        self.waiting_for_sso_data_key = False
+        webbrowser.open_new_tab(step.sso_login_url)
+
+        token = ask("SSO token: ")
+
+        if not token:
+            raise ValueError("No SSO token provided")
+        step.set_sso_token(token.strip())
+
+    def on_two_factor(self, step):
+        channels = step.get_channels()
+        totp_channel = next(
+            (c for c in channels if c.channel_type == login_steps.TwoFactorChannel.Authenticator), None
+        )
+
+        if not totp_channel:
+            raise ValueError("TOTP authenticator not available")
+
+        totp_code = ask("2FA code:")
+
+        if not totp_code:
+            raise ValueError("No TOTP code provided")
+
+        step.duration = login_steps.TwoFactorDuration.Every12Hours
+        try:
+            step.send_code(totp_channel.channel_uid, totp_code.strip())
+            logger.info("keeper 2fa success")
+        except api.KeeperApiError:
+            logger.info("keeper api error")
+
+    def on_password(self, _step):
+        raise KeyError("Password login not supported. Use SSO.")
+
+    def on_device_approval(self, _step):
+        logger.info("Waiting for device approval...")
+
+    def on_sso_data_key(self, step):
+        if not self.waiting_for_sso_data_key:
+            logger.info("sent push")
+            step.request_data_key(login_steps.DataKeyShareChannel.KeeperPush)
+            self.waiting_for_sso_data_key = True
+        logger.info("waiting for push")
+        sleep(1)
+        step.resume()
+
+
+def _extract_keeper_field(record, field: str) -> str | None:
+    if isinstance(record, keeper_vault.TypedRecord):
+        value = record.get_typed_field(field)
+        if value is None:
+            value = next((f for f in record.custom if f.label == field), None)
+
+        if value and value.value:
+            return value.value[0] if isinstance(value.value, list) else str(value.value)
+
+    return None
+
+
+def _perform_keeper_login(params):
+    if not params.user:
+        user = os.environ.get("KEEPER_USERNAME", None)
+        if user is None:
+            user = ask("User (email): ")
+        user = user.strip()
+        if not user:
+            raise ValueError("No username provided")
+        params.user = user
+
+        server = os.environ.get("KEEPER_SERVER", None)
+        if server is None:
+            server = ask("Server:")
+
+        if not server:
+            raise ValueError("No server provided")
+        params.server = server
+
+    try:
+        api.login(params, login_ui=_MinimalKeeperUI())
+    except KeyboardInterrupt:
+        raise KeyError("\nKeeper login cancelled by user.") from None
+    except Exception as e:
+        raise KeyError(f"Keeper login failed: {e}") from e
+
+
+def get_keeper_password(record_uid: str, field_path: str) -> str:
+    config_file = Path.home() / ".config" / "keeper" / "config.json"
+    config_file.parent.mkdir(parents=True, exist_ok=True)
+
+    params = KeeperParams(config_filename=str(config_file))
+
+    if config_file.exists():
+        try:
+            params.config = json.loads(config_file.read_text())
+            loader.load_config_properties(params)
+            if not params.session_token:
+                raise ValueError("No session token")
+        except Exception:
+            _perform_keeper_login(params)
+    else:
+        _perform_keeper_login(params)
+
+    try:
+        api.sync_down(params)
+    except Exception as e:
+        raise KeyError(f"Failed to sync Keeper vault: {e}") from e
+
+    try:
+        record = keeper_vault.KeeperRecord.load(params, record_uid)
+    except Exception as e:
+        raise KeyError(f"Record {record_uid} not found: {e}") from e
+
+    value = _extract_keeper_field(record, field_path)
+    if value is None:
+        raise KeyError(f"Field '{field_path}' not found in record {record_uid}")
+
+    return value

jwbmisc-0.0.3/src/jwbmisc/passwd.py

@@ -0,0 +1,75 @@
+import subprocess as sp
+import os
+from pathlib import Path
+
+
+def get_pass(*pass_keys: str):
+    if not pass_keys:
+        raise ValueError("no pass keys supplied")
+
+    for pass_key in pass_keys:
+        if pass_key.startswith("pass://"):
+            k = pass_key.removeprefix("pass://")
+            lnum = 1
+            if "?" in k:
+                k, lnum = k.rsplit("?", 1)
+            return _call_unix_pass(k, int(lnum))
+
+        if pass_key.startswith("env://"):
+            env_var = pass_key.removeprefix("env://").replace("/", "__")
+            if env_var not in os.environ:
+                raise KeyError(f"{env_var} (derived from {pass_key}) is not in the env")
+            return os.environ[env_var]
+
+        if pass_key.startswith("file://"):
+            f = Path(pass_key.removeprefix("file://"))
+            if not f.exists() or f.is_dir():
+                raise KeyError(f"{f} (derived from {pass_key}) does not exist or is a dir")
+            return f.read_text().strip()
+
+        if pass_key.startswith("keyring://"):
+            import keyring
+
+            args = pass_key.removeprefix("keyring://").split("/")
+            pw = keyring.get_password(*args)
+            if pw is None:
+                raise KeyError(f"could not find a password for {pass_key}")
+            return pw
+
+        if pass_key.startswith("keeper://"):
+            path = pass_key.removeprefix("keeper://")
+            if "/" not in path:
+                raise KeyError("Invalid keeper:// format. Expected: keeper://RECORD_UID/field/fieldname")
+
+            record_uid, field_path = path.split("/", 1)
+            return _keeper_password(record_uid, field_path)
+
+    raise KeyError(f"Could not acquire password from one of {pass_keys}")
+
+
+def _call_unix_pass(key, lnum=1):
+    proc = sp.Popen(["pass", "show", key], stdout=sp.PIPE, stderr=sp.PIPE, encoding="utf-8")
+    value, stderr = proc.communicate()
+
+    if proc.returncode != 0:
+        raise KeyError(f"pass failed for '{key}': {stderr.strip()}")
+
+    if lnum is None or lnum == 0:
+        return value.strip()
+    lines = value.splitlines()
+
+    try:
+        if isinstance(lnum, list):
+            pw = [lines[ln - 1].strip() for ln in lnum]
+        else:
+            pw = lines[lnum - 1].strip()
+    except IndexError:
+        raise KeyError(f"could not retrieve lines {lnum} for {key}")
+
+    return pw
+
+
+def _keeper_password(record_uid: str, field_path: str) -> str:
+    from .keeper import get_keeper_password
+
+    return get_keeper_password(record_uid, field_path)

jwbmisc-0.0.3/src/jwbmisc/string.py

@@ -0,0 +1,22 @@
+import re
+
+
+def jinja_replace(s, config, relaxed: bool = False, delim: tuple[str, str] = ("{{", "}}")):
+    """Jinja for poor people. A very simple
+    function to replace variables in text using `{{variable}}` syntax.
+
+    :param s: the template string/text
+    :param config: a dict of variable -> replacement mapping
+    :param relaxed: Don't raise a KeyError if a variable is not in the config dict.
+    :param delim: Change the delimiters to something else.
+    """
+
+    def handle_match(m):
+        k = m.group(1)
+        if k in config:
+            return config[k]
+        if relaxed:
+            return m.group(0)
+        raise KeyError(f"{k} is not in the supplied replacement variables")
+
+    return re.sub(re.escape(delim[0]) + r"\s*(\w+)\s*" + re.escape(delim[1]), handle_match, s)

jwbmisc-0.0.3/src/jwbmisc/util.py

@@ -0,0 +1,64 @@
+import random
+import string
+from typing import Any
+
+
+def ask(question, default=None):
+    if default is not None:
+        question += f" [{default}]"
+    answer = input(question.strip() + " ").strip()
+    return answer if answer else default
+
+
+def confirm(question, default="n"):
+    prompt = f"{question} (y/n)"
+    if default is not None:
+        prompt += f" [{default}]"
+    answer = input(prompt).strip().lower()
+    if not answer:
+        answer = default.lower() if default else "n"
+    return answer.startswith("y")
+
+
+def randomsuffix(length):
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(length))
+
+
+def qw(s: str) -> list[str]:
+    return s.split()
+
+
+def split_host(host: str) -> tuple[str | None, int | None]:
+    if not host:
+        return (None, None)
+    res = host.split(":", 1)
+    if len(res) == 1:
+        return (res[0], None)
+    return (res[0], int(res[1]))
+
+
+def goo(
+    d: dict[str, Any],
+    *keys: str | int,
+    default: Any | None = None,
+    raise_on_default: bool = False,
+):
+    path = ".".join(str(k) for k in keys)
+    parts = path.split(".")
+
+    res = d
+    for p in parts:
+        if res is None:
+            if raise_on_default:
+                raise ValueError(f"'{path}' does not exist")
+            return default
+        if isinstance(res, (list, set, tuple)):
+            res = res[int(p)]
+        else:
+            res = res.get(p)
+    if res is None:
+        if raise_on_default:
+            raise ValueError(f"'{path}' does not exist")
+        return default
+    return res

{jwbmisc-0.0.1 → jwbmisc-0.0.3/src/jwbmisc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jwbmisc
-Version: 0.0.1
+Version: 0.0.3
 Summary: Misc util functions of jwb
 Author-email: Joachim Bargsten <jw@bargsten.org>
 License:                                  Apache License
@@ -212,7 +212,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyyaml
 Requires-Dist: more-itertools
-Requires-Dist: keyring
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest>=7; extra == "dev"
@@ -220,6 +219,8 @@ Requires-Dist: setuptools_scm; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pytest-env; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: keepercommander; extra == "dev"
+Requires-Dist: keyring; extra == "dev"
 Provides-Extra: build
 Requires-Dist: build; extra == "build"
 Requires-Dist: twine; extra == "build"

jwbmisc-0.0.3/src/jwbmisc.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+LICENSE
+MANIFEST.in
+Makefile
+README.md
+pyproject.toml
+release.sh
+src/jwbmisc/__init__.py
+src/jwbmisc/_version.py
+src/jwbmisc/exec.py
+src/jwbmisc/fs.py
+src/jwbmisc/json.py
+src/jwbmisc/keeper.py
+src/jwbmisc/passwd.py
+src/jwbmisc/string.py
+src/jwbmisc/util.py
+src/jwbmisc.egg-info/PKG-INFO
+src/jwbmisc.egg-info/SOURCES.txt
+src/jwbmisc.egg-info/dependency_links.txt
+src/jwbmisc.egg-info/requires.txt
+src/jwbmisc.egg-info/top_level.txt
+tests/conftest.py
+tests/fzf
+tests/pass
+tests/test_exec.py
+tests/test_fs.py
+tests/test_json.py
+tests/test_keeper.py
+tests/test_passwd.py
+tests/test_string.py
+tests/test_util.py

{jwbmisc-0.0.1 → jwbmisc-0.0.3}/src/jwbmisc.egg-info/requires.txt

@@ -1,6 +1,5 @@
 pyyaml
 more-itertools
-keyring
 
 [all]
 jwbmisc[build,dev,docs]
@@ -21,6 +20,8 @@ setuptools_scm
 mypy
 pytest-env
 pytest-mock
+keepercommander
+keyring
 
 [docs]
 sphinx

jwbmisc-0.0.3/tests/conftest.py

@@ -0,0 +1,29 @@
+import os
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def env_var():
+    original = os.environ.copy()
+
+    def _set(**kwargs):
+        for k, v in kwargs.items():
+            os.environ[k] = v
+
+    yield _set
+    os.environ.clear()
+    os.environ.update(original)
+
+
+@pytest.fixture
+def fake_pass(monkeypatch):
+    tests_dir = Path(__file__).parent
+    monkeypatch.setenv("PATH", f"{tests_dir}:{os.environ['PATH']}")
+
+
+@pytest.fixture
+def fake_fzf(monkeypatch):
+    tests_dir = Path(__file__).parent
+    monkeypatch.setenv("PATH", f"{tests_dir}:{os.environ['PATH']}")

jwbmisc-0.0.3/tests/fzf

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Fake fzf script - returns first line of stdin
+read -r line
+echo "$line"

jwbmisc-0.0.3/tests/pass

@@ -0,0 +1,8 @@
+#!/bin/bash
+# Fake pass script for testing run_cmd and passwd
+case "$2" in
+    "test/secret") echo "password123";;
+    "test/multiline") printf "line1\nline2\nline3";;
+    "test/missing") echo "Error: not found" >&2; exit 1;;
+    *) echo "Error: unknown key $2" >&2; exit 1;;
+esac