Exemple #1
0
def parse_request(r):
    request = ure.compile("[\r\n]").split(r)[0]
    urllist = ure.compile('\s').split(request)

    if len(urllist) > 1:
        url = urllist[1]
    else:
        url = '/test'

    cmdlist = url.split("/")

    controller = 'test'
    state = 0
    delay = 0

    if len(cmdlist) == 4:
        [n, controller, state, delay] = cmdlist

    if len(cmdlist) == 3:
        [n, controller, state] = cmdlist

    if len(cmdlist) == 2:
        [n, controller] = cmdlist

    return [controller, state, delay]
Exemple #2
0
    def get_player_id(self, player_name):
        """
        Retrieve the player's ID as defined by LMS. Most likely this is the
        player's MAC address.
        """
        player_count = 0
        player_id = None

        # Retrieve player count.
        player_count = int(self.sb_query('player count'))

        # Retrieve the complete players information.
        players = ure.compile(r' playerindex%3A[0-9]+ ').split(
            self.sb_command(self.sock_queries, 'players 0 {}', player_count))

        # The first item will be the command we just sent.
        players.pop(0)

        # Prepare lookup expression.
        player_name_regex = ure.compile('name%s%s ' %
                                        (r'%3A', urlencode.quote(player_name)))

        for player in players:
            if player_name_regex.search(player):
                player_id = urlencode.unquote(
                    ure.match(r'playerid%3A([^ ]+) ', player).group(1))
                break

        return player_id
def create_server(config):
    light_controller = controller.create_light_controller(
        config['light-controller'])

    router = middleware.create_router([
        ('GET', '/v1/light/ping',
         routes.create_ping_handler(light_controller)),
        ('POST', '/v1/light/led', routes.create_led_handler(light_controller)),
        ('GET', ure.compile(r'^/v1/light/pins/(\d+)$'),
         routes.create_get_pin_handler(light_controller)),
        ('POST', ure.compile(r'^/v1/light/pins/(\d+)$'),
         routes.create_set_pin_handler(light_controller)),
        ('GET', '/v1/light/addresses',
         routes.create_get_addresses_handler(
             config['addresses']['file-path'])),
    ])

    default_handler = middleware.not_found(None)
    server = uhttp.HTTPServer(
        handler=middleware.use(
            default_handler,
            middleware.trace,
            middleware.recover,
            router,
        ),
        port=config['server']['port'],
    )
    return server
Exemple #4
0
def web_serv(s):
    html = """<!DOCTYPE html>
    <html>
        <head> <title>ESP32 Pins</title> </head>
        <body> <h1>ESP32 Pins</h1>
            <table border="1"> <tr><th>Pin</th><th>Value</th></tr> %s </table>
        </body>
         <h3>Pick a Color:</h3>
    <div style="margin:auto;width:236px;">
    </html>
    """
    regex = ure.compile('\(')
    regex2 = ure.compile('\)')
    regex3 = ure.compile('led')

    cl, addr = s.accept()
    log.info('{} : client connected from: {}'.format(timeout(), addr))
    cl_file = cl.makefile('rwb', 0)
    while True:
        line = cl_file.readline()
        log.debug('{} : {}'.format(timeout(), line))
        if regex3.search(line):
            out1 = regex.split(line)
            log.debug('{} : {}'.format(timeout(), out1))
            lightraw = regex2.split(out1[1])[0]
            lightcmd = Convert(lightraw)

        if not line or line == b'\r\n':
            break
    #response = html % '\n'.join(rows)
    cl.send(line)
    cl.close()
    return lightcmd
