Python re._pattern_type() Examples

The following are code examples for showing how to use re._pattern_type(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the ones you don't like. You can also save this page to your account.

Example 1
Project: tfutils   Author: neuroailab   File: base.py    (MIT License) View Source Project 6 votes vote down vote up
def filter_var_list(self, var_list):
        """Filter checkpoint vars for those to be restored.

        Args:
            checkpoint_vars (list): Vars that can be restored from checkpoint.
            to_restore (list[str] or regex, optional): Selects vars to restore.

        Returns:
            list: Variables to be restored from checkpoint.

        """
        if not self.to_restore:
            return var_list
        elif isinstance(self.to_restore, re._pattern_type):
            return {name: var for name, var in var_list.items()
                    if self.to_restore.match(name)}
        elif isinstance(self.to_restore, list):
            return {name: var for name, var in var_list.items()
                    if name in self.to_restore}
        raise TypeError('to_restore ({}) unsupported.'.format(type(self.to_restore))) 
Example 2
Project: filters   Author: eflglobal   File: string.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, pattern):
        # type: (Union[Text, regex._pattern_type, re._pattern_type]) -> None
        """
        :param pattern:
            String pattern, or pre-compiled regex.

            IMPORTANT:  If you specify your own compiled regex, be sure to
            add the ``UNICODE`` flag for Unicode support!
        """
        super(Regex, self).__init__()

        self.regex = (
            pattern
                if isinstance(pattern, (regex._pattern_type, re._pattern_type))
                else regex.compile(pattern, regex.UNICODE)
        ) 
Example 3
Project: filters   Author: eflglobal   File: string.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, pattern, keys=None):
        # type: (Union[Text, regex._pattern_type, re._pattern_type], Optional[Sequence[Text]]) -> None
        """
        :param pattern:
            Regex used to split incoming string values.

            IMPORTANT:  If you specify your own compiled regex, be sure
            to add the ``UNICODE`` flag for Unicode support!

        :param keys:
            If set, the resulting list will be converted into an
            OrderedDict, using the specified keys.

            IMPORTANT:  If ``keys`` is set, the split value's length
            must be less than or equal to ``len(keys)``.
        """
        super(Split, self).__init__()

        self.regex = (
            pattern
                if isinstance(pattern, (regex._pattern_type, re._pattern_type))
                else regex.compile(pattern, regex.UNICODE)
        )

        self.keys = keys 
Example 4
Project: ATX   Author: NetEaseGame   File: android_layout.py    (license) View Source Project 6 votes vote down vote up
def _filter_nodes(self, cond, nodes=None):
        if nodes is None:
            nodes = self.nodes
        res = []
        for n in nodes:
            match = True
            for k, v in cond.iteritems():
                attr = getattr(n, k)
                if isinstance(v, re._pattern_type) and \
                    isinstance(attr, basestring) and v.match(attr) is None:
                    match = False
                    break
                elif attr != v:
                    match = False
                    break
            if match:
                res.append(n)
        return res 
Example 5
Project: AutomatorX   Author: xiaoyaojjian   File: android_layout.py    (license) View Source Project 6 votes vote down vote up
def _filter_nodes(self, cond, nodes=None):
        if nodes is None:
            nodes = self.nodes
        res = []
        for n in nodes:
            match = True
            for k, v in cond.iteritems():
                attr = getattr(n, k)
                if isinstance(v, re._pattern_type) and \
                    isinstance(attr, basestring) and v.match(attr) is None:
                    match = False
                    break
                elif attr != v:
                    match = False
                    break
            if match:
                res.append(n)
        return res 
