emod-api 3.0.2__py3-none-any.whl

emod_api/demographics/service/grid_construction.py

@@ -0,0 +1,143 @@
+"""
+- construct a grid from a bounding box
+- label a collection of points by grid cells
+
+- input:     - points csv file with required columns lat,lon # see example input files (structures_households.csv)
+
+- output:    - csv file of grid locations
+             - csv with grid cell id added for each point record
+"""
+
+
+import math
+import logging
+
+from copy import deepcopy
+
+import numpy as np
+import pandas as pd
+from shapely.geometry import Point
+import pyproj
+
+# square grid cell/pixel side (in m)
+cell_size = 1000
+
+# projection param
+geod = pyproj.Geod(ellps='WGS84')
+
+
+def get_grid_cell_id(idx, idy):
+
+    return str(idx) + "_" + str(idy)
+
+
+def construct(x_min, y_min, x_max, y_max):
+    '''
+    Creating grid
+    '''
+
+    logging.info("Creating grid...")
+
+    # create corners of rectangle to be transformed to a grid
+    min_corner = Point((x_min, y_min))
+    max_corner = Point((x_max, y_max))
+
+    # get the centroid of the cell left-down from the grid min corner; that is the origin of the grid
+    origin = geod.fwd(min_corner.x, min_corner.y, -135, cell_size / math.sqrt(2))
+    origin = Point(origin[0], origin[1])
+
+    # get the centroid of the cell right-up from the grid max corner; that is the final point of the grid
+    final = geod.fwd(max_corner.x, max_corner.y, 45, cell_size / math.sqrt(2))
+    final = Point(final[0], final[1])
+
+    fwdax, backax, dx = geod.inv(origin.x, origin.y, final.x, origin.y)
+    fwday, backay, dy = geod.inv(origin.x, origin.y, origin.x, final.y)
+
+    # construct grid
+    x = origin.x
+    y = origin.y
+
+    current_point = deepcopy(origin)
+    grid_id_2_cell_id = {}
+
+    idx = 0
+
+    cell_id = 0
+    grid_lons = []
+    grid_lats = []
+
+    gcids = []
+    while x < final.x:
+        y = origin.y
+        idy = 0
+
+        while y < final.y:
+            y = geod.fwd(current_point.x, y, fwday, cell_size)[1]
+            current_point = Point(x, y)
+
+            grid_lats.append(current_point.y)
+            grid_lons.append(current_point.x)
+
+            grid_id = get_grid_cell_id(idx, idy)
+            grid_id_2_cell_id[grid_id] = cell_id
+
+            cell_id += 1
+            gcids.append(cell_id)
+            idy += 1
+
+        x = geod.fwd(current_point.x, current_point.y, fwdax, cell_size)[0]
+        current_point = Point(x, current_point.y)
+        idx += 1
+
+    grid = pd.DataFrame(data=grid_lats, index=np.arange(len(grid_lats)), columns=["lat"])
+    grid["lon"] = grid_lons
+    grid["gcid"] = gcids
+
+    num_cells_x = len(set(grid_lons))
+    num_cells_y = len(set(grid_lats))
+
+    logging.info("Created grid of size")
+    logging.info(str(num_cells_x) + "x" + str(num_cells_y))
+    logging.info("Done.")
+
+    return grid, grid_id_2_cell_id, origin, final
+
+
+def get_bbox(data):
+
+    logging.info("Getting bounding box...")
+
+    x_min = min(data['lon'].to_numpy())
+    x_max = max(data['lon'].to_numpy())
+
+    y_min = min(data['lat'].to_numpy())
+    y_max = max(data['lat'].to_numpy())
+
+    logging.info("Done.")
+
+    return x_min, y_min, x_max, y_max
+
+
+def lon_lat_2_point(lon, lat):
+
+    return Point(lon, lat)
+
+
+def point_2_grid_cell_id_lookup(point, grid_id_2_cell_id, origin):
+
+    p = lon_lat_2_point(point["lon"], point["lat"])
+
+    fwdax, backax, dx = geod.inv(origin.x, origin.y, p.x, origin.y)
+    fwday, backay, dy = geod.inv(origin.x, origin.y, origin.x, p.y)
+
+    idx = int(dx / (cell_size + 0.0)) + 1
+    idy = int(dy / (cell_size + 0.0)) + 1
+
+    grid_id = get_grid_cell_id(idx, idy)
+
+    if grid_id in grid_id_2_cell_id:
+        cid = int(grid_id_2_cell_id[grid_id])
+    else:
+        cid = None
+
+    return (cid, idx, idy)

