micrOSDevToolKit 2.8.6__py3-none-any.whl → 2.9.0__py3-none-any.whl

micrOS/source/urequests.py

@@ -5,102 +5,73 @@ except ImportError:
     from ssl import wrap_socket     # From micropython 1.23...
 from json import loads, dumps
 from Debug import errlog_add
+import uasyncio as asyncio
 
 
 ADDR_CACHE = {}
 
+#############################################
+#  micropython request - helper functions   #
+#############################################
 
-def request(method, url, data=None, json=None, headers=None, sock_size=256, jsonify=False):
+
+def _host_to_addr(host, port, force=False):
     """
-    Micropython syncronous HTTP request function for REST API handling
-    :param method: GET/POST
-    :param url: URL for REST API
-    :param data: string body (handle bare string as data for POST method)
-    :param json: json body (handle json as data for POST method)
-    :param headers: define headers
-    :param sock_size: socket buffer size (chuck size), default 256 byte (micropython defualt)
-    :param jsonify: convert response body to json
+    Resolve host name to IP address
+    and cache host address to avoid slow getaddrinfo
     """
+    addr = ADDR_CACHE.get(host, None)
+    if addr is None or force:
+        addr = getaddrinfo(host, port)[0][-1]
+        ADDR_CACHE[host] = addr
+    return addr
 
-    #############################################
-    # micropython request - internal functions  #
-    #############################################
-    def _chunked(_body):
-        decoded = bytearray()
-        while _body:
-            # Find the end of the chunk size line
-            line_end = _body.find(b"\r\n")
-            if line_end < 0:
-                break
 
-            # Extract the chunk size and convert to int
-            chunk_size_str = _body[:line_end]
-            try:
-                chunk_size = int(chunk_size_str, 16)
-            except ValueError as e:
-                chunk_size = 0
+def _chunked(_body):
+    decoded = bytearray()
+    while _body:
+        # Find the end of the chunk size line
+        line_end = _body.find(b"\r\n")
+        if line_end < 0:
+            break
 
-            # Check chunk size
-            if chunk_size == 0:
-                break
+        # Extract the chunk size and convert to int
+        chunk_size_str = _body[:line_end]
+        try:
+            chunk_size = int(chunk_size_str, 16)
+        except ValueError as e:
+            chunk_size = 0
 
-            # Add the chunk data to the decoded data
-            chunk_data = _body[line_end + 2: line_end + 2 + chunk_size]
-            decoded += chunk_data
+        # Check chunk size
+        if chunk_size == 0:
+            break
 
-            # Move to the next chunk
-            _body = _body[line_end + 4 + chunk_size:]
+        # Add the chunk data to the decoded data
+        chunk_data = _body[line_end + 2: line_end + 2 + chunk_size]
+        decoded += chunk_data
 
-            # Check for end of message marker again
-            if not _body.startswith(b"\r\n"):
-                break
-        return decoded
-
-    def _host_to_addr(force=False):
-        """
-        Cache host address to avoid getaddrinfo (slow)
-        """
-        nonlocal host, port
-        _addr = ADDR_CACHE.get(host, None)
-        if _addr is None or force:
-            _addr = getaddrinfo(host, port)[0][-1]
-            ADDR_CACHE[host] = _addr
-        return _addr
-
-    #############################################
-    #           micropython request main        #
-    #############################################
-
-    # [_parse_url] Parse HTTP(S) URL
-    headers = {} if headers is None else headers
+        # Move to the next chunk
+        _body = _body[line_end + 4 + chunk_size:]
+
+        # Check for end of message marker again
+        if not _body.startswith(b"\r\n"):
+            break
+    return decoded
+
+
+def _parse_url(url):
     # PARSE URL -> proto (http/https), host, path + SET PORT
     proto, _, host, path = url.split('/', 3)
-
     port = 443 if proto == 'https:' else 80
     # PARSE HOST - handle direct port number as input after :
     if ':' in host:
         host, port = host.split(':', 1)
         port = int(port)
+    return host, port, proto, path
 
