emod-api 3.0.2__py3-none-any.whl

emod_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.0.2"

emod_api/campaign.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+"""
+You use this simple campaign builder by importing it, adding valid events via "add", and writing it out with "save".
+"""
+
+import json
+
+from emod_api import schema_to_class as s2c
+
+schema_path = None
+_schema_json = None
+campaign_dict = {"Events": [], "Use_Defaults": 1}
+pubsub_signals_subbing = []
+pubsub_signals_pubbing = []
+adhocs = []
+custom_coordinator_events = []
+custom_node_events = []
+event_map = {}
+use_old_adhoc_handling = False
+unsafe = False
+implicits = list()
+trigger_list = None
+
+
+def reset():
+    campaign_dict["Events"].clear()
+
+    pubsub_signals_subbing.clear()
+    pubsub_signals_pubbing.clear()
+    adhocs.clear()
+    custom_coordinator_events.clear()
+    custom_node_events.clear()
+    implicits.clear()
+
+    event_map.clear()
+
+    s2c.clear_schema_cache()
+
+
+def set_schema(schema_path_in):
+    """
+    Set the (path to) the schema file. And reset all campaign variables. This is essentially a
+    "start_building_campaign" function.
+
+    Parameters:
+        schema_path_in (str): The path to a schema.json file
+
+    Returns:
+
+    """
+    reset()
+    global schema_path, _schema_json
+
+    schema_path = schema_path_in
+    with open(schema_path_in) as schema_file:
+        _schema_json = json.load(schema_file)
+
+
+def get_schema():
+    return _schema_json
+
+
+def add(event, name=None, first=False):
+    """
+    Add a complete campaign event to the campaign builder. The new event is assumed to be a Python dict, and a
+    valid event. The new event is not validated here.
+    Set the first flag to True if this is the first event in a campaign because it functions as an
+    accumulator and in some situations like sweeps it might have been used recently.
+    """
+    event.finalize()
+    if first:
+        print("Use of 'first' flag is deprecated. Use set_schema to start build a new, empty campaign.")
+        campaign_dict["Events"].clear()
+    if "Event_Name" not in event and name is not None:
+        event["Event_Name"] = name
+    if "Listening" in event:
+        pubsub_signals_subbing.extend(event["Listening"])
+        event.pop("Listening")
+    if "Broadcasting" in event:
+        pubsub_signals_pubbing.extend(event["Broadcasting"])
+        event.pop("Broadcasting")
+    campaign_dict["Events"].append(event)
+
+
+def get_trigger_list():
+    global trigger_list
+    if get_schema():
+        # This needs to be fixed in the schema post-processor: maybe create a new idmTime:EventEnum and replace
+        # all the occurrences with a reference to that.
+        try:
+            trigger_list = get_schema()["idmTypes"]["idmAbstractType:EventCoordinator"]["BroadcastCoordinatorEvent"][
+                "Broadcast_Event"]["enum"]
+        except Exception:
+            trigger_list = get_schema()["idmTypes"]["idmType:IncidenceCounter"]["Trigger_Condition_List"]["Built-in"]
+    return trigger_list
+
+
+def save(filename="campaign.json"):
+    """
+    Save 'campaign_dict' as file named 'filename'.
+    """
+    with open(filename, "w") as camp_file:
+        json.dump(campaign_dict, camp_file, sort_keys=True, indent=4)
+    import copy
+    ignored_events = copy.deepcopy(set(pubsub_signals_pubbing))
+    non_camp_events = set()
+    if len(pubsub_signals_subbing) > 0:
+        for event in set(pubsub_signals_subbing):
+            if event in ignored_events:
+                ignored_events.remove(event)
+    if len(non_camp_events) > 0:
+        for event in set(non_camp_events):
+            if event in get_adhocs() and not unsafe:
+                raise RuntimeError(f"ERROR: Report is configured to LISTEN to the following non-existent event: \n"
+                                   f"{event} \nPlease fix the error.\n")
+    return filename
+
+
+def get_adhocs():
+    return event_map
+
+
+def get_custom_coordinator_events():
+    return list(set(custom_coordinator_events))
+
+
+def get_custom_node_events():
+    return list(set(custom_node_events))
+
+
+def get_recv_trigger(trigger, old=use_old_adhoc_handling):
+    """
+    Get the correct representation of a trigger (also called signal or even event) that is being listened to.
+    """
+    pubsub_signals_subbing.append(trigger)
+    return get_event(trigger, old)
+
+
+def get_send_trigger(trigger, old=use_old_adhoc_handling):
+    """
+    Get the correct representation of a trigger (also called signal or even event) that is being broadcast.
+    """
+    pubsub_signals_pubbing.append(trigger)
+    return get_event(trigger, old)
+
+
+def get_event(event, old=False):
+    """
+    Basic placeholder functionality for now. This will map new ad-hoc events to GP_EVENTs and manage that 'cache'
+    If event in built-ins, return event, else if in adhoc map, return mapped event, else add to adhoc_map and return
+    mapped event.
+    """
+    if event is None or event == "":
+        raise ValueError("campaign.get_event() called with an empty event. Please specify a string.")
+
+    return_event = None
+    global trigger_list
+    if trigger_list is None:
+        trigger_list = get_trigger_list()
+
+    if event in trigger_list:
+        return_event = event
+    elif event in event_map:
+        return_event = event_map[event]
+    else:
+        # get next entry in GP_EVENT_xxx
+        new_event_name = event if old else f'GP_EVENT_{len(event_map):03d}'
+        event_map[event] = new_event_name
+        return_event = event_map[event]
+    return return_event

