init_components.py

import pandas as pd
from ....utils.path import init_dir
from .fetch import default_fetch
from logging import warning


def init_components(plugin):
    if hasattr(plugin, "components"):
        components = plugin.components
        for comp in components.attributes:
            component = getattr(components, comp)

            # Fetch parameters
            # If no parameters, handle the component as a whole
            if not hasattr(component, "parameters"):
                params = component
                parameters = [""]
            else:
                params = component.parameters
                parameters = params.attributes[:] + [""]

            # Loop over parameters to fetch information
            for trcr in parameters:
                tracer = getattr(params, trcr, component)

                # By default is not in the target vector, nor in the obs vector
                tracer.iscontrol = getattr(tracer, "iscontrol", False)
                tracer.isobs = getattr(tracer, "isobs", False)

                # Fetch reference directory and file format
                # Replace value in parameter by value in component if no 
                # value was specified explicitly in the yaml (= is_default)
                for attr in ["dir", "file", "file_freq"]:
                    if hasattr(tracer, attr) \
                            and attr in tracer.is_default_value:
                        if hasattr(component, attr) \
                                and attr not in component.is_default_value:
                            setattr(tracer, attr, getattr(component, attr))
                    elif not hasattr(tracer, attr):
                        if hasattr(component, attr):
                            setattr(tracer, attr, getattr(component, attr))
                        elif attr != "file_freq":
                            setattr(tracer, attr, "")

                # Fetch reference functions from the component
                for attr in ["read", "write", "fetch"]:
                    if not hasattr(tracer, attr) \
                            or attr in tracer.is_default_value:
                        if hasattr(component, attr):
                            setattr(tracer, attr, getattr(component, attr))
                        else:
                            if attr == "fetch":
                                setattr(tracer, attr, default_fetch)
                            else:
                                setattr(tracer, attr, None)
    
                tracer.varname = getattr(tracer, "varname", "")
                
                # Initializes target directory and pass info to tracer
                target_dir = "{}/datavect/{}/{}/".format(
                    plugin.workdir, comp, trcr
                )
                init_dir(target_dir)

                tracer.orig_dir = tracer.dir
                tracer.dir = target_dir
                
                # Fetch files and dates
                if tracer.fetch is not None:
                    try:
                        list_files, list_dates = tracer.fetch(
                            tracer.orig_dir,
                            tracer.file,
                            [plugin.datei, plugin.datef],
                            target_dir,
                            component=component,
                            tracer=tracer,
                        )
                    except Exception as e:
                            raise e

                    # Crop files and dates depending on global datei and datef
                    try:
                        list_files = {
                            ddi: [
                                ff for ff, dd
                                in zip(list_files[ddi], list_dates[ddi])
                                if dd[0] <= plugin.datef
                                   and dd[1] >= plugin.datei
                            ]
                            for ddi in list_files}
                        list_dates = {
                            ddi: [dd for dd in list_dates[ddi]
                                  if dd[0] <= plugin.datef
                                  and dd[1] >= plugin.datei
                            ]
                            for ddi in list_dates}
                    except Exception as e:
                        print(e)
                        pass
                    
                    # Clean empty periods
                    # Make sure that periods are datetime objects
                    list_files = {
                         pd.DatetimeIndex([ddi]).to_pydatetime()[0]:
                             list_files[ddi] for ddi in list_files
                        # if list_dates[ddi] != []
                    }
                    list_dates = {
                        pd.DatetimeIndex([ddi]).to_pydatetime()[0]:
                            list_dates[ddi] for ddi in list_dates
                        # if list_dates[ddi] != []
                    }

                    # Attach info to the tracer
                    tracer.input_dates = list_dates
                    tracer.input_files = list_files

                    # Saving tracer_dir into component dir
                    # if not already available
                    if not hasattr(component, "input_dates"):
                        component.input_dates = list_dates
                    if not hasattr(component, "input_files"):
                        component.input_files = list_files
                        
                # Get the domain and
                # change it to the domain side if lateral conditions
                if hasattr(tracer, "domain"):
                    continue

                if hasattr(tracer, "get_domain"):
                    tracer.domain = tracer.get_domain(
                        tracer.orig_dir,
                        tracer.file,
                        plugin.model.input_dates,
                        target_dir,
                        tracer=tracer,
                    )

                else:
                    tracer.domain = plugin.domain
                
                # Pass arguments from root component to tracers if not
                # explicitly defined
                for attr in component.attributes:
                    if attr != "plugin" and not hasattr(tracer, attr):
                        setattr(tracer, attr, getattr(component, attr))