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
Example #2
0
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
Example #3
0
def test_manufacture_delivery_dismissed():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Manufacture/Delivery", statute="4759922b", level="Felony Class A", disposition=Dispositions.DISMISSED
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.ELIGIBLE
    assert type_eligibility.reason == "Dismissals are generally eligible under 137.225(1)(b)"
Example #4
0
def test_manufacture_delivery_manudel():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Manu/Del Cntrld Sub-SC 1", statute="4759921B", level="Felony Class A", disposition=Dispositions.CONVICTED
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert type_eligibility.reason == "Eligible under 137.226 ⬥ Ineligible by omission from statute"
def test_attempt_to_commit_felony_class_b_charge():
    charge = ChargeFactory.create_ambiguous_charge(
        name="Attempt to Commit a Class B Felony",
        statute="161.405(2)(c)",
        level="Felony Class C",
        disposition=Dispositions.CONVICTED,
    )
    assert isinstance(charge[0].charge_type, SexCrime)
    assert isinstance(charge[1].charge_type, FelonyClassC)
def test_subsection_6_163145():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Criminally negligent homicide",
        statute="163.145",
        level="Misdemeanor Class A",
        disposition=Dispositions.CONVICTED,
    )

    assert isinstance(charges[0].charge_type, Misdemeanor)
def test_other_charge_type_true_negatives(
        person_felony_statute_with_other_charge_type):
    charges = ChargeFactory.create_ambiguous_charge(
        name="Generic",
        statute=person_felony_statute_with_other_charge_type,
        level="Felony Class B",
        disposition=Dispositions.CONVICTED,
    )
    assert [not isinstance(charge, PersonFelonyClassB) for charge in charges]
def test_subsection_6_163205():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Criminal mistreatment in the first degree",
        statute="163.205",
        level="Felony Class C",
        disposition=Dispositions.CONVICTED,
    )

    assert isinstance(charges[0].charge_type, FelonyClassC)
    assert isinstance(charges[1].charge_type, Subsection6)
def test_manufacture_delivery_manudel_felony_c():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Manu/Del Cntrld Sub-SC 1",
        statute="4759921B",
        level="Felony Class C",
        disposition=Dispositions.CONVICTED)
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.ELIGIBLE
    assert type_eligibility.reason == "Felony Class C – Eligible under 137.225(1)(b)"
def test_subsection_6_163575():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Endangering the welfare of a minor",
        statute="163.575",
        level="Misdemeanor Class A",
        disposition=Dispositions.CONVICTED,
    )

    assert isinstance(charges[0].charge_type, Subsection6)
    assert isinstance(charges[1].charge_type, Misdemeanor)
def test_163200_is_still_subsection_6_if_b_felony():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Criminal mistreatment in the second degree",
        statute="163.200",
        level="Felony Class B",
        disposition=Dispositions.CONVICTED,
    )

    assert isinstance(charges[0].charge_type, Subsection6)
    assert isinstance(charges[1].charge_type, FelonyClassB)  # TODO: Should this be a person felony?
def test_163575_is_still_subsection_6_if_b_felony():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Endangering the welfare of a minor",
        statute="163.575",
        level="Felony Class B",
        disposition=Dispositions.CONVICTED,
    )

    assert isinstance(charges[0].charge_type, Subsection6)
    assert isinstance(charges[1].charge_type, FelonyClassB)  # TODO: Should this be a person felony?
def test_attempt_to_commit_felony_class_a_charge():
    charge = ChargeFactory.create_ambiguous_charge(
        name="Attempt to Commit a Class A Felony",
        statute="161.405(2)(b)",
        level="Felony Class B",
        disposition=Dispositions.CONVICTED,
    )
    assert isinstance(charge[0].charge_type, MarijuanaEligible)
    assert isinstance(charge[1].charge_type, FelonyClassB)
    assert isinstance(charge[2].charge_type, PersonFelonyClassB)
