emodpy 1.35.0__py3-none-any.whl

emodpy/__init__.py

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

emodpy/analyzers/adult_vectors_analyzer.py

@@ -0,0 +1,38 @@
+import json
+import os
+from typing import Any
+
+from idmtools.core.interfaces.iitem import IItem
+
+from idmtools.entities.ianalyzer import IAnalyzer as BaseAnalyzer
+import matplotlib as mpl
+mpl.use('Agg')
+
+
+class AdultVectorsAnalyzer(BaseAnalyzer):
+
+    def __init__(self, name='hi'):
+        super().__init__(filenames=["output\\InsetChart.json"])
+        print(name)
+
+    def initialize(self):
+        if not os.path.exists(os.path.join(self.working_dir, "output")):
+            os.mkdir(os.path.join(self.working_dir, "output"))
+
+    def map(self, data: Any, item: IItem) -> Any:
+        return data[self.filenames[0]]["Channels"]["Adult Vectors"]["Data"]
+
+    def reduce(self, all_data: dict) -> Any:
+        output_dir = os.path.join(self.working_dir, "output")
+        with open(os.path.join(output_dir, "adult_vectors.json"), "w") as fp:
+            json.dump({str(s.uid): v for s, v in all_data.items()}, fp)
+
+        import matplotlib.pyplot as plt
+
+        fig = plt.figure()
+        ax = fig.add_subplot(111)
+
+        for pop in list(all_data.values()):
+            ax.plot(pop)
+        ax.legend([str(s.uid) for s in all_data.keys()])
+        fig.savefig(os.path.join(output_dir, "adult_vectors.png"))

emodpy/analyzers/population_analyzer.py

@@ -0,0 +1,52 @@
+import json
+import os
+from typing import Any
+
+from idmtools.core.interfaces.iitem import IItem
+from idmtools.entities.ianalyzer import IAnalyzer as BaseAnalyzer
+import matplotlib as mpl
+
+mpl.use('Agg')
+
+
+class PopulationAnalyzer(BaseAnalyzer):
+
+    def __init__(self, name='idm'):
+        super().__init__(filenames=["output/InsetChart.json"])
+        print(name)
+
+    def initialize(self):
+        if not os.path.exists(os.path.join(self.working_dir, "output")):
+            os.mkdir(os.path.join(self.working_dir, "output"))
+
+    # idmtools analyzer
+    def map(self, data: Any, item: IItem) -> Any:
+        return data[self.filenames[0]]["Channels"]["Statistical Population"]["Data"]
+
+    def reduce(self, all_data: dict) -> Any:
+        output_dir = os.path.join(self.working_dir, "output")
+
+        with open(os.path.join(output_dir, "population.json"), "w") as fp:
+            json.dump({str(s.uid): v for s, v in all_data.items()}, fp)
+
+        import matplotlib.pyplot as plt
+
+        fig = plt.figure()
+        ax = fig.add_subplot(111)
+
+        for pop in list(all_data.values()):
+            ax.plot(pop)
+        ax.legend([str(s.uid) for s in all_data.keys()])
+        fig.savefig(os.path.join(output_dir, "population.png"))
+
+
+# uncomment following lines with idmtools analyzer
+# if __name__ == "__main__":
+#     platform = Platform('COMPS2')
+#
+#     filenames = ['output/InsetChart.json']
+#     analyzers = [PopulationAnalyzer(working_dir=".")]
+#
+#     exp_id = '8bb8ae8f-793c-ea11-a2be-f0921c167861'  # comps2 exp_id
+#     manager = AnalyzeManager(platform=platform, ids=[(exp_id, ItemType.EXPERIMENT)], analyzers=analyzers)
+#     manager.analyze()

emodpy/analyzers/timeseries_analyzer.py