emod_api/channelreports/channels.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+
+"""Module for reading InsetChart.json channels."""
+
+from datetime import datetime
+import json
+from pathlib import Path
+from typing import Union
+import pandas as pd
+
+_CHANNELS = "Channels"
+_DTK_VERSION = "DTK_Version"
+_DATETIME = "DateTime"
+_REPORT_TYPE = "Report_Type"
+_REPORT_VERSION = "Report_Version"
+_SIMULATION_TIMESTEP = "Simulation_Timestep"
+_START_TIME = "Start_Time"
+_TIMESTEPS = "Timesteps"
+
+_KNOWN_KEYS = {
+    _CHANNELS,
+    _DTK_VERSION,
+    _DATETIME,
+    _REPORT_TYPE,
+    _REPORT_VERSION,
+    _SIMULATION_TIMESTEP,
+    _START_TIME,
+    _TIMESTEPS,
+}
+
+_TYPE_INSETCHART = "InsetChart"
+
+_UNITS = "Units"
+_DATA = "Data"
+
+_HEADER = "Header"
+
+
+class Header(object):
+
+    # Allow callers to send an arbitrary dictionary, potentially, with extra key:value pairs.
+    def __init__(self, **kwargs) -> None:
+
+        self._channelCount = kwargs[_CHANNELS] if kwargs and _CHANNELS in kwargs else 0
+        self._dtkVersion = (
+            kwargs[_DTK_VERSION] if kwargs and _DTK_VERSION in kwargs else "unknown-branch (unknown)"
+        )
+        self._timeStamp = (
+            kwargs[_DATETIME]
+            if kwargs and _DATETIME in kwargs
+            else f"{datetime.now():%a %B %d %Y %H:%M:%S}"
+        )
+        self._reportType = (
+            kwargs[_REPORT_TYPE]
+            if kwargs and _REPORT_TYPE in kwargs
+            else _TYPE_INSETCHART
+        )
+        self._reportVersion = (
+            kwargs[_REPORT_VERSION] if kwargs and _REPORT_VERSION in kwargs else "0.0"
+        )
+        self._stepSize = (
+            kwargs[_SIMULATION_TIMESTEP]
+            if kwargs and _SIMULATION_TIMESTEP in kwargs
+            else 1
+        )
+        self._startTime = kwargs[_START_TIME] if kwargs and _START_TIME in kwargs else 0
+        self._numTimeSteps = (
+            kwargs[_TIMESTEPS] if kwargs and _TIMESTEPS in kwargs else 0
+        )
+        self._tags = {key: kwargs[key] for key in kwargs if key not in _KNOWN_KEYS}
+
+        return
+
+    @property
+    def num_channels(self) -> int:
+        return self._channelCount
+
+    @num_channels.setter
+    def num_channels(self, count: int) -> None:
+        """> 0"""
+        assert count > 0, "numChannels must be > 0"
+        self._channelCount = count
+        return
+
+    @property
+    def dtk_version(self) -> str:
+        return self._dtkVersion
+
+    @dtk_version.setter
+    def dtk_version(self, version: str) -> None:
+        """major.minor"""
+        self._dtkVersion = f"{version}"
+        return
+
+    @property
+    def time_stamp(self) -> str:
+        return self._timeStamp
+
+    @time_stamp.setter
+    def time_stamp(self, timestamp: Union[datetime, str]) -> None:
+        """datetime or string"""
+        self._timeStamp = (
+            f"{timestamp:%a %B %d %Y %H:%M:%S}"
+            if isinstance(timestamp, datetime)
+            else f"{timestamp}"
+        )
+        return
+
+    @property
+    def report_type(self) -> str:
+        return self._reportType
+
+    @report_type.setter
+    def report_type(self, report_type: str) -> None:
+        self._reportType = f"{report_type}"
+        return
+
+    @property
+    def report_version(self) -> str:
+        return self._reportVersion
+
+    @report_version.setter
+    def report_version(self, version: str) -> None:
+        self._reportVersion = f"{version}"
+        return
+
+    @property
+    def step_size(self) -> int:
+        """>= 1"""
+        return self._stepSize
+
+    @step_size.setter
+    def step_size(self, size: int) -> None:
+        """>= 1"""
+        self._stepSize = int(size)
+        assert self._stepSize >= 1, "stepSize must be >= 1"
+        return
+
+    @property
+    def start_time(self) -> int:
+        """>= 0"""
+        return self._startTime
+
+    @start_time.setter
+    def start_time(self, time: int) -> None:
+        """>= 0"""
+        self._startTime = int(time)
+        assert self._startTime >= 0, "startTime must be >= 0"
+        return
+
+    @property
+    def num_time_steps(self) -> int:
+        """>= 1"""
+        return self._numTimeSteps
+
+    @num_time_steps.setter
+    def num_time_steps(self, count: int) -> None:
+        """>= 1"""
+        self._numTimeSteps = int(count)
+        assert self._numTimeSteps > 0, "numTimeSteps must be > 0"
+        return
+
+    def as_dictionary(self) -> dict:
+        # https://stackoverflow.com/questions/38987/how-do-i-merge-two-dictionaries-in-a-single-expression
+        return {
+            **{
+                _CHANNELS: self.num_channels,
+                _DTK_VERSION: self.dtk_version,
+                _DATETIME: self.time_stamp,
+                _REPORT_TYPE: self.report_type,
+                _REPORT_VERSION: self.report_version,
+                _SIMULATION_TIMESTEP: self.step_size,
+                _START_TIME: self.start_time,
+                _TIMESTEPS: self.num_time_steps,
+            },
+            **self._tags,
+        }
+
+
+class Channel(object):
+
+    def __init__(self, title: str, units: str, data: list) -> None:
+        self._title = title
+        self._units = units
+        self._data = data
+        return
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @title.setter
+    def title(self, title: str) -> None:
+        self._title = f"{title}"
+        return
+
+    @property
+    def units(self) -> str:
+        return self._units
+
+    @units.setter
+    def units(self, units: str) -> None:
+        self._units = f"{units}"
+        return
+
+    @property
+    def data(self):
+        return self._data
+
+    def __getitem__(self, item):
+        """Index into channel data by time step"""
+        return self._data[item]
+
+    def __setitem__(self, key, value) -> None:
+        """Update channel data by time step"""
+        self._data[key] = value
+        return
+
+    def as_dictionary(self) -> dict:
+        return {self.title: {_UNITS: self.units, _DATA: list(self.data)}}
+
+
+class ChannelReport(object):
+
+    def __init__(self, filename: str = None, **kwargs):
+
+        if filename is not None:
+            assert isinstance(filename, str), "filename must be a string"
+            self._from_file(filename)
+        else:
+            self._header = Header(**kwargs)
+            self._channels = {}
+
+        return
+
+    @property
+    def header(self) -> Header:
+        return self._header
+
+    # pass-through to header
+
+    @property
+    def dtk_version(self) -> str:
+        return self._header.dtk_version
+
+    @dtk_version.setter
+    def dtk_version(self, version: str) -> None:
+        self._header.dtk_version = version
+        return
+
+    @property
+    def time_stamp(self) -> str:
+        return self._header.time_stamp
+
+    @time_stamp.setter
+    def time_stamp(self, time_stamp: Union[datetime, str]) -> None:
+        self._header.time_stamp = time_stamp
+        return
+
+    @property
+    def report_type(self) -> str:
+        return self._header.report_type
+
+    @report_type.setter
+    def report_type(self, report_type: str) -> None:
+        self._header.report_type = report_type
+        return
+
+    @property
+    def report_version(self) -> str:
+        """major.minor"""
+        return self._header.report_version
+
+    @report_version.setter
+    def report_version(self, version: str) -> None:
+        self._header.report_version = version
+        return
+
+    @property
+    def step_size(self) -> int:
+        """>= 1"""
+        return self._header.step_size
+
+    @step_size.setter
+    def step_size(self, size: int) -> None:
+        """>= 1"""
+        self._header.step_size = size
+        return
+
+    @property
+    def start_time(self) -> int:
+        """>= 0"""
+        return self._header.start_time
+
+    @start_time.setter
+    def start_time(self, time: int) -> None:
+        """>= 0"""
+        self._header.start_time = time
+        return
+
+    @property
+    def num_time_steps(self) -> int:
+        """> 0"""
+        return self._header.num_time_steps
+
+    @num_time_steps.setter
+    def num_time_steps(self, count: int):
+        """> 0"""
+        self._header.num_time_steps = count
+        return
+
+    # end pass-through
+
+    @property
+    def num_channels(self) -> int:
+        return len(self._channels)
+
+    @property
+    def channel_names(self) -> list:
+        return sorted(self._channels)
+
+    @property
+    def channels(self) -> dict:
+        """Channel objects keyed on channel name/title"""
+        return self._channels
+
+    def __getitem__(self, item: str) -> Channel:
+        """Return Channel object by channel name/title"""
+        return self._channels[item]
+
+    def as_dataframe(self) -> pd.DataFrame:
+        """Return underlying data as a Pandas DataFrame"""
+        dataframe = pd.DataFrame(
+            {key: self.channels[key].data for key in self.channel_names}
+        )
+        return dataframe
+
+    def write_file(self, filename: str, indent: int = 0, separators=(",", ":")) -> None:
+        """Write inset chart to specified text file."""
+
+        # in case this was generated locally, lets do some consistency checks
+        assert len(self._channels) > 0, "Report has no channels."
+        counts = set([len(channel.data) for title, channel in self.channels.items()])
+        assert (
+            len(counts) == 1
+        ), f"Channels do not all have the same number of values ({counts})"
+
+        self._header.num_channels = len(self._channels)
+        self.num_time_steps = len(self._channels[self.channel_names[0]].data)
+
+        with open(filename, "w", encoding="utf-8") as file:
+            channels = {}
+            for _, channel in self.channels.items():
+                # https://stackoverflow.com/questions/38987/how-do-i-merge-two-dictionaries-in-a-single-expression
+                channels = {**channels, **channel.as_dictionary()}
+            chart = {_HEADER: self.header.as_dictionary(), _CHANNELS: channels}
+            json.dump(chart, file, indent=indent, separators=separators)
+
+        return
+
+    def _from_file(self, filename: str) -> None:
+
+        def validate_file(_jason) -> None:
+
+            assert _HEADER in _jason, f"'{filename}' missing '{_HEADER}' object."
+            assert (
+                _CHANNELS in _jason[_HEADER]
+            ), f"'{filename}' missing '{_HEADER}/{_CHANNELS}' key."
+            assert (
+                _TIMESTEPS in _jason[_HEADER]
+            ), f"'{filename}' missing '{_HEADER}/{_TIMESTEPS}' key."
+            assert _CHANNELS in _jason, f"'{filename}' missing '{_CHANNELS}' object."
+            num_channels = _jason[_HEADER][_CHANNELS]
+            channels_len = len(_jason[_CHANNELS])
+            assert num_channels == channels_len, (
+                f"'{filename}': "
+                + f"'{_HEADER}/{_CHANNELS}' ({num_channels}) does not match number of {_CHANNELS} ({channels_len})."
+            )
+
+            return
+
+        def validate_channel(_channel, _title, _header) -> None:
+
+            assert _UNITS in _channel, f"Channel '{_title}' missing '{_UNITS}' entry."
+            assert _DATA in _channel, f"Channel '{_title}' missing '{_DATA}' entry."
+            count = len(_channel[_DATA])
+            assert (
+                count == _header.num_time_steps
+            ), f"Channel '{title}' data values ({count}) does not match header Time_Steps ({_header.num_time_steps})."
+
+            return
+
+        with open(filename, "rb") as file:
+            jason = json.load(file)
+            validate_file(jason)
+
+            header_dict = jason[_HEADER]
+            self._header = Header(**header_dict)
+            self._channels = {}
+
+            channels = jason[_CHANNELS]
+            for title, channel in channels.items():
+                validate_channel(channel, title, self._header)
+                units = channel[_UNITS]
+                data = channel[_DATA]
+                self._channels[title] = Channel(title, units, data)
+
+        return
+
+    def to_csv(self, filename: Union[str, Path], channel_names: list[str] = None, transpose: bool = False) -> None:
+
+        """
+        Write each channel from the report to a row, CSV style, in the given file.
+
+        Channel name goes in the first column, channel data goes into subsequent columns.
+
+        Args:
+            filename: string or path specifying destination file
+            channel_names: optional list of channels (by name) to write to the file
+            transpose: write channels as columns rather than rows
+        """
+
+        if channel_names is None:
+            channel_names = self.channel_names
+
+        if not transpose:   # default
+            data_frame = pd.DataFrame([[channel_name] + list(self[channel_name]) for channel_name in channel_names])
+            # data_frame = pd.DataFrame(([channel_name] + list(self[channel_name]) for channel_name in channel_names))
+            data_frame.to_csv(filename, header=False, index=False)
+        else:               # transposed
+            self.as_dataframe().to_csv(filename, header=True, index=True, index_label="timestep")
+
+        return

