def _init_subclass(cls,
serializer: str = None,
namespace: str = None,
include_metadata: bool = None,
isodates: bool = None,
abstract: bool = False,
allow_blessed_key: bool = None,
decimals: bool = None) -> None:
if abstract:
# Custom base classes can set this to skip class initialization.
cls.__is_abstract__ = True
return
cls.__is_abstract__ = False
# Can set serializer/namespace/etc. using:
# class X(Record, serializer='json', namespace='com.vandelay.X'):
# ...
try:
custom_options = cls.Options
except AttributeError:
custom_options = None
else:
delattr(cls, 'Options')
options = getattr(cls, '_options', None)
if options is None:
options = ModelOptions()
else:
options = options.clone_defaults()
if custom_options:
options.__dict__.update(custom_options.__dict__)
if serializer is not None:
options.serializer = serializer
if include_metadata is not None:
options.include_metadata = include_metadata
if isodates is not None:
options.isodates = isodates
if decimals is not None:
options.decimals = decimals
if allow_blessed_key is not None:
options.allow_blessed_key = allow_blessed_key
options.namespace = namespace or canoname(cls)
# Add introspection capabilities
cls._contribute_to_options(options)
# Add FieldDescriptors for every field.
cls._contribute_field_descriptors(cls, options)
# Store options on new subclass.
cls._options = options
cls._contribute_methods()
# Register in the global registry, so we can look up
# models by namespace.
registry[options.namespace] = cls
cls._model_init = cls._BUILD_init()
if '__init__' not in cls.__dict__:
cls.__init__ = cls._model_init
def test_canoname():
class X:
...
X.__module__ = "__main__"
x = X()
class Y:
...
y = Y()
assert canoname(X, main_name="faust") == "faust.test_canoname.<locals>.X"
assert canoname(x, main_name="faust") == "faust.test_canoname.<locals>.X"
assert canoname(Y, main_name="faust") == ".".join([
__name__,
"test_canoname.<locals>.Y",
])
assert canoname(y, main_name="faust") == ".".join([
__name__,
"test_canoname.<locals>.Y",
])
def test_canoname():
class X:
...
X.__module__ = '__main__'
x = X()
class Y:
...
y = Y()
assert canoname(X, main_name='faust') == 'faust.test_canoname.<locals>.X'
assert canoname(x, main_name='faust') == 'faust.test_canoname.<locals>.X'
assert canoname(Y, main_name='faust') == '.'.join([
__name__,
'test_canoname.<locals>.Y',
])
assert canoname(y, main_name='faust') == '.'.join([
__name__,
'test_canoname.<locals>.Y',
])
def __init__(self,
fun: AgentFun,
*,
app: AppT,
name: str = None,
channel: Union[str, ChannelT] = None,
concurrency: int = 1,
sink: Iterable[SinkT] = None,
on_error: AgentErrorHandler = None,
supervisor_strategy: Type[SupervisorStrategyT] = None,
help: str = None,
key_type: ModelArg = None,
value_type: ModelArg = None,
isolated_partitions: bool = False,
**kwargs: Any) -> None:
self.app = app
self.fun: AgentFun = fun
self.name = name or canoname(self.fun)
# key-type/value_type arguments only apply when a channel
# is not set
if key_type is not None:
assert channel is None or isinstance(channel, str)
self._key_type = key_type
if value_type is not None:
assert channel is None or isinstance(channel, str)
self._value_type = value_type
self._channel_arg = channel
self._channel_kwargs = kwargs
self.concurrency = concurrency or 1
self.isolated_partitions = isolated_partitions
self.help = help or ''
self._sinks = list(sink) if sink is not None else []
self._on_error: Optional[AgentErrorHandler] = on_error
self.supervisor_strategy = supervisor_strategy
self._actors = WeakSet()
self._actor_by_partition = WeakValueDictionary()
if self.isolated_partitions and self.concurrency > 1:
raise ImproperlyConfigured(
'Agent concurrency must be 1 when using isolated partitions')
ServiceProxy.__init__(self)
def _init_subclass(
cls,
serializer: str = None,
namespace: str = None,
include_metadata: bool = None,
isodates: bool = None,
abstract: bool = False,
allow_blessed_key: bool = None,
decimals: bool = None,
coerce: bool = None,
coercions: CoercionMapping = None,
polymorphic_fields: bool = None,
validation: bool = None,
date_parser: Callable[[Any], datetime] = None,
) -> None:
# Can set serializer/namespace/etc. using:
# class X(Record, serializer='json', namespace='com.vandelay.X'):
# ...
try:
custom_options = cls.Options
except AttributeError:
custom_options = None
else:
delattr(cls, "Options")
options = getattr(cls, "_options", None)
if options is None:
options = ModelOptions()
options.coercions = {}
options.defaults = {}
else:
options = options.clone_defaults()
if custom_options:
options.__dict__.update(custom_options.__dict__)
if coerce is not None:
options.coerce = coerce
if coercions is not None:
options.coercions.update(coercions)
if serializer is not None:
options.serializer = serializer
if include_metadata is not None:
options.include_metadata = include_metadata
if isodates is not None:
options.isodates = isodates
if decimals is not None:
options.decimals = decimals
if allow_blessed_key is not None:
options.allow_blessed_key = allow_blessed_key
if polymorphic_fields is not None:
options.polymorphic_fields = polymorphic_fields
if validation is not None:
options.validation = validation
options.coerce = True # validation implies coerce
if date_parser is not None:
options.date_parser = date_parser
options.namespace = namespace or canoname(cls)
if abstract:
# Custom base classes can set this to skip class initialization.
cls.__is_abstract__ = True
cls._options = options
cls.__init__ = cls.__abstract_init__ # type: ignore
return
cls.__is_abstract__ = False
# Add introspection capabilities
cls._contribute_to_options(options)
# Add FieldDescriptors for every field.
options.descriptors = cls._contribute_field_descriptors(cls, options)
# Store options on new subclass.
cls._options = options
cls._contribute_methods()
# Register in the global registry, so we can look up
# models by namespace.
registry[options.namespace] = cls
codegens = [
("__init__", cls._BUILD_init, "_model_init"),
("__hash__", cls._BUILD_hash, "_model_hash"),
("__eq__", cls._BUILD_eq, "_model_eq"),
("__ne__", cls._BUILD_ne, "_model_ne"),
("__gt__", cls._BUILD_gt, "_model_gt"),
("__ge__", cls._BUILD_ge, "_model_ge"),
("__lt__", cls._BUILD_lt, "_model_lt"),
("__le__", cls._BUILD_le, "_model_le"),
]
for meth_name, meth_gen, attr_name in codegens:
# self._model_init = cls._BUILD_init()
# if '__init__' not in cls.__dict__:
# cls.__init__ = self._model_init
meth = meth_gen()
setattr(cls, attr_name, meth)
if meth_name not in cls.__dict__:
setattr(cls, meth_name, meth)
