micropython-stubber 1.23.1__py3-none-any.whl → 1.23.2__py3-none-any.whl

stubber/publish/package.py

@@ -1,146 +1,150 @@
-"""
-prepare a set of stub files for publishing to PyPi
-
-"""
-
-import sys
-from pathlib import Path
-from typing import Dict, Union
-
-from loguru import logger as log
-from packaging.version import parse
-from pysondb import PysonDB
-
-from mpflash.versions import clean_version
-from stubber.publish.defaults import GENERIC, GENERIC_L, default_board
-from stubber.publish.enums import StubSource
-from stubber.publish.stubpackage import StubPackage, StubSources
-from stubber.utils.config import CONFIG
-
-# replace std log handler with a custom one capped on INFO level
-log.remove()
-log.add(sys.stderr, level="INFO", backtrace=True, diagnose=True)
-
-
-def package_name(*, port: str = "", board: str = "", family: str = "micropython", **kwargs) -> str:
-    "generate a package name for the given package type"
-    # # {family}-{port}[-{board}[-{variant}]]-stubs
-    name = f"{family}-{port}-{board}-stubs".lower()
-    name = name.replace("-generic-stubs", "-stubs")
-    # Use explicit generic_ names for the stubs
-    # name = name.replace("-generic_", "-")  # @GENERIC Prefix
-    return name
-
-
-def get_package(
-    db: PysonDB,
-    *,
-    version: str,
-    port: str,
-    board: str = GENERIC_L,
-    family: str = "micropython",
-) -> StubPackage:
-    """Get the package from the database or create a new one if it does not exist."""
-    pkg_name = package_name(port=port, board=board, family=family)
-    version = clean_version(version, drop_v=True)
-    if package_info := get_package_info(
-        db,
-        CONFIG.publish_path,
-        pkg_name=pkg_name,
-        mpy_version=version,
-    ):
-        # create package from the information retrieved from the database
-        return StubPackage(pkg_name, port, board=board, version=version, json_data=package_info)
-
-    log.debug(f"No package found for {pkg_name} in database, creating new package")
-    return create_package(
-        pkg_name,
-        mpy_version=version,
-        port=port,
-        board=board,
-        family=family,
-    )
-
-
-def get_package_info(db: PysonDB, pub_path: Path, *, pkg_name: str, mpy_version: str) -> Union[Dict, None]:
-    """
-    get a package's record from the json db if it can be found
-    matches om the package name and version
-        pkg_name: package name (micropython-esp32-stubs)
-        mpy_version: micropython/firmware version (1.18)
-    """
-    # find in the database
-    recs = db.get_by_query(query=lambda x: x["mpy_version"] == mpy_version and x["name"] == pkg_name)
-    # dict to list
-    recs = [{"id": key, "data": recs[key]} for key in recs]
-    # sort
-    packages = sorted(recs, key=lambda x: parse(x["data"]["pkg_version"]))
-
-    if len(packages) > 0:
-        pkg_from_db = packages[-1]["data"]
-        log.debug(f"Found latest {pkg_name} == {pkg_from_db['pkg_version']}")
-        return pkg_from_db
-    else:
-        return None
-
-
-def create_package(
-    pkg_name: str,
-    mpy_version: str,
-    *,
-    port: str,
-    board: str = "",
-    family: str = "micropython",
-    # pkg_type: str = COMBO_STUBS,
-) -> StubPackage:  # sourcery skip: merge-duplicate-blocks, remove-redundant-if
-    """
-    create and initialize a package with the correct sources
-    """
-    ver_flat = clean_version(mpy_version, flat=True)
-    stubs: StubSources = []
-    # if pkg_type != COMBO_STUBS:
-    #     raise ValueError("Not Supported")
-
-    assert port != "", "port must be specified for combo stubs"
-    stubs = combo_sources(family, port, board, ver_flat)
-    return StubPackage(pkg_name, port=port, board=board, version=mpy_version, stubs=stubs)
-
-
-def combo_sources(family: str, port: str, board: str, ver_flat: str) -> StubSources:
-    """
-    Build a source set for combo stubs
-    """
-    # Use lower case for paths to avoid case sensitive issues
-    port = port.lower()
-    # BOARD in the micropython repo is always uppercase by convention (GENERIC)
-    # but MUST  be used in lowercase in the stubs repo
-    board_l = board.lower() if board else GENERIC_L
-    board_u = board_l.upper()
-    board_l = board_l.replace("generic_", "")  # @GENERIC Prefix
-
-    # StubSource.FIRMWARE,
-    # Path(f"{family}-{ver_flat}-{port}"),
-    # TODO: look for the most specific firmware stub folder that is available ?
-    # is it possible to prefer micropython-nrf-microbit-stubs over micropython-nrf-stubs
-    # that would also require the port - board - variant to be discoverable runtime
-
-    if board_l in GENERIC:
-        merged_path = Path(f"{family}-{ver_flat}-{port}-merged")
-        if not merged_path.exists():
-            board = default_board(port, ver_flat)
-            board_l = board.lower()
-            board_u = board
-            merged_path = Path(f"{family}-{ver_flat}-{port}-{board}-merged")
-    else:
-        merged_path = Path(f"{family}-{ver_flat}-{port}-{board}-merged")
-
-    # BOARD in source frozen path needs to be UPPERCASE
-    frozen_path = Path(f"{family}-{ver_flat}-frozen") / port / board_u.upper()
-    # TODO : Add version to core stubs
-    core_path = Path(f"{family}-core")
-
-    return [
-        (StubSource.MERGED, merged_path),
-        (StubSource.FROZEN, frozen_path),
-        (StubSource.CORE, core_path),
-    ]
+"""
+prepare a set of stub files for publishing to PyPi
+
+"""
+
+import sys
+from pathlib import Path
+from typing import Dict, Union
+
+from mpflash.logger import log
+from packaging.version import parse
+from pysondb import PysonDB
+
+from mpflash.versions import clean_version
+from stubber.publish.defaults import GENERIC, GENERIC_L, default_board
+from stubber.publish.enums import StubSource
+from stubber.publish.stubpackage import StubPackage, StubSources
+from stubber.utils.config import CONFIG
+
+# replace std log handler with a custom one capped on INFO level
+log.remove()
+log.add(sys.stderr, level="INFO", backtrace=True, diagnose=True)
+
+
+def package_name(*, port: str = "", board: str = "", family: str = "micropython", **kwargs) -> str:
+    "generate a package name for the given package type"
+    # # {family}-{port}[-{board}[-{variant}]]-stubs
+    name = f"{family}-{port}-{board}-stubs".lower()
+    name = name.replace("-generic-stubs", "-stubs")
+    # Use explicit generic_ names for the stubs
+    # name = name.replace("-generic_", "-")  # @GENERIC Prefix
+    return name
+
+
+def get_package(
+    db: PysonDB,
+    *,
+    version: str,
+    port: str,
+    board: str = GENERIC_L,
+    family: str = "micropython",
+) -> StubPackage:
+    """Get the package from the database or create a new one if it does not exist."""
+    pkg_name = package_name(port=port, board=board, family=family)
+    version = clean_version(version, drop_v=True)
+    if package_info := get_package_info(
+        db,
+        CONFIG.publish_path,
+        pkg_name=pkg_name,
+        mpy_version=version,
+    ):
+        # create package from the information retrieved from the database
+        return StubPackage(pkg_name, port, board=board, version=version, json_data=package_info)
+
+    log.debug(f"No package found for {pkg_name} in database, creating new package")
+    return create_package(
+        pkg_name,
+        mpy_version=version,
+        port=port,
+        board=board,
+        family=family,
+    )
+
+
+def get_package_info(
+    db: PysonDB, pub_path: Path, *, pkg_name: str, mpy_version: str
+) -> Union[Dict, None]:
+    """
+    get a package's record from the json db if it can be found
+    matches om the package name and version
+        pkg_name: package name (micropython-esp32-stubs)
+        mpy_version: micropython/firmware version (1.18)
+    """
+    # find in the database
+    recs = db.get_by_query(
+        query=lambda x: x["mpy_version"] == mpy_version and x["name"] == pkg_name
+    )
+    # dict to list
+    recs = [{"id": key, "data": recs[key]} for key in recs]
+    # sort
+    packages = sorted(recs, key=lambda x: parse(x["data"]["pkg_version"]))
+
+    if len(packages) > 0:
+        pkg_from_db = packages[-1]["data"]
+        log.debug(f"Found latest {pkg_name} == {pkg_from_db['pkg_version']}")
+        return pkg_from_db
+    else:
+        return None
+
+
+def create_package(
+    pkg_name: str,
+    mpy_version: str,
+    *,
+    port: str,
+    board: str = "",
+    family: str = "micropython",
+    # pkg_type: str = COMBO_STUBS,
+) -> StubPackage:  # sourcery skip: merge-duplicate-blocks, remove-redundant-if
+    """
+    create and initialize a package with the correct sources
+    """
+    ver_flat = clean_version(mpy_version, flat=True)
+    stubs: StubSources = []
+    # if pkg_type != COMBO_STUBS:
+    #     raise ValueError("Not Supported")
+
+    assert port != "", "port must be specified for combo stubs"
+    stubs = combo_sources(family, port, board, ver_flat)
+    return StubPackage(pkg_name, port=port, board=board, version=mpy_version, stubs=stubs)
+
+
+def combo_sources(family: str, port: str, board: str, ver_flat: str) -> StubSources:
+    """
+    Build a source set for combo stubs
+    """
+    # Use lower case for paths to avoid case sensitive issues
+    port = port.lower()
+    # BOARD in the micropython repo is always uppercase by convention (GENERIC)
+    # but MUST  be used in lowercase in the stubs repo
+    board_l = board.lower() if board else GENERIC_L
+    board_u = board_l.upper()
+    board_l = board_l.replace("generic_", "")  # @GENERIC Prefix
+
+    # StubSource.FIRMWARE,
+    # Path(f"{family}-{ver_flat}-{port}"),
+    # TODO: look for the most specific firmware stub folder that is available ?
+    # is it possible to prefer micropython-nrf-microbit-stubs over micropython-nrf-stubs
+    # that would also require the port - board - variant to be discoverable runtime
+
+    if board_l in GENERIC:
+        merged_path = Path(f"{family}-{ver_flat}-{port}-merged")
+        if not merged_path.exists():
+            board = default_board(port, ver_flat)
+            board_l = board.lower()
+            board_u = board
+            merged_path = Path(f"{family}-{ver_flat}-{port}-{board}-merged")
+    else:
+        merged_path = Path(f"{family}-{ver_flat}-{port}-{board}-merged")
+
+    # BOARD in source frozen path needs to be UPPERCASE
+    frozen_path = Path(f"{family}-{ver_flat}-frozen") / port / board_u.upper()
+    # TODO : Add version to core stubs
+    core_path = Path(f"{family}-core")
+
+    return [
+        (StubSource.MERGED, merged_path),
+        (StubSource.FROZEN, frozen_path),
+        (StubSource.CORE, core_path),
+    ]