Exemple #5
0
def read_forecast():
    """Read the weather forecast."""
    watcher.feed()

    start_regex = ure.compile(r'timeseries')
    continue_regex = ure.compile(r'\},\{')
    hour_regex = ure.compile(r'next_1_hours')
    precip_regex = ure.compile(r'precipitation_amount\":(\d+\.\d)')
    date_regex = ure.compile(r'time\":\"(\d+-\d+-\d+)T')
    # Large chunk size more performant as less regex's run. Must be less than
    # characters in one timeseries element in the response.
    chunkSize = 1000
    windowSize = chunkSize * 2

    rain_today_mm, rain_tomorrow_mm = (0.0, 0.0)
    window = memoryview(bytearray(windowSize))
    emptyChunk = bytes(chunkSize)
    periodFound, hourFound, precipFound, dateFound = False, False, False, False

    File.logger().info('%s - Req to: %s', clock.timestamp(), _FORECAST_URL)
    with requests.get(_FORECAST_URL, headers=secrets.HEADER) as response:
        File.logger().info('%s - HTTP status: %d', clock.timestamp(),
                           response.status_code)
        if response.status_code == 200 or response.status_code == 203:
            for chunk in response.iter_content(chunkSize):
                # Populate response window
                window[0:chunkSize] = window[chunkSize:windowSize]
                if len(chunk) == chunkSize:
                    window[chunkSize:windowSize] = chunk
                else:
                    # last chunk is short
                    window[chunkSize:windowSize] = emptyChunk
                    window[chunkSize:chunkSize + len(chunk)] = chunk
                # print(window)
                windowBytes = bytes(window)  # regex requires bytes
                # Gather precipitation data
                if continue_regex.search(windowBytes) or\
                   start_regex.search(windowBytes):
                    periodFound = True
                if periodFound and hour_regex.search(windowBytes):
                    hourFound = True
                if periodFound and not dateFound:
                    if (dateGroup := date_regex.search(windowBytes)):
                        dateFound = True
                        date = dateGroup.group(1).decode()
                if hourFound and not precipFound:
                    if (precipGroup := precip_regex.search(windowBytes)):
                        precipFound = True
                        mm = float(precipGroup.group(1))
                if dateFound and precipFound:
                    periodFound, hourFound = False, False
                    dateFound, precipFound = False, False
                    # print(date, mm)
                    if clock.greater_than_tommorow(date):
                        break
                    elif clock.equal_to_today(date):
                        rain_today_mm += mm
                    else:
                        rain_tomorrow_mm += mm
 def extract(self, _startStr, _endStr):
     # we prepare an array to store
     results = []
     # prepare regex to reduces spaces to on space
     # and remove cr/linefeeds
     removeWhiteSpaces = ure.compile("(  )+")
     removeCR = ure.compile("[\r\n]")
     endOfStream = False
     _startStrBytes = bytes(_startStr, 'utf-8')
     _endStrBytes = bytes(_endStr, 'utf-8')
     # start with mininum length of the search String
     # if it is smaller than the start - end
     pageStreamBytes = self.raw.read(len(_startStr))
     if len(pageStreamBytes) < len(_startStr):
         endOfStream = True
     # we must convert the searchstring to bytes als not for all charcters uft-8 encoding is working
     # like in Curacao (special c)
     while not endOfStream:
         if pageStreamBytes == _startStrBytes:
             # we found a matching string
             # print('Start found %s ' % pageStreamBytes.decode('utf-8'))
             # we need to find the end
             endOfTag = False
             read = self.raw.read(len(_endStr))
             if len(read) == 0:
                 endOfStream = True
             pageStreamBytes += read
             while ((not endOfStream) and (not endOfTag)):
                 # comparing the string with the find method is easier
                 # than comparing the bytes
                 if (pageStreamBytes.decode('utf-8')).find(_endStr) > 0:
                     endOfTag = True
                     result = removeWhiteSpaces.sub(
                         '', pageStreamBytes.decode('utf-8'))
                     result = removeCR.sub('', result)
                     results.append(result)
                     # print('Result: %s' % result)
                 else:
                     # read and Append
                     read = self.raw.read(1)
                     if len(read) == 0:
                         endOfStream = True
                     else:
                         pageStreamBytes += read
                         # print('End not Found %s' % pageStreamBytes.decode('utf-8'))
         else:
             # we did not find a matching string
             # and reduce by one character before we add the next
             # print('not found %s' % pageStream)
             pageStreamBytes = pageStreamBytes[1:len(_startStrBytes)]
         read = self.raw.read(1)
         if len(read) == 0:
             endOfStream = True
         pageStreamBytes = pageStreamBytes + read
     self.close()
     return results
Exemple #7
0
    def prepare_events_regexes(self):
        """
        Prepare regular expressions used for events parsing. The server
        connection must be already open.
        """
        player_id = urlencode.quote(self.player_id)

        self.power_regex = ure.compile('{} power ([10])'.format(player_id))
        self.volume_regex = ure.compile(
            '{} mixer volume ([0-9]+)'.format(player_id))
Exemple #8
0
 def get_signal_strength(self):
     csq_at = self.lte.send_at_cmd("AT+CSQ")
     csq_line_regex = ure.compile("\n")
     csq_line = csq_line_regex.split(csq_at)
     csq_string_regex = ure.compile(" ")
     csq_string = csq_string_regex.split(csq_line[1])
     csq_comma = csq_string[1]
     csq_num_regex = ure.compile(",")
     csq_num = csq_num_regex.split(csq_comma)
     csq = csq_num[0]
     return csq
Exemple #9
0
    def parse_bracket_definition(self, language, loaded_modules):
        """
        Parse the bracket defintion
        """

        names = []
        subnames = []
        find_regex = []
        sub_find_regex = []

        for params in self.bracket_rules:
            if is_valid_definition(params, language):
                try:
                    bh_plugin.load_modules(params, loaded_modules)
                    entry = BracketDefinition(params)
                    if not self.check_compare and entry.compare is not None:
                        self.check_compare = True
                    if not self.check_validate and entry.validate is not None:
                        self.check_validate = True
                    if not self.check_post_match and entry.post_match is not None:
                        self.check_post_match = True
                    self.brackets.append(entry)
                    if not entry.find_in_sub_search_only:
                        find_regex.append(params["open"])
                        find_regex.append(params["close"])
                        names.append(params["name"])
                    else:
                        find_regex.append(r"([^\s\S])")
                        find_regex.append(r"([^\s\S])")

                    if entry.find_in_sub_search:
                        sub_find_regex.append(params["open"])
                        sub_find_regex.append(params["close"])
                        subnames.append(params["name"])
                    else:
                        sub_find_regex.append(r"([^\s\S])")
                        sub_find_regex.append(r"([^\s\S])")
                except Exception as e:
                    log(e)

        if len(self.brackets):
            self.brackets = tuple(self.brackets)
            debug(
                "Bracket Pattern: (%s)\n" % ','.join(names) +
                "    (Opening|Closing):     (?:%s)\n" % '|'.join(find_regex)
            )
            debug(
                "SubBracket Pattern: (%s)\n" % ','.join(subnames) +
                "    (Opening|Closing): (?:%s)\n" % '|'.join(sub_find_regex)
            )
            self.sub_pattern = ure.compile("(?:%s)" % '|'.join(sub_find_regex), ure.MULTILINE | ure.IGNORECASE)
            self.pattern = ure.compile("(?:%s)" % '|'.join(find_regex), ure.MULTILINE | ure.IGNORECASE)
