Search is not available for this dataset
text stringlengths 75 104k |
|---|
def overview(self, tag=None, fromdate=None, todate=None):
"""
Gets a brief overview of statistics for all of your outbound email.
"""
return self.call("GET", "/stats/outbound", tag=tag, fromdate=fromdate, todate=todate) |
def sends(self, tag=None, fromdate=None, todate=None):
"""
Gets a total count of emails you’ve sent out.
"""
return self.call("GET", "/stats/outbound/sends", tag=tag, fromdate=fromdate, todate=todate) |
def bounces(self, tag=None, fromdate=None, todate=None):
"""
Gets total counts of emails you’ve sent out that have been returned as bounced.
"""
return self.call("GET", "/stats/outbound/bounces", tag=tag, fromdate=fromdate, todate=todate) |
def spam(self, tag=None, fromdate=None, todate=None):
"""
Gets a total count of recipients who have marked your email as spam.
"""
return self.call("GET", "/stats/outbound/spam", tag=tag, fromdate=fromdate, todate=todate) |
def tracked(self, tag=None, fromdate=None, todate=None):
"""
Gets a total count of emails you’ve sent with open tracking or link tracking enabled.
"""
return self.call("GET", "/stats/outbound/tracked", tag=tag, fromdate=fromdate, todate=todate) |
def opens(self, tag=None, fromdate=None, todate=None):
"""
Gets total counts of recipients who opened your emails.
This is only recorded when open tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/opens", tag=tag, fromdate=fromdate, todate=todate) |
def opens_platforms(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the platforms used to open your emails.
This is only recorded when open tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/opens/platforms", tag=tag, fromdate=fr... |
def emailclients(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the email clients used to open your emails.
This is only recorded when open tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/opens/emailclients", tag=tag, fromdat... |
def readtimes(self, tag=None, fromdate=None, todate=None):
"""
Gets the length of time that recipients read emails along with counts for each time.
This is only recorded when open tracking is enabled for that email.
Read time tracking stops at 20 seconds, so any read times above that wil... |
def clicks(self, tag=None, fromdate=None, todate=None):
"""
Gets total counts of unique links that were clicked.
"""
return self.call("GET", "/stats/outbound/clicks", tag=tag, fromdate=fromdate, todate=todate) |
def browserfamilies(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the browsers used to open links in your emails.
This is only recorded when Link Tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/clicks/browserfamilies", tag=t... |
def clicks_platforms(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the browser platforms used to open your emails.
This is only recorded when Link Tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/clicks/platforms", tag=tag, f... |
def location(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of which part of the email links were clicked from (HTML or Text).
This is only recorded when Link Tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/clicks/location", tag... |
def line_rate(self, filename=None):
"""
Return the global line rate of the coverage report. If the
`filename` file is given, return the line rate of the file.
"""
if filename is None:
el = self.xml
else:
el = self._get_class_element_by_filename(fil... |
def branch_rate(self, filename=None):
"""
Return the global branch rate of the coverage report. If the
`filename` file is given, return the branch rate of the file.
"""
if filename is None:
el = self.xml
else:
el = self._get_class_element_by_filena... |
def missed_statements(self, filename):
"""
Return a list of uncovered line numbers for each of the missed
statements found for the file `filename`.
"""
el = self._get_class_element_by_filename(filename)
lines = el.xpath('./lines/line[@hits=0]')
return [int(l.attri... |
def line_statuses(self, filename):
"""
Return a list of tuples `(lineno, status)` of all the lines found in
the Cobertura report for the given file `filename` where `lineno` is
the line number and `status` is coverage status of the line which can
be either `True` (line hit) or `F... |
def missed_lines(self, filename):
"""
Return a list of extrapolated uncovered line numbers for the
file `filename` according to `Cobertura.line_statuses`.
"""
statuses = self.line_statuses(filename)
statuses = extrapolate_coverage(statuses)
return [lno for lno, st... |
def file_source(self, filename):
"""
Return a list of namedtuple `Line` for each line of code found in the
source file with the given `filename`.
"""
lines = []
try:
with self.filesystem.open(filename) as f:
line_statuses = dict(self.line_statu... |
def total_misses(self, filename=None):
"""
Return the total number of uncovered statements for the file
`filename`. If `filename` is not given, return the total
number of uncovered statements for all files.
"""
if filename is not None:
return len(self.missed_s... |
def total_hits(self, filename=None):
"""
Return the total number of covered statements for the file
`filename`. If `filename` is not given, return the total
number of covered statements for all files.
"""
if filename is not None:
return len(self.hit_statements... |
def total_statements(self, filename=None):
"""
Return the total number of statements for the file
`filename`. If `filename` is not given, return the total
number of statements for all files.
"""
if filename is not None:
statements = self._get_lines_by_filename... |
def files(self):
"""
Return the list of available files in the coverage report.
"""
# maybe replace with a trie at some point? see has_file FIXME
already_seen = set()
filenames = []
for el in self.xml.xpath("//class"):
filename = el.attrib['filename']... |
def source_lines(self, filename):
"""
Return a list for source lines of file `filename`.
"""
with self.filesystem.open(filename) as f:
return f.readlines() |
def has_better_coverage(self):
"""
Return `True` if coverage of has improved, `False` otherwise.
This does not ensure that all changes have been covered. If this is
what you want, use `CoberturaDiff.has_all_changes_covered()` instead.
"""
for filename in self.files():
... |
def has_all_changes_covered(self):
"""
Return `True` if all changes have been covered, `False` otherwise.
"""
for filename in self.files():
for hunk in self.file_source_hunks(filename):
for line in hunk:
if line.reason is None:
... |
def _diff_attr(self, attr_name, filename):
"""
Return the difference between
`self.cobertura2.<attr_name>(filename)` and
`self.cobertura1.<attr_name>(filename)`.
This generic method is meant to diff the count of methods that return
counts for a given file `filename`, e.g... |
def diff_missed_lines(self, filename):
"""
Return a list of 2-element tuples `(lineno, is_new)` for the given
file `filename` where `lineno` is a missed line number and `is_new`
indicates whether the missed line was introduced (True) or removed
(False).
"""
line_c... |
def file_source(self, filename):
"""
Return a list of namedtuple `Line` for each line of code found in the
given file `filename`.
"""
if self.cobertura1.has_file(filename) and \
self.cobertura1.filesystem.has_file(filename):
lines1 = self.cobertura1.s... |
def file_source_hunks(self, filename):
"""
Like `CoberturaDiff.file_source`, but returns a list of line hunks of
the lines that have changed for the given file `filename`. An empty
list means that the file has no lines that have a change in coverage
status.
"""
li... |
def monitor(self):
"""Flushes the queue periodically."""
while self.monitor_running.is_set():
if time.time() - self.last_flush > self.batch_time:
if not self.queue.empty():
logger.info("Queue Flush: time without flush exceeded")
self.fl... |
def put_records(self, records, partition_key=None):
"""Add a list of data records to the record queue in the proper format.
Convinience method that calls self.put_record for each element.
Parameters
----------
records : list
Lists of records to send.
partitio... |
def put_record(self, data, partition_key=None):
"""Add data to the record queue in the proper format.
Parameters
----------
data : str
Data to send.
partition_key: str
Hash that determines which shard a given data record belongs to.
"""
#... |
def close(self):
"""Flushes the queue and waits for the executor to finish."""
logger.info('Closing producer')
self.flush_queue()
self.monitor_running.clear()
self.pool.shutdown()
logger.info('Producer closed') |
def flush_queue(self):
"""Grab all the current records in the queue and send them."""
records = []
while not self.queue.empty() and len(records) < self.batch_size:
records.append(self.queue.get())
if records:
self.send_records(records)
self.last_flus... |
def send_records(self, records, attempt=0):
"""Send records to the Kinesis stream.
Falied records are sent again with an exponential backoff decay.
Parameters
----------
records : array
Array of formated records to send.
attempt: int
Number of ti... |
def rangify(number_list):
"""Assumes the list is sorted."""
if not number_list:
return number_list
ranges = []
range_start = prev_num = number_list[0]
for num in number_list[1:]:
if num != (prev_num + 1):
ranges.append((range_start, prev_num))
range_start = ... |
def extrapolate_coverage(lines_w_status):
"""
Given the following input:
>>> lines_w_status = [
(1, True),
(4, True),
(7, False),
(9, False),
]
Return expanded lines with their extrapolated line status.
>>> extrapolate_coverage(lines_w_status) == [
(1, ... |
def reconcile_lines(lines1, lines2):
"""
Return a dict `{lineno1: lineno2}` which reconciles line numbers `lineno1`
of list `lines1` to line numbers `lineno2` of list `lines2`. Only lines
that are common in both sets are present in the dict, lines unique to one
of the sets are omitted.
"""
d... |
def hunkify_lines(lines, context=3):
"""
Return a list of line hunks given a list of lines `lines`. The number of
context lines can be control with `context` which will return line hunks
surrounded with `context` lines before and after the code change.
"""
# Find contiguous line changes
rang... |
def show(cobertura_file, format, output, source, source_prefix):
"""show coverage summary of a Cobertura report"""
cobertura = Cobertura(cobertura_file, source=source)
Reporter = reporters[format]
reporter = Reporter(cobertura)
report = reporter.generate()
if not isinstance(report, bytes):
... |
def diff(
cobertura_file1, cobertura_file2,
color, format, output, source1, source2,
source_prefix1, source_prefix2, source):
"""compare coverage of two Cobertura reports"""
cobertura1 = Cobertura(
cobertura_file1,
source=source1,
source_prefix=source_prefix1
... |
def open(self, filename):
"""
Yield a file-like object for file `filename`.
This function is a context manager.
"""
filename = self.real_filename(filename)
if not os.path.exists(filename):
raise self.FileNotFound(filename)
with codecs.open(filename,... |
def topic_inject(self, topic_name, _msg_content=None, **kwargs):
"""
Injecting message into topic. if _msg_content, we inject it directly. if not, we use all extra kwargs
:param topic_name: name of the topic
:param _msg_content: optional message content
:param kwargs: each extra ... |
def param_set(self, param_name, _value=None, **kwargs):
"""
Setting parameter. if _value, we inject it directly. if not, we use all extra kwargs
:param topic_name: name of the topic
:param _value: optional value
:param kwargs: each extra kwarg will be put in the value if structur... |
def run(self):
"""runner"""
# change version in code and changelog before running this
subprocess.check_call("git commit CHANGELOG.rst pyros/_version.py CHANGELOG.rst -m 'v{0}'".format(__version__), shell=True)
subprocess.check_call("git push", shell=True)
print("You should ver... |
def run(interface, config, logfile, ros_args):
"""
Start a pyros node.
:param interface: the interface implementation (ROS, Mock, ZMP, etc.)
:param config: the config file path, absolute, or relative to working directory
:param logfile: the logfile path, absolute, or relative to working directory
... |
def nickmask(prefix: str, kwargs: Dict[str, Any]) -> None:
""" store nick, user, host in kwargs if prefix is correct format """
if "!" in prefix and "@" in prefix:
# From a user
kwargs["nick"], remainder = prefix.split("!", 1)
kwargs["user"], kwargs["host"] = remainder.split("@", 1)
... |
def split_line(msg: str) -> Tuple[str, str, List[str]]:
""" Parse message according to rfc 2812 for routing """
match = RE_IRCLINE.match(msg)
if not match:
raise ValueError("Invalid line")
prefix = match.group("prefix") or ""
command = match.group("command")
params = (match.group("param... |
def b(field: str, kwargs: Dict[str, Any],
present: Optional[Any] = None, missing: Any = '') -> str:
"""
Return `present` value (default to `field`) if `field` in `kwargs` and
Truthy, otherwise return `missing` value
"""
if kwargs.get(field):
return field if present is None else str(pre... |
def f(field: str, kwargs: Dict[str, Any],
default: Optional[Any] = None) -> str:
""" Alias for more readable command construction """
if default is not None:
return str(kwargs.get(field, default))
return str(kwargs[field]) |
def pack(field: str, kwargs: Dict[str, Any],
default: Optional[Any] = None, sep: str=',') -> str:
""" Util for joining multiple fields with commas """
if default is not None:
value = kwargs.get(field, default)
else:
value = kwargs[field]
if isinstance(value, str):
return... |
def pack_command(command: str, **kwargs: Any) -> str:
""" Pack a command to send to an IRC server """
if not command:
raise ValueError("Must provide a command")
if not isinstance(command, str):
raise ValueError("Command must be a string")
command = command.upper()
# ================... |
async def connect(self) -> None:
"""Open a connection to the defined server."""
def protocol_factory() -> Protocol:
return Protocol(client=self)
_, protocol = await self.loop.create_connection(
protocol_factory,
host=self.host,
port=self.port,
... |
def trigger(self, event: str, **kwargs: Any) -> None:
"""Trigger all handlers for an event to (asynchronously) execute"""
event = event.upper()
for func in self._event_handlers[event]:
self.loop.create_task(func(**kwargs))
# This will unblock anyone that is awaiting on the ne... |
def on(self, event: str, func: Optional[Callable] = None) -> Callable:
"""
Decorate a function to be invoked when the given event occurs.
The function may be a coroutine. Your function should accept **kwargs
in case an event is triggered with unexpected kwargs.
Example
... |
def send(self, command: str, **kwargs: Any) -> None:
"""
Send a message to the server.
.. code-block:: python
client.send("nick", nick="weatherbot")
client.send("privmsg", target="#python", message="Hello, World!")
"""
packed_command = pack_command(comm... |
def _handle(self, nick, target, message, **kwargs):
""" client callback entrance """
for regex, (func, pattern) in self.routes.items():
match = regex.match(message)
if match:
self.client.loop.create_task(
func(nick, target, message, match, **kw... |
def main():
"""parse commandline arguments and print result"""
fcodes = collections.OrderedDict((
('f.i', protocol.FLG_FORMAT_FDI),
('fi', protocol.FLG_FORMAT_FI),
('f.i.c', protocol.FLG_FORMAT_FDIDC),
('f.ic', protocol.FLG_FORMAT_FDIC),
('fi.c', protocol.FLG_FORMAT_FIDC... |
def main():
"""parse commandline arguments and print result"""
#
# setup command line parsing a la argpase
#
parser = argparse.ArgumentParser()
# positional args
parser.add_argument('uri', metavar='URI', nargs='?', default='/',
help='[owserver:]//hostname:port/path'... |
def build_url(self, path, params=None):
'''
Constructs the url for a cheddar API resource
'''
url = u'%s/%s/productCode/%s' % (
self.endpoint,
path,
self.product_code,
)
if params:
for key, value in params.items():
... |
def make_request(self, path, params=None, data=None, method=None):
'''
Makes a request to the cheddar api using the authentication and
configuration settings available.
'''
# Setup values
url = self.build_url(path, params)
client_log.debug('Requesting: %s' % url)... |
def main():
"""parse commandline arguments and print result"""
#
# setup command line parsing a la argpase
#
parser = argparse.ArgumentParser()
# positional args
parser.add_argument('uri', metavar='URI', nargs='?', default='/',
help='[owserver:]//server:port/entity'... |
def proxy(host='localhost', port=4304, flags=0, persistent=False,
verbose=False, ):
"""factory function that returns a proxy object for an owserver at
host, port.
"""
# resolve host name/port
try:
gai = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM,
... |
def clone(proxy, persistent=True):
"""factory function for cloning a proxy object"""
if not isinstance(proxy, _Proxy):
raise TypeError('argument is not a Proxy object')
if persistent:
pclass = _PersistentProxy
else:
pclass = _Proxy
return pclass(proxy._family, proxy._socka... |
def shutdown(self):
"""shutdown connection"""
if self.verbose:
print(self.socket.getsockname(), 'xx', self.peername)
try:
self.socket.shutdown(socket.SHUT_RDWR)
except IOError as err:
assert err.errno is _ENOTCONN, "unexpected IOError: %s" % err
... |
def req(self, msgtype, payload, flags, size=0, offset=0, timeout=0):
"""send message to server and return response"""
if timeout < 0:
raise ValueError("timeout cannot be negative!")
tohead = _ToServerHeader(payload=len(payload), type=msgtype,
flags=... |
def _send_msg(self, header, payload):
"""send message to server"""
if self.verbose:
print('->', repr(header))
print('..', repr(payload))
assert header.payload == len(payload)
try:
sent = self.socket.send(header + payload)
except IOError as err... |
def _read_msg(self):
"""read message from server"""
#
# NOTE:
# '_recv_socket(nbytes)' was implemented as
# 'socket.recv(nbytes, socket.MSG_WAITALL)'
# but socket.MSG_WAITALL proved not reliable
#
def _recv_socket(nbytes):
"""read nbytes byte... |
def sendmess(self, msgtype, payload, flags=0, size=0, offset=0, timeout=0):
""" retcode, data = sendmess(msgtype, payload)
send generic message and returns retcode, data
"""
flags |= self.flags
assert not (flags & FLG_PERSISTENCE)
with self._new_connection() as conn:
... |
def ping(self):
"""sends a NOP packet and waits response; returns None"""
ret, data = self.sendmess(MSG_NOP, bytes())
if data or ret > 0:
raise ProtocolError('invalid reply to ping message')
if ret < 0:
raise OwnetError(-ret, self.errmess[-ret]) |
def present(self, path, timeout=0):
"""returns True if there is an entity at path"""
ret, data = self.sendmess(MSG_PRESENCE, str2bytez(path),
timeout=timeout)
assert ret <= 0 and not data, (ret, data)
if ret < 0:
return False
else:
... |
def dir(self, path='/', slash=True, bus=False, timeout=0):
"""list entities at path"""
if slash:
msg = MSG_DIRALLSLASH
else:
msg = MSG_DIRALL
if bus:
flags = self.flags | FLG_BUS_RET
else:
flags = self.flags & ~FLG_BUS_RET
... |
def read(self, path, size=MAX_PAYLOAD, offset=0, timeout=0):
"""read data at path"""
if size > MAX_PAYLOAD:
raise ValueError("size cannot exceed %d" % MAX_PAYLOAD)
ret, data = self.sendmess(MSG_READ, str2bytez(path),
size=size, offset=offset, timeo... |
def write(self, path, data, offset=0, timeout=0):
"""write data at path
path is a string, data binary; it is responsability of the caller
ensure proper encoding.
"""
# fixme: check of path type delayed to str2bytez
if not isinstance(data, (bytes, bytearray, )):
... |
def sendmess(self, msgtype, payload, flags=0, size=0, offset=0, timeout=0):
"""
retcode, data = sendmess(msgtype, payload)
send generic message and returns retcode, data
"""
# reuse last valid connection or create new
conn = self.conn or self._new_connection()
# ... |
def get_customers(self, filter_data=None):
'''
Returns all customers. Sometimes they are too much and cause internal
server errors on CG. API call permits post parameters for filtering
which tends to fix this
https://cheddargetter.com/developers#all-customers
filter_da... |
def delete_all_customers(self):
'''
This method does exactly what you think it does. Calling this method
deletes all customer data in your cheddar product and the configured
gateway. This action cannot be undone.
DO NOT RUN THIS UNLESS YOU REALLY, REALLY, REALLY MEAN T... |
def initial_bill_date(self):
'''
An estimated initial bill date for an account created today,
based on available plan info.
'''
time_to_start = None
if self.initial_bill_count_unit == 'months':
time_to_start = relativedelta(months=self.initial_bill_co... |
def charge(self, code, each_amount, quantity=1, description=None):
'''
Add an arbitrary charge or credit to a customer's account. A positive
number will create a charge. A negative number will create a credit.
each_amount is normalized to a Decimal with a precision of 2 as tha... |
def create_one_time_invoice(self, charges):
'''
Charges should be a list of charges to execute immediately. Each
value in the charges diectionary should be a dictionary with the
following keys:
code
Your code for this charge. This code will be displayed in the
... |
def set(self, quantity):
'''
Set the item's quantity to the passed in amount. If nothing is
passed in, a quantity of 1 is assumed. If a decimal value is passsed
in, it is rounded to the 4th decimal place as that is the level of
precision which the Cheddar API accepts.
... |
def deep_compare(self, other, settings):
"""
Compares each field of the name one at a time to see if they match.
Each name field has context-specific comparison logic.
:param Name other: other Name for comparison
:return bool: whether the two names are compatible
"""
... |
def ratio_deep_compare(self, other, settings):
"""
Compares each field of the name one at a time to see if they match.
Each name field has context-specific comparison logic.
:param Name other: other Name for comparison
:return int: sequence ratio match (out of 100)
"""
... |
def _is_compatible_with(self, other):
"""
Return True if names are not incompatible.
This checks that the gender of titles and compatibility of suffixes
"""
title = self._compare_title(other)
suffix = self._compare_suffix(other)
return title and suffix |
def _compare_title(self, other):
"""Return False if titles have different gender associations"""
# If title is omitted, assume a match
if not self.title or not other.title:
return True
titles = set(self.title_list + other.title_list)
return not (titles & MALE_TITLE... |
def _compare_suffix(self, other):
"""Return false if suffixes are mutually exclusive"""
# If suffix is omitted, assume a match
if not self.suffix or not other.suffix:
return True
# Check if more than one unique suffix
suffix_set = set(self.suffix_list + other.suffix... |
def _compare_components(self, other, settings, ratio=False):
"""Return comparison of first, middle, and last components"""
first = compare_name_component(
self.first_list,
other.first_list,
settings['first'],
ratio,
)
if settings['check_n... |
def _determine_weights(self, other, settings):
"""
Return weights of name components based on whether or not they were
omitted
"""
# TODO: Reduce weight for matches by prefix or initials
first_is_used = settings['first']['required'] or \
self.first and other... |
def init_app(self, app):
"""
:param app: :class:`sanic.Sanic` instance to rate limit.
"""
self.enabled = app.config.setdefault(C.ENABLED, True)
self._swallow_errors = app.config.setdefault(
C.SWALLOW_ERRORS, self._swallow_errors
)
self._storage_options... |
def limit(self, limit_value, key_func=None, per_method=False,
methods=None, error_message=None, exempt_when=None):
"""
decorator to be used for rate limiting individual routes.
:param limit_value: rate limit string or a callable that returns a string.
:ref:`ratelimit-stri... |
def shared_limit(self, limit_value, scope, key_func=None,
error_message=None, exempt_when=None):
"""
decorator to be applied to multiple routes sharing the same rate limit.
:param limit_value: rate limit string or a callable that returns a string.
:ref:`ratelimit-s... |
def reset(self):
"""
resets the storage if it supports being reset
"""
try:
self._storage.reset()
self.logger.info("Storage has been reset and all limits cleared")
except NotImplementedError:
self.logger.warning("This storage type does not supp... |
def get_soup(page=''):
"""
Returns a bs4 object of the page requested
"""
content = requests.get('%s/%s' % (BASE_URL, page)).text
return BeautifulSoup(content) |
def match(fullname1, fullname2, strictness='default', options=None):
"""
Takes two names and returns true if they describe the same person.
:param string fullname1: first human name
:param string fullname2: second human name
:param string strictness: strictness settings to use
:param dict optio... |
def ratio(fullname1, fullname2, strictness='default', options=None):
"""
Takes two names and returns true if they describe the same person.
Uses difflib's sequence matching on a per-field basis for names
:param string fullname1: first human name
:param string fullname2: second human name
:param... |
def _get_zipped_rows(self, soup):
"""
Returns all 'tr' tag rows as a list of tuples. Each tuple is for
a single story.
"""
# the table with all submissions
table = soup.findChildren('table')[2]
# get all rows but last 2
rows = table.findChildren(['... |
def _build_story(self, all_rows):
"""
Builds and returns a list of stories (dicts) from the passed source.
"""
# list to hold all stories
all_stories = []
for (info, detail) in all_rows:
#-- Get the into about a story --#
# split in 3 c... |
def get_stories(self, story_type='', limit=30):
"""
Yields a list of stories from the passed page
of HN.
'story_type' can be:
\t'' = top stories (homepage) (default)
\t'news2' = page 2 of top stories
\t'newest' = most recent stories
\t'best' = best... |
def get_leaders(self, limit=10):
""" Return the leaders of Hacker News """
if limit is None:
limit = 10
soup = get_soup('leaders')
table = soup.find('table')
leaders_table = table.find_all('table')[1]
listleaders = leaders_table.find_all('tr')[2:]
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.