Example #1
0
 def parse_color(self, color):
     hex_color = "[A-Fa-f0-9]"
     norm_color = comp("^#" + hex_color + "{6}$")
     trans_color_1 = comp("^\[(" + hex_color + "{2})\]#(" + hex_color +
                          "{6})$")
     trans_color_2 = comp("^#" + hex_color + "{2}(" + hex_color + "{6})$")
     if (match := trans_color_1.match(color)):
         return '#' + match.group(1) + match.group(
             2) if self.transparency else '#' + match.group(2)
Example #2
0
    def prepare_text(self):
        """ INPUT: A STRING
        ### OUTPUT: A LEMATIZED STRING WITHOUT NUMBERS, PUNCTUATIONS, AND STOP WORDS
        """
        descriptions = []
        descriptions.append(self.text)
        corpus = [self.normalize_text(s) for s in descriptions]
        descriptions = [' '.join(s) for s in corpus]

        new_desc = []
        for t in descriptions:
            new_desc.append(' '.join([
                word for word in t.split()
                if word not in stopwords.words("english")
            ]))

        new_desc2 = [sub(r'\b[0-9]+\b\s*', '', s) for s in new_desc]

        final = new_desc2[0]

        #final = "".join(l for l in final if l not in string.punctuation)

        regex = comp('[%s]' % escape(punctuation))
        final = regex.sub(' ', final)

        p = set(printable)
        final = ''.join(filter(lambda x: x in p, final))
        final = ' '.join([w for w in final.split() if len(w) > 1])

        return final
Example #3
0
def get_info(LOG_FLAG):
    """
    Parse the configuration file.
    """
    try:
        from idleoutconf import log, logsize, pid, host, port, domain
        from idleoutconf import group, name
        if LOG_FLAG != 1:
            logg(log, int(logsize))
            # Don't open another logging instance!
            LOG_FLAG = 1
        global smtp
        smtp = [host, int(port), domain]
        reg1 = comp('(\s+)\=(\s+)')
        for users in name:
            users = reg1.sub("=", users.strip())
            usrtmp = users.split()
            usrname = usrtmp[0]
            rest = usrtmp[1:]
            usr_define(usrname, rest)
        for groups in group:
            groups = reg1.sub("=", groups.strip())
            grtmp = groups.split()
            groupname = grtmp[0]
            rest = grtmp[1:]
            group_define(groupname, rest)
        return(pid)
    except Exception, err:
        print >> sys.stderr, "Error: %d: %s" % (err.errno, err.strerror)
        sys.exit(err.errno)
Example #4
0
        def match(self):
            """Used to get exploitable result of re.search"""

            # We initate this variable which gonna contain the returned data
            result = []

            # We compile the regex string
            to_match = comp(self.regex)

            # In case we have to use the implementation of ${BASH_REMATCH} we use
            # re.findall otherwise, we use re.search
            if self.rematch:  # pylint: disable=no-member
                pre_result = to_match.findall(self.data)
            else:
                pre_result = to_match.search(self.data)

            if self.return_data and pre_result is not None:  # pylint: disable=no-member
                if self.rematch:  # pylint: disable=no-member
                    for data in pre_result:
                        if isinstance(data, tuple):
                            result.extend(list(data))
                        else:
                            result.append(data)

                    if self.group != 0:  # pylint: disable=no-member
                        return result[self.group]  # pylint: disable=no-member
                else:
                    result = pre_result.group(
                        self.group).strip()  # pylint: disable=no-member

                return result
            elif not self.return_data and pre_result is not None:  # pylint: disable=no-member
                return True
            return False
