jwbmisc 0.0.3__tar.gz → 0.0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jwbmisc
-Version: 0.0.3
+Version: 0.0.5
 Summary: Misc util functions of jwb
 Author-email: Joachim Bargsten <jw@bargsten.org>
 License:                                  Apache License

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/src/jwbmisc/__init__.py

@@ -1,9 +1,10 @@
 from .passwd import get_pass
-from .string import jinja_replace
+from .string import jinja_replace, randomsuffix, qw, split_host
 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
+from .collection import goo
+from .interactive import ask, confirm
 
 __all__ = [
     "get_pass",

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.3'
-__version_tuple__ = version_tuple = (0, 0, 3)
+__version__ = version = '0.0.5'
+__version_tuple__ = version_tuple = (0, 0, 5)
 
-__commit_id__ = commit_id = 'g75f9cb167'
+__commit_id__ = commit_id = 'g68c0a3571'

jwbmisc-0.0.5/src/jwbmisc/collection.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+
+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.5/src/jwbmisc/interactive.py

@@ -0,0 +1,13 @@
+def ask(question: str, default: None | str = None):
+    if default is not None:
+        question += f" [{default}]"
+    answer = input(question.strip() + " ").strip()
+    return answer if answer else default
+
+
+def confirm(question: str, default: str = "n") -> bool:
+    prompt = f"{question} (y/n)"
+    answer = ask(prompt, default=default)
+    if not answer:
+        return False
+    return answer.lower().startswith("y")

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/src/jwbmisc/keeper.py

@@ -1,11 +1,11 @@
 import json
-from keepercommander import vault as keeper_vault
+from keepercommander import 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 .interactive import ask
 from pathlib import Path
 import webbrowser
 from keepercommander.auth import login_steps
@@ -13,8 +13,10 @@ from logging import getLogger
 
 logger = getLogger(__name__)
 
+CONFIG_FILE = Path.home() / ".config" / "jwbmisc" / "keeper.json"
 
-class _MinimalKeeperUI:
+
+class MinimalKeeperUI:
     def __init__(self):
         self.waiting_for_sso_data_key = False
 
@@ -65,19 +67,19 @@ class _MinimalKeeperUI:
         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)
+def extract_record_field(record, field: str) -> str | None:
+    if not isinstance(record, vault.TypedRecord):
+        raise TypeError("only TypedRecord is supported")
+
+    value = record.get_typed_field(field) or record.get_typed_field(None, field)
 
-        if value and value.value:
-            return value.value[0] if isinstance(value.value, list) else str(value.value)
+    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):
+def perform_login(params):
     if not params.user:
         user = os.environ.get("KEEPER_USERNAME", None)
         if user is None:
@@ -96,29 +98,28 @@ def _perform_keeper_login(params):
         params.server = server
 
     try:
-        api.login(params, login_ui=_MinimalKeeperUI())
+        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)
+def get_password(record_uid: str, field_path: str) -> str:
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
 
-    params = KeeperParams(config_filename=str(config_file))
+    params = KeeperParams(config_filename=str(CONFIG_FILE))
 
-    if config_file.exists():
+    if CONFIG_FILE.exists():
         try:
-            params.config = json.loads(config_file.read_text())
+            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)
+            perform_login(params)
     else:
-        _perform_keeper_login(params)
+        perform_login(params)
 
     try:
         api.sync_down(params)
@@ -126,11 +127,11 @@ def get_keeper_password(record_uid: str, field_path: str) -> str:
         raise KeyError(f"Failed to sync Keeper vault: {e}") from e
 
     try:
-        record = keeper_vault.KeeperRecord.load(params, record_uid)
+        record = 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)
+    value = extract_record_field(record, field_path)
     if value is None:
         raise KeyError(f"Field '{field_path}' not found in record {record_uid}")
 

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/src/jwbmisc/passwd.py

@@ -2,6 +2,8 @@ import subprocess as sp
 import os
 from pathlib import Path
 
+PASS_BIN = os.environ.get("JWBMISC_PASS_BIN", "pass")
+
 
 def get_pass(*pass_keys: str):
     if not pass_keys:
@@ -48,7 +50,7 @@ def get_pass(*pass_keys: str):
 
 
 def _call_unix_pass(key, lnum=1):
-    proc = sp.Popen(["pass", "show", key], stdout=sp.PIPE, stderr=sp.PIPE, encoding="utf-8")
+    proc = sp.Popen([PASS_BIN, "show", key], stdout=sp.PIPE, stderr=sp.PIPE, encoding="utf-8")
     value, stderr = proc.communicate()
 
     if proc.returncode != 0:
