def test_schema_dump(self):
factory = Factory(schemas={
FakeFoo[str]: Schema(name_mapping={"value": "s"}),
FakeFoo: Schema(name_mapping={"value": "v"}),
})
# self.assertEqual(factory.dump(FakeFoo("hello"), FakeFoo[str]), {"s": "hello"})
self.assertEqual(factory.dump(FakeFoo("hello")), {"v": "hello"})
def test_schema_load(self):
factory = Factory(schemas={
FakeFoo[str]: Schema(name_mapping={"value": "s"}),
FakeFoo: Schema(name_mapping={"value": "v"}),
})
data = {"v": "hello", "i": 42, "s": "SSS"}
self.assertEqual(factory.load(data, FakeFoo[str]), FakeFoo("SSS"))
self.assertEqual(factory.load(data, FakeFoo[int]), FakeFoo("hello"))
def test_schema_dump_inner(self):
factory = Factory(
schemas={
FooBaz[int]: Schema(name_mapping={"foo": "bar"}),
Foo[int]: Schema(name_mapping={"value": "v"})
})
self.assertEqual(factory.dump(FooBaz(Foo(1)), FooBaz[int]),
{"bar": {
"v": 1
}})
def create_factory():
return Factory(schemas={
datetime:
DateSchema(),
Station:
StationSchema(),
PolicyRuleCheck:
Schema(pre_parse=type_checker("0", field="action")),
PolicyRuleAction:
Schema(pre_parse=type_checker("1", field="action")),
},
default_schema=Schema(omit_default=True, ),
debug_path=True)
def test_nothing(self):
factory = Factory(
schemas={
A: Schema(pre_parse=type_checker("A", field="x")),
B: Schema(pre_parse=type_checker("B", field="x")),
C: Schema(pre_parse=type_checker("C", field="x")),
})
self.assertRaises((ValueError, KeyError, TypeError, AttributeError),
factory.load, {"some": {
"a": "hello",
"x": "XXX"
}}, Container)
self.assertRaises((ValueError, KeyError, TypeError, AttributeError),
factory.load, {"some": {
"a": "hello"
}}, Container)
def test_store_separate_parse(self):
factory = Factory(default_schema=Schema(unknown=["unknown",
"sub"], ), )
data = DataAllUnknown(Sub("b"))
serialized = {"a": "AA", "b": "b"}
self.assertEqual(data, factory.load(serialized, DataAllUnknown))
self.assertEqual({"b": "b"}, factory.dump(data))
def test_mapping(self):
factory = Factory(schemas={
Data: Schema(name_mapping={"b": "d"}, ),
}, )
data = Data("AA", "BB", "CC")
serial = {"a": "AA", "d": "BB", "c": "CC"}
self.assertEqual(factory.dump(data), serial)
self.assertEqual(factory.load(serial, Data), data)
def __init__(self, data):
self.__data = data
self.__schema = Schema(
name_mapping={
"avatar": "avatar",
"genres": ("genres", "secondaries"),
"genres_primary": ("genres", "primary"),
})
def test_exclude(self):
factory = Factory(schemas={
Data: Schema(exclude=("b", ), ),
}, )
data = Data("AA", "BB", "CC")
serial = {"a": "AA", "c": "CC"}
self.assertEqual(factory.dump(data), serial)
data2 = Data(a="AA", c="CC")
self.assertEqual(factory.load(serial, Data), data2)
def test_only(self):
factory = Factory(schemas={
Data: Schema(only=("b", ), ),
}, )
data = Data("AA", "BB", "CC")
serial = {"b": "BB"}
self.assertEqual(factory.dump(data), serial)
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_skip_internal(self):
factory = Factory(schemas={
Data: Schema(skip_internal=True, ),
}, )
data = Data("AA", "BB", "CC", "DD")
serial = {"a": "AA", "c": "CC", "b": "BB"}
self.assertEqual(factory.dump(data), serial)
data2 = Data("AA", "BB", "CC")
self.assertEqual(factory.load(serial, Data), data2)
def test_skip(self):
factory = Factory(
default_schema=Schema(
unknown=Unknown.SKIP,
),
)
data = Data("AA")
serialized = {"a": "AA", "b": "b"}
self.assertEqual(data, factory.load(serialized, Data))
def test_forbid(self):
factory = Factory(
default_schema=Schema(
unknown=Unknown.FORBID,
),
)
serialized = {"a": "AA", "b": "b"}
with self.assertRaises(ValueError):
factory.load(serialized, Data)
def test_pre_parse(self):
factory = Factory(
schemas={
A:
Schema(pre_parse=type_checker(
"A", field="x", pre_parse=pre_parse)),
B:
Schema(pre_parse=type_checker(
"B", field="x", pre_parse=pre_parse)),
C:
Schema(pre_parse=type_checker(
"C", field="x", pre_parse=pre_parse)),
})
self.assertEqual(
factory.load({"some": {
"a": "hello",
"x": "B"
}}, Container), Container(B("hello*")))
def test_include(self):
factory = Factory(
default_schema=Schema(
unknown=Unknown.STORE,
),
)
serialized = {"a": "AA", "b": "b"}
data = factory.load(serialized, DataWithExtras)
self.assertEqual(data.a, "AA")
self.assertEqual(data.extras, {"b": "b"})
def test_store_separate(self):
factory = Factory(
default_schema=Schema(
unknown="unknown",
),
)
data = Data("AA", {"b": "b"})
serialized = {"a": "AA", "b": "b"}
self.assertEqual(data, factory.load(serialized, Data))
self.assertEqual({"a": "AA", "b": "b", "sub": None}, factory.dump(data))
def __init__(self, data):
self.__data = data
self.__schema = Schema(name_mapping={
"photo_url": ("images", "coverarthq"),
"ringtone": ("hub", "actions", 1, "uri"),
"artist_id": ("artists", 0, "id"),
"apple_music_url": ("hub", "options", 0, "actions", 0, "uri"),
"spotify_url": ("hub", "providers", 0, "actions", 0, "uri"),
"spotify_uri": ("hub", "providers", 0, "actions", 1, "uri")
},
skip_internal=True)
def test_trailing_mapping(self):
factory = Factory(schemas={
Data:
Schema(
name_mapping={"c_": "c_"},
trim_trailing_underscore=True,
),
}, )
data = Data("AA", "BB", "CC")
serial = {"a": "AA", "b": "BB", "c_": "CC"}
self.assertEqual(factory.dump(data), serial)
self.assertEqual(factory.load(serial, Data), data)
def test_only_exclude(self):
factory = Factory(schemas={
Data: Schema(only=(
"a",
"b",
), exclude=("a", )),
})
data = Data("AA", "BB", "CC")
serial = {"b": "BB"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "b": "BB"}
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_internal_only(self):
factory = Factory(schemas={
Data: Schema(
only=("_d", ),
skip_internal=True,
),
})
data = Data("AA", "BB", "CC", "DD")
serial = {"_d": "DD"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "_d": "DD"}
data2 = Data(_d="DD")
self.assertEqual(factory.load(serial, Data), data2)
def test_skip(self):
factory = Factory(default_schema=Schema(
trim_trailing_underscore=True,
skip_internal=True,
), )
data = Data("1", "2", "3")
serial = {
"last": "1",
"normal": "3",
}
self.assertEqual(factory.dump(data), serial)
data = Data("1", normal="3")
self.assertEqual(factory.load(serial, Data), data)
def test_only_mapped(self):
factory = Factory(schemas={
Data:
Schema(
name_mapping={"b": "d"},
only_mapped=True,
),
}, )
data = Data("AA", "BB", "CC")
serial = {"d": "BB"}
self.assertEqual(factory.dump(data), serial)
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_keep_all(self):
factory = Factory(default_schema=Schema(
trim_trailing_underscore=False,
skip_internal=False,
))
data = Data("1", "2", "3")
serial = {
"last_": "1",
"_first": "2",
"normal": "3",
}
self.assertEqual(factory.dump(data), serial)
self.assertEqual(factory.load(serial, Data), data)
def test_internal_mapping(self):
factory = Factory(
schemas={
Data: Schema(
name_mapping={"_d": "_d"},
skip_internal=True,
),
})
data = Data("AA", "BB", "CC", "DD")
serial = {"a": "AA", "b": "BB", "c": "CC", "_d": "DD"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "_d": "DD"}
data2 = Data(a="XXX", _d="DD")
self.assertEqual(factory.load(serial, Data), data2)
def do_case_test(self, name_style: NameStyle, *, styled: str,
trailed: str):
data = {
styled: 1,
trailed: 2,
'MappedName': 3,
}
self.assert_convert(name_style, 'styled_name', styled)
self.assert_convert(name_style, 'trailed_name_', trailed)
parser = Factory(default_schema=Schema(
name_style=name_style, name_mapping={'NameToMap': 'MappedName'
})).parser(Data)
self.assertEqual(parser(data), Data(1, 2, 3))
def test_only_mapping(self):
factory = Factory(
schemas={
Data:
Schema(
only=("b", ),
name_mapping={"a": "A"},
only_mapped=True,
),
})
data = Data("AA", "BB", "CC")
serial = {"b": "BB"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "b": "BB"}
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_complex(self, typed_dict):
class MyDict(typed_dict, total=False):
python_name: str
other: str
factory = Factory(
default_schema=Schema(name_style=NameStyle.dot,
name_mapping={"other": ("inner", "field")}))
data = {
"python.name": "hello",
"inner": {
"field": "world"
},
}
mydict: MyDict = dict(python_name="hello", other="world")
self.assertEqual(mydict, factory.load(data, MyDict))
self.assertEqual(data, factory.dump(mydict, MyDict))
def __init__(self,
bot_token,
connector=None,
close_session=True,
proxy=None,
message_callback=None):
self.bot_token = bot_token
self.session = aiohttp.ClientSession(connector=connector)
self.close_session = close_session
self.proxy = proxy
self.loop = asyncio.get_event_loop()
self.url = "https://api.telegram.org/bot%s/" % bot_token
self.running = False
self.factory = Factory(default_schema=Schema(
trim_trailing_underscore=True))
self.callback = message_callback
self.me = None
class FactorySchemas:
FACTORY_TRACK_SCHEMA = Schema(name_mapping={
"photo_url": ("images", "coverarthq"),
"ringtone": ("hub", "actions", 1, "uri"),
"artist_id": ("artists", 0, "id"),
"apple_music_url": ("hub", "options", 0, "actions", 0, "uri"),
"spotify_url": ("hub", "providers", 0, "actions", 0, "uri"),
"spotify_uri": ("hub", "providers", 0, "actions", 1, "uri"),
"_sections":
"sections"
},
skip_internal=True)
FACTORY_ARTIST_SCHEMA = Schema(
name_mapping={
"avatar": "avatar",
"genres": ("genres", "secondaries"),
"genres_primary": ("genres", "primary"),
})
FACTORY_SONG_SECTION_SCHEMA = Schema(name_mapping={
"type": "type",
"meta_pages": "metapages",
"tab_name": "tabname",
"metadata": "metadata"
},
skip_internal=True)
FACTORY_VIDEO_SECTION_SCHEMA = Schema(name_mapping={
"type": "type",
"youtube_url": "youtubeurl",
"tab_name": "tabname",
},
skip_internal=True)
FACTORY_RELATED_SECTION_SCHEMA = Schema(name_mapping={
"type": "type",
"url": "url",
"tab_name": "tabname",
},
skip_internal=True)
FACTORY_YOUTUBE_TRACK_SCHEMA = Schema(name_mapping={
"caption": "caption",
"image": "image",
"actions": "actions",
},
skip_internal=True)
FACTORY_RESPONSE_TRACK_SCHEMA = Schema(name_mapping={
"matches": "matches",
"location": "location",
"retry_ms": "retryms",
"timestamp": "timestamp",
"timezone": "timezone",
"track": "track",
"tag_id": "tagid",
},
skip_internal=True)
FACTORY_LYRICS_SECTION = Schema(name_mapping={
"type": "type",
"text": "text",
"footer": "footer",
"tab_name": "tabname",
"beacon_data": "beacondata",
}, )
FACTORY_BEACON_DATA_LYRICS_SECTION = Schema(
name_mapping={
"lyrics_id": "lyricsid",
"provider_name": "providername",
"common_track_id": "commontrackid",
})
FACTORY_ARTIST_SECTION = Schema(
name_mapping={
"type": "type",
"id": "id",
"name": "name",
"verified": "verified",
"actions": "actions",
"tab_name": "tabname",
"top_tracks": "toptracks",
})
FACTORY_MATCH_MODEL = Schema(
name_mapping={
"id": "id",
"offset": "offset",
"channel": "channel",
"time_skew": "timeskew",
"frequency_skew": "frequencyskew",
})
@dataclass
class Book:
title: str
price: int
author: str = "Unknown author"
data = {
"title": "Fahrenheit 451",
"price": 100,
}
invalid_data = {
"title": "1984",
"price": -100,
}
def validate_book(book: Book) -> Book:
if not book.title:
raise ValueError("Empty title")
if book.price <= 0:
raise ValueError("InvalidPrice")
return book
factory = dataclass_factory.Factory(
schemas={Book: Schema(post_parse=validate_book)})
book = factory.load(data, Book) # No error
other_book = factory.load(invalid_data, Book) # ValueError: InvalidPrice