Search is not available for this dataset
text stringlengths 75 104k |
|---|
def get_random(self, show=True, proxy=None, timeout=0):
"""
GET MediaWiki:API (action=query) for random category
https://www.mediawiki.org/wiki/API:Random
Required {params}: None
Optional arguments:
- [show]: <bool> echo page data if true
- [proxy]: <str> use th... |
def _set_data(self, action):
"""
capture Wikidata API response data
"""
if action == 'siteinfo':
self._set_siteinfo()
elif action == 'sitematrix':
self._set_sitematrix()
elif action == 'sitevisitors':
self._set_sitevisitors() |
def _set_siteinfo(self):
"""
capture API sitematrix data in data attribute
"""
data = self._load_response('siteinfo').get('query')
mostviewed = data.get('mostviewed')
self.data['mostviewed'] = []
for item in mostviewed[1:]:
if item['ns'] == 0:
... |
def _set_sitematrix(self):
"""
capture API sitematrix data in data attribute
"""
data = self._load_response('sitematrix')
self.params.update({'title': self.COMMONS})
matrix = data.get('sitematrix')
if matrix:
self.data['sites'] = self._sitelist(matri... |
def _set_sitevisitors(self):
"""
capture API pageview/visitor data in data attribute
"""
data = self._load_response('sitevisitors').get('query')
siteviews = data.get('siteviews')
if siteviews:
values = [x for x in siteviews.values() if x]
if value... |
def _sitelist(self, matrix):
"""
Returns a list of sites from a SiteMatrix, optionally filtered
by 'domain' param
"""
_list = []
for item in matrix:
sites = []
if isinstance(matrix[item], list):
sites = matrix[item]
eli... |
def get_info(self, wiki=None, show=True, proxy=None, timeout=0):
"""
GET site info (general, statistics, siteviews, mostviewed) via
https://www.mediawiki.org/wiki/API:Siteinfo, and
https://www.mediawiki.org/wiki/Extension:PageViewInfo
Optional arguments:
- [wiki]: <str> ... |
def get_sites(self, domain=None, show=True, proxy=None, timeout=0):
"""
GET Wikimedia sites via Extension:SiteMatrix
https://www.mediawiki.org/wiki/Extension:SiteMatrix
Optional params:
- [domain]: filter sites on this domain, e.g. 'wiktionary.org'
Optional arguments:
... |
def top(self, wiki=None, limit=25):
"""
Print list of top viewed articles (ns=0) over the last WEEK
https://www.mediawiki.org/wiki/Extension:PageViewInfo
Optional params:
- [wiki]: <str> alternate wiki site (default=en.wikipedia.org)
- [limit]: <int> show up to limit art... |
def handle_wikidata_errors(data, query):
"""
Raises LookupError if wikidata error found
"""
entities = data.get('entities')
if not entities:
raise LookupError(query)
elif '-1' in entities:
raise LookupError(query)
else:
item = list(entities.values())[0]
if 'm... |
def prettyprint(datastr):
"""
Print page data strings to stderr
"""
maxwidth = WPToolsQuery.MAXWIDTH
rpad = WPToolsQuery.RPAD
extent = maxwidth - (rpad + 2)
for line in datastr:
if len(line) >= maxwidth:
line = line[:extent] + '...'
utils.stderr(line) |
def _build_showstr(self, seed):
"""
Returns show() display string for data attribute
"""
output = ["%s (%s) data" % (seed, self.params['lang'])]
output.append('{')
maxwidth = WPToolsQuery.MAXWIDTH
for item in sorted(self.data):
if self.data[item] i... |
def _continue_params(self):
"""
Returns query string fragment continue parameters
"""
if not self.data.get('continue'):
return
params = []
for item in self.data['continue']:
params.append("&%s=%s" % (item, self.data['continue'][item]))
re... |
def _handle_continuations(self, response, cache_key):
"""
Select continue params and clear cache or last continue params
"""
rcontinue = response.get('continue')
listen = ['blcontinue', 'cmcontinue', 'plcontinue']
cparams = {}
if rcontinue:
for flag i... |
def _get(self, action, show, proxy, timeout):
"""
make HTTP request and cache response
"""
silent = self.flags['silent']
if action in self.cache:
if action != 'imageinfo' and action != 'labels':
utils.stderr("+ %s results in cache" % action, silent)
... |
def _load_response(self, action):
"""
returns API reponse from cache or raises ValueError
"""
_query = self.cache[action]['query'].replace('&format=json', '')
response = self.cache[action]['response']
if not response:
raise ValueError("Empty response: %s" % s... |
def _request(self, proxy, timeout):
"""
Returns WPToolsRequest object
"""
return request.WPToolsRequest(self.flags['silent'],
self.flags['verbose'],
proxy, timeout) |
def info(self, action=None):
"""
returns cached request info for given action,
or list of cached actions
"""
if action in self.cache:
return self.cache[action]['info']
return self.cache.keys() or None |
def query(self, action=None):
"""
returns cached query string (without &format=json) for given action,
or list of cached actions
"""
if action in self.cache:
return self.cache[action]['query'].replace('&format=json', '')
return self.cache.keys() or None |
def response(self, action=None):
"""
returns cached response (as dict) for given action,
or list of cached actions
"""
if action in self.cache:
return utils.json_loads(self.cache[action]['response'])
return self.cache.keys() or None |
def show(self):
"""
Pretty-print instance data
"""
if not self.data:
return
if self.data.get('continue'):
return
ptitle = self.params.get('title')
dtitle = self.data.get('title')
pageid = self.params.get('pageid')
seed = ... |
def reduce_claims(query_claims):
"""
returns claims as reduced dict {P: [Q's or values]}
P = property
Q = item
"""
claims = collections.defaultdict(list)
for claim, entities in query_claims.items():
for ent in entities:
try:
snak = ent.get('main... |
def _get_entity_prop(self, entity, prop):
"""
returns Wikidata entity property value
"""
variant = self.params.get('variant')
lang = self.params.get('lang')
if entity.get(prop):
ent = entity[prop]
try:
return ent[variant or lang].g... |
def _marshal_claims(self, query_claims):
"""
set Wikidata entities from query claims
"""
claims = reduce_claims(query_claims)
# self.data['claimq'] = query_claims
self.data['claims'] = claims
entities = set()
for eid in claims:
if self.user_la... |
def _pop_entities(self, limit=50):
"""
returns up to limit entities and pops them off the list
"""
pop = self.data['entities'][:limit]
del self.data['entities'][:limit]
return pop |
def _query(self, action, qobj):
"""
returns wikidata query string
"""
if action == 'labels':
return qobj.labels(self._pop_entities())
elif action == 'wikidata':
return qobj.wikidata(self.params.get('title'),
self.params.get... |
def _set_data(self, action):
"""
capture Wikidata API response data
"""
if action == 'labels':
self._set_labels()
if action == 'wikidata':
self._set_wikidata()
self.get_labels(show=False) |
def _set_labels(self):
"""
set entity labels from get_labels()
"""
data = self._load_response('labels')
entities = data.get('entities') or []
for ent in entities:
label = self._get_entity_prop(entities[ent], 'labels')
self.data['labels'][ent] = la... |
def _set_title(self, item):
"""
attempt to set title from wikidata
"""
title = None
lang = self.params['lang']
label = self.data['label']
if item.get('sitelinks'):
for link in item['sitelinks']:
if link == "%swiki" % lang:
... |
def _set_wikidata(self):
"""
set attributes derived from Wikidata (action=wbentities)
"""
self.data['labels'] = {}
self.data['wikidata'] = {}
data = self._load_response('wikidata')
entities = data.get('entities')
item = entities.get(next(iter(entities)))
... |
def _update_images(self):
"""
add images from Wikidata
"""
wd_images = self.data['claims'].get('P18') # image
if wd_images:
if not isinstance(wd_images, list):
wd_images = [wd_images]
if 'image' not in self.data:
self.dat... |
def _update_what(self):
"""
set what this thing is! "instance of (P31)"
"""
if 'P31' not in self.data['claims']: # missing Wikidata
msg = ("Note: Wikidata item %s" % self.data['wikibase'],
"missing 'instance of' (P31)")
utils.stderr(" ".join(ms... |
def _update_wikidata(self):
"""
set wikidata from claims and labels
"""
claims = self.data['claims']
for ent in claims:
plabel = self.data['labels'].get(ent) # P (property) label
if plabel:
plabel = "%s (%s)" % (plabel, ent)
... |
def get_labels(self, show=False, proxy=None, timeout=0):
"""
GET Wikidata:API (action=wbgetentities) for claims labels
https://www.wikidata.org/w/api.php?action=help&modules=wbgetentities
Required {data}: entities, claims
data['claims']: {'P17': ['Q17'], 'P910': ['Q8854938']... |
def get_wikidata(self, show=True, proxy=None, timeout=0):
"""
GET Wikidata:API (action=wbgetentities) wikidata
https://www.wikidata.org/w/api.php?action=help&modules=wbgetentities
Required {params}: title OR wikibase
- title: <str> Mediawiki page title, file, category, etc.
... |
def wanted_labels(self, labels):
"""
Specify only WANTED labels to minimize get_labels() requests
Args:
- labels: <list> of wanted labels.
Example:
page.wanted_labels(['P18', 'P31'])
"""
if not isinstance(labels, list):
raise ValueError("In... |
def _html_image(page):
"""
returns HTML img tag
"""
source = _image(page)
if not source:
return
alt = page.data.get('label') or page.data.get('title')
img = "<img src=\"%s\"" % source
img += " alt=\"%s\" title=\"%s\" " % (alt, alt)
img += "align=\"right\" width=\"240\">"
... |
def _html_title(page):
"""
returns Wiki-linked HTML title
"""
link = "<a href=\"%s\">%s</a>" % (page.data.get('url'),
page.data.get('title'))
desc = page.data.get('description')
if desc:
link += "—<i>%s</i>" % desc
else:
link += "&m... |
def _page_html(page):
"""
returns assembled HTML output
"""
out = []
out.append(_html_title(page))
out.append(_html_image(page))
out.append(page.data.get('extract'))
return "\n".join([x for x in out if x]) |
def _page_text(page, nowrap=False):
"""
returns assembled text output
"""
title = page.data['title']
title = "%s\n%s" % (title, "=" * len(title))
desc = page.data.get('description')
if desc:
desc = "_%s_" % desc
img = _text_image(page)
pars = page.data.get('extext')
i... |
def _safe_exit(start, output):
"""
exit without breaking pipes
"""
try:
sys.stdout.write(output)
sys.stdout.flush()
except TypeError: # python3
sys.stdout.write(str(output, 'utf-8'))
sys.stdout.flush()
except IOError:
pass
seconds = time.time() - sta... |
def _text_image(page):
"""
returns text image URL
"""
img = None
alt = page.data.get('label') or page.data.get('title')
source = _image(page)
if source:
img = "" % (alt, source)
return img |
def get(args):
"""
invoke wptools and assemble selected output
"""
html = args.H
lang = args.l
nowrap = args.n
query = args.q
silent = args.s
title = args.t
verbose = args.v
wiki = args.w
if query:
qobj = WPToolsQuery(lang=lang, wiki=wiki)
if title:
... |
def parse_args():
"""
parse main() args
"""
description = (
"Get Wikipedia article info and Wikidata via MediaWiki APIs.\n\n"
"Gets a random English Wikipedia article by default, or in the\n"
"language -lang, or from the wikisite -wiki, or by specific\n"
"title -title. Th... |
def main(args):
"""
invoke wptools and exit safely
"""
start = time.time()
output = get(args)
_safe_exit(start, output) |
def __insert_image_info(self, title, _from, info):
"""
Insert API image INFO into matching image dict
We make one imageinfo request containing only unique image
filenames. We reduce duplication by asking for image data per
file, instead of per "kind" or source (Wikipedia, Wikida... |
def __pull_image_info(self, title, imageinfo, normalized):
"""
Pull image INFO from API response and insert
"""
for info in imageinfo:
info.update({'title': title})
# get API normalized "from" filename for matching
_from = None
for norm in... |
def _extend_data(self, datapoint, new_data):
"""
extend or assign new data to datapoint
"""
if new_data:
try:
self.data[datapoint].extend(new_data)
except KeyError:
self.data[datapoint] = new_data |
def _missing_imageinfo(self):
"""
returns list of image filenames that are missing info
"""
if 'image' not in self.data:
return
missing = []
for img in self.data['image']:
if 'url' not in img:
missing.append(img['file'])
ret... |
def _normalize_images(self):
"""
normalizes image filenames by prepending 'File:' if needed
"""
if 'image' not in self.data:
return
for img in self.data['image']:
fname = img['file'].replace('_', ' ')
fstart = fname.startswith('File:')
... |
def _query(self, action, qobj):
"""
returns WPToolsQuery string
"""
title = self.params.get('title')
pageid = self.params.get('pageid')
wikibase = self.params.get('wikibase')
qstr = None
if action == 'random':
qstr = qobj.random()
eli... |
def _set_data(self, action):
"""
marshals response data into page data
"""
if 'query' in action:
self._set_query_data(action)
elif action == 'imageinfo':
self._set_imageinfo_data()
elif action == 'parse':
self._set_parse_data()
... |
def _set_imageinfo_data(self):
"""
set image attributes from MediaWiki API:Imageinfo response
"""
data = self._load_response('imageinfo')
pages = data['query'].get('pages')
normalized = []
if 'normalized' in data['query']:
normalized = data['query']['... |
def _set_parse_data(self):
"""
set attributes derived from MediaWiki (action=parse)
"""
pdata = self._load_response('parse')['parse']
self.data['iwlinks'] = utils.get_links(pdata.get('iwlinks'))
self.data['pageid'] = pdata.get('pageid')
self.data['wikitext'] = pd... |
def _set_parse_image(self, infobox):
"""
set image data from action=parse response
"""
image = infobox.get('image')
cover = infobox.get('Cover') or infobox.get('cover')
if image or cover:
if 'image' not in self.data:
self.data['image'] = []
... |
def _set_query_data(self, action='query'):
"""
set attributes derived from MediaWiki (action=query)
"""
data = self._load_response(action)
page = data['query']['pages'][0]
self._handle_continuations(data, action)
if action == 'query':
self.data['rand... |
def _set_query_data_fast_1(self, page):
"""
set less expensive action=query response data PART 1
"""
self.data['pageid'] = page.get('pageid')
assessments = page.get('pageassessments')
if assessments:
self.data['assessments'] = assessments
extract = p... |
def _set_query_data_fast_2(self, page):
"""
set less expensive action=query response data PART 2
"""
self.data['pageid'] = page.get('pageid')
redirects = page.get('redirects')
if redirects:
self.data['redirects'] = redirects
terms = page.get('terms')... |
def _set_query_data_slow(self, page):
"""
set more expensive action=query response data
"""
categories = page.get('categories')
if categories:
self.data['categories'] = [x['title'] for x in categories]
if page.get('contributors'):
contributors = p... |
def _set_query_image(self, page):
"""
set image data from action=query response
"""
pageimage = page.get('pageimage')
thumbnail = page.get('thumbnail')
if pageimage or thumbnail:
if 'image' not in self.data:
self.data['image'] = []
if... |
def _set_random_data(self):
"""
sets page data from random request
"""
rdata = self._load_response('random')
rdata = rdata['query']['random'][0]
pageid = rdata.get('id')
title = rdata.get('title')
self.data.update({'pageid': pageid,
... |
def _update_data(self, datapoint, key, new_data):
"""
update or assign new data to datapoint
"""
if new_data:
try:
self.data[datapoint].update({key: new_data})
except KeyError:
self.data[datapoint] = {key: new_data} |
def _update_imageinfo(self):
"""
calls get_imageinfo() if data image missing info
"""
missing = self._missing_imageinfo()
deferred = self.flags.get('defer_imageinfo')
continuing = self.data.get('continue')
if missing and not deferred and not continuing:
... |
def _update_params(self):
"""
update params from response data
"""
if self.data.get('title'):
self.params['title'] = self.data.get('title')
if self.data.get('pageid'):
self.params['pageid'] = self.data.get('pageid')
if self.data.get('wikibase'):
... |
def skip_action(self, action):
"""
append action to skip flag
"""
if 'skip' not in self.flags:
self.flags['skip'] = []
self.flags['skip'].append(action) |
def get(self, show=True, proxy=None, timeout=0):
"""
Make Mediawiki, RESTBase, and Wikidata requests for page data
some sequence of:
- get_parse()
- get_query()
- get_restbase()
- get_wikidata()
"""
wikibase = self.params.get('wikibase')
i... |
def get_imageinfo(self, show=True, proxy=None, timeout=0):
"""
GET MediaWiki request for API:Imageinfo
https://www.mediawiki.org/wiki/API:Imageinfo
Required {data}:
- image: <list> member (<dict>) with 'file' and not 'url'
Optional arguments:
- [show]: <bool> ec... |
def get_more(self, show=True, proxy=None, timeout=0):
"""
Calls get_querymore() Is for convenience. You like.
"""
return self.get_querymore(show, proxy, timeout) |
def get_parse(self, show=True, proxy=None, timeout=0):
"""
GET MediaWiki:API action=parse request
https://en.wikipedia.org/w/api.php?action=help&modules=parse
Required {params}: title OR pageid
- title: <str> article title
- pageid: <int> Wikipedia database ID
O... |
def get_query(self, show=True, proxy=None, timeout=0):
"""
GET MediaWiki:API action=query selected data
https://en.wikipedia.org/w/api.php?action=help&modules=query
Required {params}: title OR pageid
- title: <str> article title
- pageid: <int> Wikipedia database ID
... |
def images(self, fields=None, token=None):
"""
Returns image info keys for kind containing token
Args:
- fields: <list> image info values wanted
- token: <str> substring to match image kind
EXAMPLES
Get all available image info:
>>> page.images()
... |
def curl_info(crl):
"""
returns curl (response) info from Pycurl object
"""
kbps = crl.getinfo(crl.SPEED_DOWNLOAD) / 1000.0
url = crl.getinfo(crl.EFFECTIVE_URL)
url = url.replace("&format=json", '').replace("&formatversion=2", '')
# https://travis-ci.org/siznax/wptools/jobs/401109410
tr... |
def get(self, url, status):
"""
in favor of python-requests for speed
"""
# consistently faster than requests by 3x
#
# r = requests.get(url,
# headers={'User-Agent': self.user_agent})
# return r.text
crl = self.cobj
try... |
def curl_perform(self, crl):
"""
performs HTTP GET and returns body of response
"""
bfr = BytesIO()
crl.setopt(crl.WRITEFUNCTION, bfr.write)
crl.perform()
info = curl_info(crl)
if info:
if self.verbose and not self.silent:
for i... |
def curl_setup(self, proxy=None, timeout=0):
"""
Set curl options
- http://pycurl.io/docs/latest/
- https://curl.haxx.se/libcurl/c/curl_easy_setopt.html
Proxy options (str or dict):
proxy = 'https://example.com:80' # pycurl.PROXY
proxy = {
'PROXY... |
def safequote_restbase(title):
"""
Safequote restbase title possibly having slash in title
"""
try:
return quote(title.encode('utf-8'), safe='')
except UnicodeDecodeError:
return quote(title, safe='') |
def category(self, title, pageid=None, cparams=None, namespace=None):
"""
Returns category query string
"""
query = self.LIST.substitute(
WIKI=self.uri,
ENDPOINT=self.endpoint,
LIST='categorymembers')
status = pageid or title
query += ... |
def labels(self, qids):
"""
Returns Wikidata labels query string
"""
if len(qids) > 50:
raise ValueError("The limit is 50.")
self.domain = 'www.wikidata.org'
self.uri = self.wiki_uri(self.domain)
query = self.WIKIDATA.substitute(
WIKI=sel... |
def imageinfo(self, files):
"""
Returns imageinfo query string
"""
files = '|'.join([safequote(x) for x in files])
self.set_status('imageinfo', files)
return self.IMAGEINFO.substitute(
WIKI=self.uri,
ENDPOINT=self.endpoint,
FILES=file... |
def parse(self, title, pageid=None):
"""
Returns Mediawiki action=parse query string
"""
qry = self.PARSE.substitute(
WIKI=self.uri,
ENDPOINT=self.endpoint,
PAGE=safequote(title) or pageid)
if pageid and not title:
qry = qry.replac... |
def query(self, titles, pageids=None, cparams=None):
"""
Returns MediaWiki action=query query string
"""
query = self.QUERY.substitute(
WIKI=self.uri,
ENDPOINT=self.endpoint,
TITLES=safequote(titles) or pageids)
status = titles or pageids
... |
def random(self, namespace=0):
"""
Returns query string for random page
"""
query = self.LIST.substitute(
WIKI=self.uri,
ENDPOINT=self.endpoint,
LIST='random')
query += "&rnlimit=1&rnnamespace=%d" % namespace
emoji = [
u'\U... |
def restbase(self, endpoint, title):
"""
Returns RESTBase query string
"""
if not endpoint:
raise ValueError("invalid endpoint: %s" % endpoint)
route = endpoint
if title and endpoint != '/page/':
route = endpoint + safequote_restbase(title)
... |
def set_status(self, action, target):
"""
Sets query status with format: "{domain} ({action}) {target}"
"""
try:
target = unquote(target)
except (AttributeError, TypeError):
pass
status = "%s (%s) %s" % (self.domain, action, target)
status... |
def site(self, action):
"""
Returns site query
"""
query = None
viewdays = 7
hostpath = self.uri + self.endpoint
if action == 'siteinfo':
query = hostpath + (
'?action=query'
'&meta=siteinfo|siteviews'
'... |
def wikidata(self, title, wikibase=None):
"""
Returns Wikidata query string
"""
self.domain = 'www.wikidata.org'
self.uri = self.wiki_uri(self.domain)
query = self.WIKIDATA.substitute(
WIKI=self.uri,
ENDPOINT=self.endpoint,
LANG=self.v... |
def _handle_response(self):
"""
returns RESTBase response if appropriate
"""
content = self.cache['restbase']['info']['content-type']
if content.startswith('text/html'):
html = self.cache['restbase']['response']
if isinstance(html, bytes):
... |
def _query(self, action, qobj):
"""
returns WPToolsQuery string from action
"""
return qobj.restbase(self.params['rest_endpoint'],
self.params.get('title')) |
def _unpack_images(self, rdata):
"""
Set image data from RESTBase response
"""
image = rdata.get('image') # /page/mobile-sections-lead
originalimage = rdata.get('originalimage') # /page/summary
thumbnail = rdata.get('thumbnail') # /page/summary
if image or ori... |
def get_restbase(self, endpoint='/page/',
show=True, proxy=None, timeout=0):
"""
GET RESTBase /page/ endpoints needing only {title}
https://en.wikipedia.org/api/rest_v1/
for example:
/page/
/page/html/{title}
/page/summary/{title}... |
def get_infobox(ptree, boxterm="box"):
"""
Returns parse tree template with title containing <boxterm> as dict:
<box> = {<name>: <value>, ...}
If simple transform fails, attempts more general assembly:
<box> = {'boxes': [{<title>: <parts>}, ...],
'count': <len(boxes)>}
... |
def get_links(rlinks):
"""
returns list of titles/urls from query/parse links response
"""
if rlinks is None:
return
links = []
for item in rlinks:
if 'url' in item:
links.append(item['url'])
if 'title' in item and 'ns' in item:
if item['ns'] == 0:... |
def is_text(obj, name=None):
"""
returns True if object is text-like
"""
try: # python2
ans = isinstance(obj, basestring)
except NameError: # python3
ans = isinstance(obj, str)
if name:
print("is_text: (%s) %s = %s" % (ans, name, obj.__class__),
file=sys.s... |
def json_loads(data):
"""
python-version-safe json.loads
"""
try:
return json.loads(data, encoding='utf-8')
except TypeError:
return json.loads(data.decode('utf-8')) |
def stderr(msg, silent=False):
"""
write msg to stderr if not silent
"""
if not silent:
print(msg, file=sys.stderr) |
def template_to_dict(tree, debug=0, find=False):
"""
returns wikitext template as dict
debug = 1
prints minimal debug info to stdout
debug > 1
compares _iter() versus _find() results
find = True
sets values from _find() algorithm (default _iter())
"""
# you can comp... |
def template_to_dict_alt(tree, title):
"""
Returns parse tree template as {<title>: <parts>}
This is a more general parse tree infobox template parser.
"""
box = []
part = []
for item in tree.iter():
if item.tag == 'part':
if part:
box.append(part)
... |
def template_to_dict_debug(name, item, debug):
"""
Print debug statements to compare algorithms
"""
if debug == 1:
print("\n%s = " % name)
elif debug > 1:
print("\n%s" % name)
print("=" * 64)
print(lxml.etree.tostring(item))
print() |
def template_to_dict_find(item, debug=0):
"""
DEPRECATED: Returns infobox parsetree value using etree.find()
Older template_to_dict() algorithm, uses etree.xpath() to "lookup"
or find specific elements, but fails to include tail text in the
order it is found, and does not _exclude_ <ext> tags (refe... |
def template_to_dict_iter(item, debug=0):
"""
Returns infobox parsetree value using etree.iter()
Preferred template_to_dict() algorithm, uses etree.iter() to
iterate over elements, accumulating tail text in order, but not
preserving `<ext>` tags (references, etc.). The advantage is that
it pick... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.