emod_api/demographics/service/service.py

@@ -0,0 +1,55 @@
+import os
+import json
+import pandas as pd
+import numpy as np # just for a sum function right now
+import emod_api.demographics.service.grid_construction as grid
+
+
+def _create_grid_files(point_records_file_in, final_grid_files_dir, site):
+    """
+    Purpose: Create grid file (as csv) from records file.
+    Author: pselvaraj
+    """
+    # create paths first...
+    output_filename = f"{site}_grid.csv"
+    if not os.path.exists(final_grid_files_dir):
+        os.mkdir(final_grid_files_dir)
+    out_path = os.path.join(final_grid_files_dir, output_filename)
+
+    if not os.path.exists(out_path):
+        # Then manip data...
+        print(f"{out_path} not found so we are going to create it.")
+        print(f"Reading {point_records_file_in}.")
+        point_records = pd.read_csv(point_records_file_in, encoding="iso-8859-1")
+        point_records.rename(columns={'longitude': 'lon', 'latitude': 'lat'}, inplace=True)
+
+        if 'pop' not in point_records.columns:
+            point_records['pop'] = [5.5] * len(point_records)
+
+        if 'hh_size' in point_records.columns:
+            point_records['pop'] = point_records['hh_size']
+
+        # point_records = point_records[point_records['pop']>0]
+        x_min, y_min, x_max, y_max = grid.get_bbox(point_records)
+        point_records = point_records[(point_records.lon >= x_min)
+                                      & (point_records.lon <= x_max)
+                                      & (point_records.lat >= y_min)
+                                      & (point_records.lat <= y_max)]
+        gridd, grid_id_2_cell_id, origin, final = grid.construct(x_min, y_min, x_max, y_max)
+        gridd.to_csv(os.path.join(final_grid_files_dir, f"{site}_grid.csv"))
+
+        with open(os.path.join(final_grid_files_dir, f"{site}_grid_id_2_cell_id.json"), "w") as g_f:
+            json.dump(grid_id_2_cell_id, g_f, indent=3)
+
+        rec_val = point_records.apply(grid.point_2_grid_cell_id_lookup, args=(grid_id_2_cell_id, origin,), axis=1).apply(pd.Series)
+        point_records[['gcid', 'gidx', 'gidy']] = rec_val
+
+        grid_pop = point_records.groupby(['gcid', 'gidx', 'gidy'])['pop'].apply(np.sum).reset_index()
+        grid_pop['pop'] = grid_pop['pop'].apply(lambda x: round(x / 5))
+        grid_final = pd.merge(gridd, grid_pop, on='gcid')
+        grid_final['node_label'] = list(grid_final.index)
+        grid_final = grid_final[grid_final['pop'] > 5]
+        grid_final.to_csv(os.path.join(final_grid_files_dir, output_filename))
+
+    print(f"{out_path} gridded population file created or found.")
+    return out_path

emod_api/demographics/susceptibility_distribution.py

