INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Sets node position for new node in the tree | def set_position(cls, resource_id, to_position, db_session=None, *args, **kwargs):
"""
Sets node position for new node in the tree
:param resource_id: resource to move
:param to_position: new position
:param db_session:
:return:def count_children(cls, resource_id, db_ses... |
Checks if parent destination is valid for node | def check_node_parent(
cls, resource_id, new_parent_id, db_session=None, *args, **kwargs
):
"""
Checks if parent destination is valid for node
:param resource_id:
:param new_parent_id:
:param db_session:
:return:
"""
db_session = get_db_sessio... |
Counts children of resource node | def count_children(cls, resource_id, db_session=None, *args, **kwargs):
"""
Counts children of resource node
:param resource_id:
:param db_session:
:return:
"""
query = db_session.query(cls.model.resource_id)
query = query.filter(cls.model.parent_id == re... |
Checks if node position for given parent is valid raises exception if this is not the case | def check_node_position(
cls, parent_id, position, on_same_branch, db_session=None, *args, **kwargs
):
"""
Checks if node position for given parent is valid, raises exception if
this is not the case
:param parent_id:
:param position:
:param on_same_branch: in... |
Given two integers ( b n ) returns ( gcd ( b n ) a m ) such that a * b + n * m = gcd ( b n ). Adapted from several sources: https:// brilliant. org/ wiki/ extended - euclidean - algorithm/ https:// rosettacode. org/ wiki/ Modular_inverse https:// en. wikibooks. org/ wiki/ Algorithm_Implementation/ Mathematics/ Extended... | def egcd(b, n):
'''
Given two integers (b, n), returns (gcd(b, n), a, m) such that
a*b + n*m = gcd(b, n).
Adapted from several sources:
https://brilliant.org/wiki/extended-euclidean-algorithm/
https://rosettacode.org/wiki/Modular_inverse
https://en.wikibooks.org/wiki/Algorithm_Imp... |
Add the needed transformations and supressions. | def register(linter):
"""Add the needed transformations and supressions.
"""
linter.register_checker(MongoEngineChecker(linter))
add_transform('mongoengine')
add_transform('mongomotor')
suppress_qs_decorator_messages(linter)
suppress_fields_attrs_messages(linter) |
Transpose all channels and output a csv that is easier to read and do charting on | def output_as_csv(file_name, nmi=None, output_file=None):
"""
Transpose all channels and output a csv that is easier
to read and do charting on
:param file_name: The NEM file to process
:param nmi: Which NMI to output if more than one
:param output_file: Specify different output location
:r... |
Fetch row using primary key - will use existing object in session if already present | def get(cls, group_id, db_session=None):
"""
Fetch row using primary key -
will use existing object in session if already present
:param group_id:
:param db_session:
:return:
"""
db_session = get_db_session(db_session)
return db_session.query(cls.... |
fetch group by name | def by_group_name(cls, group_name, db_session=None):
"""
fetch group by name
:param group_name:
:param db_session:
:return:
"""
db_session = get_db_session(db_session)
query = db_session.query(cls.model).filter(cls.model.group_name == group_name)
... |
returns paginator over users belonging to the group | def get_user_paginator(
cls,
instance,
page=1,
item_count=None,
items_per_page=50,
user_ids=None,
GET_params=None,
):
"""
returns paginator over users belonging to the group
:param instance:
:param page:
:param item_cou... |
returns list of permissions and resources for this group resource_ids restricts the search to specific resources | def resources_with_possible_perms(
cls,
instance,
perm_names=None,
resource_ids=None,
resource_types=None,
db_session=None,
):
"""
returns list of permissions and resources for this group,
resource_ids restricts the search to specific resou... |
创建支持上下文管理的pool | def create_pool(
database,
minsize=1,
maxsize=10,
echo=False,
loop=None,
**kwargs
):
"""
创建支持上下文管理的pool
"""
coro = _create_pool(
database=database,
minsize=minsize,
maxsize=maxsize,
echo=echo,
loop=loop,
**kw... |
Wait for closing all pool s connections. | def wait_closed(self):
"""
Wait for closing all pool's connections.
"""
if self._closed:
return
if not self._closing:
raise RuntimeError(
".wait_closed() should be called "
"after .close()"
)
while self.... |
同步关闭 | def sync_close(self):
"""
同步关闭
"""
if self._closed:
return
while self._free:
conn = self._free.popleft()
if not conn.closed:
# pragma: no cover
conn.sync_close()
for conn in self._used:
if not... |
iterate over free connections and remove timeouted ones | def _fill_free_pool(self, override_min):
"""
iterate over free connections and remove timeouted ones
"""
while self.size < self.minsize:
self._acquiring += 1
try:
conn = yield from connect(
database=self._database,
... |
Adds the function to the list of registered functions. | def add_function(self, function):
"""
Adds the function to the list of registered functions.
"""
function = self.build_function(function)
if function.name in self.functions:
raise FunctionAlreadyRegistered(function.name)
self.functions[function.name] = functio... |
Returns a function if it is registered the context is ignored. | def get_one(self, context, name):
"""
Returns a function if it is registered, the context is ignored.
"""
try:
return self.functions[name]
except KeyError:
raise FunctionNotFound(name) |
Verbatim copy from: https:// github. com/ django/ django/ blob/ 1. 9. 13/ django/ db/ models/ fields/ subclassing. py#L38 | def subfield_get(self, obj, type=None):
"""
Verbatim copy from:
https://github.com/django/django/blob/1.9.13/django/db/models/fields/subclassing.py#L38
"""
if obj is None:
return self
return obj.__dict__[self.field.name] |
Replace generic key related attribute with filters by object_id and content_type fields | def _preprocess_kwargs(self, initial_kwargs):
""" Replace generic key related attribute with filters by object_id and content_type fields """
kwargs = initial_kwargs.copy()
generic_key_related_kwargs = self._get_generic_key_related_kwargs(initial_kwargs)
for key, value in generic_key_rel... |
: param data:: param col_name:: param new_col_name:: param categories:: param max_categories: max proportion threshold of categories: return: new categories: rtype dict: | def categorize(
data, col_name: str = None, new_col_name: str = None,
categories: dict = None, max_categories: float = 0.15
):
"""
:param data:
:param col_name:
:param new_col_name:
:param categories:
:param max_categories: max proportion threshold of categories
:return: new categori... |
Remove columns with more NA values than threshold level | def dropna(data: pd.DataFrame, axis: int, **params):
"""
Remove columns with more NA values than threshold level
:param data:
:param axis:
Axes are defined for arrays with more than one dimension.
A 2-dimensional array has two corresponding axes: the first running
vertically downwards... |
Remove columns with more NA values than threshold level | def dropna_columns(data: pd.DataFrame, max_na_values: int=0.15):
"""
Remove columns with more NA values than threshold level
:param data:
:param max_na_values: proportion threshold of max na values
:return:
"""
size = data.shape[0]
df_na = (data.isnull().sum()/size) >= max_na_values
... |
Remove columns with more NA values than threshold level | def dropna_rows(data: pd.DataFrame, columns_name: str=None):
"""
Remove columns with more NA values than threshold level
:param data:
:param columns_name:
:return:
"""
params = {}
if columns_name is not None:
params.update({'subset': columns_name.split(',')})
data.dropna(in... |
Remove columns when the proportion of the total of unique values is more than the max_unique_values threshold just for columns with type as object or category | def drop_columns_with_unique_values(
data: pd.DataFrame, max_unique_values: int = 0.25
):
"""
Remove columns when the proportion
of the total of unique values is more than the max_unique_values
threshold, just for columns with type as object or category
:param data:
:param max_unique_values... |
To get an actual value for object quotas limit and usage issue a ** GET ** request against */ api/ <objects >/ *. | def list(self, request, *args, **kwargs):
"""
To get an actual value for object quotas limit and usage issue a **GET** request against */api/<objects>/*.
To get all quotas visible to the user issue a **GET** request against */api/quotas/*
"""
return super(QuotaViewSet, self).lis... |
To set quota limit issue a ** PUT ** request against */ api/ quotas/ <quota uuid > ** with limit values. | def retrieve(self, request, *args, **kwargs):
"""
To set quota limit issue a **PUT** request against */api/quotas/<quota uuid>** with limit values.
Please note that if a quota is a cache of a backend quota (e.g. 'storage' size of an OpenStack tenant),
it will be impossible to modify it ... |
Historical data endpoints could be available for any objects ( currently implemented for quotas and events count ). The data is available at * <object_endpoint >/ history/ * for example: */ api/ quotas/ <uuid >/ history/ *. | def history(self, request, uuid=None):
"""
Historical data endpoints could be available for any objects (currently
implemented for quotas and events count). The data is available at *<object_endpoint>/history/*,
for example: */api/quotas/<uuid>/history/*.
There are two ways to d... |
Gets object url | def _get_url(self, obj):
"""
Gets object url
"""
format_kwargs = {
'app_label': obj._meta.app_label,
}
try:
format_kwargs['model_name'] = getattr(obj.__class__, 'get_url_name')()
except AttributeError:
format_kwargs['model_name'... |
Serializes any object to his url representation | def to_representation(self, obj):
"""
Serializes any object to his url representation
"""
kwargs = None
for field in self.lookup_fields:
if hasattr(obj, field):
kwargs = {field: getattr(obj, field)}
break
if kwargs is None:
... |
Restores model instance from its url | def to_internal_value(self, data):
"""
Restores model instance from its url
"""
if not data:
return None
request = self._get_request()
user = request.user
try:
obj = core_utils.instance_from_url(data, user=user)
model = obj.__cl... |
Check that the start is before the end. | def validate(self, data):
"""
Check that the start is before the end.
"""
if 'start' in data and 'end' in data and data['start'] >= data['end']:
raise serializers.ValidationError(_('End must occur after start.'))
return data |
A helper function to deal with waldur_core high - level tasks. Define high - level task with explicit name using a pattern: waldur_core. <app_label >. <task_name > | def send_task(app_label, task_name):
""" A helper function to deal with waldur_core "high-level" tasks.
Define high-level task with explicit name using a pattern:
waldur_core.<app_label>.<task_name>
.. code-block:: python
@shared_task(name='waldur_core.openstack.provision_instan... |
Add description to celery log output | def log_celery_task(request):
""" Add description to celery log output """
task = request.task
description = None
if isinstance(task, Task):
try:
description = task.get_description(*request.args, **request.kwargs)
except NotImplementedError:
pass
except Ex... |
Deserialize input data and start backend operation execution | def run(self, serialized_instance, *args, **kwargs):
""" Deserialize input data and start backend operation execution """
try:
instance = utils.deserialize_instance(serialized_instance)
except ObjectDoesNotExist:
message = ('Cannot restore instance from serialized object ... |
Return True if exist task that is equal to current and is uncompleted | def is_previous_task_processing(self, *args, **kwargs):
""" Return True if exist task that is equal to current and is uncompleted """
app = self._get_app()
inspect = app.control.inspect()
active = inspect.active() or {}
scheduled = inspect.scheduled() or {}
reserved = ins... |
Do not run background task if previous task is uncompleted | def apply_async(self, args=None, kwargs=None, **options):
""" Do not run background task if previous task is uncompleted """
if self.is_previous_task_processing(*args, **kwargs):
message = 'Background task %s was not scheduled, because its predecessor is not completed yet.' % self.name
... |
Returns key to be used in cache | def _get_cache_key(self, args, kwargs):
""" Returns key to be used in cache """
hash_input = json.dumps({'name': self.name, 'args': args, 'kwargs': kwargs}, sort_keys=True)
# md5 is used for internal caching, not need to care about security
return hashlib.md5(hash_input).hexdigest() |
Checks whether task must be skipped and decreases the counter in that case. | def apply_async(self, args=None, kwargs=None, **options):
"""
Checks whether task must be skipped and decreases the counter in that case.
"""
key = self._get_cache_key(args, kwargs)
counter, penalty = cache.get(key, (0, 0))
if not counter:
return super(Penaliz... |
Increases penalty for the task and resets the counter. | def on_failure(self, exc, task_id, args, kwargs, einfo):
"""
Increases penalty for the task and resets the counter.
"""
key = self._get_cache_key(args, kwargs)
_, penalty = cache.get(key, (0, 0))
if penalty < self.MAX_PENALTY:
penalty += 1
logger.debu... |
Clears cache for the task. | def on_success(self, retval, task_id, args, kwargs):
"""
Clears cache for the task.
"""
key = self._get_cache_key(args, kwargs)
if cache.get(key) is not None:
cache.delete(key)
logger.debug('Penalty for the task %s has been removed.' % self.name)
... |
Logging for backend method. | def log_backend_action(action=None):
""" Logging for backend method.
Expects django model instance as first argument.
"""
def decorator(func):
@functools.wraps(func)
def wrapped(self, instance, *args, **kwargs):
action_name = func.func_name.replace('_', ' ') if action is Non... |
Get a list of services endpoints. { Oracle:/ api/ oracle/ OpenStack:/ api/ openstack/ GitLab:/ api/ gitlab/ DigitalOcean:/ api/ digitalocean/ } | def get_services(cls, request=None):
""" Get a list of services endpoints.
{
"Oracle": "/api/oracle/",
"OpenStack": "/api/openstack/",
"GitLab": "/api/gitlab/",
"DigitalOcean": "/api/digitalocean/"
}
"""
retu... |
Get a list of resources endpoints. { DigitalOcean. Droplet:/ api/ digitalocean - droplets/ Oracle. Database:/ api/ oracle - databases/ GitLab. Group:/ api/ gitlab - groups/ GitLab. Project:/ api/ gitlab - projects/ } | def get_resources(cls, request=None):
""" Get a list of resources endpoints.
{
"DigitalOcean.Droplet": "/api/digitalocean-droplets/",
"Oracle.Database": "/api/oracle-databases/",
"GitLab.Group": "/api/gitlab-groups/",
"GitLab.Project": ... |
Get a list of services and resources endpoints. {... GitLab: { url:/ api/ gitlab/ service_project_link_url:/ api/ gitlab - service - project - link/ resources: { Project:/ api/ gitlab - projects/ Group:/ api/ gitlab - groups/ } }... } | def get_services_with_resources(cls, request=None):
""" Get a list of services and resources endpoints.
{
...
"GitLab": {
"url": "/api/gitlab/",
"service_project_link_url": "/api/gitlab-service-project-link/",
... |
Get a list of service models. {... gitlab: { service: nodeconductor_gitlab. models. GitLabService service_project_link: nodeconductor_gitlab. models. GitLabServiceProjectLink resources: [ nodeconductor_gitlab. models. Group nodeconductor_gitlab. models. Project ] }... } | def get_service_models(cls):
""" Get a list of service models.
{
...
'gitlab': {
"service": nodeconductor_gitlab.models.GitLabService,
"service_project_link": nodeconductor_gitlab.models.GitLabServiceProjectLink,
... |
Get a list of resource models. { DigitalOcean. Droplet: waldur_digitalocean. models. Droplet JIRA. Project: waldur_jira. models. Project OpenStack. Tenant: waldur_openstack. models. Tenant } | def get_resource_models(cls):
""" Get a list of resource models.
{
'DigitalOcean.Droplet': waldur_digitalocean.models.Droplet,
'JIRA.Project': waldur_jira.models.Project,
'OpenStack.Tenant': waldur_openstack.models.Tenant
}
"""
... |
Get resource models by service model | def get_service_resources(cls, model):
""" Get resource models by service model """
key = cls.get_model_key(model)
return cls.get_service_name_resources(key) |
Get resource models by service name | def get_service_name_resources(cls, service_name):
""" Get resource models by service name """
from django.apps import apps
resources = cls._registry[service_name]['resources'].keys()
return [apps.get_model(resource) for resource in resources] |
Get a name for given class or model: -- it s a service type for a service -- it s a <service_type >. <resource_model_name > for a resource | def get_name_for_model(cls, model):
""" Get a name for given class or model:
-- it's a service type for a service
-- it's a <service_type>.<resource_model_name> for a resource
"""
key = cls.get_model_key(model)
model_str = cls._get_model_str(model)
service... |
Get a dictionary with related structure models for given class or model: | def get_related_models(cls, model):
""" Get a dictionary with related structure models for given class or model:
>> SupportedServices.get_related_models(gitlab_models.Project)
{
'service': nodeconductor_gitlab.models.GitLabService,
'service_project_link':... |
Check is model app name is in list of INSTALLED_APPS | def _is_active_model(cls, model):
""" Check is model app name is in list of INSTALLED_APPS """
# We need to use such tricky way to check because of inconsistent apps names:
# some apps are included in format "<module_name>.<app_name>" like "waldur_core.openstack"
# other apps are include... |
Send events as push notification via Google Cloud Messaging. Expected settings as follows: | def process(self, event):
""" Send events as push notification via Google Cloud Messaging.
Expected settings as follows:
# https://developers.google.com/mobile/add
WALDUR_CORE['GOOGLE_API'] = {
'NOTIFICATION_TITLE': "Waldur notification",
... |
Extracts context data from request headers according to specified schema. | def get_context_data_from_headers(request, headers_schema):
"""
Extracts context data from request headers according to specified schema.
>>> from lxml import etree as et
>>> from datetime import date
>>> from pyws.functions.args import TypeFactory
>>> Fake = type('Fake', (object, ), {})
>>... |
Decorator to make a function that takes no arguments use the LazyConstant class. | def lazy_constant(fn):
"""Decorator to make a function that takes no arguments use the LazyConstant class."""
class NewLazyConstant(LazyConstant):
@functools.wraps(fn)
def __call__(self):
return self.get_value()
return NewLazyConstant(fn) |
Decorator that adds an LRU cache of size maxsize to the decorated function. | def lru_cache(maxsize=128, key_fn=None):
"""Decorator that adds an LRU cache of size maxsize to the decorated function.
maxsize is the number of different keys cache can accomodate.
key_fn is the function that builds key from args. The default key function
creates a tuple out of args and kwargs. If you... |
Decorator that adds caching to an instance method. | def cached_per_instance():
"""Decorator that adds caching to an instance method.
The cached value is stored so that it gets garbage collected together with the instance.
The cached values are not stored when the object is pickled.
"""
def cache_fun(fun):
argspec = inspect2.getfullargspec... |
Generates a cache key from the passed in arguments. | def get_args_tuple(args, kwargs, arg_names, kwargs_defaults):
"""Generates a cache key from the passed in arguments."""
args_list = list(args)
args_len = len(args)
all_args_len = len(arg_names)
try:
while args_len < all_args_len:
arg_name = arg_names[args_len]
if arg_... |
Computes a kwargs_defaults dictionary for use by get_args_tuple given an argspec. | def get_kwargs_defaults(argspec):
"""Computes a kwargs_defaults dictionary for use by get_args_tuple given an argspec."""
arg_names = tuple(argspec.args)
defaults = argspec.defaults or ()
num_args = len(argspec.args) - len(defaults)
kwargs_defaults = {}
for i, default_value in enumerate(defaults... |
Memoizes return values of the decorated function. | def memoize(fun):
"""Memoizes return values of the decorated function.
Similar to l0cache, but the cache persists for the duration of the process, unless clear_cache()
is called on the function.
"""
argspec = inspect2.getfullargspec(fun)
arg_names = argspec.args + argspec.kwonlyargs
kwargs... |
Memoizes return values of the decorated function for a given time - to - live. | def memoize_with_ttl(ttl_secs=60 * 60 * 24):
"""Memoizes return values of the decorated function for a given time-to-live.
Similar to l0cache, but the cache persists for the duration of the process, unless clear_cache()
is called on the function or the time-to-live expires. By default, the time-to-live is ... |
Returns the value of the constant. | def get_value(self):
"""Returns the value of the constant."""
if self.value is not_computed:
self.value = self.value_provider()
if self.value is not_computed:
return None
return self.value |
Computes the value. Does not look at the cache. | def compute(self):
"""Computes the value. Does not look at the cache."""
self.value = self.value_provider()
if self.value is not_computed:
return None
else:
return self.value |
Return the value for given key if it exists. | def get(self, key, default=miss):
"""Return the value for given key if it exists."""
if key not in self._dict:
return default
# invokes __getitem__, which updates the item
return self[key] |
Empty the cache and optionally invoke item_evicted callback. | def clear(self, omit_item_evicted=False):
"""Empty the cache and optionally invoke item_evicted callback."""
if not omit_item_evicted:
items = self._dict.items()
for key, value in items:
self._evict_item(key, value)
self._dict.clear() |
Compatibility wrapper for the loop. create_future () call introduced in 3. 5. 2. | def create_future(loop):
# pragma: no cover
"""Compatibility wrapper for the loop.create_future() call introduced in
3.5.2."""
if hasattr(loop, 'create_future'):
return loop.create_future()
return asyncio.Future(loop=loop) |
Compatibility wrapper for the loop. create_task () call introduced in 3. 4. 2. | def create_task(coro, loop):
# pragma: no cover
"""Compatibility wrapper for the loop.create_task() call introduced in
3.4.2."""
if hasattr(loop, 'create_task'):
return loop.create_task(coro)
return asyncio.Task(coro, loop=loop) |
为类添加代理属性 | def proxy_property_directly(bind_attr, attrs):
"""
为类添加代理属性
"""
def cls_builder(cls):
"""
添加到类
"""
for attr_name in attrs:
setattr(cls, attr_name, _make_proxy_property(bind_attr, attr_name))
return cls
return cls_builder |
Return query dictionary to search objects available to user. | def get_permitted_objects_uuids(cls, user):
"""
Return query dictionary to search objects available to user.
"""
uuids = filter_queryset_for_user(cls.objects.all(), user).values_list('uuid', flat=True)
key = core_utils.camel_case_to_underscore(cls.__name__) + '_uuid'
retu... |
Checks whether user has role in entity. timestamp can have following values: - False - check whether user has role in entity at the moment. - None - check whether user has permanent role in entity. - Datetime object - check whether user will have role in entity at specific timestamp. | def has_user(self, user, role=None, timestamp=False):
"""
Checks whether user has role in entity.
`timestamp` can have following values:
- False - check whether user has role in entity at the moment.
- None - check whether user has permanent role in entity.
- ... |
Identify the contents of buf | def from_buffer(self, buf):
"""
Identify the contents of `buf`
"""
with self.lock:
try:
# if we're on python3, convert buf to bytes
# otherwise this string is passed as wchar*
# which is not what libmagic expects
... |
Starts listening to events. | def start(self, timeout=None, root_object=None):
""" Starts listening to events.
Args:
timeout (int): number of seconds before timeout. Used for testing purpose only.
root_object (bambou.NURESTRootObject): NURESTRootObject object that is listening. Used for testing p... |
Stops listening for events. | def stop(self):
""" Stops listening for events. """
if not self._is_running:
return
pushcenter_logger.debug("[NURESTPushCenter] Stopping...")
self._thread.stop()
self._thread.join()
self._is_running = False
self._current_connection = None
s... |
Wait until thread exit | def wait_until_exit(self):
""" Wait until thread exit
Used for testing purpose only
"""
if self._timeout is None:
raise Exception("Thread will never exit. Use stop or specify timeout when starting it!")
self._thread.join()
self.stop() |
Receive an event from connection | def _did_receive_event(self, connection):
""" Receive an event from connection """
if not self._is_running:
return
if connection.has_timeouted:
return
response = connection.response
data = None
if response.status_code != 200:
pushce... |
Listen a connection uuid | def _listen(self, uuid=None, session=None):
""" Listen a connection uuid """
if self.url is None:
raise Exception("NURESTPushCenter needs to have a valid URL. please use setURL: before starting it.")
events_url = "%s/events" % self.url
if uuid:
events_url = "%s?... |
Registers a new delegate callback | def add_delegate(self, callback):
""" Registers a new delegate callback
The prototype should be function(data), where data will be the decoded json push
Args:
callback (function): method to trigger when push center receives events
"""
if callback in sel... |
Unregisters a registered delegate function or a method. | def remove_delegate(self, callback):
""" Unregisters a registered delegate function or a method.
Args:
callback(function): method to trigger when push center receives events
"""
if callback not in self._delegate_methods:
return
self._delegate_me... |
Reads the configuration file if any | def _read_config(cls):
""" Reads the configuration file if any
"""
cls._config_parser = configparser.ConfigParser()
cls._config_parser.read(cls._default_attribute_values_configuration_file_path) |
Gets the default value of a given property for a given object. | def get_default_attribute_value(cls, object_class, property_name, attr_type=str):
""" Gets the default value of a given property for a given object.
These properties can be set in a config INI file looking like
.. code-block:: ini
[NUEntity]
default_beh... |
Filter each resource separately using its own filter | def filter(self, request, queryset, view):
""" Filter each resource separately using its own filter """
summary_queryset = queryset
filtered_querysets = []
for queryset in summary_queryset.querysets:
filter_class = self._get_filter(queryset)
queryset = filter_clas... |
This function creates a standard form type from a simplified form. | def TypeFactory(type_):
"""
This function creates a standard form type from a simplified form.
>>> from datetime import date, datetime
>>> from pyws.functions.args import TypeFactory
>>> from pyws.functions.args import String, Integer, Float, Date, DateTime
>>> TypeFactory(str) == String
Tr... |
Generate empty image in temporary file for testing | def dummy_image(filetype='gif'):
""" Generate empty image in temporary file for testing """
# 1x1px Transparent GIF
GIF = 'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'
tmp_file = tempfile.NamedTemporaryFile(suffix='.%s' % filetype)
tmp_file.write(base64.b64decode(GIF))
return open(t... |
Gets time delta in microseconds. | def utime_delta(days=0, hours=0, minutes=0, seconds=0):
"""Gets time delta in microseconds.
Note: Do NOT use this function without keyword arguments.
It will become much-much harder to add extra time ranges later if positional arguments are used.
"""
return (days * DAY) + (hours * HOUR) + (minutes... |
Executes specified function with timeout. Uses SIGALRM to interrupt it. | def execute_with_timeout(
fn,
args=None,
kwargs=None,
timeout=None,
fail_if_no_timer=True,
signal_type=_default_signal_type,
timer_type=_default_timer_type,
timeout_exception_cls=TimeoutError,
):
"""
Executes specified function with timeout. Uses SIGALRM to interrupt it.
:ty... |
Gets the very original function of a decorated one. | def get_original_fn(fn):
"""Gets the very original function of a decorated one."""
fn_type = type(fn)
if fn_type is classmethod or fn_type is staticmethod:
return get_original_fn(fn.__func__)
if hasattr(fn, "original_fn"):
return fn.original_fn
if hasattr(fn, "fn"):
fn.origi... |
Gets full class or function name. | def get_full_name(src):
"""Gets full class or function name."""
if hasattr(src, "_full_name_"):
return src._full_name_
if hasattr(src, "is_decorator"):
# Our own decorator or binder
if hasattr(src, "decorator"):
# Our own binder
_full_name_ = str(src.decorato... |
Converts method call ( function and its arguments ) to a str (... ) - like string. | def get_function_call_str(fn, args, kwargs):
"""Converts method call (function and its arguments) to a str(...)-like string."""
def str_converter(v):
try:
return str(v)
except Exception:
try:
return repr(v)
except Exception:
re... |
Converts method call ( function and its arguments ) to a repr (... ) - like string. | def get_function_call_repr(fn, args, kwargs):
"""Converts method call (function and its arguments) to a repr(...)-like string."""
result = get_full_name(fn) + "("
first = True
for v in args:
if first:
first = False
else:
result += ","
result += repr(v)
... |
Variation of inspect. getargspec that works for more functions. | def getargspec(func):
"""Variation of inspect.getargspec that works for more functions.
This function works for Cythonized, non-cpdef functions, which expose argspec information but
are not accepted by getargspec. It also works for Python 3 functions that use annotations, which
are simply ignored. Howe... |
Returns whether this function is either a generator function or a Cythonized function. | def is_cython_or_generator(fn):
"""Returns whether this function is either a generator function or a Cythonized function."""
if hasattr(fn, "__func__"):
fn = fn.__func__ # Class method, static method
if inspect.isgeneratorfunction(fn):
return True
name = type(fn).__name__
return (
... |
Checks if a function is compiled w/ Cython. | def is_cython_function(fn):
"""Checks if a function is compiled w/Cython."""
if hasattr(fn, "__func__"):
fn = fn.__func__ # Class method, static method
name = type(fn).__name__
return (
name == "method_descriptor"
or name == "cython_function_or_method"
or name == "builti... |
Returns whether f is a classmethod. | def is_classmethod(fn):
"""Returns whether f is a classmethod."""
# This is True for bound methods
if not inspect.ismethod(fn):
return False
if not hasattr(fn, "__self__"):
return False
im_self = fn.__self__
# This is None for instance methods on classes, but True
# for insta... |
Cython - compatible functools. wraps implementation. | def wraps(
wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, updated=functools.WRAPPER_UPDATES
):
"""Cython-compatible functools.wraps implementation."""
if not is_cython_function(wrapped):
return functools.wraps(wrapped, assigned, updated)
else:
return lambda wrapper: wrapper |
Returns all subclasses ( direct and recursive ) of cls. | def get_subclass_tree(cls, ensure_unique=True):
"""Returns all subclasses (direct and recursive) of cls."""
subclasses = []
# cls.__subclasses__() fails on classes inheriting from type
for subcls in type.__subclasses__(cls):
subclasses.append(subcls)
subclasses.extend(get_subclass_tree(s... |
This function creates a dict type with the specified name and fields. | def DictOf(name, *fields):
"""
This function creates a dict type with the specified name and fields.
>>> from pyws.functions.args import DictOf, Field
>>> dct = DictOf(
... 'HelloWorldDict', Field('hello', str), Field('hello', int))
>>> issubclass(dct, Dict)
True
>>> dct.__name__
... |
This function creates a list type with element type element_type and an empty element value element_none_value. | def ListOf(element_type, element_none_value=None):
"""
This function creates a list type with element type ``element_type`` and an
empty element value ``element_none_value``.
>>> from pyws.functions.args import Integer, ListOf
>>> lst = ListOf(int)
>>> issubclass(lst, List)
True
>>> lst... |
Return metadata for resource - specific actions such as start stop unlink | def get_actions(self, request, view):
"""
Return metadata for resource-specific actions,
such as start, stop, unlink
"""
metadata = OrderedDict()
actions = self.get_resource_actions(view)
resource = view.get_object()
for action_name, action in actions.ite... |
Get fields exposed by action s serializer | def get_action_fields(self, view, action_name, resource):
"""
Get fields exposed by action's serializer
"""
serializer = view.get_serializer(resource)
fields = OrderedDict()
if not isinstance(serializer, view.serializer_class) or action_name == 'update':
field... |
Given an instance of a serializer return a dictionary of metadata about its fields. | def get_serializer_info(self, serializer):
"""
Given an instance of a serializer, return a dictionary of metadata
about its fields.
"""
if hasattr(serializer, 'child'):
# If this is a `ListSerializer` then we want to examine the
# underlying child serializ... |
Get fields metadata skipping empty fields | def get_fields(self, serializer_fields):
"""
Get fields metadata skipping empty fields
"""
fields = OrderedDict()
for field_name, field in serializer_fields.items():
# Skip tags field in action because it is needed only for resource creation
# See also: WA... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.