@dra2020/district-analytics 17.0.1 → 17.1.0

package/README.md

@@ -1,6 +1,9 @@
 # District Analytics
 
-Type definitions and code used by dra-client and fn-all (lambdas), and which invokes dra-analytics 
+A layer between `dra-client` and `fn-all` (the scoring lambda), on the one hand, and `dra-analytics`, on the other,
+that knows enough about DRA and the analytics proper in `dra-analytics` to take data in, compose the various lower-level
+analytics calls, and make the various artifacts: scorecard, ratings, requirements checklist, etc. This allows the callers
+to remain high-level and agnostic of the analytics specifics and the analytics proper to no nothing about DRA. 
 
 ## Build Status
 
@@ -11,10 +14,12 @@ Type definitions and code used by dra-client and fn-all (lambdas), and which inv
 ```javascript
 import * as DA from 'district-analytics';
 
+// Create a session request
+
 let sr = {} as DA.SessionRequest;
-sr['title'] = "NC 2016 Contingent Corrected Map";
+sr['title'] = "NC 2020 Congress";
 sr['stateXX'] = "NC";
-sr['nDistricts'] = 13;
+sr['nDistricts'] = 14;
 sr['planType'] = PlanType.congress;  // One or ...
 sr['legislativeDistricts'] = false;  // ... the other
 sr['data'] = data as T.GeoFeatureCollection;
@@ -25,17 +30,18 @@ sr['districtShapes'] = districtShapes as T.GeoFeatureCollection;
 sr['aggregates'] = aggregates as PF.PackedFields[];
 sr['config'] = config as T.Dict;
 
+// Create an analytics session
+
 let s = new DA.AnalyticsSession(sr);
 
+// Run the analytics
+
 let bLog = false;
 s.analyzePlan(bLog);
 
-const statistics: DA.DistrictStatistics = s.getDistrictStatistics();
-const requirements: DA.RequirementsChecklist = s.getRequirementsChecklist();
+// Retrieve the artifacts
+
 const scorecard: DA.Scorecard = s.getPlanScorecard();
 const ratings: DA.Ratings = s.getRatings();
-
-const discontiguous = DA.GeoFeatureCollection = s.getDiscontiguousDistrictFeatures();
-
+const requirements: DA.RequirementsChecklist = s.getRequirementsChecklist();
 ```
-

package/dist/_api.d.ts

@@ -1,39 +1,16 @@
 import { Types } from '@dra2020/dra-analytics';
-import { PF } from '@dra2020/dra-types';
-import { RequirementsChecklist } from './results';
-import { DistrictStatistics } from './results';
-import * as D from './_data';
+import * as D from './data';
 import * as T from './types';
 import * as L from './legacy-types';
 export declare class AnalyticsSession {
-    title: string;
-    legislativeDistricts: boolean;
-    config: T.Dict;
-    bOneTimeProcessingDone: boolean;
-    bPlanAnalyzed: boolean;
-    bPostProcessingDone: boolean;
-    tests: T.TestEntries;
-    _profile?: L.Profile;
-    _scorecard?: L.Scorecard;
-    state: D.State;
-    counties: D.Counties;
-    graph: D.GraphClass;
-    features: D.Features;
-    plan: D.Plan;
-    districts: D.Districts;
-    aggregates: PF.PackedFields[];
-    repsByDistrict?: number[];
+    data: D.SessionData;
+    bLog: boolean;
     constructor(SessionRequest: T.SessionRequest);
-    processConfig(config: T.Dict): T.Dict;
     analyzePlan(bLog?: boolean, overridesJSON?: any): boolean;
-    getGoodShapes(): T.GeoFeatureCollection;
     analyzeRacialPolarization(districtID: number, groups: Types.MinorityFilter, bLog?: boolean): Types.RPVAnalysis | undefined;
-    getDistrictStatistics(bLog?: boolean): DistrictStatistics;
     getPlanProfile(bLog?: boolean): L.Profile;
     getPlanScorecard(bLog?: boolean): L.Scorecard;
     getRatings(bLog?: boolean): T.Ratings;
-    getRequirementsChecklist(bLog?: boolean): RequirementsChecklist;
-    getDiscontiguousDistrictFeatures(bLog?: boolean): T.GeoFeatureCollection;
-    getTest(testID: T.Test): T.TestEntry;
-    populationDeviationThreshold(): number;
+    getRequirementsChecklist(bLog?: boolean): T.RequirementsChecklist;
+    getDistrictStatistics(bLog?: boolean): T.DistrictStatistics;
 }

package/dist/_data.d.ts

@@ -1,5 +1,5 @@
-import { Types } from '@dra2020/dra-analytics';
 import * as T from './types';