@@ -70,6 +72,6 @@ def _call_unix_pass(key, lnum=1):
 
 
 def _keeper_password(record_uid: str, field_path: str) -> str:
-    from .keeper import get_keeper_password
+    from .keeper import get_password as keeper_get_password
 
-    return get_keeper_password(record_uid, field_path)
+    return keeper_get_password(record_uid, field_path)

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/src/jwbmisc/string.py

@@ -1,4 +1,6 @@
 import re
+import random
+import string
 
 
 def jinja_replace(s, config, relaxed: bool = False, delim: tuple[str, str] = ("{{", "}}")):
@@ -20,3 +22,21 @@ def jinja_replace(s, config, relaxed: bool = False, delim: tuple[str, str] = ("{
         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)
+
+
+def randomsuffix(length: int):
+    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]))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jwbmisc
-Version: 0.0.3
+Version: 0.0.5
 Summary: Misc util functions of jwb
 Author-email: Joachim Bargsten <jw@bargsten.org>
 License:                                  Apache License

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/src/jwbmisc.egg-info/SOURCES.txt

@@ -6,13 +6,14 @@ pyproject.toml
 release.sh
 src/jwbmisc/__init__.py
 src/jwbmisc/_version.py
+src/jwbmisc/collection.py
 src/jwbmisc/exec.py
 src/jwbmisc/fs.py
+src/jwbmisc/interactive.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
@@ -21,10 +22,11 @@ src/jwbmisc.egg-info/top_level.txt
 tests/conftest.py
 tests/fzf
 tests/pass
+tests/test_collection.py
 tests/test_exec.py
 tests/test_fs.py
+tests/test_interactive.py
 tests/test_json.py
 tests/test_keeper.py
 tests/test_passwd.py
-tests/test_string.py
-tests/test_util.py
+tests/test_string.py

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/tests/conftest.py

@@ -17,12 +17,6 @@ def env_var():
     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

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/tests/pass

@@ -1,5 +1,5 @@
-#!/bin/bash
-# Fake pass script for testing run_cmd and passwd
+#!/usr/bin/env bash
+
 case "$2" in
     "test/secret") echo "password123";;
     "test/multiline") printf "line1\nline2\nline3";;

jwbmisc-0.0.5/tests/test_collection.py

@@ -0,0 +1,41 @@
+import pytest
+from jwbmisc.collection import goo
+
+
+class TestGoo:
+    def test_simple_key(self):
+        d = {"a": 1}
+        assert goo(d, "a") == 1
+
+    def test_nested_keys(self):
+        d = {"a": {"b": {"c": 3}}}
+        assert goo(d, "a", "b", "c") == 3
+
+    def test_dot_notation(self):
+        d = {"a": {"b": 2}}
+        assert goo(d, "a.b") == 2
+
+    def test_list_index(self):
+        d = {"items": ["a", "b", "c"]}
+        assert goo(d, "items", 1) == "b"
+
+    def test_missing_key_returns_default(self):
+        d = {"a": 1}
+        assert goo(d, "b", default="missing") == "missing"
+
+    def test_missing_key_returns_none_by_default(self):
+        d = {"a": 1}
+        assert goo(d, "b") is None
+
+    def test_raise_on_default(self):
+        d = {"a": 1}
+        with pytest.raises(ValueError, match="does not exist"):
+            goo(d, "b", raise_on_default=True)
+
+    def test_none_in_path_returns_default(self):
+        d = {"a": None}
+        assert goo(d, "a", "b", default="missing") == "missing"
+
+    def test_mixed_keys_and_indices(self):
+        d = {"users": [{"name": "Alice"}, {"name": "Bob"}]}
+        assert goo(d, "users", 0, "name") == "Alice"

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/tests/test_exec.py

@@ -1,27 +1,31 @@
+# pyright: basic
 import subprocess
 
 import pytest
+from pathlib import Path
 
 from jwbmisc.exec import run_cmd
 
+PASS_BIN = str((Path(__file__).parent / "pass").absolute())
+
 
 class TestRunCmd:
-    def test_capture_stdout(self, fake_pass):
-        stdout, stderr = run_cmd(["pass", "show", "test/secret"], capture=True)
+    def test_capture_stdout(self):
+        stdout, stderr = run_cmd([PASS_BIN, "show", "test/secret"], capture=True)
         assert stdout.strip() == "password123"
         assert stderr == ""
 
-    def test_capture_disabled_returns_none(self, fake_pass):
-        result = run_cmd(["pass", "show", "test/secret"], capture=False)
+    def test_capture_disabled_returns_none(self):
+        result = run_cmd([PASS_BIN, "show", "test/secret"], capture=False)
         assert result is None
 
