Example #1
0
    def test_supervision_type_lifetime_supervision_after_inst_completion(self):
        raw_statuses = [
            {
                'sentence_external_id': '13252-20160627-1',
                'sentence_status_external_id': '13252-20160627-1-1',
                'status_code': '10I1000',
                'status_date': '20160627',
                'status_description': 'New Court Comm-Institution'
            },
            {
                'sentence_external_id': '13252-20160627-1',
                'sentence_status_external_id': '13252-20160627-1-2',
                'status_code': '90O1010',
                'status_date': '20190415',
                'status_description': "Inst. Expiration of Sentence"
            },
            {
                'sentence_external_id': '13252-20160627-1',
                'sentence_status_external_id': '13252-20160627-1-3',
                'status_code': '40O6020',
                'status_date': '20190415',
                'status_description': 'Release for Lifetime Supv'
            },
        ]

        base_sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='13252-20160627-1',
            start_date=datetime.date(year=2016, month=6, day=27))
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            base_sentence, raw_statuses)

        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                self.validation_date), StateSupervisionType.PAROLE)
Example #2
0
    def test_create_mo_incarceration_sentence(self):
        # Arrange
        raw_sentence_statuses = [
            {
                'sentence_external_id': '1167633-20171012-1',
                'sentence_status_external_id': '1167633-20171012-1-1',
                'status_code': '10I1000',
                'status_date': '20171012',
                'status_description': 'New Court Comm-Institution'
            },
        ]

        sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='1167633-20171012-1')

        # Act
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            sentence, raw_sentence_statuses)

        # Assert
        self.assertEqual(us_mo_sentence.base_sentence, sentence)
        self.assertEqual(us_mo_sentence.sentence_statuses, [
            UsMoSentenceStatus(
                sentence_status_external_id='1167633-20171012-1-1',
                sentence_external_id='1167633-20171012-1',
                status_code='10I1000',
                status_date=datetime.date(year=2017, month=10, day=12),
                status_description='New Court Comm-Institution')
        ])

        self.assertTrue(isinstance(us_mo_sentence, StateIncarcerationSentence))
        self.assertEqual(us_mo_sentence.external_id, sentence.external_id)
    def process(self,
                element,
                us_mo_sentence_statuses_by_sentence,
                *args,
                **kwargs):
        """For the given sentence convert to a state-specific subclass, if necessary.

        Args:
            element: A tuple containing person_id and either a StateSupervisionSentence or a StateIncarcerationSentence

        Yields:
            A tuple containing person_id and the sentence, converted to a state-specific subclass, if necessary
        """
        person_id, sentence = element

        state_specific_sentence = sentence
        if sentence.state_code == 'US_MO':

            sentence_statuses = []
            if sentence.external_id in us_mo_sentence_statuses_by_sentence:
                sentence_statuses = us_mo_sentence_statuses_by_sentence[sentence.external_id]

            if isinstance(sentence, entities.StateSupervisionSentence):
                state_specific_sentence = UsMoSupervisionSentence.from_supervision_sentence(sentence, sentence_statuses)
            elif isinstance(sentence, entities.StateIncarcerationSentence):
                state_specific_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(sentence,
                                                                                                sentence_statuses)
            else:
                raise ValueError(f'Unexpected sentence type: {sentence}')

        yield person_id, state_specific_sentence