Exemple #10
0
def getNetVar(varName):
    urlStr = "https://ubicomp.net/sw/db1/var2db.php?varName=" + str(varName)
    # print(urlStr)
    # http_get("https://ubicomp.net/sw/db1/var2db.php?varName=test3&varValue=14")
    # http_get("https://ubicomp.net/sw/db1/var2db.php?varName=test222&varValue=valTest222")
    resStr = http_get(urlStr)
    # import re # standrad python
    #_, retVar0 = ure.split('\r\n\r\n|\n\n',resStr)
    # retVar = ure.split(' |\n|\r',retVar0)
    reg1 = ure.compile('\r\n\r\n|\n\n')
    reg2 = ure.compile(' |\n|\r')
    _, retVar0 = reg1.split(resStr)
    retVar = reg2.split(retVar0)
    return retVar[0]
    def test_re_routes(self):
        req = MockReq()

        next_called = False

        def next_mw(w, r):
            nonlocal next_called
            next_called = True

        calls = []

        def users_create_handler(w, req, match):
            nonlocal calls
            calls.append(('users_create_handler', match.group(1)))

        def user_transactions_handler(w, req, match):
            nonlocal calls
            calls.append(
                ('user_transactions_handler', match.group(1), match.group(2)))

        router = middleware.create_router([
            ('GET', ure.compile(r"/v1/users/([A-Za-z0-9\-]+)/create"),
             users_create_handler),
            ('GET',
             ure.compile(
                 r"/v1/users/([A-Za-z0-9\-]+)/transactions/([A-Za-z0-9\-]+)"),
             user_transactions_handler),
        ])(next_mw)

        user1 = str(uuid4())
        req.uri = "/v1/users/%s/create" % user1
        router(None, req)
        self.assertEqual(calls, [("users_create_handler", user1)])
        self.assertEqual(next_called, False)
        calls = []

        trx1 = str(uuid4())
        req.uri = "/v1/users/%s/transactions/%s" % (user1, trx1)
        router(None, req)
        self.assertEqual(calls, [("user_transactions_handler", user1, trx1)])
        self.assertEqual(next_called, False)
        calls = []

        trx1 = str(uuid4())
        req.uri = "/v1/users/%s/update" % (user1)
        router(None, req)
        self.assertEqual(calls, [])
        self.assertEqual(next_called, True)
        calls = []
Exemple #12
0
    def __init__(self, bracket):
        """
        Setup the bracket object by reading the passed in dictionary.
        """

        self.style = bracket.get("style", "default")
        self.open = ure.compile("\\A" + bracket.get("open", "."), ure.MULTILINE | ure.IGNORECASE)
        self.close = ure.compile(bracket.get("close", ".") + "\\Z", ure.MULTILINE | ure.IGNORECASE)
        self.name = bracket["name"]
        sub_search = bracket.get("sub_bracket_search", "false")
        self.sub_search_only = sub_search == "only"
        self.sub_search = self.sub_search_only == True or sub_search == "true"
        self.compare = bracket.get("compare")
        self.post_match = bracket.get("post_match")
        self.scopes = bracket["scopes"]
Exemple #13
0
    def read_shortcuts(cls, filename):
        """Read all shortcuts from given file."""

        line_re = ure.compile(r'^\s*(\d+)\s+([^;]*);(.*)$')

        shortcut_dict = {}

        input_file = open(filename, 'r')
        for line in input_file:
            # Skip empty or comment lines.
            line = line.strip()
            if not line or line[0] == '#':
                continue

            match = line_re.match(line)
            if not match:
                raise BadShortcut("Bad shortcut line: " + line)

            switch_num = int(match.group(1))
            event_groups = tuple(
                EventGroup(event_group_str.strip())
                for event_group_str in match.group(2).split())
            label = match.group(3).strip()

            # Append the Shortcut to the list of shortcuts for this switch.
            shortcut_dict.setdefault(switch_num,
                                     []).append(Shortcut(event_groups, label))

        return shortcut_dict
    def __init__(self, address, port, debug=-1):
        # debug values:
        # -1 disable all logging
        # 0 (False) normal logging: requests and errors
        # 1 (True) debug logging
        # 2 extra debug logging
        self.debug = debug
        logging.basicConfig(level=logging.DEBUG)
        self.address = address
        self.port = port
        self.ROUTES = [
            # You can specify exact URI string matches...
            ("/", self.index),
            ("/ncsi.txt", self.ncsi),  # microsoft
            ("/connecttest.txt", self.connecttest),  # microsoft
            ("/redirect", self.redirect),  # microsoft
            ("/gen_204", self.redirect),  # android
            ("/generate_204", self.redirect),  # android
            ("/hotspot-detect.html", self.redirect),  # apple
            ("/squares", self.squares),
            ("/file", lambda req, resp:
             (yield from self.app.sendfile(resp, "captiveportal.py"))),
            # ... or match using a regex, the match result available as req.url_match
            # for match group extraction in your view.
            (re.compile("^/iam/(.+)"), self.hello),
        ]

        self.app = picoweb.WebApp("__main__", routes=self.ROUTES)