@@ -0,0 +1,117 @@
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+from idmtools.analysis.analyze_manager import AnalyzeManager
+from idmtools.core import ItemType
+from idmtools.core.platform_factory import Platform
+from idmtools.entities import IAnalyzer
+
+
+class TimeseriesAnalyzer(IAnalyzer):
+    data_group_names = ['group', 'sim_id', 'channel']
+    ordered_levels = ['channel', 'group', 'sim_id']
+    output_file = 'timeseries.csv'
+
+    def __init__(self, filenames=[os.path.join('output', 'InsetChart.json')], channels=('Statistical Population',
+                                                                                        'Infectious Population',
+                                                                                        'Infected',
+                                                                                        'Waning Population'),
+                 save_output=True):
+
+        super(TimeseriesAnalyzer, self).__init__(filenames=filenames)
+        self.channels = set(channels)
+        self.save_output = save_output
+
+    def initialize(self):
+        if not os.path.exists(os.path.join(self.working_dir, "output")):
+            os.mkdir(os.path.join(self.working_dir, "output"))
+
+    def default_select_fn(self, ts):
+        return pd.Series(ts)
+
+    def default_group_fn(self, k, v):
+        return k
+
+    def default_plot_fn(self, df, ax):
+        grouped = df.groupby(level=['group'], axis=1)
+        m = grouped.mean()
+        m.plot(ax=ax, legend=False)
+
+    def default_filter_fn(self, md):
+        return True
+
+    def filter(self, simulation):
+        return self.default_filter_fn(simulation.tags)
+
+    def get_channel_data(self, data_by_channel, selected_channels):
+        channel_series = [self.default_select_fn(data_by_channel[channel]["Data"]) for channel in selected_channels]
+        return pd.concat(channel_series, axis=1, keys=selected_channels)
+
+    def map(self, data, simulation):
+        cdata = data[self.filenames[0]]['Channels']
+        selected_channels = self.channels.intersection(cdata.keys()) if self.channels else cdata.keys()
+        return self.get_channel_data(cdata, selected_channels)
+
+    def plot_by_channel(self, channels, plot_fn):
+
+        import matplotlib.pyplot as plt
+
+        ncol = int(1 + len(channels) / 4)
+        nrow = int(np.ceil(float(len(channels)) / ncol))
+
+        fig, axs = plt.subplots(figsize=(max(6, min(8, 4 * ncol)), min(6, 3 * nrow)), nrows=nrow, ncols=ncol,
+                                sharex=True)
+
+        flat_axes = [axs] if ncol * nrow == 1 else axs.flat
+        for (channel, ax) in zip(channels, flat_axes):
+            ax.set_title(channel)
+            plot_fn(channel, ax)
+
+    def reduce(self, all_data):
+        output_dir = os.path.join(self.working_dir, "output")
+        selected = []
+        for sim, data in all_data.items():
+            # Enrich the data with info
+            data.group = self.default_group_fn(sim.uid, sim.tags)
+            data.sim_id = sim.uid
+            selected.append(data)
+
+        if len(selected) == 0:
+            print("\n No data have been returned... Exiting...")
+            return
+
+        # Combining selected data...
+        combined = pd.concat(selected, axis=1,
+                             keys=[(d.group, d.sim_id) for d in selected],
+                             names=self.data_group_names)
+
+        # Re-ordering multi-index levels...
+        data = combined.reorder_levels(self.ordered_levels, axis=1).sort_index(axis=1)
+
+        if self.save_output:
+            data.to_csv(os.path.join(output_dir, self.output_file))
+
+        def plot_fn(channel, ax):
+            self.default_plot_fn(data[channel].dropna(), ax)
+
+        channels = data.columns.levels[0]
+        self.plot_by_channel(channels, plot_fn)
+
+        plt.legend()
+        # plt.show()
+        plt.savefig(os.path.join(output_dir, 'timeseries.png'))
+
+
+if __name__ == "__main__":
+    platform = Platform('COMPS2')
+
+    exp_id = '8a7ff62a-fe7f-ea11-a2bf-f0921c167862'  # comps2 exp_id
+
+    filenames = ['output/InsetChart.json']
+    analyzers = [TimeseriesAnalyzer(filenames=filenames)]
+
+    manager = AnalyzeManager(platform=platform, ids=[(exp_id, ItemType.EXPERIMENT)], analyzers=analyzers)
+    manager.analyze()

emodpy/collections_utils.py