@@ -0,0 +1,170 @@
+import emod_api.demographics.demographic_exceptions as demog_ex
+
+from emod_api.demographics.updateable import Updateable
+from emod_api.utils import check_dimensionality
+
+
+class SusceptibilityDistribution(Updateable):
+    def __init__(self,
+                 ages_years: list[float],
+                 susceptible_fraction: list[float]):
+        """
+
+        A by-age susceptibility to infection distribution in fraction units 0 to 1. This is used whenever an agent is
+        created, such as during model initialization and when agents are born.
+
+        For Generic (GENERIC_SIM) simulations only.
+
+        The SusceptibilityDistribution provides a probability each agent will be initialized as susceptible to
+        infection (or not). It models the effect of natural immunity in preventing infection entirely in (1-fraction)
+        of the population. Those that are allowed to acquire an infection can also be affected by other interventions
+        or immunity derived from getting the disease. Agents are identified at creation time as 'susceptible to
+        infection' by a uniform random number draw that is compared to the susceptibility distribution value at the
+        corresponding agent age. If an agents age lies between two provided ages, its chances of being susceptible to
+        infection are linearly interpolated from the two closest corresponding ages. If the agents age lies beyond the
+        provided ages, the closest age-corresponding susceptibility will be used.
+
+        WARNING: This complex distribution is different than when using a SimpleDistribution for this feature. The
+        complex distribution makes people either completely susceptible or completely immune. In contrast, simple
+        distributions give each person a probability of acquiring an infection (i.e. value between 0 and 1 versus
+        just 0 or 1).
+
+        Args:
+            ages_years: (list[float]) A list of ages (in years) that susceptibility fraction data will be provided for.
+                Must be a list of monotonically increasing floats within range 0 <= age <= 200 years.
+            susceptible_fraction: (list[float]) A list of susceptibility fractions corresponding to the provided
+                ages_years list. These represent the chances an initialized agent at a given age will be susceptible to
+                infection. Must be a list of floats within range 0 <= fraction <= 1 .
+
+        Example:
+            ages_years: [0, 10, 20, 50, 100]
+            susceptible_fraction: [0.9, 0.7, 0.3, 0.5, 0.8]
+
+            Agent age 10 years
+                susceptible chance: 0.7
+            Agent age 15 years:
+                susceptible chance: 0.7 + (15 - 10) * ((0.3-0.7) / (20-10)) = 0.5
+            Agent age 1000 years (beyond provided age range)
+                susceptible chance: 0.8 (nearest corresponding fraction)
+        """
+        super().__init__()
+        self.ages_years = ages_years
+        self.susceptible_fraction = susceptible_fraction
+        # This will convert the object to an susceptibility distribution dictionary and then validate it reporting
+        # object-relevant messages
+        self._validate(distribution_dict=self.to_dict(validate=False), source_is_dict=False)
+
+    @classmethod
+    def _rate_scale_factor(cls):
+        return 1
+
+    def to_dict(self, validate: bool = True) -> dict:
+        # susceptibility distribution dicts MUST be in ages_days. objs must be in ages_years
+        distribution_dict = {
+            'ResultValues': self.susceptible_fraction,
+            'DistributionValues': [years * 365 for years in self.ages_years],
+            'ResultScaleFactor': self._rate_scale_factor()
+        }
+        if validate:
+            self._validate(distribution_dict=distribution_dict, source_is_dict=False)
+        return distribution_dict
+
+    @classmethod
+    def from_dict(cls, distribution_dict: dict):
+        # susceptibility distribution dicts MUST be in ages_days. objs must be in ages_years
+        cls._validate(distribution_dict=distribution_dict, source_is_dict=True)
+        ages_years = [days / 365 for days in distribution_dict['DistributionValues']]
+        return cls(ages_years=ages_years,
+                   susceptible_fraction=distribution_dict['ResultValues'])
+
+    _validation_messages = {
+        'fixed_value_check': {
+            True: "key: {0} value: {1} does not match expected value: {2}",
+            False: None  # These are all properties of the obj and cannot be made invalid
+        },
+        'data_dimensionality_check_ages': {
+            True: 'DistributionValues must be a 1-d array of floats',
+            False: 'ages_years must be a 1-d array of floats'
+        },
+        'data_dimensionality_check_susceptibility': {
+            True: 'ResultValues must be a 1-d array of floats',
+            False: 'susceptible_fraction must be a 1-d array of floats'
+        },
+        'age_and_susceptibility_length_check': {
+            True: 'DistributionValues and ResultValues must be the same length but are not',
+            False: 'ages_years and susceptible_fraction must be the same length but are not'
+        },
+        'age_range_check': {
+            True: "DistributionValues age values must be: 0 <= age <= 73000 in days. Out-of-range index:values : {0}",
+            False: "All ages_years values must be: 0 <= age <= 200 in years. Out-of-range index:values : {0}"
+        },
+        'susceptibility_range_check': {
+            True: "ResultValues susceptible fractions must be: 0 <= fraction <= 1. "
+                  "Out-of-range index:values : {0}",
+            False: "All susceptible_fraction values must be: 0 <= fraction <= 1. "
+                   "Out-of-range index:values : {0}"
+        },
+        'age_monotonicity_check': {
+            True: "DistributionValues ages in days must monotonically increase but do not, index: {0} value: {1}",
+            False: "ages_years values must monotonically increase but do not, index: {0} value: {1}"
+        }
+    }
+
+    @classmethod
+    def _validate(cls, distribution_dict: dict, source_is_dict: bool):
+        """
+        Validate a SusceptibilityDistribution in dict form
+
+        Args:
+            distribution_dict: (dict) the susceptibility distribution dict to validate
+            source_is_dict: (bool) If true, report dict-relevant error messages. If false, report obj-relevant messages.
+
+        Returns:
+            Nothing
+        """
+        if source_is_dict is True:
+            expected_values = {
+                'ResultScaleFactor': cls._rate_scale_factor()
+            }
+            for key, expected_value in expected_values.items():
+                value = distribution_dict[key]
+                if value != expected_value:
+                    message = cls._validation_messages['fixed_value_check'][source_is_dict].format(key, value, expected_value)
+                    raise demog_ex.InvalidFixedValueException(message)
+
+        # ensure the ages and distribution values are both 1-d iterables of the same length
+        ages = distribution_dict['DistributionValues']
+        susceptible_values = distribution_dict['ResultValues']
+
+        is_1d = check_dimensionality(data=ages, dimensionality=1)
+        if not is_1d:
+            message = cls._validation_messages['data_dimensionality_check_ages'][source_is_dict]
+            raise demog_ex.InvalidDataDimensionality(message)
+        is_1d = check_dimensionality(data=susceptible_values, dimensionality=1)
+        if not is_1d:
+            message = cls._validation_messages['data_dimensionality_check_susceptibility'][source_is_dict]
+            raise demog_ex.InvalidDataDimensionality(message)
+
+        if len(ages) != len(susceptible_values):
+            message = cls._validation_messages['age_and_susceptibility_length_check'][source_is_dict]
+            raise demog_ex.InvalidDataDimensionLength(message)
+
+        # ensure the age and susceptibility value lists are ascending and in reasonable ranges
+        # record in days for dict-relevant messages, years for obj-relevant messages
+        factor = 1 if source_is_dict is True else 1 / 365.0
+        out_of_range = [f"{index}:{age * factor}" for index, age in enumerate(ages) if (age < 0 * 365) or (age > 200 * 365)]
+        if len(out_of_range) > 0:
+            oor_str = ', '.join(out_of_range)
+            message = cls._validation_messages['age_range_check'][source_is_dict].format(oor_str)
+            raise demog_ex.AgeOutOfRangeException(message)
+        out_of_range = [f"{index}:{value}" for index, value in enumerate(susceptible_values)
+                        if (value < 0) or (value > 1)]
+        if len(out_of_range) > 0:
+            oor_str = ', '.join(out_of_range)
+            message = cls._validation_messages['susceptibility_range_check'][source_is_dict].format(oor_str)
+            raise demog_ex.DistributionOutOfRangeException(message)
+
+        for i in range(1, len(ages)):
+            if ages[i] - ages[i - 1] <= 0:
+                message = cls._validation_messages['age_monotonicity_check'][source_is_dict].format(i, ages[i])
+                raise demog_ex.NonMonotonicAgeException(message)