def pega_eps(link_dict: dict, conteudo: bytes = b'') -> tuple or bool:
    """Pega os episodios da pagina e passa para pegar o link."""
    try:
        if conteudo == b'':
            link_rede = link_dict['link']
            requisicao_get = req_link(link_rede)
            if requisicao_get.status_code != 200 and requisicao_get.url != link_rede:
                return False
            requisicao_get = requisicao_get.content
        else:
            requisicao_get = conteudo
        req = parse_bs(requisicao_get)
        desc = req.find('div', {'itemprop': 'description'}) \
            if req.find('div', {'itemprop': 'description'}) is not None \
            else req.find(class_=comp("description"))
        des = desc.find()
        episodios = []
        # pegar itens
        separar = des.prettify().replace('\n', '').split('<br/>')
        fila = []
        for i in separar:
            parse_pag = parse_bs(i)
            if parse_pag.find('a') is not None:
                str_episodio = ' '.join(
                    sanitizestring(
                        parse_pag.text.replace('Assistir', '').replace(
                            'Dublado', '').replace('Legendado',
                                                   '')).strip().split())
                a_tag = parse_pag.find_all('a')
                if len(a_tag) == 1:
                    str_link = tira_barra(
                        BASE +
                        a_tag[0].get('href').replace("%20", ' ').replace(
                            'redi/', '').replace('[', '').split()[0])
                else:
                    str_link = {
                        k.text.strip(): tira_barra(
                            BASE + k.get('href').replace("%20", ' ').replace(
                                'redi/', '').replace('[', '').split()[0])
                        for k in a_tag
                    }
                ep = {str_episodio: str_link}
                episodios.append(ep)
        [
            fila.append((episodios[i], link_dict, i))
            for i in range(len(episodios))
        ]
        li_ep = [None for i in range(len(episodios))]
        # print(fila)
        # [fila.put('Kill') for i in range(5)]
        env_alt(altera_link, fila, li_ep)
        # mypool = get_pool(5, altera_link, fila, li_ep)
        # [i.start() for i in mypool]
        # [i.join() for i in mypool]
        # pprint(link_tupla[0])
        return (link_dict, episodios)
    except Exception as e:
        print(red, "pega_eps:", link_dict, '\n', e.__str__(), type(e),
              e.with_traceback(e.__traceback__), reset)
Example #6
0
    def match(self, regex=None, data_to_match=None):
        """
        Used to get exploitable result of re.search

        Arguments:
            - data: str
                The data or a list of data to check.
            - regex: str
                The regex or a list or regex.

        Returns:
            list or bool
            - bool: if self.return_data is False
            - list: otherwise
        """

        # We initate this variable which gonna contain the returned data
        result = []

        if not regex:
            regex = self.regex

        if not data_to_match:
            data_to_match = self.data

        # We compile the regex string
        to_match = comp(regex)

        # In case we have to use the implementation of ${BASH_REMATCH} we use
        # re.findall otherwise, we use re.search
        if self.rematch:  # pylint: disable=no-member
            pre_result = to_match.findall(data_to_match)
        else:
            pre_result = to_match.search(data_to_match)

        if self.return_data and pre_result is not None:  # pylint: disable=no-member
            if self.rematch:  # pylint: disable=no-member
                for data in pre_result:
                    if isinstance(data, tuple):
                        result.extend(list(data))
                    else:
                        result.append(data)

                if self.group != 0:  # pylint: disable=no-member
                    return result[self.group]  # pylint: disable=no-member

            else:
                result = pre_result.group(
                    self.group  # pylint: disable=no-member
                ).strip()

            return result

        elif not self.return_data and pre_result is not None:  # pylint: disable=no-member
            return True

        return False
Example #7
0
    def matching_list(self):
        """
        This method return a list of the string which match the given
        regex.
        """

        pre_result = comp(self.regex)

        return list(filter(lambda element: pre_result.search(str(element)), self.data))
Example #8
0
def _get_version():
    """
    This function will extract the version from PyFunceble/__init__.py
    """

    to_match = comp(r'VERSION\s=\s"(.*)"\n')
    extracted = to_match.findall(open("PyFunceble/__init__.py").read())[0]

    return ".".join(list(filter(lambda x: x.isdigit(), extracted.split("."))))
    def not_matching_list(self):
        """
        This method return a list of string which don't match the
        given regex.
        """

        to_match = comp(self.regex)

        return list(filterfalse(to_match.search, self.data))
Example #10
0
    def matching_list(self):
        """
        Return a list of the string which match the given
        regex.
        """

        pre_result = comp(self.regex)

        return [x for x in self.data if pre_result.search(str(x))]
