openbadgeslib 3.5.0__tar.gz → 3.5.1__tar.gz

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/Changelog.txt

@@ -4,6 +4,47 @@ OpenBadgesLib - Changelog
 Newest first. Dates are ISO 8601 (YYYY-MM-DD).
 
 
+* v3.5.1 - 2026-07-07
+
+  - fix(ob3): a naive datetime passed as the issuance/expiration date is now
+    assumed UTC (matching status_registry._iso_z), not local time — so
+    validFrom/validUntil no longer silently shift by the host's offset and
+    stay consistent with the nbf/exp JWT claims.
+
+  - fix(ob3): the JWT verifier now cross-checks the `jti` claim against the
+    credential `id` (OB3 §8.2 binds them). A validly signed token whose jti
+    disagrees with — or omits — the credential id is rejected, alongside the
+    existing iss/nbf/sub checks.
+
+  - fix(ob3): `_b58btc_decode` bounds its input to 128 characters before the
+    O(n^2) base58 decode, so a hostile did:key / publicKeyMultibase in a
+    fetched did:web or Data Integrity document (up to 5 MiB / 256 KiB) can no
+    longer burn CPU. No real multikey exceeds ~70 characters.
+
+  - fix(ob2): an `evidence` array (which OB 2.0 permits) is preserved when
+    parsing an Assertion instead of being silently dropped — `_iri_or_none`
+    returned None for a list. A single value still collapses to its IRI.
+
+  - fix(cli): `openbadges-signer -M/--mail-badge` now prints a clear notice
+    on the default OB3 path (it was a silent no-op there); the stale
+    `openbadges-keygenerator -t ED25519` hint on the LDP path is corrected to
+    the real `key_type = ED25519` config key; and the OB1 mail path reads its
+    `[smtp]` config inside the try, so a missing `[smtp]` section is reported
+    cleanly after signing instead of raising a traceback.
+
+  - fix(publish): `openbadges-publish -V 3` no longer aborts mid-loop when a
+    badge has an unreadable key or corrupt registry — it skips that badge
+    with a notice (like the did.json path already did), regenerates the
+    others, and exits non-zero with a summary. An urgent revocation is no
+    longer masked by an unrelated half-configured badge.
+
+  - refactor(keygen): `openbadges-keygenerator` uses `enable_debug_logging`
+    instead of the legacy `Logger` class (now removed from logs.py), so key
+    generation no longer requires the `[paths]`/`[logs]` config sections just
+    to emit console lines (they raised a raw KeyError/FileNotFoundError), and
+    a missing `[issuer] name` degrades gracefully.
+
+
 * v3.5.0 - 2026-07-07
 
   - fix(status): serialise status-registry writes with an exclusive