-    def test_decode_true_returns_strings(self, fake_pass):
-        stdout, stderr = run_cmd(["pass", "show", "test/secret"], capture=True, decode=True)
+    def test_decode_true_returns_strings(self):
+        stdout, stderr = run_cmd([PASS_BIN, "show", "test/secret"], capture=True, decode=True)
         assert isinstance(stdout, str)
         assert isinstance(stderr, str)
 
-    def test_decode_false_returns_bytes(self, fake_pass):
-        stdout, stderr = run_cmd(["pass", "show", "test/secret"], capture=True, decode=False)
+    def test_decode_false_returns_bytes(self):
+        stdout, stderr = run_cmd([PASS_BIN, "show", "test/secret"], capture=True, decode=False)
         assert isinstance(stdout, bytes)
         assert isinstance(stderr, bytes)
 
@@ -61,14 +65,14 @@ class TestRunCmd:
         result = run_cmd(["echo", "test"], dry_run=True, capture=True)
         assert result == ("", "")
 
-    def test_called_process_error(self, fake_pass):
+    def test_called_process_error(self):
         with pytest.raises(subprocess.CalledProcessError) as exc_info:
-            run_cmd(["pass", "show", "test/missing"], capture=True)
+            run_cmd([PASS_BIN, "show", "test/missing"], capture=True)
         assert exc_info.value.returncode == 1
 
-    def test_sensitive_data_redacted(self, fake_pass):
+    def test_sensitive_data_redacted(self):
         with pytest.raises(subprocess.CalledProcessError) as exc_info:
-            run_cmd(["pass", "show", "test/missing"], capture=True, contains_sensitive_data=True)
+            run_cmd([PASS_BIN, "show", "test/missing"], capture=True, contains_sensitive_data=True)
         assert exc_info.value.stdout == b"<redacted>"
         assert exc_info.value.stderr == b"<redacted>"
 

jwbmisc-0.0.5/tests/test_interactive.py

@@ -0,0 +1,49 @@
+from jwbmisc.interactive import ask, confirm
+
+
+class TestAsk:
+    def test_returns_user_input(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "user_answer")
+        assert ask("Question?") == "user_answer"
+
+    def test_returns_default_on_empty_input(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "")
+        assert ask("Question?", default="default_value") == "default_value"
+
+    def test_returns_none_when_no_default_and_empty(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "")
+        assert ask("Question?") is None
+
+    def test_strips_input(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "  answer  ")
+        assert ask("Question?") == "answer"
+
+
+class TestConfirm:
+    def test_returns_true_for_y(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "y")
+        assert confirm("Continue?") is True
+
+    def test_returns_true_for_yes(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "yes")
+        assert confirm("Continue?") is True
+
+    def test_returns_true_for_Y(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "Y")
+        assert confirm("Continue?") is True
+
+    def test_returns_false_for_n(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "n")
+        assert confirm("Continue?") is False
+
+    def test_returns_false_for_no(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "no")
+        assert confirm("Continue?") is False
+
+    def test_empty_uses_default_n(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "")
+        assert confirm("Continue?", default="n") is False
+
+    def test_empty_uses_default_y(self, monkeypatch):
+        monkeypatch.setattr("builtins.input", lambda _: "")
+        assert confirm("Continue?", default="y") is True

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/tests/test_keeper.py

@@ -1,69 +1,61 @@
+# pyright: basic
 import pytest
 
+from keepercommander import vault, utils
 from jwbmisc.keeper import (
-    _MinimalKeeperUI,
-    _extract_keeper_field,
-    _perform_keeper_login,
-    get_keeper_password,
+    MinimalKeeperUI,
+    extract_record_field,
+    perform_login,
+    get_password,
 )
 
 
-class MockTypedField:
-    def __init__(self, value):
-        self.value = value
-        self.label = None
-
-
-class MockTypedRecord:
-    def __init__(self, fields=None, custom=None):
-        self._fields = fields or {}
-        self.custom = custom or []
-
-    def get_typed_field(self, name):
-        return self._fields.get(name)
+def gen_record(type_name="login"):
+    record = vault.TypedRecord()
+    record.type_name = type_name
+    record.record_uid = utils.generate_uid()
+    record.record_key = utils.generate_aes_key()
+    record.fields.append(
+        vault.TypedField.new_field(
+            field_type="password", field_label="AWS Secret Sauce", field_value=["password123"]
+        )
+    )
+    return record
 
 
 class TestExtractKeeperField:
-    def test_typed_record_with_list_value(self, mocker):
-        mocker.patch("jwbmisc.keeper.keeper_vault.TypedRecord", MockTypedRecord)
-        field = MockTypedField(["password123"])
-        record = MockTypedRecord(fields={"password": field})
+    def test_typed_record_with_list_value(self):
+        record = gen_record()
 