Example #11
0
 def mapping_block_names_search(self, script):
     pattern = "\s*return [\"'](.*)[\"'];"
     regex = comp(pattern)
     results = []
     for line in script.split("\n"):
         match = regex.match(line)
         if match:
             results.append(match.group(1))
     return results
Example #12
0
def get_version():
    """
    Extracts the version from adblock_decoder/__init__.py
    """

    to_match = comp(r'__version__\s=\s"(.*)"')

    return to_match.findall(
        open("adblock_decoder/__init__.py", encoding="utf-8").read())[0]
Example #13
0
def get_version():
    """
    Extracts the version from {NAMESPACE}/{MODULE}/__about__.py
    """

    to_match = comp(r'__version__\s=\s"(.*)"')
    extracted = to_match.findall(
        open(f"{NAMESPACE}/{MODULE}/__about__.py", encoding="utf-8").read())[0]

    return ".".join(list(filter(lambda x: x.isdigit(), extracted.split("."))))
Example #14
0
def _get_version():
    """
    This function will extract the version from a_john_shots/__init__.py
    """

    to_match = comp(r'VERSION\s=\s"(.*)"\n')
    extracted = to_match.findall(
        open("a_john_shots/__init__.py", encoding="utf-8").read())[0]

    return ".".join([x for x in extracted.split(".") if x.isdigit()])
def _get_version():
    """
    Extract the version from ultimate_hosts_blacklist/comparison/__init__.py
    """

    to_match = comp(r'VERSION\s=\s"(.*)"\n')
    extracted = to_match.findall(
        open("ultimate_hosts_blacklist/comparison/__init__.py",
             encoding="utf-8").read())[0]

    return ".".join(list(filter(lambda x: x.isdigit(), extracted.split("."))))
Example #16
0
    def not_matching_list(self):
        """
        Return a list of string which don't match the
        given regex.
        """

        pre_result = comp(self.regex)

        return list(
            filter(lambda element: not pre_result.search(str(element)),
                   self.data))
        def matching_list(self):
            """
            This method return a list of the string which match the given
            regex.
            """

            pre_result = comp(self.regex)

            return list(
                filter(lambda element: pre_result.search(str(element)), self.data)
            )
Example #18
0
def build_status_element(status_string: str) -> List[Dict[str, str]]:
    status_list: List[Dict[str, str]] = []
    regex = comp(r"^(?:\w*:(?:FAIL|PASS))(?:;(?:\w*:(?:FAIL|PASS)))*$")
    assert bool(
        regex.match(str(status_string))
    ), f"Invalid status string {status_string}, must fit ^(?:\w*:(?:FAIL|PASS))(?:;(?:\w*:(?:FAIL|PASS)))*$"
    for status in status_string.split(";"):
        name: str
        state: str
        name, state = status.split(":")
        status_list.append({"name": name, "status": state})
    return status_list
Example #19
0
def extract(spattern):
    fdict = dict()
    pt = dict()
    cat = []
    for name, value in spattern.items():
        if name[0] == "_":
            value['tokens'] = spattern[name[2:]]['tokens']
        pt.update({name: comp(value['regex'], MULTILINE)})
        eachline = dict()
        replas = dict()
        for w in value['tokens']:
            if w in value:
                if 'eachline' in value[w]:
                    eachline.update({w: value[w]['eachline']})
                if 'replace' in value[w]:
                    replas.update({
                        w: [(comp(q[0]), q[1]) if 1 < len(q) else
                            (comp(q[0]), "") for q in value[w]['replace']]
                    })
        fdict.update({name: [eachline, replas]})
        cat.append(value['tokens'])
    return fdict, pt, cat
Example #20
0
def get_version():
    """
    This function will extract the version from domain2idna/__init__.py
    """

    to_match = comp(r'VERSION\s=\s"(.*)"\n')

    try:
        extracted = to_match.findall(
            open("domain2idna/__init__.py", encoding="utf-8").read())[0]
    except FileNotFoundError:
        extracted = to_match.findall(
            open("../domain2idna/__init__.py", encoding="utf-8").read())[0]

    return ".".join([x for x in extracted.split(".") if x.isdigit()])
