jwbmisc 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

jwbmisc/__init__.py

@@ -1,243 +1,25 @@
-import subprocess as sp
-import keyring
-import random
-import string
-import re
-from collections.abc import Iterable
-from typing import Any
-import os
-import json
-from pathlib import Path
-import gzip
-
-
-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)
-
-
-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 resilient_loads(data):
-    if not data:
-        return None
-    try:
-        return json.loads(data)
-    except Exception:
-        return None
-
-
-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("'{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("'{path}' does not exist")
-        return default
-    return res
-
-
-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 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://"):
-            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
-
-    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, encoding="utf-8")
-    value, _ = proc.communicate()
-
-    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]
-        pw = lines[lnum - 1].strip()
-    except IndexError:
-        raise KeyError(f"could not not retrieve lines {lnum} for {key}")
-
-    return pw
-
-
-def jinja_replace(s, config, relaxed=False, delim=("{{", "}}")):
-    """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)
-
-
-def randomsuffix(length):
-    letters = string.ascii_lowercase
-    return "".join(random.choice(letters) for _ in range(length))
-
-
-def confirm(question, default="n"):
-    prompt = f"{question} (y/n)"
-    if default is not None:
-        prompt += f" [{default}]"
-    answer = input(prompt).strip().lower()
-    return answer.startswith("y")
-
-
-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
-
-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)
+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/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.2'
-__version_tuple__ = version_tuple = (0, 0, 2)
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)
 
 __commit_id__ = commit_id = None

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/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/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/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/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/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/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.2.dist-info → jwbmisc-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jwbmisc
-Version: 0.0.2
+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.dist-info/RECORD

@@ -0,0 +1,14 @@
+jwbmisc/__init__.py,sha256=VT_f1aG3ufoT7mYV1Ho0ocNtydMTIPbmcvOANwQE-CQ,551
+jwbmisc/_version.py,sha256=pBZsQt6tlL02W-ri--X_4JCubpAK7jjCSnOmUp_isjc,704
+jwbmisc/exec.py,sha256=9g1Jc7iDkBj1Y-dn5VhnwH1JqvWSbrFe6Mmvnf-iqag,1177
+jwbmisc/fs.py,sha256=Vf28qbOnBeHEbXNMUZjOQXtMWBurjkzD2KmfV2gJQXM,599
+jwbmisc/json.py,sha256=h3CBDNNZjcTDxydViyydPsQufXQLuxqP24wBBAT2nDs,1198
+jwbmisc/keeper.py,sha256=nOOfzoAPF7Uy3TuMPPdBdq9DvwNanyrQp6lVFI66LnU,4317
+jwbmisc/passwd.py,sha256=ZcOIT_RrwDR3uZgrcWASRLz8D6gf6iAHOEdyfwTuX4I,2520
+jwbmisc/string.py,sha256=pUNAMaP5531mBy3mrp9GCZ3QRPy6MQwegt5yzcWP1wQ,795
+jwbmisc/util.py,sha256=XCF5LEOLjI4IsYP-FF2ytbzo4J0rlCNJzrdNrtNWSGM,1568
+jwbmisc-0.0.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+jwbmisc-0.0.3.dist-info/METADATA,sha256=U6WTkWiesNELCpjGh0Myaj-Uzd6To1qw7K28--fAWkU,14507
+jwbmisc-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jwbmisc-0.0.3.dist-info/top_level.txt,sha256=FqEYs8zdG3iGOJmC6cutDXfGQUNptzfYeKsaG43y1HE,8
+jwbmisc-0.0.3.dist-info/RECORD,,

jwbmisc-0.0.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-jwbmisc/__init__.py,sha256=Tgh1Dm7B00JknbD4frFd-rAFy2E3NuT-9eZub9ck-Lg,6702
-jwbmisc/_version.py,sha256=huLsL1iGeXWQKZ8bjwDdIWC7JOkj3wnzBh-HFMZl1PY,704
-jwbmisc-0.0.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-jwbmisc-0.0.2.dist-info/METADATA,sha256=uJnh1a-j_XzPaE3zzPXBeMye2VKp2EHEaZHv25GWtdo,14444
-jwbmisc-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jwbmisc-0.0.2.dist-info/top_level.txt,sha256=FqEYs8zdG3iGOJmC6cutDXfGQUNptzfYeKsaG43y1HE,8
-jwbmisc-0.0.2.dist-info/RECORD,,