Move micropython src into /app

micro/bluetooth.py → micro/app/bluetooth.py

@@ -4,9 +4,9 @@
 import network
 import ubluetooth
 import json
-from wifi import connect_wifi, scan_wifi
-from config import get_device_id, add_config
 from machine import Pin
+from app.wifi import connect_wifi, scan_wifi
+from app.config import get_device_id, add_config
 
 DEVICE_DATA = 'DEVICE_DATA'
 REQUEST_NETWORKS = 'REQUEST_NETWORKS'

micro/app/ota/httpclient.py

@@ -0,0 +1,184 @@
+import usocket, os, gc
+class Response:
+
+ def __init__(self, socket, saveToFile=None):
+ self._socket = socket
+ self._saveToFile = saveToFile
+ self._encoding = 'utf-8'
+ if saveToFile is not None:
+ CHUNK_SIZE = 512 # bytes
+ with open(saveToFile, 'w') as outfile:
+ data = self._socket.read(CHUNK_SIZE)
+ while data:
+ outfile.write(data)
+ data = self._socket.read(CHUNK_SIZE)
+ outfile.close()
+
+ self.close()
+
+ def close(self):
+ if self._socket:
+ self._socket.close()
+ self._socket = None
+
+ @property
+ def content(self):
+ if self._saveToFile is not None:
+ raise SystemError('You cannot get the content from the response as you decided to save it in {}'.format(self._saveToFile))
+
+ try:
+ result = self._socket.read()
+ return result
+ finally:
+ self.close()
+
+ @property
+ def text(self):
+ return str(self.content, self._encoding)
+
+ def json(self):
+ try:
+ import ujson
+ result = ujson.load(self._socket)
+ return result
+ finally:
+ self.close()
+
+
+class HttpClient:
+
+ def __init__(self, headers={}):
+ self._headers = headers
+
+ def is_chunked_data(data):
+ return getattr(data, "__iter__", None) and not getattr(data, "__len__", None)
+
+ def request(self, method, url, data=None, json=None, file=None, custom=None, saveToFile=None, headers={}, stream=None):
+ chunked = data and self.is_chunked_data(data)
+ redirect = None #redirection url, None means no redirection
+ def _write_headers(sock, _headers):
+ for k in _headers:
+ sock.write(b'{}: {}\r\n'.format(k, _headers[k]))
+
+ try:
+ proto, dummy, host, path = url.split('/', 3)
+ except ValueError:
+ proto, dummy, host = url.split('/', 2)
+ path = ''
+ if proto == 'http:':
+ port = 80
+ elif proto == 'https:':
+ import ussl
+ port = 443
+ else:
+ raise ValueError('Unsupported protocol: ' + proto)
+
+ if ':' in host:
+ host, port = host.split(':', 1)
+ port = int(port)
+
+ ai = usocket.getaddrinfo(host, port, 0, usocket.SOCK_STREAM)
+ if len(ai) < 1:
+ raise ValueError('You are not connected to the internet...')
+ ai = ai[0]
+
+ s = usocket.socket(ai[0], ai[1], ai[2])
+ try:
+ s.connect(ai[-1])
+ if proto == 'https:':
+ gc.collect()
+ s = ussl.wrap_socket(s, server_hostname=host)
+ s.write(b'%s /%s HTTP/1.0\r\n' % (method, path))
+ if not 'Host' in headers:
+ s.write(b'Host: %s\r\n' % host)
+ # Iterate over keys to avoid tuple alloc
+ _write_headers(s, self._headers)
+ _write_headers(s, headers)
+
+ # add user agent
+ s.write(b'User-Agent: MicroPython Client\r\n')
+ if json is not None:
+ assert data is None
+ import ujson
+ data = ujson.dumps(json)
+ s.write(b'Content-Type: application/json\r\n')
+
+ if data:
+ if chunked:
+ s.write(b"Transfer-Encoding: chunked\r\n")
+ else:
+ s.write(b"Content-Length: %d\r\n" % len(data))
+ s.write(b"\r\n")
+ if data:
+ if chunked:
+ for chunk in data:
+ s.write(b"%x\r\n" % len(chunk))
+ s.write(chunk)
+ s.write(b"\r\n")
+ s.write("0\r\n\r\n")
+ else:
+ s.write(data)
+ elif file:
+ s.write(b'Content-Length: %d\r\n' % os.stat(file)[6])
+ s.write(b'\r\n')
+ with open(file, 'r') as file_object:
+ for line in file_object:
+ s.write(line + '\n')
+ elif custom:
+ custom(s)
+ else:
+ s.write(b'\r\n')
+
+ l = s.readline()
+ #print('l: ', l)
+ l = l.split(None, 2)
+ status = int(l[1])
+ reason = ''
+ if len(l) > 2:
+ reason = l[2].rstrip()
+ while True:
+ l = s.readline()
+ if not l or l == b'\r\n':
+ break
+ #print('l: ', l)
+ if l.startswith(b'Transfer-Encoding:'):
+ if b'chunked' in l:
+ raise ValueError('Unsupported ' + l)
+ elif l.startswith(b'Location:') and not 200 <= status <= 299:
+ if status in [301, 302, 303, 307, 308]:
+ redirect = l[10:-2].decode()
+ else:
+ raise NotImplementedError("Redirect {} not yet supported".format(status))
+ except OSError:
+ s.close()
+ raise
+
+ if redirect:
+ s.close()
+ if status in [301, 302, 303]:
+ return self.request('GET', url=redirect)
+ else:
+ return self.request(method, redirect)
+ else:
+ resp = Response(s,saveToFile)
+ resp.status_code = status
+ resp.reason = reason
+ return resp
+
+ def head(self, url, **kw):
+ return self.request('HEAD', url, **kw)
+
+ def get(self, url, **kw):
+ return self.request('GET', url, **kw)
+
+ def post(self, url, **kw):
+ return self.request('POST', url, **kw)
+
+ def put(self, url, **kw):
+ return self.request('PUT', url, **kw)
+
+ def patch(self, url, **kw):
+ return self.request('PATCH', url, **kw)
+
+ def delete(self, url, **kw):
+ return self.request('DELETE', url, **kw)