class Mapped(with_metaclass(ABCMeta)):
@classmethod
def of(cls, *args, **kwargs):
return Mapped._of(cls, *args, **kwargs)
@staticmethod
def _of(cls, *args, **kwargs):
final_args = cls.defaults()
final_args.update(*args)
final_args.update(
{cls.mappings().get(k, k): v
for k, v in kwargs.items()})
try:
return cls.factory(**final_args)
except Exception as e:
pass
factory = None
@staticmethod
def mappings():
return None
@staticmethod
def defaults():
return None
class Forwarder(with_metaclass(ABCMeta)):
def forward_args(
self,
arg_vars, # type: Optional[Dict[str,Any]]
*options # type: OptionBlockDeriv
):
# type: (...) -> OptionBlockDeriv[str,Any]
arg_vars = copy.copy(arg_vars) if arg_vars else {}
temp_options = copy.copy(
options[0]) if (options and options[0]) else OptionBlock()
kwargs = arg_vars.pop('kwargs', {})
temp_options.update(kwargs)
temp_options.update(arg_vars)
end_options = {}
for k, v in temp_options.items():
map_item = self.arg_mapping().get(k, None)
if not (map_item is None):
for out_k, out_f in map_item.items():
converted = out_f(v)
if converted is not None:
end_options[out_k] = converted
else:
end_options[k] = v
return end_options
@abstractmethod
def arg_mapping(self):
pass
class AsyncBucket(with_metaclass(CoreAsyncBucketFactory, Bucket)):
def __init__(self, *args, **kwargs):
super(AsyncBucket, self).__init__(*args, **kwargs)
def query(self, *args, **kwargs):
"""
Reimplemented from base class.
This method does not add additional functionality of the
base class' :meth:`~couchbase_v2.bucket.Bucket.query` method (all the
functionality is encapsulated in the view class anyway). However it
does require one additional keyword argument
:param class itercls: A class used for instantiating the view
object. This should be a subclass of
:class:`~couchbase_v2.asynchronous.view.AsyncViewBase`.
"""
if not issubclass(kwargs.get('itercls', None), AsyncViewBase):
raise ArgumentError.pyexc("itercls must be defined "
"and must be derived from AsyncViewBase")
return super(AsyncBucket, self).query(*args, **kwargs)
def endure(self, key, *args, **kwargs):
res = super(AsyncBucket, self).endure_multi([key], *args, **kwargs)
res._set_single()
return res
class SDK2AsyncMutationResult(with_metaclass(AsyncWrapper,
SDK2MutationResult)):
def __init__(
self,
sdk2_result # type: SDK2Result
):
# type (...)->None
super(SDK2AsyncMutationResult, self).__init__(sdk2_result)
class SDK2AsyncResult(with_metaclass(AsyncWrapper, SDK2GetResult)):
def __init__(
self,
sdk2_result, # type: SDK2Result
expiry=None, # type: Seconds
**kwargs):
kwargs['expiry'] = expiry
super(SDK2AsyncResult, self).__init__(sdk2_result, **kwargs)
class RoleAndDescription(with_metaclass(ABCMeta, Mapped)):
""" Associates a role with its name and description.
This is additional information only present in the "list available roles" response."""
factory = RawRoleAndDescription
@staticmethod
def defaults():
return {
'ce': True,
'bucket_name': None,
'scope_name': None,
'collection_name': None
}
@staticmethod
def mappings():
return {'desc': 'description', 'name': 'display_name'}
@property
@abstractmethod
def role(self):
# type: (...) -> Role
return None
@property
@abstractmethod
def ce(self):
# type: (...) -> Role
return None
@property
@abstractmethod
def display_name(self):
# type: (...) -> str
return None
@property
@abstractmethod
def description(self):
# type: (...) -> str
pass
@classmethod
def of(cls, *args, **kwargs):
return Mapped._of(cls, *args, **kwargs)
class Role(with_metaclass(ABCMeta, Mapped)):
"""A role identifies a specific permission. CAVEAT, # type: The properties of a role are likely to change with the introduction of collection-level permissions. Until then
here's what the accessor methods look like:
"""
factory = RawRole
@staticmethod
def defaults():
return {'bucket': None}
@staticmethod
def mappings():
return {'role': 'name'}
@property
@abstractmethod
def name(self):
pass
@property
@abstractmethod
def bucket(self):
pass
def __iter__(self):
return iter([self.name, self.bucket])
def __str__(self):
return Admin.role_to_str(self)
@classmethod
def decode(cls, param):
if isinstance(param, str):
param = Admin.str_to_role(param)
if isinstance(param, dict):
args = list(map(param.get, ('role', 'bucket')))
else:
args = param
return cls.factory(*args)
class V3CoreBucket(with_metaclass(AsyncBucketFactory, CoreAsyncBucket)):
def __init__(self, *args, **kwargs):
super(V3CoreBucket, self).__init__(*args, **kwargs)
class Bucket(with_metaclass(AsyncBucketFactory, V2AsyncBucket)):
def __init__(self, *args, **kwargs):
super(Bucket, self).__init__(*args, **kwargs)
class AsyncClient(with_metaclass(AsyncClientFactory, CoreClient)):
def __init__(self, *args, **kwargs):
super(AsyncClient, self).__init__(*args, **kwargs)
class AsyncCBCollection(with_metaclass(AsyncBucketFactory, BaseAsyncCBCollection)):
def __init__(self,
*args,
**kwargs
):
super(AsyncCBCollection, self).__init__(*args, **kwargs)
