_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q260200 | events.drag | validation | def drag(self, node):
""" Drags given node to mouse location.
"""
dx = self.mouse.x - self.graph.x
dy = self.mouse.y - self.graph.y
# A dashed line indicates the drag vector.
s = self.graph.styles.default
self._ctx.nofill()
self._ctx.nostroke()
if s.stroke:
self._ctx.strokewidth(s.strokewidth)
self._ctx.stroke(
s.stroke.r,
s.stroke.g,
s.stroke.g,
| python | {
"resource": ""
} |
q260201 | events.hover | validation | def hover(self, node):
""" Displays a popup when hovering over a node.
"""
if self.popup == False: return
if self.popup == True or self.popup.node != node:
if self.popup_text.has_key(node.id):
texts | python | {
"resource": ""
} |
q260202 | popup.textpath | validation | def textpath(self, i):
""" Returns a cached textpath of the given text in queue.
"""
if len(self._textpaths) == i:
self._ctx.font(self.font, self.fontsize)
txt = self.q[i]
if len(self.q) > 1:
# Indicate current text (e.g. 5/13).
txt += " ("+str(i+1)+"/" + str(len(self.q))+")"
p | python | {
"resource": ""
} |
q260203 | popup.update | validation | def update(self):
""" Rotates the queued texts and determines display time.
"""
if self.delay > 0:
# It takes a while for the popup to appear.
self.delay -= 1; return
if self.fi == 0:
# Only one text in queue, displayed infinitely.
if len(self.q) == 1:
self.fn = float("inf")
# Else, display time depends on text length.
else:
| python | {
"resource": ""
} |
q260204 | popup.draw | validation | def draw(self):
""" Draws a popup rectangle with a rotating text queue.
"""
if len(self.q) > 0:
self.update()
if self.delay == 0:
# Rounded rectangle in the given background color.
p, h = self.textpath(self.i)
f = self.fontsize
self._ctx.fill(self.background)
self._ctx.rect(
self.node.x + f*1.0,
self.node.y + f*0.5,
self._w + f,
h + f*1.5,
roundness=0.2
)
# Fade | python | {
"resource": ""
} |
q260205 | write_main | validation | def write_main(argv):
"""
write FILENAME
Write a local copy of FILENAME using FILENAME_tweaks for local tweaks.
"""
if len(argv) != 1:
print("Please provide the name of a file to write.")
return 1
filename = argv[0]
resource_name = "files/" + filename
tweaks_name = amend_filename(filename, "_tweaks")
if not pkg_resources.resource_exists("edx_lint", resource_name):
print(u"Don't have file %r to write." % filename)
return 2
if os.path.exists(filename):
print(u"Checking existing copy of %s" % filename)
tef = TamperEvidentFile(filename)
if not tef.validate():
bak_name = amend_filename(filename, "_backup")
print(u"Your copy of %s seems to have been edited, renaming it to %s" % (filename, bak_name))
if os.path.exists(bak_name):
print(u"A previous %s exists, deleting it" % bak_name)
| python | {
"resource": ""
} |
q260206 | amend_filename | validation | def amend_filename(filename, amend):
"""Amend a filename with a suffix.
amend_filename("foo.txt", "_tweak") | python | {
"resource": ""
} |
q260207 | check_main | validation | def check_main(argv):
"""
check FILENAME
Check that FILENAME has not been edited since writing.
"""
if len(argv) != 1:
print("Please provide the name of a file to check.")
return 1
filename = argv[0]
if os.path.exists(filename):
print(u"Checking existing copy of %s" % filename)
tef = TamperEvidentFile(filename)
if | python | {
"resource": ""
} |
q260208 | merge_configs | validation | def merge_configs(main, tweaks):
"""Merge tweaks into a main config file."""
for section in tweaks.sections():
for option in tweaks.options(section):
value = tweaks.get(section, option)
if option.endswith("+"):
| python | {
"resource": ""
} |
q260209 | TamperEvidentFile.write | validation | def write(self, text, hashline=b"# {}"):
u"""
Write `text` to the file.
Writes the text to the file, with a final line checksumming the
contents. The entire file must be written with one `.write()` call.
The last line is written with the `hashline` format string, which can
be changed to accommodate different file syntaxes.
Both arguments are UTF8 byte strings.
Arguments:
text (UTF8 byte string): the contents of the file to write.
hashline (UTF8 byte string): the format of the last line to append
| python | {
"resource": ""
} |
q260210 | TamperEvidentFile.validate | validation | def validate(self):
"""
Check if the file still has its original contents.
Returns True if the file is unchanged, False if it has been tampered
with.
"""
with open(self.filename, "rb") as f:
text = f.read()
start_last_line = text.rfind(b"\n", 0, -1)
| python | {
"resource": ""
} |
q260211 | check_visitors | validation | def check_visitors(cls):
"""Check that a checker's visitors are correctly named.
A checker has methods named visit_NODETYPE, but it's easy to mis-name
a visit method, and it will never be called. This decorator checks
the class to see that all of its visitors are named after an existing
node class.
"""
for name | python | {
"resource": ""
} |
q260212 | usable_class_name | validation | def usable_class_name(node):
"""Make a reasonable class name for a class node."""
name = node.qname()
for prefix in ["__builtin__.", "builtins.", "."]:
| python | {
"resource": ""
} |
q260213 | parse_pylint_output | validation | def parse_pylint_output(pylint_output):
"""
Parse the pylint output-format=parseable lines into PylintError tuples.
"""
for line in pylint_output:
if not line.strip():
continue
if line[0:5] in ("-"*5, "*"*5):
continue
parsed = PYLINT_PARSEABLE_REGEX.search(line)
if parsed is None:
LOG.warning(
u"Unable to parse %r. If this is a lint failure, please re-run pylint with the "
| python | {
"resource": ""
} |
q260214 | main | validation | def main(argv=None):
"""The edx_lint command entry point."""
if argv is None:
argv = sys.argv[1:]
if not argv or argv[0] == "help":
show_help()
return 0
elif argv[0] == "check":
return check_main(argv[1:])
elif argv[0] == "list":
return list_main(argv[1:])
elif | python | {
"resource": ""
} |
q260215 | show_help | validation | def show_help():
"""Print the help string for the edx_lint command."""
print("""\
Manage local config | python | {
"resource": ""
} |
q260216 | trans_new | validation | def trans_new(name, transform, inverse, breaks=None,
minor_breaks=None, _format=None,
domain=(-np.inf, np.inf), doc='', **kwargs):
"""
Create a transformation class object
Parameters
----------
name : str
Name of the transformation
transform : callable ``f(x)``
A function (preferably a `ufunc`) that computes
the transformation.
inverse : callable ``f(x)``
A function (preferably a `ufunc`) that computes
the inverse of the transformation.
breaks : callable ``f(limits)``
Function to compute the breaks for this transform.
If None, then a default good enough for a linear
domain is used.
minor_breaks : callable ``f(major, limits)``
Function to compute the minor breaks for this
transform. If None, then a default good enough for
a linear domain is used.
_format : callable ``f(breaks)``
Function to format the generated breaks.
domain : array_like
Domain over which the transformation is valid.
It should be of length 2.
doc : str
Docstring for the class.
**kwargs : dict
Attributes of the transform, e.g if base is passed
| python | {
"resource": ""
} |
q260217 | gettrans | validation | def gettrans(t):
"""
Return a trans object
Parameters
----------
t : str | callable | type | trans
name of transformation function
Returns
-------
out : trans
"""
obj = t
# Make sure trans object is instantiated
if isinstance(obj, str):
name = '{}_trans'.format(obj)
obj = globals()[name]()
| python | {
"resource": ""
} |
q260218 | trans.breaks | validation | def breaks(self, limits):
"""
Calculate breaks in data space and return them
in transformed space.
Expects limits to be in *transform space*, this
is the same space as that where the domain is
specified.
This method wraps around :meth:`breaks_` to ensure
that the calculated breaks are within the domain
the transform. This is helpful in cases where an
aesthetic requests breaks with limits expanded for
some padding, yet the expansion goes beyond the
domain of the transform. e.g for a probability
transform the breaks will be in the domain
``[0, 1]`` despite any outward limits.
Parameters
----------
limits : tuple
The scale limits. Size 2.
Returns
-------
out : array_like
Major breaks
"""
# clip the breaks | python | {
"resource": ""
} |
q260219 | datetime_trans.transform | validation | def transform(x):
"""
Transform from date to a numerical format
"""
try:
x = date2num(x)
except AttributeError:
# numpy datetime64
# This is not ideal because the operations do not
| python | {
"resource": ""
} |
q260220 | rescale | validation | def rescale(x, to=(0, 1), _from=None):
"""
Rescale numeric vector to have specified minimum and maximum.
Parameters
----------
x : array_like | numeric
1D vector of values to manipulate.
to : tuple
output range (numeric vector of length two)
_from : tuple
input range (numeric vector of length two).
If not given, is calculated from the range of x
Returns
-------
out : array_like
Rescaled values
Examples
--------
>>> x = [0, 2, 4, 6, 8, 10]
| python | {
"resource": ""
} |
q260221 | rescale_mid | validation | def rescale_mid(x, to=(0, 1), _from=None, mid=0):
"""
Rescale numeric vector to have specified minimum, midpoint,
and maximum.
Parameters
----------
x : array_like | numeric
1D vector of values to manipulate.
to : tuple
output range (numeric vector of length two)
_from : tuple
input range (numeric vector of length two).
If not given, is calculated from the range of x
mid : numeric
mid-point of input range
Returns
-------
out : array_like
| python | {
"resource": ""
} |
q260222 | rescale_max | validation | def rescale_max(x, to=(0, 1), _from=None):
"""
Rescale numeric vector to have specified maximum.
Parameters
----------
x : array_like | numeric
1D vector of values to manipulate.
to : tuple
output range (numeric vector of length two)
_from : tuple
input range (numeric vector of length two).
If not given, is calculated from the range of x.
Only the 2nd (max) element is essential to the
output.
Returns
-------
out : array_like
Rescaled values
Examples
--------
>>> x = [0, 2, 4, 6, 8, 10]
>>> rescale_max(x, (0, 3))
array([0. , 0.6, 1.2, 1.8, 2.4, 3. ])
Only the 2nd (max) element of the parameters ``to``
and ``_from`` are essential to the output.
>>> rescale_max(x, (1, 3))
array([0. , 0.6, 1.2, 1.8, 2.4, 3. ])
| python | {
"resource": ""
} |
q260223 | squish_infinite | validation | def squish_infinite(x, range=(0, 1)):
"""
Truncate infinite values to a range.
Parameters
----------
x : array_like
Values that should have infinities squished.
range : tuple
The range onto which to squish the infinites.
Must be of size 2.
Returns
-------
out : array_like
Values with infinites squished.
Examples
--------
>>> squish_infinite([0, .5, .25, np.inf, .44])
| python | {
"resource": ""
} |
q260224 | squish | validation | def squish(x, range=(0, 1), only_finite=True):
"""
Squish values into range.
Parameters
----------
x : array_like
Values that should have out of range values squished.
range : tuple
The range onto which to squish the values.
only_finite: boolean
When true, only squishes finite values.
Returns
-------
out : array_like
Values with out of range values squished.
Examples
--------
>>> squish([-1.5, 0.2, 0.5, 0.8, 1.0, 1.2])
[0.0, 0.2, 0.5, 0.8, 1.0, 1.0]
>>> squish([-np.inf, -1.5, 0.2, 0.5, 0.8, 1.0, np.inf], only_finite=False)
[0.0, 0.0, 0.2, 0.5, 0.8, 1.0, 1.0]
"""
xtype | python | {
"resource": ""
} |
q260225 | _censor_with | validation | def _censor_with(x, range, value=None):
"""
Censor any values outside of | python | {
"resource": ""
} |
q260226 | zero_range | validation | def zero_range(x, tol=np.finfo(float).eps * 100):
"""
Determine if range of vector is close to zero.
Parameters
----------
x : array_like | numeric
Value(s) to check. If it is an array_like, it
should be of length 2.
tol : float
Tolerance. Default tolerance is the `machine epsilon`_
times :math:`10^2`.
Returns
-------
out : bool
Whether ``x`` has zero range.
Examples
--------
>>> zero_range([1, 1])
True
>>> zero_range([1, 2])
False
>>> zero_range([1, 2], tol=2)
True
.. _machine epsilon: https://en.wikipedia.org/wiki/Machine_epsilon
"""
try:
if len(x) == 1:
return True
except TypeError:
return True
if len(x) != 2:
raise ValueError('x must be length 1 or 2')
# Deals with array_likes that have non-standard indices
x = tuple(x)
# datetime - pandas, cpython
if isinstance(x[0], (pd.Timestamp, datetime.datetime)):
# date2num include timezone info, .toordinal() does not
x = date2num(x)
# datetime - numpy
elif isinstance(x[0], np.datetime64):
return x[0] == x[1]
# timedelta - pandas, cpython
elif isinstance(x[0], (pd.Timedelta, datetime.timedelta)):
| python | {
"resource": ""
} |
q260227 | expand_range | validation | def expand_range(range, mul=0, add=0, zero_width=1):
"""
Expand a range with a multiplicative or additive constant
Parameters
----------
range : tuple
Range of data. Size 2.
mul : int | float
Multiplicative constant
add : int | float | timedelta
Additive constant
zero_width : int | float | timedelta
Distance to use if range has zero width
Returns
-------
out : tuple
Expanded range
Examples
--------
>>> expand_range((3, 8))
(3, 8)
>>> expand_range((0, 10), mul=0.1)
(-1.0, 11.0)
>>> expand_range((0, 10), add=2)
(-2, 12)
>>> expand_range((0, 10), mul=.1, add=2)
(-3.0, 13.0)
>>> expand_range((0, 1))
(0, 1)
When the range has zero width
>>> expand_range((5, 5))
(4.5, 5.5)
| python | {
"resource": ""
} |
q260228 | expand_range_distinct | validation | def expand_range_distinct(range, expand=(0, 0, 0, 0), zero_width=1):
"""
Expand a range with a multiplicative or additive constants
Similar to :func:`expand_range` but both sides of the range
expanded using different constants
Parameters
----------
range : tuple
Range of data. Size 2
expand : tuple
Length 2 or 4. If length is 2, then the same constants
are used for both sides. If length is 4 then the first
two are are the Multiplicative (*mul*) and Additive (*add*)
constants for the lower limit, and the second two are
the constants for the upper limit.
zero_width : int | float | timedelta
Distance to | python | {
"resource": ""
} |
q260229 | trans_minor_breaks._extend_breaks | validation | def _extend_breaks(self, major):
"""
Append 2 extra breaks at either end of major
If breaks of transform space are non-equidistant,
:func:`minor_breaks` add minor breaks beyond the first
and last major breaks. The solutions is to extend those
breaks (in transformed space) before the minor break call
is made. How the breaks depends on the type of transform.
"""
trans = self.trans
trans = trans if isinstance(trans, type) else trans.__class__
# so far we are only certain about this extending | python | {
"resource": ""
} |
q260230 | timedelta_helper.best_units | validation | def best_units(self, sequence):
"""
Determine good units for representing a sequence of timedeltas
"""
# Read
# [(0.9, 's'),
# (9, 'm)]
# as, break ranges between 0.9 seconds (inclusive)
# and 9 minutes are represented in seconds. And so on.
ts_range = self.value(max(sequence)) - self.value(min(sequence))
package = self.determine_package(sequence[0])
if package == 'pandas':
cuts = [
(0.9, 'us'),
(0.9, 'ms'),
(0.9, 's'),
(9, 'm'),
(6, 'h'),
(4, 'd'),
(4, 'w'),
(4, 'M'),
| python | {
"resource": ""
} |
q260231 | timedelta_helper.scaled_limits | validation | def scaled_limits(self):
"""
Minimum and Maximum to use for computing breaks
"""
| python | {
"resource": ""
} |
q260232 | timedelta_helper.numeric_to_timedelta | validation | def numeric_to_timedelta(self, numerics):
"""
Convert sequence of numerics to timedelta
"""
if self.package == 'pandas':
return [self.type(int(x*self.factor), units='ns')
for | python | {
"resource": ""
} |
q260233 | timedelta_helper.to_numeric | validation | def to_numeric(self, td):
"""
Convert timedelta to a number corresponding to the
appropriate units. The appropriate units are those
determined with the object is initialised.
"""
if self.package == 'pandas':
| python | {
"resource": ""
} |
q260234 | round_any | validation | def round_any(x, accuracy, f=np.round):
"""
Round to multiple of any number.
"""
if not hasattr(x, 'dtype'):
| python | {
"resource": ""
} |
q260235 | min_max | validation | def min_max(x, na_rm=False, finite=True):
"""
Return the minimum and maximum of x
Parameters
----------
x : array_like
Sequence
na_rm : bool
Whether to remove ``nan`` values.
finite : bool
Whether to consider only finite values.
Returns
-------
out : tuple
(minimum, maximum) of x
"""
if not hasattr(x, 'dtype'):
x = np.asarray(x)
if na_rm and finite:
x = x[np.isfinite(x)]
elif not na_rm and np.any(np.isnan(x)): | python | {
"resource": ""
} |
q260236 | precision | validation | def precision(x):
"""
Return the precision of x
Parameters
----------
x : array_like | numeric
Value(s) whose for which to compute the precision.
Returns
-------
out : numeric
The precision of ``x`` or that the values in ``x``.
Notes
-----
The precision is computed in base 10.
Examples
--------
>>> precision(0.08)
0.01
>>> precision(9)
1
>>> precision(16)
10
"""
from .bounds import zero_range
| python | {
"resource": ""
} |
q260237 | multitype_sort | validation | def multitype_sort(a):
"""
Sort elements of multiple types
x is assumed to contain elements of different types, such that
plain sort would raise a `TypeError`.
Parameters
----------
a : array-like
Array of items to be sorted
Returns
-------
out : list
Items sorted within their type groups.
"""
types = defaultdict(list)
numbers = {int, float, complex}
for x in a:
t = type(x)
| python | {
"resource": ""
} |
q260238 | nearest_int | validation | def nearest_int(x):
"""
Return nearest long integer to x
"""
if x == 0:
return np.int64(0)
elif x > | python | {
"resource": ""
} |
q260239 | is_close_to_int | validation | def is_close_to_int(x):
"""
Check if value is close to an integer
Parameters
----------
x : float
Numeric value to check
Returns
-------
out : bool
"""
| python | {
"resource": ""
} |
q260240 | same_log10_order_of_magnitude | validation | def same_log10_order_of_magnitude(x, delta=0.1):
"""
Return true if range is approximately in same order of magnitude
For example these sequences are in the same order of magnitude:
- [1, 8, 5] # [1, 10)
- [35, 20, 80] # [10 100)
- [232, 730] # [100, 1000)
Parameters
----------
x : array-like
Values in base 10. Must be size 2 and
``rng[0] <= rng[1]``.
delta : float
| python | {
"resource": ""
} |
q260241 | _format | validation | def _format(formatter, x):
"""
Helper to format and tidy up
"""
# For MPL to play nice
formatter.create_dummy_axis()
# For sensible decimal places
formatter.set_locs([val for val in x if ~np.isnan(val)])
try:
oom = int(formatter.orderOfMagnitude)
except AttributeError:
| python | {
"resource": ""
} |
q260242 | log_format._tidyup_labels | validation | def _tidyup_labels(self, labels):
"""
Make all labels uniform in format and remove redundant zeros
for labels in exponential format.
Parameters
----------
labels : list-like
Labels to be tidied.
Returns
-------
out : list-like
Labels
"""
def remove_zeroes(s):
"""
Remove unnecessary zeros for float string s
"""
tup = s.split('e')
if len(tup) == 2:
mantissa = tup[0].rstrip('0').rstrip('.')
exponent = int(tup[1])
if exponent:
s = '%se%d' % (mantissa, exponent)
else:
s = mantissa
return s
| python | {
"resource": ""
} |
q260243 | hls_palette | validation | def hls_palette(n_colors=6, h=.01, l=.6, s=.65):
"""
Get a set of evenly spaced colors in HLS hue space.
h, l, and s should be between 0 and 1
Parameters
----------
n_colors : int
number of colors in the palette
h : float
first hue
l : float
lightness
s : float
saturation
Returns
-------
palette : list
List of colors as RGB hex strings.
See Also
--------
husl_palette : Make a palette using evenly spaced circular
hues in the HUSL system.
| python | {
"resource": ""
} |
q260244 | husl_palette | validation | def husl_palette(n_colors=6, h=.01, s=.9, l=.65):
"""
Get a set of evenly spaced colors in HUSL hue space.
h, s, and l should be between 0 and 1
Parameters
----------
n_colors : int
number of colors in the palette
h : float
first hue
s : float
saturation
l : float
lightness
Returns
-------
palette : list
List of colors as RGB hex strings.
See Also
--------
hls_palette : Make a palette using evenly spaced circular
hues in the HSL system.
| python | {
"resource": ""
} |
q260245 | grey_pal | validation | def grey_pal(start=0.2, end=0.8):
"""
Utility for creating continuous grey scale palette
Parameters
----------
start : float
grey value at low end of palette
end : float
grey value at high end of palette
Returns
-------
out : function
Continuous color palette that takes a single
:class:`int` parameter ``n`` and returns ``n``
equally spaced colors.
Examples
--------
>>> palette = grey_pal()
>>> palette(5)
['#333333', '#737373', '#989898', '#b5b5b5', '#cccccc']
"""
gamma = 2.2
ends = ((0.0, start, start), (1.0, end, end))
cdict = {'red': ends, 'green': ends, 'blue': ends}
grey_cmap = mcolors.LinearSegmentedColormap('grey', cdict)
def continuous_grey_palette(n):
| python | {
"resource": ""
} |
q260246 | hue_pal | validation | def hue_pal(h=.01, l=.6, s=.65, color_space='hls'):
"""
Utility for making hue palettes for color schemes.
Parameters
----------
h : float
first hue. In the [0, 1] range
l : float
lightness. In the [0, 1] range
s : float
saturation. In the [0, 1] range
color_space : 'hls' | 'husl'
Color space to use for the palette
Returns
-------
out : function
A discrete color palette that takes a single
:class:`int` parameter ``n`` and returns ``n``
equally spaced colors. Though the palette
is continuous, since it is varies the hue it
is good for categorical data. However if ``n``
is large enough the colors show continuity.
Examples
--------
>>> hue_pal()(5)
['#db5f57', '#b9db57', '#57db94', '#5784db', '#c957db']
>>> hue_pal(color_space='husl')(5)
| python | {
"resource": ""
} |
q260247 | brewer_pal | validation | def brewer_pal(type='seq', palette=1):
"""
Utility for making a brewer palette
Parameters
----------
type : 'sequential' | 'qualitative' | 'diverging'
Type of palette. Sequential, Qualitative or
Diverging. The following abbreviations may
be used, ``seq``, ``qual`` or ``div``.
palette : int | str
Which palette to choose from. If is an integer,
it must be in the range ``[0, m]``, where ``m``
depends on the number sequential, qualitative or
diverging palettes. If it is a string, then it
is the name of the palette.
Returns
-------
out : function
A color palette that takes a single
:class:`int` parameter ``n`` and returns ``n``
colors. The maximum value of ``n`` varies
depending on the parameters.
Examples
--------
>>> brewer_pal()(5)
['#EFF3FF', '#BDD7E7', '#6BAED6', '#3182BD', '#08519C']
>>> brewer_pal('qual')(5)
['#7FC97F', '#BEAED4', '#FDC086', '#FFFF99', '#386CB0']
>>> brewer_pal('qual', 2)(5)
['#1B9E77', '#D95F02', '#7570B3', '#E7298A', '#66A61E']
>>> brewer_pal('seq', 'PuBuGn')(5)
['#F6EFF7', '#BDC9E1', '#67A9CF', '#1C9099', '#016C59']
The available color names for each palette type can be
obtained using the following code::
import palettable.colorbrewer as brewer
print([k for k in brewer.COLOR_MAPS['Sequential'].keys()])
print([k for k in brewer.COLOR_MAPS['Qualitative'].keys()])
print([k for k in brewer.COLOR_MAPS['Diverging'].keys()])
"""
def full_type_name(text):
abbrevs = {
'seq': 'Sequential',
'qual': 'Qualitative',
'div': 'Diverging'
}
text = abbrevs.get(text, text)
return text.title()
def number_to_palette_name(ctype, n):
"""
Return palette name that corresponds to a given number
Uses alphabetical ordering
"""
n -= 1
palettes = sorted(colorbrewer.COLOR_MAPS[ctype].keys())
if n < len(palettes):
return palettes[n]
raise ValueError(
"There are only '{}' palettes of type {}. "
"You requested palette no. {}".format(len(palettes),
ctype, n+1))
| python | {
"resource": ""
} |
q260248 | gradient_n_pal | validation | def gradient_n_pal(colors, values=None, name='gradientn'):
"""
Create a n color gradient palette
Parameters
----------
colors : list
list of colors
values : list, optional
list of points in the range [0, 1] at which to
place each color. Must be the same size as
`colors`. Default to evenly space the colors
name : str
Name to call the resultant MPL colormap
Returns
-------
out : function
Continuous color palette that takes a single
parameter either a :class:`float` or a sequence
of floats maps those value(s) onto the palette
and returns color(s). The float(s) must be
in the range [0, 1].
Examples
--------
>>> palette = gradient_n_pal(['red', 'blue'])
| python | {
"resource": ""
} |
q260249 | cmap_pal | validation | def cmap_pal(name=None, lut=None):
"""
Create a continuous palette using an MPL colormap
Parameters
----------
name : str
Name of colormap
lut : None | int
This is the number of entries desired in the lookup table.
Default is ``None``, leave it up Matplotlib.
Returns
-------
out : function
Continuous color palette that takes a single
parameter either a :class:`float` or a sequence
of floats maps those value(s) onto the palette
and returns color(s). The float(s) must be
in the range [0, 1].
Examples | python | {
"resource": ""
} |
q260250 | cmap_d_pal | validation | def cmap_d_pal(name=None, lut=None):
"""
Create a discrete palette using an MPL Listed colormap
Parameters
----------
name : str
Name of colormap
lut : None | int
This is the number of entries desired in the lookup table.
Default is ``None``, leave it up Matplotlib.
Returns
-------
out : function
A discrete color palette that takes a single
:class:`int` parameter ``n`` and returns ``n``
colors. The maximum value of ``n`` varies
depending on the parameters.
Examples
--------
>>> palette = cmap_d_pal('viridis')
>>> palette(5)
['#440154', '#3b528b', '#21918c', | python | {
"resource": ""
} |
q260251 | desaturate_pal | validation | def desaturate_pal(color, prop, reverse=False):
"""
Create a palette that desaturate a color by some proportion
Parameters
----------
color : matplotlib color
hex, rgb-tuple, or html color name
prop : float
saturation channel of color will be multiplied by
this value
reverse : bool
Whether to reverse the palette.
Returns
-------
out : function
Continuous color palette that takes a single
parameter either a :class:`float` or a sequence
of floats maps those value(s) onto the palette
and returns color(s). The float(s) must be
in the range [0, 1].
Examples
--------
>>> palette = desaturate_pal('red', .1)
>>> palette([0, .25, .5, .75, 1])
| python | {
"resource": ""
} |
q260252 | manual_pal | validation | def manual_pal(values):
"""
Create a palette from a list of values
Parameters
----------
values : sequence
Values that will be returned by the palette function.
Returns
-------
out : function
A function palette that takes a single
:class:`int` parameter ``n`` and returns ``n`` | python | {
"resource": ""
} |
q260253 | cubehelix_pal | validation | def cubehelix_pal(start=0, rot=.4, gamma=1.0, hue=0.8,
light=.85, dark=.15, reverse=False):
"""
Utility for creating continuous palette from the cubehelix system.
This produces a colormap with linearly-decreasing (or increasing)
brightness. That means that information will be preserved if printed to
black and white or viewed by someone who is colorblind.
Parameters
----------
start : float (0 <= start <= 3)
The hue at the start of the helix.
rot : float
Rotations around the hue wheel over the range of the palette.
gamma : float (0 <= gamma)
Gamma factor to emphasize darker (gamma < 1) or lighter (gamma > 1)
colors.
hue : float (0 <= hue <= 1)
Saturation of the colors.
dark : float (0 <= dark <= 1)
Intensity of the darkest color in the palette.
light : float (0 <= light <= 1)
Intensity of the lightest color in the palette.
reverse : bool
If True, the palette will go from dark to light.
Returns
-------
out : function
Continuous color palette that takes a single
:class:`int` parameter ``n`` and returns ``n``
| python | {
"resource": ""
} |
q260254 | scale_continuous.apply | validation | def apply(cls, x, palette, na_value=None, trans=None):
"""
Scale data continuously
Parameters
----------
x : array_like
Continuous values to scale
palette : callable ``f(x)``
Palette to use
na_value : object
Value to use for missing values.
trans : trans
How to transform the data before scaling. If
``None``, no transformation is done.
| python | {
"resource": ""
} |
q260255 | scale_continuous.map | validation | def map(cls, x, palette, limits, na_value=None, oob=censor):
"""
Map values to a continuous palette
Parameters
----------
x : array_like
Continuous values to scale
palette : callable ``f(x)``
palette to use
na_value : object
Value to use for missing values.
oob : callable ``f(x)``
Function to deal with values that are
beyond the limits
Returns
-------
| python | {
"resource": ""
} |
q260256 | scale_discrete.map | validation | def map(cls, x, palette, limits, na_value=None):
"""
Map values to a discrete palette
Parameters
----------
palette : callable ``f(x)``
palette to use
x : array_like
Continuous values to scale
na_value : object
Value to use for missing values.
Returns
-------
out : array_like
Values mapped onto a palette
| python | {
"resource": ""
} |
q260257 | EnvConfig.parse | validation | def parse(type: Type):
"""
Register a parser for a attribute type.
Parsers will be used to parse `str` type objects from either
the commandline arguments or environment variables.
Args:
type: the type the decorated function will be responsible
| python | {
"resource": ""
} |
q260258 | _patched_run_hook | validation | def _patched_run_hook(hook_name, project_dir, context):
"""Used to patch cookiecutter's ``run_hook`` function.
This patched version ensures that the temple.yaml file is created before
any cookiecutter hooks are executed
"""
if hook_name == 'post_gen_project':
with temple.utils.cd(project_dir):
temple.utils.write_temple_config(context['cookiecutter'],
| python | {
"resource": ""
} |
q260259 | _generate_files | validation | def _generate_files(repo_dir, config, template, version):
"""Uses cookiecutter to generate files for the project.
Monkeypatches cookiecutter's "run_hook" to ensure that the temple.yaml file is
generated before any hooks run. This is important to ensure that hooks can also
perform any actions involving temple.yaml
"""
with unittest.mock.patch('cookiecutter.generate.run_hook', side_effect=_patched_run_hook):
cc_generate.generate_files(repo_dir=repo_dir,
| python | {
"resource": ""
} |
q260260 | setup | validation | def setup(template, version=None):
"""Sets up a new project from a template
Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'setup' during the duration
of this function.
Args:
template (str): The git SSH path to a template
version (str, optional): The version of the template to use when updating. Defaults
to the latest version
"""
temple.check.is_git_ssh_path(template)
temple.check.not_in_git_repo()
| python | {
"resource": ""
} |
q260261 | _parse_link_header | validation | def _parse_link_header(headers):
"""Parses Github's link header for pagination.
TODO eventually use a github client for this
"""
links = {}
if 'link' in headers:
link_headers = headers['link'].split(', ')
for link_header in link_headers:
| python | {
"resource": ""
} |
q260262 | _code_search | validation | def _code_search(query, github_user=None):
"""Performs a Github API code search
Args:
query (str): The query sent to Github's code search
github_user (str, optional): The Github user being searched in the query string
Returns:
dict: A dictionary of repository information keyed on the git SSH url
Raises:
`InvalidGithubUserError`: When ``github_user`` is invalid
"""
github_client = temple.utils.GithubClient()
headers = {'Accept': 'application/vnd.github.v3.text-match+json'}
resp = github_client.get('/search/code',
| python | {
"resource": ""
} |
q260263 | ls | validation | def ls(github_user, template=None):
"""Lists all temple templates and packages associated with those templates
If ``template`` is None, returns the available templates for the configured
Github org.
If ``template`` is a Github path to a template, returns all projects spun
up with that template.
``ls`` uses the github search API to find results.
Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'ls' for the duration of this
function.
Args:
github_user (str): The github user or org being searched.
template (str, optional): The template git repo path. If provided, lists
all projects that have been created with the provided template. Note
that the template path is the SSH path
(e.g. git@github.com:CloverHealth/temple.git)
Returns:
| python | {
"resource": ""
} |
q260264 | update | validation | def update(check, enter_parameters, version):
"""
Update package with latest template. Must be inside of the project
folder to run.
Using "-e" will prompt for re-entering the template parameters again
even if the project is up to date.
Use "-v" to update to a particular version of a template.
Using "-c" will perform a check that the project is up to date
with the latest version of the template (or the version specified by "-v").
No updating will happen when using this option.
"""
if check:
if temple.update.up_to_date(version=version):
print('Temple package is up to date')
else:
| python | {
"resource": ""
} |
q260265 | ls | validation | def ls(github_user, template, long_format):
"""
List packages created with temple. Enter a github user or
organization to list all templates under the user or org.
Using a template path as the second argument will list all projects
that have been started with that template.
Use "-l" to print the Github repository descriptions of templates
or projects.
"""
github_urls = | python | {
"resource": ""
} |
q260266 | switch | validation | def switch(template, version):
"""
Switch a project's template to a different template.
""" | python | {
"resource": ""
} |
q260267 | _in_git_repo | validation | def _in_git_repo():
"""Returns True if inside a git repo, False otherwise""" | python | {
"resource": ""
} |
q260268 | _has_branch | validation | def _has_branch(branch):
"""Return True if the target branch exists."""
ret = temple.utils.shell('git rev-parse --verify {}'.format(branch),
stderr=subprocess.DEVNULL,
| python | {
"resource": ""
} |
q260269 | not_has_branch | validation | def not_has_branch(branch):
"""Raises `ExistingBranchError` if the specified branch exists."""
if _has_branch(branch):
msg = 'Cannot proceed while {} branch exists; remove and | python | {
"resource": ""
} |
q260270 | has_env_vars | validation | def has_env_vars(*env_vars):
"""Raises `InvalidEnvironmentError` when one isnt set"""
for env_var in env_vars:
if not os.environ.get(env_var):
msg = (
'Must set {} environment variable. View docs | python | {
"resource": ""
} |
q260271 | is_temple_project | validation | def is_temple_project():
"""Raises `InvalidTempleProjectError` if repository is not a temple project"""
if not os.path.exists(temple.constants.TEMPLE_CONFIG_FILE):
| python | {
"resource": ""
} |
q260272 | _get_current_branch | validation | def _get_current_branch():
"""Determine the current git branch"""
result = temple.utils.shell('git | python | {
"resource": ""
} |
q260273 | clean | validation | def clean():
"""Cleans up temporary resources
Tries to clean up:
1. The temporary update branch used during ``temple update``
2. The primary update branch used during ``temple update``
"""
temple.check.in_git_repo()
current_branch = _get_current_branch()
update_branch = temple.constants.UPDATE_BRANCH_NAME
temp_update_branch = temple.constants.TEMP_UPDATE_BRANCH_NAME
| python | {
"resource": ""
} |
q260274 | _cookiecutter_configs_have_changed | validation | def _cookiecutter_configs_have_changed(template, old_version, new_version):
"""Given an old version and new version, check if the cookiecutter.json files have changed
When the cookiecutter.json files change, it means the user will need to be prompted for
new context
Args:
template (str): The git SSH path to the template
old_version (str): The git SHA of the old version
new_version (str): The git SHA of the new | python | {
"resource": ""
} |
q260275 | _apply_template | validation | def _apply_template(template, target, *, checkout, extra_context):
"""Apply a template to a temporary directory and then copy results to target."""
with tempfile.TemporaryDirectory() as tempdir:
repo_dir = cc_main.cookiecutter(
template,
checkout=checkout,
no_input=True,
output_dir=tempdir,
extra_context=extra_context)
for item in os.listdir(repo_dir):
src = os.path.join(repo_dir, item)
dst = os.path.join(target, item)
| python | {
"resource": ""
} |
q260276 | up_to_date | validation | def up_to_date(version=None):
"""Checks if a temple project is up to date with the repo
Note that the `temple.constants.TEMPLE_ENV_VAR` is set to 'update' for the duration of this
function.
Args:
version (str, optional): Update against this git SHA or branch of the template
Returns:
boolean: True if up to date with ``version`` (or latest version), False otherwise
Raises:
`NotInGitRepoError`: When running outside of a git repo
`InvalidTempleProjectError`: | python | {
"resource": ""
} |
q260277 | _needs_new_cc_config_for_update | validation | def _needs_new_cc_config_for_update(old_template, old_version, new_template, new_version):
"""
Given two templates and their respective versions, return True if a new cookiecutter
config needs to be obtained from the user
"""
if old_template != new_template:
return True
else:
| python | {
"resource": ""
} |
q260278 | shell | validation | def shell(cmd, check=True, stdin=None, stdout=None, stderr=None):
"""Runs a subprocess shell with check=True by default"""
| python | {
"resource": ""
} |
q260279 | read_temple_config | validation | def read_temple_config():
"""Reads the temple YAML configuration file in the repository""" | python | {
"resource": ""
} |
q260280 | write_temple_config | validation | def write_temple_config(temple_config, template, version):
"""Writes the temple YAML configuration"""
with open(temple.constants.TEMPLE_CONFIG_FILE, 'w') as temple_config_file:
versioned_config = {
**temple_config,
| python | {
"resource": ""
} |
q260281 | get_cookiecutter_config | validation | def get_cookiecutter_config(template, default_config=None, version=None):
"""Obtains the configuration used for cookiecutter templating
Args:
template: Path to the template
default_config (dict, optional): The default configuration
version (str, optional): The git SHA or branch to use when
checking out template. Defaults to latest version
Returns:
tuple: The cookiecutter repo directory and the | python | {
"resource": ""
} |
q260282 | set_cmd_env_var | validation | def set_cmd_env_var(value):
"""Decorator that sets the temple command env var to value"""
def func_decorator(function):
@functools.wraps(function)
def wrapper(*args, **kwargs):
previous_cmd_env_var = os.getenv(temple.constants.TEMPLE_ENV_VAR)
os.environ[temple.constants.TEMPLE_ENV_VAR] = value
try:
ret_val = function(*args, **kwargs)
finally:
if previous_cmd_env_var is None:
| python | {
"resource": ""
} |
q260283 | GithubClient._call_api | validation | def _call_api(self, verb, url, **request_kwargs):
"""Perform a github API call
Args:
verb (str): Can be "post", "put", or "get"
url (str): The base URL with a leading slash for Github API (v3)
auth (str or HTTPBasicAuth): A Github API token or a HTTPBasicAuth object
"""
api = 'https://api.github.com{}'.format(url)
| python | {
"resource": ""
} |
q260284 | deploy | validation | def deploy(target):
"""Deploys the package and documentation.
Proceeds in the following steps:
1. Ensures proper environment variables are set and checks that we are on Circle CI
2. Tags the repository with the new version
3. Creates a standard distribution and a wheel
4. Updates version.py to have the proper version
5. Commits the ChangeLog, AUTHORS, and version.py file
6. Pushes to PyPI
7. Pushes the tags and newly committed files
Raises:
`EnvironmentError`:
- Not running on CircleCI
- `*_PYPI_USERNAME` and/or `*_PYPI_PASSWORD` environment variables
are missing
- Attempting to deploy to production from a branch that isn't master
"""
# Ensure proper environment
if not os.getenv(CIRCLECI_ENV_VAR): # pragma: no cover
raise EnvironmentError('Must be on CircleCI to run this script')
current_branch = os.getenv('CIRCLE_BRANCH')
if (target == 'PROD') and (current_branch != 'master'):
raise EnvironmentError((
'Refusing to deploy to production from branch {current_branch!r}. '
'Production deploys can only be made from master.'
).format(current_branch=current_branch))
if target in ('PROD', 'TEST'):
pypi_username = os.getenv('{target}_PYPI_USERNAME'.format(target=target))
pypi_password = os.getenv('{target}_PYPI_PASSWORD'.format(target=target))
else:
raise ValueError(
"Deploy target must be 'PROD' or 'TEST', got {target!r}.".format(target=target))
if not (pypi_username and pypi_password): # pragma: no cover
raise EnvironmentError((
"Missing '{target}_PYPI_USERNAME' and/or '{target}_PYPI_PASSWORD' "
"environment variables. These are required to push to PyPI."
).format(target=target))
# Twine requires these environment variables to be set. Subprocesses will
# inherit these when we invoke them, so no need to pass them on the command
| python | {
"resource": ""
} |
q260285 | DSStoreChecker.run | validation | def run(self):
"""
Finds .DS_Store files into path
"""
filename = ".DS_Store"
command = "find {path} -type f -name \"{filename}\" ".format(path = self.path, filename = filename)
cmd = CommandHelper(command)
cmd.execute()
files = cmd.output.split("\n")
for f in files:
if not f.endswith(filename):
continue
# Ignore paths excluded
rel_path = f.replace(self.path, "")
if rel_path.startswith(tuple(self.CONFIG['exclude_paths'])):
| python | {
"resource": ""
} |
q260286 | HttpReport.run | validation | def run(self):
"""
Method executed dynamically by framework. This method will do a http request to
endpoint setted into config file with the issues and other data.
"""
options = {}
if bool(self.config['use_proxy']):
options['proxies'] = {"http": self.config['proxy'], "https": self.config['proxy']}
options["url"] = self.config['url']
options["data"] | python | {
"resource": ""
} |
q260287 | GenericChecker.path | validation | def path(self, value):
"""
Setter for 'path' property
Args:
value (str): Absolute path | python | {
"resource": ""
} |
q260288 | GenericChecker.parseConfig | validation | def parseConfig(cls, value):
"""
Parse the config values
Args:
value (dict): Dictionary which contains the checker config
Returns:
dict: The checker config with parsed values
"""
if 'enabled' in value:
value['enabled'] = | python | {
"resource": ""
} |
q260289 | CommandHelper.getOSName | validation | def getOSName(self):
"""
Get the OS name. If OS is linux, returns the Linux distribution name
Returns:
str: OS name
"""
_system = platform.system()
if _system in [self.__class__.OS_WINDOWS, self.__class__.OS_MAC, self.__class__.OS_LINUX]:
if _system == self.__class__.OS_LINUX:
_dist = platform.linux_distribution()[0]
if _dist.lower() == self.__class__.OS_UBUNTU.lower():
return self.__class__.OS_UBUNTU
elif _dist.lower() == self.__class__.OS_DEBIAN.lower():
return self.__class__.OS_DEBIAN
elif _dist.lower() == self.__class__.OS_CENTOS.lower():
| python | {
"resource": ""
} |
q260290 | CommandHelper.execute | validation | def execute(self, shell = True):
"""
Executes the command setted into class
Args:
shell (boolean): Set True if | python | {
"resource": ""
} |
q260291 | AtomShieldsScanner._debug | validation | def _debug(message, color=None, attrs=None):
"""
Print a message if the class attribute 'verbose' is enabled
Args:
message (str): Message to print
"""
if attrs is None:
attrs = []
| python | {
"resource": ""
} |
q260292 | AtomShieldsScanner.setup | validation | def setup():
"""
Creates required directories and copy checkers and reports.
"""
# # Check if dir is writable
# if not os.access(AtomShieldsScanner.HOME, os.W_OK):
# AtomShieldsScanner.HOME = os.path.expanduser("~/.atomshields")
# AtomShieldsScanner.CHECKERS_DIR = os.path.join(AtomShieldsScanner.HOME, "checkers")
# AtomShieldsScanner.REPORTS_DIR = os.path.join(AtomShieldsScanner.HOME, "reports")
if not os.path.isdir(AtomShieldsScanner.CHECKERS_DIR):
os.makedirs(AtomShieldsScanner.CHECKERS_DIR)
if not os.path.isdir(AtomShieldsScanner.REPORTS_DIR):
os.makedirs(AtomShieldsScanner.REPORTS_DIR)
# Copy all checkers
for f in AtomShieldsScanner._getFiles(os.path.join(os.path.dirname(os.path.realpath(__file__)), "checkers"), "*.py"):
AtomShieldsScanner.installChecker(f)
# Copy all reports
| python | {
"resource": ""
} |
q260293 | AtomShieldsScanner._addConfig | validation | def _addConfig(instance, config, parent_section):
"""
Writes a section for a plugin.
Args:
instance (object): Class instance for plugin
config (object): Object (ConfigParser) which the current config
parent_section (str): Parent section for plugin. Usually 'checkers' or 'reports'
"""
try:
| python | {
"resource": ""
} |
q260294 | AtomShieldsScanner.getConfig | validation | def getConfig(self, section = None):
"""
Returns a dictionary which contains the current config. If a section is setted,
only will returns the section config
Args:
section (str): (Optional) Section name.
Returns:
dict: Representation of current config
"""
data = {}
if section is None:
for s in self.config.sections():
if '/' in s:
| python | {
"resource": ""
} |
q260295 | AtomShieldsScanner._getClassInstance | validation | def _getClassInstance(path, args=None):
"""
Returns a class instance from a .py file.
Args:
path (str): Absolute path to .py file
args (dict): Arguments passed via class constructor
Returns:
object: Class instance or None
"""
if not path.endswith(".py"):
return None
if args is None:
| python | {
"resource": ""
} |
q260296 | AtomShieldsScanner._executeMassiveMethod | validation | def _executeMassiveMethod(path, method, args=None, classArgs = None):
"""
Execute an specific method for each class instance located in path
Args:
path (str): Absolute path which contains the .py files
method (str): Method to execute into class instance
Returns:
dict: Dictionary which contains the response for every class instance.
The dictionary keys are the value of 'NAME' class variable.
"""
response = {}
if args is None:
args = {}
if classArgs is None:
classArgs = {}
sys.path.append(path)
exclude = ["__init__.py", "base.py"]
for f in AtomShieldsScanner._getFiles(path, "*.py", exclude=exclude):
try:
instance = AtomShieldsScanner._getClassInstance(path = f, args = classArgs)
if instance is not None:
if callable(method):
args["instance"] = instance
| python | {
"resource": ""
} |
q260297 | AtomShieldsScanner.run | validation | def run(self):
"""
Run a scan in the path setted.
"""
self.checkProperties()
self.debug("[*] Iniciando escaneo de AtomShields con las siguientes propiedades. . . ")
self.showScanProperties()
self.loadConfig()
# Init time counter
init_ts = datetime.now()
# Execute plugins
cwd = os.getcwd()
os.chdir(self.path)
issues = self.executeCheckers()
os.chdir(cwd)
# Finish time counter
end_ts = datetime.now()
duration = '{}'.format(end_ts - init_ts)
# Process and set issues
| python | {
"resource": ""
} |
q260298 | RetireJSChecker.install | validation | def install():
"""
Install all the dependences
"""
cmd = CommandHelper()
cmd.install("npm")
cmd = CommandHelper()
cmd.install("nodejs-legacy")
# Install retre with npm
cmd = CommandHelper()
cmd.command = "npm | python | {
"resource": ""
} |
q260299 | Issue.potential | validation | def potential(self, value):
"""
Setter for 'potential' property
Args:
value (bool): True | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.