_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q263000 | MixcloudOauth.exchange_token | validation | def exchange_token(self, code):
"""
Exchange the authorization code for an access token.
"""
access_token_url = OAUTH_ROOT + '/access_token'
params = {
'client_id': self.client_id,
'client_secret': self.client_secret,
'redirect_uri': self.redir... | python | {
"resource": ""
} |
q263001 | CountingLock.acquire | validation | def acquire(self, *args, **kwargs):
""" Wraps Lock.acquire """
with self._stat_lock:
self._waiting += 1
self._lock.acquire(*args, **kwargs)
with self._stat_lock:
self._locked = True
self._waiting -= 1 | python | {
"resource": ""
} |
q263002 | CountingLock.release | validation | def release(self):
""" Wraps Lock.release """
self._lock.release()
with self._stat_lock:
self._locked = False
self._last_released = datetime.now() | python | {
"resource": ""
} |
q263003 | DefaultCustomTypeCodec.default_decoder | validation | def default_decoder(self, obj):
"""Handle a dict that might contain a wrapped state for a custom type."""
typename, marshalled_state = self.unwrap_callback(obj)
if typename is None:
return obj
try:
cls, unmarshaller = self.serializer.unmarshallers[typename]
... | python | {
"resource": ""
} |
q263004 | DefaultCustomTypeCodec.wrap_state_dict | validation | def wrap_state_dict(self, typename: str, state) -> Dict[str, Any]:
"""
Wrap the marshalled state in a dictionary.
The returned dictionary has two keys, corresponding to the ``type_key`` and ``state_key``
options. The former holds the type name and the latter holds the marshalled state.
... | python | {
"resource": ""
} |
q263005 | publish | validation | def publish(quiet, dataset_uri):
"""Enable HTTP access to a dataset.
This only works on datasets in some systems. For example, datasets stored
in AWS S3 object storage and Microsoft Azure Storage can be published as
datasets accessible over HTTP. A published dataset is world readable.
"""
acces... | python | {
"resource": ""
} |
q263006 | _prompt_for_values | validation | def _prompt_for_values(d):
"""Update the descriptive metadata interactively.
Uses values entered by the user. Note that the function keeps recursing
whenever a value is another ``CommentedMap`` or a ``list``. The
function works as passing dictionaries and lists into a function edits
the values in p... | python | {
"resource": ""
} |
q263007 | create | validation | def create(quiet, name, base_uri, symlink_path):
"""Create a proto dataset."""
_validate_name(name)
admin_metadata = dtoolcore.generate_admin_metadata(name)
parsed_base_uri = dtoolcore.utils.generous_parse_uri(base_uri)
if parsed_base_uri.scheme == "symlink":
if symlink_path is None:
... | python | {
"resource": ""
} |
q263008 | interactive | validation | def interactive(proto_dataset_uri):
"""Interactive prompting to populate the readme."""
proto_dataset = dtoolcore.ProtoDataSet.from_uri(
uri=proto_dataset_uri,
config_path=CONFIG_PATH)
# Create an CommentedMap representation of the yaml readme template.
readme_template = _get_readme_tem... | python | {
"resource": ""
} |
q263009 | edit | validation | def edit(dataset_uri):
"""Default editor updating of readme content.
"""
try:
dataset = dtoolcore.ProtoDataSet.from_uri(
uri=dataset_uri,
config_path=CONFIG_PATH
)
except dtoolcore.DtoolCoreTypeError:
dataset = dtoolcore.DataSet.from_uri(
uri=d... | python | {
"resource": ""
} |
q263010 | show | validation | def show(dataset_uri):
"""Show the descriptive metadata in the readme."""
try:
dataset = dtoolcore.ProtoDataSet.from_uri(
uri=dataset_uri,
config_path=CONFIG_PATH
)
except dtoolcore.DtoolCoreTypeError:
dataset = dtoolcore.DataSet.from_uri(
uri=data... | python | {
"resource": ""
} |
q263011 | write | validation | def write(proto_dataset_uri, input):
"""Use YAML from a file or stdin to populate the readme.
To stream content from stdin use "-", e.g.
echo "desc: my data" | dtool readme write <DS_URI> -
"""
proto_dataset = dtoolcore.ProtoDataSet.from_uri(
uri=proto_dataset_uri
)
_validate_and_p... | python | {
"resource": ""
} |
q263012 | item | validation | def item(proto_dataset_uri, input_file, relpath_in_dataset):
"""Add a file to the proto dataset."""
proto_dataset = dtoolcore.ProtoDataSet.from_uri(
proto_dataset_uri,
config_path=CONFIG_PATH)
if relpath_in_dataset == "":
relpath_in_dataset = os.path.basename(input_file)
proto_da... | python | {
"resource": ""
} |
q263013 | metadata | validation | def metadata(proto_dataset_uri, relpath_in_dataset, key, value):
"""Add metadata to a file in the proto dataset."""
proto_dataset = dtoolcore.ProtoDataSet.from_uri(
uri=proto_dataset_uri,
config_path=CONFIG_PATH)
proto_dataset.add_item_metadata(
handle=relpath_in_dataset,
key... | python | {
"resource": ""
} |
q263014 | freeze | validation | def freeze(proto_dataset_uri):
"""Convert a proto dataset into a dataset.
This step is carried out after all files have been added to the dataset.
Freezing a dataset finalizes it with a stamp marking it as frozen.
"""
proto_dataset = dtoolcore.ProtoDataSet.from_uri(
uri=proto_dataset_uri,
... | python | {
"resource": ""
} |
q263015 | cp | validation | def cp(resume, quiet, dataset_uri, dest_base_uri):
"""Copy a dataset to a different location."""
_copy(resume, quiet, dataset_uri, dest_base_uri) | python | {
"resource": ""
} |
q263016 | compress | validation | def compress(obj, level=6, return_type="bytes"):
"""Compress anything to bytes or string.
:params obj:
:params level:
:params return_type: if bytes, then return bytes; if str, then return
base64.b64encode bytes in utf-8 string.
"""
if isinstance(obj, binary_type):
b = zlib.comp... | python | {
"resource": ""
} |
q263017 | _ymd.find_probable_year_index | validation | def find_probable_year_index(self, tokens):
"""
attempt to deduce if a pre 100 year was lost
due to padded zeros being taken off
"""
for index, token in enumerate(self):
potential_year_tokens = _ymd.find_potential_year_tokens(
token, tokens)
... | python | {
"resource": ""
} |
q263018 | tzname_in_python2 | validation | def tzname_in_python2(namefunc):
"""Change unicode output into bytestrings in Python 2
tzname() API changed in Python 3. It used to return bytes, but was changed
to unicode strings
"""
def adjust_encoding(*args, **kwargs):
name = namefunc(*args, **kwargs)
if name is not None and not... | python | {
"resource": ""
} |
q263019 | _validate_fromutc_inputs | validation | def _validate_fromutc_inputs(f):
"""
The CPython version of ``fromutc`` checks that the input is a ``datetime``
object and that ``self`` is attached as its ``tzinfo``.
"""
@wraps(f)
def fromutc(self, dt):
if not isinstance(dt, datetime):
raise TypeError("fromutc() requires a ... | python | {
"resource": ""
} |
q263020 | tzrangebase.fromutc | validation | def fromutc(self, dt):
""" Given a datetime in UTC, return local time """
if not isinstance(dt, datetime):
raise TypeError("fromutc() requires a datetime argument")
if dt.tzinfo is not self:
raise ValueError("dt.tzinfo is not self")
# Get transitions - if there ... | python | {
"resource": ""
} |
q263021 | strip_comment_line_with_symbol | validation | def strip_comment_line_with_symbol(line, start):
"""Strip comments from line string.
"""
parts = line.split(start)
counts = [len(findall(r'(?:^|[^"\\]|(?:\\\\|\\")+)(")', part))
for part in parts]
total = 0
for nr, count in enumerate(counts):
total += count
if total... | python | {
"resource": ""
} |
q263022 | strip_comments | validation | def strip_comments(string, comment_symbols=frozenset(('#', '//'))):
"""Strip comments from json string.
:param string: A string containing json with comments started by comment_symbols.
:param comment_symbols: Iterable of symbols that start a line comment (default # or //).
:return: The string with the... | python | {
"resource": ""
} |
q263023 | picknthweekday | validation | def picknthweekday(year, month, dayofweek, hour, minute, whichweek):
""" dayofweek == 0 means Sunday, whichweek 5 means last instance """
first = datetime.datetime(year, month, 1, hour, minute)
# This will work if dayofweek is ISO weekday (1-7) or Microsoft-style (0-6),
# Because 7 % 7 = 0
weekdayo... | python | {
"resource": ""
} |
q263024 | valuestodict | validation | def valuestodict(key):
"""Convert a registry key's values to a dictionary."""
dout = {}
size = winreg.QueryInfoKey(key)[1]
tz_res = None
for i in range(size):
key_name, value, dtype = winreg.EnumValue(key, i)
if dtype == winreg.REG_DWORD or dtype == winreg.REG_DWORD_LITTLE_ENDIAN:
... | python | {
"resource": ""
} |
q263025 | tzres.name_from_string | validation | def name_from_string(self, tzname_str):
"""
Parse strings as returned from the Windows registry into the time zone
name as defined in the registry.
>>> from dateutil.tzwin import tzres
>>> tzr = tzres()
>>> print(tzr.name_from_string('@tzres.dll,-251'))
'Dateline... | python | {
"resource": ""
} |
q263026 | gettz | validation | def gettz(name):
"""
This retrieves a time zone from the local zoneinfo tarball that is packaged
with dateutil.
:param name:
An IANA-style time zone name, as found in the zoneinfo file.
:return:
Returns a :class:`dateutil.tz.tzfile` time zone object.
.. warning::
It is... | python | {
"resource": ""
} |
q263027 | gettz_db_metadata | validation | def gettz_db_metadata():
""" Get the zonefile metadata
See `zonefile_metadata`_
:returns:
A dictionary with the database metadata
.. deprecated:: 2.6
See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,
query the attribute ``zoneinfo.ZoneInfoFile.metadata``.
... | python | {
"resource": ""
} |
q263028 | get_config | validation | def get_config(jid):
"""Get the configuration for the given JID based on XMPP_HTTP_UPLOAD_ACCESS.
If the JID does not match any rule, ``False`` is returned.
"""
acls = getattr(settings, 'XMPP_HTTP_UPLOAD_ACCESS', (('.*', False), ))
for regex, config in acls:
if isinstance(regex, six.strin... | python | {
"resource": ""
} |
q263029 | datetime_exists | validation | def datetime_exists(dt, tz=None):
"""
Given a datetime and a time zone, determine whether or not a given datetime
would fall in a gap.
:param dt:
A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
is provided.)
:param tz:
A :class:`datetime.tzinfo` with... | python | {
"resource": ""
} |
q263030 | tzfile._set_tzdata | validation | def _set_tzdata(self, tzobj):
""" Set the time zone data of this object from a _tzfile object """
# Copy the relevant attributes over as private attributes
for attr in _tzfile.attrs:
setattr(self, '_' + attr, getattr(tzobj, attr)) | python | {
"resource": ""
} |
q263031 | relativedelta.normalized | validation | def normalized(self):
"""
Return a version of this object represented entirely using integer
values for the relative attributes.
>>> relativedelta(days=1.5, hours=2).normalized()
relativedelta(days=1, hours=14)
:return:
Returns a :class:`dateutil.relativedel... | python | {
"resource": ""
} |
q263032 | _hash | validation | def _hash(secret: bytes, data: bytes, alg: str) -> bytes:
"""
Create a new HMAC hash.
:param secret: The secret used when hashing data.
:type secret: bytes
:param data: The data to hash.
:type data: bytes
:param alg: The algorithm to use when hashing `data`.
:type alg: str
:return: ... | python | {
"resource": ""
} |
q263033 | decode | validation | def decode(secret: Union[str, bytes], token: Union[str, bytes],
alg: str = default_alg) -> Tuple[dict, dict]:
"""
Decodes the given token's header and payload and validates the signature.
:param secret: The secret used to decode the token. Must match the
secret used when creating the tok... | python | {
"resource": ""
} |
q263034 | compare_signature | validation | def compare_signature(expected: Union[str, bytes],
actual: Union[str, bytes]) -> bool:
"""
Compares the given signatures.
:param expected: The expected signature.
:type expected: Union[str, bytes]
:param actual: The actual signature.
:type actual: Union[str, bytes]
:re... | python | {
"resource": ""
} |
q263035 | compare_token | validation | def compare_token(expected: Union[str, bytes],
actual: Union[str, bytes]) -> bool:
"""
Compares the given tokens.
:param expected: The expected token.
:type expected: Union[str, bytes]
:param actual: The actual token.
:type actual: Union[str, bytes]
:return: Do the tokens ... | python | {
"resource": ""
} |
q263036 | Jwt.valid | validation | def valid(self, time: int = None) -> bool:
"""
Is the token valid? This method only checks the timestamps within the
token and compares them against the current time if none is provided.
:param time: The timestamp to validate against
:type time: Union[int, None]
:return:... | python | {
"resource": ""
} |
q263037 | Jwt._pop_claims_from_payload | validation | def _pop_claims_from_payload(self):
"""
Check for registered claims in the payload and move them to the
registered_claims property, overwriting any extant claims.
"""
claims_in_payload = [k for k in self.payload.keys() if
k in registered_claims.values... | python | {
"resource": ""
} |
q263038 | Jwt.encode | validation | def encode(self) -> str:
"""
Create a token based on the data held in the class.
:return: A new token
:rtype: str
"""
payload = {}
payload.update(self.registered_claims)
payload.update(self.payload)
return encode(self.secret, payload, self.alg, se... | python | {
"resource": ""
} |
q263039 | Jwt.decode | validation | def decode(secret: Union[str, bytes], token: Union[str, bytes],
alg: str = default_alg) -> 'Jwt':
"""
Decodes the given token into an instance of `Jwt`.
:param secret: The secret used to decode the token. Must match the
secret used when creating the token.
:ty... | python | {
"resource": ""
} |
q263040 | Jwt.compare | validation | def compare(self, jwt: 'Jwt', compare_dates: bool = False) -> bool:
"""
Compare against another `Jwt`.
:param jwt: The token to compare against.
:type jwt: Jwt
:param compare_dates: Should the comparision take dates into account?
:type compare_dates: bool
:return... | python | {
"resource": ""
} |
q263041 | UploadView.get | validation | def get(self, request, hash, filename):
"""Download a file."""
if _ws_download is True:
return HttpResponseForbidden()
upload = Upload.objects.uploaded().get(hash=hash, name=filename)
return FileResponse(upload.file, content_type=upload.type) | python | {
"resource": ""
} |
q263042 | is_compressed_json_file | validation | def is_compressed_json_file(abspath):
"""Test a file is a valid json file.
- *.json: uncompressed, utf-8 encode json file
- *.js: uncompressed, utf-8 encode json file
- *.gz: compressed, utf-8 encode json file
"""
abspath = abspath.lower()
fname, ext = os.path.splitext(abspath)
if ext i... | python | {
"resource": ""
} |
q263043 | SupportBuiltInDataType.dump_set | validation | def dump_set(self, obj, class_name=set_class_name):
"""
``set`` dumper.
"""
return {"$" + class_name: [self._json_convert(item) for item in obj]} | python | {
"resource": ""
} |
q263044 | SupportBuiltInDataType.dump_deque | validation | def dump_deque(self, obj, class_name="collections.deque"):
"""
``collections.deque`` dumper.
"""
return {"$" + class_name: [self._json_convert(item) for item in obj]} | python | {
"resource": ""
} |
q263045 | SupportBuiltInDataType.dump_OrderedDict | validation | def dump_OrderedDict(self, obj, class_name="collections.OrderedDict"):
"""
``collections.OrderedDict`` dumper.
"""
return {
"$" + class_name: [
(key, self._json_convert(value)) for key, value in iteritems(obj)
]
} | python | {
"resource": ""
} |
q263046 | SupportNumpyArray.dump_nparray | validation | def dump_nparray(self, obj, class_name=numpy_ndarray_class_name):
"""
``numpy.ndarray`` dumper.
"""
return {"$" + class_name: self._json_convert(obj.tolist())} | python | {
"resource": ""
} |
q263047 | _invalidates_cache | validation | def _invalidates_cache(f):
"""
Decorator for rruleset methods which may invalidate the
cached length.
"""
def inner_func(self, *args, **kwargs):
rv = f(self, *args, **kwargs)
self._invalidate_cache()
return rv
return inner_func | python | {
"resource": ""
} |
q263048 | rrulebase.before | validation | def before(self, dt, inc=False):
""" Returns the last recurrence before the given datetime instance. The
inc keyword defines what happens if dt is an occurrence. With
inc=True, if dt itself is an occurrence, it will be returned. """
if self._cache_complete:
gen = self... | python | {
"resource": ""
} |
q263049 | rrulebase.after | validation | def after(self, dt, inc=False):
""" Returns the first recurrence after the given datetime instance. The
inc keyword defines what happens if dt is an occurrence. With
inc=True, if dt itself is an occurrence, it will be returned. """
if self._cache_complete:
gen = self... | python | {
"resource": ""
} |
q263050 | rrulebase.xafter | validation | def xafter(self, dt, count=None, inc=False):
"""
Generator which yields up to `count` recurrences after the given
datetime instance, equivalent to `after`.
:param dt:
The datetime at which to start generating recurrences.
:param count:
The maximum number... | python | {
"resource": ""
} |
q263051 | rrule.replace | validation | def replace(self, **kwargs):
"""Return new rrule with same attributes except for those attributes given new
values by whichever keyword arguments are specified."""
new_kwargs = {"interval": self._interval,
"count": self._count,
"dtstart": self._dtst... | python | {
"resource": ""
} |
q263052 | run_excel_to_html | validation | def run_excel_to_html():
"""
Run the excel_to_html function from the
command-line.
Args:
-p path to file
-s name of the sheet to convert
-css classes to apply
-m attempt to combine merged cells
-c caption for accessibility
-su summary for accessibility
... | python | {
"resource": ""
} |
q263053 | ConvertPHP.get_inner_template | validation | def get_inner_template(self, language, template_type, indentation, key, val):
"""
Gets the requested template for the given language.
Args:
language: string, the language of the template to look for.
template_type: string, 'iterable' or 'singular'.
An itera... | python | {
"resource": ""
} |
q263054 | ConvertPHP.translate_array | validation | def translate_array(self, string, language, level=3, retdata=False):
"""Unserializes a serialized php array and prints it to
the console as a data structure in the specified language.
Used to translate or convert a php array into a data structure
in another language. Currently supports,... | python | {
"resource": ""
} |
q263055 | get | validation | def get():
""" Only API function for the config module.
:return: {dict} loaded validated configuration.
"""
config = {}
try:
config = _load_config()
except IOError:
try:
_create_default_config()
config = _load_config()
except IOError as e:
... | python | {
"resource": ""
} |
q263056 | reusable | validation | def reusable(func):
"""Create a reusable class from a generator function
Parameters
----------
func: GeneratorCallable[T_yield, T_send, T_return]
the function to wrap
Note
----
* the callable must have an inspectable signature
* If bound to a class, the new reusable generator i... | python | {
"resource": ""
} |
q263057 | sendreturn | validation | def sendreturn(gen, value):
"""Send an item into a generator expecting a final return value
Parameters
----------
gen: ~typing.Generator[T_yield, T_send, T_return]
the generator to send the value to
value: T_send
the value to send
Raises
------
RuntimeError
if t... | python | {
"resource": ""
} |
q263058 | imap_send | validation | def imap_send(func, gen):
"""Apply a function to all ``send`` values of a generator
Parameters
----------
func: ~typing.Callable[[T_send], T_mapped]
the function to apply
gen: Generable[T_yield, T_mapped, T_return]
the generator iterable.
Returns
-------
~typing.Generat... | python | {
"resource": ""
} |
q263059 | bug_info | validation | def bug_info(exc_type, exc_value, exc_trace):
"""Prints the traceback and invokes the ipython debugger on any exception
Only invokes ipydb if you are outside ipython or python interactive session.
So scripts must be called from OS shell in order for exceptions to ipy-shell-out.
Dependencies:
Nee... | python | {
"resource": ""
} |
q263060 | copy_web_file_to_local | validation | def copy_web_file_to_local(file_path, target_path):
"""Copies a file from its location on the web to a designated
place on the local machine.
Args:
file_path: Complete url of the file to copy, string (e.g. http://fool.com/input.css).
target_path: Path and name of file on the local machine... | python | {
"resource": ""
} |
q263061 | get_line_count | validation | def get_line_count(fname):
"""Counts the number of lines in a file.
Args:
fname: string, name of the file.
Returns:
integer, the number of lines in the file.
"""
i = 0
with open(fname) as f:
for i, l in enumerate(f):
pass
return i + 1 | python | {
"resource": ""
} |
q263062 | indent_css | validation | def indent_css(f, output):
"""Indentes css that has not been indented and saves it to a new file.
A new file is created if the output destination does not already exist.
Args:
f: string, path to file.
output: string, path/name of the output file (e.g. /directory/output.css).
print type... | python | {
"resource": ""
} |
q263063 | add_newlines | validation | def add_newlines(f, output, char):
"""Adds line breaks after every occurance of a given character in a file.
Args:
f: string, path to input file.
output: string, path to output file.
Returns:
None.
"""
line_count = get_line_count(f)
f = open(f, 'r+')
output = open(... | python | {
"resource": ""
} |
q263064 | reformat_css | validation | def reformat_css(input_file, output_file):
"""Reformats poorly written css. This function does not validate or fix errors in the code.
It only gives code the proper indentation.
Args:
input_file: string, path to the input file.
output_file: string, path to where the reformatted css should... | python | {
"resource": ""
} |
q263065 | clean_strings | validation | def clean_strings(iterable):
"""
Take a list of strings and clear whitespace
on each one. If a value in the list is not a
string pass it through untouched.
Args:
iterable: mixed list
Returns:
mixed list
"""
retval = []
for val in iterable:
try:
... | python | {
"resource": ""
} |
q263066 | future_value | validation | def future_value(present_value, annual_rate, periods_per_year, years):
"""
Calculates the future value of money invested at an anual interest rate,
x times per year, for a given number of years.
Args:
present_value: int or float, the current value of the money (principal).
annual_rate:... | python | {
"resource": ""
} |
q263067 | triangle_area | validation | def triangle_area(point1, point2, point3):
"""
Uses Heron's formula to find the area of a triangle
based on the coordinates of three points.
Args:
point1: list or tuple, the x y coordinate of point one.
point2: list or tuple, the x y coordinate of point two.
point3: list or tu... | python | {
"resource": ""
} |
q263068 | median | validation | def median(data):
"""
Calculates the median of a list of integers or floating point numbers.
Args:
data: A list of integers or floating point numbers
Returns:
Sorts the list numerically and returns the middle number if the list has an odd number
of items. If the list contains ... | python | {
"resource": ""
} |
q263069 | average | validation | def average(numbers, numtype='float'):
"""
Calculates the average or mean of a list of numbers
Args:
numbers: a list of integers or floating point numbers.
numtype: string, 'decimal' or 'float'; the type of number to return.
Returns:
The average (mean) of the numbers as a floa... | python | {
"resource": ""
} |
q263070 | variance | validation | def variance(numbers, type='population'):
"""
Calculates the population or sample variance of a list of numbers.
A large number means the results are all over the place, while a
small number means the results are comparatively close to the average.
Args:
numbers: a list of integers or floa... | python | {
"resource": ""
} |
q263071 | get_percentage | validation | def get_percentage(a, b, i=False, r=False):
"""
Finds the percentage of one number over another.
Args:
a: The number that is a percent, int or float.
b: The base number that a is a percent of, int or float.
i: Optional boolean integer. True if the user wants the result returned as... | python | {
"resource": ""
} |
q263072 | DateTimeUtils.get_datetime_string | validation | def get_datetime_string(datetime_obj):
'''
Get datetime string from datetime object
:param datetime datetime_obj: datetime object
:return: datetime string
:rtype: str
'''
if isinstance(datetime_obj, datetime):
dft = DTFormat()
return date... | python | {
"resource": ""
} |
q263073 | attr | validation | def attr(prev, attr_name):
"""attr pipe can extract attribute value of object.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param attr_name: The name of attribute
:type attr_name: str
:returns: generator
"""
for obj in prev:
if hasattr(obj, attr_name):
... | python | {
"resource": ""
} |
q263074 | attrs | validation | def attrs(prev, attr_names):
"""attrs pipe can extract attribute values of object.
If attr_names is a list and its item is not a valid attribute of
prev's object. It will be excluded from yielded dict.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param attr_names: The list of ... | python | {
"resource": ""
} |
q263075 | attrdict | validation | def attrdict(prev, attr_names):
"""attrdict pipe can extract attribute values of object into a dict.
The argument attr_names can be a list or a dict.
If attr_names is a list and its item is not a valid attribute of
prev's object. It will be excluded from yielded dict.
If attr_names is dict and th... | python | {
"resource": ""
} |
q263076 | flatten | validation | def flatten(prev, depth=sys.maxsize):
"""flatten pipe extracts nested item from previous pipe.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param depth: The deepest nested level to be extracted. 0 means no extraction.
:type depth: integer
:returns: generator
"""
def inn... | python | {
"resource": ""
} |
q263077 | values | validation | def values(prev, *keys, **kw):
"""values pipe extract value from previous pipe.
If previous pipe send a dictionary to values pipe, keys should contains
the key of dictionary which you want to get. If previous pipe send list or
tuple,
:param prev: The previous iterator of pipe.
:type prev: Pipe... | python | {
"resource": ""
} |
q263078 | pack | validation | def pack(prev, n, rest=False, **kw):
"""pack pipe takes n elements from previous generator and yield one
list to next.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param rest: Set True to allow to output the rest part of last elements.
:type prev: boolean
:param padding: Sp... | python | {
"resource": ""
} |
q263079 | grep | validation | def grep(prev, pattern, *args, **kw):
"""The pipe greps the data passed from previous generator according to
given regular expression.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param pattern: The pattern which used to filter out data.
:type pattern: str|unicode|re pattern ob... | python | {
"resource": ""
} |
q263080 | match | validation | def match(prev, pattern, *args, **kw):
"""The pipe greps the data passed from previous generator according to
given regular expression. The data passed to next pipe is MatchObject
, dict or tuple which determined by 'to' in keyword argument.
By default, match pipe yields MatchObject. Use 'to' in keywor... | python | {
"resource": ""
} |
q263081 | resplit | validation | def resplit(prev, pattern, *args, **kw):
"""The resplit pipe split previous pipe input by regular expression.
Use 'maxsplit' keyword argument to limit the number of split.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param pattern: The pattern which used to split string.
:type... | python | {
"resource": ""
} |
q263082 | sub | validation | def sub(prev, pattern, repl, *args, **kw):
"""sub pipe is a wrapper of re.sub method.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param pattern: The pattern string.
:type pattern: str|unicode
:param repl: Check repl argument in re.sub method.
:type repl: str|unicode|callab... | python | {
"resource": ""
} |
q263083 | wildcard | validation | def wildcard(prev, pattern, *args, **kw):
"""wildcard pipe greps data passed from previous generator
according to given regular expression.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param pattern: The wildcard string which used to filter data.
:type pattern: str|unicode|re p... | python | {
"resource": ""
} |
q263084 | stdout | validation | def stdout(prev, endl='\n', thru=False):
"""This pipe read data from previous iterator and write it to stdout.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param endl: The end-of-line symbol for each output.
:type endl: str
:param thru: If true, data will passed to next generat... | python | {
"resource": ""
} |
q263085 | readline | validation | def readline(prev, filename=None, mode='r', trim=str.rstrip, start=1, end=sys.maxsize):
"""This pipe get filenames or file object from previous pipe and read the
content of file. Then, send the content of file line by line to next pipe.
The start and end parameters are used to limit the range of reading fr... | python | {
"resource": ""
} |
q263086 | sh | validation | def sh(prev, *args, **kw):
"""sh pipe execute shell command specified by args. If previous pipe exists,
read data from it and write it to stdin of shell process. The stdout of
shell process will be passed to next pipe object line by line.
A optional keyword argument 'trim' can pass a function into sh p... | python | {
"resource": ""
} |
q263087 | walk | validation | def walk(prev, inital_path, *args, **kw):
"""This pipe wrap os.walk and yield absolute path one by one.
:param prev: The previous iterator of pipe.
:type prev: Pipe
:param args: The end-of-line symbol for each output.
:type args: list of string.
:param kw: The end-of-line symbol for each output... | python | {
"resource": ""
} |
q263088 | join | validation | def join(prev, sep, *args, **kw):
'''alias of str.join'''
yield sep.join(prev, *args, **kw) | python | {
"resource": ""
} |
q263089 | substitute | validation | def substitute(prev, *args, **kw):
'''alias of string.Template.substitute'''
template_obj = string.Template(*args, **kw)
for data in prev:
yield template_obj.substitute(data) | python | {
"resource": ""
} |
q263090 | safe_substitute | validation | def safe_substitute(prev, *args, **kw):
'''alias of string.Template.safe_substitute'''
template_obj = string.Template(*args, **kw)
for data in prev:
yield template_obj.safe_substitute(data) | python | {
"resource": ""
} |
q263091 | to_str | validation | def to_str(prev, encoding=None):
"""Convert data from previous pipe with specified encoding."""
first = next(prev)
if isinstance(first, str):
if encoding is None:
yield first
for s in prev:
yield s
else:
yield first.encode(encoding)
... | python | {
"resource": ""
} |
q263092 | register_default_types | validation | def register_default_types():
"""Regiser all default type-to-pipe convertors."""
register_type(type, pipe.map)
register_type(types.FunctionType, pipe.map)
register_type(types.MethodType, pipe.map)
register_type(tuple, seq)
register_type(list, seq)
register_type(types.GeneratorType, seq)
... | python | {
"resource": ""
} |
q263093 | Paginator.get_dict | validation | def get_dict(self):
'''
Convert Paginator instance to dict
:return: Paging data
:rtype: dict
'''
return dict(
current_page=self.current_page,
total_page_count=self.total_page_count,
items=self.items,
total_item_count=self.... | python | {
"resource": ""
} |
q263094 | check_pidfile | validation | def check_pidfile(pidfile, debug):
"""Check that a process is not running more than once, using PIDFILE"""
# Check PID exists and see if the PID is running
if os.path.isfile(pidfile):
pidfile_handle = open(pidfile, 'r')
# try and read the PID file. If no luck, remove it
try:
... | python | {
"resource": ""
} |
q263095 | check_pid | validation | def check_pid(pid, debug):
"""This function will check whether a PID is currently running"""
try:
# A Kill of 0 is to check if the PID is active. It won't kill the process
os.kill(pid, 0)
if debug > 1:
print("Script has a PIDFILE where the process is still running")
r... | python | {
"resource": ""
} |
q263096 | disown | validation | def disown(debug):
"""This function will disown, so the Ardexa service can be restarted"""
# Get the current PID
pid = os.getpid()
cgroup_file = "/proc/" + str(pid) + "/cgroup"
try:
infile = open(cgroup_file, "r")
except IOError:
print("Could not open cgroup file: ", cgroup_file)... | python | {
"resource": ""
} |
q263097 | run_program | validation | def run_program(prog_list, debug, shell):
"""Run a program and check program return code Note that some commands don't work
well with Popen. So if this function is specifically called with 'shell=True',
then it will run the old 'os.system'. In which case, there is no program output
"""
try:
... | python | {
"resource": ""
} |
q263098 | parse_address_list | validation | def parse_address_list(addrs):
"""Yield each integer from a complex range string like "1-9,12,15-20,23"
>>> list(parse_address_list('1-9,12,15-20,23'))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 16, 17, 18, 19, 20, 23]
>>> list(parse_address_list('1-9,12,15-20,2-3-4'))
Traceback (most recent call last):
... | python | {
"resource": ""
} |
q263099 | _encode_ids | validation | def _encode_ids(*args):
"""
Do url-encode resource ids
"""
ids = []
for v in args:
if isinstance(v, basestring):
qv = v.encode('utf-8') if isinstance(v, unicode) else v
ids.append(urllib.quote(qv))
else:
qv = str(v)
ids.append(urllib.q... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.