Example #21
0
def _get_version():
    """
    This function will extract the version from PyFunceble/__init__.py
    """

    to_match = comp(r'VERSION\s=\s"(.*)"\n')

    try:
        extracted = to_match.findall(
            open("PyFunceble/abstracts/package.py",
                 encoding="utf-8").read())[0]
    except FileNotFoundError:  # pragma: no cover
        extracted = to_match.findall(
            open("../PyFunceble/abstracts/package.py",
                 encoding="utf-8").read())[0]

    return ".".join([x for x in extracted.split(".") if x.isdigit()])
Example #22
0
def _get_version(full=False):
    """
    This function will extract the version from PyFunceble/__init__.py

    Argument:
        - full: bool
            True: Return the full version name
            False: Return the short version
    """

    to_match = comp(r'VERSION\s=\s"(.*)"\n')
    extracted = to_match.findall(
        open("../PyFunceble/__init__.py", encoding="utf-8").read())[0]

    if not full:
        return ".".join([x for x in extracted.split(".") if x.isdigit()])
    return extracted
        def match(self):
            """
            Used to get exploitable result of re.search
            """

            # We initate this variable which gonna contain the returned data
            result = []

            # We compile the regex string
            to_match = comp(self.regex)

            # In case we have to use the implementation of ${BASH_REMATCH} we use
            # re.findall otherwise, we use re.search
            if self.rematch:  # pylint: disable=no-member
                pre_result = to_match.findall(self.data)
            else:
                pre_result = to_match.search(self.data)

            if self.return_data and pre_result:  # pylint: disable=no-member
                if self.rematch:  # pylint: disable=no-member
                    for data in pre_result:
                        if isinstance(data, tuple):
                            result.extend(list(data))
                        else:
                            result.append(data)

                    if self.group != 0:  # pylint: disable=no-member
                        return result[self.group]  # pylint: disable=no-member
                else:
                    result = pre_result.group(
                        self.group  # pylint: disable=no-member
                    ).strip()

                return result

            if not self.return_data and pre_result:  # pylint: disable=no-member
                return True

            return False
    def match(self, data=None):
        """
        Used to get exploitable result of re.search.

        :param data: The data we are working with.
        :type data: str
        """

        if data is None:
            data = self.data

        # We compile the regex string
        to_match = comp(self.regex)

        # In case we have to use the implementation of ${BASH_REMATCH} we use
        # re.findall otherwise, we use re.search
        pre_result = to_match.search(data)

        if pre_result:
            if self.return_data:  # pylint: disable=no-member
                return pre_result.group(self.group).strip()  # pylint: disable=no-member
            return True

        return False
Example #25
0
 def get_exempt_urls():
     """Fetches urls that do not require login"""
     exempt_urls = [comp(settings.LOGIN_URL.lstrip('/'))]
     if hasattr(settings, 'LOGIN_EXEMPT_URLS'):
         exempt_urls += [comp(expr) for expr in settings.LOGIN_EXEMPT_URLS]
     return exempt_urls
Example #26
0
from os import listdir, getcwd, chdir
from contextlib import contextmanager
from re import compile as comp

roteiros = 'roteiros'
regex = comp(r'(#|#{2}|#{3}|#{4}) (\d\d?\.\d?\.?\d?) (.+)')


@contextmanager
def cd(_dir):
    old_dir = getcwd()
    chdir(_dir)
    yield
    chdir(old_dir)


@cd('{}/roteiros'.format(getcwd(), roteiros))
def read_file(_file):
    with open(_file) as md:
        return regex.findall(md.read())


def order(val):
    for x in sorted(val):
        yield from x


def write(_file, _dir):
    with open(_file, 'w') as md:
        for x in order([read_file(el) for el in listdir(_dir)]):
            md.writelines('#### {} {}\n'.format(x[1], x[2]))
Example #27
0
from config import SPECIAL_UNITS
from re import compile as comp
# --------------- Helpers that build all of the responses ----------------------

tag = comp(r'<[^>]+>')


def remove_tags(text):
    return tag.sub('', text)