Example 6
Project: nerodia   Author: watir   File: select.py    (license) View Source Project 6 votes vote down vote up
def _js_select_by(self, term, number):
        if isinstance(term, re._pattern_type):
            js_rx = term.pattern
            js_rx = js_rx.replace('\\A', '^', 1)
            js_rx = js_rx.replace('\\Z', '$', 1)
            js_rx = js_rx.replace('\\z', '$', 1)
            js_rx = re.sub(r'\(\?#.+\)', '', js_rx)
            js_rx = re.sub(r'\(\?-\w+:', '(', js_rx)
        elif type(term) in [six.text_type, six.binary_type]:
            js_rx = '^{}$'.format(term)
        else:
            raise TypeError('expected String or Regexp, got {}'.format(term))

        for way in ['text', 'label', 'value']:
            self._element_call(lambda: self._execute_js('selectOptions{}'.format(way.capitalize()),
                                                        self, js_rx, str(number)))
            if self._is_matching_option(way, term):
                return self.selected_options[0].text

        raise NoValueFoundException('{} not found in select list'.format(term)) 
Example 7
Project: nerodia   Author: watir   File: adjacent.py    (license) View Source Project 6 votes vote down vote up
def _xpath_adjacent(self, **kwargs):
        from .elements.html_elements import HTMLElement, HTMLElementCollection
        import nerodia

        plural = kwargs.pop('plural', None)
        index = kwargs.pop('index', None)
        tag_name = kwargs.get('tag_name')

        if not (plural or any(isinstance(val, re._pattern_type) for val in kwargs.values())):
            kwargs['index'] = index or 0

        if not plural and tag_name:
            klass = nerodia.tag_to_class.get(tag_name)
        elif not plural:
            klass = HTMLElement
        elif tag_name:
            klass = nerodia.tag_to_class.get('{}_collection'.format(tag_name))
        else:
            klass = HTMLElementCollection

        return klass(self, kwargs) 
Example 8
Project: nerodia   Author: watir   File: selector_builder.py    (license) View Source Project 6 votes vote down vote up
def _build_wd_selector(self, selectors):
        if any(isinstance(val, re._pattern_type) for val in selectors.values()):
            return None

        if not selectors.pop('tag_name', None):
            raise Error('internal error: no tag_name?!')

        button_attr_exp = self.xpath_builder.attribute_expression('button', selectors)

        xpath = './/button'
        if button_attr_exp:
            xpath += '[{}]'.format(button_attr_exp)

        if selectors.get('type') is not False:
            if selectors.get('type') in [None, True]:
                selectors['type'] = Button.VALID_TYPES
            input_attr_exp = self.xpath_builder.attribute_expression('input', selectors)

            xpath += ' | .//input'
            xpath += '[{}]'.format(input_attr_exp)

        logging.debug({'build_wd_selector': xpath})

        return ['xpath', xpath] 
Example 9
Project: nerodia   Author: watir   File: selector_builder.py    (license) View Source Project 6 votes vote down vote up
def _build_wd_selector(self, selectors):
        if any(isinstance(val, re._pattern_type) for val in selectors.values()):
            return None

        selectors.pop('tag_name', None)

        input_attr_exp = self.xpath_builder.attribute_expression('input', selectors)

        xpath = './/input[(not(@type) or ({}))'.format(self._negative_type_expr)
        if input_attr_exp:
            xpath += ' and {}'.format(input_attr_exp)
        xpath += ']'

        logging.debug({'build_wd_selector': xpath})

        return ['xpath', xpath] 
Example 10
Project: nerodia   Author: watir   File: selector_builder.py    (license) View Source Project 6 votes vote down vote up
def check_type(self, how, what):
        if how == 'index':
            if not isinstance(what, int):
                raise TypeError('expected {}, got {!r}:{}'.format(int, what, what.__class__))
        elif how == 'visible':
            if not isinstance(what, bool):
                raise TypeError('expected {}, got {!r}:{}'.format(bool, what, what.__class__))
        elif how == 'visible_text':
            if type(what) not in [six.text_type, six.binary_type, re._pattern_type]:
                raise TypeError('expected str or regexp, got {}')
        else:
            if isinstance(what, list) and how != 'class_name':
                raise TypeError("only 'class_name' locator can have a value of a list")
            if type(what) not in self.VALID_WHATS:
                raise TypeError(
                    'expected one of {}, got {!r}:{}'.format(self.VALID_WHATS, what, what.__class__)) 