Exemple #15
0
def find(target, path='/', filter='^.*\.py$', recurse=False, output=''):

    # create list of files
    file_list = list(os.ilistdir(path))

    # only recurse through the dirs if needed
    if recurse:
        for f in file_list:
            if f[1] == 16384:
                find(target, merge(path, f[0]), filter, recurse, output)

    r = ure.compile(filter)

    # scan the files
    for f in file_list:
        if f[1] == 32768:
            if filter == '' or r.match(f[0]):
                scanfile = merge(path, f[0])
                h = open(scanfile)
                linenumber = 1
                for line in h:
                    if target in line:
                        hit = '{0}:\t(Line {1})\t{2}'.format(
                            scanfile, linenumber, line)
                        if output != '':
                            with open(output, 'a') as op:
                                op.write(hit)
                        else:
                            print(hit, end='')
                    linenumber += 1
                h.close()
    def connect(self):
        prov = ProvisioningClient(self._id_scope, self._device_id,
                                  self._credentials_type, self._credentials,
                                  self._logger, self._model_id)
        creds = prov.register()
        self._mqtt_client = MQTTClient(self._device_id,
                                       creds.host,
                                       8883,
                                       creds.user.encode('utf-8'),
                                       creds.password.encode('utf-8'),
                                       ssl=True,
                                       keepalive=60)
        self._commands_regex = ure.compile(
            '\$iothub\/methods\/POST\/(.+)\/\?\$rid=(.+)')
        self._mqtt_client.connect(False)
        self._connected = True
        self._logger.info('Device connected!')
        self._mqtt_client.set_callback(self._on_message)
        self._mqtt_client.subscribe(HubTopics.TWIN)
        self._mqtt_client.subscribe('{}/#'.format(HubTopics.PROPERTIES))
        self._mqtt_client.subscribe('{}/#'.format(HubTopics.COMMANDS))
        self._mqtt_client.subscribe('{}/#'.format(
            HubTopics.ENQUEUED_COMMANDS.format(self._device_id)))

        self._logger.debug(self._twin_request_id)
        self._mqtt_client.publish(
            HubTopics.TWIN_REQ.format(self._twin_request_id).encode('utf-8'),
            '{{}}')
Exemple #17
0
def import_xpub(ln):
    # read an xpub/ypub/etc and return BIP32 node and what chain it's on.
    # - can handle any garbage line
    # - returns (node, chain, addr_fmt)
    # - people are using SLIP132 so we need this
    import tcc, chains, ure

    pat = ure.compile(r'.pub[A-Za-z0-9]+')

    found = pat.search(ln)
    if not found:
        return None

    found = found.group(0)

    for ch in chains.AllChains:
        for kk in ch.slip132:
            if found[0] == ch.slip132[kk].hint:
                try:
                    node = tcc.bip32.deserialize(found, ch.slip132[kk].pub,
                                                 ch.slip132[kk].priv)
                    chain = ch
                    addr_fmt = kk
                    return (node, ch, kk)
                except ValueError:
                    pass

    # looked like one, but fail.
    return None
Exemple #18
0
def _compile(pattern, flags):
    #    # internal: compile pattern
    #    bypass_cache = flags & DEBUG
    #    if not bypass_cache:
    #        try:
    #            p, loc = _cache[type(pattern), pattern, flags]
    #            if loc is None or loc == _locale.setlocale(_locale.LC_CTYPE):
    #                return p
    #        except KeyError:
    #            pass
    if isinstance(pattern, _pattern_type):
        if flags:
            raise ValueError(
                "Cannot process flags argument with a compiled pattern")
        return pattern
#    if not sre_compile.isstring(pattern):
#        raise TypeError("first argument must be string or compiled pattern")
#    p = sre_compile.compile(pattern, flags)
    p = ure.compile(pattern, flags)  ###
    #    if not bypass_cache:
    #        if len(_cache) >= _MAXCACHE:
    #            _cache.clear()
    #        if p.flags & LOCALE:
    #            if not _locale:
    #                return p
    #            loc = _locale.setlocale(_locale.LC_CTYPE)
    #        else:
    #            loc = None
    #        _cache[type(pattern), pattern, flags] = p, loc
    return p
    def find_in_file(self, pattern, col, end):
        try: from ure import compile
        except: from re import compile
#define REGEXP 1
        Editor.find_pattern = pattern ## remember it
        if Editor.case != "y":
            pattern = pattern.lower()
        try:
            rex = compile(pattern)
        except:
            self.message = "Invalid pattern: " + pattern
            return -1
        scol = col
        for line in range(self.cur_line, end):
            l = self.content[line]
            if Editor.case != "y":
                l = l.lower()
## since micropython does not support span, a step-by_step match has to be performed
            ecol = 1 if pattern[0] == '^' else len(l) + 1
            for i in range(scol, ecol):
                match = rex.match(l[i:])
                if match: ## bingo!
                    self.col = i
                    self.cur_line = line
                    return len(match.group(0))
            scol = 0
        else:
            self.message = pattern + " not found"
            return -1
