Python re.re_match函数代码示例

 def _compareAttribute(self, node1, node2, attr):
     attr1 = node1.getAttribute(attr)
     attr2 = node2.getAttribute(attr)
     if attr2.startswith("regexp:"):
         return bool(re_match(attr2[7:], attr1))
     elif attr2.startswith("glob:"):
         return bool(re_match(glob_trans(attr2[5:]), attr1))
     else:
         return attr1 == attr2

 def route_for_task(self, task, args=None, kwargs=None):
     parts = task.split('.')
     if re_match(r'^mp[a-z_]+\.sync\.[a-z_]+$', task) is not None:
         return {
             'routing_key': task,
             'queue': parts[0] + '.sync',
             }
     elif re_match(r'^mp[a-z_]+\.async\.[a-z_]+$', task) is not None:
         return {
             'routing_key': task,
             'queue': parts[0] + '.async',
             }
     return None

    def create_user(self, first, last, gender="M", username=None, password=None, role="Provider"):
        url = self.base + USER_FORM_URL

        if not first:
            raise CreateUserException("Given name can't be blank")
        first_names = first.split()

        if not last:
            raise CreateUserException("Family name can't be blank")

        if not username:
            username = "".join([c[0] for c in first_names] + [last]).lower()

        if not password:
            password = []
            for i in range(0, 3):
                password += [random.choice(string.digits), random.choice(string.lowercase)]
            random.shuffle(password)
            password = "".join(password)
        else:
            if (
                len(password) < 6
                or not (re_match("\d", password) and re_match("[a-zA-Z]", password))
                or re_match("\s", password)
            ):
                raise CreateUserException(
                    "Password must be at least six " "characters and contain at least " "one letter and number"
                )

        params = {}
        if len(first_names) > 1:
            params.update({"names[0].middleName": first_names.pop().title()})

        params.update(
            {
                "names[0].givenName": " ".join(first_names).title(),
                "names[0].familyName": last.title(),
                "gender": gender,
                "username": username.lower(),
                "userFormPassword": password,
                "confirm": password,
                "roleStrings": role,
            }
        )

        data = urlencode(params)
        response = self.opener.open(url, data).read()
        if response.find("Username or System Id taken") != -1:
            raise CreateUserException("Username taken")

def versions_from_file(filename):
   versions = {}
   try:
      with open(filename) as f:
         for line in f.readlines():
            mo = re_match("version_version = '([^']+)'", line)
            if mo:
               versions['version'] = mo.group(1)
            mo = re_match("version_full = '([^']+)'", line)
            if mo:
               versions['full'] = mo.group(1)
   except EnvironmentError:
      return {}

   return versions

    def __init__( self, data, b0_thr = 0 ) :
        """Initialize the acquisition scheme.

        Parameters
        ----------
        data : string or numpy.ndarray
            The filename of the scheme or a matrix containing the actual values
        b0_thr : float
            The threshold on the b-values to identify the b0 images (default: 0)
        """
        if type(data) is str :
            # try loading from file
            try :
                n = 0 # headers lines to skip to get to the numeric data
                with open(data) as fid :
                    for line in fid :
                        if re_match( r'[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?', line.strip() ) :
                            break
                        n += 1
                tmp = np.loadtxt( data, skiprows=n )
            except :
                raise IOError( 'Unable to open scheme file' )
            self.load_from_table( tmp, b0_thr )
        else :
            # try loading from matrix
            self.load_from_table( data, b0_thr )

def get_platform():

    from os.path import exists
    from re import match as re_match

    platforms = []
    arch = run_output('uname', '-m').replace('686', '386')
    platforms.append(arch)

    if exists('/etc/debian_version'):
        platforms.append('debian')

    if exists('/etc/redhat-release'):
        platforms.append('redhat')

        version = file('/etc/redhat-release').read().strip()
        badge = 'Red Hat Enterprise Linux Server release (\d+)\.(\d+)'
        match = re_match(badge, version)
        if match:
            platforms.append('rhel%s' % match.group(1))

    if exists('/etc/arch-release'):
        platforms.append('archlinux')

    verbose('PLATFORMS: %s' % ",".join(platforms))
    return platforms

 def _glob_match(self, pattern, string):
     """
     Match given string, by escaping regex characters
     """
     # regex flags Multi-line, Unicode, Locale
     return bool(re_match(glob_trans(pattern), string,
                          re.M | re.U | re.L))

 def _stem_with_duplicate_character_check(word, del_len):
     if word[-1] == 's':
         del_len += 1
     stemmed_word = word[:-del_len]
     if re_match(r'.*(\w)\1$', stemmed_word):
         stemmed_word = stemmed_word[:-1]
     return stemmed_word