Example 11
Project: Price-Comparator   Author: Thejas-1   File: base_nodes.py    (license) View Source Project 6 votes vote down vote up
def _node_match_query(self, node, identifier, *args, **kwargs):
        if not self._attribute_match_query(node.generate_identifiers(), identifier.lower() if isinstance(identifier,
                                                                                                         string_instance) and not identifier.startswith(
            "re:") else identifier):
            return False

        all_my_keys = node._str_keys + node._list_keys + node._dict_keys

        if args and isinstance(args[0], (string_instance, re._pattern_type, list, tuple)):
            if not self._attribute_match_query([getattr(node, node._default_test_value)], args[0]):
                return False
            args = args[1:]

        for arg in args:
            if not arg(node):
                return False

        for key, value in kwargs.items():
            if key not in all_my_keys:
                return False

            if not self._attribute_match_query([getattr(node, key)], value):
                return False

        return True 
Example 12
Project: widgetastic.patternfly   Author: RedHatQE   File: __init__.py    (license) View Source Project 6 votes vote down vote up
def _process_step(self, step):
        """Steps can be plain strings or tuples when matching images"""
        if isinstance(step, VersionPick):
            # Version pick passed, coerce it ...
            step = step.pick(self.browser.product_version)

        if isinstance(step, tuple):
            image = step[0]
            step = step[1]
            if isinstance(step, VersionPick):
                # Version pick passed, coerce it ...
                step = step.pick(self.browser.product_version)
        else:
            image = None
        if not isinstance(step, six.string_types + (re._pattern_type,)):
            step = str(step)
        return image, step 
Example 13
Project: widgetastic.patternfly   Author: RedHatQE   File: __init__.py    (license) View Source Project 6 votes vote down vote up
def validate_node(self, node, matcher, image):
        """Helper method that matches nodes by given conditions.

        Args:
            node: Node that is matched
            matcher: If it is an instance of regular expression, that one is used, otherwise
                equality comparison is used. Against item name.
            image: If not None, then after the matcher matches, this will do an additional check for
                the image name

        Returns:
            A :py:class:`bool` if the node is correct or not.
        """
        text = self.browser.text(node)
        if isinstance(matcher, re._pattern_type):
            match = matcher.match(text) is not None
        else:
            match = matcher == text
        if not match:
            return False
        if image is not None and self.image_getter(node) != image:
            return False
        return True 
Example 14
Project: WPS-4th   Author: Fastcampus-WPS   File: custom_exception.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, re_pattern=None, source=None):
        # ?? ??? ??? re_pattern??? 
        # re._pattern_type? ????
        # (???? ????? ?? ??)
        # self.pattern_str??? re_pattern.pattern?? ??
        if isinstance(re_pattern, re._pattern_type):
            self.pattern_str = re_pattern.pattern

        # re_pattern??? str(???)?? ??
        # self.pattern_str??? ?? ?? ??? ??
        elif isinstance(re_pattern, str):
            self.pattern_str = re_pattern

        self.source = source 
Example 15
Project: pheweb   Author: statgen   File: __init__.py    (MIT License) View Source Project 5 votes vote down vote up
def extract_phenocode_from_filepath(phenolist, regex):
    print("NOTE: working with {} phenos".format(len(phenolist)))
    if not isinstance(regex, re._pattern_type):
        regex = re.compile(regex)
    for pheno in phenolist:
        if 'assoc_files' not in pheno:
            raise PheWebError("ERROR: At least one phenotype doesn't have the key 'assoc_files'.")
        if not pheno['assoc_files']:
            raise PheWebError("ERROR: At least one phenotype has an empty 'assoc_files' list.")
        phenocodes = []
        for assoc_filepath in pheno['assoc_files']:
            match = re.search(regex, assoc_filepath)
            if match is None:
                raise PheWebError("ERROR: The regex {!r} doesn't match the filepath {!r}".format(regex.pattern, assoc_filepath))
            groups = match.groups()
            if len(groups) != 1:
                raise PheWebError("ERROR: The regex {!r} doesn't capture any groups on the filepath {!r}!  You're using parentheses without backslashes, right?".format(regex.pattern, assoc_filepath))
            phenocodes.append(groups[0])
        if len(set(phenocodes)) != 1:
            raise PheWebError("ERROR: At least one phenotype gets multiple different phenocodes from its several association filepaths.  Here they are: {!r}".format(list(set(phenocodes))))
        if 'phenocode' in pheno:
            if pheno['phenocode'] != phenocodes[0]:
                raise PheWebError("""\
ERROR: The regex {!r} matched the filepaths {!r} to produce the phenocode {!r}.  But that phenotype already had a phenocode, {!r}.
""".format(regex.pattern, pheno['assoc_files'], phenocodes[0], pheno['phenocode']))
        pheno['phenocode'] = phenocodes[0]
    return phenolist 