Example #4
0
    def test_suspended_and_reinstated(self):
        raw_statuses = [{
            "sentence_external_id": "1001298-20160310-1",
            "sentence_status_external_id": "1001298-20160310-1-1",
            "status_code": "15I1000",
            "status_date": "20160310",
            "status_description": "New Court Probation"
        }, {
            "sentence_external_id": "1001298-20160310-1",
            "sentence_status_external_id": "1001298-20160310-1-2",
            "status_code": "65O2015",
            "status_date": "20160712",
            "status_description": "Court Probation Suspension"
        }, {
            "sentence_external_id": "1001298-20160310-1",
            "sentence_status_external_id": "1001298-20160310-1-3",
            "status_code": "65I2015",
            "status_date": "20180726",
            "status_description": "Court Probation Reinstated"
        }, {
            "sentence_external_id": "1001298-20160310-1",
            "sentence_status_external_id": "1001298-20160310-1-4",
            "status_code": "65O2015",
            "status_date": "20191030",
            "status_description": "Court Probation Suspension"
        }, {
            "sentence_external_id": "1001298-20160310-1",
            "sentence_status_external_id": "1001298-20160310-1-5",
            "status_code": "99O1000",
            "status_date": "20200220",
            "status_description": "Court Probation Discharge"
        }]

        base_sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='1001298-20160310-1',
            start_date=datetime.date(year=2016, month=3, day=10))
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            base_sentence, raw_statuses)

        # Suspension - treated same as termination
        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                datetime.date(2016, 7, 12)), None)

        # Suspension end - back on probation
        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                datetime.date(2018, 7, 26)), StateSupervisionType.PROBATION)

        # Suspension #2 - treated same as termination
        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                datetime.date(2019, 10, 30)), None)

        # Actual discharge
        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                datetime.date(2020, 2, 20)), None)
Example #5
0
    def process(self, element, *args, **kwargs):
        """For the sentences of the given person, convert to a state-specific subclass, if necessary.

        Args:
            element: A tuple containing person_id and a dictionary with all of the person's incarceration sentences,
                supervision sentences, and sentence statuses (if applicable)

        Yields:
            For each incarceration and supervision sentence, yields a tuple containing person_id and the sentence,
                converted to a state-specific subclass, if necessary
        """
        person_id, sentences_and_statuses = element

        incarceration_sentences = sentences_and_statuses.get('incarceration_sentences')
        supervision_sentences = sentences_and_statuses.get('supervision_sentences')
        all_sentence_statuses = sentences_and_statuses.get('sentence_statuses')

        us_mo_sentence_statuses_by_sentence: Dict[str, List[Dict[str, str]]] = defaultdict(list)

        if all_sentence_statuses:
            # Build a dictionary that maps each sentence_external_id to a list of dictionaries containing status
            # updates for this sentence
            for status_dict in all_sentence_statuses:
                sentence_external_id = status_dict.get('sentence_external_id')

                if sentence_external_id:
                    us_mo_sentence_statuses_by_sentence[sentence_external_id].append(status_dict)

        for incarceration_sentence in incarceration_sentences:
            state_specific_incarceration_sentence = incarceration_sentence
            if incarceration_sentence.state_code == 'US_MO':

                sentence_statuses = []
                if incarceration_sentence.external_id in us_mo_sentence_statuses_by_sentence:
                    sentence_statuses = us_mo_sentence_statuses_by_sentence[incarceration_sentence.external_id]

                state_specific_incarceration_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
                    incarceration_sentence, sentence_statuses)

            yield beam.pvalue.TaggedOutput('incarceration_sentences',
                                           (person_id, state_specific_incarceration_sentence))

        for supervision_sentence in supervision_sentences:
            state_specific_supervision_sentence = supervision_sentence
            if supervision_sentence.state_code == 'US_MO':

                sentence_statuses = []
                if supervision_sentence.external_id in us_mo_sentence_statuses_by_sentence:
                    sentence_statuses = us_mo_sentence_statuses_by_sentence[supervision_sentence.external_id]

                state_specific_supervision_sentence = UsMoSupervisionSentence.from_supervision_sentence(
                    supervision_sentence, sentence_statuses)

            yield beam.pvalue.TaggedOutput('supervision_sentences',
                                           (person_id, state_specific_supervision_sentence))
Example #6
0
    def test_no_statuses_does_not_crash(self):
        raw_statuses = []

        base_sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='13252-20160627-1',
            start_date=datetime.date(year=2016, month=6, day=27))
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            base_sentence, raw_statuses)

        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                self.validation_date), None)