@@ -0,0 +1,92 @@
+from typing import Tuple, List, Mapping, Union, Iterable
+
+from more_itertools import take
+
+
+def cut_iterable_to(obj: Iterable, to: int) -> Tuple[Union[List, Mapping], int]:
+    """
+       Cut an iterable to a certain length.
+
+    Args:
+        obj: The iterable to cut.
+        to: The number of elements to return.
+
+    Returns:
+        A list or dictionary (depending on the type of object) of elements and
+        the remaining elements in the original list or dictionary.
+    """
+    if isinstance(obj, dict):
+        slice = {k: v for (k, v) in take(to, obj.items())}
+    else:
+        slice = take(to, obj)
+
+    remaining = len(obj) - to
+    remaining = 0 if remaining < 0 else remaining
+    return slice, remaining
+
+
+####
+# DicDeep v2
+# https://github.com/mbello/dict-deep/blob/master/dict_deep/dict_deep.py
+def deep_get(d, key, default: callable = None, getter: callable = None, sep: str = '.'):
+    getter = __getter(getter, default)
+    keys = __keys(key, sep)
+
+    for k in keys:
+        d = getter(d, k)
+
+    return d
+
+
+def deep_set(d, key, value, default: callable = None, getter: callable = None, setter: callable = None, sep: str = '.'):
+    keys = __keys(key, sep)
+    getter = __getter(getter, default)
+    setter = __setter(setter)
+
+    for i in range(len(keys) - 1):
+        d = getter(d, keys[i])
+
+    setter(d, keys[-1], value)
+
+
+def deep_del(d: dict, key, getter: callable = None, deleter: callable = None, sep: str = '.'):
+    keys = __keys(key, sep)
+    getter = getter if getter is not None else lambda o, k: o.get(k)
+
+    for i in range(len(keys) - 1):
+        if d is None:
+            return False, None
+        d = getter(d, keys[i])
+
+    if d is not None and isinstance(d, dict) and keys[-1] in d:
+        retval = getter(d, keys[-1])
+        if deleter is None:
+            del d[keys[-1]]
+        else:
+            deleter(d, keys[-1])
+        return True, retval
+    else:
+        return False, None
+
+
+def __keys(key, sep: str):
+    if isinstance(key, str):
+        return key.split(sep=sep)
+    else:
+        return list(key)
+
+
+def __getter(getter: callable, default: callable):
+    if getter is not None:
+        return getter
+    elif default is not None:
+        return lambda o, k: o.setdefault(k, default())
+    else:
+        return lambda o, k: o[k]
+
+
+def __setter(setter: callable):
+    def __default_setter(o, k, v):
+        o[k] = v
+
+    return setter if setter is not None else __default_setter

emodpy/defaults/__init__.py

@@ -0,0 +1,2 @@
+# flake8: noqa F821
+from emodpy.defaults.emod_sir import EMODSir

emodpy/defaults/emod_sir.py

