_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q262800 | remove | validation | def remove(group_id, user_id):
"""Remove user from a group."""
group = Group.query.get_or_404(group_id)
user = User.query.get_or_404(user_id)
if group.can_edit(current_user):
try:
group.remove_member(user)
except Exception as e:
flash(str(e), "error")
return redirect(urlparse(request.referrer).path)
flash(_('User %(user_email)s was removed from %(group_name)s group.',
| python | {
"resource": ""
} |
q262801 | accept | validation | def accept(group_id):
"""Accpet pending invitation."""
membership = Membership.query.get_or_404((current_user.get_id(), group_id))
# no permission check, because they are checked during Memberships creating
try:
membership.accept()
except Exception as e:
flash(str(e), 'error')
return redirect(url_for('.invitations', group_id=membership.group.id))
flash(_('You are | python | {
"resource": ""
} |
q262802 | locate_spheres | validation | def locate_spheres(image, feature_rad, dofilter=False, order=(3 ,3, 3),
trim_edge=True, **kwargs):
"""
Get an initial featuring of sphere positions in an image.
Parameters
-----------
image : :class:`peri.util.Image` object
Image object which defines the image file as well as the region.
feature_rad : float
Radius of objects to find, in pixels. This is a featuring radius
and not a real radius, so a better value is frequently smaller
than the real radius (half the actual radius is good). If ``use_tp``
is True, then the twice ``feature_rad`` is passed as trackpy's
``diameter`` keyword.
dofilter : boolean, optional
Whether to remove the background before featuring. Doing so can
often greatly increase the success of initial featuring and
decrease later optimization time. Filtering functions by fitting
the image to a low-order polynomial and featuring the residuals.
In doing so, this will change the mean intensity of the featured
image and hence the good value of ``minmass`` will change when
``dofilter`` is True. Default is False.
order : 3-element tuple, optional
If `dofilter`, the 2+1D Leg Poly approximation to the background
illumination field. Default is (3,3,3).
Other Parameters
----------------
invert : boolean, optional
Whether to invert the image for featuring. Set to True if the
image is dark particles on a bright background. Default is True
minmass : Float or None, optional | python | {
"resource": ""
} |
q262803 | get_initial_featuring | validation | def get_initial_featuring(statemaker, feature_rad, actual_rad=None,
im_name=None, tile=None, invert=True, desc='', use_full_path=False,
featuring_params={}, statemaker_kwargs={}, **kwargs):
"""
Completely optimizes a state from an image of roughly monodisperse
particles.
The user can interactively select the image. The state is periodically
saved during optimization, with different filename for different stages
of the optimization.
Parameters
----------
statemaker : Function
A statemaker function. Given arguments `im` (a
:class:`~peri.util.Image`), `pos` (numpy.ndarray), `rad` (ndarray),
and any additional `statemaker_kwargs`, must return a
:class:`~peri.states.ImageState`. There is an example function in
scripts/statemaker_example.py
feature_rad : Int, odd
The particle radius for featuring, as passed to locate_spheres.
actual_rad : Float, optional
The actual radius of the particles. Default is feature_rad
im_name : string, optional
The file name of the image to load. If not set, it is selected
interactively through Tk.
tile : :class:`peri.util.Tile`, optional
The tile of the raw image to be analyzed. Default is None, the
entire image.
invert : Bool, optional
Whether to invert the image for featuring, as passed to trackpy.
Default is True.
desc : String, optional
A description to be inserted in saved state. The save name will
be, e.g., '0.tif-peri-' + desc + 'initial-burn.pkl'. Default is ''
use_full_path : Bool, optional
Set to True to use the full path name for the image. Default
is False.
featuring_params : Dict, optional
kwargs-like dict of any additional keyword arguments to pass to
``get_initial_featuring``, such as ``'use_tp'`` or ``'minmass'``.
Default is ``{}``.
statemaker_kwargs : Dict, optional
kwargs-like dict of any additional keyword arguments to pass to
the statemaker function. Default is ``{}``.
Other Parameters
----------------
max_mem : Numeric
The maximum additional memory to use for the optimizers, as
passed to optimize.burn. Default is 1e9.
min_rad : Float, optional
The minimum particle radius, as passed to addsubtract.add_subtract.
Particles with a fitted radius smaller than this are identified
as fake and removed. Default is 0.5 * actual_rad.
max_rad : Float, optional
The maximum particle radius, as passed to addsubtract.add_subtract.
Particles with a fitted radius larger than this are identified
as fake and removed. Default is 1.5 * actual_rad, | python | {
"resource": ""
} |
q262804 | feature_from_pos_rad | validation | def feature_from_pos_rad(statemaker, pos, rad, im_name=None, tile=None,
desc='', use_full_path=False, statemaker_kwargs={}, **kwargs):
"""
Gets a completely-optimized state from an image and an initial guess of
particle positions and radii.
The state is periodically saved during optimization, with different
filename for different stages of the optimization. The user can select
the image.
Parameters
----------
statemaker : Function
A statemaker function. Given arguments `im` (a
:class:`~peri.util.Image`), `pos` (numpy.ndarray), `rad` (ndarray),
and any additional `statemaker_kwargs`, must return a
:class:`~peri.states.ImageState`. There is an example function in
scripts/statemaker_example.py
pos : [N,3] element numpy.ndarray.
The initial guess for the N particle positions.
rad : N element numpy.ndarray.
The initial guess for the N particle radii.
im_name : string or None, optional
The filename of the image to feature. Default is None, in which
the user selects the image.
tile : :class:`peri.util.Tile`, optional
A tile of the sub-region of the image to feature. Default is
None, i.e. entire image.
desc : String, optional
A description to be inserted in saved state. The save name will
be, e.g., '0.tif-peri-' + desc + 'initial-burn.pkl'. Default is ''
use_full_path : Bool, optional
Set to True to use the full path name for the image. Default
is False.
statemaker_kwargs : Dict, optional
kwargs-like dict of any additional keyword arguments to pass to
the statemaker function. Default is ``{}``.
Other Parameters
----------------
max_mem : Numeric
The maximum additional memory to use for the optimizers, as
passed to optimize.burn. Default is 1e9.
min_rad : Float, optional
The minimum particle radius, as passed to addsubtract.add_subtract.
Particles with a fitted radius smaller than this are identified
as fake and removed. Default is 0.5 * actual_rad.
max_rad : Float, optional
The maximum particle radius, as passed to addsubtract.add_subtract.
Particles with a fitted radius larger than this are identified
as fake and removed. Default is 1.5 * actual_rad, however you
may find better results if you make this more stringent.
invert : {'guess', True, False}
Whether to invert the image for featuring, as passed to
addsubtract.add_subtract. Default is to guess | python | {
"resource": ""
} |
q262805 | optimize_from_initial | validation | def optimize_from_initial(s, max_mem=1e9, invert='guess', desc='', rz_order=3,
min_rad=None, max_rad=None):
"""
Optimizes a state from an initial set of positions and radii, without
any known microscope parameters.
Parameters
----------
s : :class:`peri.states.ImageState`
The state to optimize. It is modified internally and returned.
max_mem : Numeric, optional
The maximum memory for the optimizer to use. Default is 1e9 (bytes)
invert : Bool or `'guess'`, optional
Set to True if the image is dark particles on a bright
background, False otherwise. Used for add-subtract. The
default is to guess from the state's current particles.
desc : String, optional
An additional description to infix for periodic saving along the
way. Default is the null string ``''``.
rz_order : int, optional
``rz_order`` as passed to opt.burn. Default is 3
min_rad : Float or None, optional
The minimum radius to identify a particles as bad, as passed to
add-subtract. Default is None, which picks half the median radii.
| python | {
"resource": ""
} |
q262806 | get_particles_featuring | validation | def get_particles_featuring(feature_rad, state_name=None, im_name=None,
use_full_path=False, actual_rad=None, invert=True, featuring_params={},
**kwargs):
"""
Combines centroid featuring with the globals from a previous state.
Runs trackpy.locate on an image, sets the globals from a previous state,
calls _translate_particles
Parameters
----------
feature_rad : Int, odd
The particle radius for featuring, as passed to locate_spheres.
state_name : String or None, optional
The name of the initially-optimized state. Default is None,
which prompts the user to select the name interactively
through a Tk window.
im_name : String or None, optional
The name of the new image to optimize. Default is None,
which prompts the user to select the name interactively
through a Tk window.
use_full_path : Bool, optional
Set to True to use the full path of the state instead of
partial path names (e.g. /full/path/name/state.pkl vs
state.pkl). Default is False
actual_rad : Float or None, optional
The initial guess for the particle radii. Default is the median
of the previous state.
invert : Bool
Whether to invert the image for featuring, as passed to
addsubtract.add_subtract and locate_spheres. Set to False
if the image is bright particles on a dark background.
Default is True (dark particles on bright background).
featuring_params : Dict, optional
kwargs-like dict of any additional keyword arguments to pass to
``get_initial_featuring``, such as ``'use_tp'`` or ``'minmass'``.
Default is ``{}``.
Other Parameters
----------------
max_mem : Numeric
The maximum additional memory to use for the optimizers, as
passed to optimize.burn. Default is 1e9.
desc : String, optional
A description to be inserted in saved state. The save name will
be, e.g., '0.tif-peri-' + desc + 'initial-burn.pkl'. Default is ''
min_rad : Float, optional
The minimum particle radius, as passed to addsubtract.add_subtract.
Particles with a fitted radius smaller than this are identified
as fake and removed. Default is 0.5 * actual_rad.
max_rad : Float, optional
The maximum particle radius, as passed to addsubtract.add_subtract.
Particles with a fitted radius larger than this are identified
as fake and removed. Default is 1.5 * actual_rad, however you
may find better results if you make this more stringent.
rz_order : int, optional
If nonzero, the order of an additional augmented rscl(z)
| python | {
"resource": ""
} |
q262807 | _pick_state_im_name | validation | def _pick_state_im_name(state_name, im_name, use_full_path=False):
"""
If state_name or im_name is None, picks them interactively through Tk,
and then sets with or without the full path.
Parameters
----------
state_name : {string, None}
The name of the state. If None, selected through Tk.
im_name : {string, None}
The name of the image. If None, selected through Tk.
use_full_path : Bool, optional
Set to True to return the names as full paths rather than
relative paths. Default is False (relative path).
"""
initial_dir = os.getcwd()
if (state_name is None) or (im_name is None):
wid = tk.Tk()
wid.withdraw()
if state_name is None: | python | {
"resource": ""
} |
q262808 | _translate_particles | validation | def _translate_particles(s, max_mem=1e9, desc='', min_rad='calc',
max_rad='calc', invert='guess', rz_order=0, do_polish=True):
"""
Workhorse for translating particles. See get_particles_featuring for docs.
"""
if desc is not None:
desc_trans = desc + 'translate-particles'
desc_burn = desc + 'addsub_burn'
desc_polish = desc + 'addsub_polish'
else:
desc_trans, desc_burn, desc_polish = [None]*3
RLOG.info('Translate Particles:')
opt.burn(s, mode='do-particles', n_loop=4, fractol=0.1, desc=desc_trans,
max_mem=max_mem, include_rad=False, dowarn=False)
opt.burn(s, mode='do-particles', n_loop=4, fractol=0.05, desc=desc_trans,
max_mem=max_mem, include_rad=True, dowarn=False)
RLOG.info('Start add-subtract')
addsub.add_subtract(s, tries=30, min_rad=min_rad, max_rad=max_rad,
invert=invert)
if desc is not None:
states.save(s, desc=desc + 'translate-addsub')
| python | {
"resource": ""
} |
q262809 | link_zscale | validation | def link_zscale(st):
"""Links the state ``st`` psf zscale with the global zscale"""
# FIXME should be made more generic to other parameters and categories
psf = st.get('psf')
psf.param_dict['zscale'] = psf.param_dict['psf-zscale'] | python | {
"resource": ""
} |
q262810 | finish_state | validation | def finish_state(st, desc='finish-state', invert='guess'):
"""
Final optimization for the best-possible state.
Runs a local add-subtract to capture any difficult-to-feature particles,
then does another set of optimization designed to get to the best
possible fit.
Parameters
----------
st : :class:`peri.states.ImageState`
The state to finish
desc : String, optional
Description to intermittently save the state as, as passed to
state.save. Default is `'finish-state'`.
invert : {'guess', True, False}
| python | {
"resource": ""
} |
q262811 | makestate | validation | def makestate(im, pos, rad, slab=None, mem_level='hi'):
"""
Workhorse for creating & optimizing states with an initial centroid
guess.
This is an example function that works for a particular microscope. For
your own microscope, you'll need to change particulars such as the psf
type and the orders of the background and illumination.
Parameters
----------
im : :class:`~peri.util.RawImage`
A RawImage of the data.
pos : [N,3] element numpy.ndarray.
The initial guess for the N particle positions.
rad : N element numpy.ndarray.
The initial guess for the N particle radii.
slab : :class:`peri.comp.objs.Slab` or None, optional
If not None, a slab corresponding to that in the image. Default
is None.
mem_level : {'lo', 'med-lo', 'med', 'med-hi', 'hi'}, optional
A valid memory level for the state to control the memory overhead
at the expense of accuracy. Default is `'hi'`
Returns
-------
:class:`~peri.states.ImageState`
An ImageState with a linked z-scale, a ConfocalImageModel, and
all the necessary components with orders at which are useful for
my particular test case.
"""
if slab is not None:
| python | {
"resource": ""
} |
q262812 | _calc_ilm_order | validation | def _calc_ilm_order(imshape):
"""
Calculates an ilm order based on the shape of an image. This is based on
something that works for our particular images. Your mileage will vary.
Parameters
----------
imshape : 3-element list-like
The shape of the image.
Returns
-------
npts : tuple
The number of points to use for the ilm.
zorder : int
The order of the z-polynomial.
"""
| python | {
"resource": ""
} |
q262813 | ResponseObject._check_for_inception | validation | def _check_for_inception(self, root_dict):
'''
Used to check if there is a dict in a dict
'''
for key in root_dict:
if | python | {
"resource": ""
} |
q262814 | BarnesStreakLegPoly2P1D.randomize_parameters | validation | def randomize_parameters(self, ptp=0.2, fourier=False, vmin=None, vmax=None):
"""
Create random parameters for this ILM that mimic experiments
as closely as possible without real assumptions.
"""
if vmin is not None and vmax is not None:
ptp = vmax - vmin
elif vmax is not None and vmin is None:
vmin = vmax - ptp
elif vmin is not None and vmax is None:
vmax = vmin + ptp
else:
vmax = 1.0
vmin = vmax - ptp
self.set_values(self.category+'-scale', 1.0)
self.set_values(self.category+'-off', 0.0)
for k, v in iteritems(self.poly_params):
norm = (self.zorder + 1.0)*2
self.set_values(k, ptp*(np.random.rand() - 0.5) / norm)
for i, p in enumerate(self.barnes_params):
N = len(p)
if fourier:
t = ((np.random.rand(N)-0.5) + 1.j*(np.random.rand(N)-0.5))/(np.arange(N)+1)
q = np.real(np.fft.ifftn(t)) / (i+1)
| python | {
"resource": ""
} |
q262815 | BarnesXYLegPolyZ._barnes | validation | def _barnes(self, pos):
"""Creates a barnes interpolant & calculates its values"""
b_in = self.b_in
dist = lambda x: np.sqrt(np.dot(x,x))
#we take a filter size as the max distance between the grids along
#x or y:
sz = self.npts[1]
coeffs = self.get_values(self.barnes_params)
| python | {
"resource": ""
} |
q262816 | Profile.schedules | validation | def schedules(self):
'''
Returns details of the posting schedules associated with a social media
profile.
'''
| python | {
"resource": ""
} |
q262817 | Profile.schedules | validation | def schedules(self, schedules):
'''
Set the posting schedules for the specified social media profile.
'''
url = PATHS['UPDATE_SCHEDULES'] % self.id
data_format = "schedules[0][%s][]=%s&"
post_data = ""
| python | {
"resource": ""
} |
q262818 | moment | validation | def moment(p, v, order=1):
""" Calculates the moments of the probability distribution p with vector v """
if order == 1:
| python | {
"resource": ""
} |
q262819 | ExactPSF.psf_slice | validation | def psf_slice(self, zint, size=11, zoffset=0., getextent=False):
"""
Calculates the 3D psf at a particular z pixel height
Parameters
----------
zint : float
z pixel height in image coordinates , converted to 1/k by the
function using the slab position as well
size : int, list, tuple
The size over which to calculate the psf, can be 1 or 3 elements
for the different axes in image pixel coordinates
zoffset : float
Offset in pixel units to use in the calculation of the psf
cutval : float
If not None, the psf will be cut along a curve corresponding to
p(r) == 0 with exponential damping exp(-d^4)
getextent : boolean
If True, also return the extent of the psf in pixels for example
to get the support size. Can only be used with cutval.
"""
# calculate the current pixel value in 1/k, making sure we are above the slab
zint = max(self._p2k(self._tz(zint)), 0)
offset = np.array([zoffset*(zint>0), 0, 0])
scale = [self.param_dict[self.zscale], 1.0, 1.0]
# create the coordinate vectors for where to actually calculate the
tile = util.Tile(left=0, size=size, centered=True)
vecs = tile.coords(form='flat')
vecs = [self._p2k(s*i+o) for i,s,o in zip(vecs, scale, offset)]
psf = self.psffunc(*vecs[::-1], zint=zint, **self.pack_args()).T
vec = tile.coords(form='meshed')
# create a smoothly varying point spread function by cutting off the psf
# at a certain value and smoothly taking it to zero
if self.cutoffval is not None and not self.cutbyval:
# find the edges of the PSF
edge = psf > psf.max() * self.cutoffval
dd = nd.morphology.distance_transform_edt(~edge)
# calculate the new PSF and normalize it to the new support
psf = psf * np.exp(-dd**4)
psf /= psf.sum()
if getextent:
# the size is determined by the edge plus a 2 pad for the
# exponential damping to zero at the edge
| python | {
"resource": ""
} |
q262820 | ExactPSF._tz | validation | def _tz(self, z):
""" Transform z to real-space coordinates from tile coordinates """
| python | {
"resource": ""
} |
q262821 | ExactPSF._kpad | validation | def _kpad(self, field, finalshape, zpad=False, norm=True):
"""
fftshift and pad the field with zeros until it has size finalshape.
if zpad is off, then no padding is put on the z direction. returns
the fourier transform of the field
"""
currshape = np.array(field.shape)
if any(finalshape < currshape):
raise IndexError("PSF tile size is less than minimum support size")
d = finalshape - currshape
# fix off-by-one issues when going odd to even tile sizes
o = d % 2
d = np.floor_divide(d, 2)
| python | {
"resource": ""
} |
q262822 | ExactLineScanConfocalPSF.pack_args | validation | def pack_args(self):
"""
Pack the parameters into the form necessary for the integration
routines above. For example, packs for calculate_linescan_psf
"""
mapper = {
'psf-kfki': 'kfki',
'psf-alpha': 'alpha',
'psf-n2n1': 'n2n1',
'psf-sigkf': 'sigkf',
'psf-sph6-ab': 'sph6_ab',
'psf-laser-wavelength': 'laser_wavelength',
| python | {
"resource": ""
} |
q262823 | ExactLineScanConfocalPSF.psffunc | validation | def psffunc(self, *args, **kwargs):
"""Calculates a linescan psf"""
if self.polychromatic:
func = psfcalc.calculate_polychrome_linescan_psf
| python | {
"resource": ""
} |
q262824 | ExactPinholeConfocalPSF.psffunc | validation | def psffunc(self, x, y, z, **kwargs):
"""Calculates a pinhole psf"""
#do_pinhole?? FIXME
if self.polychromatic:
func = psfcalc.calculate_polychrome_pinhole_psf
| python | {
"resource": ""
} |
q262825 | BetsApi._req | validation | def _req(self, url, method='GET', **kw):
'''Make request and convert JSON response to python objects'''
send = requests.post if method == 'POST' else requests.get
try:
r = send(
url,
headers=self._token_header(),
timeout=self.settings['timeout'],
**kw)
except requests.exceptions.Timeout:
raise ApiError('Request timed out (%s seconds)' % self.settings['timeout'])
try:
json = r.json()
| python | {
"resource": ""
} |
q262826 | BetsApi.get_active_bets | validation | def get_active_bets(self, project_id=None):
'''Returns all active bets'''
url = urljoin(
self.settings['bets_url'],
'bets?state=fresh,active,accept_end&page=1&page_size=100')
if project_id is not None:
url += '&kava_project_id={}'.format(project_id)
bets = []
| python | {
"resource": ""
} |
q262827 | BetsApi.get_bets | validation | def get_bets(self, type=None, order_by=None, state=None, project_id=None,
page=None, page_size=None):
"""Return bets with given filters and ordering.
:param type: return bets only with this type.
Use None to include all (default).
:param order_by: '-last_stake' or 'last_stake' to sort by stake's
created date or None for default ordering.
:param state: one of 'active', 'closed', 'all' (default 'active').
:param project_id: return bets associated with given project id in kava
:param page: default 1.
:param page_site: page size (default 100).
"""
if page is None:
page = 1
if page_size is None:
page_size = 100
if state == 'all':
_states = [] # all states == no filter
elif state == 'closed':
_states = self.CLOSED_STATES
| python | {
"resource": ""
} |
q262828 | BetsApi.get_project_slug | validation | def get_project_slug(self, bet):
'''Return slug of a project that given bet is associated with
or None if bet is not associated with any project.
'''
if bet.get('form_params'):
| python | {
"resource": ""
} |
q262829 | BetsApi.subscribe | validation | def subscribe(self, event, bet_ids):
'''Subscribe to event for given bet ids.'''
if not self._subscriptions.get(event):
| python | {
"resource": ""
} |
q262830 | preview | validation | def preview(context):
"""Opens local preview of your blog website"""
config = context.obj
pelican(config, '--verbose', '--ignore-cache')
server_proc = None
os.chdir(config['OUTPUT_DIR'])
try:
try:
command = 'python -m http.server ' + str(PORT)
server_proc = run(command, bg=True)
time.sleep(3)
click.launch('http://localhost:8000')
time.sleep(5)
| python | {
"resource": ""
} |
q262831 | APIConnected.get_collection_endpoint | validation | def get_collection_endpoint(cls):
"""
Get the relative path to the API resource collection
If self.collection_endpoint is not set, it will default to the lowercase name of the resource class plus an "s" and the terminating "/"
:param cls: Resource class
:return: Relative path to the | python | {
"resource": ""
} |
q262832 | write | validation | def write(context):
"""Starts a new article"""
config = context.obj
title = click.prompt('Title')
author = click.prompt('Author', default=config.get('DEFAULT_AUTHOR'))
slug = slugify(title)
creation_date = datetime.now()
basename = '{:%Y-%m-%d}_{}.md'.format(creation_date, slug)
meta = (
('Title', title),
('Date', '{:%Y-%m-%d %H:%M}:00'.format(creation_date)),
('Modified', '{:%Y-%m-%d %H:%M}:00'.format(creation_date)),
('Author', author),
)
file_content = ''
for key, value in meta:
file_content += '{}: {}\n'.format(key, value)
file_content += '\n\n'
file_content += 'Text...\n\n'
| python | {
"resource": ""
} |
q262833 | lint | validation | def lint(context):
"""Looks for errors in source code of your blog"""
config = context.obj
try:
run('flake8 {dir} --exclude={exclude}'.format(
dir=config['CWD'],
| python | {
"resource": ""
} |
q262834 | ResourceField.set_real_value_class | validation | def set_real_value_class(self):
"""
value_class is initially a string with the import path to the resource class, but we need to get the actual class before doing any work
We do not expect the actual clas to be in value_class since the beginning to avoid nasty import egg-before-chicken errors
"""
if self.value_class is not None and isinstance(self.value_class, str):
| python | {
"resource": ""
} |
q262835 | publish | validation | def publish(context):
"""Saves changes and sends them to GitHub"""
header('Recording changes...')
run('git add -A')
header('Displaying changes...')
run('git -c color.status=always status')
if not click.confirm('\nContinue publishing'):
run('git reset HEAD --')
abort(context)
header('Saving changes...')
try:
run('git commit -m "{message}"'.format(
message='Publishing {}'.format(choose_commit_emoji())
), capture=True)
except subprocess.CalledProcessError as e:
if 'nothing to commit' not in e.stdout:
| python | {
"resource": ""
} |
q262836 | deploy | validation | def deploy(context):
"""Uploads new version of the blog website"""
config = context.obj
header('Generating HTML...')
pelican(config, '--verbose', production=True)
header('Removing unnecessary output...')
unnecessary_paths = [
'author', 'category', 'tag', 'feeds', 'tags.html',
'authors.html', 'categories.html', 'archives.html',
]
for path in unnecessary_paths:
remove_path(os.path.join(config['OUTPUT_DIR'], path))
if os.environ.get('TRAVIS'): # Travis CI
header('Setting up Git...')
| python | {
"resource": ""
} |
q262837 | signed_number | validation | def signed_number(number, precision=2):
"""
Return the given number as a string with a sign in front of it, ie. `+` if the number is positive, `-` otherwise.
"""
prefix = '' if | python | {
"resource": ""
} |
q262838 | balance | validation | def balance(ctx):
"""
Show Zebra balance.
Like the hours balance, vacation left, etc.
"""
backend = plugins_registry.get_backends_by_class(ZebraBackend)[0]
timesheet_collection = get_timesheet_collection_for_context(ctx, None)
hours_to_be_pushed = timesheet_collection.get_hours(pushed=False, ignored=False, unmapped=False)
today = datetime.date.today()
user_info = backend.get_user_info()
timesheets = backend.get_timesheets(get_first_dow(today), get_last_dow(today))
total_duration = sum([float(timesheet['time']) for timesheet in timesheets])
vacation = hours_to_days(user_info['vacation']['difference'])
vacation_balance = '{} days, {:.2f} hours'.format(*vacation)
| python | {
"resource": ""
} |
q262839 | show_response_messages | validation | def show_response_messages(response_json):
"""
Show all messages in the `messages` key of the given dict.
"""
message_type_kwargs = {
'warning': {'fg': 'yellow'},
'error': {'fg': 'red'},
}
for message in | python | {
"resource": ""
} |
q262840 | photos | validation | def photos(context, path):
"""Adds images to the last article"""
config = context.obj
header('Looking for the latest article...')
article_filename = find_last_article(config['CONTENT_DIR'])
if not article_filename:
return click.secho('No articles.', fg='red')
click.echo(os.path.basename(article_filename))
header('Looking for images...')
images = list(sorted(find_images(path)))
if not images:
return click.secho('Found no images.', fg='red')
for filename in images:
click.secho(filename, fg='green')
if not click.confirm('\nAdd these images to the latest article'):
abort(config)
url_prefix = os.path.join('{filename}', IMAGES_PATH)
images_dir = os.path.join(config['CONTENT_DIR'], IMAGES_PATH)
os.makedirs(images_dir, exist_ok=True)
header('Processing images...')
urls = []
for filename in images:
image_basename = os.path.basename(filename).replace(' ', '-').lower()
| python | {
"resource": ""
} |
q262841 | HashRing._generate_circle | validation | def _generate_circle(self):
"""Generates the circle.
"""
total_weight = 0
for node in self.nodes:
total_weight += self.weights.get(node, 1)
for node in self.nodes:
weight = 1
if node in self.weights:
weight = self.weights.get(node)
| python | {
"resource": ""
} |
q262842 | HashRing.get_node | validation | def get_node(self, string_key):
"""Given a string key a corresponding node in the hash ring is returned.
If the hash ring is empty, `None` is returned.
"""
| python | {
"resource": ""
} |
q262843 | HashRing.gen_key | validation | def gen_key(self, key):
"""Given a string key it returns a long value,
this long value represents a place on the hash ring.
md5 is currently used because | python | {
"resource": ""
} |
q262844 | _get_networking_mode | validation | def _get_networking_mode(app):
"""
Get the Marathon networking mode for the app.
"""
# Marathon 1.5+: there is a `networks` field
networks = app.get('networks')
if networks:
# Modes cannot be mixed, so assigning the last mode is fine
return networks[-1].get('mode', 'container')
# Older Marathon: determine equivalent network mode
container = app.get('container')
if container is not None and 'docker' in container:
| python | {
"resource": ""
} |
q262845 | _get_container_port_mappings | validation | def _get_container_port_mappings(app):
"""
Get the ``portMappings`` field for the app container.
"""
container = app['container']
# Marathon 1.5+: container.portMappings field
port_mappings = container.get('portMappings')
# Older Marathon: container.docker.portMappings field | python | {
"resource": ""
} |
q262846 | sort_pem_objects | validation | def sort_pem_objects(pem_objects):
"""
Given a list of pem objects, sort the objects into the private key, leaf
certificate, and list of CA certificates in the trust chain. This function
assumes that the list of pem objects will contain exactly one private key
and exactly one leaf certificate and that only key and certificate type
objects are provided.
"""
keys, certs, ca_certs = [], [], []
for pem_object in pem_objects:
if isinstance(pem_object, pem.Key):
keys.append(pem_object)
else:
# This assumes all pem objects provided are either | python | {
"resource": ""
} |
q262847 | raise_for_not_ok_status | validation | def raise_for_not_ok_status(response):
"""
Raises a `requests.exceptions.HTTPError` if the response has a non-200
status code.
"""
if response.code != OK:
| python | {
"resource": ""
} |
q262848 | _sse_content_with_protocol | validation | def _sse_content_with_protocol(response, handler, **sse_kwargs):
"""
Sometimes we need the protocol object so that we can manipulate the
underlying transport in tests.
"""
| python | {
"resource": ""
} |
q262849 | sse_content | validation | def sse_content(response, handler, **sse_kwargs):
"""
Callback to collect the Server-Sent Events content of a response. Callbacks
passed will receive event data.
:param response:
The response from the SSE request.
:param handler:
The handler for the SSE protocol.
"""
# An SSE response must be 200/OK | python | {
"resource": ""
} |
q262850 | MarathonClient._request | validation | def _request(self, failure, endpoints, *args, **kwargs):
"""
Recursively make requests to each endpoint in ``endpoints``.
"""
# We've run out of endpoints, fail
if not endpoints:
return failure
endpoint = endpoints.pop(0)
d = | python | {
"resource": ""
} |
q262851 | MarathonClient.get_json_field | validation | def get_json_field(self, field, **kwargs):
"""
Perform a GET request and get the contents of the JSON response.
Marathon's JSON responses tend to contain an object with a single key
which points to the actual data of the response. For example /v2/apps
returns something like {"apps": [ {"app1"}, {"app2"} ]}. We're
interested in the contents of "apps".
This method will raise an error if:
* There is an error response code
* The field with the given name cannot be found
""" | python | {
"resource": ""
} |
q262852 | MarathonClient._get_json_field | validation | def _get_json_field(self, response_json, field_name):
"""
Get a JSON field from the response JSON.
:param: response_json:
The parsed JSON content of the response.
:param: field_name:
| python | {
"resource": ""
} |
q262853 | Config.parse | validation | def parse(
self,
value: str,
type_: typing.Type[typing.Any] = str,
subtype: typing.Type[typing.Any] = str,
) -> typing.Any:
"""
Parse value from string.
Convert :code:`value` to
.. code-block:: python
>>> parser = Config()
>>> parser.parse('12345', type_=int)
<<< 12345
>>>
>>> parser.parse('1,2,3,4', type_=list, subtype=int)
<<< [1, 2, 3, 4]
| python | {
"resource": ""
} |
q262854 | Config.get | validation | def get(
self,
key: str,
default: typing.Any = UNSET,
type_: typing.Type[typing.Any] = str,
subtype: typing.Type[typing.Any] = str,
mapper: typing.Optional[typing.Callable[[object], object]] = None,
) -> typing.Any:
"""
Parse a value from an environment variable.
.. code-block:: python
>>> os.environ['FOO']
<<< '12345'
>>>
>>> os.environ['BAR']
<<< '1,2,3,4'
>>>
>>> 'BAZ' in os.environ
<<< False
>>>
>>> parser = Config()
>>> parser.get('FOO', type_=int)
<<< 12345
>>>
>>> parser.get('BAR', type_=list, subtype=int)
<<< [1, 2, 3, 4]
>>>
>>> parser.get('BAZ', default='abc123')
<<< 'abc123'
>>>
>>> parser.get('FOO', type_=int, mapper=lambda x: x*10)
<<< 123450
:param key: the key to look up the value under
:param default: | python | {
"resource": ""
} |
q262855 | MarathonLbClient._request | validation | def _request(self, endpoint, *args, **kwargs):
"""
Perform a request to a specific endpoint. Raise an error if the status
code indicates a client or server error.
"""
kwargs['url'] = endpoint
| python | {
"resource": ""
} |
q262856 | MarathonLbClient._check_request_results | validation | def _check_request_results(self, results):
"""
Check the result of each request that we made. If a failure occurred,
but some requests succeeded, log and count the failures. If all
requests failed, raise an error.
:return:
The list of responses, with a None value for any requests that
failed.
"""
responses = []
failed_endpoints = []
for index, result_tuple in enumerate(results):
success, result = result_tuple
if success:
responses.append(result)
else:
endpoint = self.endpoints[index]
self.log.failure(
'Failed to make a request to a marathon-lb instance: '
'{endpoint}', result, LogLevel.error, endpoint=endpoint)
responses.append(None)
| python | {
"resource": ""
} |
q262857 | maybe_key | validation | def maybe_key(pem_path):
"""
Set up a client key if one does not exist already.
https://gist.github.com/glyph/27867a478bb71d8b6046fbfb176e1a33#file-local-certs-py-L32-L50
:type pem_path: twisted.python.filepath.FilePath
:param pem_path:
The path to the certificate directory to use.
:rtype: twisted.internet.defer.Deferred
"""
acme_key_file = pem_path.child(u'client.key')
if acme_key_file.exists():
| python | {
"resource": ""
} |
q262858 | maybe_key_vault | validation | def maybe_key_vault(client, mount_path):
"""
Set up a client key in Vault if one does not exist already.
:param client:
The Vault API client to use.
:param mount_path:
The Vault key/value mount path to use.
:rtype: twisted.internet.defer.Deferred
"""
d = client.read_kv2('client_key', mount_path=mount_path)
def get_or_create_key(client_key):
if client_key is not None:
key_data = client_key['data']['data']
key = _load_pem_private_key_bytes(key_data['key'].encode('utf-8'))
return JWKRSA(key=key)
else:
| python | {
"resource": ""
} |
q262859 | VaultClient.read | validation | def read(self, path, **params):
"""
Read data from Vault. Returns the JSON-decoded response.
"""
| python | {
"resource": ""
} |
q262860 | VaultClient.write | validation | def write(self, path, **data):
"""
Write data to Vault. Returns the JSON-decoded response.
"""
d | python | {
"resource": ""
} |
q262861 | get_single_header | validation | def get_single_header(headers, key):
"""
Get a single value for the given key out of the given set of headers.
:param twisted.web.http_headers.Headers headers:
The set of headers in which to look for the header value
:param str key:
The header key
"""
raw_headers | python | {
"resource": ""
} |
q262862 | HTTPClient.request | validation | def request(self, method, url=None, **kwargs):
"""
Perform a request.
:param: method:
The HTTP method to use (example is `GET`).
:param: url:
The URL to use. The default value is the URL this client was
created with (`self.url`) (example is `http://localhost:8080`)
:param: kwargs:
Any other parameters that will be passed to `treq.request`, for
example headers. Or any URL parameters to override, for example
path, query or fragment.
"""
| python | {
"resource": ""
} |
q262863 | MarathonAcmeServer.listen | validation | def listen(self, reactor, endpoint_description):
"""
Run the server, i.e. start listening for requests on the given host and
port.
:param reactor: The ``IReactorTCP`` to use.
:param endpoint_description:
The Twisted description for the endpoint to listen on.
:return:
| python | {
"resource": ""
} |
q262864 | create_marathon_acme | validation | def create_marathon_acme(
client_creator, cert_store, acme_email, allow_multiple_certs,
marathon_addrs, marathon_timeout, sse_timeout, mlb_addrs, group,
reactor):
"""
Create a marathon-acme instance.
:param client_creator:
The txacme client creator function.
:param cert_store:
The txacme certificate store instance.
:param acme_email:
Email address to use when registering with the ACME service.
:param allow_multiple_certs:
Whether to allow multiple certificates per app port.
:param marathon_addr:
Address for the Marathon instance to find app domains that require
certificates.
:param marathon_timeout:
| python | {
"resource": ""
} |
q262865 | init_storage_dir | validation | def init_storage_dir(storage_dir):
"""
Initialise the storage directory with the certificates directory and a
default wildcard self-signed certificate for HAProxy.
:return: the storage path and certs path
"""
storage_path = FilePath(storage_dir)
# Create the default wildcard certificate if it doesn't already exist
default_cert_path = storage_path.child('default.pem')
if not default_cert_path.exists():
default_cert_path.setContent(generate_wildcard_pem_bytes())
| python | {
"resource": ""
} |
q262866 | init_logging | validation | def init_logging(log_level):
"""
Initialise the logging by adding an observer to the global log publisher.
:param str log_level: The minimum log level to log messages for.
"""
log_level_filter = LogLevelFilterPredicate(
LogLevel.levelWithName(log_level))
log_level_filter.setLogLevelForNamespace(
| python | {
"resource": ""
} |
q262867 | _parse_field_value | validation | def _parse_field_value(line):
""" Parse the field and value from a line. """
if line.startswith(':'):
# Ignore the line
return None, None
if ':' not in line:
# Treat the entire line as the field, use empty string as value
return line, ''
# Else field is before the ':' and value | python | {
"resource": ""
} |
q262868 | SseProtocol.dataReceived | validation | def dataReceived(self, data):
"""
Translates bytes into lines, and calls lineReceived.
Copied from ``twisted.protocols.basic.LineOnlyReceiver`` but using
str.splitlines() to split on ``\r\n``, ``\n``, and ``\r``.
"""
self.resetTimeout()
lines = (self._buffer + data).splitlines()
# str.splitlines() doesn't split the string after a trailing newline
# character so we must check if there is a trailing newline and, if so,
# clear the buffer as the line is "complete". Else, the line is
# incomplete and we keep the last line in the buffer.
if data.endswith(b'\n') or data.endswith(b'\r'):
self._buffer = b''
else:
self._buffer = lines.pop(-1)
for line in lines:
if self.transport.disconnecting:
# this is necessary because the transport may be told to lose
# the connection by a line within a larger packet, and it is
| python | {
"resource": ""
} |
q262869 | SseProtocol._handle_field_value | validation | def _handle_field_value(self, field, value):
""" Handle the field, value pair. """
if field == 'event':
self._event = value
elif field == 'data':
self._data_lines.append(value)
elif field == | python | {
"resource": ""
} |
q262870 | SseProtocol._dispatch_event | validation | def _dispatch_event(self):
"""
Dispatch the event to the handler.
"""
data = self._prepare_data()
| python | {
"resource": ""
} |
q262871 | MarathonAcme.listen_events | validation | def listen_events(self, reconnects=0):
"""
Start listening for events from Marathon, running a sync when we first
successfully subscribe and triggering a sync on API request events.
"""
self.log.info('Listening for events from Marathon...')
self._attached = False
def on_finished(result, reconnects):
# If the callback fires then the HTTP request to the event stream
# went fine, but the persistent connection for the SSE stream was
# dropped. Just reconnect for now- if we can't actually connect
# then the errback will fire rather.
self.log.warn('Connection lost listening for events, '
'reconnecting... ({reconnects} so far)',
reconnects=reconnects)
reconnects += 1
return self.listen_events(reconnects)
| python | {
"resource": ""
} |
q262872 | MarathonAcme.sync | validation | def sync(self):
"""
Fetch the list of apps from Marathon, find the domains that require
certificates, and issue certificates for any domains that don't already
have a certificate.
"""
self.log.info('Starting a sync...')
def log_success(result):
self.log.info('Sync completed | python | {
"resource": ""
} |
q262873 | MarathonAcme._issue_cert | validation | def _issue_cert(self, domain):
"""
Issue a certificate for the given domain.
"""
def errback(failure):
# Don't fail on some of the errors we could get from the ACME
# server, rather just log an error so that we can continue with
# other domains.
failure.trap(txacme_ServerError)
acme_error = failure.value.message
if acme_error.code in ['rateLimited', 'serverInternal',
| python | {
"resource": ""
} |
q262874 | rm_fwd_refs | validation | def rm_fwd_refs(obj):
"""When removing an object, other objects with references to the current
object should remove those references. This function identifies objects
with forward references to the current object, then removes those
references.
:param obj: Object to which forward references should be removed
"""
for stack, key in obj._backrefs_flat:
# Unpack stack
backref_key, parent_schema_name, parent_field_name = stack
# Get parent info
parent_schema = obj._collections[parent_schema_name]
parent_key_store = parent_schema._pk_to_storage(key)
parent_object = parent_schema.load(parent_key_store)
if parent_object is None:
continue | python | {
"resource": ""
} |
q262875 | rm_back_refs | validation | def rm_back_refs(obj):
"""When removing an object with foreign fields, back-references from
other objects to the current object should be deleted. This function
identifies foreign fields of the specified object whose values are not
None and which specify back-reference keys, then removes back-references
from linked objects to the specified object.
:param obj: Object for which back-references should be removed
| python | {
"resource": ""
} |
q262876 | ensure_backrefs | validation | def ensure_backrefs(obj, fields=None):
"""Ensure that all forward references on the provided object have the
appropriate backreferences.
:param StoredObject obj: Database record
:param list fields: Optional list of field names to check
"""
for ref in _collect_refs(obj, fields):
| python | {
"resource": ""
} |
q262877 | PickleStorage._remove_by_pk | validation | def _remove_by_pk(self, key, flush=True):
"""Retrieve value from store.
:param key: Key
"""
try:
del self.store[key]
| python | {
"resource": ""
} |
q262878 | Bot.start | validation | def start(self):
"""Initializes the bot, plugins, and everything."""
self.bot_start_time = datetime.now()
self.webserver = Webserver(self.config['webserver']['host'], self.config['webserver']['port'])
self.plugins.load()
self.plugins.load_state()
self._find_event_handlers()
self.sc = ThreadedSlackClient(self.config['slack_token'])
self.always_send_dm = ['_unauthorized_']
if 'always_send_dm' in self.config:
| python | {
"resource": ""
} |
q262879 | Bot.run | validation | def run(self, start=True):
"""
Connects to slack and enters the main loop.
* start - If True, rtm.start API is used. Else rtm.connect API is used
For more info, refer to
https://python-slackclient.readthedocs.io/en/latest/real_time_messaging.html#rtm-start-vs-rtm-connect
"""
# Fail out if setup wasn't run
if not self.is_setup:
raise NotSetupError
# Start the web server
self.webserver.start()
first_connect = True
try:
while self.runnable:
if self.reconnect_needed:
if not self.sc.rtm_connect(with_team_state=start):
return False
self.reconnect_needed = False
if first_connect:
| python | {
"resource": ""
} |
q262880 | Bot.stop | validation | def stop(self):
"""Does cleanup of bot and plugins."""
if self.webserver is not None:
self.webserver.stop()
| python | {
"resource": ""
} |
q262881 | Bot.send_message | validation | def send_message(self, channel, text, thread=None, reply_broadcast=None):
"""
Sends a message to the specified channel
* channel - The channel to send to. This can be a SlackChannel object, a channel id, or a channel name
(without the #)
* text - String to send
* thread - reply to the thread. See https://api.slack.com/docs/message-threading#threads_party
* reply_broadcast - Set to true to indicate your reply is germane to all members of a channel
| python | {
"resource": ""
} |
q262882 | Bot.send_im | validation | def send_im(self, user, text):
"""
Sends a message to a user as an IM
* user - The user to send to. This can be a SlackUser object, a user id, or the username (without the @)
* text - String to send
"""
if isinstance(user, | python | {
"resource": ""
} |
q262883 | MessageDispatcher.push | validation | def push(self, message):
"""
Takes a SlackEvent, parses it for a command, and runs against registered plugin
"""
if self._ignore_event(message):
return None, None
args = self._parse_message(message)
self.log.debug("Searching for command using chunks: %s", args)
cmd, msg_args = self._find_longest_prefix_command(args)
if cmd is not None:
if message.user is None:
self.log.debug("Discarded message with no originating user: %s", message)
| python | {
"resource": ""
} |
q262884 | MessageDispatcher._ignore_event | validation | def _ignore_event(self, message):
"""
message_replied event is not truly a message event and does not have a message.text
don't process such events
commands may not be idempotent, so ignore message_changed events.
"""
| python | {
"resource": ""
} |
q262885 | AuthManager.acl_show | validation | def acl_show(self, msg, args):
"""Show current allow and deny blocks for the given acl."""
name = args[0] if len(args) > 0 else None
if name is None:
return "%s: The following ACLs are defined: %s" % (msg.user, ', '.join(self._acl.keys()))
| python | {
"resource": ""
} |
q262886 | AuthManager.add_user_to_allow | validation | def add_user_to_allow(self, name, user):
"""Add a user to the given acl allow block."""
# Clear user from both allow and deny before adding
if not self.remove_user_from_acl(name, user):
return False
| python | {
"resource": ""
} |
q262887 | AuthManager.create_acl | validation | def create_acl(self, name):
"""Create a new acl."""
if name in self._acl:
return False
self._acl[name] = {
| python | {
"resource": ""
} |
q262888 | AuthManager.delete_acl | validation | def delete_acl(self, name):
"""Delete an acl."""
if name | python | {
"resource": ""
} |
q262889 | mongo | validation | def mongo(daemon=False, port=20771):
'''Run the mongod process.
'''
cmd | python | {
"resource": ""
} |
q262890 | proxy_factory | validation | def proxy_factory(BaseSchema, label, ProxiedClass, get_key):
"""Create a proxy to a class instance stored in ``proxies``.
:param class BaseSchema: Base schema (e.g. ``StoredObject``)
:param str label: Name of class variable to set
:param class ProxiedClass: Class to get or create | python | {
"resource": ""
} |
q262891 | with_proxies | validation | def with_proxies(proxy_map, get_key):
"""Class decorator factory; adds proxy class variables to target class.
:param dict proxy_map: Mapping between class variable labels and proxied
classes
:param function get_key: Extension-specific key function; may return e.g.
the current Flask request
"""
def wrapper(cls):
| python | {
"resource": ""
} |
q262892 | ForeignField._to_primary_key | validation | def _to_primary_key(self, value):
"""
Return primary key; if value is StoredObject, verify
that it is loaded.
"""
if value is None:
return None
if isinstance(value, self.base_class):
if not value._is_loaded:
| python | {
"resource": ""
} |
q262893 | set_nested | validation | def set_nested(data, value, *keys):
"""Assign to a nested dictionary.
:param dict data: Dictionary to mutate
:param value: Value to set
:param list *keys: List of nested keys
>>> data = {}
>>> set_nested(data, 'hi', 'k0', 'k1', 'k2')
>>> data
{'k0': {'k1': {'k2': 'hi'}}}
"""
| python | {
"resource": ""
} |
q262894 | UserManager.get_by_username | validation | def get_by_username(self, username):
"""Retrieve user by username"""
res = filter(lambda x: x.username == username, self.users.values())
| python | {
"resource": ""
} |
q262895 | UserManager.set | validation | def set(self, user):
"""
Adds a user object to the user manager
user - a SlackUser object
"""
self.log.info("Loading user information for %s/%s", user.id, user.username)
| python | {
"resource": ""
} |
q262896 | UserManager.load_user_rights | validation | def load_user_rights(self, user):
"""Sets permissions on user object"""
if user.username in self.admins:
user.is_admin = True
| python | {
"resource": ""
} |
q262897 | BasePlugin.send_message | validation | def send_message(self, channel, text):
"""
Used to send a message to the specified channel.
* channel - can be a channel or user
* text - message to send
"""
if isinstance(channel, SlackIM) or isinstance(channel, SlackUser):
self._bot.send_im(channel, text)
| python | {
"resource": ""
} |
q262898 | BasePlugin.start_timer | validation | def start_timer(self, duration, func, *args):
"""
Schedules a function to be called after some period of time.
* duration - time in seconds to wait before firing
* func - function to be called
* args - arguments to pass to the function
"""
| python | {
"resource": ""
} |
q262899 | BasePlugin.stop_timer | validation | def stop_timer(self, func):
"""
Stops a timer if it hasn't fired yet
* func - the function passed in start_timer
"""
if func in self._timer_callbacks:
t | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.