{openbadgeslib-3.5.0/openbadgeslib.egg-info → openbadgeslib-3.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbadgeslib
-Version: 3.5.0
+Version: 3.5.1
 Summary: Production-ready Python library & CLI for Open Badges 3.0 (W3C Verifiable Credentials): issue, verify, and revoke JWT-VC credentials with Bitstring Status Lists and did:web — plus strict OB 2.0 and legacy OB 1.0.
 Author-email: Luis González Fernández <luisgf@luisgf.es>, Jesús Cea Avión <jcea@jcea.es>
 License: LGPLv3

openbadgeslib-3.5.1/openbadgeslib/logs.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""
+        OpenBadges Library
+
+        Copyright (c) 2014-2026, Luis González Fernández, luisgf@luisgf.es
+        Copyright (c) 2014-2026, Jesús Cea Avión, jcea@jcea.es
+
+        All rights reserved.
+
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public
+        License as published by the Free Software Foundation; either
+        version 3.0 of the License, or (at your option) any later version.
+
+        This library is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+        Lesser General Public License for more details.
+
+        You should have received a copy of the GNU Lesser General Public
+        License along with this library.
+"""
+
+import logging
+from typing import Any
+
+
+def enable_debug_logging(debug: bool = False) -> None:
+    """Route library log messages to the console for the CLI tools.
+
+    With ``debug=True`` DEBUG-level messages are shown; otherwise only INFO and
+    above. Idempotent — safe to call once per CLI invocation (it will not stack
+    duplicate console handlers).
+    """
+    root = logging.getLogger()
+    if not any(getattr(h, '_obl_console', False) for h in root.handlers):
+        handler: Any = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(levelname)s - %(message)s"))
+        handler._obl_console = True
+        root.addHandler(handler)
+    root.setLevel(logging.DEBUG if debug else logging.INFO)

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/ob2/models.py

@@ -32,7 +32,7 @@
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Union
 
 from ..util import hash_email
 
@@ -122,6 +122,25 @@ def _iri_or_none(value: Any) -> Optional[str]:
     return None
 
 
+def _iri_or_iris(value: Any) -> Optional[Union[str, List[str]]]:
+    """Like :func:`_iri_or_none`, but keep an array instead of dropping it.
+
+    OB 2.0 lets ``evidence`` be a bare IRI, an object with an ``id``, or an
+    array of either. A single value collapses to its IRI string (unchanged
+    behaviour); an array yields the list of IRIs it carries. None when nothing
+    usable is present — so a conformant multi-evidence assertion is no longer
+    silently discarded on parse.
+    """
+    if isinstance(value, list):
+        iris = []
+        for item in value:
+            iri = _iri_or_none(item)
+            if iri is not None:
+                iris.append(iri)
+        return iris or None
+    return _iri_or_none(value)
+
+
 def hash_identity(email: str, salt: Optional[str]) -> str:
     """Return the ``sha256$<hex>`` IdentityHash for an email plus optional salt."""
     return "sha256$" + hash_email(email, salt if salt is not None else "").decode("ascii")
@@ -209,7 +228,7 @@ class Assertion:
     issued_on: Optional[datetime] = None   # defaults to now (UTC)
     expires: Optional[datetime] = None
     image: Optional[str] = None
-    evidence: Optional[str] = None
+    evidence: Optional[Union[str, List[str]]] = None
     narrative: Optional[str] = None
 
     def __post_init__(self) -> None:
@@ -265,7 +284,7 @@ class Assertion:
             issued_on=issued_on,
             expires=expires,
             image=_iri_or_none(d.get("image")),
-            evidence=_iri_or_none(d.get("evidence")),
+            evidence=_iri_or_iris(d.get("evidence")),
             narrative=d.get("narrative") if isinstance(d.get("narrative"), str) else None,
         )
 

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/ob3/credential.py

@@ -56,7 +56,14 @@ def _validate_context(ctx: Any) -> None:
 
 
 def _iso(dt: datetime) -> str:
-    """Return a datetime as an ISO 8601 string with Z suffix."""
+    """Return a datetime as an ISO 8601 string with Z suffix.
+
+    A naive datetime is assumed to be UTC (matching status_registry._iso_z),
+    not local time — so validFrom/validUntil never silently shift by the host's
+    offset and stay consistent with the nbf/exp JWT claims.
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
     return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
@@ -131,6 +138,14 @@ class OpenBadgeCredential:
             self.id = f"urn:uuid:{uuid.uuid4()}"
         if self.issuance_date is None:
             self.issuance_date = datetime.now(timezone.utc)
+        elif self.issuance_date.tzinfo is None:
+            # A naive datetime is assumed UTC, so validFrom (string) and nbf
+            # (epoch int) agree instead of diverging by the host's offset.
+            self.issuance_date = self.issuance_date.replace(tzinfo=timezone.utc)
+        if self.expiration_date is not None \
+                and self.expiration_date.tzinfo is None:
+            self.expiration_date = self.expiration_date.replace(
+                tzinfo=timezone.utc)
         if self.name is None:
             self.name = self.achievement.name
 

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/ob3/did.py

@@ -95,7 +95,17 @@ def _multicodec_pubkey_to_pem(data: bytes) -> bytes:
     raise OB3VerificationError("unsupported did:key multicodec 0x%x" % code)
 
 
+#: Bound on base58btc input length. Decoding is O(n^2) in the length (big-int
+#: accumulation), and a hostile did:key / publicKeyMultibase in a fetched
+#: document could be hundreds of KB; no real multikey exceeds ~70 characters.
+_MAX_B58_LEN = 128
+
+
 def _b58btc_decode(value: str) -> bytes:
+    if len(value) > _MAX_B58_LEN:
+        raise OB3VerificationError(
+            "base58btc value too long: %d characters (max %d)"
+            % (len(value), _MAX_B58_LEN))
     num = 0
     for ch in value:
         idx = _B58_INDEX.get(ch)

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/ob3/verifier.py

@@ -311,6 +311,15 @@ class OB3Verifier:
             raise OB3VerificationError("JWT payload is missing the required 'sub' claim")
         if sub is not None and sub != subject_id:
             raise OB3VerificationError("JWT 'sub' does not match the credentialSubject id")
+        # jti is the registered claim bound to the credential id (OB3 §8.2); the
+        # signer always emits it. Require it whenever the body carries an id, and
+        # reject any mismatch, so a token cannot claim one id and carry another.
+        jti = payload.get("jti")
+        vc_id = vc.get("id")
+        if vc_id is not None and jti is None:
+            raise OB3VerificationError("JWT payload is missing the required 'jti' claim")
+        if jti is not None and jti != vc_id:
+            raise OB3VerificationError("JWT 'jti' does not match the credential id")
 
         return credential
 

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/openbadges_keygenerator.py

@@ -30,14 +30,17 @@
 """
 
 import argparse
+import logging
 import os
 import sys
 
-from .logs import Logger
+from .logs import enable_debug_logging
 from .keys import KeyFactory, KeyType
 from .confparser import read_config_or_exit, resolve_badge_section
 from .util import __version__
 
+logger = logging.getLogger(__name__)
+
 # Entry Point
 
 
@@ -100,15 +103,17 @@ def main() -> None:
             print('[!] Key file is present at %s' % i)
             sys.exit(1)
 
-    log = Logger(base_log=conf['paths']['base_log'],
-                 general=conf['logs']['general'],
-                 signer=conf['logs']['signer'],
-                 show_debug=args.debug)
+    # Key generation must not require [paths]/[logs]/[issuer]: the legacy Logger
+    # opened general.log/signer.log (KeyError/FileNotFoundError on an incomplete
+    # config) just to emit these console lines. The module logger needs none.
+    enable_debug_logging(args.debug)
 
-    log.console.debug("key_type=%s private=%s public=%s"
-                      % (key_type.name, private_key, public_key))
-    log.console.info("Generating OpenBadges %s %s key pair for issuer '%s'"
-                     % (args.ob_version, key_type.name, conf['issuer']['name']))
+    logger.debug("key_type=%s private=%s public=%s",
+                 key_type.name, private_key, public_key)
+    issuer_name = (conf['issuer'].get('name', '?')
+                   if conf.has_section('issuer') else '?')
+    logger.info("Generating OpenBadges %s %s key pair for issuer '%s'",
+                args.ob_version, key_type.name, issuer_name)
 
     kf = KeyFactory(key_type)
     priv_key_pem, pub_key_pem = kf.generate_keypair()
@@ -116,8 +121,8 @@ def main() -> None:
     _write_pem_file(private_key, priv_key_pem, 0o600)
     _write_pem_file(public_key, pub_key_pem, 0o644)
 
-    log.console.info('Private key saved at: %s' % private_key)
-    log.console.info('Public key saved at: %s' % public_key)
+    logger.info('Private key saved at: %s', private_key)
+    logger.info('Public key saved at: %s', public_key)
 
 
 if __name__ == '__main__':

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/openbadges_publish.py

@@ -231,6 +231,7 @@ def _publish_ob3(args: argparse.Namespace, parser: argparse.ArgumentParser) -> N
             print('[!] Cannot derive a did:web identifier: %s' % exc)
             sys.exit(-1)
 
+    failures = []                 # badges skipped (unreadable key / registry)
     umask = os.umask(0o077)  # rwx------
     try:
         os.makedirs(args.output, exist_ok=True)
@@ -264,8 +265,13 @@ def _publish_ob3(args: argparse.Namespace, parser: argparse.ArgumentParser) -> N
                 with open(conf[name]['private_key'], 'rb') as key:
                     priv_pem = key.read()
             except (StatusError, OSError) as exc:
-                print('[!] %s' % exc)
-                sys.exit(-1)
+                # Isolate a per-badge failure (unreadable key, corrupt registry)
+                # like the did.json skip above: don't abort the whole publish —
+                # a badge_2 mid-configuration must not make an urgent badge_1
+                # revocation appear to fail after its list was already written.
+                print('[!] Skipping [%s] status lists — %s' % (name, exc))
+                failures.append(name)
+                continue
             algorithm = alg_for_key_type(detect_key_type(priv_pem))
 
             badge_dir = os.path.join(args.output, name)
@@ -285,8 +291,13 @@ def _publish_ob3(args: argparse.Namespace, parser: argparse.ArgumentParser) -> N
     finally:
         os.umask(umask)
 
+    if failures:
+        print('[!] %d badge(s) skipped (see above): %s — their status lists '
+              'were NOT regenerated' % (len(failures), ', '.join(failures)))
     print('Please configure your Web server to publish the folder %s as %s' %
           (args.output, publish_url))
+    if failures:
+        sys.exit(1)
     print('[i] Issuer DID: %s' % did)
     if ':' not in did[len('did:web:'):]:
         print('[i] A bare-host did:web resolves at '

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/openbadges_signer.py

@@ -268,26 +268,25 @@ def _sign_ob1(args: argparse.Namespace, conf: configparser.ConfigParser, badge:
             print('[!] Could not write sign log: %s' % err)
 
         if bool(args.mail_badge):
-            server = conf['smtp']['smtp_server']
-            port = int(conf['smtp']['smtp_port'])
-            # configparser stores everything as strings; 'False' would be truthy.
-            use_ssl = conf['smtp'].getboolean('use_ssl', False)
-            mail_from = conf['smtp']['mail_from']
-            username = conf['smtp'].get('username')
-            password = conf['smtp'].get('password')
-
             try:
+                server = conf['smtp']['smtp_server']
+                port = int(conf['smtp']['smtp_port'])
+                # configparser stores everything as strings; 'False' is truthy.
+                use_ssl = conf['smtp'].getboolean('use_ssl', False)
+                mail_from = conf['smtp']['mail_from']
+                username = conf['smtp'].get('username')
+                password = conf['smtp'].get('password')
                 mail = BadgeMail(server, port, use_ssl, mail_from, username, password)
                 subject, body = mail.get_mail_content(conf[badge]['mail'])
                 mail.set_subject(subject)
                 mail.set_body(body)
                 mail.send(badge_signed)
             except (ValueError, OSError, KeyError) as err:
-                # e.g. a username set without use_ssl=True (ValueError), a
-                # missing/unreadable mail template file (OSError), or a badge
-                # section with no 'mail' key (KeyError) — the badge is already
-                # signed and saved, so report the config error instead of
-                # crashing with a traceback.
+                # e.g. a missing [smtp] section or key (KeyError), a username
+                # set without use_ssl=True (ValueError), or a missing/unreadable
+                # mail template file (OSError) — the badge is already signed and
+                # saved, so report the config error instead of crashing with a
+                # traceback. The [smtp] reads are inside the try for that reason.
                 print('[!] Could not send mail: %s' % err)
 
         print('%s at: %s' % (msg, badge_file_out))
@@ -401,6 +400,9 @@ def _sign_ob3(args: argparse.Namespace, conf: configparser.ConfigParser, badge:
     except OSError as err:
         print('[!] Could not write sign log: %s' % err)
     print('%s at: %s' % (msg, badge_file_out))
+    if args.mail_badge:
+        print('[i] --mail-badge is not supported for -V 3; the badge was saved '
+              'but not emailed.')
 
 
 def _sign_ob3_ldp(badge: str, badge_obj: Badge,
@@ -416,8 +418,9 @@ def _sign_ob3_ldp(badge: str, badge_obj: Badge,
 
     if key_type is not KeyType.ED25519:
         print("[!] --proof-format ldp (eddsa-rdfc-2022) requires an Ed25519 "
-              "key; [%s] uses %s. Generate one with: "
-              "openbadges-keygenerator -t ED25519" % (badge, key_type.value))
+              "key; [%s] uses %s. Set 'key_type = ED25519' in that badge's "
+              "config section and regenerate its key with "
+              "openbadges-keygenerator -g" % (badge, key_type.value))
         sys.exit(-1)
 
     verification_method = None

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/openbadgeslib/util.py

@@ -21,7 +21,7 @@
         License along with this library.
 """
 
-__version__ = '3.5.0'
+__version__ = '3.5.1'
 
 import hashlib
 import ipaddress

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1/openbadgeslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbadgeslib
-Version: 3.5.0
+Version: 3.5.1
 Summary: Production-ready Python library & CLI for Open Badges 3.0 (W3C Verifiable Credentials): issue, verify, and revoke JWT-VC credentials with Bitstring Status Lists and did:web — plus strict OB 2.0 and legacy OB 1.0.
 Author-email: Luis González Fernández <luisgf@luisgf.es>, Jesús Cea Avión <jcea@jcea.es>
 License: LGPLv3

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/tests/test_ob2_models.py

@@ -130,6 +130,19 @@ class TestAssertion:
         d['@context'] = [OB2_CONTEXT, 'https://example.com/extension']
         assert Assertion.from_dict(d).badge == d['badge']
 
+    def test_from_dict_keeps_an_evidence_array(self):
+        # OB 2.0 allows an array of evidence (IRIs or objects); it must not be
+        # silently dropped on parse.
+        d = _assertion().to_dict()
+        d['evidence'] = ['https://e/ev1', {'id': 'https://e/ev2'}]
+        assert Assertion.from_dict(d).evidence == ['https://e/ev1',
+                                                   'https://e/ev2']
+
+    def test_from_dict_keeps_single_evidence_as_string(self):
+        d = _assertion().to_dict()
+        d['evidence'] = 'https://e/only'
+        assert Assertion.from_dict(d).evidence == 'https://e/only'
+
     def test_from_dict_rejects_wrong_type(self):
         d = _assertion().to_dict()
         d['type'] = 'BadgeClass'

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/tests/test_ob3_credential.py

@@ -306,3 +306,19 @@ class TestHelpers:
         # calls .lower()); a non-string must be rejected here.
         with pytest.raises(ValueError, match="must be a string"):
             _require({'id': bad_value}, 'id', 'vc.credentialSubject')
+
+
+class TestNaiveDatetimeAssumedUtc:
+    def test_naive_issuance_date_coerced_to_utc(self):
+        # A naive datetime is assumed UTC, so validFrom (string) and nbf (epoch)
+        # agree instead of diverging by the host's local offset.
+        cred = _make_credential(issuance_date=datetime(2026, 1, 1, 12, 0, 0))
+        assert cred.issuance_date.tzinfo is not None
+        assert cred.to_vc()['validFrom'] == '2026-01-01T12:00:00Z'
+        aware = datetime(2026, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+        assert cred.to_jwt_payload()['nbf'] == int(aware.timestamp())
+
+    def test_naive_expiration_date_coerced_to_utc(self):
+        cred = _make_credential(expiration_date=datetime(2030, 6, 1, 0, 0, 0))
+        assert cred.expiration_date.tzinfo is not None
+        assert cred.to_vc()['validUntil'] == '2030-06-01T00:00:00Z'

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/tests/test_ob3_did.py

@@ -69,6 +69,12 @@ class TestDidKey:
         with pytest.raises(OB3VerificationError, match='base58'):
             resolve_did('did:key:z0OIl')   # 0, O, I, l are not in the alphabet
 
+    def test_overlong_base58_rejected(self):
+        # A hostile did:key must be length-bounded before the O(n^2) decode; no
+        # real multikey exceeds ~70 chars.
+        with pytest.raises(OB3VerificationError, match='too long'):
+            resolve_did('did:key:z' + 'a' * 200)
+
     def test_non_z_multibase_rejected(self):
         with pytest.raises(OB3VerificationError, match='base58btc'):
             resolve_did('did:key:Qabc')

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/tests/test_ob3_signer_cli_ldp.py

@@ -190,9 +190,10 @@ class TestSignerLdpCli:
 
 
 class TestEd25519CliSupport:
-    # Badge.create_from_conf rejected key_type = ED25519 outright, so the
-    # CLI could never sign with the keys openbadges-keygenerator -t ED25519
-    # produces — a prerequisite for LDP issuance, fixed alongside it.
+    # Badge.create_from_conf rejected key_type = ED25519 outright, so the CLI
+    # could never sign with the keys openbadges-keygenerator produces from a
+    # key_type = ED25519 badge section — a prerequisite for LDP issuance,
+    # fixed alongside it.
 
     def test_vc_jwt_with_ed25519_key_roundtrips(self, tmp_path,
                                                 ed25519_key_files, capsys):

{openbadgeslib-3.5.0 → openbadgeslib-3.5.1}/tests/test_ob3_verifier.py

@@ -611,3 +611,26 @@ class TestEndToEndRoundtrip:
         token = OB3Verifier.extract_token_from_svg(signed_svg)
         restored = ob3_rsa_verifier.verify(token)
         assert restored.evidence_url == 'https://example.com/proof/123'
+
+
+class TestJtiBinding:
+    # The jti claim binds the token to the credential id (OB3 §8.2). A validly
+    # signed token whose jti disagrees with (or omits) the credential id must be
+    # rejected — sign_payload lets us forge exactly that.
+    def test_mismatched_jti_raises(
+        self, ob3_rsa_signer, ob3_rsa_verifier, ob3_credential
+    ):
+        payload = ob3_credential.to_jwt_payload()
+        payload['jti'] = 'urn:uuid:00000000-0000-0000-0000-000000000000'
+        token = ob3_rsa_signer.sign_payload(payload)
+        with pytest.raises(OB3VerificationError, match="jti"):
+            ob3_rsa_verifier.verify(token)
+
+    def test_missing_jti_raises(
+        self, ob3_rsa_signer, ob3_rsa_verifier, ob3_credential
+    ):
+        payload = ob3_credential.to_jwt_payload()
+        del payload['jti']
+        token = ob3_rsa_signer.sign_payload(payload)
+        with pytest.raises(OB3VerificationError, match="jti"):
+            ob3_rsa_verifier.verify(token)

openbadgeslib-3.5.0/openbadgeslib/logs.py

@@ -1,85 +0,0 @@
-#!/usr/bin/env python3
-"""
-        OpenBadges Library
-
-        Copyright (c) 2014-2026, Luis González Fernández, luisgf@luisgf.es
-        Copyright (c) 2014-2026, Jesús Cea Avión, jcea@jcea.es
-
-        All rights reserved.
-
-        This library is free software; you can redistribute it and/or
-        modify it under the terms of the GNU Lesser General Public
-        License as published by the Free Software Foundation; either
-        version 3.0 of the License, or (at your option) any later version.
-
-        This library is distributed in the hope that it will be useful,
-        but WITHOUT ANY WARRANTY; without even the implied warranty of
-        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-        Lesser General Public License for more details.
-
-        You should have received a copy of the GNU Lesser General Public
-        License along with this library.
-"""
-
-import logging
-import os
-from typing import Any
-
-
-def enable_debug_logging(debug: bool = False) -> None:
-    """Route library log messages to the console for the CLI tools.
-
-    With ``debug=True`` DEBUG-level messages are shown; otherwise only INFO and
-    above. Idempotent — safe to call once per CLI invocation (it will not stack
-    duplicate console handlers).
-    """
-    root = logging.getLogger()
-    if not any(getattr(h, '_obl_console', False) for h in root.handlers):
-        handler: Any = logging.StreamHandler()
-        handler.setFormatter(logging.Formatter("%(levelname)s - %(message)s"))
-        handler._obl_console = True
-        root.addHandler(handler)
-    root.setLevel(logging.DEBUG if debug else logging.INFO)
-
-
-class Logger():
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        self.main = self.init_log(logger='general', base_log=kwargs['base_log'],
-                                  file=kwargs['general'])
-        self.signer = self.init_log(logger='signer', base_log=kwargs['base_log'],
-                                    file=kwargs['signer'])
-        try:
-            self.console = self.init_console(show_debug=kwargs['show_debug'])
-        except KeyError:
-            self.console = self.init_console()
-
-    def init_log(self, logger: Any = '', base_log: Any = None,
-                 log_level: int = logging.INFO,
-                 file: Any = None) -> logging.Logger:
-        logger = logging.getLogger(logger)
-        logger.setLevel(logging.DEBUG)
-        file_path = os.path.join(base_log, file)
-
-        """ Create a file handler """
-        handler = logging.FileHandler(file_path, "a",
-                                      encoding='utf-8', delay=False)
-        handler.setLevel(log_level)
-        formatter = logging.Formatter("%(asctime)s %(message)s")
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-        return logger
-
-    def init_console(self, show_debug: bool = False) -> logging.Logger:
-        logger = logging.getLogger()
-        logger.setLevel(logging.NOTSET)
-
-        """ Console a console handler """
-        handler = logging.StreamHandler()
-        if not show_debug:
-            handler.setLevel(logging.INFO)
-        formatter = logging.Formatter("%(levelname)s - %(message)s")
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-        return logger