@@ -0,0 +1,195 @@
+from typing import Dict
+from emodpy.defaults.iemod_default import IEMODDefault
+from emodpy.emod_campaign import EMODCampaign
+
+
+class EMODSir(IEMODDefault):
+    @staticmethod
+    def config(erad_path) -> Dict:
+        return {
+            "Acquisition_Blocking_Immunity_Decay_Rate": 0.1,
+            "Acquisition_Blocking_Immunity_Duration_Before_Decay": 60,
+            "Age_Initialization_Distribution_Type": "DISTRIBUTION_SIMPLE",
+            "Animal_Reservoir_Type": "NO_ZOONOSIS",
+            "Base_Incubation_Period": 0,
+            "Base_Individual_Sample_Rate": 1,
+            "Base_Infectious_Period": 4,
+            "Base_Infectivity": 3.5,
+            "Base_Mortality": 0,
+            "Base_Population_Scale_Factor": 1,
+            "Birth_Rate_Dependence": "POPULATION_DEP_RATE",
+            "Birth_Rate_Time_Dependence": "NONE",
+            "Burnin_Cache_Mode": "none",
+            "Burnin_Cache_Period": 0,
+            "Burnin_Name": "",
+            "Campaign_Filename": "campaign.json",
+            "Climate_Model": "CLIMATE_OFF",
+            "Config_Name": "01_SIR",
+            "Custom_Coordinator_Events": [],
+            "Custom_Individual_Events": [],
+            "Custom_Node_Events": [],
+            "Custom_Reports_Filename": "NoCustomReports",
+            "Default_Geography_Initial_Node_Population": 1000,
+            "Default_Geography_Torus_Size": 10,
+            "Demographics_Filenames": ["generic_scenarios_demographics.json"],
+            "Enable_Default_Reporting": 1,
+            "Enable_Default_Shedding_Function": 1,
+            "Enable_Demographics_Birth": 0,
+            "Enable_Demographics_Builtin": 0,
+            "Enable_Demographics_Gender": 1,
+            "Enable_Demographics_Other": 0,
+            "Enable_Demographics_Reporting": 1,
+            "Enable_Disease_Mortality": 0,
+            "Enable_Heterogeneous_Intranode_Transmission": 0,
+            "Enable_Immune_Decay": 0,
+            "Enable_Immunity": 1,
+            "Enable_Infectivity_Reservoir": 0,
+            "Enable_Initial_Prevalence": 0,
+            "Enable_Infectivity_Scaling": 0,
+            "Enable_Initial_Susceptibility_Distribution": 0,
+            "Enable_Interventions": 1,
+            "Enable_Maternal_Transmission": 0,
+            "Enable_Maternal_Protection": 0,
+            "Enable_Property_Output": 0,
+            "Enable_Skipping": 0,
+            "Enable_Spatial_Output": 0,
+            "Enable_Strain_Tracking": 0,
+            "Enable_Superinfection": 0,
+            "Enable_Susceptibility_Scaling": 0,
+            "Enable_Termination_On_Zero_Total_Infectivity": 0,
+            "Enable_Vital_Dynamics": 0,
+            "Geography": "SamplesInput",
+            "Immunity_Acquisition_Factor": 0,
+            "Immunity_Initialization_Distribution_Type": "DISTRIBUTION_OFF",
+            "Immunity_Mortality_Factor": 0,
+            "Immunity_Transmission_Factor": 0,
+            "Incubation_Period_Constant": 0,
+            "Incubation_Period_Distribution": "CONSTANT_DISTRIBUTION",
+            "Individual_Sampling_Type": "TRACK_ALL",
+            "Infection_Updates_Per_Timestep": 1,
+            "Infectious_Period_Exponential": 4,
+            "Infectious_Period_Distribution": "EXPONENTIAL_DISTRIBUTION",
+            "Infectivity_Scale_Type": "CONSTANT_INFECTIVITY",
+            "Job_Node_Groups": "Chassis08",
+            "Job_Priority": "BELOWNORMAL",
+            "Listed_Events": [],
+            "Load_Balance_Filename": "",
+            "Local_Simulation": 0,
+            "Maternal_Transmission_Probability": 0,
+            "Max_Individual_Infections": 1,
+            "Max_Node_Population_Samples": 40,
+            "Migration_Model": "NO_MIGRATION",
+            "Minimum_Adult_Age_Years": 15,
+            "Mortality_Blocking_Immunity_Decay_Rate": 0.001,
+            "Mortality_Blocking_Immunity_Duration_Before_Decay": 60,
+            "Mortality_Time_Course": "DAILY_MORTALITY",
+            "Node_Grid_Size": 0.042,
+            "Num_Cores": 1,
+            "Number_Basestrains": 1,
+            "Number_Substrains": 1,
+            "PKPD_Model": "FIXED_DURATION_CONSTANT_EFFECT",
+            "Population_Density_C50": 30,
+            "Population_Density_Infectivity_Correction": "CONSTANT_INFECTIVITY",
+            "Population_Scale_Type": "USE_INPUT_FILE",
+            "Post_Infection_Acquisition_Multiplier": 0,
+            "Post_Infection_Mortality_Multiplier": 0,
+            "Post_Infection_Transmission_Multiplier": 0,
+            "Report_Coordinator_Event_Recorder": 0,
+            "Report_Event_Recorder": 0,
+            "Report_Node_Event_Recorder": 0,
+            "Report_Surveillance_Event_Recorder": 0,
+            "Run_Number": 1,
+            "Sample_Rate_0_18mo": 1,
+            "Sample_Rate_10_14": 1,
+            "Sample_Rate_15_19": 1,
+            "Sample_Rate_18mo_4yr": 1,
+            "Sample_Rate_20_Plus": 1,
+            "Sample_Rate_5_9": 1,
+            "Sample_Rate_Birth": 1,
+            "Serialization_Type": "NONE",
+            "Simulation_Duration": 90,
+            "Simulation_Timestep": 1,
+            "Simulation_Type": "GENERIC_SIM",
+            "Start_Time": 0,
+            "Susceptibility_Scale_Type": "CONSTANT_SUSCEPTIBILITY",
+            "Symptomatic_Infectious_Offset": 0,
+            "Transmission_Blocking_Immunity_Decay_Rate": 0.1,
+            "Transmission_Blocking_Immunity_Duration_Before_Decay": 60,
+            "x_Air_Migration": 1,
+            "x_Birth": 1,
+            "x_Local_Migration": 1,
+            "x_Other_Mortality": 1,
+            "x_Population_Immunity": 1,
+            "x_Regional_Migration": 1,
+            "x_Sea_Migration": 1,
+            "x_Temporary_Larval_Habitat": 1,
+        }
+
+    @staticmethod
+    def campaign() -> EMODCampaign:
+        return EMODCampaign.load_from_dict(
+            {
+                "Campaign_Name": "Initial Seeding",
+                "Events": [
+                    {
+                        "Event_Coordinator_Config": {
+                            "Demographic_Coverage": 0.0005,
+                            "Intervention_Config": {"Outbreak_Source": "PrevalenceIncrease", "class": "OutbreakIndividual"},
+                            "class": "StandardInterventionDistributionEventCoordinator",
+                        },
+                        "Event_Name": "Outbreak",
+                        "Nodeset_Config": {"class": "NodeSetAll"},
+                        "class": "CampaignEvent",
+                    }
+                ],
+                "Use_Defaults": 1,
+            }
+        )
+
+    @staticmethod
+    def demographics() -> Dict:
+        nodes = [
+            (0, 0.3, 311),
+            (0, 0.2, 511),
+            (0, 0.1, 711),
+            (0.1, 0.3, 911),
+            (0.1, 0.2, 1111),
+            (0.1, 0.1, 1311),
+            (0.2, 0.3, 1511),
+            (0.2, 0.2, 1711),
+            (0.2, 0.1, 1911),
+        ]
+
+        return {
+            "generic_scenarios_demographics.json": {
+                "Metadata": {
+                    "DateCreated": "Mon Nov 4 07:00:00 2019",
+                    "Tool": "notepad",
+                    "Author": "YeChen",
+                    "IdReference": "0",
+                    "NodeCount": 9,
+                    "Resolution": 150,
+                },
+                "Defaults": {
+                    "NodeAttributes": {"Altitude": 0, "Airport": 0, "Region": 1, "Seaport": 0, "BirthRate": 0.0, "InitialPopulation": 0},
+                    "IndividualAttributes": {
+                        "AgeDistributionFlag": 1,
+                        "AgeDistribution1": 0.0,
+                        "AgeDistribution2": 43800.0,
+                        "PrevalenceDistributionFlag": 0,
+                        "PrevalenceDistribution1": 0.0,
+                        "PrevalenceDistribution2": 0.0,
+                        "SusceptibilityDistributionFlag": 0,
+                        "SusceptibilityDistribution1": 1,
+                        "SusceptibilityDistribution2": 0,
+                        "RiskDistributionFlag": 0,
+                        "RiskDistribution1": 1,
+                        "RiskDistribution2": 0,
+                        "MigrationHeterogeneityDistributionFlag": 2,
+                        "MigrationHeterogeneityDistribution1": 15,
+                        "MigrationHeterogeneityDistribution2": 5,
+                    },
+                },
+                "Nodes": [{"NodeID": i + 1, "NodeAttributes": {"Longitude": n[0], "Latitude": n[1], "InitialPopulation": n[2]}} for i, n in enumerate(nodes)],
+            }
+        }

