PNG IHDR x sBIT|d pHYs + tEXtSoftware www.inkscape.org< ,tEXtComment
import asyncio
import errno
from enum import IntFlag
from queue import Queue
from typing import ClassVar
from .report import RecordSet
class Flags(IntFlag):
UNSPEC = 0
RO = 1
class Permit:
def __init__(self, *names: str):
self.names = names
def __iter__(self):
return iter(self.names)
class SyncBase:
permit_calls: ClassVar[Permit] = Permit('test')
def __init__(self, event_loop, obj, class_map=None, flags=Flags.UNSPEC):
self.event_loop = event_loop
self.asyncore = obj
self.flags = flags
self.class_map = {} if class_map is None else class_map
def check_permissions(self, name):
if name in self.permit_calls:
return
if self.flags & Flags.RO:
raise PermissionError('Access denied')
def _get_sync_class(self, item, key=None):
if key is None:
key = self.asyncore.table
return self.class_map.get(key, self.class_map.get('default'))(
self.event_loop, item, self.class_map, self.flags
)
async def _tm_sync_generator(self, queue, func, *argv, **kwarg):
for record in func(*argv, **kwarg):
queue.put(record)
queue.put(None)
def _main_sync_generator(self, func, *argv, **kwarg):
self.check_permissions(func.__name__)
queue = Queue()
task = asyncio.run_coroutine_threadsafe(
self._tm_sync_generator(queue, func, *argv, **kwarg),
self.event_loop,
)
while True:
record = queue.get()
if record is None:
return
yield record
ret = task.result()
if isinstance(ret, Exception):
raise ret
async def _tm_sync_call(self, func, *argv, **kwarg):
return func(*argv, **kwarg)
def _main_sync_call(self, func, *argv, **kwarg):
self.check_permissions(func.__name__)
task = asyncio.run_coroutine_threadsafe(
self._tm_sync_call(func, *argv, **kwarg), self.event_loop
)
ret = task.result()
if isinstance(ret, Exception):
raise ret
return ret
def _main_async_call(self, func, *argv, **kwarg):
self.check_permissions(func.__name__)
task = asyncio.run_coroutine_threadsafe(
func(*argv, **kwarg), self.event_loop
)
ret = task.result()
if isinstance(ret, Exception):
raise ret
return ret
def __eq__(self, other):
return self.asyncore == getattr(other, 'asyncore', None)
class SyncDB(SyncBase):
def export(self, f='stdout'):
return self._main_sync_call(self.asyncore.schema.export)
def backup(self, spec):
return self._main_sync_call(self.asyncore.schema.backup, spec)
def fetch(self, query):
return self._main_sync_generator(self.asyncore.schema.fetch, query)
def fetchone(self, query):
return self._main_sync_call(self.asyncore.schema.fetchone, query)
class SyncView(SyncBase):
permit_calls = Permit('summary', 'dump', '__getitem__')
def __getitem__(self, key, table=None):
item = self._main_sync_call(self.asyncore.__getitem__, key, table)
return self._get_sync_class(item)
def __contains__(self, key):
return key in self.keys()
def __iter__(self):
return self.keys()
def __len__(self):
return self._main_sync_call(self.asyncore.__len__)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
pass
@property
def cache(self):
return self.asyncore.cache
def get(self, spec=None, table=None, **kwarg):
item = self._main_sync_call(self.asyncore.get, spec, table, **kwarg)
if item is not None:
return self._get_sync_class(item)
def getmany(self, spec, table=None):
for item in tuple(
self._main_sync_generator(self.asyncore.getmany, spec, table)
):
yield item
def getone(self, spec, table=None):
return self._main_sync_call(self.asyncore.getone, spec, table)
def items(self):
for key in self.keys():
yield (key, self[key])
def keys(self):
for record in self.dump():
yield record
def count(self):
return self._main_sync_call(self.asyncore.count)
def create(self, *argspec, **kwarg):
item = self._main_sync_call(self.asyncore.create, *argspec, **kwarg)
return self._get_sync_class(item)
def ensure(self, *argspec, **kwarg):
item = self._main_sync_call(self.asyncore.ensure, *argspec, **kwarg)
return self._get_sync_class(item)
def add(self, *argspec, **kwarg):
item = self._main_sync_call(self.asyncore.add, *argspec, **kwarg)
return self._get_sync_class(item)
def wait(self, **spec):
item = self._main_async_call(self.asyncore.wait, **spec)
return self._get_sync_class(item)
def exists(self, key, table=None):
return self._main_sync_call(self.asyncore.exists, key, table)
def locate(self, spec=None, table=None, **kwarg):
item = self._main_sync_call(self.asyncore.locate, spec, table, **kwarg)
return self._get_sync_class(item)
def summary(self):
return RecordSet(self._main_sync_generator(self.asyncore.summary))
def dump(self):
return RecordSet(self._main_sync_generator(self.asyncore.dump))
class SyncSources(SyncView):
permit_calls = Permit('add', 'remove', 'keys', '__getitem__')
def __getitem__(self, key):
item = self._main_sync_call(self.asyncore.__getitem__, key)
return self._get_sync_class(item)
def add(self, **spec):
item = self._main_async_call(self.asyncore.add, **spec)
return self._get_sync_class(item)
def remove(self, target, code=errno.ECONNRESET, sync=True):
item = self._main_sync_call(self.asyncore.remove, target, code, sync)
return self._get_sync_class(item)
def keys(self):
for record in self.asyncore.keys():
yield record
b IDATxytVսϓ22 A@IR:hCiZ[v*E:WũZA ^dQeQ @ !jZ'>gsV仿$|?g)&x-E