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)