-        result = _extract_keeper_field(record, "password")
+        result = extract_record_field(record, "password")
         assert result == "password123"
 
-    def test_typed_record_with_string_value(self, mocker):
-        mocker.patch("jwbmisc.keeper.keeper_vault.TypedRecord", MockTypedRecord)
-        field = MockTypedField("single_value")
-        record = MockTypedRecord(fields={"password": field})
-
-        result = _extract_keeper_field(record, "password")
-        assert result == "single_value"
-
-    def test_typed_record_field_not_found(self, mocker):
-        mocker.patch("jwbmisc.keeper.keeper_vault.TypedRecord", MockTypedRecord)
-        record = MockTypedRecord(fields={})
-
-        result = _extract_keeper_field(record, "missing")
+    def test_typed_record_field_not_found(self):
+        record = gen_record()
+        record.fields = []
+        result = extract_record_field(record, "missing")
         assert result is None
 
-    def test_typed_record_custom_field(self, mocker):
-        mocker.patch("jwbmisc.keeper.keeper_vault.TypedRecord", MockTypedRecord)
-        custom_field = MockTypedField(["custom_value"])
-        custom_field.label = "custom_field"
-        record = MockTypedRecord(fields={}, custom=[custom_field])
-
-        result = _extract_keeper_field(record, "custom_field")
-        assert result == "custom_value"
+    def test_typed_record_custom_field(self):
+        record = gen_record()
+        record.custom.append(
+            vault.TypedField.new_field(
+                field_type="passwordcustom", field_label="AWS Custom Secret Sauce", field_value=["password3"]
+            )
+        )
+        result = extract_record_field(record, "passwordcustom")
+        assert result == "password3"
+        result = extract_record_field(record, "AWS Custom Secret Sauce")
+        assert result == "password3"
 
     def test_non_typed_record_returns_none(self):
-        result = _extract_keeper_field(object(), "any_field")
-        assert result is None
+        with pytest.raises(TypeError):
+            extract_record_field(object(), "any_field")
 
 
 class TestMinimalKeeperUI:
     def test_on_password_raises(self):
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         with pytest.raises(KeyError, match="Password login not supported"):
             ui.on_password(None)
 
@@ -74,7 +66,7 @@ class TestMinimalKeeperUI:
         step = mocker.MagicMock()
         step.sso_login_url = "https://sso.example.com"
 
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         ui.on_sso_redirect(step)
 
         mock_webbrowser.open_new_tab.assert_called_once_with("https://sso.example.com")
@@ -87,7 +79,7 @@ class TestMinimalKeeperUI:
         step = mocker.MagicMock()
         step.sso_login_url = "https://sso.example.com"
 
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         with pytest.raises(ValueError, match="No SSO token"):
             ui.on_sso_redirect(step)
 
@@ -100,7 +92,7 @@ class TestMinimalKeeperUI:
         step = mocker.MagicMock()
         step.get_channels.return_value = [mock_channel]
 
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         ui.on_two_factor(step)
 
         step.send_code.assert_called_once_with("channel_123", "123456")
@@ -113,12 +105,12 @@ class TestMinimalKeeperUI:
         step = mocker.MagicMock()
         step.get_channels.return_value = [mock_channel]
 
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         with pytest.raises(ValueError, match="TOTP authenticator not available"):
             ui.on_two_factor(step)
 
     def test_on_device_approval_does_not_raise(self, mocker):
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         ui.on_device_approval(None)  # Should not raise
 
     def test_on_sso_data_key_first_call(self, mocker):
@@ -127,7 +119,7 @@ class TestMinimalKeeperUI:
 
         step = mocker.MagicMock()
 
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         assert ui.waiting_for_sso_data_key is False
 
         ui.on_sso_data_key(step)
@@ -141,7 +133,7 @@ class TestMinimalKeeperUI:
         mock_sleep = mocker.patch("jwbmisc.keeper.sleep")
         step = mocker.MagicMock()
 
-        ui = _MinimalKeeperUI()
+        ui = MinimalKeeperUI()
         ui.waiting_for_sso_data_key = True
 
         ui.on_sso_data_key(step)
@@ -159,7 +151,7 @@ class TestPerformKeeperLogin:
         params = mocker.MagicMock()
         params.user = None
 
-        _perform_keeper_login(params)
+        perform_login(params)
 
         assert params.user == "user@example.com"
         assert params.server == "keepersecurity.com"
