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_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_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 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_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_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_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_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_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_3_yr_old_conviction_2_yr_old_mrc(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))
expunger_result = self.run_expunger(two_years_ago_charge,
three_years_ago_charge)
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
== "Ten years from most recent other conviction (137.225(7)(b))")
assert (
expunger_result[three_years_ago_charge.ambiguous_charge_id].
date_will_be_eligible == two_years_ago_charge.disposition.date +
Time.TEN_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 ==
"Ten years from most recent other conviction (137.225(7)(b))")
assert (
expunger_result[two_years_ago_charge.ambiguous_charge_id].
date_will_be_eligible == three_years_ago_charge.disposition.date +
Time.TEN_YEARS)
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_7_yr_old_conviction_5_yr_old_mrc(self):
seven_year_ago_charge = ChargeFactory.create(
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.SEVEN_YEARS_AGO))
five_year_ago_charge = ChargeFactory.create(
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.FIVE_YEARS_AGO))
expunger_result = self.run_expunger(five_year_ago_charge,
seven_year_ago_charge)
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
== "Ten years from most recent other conviction (137.225(7)(b))")
assert (
expunger_result[seven_year_ago_charge.ambiguous_charge_id].
date_will_be_eligible == five_year_ago_charge.disposition.date +
Time.TEN_YEARS)
assert expunger_result[
five_year_ago_charge.
ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
assert (
expunger_result[five_year_ago_charge.ambiguous_charge_id].reason ==
"Ten years from most recent other conviction (137.225(7)(b))")
assert (
expunger_result[five_year_ago_charge.ambiguous_charge_id].
date_will_be_eligible == seven_year_ago_charge.disposition.date +
Time.TEN_YEARS)
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_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
class Dispositions:
LAST_WEEK = datetime.today() - timedelta(days=7)
CONVICTED = DispositionCreator.create(ruling="Convicted", date=LAST_WEEK)
DISMISSED = DispositionCreator.create(ruling="Dismissed", date=LAST_WEEK)
UNRECOGNIZED_DISPOSITION = DispositionCreator.create(
ruling="Something unrecognized", date=LAST_WEEK)
NO_COMPLAINT = DispositionCreator.create(ruling="No Complaint",
date=LAST_WEEK)
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 _build_disposition(case_parser_data, charge_id):
disposition_data = case_parser_data.hashed_dispo_data.get(charge_id)
if disposition_data:
date = date_class.fromdatetime(
datetime.strptime(disposition_data.get("date"), "%m/%d/%Y")
) # TODO: Log error if format is not correct
ruling = disposition_data.get("ruling")
disposition = DispositionCreator.create(date, ruling, "amended" in disposition_data["event"].lower())
else:
disposition = DispositionCreator.create(date_class.today(), "missing")
return disposition
def test_disposition_status_values():
today = date.today()
assert DispositionCreator.create(today, "Dismissed").status == DispositionStatus.DISMISSED
assert DispositionCreator.create(today, "Dismissal").status == DispositionStatus.DISMISSED
assert DispositionCreator.create(today, "Acquitted").status == DispositionStatus.DISMISSED
assert DispositionCreator.create(today, "Acquittal").status == DispositionStatus.DISMISSED
assert DispositionCreator.create(today, "Convicted").status == DispositionStatus.CONVICTED
assert DispositionCreator.create(today, "Reduced to a lesser charge").status == DispositionStatus.CONVICTED
assert DispositionCreator.create(today, "Conversion - Disposition Types").status == DispositionStatus.CONVICTED
assert DispositionCreator.create(today, "Diverted").status == DispositionStatus.DIVERTED
assert DispositionCreator.create(today, "No complaint").status == DispositionStatus.NO_COMPLAINT
assert DispositionCreator.create(today, "What is this?").status == DispositionStatus.UNRECOGNIZED
def test_eligible_mrc_with_violation():
three_yr_mrc = ChargeFactory.create(
case_number="1",
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.THREE_YEARS_AGO),
)
arrest = ChargeFactory.create(
case_number="1",
disposition=DispositionCreator.create(ruling="Dismissed",
date=Time.THREE_YEARS_AGO),
)
violation = ChargeFactory.create(
level="Violation",
case_number="1",
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.THREE_YEARS_AGO),
)
case = CaseFactory.create(case_number="1",
charges=tuple([three_yr_mrc, arrest, violation]))
record = Record(tuple([case]))
expunger_result = Expunger.run(record)
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(
)
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[
violation.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
assert expunger_result[
violation.ambiguous_charge_id].date_will_be_eligible == date.today(
) + relativedelta(years=7)
assert (
expunger_result[violation.ambiguous_charge_id].reason ==
f"137.225(7)(b) – Ten years from most recent other conviction from case [{case.summary.case_number}]."
)
def test_mrc_is_eligible_in_two_years(self):
nine_year_old_conviction = ChargeFactory.create(
disposition=DispositionCreator.create(ruling="Convicted", date=Time.NINE_YEARS_AGO)
)
one_year_old_conviction = ChargeFactory.create(
disposition=DispositionCreator.create(ruling="Convicted", date=Time.ONE_YEAR_AGO)
)
eligibility_date = one_year_old_conviction.disposition.date + Time.THREE_YEARS
case = CaseFactory.create(charges=tuple([one_year_old_conviction, nine_year_old_conviction]))
record = Record(tuple([case]))
expunger_result = Expunger.run(record)
assert expunger_result[one_year_old_conviction.ambiguous_charge_id].date_will_be_eligible == eligibility_date
def test_arrest_is_unaffected_if_conviction_eligibility_is_older():
violation_charge = ChargeFactory.create(
level="Class A Violation",
date=Time.TEN_YEARS_AGO,
disposition=DispositionCreator.create(ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO),
)
arrest = ChargeFactory.create(disposition=DispositionCreator.create(ruling="Dismissed", date=Time.ONE_YEAR_AGO))
case = CaseFactory.create(charges=tuple([violation_charge, arrest]))
expunger_result = Expunger.run(Record(tuple([case])))
assert expunger_result[arrest.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
assert expunger_result[arrest.ambiguous_charge_id].date_will_be_eligible == arrest.date
assert expunger_result[arrest.ambiguous_charge_id].reason == "Eligible now"
def test_eligible_arrests_eligibility_based_on_second_mrc(self):
three_yr_conviction = ChargeFactory.create(
case_number="1",
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.THREE_YEARS_AGO),
)
arrest = ChargeFactory.create(
case_number="1",
disposition=DispositionCreator.create(ruling="Dismissed",
date=Time.THREE_YEARS_AGO),
)
violation = ChargeFactory.create(
level="Violation",
case_number="1",
disposition=DispositionCreator.create(
ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO),
)
violation_2 = ChargeFactory.create(
level="Violation",
case_number="1",
disposition=DispositionCreator.create(
ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO),
)
case = CaseFactory.create(charges=tuple(
[three_yr_conviction, arrest, violation, violation_2]))
record = Record(tuple([case]))
expunger_result = Expunger.run(record)
assert expunger_result[
three_yr_conviction.
ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
assert (
expunger_result[three_yr_conviction.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[
three_yr_conviction.
ambiguous_charge_id].date_will_be_eligible == date.today(
) + relativedelta(years=7, days=1)
assert expunger_result[
arrest.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
assert expunger_result[
arrest.ambiguous_charge_id].date_will_be_eligible == date.today(
) + relativedelta(years=7)
def test_mrc_is_eligible_in_two_years(self):
nine_year_old_conviction = ChargeFactory.create(
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.NINE_YEARS_AGO))
one_year_old_conviction = ChargeFactory.create(
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.ONE_YEAR_AGO))
eligibility_date = one_year_old_conviction.disposition.date + Time.THREE_YEARS
expunger_result = self.run_expunger(one_year_old_conviction,
nine_year_old_conviction)
assert expunger_result[
one_year_old_conviction.
ambiguous_charge_id].date_will_be_eligible == eligibility_date
def create_dismissed_charge(
cls,
case_number=1,
name="Theft of services",
statute="164.125",
level="Misdemeanor Class A",
date=date_class(1901, 1, 1),
violation_type="Offense Misdemeanor",
) -> Charge:
cls.charge_count += 1
disposition = DispositionCreator.create(date=date_class.today(),
ruling="Dismissed")
kwargs = {
"case_number": case_number,
"name": name,
"statute": statute,
"level": level,
"date": date,
"disposition": disposition,
"violation_type": violation_type,
"balance_due_in_cents": 0,
"edit_status": EditStatus.UNCHANGED,
}
charges = ChargeCreator.create(str(cls.charge_count), **kwargs)[0]
assert len(charges) == 1
return charges[0]
def test_it_knows_if_it_has_a_recent_conviction_sad_path(self):
charge = ChargeFactory.create()
charge_with_disposition = replace(
charge, disposition=DispositionCreator.create(self.TEN_YEARS_AGO, "Convicted")
)
assert charge_with_disposition.recent_conviction() is False
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_dismissed_charge_is_not_a_recent_conviction(self):
charge = ChargeFactory.create()
charge_with_disposition = replace(
charge, disposition=DispositionCreator.create(self.LESS_THAN_TEN_YEARS_AGO, "Dismissed")
)
assert charge_with_disposition.recent_conviction() is False
def test_most_recent_dismissal_sad_path(self):
charge = ChargeFactory.create(date=self.THREE_YEARS_AGO)
charge_with_disposition = replace(
charge, disposition=DispositionCreator.create(date=self.THREE_YEARS_AGO, ruling="Dismissed")
)
assert charge_with_disposition.recent_dismissal() is False
def test_convicted_charge_is_not_a_recent_dismissal(self):
charge = ChargeFactory.create(date=self.LESS_THAN_THREE_YEARS_AGO)
charge_with_disposition = replace(
charge, disposition=DispositionCreator.create(date=self.LESS_THAN_THREE_YEARS_AGO, ruling="Convicted")
)
assert charge_with_disposition.recent_dismissal() is False