emodpy/defaults/ep4/dtk_in_process.py

@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+import os
+import sys
+
+CURRENT_DIRECTORY = os.path.dirname(__file__)
+LIBRARY_PATH = os.path.join(CURRENT_DIRECTORY, "..", "site-packages")  # Need to site_packages level!!!
+sys.path.insert(0, LIBRARY_PATH)  # Very Important!
+
+# import emod_api.config as conf
+# import emod_api.campaign as camp
+# import emod_api.demographics as demo
+# import emod_api.migration as mig
+# import emod_api.weather as clim
+# import emod_api.serialization as serial
+
+
+def application(timestep):
+    print(f"Hello from dtk_in_process.py at timestep {timestep}.")
+    return ""

emodpy/defaults/ep4/dtk_post_process.py

@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+import os
+import sys
+import emod_api.config.dtk_post_process_adhocevents as dpp
+
+CURRENT_DIRECTORY = os.path.dirname(__file__)
+LIBRARY_PATH = os.path.join(CURRENT_DIRECTORY, "..", "site-packages")  # Need to site_packages level!!!
+sys.path.insert(0, LIBRARY_PATH)  # Very Important!
+
+# import emod_api.channelreports as emod_json
+# import emod_api.spatialreports as spat
+# import emod_api.tabularoutput as emod_csv
+
+
+def application(output_path):
+    if os.path.exists("config_xform.json") is False:
+        return
+    dpp.application(output_path)
+    print("dtk_post_process.py ran!")

