sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1
value |
|---|---|---|
def romanNumeral(n):
"""
>>> romanNumeral(13)
'XIII'
>>> romanNumeral(2944)
'MMCMXLIV'
"""
if 0 > n > 4000: raise ValueError('``n`` must lie between 1 and 3999: %d' % n)
roman = 'I IV V IX X XL L XC C CD D CM M'.split()
arabic = [1, 4, 5, 9, 10, 40, 50, 90, 10... | >>> romanNumeral(13)
'XIII'
>>> romanNumeral(2944)
'MMCMXLIV' | entailment |
def first(n, it, constructor=list):
"""
>>> first(3,iter([1,2,3,4]))
[1, 2, 3]
>>> first(3,iter([1,2,3,4]), iter) #doctest: +ELLIPSIS
<itertools.islice object at ...>
>>> first(3,iter([1,2,3,4]), tuple)
(1, 2, 3)
"""
return constructor(itertools.islice(it,n)) | >>> first(3,iter([1,2,3,4]))
[1, 2, 3]
>>> first(3,iter([1,2,3,4]), iter) #doctest: +ELLIPSIS
<itertools.islice object at ...>
>>> first(3,iter([1,2,3,4]), tuple)
(1, 2, 3) | entailment |
def drop(n, it, constructor=list):
"""
>>> first(10,drop(10,xrange(sys.maxint),iter))
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
"""
return constructor(itertools.islice(it,n,None)) | >>> first(10,drop(10,xrange(sys.maxint),iter))
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19] | entailment |
def run(self, func, *args, **kwargs):
"""Same as ``self.dryRun`` if ``self.dry``, else same as ``self.wetRun``."""
if self.dry:
return self.dryRun(func, *args, **kwargs)
else:
return self.wetRun(func, *args, **kwargs) | Same as ``self.dryRun`` if ``self.dry``, else same as ``self.wetRun``. | entailment |
def dryRun(self, func, *args, **kwargs):
"""Instead of running function with `*args` and `**kwargs`, just print
out the function call."""
print >> self.out, \
self.formatterDict.get(func, self.defaultFormatter)(func, *args, **kwargs) | Instead of running function with `*args` and `**kwargs`, just print
out the function call. | entailment |
def iterbridges():
''' Iterate over all the bridges in the system. '''
net_files = os.listdir(SYSFS_NET_PATH)
for d in net_files:
path = os.path.join(SYSFS_NET_PATH, d)
if not os.path.isdir(path):
continue
if os.path.exists(os.path.join(path, b"bridge")):
yiel... | Iterate over all the bridges in the system. | entailment |
def addbr(name):
''' Create new bridge with the given name '''
fcntl.ioctl(ifconfig.sockfd, SIOCBRADDBR, name)
return Bridge(name) | Create new bridge with the given name | entailment |
def iterifs(self):
''' Iterate over all the interfaces in this bridge. '''
if_path = os.path.join(SYSFS_NET_PATH, self.name, b"brif")
net_files = os.listdir(if_path)
for iface in net_files:
yield iface | Iterate over all the interfaces in this bridge. | entailment |
def addif(self, iface):
''' Add the interface with the given name to this bridge. Equivalent to
brctl addif [bridge] [interface]. '''
if type(iface) == ifconfig.Interface:
devindex = iface.index
else:
devindex = ifconfig.Interface(iface).index
ifreq = ... | Add the interface with the given name to this bridge. Equivalent to
brctl addif [bridge] [interface]. | entailment |
def delif(self, iface):
''' Remove the interface with the given name from this bridge.
Equivalent to brctl delif [bridge] [interface]'''
if type(iface) == ifconfig.Interface:
devindex = iface.index
else:
devindex = ifconfig.Interface(iface).index
ifreq... | Remove the interface with the given name from this bridge.
Equivalent to brctl delif [bridge] [interface] | entailment |
def delete(self):
''' Brings down the bridge interface, and removes it. Equivalent to
ifconfig [bridge] down && brctl delbr [bridge]. '''
self.down()
fcntl.ioctl(ifconfig.sockfd, SIOCBRDELBR, self.name)
return self | Brings down the bridge interface, and removes it. Equivalent to
ifconfig [bridge] down && brctl delbr [bridge]. | entailment |
def _get_random_id():
""" Get a random (i.e., unique) string identifier"""
symbols = string.ascii_uppercase + string.ascii_lowercase + string.digits
return ''.join(random.choice(symbols) for _ in range(15)) | Get a random (i.e., unique) string identifier | entailment |
def get_lib_filename(category, name):
""" Get a filename of a built-in library file. """
base_dir = os.path.dirname(os.path.abspath(__file__))
if category == 'js':
filename = os.path.join('js', '{0}.js'.format(name))
elif category == 'css':
filename = os.path.join('css', '{0}.css'.format... | Get a filename of a built-in library file. | entailment |
def output_notebook(
d3js_url="//d3js.org/d3.v3.min",
requirejs_url="//cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.min.js",
html_template=None
):
""" Import required Javascript libraries to Jupyter Notebook. """
if html_template is None:
html_template = read_lib('ht... | Import required Javascript libraries to Jupyter Notebook. | entailment |
def create_graph_html(js_template, css_template, html_template=None):
""" Create HTML code block given the graph Javascript and CSS. """
if html_template is None:
html_template = read_lib('html', 'graph')
# Create div ID for the graph and give it to the JS and CSS templates so
# they can refere... | Create HTML code block given the graph Javascript and CSS. | entailment |
def get_newest_possible_languagetool_version():
"""Return newest compatible version.
>>> version = get_newest_possible_languagetool_version()
>>> version in [JAVA_6_COMPATIBLE_VERSION, LATEST_VERSION]
True
"""
java_path = find_executable('java')
if not java_path:
# Just ignore this... | Return newest compatible version.
>>> version = get_newest_possible_languagetool_version()
>>> version in [JAVA_6_COMPATIBLE_VERSION, LATEST_VERSION]
True | entailment |
def iterifs(physical=True):
''' Iterate over all the interfaces in the system. If physical is
true, then return only real physical interfaces (not 'lo', etc).'''
net_files = os.listdir(SYSFS_NET_PATH)
interfaces = set()
virtual = set()
for d in net_files:
path = os.path.join(SYSFS_NE... | Iterate over all the interfaces in the system. If physical is
true, then return only real physical interfaces (not 'lo', etc). | entailment |
def init():
''' Initialize the library '''
globals()["sock"] = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
globals()["sockfd"] = globals()["sock"].fileno() | Initialize the library | entailment |
def up(self):
''' Bring up the bridge interface. Equivalent to ifconfig [iface] up. '''
# Get existing device flags
ifreq = struct.pack('16sh', self.name, 0)
flags = struct.unpack('16sh', fcntl.ioctl(sockfd, SIOCGIFFLAGS, ifreq))[1]
# Set new flags
flags = flags | IFF_U... | Bring up the bridge interface. Equivalent to ifconfig [iface] up. | entailment |
def is_up(self):
''' Return True if the interface is up, False otherwise. '''
# Get existing device flags
ifreq = struct.pack('16sh', self.name, 0)
flags = struct.unpack('16sh', fcntl.ioctl(sockfd, SIOCGIFFLAGS, ifreq))[1]
# Set new flags
if flags & IFF_UP:
... | Return True if the interface is up, False otherwise. | entailment |
def get_mac(self):
''' Obtain the device's mac address. '''
ifreq = struct.pack('16sH14s', self.name, AF_UNIX, b'\x00'*14)
res = fcntl.ioctl(sockfd, SIOCGIFHWADDR, ifreq)
address = struct.unpack('16sH14s', res)[2]
mac = struct.unpack('6B8x', address)
return ":".join(['%0... | Obtain the device's mac address. | entailment |
def set_mac(self, newmac):
''' Set the device's mac address. Device must be down for this to
succeed. '''
macbytes = [int(i, 16) for i in newmac.split(':')]
ifreq = struct.pack('16sH6B8x', self.name, AF_UNIX, *macbytes)
fcntl.ioctl(sockfd, SIOCSIFHWADDR, ifreq) | Set the device's mac address. Device must be down for this to
succeed. | entailment |
def get_index(self):
''' Convert an interface name to an index value. '''
ifreq = struct.pack('16si', self.name, 0)
res = fcntl.ioctl(sockfd, SIOCGIFINDEX, ifreq)
return struct.unpack("16si", res)[1] | Convert an interface name to an index value. | entailment |
def set_pause_param(self, autoneg, rx_pause, tx_pause):
"""
Ethernet has flow control! The inter-frame pause can be adjusted, by
auto-negotiation through an ethernet frame type with a simple two-field
payload, and by setting it explicitly.
http://en.wikipedia.org/wiki/Ethernet_f... | Ethernet has flow control! The inter-frame pause can be adjusted, by
auto-negotiation through an ethernet frame type with a simple two-field
payload, and by setting it explicitly.
http://en.wikipedia.org/wiki/Ethernet_flow_control | entailment |
def get_version():
"""Return version string."""
with io.open('grammar_check/__init__.py', encoding='utf-8') as input_file:
for line in input_file:
if line.startswith('__version__'):
return ast.parse(line).body[0].value.s | Return version string. | entailment |
def split_elements(value):
"""Split a string with comma or space-separated elements into a list."""
l = [v.strip() for v in value.split(',')]
if len(l) == 1:
l = value.split()
return l | Split a string with comma or space-separated elements into a list. | entailment |
def generate_py2k(config, py2k_dir=PY2K_DIR, run_tests=False):
"""Generate Python 2 code from Python 3 code."""
def copy(src, dst):
if (not os.path.isfile(dst) or
os.path.getmtime(src) > os.path.getmtime(dst)):
shutil.copy(src, dst)
return dst
return None
... | Generate Python 2 code from Python 3 code. | entailment |
def default_hook(config):
"""Default setup hook."""
if (any(arg.startswith('bdist') for arg in sys.argv) and
os.path.isdir(PY2K_DIR) != IS_PY2K and os.path.isdir(LIB_DIR)):
shutil.rmtree(LIB_DIR)
if IS_PY2K and any(arg.startswith('install') or
arg.startswith('buil... | Default setup hook. | entailment |
def get_default_if():
""" Returns the default interface """
f = open ('/proc/net/route', 'r')
for line in f:
words = line.split()
dest = words[1]
try:
if (int (dest) == 0):
interf = words[0]
break
except ValueError:
pass... | Returns the default interface | entailment |
def get_default_gw():
""" Returns the default gateway """
octet_list = []
gw_from_route = None
f = open ('/proc/net/route', 'r')
for line in f:
words = line.split()
dest = words[1]
try:
if (int (dest) == 0):
gw_from_route = words[2]
... | Returns the default gateway | entailment |
def init(init_type='plaintext_tcp', *args, **kwargs):
"""
Create the module instance of the GraphiteClient.
"""
global _module_instance
reset()
validate_init_types = ['plaintext_tcp', 'plaintext', 'pickle_tcp',
'pickle', 'plain']
if init_type not in validate_init... | Create the module instance of the GraphiteClient. | entailment |
def send(*args, **kwargs):
""" Make sure that we have an instance of the GraphiteClient.
Then send the metrics to the graphite server.
User consumable method.
"""
if not _module_instance:
raise GraphiteSendException(
"Must call graphitesend.init() before sending")
_module_in... | Make sure that we have an instance of the GraphiteClient.
Then send the metrics to the graphite server.
User consumable method. | entailment |
def send_dict(*args, **kwargs):
""" Make sure that we have an instance of the GraphiteClient.
Then send the metrics to the graphite server.
User consumable method.
"""
if not _module_instance:
raise GraphiteSendException(
"Must call graphitesend.init() before sending")
_modul... | Make sure that we have an instance of the GraphiteClient.
Then send the metrics to the graphite server.
User consumable method. | entailment |
def send_list(*args, **kwargs):
""" Make sure that we have an instance of the GraphiteClient.
Then send the metrics to the graphite server.
User consumable method.
"""
if not _module_instance:
raise GraphiteSendException(
"Must call graphitesend.init() before sending")
_modul... | Make sure that we have an instance of the GraphiteClient.
Then send the metrics to the graphite server.
User consumable method. | entailment |
def cli():
""" Allow the module to be called from the cli. """
import argparse
parser = argparse.ArgumentParser(description='Send data to graphite')
# Core of the application is to accept a metric and a value.
parser.add_argument('metric', metavar='metric', type=str,
help='... | Allow the module to be called from the cli. | entailment |
def connect(self):
"""
Make a TCP connection to the graphite server on port self.port
"""
self.socket = socket.socket()
self.socket.settimeout(self.timeout_in_seconds)
try:
self.socket.connect(self.addr)
except socket.timeout:
raise Graphit... | Make a TCP connection to the graphite server on port self.port | entailment |
def autoreconnect(self, sleep=1, attempt=3, exponential=True, jitter=5):
"""
Tries to reconnect with some delay:
exponential=False: up to `attempt` times with `sleep` seconds between
each try
exponential=True: up to `attempt` times with exponential growing `sleep`
and r... | Tries to reconnect with some delay:
exponential=False: up to `attempt` times with `sleep` seconds between
each try
exponential=True: up to `attempt` times with exponential growing `sleep`
and random delay in range 1..`jitter` (exponential backoff)
:param sleep: time to sleep ... | entailment |
def disconnect(self):
"""
Close the TCP connection with the graphite server.
"""
try:
self.socket.shutdown(1)
# If its currently a socket, set it to None
except AttributeError:
self.socket = None
except Exception:
self.socket =... | Close the TCP connection with the graphite server. | entailment |
def _dispatch_send(self, message):
"""
Dispatch the different steps of sending
"""
if self.dryrun:
return message
if not self.socket:
raise GraphiteSendException(
"Socket was not created before send"
)
sending_functio... | Dispatch the different steps of sending | entailment |
def _send_and_reconnect(self, message):
"""Send _message_ to Graphite Server and attempt reconnect on failure.
If _autoreconnect_ was specified, attempt to reconnect if first send
fails.
:raises AttributeError: When the socket has not been set.
:raises socket.error: When the so... | Send _message_ to Graphite Server and attempt reconnect on failure.
If _autoreconnect_ was specified, attempt to reconnect if first send
fails.
:raises AttributeError: When the socket has not been set.
:raises socket.error: When the socket connection is no longer valid. | entailment |
def send(self, metric, value, timestamp=None, formatter=None):
"""
Format a single metric/value pair, and send it to the graphite
server.
:param metric: name of the metric
:type prefix: string
:param value: value of the metric
:type prefix: float or int
:... | Format a single metric/value pair, and send it to the graphite
server.
:param metric: name of the metric
:type prefix: string
:param value: value of the metric
:type prefix: float or int
:param timestmap: epoch time of the event
:type prefix: float or int
... | entailment |
def send_dict(self, data, timestamp=None, formatter=None):
"""
Format a dict of metric/values pairs, and send them all to the
graphite server.
:param data: key,value pair of metric name and metric value
:type prefix: dict
:param timestmap: epoch time of the event
... | Format a dict of metric/values pairs, and send them all to the
graphite server.
:param data: key,value pair of metric name and metric value
:type prefix: dict
:param timestmap: epoch time of the event
:type prefix: float or int
:param formatter: option non-default format... | entailment |
def enable_asynchronous(self):
"""Check if socket have been monkey patched by gevent"""
def is_monkey_patched():
try:
from gevent import monkey, socket
except ImportError:
return False
if hasattr(monkey, "saved"):
retur... | Check if socket have been monkey patched by gevent | entailment |
def str2listtuple(self, string_message):
"Covert a string that is ready to be sent to graphite into a tuple"
if type(string_message).__name__ not in ('str', 'unicode'):
raise TypeError("Must provide a string or unicode")
if not string_message.endswith('\n'):
string_mess... | Covert a string that is ready to be sent to graphite into a tuple | entailment |
def _send(self, message):
""" Given a message send it to the graphite server. """
# An option to lowercase the entire message
if self.lowercase_metric_names:
message = message.lower()
# convert the message into a pickled payload.
message = self.str2listtuple(message... | Given a message send it to the graphite server. | entailment |
def clean_metric_name(self, metric_name):
"""
Make sure the metric is free of control chars, spaces, tabs, etc.
"""
if not self._clean_metric_name:
return metric_name
metric_name = str(metric_name)
for _from, _to in self.cleaning_replacement_list:
... | Make sure the metric is free of control chars, spaces, tabs, etc. | entailment |
def _get_languages(cls) -> set:
"""Get supported languages (by querying the server)."""
if not cls._server_is_alive():
cls._start_server_on_free_port()
url = urllib.parse.urljoin(cls._url, 'Languages')
languages = set()
for e in cls._get_root(url, num_tries=1):
... | Get supported languages (by querying the server). | entailment |
def _get_attrib(cls):
"""Get matches element attributes."""
if not cls._server_is_alive():
cls._start_server_on_free_port()
params = {'language': FAILSAFE_LANGUAGE, 'text': ''}
data = urllib.parse.urlencode(params).encode()
root = cls._get_root(cls._url, data, num_tri... | Get matches element attributes. | entailment |
def get_form(self, request, obj=None, **kwargs):
"""
Patched method for PageAdmin.get_form.
Returns a page form without the base field 'meta_description' which is
overridden in djangocms-page-meta.
This is triggered in the page add view and in the change view if
the meta description of the pag... | Patched method for PageAdmin.get_form.
Returns a page form without the base field 'meta_description' which is
overridden in djangocms-page-meta.
This is triggered in the page add view and in the change view if
the meta description of the page is empty. | entailment |
def get_cache_key(page, language):
"""
Create the cache key for the current page and language
"""
from cms.cache import _get_cache_key
try:
site_id = page.node.site_id
except AttributeError: # CMS_3_4
site_id = page.site_id
return _get_cache_key('page_meta', page, language, ... | Create the cache key for the current page and language | entailment |
def get_page_meta(page, language):
"""
Retrieves all the meta information for the page in the given language
:param page: a Page instance
:param lang: a language code
:return: Meta instance
:type: object
"""
from django.core.cache import cache
from meta.views import Meta
from .... | Retrieves all the meta information for the page in the given language
:param page: a Page instance
:param lang: a language code
:return: Meta instance
:type: object | entailment |
def begin(self, address=MPR121_I2CADDR_DEFAULT, i2c=None, **kwargs):
"""Initialize communication with the MPR121.
Can specify a custom I2C address for the device using the address
parameter (defaults to 0x5A). Optional i2c parameter allows specifying a
custom I2C bus source (defaults... | Initialize communication with the MPR121.
Can specify a custom I2C address for the device using the address
parameter (defaults to 0x5A). Optional i2c parameter allows specifying a
custom I2C bus source (defaults to platform's I2C bus).
Returns True if communication with the MPR121 ... | entailment |
def set_thresholds(self, touch, release):
"""Set the touch and release threshold for all inputs to the provided
values. Both touch and release should be a value between 0 to 255
(inclusive).
"""
assert touch >= 0 and touch <= 255, 'touch must be between 0-255 (inclusive)'
... | Set the touch and release threshold for all inputs to the provided
values. Both touch and release should be a value between 0 to 255
(inclusive). | entailment |
def filtered_data(self, pin):
"""Return filtered data register value for the provided pin (0-11).
Useful for debugging.
"""
assert pin >= 0 and pin < 12, 'pin must be between 0-11 (inclusive)'
return self._i2c_retry(self._device.readU16LE, MPR121_FILTDATA_0L + pin*2) | Return filtered data register value for the provided pin (0-11).
Useful for debugging. | entailment |
def baseline_data(self, pin):
"""Return baseline data register value for the provided pin (0-11).
Useful for debugging.
"""
assert pin >= 0 and pin < 12, 'pin must be between 0-11 (inclusive)'
bl = self._i2c_retry(self._device.readU8, MPR121_BASELINE_0 + pin)
return bl <<... | Return baseline data register value for the provided pin (0-11).
Useful for debugging. | entailment |
def touched(self):
"""Return touch state of all pins as a 12-bit value where each bit
represents a pin, with a value of 1 being touched and 0 not being touched.
"""
t = self._i2c_retry(self._device.readU16LE, MPR121_TOUCHSTATUS_L)
return t & 0x0FFF | Return touch state of all pins as a 12-bit value where each bit
represents a pin, with a value of 1 being touched and 0 not being touched. | entailment |
def is_touched(self, pin):
"""Return True if the specified pin is being touched, otherwise returns
False.
"""
assert pin >= 0 and pin < 12, 'pin must be between 0-11 (inclusive)'
t = self.touched()
return (t & (1 << pin)) > 0 | Return True if the specified pin is being touched, otherwise returns
False. | entailment |
def profileit(func):
"""
Decorator straight up stolen from stackoverflow
"""
def wrapper(*args, **kwargs):
datafn = func.__name__ + ".profile" # Name the data file sensibly
prof = cProfile.Profile()
prof.enable()
retval = prof.runcall(func, *args, **kwargs)
prof.d... | Decorator straight up stolen from stackoverflow | entailment |
def filter_ip_range(ip_range):
"""Filter :class:`.Line` objects by IP range.
Both *192.168.1.203* and *192.168.1.10* are valid if the provided ip
range is ``192.168.1`` whereas *192.168.2.103* is not valid (note the
*.2.*).
:param ip_range: IP range that you want to filter to.
:type ip_range: ... | Filter :class:`.Line` objects by IP range.
Both *192.168.1.203* and *192.168.1.10* are valid if the provided ip
range is ``192.168.1`` whereas *192.168.2.103* is not valid (note the
*.2.*).
:param ip_range: IP range that you want to filter to.
:type ip_range: string
:returns: a function that f... | entailment |
def filter_slow_requests(slowness):
"""Filter :class:`.Line` objects by their response time.
:param slowness: minimum time, in milliseconds, a server needs to answer
a request. If the server takes more time than that the log line is
accepted.
:type slowness: string
:returns: a function that... | Filter :class:`.Line` objects by their response time.
:param slowness: minimum time, in milliseconds, a server needs to answer
a request. If the server takes more time than that the log line is
accepted.
:type slowness: string
:returns: a function that filters by the server response time.
:... | entailment |
def filter_wait_on_queues(max_waiting):
"""Filter :class:`.Line` objects by their queueing time in
HAProxy.
:param max_waiting: maximum time, in milliseconds, a request is waiting on
HAProxy prior to be delivered to a backend server. If HAProxy takes less
than that time the log line is counted.... | Filter :class:`.Line` objects by their queueing time in
HAProxy.
:param max_waiting: maximum time, in milliseconds, a request is waiting on
HAProxy prior to be delivered to a backend server. If HAProxy takes less
than that time the log line is counted.
:type max_waiting: string
:returns: a ... | entailment |
def filter_time_frame(start, delta):
"""Filter :class:`.Line` objects by their connection time.
:param start: a time expression (see -s argument on --help for its format)
to filter log lines that are before this time.
:type start: string
:param delta: a relative time expression (see -s argument o... | Filter :class:`.Line` objects by their connection time.
:param start: a time expression (see -s argument on --help for its format)
to filter log lines that are before this time.
:type start: string
:param delta: a relative time expression (see -s argument on --help for
its format) to limit the ... | entailment |
def filter_response_size(size):
"""Filter :class:`.Line` objects by the response size (in bytes).
Specially useful when looking for big file downloads.
:param size: Minimum amount of bytes a response body weighted.
:type size: string
:returns: a function that filters by the response size.
:rty... | Filter :class:`.Line` objects by the response size (in bytes).
Specially useful when looking for big file downloads.
:param size: Minimum amount of bytes a response body weighted.
:type size: string
:returns: a function that filters by the response size.
:rtype: function | entailment |
def _get_fields_for_model(model):
"""
Gets all of the fields on the model.
:param DeclarativeModel model: A SQLAlchemy ORM Model
:return: A tuple of the fields on the Model corresponding
to the columns on the Model.
:rtype: tuple
"""
fields = []
for name in model._sa_class_manag... | Gets all of the fields on the model.
:param DeclarativeModel model: A SQLAlchemy ORM Model
:return: A tuple of the fields on the Model corresponding
to the columns on the Model.
:rtype: tuple | entailment |
def _get_relationships(model):
"""
Gets the necessary relationships for the resource
by inspecting the sqlalchemy model for relationships.
:param DeclarativeMeta model: The SQLAlchemy ORM model.
:return: A tuple of Relationship/ListRelationship instances
corresponding to the relationships o... | Gets the necessary relationships for the resource
by inspecting the sqlalchemy model for relationships.
:param DeclarativeMeta model: The SQLAlchemy ORM model.
:return: A tuple of Relationship/ListRelationship instances
corresponding to the relationships on the Model.
:rtype: tuple | entailment |
def create_resource(model, session_handler, resource_bases=(CRUDL,),
relationships=None, links=None, preprocessors=None,
postprocessors=None, fields=None, paginate_by=100,
auto_relationships=True, pks=None, create_fields=None,
update_fields... | Creates a ResourceBase subclass by inspecting a SQLAlchemy
Model. This is somewhat more restrictive than explicitly
creating managers and resources. However, if you only need
any of the basic CRUD+L operations,
:param sqlalchemy.Model model: This is the model that
will be ... | entailment |
def _is_pickle_valid(self):
"""Logic to decide if the file should be processed or just needs to
be loaded from its pickle data.
"""
if not os.path.exists(self._pickle_file):
return False
else:
file_mtime = os.path.getmtime(self.logfile)
pickle_... | Logic to decide if the file should be processed or just needs to
be loaded from its pickle data. | entailment |
def _load(self):
"""Load data from a pickle file. """
with open(self._pickle_file, 'rb') as source:
pickler = pickle.Unpickler(source)
for attribute in self._pickle_attributes:
pickle_data = pickler.load()
setattr(self, attribute, pickle_data) | Load data from a pickle file. | entailment |
def _save(self):
"""Save the attributes defined on _pickle_attributes in a pickle file.
This improves a lot the nth run as the log file does not need to be
processed every time.
"""
with open(self._pickle_file, 'wb') as source:
pickler = pickle.Pickler(source, pickle... | Save the attributes defined on _pickle_attributes in a pickle file.
This improves a lot the nth run as the log file does not need to be
processed every time. | entailment |
def parse_data(self, logfile):
"""Parse data from data stream and replace object lines.
:param logfile: [required] Log file data stream.
:type logfile: str
"""
for line in logfile:
stripped_line = line.strip()
parsed_line = Line(stripped_line)
... | Parse data from data stream and replace object lines.
:param logfile: [required] Log file data stream.
:type logfile: str | entailment |
def filter(self, filter_func, reverse=False):
"""Filter current log lines by a given filter function.
This allows to drill down data out of the log file by filtering the
relevant log lines to analyze.
For example, filter by a given IP so only log lines for that IP are
further p... | Filter current log lines by a given filter function.
This allows to drill down data out of the log file by filtering the
relevant log lines to analyze.
For example, filter by a given IP so only log lines for that IP are
further processed with commands (top paths, http status counter...... | entailment |
def commands(cls):
"""Returns a list of all methods that start with ``cmd_``."""
cmds = [cmd[4:] for cmd in dir(cls) if cmd.startswith('cmd_')]
return cmds | Returns a list of all methods that start with ``cmd_``. | entailment |
def cmd_http_methods(self):
"""Reports a breakdown of how many requests have been made per HTTP
method (GET, POST...).
"""
methods = defaultdict(int)
for line in self._valid_lines:
methods[line.http_request_method] += 1
return methods | Reports a breakdown of how many requests have been made per HTTP
method (GET, POST...). | entailment |
def cmd_ip_counter(self):
"""Reports a breakdown of how many requests have been made per IP.
.. note::
To enable this command requests need to provide a header with the
forwarded IP (usually X-Forwarded-For) and be it the only header
being captured.
"""
ip_... | Reports a breakdown of how many requests have been made per IP.
.. note::
To enable this command requests need to provide a header with the
forwarded IP (usually X-Forwarded-For) and be it the only header
being captured. | entailment |
def cmd_status_codes_counter(self):
"""Generate statistics about HTTP status codes. 404, 500 and so on.
"""
status_codes = defaultdict(int)
for line in self._valid_lines:
status_codes[line.status_code] += 1
return status_codes | Generate statistics about HTTP status codes. 404, 500 and so on. | entailment |
def cmd_request_path_counter(self):
"""Generate statistics about HTTP requests' path."""
paths = defaultdict(int)
for line in self._valid_lines:
paths[line.http_request_path] += 1
return paths | Generate statistics about HTTP requests' path. | entailment |
def cmd_slow_requests(self):
"""List all requests that took a certain amount of time to be
processed.
.. warning::
By now hardcoded to 1 second (1000 milliseconds), improve the
command line interface to allow to send parameters to each command
or globally.
... | List all requests that took a certain amount of time to be
processed.
.. warning::
By now hardcoded to 1 second (1000 milliseconds), improve the
command line interface to allow to send parameters to each command
or globally. | entailment |
def cmd_average_response_time(self):
"""Returns the average response time of all, non aborted, requests."""
average = [
line.time_wait_response
for line in self._valid_lines
if line.time_wait_response >= 0
]
divisor = float(len(average))
if di... | Returns the average response time of all, non aborted, requests. | entailment |
def cmd_average_waiting_time(self):
"""Returns the average queue time of all, non aborted, requests."""
average = [
line.time_wait_queues
for line in self._valid_lines
if line.time_wait_queues >= 0
]
divisor = float(len(average))
if divisor > ... | Returns the average queue time of all, non aborted, requests. | entailment |
def cmd_server_load(self):
"""Generate statistics regarding how many requests were processed by
each downstream server.
"""
servers = defaultdict(int)
for line in self._valid_lines:
servers[line.server_name] += 1
return servers | Generate statistics regarding how many requests were processed by
each downstream server. | entailment |
def cmd_queue_peaks(self):
"""Generate a list of the requests peaks on the queue.
A queue peak is defined by the biggest value on the backend queue
on a series of log lines that are between log lines without being
queued.
.. warning::
Allow to configure up to which pe... | Generate a list of the requests peaks on the queue.
A queue peak is defined by the biggest value on the backend queue
on a series of log lines that are between log lines without being
queued.
.. warning::
Allow to configure up to which peak can be ignored. Currently
... | entailment |
def cmd_connection_type(self):
"""Generates statistics on how many requests are made via HTTP and how
many are made via SSL.
.. note::
This only works if the request path contains the default port for
SSL (443).
.. warning::
The ports are hardcoded, they s... | Generates statistics on how many requests are made via HTTP and how
many are made via SSL.
.. note::
This only works if the request path contains the default port for
SSL (443).
.. warning::
The ports are hardcoded, they should be configurable. | entailment |
def cmd_requests_per_minute(self):
"""Generates statistics on how many requests were made per minute.
.. note::
Try to combine it with time constrains (``-s`` and ``-d``) as this
command output can be huge otherwise.
"""
if len(self._valid_lines) == 0:
re... | Generates statistics on how many requests were made per minute.
.. note::
Try to combine it with time constrains (``-s`` and ``-d``) as this
command output can be huge otherwise. | entailment |
def cmd_print(self):
"""Returns the raw lines to be printed."""
if not self._valid_lines:
return ''
return '\n'.join([line.raw_line for line in self._valid_lines]) + '\n' | Returns the raw lines to be printed. | entailment |
def _sort_lines(self):
"""Haproxy writes its logs after having gathered all information
related to each specific connection. A simple request can be
really quick but others can be really slow, thus even if one connection
is logged later, it could have been accepted before others that are... | Haproxy writes its logs after having gathered all information
related to each specific connection. A simple request can be
really quick but others can be really slow, thus even if one connection
is logged later, it could have been accepted before others that are
already processed and log... | entailment |
def _sort_and_trim(data, reverse=False):
"""Sorts a dictionary with at least two fields on each of them sorting
by the second element.
.. warning::
Right now is hardcoded to 10 elements, improve the command line
interface to allow to send parameters to each command or global... | Sorts a dictionary with at least two fields on each of them sorting
by the second element.
.. warning::
Right now is hardcoded to 10 elements, improve the command line
interface to allow to send parameters to each command or globally. | entailment |
def db_access_point(func):
"""
Wraps a function that actually accesses the database.
It injects a session into the method and attempts to handle
it after the function has run.
:param method func: The method that is interacting with the database.
"""
@wraps(func)
def wrapper(self, *args,... | Wraps a function that actually accesses the database.
It injects a session into the method and attempts to handle
it after the function has run.
:param method func: The method that is interacting with the database. | entailment |
def _get_field_python_type(model, name):
"""
Gets the python type for the attribute on the model
with the name provided.
:param Model model: The SqlAlchemy model class.
:param unicode name: The column name on the model
that you are attempting to get the python type.
... | Gets the python type for the attribute on the model
with the name provided.
:param Model model: The SqlAlchemy model class.
:param unicode name: The column name on the model
that you are attempting to get the python type.
:return: The python type of the column
:rtype... | entailment |
def get_field_type(cls, name):
"""
Takes a field name and gets an appropriate BaseField instance
for that column. It inspects the Model that is set on the manager
to determine what the BaseField subclass should be.
:param unicode name:
:return: A BaseField subclass that... | Takes a field name and gets an appropriate BaseField instance
for that column. It inspects the Model that is set on the manager
to determine what the BaseField subclass should be.
:param unicode name:
:return: A BaseField subclass that is appropriate for
translating a strin... | entailment |
def create(self, session, values, *args, **kwargs):
"""
Creates a new instance of the self.model
and persists it to the database.
:param dict values: The dictionary of values to
set on the model. The key is the column name
and the value is what it will be set to... | Creates a new instance of the self.model
and persists it to the database.
:param dict values: The dictionary of values to
set on the model. The key is the column name
and the value is what it will be set to. If
the cls._create_fields is defined then it will
... | entailment |
def retrieve(self, session, lookup_keys, *args, **kwargs):
"""
Retrieves a model using the lookup keys provided.
Only one model should be returned by the lookup_keys
or else the manager will fail.
:param Session session: The SQLAlchemy session to use
:param dict lookup_k... | Retrieves a model using the lookup keys provided.
Only one model should be returned by the lookup_keys
or else the manager will fail.
:param Session session: The SQLAlchemy session to use
:param dict lookup_keys: A dictionary mapping the fields
and their expected values
... | entailment |
def retrieve_list(self, session, filters, *args, **kwargs):
"""
Retrieves a list of the model for this manager.
It is restricted by the filters provided.
:param Session session: The SQLAlchemy session to use
:param dict filters: The filters to restrict the returned
m... | Retrieves a list of the model for this manager.
It is restricted by the filters provided.
:param Session session: The SQLAlchemy session to use
:param dict filters: The filters to restrict the returned
models on
:return: A tuple of the list of dictionary representation
... | entailment |
def update(self, session, lookup_keys, updates, *args, **kwargs):
"""
Updates the model with the specified lookup_keys and returns
the dictified object.
:param Session session: The SQLAlchemy session to use
:param dict lookup_keys: A dictionary mapping the fields
and... | Updates the model with the specified lookup_keys and returns
the dictified object.
:param Session session: The SQLAlchemy session to use
:param dict lookup_keys: A dictionary mapping the fields
and their expected values
:param dict updates: The columns and the values to upda... | entailment |
def delete(self, session, lookup_keys, *args, **kwargs):
"""
Deletes the model found using the lookup_keys
:param Session session: The SQLAlchemy session to use
:param dict lookup_keys: A dictionary mapping the fields
and their expected values
:return: An empty dicti... | Deletes the model found using the lookup_keys
:param Session session: The SQLAlchemy session to use
:param dict lookup_keys: A dictionary mapping the fields
and their expected values
:return: An empty dictionary
:rtype: dict
:raises: NotFoundException | entailment |
def serialize_model(self, model, field_dict=None):
"""
Takes a model and serializes the fields provided into
a dictionary.
:param Model model: The Sqlalchemy model instance to serialize
:param dict field_dict: The dictionary of fields to return.
:return: The serialized m... | Takes a model and serializes the fields provided into
a dictionary.
:param Model model: The Sqlalchemy model instance to serialize
:param dict field_dict: The dictionary of fields to return.
:return: The serialized model.
:rtype: dict | entailment |
def _serialize_model_helper(self, model, field_dict=None):
"""
A recursive function for serializing a model
into a json ready format.
"""
field_dict = field_dict or self.dot_field_list_to_dict()
if model is None:
return None
if isinstance(model, Query... | A recursive function for serializing a model
into a json ready format. | entailment |
def _get_model(self, lookup_keys, session):
"""
Gets the sqlalchemy Model instance associated with
the lookup keys.
:param dict lookup_keys: A dictionary of the keys
and their associated values.
:param Session session: The sqlalchemy session
:return: The sqla... | Gets the sqlalchemy Model instance associated with
the lookup keys.
:param dict lookup_keys: A dictionary of the keys
and their associated values.
:param Session session: The sqlalchemy session
:return: The sqlalchemy orm model instance. | entailment |
def _set_values_on_model(self, model, values, fields=None):
"""
Updates the values with the specified values.
:param Model model: The sqlalchemy model instance
:param dict values: The dictionary of attributes and
the values to set.
:param list fields: A list of strin... | Updates the values with the specified values.
:param Model model: The sqlalchemy model instance
:param dict values: The dictionary of attributes and
the values to set.
:param list fields: A list of strings indicating
the valid fields. Defaults to self.fields.
:re... | entailment |
def print_commands():
"""Prints all commands available from Log with their
description.
"""
dummy_log_file = Log()
commands = Log.commands()
commands.sort()
for cmd in commands:
cmd = getattr(dummy_log_file, 'cmd_{0}'.format(cmd))
description = cmd.__doc__
if descrip... | Prints all commands available from Log with their
description. | entailment |
def print_filters():
"""Prints all filters available with their description."""
for filter_name in VALID_FILTERS:
filter_func = getattr(filters, 'filter_{0}'.format(filter_name))
description = filter_func.__doc__
if description:
description = re.sub(r'\n\s+', ' ', description... | Prints all filters available with their description. | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.