emod_api/channelreports/icj_to_csv.py

@@ -0,0 +1,65 @@
+import os
+import json
+import pandas as pd
+
+
+def _get_sim_years(output_path):
+
+    if not os.path.exists("config.json"):
+        return None
+    with open("config.json") as config_fp:
+        config = json.load(config_fp)
+    if "Base_Year" not in config["parameters"]:
+        return None
+
+    base_year = config["parameters"]["Base_Year"]
+    step = config["parameters"]["Simulation_Timestep"] / 365
+    steps = round(config["parameters"]["Simulation_Duration"] / step)
+
+    sim_year = [base_year + step * x for x in range(steps)]
+    return sim_year
+
+
+def inset_chart_json_to_csv_dataframe_pd(output_path: str):
+    """
+    Convert InsetChart.json file in 'output_path' to InsetChart.csv.
+    Adding Simulation_Year column if Base_Year exists in config.json.
+
+    Args:
+
+        output_path (str): Subdirectory in which to find InsetChart.json
+
+    Returns:
+
+    Raises:
+        ValueError: if InsetChart.json can't be found.
+        ValueError: if InsetChart.csv can't be written.
+    """
+
+    icj_path = os.path.join(output_path, "InsetChart.json")
+    if not os.path.exists(icj_path):
+        raise ValueError(f"InsetChart.json not found at {output_path}.")
+
+    # Load JSON data from file
+    with open(icj_path) as fp:
+        icj = json.load(fp)
+
+    optional_years_channel = _get_sim_years(output_path)
+    if optional_years_channel:
+        icj["Channels"]["Simulation_Year"]["Data"] = optional_years_channel
+
+    # Create an empty DataFrame
+    df = pd.DataFrame()
+
+    # Iterate over the Channels keys and extract time series data
+    for channel, values in icj["Channels"].items():
+        # Create a column in the DataFrame for each channel
+        df[channel] = values["Data"]
+
+    try:
+        # Convert DataFrame to CSV
+        csv_path = os.path.join(output_path, "InsetChart.csv")
+        df.to_csv(csv_path, index=False)
+    except Exception as ex:
+        print(f"ERROR: Exception {ex} while writing csv dataframe of InsetChart.json to disk.")
+        raise ValueError(ex)