+export * from './data';
 import { AnalyticsSession } from './_api';
 export type TransposedTable = {
     totalPop: number[];
@@ -32,7 +32,7 @@ export type TransposedTable = {
     asianPct: number[];
     nativePct: number[];
 };
-export declare class Districts {
+export declare class LegacyDistricts {
     _session: AnalyticsSession;
     _shapes: T.GeoFeatureCollection;
     _geoProperties: T.DistrictProperties;
@@ -48,69 +48,4 @@ export declare class Districts {
     recalcStatistics(bLog?: boolean): void;
     extractDistrictShapeProperties(bLog?: boolean): void;
     getCountyIndex(geoID: string): number;
-    extractVotesByDemographic(districtID: number, groups: Types.MinorityFilter, bLog?: boolean): Types.DemographicVotingByFeature | undefined;
-}
-export declare function inferSelectedMinority(groups: Types.MinorityFilter): string;
-export declare class Features {
-    _session: AnalyticsSession;
-    _data: T.GeoFeatureCollection;
-    _keys: T.DatasetKeys;
-    _featureIDs: T.FeaturesByGeoID;
-    constructor(s: AnalyticsSession, data: T.GeoFeatureCollection, keys: T.DatasetKeys);
-    nFeatures(): number;
-    featureByIndex(i: number): T.GeoFeature;
-    resetDataset(d: T.Dataset, k: string): void;
-    mapGeoIDsToFeatureIDs(): void;
-    featureID(i: string): number;
-}
-export declare function geoIDForFeature(f: any): string;
-export declare function fieldForFeature(f: any, dk: string, ff: T.FeatureField): any;
-export declare class Counties {
-    _session: AnalyticsSession;
-    _data: T.GeoFeatureCollection;
-    _countyNameLookup: T.FIPSCodeToCountyNameMap;
-    nCounties: number;
-    index: T.FIPSToOrdinalMap;
-    fips: T.OrdinalToFIPSlMap;
-    totalPopulation: number[];
-    constructor(s: AnalyticsSession, data: T.GeoFeatureCollection);
-    countyByIndex(i: number): T.GeoFeature;
-    propertyForCounty(f: any, pk: string): any;
-    mapFIPSToName(fips: string, name: string): void;
-    nameFromFIPS(fips: string): string;
-    indexFromFIPS(fips: string): number;
-}
-export declare class State {
-    _session: AnalyticsSession;
-    xx: string;
-    nDistricts: number;
-    nReps: number;
-    totalPop: number;
-    targetSize: number;
-    tooBigFIPS: string[];
-    tooBigName: string[];
-    singleCountyDistrictMax: number;
-    expectedSplits: number;
-    expectedAffected: number;
-    constructor(s: AnalyticsSession, xx: string, n: number);
-}
-export declare class Plan {
-    _session: AnalyticsSession;
-    _planByGeoID: T.PlanByGeoID;
-    _planByDistrictID: T.PlanByDistrictID;
-    districtIDs: number[];
-    constructor(s: AnalyticsSession, p: T.PlanByGeoID);
-    invertPlan(bLog?: boolean): void;
-    initializeDistrict(i: number): void;
-    byGeoID(): T.PlanByGeoID;
-    byDistrictID(): T.PlanByDistrictID;
-    districtForGeoID(i: string): number;
-    geoIDsForDistrictID(i: number): Set<string>;
-}
-export declare function invertPlan(plan: T.PlanByGeoID, s?: AnalyticsSession, bLog?: boolean): T.PlanByDistrictID;
-export declare class GraphClass {
-    _session: AnalyticsSession;
-    _graph: T.ContiguityGraph;
-    constructor(s: AnalyticsSession, graph: T.ContiguityGraph);
-    peerNeighbors(node: string): string[];
 }

package/dist/analyze.d.ts

@@ -1,4 +1,2 @@
 import { AnalyticsSession } from './_api';
-export declare function doAnalyzeDistricts(s: AnalyticsSession, bLog?: boolean): void;
-export declare function doAnalyzePlan(s: AnalyticsSession, bLog?: boolean): void;
-export declare function doDeriveSecondaryTests(s: AnalyticsSession, bLog?: boolean): void;
+export declare function newAnalyzePlan(s: AnalyticsSession): boolean;

package/dist/cohesive.d.ts

@@ -1,4 +1,3 @@
 import * as T from './types';
-import { AnalyticsSession } from './_api';
-export declare function doFindCountiesSplitUnexpectedly(s: AnalyticsSession, bLog?: boolean): T.TestEntry;
-export declare function doFindSplitVTDs(s: AnalyticsSession, bLog?: boolean): T.TestEntry;
+import * as D from './data';
+export declare function findCountiesSplitUnexpectedly(container: D.SessionData, bLog?: boolean): T.TestEntry;

package/dist/compact.d.ts

@@ -1,2 +0,0 @@
-import { AnalyticsSession } from './_api';
-export declare function extractDistrictProperties(s: AnalyticsSession, bLog?: boolean): void;

package/dist/data.d.ts

@@ -1,37 +1,80 @@
+import { PF } from '@dra2020/dra-types';
+import { Types } from '@dra2020/dra-analytics';
 import * as T from './types';
+import * as L from './legacy-types';
+import * as D from './data';
 import { AnalyticsSession } from './_api';
-export declare class Districts {
+export declare class SessionData {
     _session: AnalyticsSession;
+    profile?: L.Profile;
+    legacyScorecardAlt?: L.Scorecard;
+    newScorecard?: Types.Scorecard;
+    ratings?: T.Ratings;
+    checklist?: T.RequirementsChecklist;
+    statistics?: T.DistrictStatistics;
+    bOneTimeProcessingDone: boolean;
+    bPlanAnalyzed: boolean;
+    title: string;
+    legislativeDistricts: boolean;
+    repsByDistrict?: number[];
+    config: T.Dict;
+    state: State;
+    counties: Counties;
+    graph: T.ContiguityGraph;
+    features: Features;
+    plan: Plan;
+    districts: Districts;
+    aggregates: Aggregates;
+    CxD: number[][];
+    constructor(s: AnalyticsSession, SessionRequest: T.SessionRequest);
+}
+export declare class Aggregates {
+    _container: D.SessionData;
+    _aggregates: PF.PackedFields[];
+    unpacked: {
+        [key: string]: {
+            [key: string]: number[];
+        };
+    };
+    columns: {
+        [key: string]: any[];
+    };
+    constructor(container: D.SessionData, aggregates: PF.PackedFields[]);
+    process(): void;
+    transpose(): T.DistrictRow[];
+    private _unpack;
+    private _columnize;
+    private _checkReqs;
+    private _convert;
+}
+export declare class Districts {
+    _container: D.SessionData;
     _shapes: T.GeoFeatureCollection;
-    _geoProperties: T.DistrictProperties;
-    constructor(s: AnalyticsSession, ds: T.GeoFeatureCollection);
-    getDistrictShapes(): T.GeoFeatureCollection;
-    getDistrictShapeByID(id: number): T.GeoFeature | undefined;
-    getCountyIndex(geoID: string): number;
+    constructor(container: D.SessionData, ds: T.GeoFeatureCollection);
+    getShapes(): T.GeoFeatureCollection;
 }
 export declare class Features {
-    _session: AnalyticsSession;
+    _container: D.SessionData;
     _data: T.GeoFeatureCollection;
     _keys: T.DatasetKeys;
     _featureIDs: T.FeaturesByGeoID;
-    constructor(s: AnalyticsSession, data: T.GeoFeatureCollection, keys: T.DatasetKeys);
+    constructor(container: D.SessionData, data: T.GeoFeatureCollection, keys: T.DatasetKeys);
     nFeatures(): number;
     featureByIndex(i: number): T.GeoFeature;
-    resetDataset(d: T.Dataset, k: string): void;
     mapGeoIDsToFeatureIDs(): void;
     featureID(i: string): number;
 }
 export declare function geoIDForFeature(f: any): string;
 export declare function fieldForFeature(f: any, dk: string, ff: T.FeatureField): any;
 export declare class Counties {
-    _session: AnalyticsSession;
+    _container: D.SessionData;
     _data: T.GeoFeatureCollection;
     _countyNameLookup: T.FIPSCodeToCountyNameMap;
     nCounties: number;
     index: T.FIPSToOrdinalMap;
     fips: T.OrdinalToFIPSlMap;
     totalPopulation: number[];
-    constructor(s: AnalyticsSession, data: T.GeoFeatureCollection);
+    constructor(container: D.SessionData, data: T.GeoFeatureCollection);
     countyByIndex(i: number): T.GeoFeature;
     propertyForCounty(f: any, pk: string): any;
     mapFIPSToName(fips: string, name: string): void;
@@ -39,7 +82,7 @@ export declare class Counties {
     indexFromFIPS(fips: string): number;
 }
 export declare class State {
-    _session: AnalyticsSession;
+    _container: D.SessionData;
     xx: string;
     nDistricts: number;
     nReps: number;
@@ -50,14 +93,14 @@ export declare class State {
     singleCountyDistrictMax: number;
     expectedSplits: number;
     expectedAffected: number;
-    constructor(s: AnalyticsSession, xx: string, n: number);
+    constructor(container: D.SessionData, xx: string, n: number);
 }
 export declare class Plan {
-    _session: AnalyticsSession;
+    _container: D.SessionData;
     _planByGeoID: T.PlanByGeoID;
     _planByDistrictID: T.PlanByDistrictID;
     districtIDs: number[];
-    constructor(s: AnalyticsSession, p: T.PlanByGeoID);
+    constructor(container: D.SessionData, p: T.PlanByGeoID);
     invertPlan(bLog?: boolean): void;
     initializeDistrict(i: number): void;
     byGeoID(): T.PlanByGeoID;
@@ -65,4 +108,5 @@ export declare class Plan {
     districtForGeoID(i: string): number;
     geoIDsForDistrictID(i: number): Set<string>;
 }
-export declare function invertPlan(plan: T.PlanByGeoID, s?: AnalyticsSession, bLog?: boolean): T.PlanByDistrictID;
+export declare function invertPlan(plan: T.PlanByGeoID, container?: D.SessionData, bLog?: boolean): T.PlanByDistrictID;
+export declare function processConfig(config: T.Dict): T.Dict;