Exemple #20
0
class TextSensorDataParser:
    SENSOR_REGEX = '([A-Z]*)([0-9]*)?\:(\-?[0-9]*\.?[0-9]*]*)'
    SENSOR_SEPARATOR = '|'
    regex = ure.compile(SENSOR_REGEX)

    def __init__(self, sensor_mapping):
        self.__sensor_mapping = sensor_mapping

    def is_buffer_parsable(self, buffer):
        return buffer.endswith(self.SENSOR_SEPARATOR)

    def parse(self, text_buffer):
        text_buffer = text_buffer[:-1]
        sensors = []
        for sensor_data in text_buffer.split('|'):
            sensor_components = self.regex.search(sensor_data)
            if not sensor_components:
                continue
            mapping = self.__sensor_mapping[sensor_components.group(1)]
            sensors.append({
                'type': mapping[0],
                'id': mapping[1],
                'value': sensor_components.group(3)
            })

        return sensors
 def find_in_file(self, pattern, col, end):
     try:
         from ure import compile
     except:
         from re import compile
     Editor.find_pattern = pattern
     if Editor.case != "y":
         pattern = pattern.lower()
     try:
         rex = compile(pattern)
     except:
         self.message = "Invalid pattern: " + pattern
         return -1
     scol = col
     for line in range(self.cur_line, end):
         l = self.content[line]
         if Editor.case != "y":
             l = l.lower()
         ecol = 1 if pattern[0] == '^' else len(l) + 1
         for i in range(scol, ecol):
             match = rex.match(l[i:])
             if match:
                 self.col = i
                 self.cur_line = line
                 return len(match.group(0))
         scol = 0
     else:
         self.message = pattern + " not found"
         return -1
Exemple #22
0
 def __compile_regex(self, url):
     try:
         self.regex_str = "^{p}\S+".format(p=self.file_path)
         return ure.compile(self.regex_str), []
     except:
         raise CompileRegexException(
             "Error with compiling regex in static route class!")
Exemple #23
0
 def __init__(self, url_pattern):
     self.pattern = ''
     self.args = []
     use_regex = False
     for segment in url_pattern.lstrip('/').split('/'):
         if segment and segment[0] == '<':
             if segment[-1] != '>':
                 raise ValueError('invalid URL pattern')
             segment = segment[1:-1]
             if ':' in segment:
                 type_, name = segment.rsplit(':', 1)
             else:
                 type_ = 'string'
                 name = segment
             if type_ == 'string':
                 pattern = '[^/]+'
             elif type_ == 'int':
                 pattern = '\\d+'
             elif type_ == 'path':
                 pattern = '.+'
             elif type_.startswith('re:'):
                 pattern = type_[3:]
             else:
                 raise ValueError('invalid URL segment type')
             use_regex = True
             self.pattern += '/({pattern})'.format(pattern=pattern)
             self.args.append({'type': type_, 'name': name})
         else:
             self.pattern += '/{segment}'.format(segment=segment)
     if use_regex:
         self.pattern = re.compile('^' + self.pattern + '$')
Exemple #24
0
    def split_request(self, request):
        method = ""
        path = ""
        queryStrings = {}
        params = {}

        if isinstance(request, bytes):
            request = request.decode('ascii')

        try:
            regex = compile("[\r\n]")
            request_per_line = regex.split(request)
            firstLine = str(request_per_line[0])
            method, url, _ = firstLine.split(" ")

            path = url

            if len(url.split("?")) == 2:
                path, queryString = url.split("?")
                queryStrings = queryString.split("&")

            for item in queryStrings:
                k, v = item.split("=")
                params[b"%s" % k] = b"%s" % v

        except:
            print("> Bad request: " + request)

        return method, path, params
Exemple #25
0
 def add_route(self, verb, path, function):
     # default priority is number of slashes -> longer matches preferred
     priority = path.count('/')
     if not path.endswith('$'):
         path = path + '$'
     self.routes.setdefault(verb, []).append((priority, path, ure.compile(path), function))
     return function
Exemple #26
0
    def __compile_regex(self, url):
        try:
            log.debug("Compile url to regex.")

            self.num_slashes = []
            slash = 0
            params = []
            current_param = ""
            param_reading = False
            self.regex_str = "^"

            for char in url:
                if char is "{":
                    self.num_slashes.append(slash)
                    param_reading = True
                elif char is "}":
                    param_reading = False
                    params.append(current_param)
                    self.regex_str += "\w+"
                    current_param = ""
                elif param_reading:
                    current_param += char
                else:
                    self.regex_str += char
                    slash = slash + 1 if char is "/" else slash

            self.regex_str += "$"
            return ure.compile(self.regex_str), params
        except:
            raise CompileRegexException(
                "Error with compiling regex in route class!")
Exemple #27
0
def handle(conn):
    byteRequest = conn.recv(1024)
    request = byteRequest.decode('utf-16')

    getHeightRequest = request.find('/height')
    setHeightRequest = request.find('?height')
    cancelRequest = request.find('/cancel')

    statusCode = 200
    responseDict = {}
    if getHeightRequest >= 0:
        responseDict["height"] = str(desk.getHeight())
    elif cancelRequest >= 0:
        responseDict["msg"] = "Adjustment Cancelled"
        desk.cancel()
    elif setHeightRequest >= 0:
        desk.stop()

        regex = ure.compile("^GET.\/\?height=([0-9]*)")
        matches = regex.match(request)
        if matches is not None:
            height = int(regex.match(request).group(1))
            responseDict["height"] = height
            desk.setTargetHeight(height)
        else:
            statusCode = 400
            responseDict["error"] = "Unable to process height value."
    else:
        statusCode = 404
        responseDict["error"] = "No endpoint found"

    return statusCode, responseDict