@@ -173,7 +165,7 @@ class TestPerformKeeperLogin:
         params = mocker.MagicMock()
         params.user = None
 
-        _perform_keeper_login(params)
+        perform_login(params)
 
         assert params.user == "user@example.com"
         assert params.server == "keepersecurity.com"
@@ -188,7 +180,7 @@ class TestPerformKeeperLogin:
         params.user = None
 
         with pytest.raises(KeyError, match="cancelled by user"):
-            _perform_keeper_login(params)
+            perform_login(params)
 
 
 class TestGetKeeperPassword:
@@ -200,15 +192,15 @@ class TestGetKeeperPassword:
         mocker.patch("jwbmisc.keeper.KeeperParams", return_value=mock_params)
 
         mock_api = mocker.patch("jwbmisc.keeper.api")
-        mock_vault = mocker.patch("jwbmisc.keeper.keeper_vault")
+        mock_vault = mocker.patch("jwbmisc.keeper.vault")
 
         mock_record = mocker.MagicMock()
         mock_vault.KeeperRecord.load.return_value = mock_record
 
-        mocker.patch("jwbmisc.keeper._extract_keeper_field", return_value="the_password")
-        mocker.patch("jwbmisc.keeper._perform_keeper_login")
+        mocker.patch("jwbmisc.keeper.extract_record_field", return_value="the_password")
+        mocker.patch("jwbmisc.keeper.perform_login")
 
-        result = get_keeper_password("RECORD123", "password")
+        result = get_password("RECORD123", "password")
 
         assert result == "the_password"
         mock_api.sync_down.assert_called_once()
@@ -221,14 +213,14 @@ class TestGetKeeperPassword:
         mocker.patch("jwbmisc.keeper.KeeperParams", return_value=mock_params)
 
         mocker.patch("jwbmisc.keeper.api")
-        mock_vault = mocker.patch("jwbmisc.keeper.keeper_vault")
+        mock_vault = mocker.patch("jwbmisc.keeper.vault")
         mock_vault.KeeperRecord.load.return_value = mocker.MagicMock()
 
-        mocker.patch("jwbmisc.keeper._extract_keeper_field", return_value=None)
-        mocker.patch("jwbmisc.keeper._perform_keeper_login")
+        mocker.patch("jwbmisc.keeper.extract_record_field", return_value=None)
+        mocker.patch("jwbmisc.keeper.perform_login")
 
         with pytest.raises(KeyError, match="Field.*not found"):
-            get_keeper_password("RECORD123", "missing_field")
+            get_password("RECORD123", "missing_field")
 
     def test_sync_failure_raises(self, mocker, tmp_path):
         mocker.patch("jwbmisc.keeper.Path.home", return_value=tmp_path)
@@ -240,7 +232,29 @@ class TestGetKeeperPassword:
         mock_api = mocker.patch("jwbmisc.keeper.api")
         mock_api.sync_down.side_effect = Exception("Sync failed")
 
-        mocker.patch("jwbmisc.keeper._perform_keeper_login")
+        mocker.patch("jwbmisc.keeper.perform_login")
 
         with pytest.raises(KeyError, match="Failed to sync"):
-            get_keeper_password("RECORD123", "password")
+            get_password("RECORD123", "password")
+
+    # def test_keeper_url(self, mocker):
+    #     mock_keeper = mocker.patch("jwbmisc.passwd._keeper_password")
+    #     mock_keeper.return_value = "keeper_password"
+
+    #     result = pw.get_pass("keeper://RECORD123/field/password")
+    #     assert result == "keeper_password"
+    #     mock_keeper.assert_called_once_with("RECORD123", "field/password")
+
+    # def test_keeper_url_invalid_format_raises(self):
+    #     with pytest.raises(KeyError, match="Invalid keeper:// format"):
+    #         pw.get_pass("keeper://RECORD123")
+
+
+# class TestKeeperPassword:
+#     def test_delegates_to_get_password(self, mocker):
+#         mock_get = mocker.patch("jwbmisc.keeper.get_password")
+#         mock_get.return_value = "keeper_secret"
+
+#         result = _keeper_password("RECORD_UID", "field/path")
+#         assert result == "keeper_secret"
+#         mock_get.assert_called_once_with("RECORD_UID", "field/path")

jwbmisc-0.0.5/tests/test_passwd.py

