Add frozen stubs for v1.26.1

Signed-off-by: Jos Verlinde <Jos_Verlinde@hotmail.com>

Author: Josverl

stubs/micropython-v1_26_1-frozen/alif/GENERIC/_boot.py

@@ -0,0 +1,23 @@
+import sys, os, alif
+
+
+bdev = alif.Flash()
+if hasattr(alif, "usb_msc"):
+    try:
+        # This may fail on VfsFat construction, or mount.
+        os.mount(os.VfsFat(bdev), "/flash")
+    except:
+        os.VfsFat.mkfs(bdev)
+        os.mount(os.VfsFat(bdev), "/flash")
+else:
+    try:
+        os.mount(os.VfsLfs2(bdev, progsize=256), "/flash")
+    except:
+        os.VfsLfs2.mkfs(bdev, progsize=256)
+        os.mount(os.VfsLfs2(bdev, progsize=256), "/flash")
+
+sys.path.append("/flash")
+sys.path.append("/flash/lib")
+os.chdir("/flash")
+
+del sys, os, alif, bdev

stubs/micropython-v1_26_1-frozen/alif/GENERIC/_boot.pyi

@@ -0,0 +1,3 @@
+from _typeshed import Incomplete
+
+bdev: Incomplete

stubs/micropython-v1_26_1-frozen/alif/GENERIC/dht.py

@@ -0,0 +1,47 @@
+# DHT11/DHT22 driver for MicroPython on ESP8266
+# MIT license; Copyright (c) 2016 Damien P. George
+
+import sys
+import machine
+
+if hasattr(machine, "dht_readinto"):
+    from machine import dht_readinto
+elif sys.platform.startswith("esp"):
+    from esp import dht_readinto
+elif sys.platform == "pyboard":
+    from pyb import dht_readinto
+else:
+    dht_readinto = __import__(sys.platform).dht_readinto
+
+del machine
+
+
+class DHTBase:
+    def __init__(self, pin):
+        self.pin = pin
+        self.buf = bytearray(5)
+
+    def measure(self):
+        buf = self.buf
+        dht_readinto(self.pin, buf)
+        if (buf[0] + buf[1] + buf[2] + buf[3]) & 0xFF != buf[4]:
+            raise Exception("checksum error")
+
+
+class DHT11(DHTBase):
+    def humidity(self):
+        return self.buf[0]
+
+    def temperature(self):
+        return self.buf[2]
+
+
+class DHT22(DHTBase):
+    def humidity(self):
+        return (self.buf[0] << 8 | self.buf[1]) * 0.1
+
+    def temperature(self):
+        t = ((self.buf[2] & 0x7F) << 8 | self.buf[3]) * 0.1
+        if self.buf[2] & 0x80:
+            t = -t
+        return t

stubs/micropython-v1_26_1-frozen/alif/GENERIC/dht.pyi

@@ -0,0 +1,15 @@
+from _typeshed import Incomplete
+
+class DHTBase:
+    pin: Incomplete
+    buf: Incomplete
+    def __init__(self, pin) -> None: ...
+    def measure(self) -> None: ...
+
+class DHT11(DHTBase):
+    def humidity(self): ...
+    def temperature(self): ...
+
+class DHT22(DHTBase):
+    def humidity(self): ...
+    def temperature(self): ...

stubs/micropython-v1_26_1-frozen/alif/GENERIC/mip/__init__.py