Example 16
Project: PrivacyScore   Author: PrivacyScore   File: serverleak.py    (license) View Source Project 5 votes vote down vote up
def process_test_data(raw_data: list, previous_results: dict) -> Dict[str, Dict[str, object]]:
    leaks = []
    result = {}
    
    url = None
    if 'url' in raw_data:
        url = raw_data['url']['data'].decode()

    for trial, pattern in TRIALS:
        if url:
            if callable(trial):
                trial = trial(url)
                if trial is None:
                    continue
        if trial not in raw_data:
            # Test raw data too old or particular request failed.
            continue
        response = json.loads(raw_data[trial]['data'].decode())
        if response['status_code'] == 200:
            # The pattern can have three different types.
            # - If it is a simple string, we only check if it is contained in the response
            if isinstance(pattern, str):
                if pattern in response['text']:
                    leaks.append(trial)
            # - If it is a RegEx object, we perform a pattern match
            elif isinstance(pattern, re._pattern_type):
                if re.match(response['text']):
                    leaks.append(trial)
            # - If it is callable, we call it with the response text and check the return value
            elif callable(pattern):
                if pattern(response['text']):
                    leaks.append(trial)

    result['leaks'] = leaks
    return result 
Example 17
Project: harbour-sailfinder   Author: DylanVanAssche   File: helpers.py    (license) View Source Project 5 votes vote down vote up
def match_text(text, tag):
    if isinstance(text, string_types):
        return text in tag.text
    if isinstance(text, re._pattern_type):
        return text.search(tag.text) 
Example 18
Project: harbour-sailfinder   Author: DylanVanAssche   File: helpers.py    (license) View Source Project 5 votes vote down vote up
def match_text(text, tag):
    if isinstance(text, string_types):
        return text in tag.text
    if isinstance(text, re._pattern_type):
        return text.search(tag.text) 
Example 19
Project: ReGraph   Author: eugeniashurko   File: attribute_sets.py    (license) View Source Project 5 votes vote down vote up
def _regex_to_string(a):
    if isinstance(a, str):
        return a
    elif isinstance(a, re._pattern_type):
        return a.pattern
    elif isinstance(a, RegexSet):
        if a.pattern is not None:
            return a.pattern
        else:
            return None
    else:
        raise AttributeSetError("Cannot convert regex to string!") 
Example 20
Project: RPoint   Author: george17-meet   File: responses.py    (license) View Source Project 5 votes vote down vote up
def _has_url_match(self, match, request_url):
        url = match['url']

        if _is_string(url):
            if match['match_querystring']:
                return self._has_strict_url_match(url, request_url)
            else:
                url_without_qs = request_url.split('?', 1)[0]
                return url == url_without_qs
        elif isinstance(url, re._pattern_type) and url.match(request_url):
            return True
        else:
            return False 
Example 21
Project: nerodia   Author: watir   File: select.py    (license) View Source Project 5 votes vote down vote up
def _find_options(self, how, term):
        types = [six.text_type, six.binary_type, int, re._pattern_type]
        found = []

        def func(sel):
            if type(term) in types:
                collection = sel.options(value=term) if how == 'value' else []
                if not list(collection):
                    collection = sel.options(text=term)
                if not list(collection):
                    collection = sel.options(label=term)
                if collection:
                    found.append(collection)
                    return False
                else:
                    return not found and nerodia.relaxed_locate
            else:
                raise TypeError('expected {!r}, got {}:{}'.format(types, term, term.__class__))

        try:
            Wait.until_not(func, object=self)
            if found:
                return found[0]
            raise NoValueFoundException('{} not found in select list'.format(term))
        except TimeoutError:
            raise NoValueFoundException('{} not found in select list'.format(term)) 
