nrfcloud-utils 3.0.12__tar.gz → 3.2.0__tar.gz

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/PKG-INFO

@@ -1,27 +1,26 @@
 Metadata-Version: 2.4
 Name: nrfcloud-utils
-Version: 3.0.12
+Version: 3.2.0
 Summary: Scripts and utilities for working with the nRF Cloud
-License: BSD-3-Clause
+License-Expression: BSD-3-Clause
 License-File: LICENSE.txt
 Author: Nordic Semiconductor ASA
 Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: cbor2 (>=5.4.2.post1,<6.0.0)
-Requires-Dist: cffi (>=2.0.0,<3.0.0)
-Requires-Dist: cryptography (>=46.0.5,<47.0.0)
-Requires-Dist: inquirer (>=3.4.0,<4.0.0)
-Requires-Dist: nrfcredstore (>=2.0.9,<3.0.0)
-Requires-Dist: pyjwt (>=2.3.0,<3.0.0)
-Requires-Dist: requests (>=2.32.0,<3.0.0)
-Requires-Dist: semver (>=3.0.0,<4.0.0)
-Requires-Dist: urllib3 (>=2.2.2,<3.0.0)
+Requires-Dist: cbor2 (>=5.4.2.post1)
+Requires-Dist: cffi (>=2.0.0)
+Requires-Dist: cryptography (>=46.0.5)
+Requires-Dist: inquirer (>=3.4.0)
+Requires-Dist: nrfcredstore (>=2.1.0)
+Requires-Dist: pyjwt (>=2.3.0)
+Requires-Dist: requests (>=2.32.0)
+Requires-Dist: semver (>=3.0.0)
+Requires-Dist: urllib3 (>=2.7.0)
 Project-URL: Repository, https://github.com/nRFCloud/utils
 Description-Content-Type: text/markdown
 

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/pyproject.toml

@@ -2,36 +2,33 @@
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
-[tool.poetry]
+[project]
 name = "nrfcloud-utils"
-version = "3.0.12"
+version = "3.2.0"
 description = "Scripts and utilities for working with the nRF Cloud"
-authors = ["Nordic Semiconductor ASA"]
 license = "BSD-3-Clause"
 readme = "README.md"
