INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
calls map to shift the recover execution to flat_map_nvim_io | def nvim_io_recover(self, io: NvimIORecover[A]) -> NvimIO[B]:
'''calls `map` to shift the recover execution to flat_map_nvim_io
'''
return eval_step(self.vim)(io.map(lambda a: a)) |
Read codeml file. | def read_codeml_output(
filename,
df,
altall_cutoff=0.2,
):
"""Read codeml file.
"""
# Read paml output.
with open(filename, 'r') as f:
data = f.read()
# Rip all trees out of the codeml output.
regex = re.compile('\([()\w\:. ,]+;')
trees = regex.findall(data)
anc... |
Always return a stripped string localized if possible | def ugettext(message, context=None):
"""Always return a stripped string, localized if possible"""
stripped = strip_whitespace(message)
message = add_context(context, stripped) if context else stripped
ret = django_ugettext(message)
# If the context isn't found, we need to return the string withou... |
Always return a stripped string localized if possible | def ungettext(singular, plural, number, context=None):
"""Always return a stripped string, localized if possible"""
singular_stripped = strip_whitespace(singular)
plural_stripped = strip_whitespace(plural)
if context:
singular = add_context(context, singular_stripped)
plural = add_conte... |
Install our gettext and ngettext functions into Jinja2 s environment. | def install_jinja_translations():
"""
Install our gettext and ngettext functions into Jinja2's environment.
"""
class Translation(object):
"""
We pass this object to jinja so it can find our gettext implementation.
If we pass the GNUTranslation object directly, it won't have our
... |
Override django s utils. translation. activate (). Django forces files to be named django. mo ( http:// code. djangoproject. com/ ticket/ 6376 ). Since that s dumb and we want to be able to load different files depending on what part of the site the user is in we ll make our own function here. | def activate(locale):
"""
Override django's utils.translation.activate(). Django forces files
to be named django.mo (http://code.djangoproject.com/ticket/6376). Since
that's dumb and we want to be able to load different files depending on
what part of the site the user is in, we'll make our own fu... |
We piggyback on jinja2 s babel_extract () ( really Babel s extract_ * functions ) but they don t support some things we need so this function will tweak the message. Specifically: | def tweak_message(message):
"""We piggyback on jinja2's babel_extract() (really, Babel's extract_*
functions) but they don't support some things we need so this function will
tweak the message. Specifically:
1) We strip whitespace from the msgid. Jinja2 will only strip
whitespace from... |
this is the central unsafe function using a lock and updating the state in guard in - place. | def exclusive_ns(guard: StateGuard[A], desc: str, thunk: Callable[..., NS[A, B]], *a: Any) -> Do:
'''this is the central unsafe function, using a lock and updating the state in `guard` in-place.
'''
yield guard.acquire()
log.debug2(lambda: f'exclusive: {desc}')
state, response = yield N.ensure_failu... |
Calculate a percentage. | def _percent(data, part, total):
"""
Calculate a percentage.
"""
try:
return round(100 * float(data[part]) / float(data[total]), 1)
except ZeroDivisionError:
return 0 |
Get stats info. | def _get_cache_stats(server_name=None):
"""
Get stats info.
"""
server_info = {}
for svr in mc_client.get_stats():
svr_info = svr[0].split(' ')
svr_name = svr_info[0]
svr_stats = svr[1]
svr_stats['bytes_percent'] = _percent(svr_stats, 'bytes', 'limit_maxbytes')
... |
Get slabs info. | def _get_cache_slabs(server_name=None):
"""
Get slabs info.
"""
server_info = {}
for svr in mc_client.get_slabs():
svr_info = svr[0].split(' ')
svr_name = svr_info[0]
if server_name and server_name == svr_name:
return svr[1]
server_info[svr_name] = svr[1]
... |
Add admin global context for compatibility with Django 1. 7 | def _context_data(data, request=None):
"""
Add admin global context, for compatibility with Django 1.7
"""
try:
return dict(site.each_context(request).items() + data.items())
except AttributeError:
return data |
Return the status of all servers. | def server_status(request):
"""
Return the status of all servers.
"""
data = {
'cache_stats': _get_cache_stats(),
'can_get_slabs': hasattr(mc_client, 'get_slabs'),
}
return render_to_response('memcache_admin/server_status.html', data, RequestContext(request)) |
Show the dashboard. | def dashboard(request):
"""
Show the dashboard.
"""
# mc_client will be a dict if memcached is not configured
if not isinstance(mc_client, dict):
cache_stats = _get_cache_stats()
else:
cache_stats = None
if cache_stats:
data = _context_data({
'title': _('M... |
Show server statistics. | def stats(request, server_name):
"""
Show server statistics.
"""
server_name = server_name.strip('/')
data = _context_data({
'title': _('Memcache Statistics for %s') % server_name,
'cache_stats': _get_cache_stats(server_name),
},
request)
return render_to_response('me... |
Show server slabs. | def slabs(request, server_name):
"""
Show server slabs.
"""
data = _context_data({
'title': _('Memcache Slabs for %s') % server_name,
'cache_slabs': _get_cache_slabs(server_name),
},
request)
return render_to_response('memcache_admin/slabs.html', data, RequestContext(requ... |
Convert a byte value into a human - readable format. | def human_bytes(value):
"""
Convert a byte value into a human-readable format.
"""
value = float(value)
if value >= 1073741824:
gigabytes = value / 1073741824
size = '%.2f GB' % gigabytes
elif value >= 1048576:
megabytes = value / 1048576
size = '%.2f MB' % megaby... |
Find a config in our children so we can fill in variables in our other children with its data. | def find_config(self, children):
"""
Find a config in our children so we can fill in variables in our other
children with its data.
"""
named_config = None
found_config = None
# first see if we got a kwarg named 'config', as this guy is special
if 'config... |
Add objects to the environment. | def add(self, **kwargs):
"""
Add objects to the environment.
"""
for key in kwargs:
if type(kwargs[key]) == str:
self._children[key] = Directory(kwargs[key])
else:
self._children[key] = kwargs[key]
self._children[key]._e... |
Replace any config tokens in the file s path with values from the config. | def apply_config(self, applicator):
"""
Replace any config tokens in the file's path with values from the config.
"""
if type(self._fpath) == str:
self._fpath = applicator.apply(self._fpath) |
Get the path to the file relative to its parent. | def path(self):
"""
Get the path to the file relative to its parent.
"""
if self._parent:
return os.path.join(self._parent.path, self._fpath)
else:
return self._fpath |
Read and return the contents of the file. | def read(self):
"""
Read and return the contents of the file.
"""
with open(self.path) as f:
d = f.read()
return d |
Write data to the file. | def write(self, data, mode='w'):
"""
Write data to the file.
`data` is the data to write
`mode` is the mode argument to pass to `open()`
"""
with open(self.path, mode) as f:
f.write(data) |
Configure the Python logging module for this file. | def configure(self):
"""
Configure the Python logging module for this file.
"""
# build a file handler for this file
handler = logging.FileHandler(self.path, delay=True)
# if we got a format string, create a formatter with it
if self._format:
handler.... |
Create the file. | def create(self):
"""
Create the file.
If the file already exists an exception will be raised
"""
if not os.path.exists(self.path):
open(self.path, 'a').close()
else:
raise Exception("File exists: {}".format(self.path)) |
Replace any config tokens with values from the config. | def apply_config(self, applicator):
"""
Replace any config tokens with values from the config.
"""
if type(self._path) == str:
self._path = applicator.apply(self._path)
for key in self._children:
self._children[key].apply_config(applicator) |
Return the path to this directory. | def path(self):
"""
Return the path to this directory.
"""
p = ''
if self._parent and self._parent.path:
p = os.path.join(p, self._parent.path)
if self._base:
p = os.path.join(p, self._base)
if self._path:
p = os.path.join(p, s... |
Remove the directory. | def remove(self, recursive=True, ignore_error=True):
"""
Remove the directory.
"""
try:
if recursive or self._cleanup == 'recursive':
shutil.rmtree(self.path)
else:
os.rmdir(self.path)
except Exception as e:
if n... |
Prepare the Directory for use in an Environment. | def prepare(self):
"""
Prepare the Directory for use in an Environment.
This will create the directory if the create flag is set.
"""
if self._create:
self.create()
for k in self._children:
self._children[k]._env = self._env
self._chil... |
Clean up children and remove the directory. | def cleanup(self):
"""
Clean up children and remove the directory.
Directory will only be removed if the cleanup flag is set.
"""
for k in self._children:
self._children[k].cleanup()
if self._cleanup:
self.remove(True) |
Find the path to something inside this directory. | def path_to(self, path):
"""
Find the path to something inside this directory.
"""
return os.path.join(self.path, str(path)) |
List the contents of the directory. | def list(self):
"""
List the contents of the directory.
"""
return [File(f, parent=self) for f in os.listdir(self.path)] |
Write to a file in the directory. | def write(self, filename, data, mode='w'):
"""
Write to a file in the directory.
"""
with open(self.path_to(str(filename)), mode) as f:
f.write(data) |
Read a file from the directory. | def read(self, filename):
"""
Read a file from the directory.
"""
with open(self.path_to(str(filename))) as f:
d = f.read()
return d |
Add objects to the directory. | def add(self, *args, **kwargs):
"""
Add objects to the directory.
"""
for key in kwargs:
if isinstance(kwargs[key], str):
self._children[key] = File(kwargs[key])
else:
self._children[key] = kwargs[key]
self._children[key... |
Save the state to a file. | def save(self):
"""
Save the state to a file.
"""
with open(self.path, 'w') as f:
f.write(yaml.dump(dict(self.d))) |
Load a saved state file. | def load(self):
"""
Load a saved state file.
"""
if os.path.exists(self.path):
with open(self.path, 'r') as f:
self.d = yaml.safe_load(f.read().replace('\t', ' '*4)) |
Clean up the saved state. | def cleanup(self):
"""
Clean up the saved state.
"""
if os.path.exists(self.path):
os.remove(self.path) |
Loads plugins from the specified directory. | def load_plugins(self, directory):
"""
Loads plugins from the specified directory.
`directory` is the full path to a directory containing python modules
which each contain a subclass of the Plugin class.
There is no criteria for a valid plugin at this level - any python
... |
Recursively merge values from a nested dictionary into another nested dictionary. | def update_dict(target, source):
"""
Recursively merge values from a nested dictionary into another nested
dictionary.
For example:
>>> target = {
... 'thing': 123,
... 'thang': {
... 'a': 1,
... 'b': 2
... }
... }
>>> source = {
... ... |
Return a ConfigNode object representing a child node with the specified relative path. | def _child(self, path):
"""
Return a ConfigNode object representing a child node with the specified
relative path.
"""
if self._path:
path = '{}.{}'.format(self._path, path)
return ConfigNode(root=self._root, path=path) |
Returns a tuple of a reference to the last container in the path and the last component in the key path. | def _resolve_path(self, create=False):
"""
Returns a tuple of a reference to the last container in the path, and
the last component in the key path.
For example, with a self._value like this:
{
'thing': {
'another': {
'some_leaf':... |
Get the value represented by this node. | def _get_value(self):
"""
Get the value represented by this node.
"""
if self._path:
try:
container, last = self._resolve_path()
return container[last]
except KeyError:
return None
except IndexError:
... |
Update the configuration with new data. | def update(self, data={}, options={}):
"""
Update the configuration with new data.
This can be passed either or both `data` and `options`.
`options` is a dict of keypath/value pairs like this (similar to
CherryPy's config mechanism:
>>> c.update(options={
... |
Load the config and defaults from files. | def load(self, reload=False):
"""
Load the config and defaults from files.
"""
if reload or not self._loaded:
# load defaults
if self._defaults_file and type(self._defaults_file) == str:
self._defaults_file = File(self._defaults_file, parent=self._... |
Apply the config to a string. | def apply_to_str(self, obj):
"""
Apply the config to a string.
"""
toks = re.split('({config:|})', obj)
newtoks = []
try:
while len(toks):
tok = toks.pop(0)
if tok == '{config:':
# pop the config variable, lo... |
View decorator to validate requests from Twilio per http:// www. twilio. com/ docs/ security. | def validate_twilio_signature(func=None, backend_name='twilio-backend'):
"""View decorator to validate requests from Twilio per http://www.twilio.com/docs/security."""
def _dec(view_func):
@functools.wraps(view_func, assigned=available_attrs(view_func))
def _wrapped_view(request, *args, **kwarg... |
Build Twilio callback url for confirming message delivery status | def build_callback_url(request, urlname, message):
"""
Build Twilio callback url for confirming message delivery status
:type message: OutgoingSMS
"""
location = reverse(urlname, kwargs={"pk": message.pk})
callback_domain = getattr(settings, "TWILIO_CALLBACK_DOMAIN", None)
if callback_doma... |
Create: class: OutgoingSMS object and send SMS using Twilio. | def send_sms(request, to_number, body, callback_urlname="sms_status_callback"):
"""
Create :class:`OutgoingSMS` object and send SMS using Twilio.
"""
client = TwilioRestClient(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)
from_number = settings.TWILIO_PHONE_NUMBER
message = OutgoingS... |
\ b Examples: $ moo README. md # live preview README. md $ moo - e *. md # export all markdown files $ moo -- no - css - e README. md # export README. md without CSS $ cat README. md | moo - e - | less # export STDIN to STDOUT | def main(port, export, css, files):
"""
\b
Examples:
$ moo README.md # live preview README.md
$ moo -e *.md # export all markdown files
$ moo --no-css -e README.md # export README.md without CSS
$ cat README.md | moo -e - | less # export ST... |
Called when socket is read - ready | def process_input(self):
"""Called when socket is read-ready"""
try:
pyngus.read_socket_input(self.connection, self.socket)
except Exception as e:
LOG.error("Exception on socket read: %s", str(e))
self.connection.close_input()
self.connection.close... |
Called when socket is write - ready | def send_output(self):
"""Called when socket is write-ready"""
try:
pyngus.write_socket_output(self.connection,
self.socket)
except Exception as e:
LOG.error("Exception on socket write: %s", str(e))
self.connection.close_... |
Do connection - based processing ( I/ O and timers ) | def process(self):
""" Do connection-based processing (I/O and timers) """
readfd = []
writefd = []
if self.connection.needs_input > 0:
readfd = [self.socket]
if self.connection.has_output > 0:
writefd = [self.socket]
timeout = None
deadli... |
Caller factory | def create_caller(self, method_map, source_addr, target_addr,
receiver_properties, sender_properties):
""" Caller factory
"""
if self.caller:
self.caller.destroy()
self.caller = MyCaller(method_map, self, source_addr, target_addr,
... |
Send a message containing the RPC method call | def _send_request(self):
"""Send a message containing the RPC method call
"""
msg = Message()
msg.subject = "An RPC call!"
msg.address = self._to
msg.reply_to = self._reply_to
msg.body = self._method
msg.correlation_id = 5 # whatever...
print("se... |
Read from the network layer and processes all data read. Can support both blocking and non - blocking sockets. Returns the number of input bytes processed or EOS if input processing is done. Any exceptions raised by the socket are re - raised. | def read_socket_input(connection, socket_obj):
"""Read from the network layer and processes all data read. Can
support both blocking and non-blocking sockets.
Returns the number of input bytes processed, or EOS if input processing
is done. Any exceptions raised by the socket are re-raised.
"""
... |
Write data to the network layer. Can support both blocking and non - blocking sockets. Returns the number of output bytes sent or EOS if output processing is done. Any exceptions raised by the socket are re - raised. | def write_socket_output(connection, socket_obj):
"""Write data to the network layer. Can support both blocking and
non-blocking sockets.
Returns the number of output bytes sent, or EOS if output processing
is done. Any exceptions raised by the socket are re-raised.
"""
count = connection.has_o... |
Decorator that prevents callbacks from calling into link methods that are not reentrant | def _not_reentrant(func):
"""Decorator that prevents callbacks from calling into link methods that
are not reentrant """
def wrap(*args, **kws):
link = args[0]
if link._callback_lock.in_callback:
m = "Link %s cannot be invoked from a callback!" % func
raise RuntimeErr... |
Return a map containing the settle modes as provided by the remote. Skip any default value. | def _get_remote_settle_modes(pn_link):
"""Return a map containing the settle modes as provided by the remote.
Skip any default value.
"""
modes = {}
snd = pn_link.remote_snd_settle_mode
if snd == proton.Link.SND_UNSETTLED:
modes['snd-settle-mode'] = 'unsettled'
elif snd == proton.Lin... |
Assign addresses properties etc. | def configure(self, target_address, source_address, handler, properties):
"""Assign addresses, properties, etc."""
self._handler = handler
self._properties = properties
dynamic_props = None
if properties:
dynamic_props = properties.get("dynamic-node-properties")
... |
Return the authorative source of the link. | def source_address(self):
"""Return the authorative source of the link."""
# If link is a sender, source is determined by the local
# value, else use the remote.
if self._pn_link.is_sender:
return self._pn_link.source.address
else:
return self._pn_link.rem... |
Return the authorative target of the link. | def target_address(self):
"""Return the authorative target of the link."""
# If link is a receiver, target is determined by the local
# value, else use the remote.
if self._pn_link.is_receiver:
return self._pn_link.target.address
else:
return self._pn_link... |
Remote has closed the session used by this link. | def _session_closed(self):
"""Remote has closed the session used by this link."""
# if link not already closed:
if self._endpoint_state & proton.Endpoint.REMOTE_ACTIVE:
# simulate close received
self._process_remote_state()
elif self._endpoint_state & proton.Endpo... |
See Link Reject AMQP1. 0 spec. | def reject(self, pn_condition=None):
"""See Link Reject, AMQP1.0 spec."""
self._pn_link.source.type = proton.Terminus.UNSPECIFIED
super(SenderLink, self).reject(pn_condition) |
Check if the delivery can be processed. | def _process_delivery(self, pn_delivery):
"""Check if the delivery can be processed."""
if pn_delivery.tag in self._send_requests:
if pn_delivery.settled or pn_delivery.remote_state:
# remote has reached a 'terminal state'
outcome = pn_delivery.remote_state
... |
See Link Reject AMQP1. 0 spec. | def reject(self, pn_condition=None):
"""See Link Reject, AMQP1.0 spec."""
self._pn_link.target.type = proton.Terminus.UNSPECIFIED
super(ReceiverLink, self).reject(pn_condition) |
Check if the delivery can be processed. | def _process_delivery(self, pn_delivery):
"""Check if the delivery can be processed."""
if pn_delivery.readable and not pn_delivery.partial:
data = self._pn_link.recv(pn_delivery.pending)
msg = proton.Message()
msg.decode(data)
self._pn_link.advance()
... |
Create a new sender link. | def new_sender(self, name):
"""Create a new sender link."""
pn_link = self._pn_session.sender(name)
return self.request_sender(pn_link) |
Create link from request for a sender. | def request_sender(self, pn_link):
"""Create link from request for a sender."""
sl = SenderLink(self._connection, pn_link)
self._links.add(sl)
return sl |
Create a new receiver link. | def new_receiver(self, name):
"""Create a new receiver link."""
pn_link = self._pn_session.receiver(name)
return self.request_receiver(pn_link) |
Create link from request for a receiver. | def request_receiver(self, pn_link):
"""Create link from request for a receiver."""
rl = ReceiverLink(self._connection, pn_link)
self._links.add(rl)
return rl |
Link has been destroyed. | def link_destroyed(self, link):
"""Link has been destroyed."""
self._links.discard(link)
if not self._links:
# no more links
LOG.debug("destroying unneeded session")
self._pn_session.close()
self._pn_session.free()
self._pn_session = No... |
Peer has closed its end of the session. | def _ep_need_close(self):
"""Peer has closed its end of the session."""
LOG.debug("Session %s close requested - closing...",
self._name)
links = self._links.copy() # may modify _links
for link in links:
link._session_closed() |
Called when the Proton Engine generates an endpoint state change event. | def _process_endpoint_event(self, event):
"""Called when the Proton Engine generates an endpoint state change
event.
"""
state_fsm = Endpoint._FSM[self._state]
entry = state_fsm.get(event)
if not entry:
# protocol error: invalid event for current state
... |
Modifies inline patterns. | def extendMarkdown(self, md, md_globals):
"""Modifies inline patterns."""
mark_tag = SimpleTagPattern(MARK_RE, 'mark')
md.inlinePatterns.add('mark', mark_tag, '_begin') |
Peer has closed its end of the link. | def receiver_remote_closed(self, receiver_link, pn_condition):
"""Peer has closed its end of the link."""
LOG.debug("receiver_remote_closed condition=%s", pn_condition)
receiver_link.close()
self.done = True |
Protocol error occurred. | def receiver_failed(self, receiver_link, error):
"""Protocol error occurred."""
LOG.warn("receiver_failed error=%s", error)
receiver_link.close()
self.done = True |
Parse the hostname and port out of the server_address. | def get_host_port(server_address):
"""Parse the hostname and port out of the server_address."""
regex = re.compile(r"^amqp://([a-zA-Z0-9.]+)(:([\d]+))?$")
x = regex.match(server_address)
if not x:
raise Exception("Bad address syntax: %s" % server_address)
matches = x.groups()
host = matc... |
Create a TCP connection to the server. | def connect_socket(host, port, blocking=True):
"""Create a TCP connection to the server."""
addr = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)
if not addr:
raise Exception("Could not translate address '%s:%s'"
% (host, str(port)))
my_socket = socket... |
Create a TCP listening socket for a server. | def server_socket(host, port, backlog=10):
"""Create a TCP listening socket for a server."""
addr = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)
if not addr:
raise Exception("Could not translate address '%s:%s'"
% (host, str(port)))
my_socket = socke... |
Handle I/ O and Timers on a single Connection. | def process_connection(connection, my_socket):
"""Handle I/O and Timers on a single Connection."""
if connection.closed:
return False
work = False
readfd = []
writefd = []
if connection.needs_input > 0:
readfd = [my_socket]
work = True
if connection.has_output > 0:
... |
A utility to help determine which connections need processing. Returns a triple of lists containing those connections that 0 ) need to read from the network 1 ) need to write to the network 2 ) waiting for pending timers to expire. The timer list is sorted with the connection next expiring at index 0. | def need_processing(self):
"""A utility to help determine which connections need
processing. Returns a triple of lists containing those connections that
0) need to read from the network, 1) need to write to the network, 2)
waiting for pending timers to expire. The timer list is sorted w... |
Decorator that prevents callbacks from calling into methods that are not reentrant | def _not_reentrant(func):
"""Decorator that prevents callbacks from calling into methods that are
not reentrant
"""
def wrap(self, *args, **kws):
if self._callback_lock and self._callback_lock.in_callback:
m = "Connection %s cannot be invoked from a callback!"... |
Perform connection state processing. | def process(self, now):
"""Perform connection state processing."""
if self._pn_connection is None:
LOG.error("Connection.process() called on destroyed connection!")
return 0
# do nothing until the connection has been opened
if self._pn_connection.state & proton.E... |
Get a buffer of data that needs to be written to the network. | def output_data(self):
"""Get a buffer of data that needs to be written to the network.
"""
c = self.has_output
if c <= 0:
return None
try:
buf = self._pn_transport.peek(c)
except Exception as e:
self._connection_failed(str(e))
... |
Factory method for Sender links. | def create_sender(self, source_address, target_address=None,
event_handler=None, name=None, properties=None):
"""Factory method for Sender links."""
ident = name or str(source_address)
if ident in self._sender_links:
raise KeyError("Sender %s already exists!" % ... |
Rejects the SenderLink and destroys the handle. | def reject_sender(self, link_handle, pn_condition=None):
"""Rejects the SenderLink, and destroys the handle."""
link = self._sender_links.get(link_handle)
if not link:
raise Exception("Invalid link_handle: %s" % link_handle)
link.reject(pn_condition)
# note: normally,... |
Factory method for creating Receive links. | def create_receiver(self, target_address, source_address=None,
event_handler=None, name=None, properties=None):
"""Factory method for creating Receive links."""
ident = name or str(target_address)
if ident in self._receiver_links:
raise KeyError("Receiver %s a... |
Clean up after connection failure detected. | def _connection_failed(self, error="Error not specified!"):
"""Clean up after connection failure detected."""
if not self._error:
LOG.error("Connection failed: %s", str(error))
self._error = error |
Both ends of the Endpoint have become active. | def _ep_active(self):
"""Both ends of the Endpoint have become active."""
LOG.debug("Connection is up")
if self._handler:
with self._callback_lock:
self._handler.connection_active(self) |
The remote has closed its end of the endpoint. | def _ep_need_close(self):
"""The remote has closed its end of the endpoint."""
LOG.debug("Connection remotely closed")
if self._handler:
cond = self._pn_connection.remote_condition
with self._callback_lock:
self._handler.connection_remote_closed(self, cond... |
The endpoint state machine failed due to protocol error. | def _ep_error(self, error):
"""The endpoint state machine failed due to protocol error."""
super(Connection, self)._ep_error(error)
self._connection_failed("Protocol error occurred.") |
This decorator provides several helpful shortcuts for writing Twilio views. | def twilio_view(f):
"""This decorator provides several helpful shortcuts for writing Twilio
views.
- It ensures that only requests from Twilio are passed through. This
helps protect you from forged requests.
- It ensures your view is exempt from CSRF checks via Django's
@cs... |
Equality test | def _is_equal(self, test_color):
"""Equality test"""
if test_color is None:
ans = False
elif test_color.color_type != self.color_type:
ans = False
elif self.name is not None and self.name == test_color.name:
ans = True
elif (self.red ==... |
Adobe output string for defining colors | def _get_color_string(self):
"""Adobe output string for defining colors"""
s = ''
if self.color_type == 'd':
if self.name is "black":
s = '%.3f G' % 0
else:
s = '%.3f %.3f %.3f RG' % (
self.red / 255.0, self.gree... |
Select a font ; size given in points | def _set_font(self, family=None, style=None, size=None):
"""Select a font; size given in points"""
if style is not None:
if 'B' in style:
family += '_bold'
if 'I' in style:
family += '_italic'
self._set_family(family)
self._get_dif... |
Get width of a string in the current font | def _string_width(self, s):
"""Get width of a string in the current font"""
s = str(s)
w = 0
for char in s:
char = ord(char)
w += self.character_widths[char]
return w * self.font_size / 1000.0 |
Given a search path find file with requested extension | def get_ttf(self):
""" Given a search path, find file with requested extension """
font_dict = {}
families = []
rootdirlist = string.split(self.search_path, os.pathsep)
#for rootdir in rootdirlist:
# rootdir = os.path.expanduser(rootdir)
for dirName, subdirLis... |
May be used to compress PDF files. Code is more readable for testing and inspection if not compressed. Requires a boolean. | def _set_compression(self, value):
""" May be used to compress PDF files. Code is more readable
for testing and inspection if not compressed. Requires a boolean. """
if isinstance(value, bool):
self.compression = value
else:
raise Exception(
... |
PDF objects #1 through #3 are typically saved for the Zeroth Catalog and Pages Objects. This program will save the numbers but outputs the individual Page and Content objects first. The actual Catalog and Pages objects are calculated after. | def _create_placeholder_objects(self):
""" PDF objects #1 through #3 are typically saved for the
Zeroth, Catalog, and Pages Objects. This program will save
the numbers, but outputs the individual Page and Content objects
first. The actual Catalog and Pages objects are cal... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.