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)