Exemple #28
0
def server(config, stripData, micropython_optimize=False):

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(('', 80))
    s.listen(5)

    while True:
        try:
            conn, addr = s.accept()
            request = conn.recv(4096)
            print(conn)

            request = re.compile('\r?\n').split(request.decode('utf-8'))
            method, path, protocol = request[0].split()

            response = ""

            parseGet = get(path)

            if parseGet["cmd"] == "static":
                response = parseGet["content"]
            else:
                if parseGet["cmd"] == "get" and parseGet["route"][
                        0] in routes.routes:
                    response = routes.routes[parseGet["route"][0]](
                        parseGet["route"][1:], parseGet["params"], stripData)
                    print(response, response == "")
                    if response == "":
                        response = open('client/index.html', 'r').read()

        except ValueError:
            response = open('client/index.html', 'r').read()

        conn.send(response)
        conn.close()
Exemple #29
0
 def splittype(url):  ###
     import ure  ###
     _typeprog = ure.compile('^([^/:]+):')  ###
     match = _typeprog.match(url)  ###
     if match:  ###
         scheme = match.group(1)  ###
         return scheme.lower(), url[len(scheme) + 1:]  ###
     return None, url  ###
Exemple #30
0
 def add_route(self, verb, path, function):
     # default priority is number of slashes -> longer matches preferred
     priority = path.count('/')
     if not path.endswith('$'):
         path = path + '$'
     self.routes.setdefault(verb, []).append(
         (priority, path, ure.compile(path), function))
     return function
Exemple #31
0
def _compile(pattern, flags):
    if isinstance(pattern, _pattern_type):
        if flags:
            raise ValueError(
                "Cannot process flags argument with a compiled pattern")
        return pattern
    p = ure.compile(pattern, flags)                                             ###
    return p
Exemple #32
0
 def __init__(self, pkg, routes=None, serve_static=True):
     if routes:
         self.url_map = routes
     else:
         self.url_map = []
     if pkg and pkg != "__main__":
         self.pkg = pkg.split(".", 1)[0]
     else:
         self.pkg = None
     if serve_static:
         self.url_map.append((re.compile("^/(static/.+)"), self.handle_static))
     self.mounts = []
     self.inited = False
     # Instantiated lazily
     self.template_loader = None
     self.headers_mode = "parse"
    def find_in_file(self, pattern, col, end):
        if is_micropython:
            from ure import compile
        else: 
            from re import compile

        Editor.find_pattern = pattern ## remember it
        if Editor.case != "y":
            pattern = pattern.lower()
        try:
            rex = compile(pattern)
        except:
            self.message = "Invalid pattern: " + pattern
            return None
        start = self.cur_line
        if (col > len(self.content[start]) or   # After EOL
            (pattern[0] == '^' and col != 0)):  # or anchored and not at BOL
            start, col = start + 1, 0           # Skip to the next line
        for line in range(start, end):
            l = self.content[line][col:]
            if Editor.case != "y":
                l = l.lower()
            match = rex.search(l)
            if match: # Bingo
                self.cur_line = line
## Instead of match.span, a simple find has to be performed to get the cursor position. 
## And '$' has to be treated separately, so look for a true EOL match first
                if pattern[-1:] == "$" and match.group(0)[-1:] != "$": 
                    self.col = col + len(l) - len(match.group(0))
                else:
                    self.col = col + l.find(match.group(0))
                return len(match.group(0))
            col = 0
        else:
            self.message = pattern + " not found (again)"
            return None
# test splitting with pattern matches that can be empty
#
# CPython 3.5 issues a FutureWarning for these tests because their
# behaviour will change in a future version.  MicroPython just stops
# splitting as soon as an empty match is found.

try:
    import ure as re
except ImportError:
    print("SKIP")
    raise SystemExit

r = re.compile(" *")
s = r.split("a b    c   foobar")
print(s)

r = re.compile("x*")
s = r.split("foo")
print(s)

r = re.compile("x*")
s = r.split("axbc")
print(s)
Exemple #35
0
def A():
    return "A"
print(re.sub('a', A(), 'aBCBABCDabcda.'))

print(
    re.sub(
        r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):', 
        'static PyObject*\npy_\\1(void){\n  return;\n}\n', 
        '\n\ndef myfunc():\n\ndef myfunc1():\n\ndef myfunc2():'
    )
) 

print(
    re.compile(
         '(calzino) (blu|bianco|verde) e (scarpa) (blu|bianco|verde)'
    ).sub(
        r'\g<1> colore \2 con \g<3> colore \4? ...',
        'calzino blu e scarpa verde'
    )
)

# no matches at all
print(re.sub('a', 'b', 'c'))

# with maximum substitution count specified
print(re.sub('a', 'b', '1a2a3a', 2))

# invalid group
try:
    re.sub('(a)', 'b\\2', 'a')
except:
    print('invalid group')

# init pin for dht11
dat = Pin(DHT_PIN, Pin.OPEN_DRAIN)
dat(1)

# freezing -> did we already send the sms ? don't send it twice
freezing = False

# set the clock
c = untplib.NTPClient()
rtclock = RTC()
clock_adjust()

# set the regex for the uart answers
re = ure.compile("\r\nOK\r\n")
er = ure.compile("\r\nERROR\r\n")

# config the uart and see if somethings answers
uart = UART(1, baudrate=115200, pins=(TX_PIN, RX_PIN))  # uart #, baudrate, pins tx,rx
uart.write('+++')
uart.write('AT+COPS?\r\n')
time.sleep(1)
while uart.any() != 0:
    print(uart.readall())

# get the battery
adc = ADC()
bat = adc.channel(pin=BAT_PIN)

