Search is not available for this dataset
text stringlengths 75 104k |
|---|
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... |
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... |
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_... |
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... |
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... |
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 ... |
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 |
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 |
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] |
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() |
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) |
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 |
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... |
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.
- ... |
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
... |
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... |
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... |
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() |
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... |
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?... |
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... |
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... |
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) |
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... |
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... |
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... |
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... |
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... |
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... |
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... |
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... |
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... |
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)
... |
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... |
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 (
... |
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... |
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... |
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 |
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... |
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__
... |
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... |
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... |
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... |
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... |
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... |
def get_field_info(self, field, field_name):
"""
Given an instance of a serializer field, return a dictionary
of metadata about it.
"""
field_info = OrderedDict()
field_info['type'] = self.label_lookup[field]
field_info['required'] = getattr(field, 'required', Fal... |
def connect(
database: str,
loop: asyncio.BaseEventLoop = None,
executor: concurrent.futures.Executor = None,
timeout: int = 5,
echo: bool = False,
isolation_level: str = '',
check_same_thread: bool = False,
**kwargs: dict
):
"""
把async方法执行后的对象创建为a... |
def recalculate_estimate(recalculate_total=False):
""" Recalculate price of consumables that were used by resource until now.
Regular task. It is too expensive to calculate consumed price on each
request, so we store cached price each hour.
If recalculate_total is True - task also recalcula... |
def get_data(self, path):
"""Needs to return the string source for the module."""
return LineCacheNotebookDecoder(
code=self.code, raw=self.raw, markdown=self.markdown
).decode(self.decode(), self.path) |
def loader(self):
"""Create a lazy loader source file loader."""
loader = super().loader
if self._lazy and (sys.version_info.major, sys.version_info.minor) != (3, 4):
loader = LazyLoader.factory(loader)
# Strip the leading underscore from slots
return partial(
... |
def load(cls, filename, dir=None, main=False, **kwargs):
"""Import a notebook as a module from a filename.
dir: The directory to load the file from.
main: Load the module in the __main__ context.
> assert Notebook.load('loader.ipynb')
"""
name = main and... |
def source_to_code(self, nodes, path, *, _optimize=-1):
"""* Convert the current source to ast
* Apply ast transformers.
* Compile the code."""
if not isinstance(nodes, ast.Module):
nodes = ast.parse(nodes, self.path)
if self._markdown_docstring:
nodes = ... |
def get_urls(self):
"""
Inject extra action URLs.
"""
urls = []
for action in self.get_extra_actions():
regex = r'^{}/$'.format(self._get_action_href(action))
view = self.admin_site.admin_view(action)
urls.append(url(regex, view))
ret... |
def changelist_view(self, request, extra_context=None):
"""
Inject extra links into template context.
"""
links = []
for action in self.get_extra_actions():
links.append({
'label': self._get_action_label(action),
'href': self._get_acti... |
def start(self):
"""
Starts the session.
Starting the session will actually get the API key of the current user
"""
if NURESTSession.session_stack:
bambou_logger.critical("Starting a session inside a with statement is not supported.")
raise Excep... |
def init_quotas(sender, instance, created=False, **kwargs):
""" Initialize new instances quotas """
if not created:
return
for field in sender.get_quotas_fields():
try:
field.get_or_create_quota(scope=instance)
except CreationConditionFailedQuotaError:
pass |
def count_quota_handler_factory(count_quota_field):
""" Creates handler that will recalculate count_quota on creation/deletion """
def recalculate_count_quota(sender, instance, **kwargs):
signal = kwargs['signal']
if signal == signals.post_save and kwargs.get('created'):
count_quota... |
def handle_aggregated_quotas(sender, instance, **kwargs):
""" Call aggregated quotas fields update methods """
quota = instance
# aggregation is not supported for global quotas.
if quota.scope is None:
return
quota_field = quota.get_field()
# usage aggregation should not count another us... |
def get_settings(self, link):
"""
URL of service settings
"""
return reverse(
'servicesettings-detail', kwargs={'uuid': link.service.settings.uuid}, request=self.context['request']) |
def get_url(self, link):
"""
URL of service
"""
view_name = SupportedServices.get_detail_view_for_model(link.service)
return reverse(view_name, kwargs={'uuid': link.service.uuid.hex}, request=self.context['request']) |
def get_resources_count(self, link):
"""
Count total number of all resources connected to link
"""
total = 0
for model in SupportedServices.get_service_resources(link.service):
# Format query path from resource to service project link
query = {model.Permis... |
def drop_columns(
self, max_na_values: int = None, max_unique_values: int = None
):
"""
When max_na_values was informed, remove columns when the proportion of
total NA values more than max_na_values threshold.
When max_unique_values was informed, remove columns when the prop... |
def dropna(self):
"""
:return:
"""
step = {
'data-set': self.iid,
'operation': 'drop-na',
'expression': '{"axis": 0}'
}
self.attr_update(attr='steps', value=[step]) |
def log(self, message: str):
"""
@deprecated
:param message:
:return:
"""
dset_log_id = '_%s_log' % self.iid
if dset_log_id not in self.parent.data.keys():
dset = self.parent.data.create_dataset(
dset_log_id, shape=(1,),
... |
def summary(self, compute=False) -> pd.DataFrame:
"""
:param compute: if should call compute method
:return:
"""
if compute or self.result is None:
self.compute()
return summary(self.result) |
def serve(request, server):
"""
Twisted Web adapter. It has two arguments:
#. ``request`` is a Twisted Web request object,
#. ``server`` is a pyws server object.
First one is the context of an application, function ``serve`` transforms
it into a pyws request object. Then it feeds the request t... |
def get_sorted_dependencies(service_model):
"""
Returns list of application models in topological order.
It is used in order to correctly delete dependent resources.
"""
app_models = list(service_model._meta.app_config.get_models())
dependencies = {model: set() for model in app_models}
relat... |
def update_pulled_fields(instance, imported_instance, fields):
"""
Update instance fields based on imported from backend data.
Save changes to DB only one or more fields were changed.
"""
modified = False
for field in fields:
pulled_value = getattr(imported_instance, field)
curre... |
def handle_resource_not_found(resource):
"""
Set resource state to ERRED and append/create "not found" error message.
"""
resource.set_erred()
resource.runtime_state = ''
message = 'Does not exist at backend.'
if message not in resource.error_message:
if not resource.error_message:
... |
def handle_resource_update_success(resource):
"""
Recover resource if its state is ERRED and clear error message.
"""
update_fields = []
if resource.state == resource.States.ERRED:
resource.recover()
update_fields.append('state')
if resource.state in (resource.States.UPDATING, r... |
def set_header(self, header, value):
""" Set header value """
# requests>=2.11 only accepts `str` or `bytes` header values
# raising an exception here, instead of leaving it to `requests` makes
# it easy to know where we passed a wrong header type in the code.
if not isinstance(v... |
def set_instance_erred(self, instance, error_message):
""" Mark instance as erred and save error message """
instance.set_erred()
instance.error_message = error_message
instance.save(update_fields=['state', 'error_message']) |
def map_language(language, dash3=True):
""" Use ISO 639-3 ?? """
if dash3:
from iso639 import languages
else:
from pycountry import languages
if '_' in language:
language = language.split('_')[0]
if len(language) == 2:
try: return languages.get(alpha2=language.lower(... |
def get_task_signature(cls, instance, serialized_instance, **kwargs):
"""
Delete each resource using specific executor.
Convert executors to task and combine all deletion task into single sequential task.
"""
cleanup_tasks = [
ProjectResourceCleanupTask().si(
... |
def sort_dict(unsorted_dict):
"""
Return a OrderedDict ordered by key names from the :unsorted_dict:
"""
sorted_dict = OrderedDict()
# sort items before inserting them into a dict
for key, value in sorted(unsorted_dict.items(), key=itemgetter(0)):
sorted_dict[key] = value
return sort... |
def format_time_and_value_to_segment_list(time_and_value_list, segments_count, start_timestamp,
end_timestamp, average=False):
"""
Format time_and_value_list to time segments
Parameters
^^^^^^^^^^
time_and_value_list: list of tuples
Have to be sorte... |
def serialize_instance(instance):
""" Serialize Django model instance """
model_name = force_text(instance._meta)
return '{}:{}'.format(model_name, instance.pk) |
def deserialize_instance(serialized_instance):
""" Deserialize Django model instance """
model_name, pk = serialized_instance.split(':')
model = apps.get_model(model_name)
return model._default_manager.get(pk=pk) |
def deserialize_class(serilalized_cls):
""" Deserialize Python class """
module_name, cls_name = serilalized_cls.split(':')
module = importlib.import_module(module_name)
return getattr(module, cls_name) |
def instance_from_url(url, user=None):
""" Restore instance from URL """
# XXX: This circular dependency will be removed then filter_queryset_for_user
# will be moved to model manager method
from waldur_core.structure.managers import filter_queryset_for_user
url = clear_url(url)
match = resolve... |
def close(self):
"""
Close this transaction.
If this transaction is the base transaction in a begin/commit
nesting, the transaction will rollback(). Otherwise, the
method returns.
This is used to cancel a Transaction without affecting the scope of
an enclosing ... |
def commit(self):
"""
Commit this transaction.
"""
if not self._parent._is_active:
raise exc.InvalidRequestError("This transaction is inactive")
yield from self._do_commit()
self._is_active = False |
def _get_app_config(self, app_name):
"""
Returns an app config for the given name, not by label.
"""
matches = [app_config for app_config in apps.get_app_configs()
if app_config.name == app_name]
if not matches:
return
return matches[0] |
def _get_app_version(self, app_config):
"""
Some plugins ship multiple applications and extensions.
However all of them have the same version, because they are released together.
That's why only-top level module is used to fetch version information.
"""
base_name = app_c... |
def _get_quick_access_info(self):
"""
Returns a list of ListLink items to be added to Quick Access tab.
Contains:
- links to Organizations, Projects and Users;
- a link to shared service settings;
- custom configured links in admin/settings FLUENT_DASHBOARD_QUICK_ACCESS_L... |
def _get_erred_shared_settings_module(self):
"""
Returns a LinkList based module which contains link to shared service setting instances in ERRED state.
"""
result_module = modules.LinkList(title=_('Shared provider settings in erred state'))
result_module.template = 'admin/dashbo... |
def _get_erred_resources_module(self):
"""
Returns a list of links to resources which are in ERRED state and linked to a shared service settings.
"""
result_module = modules.LinkList(title=_('Resources in erred state'))
erred_state = structure_models.NewResource.States.ERRED
... |
def serve(request, tail, server):
"""
Django adapter. It has three arguments:
#. ``request`` is a Django request object,
#. ``tail`` is everything that's left from an URL, which adapter is
attached to,
#. ``server`` is a pyws server object.
First two are the context of an application, f... |
def index(self, nurest_object):
""" Get index of the given item
Args:
nurest_object (bambou.NURESTObject): the NURESTObject object to verify
Returns:
Returns the position of the object.
Raises:
Raise a ValueError exception if ... |
def fetcher_with_object(cls, parent_object, relationship="child"):
""" Register the fetcher for a served object.
This method will fill the fetcher with `managed_class` instances
Args:
parent_object: the instance of the parent object to serve
Returns:
... |
def _prepare_headers(self, request, filter=None, order_by=None, group_by=[], page=None, page_size=None):
""" Prepare headers for the given request
Args:
request: the NURESTRequest to send
filter: string
order_by: string
group_by: list ... |
def fetch(self, filter=None, order_by=None, group_by=[], page=None, page_size=None, query_parameters=None, commit=True, async=False, callback=None):
""" Fetch objects according to given filter and page.
Note:
This method fetches all managed class objects and store them
... |
def _did_fetch(self, connection):
""" Fetching objects has been done """
self.current_connection = connection
response = connection.response
should_commit = 'commit' not in connection.user_info or connection.user_info['commit']
if connection.response.status_code >= 400 and Bamb... |
def get(self, filter=None, order_by=None, group_by=[], page=None, page_size=None, query_parameters=None, commit=True, async=False, callback=None):
""" Fetch object and directly return them
Note:
`get` won't put the fetched objects in the parent's children list.
You c... |
def get_first(self, filter=None, order_by=None, group_by=[], query_parameters=None, commit=False, async=False, callback=None):
""" Fetch object and directly return the first one
Note:
`get_first` won't put the fetched object in the parent's children list.
You cannot ... |
def count(self, filter=None, order_by=None, group_by=[], page=None, page_size=None, query_parameters=None, async=False, callback=None):
""" Get the total count of objects that can be fetched according to filter
This method can be asynchronous and trigger the callback method
when result ... |
def get_count(self, filter=None, order_by=None, group_by=[], page=None, page_size=None, query_parameters=None):
""" Get the total count of objects that can be fetched according to filter
Args:
filter (string): string that represents a predicate fitler (eg. name == 'x')
... |
def _did_count(self, connection):
""" Called when count if finished """
self.current_connection = connection
response = connection.response
count = 0
callback = None
if 'X-Nuage-Count' in response.headers:
count = int(response.headers['X-Nuage-Count'])
... |
def _send_content(self, content, connection):
""" Send a content array from the connection """
if connection:
if connection.async:
callback = connection.callbacks['remote']
if callback:
callback(self, self.parent_object, content)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.