Example 22
Project: nerodia   Author: watir   File: selector_builder.py    (license) View Source Project 5 votes vote down vote up
def _build_wd_selector(self, selectors):
        if any(isinstance(val, re._pattern_type) for val in selectors.values()):
            return None

        expressions = ['./th', './td']
        attr_expr = self.xpath_builder.attribute_expression(None, selectors)

        if attr_expr:
            expressions = ['{}[{}]'.format(e, attr_expr) for e in expressions]

        xpath = " | ".join(expressions)

        logging.debug({'build_wd_selector': xpath})

        return ['xpath', xpath] 
Example 23
Project: nerodia   Author: watir   File: validator.py    (license) View Source Project 5 votes vote down vote up
def match_str_or_regex(str_or_regex, term):
        if isinstance(str_or_regex, re._pattern_type) and str_or_regex.search(term):
            return True
        elif str_or_regex == term:
            return True
        else:
            return False 
Example 24
Project: nerodia   Author: watir   File: locator.py    (license) View Source Project 5 votes vote down vote up
def _delete_regexps_from(selector):
        rx_selector = {}

        for how, what in copy(selector).items():
            if not isinstance(what, re._pattern_type):
                continue
            rx_selector[how] = what
            selector.pop(how)

        return rx_selector 
Example 25
Project: nerodia   Author: watir   File: selector_builder.py    (license) View Source Project 5 votes vote down vote up
def _build_wd_selector(self, selectors):
        if any(isinstance(val, re._pattern_type) for val in selectors.values()):
            return None
        return self._build_xpath(selectors) 
Example 26
Project: crc-diagram   Author: IuryAlves   File: utils.py    (license) View Source Project 5 votes vote down vote up
def regex_compile(pattern, flags=0):
    if not isinstance(pattern, re._pattern_type):
        return re.compile(pattern, flags=flags)
    return pattern 
Example 27
Project: sailcron   Author: a-dekker   File: crontab.py    (license) View Source Project 5 votes vote down vote up
def find_command(self, command):
        """Return an iter of jobs matching any part of the command."""
        for job in list(self.crons):
            if isinstance(command, re._pattern_type):
                if command.findall(job.command):
                    yield job
            elif command in job.command:
                yield job 
Example 28
Project: sailcron   Author: a-dekker   File: crontab.py    (license) View Source Project 5 votes vote down vote up
def find_comment(self, comment):
        """Return an iter of jobs that match the comment field exactly."""
        for job in list(self.crons):
            if isinstance(comment, re._pattern_type):
                if comment.findall(job.comment):
                    yield job
            elif comment == job.comment:
                yield job 
Example 29
Project: Price-Comparator   Author: Thejas-1   File: base_nodes.py    (license) View Source Project 5 votes vote down vote up
def _attribute_match_query(self, attribute_names, query):
        """
        Take a list/tuple of attributes that can match and a query, return True
        if any of the attributes match the query.
        """
        assert isinstance(attribute_names, (list, tuple))

        if isinstance(query, string_instance) and query.startswith("re:"):
            query = re.compile(query[3:])

        for attribute in attribute_names:
            if callable(query):
                if query(attribute):
                    return True

            elif isinstance(query, string_instance) and query.startswith("g:"):
                if fnmatch(attribute, query[2:]):
                    return True

            elif isinstance(query, re._pattern_type):
                if query.match(attribute):
                    return True

            elif isinstance(query, (list, tuple)):
                if attribute in query:
                    return True
            else:
                if attribute == query:
                    return True

        return False 
Example 30
Project: oil   Author: oilshell   File: test_re.py    (license) View Source Project 5 votes vote down vote up
def test_compile(self):
        # Test return value when given string and pattern as parameter
        pattern = re.compile('random pattern')
        self.assertIsInstance(pattern, re._pattern_type)
        same_pattern = re.compile(pattern)
        self.assertIsInstance(same_pattern, re._pattern_type)
        self.assertIs(same_pattern, pattern)
        # Test behaviour when not given a string or pattern as parameter
        self.assertRaises(TypeError, re.compile, 0) 