Example #7
0
    def test_incarcerated_on_date(self):
        raw_statuses = [{
            'sentence_external_id': '13252-20160627-1',
            'sentence_status_external_id': '13252-20160627-1-1',
            'status_code': '10I1000',
            'status_date': '20160627',
            'status_description': 'New Court Comm-Institution'
        }]

        base_sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='13252-20160627-1',
            start_date=datetime.date(year=2016, month=6, day=27))
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            base_sentence, raw_statuses)

        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                self.validation_date), None)
Example #8
0
    def test_supervision_type_court_parole(self):
        # Court Parole is actually probation
        raw_statuses = [{
            "sentence_external_id": "1344959-20190718-1",
            "sentence_status_external_id": "1344959-20190718-1-1",
            "status_code": "15I1200",
            "status_date": "20190718",
            "status_description": "New Court Parole"
        }]

        base_sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='1344959-20190718-1',
            start_date=datetime.date(year=2017, month=10, day=12))
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            base_sentence, raw_statuses)

        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                self.validation_date), StateSupervisionType.PROBATION)
Example #9
0
    def test_lifetime_supervision_no_supervision_in(self):
        raw_statuses = [{
            "sentence_external_id": "1096616-20060515-3",
            "sentence_status_external_id": "1096616-20060515-3-5",
            "status_code": "20I1000",
            "status_date": "20090611",
            "status_description": "Court Comm-Inst-Addl Charge"
        }, {
            "sentence_external_id": "1096616-20060515-3",
            "sentence_status_external_id": "1096616-20060515-3-10",
            "status_code": "90O1070",
            "status_date": "20151129",
            "status_description": "Director's Rel Comp-Life Supv"
        }]

        base_sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='1096616-20060515-3',
            start_date=datetime.date(year=2009, month=6, day=11))
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            base_sentence, raw_statuses)

        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                self.validation_date), StateSupervisionType.PAROLE)
Example #10
0
    def test_supervision_type_parole(self):
        raw_statuses = [{
            'sentence_external_id': '1167633-20171012-2',
            'sentence_status_external_id': '1167633-20171012-2-1',
            'status_code': '10I1000',
            'status_date': '20171012',
            'status_description': 'New Court Comm-Institution'
        }, {
            'sentence_external_id': '1167633-20171012-2',
            'sentence_status_external_id': '1167633-20171012-2-2',
            'status_code': '40O1010',
            'status_date': '20190913',
            'status_description': 'Parole Release'
        }]

        base_sentence = StateIncarcerationSentence.new_with_defaults(
            external_id='1167633-20171012-2',
            start_date=datetime.date(year=2017, month=10, day=12))
        us_mo_sentence = UsMoIncarcerationSentence.from_incarceration_sentence(
            base_sentence, raw_statuses)

        self.assertEqual(
            us_mo_sentence.get_sentence_supervision_type_on_day(
                self.validation_date), StateSupervisionType.PAROLE)
    def test_ConvertSentenceToStateSpecificType_incarceration_sentence_mo(
            self):
        """Tests that for MO, incarceration sentences get converted to UsMoIncarcerationSentence."""
        person_id = 456
        incarceration_sentence_id = 123

        incarceration_sentence = StateIncarcerationSentence.new_with_defaults(
            incarceration_sentence_id=incarceration_sentence_id,
            state_code='US_MO',
            external_id='123-external-id',
            start_date=date(2000, 1, 1),
        )

        expected_sentence = UsMoIncarcerationSentence.new_with_defaults(
            incarceration_sentence_id=incarceration_sentence_id,
            state_code='US_MO',
            external_id='123-external-id',
            start_date=date(2000, 1, 1),
            base_sentence=incarceration_sentence,
            sentence_statuses=[self.TEST_CONVERTED_MO_STATUS])

        self.run_test_pipeline(person_id, incarceration_sentence,
                               self.TEST_MO_SENTENCE_STATUS_ROWS,
                               expected_sentence)