Files added

# This file is executed on every boot (including wake-boot from deepsleep)

import esp

esp.osdebug(None)

import gc

import webrepl

webrepl.start()

gc.collect()

import cconnect

cconnect.do_connect()

import uurequests

import time

import machine

import network

def getEvents(param):

    led = machine.Pin(2, machine.Pin.OUT)

    sta_if = network.WLAN(network.STA_IF)

    while True:

        if sta_if.isconnected() == True:

            r = uurequests.get("https://script.google.com/macros/s/AKfycbyz55y8cdFmtX31yiOOuPn5SLGdGOuL6KvPOorfZZEmvzUppo0/exec")

            print(r.text)

            print(sta_if.ifconfig())

        else:

            print("No connecttion to router")

        for i in range(15):

            led.on()

            time.sleep(1)

            led.off()

            time.sleep(1)

            print(".")

print("Welcome to calendar eventsssss")

def do_connect():

    import network

    sta_if = network.WLAN(network.STA_IF)

    if not sta_if.isconnected():

        print('connecting to network...')

        sta_if.active(True)

        sta_if.connect('ssids', 'password')

        while not sta_if.isconnected():

            pass

    print('network config:', sta_if.ifconfig())

    import ccalendar

    ccalendar.getEvents("")

import usocket

class Response:

    def __init__(self, f):

        self.raw = f

        self.encoding = "utf-8"

        self._cached = None

    def close(self):

        if self.raw:

            self.raw.close()

            self.raw = None

        self._cached = None

    @property

    def content(self):

        if self._cached is None:

            try:

                self._cached = self.raw.read()

            finally:

                self.raw.close()

                self.raw = None

        return self._cached

    @property

    def text(self):

        return str(self.content, self.encoding)

    def json(self):

        import ujson

        return ujson.loads(self.content)

def request(method, url, data=None, json=None, headers={}, stream=None, parse_headers=True):

    redir_cnt = 1

    while True:

        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)

        ai = ai[0]

        resp_d = None

        if parse_headers is not False:

            resp_d = {}

        s = usocket.socket(ai[0], ai[1], ai[2])

        try:

            s.connect(ai[-1])

            if proto == "https:":

                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

            for k in headers:

                s.write(k)

                s.write(b": ")

                s.write(headers[k])

                s.write(b"\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:

                s.write(b"Content-Length: %d\r\n" % len(data))

            s.write(b"Connection: close\r\n\r\n")

            if data:

                s.write(data)

            l = s.readline()

            #print(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)

                if l.startswith(b"Transfer-Encoding:"):

                    if b"chunked" in l:

                        raise ValueError("Unsupported " + l)

                elif l.startswith(b"Location:") and 300 <= status <= 399:

                    if not redir_cnt:

                        raise ValueError("Too many redirects")

                    redir_cnt -= 1

                    url = l[9:].decode().strip()

                    #print("redir to:", url)

                    status = 300

                    break

                if parse_headers is False:

                    pass

                elif parse_headers is True:

                    l = l.decode()

                    k, v = l.split(":", 1)

                    resp_d[k] = v.strip()

                else:

                    parse_headers(l, resp_d)

        except OSError:

            s.close()

            raise

        if status != 300:

            break

    resp = Response(s)

    resp.status_code = status

    resp.reason = reason

    if resp_d is not None:

        resp.headers = resp_d

    return resp

def head(url, **kw):

    return request("HEAD", url, **kw)

def get(url, **kw):

    return request("GET", url, **kw)

def post(url, **kw):

    return request("POST", url, **kw)

def put(url, **kw):

    return request("PUT", url, **kw)

def patch(url, **kw):

    return request("PATCH", url, **kw)

def delete(url, **kw):

    return request("DELETE", url, **kw)