emod_api/demographics/updateable.py

@@ -0,0 +1,58 @@
+from typing import Union, Any
+
+
+class Updateable:
+    """
+    (Base) class that provides update() method for each class that inherits from this class, in particular demographic-
+    related classes.
+    """
+    def __init__(self):
+        self.parameter_dict = {}
+
+    def to_dict(self) -> dict:
+        raise NotImplementedError
+
+    def update(self, overlay_object: Union["Updateable", dict], allow_nones: bool = False) -> None:
+        """
+        Updates an object with the values from overlay_object.
+
+        Args:
+            overlay_object: object with overriding attributes/values to apply to THIS object
+            allow_nones: whether or not to apply/use attributes in overlay_object with value = None
+
+        Returns:
+            Nothing
+        """
+        try:
+            # overlaying a provided Updateable object
+            overlay_dict = vars(overlay_object)
+        except TypeError:
+            # overlaying a provided dict
+            overlay_dict = overlay_object
+
+        for attribute_name, new_attribute_value in overlay_dict.items():
+            if not hasattr(self, attribute_name):
+                raise AttributeError(f"Object of type: {type(self)} does not have an attribute named {attribute_name} "
+                                     f"to override)")
+            # only overlay non-None value UNLESS explicitly allowing it
+            if new_attribute_value is not None or allow_nones is True:
+                try:
+                    # Calling update method in case we have an Updateable being overridden
+                    getattr(self, attribute_name).update(new_attribute_value)
+                except AttributeError:
+                    # not an Updateable being overridden, do direct assignment
+                    setattr(self, attribute_name, new_attribute_value)
+
+    def add_parameter(self, key: str, value: Any) -> None:
+        """
+        Adds a user defined key-value pair to demographics.
+
+        Args:
+            key (str): parameter name to add to the object.
+            value (any): Custom value to assign to the new key.
+
+        Returns:
+            Nothing
+
+        """
+        self.parameter_dict[key] = value