Example 31
Project: python2-tracer   Author: extremecoders-re   File: test_re.py    (license) View Source Project 5 votes vote down vote up
def test_compile(self):
        # Test return value when given string and pattern as parameter
        pattern = re.compile('random pattern')
        self.assertIsInstance(pattern, re._pattern_type)
        same_pattern = re.compile(pattern)
        self.assertIsInstance(same_pattern, re._pattern_type)
        self.assertIs(same_pattern, pattern)
        # Test behaviour when not given a string or pattern as parameter
        self.assertRaises(TypeError, re.compile, 0) 
Example 32
Project: r2-d7   Author: FreakyDug   File: core.py    (license) View Source Project 5 votes vote down vote up
def register_handler(self, pattern, method):
        if not isinstance(pattern, re._pattern_type):
            pattern = re.compile(pattern)
        self._handlers[pattern] = method 
Example 33
Project: r2-d7   Author: FreakyDug   File: core.py    (license) View Source Project 5 votes vote down vote up
def register_dm_handler(self, pattern, method):
        if not isinstance(pattern, re._pattern_type):
            pattern = re.compile(pattern)
        self._dm_handlers[pattern] = method 
Example 34
Project: python-crontab   Author: doctormo   File: crontab.py    (license) View Source Project 5 votes vote down vote up
def find_command(self, command):
        """Return an iter of jobs matching any part of the command."""
        for job in list(self.crons):
            if isinstance(command, re._pattern_type):
                if command.findall(job.command):
                    yield job
            elif command in job.command:
                yield job 
Example 35
Project: python-crontab   Author: doctormo   File: crontab.py    (license) View Source Project 5 votes vote down vote up
def find_comment(self, comment):
        """Return an iter of jobs that match the comment field exactly."""
        for job in list(self.crons):
            if isinstance(comment, re._pattern_type):
                if comment.findall(job.comment):
                    yield job
            elif comment == job.comment:
                yield job 
Example 36
Project: web_ctp   Author: molebot   File: test_re.py    (license) View Source Project 5 votes vote down vote up
def test_compile(self):
        # Test return value when given string and pattern as parameter
        pattern = re.compile('random pattern')
        self.assertIsInstance(pattern, re._pattern_type)
        same_pattern = re.compile(pattern)
        self.assertIsInstance(same_pattern, re._pattern_type)
        self.assertIs(same_pattern, pattern)
        # Test behaviour when not given a string or pattern as parameter
        self.assertRaises(TypeError, re.compile, 0) 
Example 37
Project: PyDataLondon29-EmbarrassinglyParallelDAWithAWSLambda   Author: SignalMedia   File: common.py    (license) View Source Project 5 votes vote down vote up
def is_re(obj):
    return isinstance(obj, re._pattern_type) 
Example 38
Project: pefile.pypy   Author: cloudtracer   File: test_re.py    (license) View Source Project 5 votes vote down vote up
def test_compile(self):
        # Test return value when given string and pattern as parameter
        pattern = re.compile('random pattern')
        self.assertIsInstance(pattern, re._pattern_type)
        same_pattern = re.compile(pattern)
        self.assertIsInstance(same_pattern, re._pattern_type)
        self.assertIs(same_pattern, pattern)
        # Test behaviour when not given a string or pattern as parameter
        self.assertRaises(TypeError, re.compile, 0) 
Example 39
Project: ouroboros   Author: pybee   File: test_re.py    (license) View Source Project 5 votes vote down vote up
def test_compile(self):
        # Test return value when given string and pattern as parameter
        pattern = re.compile('random pattern')
        self.assertIsInstance(pattern, re._pattern_type)
        same_pattern = re.compile(pattern)
        self.assertIsInstance(same_pattern, re._pattern_type)
        self.assertIs(same_pattern, pattern)
        # Test behaviour when not given a string or pattern as parameter
        self.assertRaises(TypeError, re.compile, 0) 