# initialize Blynk
                        if x not in scopes:
                            scopes[x] = scope_count
                            scope_count += 1
                            self.scopes.append({"name": x, "brackets": [entry]})
                        else:
                            self.scopes[scopes[x]]["brackets"].append(entry)
                except Exception, e:
                    bh_logging(e)

        if len(self.brackets):
            bh_debug(
                "Search patterns:\n" +
                "(?:%s)\n" % '|'.join(self.find_regex) +
                "(?:%s)" % '|'.join(self.sub_find_regex)
            )
            self.sub_pattern = ure.compile("(?:%s)" % '|'.join(self.sub_find_regex), ure.MULTILINE | ure.IGNORECASE)
            self.pattern = ure.compile("(?:%s)" % '|'.join(self.find_regex), ure.MULTILINE | ure.IGNORECASE)
            self.enabled = True

    def init_match(self):
        """
        Initialize matching for the current view's syntax.
        """

        self.chars = 0
        self.lines = 0
        syntax = self.view.settings().get('syntax')
        language = basename(syntax).replace('.tmLanguage', '').lower() if syntax != None else "plain text"

        if language != self.view_tracker[0] or self.view.id() != self.view_tracker[1]:
            self.init_bracket_regions()
import ure as re

r = re.compile('( )')
try:
    s = r.split("a b c foobar")
except NotImplementedError:
    print('NotImplementedError')
Exemple #39
0
    return min(int(page), 1)

@app.route('/', methods=['GET', 'POST'])
def homepage(request, response):
    if request.method == 'POST':
        print(request.headers)
        yield from request.read_form_data()
        if request.form.get('content'):
            note_id = Note.create(content=request.form['content'][0])
            note = list(Note.get_id(note_id))[0]
            print("note after create:", note)
            tmpl = app._load_template('note.html')
            yield from picoweb.start_response(response, "application/json")
            yield from response.awriteiter(ijson.idumps({'note': tmpl(note), 'success': 1}))
            return

        yield from picoweb.jsonify(response, {'success': 0})
        return

    yield from picoweb.start_response(response)
#    notes = Note.public().paginate(get_page(), 50)
    notes = Note.public()
    yield from app.render_template(response, 'homepage.html', (notes,))

@app.route(re.compile('^/archive/(.+)'), methods=['POST'])
def archive_note(request, response):
    pkey = picoweb.utils.unquote_plus(request.url_match.group(1))
    print("archive_note", pkey)
    Note.update({"timestamp": pkey}, archived=1)
    yield from picoweb.jsonify(response, {'success': True})
Exemple #40
0
# test printing debugging info when compiling
import ure
ure.compile('^a|b[0-9]\w$', ure.DEBUG)
Exemple #41
0
def test_re(r):
    try:
        re.compile(r)
        print("OK")
    except: # uPy and CPy use different errors, so just ignore the type
        print("Error")
Exemple #42
0
import gpio
import ddns
import util

pkg = ['ap', 'gpio', 'ddns']
for i in pkg:
  lib = __import__(i)
  lib.model.setup()

routes = [
  ('/cfg', util.handler(config.crud)),
  ('/cfg/reset', util.handler(config.reset)),
  ('/cfg/factory', util.handler(config.factory)),
  ('/sta', util.handler(sta.crud)),
  ('/sta/scan', util.handler(sta.scan)),
  ('/ap', util.handler(ap.ctl.crud)),
  ('/pwm', util.handler(pwm.list)),
  (re.compile('^/pwm/(\w+)$'), util.handler(pwm.crud)),
  (re.compile('^/pwm/(\w+)/duty$'), util.handler(pwm.duty)),
  ('/gpio', util.handler(gpio.ctl.list)),
  (re.compile('^/gpio/(\w+)$'), util.handler(gpio.ctl.crud)),
  (re.compile('^/ddns$'), util.handler(ddns.ctl.crud)),
  (re.compile('^(.*)$'), util.handler(util.static))
]
app = picoweb.WebApp(__name__, routes, False)
app.run(host="0.0.0.0", port=80)

import uasyncio as asyncio
loop = asyncio.get_event_loop()
loop.run_forever()
Exemple #43
0
try:
    import ure as re
except ImportError:
    import re

r = re.compile(".+")
m = r.match("abc")
print(m.group(0))
try:
    m.group(1)
except IndexError:
    print("IndexError")

r = re.compile("(.+)1")
m = r.match("xyz781")
print(m.group(0))
print(m.group(1))
try:
    m.group(2)
except IndexError:
    print("IndexError")

r = re.compile("[a-cu-z]")
m = r.match("a")
print(m.group(0))
m = r.match("z")
print(m.group(0))
m = r.match("d")
print(m)
m = r.match("A")
print(m)
try:
    import ure as re
except ImportError:
    import re

r = re.compile(" ")
s = r.split("a b c foobar")
print(s)

r = re.compile(" +")
s = r.split("a b    c   foobar")
print(s)

r = re.compile(" +")
s = r.split("a b    c   foobar", 1)
print(s)

r = re.compile(" +")
s = r.split("a b    c   foobar", 2)
print(s)

r = re.compile(" *")
s = r.split("a b    c   foobar")
# TODO - no idea how this is supposed to work, per docs, empty match == stop
# splitting, so CPython code apparently does some dirty magic.
#print(s)

r = re.compile("x*")
s = r.split("foo")
print(s)
Exemple #45
0
try:
    import ure as re
except ImportError:
    try:
        import re
    except ImportError:
        print("SKIP")
        raise SystemExit

