def _process_annotation(self, anno, flat=False):
dflat = attrs.asdict(anno, filter=lambda a, v: v is not None)
dflat = self._process_spatial(dflat)
if flat:
return dflat
else:
return self._unflatten_spatial_points(dflat)
def asdict(self) -> dict:
"""Return dictionary suitable for sending over CBOR."""
d = asdict(self)
d["test"] = d.pop("test_vectors")
d["write"] = d.pop("write_vectors")
d["new-length"] = d.pop("new_length")
return d
def test_smoke(self):
"""
`attrs.asdict` only changes defaults, so we just call it and compare.
"""
inst = C("foo", {(1, ): 42})
assert attrs.asdict(inst) == _attr.asdict(inst,
retain_collection_types=True)
def _get_model_dict(self) -> dict:
"""Convenience method that wraps the `attrs.asdict` method. Returns the object's
parameters as a dictionary.
Returns
-------
dict
The provided or default, if no input provided, model settings as a dictionary.
"""
return attrs.asdict(self)
def encode(obj):
if isinstance(obj, (list, tuple, set)):
return [encode(x) for x in obj]
elif issubclass(obj.__class__, enum.Enum):
return obj.value
elif isinstance(obj, dict):
return {encode(k): encode(v) for k, v in obj.items() if v is not None}
elif isinstance(obj, bool):
return bool2str(obj)
try:
return encode(attrs.asdict(obj))
except attrs.exceptions.NotAnAttrsClassError:
pass
return obj
def prepare_for_json(obj):
if isinstance(obj, (list, tuple, set)):
return [prepare_for_json(x) for x in obj]
elif issubclass(obj.__class__, enum.Enum):
return obj.value
elif isinstance(obj, dict):
return {
prepare_for_json(k): prepare_for_json(v)
for k, v in obj.items() if v is not None and (
(isinstance(v, list) and v) or not isinstance(v, list))
}
elif isinstance(obj, str):
return obj
try:
return prepare_for_json(attrs.asdict(obj))
except attrs.exceptions.NotAnAttrsClassError:
pass
return obj
async def read_test_write_chunks(
self,
storage_index: bytes,
write_enabler_secret: bytes,
lease_renew_secret: bytes,
lease_cancel_secret: bytes,
testwrite_vectors: dict[int, TestWriteVectors],
read_vector: list[ReadVector],
) -> ReadTestWriteResult:
"""
Read, test, and possibly write chunks to a particular mutable storage
index.
Reads are done before writes.
Given a mapping between share numbers and test/write vectors, the tests
are done and if they are valid the writes are done.
"""
url = self._client.relative_url(
"/v1/mutable/{}/read-test-write".format(_encode_si(storage_index)))
message = {
"test-write-vectors": {
share_number: twv.asdict()
for (share_number, twv) in testwrite_vectors.items()
},
"read-vector": [asdict(r) for r in read_vector],
}
response = await self._client.request(
"POST",
url,
write_enabler_secret=write_enabler_secret,
lease_renew_secret=lease_renew_secret,
lease_cancel_secret=lease_cancel_secret,
message_to_serialize=message,
)
if response.code == http.OK:
result = await _decode_cbor(response,
_SCHEMAS["mutable_read_test_write"])
return ReadTestWriteResult(success=result["success"],
reads=result["data"])
else:
raise ClientException(response.code, (await response.content()))
attr.assoc(<warning descr="'attr.assoc' method should be called on attrs instances">B</warning>)
attr.evolve(<warning descr="'attr.evolve' method should be called on attrs instances">B</warning>)
@attrs.define
class B2:
pass
attrs.fields(B2)
attrs.fields(<warning descr="'attr.fields' method should be called on attrs types">B2()</warning>)
attrs.fields_dict(B2)
attrs.fields_dict(<warning descr="'attr.fields_dict' method should be called on attrs types">B2()</warning>)
attrs.asdict(B2())
attrs.astuple(B2())
attrs.assoc(B2())
attrs.evolve(B2())
attrs.asdict(<warning descr="'attrs.asdict' method should be called on attrs instances">B2</warning>)
attrs.astuple(<warning descr="'attrs.astuple' method should be called on attrs instances">B2</warning>)
attrs.assoc(<warning descr="'attr.assoc' method should be called on attrs instances">B2</warning>)
attrs.evolve(<warning descr="'attr.evolve' method should be called on attrs instances">B2</warning>)
def unknown(p):
attr.fields(p)
attr.fields_dict(p)
attr.asdict(p)
@attr.s
class FactoryTest:
a: List[int] = attr.ib(default=attr.Factory(list))
b: List[Any] = attr.ib(default=attr.Factory(list, False))
c: List[int] = attr.ib(default=attr.Factory((lambda s: s.a), True))
@attrs.define
class FactoryTest2:
a: List[int] = attrs.field(default=attrs.Factory(list))
b: List[Any] = attrs.field(default=attrs.Factory(list, False))
c: List[int] = attrs.field(default=attrs.Factory((lambda s: s.a), True))
attrs.asdict(FactoryTest2())
attr.asdict(FactoryTest(), tuple_keys=True)
# Check match_args stub
@attr.s(match_args=False)
class MatchArgs:
a: int = attr.ib()
b: int = attr.ib()
attr.asdict(FactoryTest())
attr.asdict(FactoryTest(), retain_collection_types=False)
# Check match_args stub
def printjson(out: List[Role]):
jsonpickle.set_encoder_options("json", ensure_ascii=False)
print(jsonpickle.encode(asdict(Roles(out)), indent=4))
def asdict(inst: Any,
filter_: Optional[Callable[..., bool]] = None) -> Dict[str, Any]:
if isinstance(inst, BaseModel):
assert filter_ is None
return inst.dict()
return attrs.asdict(inst, filter=filter_)
