corebridge 0.2.24__py3-none-any.whl

corebridge/__init__.py

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

corebridge/_modidx.py

@@ -0,0 +1,64 @@
+# Autogenerated by nbdev
+
+d = { 'settings': { 'branch': 'main',
+                'doc_baseurl': '/corebridge',
+                'doc_host': 'https://fenke.github.io',
+                'git_url': 'https://github.com/fenke/corebridge',
+                'lib_path': 'corebridge'},
+  'syms': { 'corebridge.aicorebridge': { 'corebridge.aicorebridge.AICoreModule': ( 'aicorebridge.html#aicoremodule',
+                                                                                   'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.AICoreModule.__init__': ( 'aicorebridge.html#aicoremodule.__init__',
+                                                                                            'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.AICoreModule._init_processor': ( 'aicorebridge.html#aicoremodule._init_processor',
+                                                                                                   'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.AICoreModule.call_processor': ( 'aicorebridge.html#aicoremodule.call_processor',
+                                                                                                  'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.AICoreModule.get_call_data': ( 'aicorebridge.html#aicoremodule.get_call_data',
+                                                                                                 'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.AICoreModule.get_callargs': ( 'aicorebridge.html#aicoremodule.get_callargs',
+                                                                                                'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.AICoreModule.infer': ( 'aicorebridge.html#aicoremodule.infer',
+                                                                                         'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.AICoreModule.init_annotated_param': ( 'aicorebridge.html#aicoremodule.init_annotated_param',
+                                                                                                        'corebridge/aicorebridge.py'),
+                                         'corebridge.aicorebridge.build_historic_args': ( 'aicorebridge.html#build_historic_args',
+                                                                                          'corebridge/aicorebridge.py')},
+            'corebridge.core': { 'corebridge.core.init_console_logging': ('core.html#init_console_logging', 'corebridge/core.py'),
+                                 'corebridge.core.pop_nan_values': ('core.html#pop_nan_values', 'corebridge/core.py'),
+                                 'corebridge.core.set_time_index_zone': ('core.html#set_time_index_zone', 'corebridge/core.py'),
+                                 'corebridge.core.timeseries_dataframe': ('core.html#timeseries_dataframe', 'corebridge/core.py'),
+                                 'corebridge.core.timeseries_dataframe_from_datadict': ( 'core.html#timeseries_dataframe_from_datadict',
+                                                                                         'corebridge/core.py'),
+                                 'corebridge.core.timeseries_dataframe_resample': ( 'core.html#timeseries_dataframe_resample',
+                                                                                    'corebridge/core.py'),
+                                 'corebridge.core.timeseries_dataframe_to_datadict': ( 'core.html#timeseries_dataframe_to_datadict',
+                                                                                       'corebridge/core.py')},
+            'corebridge.rscript': { 'corebridge.rscript.calc_hash_from_data_files': ( 'rscriptbridge.html#calc_hash_from_data_files',
+                                                                                      'corebridge/rscript.py'),
+                                    'corebridge.rscript.calc_hash_from_files': ( 'rscriptbridge.html#calc_hash_from_files',
+                                                                                 'corebridge/rscript.py'),
+                                    'corebridge.rscript.calc_hash_from_flowobject': ( 'rscriptbridge.html#calc_hash_from_flowobject',
+                                                                                      'corebridge/rscript.py'),
+                                    'corebridge.rscript.calc_hash_from_input_files': ( 'rscriptbridge.html#calc_hash_from_input_files',
+                                                                                       'corebridge/rscript.py'),
+                                    'corebridge.rscript.check_rscript_lib': ( 'rscriptbridge.html#check_rscript_lib',
+                                                                              'corebridge/rscript.py'),
+                                    'corebridge.rscript.check_rscript_libs': ( 'rscriptbridge.html#check_rscript_libs',
+                                                                               'corebridge/rscript.py'),
+                                    'corebridge.rscript.check_script_inputs': ( 'rscriptbridge.html#check_script_inputs',
+                                                                                'corebridge/rscript.py'),
+                                    'corebridge.rscript.check_script_output': ( 'rscriptbridge.html#check_script_output',
+                                                                                'corebridge/rscript.py'),
+                                    'corebridge.rscript.generate_checksum_file': ( 'rscriptbridge.html#generate_checksum_file',
+                                                                                   'corebridge/rscript.py'),
+                                    'corebridge.rscript.get_asset_path': ('rscriptbridge.html#get_asset_path', 'corebridge/rscript.py'),
+                                    'corebridge.rscript.get_rscript_env': ('rscriptbridge.html#get_rscript_env', 'corebridge/rscript.py'),
+                                    'corebridge.rscript.get_rscript_libpath': ( 'rscriptbridge.html#get_rscript_libpath',
+                                                                                'corebridge/rscript.py'),
+                                    'corebridge.rscript.get_save_path': ('rscriptbridge.html#get_save_path', 'corebridge/rscript.py'),
+                                    'corebridge.rscript.install_R_package_wait': ( 'rscriptbridge.html#install_r_package_wait',
+                                                                                   'corebridge/rscript.py'),
+                                    'corebridge.rscript.run_rscript_nowait': ( 'rscriptbridge.html#run_rscript_nowait',
+                                                                               'corebridge/rscript.py'),
+                                    'corebridge.rscript.run_rscript_wait': ( 'rscriptbridge.html#run_rscript_wait',
+                                                                             'corebridge/rscript.py')}}}

corebridge/aicorebridge.py

@@ -0,0 +1,278 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01_aicorebridge.ipynb.
+
+# %% auto 0
+__all__ = ['syslog', 'annotated_arg_builders', 'build_historic_args', 'AICoreModule']
+
+# %% ../nbs/01_aicorebridge.ipynb 4
+import typing
+import logging
+import traceback
+import inspect
+import datetime
+import json
+import os
+import pandas, pandas as pd
+import numpy, numpy as np
+
+from dateutil import parser
+from fastcore.basics import patch_to, patch
+from .core import *
+from . import __version__
+
+
+# %% ../nbs/01_aicorebridge.ipynb 5
+syslog = logging.getLogger(__name__)
+
+# %% ../nbs/01_aicorebridge.ipynb 6
+try:
+    print(f"Loading {__name__} {__version__} from {__file__}")
+except:
+    pass
+
+# %% ../nbs/01_aicorebridge.ipynb 8
+def build_historic_args(data:pd.DataFrame, history:dict|list) -> dict:
+    """Create a timeseries DataFrame from historic data defined in `history`.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        The input time-series DataFrame.
+    history : dict or list of dicts
+        Historic data definition, each item in the list is a dictionary with a startDate key to set the start of a section of historic data in the result and a column-value pair for each of the columns in the 
+
+    Returns
+    -------
+    historic_data : dict
+        Historic data in dictionary format where keys are column names and values are the historic values as numpy array.
+    """
+
+    if not history:
+        return {}
+    
+    if isinstance(history, dict):
+        return history
+    
+    if not isinstance(history, list):
+        return {}
+    
+    if isinstance(data, pd.DataFrame):
+        dates = data.index.astype(np.int64).astype(np.float64) / 1e9
+        dates = dates.to_numpy()
+    elif data.dtype.names is not None:
+        dates = data.view(dtype=np.float64).reshape(data.shape[0],len(data.dtype))[:,0]
+    else:
+        dates = data[:,0]
+    dates = dates.astype(np.int64)
+    
+    columns = list(set([K for I in history for K in I.keys() if K != 'startDate']))
+    column_data = {K:np.full(len(dates), np.nan, dtype=np.float64) for K in columns}
+
+    for I in history:
+        date = parser.parse(str((I.pop('startDate','2000-01-01T00:00:00+00:00')))).timestamp()
+        mask = np.greater_equal(dates, date)
+        for K,V in I.items():
+            column_data[K][mask] = V
+    
+    return column_data
+    #return pd.DataFrame(column_data, index=data.index)
+
+
+# %% ../nbs/01_aicorebridge.ipynb 12
+class AICoreModule(): pass
+
+# %% ../nbs/01_aicorebridge.ipynb 13
+@patch
+def __init__(self:AICoreModule, 
+             processor:typing.Callable, # data processing function
+             save_dir:str, # path where the module can keep files 
+             assets_dir:str,
+             *args, **kwargs):
+    
+    self.init_time = datetime.datetime.now(datetime.UTC)
+    self._init_processor(processor)
+
+    self.init_args = args
+    self.init_kwargs = dict(
+        **kwargs,
+        assets_dir=assets_dir,
+        save_dir=save_dir
+    )
+
+
+
+# %% ../nbs/01_aicorebridge.ipynb 14
+@patch
+def _init_processor(
+        self:AICoreModule, 
+        processor:typing.Callable):
+    """Initializes processor related variables on self"""
+    
+    self.processor = processor
+    self.processor_signature = inspect.signature(self.processor)
+    self.processor_params = dict(self.processor_signature.parameters)
+    self.return_param = self.processor_params.pop('return', None)
+    self.data_param, *self.call_params = list(self.processor_params.keys())
+
+
+# %% ../nbs/01_aicorebridge.ipynb 15
+# can be overloaded
+@patch
+def call_processor(self:AICoreModule, calldata, **callargs):
+    return self.processor(calldata, **callargs)
+
+
+# %% ../nbs/01_aicorebridge.ipynb 17
+@patch
+def infer(self:AICoreModule, data:dict, *_, **kwargs):
+    try:
+
+        msg=[
+            f"Startup time: {self.init_time.isoformat()}",
+            f"{self.processor.__name__}({self.processor_signature})",             
+            f"init_args: {self.init_args}, init_kwargs: {self.init_kwargs}",
+        ]
+
+        # Pickup params, pop those that are not intended for the processor
+        lastSeen = kwargs.pop('lastSeen', False)
+        recordformat = kwargs.pop('format', "records").lower()
+        timezone = kwargs.get('timezone', 'UTC')
+        msg.append(f"lastSeen: {lastSeen}, recordformat: {recordformat}, timezone: {timezone}")
+
+        samplerPeriod = kwargs.pop('samplerPeriod', self.init_kwargs.get('samplerPeriod','h'))
+        samplerMethod = kwargs.pop('samplerMethod', self.init_kwargs.get('samplerMethod',None))
+        reversed = kwargs.pop('reversed', False)
+
+        calldata = self.get_call_data(
+            data, 
+            recordformat=recordformat,
+            timezone=timezone)
+        
+        msg.append(f"calldata shape: {calldata.shape}")
+
+        history = build_historic_args(calldata, kwargs.pop('history', {}))
+
+        callargs = self.get_callargs(kwargs, history)
+
+        for arg, val in callargs.items():
+            msg.append(f"{arg}: {val}")
+            
+        result = timeseries_dataframe(
+            self.call_processor(
+                calldata, 
+                **callargs), 
+            timezone=timezone)
+        
+        msg.append(f"result shape: {result.shape}")
+
+        if samplerMethod:
+            msg.append(f"Sampler: {samplerMethod}, period: {samplerPeriod}")
+            result = timeseries_dataframe_resample(result, samplerPeriod, samplerMethod)
+
+        msg.append(f"return-data shape: {result.shape}")
+
+        if reversed:
+            result = result[::-1]
+
+        return {
+            'msg':msg,
+            'data': timeseries_dataframe_to_datadict(
+                result if not lastSeen else result[-1:],
+                recordformat=recordformat,
+                timezone=timezone,
+                popNaN=True)
+        }
+    except Exception as err:
+        msg.append(''.join(traceback.format_exception(None, err, err.__traceback__)))
+        syslog.exception(f"Exception {str(err)} in infer()")
+        return {
+            'msg': f"Unexpected {err=}, {type(err)=}",
+            'data': []
+        }
+
+
+# %% ../nbs/01_aicorebridge.ipynb 19
+# Specialized types for initializing annotated parameters
+# Add types by adding a tuple with the type name and a builder function
+annotated_arg_builders = {
+    str(B[0]):B[1] for B in [
+        (numpy.ndarray, lambda X: numpy.array(X, dtype=X.dtype))
+    ]
+}
+
+# %% ../nbs/01_aicorebridge.ipynb 20
+@patch
+def init_annotated_param(self:AICoreModule, param_name, value):
+    """
+    Initialize argument for the processor call
+    
+    param_name: name of the parameter to be initialized
+    value: value of the parameter read from infer data to be used for initialization
+    
+    """
+
+    annotation = self.processor_signature.parameters[param_name].annotation
+
+    # try to convert value to one of the types in the annotation
+    for T in typing.get_args(annotation):
+        try:
+            builder = annotated_arg_builders.get(str(T), T)
+            return builder(value)
+        except TypeError as err:
+            continue
+    try:
+        return annotation(value)
+    except TypeError as err:
+        syslog.exception(f"Exception {str(err)} in fallback conversion to {annotation} of {type(value)}")
+
+ 
+
+# %% ../nbs/01_aicorebridge.ipynb 21
+@patch
+def get_callargs(self:AICoreModule, kwargs, history):
+    "Get arguments for the processor call"
+
+    # Remove null / None values
+    kwargs = {k:v for k,v in kwargs.items() if v is not None}
+    
+    return {
+        K:self.init_annotated_param(
+            K,
+            history.get(
+                K,
+                self.init_kwargs.get(
+                    K,
+                    kwargs.get(
+                        K, 
+                        self.processor_signature.parameters[K].default
+                    )
+                )
+            )
+        )
+        for K in self.call_params
+    }
+
+
+# %% ../nbs/01_aicorebridge.ipynb 25
+@patch
+def get_call_data(
+        self:AICoreModule, 
+        data:dict, 
+        recordformat='records', 
+        timezone='UTC'):
+    
+    "Convert data to the processor signature"
+
+    df = set_time_index_zone(timeseries_dataframe_from_datadict(
+        data, ['datetimeMeasure', 'time'], recordformat), timezone)
+
+    df.sort_index(inplace=True)
+
+    if self.processor_params[self.data_param].annotation == pd.DataFrame:
+        return df
+    elif len(df.columns) > 1:
+        df.index = (df.index - datetime.datetime(1970,1,1, tzinfo=datetime.timezone.utc)) / datetime.timedelta(seconds=1)
+        return df.to_records(index=True)
+    else:
+        df.index = (df.index - datetime.datetime(1970,1,1, tzinfo=datetime.timezone.utc)) / datetime.timedelta(seconds=1)
+        return df.reset_index().to_numpy()
+        

corebridge/core.py

@@ -0,0 +1,288 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_core.ipynb.
+
+# %% auto 0
+__all__ = ['ResamplerMethods', 'ReSamplerPeriods', 'init_console_logging', 'set_time_index_zone', 'timeseries_dataframe',
+           'timeseries_dataframe_from_datadict', 'pop_nan_values', 'timeseries_dataframe_to_datadict',
+           'timeseries_dataframe_resample']
+
+# %% ../nbs/00_core.ipynb 3
+import typing, logging
+import os
+import numpy as np
+import pandas as pd
+
+# %% ../nbs/00_core.ipynb 4
+def init_console_logging(name=None, level=logging.INFO):
+    '''Setup none-blocking stream handler for sending loggin to the console.'''
+
+    # Only if no handlers defined.
+    if not logging.getLogger(name).handlers:
+
+        logger = logging.getLogger()
+        logger.setLevel(level)
+
+        console = logging.StreamHandler()
+        console.setLevel(level)
+
+        # set a format which is simpler for console use
+        formatter = logging.Formatter("%(asctime)s %(levelname)s\t%(process)d\t%(name)s\t%(filename)s\t%(lineno)d\t%(message)s", datefmt='%Y-%m-%dT%H:%M:%S%z')
+
+        # tell the handler to use this format
+        console.setFormatter(formatter)
+
+        # add the handler to the root logger
+        logger.addHandler(console)
+        return logger
+    else:
+        logging.getLogger(name).info(f'There already is a logger installed for {name}.')
+
+
+# %% ../nbs/00_core.ipynb 5
+try:
+    logging.getLogger(__name__).info(f"Loading {__name__} from {__file__}")
+except:
+    pass
+
+# %% ../nbs/00_core.ipynb 8
+def set_time_index_zone(df:pd.DataFrame, timezone):
+    """
+    Sets the time zone of the index of a pandas DataFrame.
+
+    Args:
+        df (pd.DataFrame): The DataFrame whose index time zone is to be set.
+        timezone (str): The desired time zone.
+
+    Returns:
+        pd.DataFrame: The DataFrame with its index time zone set to the specified time zone.
+
+    Raises:
+        None
+
+    Examples:
+        >>> df = pd.DataFrame({'A': [1, 2, 3]}, index=pd.DatetimeIndex(['2022-01-01', '2022-01-02', '2022-01-03']))
+        >>> set_time_index_zone(df, 'Europe/Berlin')
+                     A
+        2022-01-01  1
+        2022-01-02  2
+        2022-01-03  3
+        DatetimeIndex: 3 entries, 2022-01-01 01:00:00+01:00 to 2022-01-03 01:00:00+01:00
+    """
+    
+    if isinstance(df.index, pd.DatetimeIndex):
+        df.index.name = 'time'
+        if not hasattr(df.index, 'tz')  or not df.index.tz or not df.index.tz:
+            df.index = df.index.tz_localize('UTC').tz_convert(timezone)
+        elif str(df.index.tz) != timezone:
+            df.index = df.index.tz_convert(timezone)
+
+    return df
+
+
+# %% ../nbs/00_core.ipynb 12
+def timeseries_dataframe(
+        data:typing.Union[pd.DataFrame, pd.Series, dict, np.ndarray, np.recarray], 
+        timezone='UTC', 
+        columnnames=None):
+    
+    """Convert various tabular data formats to timeseries DataFrame
+
+    Args:
+        data (Union[pd.DataFrame, pd.Series, dict, np.ndarray, np.recarray]): The input data to be converted.
+        timezone (str, optional): The timezone to set for the index of the DataFrame. Defaults to 'UTC'.
+        columnnames (Optional[List[str]]): The column names to use for the DataFrame. Defaults to None.
+
+    Returns:
+        pd.DataFrame: The converted timeseries DataFrame with the index set to the specified timezone.
+    """
+
+    if isinstance(data, pd.DataFrame):
+        df = data
+
+    elif isinstance(data, pd.Series):
+        df = pd.DataFrame(data)
+
+    elif isinstance(data, dict):
+        # assume a dict/mapping of individual arrays representing timeseries 
+        df = pd.DataFrame({
+            C:pd.Series(data=A[:,1], index=pd.DatetimeIndex(A[:,0]*1e9)) if isinstance(A, np.ndarray) else A
+            for C,A in data.items()
+        })
+
+    elif data.dtype.names is not None:
+        # structured or recarray, we use column names from the recarray
+        df = pd.DataFrame(
+            data=data.view(dtype=np.float64).reshape(data.shape[0],len(data.dtype))[:,range(1,len(data.dtype))],
+            index=pd.DatetimeIndex(data.view(dtype=np.float64).reshape(data.shape[0],len(data.dtype))[:,0] * 1e9),
+            columns=data.dtype.names[1:]
+        )
+
+    else:
+        if data.shape[0] > 0:
+            # column names, either 'value' if there is only one column, or
+            # value_0, value_1 .... value_nn when more the one column is present
+            if data.shape[1]>2:
+                columns=[f"value_{str(i+1)}" for i in range(data.shape[1]-1)] if not columnnames else [f"{str(i)}" for i in columnnames[1:]]
+            else:
+                columns=['value']
+
+            df = pd.DataFrame(
+                data=data[:, 1:],
+                index=pd.DatetimeIndex(data[:,0]*1e9),
+                columns=columns
+            )
+        else:
+            return pd.DataFrame()
+
+    return set_time_index_zone(df, timezone)
+
+# %% ../nbs/00_core.ipynb 15
+def timeseries_dataframe_from_datadict(
+        data:dict, 
+        timecolumns=None,
+        recordformat='records'):
+        
+    """
+    Converts a data dict into a pandas DataFrame based on the specified record format. 
+    Parameters:
+        - data: A dictionary containing the data to convert.
+        - timecolumns: A list of column names to be treated as time columns.
+        - recordformat: A string specifying the format of the data records ('records', 'table', 'split', 'index', 'tight').
+    Returns:
+        - df: A pandas DataFrame with a DatetimeIndex representing the converted data.
+    """
+
+    orient = recordformat.lower()
+    assert orient in ['records', 'table', 'split', 'index', 'tight']
+    assert timecolumns, 'No time columns specified'
+
+    if orient == 'records':
+        # data is a structured ndarray, sequence of tuples or dicts, or DataFrame
+        df = pd.DataFrame.from_records(data)
+        time_columns_in_df = [C for C in df.columns if C in timecolumns]
+        if not  time_columns_in_df:
+            syslog.error(f"No  column in records {df.columns} matches specification in time columns {timecolumns}, assuming first column is time")
+            time_column = df.columns[0]
+        else:
+            time_column = time_columns_in_df[0]
+
+    elif orient == 'table':
+        # data is in pandas table format
+        time_column = data['schema']['primaryKey'][0]
+        df = pd.DataFrame.from_dict(data['data']).set_index(data['schema']['primaryKey'])
+        df.index.name = 'time'
+    else:
+        # data  is formatted according to 'orient' parameter (pandas)
+        df = pd.DataFrame.from_dict(data, orient=orient)
+        time_column = df.index.name
+
+
+    df.columns = list(df.columns)
+    df[time_column] = pd.to_datetime(df[time_column],utc=True,format='ISO8601')
+    df.set_index(time_column, inplace=True)
+    df.index = pd.DatetimeIndex(df.index).round('ms')
+    
+    df.index.name = 'time'
+
+    return df
+
+
+# %% ../nbs/00_core.ipynb 18
+def pop_nan_values(data):
+    """
+    Recursively pop keys with nan values from dict or lists with dicts.
+
+    Args:
+        data (Union[list, dict]): The data to be processed.
+
+    Returns:
+        Union[list, dict]: The processed data with keys with nan values removed.
+    """
+    
+    if isinstance(data, list):
+        return [pop_nan_values(v) for v in data if pd.notnull([v]).any()]
+    elif isinstance(data, dict):
+        return {k:pop_nan_values(v) for k, v in data.items() if pd.notnull([v]).any()}
+    else:
+        return data
+
+# %% ../nbs/00_core.ipynb 19
+def timeseries_dataframe_to_datadict(
+        data:typing.Union[pd.DataFrame, pd.Series, dict], 
+        recordformat:str='records', 
+        timezone:str='UTC',
+        popNaN:bool=False):
+
+    """
+    Convert a timeseries DataFrame or Series into a dictionary representation.
+
+    Args:
+        data (Union[pd.DataFrame, pd.Series, dict]): The input data to be converted. It can be a pandas DataFrame, Series, or a dictionary.
+        recordformat (str, optional): The format of the output records. Defaults to 'records'.
+        timezone (str, optional): The timezone to use for the DataFrame index. Defaults to 'UTC'.
+        popNaN (bool, optional): Whether to remove NaN values from the output dictionary. Defaults to False.
+
+    Returns:
+        Union[dict, list]: The converted dictionary representation of the input data. If `popNaN` is True, it returns a dictionary with NaN values removed. Otherwise, it returns a dictionary or a list of dictionaries depending on the `recordformat` parameter.
+    """
+        
+    orient = recordformat.lower()
+
+    normalized_data = timeseries_dataframe(data, timezone=timezone)
+    if isinstance(normalized_data.index, pd.DatetimeIndex):
+        normalized_data.index = normalized_data.index.map(lambda x: x.isoformat())
+    
+    if orient == 'records':
+        records = normalized_data.reset_index().to_dict(orient='records')
+    else:
+        records =  normalized_data.to_dict(orient=orient)
+
+    if popNaN and normalized_data.isna().any(axis=None):
+            return pop_nan_values(records)
+    
+    return records    
+
+
+# %% ../nbs/00_core.ipynb 26
+#def interpolate_timeseries(sampler, period, method_args):
+
+
+ResamplerMethods = dict(
+    count=lambda R: R.count(),
+    median=lambda R: R.median(),
+    mean=lambda R: R.mean(),
+    min=lambda R: R.min(),
+    max=lambda R: R.max(),
+    sum=lambda R: R.sum(),
+    std=lambda R: R.std(),
+    var=lambda R: R.var(),
+    nearest=lambda R: R.nearest(),
+)
+
+ReSamplerPeriods = dict(
+    H='h', T='min', S='sec', L='ms', U='us', N='ns'
+)
+
+def timeseries_dataframe_resample(df:pd.DataFrame, period:str, method:str):
+    """
+    Resamples a time-series DataFrame on the specified period and method.
+
+    Parameters:
+        df (pd.DataFrame): The input time-series DataFrame.
+        period (str): The resampling period.
+        method (str): The resampling method. Can be a string of multiple methods separated by ';'.
+        method_args (dict, optional): Additional arguments for the resampling method.
+
+    Returns:
+        pd.DataFrame: The resampled DataFrame.
+    """
+    sampler = df.resample(ReSamplerPeriods.get(period, str(period)))
+
+    dataframes = [df]
+    for M in str(method).split(';'):
+        sdf = ResamplerMethods.get(M)(sampler)
+        sdf.columns = [f"{C}_{M}" for C in df.columns]
+        dataframes.append(sdf)
+
+    return pd.concat(dataframes, axis=1, join='outer')
+
+