@@ -0,0 +1,187 @@
+# MicroPython package installer
+# MIT license; Copyright (c) 2022 Jim Mussared
+
+from micropython import const
+import requests
+import sys
+
+
+_PACKAGE_INDEX = "https://micropython.org/pi/v2"
+_CHUNK_SIZE = 128
+
+allowed_mip_url_prefixes = ("http://", "https://", "github:", "gitlab:")
+
+
+# This implements os.makedirs(os.dirname(path))
+def _ensure_path_exists(path):
+    import os
+
+    split = path.split("/")
+
+    # Handle paths starting with "/".
+    if not split[0]:
+        split.pop(0)
+        split[0] = "/" + split[0]
+
+    prefix = ""
+    for i in range(len(split) - 1):
+        prefix += split[i]
+        try:
+            os.stat(prefix)
+        except:
+            os.mkdir(prefix)
+        prefix += "/"
+
+
+# Copy from src (stream) to dest (function-taking-bytes)
+def _chunk(src, dest):
+    buf = memoryview(bytearray(_CHUNK_SIZE))
+    while True:
+        n = src.readinto(buf)
+        if n == 0:
+            break
+        dest(buf if n == _CHUNK_SIZE else buf[:n])
+
+
+# Check if the specified path exists and matches the hash.
+def _check_exists(path, short_hash):
+    pass
+
+    try:
+        import binascii
+        import hashlib
+
+        with open(path, "rb") as f:
+            hs256 = hashlib.sha256()
+            _chunk(f, hs256.update)
+            existing_hash = str(binascii.hexlify(hs256.digest())[: len(short_hash)], "utf-8")
+            return existing_hash == short_hash
+    except:
+        return False
+
+
+def _rewrite_url(url, branch=None):
+    if not branch:
+        branch = "HEAD"
+    if url.startswith("github:"):
+        url = url[7:].split("/")
+        url = (
+            "https://raw.githubusercontent.com/"
+            + url[0]
+            + "/"
+            + url[1]
+            + "/"
+            + branch
+            + "/"
+            + "/".join(url[2:])
+        )
+    elif url.startswith("gitlab:"):
+        url = url[7:].split("/")
+        url = (
+            "https://gitlab.com/"
+            + url[0]
+            + "/"
+            + url[1]
+            + "/-/raw/"
+            + branch
+            + "/"
+            + "/".join(url[2:])
+        )
+    return url
+
+
+def _download_file(url, dest):
+    response = requests.get(url)
+    try:
+        if response.status_code != 200:
+            print("Error", response.status_code, "requesting", url)
+            return False
+
+        print("Copying:", dest)
+        _ensure_path_exists(dest)
+        with open(dest, "wb") as f:
+            _chunk(response.raw, f.write)
+
+        return True
+    finally:
+        response.close()
+
+
+def _install_json(package_json_url, index, target, version, mpy):
+    response = requests.get(_rewrite_url(package_json_url, version))
+    try:
+        if response.status_code != 200:
+            print("Package not found:", package_json_url)
+            return False
+
+        package_json = response.json()
+    finally:
+        response.close()
+    for target_path, short_hash in package_json.get("hashes", ()):
+        fs_target_path = target + "/" + target_path
+        if _check_exists(fs_target_path, short_hash):
+            print("Exists:", fs_target_path)
+        else:
+            file_url = "{}/file/{}/{}".format(index, short_hash[:2], short_hash)
+            if not _download_file(file_url, fs_target_path):
+                print("File not found: {} {}".format(target_path, short_hash))
+                return False
+    base_url = package_json_url.rpartition("/")[0]
+    for target_path, url in package_json.get("urls", ()):
+        fs_target_path = target + "/" + target_path
+        is_full_url = any(url.startswith(p) for p in allowed_mip_url_prefixes)
+        if base_url and not is_full_url:
+            url = f"{base_url}/{url}"  # Relative URLs
+        if not _download_file(_rewrite_url(url, version), fs_target_path):
+            print("File not found: {} {}".format(target_path, url))
+            return False
+    for dep, dep_version in package_json.get("deps", ()):
+        if not _install_package(dep, index, target, dep_version, mpy):
+            return False
+    return True
+
+
+def _install_package(package, index, target, version, mpy):
+    if any(package.startswith(p) for p in allowed_mip_url_prefixes):
+        if package.endswith(".py") or package.endswith(".mpy"):
+            print("Downloading {} to {}".format(package, target))
+            return _download_file(
+                _rewrite_url(package, version), target + "/" + package.rsplit("/")[-1]
+            )
+        else:
+            if not package.endswith(".json"):
+                if not package.endswith("/"):
+                    package += "/"
+                package += "package.json"
+            print("Installing {} to {}".format(package, target))
+    else:
+        if not version:
+            version = "latest"
+        print("Installing {} ({}) from {} to {}".format(package, version, index, target))
+
+        mpy_version = (
+            sys.implementation._mpy & 0xFF if mpy and hasattr(sys.implementation, "_mpy") else "py"
+        )
+
+        package = "{}/package/{}/{}/{}.json".format(index, mpy_version, package, version)
+
+    return _install_json(package, index, target, version, mpy)
+
+
+def install(package, index=None, target=None, version=None, mpy=True):
+    if not target:
+        for p in sys.path:
+            if not p.startswith("/rom") and p.endswith("/lib"):
+                target = p
+                break
+        else:
+            print("Unable to find lib dir in sys.path")
+            return
+
+    if not index:
+        index = _PACKAGE_INDEX
+
+    if _install_package(package, index.rstrip("/"), target, version, mpy):
+        print("Done")
+    else:
+        print("Package may be partially installed")

stubs/micropython-v1_26_1-frozen/alif/GENERIC/mip/__init__.pyi

@@ -0,0 +1,15 @@
+from _typeshed import Incomplete
+from micropython import const as const
+
+_PACKAGE_INDEX: str
+_CHUNK_SIZE: int
+allowed_mip_url_prefixes: Incomplete
+
+def _ensure_path_exists(path) -> None: ...
+def _chunk(src, dest) -> None: ...
+def _check_exists(path, short_hash): ...
+def _rewrite_url(url, branch=None): ...
+def _download_file(url, dest): ...
+def _install_json(package_json_url, index, target, version, mpy): ...
+def _install_package(package, index, target, version, mpy): ...
+def install(package, index=None, target=None, version=None, mpy: bool = True) -> None: ...

stubs/micropython-v1_26_1-frozen/alif/GENERIC/modules.json

@@ -0,0 +1,64 @@
+{
+    "$schema": "https://raw.githubusercontent.com/Josverl/micropython-stubber/main/data/schema/stubber-v1_4_0.json",
+    "firmware": {
+        "family": "micropython",
+        "port": "alif",
+        "platform": "alif",
+        "machine": "GENERIC",
+        "firmware": "micropython-alif-v1_26_1",
+        "nodename": "micropython",
+        "version": "v1.26.1",
+        "release": "v1.26.1",
+        "sysname": "micropython"
+    },
+    "stubber": {
+        "version": "1.26.3",
+        "stubtype": "frozen"
+    },
+    "modules": [
+        {
+            "file": "_boot.py",
+            "module": "_boot"
+        },
+        {
+            "file": "dht.py",
+            "module": "dht"
+        },
+        {
+            "file": "mip/__init__.py",
+            "module": "__init__"
+        },
+        {
+            "file": "neopixel.py",
+            "module": "neopixel"
+        },
+        {
+            "file": "ntptime.py",
+            "module": "ntptime"
+        },
+        {
+            "file": "onewire.py",
+            "module": "onewire"
+        },
+        {
+            "file": "requests/__init__.py",
+            "module": "__init__"
+        },
+        {
+            "file": "ssl.py",
+            "module": "ssl"
+        },
+        {
+            "file": "urequests.py",
+            "module": "urequests"
+        },
+        {
+            "file": "webrepl.py",
+            "module": "webrepl"
+        },
+        {
+            "file": "webrepl_setup.py",
+            "module": "webrepl_setup"
+        }
+    ]
+}