def copy_fields_to_builder(state_person_builder: entities.StatePerson.Builder, proto: StatePerson, metadata: IngestMetadata): """Mutates the provided |state_person_builder| by converting an ingest_info proto StatePerson. Note: This will not copy children into the Builder! """ enum_fields = { 'gender': Gender, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) new = state_person_builder # Enum mappings new.gender = enum_mappings.get(Gender) new.gender_raw_text = fn(normalize, 'gender', proto) # 1-to-1 mappings new.full_name = parse_name(proto) new.birthdate, new.birthdate_inferred_from_age = parse_birthdate( proto, 'birthdate', 'age') new.current_address = fn(normalize, 'current_address', proto) new.residency_status = fn( parse_residency_status, 'current_address', proto) new.state_code = parse_region_code_with_override( proto, 'state_code', metadata)
def _convert_booking(self, ingest_booking): """Converts an ingest_info proto Booking to a persistence entity.""" booking_builder = entities.Booking.builder() booking.copy_fields_to_builder(booking_builder, ingest_booking, self.metadata) booking_builder.arrest = \ fn(lambda i: arrest.convert(self.arrests[i]), 'arrest_id', ingest_booking) converted_holds = [ hold.convert(self.holds[hold_id], self.metadata) for hold_id in ingest_booking.hold_ids ] booking_builder.holds = list( more_itertools.unique_everseen(converted_holds)) ingest_charges = [self.charges[c] for c in ingest_booking.charge_ids] charges = self._convert_charges(ingest_charges) booking_builder.charges = charges bond_info_tuple = fn(parse_bond_amount_type_and_status, 'total_bond_amount', ingest_booking) if bond_info_tuple is not None: bond_amount, bond_type, bond_status = bond_info_tuple booking_builder.charges = \ _charges_pointing_to_total_bond( bond_amount, bond_type, bond_status, charges) return booking_builder.build()
def convert( proto: StateSupervisionViolationResponseDecisionEntry, metadata: IngestMetadata ) -> entities.StateSupervisionViolationResponseDecisionEntry: """Converts an ingest_info proto StateSupervisionViolationResponseDecisionEntry to a persistence entity. """ new = entities.StateSupervisionViolationResponseDecisionEntry.builder() enum_fields = { "decision": StateSupervisionViolationResponseDecision, "revocation_type": StateSupervisionViolationResponseRevocationType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # Enum mappings new.decision = enum_mappings.get(StateSupervisionViolationResponseDecision) new.decision_raw_text = fn(normalize, "decision", proto) new.revocation_type = enum_mappings.get( StateSupervisionViolationResponseRevocationType) new.revocation_type_raw_text = fn(normalize, "revocation_type", proto) # 1-to-1 mappings new.state_code = parse_region_code_with_override(proto, "state_code", metadata) return new.build()
def copy_fields_to_builder( fine_builder: entities.StateFine.Builder, proto: StateFine, metadata: IngestMetadata ) -> None: """Mutates the provided |fine_builder| by converting an ingest_info proto StateFine. Note: This will not copy children into the Builder! """ new = fine_builder enum_fields = { "status": StateFineStatus, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.status = enum_mappings.get( StateFineStatus, default=StateFineStatus.PRESENT_WITHOUT_INFO ) new.status_raw_text = fn(normalize, "status", proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, "state_fine_id", proto) new.date_paid = fn(parse_date, "date_paid", proto) new.state_code = parse_region_code_with_override(proto, "state_code", metadata) new.county_code = fn(normalize, "county_code", proto) new.fine_dollars = fn(parse_dollars, "fine_dollars", proto)
def convert( proto: StateIncarcerationIncidentOutcome, metadata: IngestMetadata ) -> entities.StateIncarcerationIncidentOutcome: """Converts an ingest_info proto StateIncarcerationIncidentOutcome to a persistence entity. """ new = entities.StateIncarcerationIncidentOutcome.builder() enum_fields = { 'outcome_type': StateIncarcerationIncidentOutcomeType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.outcome_type = enum_mappings.get(StateIncarcerationIncidentOutcomeType) new.outcome_type_raw_text = fn(normalize, 'outcome_type', proto) # 1-to-1 mappings new.external_id = \ fn(parse_external_id, 'state_incarceration_incident_outcome_id', proto) new.date_effective = fn(parse_date, 'date_effective', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) new.outcome_description = fn(normalize, 'outcome_description', proto) new.punishment_length_days = fn(parse_int, 'punishment_length_days', proto) return new.build()
def copy_fields_to_builder( supervision_violation_builder: entities.StateSupervisionViolation.Builder, proto: StateSupervisionViolation, metadata: IngestMetadata) -> None: """Converts an ingest_info proto StateSupervisionViolation to a persistence entity.""" new = supervision_violation_builder enum_fields = { 'violation_type': StateSupervisionViolationType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.violation_type = enum_mappings.get(StateSupervisionViolationType) new.violation_type_raw_text = fn(normalize, 'violation_type', proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, 'state_supervision_violation_id', proto) new.violation_date = fn(parse_date, 'violation_date', proto) new.state_code = parse_region_code_with_override( proto, 'state_code', metadata) new.is_violent = fn(parse_bool, 'is_violent', proto) new.violated_conditions = fn(normalize, 'violated_conditions', proto)
def convert(proto, metadata: IngestMetadata) -> entities.Bond: """Converts an ingest_info proto Bond to a persistence entity.""" new = entities.Bond.builder() enum_fields = { 'status': BondStatus, 'bond_type': BondType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.bond_type = enum_mappings.get(BondType) new.bond_type_raw_text = fn(normalize, 'bond_type', proto) new.status = enum_mappings.get(BondStatus) new.status_raw_text = fn(normalize, 'status', proto) # parsed values new.external_id = fn(parse_external_id, 'bond_id', proto) new.bond_agent = fn(normalize, 'bond_agent', proto) new.amount_dollars, new.bond_type, new.status = \ converter_utils.parse_bond_amount_type_and_status( fn(normalize, 'amount', proto), provided_bond_type=cast(Optional[BondType], new.bond_type), provided_status=cast(Optional[BondStatus], new.status)) return new.build()
def parse_name(proto) -> Optional[str]: """Parses name into a single string.""" names = Names(full_name=fn(normalize, 'full_name', proto), given_names=fn(normalize, 'given_names', proto), middle_names=fn(normalize, 'middle_names', proto), surname=fn(normalize, 'surname', proto), name_suffix=fn(normalize, 'name_suffix', proto)) return names.combine()
def parse_name(proto) -> Optional[str]: """Parses name into a single string.""" names = Names( full_name=fn(normalize, "full_name", proto), given_names=fn(normalize, "given_names", proto), middle_names=fn(normalize, "middle_names", proto), surname=fn(normalize, "surname", proto), name_suffix=fn(normalize, "name_suffix", proto), ) return names.combine()
def copy_fields_to_builder( supervision_period_builder: entities.StateSupervisionPeriod.Builder, proto: StateSupervisionPeriod, metadata: IngestMetadata) -> None: """Mutates the provided |supervision_period_builder| by converting an ingest_info proto StateSupervisionPeriod. Note: This will not copy children into the Builder! """ new = supervision_period_builder # 1-to-1 mappings new.external_id = fn(parse_external_id, 'state_supervision_period_id', proto) new.start_date = fn(parse_date, 'start_date', proto) new.termination_date = fn(parse_date, 'termination_date', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) new.county_code = fn(normalize, 'county_code', proto) new.supervision_site = fn(normalize, 'supervision_site', proto) if proto.conditions: new.conditions = create_comma_separated_list(proto, 'conditions') enum_fields = { 'status': StateSupervisionPeriodStatus, 'supervision_type': StateSupervisionType, 'admission_reason': StateSupervisionPeriodAdmissionReason, 'termination_reason': StateSupervisionPeriodTerminationReason, 'supervision_level': StateSupervisionLevel } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values # Status default based on presence of admission/release dates if new.termination_date: status_default = StateSupervisionPeriodStatus.TERMINATED elif new.start_date and not new.termination_date: status_default = StateSupervisionPeriodStatus.UNDER_SUPERVISION else: status_default = StateSupervisionPeriodStatus.PRESENT_WITHOUT_INFO new.status = enum_mappings.get(StateSupervisionPeriodStatus, default=status_default) new.status_raw_text = fn(normalize, 'status', proto) new.supervision_type = enum_mappings.get(StateSupervisionType) new.supervision_type_raw_text = fn(normalize, 'supervision_type', proto) new.admission_reason = enum_mappings.get( StateSupervisionPeriodAdmissionReason) new.admission_reason_raw_text = fn(normalize, 'admission_reason', proto) new.termination_reason = enum_mappings.get( StateSupervisionPeriodTerminationReason) new.termination_reason_raw_text = fn(normalize, 'termination_reason', proto) new.supervision_level = enum_mappings.get(StateSupervisionLevel) new.supervision_level_raw_text = fn(normalize, 'supervision_level', proto)
def convert(proto: StatePersonExternalId, metadata: IngestMetadata) -> entities.StatePersonExternalId: """Converts an ingest_info proto Hold to a persistence entity.""" new = entities.StatePersonExternalId.builder() new.external_id = \ fn(_parse_state_external_id, 'state_person_external_id_id', proto) new.id_type = fn(normalize, 'id_type', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) return new.build()
def copy_fields_to_builder(court_case_builder: entities.StateCourtCase.Builder, proto: StateCourtCase, metadata: IngestMetadata) -> None: """Mutates the provided |court_case_builder| by converting an ingest_info proto StateCourtCase. Note: This will not copy children into the Builder! """ new = court_case_builder enum_fields = { 'status': StateCourtCaseStatus, 'court_type': StateCourtType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.status = enum_mappings.get( StateCourtCaseStatus, default=StateCourtCaseStatus.PRESENT_WITHOUT_INFO) new.status_raw_text = fn(normalize, 'status', proto) new.court_type = enum_mappings.get( StateCourtType, default=StateCourtType.PRESENT_WITHOUT_INFO) new.court_type_raw_text = fn(normalize, 'court_type', proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, 'state_court_case_id', proto) new.date_convicted = fn(parse_date, 'date_convicted', proto) new.next_court_date = fn(parse_date, 'next_court_date', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) new.county_code = fn(normalize, 'county_code', proto) new.judicial_district_code = fn(normalize, 'judicial_district_code', proto) new.court_fee_dollars = fn(parse_dollars, 'court_fee_dollars', proto)
def __init__(self, proto, enum_fields: Mapping[str, EntityEnumMeta], overrides: EnumOverrides): """ Initializes a mapping from enum fields within a single Entity to enum values. If enum fields map to enum values in a different entity, those values will be ignored. EnumMappings prefers values that are the same type as the field they are from; for example, if both ChargeClass and ChargeStatus fields map to a ChargeClass, we will return the ChargeClass from the charge_class field. However, if multiple fields map to different values of the another enum type (for example, if ChargeDegree and ChargeStatus fields map to two ChargeClasses), an error will be raised on calling |get|. If the given enum fields dict contains multiple fields that map to the same enum type, both will be retrievable by their field name in the `get` method below. Args: proto: the proto to read fields from, e.g. Person, Booking, etc. enum_fields: a mapping from field names (e.g. custody_status) to parsing functions (e.g. CustodyStatus.parse). overrides: the enum overrides mapping. """ self.parsed_enums_from_original_field: Dict[EntityEnumMeta, Dict[str, EntityEnum]] = dict() self.all_parsed_enums: Set[EntityEnum] = set() for field_name, from_enum in enum_fields.items(): value = fn(from_enum.parse, field_name, proto, overrides) if not value: continue if isinstance(value, from_enum): default_mapping: Dict[str, EntityEnum] = {} mappings_by_field = self.parsed_enums_from_original_field.get(from_enum, default_mapping) mappings_by_field[field_name] = value self.parsed_enums_from_original_field[from_enum] = mappings_by_field else: self.all_parsed_enums.add(value)
def _convert_incarceration_incident( self, ingest_incident: StateIncarcerationIncident ) -> entities.StateIncarcerationIncident: """Converts an ingest_info proto StateIncarcerationIncident to a persistence entity.""" incident_builder = entities.StateIncarcerationIncident.builder() state_incarceration_incident.copy_fields_to_builder( incident_builder, ingest_incident, self.metadata) incident_builder.responding_officer = fn( lambda i: state_agent.convert(self.agents[i], self.metadata), "responding_officer_id", ingest_incident, ) converted_outcomes = [ state_incarceration_incident_outcome.convert( self.incarceration_incident_outcomes[outcome_id], self.metadata) for outcome_id in ingest_incident.state_incarceration_incident_outcome_ids ] incident_builder.incarceration_incident_outcomes = converted_outcomes return incident_builder.build()
def _convert_charge(self, ingest_charge): """Converts an ingest_info proto Charge to a persistence entity.""" charge_builder = entities.Charge.builder() charge.copy_fields_to_builder(charge_builder, ingest_charge, self.metadata) charge_builder.bond = \ fn(lambda i: bond.convert(self.bonds[i], self.metadata), 'bond_id', ingest_charge) charge_builder.sentence = \ fn(lambda i: self._convert_sentence(self.sentences[i]), 'sentence_id', ingest_charge) return charge_builder.build()
def convert(proto, metadata: IngestMetadata) -> entities.Hold: """Converts an ingest_info proto Hold to a persistence entity.""" new = entities.Hold.builder() enum_fields = { "status": HoldStatus, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) new.status = enum_mappings.get(HoldStatus, default=HoldStatus.PRESENT_WITHOUT_INFO) new.status_raw_text = fn(normalize, "status", proto) new.external_id = fn(parse_external_id, "hold_id", proto) new.jurisdiction_name = fn(normalize, "jurisdiction_name", proto) return new.build()
def copy_fields_to_builder( early_discharge_builder: entities.StateEarlyDischarge.Builder, proto: StateEarlyDischarge, metadata: IngestMetadata) -> None: """Converts an ingest_info proto StateEarlyDischarge to a early discharge entity.""" new = early_discharge_builder enum_fields = { 'decision': StateEarlyDischargeDecision, 'deciding_body_type': StateActingBodyType, 'requesting_body_type': StateActingBodyType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.decision = enum_mappings.get(StateEarlyDischargeDecision) new.decision_raw_text = fn(normalize, 'decision', proto) new.deciding_body_type = enum_mappings.get(StateActingBodyType, field_name='deciding_body_type') new.deciding_body_type_raw_text = fn(normalize, 'deciding_body_type', proto) new.requesting_body_type = enum_mappings.get( StateActingBodyType, field_name='requesting_body_type') new.requesting_body_type_raw_text = fn(normalize, 'requesting_body_type', proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, 'state_early_discharge_id', proto) new.request_date = fn(parse_date, 'request_date', proto) new.decision_date = fn(parse_date, 'decision_date', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) new.county_code = fn(normalize, 'county_code', proto)
def copy_fields_to_builder( state_parole_decision_builder: entities.StateParoleDecision.Builder, proto: StateParoleDecision, metadata: IngestMetadata) -> None: """Mutates the provided |state_parole_decision_builder| by converting an ingest_info proto StateParoleDecision. Note: This will not copy children into the Builder! """ new = state_parole_decision_builder enum_fields = { 'decision_outcome': StateParoleDecisionOutcome, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # Enum mappings new.decision_outcome = enum_mappings.get(StateParoleDecisionOutcome) new.decision_outcome_raw_text = fn(normalize, 'decision_outcome', proto) new.external_id = fn(parse_external_id, 'state_parole_decision_id', proto) new.decision_date = fn(parse_date, 'decision_date', proto) new.corrective_action_deadline = fn(parse_date, 'corrective_action_deadline', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) new.county_code = fn(normalize, 'county_code', proto) new.decision_reasoning = fn(normalize, 'decision_reasoning', proto) new.corrective_action = fn(normalize, 'corrective_action', proto)
def copy_fields_to_builder( state_assessment_builder: entities.StateAssessment.Builder, proto: StateAssessment, metadata: IngestMetadata) -> None: """Mutates the provided |state_assessment_builder| by converting an ingest_info proto StateAssessment. Note: This will not copy children into the Builder! """ new = state_assessment_builder enum_fields = { 'assessment_class': StateAssessmentClass, 'assessment_type': StateAssessmentType, 'assessment_level': StateAssessmentLevel, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # Enum mappings new.assessment_class = enum_mappings.get(StateAssessmentClass) new.assessment_class_raw_text = fn(normalize, 'assessment_class', proto) new.assessment_type = enum_mappings.get(StateAssessmentType) new.assessment_type_raw_text = fn(normalize, 'assessment_type', proto) new.assessment_level = enum_mappings.get(StateAssessmentLevel) new.assessment_level_raw_text = fn(normalize, 'assessment_level', proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, 'state_assessment_id', proto) new.assessment_date = fn(parse_date, 'assessment_date', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) new.assessment_score = fn(parse_int, 'assessment_score', proto) new.assessment_metadata = fn(normalize, 'assessment_metadata', proto)
def convert(proto: StateBond, metadata: IngestMetadata) -> entities.StateBond: """Converts an ingest_info proto StateBond to a persistence entity.""" new = entities.StateBond.builder() enum_fields = { "status": BondStatus, "bond_type": BondType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.status = enum_mappings.get(BondStatus) new.status_raw_text = fn(normalize, "status", proto) new.bond_type = enum_mappings.get(BondType) new.bond_type_raw_text = fn(normalize, "bond_type", proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, "state_bond_id", proto) new.date_paid = fn(parse_date, "date_paid", proto) new.state_code = parse_region_code_with_override(proto, "state_code", metadata) new.county_code = fn(normalize, "county_code", proto) new.bond_agent = fn(normalize, "bond_agent", proto) ( new.amount_dollars, new.bond_type, new.status, ) = converter_utils.parse_bond_amount_type_and_status( fn(normalize, "amount", proto), provided_bond_type=cast(Optional[BondType], new.bond_type), provided_status=cast(Optional[BondStatus], new.status), ) return new.build()
def copy_fields_to_builder( sentence_group_builder: entities.StateSentenceGroup.Builder, proto: StateSentenceGroup, metadata: IngestMetadata) -> None: """Mutates the provided |sentence_group_builder| by converting an ingest_info proto StateSentenceGroup. Note: This will not copy children into the Builder! """ new = sentence_group_builder enum_fields = { 'status': StateSentenceStatus, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # Enum mappings new.status = enum_mappings.get( StateSentenceStatus, default=StateSentenceStatus.PRESENT_WITHOUT_INFO) new.status_raw_text = fn(normalize, 'status', proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, 'state_sentence_group_id', proto) new.date_imposed = fn(parse_date, 'date_imposed', proto) new.state_code = parse_region_code_with_override( proto, 'state_code', metadata) new.county_code = fn(normalize, 'county_code', proto) new.min_length_days = fn(parse_days, 'min_length', proto) new.max_length_days = fn(parse_days, 'max_length', proto) new.is_life = fn(parse_bool, 'is_life', proto)
def _convert_charge(self, ingest_charge: StateCharge) \ -> entities.StateCharge: """Converts an ingest_info proto StateCharge to a persistence entity.""" charge_builder = entities.StateCharge.builder() state_charge.copy_fields_to_builder(charge_builder, ingest_charge, self.metadata) charge_builder.bond = \ fn(lambda i: state_bond.convert(self.bonds[i], self.metadata), 'state_bond_id', ingest_charge) charge_builder.court_case = \ fn(lambda i: self._convert_court_case(self.court_cases[i]), 'state_court_case_id', ingest_charge) return charge_builder.build()
def _parse_admission(proto, metadata): admission_date = fn(parse_date, 'admission_date', proto) if admission_date is None: admission_date = metadata.ingest_time.date() admission_date_inferred = True else: admission_date_inferred = False return admission_date, admission_date_inferred
def copy_fields_to_builder(booking_builder, proto, metadata): """Mutates the provided |booking_builder| by converting an ingest_info proto Booking. Note: This will not copy children into the Builder! """ new = booking_builder enum_fields = { "admission_reason": AdmissionReason, "release_reason": ReleaseReason, "custody_status": CustodyStatus, "classification": Classification, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # Enum mappings new.admission_reason = enum_mappings.get(AdmissionReason) new.admission_reason_raw_text = fn(normalize, "admission_reason", proto) new.release_reason = enum_mappings.get(ReleaseReason) new.release_reason_raw_text = fn(normalize, "release_reason", proto) new.custody_status = enum_mappings.get( CustodyStatus, default=CustodyStatus.PRESENT_WITHOUT_INFO) new.custody_status_raw_text = fn(normalize, "custody_status", proto) new.classification = enum_mappings.get(Classification) new.classification_raw_text = fn(normalize, "classification", proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, "booking_id", proto) new.projected_release_date = fn(parse_date, "projected_release_date", proto) new.facility = fn(normalize, "facility", proto) new.facility_id = fn(validate_fid, "facility_id", proto, default=metadata.facility_id) # Inferred attributes new.admission_date, new.admission_date_inferred = _parse_admission( proto, metadata) ( new.release_date, new.projected_release_date, new.release_date_inferred, ) = _parse_release_date(proto, metadata) _set_custody_status_if_needed(new) # Metadata new.last_seen_time = metadata.ingest_time # Will be overwritten by first_seen_time value in database if one is already # present new.first_seen_time = metadata.ingest_time
def _parse_release_date( proto, metadata: IngestMetadata ) -> Tuple[Optional[date], Optional[date], Optional[bool]]: """Reads release_date and projected_release_date from |proto|. If release_date is present on proto, sets release_date_inferred to (False). If release_date is in the future relative to scrape time, will be treated as projected_release_date instead. """ release_date = fn(parse_date, "release_date", proto) projected_release_date = fn(parse_date, "projected_release_date", proto) if release_date and release_date > metadata.ingest_time.date(): projected_release_date = release_date release_date = None release_date_inferred = None if release_date is None else False return release_date, projected_release_date, release_date_inferred
def _convert_supervision_period( self, ingest_supervision_period: StateSupervisionPeriod) \ -> entities.StateSupervisionPeriod: """Converts an ingest_info proto StateSupervisionPeriod to a persistence entity.""" supervision_period_builder = \ entities.StateSupervisionPeriod.builder() state_supervision_period.copy_fields_to_builder( supervision_period_builder, ingest_supervision_period, self.metadata) supervision_period_builder.supervising_officer = \ fn(lambda i: state_agent.convert(self.agents[i], self.metadata), 'supervising_officer_id', ingest_supervision_period) converted_violations = [ self._convert_supervision_violation( self.supervision_violations[violation_id]) for violation_id in ingest_supervision_period.state_supervision_violation_entry_ids ] supervision_period_builder.supervision_violation_entries = \ converted_violations converted_assessments = [ self._convert_assessment(self.assessments[assessment_id]) for assessment_id in ingest_supervision_period.state_assessment_ids ] supervision_period_builder.assessments = converted_assessments converted_program_assignments = [ self._convert_program_assignment( self.program_assignments[assignment_id]) for assignment_id in ingest_supervision_period.state_program_assignment_ids ] supervision_period_builder.program_assignments = \ converted_program_assignments converted_case_types = [ state_supervision_case_type_entry.convert( self.supervision_case_type_entries[case_type_id], self.metadata) for case_type_id in ingest_supervision_period.state_supervision_case_type_entry_ids ] supervision_period_builder.case_type_entries = converted_case_types converted_contacts = [ self._convert_supervision_contact( self.supervision_contacts[contact_id]) for contact_id in ingest_supervision_period.state_supervision_contact_ids ] supervision_period_builder.supervision_contacts = converted_contacts return supervision_period_builder.build()
def convert(proto: StateAgent, metadata: IngestMetadata) -> entities.StateAgent: """Converts an ingest_info proto StateAgent to a persistence entity.""" new = entities.StateAgent.builder() enum_fields = { 'agent_type': StateAgentType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.agent_type = enum_mappings.get(StateAgentType) new.agent_type_raw_text = fn(normalize, 'agent_type', proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, 'state_agent_id', proto) new.state_code = parse_region_code_with_override(proto, 'state_code', metadata) new.full_name = parse_name(proto) return new.build()
def copy_fields_to_builder( state_incarceration_incident_builder: entities.StateIncarcerationIncident. Builder, proto: StateIncarcerationIncident, metadata: IngestMetadata, ) -> None: """Mutates the provided |state_incarceration_incident_builder| by converting an ingest_info proto StateIncarcerationIncident. Note: This will not copy children into the Builder! """ new = state_incarceration_incident_builder enum_fields = { "incident_type": StateIncarcerationIncidentType, } enum_mappings = EnumMappings(proto, enum_fields, metadata.enum_overrides) # enum values new.incident_type = enum_mappings.get(StateIncarcerationIncidentType) new.incident_type_raw_text = fn(normalize, "incident_type", proto) # 1-to-1 mappings new.external_id = fn(parse_external_id, "state_incarceration_incident_id", proto) new.incident_date = fn(parse_date, "incident_date", proto) new.state_code = parse_region_code_with_override(proto, "state_code", metadata) new.facility = fn(normalize, "facility", proto) new.location_within_facility = fn(normalize, "location_within_facility", proto) new.incident_details = fn(normalize, "incident_details", proto)
def _convert_court_case(self, ingest_court_case: StateCourtCase): court_case_builder = entities.StateCourtCase.builder() state_court_case.copy_fields_to_builder(court_case_builder, ingest_court_case, self.metadata) court_case_builder.judge = \ fn(lambda i: state_agent.convert(self.agents[i], self.metadata), 'judge_id', ingest_court_case) return court_case_builder.build()
def convert( proto: StateSupervisionViolatedConditionEntry, metadata: IngestMetadata ) -> entities.StateSupervisionViolatedConditionEntry: """Converts an ingest_info proto StateSupervisionViolatedConditionEntry to a persistence entity.""" new = entities.StateSupervisionViolatedConditionEntry.builder() # 1-to-1 mappings new.condition = fn(normalize, "condition", proto) new.state_code = parse_region_code_with_override(proto, "state_code", metadata) return new.build()