def build_speechlet_response(title, output, reprompt_text, should_end_session):
    return {
        'outputSpeech': {
            'type': 'SSML',
            'ssml': output
        },
        'card': {
            'type': 'Simple',
            'title': title,
            'content': remove_tags(output)
        },
        'reprompt': {
            'outputSpeech': {
                'type': 'SSML',
                'ssml': reprompt_text
            }
        },
        'shouldEndSession': should_end_session
    }
Example #28
0
    def run(self):
        skip = False
        
        # try getting youtube video id or give error code
        try:
            url = str(self.ui.lineEdit.text())
            regex = comp(r'(https?://)?(www\.)?(youtube|youtu|youtube-nocookie)\.(com|be)/(watch\?v=|embed/|v/|.+\?v=)?(?P<id>[A-Za-z0-9\-=_]{11})')

            match = regex.match(url)
            videoid = match.group('id')
        except:
            self.ui.outputBox.append("Video URL missing or incorrect.\n")
            skip = True
        
        # try getting video comments from API
        if not skip:
            try:
                coms = get_video_comments(service, videoId=videoid, part='id,snippet,replies')
            except:
                self.ui.outputBox.append("Could not find video or connection refused. Check your internet connection or video URL.\n")
                skip = True
        
        # count and display votes
        if not skip:
            name1 = str(self.ui.hashtag1In.text()).lower()
            name2 = str(self.ui.hashtag2In.text()).lower()
        
            hashtag1 = 0
            hashtag2 = 0
        
            if name1 == "":
                hashtag1 = -1
            if name2 == "":
                hashtag2 = -1
        
            for com in coms:   
                if name1 in str(com).lower() and hashtag1 != -1:
                    hashtag1 += 1
                if name2 in str(com).lower() and hashtag2 != -1:
                    hashtag2 += 1
                
            if hashtag1 != -1:
                try: # avoid division by 0
                    percent1 = hashtag1 / (hashtag1 + hashtag2) * 100 
                except:
                    percent1 = 0
            else:
                percent1 = 0
                hashtag1 = 0
                name1 = "NONE"
        
            if hashtag2 != -1:
                try: # avoid division by 0
                    percent2 = hashtag2 / (hashtag1 + hashtag2) * 100
                except:
                    percent2 = 0
            else:
                percent2 = 0
                hashtag2 = 0
                name2 = "NONE"
        	
        	#stop loading screen
            loading.stopAnimation()
        
            percent1 = "{:.2f}".format(percent1)
            percent2 = "{:.2f}".format(percent2)
        
        	# display count results
            self.ui.outputBox.append(name1 + ": " + str(hashtag1) + " (" + str(percent1) + "%)" + "\n" + name2 + 
                                  ": " + str(hashtag2) + " (" + str(percent2) + "%)" + "\n")
        
        # if got error wait 1sec then stop animation otherwise program crashes    
        sleep(1)
        loading.stopAnimation()
        self.ui.pushButton.setEnabled(True)
        self.quit()
Example #29
0
def numericalSort(value):
    ## Numerically orders files
    numbers = comp(r'(\d+)')
    parts = numbers.split(value)
    parts[1::2] = map(int, parts[1::2])
    return parts
from config import SPECIAL_UNITS
from re import compile as comp
# --------------- Helpers that build all of the responses ----------------------

tag = comp(r'<[^>]+>')

def remove_tags(text):
    return tag.sub('', text)

def build_speechlet_response(title, output, reprompt_text, should_end_session):
    return {
        'outputSpeech': {
            'type': 'SSML',
            'ssml': output
        },
        'card': {
            'type': 'Simple',
            'title': title,
            'content':remove_tags(output)
        },
        'reprompt': {
            'outputSpeech': {
                'type': 'SSML',
                'ssml': reprompt_text
            }
        },
        'shouldEndSession': should_end_session
    }


def build_response(session_attributes, speechlet_response):
Example #31
0
def clean_html(raw_html):
    """Remove tags from `raw_html`"""
    output = sub(comp('<.*?>'), '', raw_html).strip()
    output = sub(comp('\^.'), '', output)
    return output
def clean_html(raw_html):
    """Remove tags from `raw_html`"""
    return sub(comp('<.*?>'), '', raw_html).strip()