_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q264200 | ManagedResource.put | validation | def put(self, request, response):
"""Processes a `PUT` request."""
if self.slug is None:
# Mass-PUT is not implemented.
raise http.exceptions.NotImplemented()
# Check if the resource exists.
target = self.read()
# Deserialize and clean the incoming objec... | python | {
"resource": ""
} |
q264201 | ManagedResource.delete | validation | def delete(self, request, response):
"""Processes a `DELETE` request."""
if self.slug is None:
# Mass-DELETE is not implemented.
raise http.exceptions.NotImplemented()
# Ensure we're allowed to destroy a resource.
self.assert_operations('destroy')
# Dele... | python | {
"resource": ""
} |
q264202 | ManagedResource.link | validation | def link(self, request, response):
"""Processes a `LINK` request.
A `LINK` request is asking to create a relation from the currently
represented URI to all of the `Link` request headers.
"""
from armet.resources.managed.request import read
if self.slug is None:
... | python | {
"resource": ""
} |
q264203 | DjangoCreator.create_project | validation | def create_project(self):
'''
Creates a base Django project
'''
if os.path.exists(self._py):
prj_dir = os.path.join(self._app_dir, self._project_name)
if os.path.exists(prj_dir):
if self._force:
logging.warn('Removing existing p... | python | {
"resource": ""
} |
q264204 | ilike_helper | validation | def ilike_helper(default):
"""Helper function that performs an `ilike` query if a string value
is passed, otherwise the normal default operation."""
@functools.wraps(default)
def wrapped(x, y):
# String values should use ILIKE queries.
if isinstance(y, six.string_types) and not isinstanc... | python | {
"resource": ""
} |
q264205 | parse | validation | def parse(text, encoding='utf8'):
"""Parse the querystring into a normalized form."""
# Decode the text if we got bytes.
if isinstance(text, six.binary_type):
text = text.decode(encoding)
return Query(text, split_segments(text)) | python | {
"resource": ""
} |
q264206 | split_segments | validation | def split_segments(text, closing_paren=False):
"""Return objects representing segments."""
buf = StringIO()
# The segments we're building, and the combinators used to combine them.
# Note that after this is complete, this should be true:
# len(segments) == len(combinators) + 1
# Thus we can und... | python | {
"resource": ""
} |
q264207 | parse_segment | validation | def parse_segment(text):
"we expect foo=bar"
if not len(text):
return NoopQuerySegment()
q = QuerySegment()
# First we need to split the segment into key/value pairs. This is done
# by attempting to split the sequence for each equality comparison. Then
# discard any that did not spl... | python | {
"resource": ""
} |
q264208 | Attribute.set | validation | def set(self, target, value):
"""Set the value of this attribute for the passed object.
"""
if not self._set:
return
if self.path is None:
# There is no path defined on this resource.
# We can do no magic to set the value.
self.set = lamb... | python | {
"resource": ""
} |
q264209 | parse | validation | def parse(specifiers):
"""
Consumes set specifiers as text and forms a generator to retrieve
the requested ranges.
@param[in] specifiers
Expected syntax is from the byte-range-specifier ABNF found in the
[RFC 2616]; eg. 15-17,151,-16,26-278,15
@returns
Consecutive tuples th... | python | {
"resource": ""
} |
q264210 | paginate | validation | def paginate(request, response, items):
"""Paginate an iterable during a request.
Magically splicling an iterable in our supported ORMs allows LIMIT and
OFFSET queries. We should probably delegate this to the ORM or something
in the future.
"""
# TODO: support dynamic rangewords and page length... | python | {
"resource": ""
} |
q264211 | indexesOptional | validation | def indexesOptional(f):
"""Decorate test methods with this if you don't require strict index checking"""
stack = inspect.stack()
_NO_INDEX_CHECK_NEEDED.add('%s.%s.%s' % (f.__module__, stack[1][3], f.__name__))
del stack
return f | python | {
"resource": ""
} |
q264212 | Request.read | validation | def read(self, deserialize=False, format=None):
"""Read and return the request data.
@param[in] deserialize
True to deserialize the resultant text using a determiend format
or the passed format.
@param[in] format
A specific format to deserialize in; if provi... | python | {
"resource": ""
} |
q264213 | use | validation | def use(**kwargs):
"""
Updates the active resource configuration to the passed
keyword arguments.
Invoking this method without passing arguments will just return the
active resource configuration.
@returns
The previous configuration.
"""
config = dict(use.config)
use.config... | python | {
"resource": ""
} |
q264214 | try_delegation | validation | def try_delegation(method):
'''This decorator wraps descriptor methods with a new method that tries
to delegate to a function of the same name defined on the owner instance
for convenience for dispatcher clients.
'''
@functools.wraps(method)
def delegator(self, *args, **kwargs):
if self.... | python | {
"resource": ""
} |
q264215 | Dispatcher.register | validation | def register(self, method, args, kwargs):
'''Given a single decorated handler function,
prepare, append desired data to self.registry.
'''
invoc = self.dump_invoc(*args, **kwargs)
self.registry.append((invoc, method.__name__)) | python | {
"resource": ""
} |
q264216 | Dispatcher.get_method | validation | def get_method(self, *args, **kwargs):
'''Find the first method this input dispatches to.
'''
for method in self.gen_methods(*args, **kwargs):
return method
msg = 'No method was found for %r on %r.'
raise self.DispatchError(msg % ((args, kwargs), self.inst)) | python | {
"resource": ""
} |
q264217 | TypeDispatcher.gen_method_keys | validation | def gen_method_keys(self, *args, **kwargs):
'''Given a node, return the string to use in computing the
matching visitor methodname. Can also be a generator of strings.
'''
token = args[0]
for mro_type in type(token).__mro__[:-1]:
name = mro_type.__name__
y... | python | {
"resource": ""
} |
q264218 | TypeDispatcher.gen_methods | validation | def gen_methods(self, *args, **kwargs):
'''Find all method names this input dispatches to.
'''
token = args[0]
inst = self.inst
prefix = self._method_prefix
for method_key in self.gen_method_keys(*args, **kwargs):
method = getattr(inst, prefix + method_key, No... | python | {
"resource": ""
} |
q264219 | BumpRequirement.parse | validation | def parse(cls, s, required=False):
"""
Parse string to create an instance
:param str s: String with requirement to parse
:param bool required: Is this requirement required to be fulfilled? If not, then it is a filter.
"""
req = pkg_resources.Requirement.parse(s)
... | python | {
"resource": ""
} |
q264220 | RequirementsManager.add | validation | def add(self, requirements, required=None):
"""
Add requirements to be managed
:param list/Requirement requirements: List of :class:`BumpRequirement` or :class:`pkg_resources.Requirement`
:param bool required: Set required flag for each requirement if provided.
"""
if is... | python | {
"resource": ""
} |
q264221 | RequirementsManager.satisfied_by_checked | validation | def satisfied_by_checked(self, req):
"""
Check if requirement is already satisfied by what was previously checked
:param Requirement req: Requirement to check
"""
req_man = RequirementsManager([req])
return any(req_man.check(*checked) for checked in self.checked) | python | {
"resource": ""
} |
q264222 | Bump.require | validation | def require(self, req):
""" Add new requirements that must be fulfilled for this bump to occur """
reqs = req if isinstance(req, list) else [req]
for req in reqs:
if not isinstance(req, BumpRequirement):
req = BumpRequirement(req)
req.required = True
... | python | {
"resource": ""
} |
q264223 | AbstractBumper.requirements_for_changes | validation | def requirements_for_changes(self, changes):
"""
Parse changes for requirements
:param list changes:
"""
requirements = []
reqs_set = set()
if isinstance(changes, str):
changes = changes.split('\n')
if not changes or changes[0].startswith('-... | python | {
"resource": ""
} |
q264224 | AbstractBumper.bump | validation | def bump(self, bump_reqs=None, **kwargs):
"""
Bump dependencies using given requirements.
:param RequirementsManager bump_reqs: Bump requirements manager
:param dict kwargs: Additional args from argparse. Some bumpers accept user options, and some not.
:return: List of :... | python | {
"resource": ""
} |
q264225 | AbstractBumper.reverse | validation | def reverse(self):
""" Restore content in target file to be before any changes """
if self._original_target_content:
with open(self.target, 'w') as fp:
fp.write(self._original_target_content) | python | {
"resource": ""
} |
q264226 | Serializer.serialize | validation | def serialize(self, data=None):
"""
Transforms the object into an acceptable format for transmission.
@throws ValueError
To indicate this serializer does not support the encoding of the
specified object.
"""
if data is not None and self.response is not No... | python | {
"resource": ""
} |
q264227 | cons | validation | def cons(collection, value):
"""Extends a collection with a value."""
if isinstance(value, collections.Mapping):
if collection is None:
collection = {}
collection.update(**value)
elif isinstance(value, six.string_types):
if collection is None:
collection = []... | python | {
"resource": ""
} |
q264228 | _merge | validation | def _merge(options, name, bases, default=None):
"""Merges a named option collection."""
result = None
for base in bases:
if base is None:
continue
value = getattr(base, name, None)
if value is None:
continue
result = utils.cons(result, value)
va... | python | {
"resource": ""
} |
q264229 | PyPI.package_info | validation | def package_info(cls, package):
""" All package info for given package """
if package not in cls.package_info_cache:
package_json_url = 'https://pypi.python.org/pypi/%s/json' % package
try:
logging.getLogger('requests').setLevel(logging.WARN)
res... | python | {
"resource": ""
} |
q264230 | PyPI.all_package_versions | validation | def all_package_versions(package):
""" All versions for package """
info = PyPI.package_info(package)
return info and sorted(info['releases'].keys(), key=lambda x: x.split(), reverse=True) or [] | python | {
"resource": ""
} |
q264231 | Response.close | validation | def close(self):
"""Flush and close the stream.
This is called automatically by the base resource on resources
unless the resource is operating asynchronously; in that case,
this method MUST be called in order to signal the end of the request.
If not the request will simply hang... | python | {
"resource": ""
} |
q264232 | Response.write | validation | def write(self, chunk, serialize=False, format=None):
"""Writes the given chunk to the output buffer.
@param[in] chunk
Either a byte array, a unicode string, or a generator. If `chunk`
is a generator then calling `self.write(<generator>)` is
equivalent to:
... | python | {
"resource": ""
} |
q264233 | Response.serialize | validation | def serialize(self, data, format=None):
"""Serializes the data into this response using a serializer.
@param[in] data
The data to be serialized.
@param[in] format
A specific format to serialize in; if provided, no detection is
done. If not provided, the acce... | python | {
"resource": ""
} |
q264234 | Response.flush | validation | def flush(self):
"""Flush the write buffers of the stream.
This results in writing the current contents of the write buffer to
the transport layer, initiating the HTTP/1.1 response. This initiates
a streaming response. If the `Content-Length` header is not given
then the chunked... | python | {
"resource": ""
} |
q264235 | Response.send | validation | def send(self, *args, **kwargs):
"""Writes the passed chunk and flushes it to the client."""
self.write(*args, **kwargs)
self.flush() | python | {
"resource": ""
} |
q264236 | Response.end | validation | def end(self, *args, **kwargs):
"""
Writes the passed chunk, flushes it to the client,
and terminates the connection.
"""
self.send(*args, **kwargs)
self.close() | python | {
"resource": ""
} |
q264237 | replaced_directory | validation | def replaced_directory(dirname):
"""This ``Context Manager`` is used to move the contents of a directory
elsewhere temporarily and put them back upon exit. This allows testing
code to use the same file directories as normal code without fear of
damage.
The name of the temporary directory which con... | python | {
"resource": ""
} |
q264238 | capture_stdout | validation | def capture_stdout():
"""This ``Context Manager`` redirects STDOUT to a ``StringIO`` objects
which is returned from the ``Context``. On exit STDOUT is restored.
Example:
.. code-block:: python
with capture_stdout() as capture:
print('foo')
# got here? => capture.getvalue... | python | {
"resource": ""
} |
q264239 | capture_stderr | validation | def capture_stderr():
"""This ``Context Manager`` redirects STDERR to a ``StringIO`` objects
which is returned from the ``Context``. On exit STDERR is restored.
Example:
.. code-block:: python
with capture_stderr() as capture:
print('foo')
# got here? => capture.getvalue... | python | {
"resource": ""
} |
q264240 | Resource.urls | validation | def urls(cls):
"""Builds the URL configuration for this resource."""
return urls.patterns('', urls.url(
r'^{}(?:$|(?P<path>[/:(.].*))'.format(cls.meta.name),
cls.view,
name='armet-api-{}'.format(cls.meta.name),
kwargs={'resource': cls.meta.name})) | python | {
"resource": ""
} |
q264241 | dump | validation | def dump(obj, fp, startindex=1, separator=DEFAULT, index_separator=DEFAULT):
'''Dump an object in req format to the fp given.
:param Mapping obj: The object to serialize. Must have a keys method.
:param fp: A writable that can accept all the types given.
:param separator: The separator between key and... | python | {
"resource": ""
} |
q264242 | dumps | validation | def dumps(obj, startindex=1, separator=DEFAULT, index_separator=DEFAULT):
'''Dump an object in req format to a string.
:param Mapping obj: The object to serialize. Must have a keys method.
:param separator: The separator between key and value. Defaults to u'|' or b'|', depending on the types.
:param ... | python | {
"resource": ""
} |
q264243 | load | validation | def load(fp, separator=DEFAULT, index_separator=DEFAULT, cls=dict, list_cls=list):
'''Load an object from the file pointer.
:param fp: A readable filehandle.
:param separator: The separator between key and value. Defaults to u'|' or b'|', depending on the types.
:param index_separator: The separator b... | python | {
"resource": ""
} |
q264244 | loads | validation | def loads(s, separator=DEFAULT, index_separator=DEFAULT, cls=dict, list_cls=list):
'''Loads an object from a string.
:param s: An object to parse
:type s: bytes or str
:param separator: The separator between key and value. Defaults to u'|' or b'|', depending on the types.
:param index_separator: T... | python | {
"resource": ""
} |
q264245 | BumperDriver.reverse | validation | def reverse(self):
""" Reverse all bumpers """
if not self.test_drive and self.bumps:
map(lambda b: b.reverse(), self.bumpers) | python | {
"resource": ""
} |
q264246 | BumperDriver._expand_targets | validation | def _expand_targets(self, targets, base_dir=None):
""" Expand targets by looking for '-r' in targets. """
all_targets = []
for target in targets:
target_dirs = [p for p in [base_dir, os.path.dirname(target)] if p]
target_dir = target_dirs and os.path.join(*target_dirs) o... | python | {
"resource": ""
} |
q264247 | ProjectCreator.get_nginx_config | validation | def get_nginx_config(self):
"""
Gets the Nginx config for the project
"""
if os.path.exists(self._nginx_config):
return open(self._nginx_config, 'r').read()
else:
return None | python | {
"resource": ""
} |
q264248 | ProjectCreator.check_directories | validation | def check_directories(self):
"""
Creates base directories for app, virtualenv, and nginx
"""
self.log.debug('Checking directories')
if not os.path.exists(self._ve_dir):
os.makedirs(self._ve_dir)
if not os.path.exists(self._app_dir):
os.makedirs(se... | python | {
"resource": ""
} |
q264249 | ProjectCreator.create_virtualenv | validation | def create_virtualenv(self):
"""
Creates the virtualenv for the project
"""
if check_command('virtualenv'):
ve_dir = os.path.join(self._ve_dir, self._project_name)
if os.path.exists(ve_dir):
if self._force:
logging.warn... | python | {
"resource": ""
} |
q264250 | ProjectCreator.create_nginx_config | validation | def create_nginx_config(self):
"""
Creates the Nginx configuration for the project
"""
cfg = '# nginx config for {0}\n'.format(self._project_name)
if not self._shared_hosting:
# user
if self._user:
cfg += 'user {0};\n'.format(self._user)
... | python | {
"resource": ""
} |
q264251 | ProjectCreator.create_manage_scripts | validation | def create_manage_scripts(self):
"""
Creates scripts to start and stop the application
"""
# create start script
start = '# start script for {0}\n\n'.format(self._project_name)
# start uwsgi
start += 'echo \'Starting uWSGI...\'\n'
start += 'sh {0}.uwsgi\n... | python | {
"resource": ""
} |
q264252 | ProjectCreator.create | validation | def create(self):
"""
Creates the full project
"""
# create virtualenv
self.create_virtualenv()
# create project
self.create_project()
# generate uwsgi script
self.create_uwsgi_script()
# generate nginx config
self.create_nginx_con... | python | {
"resource": ""
} |
q264253 | dasherize | validation | def dasherize(value):
"""Dasherizes the passed value."""
value = value.strip()
value = re.sub(r'([A-Z])', r'-\1', value)
value = re.sub(r'[-_\s]+', r'-', value)
value = re.sub(r'^-', r'', value)
value = value.lower()
return value | python | {
"resource": ""
} |
q264254 | Resource.redirect | validation | def redirect(cls, request, response):
"""Redirect to the canonical URI for this resource."""
if cls.meta.legacy_redirect:
if request.method in ('GET', 'HEAD',):
# A SAFE request is allowed to redirect using a 301
response.status = http.client.MOVED_PERMANENTLY... | python | {
"resource": ""
} |
q264255 | Resource.parse | validation | def parse(cls, path):
"""Parses out parameters and separates them out of the path.
This uses one of the many defined patterns on the options class. But,
it defaults to a no-op if there are no defined patterns.
"""
# Iterate through the available patterns.
for resource, p... | python | {
"resource": ""
} |
q264256 | Resource.traverse | validation | def traverse(cls, request, params=None):
"""Traverses down the path and determines the accessed resource.
This makes use of the patterns array to implement simple traversal.
This defaults to a no-op if there are no defined patterns.
"""
# Attempt to parse the path using a patter... | python | {
"resource": ""
} |
q264257 | Resource.stream | validation | def stream(cls, response, sequence):
"""
Helper method used in conjunction with the view handler to
stream responses to the client.
"""
# Construct the iterator and run the sequence once in order
# to capture any headers and status codes set.
iterator = iter(seque... | python | {
"resource": ""
} |
q264258 | Resource.deserialize | validation | def deserialize(self, request=None, text=None, format=None):
"""Deserializes the text using a determined deserializer.
@param[in] request
The request object to pull information from; normally used to
determine the deserialization format (when `format` is
not provided... | python | {
"resource": ""
} |
q264259 | Resource.serialize | validation | def serialize(self, data, response=None, request=None, format=None):
"""Serializes the data using a determined serializer.
@param[in] data
The data to be serialized.
@param[in] response
The response object to serialize the data to.
If this method is invoked ... | python | {
"resource": ""
} |
q264260 | Resource.dispatch | validation | def dispatch(self, request, response):
"""Entry-point of the dispatch cycle for this resource.
Performs common work such as authentication, decoding, etc. before
handing complete control of the result to a function with the
same name as the request method.
"""
# Assert a... | python | {
"resource": ""
} |
q264261 | Resource.require_authentication | validation | def require_authentication(self, request):
"""Ensure we are authenticated."""
request.user = user = None
if request.method == 'OPTIONS':
# Authentication should not be checked on an OPTIONS request.
return
for auth in self.meta.authentication:
user =... | python | {
"resource": ""
} |
q264262 | Resource.require_accessibility | validation | def require_accessibility(self, user, method):
"""Ensure we are allowed to access this resource."""
if method == 'OPTIONS':
# Authorization should not be checked on an OPTIONS request.
return
authz = self.meta.authorization
if not authz.is_accessible(user, method... | python | {
"resource": ""
} |
q264263 | Resource.require_http_allowed_method | validation | def require_http_allowed_method(cls, request):
"""Ensure that we're allowed to use this HTTP method."""
allowed = cls.meta.http_allowed_methods
if request.method not in allowed:
# The specified method is not allowed for the resource
# identified by the request URI.
... | python | {
"resource": ""
} |
q264264 | Resource.route | validation | def route(self, request, response):
"""Processes every request.
Directs control flow to the appropriate HTTP/1.1 method.
"""
# Ensure that we're allowed to use this HTTP method.
self.require_http_allowed_method(request)
# Retrieve the function corresponding to this HTTP... | python | {
"resource": ""
} |
q264265 | Resource.options | validation | def options(self, request, response):
"""Process an `OPTIONS` request.
Used to initiate a cross-origin request. All handling specific to
CORS requests is done on every request however this method also
returns a list of available methods.
"""
# Gather a list available HTT... | python | {
"resource": ""
} |
q264266 | resource | validation | def resource(**kwargs):
"""Wraps the decorated function in a lightweight resource."""
def inner(function):
name = kwargs.pop('name', None)
if name is None:
name = utils.dasherize(function.__name__)
methods = kwargs.pop('methods', None)
if isinstance(methods, six.stri... | python | {
"resource": ""
} |
q264267 | CookieDict.render_to_string | validation | def render_to_string(self):
"""Render to cookie strings.
"""
values = ''
for key, value in self.items():
values += '{}={};'.format(key, value)
return values | python | {
"resource": ""
} |
q264268 | CookieDict.from_cookie_string | validation | def from_cookie_string(self, cookie_string):
"""update self with cookie_string.
"""
for key_value in cookie_string.split(';'):
if '=' in key_value:
key, value = key_value.split('=', 1)
else:
key = key_value
strip_key = key.strip... | python | {
"resource": ""
} |
q264269 | AuthPolicy._add_method | validation | def _add_method(self, effect, verb, resource, conditions):
"""
Adds a method to the internal lists of allowed or denied methods.
Each object in the internal list contains a resource ARN and a
condition statement. The condition statement can be null.
"""
if verb != '*' and... | python | {
"resource": ""
} |
q264270 | AuthPolicy._get_effect_statement | validation | def _get_effect_statement(self, effect, methods):
"""
This function loops over an array of objects containing
a resourceArn and conditions statement and generates
the array of statements for the policy.
"""
statements = []
if len(methods) > 0:
stateme... | python | {
"resource": ""
} |
q264271 | Deployment.deref | validation | def deref(self, data):
"""AWS doesn't quite have Swagger 2.0 validation right and will fail
on some refs. So, we need to convert to deref before
upload."""
# We have to make a deepcopy here to create a proper JSON
# compatible object, otherwise `json.dumps` fails when it
... | python | {
"resource": ""
} |
q264272 | check_pre_requirements | validation | def check_pre_requirements(pre_requirements):
"""Check all necessary system requirements to exist.
:param pre_requirements:
Sequence of pre-requirements to check by running
``where <pre_requirement>`` on Windows and ``which ...`` elsewhere.
"""
pre_requirements = set(pre_requirements or... | python | {
"resource": ""
} |
q264273 | config_to_args | validation | def config_to_args(config):
"""Convert config dict to arguments list.
:param config: Configuration dict.
"""
result = []
for key, value in iteritems(config):
if value is False:
continue
key = '--{0}'.format(key.replace('_', '-'))
if isinstance(value, (list, se... | python | {
"resource": ""
} |
q264274 | create_env | validation | def create_env(env, args, recreate=False, ignore_activated=False, quiet=False):
"""Create virtual environment.
:param env: Virtual environment name.
:param args: Pass given arguments to ``virtualenv`` script.
:param recerate: Recreate virtual environment? By default: False
:param ignore_activated:
... | python | {
"resource": ""
} |
q264275 | error_handler | validation | def error_handler(func):
"""Decorator to error handling."""
@wraps(func)
def wrapper(*args, **kwargs):
"""
Run actual function and if exception catched and error handler enabled
put traceback to log file
"""
try:
return func(*args, **kwargs)
except... | python | {
"resource": ""
} |
q264276 | install | validation | def install(env, requirements, args, ignore_activated=False,
install_dev_requirements=False, quiet=False):
"""Install library or project into virtual environment.
:param env: Use given virtual environment name.
:param requirements: Use given requirements file for pip.
:param args: Pass give... | python | {
"resource": ""
} |
q264277 | iteritems | validation | def iteritems(data, **kwargs):
"""Iterate over dict items."""
return iter(data.items(**kwargs)) if IS_PY3 else data.iteritems(**kwargs) | python | {
"resource": ""
} |
q264278 | iterkeys | validation | def iterkeys(data, **kwargs):
"""Iterate over dict keys."""
return iter(data.keys(**kwargs)) if IS_PY3 else data.iterkeys(**kwargs) | python | {
"resource": ""
} |
q264279 | main | validation | def main(*args):
r"""Bootstrap Python projects and libraries with virtualenv and pip.
Also check system requirements before bootstrap and run post bootstrap
hook if any.
:param \*args: Command line arguments list.
"""
# Create parser, read arguments from direct input or command line
with d... | python | {
"resource": ""
} |
q264280 | parse_args | validation | def parse_args(args):
"""
Parse args from command line by creating argument parser instance and
process it.
:param args: Command line arguments list.
"""
from argparse import ArgumentParser
description = ('Bootstrap Python projects and libraries with virtualenv '
'and pi... | python | {
"resource": ""
} |
q264281 | pip_cmd | validation | def pip_cmd(env, cmd, ignore_activated=False, **kwargs):
r"""Run pip command in given or activated virtual environment.
:param env: Virtual environment name.
:param cmd: Pip subcommand to run.
:param ignore_activated:
Ignore activated virtual environment and use given venv instead. By
d... | python | {
"resource": ""
} |
q264282 | prepare_args | validation | def prepare_args(config, bootstrap):
"""Convert config dict to command line args line.
:param config: Configuration dict.
:param bootstrap: Bootstrapper configuration dict.
"""
config = copy.deepcopy(config)
environ = dict(copy.deepcopy(os.environ))
data = {'env': bootstrap['env'],
... | python | {
"resource": ""
} |
q264283 | print_error | validation | def print_error(message, wrap=True):
"""Print error message to stderr, using ANSI-colors.
:param message: Message to print
:param wrap:
Wrap message into ``ERROR: <message>. Exit...`` template. By default:
True
"""
if wrap:
message = 'ERROR: {0}. Exit...'.format(message.rstr... | python | {
"resource": ""
} |
q264284 | print_message | validation | def print_message(message=None):
"""Print message via ``subprocess.call`` function.
This helps to ensure consistent output and avoid situations where print
messages actually shown after messages from all inner threads.
:param message: Text message to print.
"""
kwargs = {'stdout': sys.stdout,
... | python | {
"resource": ""
} |
q264285 | read_config | validation | def read_config(filename, args):
"""
Read and parse configuration file. By default, ``filename`` is relative
path to current work directory.
If no config file found, default ``CONFIG`` would be used.
:param filename: Read config from given filename.
:param args: Parsed command line arguments.
... | python | {
"resource": ""
} |
q264286 | run_cmd | validation | def run_cmd(cmd, echo=False, fail_silently=False, **kwargs):
r"""Call given command with ``subprocess.call`` function.
:param cmd: Command to run.
:type cmd: tuple or str
:param echo:
If enabled show command to call and its output in STDOUT, otherwise
hide all output. By default: False
... | python | {
"resource": ""
} |
q264287 | run_hook | validation | def run_hook(hook, config, quiet=False):
"""Run post-bootstrap hook if any.
:param hook: Hook to run.
:param config: Configuration dict.
:param quiet: Do not output messages to STDOUT/STDERR. By default: False
"""
if not hook:
return True
if not quiet:
print_message('== Ste... | python | {
"resource": ""
} |
q264288 | save_traceback | validation | def save_traceback(err):
"""Save error traceback to bootstrapper log file.
:param err: Catched exception.
"""
# Store logs to ~/.bootstrapper directory
dirname = safe_path(os.path.expanduser(
os.path.join('~', '.{0}'.format(__script__))
))
# But ensure that directory exists
if ... | python | {
"resource": ""
} |
q264289 | smart_str | validation | def smart_str(value, encoding='utf-8', errors='strict'):
"""Convert Python object to string.
:param value: Python object to convert.
:param encoding: Encoding to use if in Python 2 given object is unicode.
:param errors: Errors mode to use if in Python 2 given object is unicode.
"""
if not IS_P... | python | {
"resource": ""
} |
q264290 | copy_w_plus | validation | def copy_w_plus(src, dst):
"""Copy file from `src` path to `dst` path. If `dst` already exists, will add '+' characters
to the end of the basename without extension.
Parameters
----------
src: str
dst: str
Returns
-------
dstpath: str
"""
dst_ext = get_extension(dst)
d... | python | {
"resource": ""
} |
q264291 | get_abspath | validation | def get_abspath(folderpath):
"""Returns the absolute path of folderpath.
If the path does not exist, will raise IOError.
"""
if not op.exists(folderpath):
raise FolderNotFound(folderpath)
return op.abspath(folderpath) | python | {
"resource": ""
} |
q264292 | get_extension | validation | def get_extension(filepath, check_if_exists=False, allowed_exts=ALLOWED_EXTS):
"""Return the extension of fpath.
Parameters
----------
fpath: string
File name or path
check_if_exists: bool
allowed_exts: dict
Dictionary of strings, where the key if the last part of a complex ('.' separ... | python | {
"resource": ""
} |
q264293 | add_extension_if_needed | validation | def add_extension_if_needed(filepath, ext, check_if_exists=False):
"""Add the extension ext to fpath if it doesn't have it.
Parameters
----------
filepath: str
File name or path
ext: str
File extension
check_if_exists: bool
Returns
-------
File name or path with extension... | python | {
"resource": ""
} |
q264294 | join_path_to_filelist | validation | def join_path_to_filelist(path, filelist):
"""Joins path to each line in filelist
Parameters
----------
path: str
filelist: list of str
Returns
-------
list of filepaths
"""
return [op.join(path, str(item)) for item in filelist] | python | {
"resource": ""
} |
q264295 | remove_all | validation | def remove_all(filelist, folder=''):
"""Deletes all files in filelist
Parameters
----------
filelist: list of str
List of the file paths to be removed
folder: str
Path to be used as common directory for all file paths in filelist
"""
if not folder:
for f in filelist... | python | {
"resource": ""
} |
q264296 | ux_file_len | validation | def ux_file_len(filepath):
"""Returns the length of the file using the 'wc' GNU command
Parameters
----------
filepath: str
Returns
-------
float
"""
p = subprocess.Popen(['wc', '-l', filepath], stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
result, er... | python | {
"resource": ""
} |
q264297 | merge | validation | def merge(dict_1, dict_2):
"""Merge two dictionaries.
Values that evaluate to true take priority over falsy values.
`dict_1` takes priority over `dict_2`.
"""
return dict((str(key), dict_1.get(key) or dict_2.get(key))
for key in set(dict_2) | set(dict_1)) | python | {
"resource": ""
} |
q264298 | get_sys_path | validation | def get_sys_path(rcpath, app_name, section_name=None):
"""Return a folder path if it exists.
First will check if it is an existing system path, if it is, will return it
expanded and absoluted.
If this fails will look for the rcpath variable in the app_name rcfiles or
exclusively within the given s... | python | {
"resource": ""
} |
q264299 | rcfile | validation | def rcfile(appname, section=None, args={}, strip_dashes=True):
"""Read environment variables and config files and return them merged with
predefined list of arguments.
Parameters
----------
appname: str
Application name, used for config files and environment variable
names.
sec... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.