def _contribute_to_options(cls, options: ModelOptions) -> None:
# Find attributes and their types, and create indexes for these.
# This only happens once when the class is created, so Faust
# models are fast at runtime.
fields, defaults = annotations(
cls,
stop=Record,
skip_classvar=True,
alias_types=ALIAS_FIELD_TYPES,
localns={cls.__name__: cls},
)
options.fields = cast(Mapping, fields)
options.fieldset = frozenset(fields)
options.fieldpos = {i: k for i, k in enumerate(fields.keys())}
is_concretely = _is_concretely
# extract all default values, but only for actual fields.
options.defaults = {
k: v.default if isinstance(v, FieldDescriptor) else v
for k, v in defaults.items() if k in fields
and not (isinstance(v, FieldDescriptor) and v.required)
}
options.models = {}
modelattrs = options.modelattrs = {}
for field, typ in fields.items():
is_model, polymorphic_type = _is_model(typ)
if is_model:
# Extract all model fields
options.models[field] = typ
# Create mapping of model fields to polymorphic types if
# available
modelattrs[field] = polymorphic_type
if is_optional(typ):
# Optional[X] also needs to be added to defaults mapping.
options.defaults.setdefault(field, None)
# Create frozenset index of default fields.
options.optionalset = frozenset(options.defaults)
# extract all fields that we want to coerce to a different type
# (decimals=True, isodates=True, coercions={MyClass: converter})
# Then move them to options.field_coerce, which is what the
# model.__init__ method uses to coerce any fields that need to
# be coerced.
options.field_coerce = {}
if options.isodates:
options.coercions.setdefault(DATE_TYPES, iso8601.parse)
if options.decimals:
options.coercions.setdefault(DECIMAL_TYPES, str_to_decimal)
for coerce_types, coerce_handler in options.coercions.items():
options.field_coerce.update({
field: TypeCoerce(typ, coerce_handler)
for field, typ in fields.items() if field not in modelattrs
and is_concretely(coerce_types, typ)
})
def _contribute_to_options(cls, options: ModelOptions) -> None:
# Find attributes and their types, and create indexes for these.
# This only happens once when the class is created, so Faust
# models are fast at runtime.
fields, defaults = annotations(
cls,
stop=Record,
skip_classvar=True,
alias_types=ALIAS_FIELD_TYPES,
localns={cls.__name__: cls},
)
options.fields = cast(Mapping, fields)
options.fieldset = frozenset(fields)
options.fieldpos = {i: k for i, k in enumerate(fields.keys())}
# extract all default values, but only for actual fields.
options.defaults = {
k: v.default if isinstance(v, FieldDescriptor) else v
for k, v in defaults.items() if k in fields
and not (isinstance(v, FieldDescriptor) and v.required)
}
# Raise error if non-defaults are mixed in with defaults
# like namedtuple/dataclasses do.
local_defaults = []
for attr_name in cls.__annotations__:
if attr_name in cls.__dict__:
default_value = cls.__dict__[attr_name]
if isinstance(default_value, FieldDescriptorT):
if not default_value.required:
local_defaults.append(attr_name)
else:
local_defaults.append(attr_name)
else:
if local_defaults:
raise TypeError(
E_NON_DEFAULT_FOLLOWS_DEFAULT.format(
cls_name=cls.__name__,
field_name=attr_name,
fields=pluralize(len(local_defaults), 'field'),
default_names=', '.join(local_defaults),
))
for field, typ in fields.items():
if is_optional(typ):
# Optional[X] also needs to be added to defaults mapping.
options.defaults.setdefault(field, None)
# Create frozenset index of default fields.
options.optionalset = frozenset(options.defaults)
def _is_of_type(value: Any, typ: Type) -> bool:
if is_optional(typ):
# Optional/Union can contain nested types, e.g:
# Optional[Union[str, int, Optional[Foo]]]
#
# to avoid recursion we add new Union types to a stack
# and return False only when that stack is exhausted.
#
# NOTE: Optional[str] actually returns Union[str, type(None)]
stack = deque([typ])
while stack:
node = stack.popleft()
concrete_types = []
for subtype in node.__args__:
if is_optional(subtype):
stack.append(subtype)
else:
concrete_types.append(subtype)
if isinstance(value, tuple(concrete_types)):
return True
return False
else:
return isinstance(value, typ)
def inspect_type(cls, typ: Type) -> TypeInfo:
optional = is_optional(typ)
if optional:
args = getattr(typ, '__args__', ())
union_args: List[Type] = []
found_none = False
for arg in args:
if _is_NoneType(arg):
found_none = True
else:
union_args.append(arg)
if len(union_args) == 1:
assert found_none
return _TypeInfo_from_type(union_args[0], optional=True)
return _TypeInfo_from_type(typ, optional=True)
return _TypeInfo_from_type(typ, optional=False)
def _contribute_field_descriptors(
cls,
target: Type,
options: ModelOptions,
parent: FieldDescriptorT = None) -> FieldMap:
fields = options.fields
defaults = options.defaults
date_parser = options.date_parser
coerce = options.coerce
index = {}
secret_fields = set()
sensitive_fields = set()
personal_fields = set()
tagged_fields = set()
def add_to_tagged_indices(field: str, tag: Type[Tag]) -> None:
if tag.is_secret:
options.has_secret_fields = True
secret_fields.add(field)
if tag.is_sensitive:
options.has_sensitive_fields = True
sensitive_fields.add(field)
if tag.is_personal:
options.has_personal_fields = True
personal_fields.add(field)
options.has_tagged_fields = True
tagged_fields.add(field)
def add_related_to_tagged_indices(field: str,
related_model: Type = None) -> None:
if related_model is None:
return
try:
related_options = related_model._options
except AttributeError:
return
if related_options.has_secret_fields:
options.has_secret_fields = True
secret_fields.add(field)
if related_options.has_sensitive_fields:
options.has_sensitive_fields = True
sensitive_fields.add(field)
if related_options.has_personal_fields:
options.has_personal_fields = True
personal_fields.add(field)
if related_options.has_tagged_fields:
options.has_tagged_fields = True
tagged_fields.add(field)
for field, typ in fields.items():
try:
default, needed = defaults[field], False
except KeyError:
default, needed = None, True
descr = getattr(target, field, None)
if is_optional(typ):
target_type = remove_optional(typ)
else:
target_type = typ
if descr is None or not isinstance(descr, FieldDescriptorT):
DescriptorType, tag = field_for_type(target_type)
if tag:
add_to_tagged_indices(field, tag)
descr = DescriptorType(
field=field,
type=typ,
model=cls,
required=needed,
default=default,
parent=parent,
coerce=coerce,
date_parser=date_parser,
tag=tag,
)
else:
descr = descr.clone(
field=field,
type=typ,
model=cls,
required=needed,
default=default,
parent=parent,
coerce=coerce,
)
descr.on_model_attached()
for related_model in descr.related_models:
add_related_to_tagged_indices(field, related_model)
setattr(target, field, descr)
index[field] = descr
options.secret_fields = frozenset(secret_fields)
options.sensitive_fields = frozenset(sensitive_fields)
options.personal_fields = frozenset(personal_fields)
options.tagged_fields = frozenset(tagged_fields)
return index
def _contribute_to_options(cls, options: ModelOptions) -> None:
# Find attributes and their types, and create indexes for these.
# This only happens once when the class is created, so Faust
# models are fast at runtime.
fields, defaults = annotations(
cls,
stop=Record,
skip_classvar=True,
alias_types=ALIAS_FIELD_TYPES,
localns={cls.__name__: cls},
)
options.fields = cast(Mapping, fields)
options.fieldset = frozenset(fields)
options.fieldpos = {i: k for i, k in enumerate(fields.keys())}
# extract all default values, but only for actual fields.
options.defaults = {
k: v.default if isinstance(v, FieldDescriptor) else v
for k, v in defaults.items() if k in fields
and not (isinstance(v, FieldDescriptor) and v.required)
}
options.models = {}
options.polyindex = {}
modelattrs = options.modelattrs = {}
def _is_concrete_type(field: str, wanted: IsInstanceArgT) -> bool:
typeinfo = options.polyindex[field]
try:
return issubclass(typeinfo.member_type, wanted)
except TypeError:
return False
# Raise error if non-defaults are mixed in with defaults
# like namedtuple/dataclasses do.
local_defaults = []
for attr_name in cls.__annotations__:
if attr_name in cls.__dict__:
default_value = cls.__dict__[attr_name]
if isinstance(default_value, FieldDescriptorT):
if not default_value.required:
local_defaults.append(attr_name)
else:
local_defaults.append(attr_name)
else:
if local_defaults:
raise TypeError(
E_NON_DEFAULT_FOLLOWS_DEFAULT.format(
cls_name=cls.__name__,
field_name=attr_name,
fields=pluralize(len(local_defaults), 'field'),
default_names=', '.join(local_defaults),
))
for field, typ in fields.items():
is_model, member_type, generic_type = _is_model(typ)
options.polyindex[field] = TypeInfo(generic_type, member_type)
if is_model:
# Extract all model fields
options.models[field] = typ
# Create mapping of model fields to polymorphic types if
# available
modelattrs[field] = generic_type
if is_optional(typ):
# Optional[X] also needs to be added to defaults mapping.
options.defaults.setdefault(field, None)
# Create frozenset index of default fields.
options.optionalset = frozenset(options.defaults)
# extract all fields that we want to coerce to a different type
# (decimals=True, isodates=True, coercions={MyClass: converter})
# Then move them to options.field_coerce, which is what the
# model.__init__ method uses to coerce any fields that need to
# be coerced.
options.field_coerce = {}
if options.isodates:
options.coercions.setdefault(DATE_TYPES, iso8601.parse)
if options.decimals:
options.coercions.setdefault(DECIMAL_TYPES, str_to_decimal)
for coerce_types, coerce_handler in options.coercions.items():
options.field_coerce.update({
field: TypeCoerce(typ, coerce_handler)
for field, typ in fields.items()
if (field not in modelattrs
and _is_concrete_type(field, coerce_types))
})
def test_is_optional(input, expected):
assert is_optional(input) == expected