r = re.compile(" ")
s = r.split("a b c foobar")
print(s)

r = re.compile(" +")
s = r.split("a b    c   foobar")
print(s)

r = re.compile(" +")
s = r.split("a b    c   foobar", 1)
print(s)

r = re.compile(" +")
s = r.split("a b    c   foobar", 2)
print(s)

r = re.compile("[a-f]+")
s = r.split("0a3b9")
print(s)

# bytes objects
r = re.compile(b"x")
Exemple #46
0
### Author: EMF Badge team
### Description: Model and Helpers for TiLDA apps and the App Library API
### License: MIT
import os, ure, http_client
import filesystem

EMF_USER = "******"
USER_NAME_SEPARATOR = "~"
ATTRIBUTE_MATCHER = ure.compile("^\s*###\s*([^:]*?)\s*:\s*(.*)\s*$") # Yeah, regex!
CATEGORY_ALL = "all"
CATEGORY_NOT_SET = "uncategorised"

class App:
	"""Models an app and provides some helper functions"""
	def __init__(self, folder_name, api_information = None):
		self.folder_name = self.name = folder_name.lower()
		self.user = EMF_USER
		if USER_NAME_SEPARATOR in folder_name:
			[self.user, self.name] = folder_name.split(USER_NAME_SEPARATOR, 1)
			self.user = self.user.lower()
			self.name = self.name.lower()

		self._attributes = None # Load lazily
		self.api_information = api_information

	@property
	def folder_path(self):
		return "apps/" + self.folder_name

	@property
	def main_path(self):
Exemple #47
0
try:
    import ure as re
except ImportError:
    import re

r = re.compile(".+")
m = r.match("abc")
print(m.group(0))
try:
    m.group(1)
except IndexError:
    print("IndexError")

r = re.compile("(.+)1")
m = r.match("xyz781")
print(m.group(0))
print(m.group(1))
try:
    m.group(2)
except IndexError:
    print("IndexError")


r = re.compile("o+")
m = r.search("foobar")
print(m.group(0))
try:
    m.group(1)
except IndexError:
    print("IndexError")
Exemple #48
0

def hello(req, resp):
    yield from picoweb.start_response(resp)
    # Here's how you extract matched groups from a regex URI match
    yield from resp.awrite("Hello " + req.url_match.group(1))


ROUTES = [
    # You can specify exact URI string matches...
    ("/", index),
    ("/squares", squares),
    ("/file", lambda req, resp: (yield from app.sendfile(resp, "example_webapp.py"))),
    # ... or match using a regex, the match result available as req.url_match
    # for match group extraction in your view.
    (re.compile("^/iam/(.+)"), hello),
]


import ulogging as logging
logging.basicConfig(level=logging.INFO)
#logging.basicConfig(level=logging.DEBUG)

app = picoweb.WebApp(__name__, ROUTES)
# debug values:
# -1 disable all logging
# 0 (False) normal logging: requests and errors
# 1 (True) debug logging
# 2 extra debug logging
app.run(debug=1)
<!DOCTYPE html>
<html>
<head>
<link href="style.css" rel="stylesheet">
</head>
<body>
<p>The style.css should be cached and might be encoded.</p>
<p class="green">Check out your webdev tool!</p>
</body>
</html>""")


# Send gzipped content if supported by client.
# Shows specifying headers as a flat binary string -
# more efficient if such headers are static.
@app.route(re.compile('^\/(.+\.css)$'))
def styles(req, resp):
    file_path = req.url_match.group(1)
    headers = b"Cache-Control: max-age=86400\r\n"

    if b"gzip" in req.headers.get(b"Accept-Encoding", b""):
        file_path += ".gz"
        headers += b"Content-Encoding: gzip\r\n"

    print("sending " + file_path)
    yield from app.sendfile(resp, "static/" + file_path, "text/css", headers)


import ulogging as logging
logging.basicConfig(level=logging.INFO)
Exemple #50
0
try:
    import ure as re
except ImportError:
    try:
        import re
    except ImportError:
        import sys
        print("SKIP")
        sys.exit()

r = re.compile(".+")
m = r.match("abc")
print(m.group(0))
try:
    m.group(1)
except IndexError:
    print("IndexError")

# conversion of re and match to string
str(r)
str(m)

r = re.compile("(.+)1")
m = r.match("xyz781")
print(m.group(0))
print(m.group(1))
try:
    m.group(2)
except IndexError:
    print("IndexError")
Exemple #51
0
    return dt

def parse_date(dtstr, dt=None):
    """Parses date from NMEA date format into Datetime object"""
    if not dt:
        dt = Datetime()

    dt.day = int(dtstr[0:2])
    dt.month = int(dtstr[2:4])
    dt.year = 2000 + int(dtstr[4:])

    return dt

# Adapted from https://github.com/Knio/pynmea2/blob/master/pynmea2/nmea_utils.py
dm_to_sd_re = re.compile(r'^(\d+)(\d\d\.\d+)$')
def dm_to_sd(dm):
    """Converts the NMEA dddmm.mmmm format to the more commonly used decimal format"""
    if (   not dm
        or dm == '0'):
        return 0.0
    match = dm_to_sd_re.match(dm)
    d = match.group(1)
    m = match.group(2)
    return float(d) + float(m) / 60


def parse_gprmc(line, fix=None):
    """Parses G[PLN]RMC sentence, returns a Fix object. NOTE: The line must be a string, not bytearray. Cast before passing"""
    if not fix:
        fix = Fix()