@@ -0,0 +1,84 @@
+# pyright: basic
+import pytest
+
+import jwbmisc.passwd as pw
+from pathlib import Path
+
+pw.PASS_BIN = str((Path(__file__).parent / "pass").absolute())
+
+
+class TestUnixPass:
+    def test_pass_url_single_line(self):
+        result = pw.get_pass("pass://test/secret")
+        assert result == "password123"
+
+    def test_pass_url_with_line_number(self):
+        result = pw.get_pass("pass://test/multiline?2")
+        assert result == "line2"
+
+    def test_pass_url_with_all_lines(self):
+        result = pw.get_pass("pass://test/multiline?0")
+        assert "line1" in result
+        assert "line2" in result
+        assert "line3" in result
+
+    def test_pass_url_with_invalid_line_number(self):
+        with pytest.raises(KeyError):
+            pw.get_pass("pass://test/multiline?99")
+
+
+class TestGetPass:
+    def test_no_keys_raises(self):
+        with pytest.raises(ValueError):
+            pw.get_pass()
+
+    def test_pass_url_missing_raises(self):
+        with pytest.raises(KeyError, match="pass failed"):
+            pw.get_pass("pass://test/missing")
+
+    def test_env_url(self, env_var):
+        env_var(MY_PASSWORD="secret123")
+        result = pw.get_pass("env://MY_PASSWORD")
+        assert result == "secret123"
+
+    def test_env_url_with_slashes(self, env_var):
+        env_var(MY__NESTED__VAR="nested_value")
+        result = pw.get_pass("env://MY/NESTED/VAR")
+        assert result == "nested_value"
+
+    def test_env_url_missing_raises(self):
+        with pytest.raises(KeyError, match="is not in the env"):
+            pw.get_pass("env://NONEXISTENT_VAR_12345")
+
+    def test_file_url(self, tmp_path):
+        secret_file = tmp_path / "secret.txt"
+        secret_file.write_text("file_password\n")
+        result = pw.get_pass(f"file://{secret_file}")
+        assert result == "file_password"
+
+    def test_file_url_strips_whitespace(self, tmp_path):
+        secret_file = tmp_path / "secret.txt"
+        secret_file.write_text("  password  \n\n")
+        result = pw.get_pass(f"file://{secret_file}")
+        assert result == "password"
+
+    def test_file_url_missing_raises(self, tmp_path):
+        missing = tmp_path / "missing.txt"
+        with pytest.raises(KeyError, match="does not exist"):
+            pw.get_pass(f"file://{missing}")
+
+    def test_file_url_directory_raises(self, tmp_path):
+        with pytest.raises(KeyError, match="does not exist or is a dir"):
+            pw.get_pass(f"file://{tmp_path}")
+
+    def test_keyring_url(self, mocker):
+        mocker.patch("keyring.get_password", return_value="keyring_password")
+
+        result = pw.get_pass("keyring://service/username")
+        assert result == "keyring_password"
+
+    def test_keyring_url_not_found_raises(self, mocker):
+        mocker.patch("keyring.get_password", return_value=None)
+
+        with pytest.raises(KeyError):
+            pw.get_pass("keyring://service/username")

{jwbmisc-0.0.3 → jwbmisc-0.0.5}/tests/test_string.py

@@ -1,6 +1,6 @@
 import pytest
 
-from jwbmisc.string import jinja_replace
+from jwbmisc.string import jinja_replace, qw, split_host, randomsuffix
 
 
 class TestJinjaReplace:
@@ -43,3 +43,51 @@ class TestJinjaReplace:
     def test_repeated_variable(self):
         result = jinja_replace("{{x}} and {{x}}", {"x": "same"})
         assert result == "same and same"
+
+
+class TestRandomsuffix:
+    def test_correct_length(self):
+        result = randomsuffix(10)
+        assert len(result) == 10
+
+    def test_only_lowercase(self):
+        result = randomsuffix(100)
+        assert result.islower()
+        assert result.isalpha()
+
+    def test_zero_length(self):
+        assert randomsuffix(0) == ""
+
+
+class TestQw:
+    def test_splits_on_whitespace(self):
+        assert qw("a b c") == ["a", "b", "c"]
+
+    def test_splits_on_multiple_spaces(self):
+        assert qw("a   b   c") == ["a", "b", "c"]
+
+    def test_splits_on_tabs(self):
+        assert qw("a\tb\tc") == ["a", "b", "c"]
+
+    def test_splits_on_newlines(self):
+        assert qw("a\nb\nc") == ["a", "b", "c"]
+
+    def test_empty_string(self):
+        assert qw("") == []
+
+    def test_single_word(self):
+        assert qw("word") == ["word"]
+
+
+class TestSplitHost:
+    def test_host_and_port(self):
+        assert split_host("localhost:8080") == ("localhost", 8080)
+
+    def test_host_only(self):
+        assert split_host("localhost") == ("localhost", None)
+
+    def test_empty_string(self):
+        assert split_host("") == (None, None)
+
+    def test_ipv4_with_port(self):
+        assert split_host("192.168.1.1:443") == ("192.168.1.1", 443)