emod_api/legacy/plotAllCharts.py

@@ -0,0 +1,230 @@
+#!/usr/bin/python
+
+import argparse
+import os
+import matplotlib
+
+if os.environ.get("DISPLAY", "") == "":
+    print("no display found. Using non-interactive Agg backend")
+    matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+import sys
+import pylab
+from math import sqrt, ceil
+
+
+def plotOneFromDisk():
+    with open(sys.argv[1]) as ref_sim:
+        ref_data = json.loads(ref_sim.read())
+
+    idx = 0
+    for chan_title in sorted(ref_data["Channels"]):
+        try:
+            subplot = plt.subplot(4, 5, idx)
+            subplot.plot(ref_data["Channels"][chan_title]["Data"], "r-")
+            plt.title(chan_title)
+        except Exception as ex:
+            print(f"{ex}, idx = {idx}")
+        if idx == 4 * 5:
+            break
+
+    plt.show()
+
+
+def plotCompareFromDisk(
+    reference, comparison, label="", savefig=True, headless=False, closefig=True
+):
+    with open(reference) as ref_sim:
+        ref_data = json.loads(ref_sim.read())
+
+    with open(comparison) as test_sim:
+        test_data = json.loads(test_sim.read())
+
+    num_chans = ref_data["Header"]["Channels"]
+
+    plt.figure(figsize=(20, 15))
+
+    square_root = ceil(sqrt(num_chans))
+
+    n_figures_x = square_root
+    n_figures_y = ceil(
+        float(num_chans) / float(square_root)
+    )
+
+    if label == "unspecified":
+        label = sys.argv[1]
+
+    ref_tstep = 1
+    if "Simulation_Timestep" in ref_data["Header"]:
+        ref_tstep = ref_data["Header"]["Simulation_Timestep"]
+
+    tst_tstep = 1
+    if "Simulation_Timestep" in test_data["Header"]:
+        tst_tstep = test_data["Header"]["Simulation_Timestep"]
+
+    idx = 1
+    for chan_title in sorted(ref_data["Channels"]):
+        if chan_title not in test_data["Channels"]:
+            print("title on in test. ignore.")
+            continue
+
+        try:
+            subplot = plt.subplot(n_figures_x, n_figures_y, idx)
+            ref_x_len = len(ref_data["Channels"][chan_title]["Data"])
+            tst_x_len = len(test_data["Channels"][chan_title]["Data"])
+            ref_tstep = 1
+            tst_tstep = 1
+            if "Simulation_Timestep" in ref_data["Header"].keys():
+                ref_tstep = ref_data["Header"]["Simulation_Timestep"]
+                if "Simulation_Timestep" in test_data["Header"].keys():
+                    tst_tstep = test_data["Header"]["Simulation_Timestep"]
+            ref_x_data = np.arange(0, ref_x_len * ref_tstep, ref_tstep)
+            tst_x_data = np.arange(0, tst_x_len * tst_tstep, tst_tstep)
+            subplot.plot(
+                ref_x_data,
+                ref_data["Channels"][chan_title]["Data"],
+                "r-",
+                tst_x_data,
+                test_data["Channels"][chan_title]["Data"],
+                "b-",
+            )
+            plt.setp(subplot.get_xticklabels(), fontsize="5")
+            plt.title(chan_title, fontsize="6")
+            idx += 1
+        except Exception as ex:
+            print("Exception: " + str(ex))
+
+    if reference == comparison:
+        plt.suptitle(label + " " + reference)
+    else:
+        plt.suptitle(
+            label + " reference(red)=" + reference + "  \n test(blue)=" + comparison
+        )
+    plt.subplots_adjust(bottom=0.05)
+
+    if savefig:
+        path_dir = "."  # dumb but might want to change
+        plotname = "InsetChart"
+        pylab.savefig(
+            os.path.join(path_dir, plotname) + ".png",
+            bbox_inches="tight",
+            orientation="landscape",
+        )  # , dpi=200 )
+    if not headless:
+        plt.show()
+    if closefig:
+        plt.close()
+
+
+def plotBunch(all_data, plot_name, baseline_data=None, closefig=True):
+    num_chans = all_data[0]["Header"]["Channels"]
+    plt.suptitle(plot_name)
+    plt.figure(figsize=(20, 15))
+    square_root = 4
+    if num_chans > 30:
+        square_root = 6
+    elif num_chans > 16:
+        square_root = 5
+    plots = []
+    labels = []
+
+    idx = 0
+    for chan_title in sorted(all_data[0]["Channels"]):
+        idx_x = idx % square_root
+        idx_y = int(idx / square_root)
+
+        try:
+            subplot = plt.subplot2grid((square_root, square_root), (idx_y, idx_x))
+            colors = ["b", "g", "c", "m", "y", "k"]
+
+            if baseline_data is not None:
+                tstep = 1
+                if "Simulation_Timestep" in baseline_data["Header"]:
+                    tstep = baseline_data["Header"]["Simulation_Timestep"]
+                x_len = len(baseline_data["Channels"][chan_title]["Data"])
+                x_data = np.arange(0, x_len * tstep, tstep)
+                plots.append(
+                    subplot.plot(
+                        x_data,
+                        baseline_data["Channels"][chan_title]["Data"],
+                        "r-",
+                        linewidth=2,
+                    )
+                )
+
+            for sim_idx in range(0, len(all_data)):
+                labels.append(str(sim_idx))
+
+                x_len = len(all_data[sim_idx]["Channels"][chan_title]["Data"])
+
+                tstep = 1
+                if "Simulation_Timestep" in all_data[sim_idx]["Header"]:
+                    tstep = all_data[sim_idx]["Header"]["Simulation_Timestep"]
+
+                x_data = np.arange(0, x_len * tstep, tstep)
+
+                plots.append(
+                    subplot.plot(
+                        x_data,
+                        all_data[sim_idx]["Channels"][chan_title]["Data"],
+                        colors[sim_idx % len(colors)] + "-",
+                    )
+                )
+
+            plt.title(chan_title)
+        except Exception as ex:
+            print(str(ex))
+        if idx == (square_root * square_root) - 1:
+            break
+
+        idx += 1
+
+    plt.subplots_adjust(
+        left=0.04, right=0.99, bottom=0.02, top=0.9, wspace=0.3, hspace=0.3
+    )
+    pylab.savefig(
+        plot_name.replace(" ", "_") + ".png",
+        bbox_inches="tight",
+        orientation="landscape",
+    )
+    plt.show()
+    if closefig:
+        plt.close()
+
+
+def main(reference, comparison, label, savefig, headless):
+    if headless:
+        savefig = True
+    plotCompareFromDisk(reference, comparison, label, savefig, headless, closefig=False)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("reference", help="Reference chart(s) filename")
+    parser.add_argument(
+        "comparison", default=None, nargs="?", help="Comparison chart(s) filename"
+    )
+    parser.add_argument("label", default="", nargs="?", help="Plot label")
+    parser.add_argument(
+        "--savefig",
+        action="store_true",
+        default=False,
+        help="Write plot image to disk.",
+    )
+    parser.add_argument(
+        "--headless",
+        action="store_true",
+        default=False,
+        help="Do not display; just save to disk.",
+    )
+    args = parser.parse_args()
+
+    main(
+        args.reference,
+        args.comparison if args.comparison else args.reference,
+        args.label,
+        args.savefig,
+        args.headless,
+    )

emod_api/migration/__main__.py

@@ -0,0 +1,22 @@
+#! /usr/bin/env python3
+
+from argparse import ArgumentParser
+from pathlib import Path
+import sys
+
+from .migration import to_csv, examine_file
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser(prog='migration')
+    parser.add_argument("-c", "--csv", type=Path, default=None,
+                        help="Dump contents of <filename> to stdout in CSV format.", metavar='<filename>')
+    parser.add_argument("-e", "--examine", type=Path, default=None, help="Display metadata from <filename> on stdout.",
+                        metavar='<filename>')
+    args = parser.parse_args()
+
+    if len(sys.argv) > 1:
+        to_csv(args.csv) if args.csv else None
+        examine_file(args.examine) if args.examine else None
+    else:
+        parser.print_help()