def quote_split(s, splitchar=';'):
rv = [""]
inquote = False
for i in xrange(len(s)):
if not inquote and s[i]==splitchar:
rv.append( "" )
continue
rv[-1] = rv[-1] + s[i]
if s[i]=="'":
inquote = not inquote
return rv
## Return a compiled regex which matches the word-boundaried word 'x'
## See http://docs.python.org/2/library/re.html under the "\b"
## special matcher
python类html()的实例源码
def set_html(self, html):
"""
When setting the html for this Google Document we do two
things:
1. We extract the content from the html. Using a regular
expression we pull the meat of the document out of the body
of the html, we also cut off the footer Google adds on
automatically.
2. We extract the various sections from the content of the
document. Again using a regular expression, we look for h1,
h2, ... tags to split the document up into sections. Note:
it is important when you are writing your Google Document
to use the heading text styles, so this code will split
things correctly.
"""
self._html = html
self._extract_content()
self._extract_sections()
def _construct_section_tree(self):
"""
For some weird reason Google Documents doesn't like nesting
lists, so their table of contents requires a bunch of special
formatting. Instead of trying to hack off what they provide
us, we create a tree of sections based on each sections
level. This tree will be used to construct the html for the
table of contents.
"""
self._section_tree = TreeNode(Section(level=0))
current_node = self._section_tree
for section in self._sections:
while section['level'] <= current_node.value['level']:
current_node = current_node.parent
while section['level'] > current_node.value['level'] + 1:
empty_section = Section(level=current_node.value['level'] + 1)
current_node = current_node.add_child(empty_section)
assert section['level'] == current_node.value['level'] + 1
current_node = current_node.add_child(section)
def _navigation_list(self, node=None):
"""
Return an html representation of the table of contents for
this document. This is done recursively adding on a list item
for each element in the tree, and an unordered list if this
node has children. I might want to double check that this html
is the correct way to nest lists.
"""
if node is None:
self._construct_section_tree()
return self._navigation_list(self._section_tree)
result = ""
if 'title' in node.value and 'id' in node.value:
result += '<li>%s</li>' % node.value.url()
if len(node) > 0:
result += "<ul>%s</ul>" % \
"\n".join([self._navigation_list(child) for child in node])
return result
def get_db_connection():
if DbHelperM.__db_connection is None:
DbHelperM.__db_connection = sqlite3.connect(wbd.wbd_global.get_database_filename())
# Upgrading the database
# Very good upgrade explanation:
# http://stackoverflow.com/questions/19331550/database-change-with-software-update
# More info here: https://www.sqlite.org/pragma.html#pragma_schema_version
current_db_ver_it = get_schema_version(DbHelperM.__db_connection)
target_db_ver_it = max(upgrade_steps)
for upgrade_step_it in range(current_db_ver_it + 1, target_db_ver_it + 1):
if upgrade_step_it in upgrade_steps:
upgrade_steps[upgrade_step_it](DbHelperM.__db_connection)
set_schema_version(DbHelperM.__db_connection, upgrade_step_it)
DbHelperM.__db_connection.commit()
# TODO: Where do we close the db connection? (Do we need to close it?)
# http://stackoverflow.com/questions/3850261/doing-something-before-program-exit
return DbHelperM.__db_connection
def set_html(self, html):
"""
When setting the html for this Google Document we do two
things:
1. We extract the content from the html. Using a regular
expression we pull the meat of the document out of the body
of the html, we also cut off the footer Google adds on
automatically.
2. We extract the various sections from the content of the
document. Again using a regular expression, we look for h1,
h2, ... tags to split the document up into sections. Note:
it is important when you are writing your Google Document
to use the heading text styles, so this code will split
things correctly.
"""
self._html = html
self._extract_content()
self._extract_sections()
def _construct_section_tree(self):
"""
For some weird reason Google Documents doesn't like nesting
lists, so their table of contents requires a bunch of special
formatting. Instead of trying to hack off what they provide
us, we create a tree of sections based on each sections
level. This tree will be used to construct the html for the
table of contents.
"""
self._section_tree = TreeNode(Section(level=0))
current_node = self._section_tree
for section in self._sections:
while section['level'] <= current_node.value['level']:
current_node = current_node.parent
while section['level'] > current_node.value['level'] + 1:
empty_section = Section(level=current_node.value['level'] + 1)
current_node = current_node.add_child(empty_section)
assert section['level'] == current_node.value['level'] + 1
current_node = current_node.add_child(section)
def _navigation_list(self, node=None):
"""
Return an html representation of the table of contents for
this document. This is done recursively adding on a list item
for each element in the tree, and an unordered list if this
node has children. I might want to double check that this html
is the correct way to nest lists.
"""
if node is None:
self._construct_section_tree()
return self._navigation_list(self._section_tree)
result = ""
if 'title' in node.value and 'id' in node.value:
result += '<li>%s</li>' % node.value.url()
if len(node) > 0:
result += "<ul>%s</ul>" % \
"\n".join([self._navigation_list(child) for child in node])
return result
def assert_found(patt, filename, msg=None, encoding='utf-8'):
"""Assert that regex pattern ``patt`` is found in the file ``filename``.
:arg patt: The regex pattern to search.
Any standard Python `regular expression
<https://docs.python.org/3.6/library/re.html#regular-expression-syntax>`_
is accepted.
:arg filename: The name of the file to examine.
Any :class:`OSError` raised while processing the file will be
propagated as a :class:`reframe.core.exceptions.SanityError`.
:arg encoding: The name of the encoding used to decode the file.
:returns: ``True`` on success.
:raises reframe.core.exceptions.SanityError: if assertion fails.
"""
num_matches = count(finditer(patt, filename, encoding))
try:
evaluate(assert_true(num_matches))
except SanityError:
error_msg = msg or "pattern `{0}' not found in `{1}'"
raise SanityError(_format(error_msg, patt, filename))
else:
return True
def extractall(patt, filename, tag=0, conv=None, encoding='utf-8'):
"""Extract all values from the capturing group ``tag`` of a matching regex
``patt`` in the file ``filename``.
:arg patt: The regex pattern to search.
Any standard Python `regular expression
<https://docs.python.org/3.6/library/re.html#regular-expression-syntax>`_
is accepted.
:arg filename: The name of the file to examine.
:arg encoding: The name of the encoding used to decode the file.
:arg tag: The regex capturing group to be extracted.
Group ``0`` refers always to the whole match.
Since the file is processed line by line, this means that group ``0``
returns the whole line that was matched.
:arg conv: A callable that takes a single argument and returns a new value.
If provided, it will be used to convert the extracted values before
returning them.
:returns: A list of the extracted values from the matched regex.
:raises reframe.core.exceptions.SanityError: In case of errors.
"""
return list(evaluate(x)
for x in extractiter(patt, filename, tag, conv, encoding))
def __str__(self):
return "the command '{0}' is unknown".format(self.msg)
## The command object will use a "line source" object which
## should expose (at least) the context protocol
## (http://docs.python.org/2/library/stdtypes.html#context-manager-types)
## and the iterator protocol
## (http://docs.python.org/2/library/stdtypes.html#iterator-types)
##
## The ".run( <linesource> )" method uses the line source object
## as:
## self.run( <linesource> ):
## with <linesource> as tmp:
## for line in tmp:
## execute( line )
##
## This allows the linesource object to create a context which
## will be automagically destroyed when the ".run()" is finished.
##
## The "readkbd" line source class uses this context to save &
## restore the current history [== Python interactive shell's history]
## and to restore and save the history of the command line environment,
## the application's interactive shell.
##
## This way the two histories remain nicely separated/unpolluted
## This is the base class implementing a push/pop of current history
## and push/pop of (temporary) alternative history. Classes which
## want their own readline history saved can derive from this one.
def run(self):
"""Run module's code."""
conversations = self._get_conversation_list()
# Output
title = "Conversation List"
header = None
output_format = self.get_option_value("OUTPUT_FORMAT").lower()
if (output_format == "stdout"):
print title
self._print_table(conversations)
elif (output_format == "html"):
if (not os.path.isdir(self.output_dir)):
os.mkdir(self.output_dir)
output_prefix = self.get_option_value("OUTPUT_FILE_NAME_PREFIX")
file_full_path = self.output_dir + "/" + output_prefix + ".html"
html.create_document_from_row_list(title,
header,
conversations,
file_full_path)
print "Output saved to: " + file_full_path
elif (output_format == "pdf"):
if (not os.path.isdir(self.output_dir)):
os.mkdir(self.output_dir)
output_prefix = self.get_option_value("OUTPUT_FILE_NAME_PREFIX")
file_full_path = self.output_dir + "/" + output_prefix + ".pdf"
pdf.create_document_from_row_list(title,
header,
conversations,
file_full_path)
print "Output saved to: " + file_full_path
else:
print "Unsupported OUTPUT_FORMAT"
# ***************************************************************
# HELPER methods
# ***************************************************************
def to_html(self):
return render_to_string('section.html', self)
def _extract_sections(self):
"""
Here is an example of what a section header looks like in the
html of a Google Document:
<h3 class="c1"><a name="h.699ffpepx6zs"></a><span>Hello World
</span></h3>
We split the content of the Google Document up using a regular
expression that matches the above header. re.split is a pretty
cool function if you haven't tried it before. It puts the
matching groups into the list as well as the content between
the matches. Check it out here:
http://docs.python.org/library/re.html#re.split
One big thing we do in this method is replace the ugly section
id that Google creates with a nicely slugified version of the
section title. This makes for pretty urls.
"""
self._sections = []
header = r'<h(?P<level>\d) class="[^"]+">' \
r'<a name="(?P<id>[^"]+)"></a>' \
r'<span>(?P<title>[^<]+)</span>' \
r'</h\d>'
l = re.split(header, self._content)
l.pop(0)
while l:
section = Section(
# hack: cause we started with h3 in google docs
level=int(l.pop(0)) - 2,
id=l.pop(0),
title=l.pop(0).decode('utf8'),
content=l.pop(0),
)
section['id'] = slugify(section['title'])
if section['level'] >= 1:
self._sections.append(section)
def to_html(self):
"""
Return a cleaned up HTML representation of this Google
Document.
"""
return render_to_string('google_doc.html', {
'nav': self._navigation_html(),
'content': '\n'.join([s.to_html() for s in self._sections])})
def any_of(s):
"""s must be in the right format.
See https://docs.python.org/3/library/re.html#regular-expression-syntax ."""
return wrap('[', Dinant(s, escape=False), ']')
# another helper function
def simple_lexer(rules):
"""
A very simple lexer factory based on a recipe on Python's regex module.
"""
# This is a simplified version of the techique described at
# https://docs.python.org/3/library/re.html#writing-a-lexer
regex = '|'.join(r'(?P<%s>%s)' % item for item in rules)
regex += r'|(?P<whitespace>\s+)|(?P<error>.+)'
regex = re.compile(regex)
def lexer(expr):
for match in re.finditer(regex, expr):
typ = match.lastgroup
value = match.group(typ)
if typ == 'whitespace':
continue
elif typ == 'error':
raise SyntaxError('invalid value: %r' % value)
yield Token(typ, value)
lexer.which = 'simple'
return lexer
def get_all_tags_or_friends(i_special_char_str: str) -> list:
ret_tag_tuple_list_list = []
# ret_tag_tuple_list_list: [("#tag1", [id1, id2, ___]), ("#tag2", [id1, id3, ___]), ___]
db_connection = DbHelperM.get_db_connection()
db_cursor = db_connection.cursor()
db_cursor_result = db_cursor.execute(
"SELECT * FROM " + DbSchemaM.DiaryEntryTable.name
+ " WHERE " + DbSchemaM.DiaryEntryTable.Cols.diary_entry
+ " LIKE " + '"%' + i_special_char_str + '%"'
)
# -http://sqlite.org/lang_expr.html#like
diary_db_te_list = db_cursor_result.fetchall()
for diary_db_te in diary_db_te_list:
diary_entry = DiaryEntryM(*diary_db_te)
string_with_hashtag_str = diary_entry.diary_text
t_diary_id_int = diary_entry.id
regexp_pattern_obj = re.compile("\\" + i_special_char_str + r"\w+")
# Please note: we need to escape the caret ("^") character becase this is a
# special character ("literal")
regexp_search_result_list = regexp_pattern_obj.findall(string_with_hashtag_str)
# https://docs.python.org/3/library/re.html
for t_re_tag_str in regexp_search_result_list:
# -regexp_search_result_list: ["#tag1", "#tag2", ___]
flag_boolean = False
for (t_ret_tag_str, t_ret_diary_id_list) in ret_tag_tuple_list_list:
if t_re_tag_str == t_ret_tag_str:
t_ret_diary_id_list.append(t_diary_id_int)
flag_boolean = True
break
if flag_boolean:
break
else:
ret_tag_tuple_list_list.append((t_re_tag_str, [t_diary_id_int]))
db_connection.commit()
# TODO: Removing duplicates
return ret_tag_tuple_list_list
def _get_mpl_date(dates, fmt='%d.%m.%Y %H:%M'):
"""Convert date strings into matplotlib time format.
Parameters:
dates (ndarray): Array containing date strings.
fmt (str): Date string format [0].
[0] http://pubs.opengroup.org/onlinepubs/009695399/functions/strptime.html
Returns:
np.array: Matplotlib time values.
"""
return np.array([strpdate2num(fmt)(d) for d in dates])
def read_profile(filename, var_regex=None, var_key='PROFILE', **kwargs):
"""Read scattering coefficients from CSV file.
Parameters:
filename (str): Path to CSV file.
var_regex (str): Python regular expression [0] matching
the variable name of the profile.
var_key (str): Dictionary key for extracted profile.
**kwargs: Additional keyword arguments passed to `read`.
[0] https://docs.python.org/3.1/library/re.html
Returns:
dict: Dictionary containing the data arrays and the stacked profile.
"""
profile_key = var_key + '_Z'
output = read(filename, **kwargs)
p = re.compile(var_regex)
var_names = [var for var in output.keys() if p.match(var)]
var_names.sort()
profile = np.vstack([output[v] for v in var_names])
z = [float(re.sub('[^0-9]', '', v)) for v in var_names]
# Extract height information from variable name.
output[var_key] = np.ma.masked_invalid(profile)
output[profile_key] = np.array(z)
return output
def read_scat(filename, var_regex='CLB_B\d{5}', var_key='CLB_MATRIX',
**kwargs):
"""Read scattering coefficients from CSV file.
Parameters:
filename (str): Path to CSV file.
var_regex (str): Python regular expression [0] matching
the variable name of the profile.
var_key (str): Dictionary key for extracted profile.
**kwargs: Additional keyword arguments passed to `read_profile`.
[0] https://docs.python.org/3.1/library/re.html
Returns:
ndarray, ndarray: scattering coefficient, height levels
"""
output = read_profile(
filename,
var_key=var_key,
var_regex=var_regex,
**kwargs,
)
back_scat = output[var_key]
back_scat = np.ma.masked_less(back_scat, 0)
output[var_key] = back_scat
return output
def to_html(self):
return render_to_string('section.html', self)
def _extract_sections(self):
"""
Here is an example of what a section header looks like in the
html of a Google Document:
<h3 class="c1"><a name="h.699ffpepx6zs"></a><span>Hello World
</span></h3>
We split the content of the Google Document up using a regular
expression that matches the above header. re.split is a pretty
cool function if you haven't tried it before. It puts the
matching groups into the list as well as the content between
the matches. Check it out here:
http://docs.python.org/library/re.html#re.split
One big thing we do in this method is replace the ugly section
id that Google creates with a nicely slugified version of the
section title. This makes for pretty urls.
"""
self._sections = []
header = r'<h(?P<level>\d) class="[^"]+">' \
r'<a name="(?P<id>[^"]+)"></a>' \
r'<span>(?P<title>[^<]+)</span>' \
r'</h\d>'
l = re.split(header, self._content)
l.pop(0)
while l:
section = Section(
# hack: cause we started with h3 in google docs
level=int(l.pop(0)) - 2,
id=l.pop(0),
title=l.pop(0).decode('utf8'),
content=l.pop(0),
)
section['id'] = slugify(section['title'])
if section['level'] >= 1:
self._sections.append(section)
def to_html(self):
"""
Return a cleaned up HTML representation of this Google
Document.
"""
return render_to_string('google_doc.html', {
'nav': self._navigation_html(),
'content': '\n'.join([s.to_html() for s in self._sections])})
def _convert_simple_pattern(self, regex_string): # EXPERIMENTAL
"""This is EXPERIMENTAL: Consider option to recognize "simple" patterns and
automatically put them in the trie, otherwise use Python matcher.
Convet a simple pattern to a form that can be inserted into a
`RegexTrieDict`, if possible. Returns `None` if the pattern is too
complicated. Simple pattern is essentially defined by what this routine
is implemented to do (and a `RegexTrieDict` can/should do)"""
return None
# TODO the immediate below seems to work for some very simple patterns.
simple_regex_patt = re.compile(r"^[a-zA-Z0-9_\-]+$", re.VERBOSE|re.UNICODE)
match = simple_regex_patt.match(regex_string)
if match is None: return None
return regex_string # No processing needed for very simple.
# SCRATCH BELOW
# Note negative lookbehind assertion (?<!\\) for escape before
# the strings which start Python regex special chars.
non_simple_regex_contains = \
r"""(
( (?<!\\)[.^$*+?{[|(] )+ # Start of special char.
| ( [\\][ABdDsSwWZ] )+ # Python regex escape.
))"""
compiled_non_simple_regex_contains = re.compile(
non_simple_regex_contains, re.VERBOSE|re.UNICODE)
def is_simple_pattern(regex_string):
# Could be single-char in brackets!
# https://docs.python.org/2.0/ref/strings.html
match_object = compiled_non_simple_regex_contains.search(regex_string)
#matched_string = regex_string[match_object.start():match_object.end()]
#print(" substring", matched_string)
return not bool(match_object)
#if is_simple_pattern(regex_string):
# print("simple pattern", regex_string)
#else:
# print("non-simple pattern", regex_string)
def findall(patt, filename, encoding='utf-8'):
"""Get all matches of regex ``patt`` in ``filename``.
:arg patt: The regex pattern to search.
Any standard Python `regular expression
<https://docs.python.org/3.6/library/re.html#regular-expression-syntax>`_
is accepted.
:arg filename: The name of the file to examine.
:arg encoding: The name of the encoding used to decode the file.
:returns: A list of raw `regex match objects
<https://docs.python.org/3.6/library/re.html#match-objects>`_.
:raises reframe.core.exceptions.SanityError: In case an :class:`OSError` is
raised while processing ``filename``.
"""
return list(evaluate(x) for x in finditer(patt, filename, encoding))
def parse_phone(phone_num):
"""Takes a phone number in a variety of formats and returns 10 digits.
arguments:
phone_num: string containing a phone number, in one of these formats:
(555) 555-5555
(555)555-5555
555-555-5555
5555555555
returns:
string of 10 digits (neglecting errors for now), or None if error.
Examples / doctests:
>>> print parse_phone("(555) 555-5555")
5555555555
>>> print parse_phone("(555)555-5555")
5555555555
>>> print parse_phone("555-555-5555")
5555555555
>>> print parse_phone("555555-5555")
5555555555
>>> print parse_phone("(555) 555-55555")
None
"""
# a somewhat obscure regular expression to get the data out of the phone
# number in various formats. (see http://regex101.com for more details on
# -- and a sandbox for -- regular expressions.)
matches = re.match(r'^\(?(\d{3})\)?[\s\-]?(\d{3})-?(\d{4})$', phone_num)
if not matches:
# the phone number wasn't in one of the acceptable formats
return None
# get the data from the regular expression
# for more details, see
# https://docs.python.org/2/library/re.html#match-objects
area_code = matches.group(1)
exchange = matches.group(2)
other_part = matches.group(3)
return "{}{}{}".format(area_code, exchange, other_part)
def read_ionization_energies( element ):
"""
Read the ionization energies from a data file
Parameters
----------
element: string
The atomic symbol of the considered ionizable species
(e.g. 'He', 'N' ; do not use 'Helium' or 'Nitrogen')
Returns
-------
An array with one array element per ionization state, containing the
ionization energy in Joules.
"""
# Open and read the file atomic_data.txt
filename = os.path.join( os.path.dirname(__file__), 'atomic_data.txt' )
with open(filename) as f:
text_data = f.read()
# Parse the data using regular expressions (a.k.a. regex)
# (see https://docs.python.org/2/library/re.html)
# The regex command below parses lines of the type
# '\n 10 | Ne IV | +3 | [97.1900]'
# and only considers those for which the element (Ne in the above example)
# matches the element which is passed as argument of this function
# For each line that satisfies this requirement, it extracts a tuple with
# - the atomic number (represented as (\d+))
# - the ionization level (represented as the second (\d+))
# - the ionization energy (represented as (\d+\.*\d*))
regex_command = \
'\n\s+(\d+)\s+\|\s+%s\s+\w+\s+\|\s+\+*(\d+)\s+\|\s+\(*\[*(\d+\.*\d*)' \
%element
list_of_tuples = re.findall( regex_command, text_data )
# Return None if the requested element was not found
if list_of_tuples == []:
return(None)
# Go through the list of tuples and fill the array of ionization energies.
atomic_number = int( list_of_tuples[0][0] )
assert atomic_number > 0
energies = np.zeros( atomic_number )
for ion_level in range( atomic_number ):
# Check that, when reading the file,
# we obtained the correct ionization level
assert ion_level == int( list_of_tuples[ion_level][1] )
# Get the ionization energy and convert in Joules using e
energies[ ion_level ] = e * float( list_of_tuples[ion_level][2] )
return( energies )
def initial_schema_and_setup(i_db_conn):
"""Auto-increment is not needed in our case: https://www.sqlite.org/autoinc.html
"""
i_db_conn.execute(
"CREATE TABLE " + DbSchemaM.QuestionTable.name + "("
+ DbSchemaM.QuestionTable.Cols.id + " INTEGER PRIMARY KEY, "
+ DbSchemaM.QuestionTable.Cols.sort_order + " INTEGER NOT NULL, "
+ DbSchemaM.QuestionTable.Cols.title + " TEXT NOT NULL, "
+ DbSchemaM.QuestionTable.Cols.question + " TEXT NOT NULL DEFAULT '', "
+ DbSchemaM.QuestionTable.Cols.archived + " INTEGER DEFAULT " + str(SQLITE_FALSE)
+ ")"
)
i_db_conn.execute(
"INSERT INTO " + DbSchemaM.QuestionTable.name + "("
+ DbSchemaM.QuestionTable.Cols.id + ", "
+ DbSchemaM.QuestionTable.Cols.sort_order + ", "
+ DbSchemaM.QuestionTable.Cols.title + ", "
+ DbSchemaM.QuestionTable.Cols.question
+ ") VALUES (?, ?, ?, ?)", (wbd.wbd_global.NO_ACTIVE_QUESTION_INT, -1, "<i>no question</i>", "")
)
i_db_conn.execute(
"CREATE TABLE " + DbSchemaM.DiaryEntryTable.name + "("
+ DbSchemaM.DiaryEntryTable.Cols.id + " INTEGER PRIMARY KEY, "
+ DbSchemaM.DiaryEntryTable.Cols.date_added + " INTEGER, "
+ DbSchemaM.DiaryEntryTable.Cols.favorite + " INTEGER NOT NULL DEFAULT '"
+ str(SQLITE_FALSE) + "', "
+ DbSchemaM.DiaryEntryTable.Cols.diary_entry + " TEXT, "
+ DbSchemaM.DiaryEntryTable.Cols.question_ref
+ " INTEGER REFERENCES " + DbSchemaM.QuestionTable.name
+ "(" + DbSchemaM.QuestionTable.Cols.id + ")"
+ " NOT NULL DEFAULT '" + str(wbd.wbd_global.NO_ACTIVE_QUESTION_INT) + "'"
+ ")"
)
# + " NOT NULL DEFAULT '" + str(wbd.bwbglobal.NO_ACTIVE_QUESTION_INT) + "'"
"""
i_db_conn.execute(
"CREATE INDEX " + DbSchemaM.DiaryEntryTable.name + "("
+ ")"
)
"""
i_db_conn.execute(
"CREATE TABLE " + DbSchemaM.ReminderTable.name + "("
+ DbSchemaM.ReminderTable.Cols.id + " INTEGER PRIMARY KEY, "
+ DbSchemaM.ReminderTable.Cols.title + " TEXT DEFAULT '', "
+ DbSchemaM.ReminderTable.Cols.reminder + " TEXT DEFAULT ''"
+ ")"
)
if wbd.wbd_global.testing_bool:
populate_db_with_test_data()
def map(self, regex):
"""Decorate a function to map it to a regex expression.
Decorator that allows to map a Python function to a regex expression provided as argument. The regex expression
is parsed using the 're' module (https://docs.python.org/3/library/re.html). Therefore, all regex syntax that
this module supports is also supported by this regex matcher. To encapsulate arguments for the function in the
regex expression use named capture groups (see examples).
Inspired by the URL mapping of the Flask microframework (http://flask.pocoo.org/)
Args:
regex: An Python raw string (r'I am a raw string') that can be interpreted as regular expression
Returns:
func: The input function without modfication
Example:
The simplest case just maps a function to a name:
>>> mapper = FuncMapper()
>>> @mapper.map(r'a name')
... def my_func():
... return 'I, my_func, have been called'
>>> mapper('a name')
'I, my_func, have been called'
But you can also use variables by adding regex capture groups:
(Note: Only named match groups are supported!)
>>> mapper = FuncMapper()
>>> @mapper.map(r'(?P<first>\d+)\+(?P<second>\d+)')
... def adder(first, second):
... return '{} + {} = {}'.format(first, second, int(first) + int(second))
>>> mapper('3+5')
'3 + 5 = 8'
"""
def wrapper(f):
self._mapped_functions[regex] = f
compiled_regex = re.compile(regex)
if compiled_regex.groups > 0 and len(compiled_regex.groupindex) < compiled_regex.groups:
raise NotSupportedError("Only named matched groups are Supported!")
self._mapped_regex[regex] = compiled_regex
return f
return wrapper