jwbmisc-0.0.3/src/jwbmisc/util.py

@@ -1,64 +0,0 @@
-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.3/tests/test_passwd.py

@@ -1,121 +0,0 @@
-import pytest
-
-from jwbmisc.passwd import _call_unix_pass, _keeper_password, get_pass
-
-
-class TestGetPass:
-    def test_no_keys_raises(self):
-        with pytest.raises(ValueError, match="no pass keys"):
-            get_pass()
-
-    def test_pass_url_single_line(self, fake_pass):
-        result = get_pass("pass://test/secret")
-        assert result == "password123"
-
-    def test_pass_url_with_line_number(self, fake_pass):
-        result = get_pass("pass://test/multiline?2")
-        assert result == "line2"
-
-    def test_pass_url_missing_raises(self, fake_pass):
-        with pytest.raises(KeyError, match="pass failed"):
-            get_pass("pass://test/missing")
-
-    def test_env_url(self, env_var):
-        env_var(MY_PASSWORD="secret123")
-        result = get_pass("env://MY_PASSWORD")
-        assert result == "secret123"
-
-    def test_env_url_with_slashes(self, env_var):
-        env_var(MY__NESTED__VAR="nested_value")
-        result = get_pass("env://MY/NESTED/VAR")
-        assert result == "nested_value"
-
-    def test_env_url_missing_raises(self):
-        with pytest.raises(KeyError, match="is not in the env"):
-            get_pass("env://NONEXISTENT_VAR_12345")
-
-    def test_file_url(self, tmp_path):
-        secret_file = tmp_path / "secret.txt"
-        secret_file.write_text("file_password\n")
-        result = get_pass(f"file://{secret_file}")
-        assert result == "file_password"
-
-    def test_file_url_strips_whitespace(self, tmp_path):
-        secret_file = tmp_path / "secret.txt"
-        secret_file.write_text("  password  \n\n")
-        result = get_pass(f"file://{secret_file}")
-        assert result == "password"
-
-    def test_file_url_missing_raises(self, tmp_path):
-        missing = tmp_path / "missing.txt"
-        with pytest.raises(KeyError, match="does not exist"):
-            get_pass(f"file://{missing}")
-
-    def test_file_url_directory_raises(self, tmp_path):
-        with pytest.raises(KeyError, match="does not exist or is a dir"):
-            get_pass(f"file://{tmp_path}")
-
-    def test_keyring_url(self, mocker):
-        mocker.patch.dict("sys.modules", {"keyring": mocker.MagicMock()})
-        import sys
-
-        sys.modules["keyring"].get_password.return_value = "keyring_password"
-
-        result = get_pass("keyring://service/username")
-        assert result == "keyring_password"
-        sys.modules["keyring"].get_password.assert_called_once_with("service", "username")
-
-    def test_keyring_url_not_found_raises(self, mocker):
-        mocker.patch.dict("sys.modules", {"keyring": mocker.MagicMock()})
-        import sys
-
-        sys.modules["keyring"].get_password.return_value = None
-
-        with pytest.raises(KeyError, match="could not find a password"):
-            get_pass("keyring://service/username")
-
-    def test_keeper_url(self, mocker):
-        mock_keeper = mocker.patch("jwbmisc.passwd._keeper_password")
-        mock_keeper.return_value = "keeper_password"
-
-        result = get_pass("keeper://RECORD123/field/password")
-        assert result == "keeper_password"
-        mock_keeper.assert_called_once_with("RECORD123", "field/password")
-
-    def test_keeper_url_invalid_format_raises(self):
-        with pytest.raises(KeyError, match="Invalid keeper:// format"):
-            get_pass("keeper://RECORD123")
-
-
-class TestCallUnixPass:
-    def test_single_line(self, fake_pass):
-        result = _call_unix_pass("test/secret")
-        assert result == "password123"
-
-    def test_get_specific_line(self, fake_pass):
-        result = _call_unix_pass("test/multiline", lnum=2)
-        assert result == "line2"
-
-    def test_get_all_lines(self, fake_pass):
-        result = _call_unix_pass("test/multiline", lnum=0)
-        assert "line1" in result
-        assert "line2" in result
-        assert "line3" in result
-
-    def test_error_raises_keyerror(self, fake_pass):
-        with pytest.raises(KeyError, match="pass failed"):
-            _call_unix_pass("test/missing")
-
-    def test_line_number_out_of_range(self, fake_pass):
-        with pytest.raises(KeyError, match="could not retrieve lines"):
-            _call_unix_pass("test/secret", lnum=99)
-
-
-class TestKeeperPassword:
-    def test_delegates_to_get_keeper_password(self, mocker):
-        mock_get = mocker.patch("jwbmisc.keeper.get_keeper_password")
-        mock_get.return_value = "keeper_secret"
-
-        result = _keeper_password("RECORD_UID", "field/path")
-        assert result == "keeper_secret"
-        mock_get.assert_called_once_with("RECORD_UID", "field/path")