-repository = "https://github.com/nRFCloud/utils"
-packages = [
-    { include = "nrfcloud_utils", from = "src" }
+requires-python = ">=3.10,<4.0"
+authors = [
+    { name = "Nordic Semiconductor ASA" }
+]
+dependencies = [
+    "cbor2>=5.4.2.post1",
+    "cryptography>=46.0.5",
+    "cffi>=2.0.0",
+    "requests>=2.32.0",
+    "urllib3>=2.7.0",
+    "semver>=3.0.0",
+    "pyjwt>=2.3.0",
+    "inquirer>=3.4.0",
+    "nrfcredstore>=2.1.0",
 ]
 
-[tool.poetry.dependencies]
-python = "^3.10"
-cbor2 = "^5.4.2.post1"
-cryptography = "^46.0.5"
-cffi = "^2.0.0"
-requests = "^2.32.0"
-urllib3 = "^2.2.2"
-semver = "^3.0.0"
-pyjwt = "^2.3.0"
-inquirer = "^3.4.0"
-nrfcredstore = "^2.0.9"
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^7.3.1"
-pytest-cov = "^4.0.0"
-pytest-watch = "^4.2.0"
+[project.urls]
+repository = "https://github.com/nRFCloud/utils"
 
-[tool.poetry.scripts]
+[project.scripts]
+nrfcloud-utils = "nrfcloud_utils.cli:run"
 claim_and_provision_device = "nrfcloud_utils.claim_and_provision_device:run"
 claim_devices = "nrfcloud_utils.claim_devices:run"
 create_ca_cert = "nrfcloud_utils.create_ca_cert:run"
@@ -42,6 +39,20 @@ gather_attestation_tokens = "nrfcloud_utils.gather_attestation_tokens:run"
 modem_credentials_parser = "nrfcloud_utils.modem_credentials_parser:run"
 nrf_cloud_device_mgmt = "nrfcloud_utils.nrf_cloud_device_mgmt:run"
 nrf_cloud_onboard = "nrfcloud_utils.nrf_cloud_onboard:run"
+nrf93_onboard = "nrfcloud_utils.nrf93_onboard:run"
+
+[dependency-groups]
+dev = [
+    "pytest>=7.3.1",
+    "pytest-cov>=4.0.0",
+    "pytest-watch>=4.2.0",
+    "poetry (>=2.4.1,<3.0.0)",  # used for development today. might be migrated to uv in the future.
+]
+
+[tool.poetry]
+packages = [
+    { include = "nrfcloud_utils", from = "src" }
+]
 
 [tool.pytest.ini_options]
 addopts = ["--import-mode=importlib"]

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/claim_and_provision_device.py

@@ -7,7 +7,7 @@ import sys
 import time
 import json
 import argparse
-import coloredlogs, logging
+import logging
 from nrfcloud_utils import (
     ca_certs,
     nrf_cloud_onboard,
@@ -15,8 +15,8 @@ from nrfcloud_utils import (
     nrf_cloud_diap,
     create_device_credentials
 )
-from nrfcloud_utils.cli_helpers import is_linux, is_windows, is_macos
-from nrfcloud_utils.cli_helpers import CMD_TERM_DICT, CMD_TYPE_AUTO, CMD_TYPE_AT, CMD_TYPE_AT_SHELL, CMD_TYPE_TLS_SHELL, parser_add_comms_args
+from nrfcloud_utils.cli_helpers import setup_logging
+from nrfcloud_utils.cli_helpers import CMD_TERM_DICT, CMD_TYPE_AUTO, CMD_TYPE_AT, CMD_TYPE_AT_SHELL, parser_add_comms_args
 from cryptography import x509
 from cryptography.hazmat.primitives import serialization
 from nrfcredstore.comms import Comms
@@ -27,9 +27,10 @@ logger = logging.getLogger(__name__)
 IMEI_LEN = 15
 DEV_ID_MAX_LEN = 64
 
-def parse_args(in_args):
+def get_parser():
     parser = argparse.ArgumentParser(description="nRF Cloud Claim and Provision",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                                     add_help=False)
     parser_add_comms_args(parser)
     parser.add_argument("--dv", type=int, help="Number of days cert is valid",
                         default=(10 * 365))
@@ -81,11 +82,13 @@ def parse_args(in_args):
                         choices=['debug', 'info', 'warning', 'error', 'critical'],
                         help='Set the logging level'
     )
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    if args.plain:
-        logging.basicConfig(level=args.log_level.upper())
-    else:
-        coloredlogs.install(level=args.log_level.upper(), fmt='%(levelname)-8s %(message)s')
+    setup_logging(level=args.log_level, use_color=not args.plain)
     return args
 
 def error_exit(err_msg):
@@ -132,7 +135,7 @@ def main(in_args):
             error_exit(f'Device ID must not exceed {DEV_ID_MAX_LEN} characters')
 
     if 'CN=' in args.csr_attr:
-        error_exit(f'Do not include CN in --csr_attr. The device ID will be used as the CN')
+        error_exit('Do not include CN in --csr_attr. The device ID will be used as the CN')
 
     # load local CA cert and key if needed; assume not needed if using provisioning tags
     if args.provisioning_tags is None:
@@ -195,7 +198,7 @@ def main(in_args):
         logger.info(f'Unclaiming device {dev_uuid}...')
         api_res = nrf_cloud_diap.unclaim_device(args.api_key, dev_uuid)
         if api_res.status_code == 204:
-            logger.info(f'...success')
+            logger.info('...success')
         else:
             nrf_cloud_diap.print_api_result("Unclaim device response", api_res)
             logger.info("Device may not have been claimed before, continuing...")

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/claim_devices.py

@@ -7,9 +7,9 @@ import io
 import sys
 import csv
 import argparse
-import coloredlogs, logging
+import logging
 from nrfcloud_utils import nrf_cloud_diap
-from nrfcloud_utils.cli_helpers import is_linux, is_windows, is_macos
+from nrfcloud_utils.cli_helpers import setup_logging
 
 logger = logging.getLogger(__name__)
 
@@ -17,9 +17,10 @@ args = None
 IMEI_LEN = 15
 MAX_CSV_ROWS = 1000
 
-def parse_args(in_args):
+def get_parser():
     parser = argparse.ArgumentParser(description="nRF Cloud Claim Devices",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                                     add_help=False)
 
     parser.add_argument("--csv", type=str,
                         help="Filepath to attestation token CSV file",
@@ -39,11 +40,13 @@ def parse_args(in_args):
                         choices=['debug', 'info', 'warning', 'error', 'critical'],
                         help='Set the logging level'
     )
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    if args.plain:
-        logging.basicConfig(level=args.log_level.upper())
-    else:
-        coloredlogs.install(level=args.log_level.upper(), fmt='%(levelname)-8s %(message)s')
+    setup_logging(level=args.log_level, use_color=not args.plain)
     return args
 
 def bulk_claim(api_key, array_of_claims):

nrfcloud_utils-3.2.0/src/nrfcloud_utils/cli.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2025 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: BSD-3-Clause
+import argparse
+import sys
+
+from nrfcloud_utils import (
+    claim_and_provision_device,
+    claim_devices,
+    create_ca_cert,
+    create_device_credentials,
+    create_proxy_jwt,
+    device_credentials_installer,
+    gather_attestation_tokens,
+    modem_credentials_parser,
+    nrf_cloud_device_mgmt,
+    nrf_cloud_onboard,
+    nrf93_onboard,
+)
+
+_MODULES = {
+    "claim_and_provision_device": claim_and_provision_device,
+    "claim_devices": claim_devices,
+    "create_ca_cert": create_ca_cert,
+    "create_device_credentials": create_device_credentials,
+    "create_proxy_jwt": create_proxy_jwt,
+    "device_credentials_installer": device_credentials_installer,
+    "gather_attestation_tokens": gather_attestation_tokens,
+    "modem_credentials_parser": modem_credentials_parser,
+    "nrf_cloud_device_mgmt": nrf_cloud_device_mgmt,
+    "nrf_cloud_onboard": nrf_cloud_onboard,
+    "nrf93_onboard": nrf93_onboard,
+}
+
+
+def _build_parser():
+    parser = argparse.ArgumentParser(
+        prog="nrfcloud-utils",
+        description="Scripts and utilities for working with nRF Cloud",
+    )
+    subparsers = parser.add_subparsers(dest="command", metavar="command", required=False)
+    for name, mod in _MODULES.items():
+        _p = mod.get_parser()
+        subparsers.add_parser(
+            name,
+            parents=[_p],
+            description=_p.description,
+            formatter_class=_p.formatter_class,
+            help=_p.description,
+        )
+    return parser
+
+
+def run():
+    parser = _build_parser()
+    # parse_args() handles --help at both levels and validates the subcommand name
+    # and its args (using each module's get_parser() for the subparser definition).
+    # We then re-dispatch to the module's own main() so setup_logging and other
+    # module init runs exactly as it does when the command is called standalone.
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    cmd = args.command
+    sys.argv = [cmd] + sys.argv[2:]
+    _MODULES[cmd].main(sys.argv[1:])
+
+
+if __name__ == "__main__":
+    run()

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/cli_helpers.py

@@ -10,6 +10,7 @@ import platform
 import os
 import csv
 import logging
+import coloredlogs
 
 MAX_CSV_ROWS = 1000
 
@@ -20,6 +21,39 @@ full_encoding = 'mbcs' if is_windows else 'ascii'
 
 logger = logging.getLogger(__name__)
 
+def setup_logging(level='info', fmt='%(levelname)-8s %(message)s', use_color=True):
+    """
+    Configure colored logging with dark-terminal-friendly colors.
+    
+    Args:
+        level: logging level as string (debug, info, warning, error, critical)
+        fmt: log format string
+        use_color: whether to use colored output (False for --plain mode)
+    """
+    log_level = getattr(logging, level.upper(), logging.INFO)
+    
+    if use_color:
+        # Define colors for dark terminals with better contrast
+        level_styles = {
+            'debug': {'color': 'cyan'},
+            'info': {'color': 'green'},
+            'warning': {'color': 'yellow'},
+            'error': {'color': 'red'},
+            'critical': {'color': 'red', 'bold': True},
+        }
+        field_styles = {
+            'asctime': {'color': 'white'},
+            'levelname': {'color': 'white', 'bold': True},
+        }
+        coloredlogs.install(
+            level=log_level,
+            fmt=fmt,
+            level_styles=level_styles,
+            field_styles=field_styles
+        )
+    else:
+        logging.basicConfig(level=log_level, format=fmt)
+
 def write_file(pathname, filename, bytes):
     """
     save bytes to file
@@ -28,7 +62,7 @@ def write_file(pathname, filename, bytes):
     if not path.isdir(pathname):
         try:
             makedirs(pathname, exist_ok=True)
-        except OSError as e:
+        except OSError:
             raise RuntimeError(f"Error creating file path [{pathname}]")
 
     full_path = path.join(pathname, filename)

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/create_ca_cert.py

@@ -22,13 +22,14 @@ from cryptography.x509 import (
     SubjectKeyIdentifier,
 )
 
-from nrfcloud_utils.cli_helpers import write_file
-import coloredlogs, logging
+from nrfcloud_utils.cli_helpers import write_file, setup_logging
+import logging
 
 logger = logging.getLogger(__name__)
 
-def parse_args(in_args):
-    parser = argparse.ArgumentParser(description="Create CA Certificate")
+def get_parser():
+    parser = argparse.ArgumentParser(description="Create CA Certificate",
+                                     add_help=False)
     parser.add_argument("-c", type=str, help="2 character country code", default="NO")
     parser.add_argument("--st", type=str, help="State or Province", default="")
     parser.add_argument("-l", type=str, help="Locality", default="")
@@ -50,10 +51,13 @@ def parse_args(in_args):
                         choices=['debug', 'info', 'warning', 'error', 'critical'],
                         help='Set the logging level'
     )
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    level = getattr(logging, args.log_level.upper(), logging.INFO)
-    fmt = '%(levelname)-8s %(message)s'
-    coloredlogs.install(level=level, fmt=fmt)
+    setup_logging(level=args.log_level)
     return args
 
 

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/create_device_credentials.py

@@ -15,22 +15,18 @@ from cryptography.x509.oid import NameOID
 from cryptography import x509
 import uuid
 from cryptography.x509 import (
-    Name,
-    NameAttribute,
-    BasicConstraints,
     KeyUsage,
-    AuthorityKeyIdentifier,
-    SubjectKeyIdentifier,
 )
 
-from nrfcloud_utils.cli_helpers import write_file, save_onboarding_csv
+from nrfcloud_utils.cli_helpers import write_file, save_onboarding_csv, setup_logging
 from nrfcloud_utils import ca_certs
-import coloredlogs, logging
+import logging
 
 logger = logging.getLogger(__name__)
 
-def parse_args(in_args):
-    parser = argparse.ArgumentParser(description="Create Device Credentials")
+def get_parser():
+    parser = argparse.ArgumentParser(description="Create Device Credentials",
+                                     add_help=False)
     parser.add_argument("--ca", type=str, required=True, help="Filepath to your CA cert PEM", default="")
     parser.add_argument("--ca-key", type=str, required=True, help="Filepath to your CA's private key PEM", default="")
     parser.add_argument("-c", type=str, help="2 character country code; required if CSR is not provided", default="NO")
@@ -60,10 +56,13 @@ def parse_args(in_args):
                         choices=['debug', 'info', 'warning', 'error', 'critical'],
                         help='Set the logging level'
     )
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    level = getattr(logging, args.log_level.upper(), logging.INFO)
-    fmt = '%(levelname)-8s %(message)s'
-    coloredlogs.install(level=level, fmt=fmt)
+    setup_logging(level=args.log_level)
     if len(args.csr) == 0 and len(args.cn) == 0:
         args.cn = str(uuid.uuid4())
     return args

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/create_proxy_jwt.py

@@ -9,13 +9,15 @@ import sys
 import jwt
 from datetime import datetime, timezone, timedelta
 from os import path
-import coloredlogs, logging
+import logging
+from nrfcloud_utils.cli_helpers import setup_logging
 
 logger = logging.getLogger(__name__)
 
-def parse_args(in_args):
+def get_parser():
     parser = argparse.ArgumentParser(description="Create JWT for proxy (cloud-to-cloud) requests to nRF Cloud",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                                     add_help=False)
 
     parser.add_argument("--key", type=str, required=True,
                         help="Required filepath to the ES256 private key PEM (Service Key) used for JWT signing. \
@@ -42,10 +44,13 @@ def parse_args(in_args):
                         choices=['debug', 'info', 'warning', 'error', 'critical'],
                         help='Set the logging level'
     )
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    level = getattr(logging, args.log_level.upper(), logging.INFO)
-    fmt = '%(levelname)-8s %(message)s'
-    coloredlogs.install(level=level, fmt=fmt)
+    setup_logging(level=args.log_level)
     return args
 
 def create_nrf_cloud_jwt(prv_key_bytes, team_id, dev_id, days_valid):

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/device_credentials_installer.py

@@ -10,9 +10,9 @@ import os
 import sys
 import uuid
 import semver
-import coloredlogs, logging
+import logging
 from nrfcloud_utils import create_device_credentials, ca_certs, modem_credentials_parser
-from nrfcloud_utils.cli_helpers import write_file, save_devinfo_csv, save_onboarding_csv, is_linux, is_windows, is_macos, full_encoding
+from nrfcloud_utils.cli_helpers import write_file, save_devinfo_csv, save_onboarding_csv, full_encoding, setup_logging
 from nrfcloud_utils.cli_helpers import CMD_TERM_DICT, CMD_TYPE_AUTO, CMD_TYPE_AT, CMD_TYPE_AT_SHELL, CMD_TYPE_TLS_SHELL, parser_add_comms_args
 from nrfcredstore.command_interface import ATCommandInterface, TLSCredShellInterface
 from nrfcredstore.comms import Comms
@@ -27,9 +27,10 @@ DEV_ID_MAX_LEN = 64
 MIN_REQD_MFW_VER = "1.3.0"
 MIN_REQD_MFW_VER_FOR_VERIFY = "1.3.2"
 
-def parse_args(in_args):
+def get_parser():
     parser = argparse.ArgumentParser(description="Device Credentials Installer",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                                     add_help=False)
     parser_add_comms_args(parser)
     parser.add_argument("--dv", type=int, help="Number of days cert is valid",
                         default=(10 * 365))
@@ -105,11 +106,13 @@ def parse_args(in_args):
                         choices=['debug', 'info', 'warning', 'error', 'critical'],
                         help='Set the logging level'
     )
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    if args.plain:
-        logging.basicConfig(level=args.log_level.upper())
-    else:
-        coloredlogs.install(level=args.log_level.upper(), fmt='%(levelname)-8s %(message)s')
+    setup_logging(level=args.log_level, use_color=not args.plain)
     return args
 
 def parse_mfw_ver(ver_str):
@@ -380,17 +383,32 @@ def main(in_args):
     # write CA cert(s) to device
     nrf_ca_cert_text = format_cred(ca_certs.get_ca_certs(args.coap, stage=args.stage))
 
-    logger.info(f'Writing CA cert(s) to device...')
-    cred_if.write_credential(args.sectag, 0, nrf_ca_cert_text)
+    logger.info('Writing CA cert(s) to device...')
+    try:
+        cred_if.write_credential(args.sectag, 0, nrf_ca_cert_text)
+    except Exception as e:
+        logger.error('Failed to write CA certificate to device')
+        logger.debug(f'Error details: {e}')
+        raise
 
     # write dev cert to device
-    logger.info(f'Writing dev cert to device...')
-    cred_if.write_credential(args.sectag, 1, dev_text)
+    logger.info('Writing dev cert to device...')
+    try:
+        cred_if.write_credential(args.sectag, 1, dev_text)
+    except Exception as e:
+        logger.error('Failed to write device certificate to device')
+        logger.debug(f'Error details: {e}')
+        raise
 
     # If the private key was locally generated, write it to the device
     if prv_text is not None:
-        logger.info(f'Writing private key to device...')
-        cred_if.write_credential(args.sectag, 2, prv_text)
+        logger.info('Writing private key to device...')
+        try:
+            cred_if.write_credential(args.sectag, 2, prv_text)
+        except Exception as e:
+            logger.error('Failed to write private key to device')
+            logger.debug(f'Error details: {e}')
+            raise
 
     if args.verify:
         logger.info('Verifying credentials...')
@@ -451,7 +469,14 @@ def verify_credential(cred_if, sec_tag, cred_type, cred = None, get_hash = False
         logger.error('Invalid credential string')
         return False
 
-    present, hash = cred_if.check_credential_exists(sec_tag, cred_type, get_hash = get_hash)
+    try:
+        present, hash = cred_if.check_credential_exists(sec_tag, cred_type, get_hash = get_hash)
+    except IndexError as e:
+        logger.error(f'...Failed to verify {cred_type_name}: Modem returned malformed response')
+        logger.debug(f'Error details: {e}')
+        logger.error('This may indicate the credential was not properly written to the device.')
+        logger.error('Try re-running the provisioning process.')
+        return False
 
     if not present:
         logger.error(f'...{cred_type_name} not found')
@@ -462,7 +487,13 @@ def verify_credential(cred_if, sec_tag, cred_type, cred = None, get_hash = False
         return False
 
     if verify_hash:
-        expected_hash = cred_if.calculate_expected_hash(cred)
+        try:
+            expected_hash = cred_if.calculate_expected_hash(cred)
+        except (IndexError, Exception) as e:
+            logger.error(f'...Failed to calculate hash for {cred_type_name}')
+            logger.debug(f'Error details: {e}')
+            return False
+            
         if hash != expected_hash:
                 logger.error(f'{cred_type_name} - SHA mismatch:')
                 logger.error(f'\tDevice    : {hash}')

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/gather_attestation_tokens.py

@@ -8,20 +8,21 @@ import sys
 import csv
 import argparse
 from nrfcloud_utils import modem_credentials_parser
-from nrfcloud_utils.cli_helpers import is_linux, is_windows, is_macos
-from nrfcloud_utils.cli_helpers import CMD_TERM_DICT, CMD_TYPE_AUTO, CMD_TYPE_AT, CMD_TYPE_AT_SHELL, CMD_TYPE_TLS_SHELL, parser_add_comms_args
+from nrfcloud_utils.cli_helpers import setup_logging
+from nrfcloud_utils.cli_helpers import CMD_TERM_DICT, CMD_TYPE_AUTO, CMD_TYPE_AT, CMD_TYPE_AT_SHELL, parser_add_comms_args
 from nrfcredstore.comms import Comms
 from nrfcredstore.command_interface import ATCommandInterface
 from datetime import datetime, timezone
-import coloredlogs, logging
+import logging
 
 logger = logging.getLogger(__name__)
 
 IMEI_LEN = 15
 
-def parse_args(in_args):
+def get_parser():
     parser = argparse.ArgumentParser(description="Gather Attestation Tokens",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                                     add_help=False)
     parser_add_comms_args(parser)
     parser.add_argument("--csv", type=str,
                         help="Filepath to attestation token CSV file",
@@ -40,11 +41,13 @@ def parse_args(in_args):
                         choices=['debug', 'info', 'warning', 'error', 'critical'],
                         help='Set the logging level'
     )
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    if args.plain:
-        logging.basicConfig(level=args.log_level.upper())
-    else:
-        coloredlogs.install(level=args.log_level.upper(), fmt='%(levelname)-8s %(message)s')
+    setup_logging(level=args.log_level, use_color=not args.plain)
     return args
 
 def check_if_device_exists_in_csv(csv_filename, uuid, delete_duplicates):

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/modem_credentials_parser.py

@@ -6,15 +6,14 @@
 
 import argparse
 import sys
-from os import path
-from os import makedirs
 from cbor2 import loads
 import base64
 import hashlib
-import coloredlogs, logging
+import logging
+import textwrap
 from cryptography.hazmat.primitives import serialization
 from cryptography import x509
-from nrfcloud_utils.cli_helpers import write_file
+from nrfcloud_utils.cli_helpers import write_file, setup_logging
 
 logger = logging.getLogger(__name__)
 
@@ -43,8 +42,9 @@ header_key_type_dict = {
     -5: 'nordic_base_rd_key'
 }
 
-def parse_args(in_args):
-    parser = argparse.ArgumentParser(description="Modem Credentials Parser")
+def get_parser():
+    parser = argparse.ArgumentParser(description="Modem Credentials Parser",
+                                     add_help=False)
     parser.add_argument("-k", "--keygen", type=str, help="base64url string: KEYGEN output", default="")
     parser.add_argument("-a", "--attest", type=str, help="base64url string: ATTESTTOKEN output", default="")
     parser.add_argument("-s", "--save", action='store_true', help="Save PEM file(s): <UUID>_<sec_tag>_<type>.pem")
@@ -58,21 +58,137 @@ def parse_args(in_args):
     parser.add_argument("-P", "--plain",
                         help="bool: Plain output (no colors)",
                         action='store_true', default=False)
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    if args.plain:
-        logging.basicConfig(level=args.log_level.upper())
-    else:
-        coloredlogs.install(level=args.log_level.upper(), fmt='%(levelname)-8s %(message)s')
+    setup_logging(level=args.log_level, use_color=not args.plain)
     return args
 
 def base64_decode(string):
     """
     add padding before decoding.
     """
-    padding = 4 - (len(string) % 4)
+    # Base64url data can omit padding; only add what is required.
+    padding = (-len(string)) % 4
     string = string + ("=" * padding)
     return base64.urlsafe_b64decode(string)
 
+def _decode_tlv_length(data, offset):
+    """Decode DER length and return (value_length, header_length)."""
+    first = data[offset]
+    if first < 0x80:
+        return first, 1
+
+    nbytes = first & 0x7F
+    if nbytes == 0:
+        raise ValueError("Indefinite DER length is not supported")
+
+    value_len = 0
+    for i in range(nbytes):
+        value_len = (value_len << 8) | data[offset + 1 + i]
+    return value_len, 1 + nbytes
+
+def _encode_tlv_length(value_len):
+    """Encode DER length bytes for value_len."""
+    if value_len < 0x80:
+        return bytes([value_len])
+
+    out = []
+    value = value_len
+    while value > 0:
+        out.append(value & 0xFF)
+        value >>= 8
+    out.reverse()
+    return bytes([0x80 | len(out), *out])
+
+def _normalize_ecdsa_csr_der(der_bytes):
+    """
+    Normalize CSR DER that encodes ecdsa-with-SHA256 with NULL params.
+
+    Older modem output may include signatureAlgorithm = SEQUENCE(OID, NULL).
+    For ECDSA-with-SHA* this must be encoded without parameters.
+    """
+    # ecdsa-with-SHA256 OID (1.2.840.10045.4.3.2)
+    ecdsa_sha256_oid_tlv = b"\x06\x08\x2A\x86\x48\xCE\x3D\x04\x03\x02"
+
+    if len(der_bytes) < 8 or der_bytes[0] != 0x30:
+        return None
+
+    try:
+        outer_len, outer_len_hdr = _decode_tlv_length(der_bytes, 1)
+    except (IndexError, ValueError):
+        return None
+
+    outer_start = 1 + outer_len_hdr
+    outer_end = outer_start + outer_len
+    if outer_end != len(der_bytes):
+        return None
+
+    # certificationRequestInfo
+    cri_tag_idx = outer_start
+    if der_bytes[cri_tag_idx] != 0x30:
+        return None
+    try:
+        cri_len, cri_len_hdr = _decode_tlv_length(der_bytes, cri_tag_idx + 1)
+    except (IndexError, ValueError):
+        return None
+    cri_start = cri_tag_idx
+    cri_value_start = cri_tag_idx + 1 + cri_len_hdr
+    cri_end = cri_value_start + cri_len
+
+    # signatureAlgorithm
+    sig_alg_tag_idx = cri_end
+    if sig_alg_tag_idx >= outer_end or der_bytes[sig_alg_tag_idx] != 0x30:
+        return None
+    try:
+        sig_alg_len, sig_alg_len_hdr = _decode_tlv_length(der_bytes, sig_alg_tag_idx + 1)
+    except (IndexError, ValueError):
+        return None
+    sig_alg_value_start = sig_alg_tag_idx + 1 + sig_alg_len_hdr
+    sig_alg_end = sig_alg_value_start + sig_alg_len
+    if sig_alg_end > outer_end:
+        return None
+
+    sig_alg_value = der_bytes[sig_alg_value_start:sig_alg_end]
+    # Only normalize the exact legacy ECDSA+NULL form.
+    if not (sig_alg_value.startswith(ecdsa_sha256_oid_tlv) and sig_alg_value.endswith(b"\x05\x00")):
+        return None
+    if len(sig_alg_value) != len(ecdsa_sha256_oid_tlv) + 2:
+        return None
+
+    # signature BIT STRING (keep as-is)
+    sig_tag_idx = sig_alg_end
+    if sig_tag_idx >= outer_end or der_bytes[sig_tag_idx] != 0x03:
+        return None
+    try:
+        sig_len, sig_len_hdr = _decode_tlv_length(der_bytes, sig_tag_idx + 1)
+    except (IndexError, ValueError):
+        return None
+    sig_value_start = sig_tag_idx + 1 + sig_len_hdr
+    sig_end = sig_value_start + sig_len
+    if sig_end != outer_end:
+        return None
+
+    cri_tlv = der_bytes[cri_start:cri_end]
+    normalized_sig_alg = b"\x30" + _encode_tlv_length(len(ecdsa_sha256_oid_tlv)) + ecdsa_sha256_oid_tlv
+    sig_tlv = der_bytes[sig_tag_idx:sig_end]
+
+    new_outer_value = cri_tlv + normalized_sig_alg + sig_tlv
+    return b"\x30" + _encode_tlv_length(len(new_outer_value)) + new_outer_value
+
+def _csr_der_to_pem(der_bytes):
+    """Convert CSR DER bytes to PEM without changing the original DER payload."""
+    b64 = base64.b64encode(der_bytes).decode("ascii")
+    wrapped = "\n".join(textwrap.wrap(b64, 64))
+    return (
+        "-----BEGIN CERTIFICATE REQUEST-----\n"
+        + wrapped
+        + "\n-----END CERTIFICATE REQUEST-----\n"
+    ).encode("ascii")
+
 def format_uuid(hex_str):
     return '{0}-{1}-{2}-{3}-{4}'.format(hex_str[:8],    hex_str[8:12],
                                         hex_str[12:16], hex_str[16:20],
@@ -178,30 +294,26 @@ def parse_keygen_output(keygen_str):
     body = body_cose[0]
 
     # Decode base64url to binary
-    body_bytes = base64_decode(body)
+    payload_body_bytes = base64_decode(body)
+    body_bytes = payload_body_bytes
 
-    # This can be either a CSR or device public key
     try:
-        # Try to load CSR, if it fails, assume public key
         csr = x509.load_der_x509_csr(body_bytes)
+    except:
+        logger.warning("normalizing CSR")
+        normalized = _normalize_ecdsa_csr_der(body_bytes)
+        logger.warning(f"keygen_str: {keygen_str}, normalized: {base64.urlsafe_b64encode(normalized)}")
+        csr = x509.load_der_x509_csr(normalized)
 
-    except ValueError:
-        # Handle public key only
-        pub_key = serialization.load_der_public_key(body_bytes)
-        pub_key_bytes = pub_key.public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
-
-    else:
-        # CSR loaded, logger.info it
-        csr_pem_bytes = csr.public_bytes(serialization.Encoding.PEM)
-        csr_pem_list = str(csr_pem_bytes.decode()).split('\n')
-        logger.info(csr_pem_bytes.decode().replace('\n', '\\n'))
+    csr_pem_bytes = csr.public_bytes(serialization.Encoding.PEM)
+    logger.info(csr_pem_bytes.decode().replace('\n', '\\n'))
 
-        # Extract public key
-        pub_key_bytes = csr.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
+    # Extract public key
+    pub_key_bytes = csr.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
 
     logger.info("Device public key: {}".format(pub_key_bytes.decode().replace('\n', '\\n')))
 
-    payload_digest = hashlib.sha256(body_bytes).hexdigest()
+    payload_digest = hashlib.sha256(payload_body_bytes).hexdigest()
     logger.info(f"SHA256 Digest: {payload_digest}")
 
     # Get optional cose

nrfcloud_utils-3.2.0/src/nrfcloud_utils/nrf93_onboard.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2026 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import argparse
+import re
+import sys
+import logging
+import requests
+import coloredlogs
+from nrfcredstore.comms import Comms
+from nrfcredstore.command_interface import ATCommandInterface
+
+logger = logging.getLogger(__name__)
+
+_TAG_PATTERN = re.compile(r'^[a-zA-Z0-9_.,@\/:#-]{0,799}$')
+
+def _valid_tag(value):
+    if not _TAG_PATTERN.match(value):
+        raise argparse.ArgumentTypeError(
+            f"Invalid tag {value!r}. Must match /[a-zA-Z0-9_.,@\\/:#-]{{0,799}}/"
+        )
+    return value
+
+DEV_STAGE_DICT = {'dev':     '.dev.',
+                  'prod':    '.',
+                  '':        '.'}
+dev_stage_key = 'prod'
+
+API_URL_START = 'https://api'
+API_URL_END = 'nrfcloud.com/v1/'
+api_url = API_URL_START + DEV_STAGE_DICT[dev_stage_key] + API_URL_END
+
+def get_nrf93m1_uuid(cred_if):
+    """Get or create device UUID for nRF93M1."""
+    result = cred_if.at_command('AT%DEVICEUUID', wait_for_result=False)
+    if not result:
+        logger.error('Failed to send AT%DEVICEUUID command')
+        return None
+
+    # Expect response like: %DEVICEUUID: 988234bd-a066-a101-656e-684d6f5adad6
+    retval, output = cred_if.comms.expect_response("OK", "ERROR", "%DEVICEUUID:")
+    if not retval:
+        logger.error('Failed to get device UUID from nRF93M1')
+        return None
+
+    # Parse UUID from output
+    lines = [line.strip() for line in output.split("\n") if "%DEVICEUUID:" in line]
+    if not lines:
+        logger.error('UUID not found in response')
+        return None
+
+    # Extract UUID (format: "%DEVICEUUID: <uuid>" or "%DEVICEUUID: creating device uuid...")
+    uuid_line = lines[-1]  # Get the last line with UUID
+    if ':' in uuid_line:
+        uuid_str = uuid_line.split(':', 1)[1].strip()
+        # Check if it's not a status message
+        if 'creating' not in uuid_str.lower() and len(uuid_str) > 30:
+            logger.debug(f'Retrieved device UUID: {uuid_str}')
+            return uuid_str
+
+    logger.error('Failed to parse UUID from response')
+    return None
+
+def get_nrf93m1_identity_key(cred_if):
+    """Get or create identity key for nRF93M1."""
+    result = cred_if.at_command('AT%CLOUDACCESSKEY', wait_for_result=False)
+    if not result:
+        logger.error('Failed to send AT%CLOUDACCESSKEY command')
+        return None
+
+    # Expect response like: %CLOUDACCESSKEY: MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE...
+    retval, output = cred_if.comms.expect_response("OK", "ERROR", "%CLOUDACCESSKEY:")
+    if not retval:
+        logger.error('Failed to get identity key from nRF93M1')
+        return None
+
+    # Parse identity key from output
+    lines = [line.strip() for line in output.split("\n") if "%CLOUDACCESSKEY:" in line]
+    if not lines:
+        logger.error('Identity key not found in response')
+        return None
+
+    # Extract identity key (format: "%CLOUDACCESSKEY: <base64_key>")
+    identity_key_line = lines[-1]  # Get the last line with key
+    if ':' in identity_key_line:
+        identity_key_str = identity_key_line.split(':', 1)[1].strip()
+        # Check if it's not a status message
+        if 'creating' not in identity_key_str.lower() and len(identity_key_str) > 50:
+            logger.debug(f'Retrieved device identity key: {identity_key_str}')
+            return identity_key_str
+
+    logger.error('Failed to parse identity key from response')
+    return None
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="nRF93M1 - Onboard Device using Registration token JWT",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        add_help=False
+    )
+    parser.add_argument("--port", type=str, required=True,
+                        help="Serial port for the nRF93M1 device (e.g., /dev/ttyACM0 or COM3)")
+    parser.add_argument("--baudrate", type=int, help="Serial baudrate", default=115200)
+    parser.add_argument("--api-key", type=str, required=True,
+                        help="nRF Cloud API key", default="")
+    parser.add_argument('--log-level', default='info',
+                        choices=['debug', 'info', 'warning', 'error', 'critical'],
+                        help='Set the logging level')
+    parser.add_argument("--stage", type=str,
+                        choices=['prod', 'dev'],
+                        help="For internal (Nordic) use only", default="")
+    parser.add_argument("--tags", type=_valid_tag, nargs="+", default=["nRF93M1-EK"],
+                        metavar="TAG",
+                        help="Tags to assign to the device on nRF Cloud. "
+                             "Each tag must match /[a-zA-Z0-9_.,@\\/:#-]{0,799}/")
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
+    args = parser.parse_args(in_args)
+
+    # Setup logging
+    if hasattr(args, 'log_level'):
+        coloredlogs.install(level=args.log_level.upper(), fmt='%(levelname)-8s %(message)s')
+    else:
+        coloredlogs.install(level='INFO', fmt='%(levelname)-8s %(message)s')
+
+    return args
+
+def set_dev_stage(stage = ''):
+    global api_url
+    global dev_stage_key
+
+    if stage in DEV_STAGE_DICT.keys():
+        dev_stage_key = stage
+        api_url = '{}{}{}'.format(API_URL_START, DEV_STAGE_DICT[dev_stage_key], API_URL_END)
+    else:
+        logger.error('Invalid stage')
+
+    return api_url
+
+def fetch_tenant_id(api_key):
+    hdr = {'Authorization': 'Bearer ' + api_key}
+    req = api_url + "account"
+    response = requests.get(req, headers=hdr)
+    if not response.ok:
+        logger.error(f'Failed to fetch tenant ID: HTTP {response.status_code}')
+        return None
+
+    try:
+        account_info = response.json()
+    except ValueError:
+        logger.error('Failed to parse account response JSON')
+        return None
+
+    tenant_id = account_info.get('team', {}).get('tenantId')
+    if not tenant_id:
+        logger.error('tenantId not found in account response')
+        return None
+
+    return tenant_id
+
+def gen_registration_jwt(cred_if, tenant_id):
+    result = cred_if.at_command(f'AT%REGJWT="{tenant_id}"', wait_for_result=False)
+    if not result:
+        logger.error('Failed to send AT%REGJWT command')
+        return None
+
+    retval, output = cred_if.comms.expect_response("OK", "ERROR", "%REGJWT:")
+    if not retval:
+        logger.error('Failed to get registration JWT from nRF93M1')
+        return None
+
+    lines = [line.strip() for line in output.split("\n") if line.strip().startswith("%REGJWT:")]
+    if not lines:
+        logger.error('Registration JWT not found in response')
+        return None
+
+    jwt_str = lines[-1].split(':', 1)[1].strip()
+    if not jwt_str:
+        logger.error('Registration JWT is empty')
+        return None
+
+    logger.debug('Retrieved registration JWT from device')
+    return jwt_str
+
+def onboard_device(api_key, dev_id, sub_type, tags, fw_types, onboarding_token):
+    hdr = {
+        'Authorization': 'Bearer ' + api_key,
+        'Accept': 'application/json',
+    }
+
+    req = api_url + "devices/" + dev_id
+
+    payload = {
+        'onboardingToken': onboarding_token,
+        'subType': sub_type,
+        'tags': tags,
+        'supportedFirmwareTypes': fw_types,
+    }
+
+    return requests.post(req, json=payload, headers=hdr)
+
+def main(in_args):
+    args = parse_args(in_args)
+
+    if args.stage:
+        set_dev_stage(args.stage)
+
+    logger.info('nRF93M1 - Onboard Device using Registration token JWT')
+    logger.info(f'Connecting to device on {args.port}...')
+
+    # Initialize serial communication
+    try:
+        serial_interface = Comms(
+            port=args.port,
+            baudrate=args.baudrate,
+        )
+    except Exception as e:
+        logger.error(f'Failed to open serial port: {e}')
+        sys.exit(1)
+
+    # Create AT command interface
+    cred_if = ATCommandInterface(serial_interface)
+
+    try:
+        # Verify device is responsive
+        logger.info('Checking device connectivity...')
+        resp = cred_if.at_command('AT', wait_for_result=True)
+        if not resp:
+            logger.error('No response from device. Check connection and try again.')
+            sys.exit(1)
+        logger.info('Device is responsive')
+
+        # Get device UUID
+        logger.info('Retrieving device UUID...')
+        dev_id = get_nrf93m1_uuid(cred_if)
+        if not dev_id:
+            logger.error('[Failed] Device UUID')
+            sys.exit(2)
+        logger.info('[OK] Device UUID')
+
+        # Get identity key
+        logger.info('Retrieving identity key...')
+        identity_key_base64 = get_nrf93m1_identity_key(cred_if)
+        if not identity_key_base64:
+            logger.error('[Failed] Device identity key')
+            sys.exit(3)
+        logger.info('[OK] Device identity key')
+
+        # Based on the stage specified, we query the tenantID from nRF Cloud using the user's API key.
+        logger.info('Retrieving tenant ID from nRF Cloud account...')
+        tenant_id = fetch_tenant_id(args.api_key)
+        if not tenant_id:
+            logger.error('[Failed] Tenant ID')
+            sys.exit(4)
+        logger.info(f'[OK] Tenant ID')
+
+        # Generate the registration JWT on the device using the tenantId
+        logger.info('Generating registration JWT...')
+        registration_jwt = gen_registration_jwt(cred_if, tenant_id)
+        if not registration_jwt:
+            logger.error('[Failed] Registration JWT')
+            sys.exit(5)
+        logger.info('[OK] Registration JWT')
+
+        # Onboard the device
+        logger.info('Onboarding device to nRF Cloud...')
+        sub_type = "nRF93M1"
+        fw_types = ["MODEM"]
+        onboard_response = onboard_device(args.api_key, dev_id, sub_type, args.tags, fw_types, registration_jwt)
+        if not onboard_response.ok:
+            logger.error(f'Failed to onboard device: HTTP {onboard_response.status_code} - {onboard_response.text}')
+            sys.exit(6)
+        logger.info('[OK] Device onboarded successfully')
+
+    except KeyboardInterrupt:
+        logger.warning('Interrupted by user')
+        sys.exit(130)
+    except Exception as e:
+        logger.error(f'Unexpected error: {e}', exc_info=True)
+        sys.exit(99)
+
+def run():
+    main(sys.argv[1:])
+
+
+if __name__ == '__main__':
+    run()

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/nrf_cloud_device_mgmt.py

@@ -182,9 +182,10 @@ class nRFCloudDevice:
 def url_encode(token):
     return urllib.parse.quote_plus(token)
 
-def parse_args(in_args):
+def get_parser():
     parser = argparse.ArgumentParser(description="nRF Cloud Manage FOTA Update Jobs",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                                     add_help=False)
     parser.add_argument("--api-key",
                         help="nRF Cloud API key",
                         type=str, required=True, default="")
@@ -218,7 +219,11 @@ def parse_args(in_args):
     parser.add_argument("--desc",
                         help="The description of the created updated.",
                         type=str, required=False, default="")
+    return parser
 
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
     return args
 

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/nrf_cloud_diap.py

@@ -5,7 +5,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import requests
-import coloredlogs, logging
+import logging
 from nrfcloud_utils import ca_certs
 
 DEV_STAGE_DICT = {'dev':     '.dev.',

{nrfcloud_utils-3.0.12 → nrfcloud_utils-3.2.0}/src/nrfcloud_utils/nrf_cloud_onboard.py

@@ -10,15 +10,12 @@ import requests
 import csv
 import time
 import json
-import requests
 import os
 import io
-import coloredlogs, logging
-from os import path
+import logging
 from os import makedirs
-from ast import literal_eval
 from enum import Enum
-from nrfcloud_utils.cli_helpers import write_file
+from nrfcloud_utils.cli_helpers import write_file, setup_logging
 
 logger = logging.getLogger(__name__)
 
@@ -52,9 +49,10 @@ DEV_LIST_ID_IDX = 0
 DEV_LIST_RES_IDX = 1
 BULK_OP_REQ_ID = "bulkOpsRequestId"
 
-def parse_args(in_args):
+def get_parser():
     parser = argparse.ArgumentParser(description="nRF Cloud Device Onboarding",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                                     add_help=False)
     parser.add_argument("--api-key", type=str, required=True,
                         help="nRF Cloud API key", default="")
     parser.add_argument("--chk", action='store_true', default=False,
@@ -85,11 +83,13 @@ def parse_args(in_args):
     parser.add_argument("-P", "--plain",
                         help="bool: Plain output (no colors)",
                         action='store_true', default=False)
+    return parser
+
+def parse_args(in_args):
+    _p = get_parser()
+    parser = argparse.ArgumentParser(parents=[_p], description=_p.description, formatter_class=_p.formatter_class)
     args = parser.parse_args(in_args)
-    if args.plain:
-        logging.basicConfig(level=args.log_level.upper())
-    else:
-        coloredlogs.install(level=args.log_level.upper(), fmt='%(levelname)-8s %(message)s')
+    setup_logging(level=args.log_level, use_color=not args.plain)
     return args
 
 def set_dev_stage(stage = ''):
@@ -353,7 +353,7 @@ def check_file_path(file):
     if not os.path.exists(path):
         try:
             makedirs(path, exist_ok=True)
-        except OSError as e:
+        except OSError:
             logger.error("Error creating file path: " + path)
             return ''