code stringlengths 51 2.38k | docstring stringlengths 4 15.2k |
|---|---|
def empty_over_span(self, time, duration):
for seg in self.segments:
if seg.comp_location_in_seconds >= time and\
seg.comp_location_in_seconds < time + duration:
return False
elif seg.comp_location_in_seconds + seg.duration_in_seconds >= time and\
... | Helper method that tests whether composition contains any segments
at a given time for a given duration.
:param time: Time (in seconds) to start span
:param duration: Duration (in seconds) of span
:returns: `True` if there are no segments in the composition that overlap the span starti... |
def write(self, auth, resource, value, options={}, defer=False):
return self._call('write', auth, [resource, value, options], defer) | Writes a single value to the resource specified.
Args:
auth: cik for authentication.
resource: resource to write to.
value: value to write
options: options. |
def now(tzinfo=True):
if dj_now:
return dj_now()
if tzinfo:
return datetime.utcnow().replace(tzinfo=utc)
return datetime.now() | Return an aware or naive datetime.datetime, depending on settings.USE_TZ. |
def detect_encoding(value):
if six.PY2:
null_pattern = tuple(bool(ord(char)) for char in value[:4])
else:
null_pattern = tuple(bool(char) for char in value[:4])
encodings = {
(0, 0, 0, 1): 'utf-32-be',
(0, 1, 0, 1): 'utf-16-be',
(1, 0, 0, 0): 'utf-32-le',
(1, ... | Returns the character encoding for a JSON string. |
def _create_training_directories():
logger.info('Creating a new training folder under %s .' % base_dir)
os.makedirs(model_dir)
os.makedirs(input_config_dir)
os.makedirs(output_data_dir)
_write_json({}, hyperparameters_file_dir)
_write_json({}, input_data_config_file_dir)
host_name = socket.g... | Creates the directory structure and files necessary for training under the base path |
def get_institution(self, **kwargs):
qualifier = kwargs.get('qualifier', '')
content = kwargs.get('content', '')
if qualifier == 'grantor':
return content
return None | Get the dissertation institution. |
def list_proxy(root_package = 'vlcp'):
proxy_dict = OrderedDict()
pkg = __import__(root_package, fromlist=['_'])
for imp, module, _ in walk_packages(pkg.__path__, root_package + '.'):
m = __import__(module, fromlist = ['_'])
for _, v in vars(m).items():
if v is not None and isins... | Walk through all the sub modules, find subclasses of vlcp.server.module._ProxyModule,
list their default values |
def copy_figure_to_clipboard(figure='gcf'):
try:
import pyqtgraph as _p
if figure is 'gcf': figure = _s.pylab.gcf()
path = _os.path.join(_s.settings.path_home, "clipboard.png")
figure.savefig(path)
_p.QtGui.QApplication.instance().clipboard().setImage(_p.QtGui.QImage(path))
... | Copies the specified figure to the system clipboard. Specifying 'gcf'
will use the current figure. |
def add(self, recipients):
if recipients:
if isinstance(recipients, str):
self._recipients.append(
Recipient(address=recipients, parent=self._parent,
field=self._field))
elif isinstance(recipients, Recipient):
... | Add the supplied recipients to the exiting list
:param recipients: list of either address strings or
tuples (name, address) or dictionary elements
:type recipients: list[str] or list[tuple] or list[dict] |
def create_highlight(self, artist):
highlight = copy.copy(artist)
highlight.set(color=self.highlight_color, mec=self.highlight_color,
lw=self.highlight_width, mew=self.highlight_width)
artist.axes.add_artist(highlight)
return highlight | Create a new highlight for the given artist. |
def showEvent(self, event):
super(CodeEdit, self).showEvent(event)
self.panels.refresh() | Overrides showEvent to update the viewport margins |
def browsers(self, browser=None, browser_version=None, device=None, os=None, os_version=None):
response = self.execute('GET', '/screenshots/browsers.json')
for key, value in list(locals().items()):
if key in ('self', 'response') or not value:
continue
response = [... | Returns list of available browsers & OS. |
def get_bounce(bounce_id, api_key=None, secure=None, test=None,
**request_args):
return _default_bounce.get(bounce_id, api_key=api_key, secure=secure,
test=test, **request_args) | Get a single bounce.
:param bounce_id: The bounce's id. Get the id with :func:`get_bounces`.
:param api_key: Your Postmark API key. Required, if `test` is not `True`.
:param secure: Use the https scheme for the Postmark API.
Defaults to `True`
:param test: Use the Postmark Test API. Defaults to... |
def selectisnot(table, field, value, complement=False):
return selectop(table, field, value, operator.is_not, complement=complement) | Select rows where the given field `is not` the given value. |
def match(self, row):
for condition in self._conditions:
if condition.match(row):
return True
return False | Returns True if the row matches one or more child conditions. Returns False otherwise.
:param dict row: The row.
:rtype: bool |
def as_set(self, include_weak=False):
rv = set(self._strong)
if include_weak:
rv.update(self._weak)
return rv | Convert the `ETags` object into a python set. Per default all the
weak etags are not part of this set. |
def copy(self):
model = self.__class__(self._database)
model._limits_lower = dict(self._limits_lower)
model._limits_upper = dict(self._limits_upper)
model._reaction_set = set(self._reaction_set)
model._compound_set = set(self._compound_set)
return model | Return copy of model |
def spit(path, txt, encoding='UTF-8', append=False):
mode = 'a' if append else 'w'
with io.open(path, mode, encoding=encoding) as f:
f.write(txt)
return txt | Write a unicode string `txt` to file `path`.
By default encoded as UTF-8 and truncates the file prior to writing
Parameters
----------
path : str
File path to file on disk
txt : unicode
Text content to write to file
encoding : str, default `UTF-8`, optional
Encoding of... |
def get_name(self, tag):
name = super(functionTagProcessor, self).get_name(tag)
if self.include_function_signatures:
func_args = tag.findChild('arglist')
if func_args and len(func_args.contents):
name += func_args.contents[0]
ret_type = tag.findChild('... | Override. Extract a representative "name" from a function tag.
get_name's output can be controlled through keyword arguments that are
provided when initializing a functionTagProcessor. For instance,
function arguments and return types can be included by passing
include_function_signatur... |
def create_element(self, ns, name):
elem = self._node.makeelement('{%s}%s' % (SLDNode._nsmap[ns], name), nsmap=SLDNode._nsmap)
self._node.append(elem)
return getattr(self, name) | Create an element as a child of this SLDNode.
@type ns: string
@param ns: The namespace of the new element.
@type name: string
@param name: The name of the new element.
@rtype: L{SLDNode}
@return: The wrapped node, in the parent's property class. This will
... |
def write_yaml(filename, content):
y = _yaml.dump(content, indent=4, default_flow_style=False)
if y:
return write_file(filename, y) | Writes YAML files
:param filename:
The full path to the YAML file
:param content:
The content to dump
:returns:
The size written |
def subscribe(self, topic=b''):
self.sockets[zmq.SUB].setsockopt(zmq.SUBSCRIBE, topic)
poller = self.pollers[zmq.SUB]
return poller | subscribe to the SUB socket, to listen for incomming variables, return a stream that can be listened to. |
def get_context_data(self, **kwargs):
context = super(ScheduleXmlView, self).get_context_data(**kwargs)
if self.request.GET.get('render_description', None) == '1':
context['render_description'] = True
else:
context['render_description'] = False
return context | Allow adding a 'render_description' parameter |
def get_article(self, url=None, article_id=None, max_pages=25):
query_params = {}
if url is not None:
query_params['url'] = url
if article_id is not None:
query_params['article_id'] = article_id
query_params['max_pages'] = max_pages
url = self._generate_ur... | Send a GET request to the `parser` endpoint of the parser API to get
back the representation of an article.
The article can be identified by either a URL or an id that exists
in Readability.
Note that either the `url` or `article_id` param should be passed.
:param url (optiona... |
def _init_training(self):
if self.check:
self.backprop = CheckedBackprop(self.network, self.problem.cost)
else:
self.backprop = BatchBackprop(self.network, self.problem.cost)
self.momentum = Momentum()
self.decent = GradientDecent()
self.decay = WeightDeca... | Classes needed during training. |
def setup_request_sessions(self):
self.req_session = requests.Session()
self.req_session.headers.update(self.headers) | Sets up a requests.Session object for sharing headers across API requests. |
def peek(self, length):
return self.string[self.pos:self.pos + length] | Get a number of characters without advancing the scan pointer.
>>> s = Scanner("test string")
>>> s.peek(7)
'test st'
>>> s.peek(7)
'test st' |
def read_csv(self, dtype=False, parse_dates=True, *args, **kwargs):
import pandas
t = self.resolved_url.get_resource().get_target()
kwargs = self._update_pandas_kwargs(dtype, parse_dates, kwargs)
return pandas.read_csv(t.fspath, *args, **kwargs) | Fetch the target and pass through to pandas.read_csv
Don't provide the first argument of read_csv(); it is supplied internally. |
def AddHeadwayPeriodObject(self, headway_period, problem_reporter):
warnings.warn("No longer supported. The HeadwayPeriod class was renamed to "
"Frequency, and all related functions were renamed "
"accordingly.", DeprecationWarning)
self.AddFrequencyObject(frequency, problem... | Deprecated. Please use AddFrequencyObject instead. |
def make_fake_data(g, fac=1.0):
if hasattr(g, 'keys'):
if not isinstance(g, BufferDict):
g = BufferDict(g)
return BufferDict(g, buf=make_fake_data(g.buf, fac))
else:
g_shape = numpy.shape(g)
g_flat = numpy.array(g).flat
zero = numpy.zeros(len(g_flat), float)
... | Make fake data based on ``g``.
This function replaces the |GVar|\s in ``g`` by new |GVar|\s with similar
means and a similar covariance matrix, but multiplied by ``fac**2`` (so
standard deviations are ``fac`` times smaller). The changes are random.
The function was designed to create fake data for tes... |
def _must_be_deleted(local_path, r_st):
if not os.path.lexists(local_path):
return True
l_st = os.lstat(local_path)
if S_IFMT(r_st.st_mode) != S_IFMT(l_st.st_mode):
return True
return False | Return True if the remote correspondent of local_path has to be deleted.
i.e. if it doesn't exists locally or if it has a different type from the remote one. |
def parse_broken_json(json_text: str) -> dict:
json_text = json_text.replace(":", ": ")
json_dict = yaml.load(json_text)
return json_dict | Parses broken JSON that the standard Python JSON module cannot parse.
Ex: {success:true}
Keys do not contain quotes and the JSON cannot be parsed using the regular json encoder.
YAML happens to be a superset of JSON and can parse json without quotes. |
def methods(self) -> 'PrettyDir':
return PrettyDir(
self.obj,
[
pattr
for pattr in self.pattrs
if category_match(pattr.category, AttrCategory.FUNCTION)
],
) | Returns all methods of the inspected object.
Note that "methods" can mean "functions" when inspecting a module. |
def unique(lst):
seen = set()
def make_seen(x):
seen.add(x)
return x
return [make_seen(x) for x in lst if x not in seen] | Return unique elements
:class:`pandas.unique` and :class:`numpy.unique` cast
mixed type lists to the same type. They are faster, but
some times we want to maintain the type.
Parameters
----------
lst : list-like
List of items
Returns
-------
out : list
Unique items... |
def draw_identity_line(ax=None, dynamic=True, **kwargs):
ax = ax or plt.gca()
if 'c' not in kwargs and 'color' not in kwargs:
kwargs['color'] = LINE_COLOR
if 'alpha' not in kwargs:
kwargs['alpha'] = 0.5
identity, = ax.plot([],[], **kwargs)
def callback(ax):
xlim = ax.get_xlim... | Draws a 45 degree identity line such that y=x for all points within the
given axes x and y limits. This function also registeres a callback so
that as the figure is modified, the axes are updated and the line remains
drawn correctly.
Parameters
----------
ax : matplotlib Axes, default: None
... |
def _proc_dihedral(self):
main_axis, rot = max(self.rot_sym, key=lambda v: v[1])
self.sch_symbol = "D{}".format(rot)
mirror_type = self._find_mirror(main_axis)
if mirror_type == "h":
self.sch_symbol += "h"
elif not mirror_type == "":
self.sch_symbol += "d" | Handles dihedral group molecules, i.e those with intersecting R2 axes
and a main axis. |
def peak_generation_per_technology_and_weather_cell(self):
peak_generation = defaultdict(float)
for gen in self.generators:
if hasattr(gen, 'weather_cell_id'):
if (gen.type, gen.weather_cell_id) in peak_generation.keys():
peak_generation[gen.type, gen.weat... | Peak generation of each technology and the
corresponding weather cell in the grid
Returns
-------
:pandas:`pandas.Series<series>`
Peak generation index by technology |
def parse_substitution_from_list(list_rep):
if type(list_rep) is not list:
raise SyntaxError('Substitution must be a list')
if len(list_rep) < 2:
raise SyntaxError('Substitution must be a list of size 2')
pattern = list_rep[0]
replacement = list_rep[1]
is_multiline = False
if (le... | Parse a substitution from the list representation in the config file. |
def symmetry_reduce(tensors, structure, tol=1e-8, **kwargs):
sga = SpacegroupAnalyzer(structure, **kwargs)
symmops = sga.get_symmetry_operations(cartesian=True)
unique_mapping = TensorMapping([tensors[0]], [[]], tol=tol)
for tensor in tensors[1:]:
is_unique = True
for unique_tensor, symm... | Function that converts a list of tensors corresponding to a structure
and returns a dictionary consisting of unique tensor keys with symmop
values corresponding to transformations that will result in derivative
tensors from the original list
Args:
tensors (list of tensors): list of Tensor objec... |
def create_comment(self, text):
return DashboardComment.get_or_create(self._issue_or_pr, self._header, text) | Mimic issue API, so we can use it everywhere.
Return dashboard comment. |
def extract_cpio (archive, compression, cmd, verbosity, interactive, outdir):
cmdlist = [util.shell_quote(cmd), '--extract', '--make-directories',
'--preserve-modification-time']
if sys.platform.startswith('linux') and not cmd.endswith('bsdcpio'):
cmdlist.extend(['--no-absolute-filenames',
... | Extract a CPIO archive. |
def enumerate_spans(sentence: List[T],
offset: int = 0,
max_span_width: int = None,
min_span_width: int = 1,
filter_function: Callable[[List[T]], bool] = None) -> List[Tuple[int, int]]:
max_span_width = max_span_width or len(sentence)
... | Given a sentence, return all token spans within the sentence. Spans are `inclusive`.
Additionally, you can provide a maximum and minimum span width, which will be used
to exclude spans outside of this range.
Finally, you can provide a function mapping ``List[T] -> bool``, which will
be applied to every... |
def __decode_timehex(self, timehex):
year, month, day, hour, minute, second = unpack("6B", timehex)
year += 2000
d = datetime(year, month, day, hour, minute, second)
return d | timehex string of six bytes |
def paths(self):
paths = traversal.closed_paths(self.entities,
self.vertices)
return paths | Sequence of closed paths, encoded by entity index.
Returns
---------
paths: (n,) sequence of (*,) int referencing self.entities |
def fork(executable, args=(), env={}, path=None, timeout=3600):
d = defer.Deferred()
p = ProcessProtocol(d, timeout)
reactor.spawnProcess(p, executable, (executable,)+tuple(args), env, path)
return d | fork
Provides a deferred wrapper function with a timeout function
:param executable: Executable
:type executable: str.
:param args: Tupple of arguments
:type args: tupple.
:param env: Environment dictionary
:type env: dict.
:param timeout: Kill the child process if timeout is exceeded
... |
def add_to_linestring(position_data, kml_linestring):
global kml
position_data[2] += float(args.aoff)
kml_linestring.coords.addcoordinates([position_data]) | add a point to the kml file |
def reset(self):
self._variables_shim = {}
self._executable = None
self._bitstrings = None
self.status = 'connected' | Reset the Quantum Abstract Machine to its initial state, which is particularly useful
when it has gotten into an unwanted state. This can happen, for example, if the QAM
is interrupted in the middle of a run. |
def human_repr(self):
return urlunsplit(
SplitResult(
self.scheme,
self._make_netloc(
self.user, self.password, self.host, self._val.port, encode=False
),
self.path,
self.query_string,
... | Return decoded human readable string for URL representation. |
def CheckHeader(context, header, include_quotes = '<>', language = None):
prog_prefix, hdr_to_check = \
createIncludesFromHeaders(header, 1, include_quotes)
res = SCons.Conftest.CheckHeader(context, hdr_to_check, prog_prefix,
language = language,
... | A test for a C or C++ header file. |
def on_btn_add_fit(self, event):
if self.auto_save.GetValue():
self.current_fit = self.add_fit(self.s, None, None, None, saved=True)
else:
self.current_fit = self.add_fit(self.s, None, None, None, saved=False)
self.generate_warning_text()
self.update_warning_box()... | add a new interpretation to the current specimen
Parameters
----------
event : the wx.ButtonEvent that triggered this function
Alters
------
pmag_results_data |
def mark_module_skipped(self, module_name):
try:
del self.modules[module_name]
except KeyError:
pass
self.skip_modules[module_name] = True | Skip reloading the named module in the future |
def DeleteInstanceTags(r, instance, tags, dry_run=False):
query = {
"tag": tags,
"dry-run": dry_run,
}
return r.request("delete", "/2/instances/%s/tags" % instance, query=query) | Deletes tags from an instance.
@type instance: str
@param instance: instance to delete tags from
@type tags: list of str
@param tags: tags to delete
@type dry_run: bool
@param dry_run: whether to perform a dry run |
def price_oscillator(data, short_period, long_period):
catch_errors.check_for_period_error(data, short_period)
catch_errors.check_for_period_error(data, long_period)
ema_short = ema(data, short_period)
ema_long = ema(data, long_period)
po = ((ema_short - ema_long) / ema_long) * 100
return po | Price Oscillator.
Formula:
(short EMA - long EMA / long EMA) * 100 |
def get_remote_port(self, tlv_data):
ret, parsed_val = self._check_common_tlv_format(
tlv_data, "\n", "Port Description TLV")
if not ret:
return None
return parsed_val[1].strip() | Returns Remote Port from the TLV. |
def symlink_exists(self, symlink):
if not isinstance(symlink, basestring):
raise TypeError("symlink can only be an instance of type basestring")
exists = self._call("symlinkExists",
in_p=[symlink])
return exists | Checks whether a symbolic link exists in the guest.
in symlink of type str
Path to the alleged symbolic link. Guest path style.
return exists of type bool
Returns @c true if the symbolic link exists. Returns @c false if it
does not exist, if the file system object... |
def end_subsegment(self, end_time=None):
subsegment = self.get_trace_entity()
if self._is_subsegment(subsegment):
subsegment.close(end_time)
self._local.entities.pop()
return True
else:
log.warning("No subsegment to end.")
return False | End the current active segment. Return False if there is no
subsegment to end.
:param int end_time: epoch in seconds. If not specified the current
system time will be used. |
def respond(self):
response = self.req.server.wsgi_app(self.env, self.start_response)
try:
for chunk in filter(None, response):
if not isinstance(chunk, six.binary_type):
raise ValueError('WSGI Applications must yield bytes')
self.write(chu... | Process the current request.
From :pep:`333`:
The start_response callable must not actually transmit
the response headers. Instead, it must store them for the
server or gateway to transmit only after the first
iteration of the application return value that yield... |
def find_matching_bracket_position(self, start_pos=None, end_pos=None):
for A, B in '()', '[]', '{}', '<>':
if self.current_char == A:
return self.find_enclosing_bracket_right(A, B, end_pos=end_pos) or 0
elif self.current_char == B:
return self.find_enclos... | Return relative cursor position of matching [, (, { or < bracket.
When `start_pos` or `end_pos` are given. Don't look past the positions. |
def _lengstr(obj):
n = leng(obj)
if n is None:
r = ''
elif n > _len(obj):
r = ' leng %d!' % n
else:
r = ' leng %d' % n
return r | Object length as a string. |
def modify_parameters(self, modifier_function):
baseline_parameters = self.baseline.parameters
baseline_parameters_copy = copy.deepcopy(baseline_parameters)
reform_parameters = modifier_function(baseline_parameters_copy)
if not isinstance(reform_parameters, ParameterNode):
re... | Make modifications on the parameters of the legislation
Call this function in `apply()` if the reform asks for legislation parameter modifications.
:param modifier_function: A function that takes an object of type :any:`ParameterNode` and should return an object of the same type. |
def update_task_redundancy(config, task_id, redundancy):
if task_id is None:
msg = ("Are you sure you want to update all the tasks redundancy?")
if click.confirm(msg):
res = _update_tasks_redundancy(config, task_id, redundancy)
click.echo(res)
else:
click.... | Update task redudancy for a project. |
def update_orders(self, market_id, instructions, customer_ref=None):
return self.make_api_request(
'Sports',
'updateOrders',
utils.get_kwargs(locals()),
model=models.UpdateExecutionReport,
) | Update non-exposure changing fields.
:param str market_id: The market id these orders are to be placed on
:param list instructions: List of `UpdateInstruction` objects
:param str customer_ref: Optional order identifier string |
def invalidate(self, key):
if key not in self.data:
return
del self.data[key]
for cname in self.components:
if key in self.depends[cname]:
for downstream_key in self.provides[cname]:
self.invalidate(downstream_key) | Remove the given data item along with all items that depend on it in the graph. |
def get_job_asset_url(self, job_id, filename):
return 'https://saucelabs.com/rest/v1/{}/jobs/{}/assets/{}'.format(
self.client.sauce_username, job_id, filename) | Get details about the static assets collected for a specific job. |
def _wrap_stream_errors(callable_):
_patch_callable_name(callable_)
@general_helpers.wraps(callable_)
def error_remapped_callable(*args, **kwargs):
try:
result = callable_(*args, **kwargs)
return _StreamingResponseIterator(result)
except grpc.RpcError as exc:
... | Wrap errors for Unary-Stream and Stream-Stream gRPC callables.
The callables that return iterators require a bit more logic to re-map
errors when iterating. This wraps both the initial invocation and the
iterator of the return value to re-map errors. |
def from_json(cls, json_obj):
if isinstance(json_obj, str):
json_obj = json.loads(json_obj)
time = None
value = None
if cls.TIME_FIELD_NAME in json_obj:
time = json_obj[cls.TIME_FIELD_NAME]
else:
raise InvalidMetricError("{field} must be presen... | Build a MetricResponse from JSON.
:param json_obj: JSON data representing a Cube Metric.
:type json_obj: `String` or `json`
:throws: `InvalidMetricError` when any of {type,time,data} fields are
not present in json_obj. |
def make_image(location, size, fmt):
if not os.path.isabs(location):
return ''
if not os.path.isdir(os.path.dirname(location)):
return ''
if not __salt__['cmd.retcode'](
'qemu-img create -f {0} {1} {2}M'.format(
fmt,
location,
size)... | Create a blank virtual machine image file of the specified size in
megabytes. The image can be created in any format supported by qemu
CLI Example:
.. code-block:: bash
salt '*' qemu_img.make_image /tmp/image.qcow 2048 qcow2
salt '*' qemu_img.make_image /tmp/image.raw 10240 raw |
def blur(dset,fwhm,prefix=None):
if prefix==None:
prefix = nl.suffix(dset,'_blur%.1fmm'%fwhm)
return available_method('blur')(dset,fwhm,prefix) | blurs ``dset`` with given ``fwhm`` runs 3dmerge to blur dataset to given ``fwhm``
default ``prefix`` is to suffix ``dset`` with ``_blur%.1fmm`` |
def artifact2destination(self, artifact, descriptor):
_art = base64.b64decode(artifact)
assert _art[:2] == ARTIFACT_TYPECODE
try:
endpoint_index = str(int(_art[2:4]))
except ValueError:
endpoint_index = str(int(hexlify(_art[2:4])))
entity = self.sourceid[_... | Translate an artifact into a receiver location
:param artifact: The Base64 encoded SAML artifact
:return: |
def extract_geometry(dataset):
alg = vtk.vtkGeometryFilter()
alg.SetInputDataObject(dataset)
alg.Update()
return _get_output(alg) | Extract the outer surface of a volume or structured grid dataset as
PolyData. This will extract all 0D, 1D, and 2D cells producing the
boundary faces of the dataset. |
def lpop(self, key, *, encoding=_NOTSET):
return self.execute(b'LPOP', key, encoding=encoding) | Removes and returns the first element of the list stored at key. |
def copy_current_websocket_context(func: Callable) -> Callable:
if not has_websocket_context():
raise RuntimeError('Attempt to copy websocket context outside of a websocket context')
websocket_context = _websocket_ctx_stack.top.copy()
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> ... | Share the current websocket context with the function decorated.
The websocket context is local per task and hence will not be
available in any other task. This decorator can be used to make
the context available,
.. code-block:: python
@copy_current_websocket_context
async def within... |
def _memory_usage(func, gallery_conf):
if gallery_conf['show_memory']:
from memory_profiler import memory_usage
assert callable(func)
mem, out = memory_usage(func, max_usage=True, retval=True,
multiprocess=True)
mem = mem[0]
else:
out = fun... | Get memory usage of a function call. |
def end_compress(codec, stream):
OPENJP2.opj_end_compress.argtypes = [CODEC_TYPE, STREAM_TYPE_P]
OPENJP2.opj_end_compress.restype = check_error
OPENJP2.opj_end_compress(codec, stream) | End of compressing the current image.
Wraps the openjp2 library function opj_end_compress.
Parameters
----------
codec : CODEC_TYPE
Compressor handle.
stream : STREAM_TYPE_P
Output stream buffer.
Raises
------
RuntimeError
If the OpenJPEG library routine opj_en... |
def read_moc_fits(moc, filename, include_meta=False, **kwargs):
hl = fits.open(filename, mode='readonly', **kwargs)
read_moc_fits_hdu(moc, hl[1], include_meta) | Read data from a FITS file into a MOC.
Any additional keyword arguments are passed to the
astropy.io.fits.open method. |
def _configobj_factory(self,
infile,
raise_errors=True,
list_values=True,
file_error=True,
interpolation=False,
configspec=None,
st... | Factory Method.
Create Configobj instance and register it to self.config.
This method also is used to create configspec instance.
Because configspec instance also is ConfigObj instance. |
def knt2mlt(t):
t = np.atleast_1d(t)
if t.ndim > 1:
raise ValueError("t must be a list or a rank-1 array")
out = []
e = None
for k in range(t.shape[0]):
if t[k] != e:
e = t[k]
count = 0
else:
count += 1
out.append(count)
... | Count multiplicities of elements in a sorted list or rank-1 array.
Minimal emulation of MATLAB's ``knt2mlt``.
Parameters:
t:
Python list or rank-1 array. Must be sorted!
Returns:
out
rank-1 array such that
out[k] = #{ t[i] == t[k] for i < k }
Example:
If ``t = [1, 1, 2, 3, 3, 3]`... |
def list_themes(dark=True):
dark = "dark" if dark else "light"
themes = os.scandir(os.path.join(MODULE_DIR, "colorschemes", dark))
return [t for t in themes if os.path.isfile(t.path)] | List all installed theme files. |
def _match_real(filename, include, exclude, follow, symlinks):
sep = '\\' if util.platform() == "windows" else '/'
if isinstance(filename, bytes):
sep = os.fsencode(sep)
if not filename.endswith(sep) and os.path.isdir(filename):
filename += sep
matched = False
for pattern in include:... | Match real filename includes and excludes. |
def get_converter(self, parameter):
if parameter not in self._converters:
param = self.get_parameter(parameter)
try:
scale = float(param['Scale'])
except KeyError:
scale = 1
def convert(value):
return value * scale
... | Generate unit conversion function for given parameter |
def shuffle_step(entries, step):
answer = []
for i in range(0, len(entries), step):
sub = entries[i:i+step]
shuffle(sub)
answer += sub
return answer | Shuffle the step |
def getIndices(self):
for indexName in self.neograph.nodes.indexes.keys():
indexObject = self.neograph.nodes.indexes.get(indexName)
yield Index(indexName, "vertex", "manual", indexObject)
for indexName in self.neograph.relationships.indexes.keys():
indexObject = self.... | Returns a generator function over all the existing indexes
@returns A generator function over all rhe Index objects |
def delete_object_in_seconds(self, obj, seconds, extra_info=None):
return self.manager.delete_object_in_seconds(self, obj, seconds) | Sets the object in this container to be deleted after the specified
number of seconds.
The 'extra_info' parameter is included for backwards compatibility. It
is no longer used at all, and will not be modified with swiftclient
info, since swiftclient is not used any more. |
def CallDhclient(
interfaces, logger, dhclient_script=None):
logger.info('Enabling the Ethernet interfaces %s.', interfaces)
dhclient_command = ['dhclient']
if dhclient_script and os.path.exists(dhclient_script):
dhclient_command += ['-sf', dhclient_script]
try:
subprocess.check_call(dhclient_comman... | Configure the network interfaces using dhclient.
Args:
interfaces: list of string, the output device names to enable.
logger: logger object, used to write to SysLog and serial port.
dhclient_script: string, the path to a dhclient script used by dhclient. |
def scale_down(self, workers, pods=None):
pods = pods or self._cleanup_terminated_pods(self.pods())
ips = set(urlparse(worker).hostname for worker in workers)
to_delete = [p for p in pods if p.status.pod_ip in ips]
if not to_delete:
return
self._delete_pods(to_delete) | Remove the pods for the requested list of workers
When scale_down is called by the _adapt async loop, the workers are
assumed to have been cleanly closed first and in-memory data has been
migrated to the remaining workers.
Note that when the worker process exits, Kubernetes leaves the ... |
def compute_mask_offsets(shard_id2num_examples):
total_num_examples = sum(shard_id2num_examples)
mask_offsets = []
total_num_examples = 0
for num_examples_in_shard in shard_id2num_examples:
mask_offsets.append(total_num_examples % 100)
total_num_examples += num_examples_in_shard
return mask_offsets | Return the list of offsets associated with each shards.
Args:
shard_id2num_examples: `list[int]`, mapping shard_id=>num_examples
Returns:
mask_offsets: `list[int]`, offset to skip for each of the shard |
def dijkstra(graph, start, end=None):
D = {}
P = {}
Q = _priorityDictionary()
Q[start] = 0
for v in Q:
D[v] = Q[v]
if v == end: break
for w in graph.out_nbrs(v):
edge_id = graph.edge_by_node(v,w)
vwLength = D[v] + graph.edge_data(edge_id)
... | Dijkstra's algorithm for shortest paths
`David Eppstein, UC Irvine, 4 April 2002 <http://www.ics.uci.edu/~eppstein/161/python/>`_
`Python Cookbook Recipe <http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/119466>`_
Find shortest paths from the start node to all nodes nearer than or equal to the en... |
def user(session, uid, ladder_ids=None):
data = get_user(session, uid)
resp = dict(data)
if not ladder_ids:
return resp
resp['ladders'] = {}
for ladder_id in ladder_ids:
if isinstance(ladder_id, str):
ladder_id = lookup_ladder_id(ladder_id)
try:
ladder... | Get all possible user info by name. |
def get_range(self, i):
try:
m = i.match(RE_INT_ITER)
if m:
return self.get_int_range(*m.groups())
m = i.match(RE_CHR_ITER)
if m:
return self.get_char_range(*m.groups())
except Exception:
pass
return None | Check and retrieve range if value is a valid range.
Here we are looking to see if the value is series or range.
We look for `{1..2[..inc]}` or `{a..z[..inc]}` (negative numbers are fine). |
def get_image_command(image):
info = docker_inspect_or_pull(image)
try:
return info['Config']['Cmd']
except KeyError as ke:
raise DockerError('Failed to inspect image: JSON result missing key {}'.format(ke)) | Gets the default command for an image |
def __getTemplate(template_file_name):
with open(template_file_name) as template_file:
template_raw = template_file.read()
template = parse(template_raw)
return template | Get temaplte to save the ranking.
:param template_file_name: path to the template.
:type template_file_name: str.
:return: template for the file.
:rtype: pystache's template. |
def getContainerName(job):
return '--'.join([str(job),
base64.b64encode(os.urandom(9), b'-_').decode('utf-8')])\
.replace("'", '').replace('"', '').replace('_', '') | Create a random string including the job name, and return it. |
def _right(self):
left, _, width, _ = self._extents
return left + width | Index of column following the last column in range |
def put_settings(self, using=None, **kwargs):
return self._get_connection(using).indices.put_settings(index=self._name, **kwargs) | Change specific index level settings in real time.
Any additional keyword arguments will be passed to
``Elasticsearch.indices.put_settings`` unchanged. |
def add_instance(self, name, properties):
if name in self.__instances:
raise NameError(name)
self.__instances[name] = properties | Stores the description of a component instance. The given properties
are stored as is.
:param name: Instance name
:param properties: Instance properties
:raise NameError: Already known instance name |
def bytes_to_int(b, order='big'):
if six.PY2:
_b = b.__class__()
if order != 'little':
b = reversed(b)
if not isinstance(_b, bytearray):
b = six.iterbytes(b)
return sum(c << (i * 8) for i, c in enumerate(b))
return int.from_... | convert bytes to integer |
def open_fastq(in_file):
if objectstore.is_remote(in_file):
return objectstore.open_file(in_file)
else:
return utils.open_gzipsafe(in_file) | open a fastq file, using gzip if it is gzipped |
def as_string(self):
if type(self.instruction) is str:
return self.instruction
if self.action == "FROM" and not isinstance(self.command, six.string_types):
extra = "" if self.extra is NotSpecified else " {0}".format(self.extra)
return "{0} {1}{2}".format(self.action, ... | Return the command as a single string for the docker file |
def update_meta_data_for_state_view(graphical_editor_view, state_v, affects_children=False, publish=True):
from gaphas.item import NW
update_meta_data_for_port(graphical_editor_view, state_v, None)
if affects_children:
update_meta_data_for_name_view(graphical_editor_view, state_v.name_view, publish=... | This method updates the meta data of a state view
:param graphical_editor_view: Graphical Editor view the change occurred in
:param state_v: The state view which has been changed/moved
:param affects_children: Whether the children of the state view have been resized or not
:param publish: Whether to pu... |
def lotus_root_geometry():
a_offset = np.pi / 2
apart = uniform_partition(a_offset,
a_offset + 2 * np.pi * 366. / 360.,
366)
d_offset = 0.35
dpart = uniform_partition(d_offset - 60, d_offset + 60, 2240)
geometry = FanBeamGeometry(apart, dpa... | Tomographic geometry for the lotus root dataset.
Notes
-----
See the article `Tomographic X-ray data of a lotus root filled with
attenuating objects`_ for further information.
See Also
--------
lotus_root_geometry
References
----------
.. _Tomographic X-ray data of a lotus roo... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.