def parse_option(args, spec, options={}, header='', footer=''):
    from re import match as re_match
    from getopt import getopt, GetoptError
    help_message = header
    short_opt, long_opt, opt_cond = '', [], {}
    for line in spec.splitlines():
        match = re_match('([a-z])\|(\w+)([:=])(.+)', line)
        if not match:
            continue
        opt_s, opt_l, opt_v, opt_h = match.groups()
        help_message = (help_message +
                        '\n-%s, --%s\t\t%s' % (opt_s, opt_l, opt_h))
        opt_cond['-' + opt_s] = opt_l
        opt_cond['--' + opt_l] = opt_l
        if opt_v == '=':
            opt_s = opt_s + ':'
            opt_l = opt_l + '='
        short_opt = short_opt + opt_s
        long_opt.append(opt_l)

    help_message = help_message + '\n' + footer
    try:
        opts, args = getopt(args, short_opt, long_opt)
        for optname, optval in opts:
            if optname in opt_cond:
                options[opt_cond[optname]] = optval
        return options
    except GetoptError as err:
        from sys import stderr, exit
        print >>stderr, 'ERROR:', str(err)
        print >>stderr, '\n', help_message, '\n'
        exit(1)

def do_get_blog_tag_posts(parser, token):
    """
    Get the blog Posts for a specified tag and store it in a context variable.
    
    Usage::

      {% get_blog_tag_posts [tag_name] as [varname] %}
    
    tag should be a variable or a quoted string

    Example::
    
      {% get_blog_tag_posts "django" as blog_posts %}
    
    """
    try:
        tag_name, arg = token.contents.split(None, 1)
    except ValueError:
        raise template.TemplateSyntaxError(
            '%r tag requires arguments' % token.contents.split()[0])
    m = re_match(r'(.*?) as (\w+)', arg)
    if not m:
        raise template.TemplateSyntaxError(
            '%r tag had invalid arguments' % tag_name)
    tag, var_name = m.groups()
    return BlogTagPostsNode(tag, var_name)

def o_b58(r160, magicbyte=0):
    """ Base58 encoding w leading zero compact
    """
    from re import match as re_match
    inp_fmtd = chr(int(magicbyte)) + r160
    leadingzbytes = len(re_match('^\x00*', inp_fmtd).group(0))
    checksum = hashlib.sha256(hashlib.sha256(inp_fmtd).digest()).digest()[:4]
    return '1' * leadingzbytes + encode(decode(inp_fmtd + checksum, 256), 58, 0)

def base58Encode(r160, magicbyte=0, prefix=1, length=0):
	""" Base58 encoding w leading zero compact
	"""
	from re import match as re_match
	inp_fmtd = chr(int(magicbyte if magicbyte < 255 else 255)) + r160
	leadingzbytes = len(re_match('^\x00*', inp_fmtd).group(0))
	checksum = hashlib.sha256(hashlib.sha256(inp_fmtd).digest()).digest()[:4]
	return str(prefix) * leadingzbytes + enc.encode(enc.decode(inp_fmtd + checksum, 256), 58, 0)

def match_regexp(transition, event, _token, _fsa):
    """
    The 'regexp' matcher.

    With this matcher,
    transition conditions are interpreted as regular expressions.
    Note that the *whole* event must match the regular expression
    (this is ensured by automatically prepending ``^`` and appending ``$`` to the condition).
    """
    return re_match('^%s$' % transition['condition'], event)

 def normalise_email(self):
     """
     Normalise the email address provides into an account URL
     """
     url = urlparse(self.request_email, "acct")
     if url.scheme != "acct":
         raise TypeError()
     self.request_email = url
     match = re_match(".*\@(.*)", url.path)
     self.hostmeta = HostMeta(match.group(1))

    def strip_url(url):
        split_results = urlsplit(url)
        path = split_results.path

        path_match = re_match("/(sales|lettings)/(.*?)/(\d*)/?", path)
        category, tag, prop_id = path_match.groups() \
                if path_match \
                else ("", "", "")

        return category, tag, prop_id