emodpy/defaults/ep4/dtk_pre_process.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python
+
+import os
+# import sys
+import json
+
+# CURRENT_DIRECTORY = os.path.dirname(__file__)
+# LIBRARY_PATH = os.path.join(CURRENT_DIRECTORY, "..", "site-packages")  # Need to site_packages level!!!
+# sys.path.insert(0, LIBRARY_PATH)  # Very Important!
+
+# import emod_api.config.dtk_pre_process_adhocevents as adhoc  # the code in this emod_api submodule should be updated then we can use it instad of having our own modified version.
+
+
+def convert_plugin_reports(config_json):
+    # Could do a nifty for loop but obsessing about copy-pasting can sometimes lead to unnecessarily opaque code
+    crf = ""
+    if "Custom_Reports_Filename" in config_json["parameters"]:
+        crf = config_json["parameters"]["Custom_Reports_Filename"]
+    if os.path.exists(crf):
+        report_json = None
+        with open(crf) as crf_handle:
+            # could just read string, do replace, and write string but seems nasty to skip json parsing....
+            report_json_str = json.dumps(json.load(crf_handle))
+            event_map = config_json["parameters"]["Event_Map"]
+            for replacement, event in event_map.items():
+                report_json_str = report_json_str.replace(f'"{event}"', f'"{replacement}"')
+            report_json = json.loads(report_json_str)
+
+        with open("custom_reports_xform.json", "w") as report_json_handle:
+            report_json_handle.write(json.dumps(report_json, sort_keys=True, indent=4))
+
+        config_json["parameters"]["Custom_Reports_Filename"] = "custom_reports_xform.json"
+
+    return config_json
+
+
+def application(json_config_path):
+    # Check if config.json has "Adhoc_Events". If so, process
+    config_json = json.load(open(json_config_path, "r"))
+    # campaign is written with GP_EVENT_XXX's but custom_reports need to be modified.
+    if "Event_Map" in config_json["parameters"] and len(config_json["parameters"]["Event_Map"]) > 0:
+        event_map = config_json["parameters"]["Event_Map"]
+        config_json = convert_plugin_reports(config_json)
+
+        config_json_str = json.dumps(config_json)
+        for replacement, event in event_map.items():
+            config_json_str = config_json_str.replace(f'"{event}"', f'"{replacement}"')
+        config_json = json.loads(config_json_str)
+        config_json["parameters"]["Event_Map"] = event_map
+        with open("config_xform.json", "w") as new_config:
+            json.dump(config_json, new_config)
+        return "config_xform.json"
+        # return adhoc.do_mapping_from_events( json_config_path, adhoc_events )
+    else:
+        return json_config_path

emodpy/defaults/iemod_default.py

@@ -0,0 +1,20 @@
+from abc import ABCMeta
+from typing import Dict
+
+from emodpy.emod_campaign import EMODCampaign
+
+
+class IEMODDefault(metaclass=ABCMeta):
+    def config(self, erad_path) -> Dict:
+        return {}
+
+    def campaign(self) -> Dict:
+        return EMODCampaign()
+
+    def demographics(self) -> Dict:
+        return {}
+
+    def process_simulation(self, simulation):
+        simulation.campaign = self.campaign()
+
+        simulation.config = self.config()