def parse_user_name(user_name: str) -> str:
"""Checks if ``user_name`` is valid.
Parameters
----------
user_name : str
Possible user name.
Returns
-------
user_name : str
Valid user name.
Raises
------
click.BadParameter
If user name is not valid.
"""
if re.fullmatch(r'^[a-z][a-z0-9_]{5,}', user_name):
return user_name
else:
raise click.BadParameter(
'ERROR: Use at least six lower-case characters, '
'digits and underscores.', param=user_name)
python类fullmatch()的实例源码
def parse_password(password: str) -> str:
"""Checks if ``password`` is suffiently strong.
Parameters
----------
password : str
Possible password.
Returns
-------
password : str
Valid password.
Raises:
click.BadParameter
If password is not sufficiently strong.
"""
if password in ['password', 'hallo123', 'admin']:
raise click.BadParameter('ERROR: You are kidding, right?')
elif re.fullmatch(r'[A-Za-z0-9]{{{},}}'.format(PASSWORD_LENGTH), password):
return password
else:
raise click.BadParameter('ERROR: Use only alphanumeric characters.')
def parse_port(port: str) -> str:
"""Checks if port is valid.
Parameters
----------
port : str
Possible port name.
Returns
-------
port : str
Valid port name
Raises
------
click.BadParameter
If ``port`` is not a four-digit number not starting with zero.
"""
if re.fullmatch(r'^[1-9][0-9]{,3}', port):
return port
else:
raise click.BadParameter(
'ERROR: Use up to four digits not starting with zero.')
def parse_table_name(table_name: str) -> str:
"""Checks if ``table_name`` is a valid name for a PostgreSQL table.
Parameters
----------
table_name : str
Possible table name.
Returns
-------
table_name : str
Valid table name
Raises
------
click.BadParameter
If ``table_name`` is not valid for PSQL.
"""
if re.fullmatch(r'^[a-z][a-z_]{5,}', table_name):
return table_name
else:
raise click.BadParameter(
'ERROR: Use only lower-case characters and underscores.')
def test_file_writer_decorator(call, call_init_kwargs, call_kwargs, dec_kwargs, exp, tmpdir):
tmp_dec_kwargs = dict(dec_kwargs)
tmp_dec_kwargs['filename'] = os.path.join('%s' % tmpdir, dec_kwargs['filename'])
call = fuzzinator.call.FileWriterDecorator(**tmp_dec_kwargs)(call)
if inspect.isclass(call):
call = call(**call_init_kwargs)
out = call(**call_kwargs)
if out is not None:
assert re.fullmatch(pattern=dec_kwargs['filename'].format(uid='.*'), string=out['filename']) is not None
assert out['test'] == os.path.join('%s' % tmpdir, out['filename'])
assert not os.path.exists(out['test'])
del out['filename']
del out['test']
assert out == exp
def cli(ctx, url):
""" Thumb-up issues, PRs, or comments thereon """
for u in url:
m = re.fullmatch(r'(?:https?://)?(?:www\.)?github\.com'
r'/(?P<owner>[^/]+)'
r'/(?P<repo>[^/]+)'
r'/(?:issues|pull)'
r'/(?P<issue>\d+)'
r'(?:#issuecomment-(?P<comment>\d+))?', u)
if not m:
click.echo('{}: could not parse {!r}'.format(ctx.command_path, u),
err=True)
continue
endpoint = ctx.obj.repos[m.group('owner')][m.group('repo')].issues
if m.group('comment') is None:
endpoint = endpoint[m.group('issue')].reactions
else:
endpoint = endpoint.comments[m.group('comment')].reactions
endpoint.post(json={"content": "+1"})
def __init__(self, text: str, start_location: Location, end_location: Location):
super().__init__(text, start_location, end_location)
if self._clean_text.startswith('0b'):
self._base = IntegerBase.base2
m = re.fullmatch(self._regex2, self._clean_text)
elif self._clean_text.startswith('0o'):
self._base = IntegerBase.base8
m = re.fullmatch(self._regex8, self._clean_text)
elif self._clean_text.startswith('0x'):
self._base = IntegerBase.base16
m = re.fullmatch(self._regex16, self._clean_text)
else:
self._base = IntegerBase.base10
m = re.fullmatch(self._regex10, self._clean_text)
if m is None:
raise SyntacticalError(self, 'Malformed {}'.format(self.short_name()))
self._value = int(m.group(1), self._base.value)
suffix = m.group(2)
if suffix is not None:
self._kind = IntegerKind(suffix)
else:
self._kind = IntegerKind.NONE
def GetColumnAsSnakeCase(self) -> str:
"""SQL column name to snake case.
Returns:
str: the column name from the SQL in snake case
"""
if re.fullmatch("[a-zA-Z0-9]*", self.sql_column):
substitute_first_part = re.sub('(.)([A-Z][a-z]+)', r'\1_\2',
self.sql_column)
substitute_second_part = re.sub(
'([a-z0-9])([A-Z])', r'\1_\2', substitute_first_part).lower()
return substitute_second_part
else:
return self.sql_column.lower()
def ExecuteQueryDetailed(
self, query: str) -> sql_query_data.SQLQueryData:
"""Executes the SQL Query and gets detailed information.
Args:
query (str): The SQL Query to execute on the SQLite database.
Returns:
sql_query_data.SQLQueryData: The data to the Query
"""
query_data = sql_query_data.SQLQueryData(
data=None, has_error=True, columns=None)
if not re.fullmatch('[A-Za-z,.;*=_0-9 ]*', query):
query_data.error_message = ('Warning: Don\'t use any characters beside'
' a-z A-Z 0-9 . ; , * = _')
return query_data
if query.lower()[query.lower().find(' from '):].find(' as ') != -1:
query_data.error_message = ('Warning: '
'Don\'t use any alias for a table name')
return query_data
data_from_executed_query = self._ExecuteQuery(query, True)
if not data_from_executed_query.has_error:
duplicate_names = self._type_helper.GetDuplicateColumnNames(
data_from_executed_query.columns)
if duplicate_names:
duplicate_names_as_string = ' '.join(duplicate_names)
data_from_executed_query.has_error = True
data_from_executed_query.error_message = (
'Please use an alias (AS) for '
'those column names: {0}'.format(duplicate_names_as_string))
if not data_from_executed_query.has_error:
data_from_executed_query.columns = (
self._type_helper.AddMissingTypesFromSchema(
data_from_executed_query.columns, query))
return data_from_executed_query
def parse_float_value_from_text_stream(text, key):
"""Parse float value from the text.
Go through all lines of the text file, find the line with given key
and parse float value specified here.
"""
regexp = key + "\s*=\s*(\d.\d*)"
for line in text.split("\n"):
if line.startswith(key):
# the key was found, now try to find and parse the float value
match = re.fullmatch(regexp, line)
assert match is not None
assert match.lastindex == 1
return float(match.group(1))
def filter_pattern(values, pattern):
for value in values:
if not pattern or fullmatch(pattern, value):
yield value
def __getitem__(self, name: str) -> str:
if name not in self.keys():
with _GLOBAL_LOCK:
if re.fullmatch(_ALLOWED_NAME, name) is None:
raise exceptions.BotoEra(
("Unacceptable API Method Name: {}, "
"r\"^[a-z]([a-z\_]+)?$\" is expected.").format(name))
self[name] = name.strip().replace("_", "")
return dict.__getitem__(self, name)
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = tkinter.Tcl()
patchlevel = tcl.call('info', 'patchlevel')
m = re.fullmatch(r'(\d+)\.(\d+)([ab.])(\d+)', patchlevel)
major, minor, releaselevel, serial = m.groups()
major, minor, serial = int(major), int(minor), int(serial)
releaselevel = {'a': 'alpha', 'b': 'beta', '.': 'final'}[releaselevel]
if releaselevel == 'final':
_tk_patchlevel = major, minor, serial, releaselevel, 0
else:
_tk_patchlevel = major, minor, 0, releaselevel, serial
return _tk_patchlevel
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = tkinter.Tcl()
patchlevel = tcl.call('info', 'patchlevel')
m = re.fullmatch(r'(\d+)\.(\d+)([ab.])(\d+)', patchlevel)
major, minor, releaselevel, serial = m.groups()
major, minor, serial = int(major), int(minor), int(serial)
releaselevel = {'a': 'alpha', 'b': 'beta', '.': 'final'}[releaselevel]
if releaselevel == 'final':
_tk_patchlevel = major, minor, serial, releaselevel, 0
else:
_tk_patchlevel = major, minor, 0, releaselevel, serial
return _tk_patchlevel
def _parameters_valid(meetup_name, event_id):
return re.fullmatch('[0-9a-zA-Z-]*', meetup_name) and re.fullmatch('[0-9]*', event_id)
def parse_log(self, logdir):
logpath = self.find_log(logdir)
if not logpath:
return {}
fh = open(logpath, "rt", encoding='cp437')
try:
stage_pattern = re.compile(r'^\S+\s+\S+\s+Texture stage #(\d+)\s.*\\([^\\]+)\\(Tex_\d+_\d+\.dds)\s*$')
mesh_pattern = re.compile(r'^\S+\s+\S+\s+Mesh saved as:.*\\([^\\]+)\\(Mesh_\d+\.rip)\s*$')
logtable = {}
stage_accum = {}
for line in fh:
match = mesh_pattern.fullmatch(line)
if match:
subdir = match.group(1).lower()
if subdir not in logtable:
logtable[subdir] = {}
logtable[subdir][match.group(2).lower()] = stage_accum
stage_accum = {}
else:
match = stage_pattern.fullmatch(line)
if match:
stage_accum[int(match.group(1))] = match.group(3)
return logtable
finally:
fh.close()
def check_mac_format(mac):
if not re.fullmatch('([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}', mac):
return False
return True
def _is_valid_fn_name(maybe_fn_name: str) -> bool:
"""
Check if this is a valid function name.
"""
return (re.fullmatch(_VALID_FN_NAME_RE, maybe_fn_name) is not None)
def ldh_convert_check(name):
name_con = re.sub(r'[^-a-z0-9]', '-', name.lower())
logging.info("Converted \"{}\" to \"{}\" for"
" TPR/CRD name".format(name, name_con))
if not re.fullmatch('[a-z0-9]([-a-z0-9]*[a-z0-9])?', name_con):
logging.error("Cant create valid TPR/CRD name using "
"\"{}\" - must match regex "
"[a-z0-9]([-a-z0-9]*[a-z0-9])?".format(name_con))
exit(1)
return name_con