-    # [1] CONNECT - create socket object
-    sock = socket()
-    sock.settimeout(3)
-    # [1.1] CONNECT - resolve IP by host
-    addr = _host_to_addr()
-    # [1.2] CONNECT - if https handle ssl
-    try:
-        sock.connect(addr)
-    except Exception:
-        # Refresh host address & reconnect
-        addr = _host_to_addr(force=True)
-        sock.connect(addr)
-
-    try:
-        sock = wrap_socket(sock) if proto == 'https:' else sock
-    except Exception as e:
-        errlog_add(f'[ERR] https soc-wrap: {e}')
 
-    # [_build_request] Create request (body, headers)
+def _build_request(host, method, path, headers, data=None, json=None):
+    # Create request (body, headers)
     body = None
     if data:
         body = data.encode('utf-8')
@@ -119,6 +90,60 @@ def request(method, url, data=None, json=None, headers=None, sock_size=256, json
     http_request = '\r\n'.join(lines) + '\r\n\r\n'
     if body:
         http_request += body.decode('utf-8')
+    return http_request
+
+
+def _parse_response(response):
+    # Parse response - get body
+    headers, body = response.split(b'\r\n\r\n', 1)
+    status_code = int(headers.split(b' ')[1])
+    headers = dict(h.split(b': ') for h in headers.split(b'\r\n')[1:])
+    if headers.get(b'Transfer-Encoding', b'') == b'chunked':
+        body = _chunked(body)
+    else:
+        body = body.decode('utf-8')
+    return status_code, body
+
+
+#############################################
+#          micropython HTTP request         #
+#############################################
+
+def request(method, url, data=None, json=None, headers=None, sock_size=256, jsonify=False):
+    """
+    Micropython syncronous HTTP request function for REST API handling
+    :param method: GET/POST
+    :param url: URL for REST API
+    :param data: string body (handle bare string as data for POST method)
+    :param json: json body (handle json as data for POST method)
+    :param headers: define headers
+    :param sock_size: socket buffer size (chuck size), default 256 byte (micropython defualt)
+    :param jsonify: convert response body to json
+    """
+
+    # Parse HTTP(S) URL and headers
+    headers = {} if headers is None else headers
+    host, port, proto, path = _parse_url(url)
+    addr = _host_to_addr(host, port)
+
+    # [1] CONNECT - create socket object
+    sock = socket()
+    sock.settimeout(3)
+    # [1.1] CONNECT - if https handle ssl
+    try:
+        sock.connect(addr)
+    except Exception:
+        # Refresh host address & reconnect
+        addr = _host_to_addr(host, port, force=True)
+        sock.connect(addr)
+
+    try:
+        sock = wrap_socket(sock) if proto == 'https:' else sock
+    except Exception as e:
+        errlog_add(f'[ERR] https soc-wrap: {e}')
+
+    # [1] BUILD REQUEST
+    http_request = _build_request(host, method, path, headers, data, json)
 
     # [2] SEND REQUEST
     if proto == 'https:':
@@ -138,23 +163,68 @@ def request(method, url, data=None, json=None, headers=None, sock_size=256, json
         response += data
     sock.close()
 
-    # [_parse_response] Parse response - get body
-    headers, body = response.split(b'\r\n\r\n', 1)
-    status_code = int(headers.split(b' ')[1])
-    headers = dict(h.split(b': ') for h in headers.split(b'\r\n')[1:])
-    if headers.get(b'Transfer-Encoding', b'') == b'chunked':
-        body = _chunked(body)
-    else:
-        body = body.decode('utf-8')
+    # [4] PARSE RESPONSE
+    status_code, body = _parse_response(response)
 
-    # Return status code, headers and body (text or jsons)
-    return status_code, loads(body) if jsonify else body
+    # Return status code, body (text or json)
+    return status_code, loads(body) if jsonify and status_code == 200 else body
 
 
 #############################################
-#      Implement http get/post functions    #
+#       async micropython HTTP request      #
 #############################################
 
+async def arequest(method, url, data=None, json=None, headers=None, sock_size=256, jsonify=False):
+    """
+    Micropython asynchronous HTTP request function for REST API handling
+    :param method: GET/POST
+    :param url: URL for REST API
+    :param data: string body (handle bare string as data for POST method)
+    :param json: json body (handle json as data for POST method)
+    :param headers: define headers
+    :param sock_size: socket buffer size (chunk size), default 256 bytes (micropython default)
+    :param jsonify: convert response body to json
+    """
+    headers = {} if headers is None else headers
+    host, port, proto, path = _parse_url(url)
+    addr = _host_to_addr(host, port)
+    reader, writer = None, None
+
+    try:
+        # Open a connection
+        reader, writer = await asyncio.open_connection(addr[0], port, ssl=(proto == 'https:'))
+
+        # Build the HTTP request
+        http_request = _build_request(host, method, path, headers, data, json)
+
+        # Send the request
+        writer.write(http_request.encode('utf-8'))
+        await writer.drain()
+
+        # Receive response
+        response = b''
+        while True:
+            chunk = await reader.read(sock_size)
+            if not chunk:
+                break
+            response += chunk
+
+        # Parse response
+        status_code, body = _parse_response(response)
+    except Exception as e:
+        status_code = 500
+        body = f'[ERR] arequest failed: {e}'
+        errlog_add(body)
+    finally:
+        if writer:
+            writer.close()
+            await writer.wait_closed()
+    return status_code, loads(body) if jsonify and status_code == 200 else body
+
+
+#############################################
+#      Implement http get/post functions    #
+#############################################
 
 def get(url, headers={}, sock_size=256, jsonify=False):
     """
@@ -172,6 +242,22 @@ def post(url, data=None, json=None, headers={}, sock_size=256, jsonify=False):
     return request('POST', url, data=data, json=json, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
+async def aget(url, headers={}, sock_size=256, jsonify=False):
+    """
+    GENERIC ASYNC HTTP GET FUNCTION
+    """
+    return await arequest('GET', url, headers=headers, sock_size=sock_size, jsonify=jsonify)
+
+
+async def apost(url, data=None, json=None, headers={}, sock_size=256, jsonify=False):
+    """
+    GENERIC ASYNC HTTP POST FUNCTION
+    :param data: string body (handle bare string as data for POST method)
+    :param json: json body (handle json as data for POST method)
+    """
+    return await arequest('POST', url, data=data, json=json, headers=headers, sock_size=sock_size, jsonify=jsonify)
+
+
 def host_cache():
     """
     Return address cache

{micrOSDevToolKit-2.8.6.dist-info → micrOSDevToolKit-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: micrOSDevToolKit
-Version: 2.8.6
+Version: 2.9.0
 Summary: Development and deployment environment for micrOS, the diy micropython automation OS (IoT)
 Home-page: https://github.com/BxNxM/micrOS
 Author: Marcell Ban
@@ -28,7 +28,7 @@ Requires-Dist: soundfile
 
 # ![LOGO](./media/logo_mini.png?raw=true) micrOS
 
-> **"Simple, yet increadbly useful."**
+> **"The mini yet powerful operating system for DIY projects."**
 
 ![telnet](https://img.shields.io/badge/wifi-telnet-blue) ![esp32S2](https://img.shields.io/badge/esp32-S2-olive) ![tinypico](https://img.shields.io/badge/esp32-tinypico-olive) ![esp32S3](https://img.shields.io/badge/esp32-S3-olive) ![esp32S3](https://img.shields.io/badge/esp32-S3_RAM-olive) ![PYQT](https://img.shields.io/badge/esp32-PYQT-olive) ![raspberry-pico-w](https://img.shields.io/badge/raspberry-pico_W-critical) ![espCAM-esp-s](https://img.shields.io/badge/esp32-CAM_OV2640-olive) ![esp32-c3](https://img.shields.io/badge/esp32-C3_RISCV-olive) ![OTA](https://img.shields.io/badge/ota-update-blue) ![GPIO](https://img.shields.io/badge/gpio-i2c-success) ![clock](https://img.shields.io/badge/rtc-ntp-success) ![async](https://img.shields.io/badge/async-task_manager-success) ![irq](https://img.shields.io/badge/hardware-IRQs-success) ![socket](https://img.shields.io/badge/socket-STA_or_AP-blue) ![cron](https://img.shields.io/badge/scheduling-cron-success) ![stable](https://img.shields.io/badge/stabile-master_HEAD-success) ![stable](https://img.shields.io/badge/micropython-OS-gold)<br/>