stubber/publish/pathnames.py

@@ -1,51 +1,51 @@
-"""
-Helper functions to deal with path names and filenames for the folders in the stubs repo
-
-"""
-
-from pathlib import Path
-from typing import Dict, Optional
-
-from loguru import logger as log
-
-from mpflash.versions import V_PREVIEW, clean_version
-from stubber.publish.defaults import default_board
-from stubber.publish.package import GENERIC
-from stubber.utils.config import CONFIG
-
-
-## Helper functions
-def get_base(candidate: Dict[str, str], version: Optional[str] = None):
-    if version:
-        version = clean_version(version, flat=True)
-    else:
-        version = clean_version(candidate["version"], flat=True)
-    base = f"{candidate['family']}-{version}"
-    return base.lower()
-
-
-def board_folder_name(fw: Dict, *, version: Optional[str] = None) -> str:
-    """Return the name of the firmware folder. Can be in AnyCase."""
-    base = get_base(fw, version=version)
-    if fw["board"] in GENERIC:
-        board = default_board(fw["port"], fw["version"])
-    else:
-        board = fw["board"]
-    folder_name = f"{base}-{fw['port']}-{board}" if board else f"{base}-{fw['port']}"
-    # do NOT force name to lowercase
-    # remove GENERIC Prefix
-    # folder_name = folder_name.replace("-generic_", "-").replace("-GENERIC_", "-")
-    return folder_name
-
-
-def get_board_path(candidate: Dict) -> Path:
-    board_path = CONFIG.stub_path / board_folder_name(candidate)
-    if V_PREVIEW in candidate["version"] and not board_path.exists():
-        log.debug(f"no MCU stubs found for {candidate['version']}, trying stable")
-        board_path = CONFIG.stub_path / board_folder_name(candidate, version=CONFIG.stable_version)
-
-    return board_path
-
-
-def get_merged_path(fw: Dict) -> Path:
-    return CONFIG.stub_path / (board_folder_name(fw) + "-merged")
+"""
+Helper functions to deal with path names and filenames for the folders in the stubs repo
+
+"""
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from mpflash.logger import log
+
+from mpflash.versions import V_PREVIEW, clean_version
+from stubber.publish.defaults import default_board
+from stubber.publish.package import GENERIC
+from stubber.utils.config import CONFIG
+
+
+## Helper functions
+def get_base(candidate: Dict[str, str], version: Optional[str] = None):
+    if version:
+        version = clean_version(version, flat=True)
+    else:
+        version = clean_version(candidate["version"], flat=True)
+    base = f"{candidate['family']}-{version}"
+    return base.lower()
+
+
+def board_folder_name(fw: Dict, *, version: Optional[str] = None) -> str:
+    """Return the name of the firmware folder. Can be in AnyCase."""
+    base = get_base(fw, version=version)
+    if fw["board"] in GENERIC:
+        board = default_board(fw["port"], fw["version"])
+    else:
+        board = fw["board"]
+    folder_name = f"{base}-{fw['port']}-{board}" if board else f"{base}-{fw['port']}"
+    # do NOT force name to lowercase
+    # remove GENERIC Prefix
+    # folder_name = folder_name.replace("-generic_", "-").replace("-GENERIC_", "-")
+    return folder_name
+
+
+def get_board_path(candidate: Dict) -> Path:
+    board_path = CONFIG.stub_path / board_folder_name(candidate)
+    if V_PREVIEW in candidate["version"] and not board_path.exists():
+        log.debug(f"no MCU stubs found for {candidate['version']}, trying stable")
+        board_path = CONFIG.stub_path / board_folder_name(candidate, version=CONFIG.stable_version)
+
+    return board_path
+
+
+def get_merged_path(fw: Dict) -> Path:
+    return CONFIG.stub_path / (board_folder_name(fw) + "-merged")