def test_pcs_class_c():
    charges = ChargeFactory.create_ambiguous_charge(
        name="PCS",
        statute="4759924A",
        level="Felony Class C",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.ELIGIBLE
    assert type_eligibility.reason == "Felony Class C – Eligible under 137.225(1)(b)"
def test_sex_crimes_with_romeo_and_juliet_exception(sex_crimes_statute):
    charges = ChargeFactory.create_ambiguous_charge(
        name="Generic",
        statute=sex_crimes_statute,
        level="Misdemeanor Class A",
        disposition=Dispositions.CONVICTED)
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)
    assert isinstance(charges[0], Misdemeanor)
    assert isinstance(charges[1], RomeoAndJulietIneligibleSexCrime)
    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert type_eligibility.reason == "Eligible under 137.225(5)(b) тме Failure to meet requirements under 163A.140(1)"
Example #16
0
def test_manufacture_delivery_missing_disposition():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Manufacture/Delivery", statute="4759922b", level="Felony Class A", disposition=None
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert (
        type_eligibility.reason
        == "Always eligible under 137.226 (for convictions) or 137.225(1)(b) (for dismissals) ⬥ Disposition not found. Needs further analysis"
    )
Example #17
0
def test_sex_crimes_with_romeo_and_juliet_exception(sex_crimes_statute):
    charges = ChargeFactory.create_ambiguous_charge(
        name="Generic", statute=sex_crimes_statute, level="Misdemeanor Class A", disposition=Dispositions.CONVICTED
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)
    assert isinstance(charges[0], RomeoAndJulietNMASexCrime)
    assert isinstance(charges[1], RomeoAndJulietIneligibleSexCrime)
    assert type_eligibility.status is EligibilityStatus.INELIGIBLE
    assert (
        type_eligibility.reason
        == "Possibly meets requirements under 137.225(6)(f) - Email [email protected] with subject line '6F' for free and confidential further analysis тме Fails to meet requirements under 137.225(6)(f)"
    )
Example #18
0
def test_subsection_6_dismissed():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Criminal mistreatment in the second degree",
        statute="163.200",
        level="Misdemeanor Class A",
        disposition=Dispositions.DISMISSED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert isinstance(charges[0], DismissedCharge)
    assert type_eligibility.status is EligibilityStatus.ELIGIBLE
    assert type_eligibility.reason == "Dismissals are generally eligible under 137.225(1)(b)"
def test_person_felony_class_b(person_felony_statute):
    charges = ChargeFactory.create_ambiguous_charge(
        name="Generic",
        statute=person_felony_statute,
        level="Felony Class B",
        disposition=Dispositions.CONVICTED)
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)
    assert any([isinstance(charge, PersonFelonyClassB) for charge in charges])
    assert type_eligibility.status in [
        EligibilityStatus.NEEDS_MORE_ANALYSIS, EligibilityStatus.INELIGIBLE
    ]
    assert "Ineligible under 137.225(5)(a)" in type_eligibility.reason
Example #20
0
def test_subsection_6_163165():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Assault in the third degree",
        statute="163.165",
        level="Felony Class C",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert isinstance(charges[0], FelonyClassC)
    assert isinstance(charges[1], Subsection6)
    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert type_eligibility.reason == "Eligible under 137.225(5)(b) ⬥ Ineligible under 137.225(6)"
Example #21
0
def test_subsection_6_163200():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Criminal mistreatment in the second degree",
        statute="163.200",
        level="Misdemeanor Class A",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert isinstance(charges[0], Subsection6)
    assert isinstance(charges[1], Misdemeanor)
    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert type_eligibility.reason == "Ineligible under 137.225(6) ⬥ Eligible under 137.225(5)(b)"
