code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
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._writers -= 1
self._sync() | def remove_callback(self, handle) | Remove a callback. | 5.412226 | 5.239643 | 1.032938 |
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):
raise ValueError('illegal event mask: {}'.format(events))
if handle.... | def update_callback(self, handle, events) | Update the event mask for a callback. | 3.216679 | 3.021597 | 1.064563 |
if self._poll is None:
return
self._poll.close()
self._poll = None
self._readers = 0
self._writers = 0
self._events = 0
clear_callbacks(self) | def close(self) | Close the poll instance. | 4.019728 | 3.09591 | 1.298399 |
if self._mpoll is None:
raise RuntimeError('Poller instance is closed')
try:
mpoll = self._mpoll[fd]
except KeyError:
mpoll = self._mpoll[fd] = MultiPoll(self._loop, fd)
handle = mpoll.add_callback(events, callback)
return handle | def add_callback(self, fd, events, callback) | Add a new callback.
The file descriptor *fd* will be watched for the events specified by
the *events* parameter, which should be a bitwise OR of the constants
``READABLE`` and ``WRITABLE``. Whenever one or more of the specified
events occur, *callback* will be called with a single integ... | 4.066051 | 4.444027 | 0.914947 |
if self._mpoll is None:
raise RuntimeError('Poller instance is closed')
mpoll = self._mpoll.get(fd)
if mpoll is None:
raise ValueError('not watching fd {}'.format(fd))
mpoll.remove_callback(handle) | def remove_callback(self, fd, handle) | Remove a callback added by :meth:`~Poller.add_callback`.
If this is the last callback that is registered for the fd then this
will deallocate the ``MultiPoll`` instance and close the libuv handle. | 4.926264 | 4.182283 | 1.177889 |
if self._mpoll is None:
raise RuntimeError('Poller instance is closed')
mpoll = self._mpoll.get(fd)
if mpoll is None:
raise ValueError('not watching fd {}'.format(fd))
mpoll.update_callback(handle, events) | 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 again later. | 5.102634 | 5.451367 | 0.936028 |
if self._mpoll is None:
return
for mpoll in self._mpoll.values():
mpoll.close()
self._mpoll.clear()
self._mpoll = None | def close(self) | Close all active poll instances and remove all callbacks. | 3.867625 | 2.796741 | 1.382904 |
if not self.authOrder:
raise DBusAuthenticationFailed()
self.authMech = self.authOrder.pop()
if self.authMech == 'DBUS_COOKIE_SHA1':
self.sendAuthMessage('AUTH ' + self.authMech + ' ' +
hexlify(getpass.getus... | def authTryNextMethod(self) | Tries the next authentication method or raises a failure if all mechanisms
have been tried. | 4.156387 | 3.990497 | 1.041571 |
# XXX Ensure we obtain the correct directory for the
# authenticating user and that that user actually
# owns the keyrings directory
if self.cookie_dir is None:
cookie_dir = os.path.expanduser('~/.dbus-keyrings')
else:
cookie_dir = ... | def _authGetDBusCookie(self, cookie_context, cookie_id) | Reads the requested cookie_id from the cookie_context file | 3.794742 | 3.754402 | 1.010745 |
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 isinstance(callbacks, dllist):
obj._callbacks = dllist()
obj._call... | def add_callback(obj, callback, args=()) | Add a callback to an object. | 4.518449 | 4.327332 | 1.044165 |
callbacks = obj._callbacks
if callbacks is handle:
obj._callbacks = None
elif isinstance(callbacks, dllist):
callbacks.remove(handle)
if not callbacks:
obj._callbacks = None | def remove_callback(obj, handle) | Remove a callback from an object. | 3.977632 | 3.828177 | 1.039041 |
callbacks = obj._callbacks
if not callbacks:
return False
if isinstance(callbacks, Node):
return handle is callbacks
else:
return handle in callbacks | def has_callback(obj, handle) | Return whether a callback is currently registered for an object. | 4.888912 | 4.705249 | 1.039034 |
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:
obj._callbacks = None
return node.data, no... | def pop_callback(obj) | Pop a single callback. | 3.836607 | 3.750497 | 1.02296 |
callbacks = obj._callbacks
if isinstance(callbacks, dllist):
# Help the garbage collector by clearing all links.
callbacks.clear()
obj._callbacks = None | def clear_callbacks(obj) | Remove all callbacks from an object. | 8.230541 | 8.154208 | 1.009361 |
callbacks = obj._callbacks
if isinstance(callbacks, Node):
node = callbacks
try:
if not func(node.data, node.extra):
obj._callbacks = None
except Exception:
if log is None:
log = logging.get_logger()
log.exception('... | def walk_callbacks(obj, func, log=None) | Call func(callback, args) for all callbacks and keep only those
callbacks for which the function returns True. | 2.637789 | 2.735944 | 0.964124 |
def run_callback(callback, args):
return callback(*args)
return walk_callbacks(obj, run_callback, log) | def run_callbacks(obj, log=None) | Run callbacks. | 5.478526 | 5.731492 | 0.955864 |
class AutoConfigModelSerializer(ModelSerializer):
class Meta(object):
model = configuration_model
fields = '__all__'
def create(self, validated_data):
if "changed_by_username" in self.context:
model = get_user_model()
... | def get_serializer_class(configuration_model) | Returns a ConfigurationModel serializer class for the supplied configuration_model. | 2.852315 | 2.684978 | 1.062323 |
parsed_json = JSONParser().parse(stream)
serializer_class = get_serializer_class(apps.get_model(parsed_json["model"]))
list_serializer = serializer_class(data=parsed_json["data"], context={"changed_by_username": username}, many=True)
if list_serializer.is_valid():
model_class = serializer_c... | 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": True,
"color": "black"
... | 3.261116 | 3.242826 | 1.00564 |
return [
f.name
for f in self.model._meta.get_fields()
if not f.one_to_many
] | def get_displayable_field_names(self) | Return all field names, excluding reverse foreign key relationships. | 3.252331 | 2.413803 | 1.347389 |
if queryset.count() != 1:
self.message_user(request, _("Please select a single configuration to revert to."))
return
target = queryset[0]
target.id = None
self.save_model(request, target, None, False)
self.message_user(request, _("Reverted config... | def revert(self, request, queryset) | Admin action to revert a configuration back to the selected value | 2.391793 | 2.248127 | 1.063904 |
show_all = self.used_parameters.get(self.parameter_name) == "1"
return (
{
'display': _('Current Configuration'),
'selected': not show_all,
'query_string': changelist.get_query_string({}, [self.parameter_name]),
},
... | def choices(self, changelist) | Returns choices ready to be output in the template. | 3.314711 | 3.241578 | 1.022561 |
if request.GET.get(ShowHistoryFilter.parameter_name) == '1':
queryset = self.model.objects.with_active_flag()
else:
# Show only the most recent row for each key.
queryset = self.model.objects.current_set()
ordering = self.get_ordering(request)
... | 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. | 4.547584 | 3.455109 | 1.316191 |
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="{}">{}</a>'.format(update_url, _('Update')) | def edit_link(self, inst) | Edit link for the change view | 2.957096 | 2.828411 | 1.045497 |
ctx = original_submit_row(context)
if context.get('readonly', False):
ctx.update({
'show_delete_link': False,
'show_save_as_new': False,
'show_save_and_add_another': False,
'show_save_and_continue': False,
'show_save': False,
})
... | 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. | 2.789362 | 2.246245 | 1.241789 |
return self.values(*self.model.KEY_FIELDS).annotate(max=models.Max('pk')).values('max') | def _current_ids_subquery(self) | Internal helper method to return an SQL string that will get the IDs of
all the current entries (i.e. the most recent entry for each unique set
of key values). Only useful if KEY_FIELDS is set. | 13.402846 | 6.803348 | 1.970037 |
assert self.model.KEY_FIELDS != (), "Just use model.current() if there are no KEY_FIELDS"
return self.get_queryset().filter(
pk__in=self._current_ids_subquery()
).annotate(
is_active=models.Value(1, output_field=models.IntegerField())
) | 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. | 8.319753 | 5.472334 | 1.52033 |
if self.model.KEY_FIELDS:
return self.get_queryset().annotate(
is_active=models.ExpressionWrapper(
models.Q(pk__in=self._current_ids_subquery()),
output_field=models.IntegerField(),
)
)
return self.g... | 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. | 3.142613 | 2.608645 | 1.204692 |
# Always create a new entry, instead of updating an existing model
self.pk = None # pylint: disable=invalid-name
super(ConfigurationModel, self).save(
force_insert,
force_update,
using,
update_fields
)
cache.delete(self.ca... | def save(self, force_insert=False, force_update=False, using=None,
update_fields=None) | Clear the cached value when saving a new configuration entry | 4.437711 | 4.077076 | 1.088454 |
if cls.KEY_FIELDS != ():
if len(args) != len(cls.KEY_FIELDS):
raise TypeError(
"cache_key_name() takes exactly {} arguments ({} given)".format(len(cls.KEY_FIELDS), len(args))
)
# pylint: disable=unicode-builtin
retu... | def cache_key_name(cls, *args) | Return the name of the key to use to cache the current configuration | 3.240886 | 3.050729 | 1.062331 |
cached = cache.get(cls.cache_key_name(*args))
if cached is not None:
return cached
key_dict = dict(zip(cls.KEY_FIELDS, args))
try:
current = cls.objects.filter(**key_dict).order_by('-change_date')[0]
except IndexError:
current = cls(*... | def current(cls, *args) | Return the active configuration entry, either from cache,
from the database, or by creating a new empty entry (which is not
persisted). | 2.659567 | 2.575112 | 1.032796 |
key_fields = key_fields or cls.KEY_FIELDS
return 'configuration/{}/key_values/{}'.format(cls.__name__, ','.join(key_fields)) | def key_values_cache_key_name(cls, *key_fields) | Key for fetching unique key values from the cache | 5.082156 | 5.136251 | 0.989468 |
flat = kwargs.pop('flat', False)
assert not kwargs, "'flat' is the only kwarg accepted"
key_fields = key_fields or cls.KEY_FIELDS
cache_key = cls.key_values_cache_key_name(*key_fields)
cached = cache.get(cache_key)
if cached is not None:
return cached... | def key_values(cls, *key_fields, **kwargs) | Get the set of unique values in the configuration table for the given
key[s]. Calling cls.current(*value) for each value in the resulting
list should always produce an entry, though any such entry may have
enabled=False.
Arguments:
key_fields: The positional arguments are th... | 2.765166 | 2.767583 | 0.999127 |
for field in self._meta.get_fields():
if not field.many_to_many and field.name not in fields_to_ignore:
if getattr(instance, field.name) != getattr(self, field.name):
return False
return True | 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:
instance: the model instance to compare
fields_to_ignore: List of fields that shoul... | 2.1824 | 2.068392 | 1.055119 |
# Remove many-to-many relationships from json.
# They require an instance to be already saved.
info = model_meta.get_field_info(cls)
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in json):
json.pop(... | 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-to-many associations, as those can only
be set on a saved model instance (and saving the model inst... | 4.851859 | 4.514251 | 1.074787 |
def _create_atomic_wrapper(*args, **kwargs):
# When a view call fails due to a permissions error, it raises an exception.
# An uncaught exception breaks the DB transaction for any following DB operations
# unless it's wrapped in a atomic() decorator or c... | def create_atomic_wrapper(cls, wrapped_func) | Returns a wrapped function. | 7.557894 | 7.05335 | 1.071533 |
view = super(AtomicMixin, cls).as_view(**initkwargs)
return cls.create_atomic_wrapper(view) | def as_view(cls, **initkwargs) | Overrides as_view to add atomic transaction. | 5.628776 | 4.395269 | 1.280644 |
def _decorator(func):
@wraps(func)
def _inner(*args, **kwargs):
if not config_model.current().enabled:
return HttpResponseNotFound()
return func(*args, **kwargs)
return _inner
return _decorator | def require_config(config_model) | View decorator that enables/disables a view based on configuration.
Arguments:
config_model (ConfigurationModel subclass): The class of the configuration
model to check.
Returns:
HttpResponse: 404 if the configuration model is disabled,
otherwise returns the response fr... | 3.626687 | 3.329017 | 1.089417 |
''' 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'])
tile.complete()
data = tile.o... | 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. | 11.179223 | 4.244046 | 2.634096 |
if shape.type in ('Polygon', 'MultiPolygon') and not shape.is_valid:
shape = shape.buffer(0)
# return value from buffer is usually valid, but it's
# not clear from the docs whether this is guaranteed,
# so return None if not.
if not shape.is_valid:
return No... | 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. | 5.484289 | 4.694207 | 1.16831 |
props_size = 0
if src_props:
for k, v in src_props.items():
if v is not None:
props_size += len(k) + _sizeof(v)
dest_props[k] = v
return props_size | 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 | 2.632172 | 2.434381 | 1.081249 |
from tilequeue.tile import coord_children_subrange
from tilequeue.tile import metatile_zoom_from_size
assert tile_size >= 256
assert tile_size <= 256 * (1 << metatile_zoom)
assert _is_power_of_2(tile_size)
# delta is how many zoom levels _lower_ we want the child tiles, based on
# th... | def metatile_children_with_size(coord, metatile_zoom, nominal_zoom, tile_size) | Return a list of all the coords which are children of the input metatile
at `coord` with zoom `metatile_zoom` (i.e: 0 for a single tile metatile,
1 for 2x2, 2 for 4x4, etc...) with size `tile_size` corrected for the
`nominal_zoom`.
For example, in a single tile metatile, the `tile_size` must be 256 and... | 5.165899 | 4.938378 | 1.046072 |
from tilequeue.tile import metatile_zoom_from_size
tile_size_by_zoom = {}
nominal_zoom = coord.zoom + metatile_zoom
# check that the tile sizes are correct and within range.
for tile_size in cfg_tile_sizes:
assert tile_size >= 256
assert tile_size <= 256 * (1 << metatile_zoom... | 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 generate
the smallest tiles possible, as this allows "overzooming" by simply
extrac... | 2.771817 | 2.670427 | 1.037968 |
tile_sizes_by_zoom = calculate_sizes_by_zoom(
coord, metatile_zoom, cfg_tile_sizes, max_zoom)
cut_coords_by_zoom = {}
for nominal_zoom, tile_sizes in tile_sizes_by_zoom.iteritems():
cut_coords = []
for tile_size in tile_sizes:
cut_coords.extend(metatile_children_wi... | 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. | 2.179627 | 1.994183 | 1.092992 |
'''
Simple emulation of function `os.replace(..)` from modern version
of Python. Implementation is not fully atomic, but enough for us.
'''
orig_os_replace_func = getattr(os, 'replace', None)
if orig_os_replace_func is not None:
# not need for emulation: we using modern version of Pyth... | def os_replace(src, dst) | Simple emulation of function `os.replace(..)` from modern version
of Python. Implementation is not fully atomic, but enough for us. | 5.415154 | 4.31255 | 1.255673 |
if fmt and fmt == zip_format:
return metatiles_are_equal(tile_data_1, tile_data_2)
else:
return tile_data_1 == tile_data_2 | 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 doesn't control file ordering. | 3.810288 | 3.166131 | 1.203452 |
existing_data = store.read_tile(coord, format)
if not existing_data or \
not tiles_are_equal(existing_data, tile_data, format):
store.write_tile(tile_data, coord, format)
return True
else:
return False | 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. | 2.720916 | 2.582234 | 1.053706 |
key = yamlkeys[0]
rest = yamlkeys[1:]
if len(rest) == 0:
# no rest means we found the key to update.
container[key] = value
elif key in container:
# still need to find the leaf in the tree, so recurse.
_override_cfg(container[key], rest, value)
else:
... | 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. | 3.587188 | 3.454906 | 1.038288 |
if zoom_start <= coord.zoom:
yield coord
for child_coord in coord_children_range(coord, zoom_stop):
if zoom_start <= child_coord.zoom:
yield child_coord | 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. | 3.784694 | 3.997567 | 0.946749 |
for coord in coords:
for child in coord_pyramid(coord, zoom_start, zoom_stop):
yield child | 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. | 4.218143 | 4.748399 | 0.888329 |
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.fetch_tiles_of_interest()
n_toi = len(tiles_of_interest)
logger.info('Fetching tiles of interest ... done')
... | def tilequeue_enqueue_full_pyramid_from_toi(cfg, peripherals, args) | enqueue a full pyramid from the z10 toi | 2.823842 | 2.851995 | 0.990129 |
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')
assert rawr_yaml, 'Missing rawr yaml'
group_by_zoom = rawr_yaml.get('group-zoom')
assert... | def tilequeue_enqueue_random_pyramids(cfg, peripherals, args) | enqueue random pyramids | 2.79613 | 2.792126 | 1.001434 |
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.stats.gauge('tiles-of-interest.count', total)
for zoom, count in count_by_zoom.items():
peripheral... | def emit_toi_stats(toi_set, peripherals) | Calculates new TOI stats and emits them via statsd. | 3.758862 | 3.458613 | 1.086812 |
logger = make_logger(cfg, 'load_tiles_of_interest')
toi_filename = "toi.txt"
logger.info('Loading tiles of interest from %s ... ', toi_filename)
with open(toi_filename, 'r') as f:
new_toi = load_set_from_fp(f)
logger.info('Loading tiles of interest from %s ... done', toi_filename)
... | def tilequeue_load_tiles_of_interest(cfg, peripherals) | Given a newline-delimited file containing tile coordinates in
`zoom/column/row` format, load those tiles into the tiles of interest. | 2.958919 | 3.060934 | 0.966672 |
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 in store.list_tiles(format, layer):
coord_int = coord_marshall_int(coord)
if coord_int not in t... | def tilequeue_stuck_tiles(cfg, peripherals) | Check which files exist on s3 but are not in toi. | 9.486851 | 7.987507 | 1.187711 |
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 not args.coords:
logger.warning('No coordinates given on the command line.')
return
# pre-load TOI to avoid ha... | def tilequeue_tile_status(cfg, peripherals, args) | Report the status of the given tiles in the store, queue and TOI. | 5.141945 | 4.932639 | 1.042433 |
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_yaml, 'Missing message-marshall config'
msg_marshaller = make_message_marshaller(msg_marshall_yaml)
logger... | def tilequeue_rawr_enqueue(cfg, args) | command to take tile expiry path and enqueue for rawr tile generation | 3.870537 | 3.569071 | 1.084466 |
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 config'
from raw_tiles.formatter.msgpack import Msgpack
from raw_tiles.gen import Raw... | def _tilequeue_rawr_setup(cfg) | command to read from rawr queue and generate rawr tiles | 2.354143 | 2.336058 | 1.007742 |
tiles_of_interest = peripherals.toi.fetch_tiles_of_interest()
coords = map(coord_unmarshall_int, tiles_of_interest)
_tilequeue_rawr_seed(cfg, peripherals, coords) | def tilequeue_rawr_seed_toi(cfg, peripherals) | command to read the toi and enqueue the corresponding rawr tiles | 5.822131 | 5.856933 | 0.994058 |
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-zoom rawr config'
max_coord = 2 ** group_by_zoom
# creating the list of all coordinates here mi... | def tilequeue_rawr_seed_all(cfg, peripherals) | command to enqueue all the tiles at the group-by zoom | 5.456368 | 4.896401 | 1.114363 |
precision = precision_for_zoom(zoom)
fs = create_layer_feature_collection(features, precision)
json.dump(fs, out) | def encode_single_layer(out, features, zoom) | Encode a list of (WKB|shapely, property dict, id) features into a
GeoJSON stream.
If no id is available, pass in None
Geometries in the features list are assumed to be lon, lats. | 9.871971 | 9.983368 | 0.988842 |
precision = precision_for_zoom(zoom)
geojson = {}
for layer_name, features in features_by_layer.items():
fs = create_layer_feature_collection(features, precision)
geojson[layer_name] = fs
json.dump(geojson, out) | def encode_multiple_layers(out, features_by_layer, zoom) | features_by_layer should be a dict: layer_name -> feature tuples | 4.0434 | 3.634582 | 1.11248 |
if geometry['type'] in ('Point', 'MultiPoint'):
return
elif geometry['type'] == 'LineString':
for arc_index, old_arc in enumerate(geometry['arcs']):
geometry['arcs'][arc_index] = len(merged_arcs)
merged_arcs.append(old_arcs[old_arc])
elif geometry['type'] == 'P... | 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. | 1.538767 | 1.547889 | 0.994107 |
tx, ty = bounds[0], bounds[1]
sx, sy = (bounds[2] - bounds[0]) / size, (bounds[3] - bounds[1]) / size
def forward(lon, lat):
return int(round((lon - tx) / sx)), int(round((lat - ty) / sy))
return dict(translate=(tx, ty), scale=(sx, sy)), forward | 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. | 2.874446 | 2.7725 | 1.036771 |
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 if (x, y) != (0, 0)] | def diff_encode(line, transform) | Differentially encode a shapely linestring or ring. | 2.607384 | 2.555699 | 1.020223 |
transform, forward = get_transform(bounds, size=size)
arcs = []
geometries_by_layer = {}
for layer, features in features_by_layer.iteritems():
geometries = []
for shape, props, fid in features:
if shape.type == 'GeometryCollection':
continue
... | def encode(file, features_by_layer, bounds, size=4096) | Encode a dict of layername: (shape, props, id) features into a
TopoJSON stream.
If no id is available, pass in None
Geometries in the features list are assumed to be unprojected
lon, lats. Bounds are given in geographic coordinates as
(xmin, ymin, xmax, ymax).
Size is... | 1.808148 | 1.806943 | 1.000667 |
min_point = 'ST_MakePoint(%.12f, %.12f)' % (bounds[0], bounds[1])
max_point = 'ST_MakePoint(%.12f, %.12f)' % (bounds[2], bounds[3])
bbox_no_srid = 'ST_MakeBox2D(%s, %s)' % (min_point, max_point)
bbox = 'ST_SetSrid(%s, %d)' % (bbox_no_srid, srid)
bbox_filter = \
'((%(col)s && %(bbox)s) ... | 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
means that if the box or polygon is completely within the other, then
st_ove... | 2.209101 | 2.236792 | 0.987621 |
sources = parse_source_data(query_cfg)
queries_generator = make_queries_generator(
sources, template_path, reload_templates)
return DataFetcher(
postgresql_conn_info, queries_generator, io_pool) | 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. | 4.068848 | 4.529128 | 0.898373 |
assert parent is not None, \
"Parent tile must be provided and not None to make a metatile."
if len(tiles) == 0:
return []
if date_time is None:
date_time = gmtime()[0:6]
layer = tiles[0]['layer']
buf = StringIO.StringIO()
with zipfile.ZipFile(buf, mode='w') as ... | def make_multi_metatile(parent, tiles, date_time=None) | Make a metatile containing a list of tiles all having the same layer,
with coordinates relative to the given parent. Set date_time to a 6-tuple
of (year, month, day, hour, minute, second) to set the timestamp for
members. Otherwise the current wall clock time is used. | 3.424563 | 3.294612 | 1.039444 |
if a.zoom < b.zoom:
b = b.zoomTo(a.zoom).container()
elif a.zoom > b.zoom:
a = a.zoomTo(b.zoom).container()
while a.row != b.row or a.column != b.column:
a = a.zoomBy(-1).container()
b = b.zoomBy(-1).container()
# by this point a == b.
return a | 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. | 3.571378 | 2.987128 | 1.195589 |
parent = None
for t in tiles:
if parent is None:
parent = t
else:
parent = common_parent(parent, t)
return parent | def _parent_tile(tiles) | Find the common parent tile for a sequence of tiles. | 3.464434 | 2.654801 | 1.304969 |
groups = defaultdict(list)
for tile in tiles:
key = tile['layer']
groups[key].append(tile)
metatiles = []
for group in groups.itervalues():
parent = _parent_tile(t['coord'] for t in group)
metatiles.extend(make_multi_metatile(parent, group, date_time))
return ... | 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 None to use the current time. | 4.013924 | 3.420928 | 1.173344 |
ext = fmt.extension
if offset is None:
tile_name = '0/0/0.%s' % ext
else:
tile_name = '%d/%d/%d.%s' % (offset.zoom, offset.column, offset.row,
ext)
with zipfile.ZipFile(io, mode='r') as zf:
if tile_name in zf.namelist():
ret... | def extract_metatile(io, fmt, offset=None) | Extract the tile at the given offset (defaults to 0/0/0) and format from
the metatile in the file-like object io. | 2.661887 | 2.440129 | 1.09088 |
names_1 = set(zip_1.namelist())
names_2 = set(zip_2.namelist())
if names_1 != names_2:
return False
for n in names_1:
bytes_1 = zip_1.read(n)
bytes_2 = zip_2.read(n)
if bytes_1 != bytes_2:
return False
return True | 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. | 1.756386 | 1.655247 | 1.061102 |
try:
buf_1 = StringIO.StringIO(tile_data_1)
buf_2 = StringIO.StringIO(tile_data_2)
with zipfile.ZipFile(buf_1, mode='r') as zip_1:
with zipfile.ZipFile(buf_2, mode='r') as zip_2:
return _metatile_contents_equal(zip_1, zip_2)
except (StandardError, zipf... | 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. | 3.175475 | 2.980545 | 1.065401 |
return dict(
z=int_if_exact(coord.zoom),
x=int_if_exact(coord.column),
y=int_if_exact(coord.row),
) | def make_coord_dict(coord) | helper function to make a dict from a coordinate for logging | 4.02433 | 3.776985 | 1.065487 |
features_by_layer = {}
for feature_layer in feature_layers:
layer_name = feature_layer['name']
features = feature_layer['features']
features_by_layer[layer_name] = features
return features_by_layer | 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 | 1.957736 | 1.876 | 1.043569 |
groups = []
for i in range(len(self.zoom_range_items)):
groups.append([])
# first group the coordinates based on their queue
for coord in coords:
for i, zri in enumerate(self.zoom_range_items):
toi_match = zri.in_toi is None or \
... | 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 message. | 4.560393 | 4.222362 | 1.080057 |
parent = None
for coord in coords:
assert parent_zoom <= coord.zoom
coord_parent = coord.zoomTo(parent_zoom).container()
if parent is None:
parent = coord_parent
else:
assert parent == coord_parent
assert parent is not None, 'No coords?'
retur... | def common_parent(coords, parent_zoom) | Return the common parent for coords
Also check that all coords do indeed share the same parent coordinate. | 4.003246 | 3.88588 | 1.030203 |
assert isinstance(coord, Coordinate)
coord = coord.container()
return Tile(int(coord.zoom), int(coord.column), int(coord.row)) | def convert_coord_object(coord) | Convert ModestMaps.Core.Coordinate -> raw_tiles.tile.Tile | 5.855038 | 3.866125 | 1.514446 |
assert isinstance(tile, Tile)
return Coordinate(zoom=tile.z, column=tile.x, row=tile.y) | def unconvert_coord_object(tile) | Convert rawr_tiles.tile.Tile -> ModestMaps.Core.Coordinate | 4.155983 | 3.508317 | 1.184609 |
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 = zipfile.ZipInfo(fmt_data.name, date_time)
z.writestr(zip_info, fmt_data.data, zipfile.ZIP_DEFLATED... | def make_rawr_zip_payload(rawr_tile, date_time=None) | make a zip file from the rawr tile formatted data | 2.60798 | 2.555312 | 1.020611 |
# 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, which should be safe to store in
# RAM.
from tilequeue.query.common import Table
from io import BytesIO
... | def unpack_rawr_zip_payload(table_sources, payload) | unpack a zipfile and turn it into a callable "tables" object. | 7.877991 | 7.529075 | 1.046342 |
from time import sleep
backoff_interval = 1
backoff_factor = 2
for try_counter in xrange(0, num_tries):
failed_messages = self.send_without_retry(payloads)
# success!
if not failed_messages:
payloads = []
bre... | def send(self, payloads, logger, num_tries=5) | Enqueue payloads to the SQS queue, retrying failed messages with
exponential backoff. | 4.017818 | 3.823894 | 1.050714 |
resp = self.sqs_client.receive_message(
QueueUrl=self.queue_url,
MaxNumberOfMessages=1,
AttributeNames=('SentTimestamp',),
WaitTimeSeconds=self.recv_wait_time_seconds,
)
if resp['ResponseMetadata']['HTTPStatusCode'] != 200:
rai... | def read(self) | read a single message from the queue | 2.538161 | 2.439846 | 1.040295 |
self.sqs_client.delete_message(
QueueUrl=self.queue_url,
ReceiptHandle=msg_handle.handle,
) | def done(self, msg_handle) | acknowledge completion of message | 3.582879 | 3.361649 | 1.06581 |
# 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:
get_options['IfNoneMatch'] = self.etag
try:
r... | def tiles_of_interest(self) | conditionally get the toi from s3 | 3.513704 | 3.194893 | 1.099788 |
# returns tuple of (handle, error), either of which can be None
track_result = msg_tracker.done(coord_handle)
queue_handle = track_result.queue_handle
if not queue_handle:
return None, None
tile_queue = queue_mapper.get_queue(queue_handle.queue_id)
assert tile_queue, \
'M... | def _ack_coord_handle(
coord, coord_handle, queue_mapper, msg_tracker, timing_state,
tile_proc_logger, stats_handler) | share code for acknowledging a coordinate | 3.058302 | 3.045681 | 1.004144 |
rounded = round(num)
delta = abs(num - rounded)
if delta < eps:
return int(rounded)
else:
return int(resolution(num)) | def _snapping_round(num, eps, resolution) | Return num snapped to within eps of an integer, or int(resolution(num)). | 5.10112 | 2.963173 | 1.721506 |
if shape.geom_type == 'LineString':
return [shape]
elif shape.geom_type == 'MultiLineString':
return shape.geoms
elif shape.geom_type == 'GeometryCollection':
lines = []
for geom in shape.geoms:
lines.extend(_explode_lines(geom))
return lines
... | def _explode_lines(shape) | Return a list of LineStrings which make up the shape. | 2.029773 | 1.649335 | 1.230662 |
lines = _explode_lines(shape)
if len(lines) == 1:
return lines[0]
else:
return MultiLineString(lines) | def _lines_only(shape) | Extract the lines (LineString, MultiLineString) from any geometry. We
expect the input to be mostly lines, such as the result of an intersection
between a line and a polygon. The main idea is to remove points, and any
other geometry which might throw a wrench in the works. | 3.845772 | 2.858893 | 1.345196 |
assert shape.geom_type in ('Polygon', 'MultiPolygon')
if shape.geom_type == 'Polygon':
return orient(shape)
else:
polys = []
for geom in shape.geoms:
polys.append(orient(geom))
return MultiPolygon(polys) | def _orient(shape) | The Shapely version of the orient function appears to only work on
Polygons, and fails on MultiPolygons. This is a quick wrapper to allow
orienting of either. | 2.580954 | 2.26767 | 1.138153 |
self.coordinates = []
self.index = []
self.position = 0
self.lastX = 0
self.lastY = 0
self.isPoly = False
self.isPoint = True;
self.dropped = 0;
self.first = True
# Used for exception strings
self._current_strin... | def parseGeometry(self, geometry) | A factory method for creating objects of the correct OpenGIS type. | 11.484156 | 11.513235 | 0.997474 |
# Need to check endianess here!
endianness = reader.unpack_byte()
if endianness == 0:
reader.setEndianness('XDR')
elif endianness == 1:
reader.setEndianness('NDR')
else:
raise ExceptionWKBParser("Invalid endianness in WKB form... | def _dispatchNextType(self,reader) | Read a type id from the binary stream (reader) and call the correct method to parse it. | 5.958612 | 5.880015 | 1.013367 |
if not buffer_cfg:
return bounds
format_buffer_cfg = buffer_cfg.get(format.extension)
if format_buffer_cfg is None:
return bounds
geometry_type = normalize_geometry_type(geometry_type)
per_layer_cfg = format_buffer_cfg.get('layer', {}).get(layer_name)
if per_layer_cfg is... | def calc_buffered_bounds(
format, bounds, meters_per_pixel_dim, layer_name, geometry_type,
buffer_cfg) | Calculate the buffered bounds per format per layer based on config. | 2.147363 | 2.068911 | 1.03792 |
polys = []
for poly in shape.geoms:
if tile_bounds.intersects(poly):
if not clip_bounds.contains(poly):
poly = clip_bounds.intersection(poly)
# the intersection operation can make the resulting polygon
# invalid. including it in a MultiPolygon w... | def _intersect_multipolygon(shape, tile_bounds, clip_bounds) | Return the parts of the MultiPolygon shape which overlap the tile_bounds,
each clipped to the clip_bounds. This can be used to extract only the
parts of a multipolygon which are actually visible in the tile, while
keeping those parts which extend beyond the tile clipped to avoid huge
polygons. | 3.632454 | 3.547003 | 1.024091 |
shape_buf_bounds = geometry.box(*buffer_padded_bounds)
if not shape_buf_bounds.intersects(shape):
return None
if is_clipped:
# now we know that we should include the geometry, but
# if the geometry should be clipped, we'll clip to the
# layer-specific padded bounds
... | def _clip_shape(shape, buffer_padded_bounds, is_clipped, clip_factor) | Return the shape clipped to a clip_factor expansion of buffer_padded_bounds
if is_clipped is True. Otherwise return the original shape, or None if the
shape does not intersect buffer_padded_bounds at all.
This is used to reduce the size of the geometries which are encoded in the
tiles by removing thing... | 3.758218 | 3.566989 | 1.053611 |
if self._now is None:
# Compute the current time only once per instance
self._now = datetime.utcnow()
return self._now | def now(self) | Capture time. | 5.407541 | 5.200904 | 1.039731 |
expiration = getattr(settings, 'OAUTH_ID_TOKEN_EXPIRATION', 30)
expires = self.now + timedelta(seconds=expiration)
return timegm(expires.utctimetuple()) | def claim_exp(self, data) | Required expiration time. | 5.006607 | 4.746584 | 1.054781 |
# Validate URLs
for url_to_validate in (url, redirect_uri):
try:
URLValidator()(url_to_validate)
except ValidationError:
raise CommandError("URLs provided are invalid. Please provide valid application and redirect URLs.")
# Valida... | def _clean_required_args(self, url, redirect_uri, client_type) | Validate and clean the command's arguments.
Arguments:
url (str): Client's application URL.
redirect_uri (str): Client application's OAuth2 callback URI.
client_type (str): Client's type, indicating whether the Client application
is capable of maintaining the... | 3.05426 | 2.856003 | 1.069418 |
for key in ('username', 'client_name', 'client_id', 'client_secret', 'trusted', 'logout_uri'):
value = options.get(key)
if value is not None:
self.fields[key] = value
username = self.fields.pop('username', None)
if username is not None:
... | def _parse_options(self, options) | Parse the command's options.
Arguments:
options (dict): Options with which the command was called.
Raises:
CommandError, if a user matching the provided username does not exist. | 3.211727 | 3.163229 | 1.015332 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.