def get_context_data(self, **kwargs): # Quick notation to access all complaints fire_alarms = FireAlarm.objects.all() total_count = fire_alarms.count() region_names = ["batemans bay", "bourke", "broken hill", "byron bay", "canberra", \ "cobar", "cooma", "deniliquin", "dubbo", "grafton", "gunnedah", \ "katoomba", "kempsey", "kiama", "moree", "newcastle", "sydney", "tamworth", "wagga wagga"] regions = {} # Iterate over each name in our region_names list for reg in region_names: # Filter for complaints in each region qs = fire_alarms.filter(region=reg) # create a data dictionary for the region regions[reg] = {} regions[reg]['total'] = qs.count() regions[reg]['true_alarms'] = qs.filter(true_or_false_alarm=True).count() regions[reg]['false_alarms'] = qs.filter(true_or_false_alarm=False).count() # get a count of how many complaints total are in the queryset # use calculate to find percentages regions[reg]['per_true_alarms'] = calculate.percentage(regions[reg]['true_alarms'],regions[reg]['total']) regions[reg]['per_false_alarms'] = calculate.percentage(regions[reg]['false_alarms'],regions[reg]['total']) return locals()
def counties(self): """ Returns all the counties that report results for this race as a list of ReportingUnit objects. """ ru_list = sorted([ o for o in self.reporting_units if o.fips and not o.is_state and o.fips != '00000' ], key=lambda x: x.name) # If the AP reports sub-County data for this state, as they do for some # New England states, we'll need to aggregate it here. If not, we can # just pass out the data "as is." if self.state.abbrev in COUNTY_CROSSWALK.keys(): d = {} for ru in ru_list: try: d[ru.fips].append(ru) except KeyError: d[ru.fips] = [ru] county_list = [] for county, units in d.items(): ru = ReportingUnit( name=COUNTY_CROSSWALK[self.state.abbrev][county], ap_number='', fips=county, abbrev=self.name, precincts_reporting=sum( [int(i.precincts_reporting) for i in units]), precincts_total=sum( [int(i.precincts_total) for i in units]), num_reg_voters=sum([int(i.num_reg_voters) for i in units]), votes_cast=sum([int(i.votes_cast) for i in units])) ru.precincts_reporting_percent = calculate.percentage( ru.precincts_reporting, ru.precincts_total) # Group all the candidates cands = {} for unit in units: for result in unit.results: try: cands[result.candidate.ap_polra_number].append( result) except KeyError: cands[result.candidate.ap_polra_number] = [result] for ap_polra_number, results in cands.items(): combined = Result(candidate=results[0].candidate, reporting_unit=ru, vote_total=sum( [i.vote_total for i in results]), vote_total_percent=calculate.percentage( sum([i.vote_total for i in results]), ru.votes_cast)) # Update result connected to the reporting unit ru.update_result(combined) # Load the finished county into our list county_list.append(ru) return county_list else: return ru_list return ru_list
def test_percentage(self): self.assertEqual(calculate.percentage(12, 60), 20) self.assertEqual(calculate.percentage(12, 60, multiply=False), 0.2) self.assertEqual(calculate.percentage(12, 0), None) self.assertRaises(ZeroDivisionError, calculate.percentage, 12, 0, fail_silently=False)
def test_percentage(self): self.assertEqual(calculate.percentage(12, 60), 20) self.assertEqual(calculate.percentage(12, 60, multiply=False), 0.2) self.assertEqual(calculate.percentage(12, 0), None) self.assertRaises( ZeroDivisionError, calculate.percentage, 12, 0, fail_silently=False )
def handle(self, *args, **kwargs): """ Make it happen. """ # Loop through all the models and find any fields without docs field_count = 0 missing_list = [] for m in get_model_list(): field_list = m().get_field_list() field_count += len(field_list) for f in field_list: if not self.has_docs(f): self.log("Missing: %s.%s.%s" % (m().klass_group, m().klass_name, f)) missing_list.append((m, f)) # If everything is done, declare victory if not missing_list: self.success("All %s fields documented!" % field_count) return False # If not, loop through the missing and create issues missing_count = len(missing_list) self.failure("%s/%s (%d%%) of fields lack documentation" % (intcomma(missing_count), intcomma(field_count), calculate.percentage(missing_count, field_count)))
def handle(self, *args, **kwargs): """ Make it happen. """ self.set_options() self.header( "Creating GitHub issues for model models without a UNIQUE_KEY") # Loop through all the models and find any fields without docs missing_list = [] model_count = 0 for m in get_model_list(): model_count += 1 if not m.UNIQUE_KEY: self.log("Missing: %s.%s" % ( m().klass_group, m().klass_name, )) missing_list.append(m) # If everything is done, declare victory missing_count = len(missing_list) if not missing_count: self.success("All %s models have a UNIQUE_KEY!" % missing_count) return False # If not, loop through the missing and create issues self.log("- %s/%s (%d%%) of fields lack a UNIQUE_KEY" % (intcomma(missing_count), intcomma(model_count), calculate.percentage(missing_count, model_count))) for model in missing_list[1:]: self.create_issue(model)
def handle(self, *args, **kwargs): """ Make it happen. """ # Loop through all the models and find any fields without docs missing_list = [] model_count = 0 for m in get_model_list(): model_count += 1 if not m.UNIQUE_KEY: self.log("Missing: %s.%s" % ( m().klass_group, m().klass_name, ) ) missing_list.append(m) # If everything is done, declare victory missing_count = len(missing_list) if not missing_count: self.success("All %s models have a UNIQUE_KEY!" % missing_count) return False # If not, loop through the missing and create issues self.failure( "%s/%s (%d%%) of models lack a UNIQUE_KEY" % ( intcomma(missing_count), model_count, calculate.percentage(missing_count, model_count) ) )
def handle(self, *args, **kwargs): """ Make it happen. """ self.set_options() self.header( "Creating GitHub issues for model fields without documentation") # Loop through all the models and find any fields without docs field_count = 0 missing_list = [] for m in get_model_list(): field_list = m().get_field_list() field_count += len(field_list) for f in field_list: if not self.has_docs(f): missing_list.append((m, f)) # If everything is done, declare victory if not missing_list: self.success("All %s fields documented!" % field_count) return False # If not, loop through the missing and create issues missing_count = len(missing_list) self.log("- %s/%s (%d%%) of fields lack documentation" % (intcomma(missing_count), intcomma(field_count), calculate.percentage(missing_count, field_count))) for model, field in missing_list[611:]: # For now we are excluding the 'other' model module to # avoid overkill if model().klass_group != 'other': self.create_issue(model, field)
def handle(self, *args, **kwargs): """ Make it happen. """ # Loop through all the models and find any fields without docs field_count = 0 missing_list = [] for m in get_model_list(): field_list = m().get_field_list() field_count += len(field_list) for f in field_list: if not self.has_docs(f): self.log("Missing: %s.%s.%s" % ( m().klass_group, m().klass_name, f ) ) missing_list.append((m, f)) # If everything is done, declare victory if not missing_list: self.success("All %s fields documented!" % field_count) return False # If not, loop through the missing and create issues missing_count = len(missing_list) self.failure( "%s/%s (%d%%) of fields lack documentation" % ( intcomma(missing_count), intcomma(field_count), calculate.percentage(missing_count, field_count) ) )
def handle(self, *args, **kwargs): """ Make it happen. """ # Loop through all the models and find any fields without docs missing_list = [] model_count = 0 for m in get_model_list(): model_count += 1 if m.UNIQUE_KEY is None: self.log("Missing: %s.%s" % ( m().klass_group, m().klass_name, )) missing_list.append(m) # If everything is done, declare victory missing_count = len(missing_list) if not missing_count: self.success("All %s models have a UNIQUE_KEY!" % missing_count) return False # If not, loop through the missing and create issues self.failure("%s/%s (%d%%) of models lack a UNIQUE_KEY" % (intcomma(missing_count), model_count, calculate.percentage(missing_count, model_count)))
def __init__(self, party, delegates_needed, delegates_total, delegates_chosen): self.party = party self.delegates_needed = delegates_needed self.delegates_total = delegates_total self.delegates_chosen = delegates_chosen self.delegates_chosen_percent = calculate.percentage( delegates_chosen, delegates_total) self._candidates = [] self._states = []
def __init__(self, party, delegates_needed, delegates_total, delegates_chosen): self.party = party self.delegates_needed = delegates_needed self.delegates_total = delegates_total self.delegates_chosen = delegates_chosen self.delegates_chosen_percent = calculate.percentage( delegates_chosen, delegates_total ) self._candidates = [] self._states = []
def handle(self, *args, **kwargs): """ Make it happen. """ self.set_options() self.header( "Creating GitHub issues for model fields without documentation" ) # Loop through all the models and find any fields without docs field_count = 0 missing_list = [] for m in get_model_list(): field_list = m().get_field_list() field_count += len(field_list) for f in field_list: if not self.has_docs(f): missing_list.append((m, f)) # If everything is done, declare victory if not missing_list: self.success("All %s fields documented!" % field_count) return False # If not, loop through the missing and create issues missing_count = len(missing_list) self.log( "- %s/%s (%d%%) of fields lack documentation" % ( intcomma(missing_count), intcomma(field_count), calculate.percentage(missing_count, field_count) ) ) for model, field in missing_list[50:101]: # For now we are excluding the 'other' model module to # avoid overkill if model().klass_group != 'other': self.create_issue(model, field)
def counties(self): """ Returns all the counties that report results for this race as a list of ReportingUnit objects. """ ru_list = sorted( [o for o in self.reporting_units if o.fips and not o.is_state and o.fips != '00000'], key=lambda x: x.name ) # If the AP reports sub-County data for this state, as they do for some # New England states, we'll need to aggregate it here. If not, we can # just pass out the data "as is." if self.state.abbrev in COUNTY_CROSSWALK.keys(): d = {} for ru in ru_list: try: d[ru.fips].append(ru) except KeyError: d[ru.fips] = [ru] county_list = [] for county, units in d.items(): ru = ReportingUnit( name = COUNTY_CROSSWALK[self.state.abbrev][county], ap_number = '', fips = county, abbrev = self.name, precincts_reporting = sum([int(i.precincts_reporting) for i in units]), precincts_total = sum([int(i.precincts_total) for i in units]), num_reg_voters = sum([int(i.num_reg_voters) for i in units]), votes_cast = sum([int(i.votes_cast) for i in units]) ) ru.precincts_reporting_percent = calculate.percentage( ru.precincts_reporting, ru.precincts_total ) # Group all the candidates cands = {} for unit in units: for result in unit.results: try: cands[result.candidate.ap_polra_number].append(result) except KeyError: cands[result.candidate.ap_polra_number] = [result] for ap_polra_number, results in cands.items(): combined = Result( candidate = results[0].candidate, reporting_unit = ru, vote_total = sum([i.vote_total for i in results]), vote_total_percent = calculate.percentage( sum([i.vote_total for i in results]), ru.votes_cast ) ) # Update result connected to the reporting unit ru.update_result(combined) # Load the finished county into our list county_list.append(ru) return county_list else: return ru_list return ru_list
def _get_flat_results(self, ftp=None): """ Download, parse and structure the state and county votes totals. """ # Download the data flat_list = self.client._fetch_flatfile( self.results_file_path, [ # First the basic fields that will the same in each row 'test', 'election_date', 'state_postal', 'county_number', 'fips', 'county_name', 'race_number', 'office_id', 'race_type_id', 'seat_number', 'office_name', 'seat_name', 'race_type_party', 'race_type', 'office_description', 'number_of_winners', 'number_in_runoff', 'precincts_reporting', 'total_precincts', ], [ # Then the candidate fields that will repeat after the basics 'candidate_number', 'order', 'party', 'first_name', 'middle_name', 'last_name', 'junior', 'use_junior', 'incumbent', 'vote_count', 'is_winner', 'national_politician_id', ] ) # Figure out if we're dealing with test data or the real thing self.is_test = flat_list[0]['test'] == 't' # Start looping through the lines... for row in flat_list: # Get the race race = self.get_race(row['race_number']) # Figure out if it's a state or a county fips =row['fips'] is_state = row['county_number'] == '1' county_number = str(row['county_number']) # Pull the reporting unit reporting_unit = race.get_reporting_unit( "%s%s" % (row['county_name'], county_number) ) # Loop through all the candidates votes_cast = 0 for cand in row['candidates']: # Skip it if the candidate is empty, as it sometimes is at # the end of the row if not cand['candidate_number']: continue # Pull the existing candidate object candidate = race.get_candidate(cand["candidate_number"]) # Pull the vote total vote_count = int(cand['vote_count']) # Add it to the overall total votes_cast += vote_count # Update the candidate's global vote total if data are statewide if is_state: candidate.vote_total = vote_count # Set is_winner and is_runoff # (This will just get set over and over as we loop # but AP seems to put the statewide result in for every # reporting unit so I think we're safe.) candidate.is_winner = cand['is_winner'] == 'X' candidate.is_runoff = cand['is_winner'] == 'R' # Set whether the candidate is an incumbent candidate.is_incumbent = cand['incumbent'] == '1' # Create the Result object, which is specific to the # reporting unit in this row of the flatfile. result = Result( candidate = candidate, vote_total = vote_count, reporting_unit = reporting_unit ) # Update result connected to the reporting unit reporting_unit.update_result(result) # Update the reporting unit's precincts status reporting_unit.precincts_total = int(row['total_precincts']) reporting_unit.precincts_reporting = int(row['precincts_reporting']) reporting_unit.precincts_reporting_percent = calculate.percentage( reporting_unit.precincts_reporting, reporting_unit.precincts_total ) # Update the total votes cast reporting_unit.votes_cast = votes_cast # Loop back through the results and set the percentages now # that we know the overall total for result in reporting_unit.results: result.vote_total_percent = calculate.percentage( result.vote_total, votes_cast )
def _get_results(self, ftp=None): """ Download, parse and structure the state and county votes totals. """ # Download the data flat_list = self._fetch_flatfile( self.results_file_path, [ # First the basic fields that will the same in each row 'test', 'election_date', 'state_postal', 'county_number', 'fips', 'county_name', 'race_number', 'office_id', 'race_type_id', 'seat_number', 'office_name', 'seat_name', 'race_type_party', 'race_type', 'office_description', 'number_of_winners', 'number_in_runoff', 'precincts_reporting', 'total_precincts', ], [ # Then the candidate fields that will repeat after the basics 'candidate_number', 'order', 'party', 'first_name', 'middle_name', 'last_name', 'junior', 'use_junior', 'incumbent', 'vote_count', 'is_winner', 'national_politician_id', ] ) # Figure out if we're dealing with test data or the real thing is_test = flat_list[0]['test'] == 't' # Start looping through the lines... for row in flat_list: # Get the race, with a special case for the presidential race ap_race_number = self.ap_number_template % ({ 'number': row['race_number'], 'state': row['state_postal'] }) race = self.get_race(ap_race_number) # Pull the reporting unit ru_key = "%s%s" % (row['county_name'], row['county_number']) reporting_unit = self.get_reporting_unit(ru_key) # Total the votes votes_total = sum([int(o['vote_count']) for o in row['candidates']]) # Loop through all the candidates for candrow in row['candidates']: # Skip it if the candidate is empty, as it sometimes is at # the end of the row if not candrow['candidate_number']: continue # Pull the existing candidate object candidate = self.get_candidate(candrow["candidate_number"]) cru = CandidateReportingUnit( test=is_test, initialization_data=False, lastupdated=None, # Race electiondate=race.electiondate, raceid=race.raceid, statepostal=race.statepostal, statename=race.statename, racetype=race.racetype, racetypeid=race.racetypeid, officeid=race.officeid, officename=race.officename, seatname=race.seatname, description=race.description, seatnum=race.seatnum, national=race.national, is_ballot_measure=None, uncontested=race.uncontested, # Candidate first=candidate.first, last=candidate.last, party=candidate.party, candidateID=candidate.candidateid, polID=candidate.polid, polNum=candidate.polnum, incumbent=candrow['incumbent'] == '1', ballotOrder=candidate.ballotorder, # Results voteCount=int(candrow['vote_count']), votePct=calculate.percentage(int(candrow['vote_count']), votes_total, multiply=False) or 0.0, winner=candrow['is_winner'], # Reporting unit level=reporting_unit.level, reportingunitname=reporting_unit.reportingunitname, reportingunitid=reporting_unit.reportingunitid, fipscode=reporting_unit.fipscode, precinctsreporting=int(row['precincts_reporting']), precinctstotal=int(row['total_precincts']), precinctsreportingpct=calculate.percentage(int(row['precincts_reporting']), int(row['total_precincts']), multiply=True) or 0.0, ) cru.key = "%s%s%s" % ( race.raceid, ru_key, candrow["candidate_number"], ) self._results[cru.key] = cru # Update the reporting unit's precincts status reporting_unit.precinctstotal = int(row['total_precincts']) reporting_unit.precinctsreporting = int(row['precincts_reporting']) reporting_unit.precinctsreportingpct = calculate.percentage( reporting_unit.precinctsreporting, reporting_unit.precinctstotal, multiply=True ) or 0.0 reporting_unit.votecount = votes_total
def get_context_data(self, **kwargs): # Quick notation to access all complaints complaints = Complaint.objects.all() # Quick means of accessing both open and closed cases open_cases = complaints.filter(is_closed=False) closed_cases = complaints.filter(is_closed=True) # Overall complaints not addressed within a year over_one_year = complaints.filter(more_than_one_year=True) open_over_one_year = over_one_year.filter(is_closed=False) closed_over_one_year = over_one_year.filter(is_closed=True) # Total counts of cases, all priority levels total_count = complaints.all().count() total_by_csr = get_counts_by_csr(complaints) # Counts of open cases, all priority levels open_cases_count = open_cases.count() open_by_csr = get_counts_by_csr(open_cases) # Counts of cases that have been open fore more than a year, all priority levels open_over_one_year_count = open_over_one_year.count() open_over_one_year_by_csr = get_counts_by_csr(open_over_one_year) # Counts of cases that were closed, but have been open for more than a year, all priority levels. closed_over_one_year_count = closed_over_one_year.count() closed_over_one_year_by_csr = get_counts_by_csr(closed_over_one_year) # A much better means of getting expected wait times is to use a survival analysis function # In this case, we use a Kaplan-Meier estimator from the Python package lifelines # We repeat this for all complaints, and for each CSR priority levels. all_complaints = Complaint.objects.exclude(days_since_complaint__lt=0) kmf_fit = get_kmf_fit(all_complaints) median_wait_time_kmf = get_kmf_median(kmf_fit) csr1 = all_complaints.filter(csr_priority="1") kmf_fit_csr1 = get_kmf_fit(csr1) median_wait_time_csr1_kmf = get_kmf_median(kmf_fit_csr1) csr2 = all_complaints.filter(csr_priority="2") kmf_fit_csr2 = get_kmf_fit(csr2) median_wait_time_csr2_kmf = get_kmf_median(kmf_fit_csr2) csr3 = all_complaints.filter(csr_priority="3") kmf_fit_csr3 = get_kmf_fit(csr3) median_wait_time_csr3_kmf = get_kmf_median(kmf_fit_csr3) region_names = [ 'Central', 'East Los Angeles', 'Harbor', 'North Valley', 'South Los Angeles', 'South Valley', 'West Los Angeles' ] regions = {} # Iterate over each name in our region_names list for region in region_names: # Filter for complaints in each region qs = complaints.filter(area_planning_commission=region, days_since_complaint__gte=0) # create a data dictionary for the region regions[region] = {} # get a count of how many complaints total are in the queryset regions[region]['total'] = qs.count() regions[region][ 'avg_complaints_per_year'] = get_avg_complaints_filed_per_year( region) # Separate the complaints into querysets of their respective priority levels region_csr1 = qs.filter(csr_priority="1") region_csr2 = qs.filter(csr_priority="2") region_csr3 = qs.filter(csr_priority="3") # Find the KMF fit for all complaints in the area and by each priority level regional_kmf_fit = get_kmf_fit(qs) regional_kmf_fit_csr1 = get_kmf_fit(region_csr1) regional_kmf_fit_csr2 = get_kmf_fit(region_csr2) regional_kmf_fit_csr3 = get_kmf_fit(region_csr3) # Get the median value from the KMF fit. regions[region]['median_wait_kmf'] = get_kmf_median( regional_kmf_fit) regions[region]['median_wait_kmf_csr1'] = get_kmf_median( regional_kmf_fit_csr1) regions[region]['median_wait_kmf_csr2'] = get_kmf_median( regional_kmf_fit_csr2) regions[region]['median_wait_kmf_csr3'] = get_kmf_median( regional_kmf_fit_csr3) regions[region]['gt_year'] = qs.filter( more_than_one_year=True).count() # Paste response time breakdown here # Also grab counts of the number of complaints greater than 30, 90 and 180 days regions[region]['gt_30_days'] = qs.filter(gt_30_days=True).count() regions[region]['gt_90_days'] = qs.filter(gt_90_days=True).count() regions[region]['gt_180_days'] = qs.filter( gt_180_days=True).count() # use calculate to find percentages regions[region]['per_gt_30_days'] = calculate.percentage( regions[region]['gt_30_days'], regions[region]['total']) regions[region]['per_gt_90_days'] = calculate.percentage( regions[region]['gt_90_days'], regions[region]['total']) regions[region]['per_gt_180_days'] = calculate.percentage( regions[region]['gt_180_days'], regions[region]['total']) regions[region]['per_gt_year'] = calculate.percentage( regions[region]['gt_year'], regions[region]['total']) return locals()
def _get_results(self, ftp=None): """ Download, parse and structure the state and county votes totals. """ # Download the data flat_list = self._fetch_flatfile( self.results_file_path, [ # First the basic fields that will the same in each row 'test', 'election_date', 'state_postal', 'county_number', 'fips', 'county_name', 'race_number', 'office_id', 'race_type_id', 'seat_number', 'office_name', 'seat_name', 'race_type_party', 'race_type', 'office_description', 'number_of_winners', 'number_in_runoff', 'precincts_reporting', 'total_precincts', ], [ # Then the candidate fields that will repeat after the basics 'candidate_number', 'order', 'party', 'first_name', 'middle_name', 'last_name', 'junior', 'use_junior', 'incumbent', 'vote_count', 'is_winner', 'national_politician_id', ]) # Figure out if we're dealing with test data or the real thing is_test = flat_list[0]['test'] == 't' # Start looping through the lines... for row in flat_list: # Get the race, with a special case for the presidential race ap_race_number = self.ap_number_template % ( { 'number': row['race_number'], 'state': row['state_postal'] }) race = self.get_race(ap_race_number) # Pull the reporting unit ru_key = "%s%s" % (row['county_name'], row['county_number']) reporting_unit = self.get_reporting_unit(ru_key) # Total the votes votes_total = sum( [int(o['vote_count']) for o in row['candidates']]) # Loop through all the candidates for candrow in row['candidates']: # Skip it if the candidate is empty, as it sometimes is at # the end of the row if not candrow['candidate_number']: continue # Pull the existing candidate object candidate = self.get_candidate(candrow["candidate_number"]) cru = CandidateReportingUnit( test=is_test, initialization_data=False, lastupdated=None, # Race electiondate=race.electiondate, raceid=race.raceid, statepostal=race.statepostal, statename=race.statename, racetype=race.racetype, racetypeid=race.racetypeid, officeid=race.officeid, officename=race.officename, seatname=race.seatname, description=race.description, seatnum=race.seatnum, national=race.national, is_ballot_measure=None, uncontested=race.uncontested, # Candidate first=candidate.first, last=candidate.last, party=candidate.party, candidateID=candidate.candidateid, polID=candidate.polid, polNum=candidate.polnum, incumbent=candrow['incumbent'] == '1', ballotOrder=candidate.ballotorder, # Results voteCount=int(candrow['vote_count']), votePct=calculate.percentage(int(candrow['vote_count']), votes_total, multiply=False) or 0.0, winner=candrow['is_winner'], # Reporting unit level=reporting_unit.level, reportingunitname=reporting_unit.reportingunitname, reportingunitid=reporting_unit.reportingunitid, fipscode=reporting_unit.fipscode, precinctsreporting=int(row['precincts_reporting']), precinctstotal=int(row['total_precincts']), precinctsreportingpct=calculate.percentage( int(row['precincts_reporting']), int(row['total_precincts']), multiply=True) or 0.0, ) cru.key = "%s%s%s" % ( race.raceid, ru_key, candrow["candidate_number"], ) self._results[cru.key] = cru # Update the reporting unit's precincts status reporting_unit.precinctstotal = int(row['total_precincts']) reporting_unit.precinctsreporting = int(row['precincts_reporting']) reporting_unit.precinctsreportingpct = calculate.percentage( reporting_unit.precinctsreporting, reporting_unit.precinctstotal, multiply=True) or 0.0 reporting_unit.votecount = votes_total
def _get_flat_results(self, ftp=None): """ Download, parse and structure the state and county votes totals. """ # Download the data flat_list = self.client._fetch_flatfile( self.results_file_path, [ # First the basic fields that will the same in each row 'test', 'election_date', 'state_postal', 'county_number', 'fips', 'county_name', 'race_number', 'office_id', 'race_type_id', 'seat_number', 'office_name', 'seat_name', 'race_type_party', 'race_type', 'office_description', 'number_of_winners', 'number_in_runoff', 'precincts_reporting', 'total_precincts', ], [ # Then the candidate fields that will repeat after the basics 'candidate_number', 'order', 'party', 'first_name', 'middle_name', 'last_name', 'junior', 'use_junior', 'incumbent', 'vote_count', 'is_winner', 'national_politician_id', ]) # Figure out if we're dealing with test data or the real thing self.is_test = flat_list[0]['test'] == 't' # Start looping through the lines... for row in flat_list: # Get the race race = self.get_race(row['race_number']) # Figure out if it's a state or a county fips = row['fips'] is_state = row['county_number'] == '1' county_number = str(row['county_number']) # Pull the reporting unit reporting_unit = race.get_reporting_unit( "%s%s" % (row['county_name'], county_number)) # Loop through all the candidates votes_cast = 0 for cand in row['candidates']: # Skip it if the candidate is empty, as it sometimes is at # the end of the row if not cand['candidate_number']: continue # Pull the existing candidate object candidate = race.get_candidate(cand["candidate_number"]) # Pull the vote total vote_count = int(cand['vote_count']) # Add it to the overall total votes_cast += vote_count # Update the candidate's global vote total if data are statewide if is_state: candidate.vote_total = vote_count # Set is_winner and is_runoff # (This will just get set over and over as we loop # but AP seems to put the statewide result in for every # reporting unit so I think we're safe.) candidate.is_winner = cand['is_winner'] == 'X' candidate.is_runoff = cand['is_winner'] == 'R' # Create the Result object, which is specific to the # reporting unit in this row of the flatfile. result = Result(candidate=candidate, vote_total=vote_count, reporting_unit=reporting_unit) # Update result connected to the reporting unit reporting_unit.update_result(result) # Update the reporting unit's precincts status reporting_unit.precincts_total = int(row['total_precincts']) reporting_unit.precincts_reporting = int( row['precincts_reporting']) reporting_unit.precincts_reporting_percent = calculate.percentage( reporting_unit.precincts_reporting, reporting_unit.precincts_total) # Update the total votes cast reporting_unit.votes_cast = votes_cast # Loop back through the results and set the percentages now # that we know the overall total for result in reporting_unit.results: result.vote_total_percent = calculate.percentage( result.vote_total, votes_cast)
def get_context_data(self, **kwargs): # Quick notation to access all complaints complaints = Complaint.objects.all() # Quick means of accessing both open and closed cases open_cases = complaints.filter(is_closed=False) closed_cases = complaints.filter(is_closed=True) # Overall complaints not addressed within a year over_one_year = complaints.filter(more_than_one_year=True) open_over_one_year = over_one_year.filter(is_closed=False) closed_over_one_year = over_one_year.filter(is_closed=True) # Total counts of cases, all priority levels total_count = complaints.all().count() total_by_csr = get_counts_by_csr(complaints) # Counts of open cases, all priority levels open_cases_count = open_cases.count() open_by_csr = get_counts_by_csr(open_cases) # Counts of cases that have been open fore more than a year, all priority levels open_over_one_year_count = open_over_one_year.count() open_over_one_year_by_csr = get_counts_by_csr(open_over_one_year) # Counts of cases that were closed, but have been open for more than a year, all priority levels. closed_over_one_year_count = closed_over_one_year.count() closed_over_one_year_by_csr = get_counts_by_csr(closed_over_one_year) # A much better means of getting expected wait times is to use a survival analysis function # In this case, we use a Kaplan-Meier estimator from the Python package lifelines # We repeat this for all complaints, and for each CSR priority levels. all_complaints = Complaint.objects.exclude(days_since_complaint__lt=0) kmf_fit = get_kmf_fit(all_complaints) median_wait_time_kmf = get_kmf_median(kmf_fit) csr1 = all_complaints.filter(csr_priority="1") kmf_fit_csr1 = get_kmf_fit(csr1) median_wait_time_csr1_kmf = get_kmf_median(kmf_fit_csr1) csr2 = all_complaints.filter(csr_priority="2") kmf_fit_csr2 = get_kmf_fit(csr2) median_wait_time_csr2_kmf = get_kmf_median(kmf_fit_csr2) csr3 = all_complaints.filter(csr_priority="3") kmf_fit_csr3 = get_kmf_fit(csr3) median_wait_time_csr3_kmf = get_kmf_median(kmf_fit_csr3) region_names = ['Central','East Los Angeles','Harbor','North Valley','South Los Angeles','South Valley','West Los Angeles'] regions = {} # Iterate over each name in our region_names list for region in region_names: # Filter for complaints in each region qs = complaints.filter(area_planning_commission=region, days_since_complaint__gte=0) # create a data dictionary for the region regions[region] = {} # get a count of how many complaints total are in the queryset regions[region]['total'] = qs.count() regions[region]['avg_complaints_per_year'] = get_avg_complaints_filed_per_year(region) # Separate the complaints into querysets of their respective priority levels region_csr1 = qs.filter(csr_priority="1") region_csr2 = qs.filter(csr_priority="2") region_csr3 = qs.filter(csr_priority="3") # Find the KMF fit for all complaints in the area and by each priority level regional_kmf_fit = get_kmf_fit(qs) regional_kmf_fit_csr1 = get_kmf_fit(region_csr1) regional_kmf_fit_csr2 = get_kmf_fit(region_csr2) regional_kmf_fit_csr3 = get_kmf_fit(region_csr3) # Get the median value from the KMF fit. regions[region]['median_wait_kmf'] = get_kmf_median(regional_kmf_fit) regions[region]['median_wait_kmf_csr1'] = get_kmf_median(regional_kmf_fit_csr1) regions[region]['median_wait_kmf_csr2'] = get_kmf_median(regional_kmf_fit_csr2) regions[region]['median_wait_kmf_csr3'] = get_kmf_median(regional_kmf_fit_csr3) regions[region]['gt_year'] = qs.filter(more_than_one_year=True).count() # Paste response time breakdown here # Also grab counts of the number of complaints greater than 30, 90 and 180 days regions[region]['gt_30_days'] = qs.filter(gt_30_days=True).count() regions[region]['gt_90_days'] = qs.filter(gt_90_days=True).count() regions[region]['gt_180_days'] = qs.filter(gt_180_days=True).count() # use calculate to find percentages regions[region]['per_gt_30_days'] = calculate.percentage(regions[region]['gt_30_days'],regions[region]['total']) regions[region]['per_gt_90_days'] = calculate.percentage(regions[region]['gt_90_days'],regions[region]['total']) regions[region]['per_gt_180_days'] = calculate.percentage(regions[region]['gt_180_days'],regions[region]['total']) regions[region]['per_gt_year'] = calculate.percentage(regions[region]['gt_year'],regions[region]['total']) return locals()