def test_manufacture_delivery_heroin():
    charges = ChargeFactory.create_ambiguous_charge(
        name="MANUFACTURING CONTROLLED SUB HEROIN",
        statute="4759921A",
        level="Felony Unclassified",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert (
        type_eligibility.reason ==
        "Ineligible by omission from statute ⬥ Convictions that fulfill the conditions of 137.225(5)(a) are eligible"
    )
def test_manufacture_delivery_manudel_felony_unclassified():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Manu/Del Cntrld Sub-SC 1",
        statute="4759921B",
        level="Felony Unclassified",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert (
        type_eligibility.reason ==
        "Eligible under 137.226 ⬥ Ineligible by omission from statute ⬥ Convictions that fulfill the conditions of 137.225(5)(a) are eligible ⬥ Eligible under 137.225(5)(b)"
    )
def test_manufacture_delivery_manufacturing_name():
    charges = ChargeFactory.create_ambiguous_charge(
        name="MANUFACTURING CONTROLLED SUB",
        statute="4759921A",
        level="Felony Unclassified",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert (
        type_eligibility.reason ==
        "Marijuana Manufacture Delivery – Eligible under 137.226 OR Felony Class A – Ineligible by omission from statute OR Felony Class B – Convictions that fulfill the conditions of 137.225(1)(b) are eligible OR Felony Class C – Eligible under 137.225(1)(b)"
    )
def test_manufacture_delivery_unrecognized_disposition():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Manufacture/Delivery",
        statute="4759922b",
        level="Felony Class B",
        disposition=Dispositions.UNRECOGNIZED_DISPOSITION,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert (
        type_eligibility.reason ==
        "Marijuana Manufacture Delivery – Always eligible under 137.226 (for convictions) or 137.225(1)(d) (for dismissals) OR Felony Class B – Disposition not recognized. Needs further analysis"
    )
def test_felony_unclassified_charge():
    charges = ChargeFactory.create_ambiguous_charge(
        name="Criminal Forfeiture",
        statute="CH666",
        level="Felony Unclassified",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
    assert (
        type_eligibility.reason ==
        "Felony Class A – Ineligible by omission from statute OR Felony Class B – Convictions that fulfill the conditions of 137.225(1)(b) are eligible OR Felony Class C – Eligible under 137.225(1)(b)"
    )
def test_pcs_heroin():
    charges = ChargeFactory.create_ambiguous_charge(
        name="POSS CONTROLLED SUB HEROIN",
        statute="4757521A",
        level="Felony Unclassified",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.ELIGIBLE
    assert (
        type_eligibility.reason ==
        "Felony Class B – Convictions that fulfill the conditions of 137.225(1)(b) are eligible OR Felony Class C – Eligible under 137.225(1)(b)"
    )
def test_pcs():
    charges = ChargeFactory.create_ambiguous_charge(
        name="PCS",
        statute="4759924A",
        level="Felony Class B",
        disposition=Dispositions.CONVICTED,
    )
    type_eligibility = RecordMerger.merge_type_eligibilities(charges)

    assert type_eligibility.status is EligibilityStatus.ELIGIBLE
    assert (
        type_eligibility.reason ==
        "Marijuana Manufacture Delivery – Eligible under 137.226 OR Felony Class B – Convictions that fulfill the conditions of 137.225(1)(b) are eligible"
    )
Example #29
0
def test_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.THREE_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)

    ten_years_from_mrc = eligible_charge.disposition.date + Time.TEN_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 == date.today()

    assert expunger_result_b[
        arrest.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
    assert (
        expunger_result_b[arrest.ambiguous_charge_id].reason ==
        f"137.225(7)(b) – Ten years from most recent conviction from case [{case_a.summary.case_number}]."
    )
    assert expunger_result_b[
        arrest.ambiguous_charge_id].date_will_be_eligible == ten_years_from_mrc
Example #30
0
def test_duii():
    charges = ChargeFactory.create_ambiguous_charge(statute="813.010", disposition=Dispositions.DISMISSED)

    assert isinstance(charges[0], DivertedDuii)
    assert isinstance(charges[1], DismissedCharge)