Example 40
Project: ndk-python   Author: gittor   File: test_re.py    (license) View Source Project 5 votes vote down vote up
def test_compile(self):
        # Test return value when given string and pattern as parameter
        pattern = re.compile('random pattern')
        self.assertIsInstance(pattern, re._pattern_type)
        same_pattern = re.compile(pattern)
        self.assertIsInstance(same_pattern, re._pattern_type)
        self.assertIs(same_pattern, pattern)
        # Test behaviour when not given a string or pattern as parameter
        self.assertRaises(TypeError, re.compile, 0) 
Example 41
Project: pyrocopy   Author: caskater4   File: pyrocopy.py    (license) View Source Project 5 votes vote down vote up
def _normalizeDirPattern(pattern, path):
    bIsRegex = False
    tmpPattern = pattern
    if (isinstance(pattern, re._pattern_type)):
        tmpPattern = pattern.pattern
        bIsRegex = True
    elif (pattern.startswith('re:')):
        tmpPattern = pattern[3:]
        bIsRegex = True

    numPathSep = path.count(os.path.sep)
    numPatternSep = tmpPattern.count(os.path.sep)
    
    # When the path has more levels, fill in the pattern with wildcards
    if (numPathSep > numPatternSep):
        while (numPathSep > numPatternSep):
            if (bIsRegex):
                if (tmpPattern != ''):
                    tmpPattern = tmpPattern + "/.*"
                else:
                    tmpPattern = '.*'
            else:
                tmpPattern = os.path.join(tmpPattern, "*")
            numPatternSep = numPatternSep + 1

    if (bIsRegex):
        return re.compile(tmpPattern)
    else:
        return tmpPattern 
Example 42
Project: pyrocopy   Author: caskater4   File: pyrocopy.py    (license) View Source Project 5 votes vote down vote up
def _normalizeFilePattern(pattern, filepath):
    bIsRegex = False
    tmpPattern = pattern
    if (isinstance(pattern, re._pattern_type)):
        tmpPattern = pattern.pattern
        bIsRegex = True
    elif (pattern.startswith('re:')):
        tmpPattern = pattern[3:]
        bIsRegex = True

    # Separate the file pattern from the dir/path pattern
    patternParts = os.path.split(tmpPattern)
    tmpPattern = patternParts[0]

    numPathSep = filepath.count(os.path.sep)
    numPatternSep = tmpPattern.count(os.path.sep)
    if (tmpPattern != ''):
        numPatternSep = numPatternSep + 1
    
    # When the path has more levels, fill in the pattern with wildcards
    if (numPathSep > numPatternSep):
        while (numPathSep > numPatternSep):
            if (bIsRegex):
                if (tmpPattern != ''):
                    tmpPattern = tmpPattern + "/.*"
                else:
                    tmpPattern = '.*'
            else:
                tmpPattern = os.path.join(tmpPattern, "*")
            numPatternSep = numPatternSep + 1

    # Append the file pattern back
    if (bIsRegex):
        tmpPattern = tmpPattern + "/" + patternParts[1]
    else:
        tmpPattern = os.path.join(tmpPattern, patternParts[1])

    if (bIsRegex):
        return re.compile(tmpPattern)
    else:
        return tmpPattern 
Example 43
Project: sqlalchemy_zdb   Author: skftn   File: operators.py    (license) View Source Project 5 votes vote down vote up
def zdb_like_op(left, right, c, compiler, tables, format_args):
    r"""Implement the ``LIKE`` operator.

    In a normal context, produces the expression::

        column:"foo"

    E.g.::

        stmt = select([sometable]).\
            where(sometable.c.column.like("foo"))


    In a regex context, produces the expression::

        column:~"foo[a-z]"

    E.g.::

        stmt = select([sometable]).\
            where(sometable.c.column.like(re.compile("foo[a-z]")))
    """
    from sqlalchemy_zdb.compiler import compile_clause

    if isinstance(right.value, re._pattern_type):
        _oper = ":~"
    else:
        _oper = ":"

    return "%s%s%s" % (left.name, _oper, compile_clause(right, compiler, tables, format_args)) 