stubber/publish/publish.py

@@ -1,120 +1,120 @@
-"""
-prepare a set of stub files for publishing to PyPi
-
-!!Note: anything excluded in .gitignore is not packaged by poetry
-"""
-
-from typing import Any, Dict, List, Optional, Union
-
-from loguru import logger as log
-
-from mpflash.versions import V_PREVIEW
-from stubber.publish.candidates import board_candidates, filter_list
-from stubber.publish.database import get_database
-from stubber.publish.defaults import GENERIC_U
-from stubber.publish.package import get_package
-from stubber.utils.config import CONFIG
-
-
-def build_multiple(
-    family: str = "micropython",
-    versions: Optional[List[str]] = None,
-    ports: Optional[List[str]] = None,
-    boards: Optional[List[str]] = None,
-    production: bool = False,
-    clean: bool = False,
-    force: bool = False,
-) -> List[Dict[str, Any]]:  # sourcery skip: default-mutable-arg
-    """
-    Build a bunch of stub packages
-    """
-    # default parameter values
-    versions = versions or [V_PREVIEW]
-    ports = ports or ["all"]
-    boards = boards or [GENERIC_U]
-
-    db = get_database(CONFIG.publish_path, production=production)
-    results: List[Dict[str, Any]] = []
-    worklist = build_worklist(family, versions, ports, boards)
-    if len(worklist) == 0:
-        log.error("Could not find any packages that can be build.")
-        return results
-    log.info(f"checking {len(worklist)} possible board candidates")
-
-    for todo in worklist:
-        if package := get_package(db, **todo):
-            package.build_distribution(force=force, production=production)
-            results.append(package.status)
-        else:
-            log.error(f"Failed to create package for {todo}")
-    return results
-
-
-def publish_multiple(
-    family: str = "micropython",
-    versions: Optional[List[str]] = None,
-    ports: Optional[List[str]] = None,
-    boards: Optional[List[str]] = None,
-    production: bool = False,
-    clean: bool = False,
-    build: bool = False,
-    force: bool = False,
-    dry_run: bool = False,
-) -> List[Dict[str, Any]]:  # sourcery skip: default-mutable-arg
-    """
-    Publish a bunch of stub packages
-    """
-    # default parameter values
-    versions = versions or [V_PREVIEW]
-    ports = ports or ["all"]
-    boards = boards or [GENERIC_U]
-
-    db = get_database(CONFIG.publish_path, production=production)
-    results = []
-    worklist = build_worklist(family, versions, ports, boards)
-
-    if len(worklist) == 0:
-        log.error("Could not find any packages than can be published.")
-        return results
-
-    for todo in worklist:
-        if package := get_package(db, **todo):
-            package.publish_distribution_ifchanged(
-                db=db,
-                clean=clean,
-                force=force,
-                build=build,
-                production=production,
-                dry_run=dry_run,
-            )
-            results.append(package.status)
-        else:
-            log.error(f"Failed to create package for {todo}")
-    return results
-
-
-def build_worklist(
-    family: str,
-    versions: Union[List[str], str],
-    ports: Union[List[str], str],
-    boards: Union[List[str], str],
-):
-    """Build a worklist of packages to build or publish, and filter to only the requested ports and boards"""
-    if isinstance(versions, str):
-        versions = [versions]
-    if isinstance(ports, str):
-        ports = [ports]
-    if isinstance(boards, str):
-        boards = [boards]
-    if family != "micropython":
-        return []
-    # get all the candidates
-    worklist = list(board_candidates(family=family, versions=versions))
-    worklist = filter_list(worklist, ports, boards)
-
-    for b in boards:
-        if b == "auto":
-            continue
-        if not any(i for i in worklist if i["board"].lower() == b.lower()):
-            log.warning(f"Could not find any package candidate for board {b}")
-    return worklist
+"""
+prepare a set of stub files for publishing to PyPi
+
+!!Note: anything excluded in .gitignore is not packaged by poetry
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+from mpflash.logger import log
+
+from mpflash.versions import V_PREVIEW
+from stubber.publish.candidates import board_candidates, filter_list
+from stubber.publish.database import get_database
+from stubber.publish.defaults import GENERIC_U
+from stubber.publish.package import get_package
+from stubber.utils.config import CONFIG
+
+
+def build_multiple(
+    family: str = "micropython",
+    versions: Optional[List[str]] = None,
+    ports: Optional[List[str]] = None,
+    boards: Optional[List[str]] = None,
+    production: bool = False,
+    clean: bool = False,
+    force: bool = False,
+) -> List[Dict[str, Any]]:  # sourcery skip: default-mutable-arg
+    """
+    Build a bunch of stub packages
+    """
+    # default parameter values
+    versions = versions or [V_PREVIEW]
+    ports = ports or ["all"]
+    boards = boards or [GENERIC_U]
+
+    db = get_database(CONFIG.publish_path, production=production)
+    results: List[Dict[str, Any]] = []
+    worklist = build_worklist(family, versions, ports, boards)
+    if len(worklist) == 0:
+        log.error("Could not find any packages that can be build.")
+        return results
+    log.info(f"checking {len(worklist)} possible board candidates")
+
+    for todo in worklist:
+        if package := get_package(db, **todo):
+            package.build_distribution(force=force, production=production)
+            results.append(package.status)
+        else:
+            log.error(f"Failed to create package for {todo}")
+    return results
+
+
+def publish_multiple(
+    family: str = "micropython",
+    versions: Optional[List[str]] = None,
+    ports: Optional[List[str]] = None,
+    boards: Optional[List[str]] = None,
+    production: bool = False,
+    clean: bool = False,
+    build: bool = False,
+    force: bool = False,
+    dry_run: bool = False,
+) -> List[Dict[str, Any]]:  # sourcery skip: default-mutable-arg
+    """
+    Publish a bunch of stub packages
+    """
+    # default parameter values
+    versions = versions or [V_PREVIEW]
+    ports = ports or ["all"]
+    boards = boards or [GENERIC_U]
+
+    db = get_database(CONFIG.publish_path, production=production)
+    results = []
+    worklist = build_worklist(family, versions, ports, boards)
+
+    if len(worklist) == 0:
+        log.error("Could not find any packages than can be published.")
+        return results
+
+    for todo in worklist:
+        if package := get_package(db, **todo):
+            package.publish_distribution_ifchanged(
+                db=db,
+                clean=clean,
+                force=force,
+                build=build,
+                production=production,
+                dry_run=dry_run,
+            )
+            results.append(package.status)
+        else:
+            log.error(f"Failed to create package for {todo}")
+    return results
+
+
+def build_worklist(
+    family: str,
+    versions: Union[List[str], str],
+    ports: Union[List[str], str],
+    boards: Union[List[str], str],
+):
+    """Build a worklist of packages to build or publish, and filter to only the requested ports and boards"""
+    if isinstance(versions, str):
+        versions = [versions]
+    if isinstance(ports, str):
+        ports = [ports]
+    if isinstance(boards, str):
+        boards = [boards]
+    if family != "micropython":
+        return []
+    # get all the candidates
+    worklist = list(board_candidates(family=family, versions=versions))
+    worklist = filter_list(worklist, ports, boards)
+
+    for b in boards:
+        if b == "auto":
+            continue
+        if not any(i for i in worklist if i["board"].lower() == b.lower()):
+            log.warning(f"Could not find any package candidate for board {b}")
+    return worklist