def get_scraper_enum_overrides(self) -> EnumOverrides: """Retrieves the overrides object of a scraper region.""" if self.is_direct_ingest: raise ValueError("Method not supported for direct ingest region.") obj = self.get_scraper() if obj: return obj.get_enum_overrides() return EnumOverrides.empty()
def test_entity_deserialize_use_normal_constructor(self) -> None: with self.assertRaises(TypeError): _ = MyEntity(int_with_default="3") # type: ignore[arg-type] with self.assertRaises(TypeError): _ = MyEntity(opt_int="3") # type: ignore[arg-type] with self.assertRaises(TypeError): _ = MyEntity(bool_with_default="True") # type: ignore[arg-type] with self.assertRaises(TypeError): _ = MyEntity(opt_bool="True") # type: ignore[arg-type] with self.assertRaises(TypeError): _ = MyEntity( enum_with_default=EnumParser( # type: ignore[arg-type] raw_text="BLACK", enum_cls=Race, enum_overrides=EnumOverrides.empty(), ) ) with self.assertRaises(TypeError): _ = MyEntity( opt_enum=EnumParser( # type: ignore[arg-type] raw_text="BLACK", enum_cls=Race, enum_overrides=EnumOverrides.empty(), ) ) default_entity = MyEntity() expected_default_entity = MyEntity( int_with_default=1, bool_with_default=True, str_with_default="default", enum_with_default=Race.EXTERNAL_UNKNOWN, opt_int=None, opt_bool=None, opt_str=None, opt_enum=None, ) self.assertEqual(default_entity, expected_default_entity)
def test_entity_deserialize(self) -> None: expected_default_entity = MyEntity( int_with_default=1, bool_with_default=True, str_with_default="default", enum_with_default=Race.EXTERNAL_UNKNOWN, opt_int=None, opt_bool=None, opt_str=None, opt_enum=None, ) self.assertEqual(expected_default_entity, MyEntityFactory.deserialize()) self.assertEqual( attr.evolve(expected_default_entity, str_with_default="HELLO"), MyEntityFactory.deserialize(str_with_default="hello"), ) self.assertEqual( attr.evolve(expected_default_entity, opt_str="HELLO"), MyEntityFactory.deserialize(opt_str="hello"), ) self.assertEqual( attr.evolve(expected_default_entity, int_with_default=3), MyEntityFactory.deserialize(int_with_default="3"), ) self.assertEqual( attr.evolve(expected_default_entity, opt_int=3), MyEntityFactory.deserialize(opt_int="3"), ) self.assertEqual( attr.evolve(expected_default_entity, bool_with_default=False), MyEntityFactory.deserialize(bool_with_default="False"), ) self.assertEqual( attr.evolve(expected_default_entity, opt_bool=False), MyEntityFactory.deserialize(opt_bool="False"), ) enum_parser = EnumParser( raw_text="BLACK", enum_cls=Race, enum_overrides=EnumOverrides.empty() ) self.assertEqual( attr.evolve(expected_default_entity, enum_with_default=Race.BLACK), MyEntityFactory.deserialize(enum_with_default=enum_parser), ) self.assertEqual( attr.evolve(expected_default_entity, opt_enum=Race.BLACK), MyEntityFactory.deserialize(opt_enum=enum_parser), )
def for_state( cls, region: str, enum_overrides: Optional[EnumOverrides] = None, ) -> IngestMetadata: return IngestMetadata( region=region, jurisdiction_id="", ingest_time=datetime.datetime(2020, 4, 14, 12, 31, 00), enum_overrides=enum_overrides or EnumOverrides.empty(), system_level=SystemLevel.STATE, database_key=SQLAlchemyDatabaseKey.canonical_for_schema(SchemaType.STATE), )
def for_county( cls, region: str, jurisdiction_id: Optional[str] = None, ingest_time: Optional[datetime.datetime] = None, enum_overrides: Optional[EnumOverrides] = None, facility_id: Optional[str] = None, ) -> IngestMetadata: return IngestMetadata( region=region, jurisdiction_id=jurisdiction_id or "jurisdiction_id", ingest_time=ingest_time or datetime.datetime(2020, 4, 14, 12, 31, 00), enum_overrides=enum_overrides or EnumOverrides.empty(), facility_id=facility_id, system_level=SystemLevel.COUNTY, database_key=SQLAlchemyDatabaseKey.for_schema(SchemaType.JAILS), )
def test_deserialize_StatePerson(self) -> None: result = deserialize_entity_factories.StatePersonFactory.deserialize( state_code="us_xx", gender=EnumParser("MALE", Gender, EnumOverrides.empty()), gender_raw_text="MALE", full_name='{"full_name": "full NAME"}', birthdate="12-31-1999", current_address="NNN\n STREET \t ZIP", residency_status="NNN\n STREET \t ZIP", ) # Assert expected_result = entities.StatePerson.new_with_defaults( gender=Gender.MALE, gender_raw_text="MALE", full_name='{"full_name": "FULL NAME"}', birthdate=date(year=1999, month=12, day=31), birthdate_inferred_from_age=None, current_address="NNN STREET ZIP", residency_status=ResidencyStatus.PERMANENT, state_code="US_XX", ) self.assertEqual(result, expected_result)
def test_parseBadGenderEnum(self): with pytest.raises(EnumParsingError): Gender.parse("ABD", EnumOverrides.empty())
def test_parseGenderEnum(self): assert Gender.parse("Male", EnumOverrides.empty()) == Gender.MALE
def get_enum_overrides(self) -> EnumOverrides: return EnumOverrides.empty()
def testCanParse_Valid(self): self.assertTrue( FakeEntityEnum.can_parse('banana', EnumOverrides.empty()))
def testCanParse_Invalid(self): self.assertFalse( FakeEntityEnum.can_parse('invalid', EnumOverrides.empty()))
def test_entity_deserialize_with_converter_overrides(self) -> None: def parse_int_and_double(int_str: str) -> int: return int(int_str) * 2 def set_race_to_white(_race_enum_parser: EnumParser) -> Race: return Race.WHITE @attr.s(eq=False) class MyEntityWithFieldOverrides(Entity): str_with_override: str = attr.ib(validator=attr_validators.is_str) int_with_override: int = attr.ib(validator=attr_validators.is_int) enum_with_override: Race = attr.ib( validator=attr.validators.instance_of(Race) ) str_no_override: str = attr.ib(validator=attr_validators.is_str) int_no_override: int = attr.ib(validator=attr_validators.is_int) enum_no_override: Race = attr.ib( validator=attr.validators.instance_of(Race) ) class MyEntityWithFieldOverridesFactory: @staticmethod def deserialize( **kwargs: Union[str, EnumParser] ) -> MyEntityWithFieldOverrides: return entity_deserialize( MyEntityWithFieldOverrides, converter_overrides={ "str_with_override": EntityFieldConverter(str, str.lower), "int_with_override": EntityFieldConverter( str, parse_int_and_double ), "enum_with_override": EntityFieldConverter( EnumParser, set_race_to_white ), }, **kwargs ) entity = MyEntityWithFieldOverridesFactory.deserialize( str_with_override="AbCd", int_with_override="3", enum_with_override=EnumParser( raw_text="BLACK", enum_cls=Race, enum_overrides=EnumOverrides.empty() ), str_no_override="AbCd", int_no_override="3", enum_no_override=EnumParser( raw_text="BLACK", enum_cls=Race, enum_overrides=EnumOverrides.empty() ), ) self.assertEqual( entity, MyEntityWithFieldOverrides( str_with_override="abcd", int_with_override=6, enum_with_override=Race.WHITE, str_no_override="ABCD", int_no_override=3, enum_no_override=Race.BLACK, ), )
def testParse_NoOverrides_UsesDefaultMap(self): self.assertEqual(FakeEntityEnum.parse('banana', EnumOverrides.empty()), FakeEntityEnum.BANANA)
def testParse_InvalidString_throwsEnumParsingError(self): with self.assertRaises(EnumParsingError): FakeEntityEnum.parse('invalid', EnumOverrides.empty())
def testCanParse_Valid(self) -> None: self.assertTrue( FakeEntityEnum.can_parse("banana", EnumOverrides.empty()))
def testCanParse_Invalid(self) -> None: self.assertFalse( FakeEntityEnum.can_parse("invalid", EnumOverrides.empty()))
def get_enum_overrides(self) -> EnumOverrides: """Retrieves the overrides object of a region""" obj = self.get_ingestor() if obj: return obj.get_enum_overrides() return EnumOverrides.empty()
def testParse_WithPunctuation(self): self.assertEqual( FakeEntityEnum.parse('"PASSION"-FRUIT.', EnumOverrides.empty()), FakeEntityEnum.PASSION_FRUIT)