Example 44
Project: sqlalchemy_zdb   Author: skftn   File: compiler.py    (license) View Source Project 5 votes vote down vote up
def compile_clause(c, compiler, tables, format_args):
    if isinstance(c, BindParameter) and isinstance(c.value, (
            str, int, re._pattern_type, ZdbLiteral)):
        if isinstance(c.value, str):
            return "\"%s\"" % escape_tokens(c.value)
        elif isinstance(c.value, re._pattern_type):
            return "\"%s\"" % c.value.pattern
        elif isinstance(c.value, ZdbLiteral):
            return c.value.literal
        else:
            return c.value
    elif isinstance(c, (True_, False_)):
        return str(type(c) == True_).lower()
    elif isinstance(c, TextClause):
        return c.text
    elif isinstance(c, BinaryExpression):
        return compile_binary_clause(c, compiler, tables, format_args)
    elif isinstance(c, BooleanClauseList):
        return compile_boolean_clause_list(c, compiler, tables, format_args)
    elif isinstance(c, Column):
        return compile_column_clause(c, compiler, tables, format_args)
    elif isinstance(c, Grouping):
        return compile_grouping(c, compiler, tables, format_args)
    elif isinstance(c, Null):
        return "NULL"
    raise ValueError("Unsupported clause") 
Example 45
Project: kbe_server   Author: xiaohaoppy   File: test_re.py    (license) View Source Project 5 votes vote down vote up
def test_compile(self):
        # Test return value when given string and pattern as parameter
        pattern = re.compile('random pattern')
        self.assertIsInstance(pattern, re._pattern_type)
        same_pattern = re.compile(pattern)
        self.assertIsInstance(same_pattern, re._pattern_type)
        self.assertIs(same_pattern, pattern)
        # Test behaviour when not given a string or pattern as parameter
        self.assertRaises(TypeError, re.compile, 0) 
Example 46
Project: SignalBotFramework   Author: JankySolutions   File: bot.py    (license) View Source Project 5 votes vote down vote up
def register_handler(self, handler, regex, group):
        if not isinstance(regex, re._pattern_type):
            regex = re.compile(regex)
        self.handlers.append((handler, regex, group)) 
Example 47
Project: ansible-provider-docs   Author: alibaba   File: netcfg.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, indent=1, contents=None, ignore_lines=None):
        self._indent = indent
        self._items = list()
        self._config_text = None

        if ignore_lines:
            for item in ignore_lines:
                if not isinstance(item, re._pattern_type):
                    item = re.compile(item)
                DEFAULT_IGNORE_LINES_RE.add(item)

        if contents:
            self.load(contents) 
Example 48
Project: widgetastic.patternfly   Author: RedHatQE   File: __init__.py    (license) View Source Project 5 votes vote down vote up
def _repr_step(image, step):
        if isinstance(step, re._pattern_type):
            # Make it look like r'pattern'
            step_repr = 'r' + re.sub(r'^[^"\']', '', repr(step.pattern))
        else:
            step_repr = step
        if image is None:
            return step_repr
        else:
            return '{}[{}]'.format(step_repr, image) 
Example 49
Project: futhon   Author: delihiros   File: futhon_parser_test.py    (license) View Source Project 5 votes vote down vote up
def test_regex_string(self):
        parser = futhon_parser.FuthonParser()
        self.assertIsInstance(parser.parse("#\"\""),
                              re._pattern_type)
        self.assertIsInstance(parser.parse("#\"hello\""),
                              re._pattern_type) 
Example 50
Project: ReGraph   Author: Kappa-Dev   File: attribute_sets.py    (license) View Source Project 5 votes vote down vote up
def _regex_to_string(a):
    if isinstance(a, str):
        return a
    elif isinstance(a, re._pattern_type):
        return a.pattern
    elif isinstance(a, RegexSet):
        if a.pattern is not None:
            return a.pattern
        else:
            return None
    else:
        raise AttributeSetError("Cannot convert regex to string!")