def test_basic_local(): """Basic local object support""" l = Local() l.foo = 0 values = [] def value_setter(idx): time.sleep(0.01 * idx) l.foo = idx time.sleep(0.02) values.append(l.foo) threads = [Thread(target=value_setter, args=(x, )) for x in [1, 2, 3]] for thread in threads: thread.start() time.sleep(0.2) assert sorted(values) == [1, 2, 3] def delfoo(): del l.foo delfoo() assert_raises(AttributeError, lambda: l.foo) assert_raises(AttributeError, delfoo) release_local(l)
def test_local_release(): """Locals work without manager""" loc = Local() loc.foo = 42 release_local(loc) assert not hasattr(loc, 'foo') ls = LocalStack() ls.push(42) release_local(ls) assert ls.top is None
def __init__(self, *providers, name: str = None): self.name = name self._providers = providers self.importer = Importer() # Can't inject it, obviously. self.service_conf = {} self.app_conf = {} self.service_instances = {} self.service_classes = {} self.factory_classes = {} self._namespaces = {} self._service_names = [] self._local = Local()
class Context(object): locals = Local() local_manager = LocalManager([locals]) current_context = locals('context') def __init__(self, app, environ=None, request=None, args=None): self.app = app self.environ = environ self.request = request self.args = args self.response = None def __enter__(self): self.locals.context = self for fn in self.app.get_hook_functions('context-start'): fn(self) return self def __exit__(self, type, value, traceback): for fn in self.app.get_hook_functions('context-end'): fn(self) del self.locals.context
from rest_framework import serializers from rest_framework.utils.model_meta import get_field_info from rest_framework.serializers import raise_errors_on_nested_writes from rest_framework.utils import model_meta from api_basebone.core import drf_field, gmeta from api_basebone.core.fields import JSONField from jsonfield import JSONField as OriginJSONField from rest_framework.fields import JSONField as DrfJSONField from api_basebone.restful.const import CLIENT_END_SLUG, MANAGE_END_SLUG from api_basebone.utils import module from api_basebone.utils.gmeta import get_gmeta_config_by_key from werkzeug import Local rfu_modes = Local() compare_funcs = { '=': lambda a, b: a == b, '==': lambda a, b: a == b, '===': lambda a, b: a == b, '>': lambda a, b: a > b, '<': lambda a, b: a < b, 'in': lambda a, b: a in b, 'include': lambda a, b: b in a, } class BulkCreateListSerializer(serializers.ListSerializer): def create(self, validated_data): result = [self.child.create(attrs) for attrs in validated_data] # self.child.Meta.model.objects.bulk_create(result, ignore_conflicts=False)