jwbmisc-0.0.3/tests/test_util.py

@@ -1,138 +0,0 @@
-import pytest
-
-from jwbmisc.util import ask, confirm, goo, qw, randomsuffix, split_host
-
-
-class TestAsk:
-    def test_returns_user_input(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "user_answer")
-        assert ask("Question?") == "user_answer"
-
-    def test_returns_default_on_empty_input(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "")
-        assert ask("Question?", default="default_value") == "default_value"
-
-    def test_returns_none_when_no_default_and_empty(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "")
-        assert ask("Question?") is None
-
-    def test_strips_input(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "  answer  ")
-        assert ask("Question?") == "answer"
-
-
-class TestConfirm:
-    def test_returns_true_for_y(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "y")
-        assert confirm("Continue?") is True
-
-    def test_returns_true_for_yes(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "yes")
-        assert confirm("Continue?") is True
-
-    def test_returns_true_for_Y(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "Y")
-        assert confirm("Continue?") is True
-
-    def test_returns_false_for_n(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "n")
-        assert confirm("Continue?") is False
-
-    def test_returns_false_for_no(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "no")
-        assert confirm("Continue?") is False
-
-    def test_empty_uses_default_n(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "")
-        assert confirm("Continue?", default="n") is False
-
-    def test_empty_uses_default_y(self, monkeypatch):
-        monkeypatch.setattr("builtins.input", lambda _: "")
-        assert confirm("Continue?", default="y") is True
-
-
-class TestRandomsuffix:
-    def test_correct_length(self):
-        result = randomsuffix(10)
-        assert len(result) == 10
-
-    def test_only_lowercase(self):
-        result = randomsuffix(100)
-        assert result.islower()
-        assert result.isalpha()
-
-    def test_zero_length(self):
-        assert randomsuffix(0) == ""
-
-
-class TestQw:
-    def test_splits_on_whitespace(self):
-        assert qw("a b c") == ["a", "b", "c"]
-
-    def test_splits_on_multiple_spaces(self):
-        assert qw("a   b   c") == ["a", "b", "c"]
-
-    def test_splits_on_tabs(self):
-        assert qw("a\tb\tc") == ["a", "b", "c"]
-
-    def test_splits_on_newlines(self):
-        assert qw("a\nb\nc") == ["a", "b", "c"]
-
-    def test_empty_string(self):
-        assert qw("") == []
-
-    def test_single_word(self):
-        assert qw("word") == ["word"]
-
-
-class TestSplitHost:
-    def test_host_and_port(self):
-        assert split_host("localhost:8080") == ("localhost", 8080)
-
-    def test_host_only(self):
-        assert split_host("localhost") == ("localhost", None)
-
-    def test_empty_string(self):
-        assert split_host("") == (None, None)
-
-    def test_ipv4_with_port(self):
-        assert split_host("192.168.1.1:443") == ("192.168.1.1", 443)
-
-
-class TestGoo:
-    def test_simple_key(self):
-        d = {"a": 1}
-        assert goo(d, "a") == 1
-
-    def test_nested_keys(self):
-        d = {"a": {"b": {"c": 3}}}
-        assert goo(d, "a", "b", "c") == 3
-
-    def test_dot_notation(self):
-        d = {"a": {"b": 2}}
-        assert goo(d, "a.b") == 2
-
-    def test_list_index(self):
-        d = {"items": ["a", "b", "c"]}
-        assert goo(d, "items", 1) == "b"
-
-    def test_missing_key_returns_default(self):
-        d = {"a": 1}
-        assert goo(d, "b", default="missing") == "missing"
-
-    def test_missing_key_returns_none_by_default(self):
-        d = {"a": 1}
-        assert goo(d, "b") is None
-
-    def test_raise_on_default(self):
-        d = {"a": 1}
-        with pytest.raises(ValueError, match="does not exist"):
-            goo(d, "b", raise_on_default=True)
-
-    def test_none_in_path_returns_default(self):
-        d = {"a": None}
-        assert goo(d, "a", "b", default="missing") == "missing"
-
-    def test_mixed_keys_and_indices(self):
-        d = {"users": [{"name": "Alice"}, {"name": "Bob"}]}
-        assert goo(d, "users", 0, "name") == "Alice"