def _structure_attr_from_dict(self, a, name, mapping):
"""Handle an individual attrs attribute structuring."""
val = mapping.get(name, NOTHING)
if val is NOTHING:
return NOTHING
type_ = a.type
if type_ is None:
# No type.
return val
if _is_union_type(type_):
if NoneType in type_.__args__ and val is None:
return None
return self._structure_union(val, type_)
return self._structure.dispatch(type_)(val, type_)
python类NOTHING的实例源码
def Field(*args, default=attr.NOTHING, **kwargs):
if callable(default):
default = attr.Factory(default)
return attr.ib(*args, default=default, **kwargs)
def attr_init(factory_or_default=attr.NOTHING, **attr_kws):
if callable(factory_or_default): factory_or_default = attr.Factory(factory_or_default)
return attr.ib(default=factory_or_default, **attr_kws)
def BooleanField(default=NOTHING, required=True, repr=True, cmp=True,
key=None):
"""
Create new bool field on a model.
:param default: any boolean value
:param bool required: whether or not the object is invalid if not provided.
:param bool repr: include this field should appear in object's repr.
:param bool cmp: include this field in generated comparison.
:param string key: override name of the value when converted to dict.
"""
default = _init_fields.init_default(required, default, None)
validator = _init_fields.init_validator(required, bool)
return attrib(default=default, validator=validator, repr=repr, cmp=cmp,
metadata=dict(key=key))
def init_default(required, default, optional_default):
"""
Returns optional default if field is not required and
default was not provided.
:param bool required: whether the field is required in a given model.
:param default: default provided by creator of field.
:param optional_default: default for the data type if none provided.
:return: default or optional default based on inputs
"""
if not required and default == NOTHING:
default = optional_default
return default
def __init__(self, requester: Requester, token: str = attr.NOTHING, *,
base_url: str = ''):
#: ?? API ????
self.base_url = base_url or self.base_url # type: str
self._token = token # type: str
#: meta ?? API
self.meta = MetaAPI(
requester, token=token, base_url=self.base_url
) # type: MetaAPI
#: ???? API
self.team = TeamAPI(
requester, token=token, base_url=self.base_url
) # type: TeamAPI
#: ???? API
self.user = UserAPI(
requester, token=token, base_url=self.base_url
) # type: UserAPI
#: ?????? API
self.vchannel = VchannelAPI(
requester, token=token, base_url=self.base_url
) # type: VchannelAPI
#: ????? API
self.channel = ChannelAPI(
requester, token=token, base_url=self.base_url
) # type: ChannelAPI
#: ??????? API
self.session_channel = SessionChannelAPI(
requester, token=token, base_url=self.base_url
) # type: SessionChannelAPI
#: P2P ???? API
self.p2p = P2pAPI(
requester, token=token, base_url=self.base_url
) # type: P2pAPI
#: ???? API
self.message = MessageAPI(
requester, token=token, base_url=self.base_url
) # type: MessageAPI
#: ????? emoji ?? API
self.emoji = EmojiAPI(
requester, token=token, base_url=self.base_url
) # type: EmojiAPI
#: ?? sticker ?? API
self.sticker = StickerAPI(
requester, token=token, base_url=self.base_url
) # type: StickerAPI
#: RTM ?? API
self.rtm = RtmAPI(
requester, token=token, base_url=self.base_url
) # type: RtmAPI
def make_struct(cls, exclude_attrs=(), struct=c.Struct):
"""Helper function to make C-like structs from attrs-powered classes.
Attributes become fields, annotations define C types.
"""
# The whole thing is highly dependent on the internals of attrs :(
# pylint: disable=protected-access
struct_fields = []
# Bits are accumulated into octets.
bits = []
type_ = None
for name, attrib in _attribs_from(cls):
if name in exclude_attrs:
continue
attrib = getattr(cls, name)
type_ = cls.__annotations__[name]
if type_ is d.Bit:
bits.append(name / c.Flag)
continue
# In AMQP 0.9.1, all methods (that have bit fields) have sequential
# bit fields that should (and technically can) be accumulated
# into a single octet.
if type_ is not d.Bit and bits:
if len(bits) < 8:
bits += [c.Padding(8 - len(bits))]
bit_struct = c.Embedded(c.BitStruct(*reversed(bits)))
struct_fields.append(bit_struct)
bits = []
if attrib._default is None:
type_ = c.Default(type_, c.Pass)
elif attrib._default is not attr.NOTHING and not attrib.init:
type_ = c.Const(type_, attrib._default)
struct_fields.append(name / type_)
# Handle the case when a method ends with a bit field.
if type_ is d.Bit:
if len(bits) < 8:
bits += [c.Padding(8 - len(bits))]
bit_struct = c.Embedded(c.BitStruct(*reversed(bits)))
struct_fields.append(bit_struct)
return cls.__name__ / struct(*struct_fields)
