_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14100 | ColorCode._init_hex | train | def _init_hex(self, hexval: str) -> None:
""" Initialize from a hex value string. """
self.hexval = hex2termhex(fix_hex(hexval))
self.code = hex2term(self.hexval)
self.rgb = hex2rgb(self.hexval) | python | {
"resource": ""
} |
q14101 | ColorCode._init_rgb | train | def _init_rgb(self, r: int, g: int, b: int) -> None:
""" Initialize from red, green, blue args. """
if self.rgb_mode:
self.rgb = (r, g, b)
self.hexval = rgb2hex(r, g, b)
else:
self.rgb = hex2rgb(rgb2termhex(r, g, b))
self.hexval = rgb2termhex(r, g,... | python | {
"resource": ""
} |
q14102 | ColorCode.from_code | train | def from_code(cls, code: int) -> 'ColorCode':
""" Return a ColorCode from a terminal code. """
c = cls()
c._init_code(code)
return c | python | {
"resource": ""
} |
q14103 | ColorCode.from_hex | train | def from_hex(cls, hexval: str) -> 'ColorCode':
""" Return a ColorCode from a hex string. """
c = cls()
c._init_hex(hexval)
return c | python | {
"resource": ""
} |
q14104 | ColorCode.from_rgb | train | def from_rgb(cls, r: int, g: int, b: int) -> 'ColorCode':
""" Return a ColorCode from a RGB tuple. """
c = cls()
c._init_rgb(r, g, b)
return c | python | {
"resource": ""
} |
q14105 | commit | train | def commit(func):
'''Used as a decorator for automatically making session commits'''
def wrap(**kwarg):
with session_withcommit() as session:
a = func(**kwarg)
session.add(a)
return session.query(songs).order_by(
songs.song_id.desc()).first().song_id
retur... | python | {
"resource": ""
} |
q14106 | get_hub | train | def get_hub():
"""Return the instance of the hub."""
try:
hub = _local.hub
except AttributeError:
# The Hub can only be instantiated from the root fiber. No other fibers
# can run until the Hub is there, so the root will always be the first
# one to call get_hub().
as... | python | {
"resource": ""
} |
q14107 | switch_back.switch | train | def switch(self, value=None):
"""Switch back to the origin fiber. The fiber is switch in next time
the event loop runs."""
if self._hub is None or not self._fiber.is_alive():
return
self._hub.run_callback(self._fiber.switch, value)
self._hub = self._fiber = None | python | {
"resource": ""
} |
q14108 | switch_back.throw | train | def throw(self, typ, val=None, tb=None):
"""Throw an exception into the origin fiber. The exception is thrown
the next time the event loop runs."""
# The might seem redundant with self._fiber.cancel(exc), but it isn't
# as self._fiber might be a "raw" fibers.Fiber() that doesn't have a
... | python | {
"resource": ""
} |
q14109 | Hub.close | train | def close(self):
"""Close the hub and wait for it to be closed.
This may only be called in the root fiber. After this call returned,
Gruvi cannot be used anymore in the current thread. The main use case
for calling this method is to clean up resources in a multi-threaded
program... | python | {
"resource": ""
} |
q14110 | Hub.switch | train | def switch(self):
"""Switch to the hub.
This method pauses the current fiber and runs the event loop. The
caller should ensure that it has set up appropriate callbacks so that
it will get scheduled again, preferably using :class:`switch_back`. In
this case then return value of t... | python | {
"resource": ""
} |
q14111 | Hub._run_callbacks | train | def _run_callbacks(self):
"""Run registered callbacks."""
for i in range(len(self._callbacks)):
callback, args = self._callbacks.popleft()
try:
callback(*args)
except Exception:
self._log.exception('Ignoring exception in callback:') | python | {
"resource": ""
} |
q14112 | Hub.run_callback | train | def run_callback(self, callback, *args):
"""Queue a callback.
The *callback* will be called with positional arguments *args* in the
next iteration of the event loop. If you add multiple callbacks, they
will be called in the order that you added them. The callback will run
in the... | python | {
"resource": ""
} |
q14113 | message_info | train | def message_info(message):
"""Return a string describing a message, for debugging purposes."""
method = message.get('method')
msgid = message.get('id')
error = message.get('error')
if method and msgid is not None:
return 'method call "{}", id = "{}"'.format(method, msgid)
elif method:
... | python | {
"resource": ""
} |
q14114 | JsonRpcVersion.next_id | train | def next_id(self):
"""Return a unique message ID."""
msgid = self._id_template.format(self._next_id)
self._next_id += 1
return msgid | python | {
"resource": ""
} |
q14115 | JsonRpcProtocol.send_message | train | def send_message(self, message):
"""Send a raw JSON-RPC message.
The *message* argument must be a dictionary containing a valid JSON-RPC
message according to the version passed into the constructor.
"""
if self._error:
raise compat.saved_exc(self._error)
elif... | python | {
"resource": ""
} |
q14116 | JsonRpcProtocol.call_method | train | def call_method(self, method, *args):
"""Call a JSON-RPC method and wait for its result.
The *method* is called with positional arguments *args*.
On success, the ``result`` field from the JSON-RPC response is
returned. On error, a :class:`JsonRpcError` is raised, which you can
... | python | {
"resource": ""
} |
q14117 | JsonRpcProtocol.send_notification | train | def send_notification(self, method, *args):
"""Send a JSON-RPC notification.
The notification *method* is sent with positional arguments *args*.
"""
message = self._version.create_request(method, args, notification=True)
self.send_message(message) | python | {
"resource": ""
} |
q14118 | JsonRpcProtocol.send_response | train | def send_response(self, request, result=None, error=None):
"""Respond to a JSON-RPC method call.
This is a response to the message in *request*. If *error* is not
provided, then this is a succesful response, and the value in *result*,
which may be ``None``, is passed back to the client.... | python | {
"resource": ""
} |
q14119 | unmarshal | train | def unmarshal( compoundSignature, data, offset = 0, lendian = True ):
"""
Unmarshals DBus encoded data.
@type compoundSignature: C{string}
@param compoundSignature: DBus signature specifying the encoded value types
@type data: C{string}
@param data: Binary data
@type offset: C{int}
@p... | python | {
"resource": ""
} |
q14120 | spawn | train | def spawn(func, *args, **kwargs):
"""Spawn a new fiber.
A new :class:`Fiber` is created with main function *func* and positional
arguments *args*. The keyword arguments are passed to the :class:`Fiber`
constructor, not to the main function. The fiber is then scheduled to start
by calling its :meth:... | python | {
"resource": ""
} |
q14121 | Fiber.start | train | def start(self):
"""Schedule the fiber to be started in the next iteration of the
event loop."""
target = getattr(self._target, '__qualname__', self._target.__name__)
self._log.debug('starting fiber {}, target {}', self.name, target)
self._hub.run_callback(self.switch) | python | {
"resource": ""
} |
q14122 | Fiber.cancel | train | def cancel(self, message=None):
"""Schedule the fiber to be cancelled in the next iteration of the
event loop.
Cancellation works by throwing a :class:`~gruvi.Cancelled` exception
into the fiber. If *message* is provided, it will be set as the value
of the exception.
"""... | python | {
"resource": ""
} |
q14123 | MetaMusic.align_matches | train | def align_matches(self, matches: list)->Optional[dict]:
"""
Finds hash matches that align in time with other matches and finds
consensus about which hashes are "true" signal from the audio.
Returns a dictionary with match information.
"""
# align by diffs
... | python | {
"resource": ""
} |
q14124 | saddr | train | def saddr(address):
"""Return a string representation for an address.
The *address* paramater can be a pipe name, an IP address tuple, or a
socket address.
The return value is always a ``str`` instance.
"""
if isinstance(address, six.string_types):
return address
elif isinstance(ad... | python | {
"resource": ""
} |
q14125 | paddr | train | def paddr(address):
"""Parse a string representation of an address.
This function is the inverse of :func:`saddr`.
"""
if not isinstance(address, six.string_types):
raise TypeError('expecting a string')
if address.startswith('['):
p1 = address.find(']:')
if p1 == -1:
... | python | {
"resource": ""
} |
q14126 | get_codes | train | def get_codes(s: Union[str, 'ChainedBase']) -> List[str]:
""" Grab all escape codes from a string.
Returns a list of all escape codes.
"""
return codegrabpat.findall(str(s)) | python | {
"resource": ""
} |
q14127 | get_indices | train | def get_indices(s: Union[str, 'ChainedBase']) -> Dict[int, str]:
""" Retrieve a dict of characters and escape codes with their real index
into the string as the key.
"""
codes = get_code_indices(s)
if not codes:
# This function is not for non-escape-code stuff, but okay.
return {... | python | {
"resource": ""
} |
q14128 | MultiPoll.remove_callback | train | def remove_callback(self, handle):
"""Remove a callback."""
if self._poll is None:
raise RuntimeError('poll instance is closed')
remove_callback(self, handle)
if handle.extra & READABLE:
self._readers -= 1
if handle.extra & WRITABLE:
self._writ... | python | {
"resource": ""
} |
q14129 | MultiPoll.update_callback | train | def update_callback(self, handle, events):
"""Update the event mask for a callback."""
if self._poll is None:
raise RuntimeError('poll instance is closed')
if not has_callback(self, handle):
raise ValueError('no such callback')
if events & ~(READABLE|WRITABLE):
... | python | {
"resource": ""
} |
q14130 | MultiPoll.close | train | def close(self):
"""Close the poll instance."""
if self._poll is None:
return
self._poll.close()
self._poll = None
self._readers = 0
self._writers = 0
self._events = 0
clear_callbacks(self) | python | {
"resource": ""
} |
q14131 | Poller.update_callback | train | def update_callback(self, fd, handle, events):
"""Update the event mask associated with an existing callback.
If you want to temporarily disable a callback then you can use this
method with an *events* argument of ``0``. This is more efficient than
removing the callback and adding it ag... | python | {
"resource": ""
} |
q14132 | Poller.close | train | def close(self):
"""Close all active poll instances and remove all callbacks."""
if self._mpoll is None:
return
for mpoll in self._mpoll.values():
mpoll.close()
self._mpoll.clear()
self._mpoll = None | python | {
"resource": ""
} |
q14133 | ClientAuthenticator.authTryNextMethod | train | def authTryNextMethod(self):
"""
Tries the next authentication method or raises a failure if all mechanisms
have been tried.
"""
if not self.authOrder:
raise DBusAuthenticationFailed()
self.authMech = self.authOrder.pop()
if self... | python | {
"resource": ""
} |
q14134 | ClientAuthenticator._authGetDBusCookie | train | def _authGetDBusCookie(self, cookie_context, cookie_id):
"""
Reads the requested cookie_id from the cookie_context file
"""
# XXX Ensure we obtain the correct directory for the
# authenticating user and that that user actually
# owns the keyrings directory
... | python | {
"resource": ""
} |
q14135 | add_callback | train | def add_callback(obj, callback, args=()):
"""Add a callback to an object."""
callbacks = obj._callbacks
node = Node(callback, args)
# Store a single callback directly in _callbacks
if callbacks is None:
obj._callbacks = node
return node
# Otherwise use a dllist.
if not isinst... | python | {
"resource": ""
} |
q14136 | remove_callback | train | def remove_callback(obj, handle):
"""Remove a callback from an object."""
callbacks = obj._callbacks
if callbacks is handle:
obj._callbacks = None
elif isinstance(callbacks, dllist):
callbacks.remove(handle)
if not callbacks:
obj._callbacks = None | python | {
"resource": ""
} |
q14137 | has_callback | train | def has_callback(obj, handle):
"""Return whether a callback is currently registered for an object."""
callbacks = obj._callbacks
if not callbacks:
return False
if isinstance(callbacks, Node):
return handle is callbacks
else:
return handle in callbacks | python | {
"resource": ""
} |
q14138 | pop_callback | train | def pop_callback(obj):
"""Pop a single callback."""
callbacks = obj._callbacks
if not callbacks:
return
if isinstance(callbacks, Node):
node = callbacks
obj._callbacks = None
else:
node = callbacks.first
callbacks.remove(node)
if not callbacks:
... | python | {
"resource": ""
} |
q14139 | clear_callbacks | train | def clear_callbacks(obj):
"""Remove all callbacks from an object."""
callbacks = obj._callbacks
if isinstance(callbacks, dllist):
# Help the garbage collector by clearing all links.
callbacks.clear()
obj._callbacks = None | python | {
"resource": ""
} |
q14140 | run_callbacks | train | def run_callbacks(obj, log=None):
"""Run callbacks."""
def run_callback(callback, args):
return callback(*args)
return walk_callbacks(obj, run_callback, log) | python | {
"resource": ""
} |
q14141 | get_serializer_class | train | def get_serializer_class(configuration_model):
""" Returns a ConfigurationModel serializer class for the supplied configuration_model. """
class AutoConfigModelSerializer(ModelSerializer):
"""Serializer class for configuration models."""
class Meta(object):
"""Meta information for A... | python | {
"resource": ""
} |
q14142 | deserialize_json | train | def deserialize_json(stream, username):
"""
Given a stream containing JSON, deserializers the JSON into ConfigurationModel instances.
The stream is expected to be in the following format:
{ "model": "config_models.ExampleConfigurationModel",
"data":
[
{ "enabled"... | python | {
"resource": ""
} |
q14143 | ConfigurationModelAdmin.get_displayable_field_names | train | def get_displayable_field_names(self):
"""
Return all field names, excluding reverse foreign key relationships.
"""
return [
f.name
for f in self.model._meta.get_fields()
if not f.one_to_many
] | python | {
"resource": ""
} |
q14144 | ConfigurationModelAdmin.revert | train | def revert(self, request, queryset):
"""
Admin action to revert a configuration back to the selected value
"""
if queryset.count() != 1:
self.message_user(request, _("Please select a single configuration to revert to."))
return
target = queryset[0]
... | python | {
"resource": ""
} |
q14145 | ShowHistoryFilter.choices | train | def choices(self, changelist):
""" Returns choices ready to be output in the template. """
show_all = self.used_parameters.get(self.parameter_name) == "1"
return (
{
'display': _('Current Configuration'),
'selected': not show_all,
'quer... | python | {
"resource": ""
} |
q14146 | KeyedConfigurationModelAdmin.get_queryset | train | def get_queryset(self, request):
"""
Annote the queryset with an 'is_active' property that's true iff that row is the most
recently added row for that particular set of KEY_FIELDS values.
Filter the queryset to show only is_active rows by default.
"""
if request.GET.get(S... | python | {
"resource": ""
} |
q14147 | KeyedConfigurationModelAdmin.edit_link | train | def edit_link(self, inst):
""" Edit link for the change view """
if not inst.is_active:
return u'--'
update_url = reverse('admin:{}_{}_add'.format(self.model._meta.app_label, self.model._meta.model_name))
update_url += "?source={}".format(inst.pk)
return u'<a href="{}... | python | {
"resource": ""
} |
q14148 | submit_row | train | def submit_row(context):
"""
Overrides 'django.contrib.admin.templatetags.admin_modify.submit_row'.
Manipulates the context going into that function by hiding all of the buttons
in the submit row if the key `readonly` is set in the context.
"""
ctx = original_submit_row(context)
if context... | python | {
"resource": ""
} |
q14149 | ConfigurationModelManager.current_set | train | def current_set(self):
"""
A queryset for the active configuration entries only. Only useful if KEY_FIELDS is set.
Active means the means recent entries for each unique combination of keys. It does not
necessaryily mean enbled.
"""
assert self.model.KEY_FIELDS != (), "Ju... | python | {
"resource": ""
} |
q14150 | ConfigurationModelManager.with_active_flag | train | def with_active_flag(self):
"""
A query set where each result is annotated with an 'is_active' field that indicates
if it's the most recent entry for that combination of keys.
"""
if self.model.KEY_FIELDS:
return self.get_queryset().annotate(
is_active... | python | {
"resource": ""
} |
q14151 | ConfigurationModel.save | train | def save(self, force_insert=False, force_update=False, using=None,
update_fields=None):
"""
Clear the cached value when saving a new configuration entry
"""
# Always create a new entry, instead of updating an existing model
self.pk = None # pylint: disable=invalid-n... | python | {
"resource": ""
} |
q14152 | ConfigurationModel.cache_key_name | train | def cache_key_name(cls, *args):
"""Return the name of the key to use to cache the current configuration"""
if cls.KEY_FIELDS != ():
if len(args) != len(cls.KEY_FIELDS):
raise TypeError(
"cache_key_name() takes exactly {} arguments ({} given)".format(len(cl... | python | {
"resource": ""
} |
q14153 | ConfigurationModel.key_values_cache_key_name | train | def key_values_cache_key_name(cls, *key_fields):
""" Key for fetching unique key values from the cache """
key_fields = key_fields or cls.KEY_FIELDS
return 'configuration/{}/key_values/{}'.format(cls.__name__, ','.join(key_fields)) | python | {
"resource": ""
} |
q14154 | ConfigurationModel.fields_equal | train | def fields_equal(self, instance, fields_to_ignore=("id", "change_date", "changed_by")):
"""
Compares this instance's fields to the supplied instance to test for equality.
This will ignore any fields in `fields_to_ignore`.
Note that this method ignores many-to-many fields.
Args:... | python | {
"resource": ""
} |
q14155 | ConfigurationModel.equal_to_current | train | def equal_to_current(cls, json, fields_to_ignore=("id", "change_date", "changed_by")):
"""
Compares for equality this instance to a model instance constructed from the supplied JSON.
This will ignore any fields in `fields_to_ignore`.
Note that this method cannot handle fields with many-... | python | {
"resource": ""
} |
q14156 | AtomicMixin.create_atomic_wrapper | train | def create_atomic_wrapper(cls, wrapped_func):
"""Returns a wrapped function."""
def _create_atomic_wrapper(*args, **kwargs):
"""Actual wrapper."""
# When a view call fails due to a permissions error, it raises an exception.
# An uncaught exception breaks the DB transa... | python | {
"resource": ""
} |
q14157 | AtomicMixin.as_view | train | def as_view(cls, **initkwargs):
"""Overrides as_view to add atomic transaction."""
view = super(AtomicMixin, cls).as_view(**initkwargs)
return cls.create_atomic_wrapper(view) | python | {
"resource": ""
} |
q14158 | merge | train | def merge(file, feature_layers):
''' Retrieve a list of OSciMap4 tile responses and merge them into one.
get_tiles() retrieves data and performs basic integrity checks.
'''
tile = VectorTile(extents)
for layer in feature_layers:
tile.addFeatures(layer['features'], layer['name'])
t... | python | {
"resource": ""
} |
q14159 | _make_valid_if_necessary | train | def _make_valid_if_necessary(shape):
"""
attempt to correct invalid shapes if necessary
After simplification, even when preserving topology, invalid
shapes can be returned. This appears to only occur with polygon
types. As an optimization, we only check if the polygon types are
valid.
"""
... | python | {
"resource": ""
} |
q14160 | _accumulate_props | train | def _accumulate_props(dest_props, src_props):
"""
helper to accumulate a dict of properties
Mutates dest_props by adding the non None src_props and returns
the new size
"""
props_size = 0
if src_props:
for k, v in src_props.items():
if v is not None:
prop... | python | {
"resource": ""
} |
q14161 | calculate_sizes_by_zoom | train | def calculate_sizes_by_zoom(coord, metatile_zoom, cfg_tile_sizes, max_zoom):
"""
Returns a map of nominal zoom to the list of tile sizes to generate at that
zoom.
This is because we want to generate different metatile contents at
different zoom levels. At the most detailed zoom level, we want to ge... | python | {
"resource": ""
} |
q14162 | calculate_cut_coords_by_zoom | train | def calculate_cut_coords_by_zoom(
coord, metatile_zoom, cfg_tile_sizes, max_zoom):
"""
Returns a map of nominal zoom to the list of cut coordinates at that
nominal zoom.
Note that max_zoom should be the maximum coordinate zoom, not nominal
zoom.
"""
tile_sizes_by_zoom = calculate_s... | python | {
"resource": ""
} |
q14163 | tiles_are_equal | train | def tiles_are_equal(tile_data_1, tile_data_2, fmt):
"""
Returns True if the tile data is equal in tile_data_1 and tile_data_2. For
most formats, this is a simple byte-wise equality check. For zipped
metatiles, we need to check the contents, as the zip format includes
metadata such as timestamps and ... | python | {
"resource": ""
} |
q14164 | write_tile_if_changed | train | def write_tile_if_changed(store, tile_data, coord, format):
"""
Only write tile data if different from existing.
Try to read the tile data from the store first. If the existing
data matches, don't write. Returns whether the tile was written.
"""
existing_data = store.read_tile(coord, format)
... | python | {
"resource": ""
} |
q14165 | _override_cfg | train | def _override_cfg(container, yamlkeys, value):
"""
Override a hierarchical key in the config, setting it to the value.
Note that yamlkeys should be a non-empty list of strings.
"""
key = yamlkeys[0]
rest = yamlkeys[1:]
if len(rest) == 0:
# no rest means we found the key to update.... | python | {
"resource": ""
} |
q14166 | coord_pyramid | train | def coord_pyramid(coord, zoom_start, zoom_stop):
"""
generate full pyramid for coord
Generate the full pyramid for a single coordinate. Note that zoom_stop is
exclusive.
"""
if zoom_start <= coord.zoom:
yield coord
for child_coord in coord_children_range(coord, zoom_stop):
i... | python | {
"resource": ""
} |
q14167 | coord_pyramids | train | def coord_pyramids(coords, zoom_start, zoom_stop):
"""
generate full pyramid for coords
Generate the full pyramid for the list of coords. Note that zoom_stop is
exclusive.
"""
for coord in coords:
for child in coord_pyramid(coord, zoom_start, zoom_stop):
yield child | python | {
"resource": ""
} |
q14168 | tilequeue_enqueue_full_pyramid_from_toi | train | def tilequeue_enqueue_full_pyramid_from_toi(cfg, peripherals, args):
"""enqueue a full pyramid from the z10 toi"""
logger = make_logger(cfg, 'enqueue_tiles_of_interest')
logger.info('Enqueueing tiles of interest')
logger.info('Fetching tiles of interest ...')
tiles_of_interest = peripherals.toi.fet... | python | {
"resource": ""
} |
q14169 | tilequeue_enqueue_random_pyramids | train | def tilequeue_enqueue_random_pyramids(cfg, peripherals, args):
"""enqueue random pyramids"""
from tilequeue.stats import RawrTileEnqueueStatsHandler
from tilequeue.rawr import make_rawr_enqueuer_from_cfg
logger = make_logger(cfg, 'enqueue_random_pyramids')
rawr_yaml = cfg.yml.get('rawr')
asse... | python | {
"resource": ""
} |
q14170 | emit_toi_stats | train | def emit_toi_stats(toi_set, peripherals):
"""
Calculates new TOI stats and emits them via statsd.
"""
count_by_zoom = defaultdict(int)
total = 0
for coord_int in toi_set:
coord = coord_unmarshall_int(coord_int)
count_by_zoom[coord.zoom] += 1
total += 1
peripherals.s... | python | {
"resource": ""
} |
q14171 | tilequeue_stuck_tiles | train | def tilequeue_stuck_tiles(cfg, peripherals):
"""
Check which files exist on s3 but are not in toi.
"""
store = _make_store(cfg)
format = lookup_format_by_extension('zip')
layer = 'all'
assert peripherals.toi, 'Missing toi'
toi = peripherals.toi.fetch_tiles_of_interest()
for coord i... | python | {
"resource": ""
} |
q14172 | tilequeue_tile_status | train | def tilequeue_tile_status(cfg, peripherals, args):
"""
Report the status of the given tiles in the store, queue and TOI.
"""
logger = make_logger(cfg, 'tile_status')
# friendly warning to avoid confusion when this command outputs nothing
# at all when called with no positional arguments.
if... | python | {
"resource": ""
} |
q14173 | tilequeue_rawr_enqueue | train | def tilequeue_rawr_enqueue(cfg, args):
"""command to take tile expiry path and enqueue for rawr tile generation"""
from tilequeue.stats import RawrTileEnqueueStatsHandler
from tilequeue.rawr import make_rawr_enqueuer_from_cfg
msg_marshall_yaml = cfg.yml.get('message-marshall')
assert msg_marshall_y... | python | {
"resource": ""
} |
q14174 | _tilequeue_rawr_setup | train | def _tilequeue_rawr_setup(cfg):
"""command to read from rawr queue and generate rawr tiles"""
rawr_yaml = cfg.yml.get('rawr')
assert rawr_yaml is not None, 'Missing rawr configuration in yaml'
rawr_postgresql_yaml = rawr_yaml.get('postgresql')
assert rawr_postgresql_yaml, 'Missing rawr postgresql c... | python | {
"resource": ""
} |
q14175 | tilequeue_rawr_seed_toi | train | def tilequeue_rawr_seed_toi(cfg, peripherals):
"""command to read the toi and enqueue the corresponding rawr tiles"""
tiles_of_interest = peripherals.toi.fetch_tiles_of_interest()
coords = map(coord_unmarshall_int, tiles_of_interest)
_tilequeue_rawr_seed(cfg, peripherals, coords) | python | {
"resource": ""
} |
q14176 | tilequeue_rawr_seed_all | train | def tilequeue_rawr_seed_all(cfg, peripherals):
"""command to enqueue all the tiles at the group-by zoom"""
rawr_yaml = cfg.yml.get('rawr')
assert rawr_yaml is not None, 'Missing rawr configuration in yaml'
group_by_zoom = rawr_yaml.get('group-zoom')
assert group_by_zoom is not None, 'Missing group... | python | {
"resource": ""
} |
q14177 | update_arc_indexes | train | def update_arc_indexes(geometry, merged_arcs, old_arcs):
""" Updated geometry arc indexes, and add arcs to merged_arcs along the way.
Arguments are modified in-place, and nothing is returned.
"""
if geometry['type'] in ('Point', 'MultiPoint'):
return
elif geometry['type'] == 'LineStrin... | python | {
"resource": ""
} |
q14178 | get_transform | train | def get_transform(bounds, size=4096):
""" Return a TopoJSON transform dictionary and a point-transforming function.
Size is the tile size in pixels and sets the implicit output
resolution.
"""
tx, ty = bounds[0], bounds[1]
sx, sy = (bounds[2] - bounds[0]) / size, (bounds[3] - bounds[1])... | python | {
"resource": ""
} |
q14179 | diff_encode | train | def diff_encode(line, transform):
""" Differentially encode a shapely linestring or ring.
"""
coords = [transform(x, y) for (x, y) in line.coords]
pairs = zip(coords[:], coords[1:])
diffs = [(x2 - x1, y2 - y1) for ((x1, y1), (x2, y2)) in pairs]
return coords[:1] + [(x, y) for (x, y) in diffs i... | python | {
"resource": ""
} |
q14180 | jinja_filter_bbox_overlaps | train | def jinja_filter_bbox_overlaps(bounds, geometry_col_name, srid=3857):
"""
Check whether the boundary of the geometry intersects with the bounding
box.
Note that the usual meaning of "overlaps" in GIS terminology is that the
boundaries of the box and polygon intersect, but not the interiors. This
... | python | {
"resource": ""
} |
q14181 | make_db_data_fetcher | train | def make_db_data_fetcher(postgresql_conn_info, template_path, reload_templates,
query_cfg, io_pool):
"""
Returns an object which is callable with the zoom and unpadded bounds and
which returns a list of rows.
"""
sources = parse_source_data(query_cfg)
queries_generator ... | python | {
"resource": ""
} |
q14182 | common_parent | train | def common_parent(a, b):
"""
Find the common parent tile of both a and b. The common parent is the tile
at the highest zoom which both a and b can be transformed into by lowering
their zoom levels.
"""
if a.zoom < b.zoom:
b = b.zoomTo(a.zoom).container()
elif a.zoom > b.zoom:
... | python | {
"resource": ""
} |
q14183 | _parent_tile | train | def _parent_tile(tiles):
"""
Find the common parent tile for a sequence of tiles.
"""
parent = None
for t in tiles:
if parent is None:
parent = t
else:
parent = common_parent(parent, t)
return parent | python | {
"resource": ""
} |
q14184 | make_metatiles | train | def make_metatiles(size, tiles, date_time=None):
"""
Group by layers, and make metatiles out of all the tiles which share those
properties relative to the "top level" tile which is parent of them all.
Provide a 6-tuple date_time to set the timestamp on each tile within the
metatile, or leave it as N... | python | {
"resource": ""
} |
q14185 | _metatile_contents_equal | train | def _metatile_contents_equal(zip_1, zip_2):
"""
Given two open zip files as arguments, this returns True if the zips
both contain the same set of files, having the same names, and each
file within the zip is byte-wise identical to the one with the same
name in the other zip.
"""
names_1 = s... | python | {
"resource": ""
} |
q14186 | metatiles_are_equal | train | def metatiles_are_equal(tile_data_1, tile_data_2):
"""
Return True if the two tiles are both zipped metatiles and contain the
same set of files with the same contents. This ignores the timestamp of
the individual files in the zip files, as well as their order or any
other metadata.
"""
try:... | python | {
"resource": ""
} |
q14187 | make_coord_dict | train | def make_coord_dict(coord):
"""helper function to make a dict from a coordinate for logging"""
return dict(
z=int_if_exact(coord.zoom),
x=int_if_exact(coord.column),
y=int_if_exact(coord.row),
) | python | {
"resource": ""
} |
q14188 | convert_feature_layers_to_dict | train | def convert_feature_layers_to_dict(feature_layers):
"""takes a list of 'feature_layer' objects and converts to a dict
keyed by the layer name"""
features_by_layer = {}
for feature_layer in feature_layers:
layer_name = feature_layer['name']
features = feature_layer['features']
... | python | {
"resource": ""
} |
q14189 | ZoomRangeAndZoomGroupQueueMapper.group | train | def group(self, coords):
"""return CoordGroups that can be used to send to queues
Each CoordGroup represents a message that can be sent to a
particular queue, stamped with the queue_id. The list of
coords, which can be 1, is what should get used for the
payload for each queue me... | python | {
"resource": ""
} |
q14190 | common_parent | train | def common_parent(coords, parent_zoom):
"""
Return the common parent for coords
Also check that all coords do indeed share the same parent coordinate.
"""
parent = None
for coord in coords:
assert parent_zoom <= coord.zoom
coord_parent = coord.zoomTo(parent_zoom).container()
... | python | {
"resource": ""
} |
q14191 | convert_coord_object | train | def convert_coord_object(coord):
"""Convert ModestMaps.Core.Coordinate -> raw_tiles.tile.Tile"""
assert isinstance(coord, Coordinate)
coord = coord.container()
return Tile(int(coord.zoom), int(coord.column), int(coord.row)) | python | {
"resource": ""
} |
q14192 | unconvert_coord_object | train | def unconvert_coord_object(tile):
"""Convert rawr_tiles.tile.Tile -> ModestMaps.Core.Coordinate"""
assert isinstance(tile, Tile)
return Coordinate(zoom=tile.z, column=tile.x, row=tile.y) | python | {
"resource": ""
} |
q14193 | make_rawr_zip_payload | train | def make_rawr_zip_payload(rawr_tile, date_time=None):
"""make a zip file from the rawr tile formatted data"""
if date_time is None:
date_time = gmtime()[0:6]
buf = StringIO()
with zipfile.ZipFile(buf, mode='w') as z:
for fmt_data in rawr_tile.all_formatted_data:
zip_info = z... | python | {
"resource": ""
} |
q14194 | unpack_rawr_zip_payload | train | def unpack_rawr_zip_payload(table_sources, payload):
"""unpack a zipfile and turn it into a callable "tables" object."""
# the io we get from S3 is streaming, so we can't seek on it, but zipfile
# seems to require that. so we buffer it all in memory. RAWR tiles are
# generally up to around 100MB in size... | python | {
"resource": ""
} |
q14195 | SqsQueue.send | train | def send(self, payloads, logger, num_tries=5):
"""
Enqueue payloads to the SQS queue, retrying failed messages with
exponential backoff.
"""
from time import sleep
backoff_interval = 1
backoff_factor = 2
for try_counter in xrange(0, num_tries):
... | python | {
"resource": ""
} |
q14196 | SqsQueue.read | train | def read(self):
"""read a single message from the queue"""
resp = self.sqs_client.receive_message(
QueueUrl=self.queue_url,
MaxNumberOfMessages=1,
AttributeNames=('SentTimestamp',),
WaitTimeSeconds=self.recv_wait_time_seconds,
)
if resp['Re... | python | {
"resource": ""
} |
q14197 | SqsQueue.done | train | def done(self, msg_handle):
"""acknowledge completion of message"""
self.sqs_client.delete_message(
QueueUrl=self.queue_url,
ReceiptHandle=msg_handle.handle,
) | python | {
"resource": ""
} |
q14198 | RawrToiIntersector.tiles_of_interest | train | def tiles_of_interest(self):
"""conditionally get the toi from s3"""
# also return back whether the response was cached
# useful for metrics
is_cached = False
get_options = dict(
Bucket=self.bucket,
Key=self.key,
)
if self.etag:
... | python | {
"resource": ""
} |
q14199 | _ack_coord_handle | train | def _ack_coord_handle(
coord, coord_handle, queue_mapper, msg_tracker, timing_state,
tile_proc_logger, stats_handler):
"""share code for acknowledging a coordinate"""
# returns tuple of (handle, error), either of which can be None
track_result = msg_tracker.done(coord_handle)
queue_han... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.