def test_nonblocking_charge_is_not_skipped_and_does_not_block(): civil_offense = ChargeFactory.create(level="N/A", statute="1.000", disposition=DispositionCreator.create( ruling="Convicted", date=Time.ONE_YEAR_AGO)) violation_charge = ChargeFactory.create( level="Class A Violation", date=Time.TEN_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.TEN_YEARS_AGO), ) case = CaseFactory.create(charges=tuple([civil_offense, violation_charge])) expunger_result = Expunger.run(Record(tuple([case]))) assert expunger_result[ civil_offense. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert (expunger_result[civil_offense.ambiguous_charge_id].reason == "Never. Type ineligible charges are always time ineligible.") assert expunger_result[ civil_offense.ambiguous_charge_id].date_will_be_eligible == date.max assert expunger_result[ violation_charge. ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
def test_very_old_needs_more_analysis_mrc_with_single_arrest(): charge_dict = ChargeFactory.default_dict() charge_dict["name"] = "Assault in the third degree" charge_dict["statute"] = "163.165" charge_dict["level"] = "Felony Class C" charge_dict["disposition"] = Disposition(ruling="Convicted", date=Time.TWENTY_YEARS_AGO) mrc = ChargeFactory.create(**charge_dict) arrest = ChargeFactory.create( disposition=Disposition(ruling="Dismissed", date=Time.THREE_YEARS_AGO)) case = CaseFactory.create() case.charges = [mrc, arrest] record = Record([case]) expunger = Expunger(record) expunger.run() three_years_from_mrc = mrc.disposition.date + Time.THREE_YEARS assert arrest.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE assert arrest.expungement_result.time_eligibility.date_will_be_eligible == three_years_from_mrc assert arrest.expungement_result.time_eligibility.date_eligible_without_friendly_rule == Time.THREE_YEARS_AGO assert arrest.expungement_result.charge_eligibility.status == ChargeEligibilityStatus.ELIGIBLE_NOW assert arrest.expungement_result.charge_eligibility.label == "Eligible" assert mrc.expungement_result.type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS assert mrc.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE assert mrc.expungement_result.time_eligibility.date_will_be_eligible == three_years_from_mrc assert mrc.expungement_result.charge_eligibility.status == ChargeEligibilityStatus.POSSIBLY_ELIGIBILE assert mrc.expungement_result.charge_eligibility.label == "Possibly Eligible (review)"
def test_2_violations_are_time_restricted(): violation_charge_1 = ChargeFactory.create( level="Class A Violation", date=Time.LESS_THAN_THREE_YEARS_AGO, disposition=DispositionCreator.create( ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO), ) violation_charge_2 = ChargeFactory.create( level="Class A Violation", date=Time.TWO_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.TWO_YEARS_AGO), ) case = CaseFactory.create( charges=tuple([violation_charge_1, violation_charge_2])) expunger_result = Expunger.run(Record(tuple([case]))) assert expunger_result[ violation_charge_1. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert (expunger_result[violation_charge_1.ambiguous_charge_id].reason == "Three years from date of conviction (137.225(1)(a))") assert (expunger_result[violation_charge_1.ambiguous_charge_id]. date_will_be_eligible == violation_charge_1.disposition.date + Time.THREE_YEARS) assert expunger_result[ violation_charge_2. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert (expunger_result[violation_charge_2.ambiguous_charge_id].reason == "Three years from date of conviction (137.225(1)(a))") assert (expunger_result[violation_charge_2.ambiguous_charge_id]. date_will_be_eligible == violation_charge_2.disposition.date + Time.THREE_YEARS)
def test_ineligible_mrc_with_arrest_on_single_case(self): # In this case, the friendly rule doesn't apply because the conviction doesn't become eligible mrc = ChargeFactory.create( case_number="1", disposition=DispositionCreator.create( ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO), statute="666.666", level="Felony Class A", ) arrest = ChargeFactory.create( case_number="1", disposition=DispositionCreator.create( ruling="Dismissed", date=Time.LESS_THAN_THREE_YEARS_AGO), ) case = CaseFactory.create(charges=tuple([mrc, arrest])) record = Record(tuple([case])) expunger_result = Expunger.run(record) assert expunger_result[ arrest.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert (expunger_result[arrest.ambiguous_charge_id].reason == "Ten years from most recent conviction (137.225(7)(b))") assert expunger_result[ mrc.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert (expunger_result[mrc.ambiguous_charge_id].reason == "Never. Type ineligible charges are always time ineligible.") assert expunger_result[ mrc.ambiguous_charge_id].date_will_be_eligible == date.max
def test_3_violations_are_time_restricted(): violation_charge_1 = ChargeFactory.create( level="Class A Violation", date=Time.LESS_THAN_THREE_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO), ) violation_charge_2 = ChargeFactory.create( level="Class A Violation", date=Time.TWO_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.TWO_YEARS_AGO), ) violation_charge_3 = ChargeFactory.create( level="Class A Violation", date=Time.ONE_YEAR_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.ONE_YEAR_AGO), ) arrest = ChargeFactory.create(disposition=DispositionCreator.create(ruling="Dismissed", date=Time.ONE_YEAR_AGO)) case = CaseFactory.create(charges=tuple([violation_charge_3, violation_charge_2, violation_charge_1, arrest])) expunger_result = Expunger.run(Record(tuple([case]))) earliest_date_eligible = min( expunger_result[violation_charge_1.ambiguous_charge_id].date_will_be_eligible, expunger_result[violation_charge_2.ambiguous_charge_id].date_will_be_eligible, expunger_result[violation_charge_3.ambiguous_charge_id].date_will_be_eligible, ) assert expunger_result[arrest.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[arrest.ambiguous_charge_id].reason == 'Time eligibility of the arrest matches conviction on the same case (the "friendly" rule)' ) assert expunger_result[arrest.ambiguous_charge_id].date_will_be_eligible == earliest_date_eligible
def test_eligible_mrc_with_single_arrest(): three_yr_mrc = ChargeFactory.create( disposition=Disposition(ruling="Convicted", date=Time.THREE_YEARS_AGO)) arrest = ChargeFactory.create( disposition=Disposition(ruling="Dismissed", date=Time.THREE_YEARS_AGO)) case = CaseFactory.create() case.charges = [three_yr_mrc, arrest] record = Record([case]) expunger = Expunger(record) expunger.run() assert arrest.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE assert ( arrest.expungement_result.time_eligibility.reason == 'Time eligibility of the arrest matches conviction on the same case (the "friendly" rule)' ) assert arrest.expungement_result.time_eligibility.date_will_be_eligible == date.today( ) assert three_yr_mrc.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE assert three_yr_mrc.expungement_result.time_eligibility.reason == "" assert three_yr_mrc.expungement_result.time_eligibility.date_will_be_eligible == date.today( )
def test_marijuana_violation_eligible_with_prior_conviction(): marijuana_violation = ChargeFactory.create( case_number="1", name="Possession of Marijuana < 1 Ounce", statute="4758643", level="Violation Unclassified", date=date.today(), disposition=DispositionCreator.create(ruling="Convicted", date=date.today() + relativedelta(days=-1)), ) case_1 = CaseFactory.create(case_number="1", charges=tuple([marijuana_violation])) prior_conviction = ChargeFactory.create( case_number="2", name="Identity Theft", statute="165.800", level="Felony Class C", date=Time.FIVE_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.ONE_YEAR_AGO), ) case_2 = CaseFactory.create(case_number="2", charges=tuple([prior_conviction])) expunger_result = Expunger.run(Record(tuple([case_1, case_2]))) assert isinstance(marijuana_violation.charge_type, MarijuanaViolation) assert expunger_result[marijuana_violation.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert expunger_result[prior_conviction.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
def setUp(self): self.case_1 = CaseFactory.create() self.case_2 = CaseFactory.create() self.recent_dismissal = ChargeFactory.create_dismissed_charge( case=self.case_1, date=Time.TWO_YEARS_AGO) self.case_1.charges = [self.recent_dismissal]
def test_doubly_eligible_b_felony_gets_normal_eligibility_rule(): # This charge is both ManufactureDelivery and also a class B felony. ManufactureDelivery classification takes precedence and the B felony time rule does not apply. manudel_charges = ChargeFactory.create_ambiguous_charge( case_number="1", name="Manufacture/Delivery 1", statute="4759922b", level="Felony Class B", date=Time.LESS_THAN_TWENTY_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.LESS_THAN_TWENTY_YEARS_AGO), ) manudel_type_eligilibility = RecordMerger.merge_type_eligibilities(manudel_charges) case_1a = CaseFactory.create(case_number="1", charges=tuple([manudel_charges[0]])) case_1b = CaseFactory.create(case_number="1", charges=tuple([manudel_charges[1]])) subsequent_charge = ChargeFactory.create( case_number="2", disposition=DispositionCreator.create(ruling="Convicted", date=Time.TEN_YEARS_AGO), ) case_2 = CaseFactory.create(case_number="2", charges=tuple([subsequent_charge])) possible_record_1 = Record(tuple([case_1a, case_2])) possible_record_2 = Record(tuple([case_1b, case_2])) expunger_result_1 = Expunger.run(possible_record_1) expunger_result_2 = Expunger.run(possible_record_2) assert manudel_type_eligilibility.status is EligibilityStatus.ELIGIBLE assert expunger_result_1[manudel_charges[0].ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert expunger_result_2[manudel_charges[1].ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
def test_2_violations_are_time_restricted(): violation_charge_1 = ChargeFactory.create( level="Class A Violation", date=Time.LESS_THAN_THREE_YEARS_AGO, disposition=Disposition(ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO), ) violation_charge_2 = ChargeFactory.create( level="Class A Violation", date=Time.TWO_YEARS_AGO, disposition=Disposition(ruling="Convicted", date=Time.TWO_YEARS_AGO), ) case = CaseFactory.create() case.charges = [violation_charge_1, violation_charge_2] expunger = Expunger(Record([case])) expunger.run() assert violation_charge_1.expungement_result.time_eligibility.status is EligibilityStatus.INELIGIBLE assert (violation_charge_1.expungement_result.time_eligibility.reason == "Three years from date of conviction (137.225(1)(a))") assert (violation_charge_1.expungement_result.time_eligibility. date_will_be_eligible == violation_charge_1.disposition.date + Time.THREE_YEARS) assert violation_charge_2.expungement_result.time_eligibility.status is EligibilityStatus.INELIGIBLE assert (violation_charge_2.expungement_result.time_eligibility.reason == "Three years from date of conviction (137.225(1)(a))") assert (violation_charge_2.expungement_result.time_eligibility. date_will_be_eligible == violation_charge_2.disposition.date + Time.THREE_YEARS)
def create_dismissed_charge( case=CaseFactory.create(), name="Theft of services", statute="164.125", level="Misdemeanor Class A", date=date_class(1901, 1, 1), ):
def test_3_yr_old_and_2_yr_old_class_a_misdemeanors(self): three_years_ago_charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.THREE_YEARS_AGO) ) two_years_ago_charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.TWO_YEARS_AGO) ) case = CaseFactory.create(charges=tuple([two_years_ago_charge, three_years_ago_charge])) record = Record(tuple([case])) expunger_result = Expunger.run(record) assert expunger_result[three_years_ago_charge.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[three_years_ago_charge.ambiguous_charge_id].reason == f"137.225(7)(b) – Three years from most recent other conviction from case [{case.summary.case_number}]." ) assert ( expunger_result[three_years_ago_charge.ambiguous_charge_id].date_will_be_eligible == two_years_ago_charge.disposition.date + Time.THREE_YEARS ) assert expunger_result[two_years_ago_charge.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[two_years_ago_charge.ambiguous_charge_id].reason == "Three years from date of conviction (137.225(1)(b))" ) assert ( expunger_result[two_years_ago_charge.ambiguous_charge_id].date_will_be_eligible == two_years_ago_charge.disposition.date + Time.THREE_YEARS )
def test_7_yr_old_conviction_2_yr_old_mrc(self): seven_year_ago_charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.SEVEN_YEARS_AGO), name="Identity Theft", statute="165.800", level="Felony Class C", ) two_year_ago_charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.TWO_YEARS_AGO) ) case = CaseFactory.create(charges=tuple([two_year_ago_charge, seven_year_ago_charge])) record = Record(tuple([case])) expunger_result = Expunger.run(record) assert expunger_result[seven_year_ago_charge.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[seven_year_ago_charge.ambiguous_charge_id].reason == f"137.225(7)(b) – Five years from most recent other conviction from case [{case.summary.case_number}]." ) assert ( expunger_result[seven_year_ago_charge.ambiguous_charge_id].date_will_be_eligible == two_year_ago_charge.disposition.date + Time.FIVE_YEARS ) assert expunger_result[two_year_ago_charge.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[two_year_ago_charge.ambiguous_charge_id].reason == "Three years from date of conviction (137.225(1)(b))" ) assert ( expunger_result[two_year_ago_charge.ambiguous_charge_id].date_will_be_eligible == two_year_ago_charge.disposition.date + Time.THREE_YEARS )
def test_arrest_time_eligibility_is_set_to_older_violation(): older_violation = ChargeFactory.create( level="Class A Violation", date=Time.LESS_THAN_THREE_YEARS_AGO, disposition=DispositionCreator.create( ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO), ) newer_violation = ChargeFactory.create( level="Class A Violation", date=Time.TWO_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.TWO_YEARS_AGO), ) arrest = ChargeFactory.create(disposition=DispositionCreator.create( ruling="Dismissed", date=Time.ONE_YEAR_AGO)) case = CaseFactory.create( charges=tuple([older_violation, newer_violation, arrest])) expunger_result = Expunger.run(Record(tuple([case]))) assert expunger_result[ arrest.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[arrest.ambiguous_charge_id].reason == 'Time eligibility of the arrest matches conviction on the same case (the "friendly" rule)' ) assert (expunger_result[arrest.ambiguous_charge_id].date_will_be_eligible == older_violation.disposition.date + Time.THREE_YEARS)
def test_10_yr_old_conviction_with_3_yr_old_mrc(self): ten_yr_charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.TEN_YEARS_AGO)) three_yr_mrc = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.THREE_YEARS_AGO)) case = CaseFactory.create(charges=tuple([ten_yr_charge, three_yr_mrc])) record = Record(tuple([case])) expunger_result = Expunger.run(record) assert expunger_result[ ten_yr_charge. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert (expunger_result[ten_yr_charge.ambiguous_charge_id].reason == "Ten years from most recent other conviction (137.225(7)(b))") assert (expunger_result[ten_yr_charge.ambiguous_charge_id]. date_will_be_eligible == three_yr_mrc.disposition.date + Time.TEN_YEARS) assert expunger_result[ three_yr_mrc. ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert expunger_result[ three_yr_mrc.ambiguous_charge_id].reason == "Eligible now" assert (expunger_result[three_yr_mrc.ambiguous_charge_id]. date_will_be_eligible == ten_yr_charge.disposition.date + Time.TEN_YEARS)
def test_eligible_mrc_with_single_arrest(): three_yr_mrc = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.THREE_YEARS_AGO) ) arrest = ChargeFactory.create(disposition=DispositionCreator.create(ruling="Dismissed", date=Time.THREE_YEARS_AGO)) case = CaseFactory.create(charges=tuple([three_yr_mrc, arrest])) record = Record(tuple([case])) expunger_result = Expunger.run(record) assert expunger_result[arrest.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert ( expunger_result[arrest.ambiguous_charge_id].reason == 'Time eligibility of the arrest matches conviction on the same case (the "friendly" rule)' ) assert expunger_result[arrest.ambiguous_charge_id].date_will_be_eligible == date.today() assert expunger_result[three_yr_mrc.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert expunger_result[three_yr_mrc.ambiguous_charge_id].reason == "Eligible now" assert expunger_result[three_yr_mrc.ambiguous_charge_id].date_will_be_eligible == date.today() merged_record = RecordMerger.merge([record], [expunger_result]) assert ( merged_record.cases[0].charges[0].expungement_result.charge_eligibility.status # type: ignore == ChargeEligibilityStatus.ELIGIBLE_NOW ) assert merged_record.cases[0].charges[0].expungement_result.charge_eligibility.label == "Eligible" # type: ignore assert ( merged_record.cases[0].charges[1].expungement_result.charge_eligibility.status # type: ignore == ChargeEligibilityStatus.ELIGIBLE_NOW ) assert merged_record.cases[0].charges[1].expungement_result.charge_eligibility.label == "Eligible" # type: ignore
def test_very_old_needs_more_analysis_mrc_with_single_arrest(): eligible_charge, ineligible_charge = ChargeFactory.create_ambiguous_charge( name="Assault in the third degree", statute="163.165", level="Felony Class C", disposition=DispositionCreator.create(ruling="Convicted", date=Time.TWENTY_YEARS_AGO), ) arrest = ChargeFactory.create(disposition=DispositionCreator.create(ruling="Dismissed", date=Time.THREE_YEARS_AGO)) case_a = CaseFactory.create(charges=tuple([eligible_charge, arrest])) case_b = CaseFactory.create(charges=tuple([ineligible_charge, arrest])) record_a = Record(tuple([case_a])) record_b = Record(tuple([case_b])) expunger_result_a = Expunger.run(record_a) expunger_result_b = Expunger.run(record_b) three_years_from_mrc = eligible_charge.disposition.date + Time.THREE_YEARS assert expunger_result_a[arrest.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert ( expunger_result_a[arrest.ambiguous_charge_id].reason == 'Time eligibility of the arrest matches conviction on the same case (the "friendly" rule)' ) assert expunger_result_a[arrest.ambiguous_charge_id].date_will_be_eligible == three_years_from_mrc assert expunger_result_b[arrest.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert expunger_result_b[arrest.ambiguous_charge_id].reason == "Eligible now" assert expunger_result_b[arrest.ambiguous_charge_id].date_will_be_eligible == arrest.disposition.date
def test_10_yr_old_conviction_with_less_than_3_yr_old_mrc(self): ten_yr_charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.TEN_YEARS_AGO)) less_than_three_yr_mrc = ChargeFactory.create( disposition=DispositionCreator.create( ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO)) case = CaseFactory.create( charges=tuple([ten_yr_charge, less_than_three_yr_mrc])) record = Record(tuple([case])) expunger_result = Expunger.run(record) assert expunger_result[ ten_yr_charge. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert (expunger_result[ten_yr_charge.ambiguous_charge_id].reason == "Ten years from most recent other conviction (137.225(7)(b))") assert ( expunger_result[ten_yr_charge.ambiguous_charge_id]. date_will_be_eligible == less_than_three_yr_mrc.disposition.date + Time.TEN_YEARS) assert expunger_result[ less_than_three_yr_mrc. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[less_than_three_yr_mrc.ambiguous_charge_id].reason == "Three years from date of conviction (137.225(1)(a))") assert expunger_result[ less_than_three_yr_mrc. ambiguous_charge_id].date_will_be_eligible == date.today( ) + relativedelta(days=+1)
def test_felony_class_b_with_subsequent_conviction(): b_felony_charge = create_class_b_felony_charge("1", Time.TWENTY_YEARS_AGO) case_1 = CaseFactory.create(case_number="1", charges=tuple([b_felony_charge])) subsequent_charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.TEN_YEARS_AGO)) case_2 = CaseFactory.create(case_number="2", charges=tuple([subsequent_charge])) expunger_result = Expunger.run(Record(tuple([case_1, case_2]))) assert expunger_result[ b_felony_charge. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[b_felony_charge.ambiguous_charge_id].reason == "Never. Class B felony can have no subsequent arrests or convictions (137.225(5)(a)(A)(ii))" ) assert expunger_result[ b_felony_charge.ambiguous_charge_id].date_will_be_eligible == date.max # The Class B felony does not affect eligibility of another charge that is otherwise eligible assert expunger_result[ subsequent_charge. ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert subsequent_charge.type_eligibility.status is EligibilityStatus.ELIGIBLE
def test_felony_class_b_less_than_20yrs(): charge = create_class_b_felony_charge("1", Time.LESS_THAN_SEVEN_YEARS_AGO) case = CaseFactory.create(charges=tuple([charge])) expunger_result = Expunger.run(Record(tuple([case]))) assert expunger_result[charge.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert expunger_result[charge.ambiguous_charge_id].reason == "Seven years from date of conviction (137.225(1)(b))" assert expunger_result[charge.ambiguous_charge_id].date_will_be_eligible == Time.TOMORROW
def test_print_balance_in_cents(self): recordTest = RecordFactory.create([ CaseFactory.create(balance='123.00'), CaseFactory.create(balance='246.00') ]) assert recordTest.total_balance_due == 369.00
def test_felony_class_b_seven_years(): charge = create_class_b_felony_charge("1", Time.SEVEN_YEARS_AGO) case = CaseFactory.create(charges=tuple([charge])) expunger_result = Expunger.run(Record(tuple([case]))) assert expunger_result[charge.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert expunger_result[charge.ambiguous_charge_id].reason == "Eligible now" assert expunger_result[charge.ambiguous_charge_id].date_will_be_eligible == date.today()
def create( case=CaseFactory.create(), name="Theft of services", statute="164.125", level="Misdemeanor Class A", date=date_class(1901, 1, 1), disposition=None, ):
def setUp(self): self.case_1 = CaseFactory.create(case_number="1") self.case_2 = CaseFactory.create(case_number="2") self.recent_dismissal = ChargeFactory.create_dismissed_charge( case_number=self.case_1.case_number, date=Time.TWO_YEARS_AGO, violation_type=self.case_1.violation_type) self.case_1.charges = [self.recent_dismissal]
def setUp(self): self.charge_dict = ChargeFactory.build() case = CaseFactory.create(type_status=["Municipal Parking", "Closed"]) self.charge_dict["statute"] = "109" self.charge_dict["case"] = case self.charge_dict["level"] = "Violation Unclassified" last_week = datetime.today() - timedelta(days=7) self.convicted = ["Convicted", last_week] self.dismissed = ["Dismissed", last_week]
def setUp(self): self.charge_zero = ChargeFactory.create(case_number="1") self.case_1 = CaseFactory.create(case_number="1", charges=tuple([self.charge_zero])) self.charge_one = ChargeFactory.create(case_number="2") self.charge_two = ChargeFactory.create(case_number="2") self.case_2 = CaseFactory.create(case_number="2", charges=tuple([self.charge_one, self.charge_two])) self.record = Record(tuple([self.case_1, self.case_2]))
def test_3_violations_are_time_restricted(): violation_charge_1 = ChargeFactory.create( level="Class A Violation", date=Time.LESS_THAN_THREE_YEARS_AGO, disposition=DispositionCreator.create( ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO), ) violation_charge_2 = ChargeFactory.create( level="Class A Violation", date=Time.TWO_YEARS_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.TWO_YEARS_AGO), ) violation_charge_3 = ChargeFactory.create( level="Class A Violation", date=Time.ONE_YEAR_AGO, disposition=DispositionCreator.create(ruling="Convicted", date=Time.ONE_YEAR_AGO), ) case = CaseFactory.create(charges=tuple( [violation_charge_3, violation_charge_2, violation_charge_1])) expunger_result = Expunger.run(Record(tuple([case]))) assert expunger_result[ violation_charge_1. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[violation_charge_1.ambiguous_charge_id].reason == f"137.225(7)(b) – Ten years from most recent other conviction from case [{case.summary.case_number}]." ) assert (expunger_result[violation_charge_1.ambiguous_charge_id]. date_will_be_eligible == violation_charge_2.disposition.date + Time.TEN_YEARS) assert expunger_result[ violation_charge_2. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[violation_charge_2.ambiguous_charge_id].reason == f"137.225(7)(b) – Ten years from most recent other conviction from case [{case.summary.case_number}]." ) assert (expunger_result[violation_charge_2.ambiguous_charge_id]. date_will_be_eligible == violation_charge_1.disposition.date + Time.TEN_YEARS) assert expunger_result[ violation_charge_3. ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE assert ( expunger_result[violation_charge_3.ambiguous_charge_id].reason == f"137.225(7)(b) – Ten years from most recent other conviction from case [{case.summary.case_number}]." ) assert (expunger_result[violation_charge_3.ambiguous_charge_id]. date_will_be_eligible == violation_charge_1.disposition.date + Time.TEN_YEARS)
def setUp(self): self.case_zero = CaseFactory.create() self.charge_zero = ChargeFactory.create(case=self.case_zero) self.case_zero.charges = [self.charge_zero] self.case_one = CaseFactory.create() self.charge_one = ChargeFactory.create(case=self.case_one) self.charge_two = ChargeFactory.create(case=self.case_one) self.case_one.charges = [self.charge_one, self.charge_two] self.record = RecordFactory.create([self.case_zero, self.case_one])
def test_more_than_three_year_rule_conviction(self): charge = ChargeFactory.create( disposition=DispositionCreator.create(ruling="Convicted", date=Time.THREE_YEARS_AGO) ) case = CaseFactory.create(charges=tuple([charge])) record = Record(tuple([case])) expunger_result = Expunger.run(record) assert expunger_result[charge.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE assert expunger_result[charge.ambiguous_charge_id].reason == "Eligible now" assert expunger_result[charge.ambiguous_charge_id].date_will_be_eligible == date.today()
def test_dismissed_felony_class_b_with_subsequent_conviction(): b_felony_charge = create_class_b_felony_charge("1", Time.LESS_THAN_TWENTY_YEARS_AGO, "Dismissed") case_1 = CaseFactory.create(case_number="1", charges=tuple([b_felony_charge])) subsequent_charge = ChargeFactory.create( case_number="2", disposition=DispositionCreator.create(ruling="Convicted", date=Time.TEN_YEARS_AGO), ) case_2 = CaseFactory.create(case_number="2", charges=tuple([subsequent_charge])) expunger_result = Expunger.run(Record(tuple([case_1, case_2]))) assert b_felony_charge.type_eligibility.status is EligibilityStatus.ELIGIBLE assert expunger_result[b_felony_charge.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE