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