Search is not available for this dataset
text stringlengths 75 104k |
|---|
def main():
'''manual test loop for make_clean_visible_from_raw
'''
import argparse
import sys
parser = argparse.ArgumentParser()
parser.add_argument('path')
args = parser.parse_args()
html = open(args.path).read()
html = html.decode('utf8')
cursor = 0
for s in non_tag_... |
def tryload_stage(self, moduleName, functionName, name=None):
'''Try to load a stage into self, ignoring errors.
If loading a module fails because of some subordinate load
failure, just give a warning and move on. On success the
stage is added to the stage dictionary.
:param s... |
def load_external_stages(self, path):
'''Add external stages from the Python module in `path`.
`path` must be a path to a Python module source that contains
a `Stages` dictionary, which is a map from stage name to callable.
:param str path: path to the module file
'''
m... |
def load_module_stages(self, mod):
'''Add external stages from the Python module `mod`.
If `mod` is a string, then it will be interpreted as the name
of a module; otherwise it is an actual module object. The
module should exist somewhere in :data:`sys.path`. The module
must co... |
def init_stage(self, name, config):
'''Construct and configure a stage from known stages.
`name` must be the name of one of the stages in this. `config`
is the configuration dictionary of the containing object, and its `name`
member will be passed into the stage constructor.
... |
def read_to( idx_bytes, stop_bytes=None, run_bytes=None ):
'''
iterates through idx_bytes until a byte in stop_bytes or a byte
not in run_bytes.
:rtype (int, string): idx of last byte and all of bytes including
the terminal byte from stop_bytes or not in run_bytes
'''
idx = None
vals = ... |
def iter_attrs( idx_bytes ):
'''
called when idx_chars is just past "<a " inside an HTML anchor tag
generates tuple(end_idx, attr_name, attr_value)
'''
## read to the end of the "A" tag
while 1:
idx, attr_name, next_b = read_to(idx_bytes, ['=', '>'])
attr_vals = []
... |
def href_filter(self, href):
'''
Test whether an href string meets criteria specified by
configuration parameters 'require_abs_url', which means "does
it look like it is probably an absolute URL?" and
'domain_substrings'. It searches for each of the
domain_substrings in ... |
def line_href_anchors(self):
'''
simple, regex-based extractor of anchor tags, so we can
compute LINE offsets for anchor texts and associate them with
their href.
Generates tuple(href_string, first_byte, byte_length, anchor_text)
Also, this mangles the body.clea... |
def byte_href_anchors(self, chars=False):
'''
simple, regex-based extractor of anchor tags, so we can
compute BYTE offsets for anchor texts and associate them with
their href.
Generates tuple(href_string, first_byte, byte_length, anchor_text)
'''
input_bu... |
def byte_href_anchors_state_machine(self):
'''
byte-based state machine extractor of anchor tags, so we can
compute byte offsets for anchor texts and associate them with
their href.
Generates tuple(href_string, first_byte, byte_length, anchor_text)
'''
ta... |
def make_labels(self, clean_html, clean_visible=None):
'''
Make a list of Labels for 'author' and the filtered hrefs &
anchors
'''
if self.offset_type == OffsetType.BYTES:
parser = self.byte_href_anchors
elif self.offset_type == OffsetType.CHARS:
... |
def paths(input_dir):
'yield all file paths under input_dir'
for root, dirs, fnames in os.walk(input_dir):
for i_fname in fnames:
i_path = os.path.join(root, i_fname)
yield i_path |
def _create_column_family(self, family, bytes_columns=[],
key_validation_class=TIME_UUID_TYPE):
'''
Creates a column family of the name 'family' and sets any of
the names in the bytes_column list to have the BYTES_TYPE.
key_validation_class defaults to TIM... |
def _create_counter_column_family(self, family, counter_columns=[],
key_validation_class=UTF8Type):
'''
Creates a column family of the name 'family' and sets any of
the names in the bytes_column list to have the BYTES_TYPE.
key_validation_class defaults to ... |
def tasks(self, key_prefix=''):
'''
generate the data objects for every task
'''
for row in self._tasks.get_range():
logger.debug(row)
if not row[0].startswith(key_prefix):
continue
data = json.loads(row[1]['task_data'])
dat... |
def get_random_available(self, max_iter=10000):
'''
get a random key out of the first max_iter rows
'''
c = 1
keeper = None
## note the ConsistencyLevel here. If we do not do this, and
## get all slick with things like column_count=0 and filter
## empty F... |
def files(text):
'''
Iterate over <FILENAME> XML-like tags and tokenize with nltk
'''
for f_match in filename_re.finditer(text):
yield f_match.group('stream_id'), f_match.group('tagged_doc') |
def sentences(self):
'''
Iterate over <s> XML-like tags and tokenize with nltk
'''
for sentence_id, node in enumerate(self.ner_dom.childNodes):
## increment the char index with any text before the <s>
## tag. Crucial assumption here is that the LingPipe XML
... |
def _make_token(self, start, end):
'''
Instantiates a Token from self._input_string[start:end]
'''
## all thfift strings must be encoded first
tok_string = self._input_string[start:end].encode('utf-8')
if only_whitespace.match(tok_string):
## drop any tokens w... |
def tokens(self, sentence_dom):
'''
Tokenize all the words and preserve NER labels from ENAMEX tags
'''
## keep track of sentence position, which is reset for each
## sentence, and used above in _make_token
self.sent_pos = 0
## keep track of mention_id, so we... |
def get_sentences(self, ner_dom):
'''parse the sentences and tokens out of the XML'''
lp_parser = LingPipeParser(self.config)
lp_parser.set(ner_dom)
sentences = list( lp_parser.sentences() )
return sentences, lp_parser.relations, lp_parser.attributes |
def recursive_glob_with_tree(new_base, old_base, treeroot, pattern):
'''generate a list of tuples(new_base, list(paths to put there)
where the files are found inside of old_base/treeroot.
'''
results = []
old_cwd = os.getcwd()
os.chdir(old_base)
for rel_base, dirs, files in os.walk(treeroot)... |
def _retry(func):
'''
Decorator for methods that need many retries, because of
intermittent failures, such as AWS calls via boto, which has a
non-back-off retry.
'''
def retry_func(self, *args, **kwargs):
tries = 1
while True:
# If a handler allows execution to contin... |
def verify_md5(md5_expected, data, other_errors=None):
"return True if okay, raise Exception if not" # O_o ?
md5_recv = hashlib.md5(data).hexdigest()
if md5_expected != md5_recv:
if other_errors is not None:
logger.critical('\n'.join(other_errors))
raise FailedVerification('orig... |
def get_bucket(config, bucket_name=None):
'''This function is mostly about managing configuration, and then
finally returns a boto.Bucket object.
AWS credentials come first from config keys
aws_access_key_id_path, aws_secret_access_key_path (paths to one
line files); secondly from environment varia... |
def _decode(self, data):
'''
Given the raw data from s3, return a generator for the items
contained in that data. A generator is necessary to support
chunk files, but non-chunk files can be provided by a generator
that yields exactly one item.
Decoding works by case anal... |
def get_chunk(self, bucket_name, key_path):
'''return Chunk object full of records
bucket_name may be None'''
bucket = get_bucket(self.config, bucket_name=bucket_name)
key = bucket.get_key(key_path)
if key is None:
raise FailedExtraction('Key "%s" does not exist.' % k... |
def stream_id_to_kvlayer_key(stream_id):
'''Convert a text stream ID to a kvlayer key.
The return tuple can be used directly as a key in the
:data:`STREAM_ITEMS_TABLE` table.
:param str stream_id: stream ID to convert
:return: :mod:`kvlayer` key tuple
:raise exceptions.KeyError: if `stream_id`... |
def kvlayer_key_to_stream_id(k):
'''Convert a kvlayer key to a text stream ID.
`k` should be of the same form produced by
:func:`stream_id_to_kvlayer_key`.
:param k: :mod:`kvlayer` key tuple
:return: converted stream ID
:returntype str:
'''
abs_url_hash, epoch_ticks = k
return '{0... |
def key_for_stream_item(si):
'''Get a kvlayer key from a stream item.
The return tuple can be used directly as a key in the
:data:`STREAM_ITEMS_TABLE` table. Note that this recalculates the
stream ID, and if the internal data on the stream item is inconsistent
then this could return a different re... |
def main(argv=sys.argv):
args = parse(argv)
"""Serve up some ponies."""
hostname = args.listen
port = args.port
print(
"Making all your dreams for a pony come true on http://{0}:{1}.\n"
"Press Ctrl+C to quit.\n".format(hostname, port))
# Hush, werkzeug.
logging.getLogger('we... |
def build_parser():
"""Build the parser that will have all available commands and options."""
description = (
'HTTPony (pronounced aych-tee-tee-pony) is a simple HTTP '
'server that pretty prints HTTP requests to a terminal. It '
'is a useful aide for developing clients that send HTTP '
... |
def add_xpaths_to_stream_item(si):
'''Mutably tag tokens with xpath offsets.
Given some stream item, this will tag all tokens from all taggings
in the document that contain character offsets. Note that some
tokens may not have computable xpath offsets, so an xpath offset
for those tokens will not b... |
def sentences_to_char_tokens(si_sentences):
'''Convert stream item sentences to character ``Offset``s.'''
for sentence in si_sentences:
for token in sentence.tokens:
if OffsetType.CHARS in token.offsets:
yield token |
def char_tokens_to_char_offsets(si_tokens):
'''Convert character ``Offset``s to character ranges.'''
for token in si_tokens:
offset = token.offsets[OffsetType.CHARS]
yield offset.first, offset.first + offset.length |
def char_offsets_to_xpaths(html, char_offsets):
'''Converts HTML and a sequence of char offsets to xpath offsets.
Returns a generator of :class:`streamcorpus.XpathRange` objects
in correspondences with the sequence of ``char_offsets`` given.
Namely, each ``XpathRange`` should address precisely the same... |
def stream_item_roundtrip_xpaths(si, quick=False):
'''Roundtrip all Xpath offsets in the given stream item.
For every token that has both ``CHARS`` and ``XPATH_CHARS``
offsets, slice the ``clean_html`` with the ``XPATH_CHARS`` offset
and check that it matches slicing ``clean_visible`` with the
``CH... |
def add_element(self, tag):
'''Record that `tag` has been seen at this depth.
If `tag` is :class:`TextElement`, it records a text node.
'''
# Collapse adjacent text nodes
if tag is TextElement and self.last_tag is TextElement:
return
self.last_tag = tag
... |
def xpath_piece(self):
'''Get an XPath fragment for this location.
It is of the form ``tag[n]`` where `tag` is the most recent
element added and n is its position.
'''
if self.last_tag is TextElement:
return 'text()[{count}]'.format(count=self.text_index())
... |
def text_index(self):
'''Returns the one-based index of the current text node.'''
# This is the number of text nodes we've seen so far.
# If we are currently in a text node, great; if not then add
# one for the text node that's about to begin.
i = self.tags.get(TextElement, 0)
... |
def xpath_offset(self):
'''Returns a tuple of ``(xpath, character offset)``.
The ``xpath`` returned *uniquely* identifies the end of the
text node most recently inserted. The character offsets
indicates where the text inside the node ends. (When the text
node is empty, the offse... |
def descendants(elem):
'''
Yields all the elements descendant of elem in document order
'''
for child in elem.xml_children:
if isinstance(child, element):
yield child
yield from descendants(child) |
def select_elements(source):
'''
Yields all the elements from the source
source - if an element, yields all child elements in order; if any other iterator yields the elements from that iterator
'''
if isinstance(source, element):
source = source.xml_children
return filter(lambda x: isins... |
def select_name(source, name):
'''
Yields all the elements with the given name
source - if an element, starts with all child elements in order; can also be any other iterator
name - will yield only elements with this name
'''
return filter(lambda x: x.xml_name == name, select_elements(source)) |
def select_name_pattern(source, pat):
'''
Yields elements from the source whose name matches the given regular expression pattern
source - if an element, starts with all child elements in order; can also be any other iterator
pat - re.pattern object
'''
return filter(lambda x: pat.match(x.xml_na... |
def select_value(source, val):
'''
Yields elements from the source with the given value (accumulated child text)
source - if an element, starts with all child elements in order; can also be any other iterator
val - string value to match
'''
if isinstance(source, element):
source = source... |
def select_attribute(source, name, val=None):
'''
Yields elements from the source having the given attrivute, optionally with the given attribute value
source - if an element, starts with all child elements in order; can also be any other iterator
name - attribute name to check
val - if None check o... |
def following_siblings(elem):
'''
Yields elements and text which have the same parent as elem, but come afterward in document order
'''
it = itertools.dropwhile(lambda x: x != elem, elem.xml_parent.xml_children)
next(it) #Skip the element itself
return it |
def select_pattern(node, pattern, state=None):
'''
Yield descendant nodes matching the given pattern specification
pattern - tuple of steps, each of which matches an element by name, with "*" acting like a wildcard, descending the tree in tuple order
sort of like a subset of XPath in Python ... |
def make_pretty(elem, depth=0, indent=' '):
'''
Add text nodes as possible to all descendants of an element for spacing & indentation
to make the MicroXML as printed easier for people to read. Will not modify the
value of any text node which is not already entirely whitespace.
Warning: even though... |
def call_inkscape(args_strings, inkscape_binpath=None):
"""Call inkscape CLI with arguments and returns its return value.
Parameters
----------
args_string: list of str
inkscape_binpath: str
Returns
-------
return_value
Inkscape command CLI call return value.
"""
log.d... |
def inkscape_export(input_file, output_file, export_flag="-A", dpi=90, inkscape_binpath=None):
""" Call Inkscape to export the input_file to output_file using the
specific export argument flag for the output file type.
Parameters
----------
input_file: str
Path to the input file
outpu... |
def svg2pdf(svg_file_path, pdf_file_path, dpi=150, command_binpath=None, support_unicode=False):
""" Transform SVG file to PDF file
"""
if support_unicode:
return rsvg_export(svg_file_path, pdf_file_path, dpi=dpi, rsvg_binpath=command_binpath)
return inkscape_export(svg_file_path, pdf_file_pat... |
def svg2png(svg_file_path, png_file_path, dpi=150, inkscape_binpath=None):
""" Transform SVG file to PNG file
"""
return inkscape_export(svg_file_path, png_file_path, export_flag="-e",
dpi=dpi, inkscape_binpath=inkscape_binpath) |
def get_environment_for(file_path):
"""Return a Jinja2 environment for where file_path is.
Parameters
----------
file_path: str
Returns
-------
jinja_env: Jinja2.Environment
"""
work_dir = os.path.dirname(os.path.abspath(file_path))
if not os.path.exists(work_dir):
ra... |
def _setup_template_file(self, template_file_path):
""" Setup self.template
Parameters
----------
template_file_path: str
Document template file path.
"""
try:
template_file = template_file_path
template_env = get_environment_for(templ... |
def fill(self, doc_contents):
""" Fill the content of the document with the information in doc_contents.
Parameters
----------
doc_contents: dict
Set of values to set the template document.
Returns
-------
filled_doc: str
The content of t... |
def save_content(self, file_path, encoding='utf-8'):
""" Save the content of the .txt file in a text file.
Parameters
----------
file_path: str
Path to the output file.
"""
if self.file_content_ is None:
msg = 'Template content has not been update... |
def from_template_file(cls, template_file_path, command=None):
""" Factory function to create a specific document of the
class given by the `command` or the extension of `template_file_path`.
See get_doctype_by_command and get_doctype_by_extension.
Parameters
----------
... |
def fill(self, doc_contents):
""" Fill the content of the document with the information in doc_contents.
This is different from the TextDocument fill function, because this will
check for symbools in the values of `doc_content` and replace them
to good XML codes before filling the templa... |
def render(self, file_path, **kwargs):
""" Save the content of the .svg file in the chosen rendered format.
Parameters
----------
file_path: str
Path to the output file.
Kwargs
------
file_type: str
Choices: 'png', 'pdf', 'svg'
... |
def render(self, file_path, **kwargs):
""" Save the content of the .text file in the PDF.
Parameters
----------
file_path: str
Path to the output file.
"""
temp = get_tempfile(suffix='.tex')
self.save_content(temp.name)
try:
self.... |
def parse(source, handler):
'''
Convert XML 1.0 to MicroXML
source - XML 1.0 input
handler - MicroXML events handler
Returns uxml, extras
uxml - MicroXML element extracted from the source
extras - information to be preserved but not part of MicroXML, e.g. namespaces
'''
h = expat_... |
def search(self):
'''Start the optimisation/search using the supplied optimisation
method with the supplied inputs for the supplied function'''
search = self._method(inputs=self._inputs, function=self._function,
state=self._state)
search.run() |
def parse(source, prefixes=None, model=None, encoding=None, use_xhtml_ns=False):
'''
Parse an input source with HTML text into an Amara 3 tree
>>> from amara3.uxml import html5
>>> import urllib.request
>>> with urllib.request.urlopen('http://uche.ogbuji.net/') as response:
... html5.parse(... |
def markup_fragment(source, encoding=None):
'''
Parse a fragment if markup in HTML mode, and return a bindery node
Warning: if you pass a string, you must make sure it's a byte string, not a Unicode object. You might also want to wrap it with amara.lib.inputsource.text if it's not obviously XML or HTML (f... |
def insertText(self, data, insertBefore=None):
"""Insert data as text in the current node, positioned before the
start of node insertBefore or to the end of the node's text.
"""
if insertBefore:
self.insertBefore(tree.text(data), insertBefore)
else:
self.x... |
def insertBefore(self, node, refNode):
"""Insert node as a child of the current node, before refNode in the
list of child nodes. Raises ValueError if refNode is not a child of
the current node"""
offset = self.xml_children.index(refNode)
self.xml_insert(node, offset) |
def cloneNode(self):
"""Return a shallow copy of the current node i.e. a node with the same
name and attributes but with no parent or child nodes
"""
attrs = self.xml_attributes.copy()
return element(self.xml_name, attrs=attrs) |
def execute(option):
'''A script that melody calls with each valid set of options. This
script runs the required code and returns the results.'''
namelist_option = []
makefile_option = []
flags = ""
for entry in option:
key = entry.keys()[0]
if key == "Problem Size":
... |
def create_vcard3_str(name, surname, displayname, email='', org='', title='', url='', note=''):
""" Create a vCard3.0 string with the given parameters.
Reference: http://www.evenx.com/vcard-3-0-format-specification
"""
vcard = []
vcard += ['BEGIN:VCARD']
vcard += ['VERSION:3.0']
if name and... |
def strval(node, outermost=True):
'''
XPath-like string value of node
'''
if not isinstance(node, element):
return node.xml_value if outermost else [node.xml_value]
accumulator = []
for child in node.xml_children:
if isinstance(child, text):
accumulator.append(child.x... |
def xml_insert(self, child, index=-1):
'''
Append a node as the last child
child - the child to append. If a string, convert to a text node, for convenience
'''
if isinstance(child, str):
child = text(child, parent=self)
else:
child._xml_parent = ... |
def parse_options():
"""
Commandline options arguments parsing.
"""
# build options and help
version = "%%prog {version}".format(version=__version__)
parser = OptionParser(version=version)
parser.add_option(
"-u", "--username", action="store", dest="username",
type="string",... |
def parse_config(options):
"""
Get settings from config file.
"""
if os.path.exists(options.config):
config = ConfigParser.ConfigParser()
try:
config.read(options.config)
except Exception, err:
if not options.quiet:
sys.stderr.write("ERROR... |
def get_google_credentials(options, config):
"""
Get google API credentials for user.
"""
try:
if options.get_google_credentials:
flow = flow_from_clientsecrets(config["secrets"], scope=SCOPE, redirect_uri="oob")
sys.stdout.write("Follow this URL: {url} and grant access ... |
def create_event_datetimes(options, config):
"""
Create event start and end datetimes.
"""
now = datetime.datetime.now()
return {
"start": {
"dateTime": (now + datetime.timedelta(minutes=int(config["start"]))).strftime(DT_FORMAT),
"timeZone": options.timezone,
... |
def create_event(options, config, credentials):
"""
Create event in calendar with sms reminder.
"""
try:
http = credentials.authorize(httplib2.Http())
service = build("calendar", "v3", http=http)
event = {
"summary": options.message,
"location": "",
... |
def main():
"""
Processing notification call main function.
"""
# getting info for creating event
options = parse_options()
config = parse_config(options)
credentials = get_google_credentials(options, config)
if not options.get_google_credentials:
create_event(options, config, ... |
def create(input, template, field, outdir, prefix, otype, command, index,
dpi, verbose, unicode_support):
"""Use docstamp to create documents from the content of a CSV file or
a Google Spreadsheet.
Examples: \n
docstamp create -i badge.csv -t badge_template.svg -o badges
docstamp create ... |
def get_extension(filepath, check_if_exists=False):
"""Return the extension of fpath.
Parameters
----------
fpath: string
File name or path
check_if_exists: bool
Returns
-------
str
The extension of the file name or path
"""
if check_if_exists:
if not os.path.e... |
def add_extension_if_needed(filepath, ext, check_if_exists=False):
"""Add the extension ext to fpath if it doesn't have it.
Parameters
----------
filepath: str
File name or path
ext: str
File extension
check_if_exists: bool
Returns
-------
File name or path with extension... |
def get_tempfile(suffix='.txt', dirpath=None):
""" Return a temporary file with the given suffix within dirpath.
If dirpath is None, will look for a temporary folder in your system.
Parameters
----------
suffix: str
Temporary file name suffix
dirpath: str
Folder path where crea... |
def cleanup(workdir, extension):
""" Remove the files in workdir that have the given extension.
Parameters
----------
workdir:
Folder path from where to clean the files.
extension: str
File extension without the dot, e.g., 'txt'
"""
[os.remove(f) for f in glob(os.path.join(... |
def csv_to_json(csv_filepath, json_filepath, fieldnames, ignore_first_line=True):
""" Convert a CSV file in `csv_filepath` into a JSON file in `json_filepath`.
Parameters
----------
csv_filepath: str
Path to the input CSV file.
json_filepath: str
Path to the output JSON file. Will ... |
def write_to_file(file_path, content, encoding=None):
""" Write `content` inside the file in `file_path` with the given encoding.
Parameters
----------
file_path: str
Path to the output file. Will be overwritten if exists.
content: str
The content you want in the file.
encoding... |
def replace_file_content(filepath, old, new, max=1):
""" Modify the content of `filepath`, replacing `old` for `new`.
Parameters
----------
filepath: str
Path to the file to be modified. It will be overwritten.
old: str
This is old substring to be replaced.
new: str
Th... |
def cleanup_docstamp_output(output_dir=''):
""" Remove the 'tmp*.aux', 'tmp*.out' and 'tmp*.log' files in `output_dir`.
:param output_dir:
"""
suffixes = ['aux', 'out', 'log']
files = [f for suf in suffixes for f in glob(os.path.join(output_dir, 'tmp*.{}'.format(suf)))]
[os.remove(file) for file... |
def parse(self):
"""
Run all parsing functions.
"""
for tag in self.soup.findAll('span'):
self.create_italic(tag)
self.create_strong(tag)
self.create_underline(tag)
self.unwrap_span(tag)
for tag in self.soup.findAll('a'):
... |
def check_next(self, tag):
"""
If next tag is link with same href, combine them.
"""
if (type(tag.next_sibling) == element.Tag and
tag.next_sibling.name == 'a'):
next_tag = tag.next_sibling
if tag.get('href') and next_tag.get('href'):
... |
def create_italic(self, tag):
"""
See if span tag has italic style and wrap with em tag.
"""
style = tag.get('style')
if style and 'font-style:italic' in style:
tag.wrap(self.soup.new_tag('em')) |
def create_strong(self, tag):
"""
See if span tag has bold style and wrap with strong tag.
"""
style = tag.get('style')
if (style and
('font-weight:bold' in style or 'font-weight:700' in style)):
tag.wrap(self.soup.new_tag('strong')) |
def create_underline(self, tag):
"""
See if span tag has underline style and wrap with u tag.
"""
style = tag.get('style')
if style and 'text-decoration:underline' in style:
tag.wrap(self.soup.new_tag('u')) |
def parse_attrs(self, tag):
"""
Reject attributes not defined in ATTR_WHITELIST.
"""
if tag.name in ATTR_WHITELIST.keys():
attrs = copy(tag.attrs)
for attr, value in attrs.items():
if attr in ATTR_WHITELIST[tag.name]:
tag.attrs[... |
def remove_empty(self, tag):
"""
Remove non-self-closing tags with no children *and* no content.
"""
has_children = len(tag.contents)
has_text = len(list(tag.stripped_strings))
if not has_children and not has_text and not tag.is_empty_element:
tag.extract() |
def clean_linebreaks(self, tag):
"""
get unicode string without any other content transformation.
and clean extra spaces
"""
stripped = tag.decode(formatter=None)
stripped = re.sub('\s+', ' ', stripped)
stripped = re.sub('\n', '', stripped)
return stripped |
def _parse_href(self, href):
"""
Extract "real" URL from Google redirected url by getting `q`
querystring parameter.
"""
params = parse_qs(urlsplit(href).query)
return params.get('q') |
def _parse_attr(self, tagname, attr, value):
"""
Parse attribute. Delegate to href parser for hrefs, otherwise return
value.
"""
if tagname == 'a' and attr == 'href':
return self._parse_href(value)
else:
return value |
def translate_key_values(adict, translations, default=''):
"""Modify the keys in adict to the ones in translations.
Be careful, this will modify your input dictionary.
The keys not present in translations will be left intact.
Parameters
----------
adict: a dictionary
translations: iterable... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.