def init(self):
TemplateNodeMixin.init(self)
self.COV_IN = 'covariance_df'
self.ORDER_IN = 'asset_order_df'
self.OUTPUT_PORT_NAME = 'out'
self.delayed_process = True
self.infer_meta = False
port_type = PortsSpecSchema.port_type
port_inports = {
self.COV_IN: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.ORDER_IN: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:covariance_df}"
},
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'importance_curve'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: ["xgboost.Booster", "builtins.dict"]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: ["matplotlib.figure.Figure"]
}
}
cols_required = {}
retension = {}
meta_inports = {self.INPUT_PORT_NAME: cols_required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: retension
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'out'
self.delayed_process = True
self.infer_meta = False
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {self.OUTPUT_PORT_NAME: {port_type: "${port:in}"}}
cols_required = {
'sample_id': 'int64',
'year': 'int16',
'month': 'int16',
}
meta_inports = {self.INPUT_PORT_NAME: cols_required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: {}
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {self.OUTPUT_PORT_NAME: {port_type: "${port:in}"}}
name = self.conf.get('sign', 'sign')
addition = {name: "int64"}
cols_required = {}
meta_inports = {self.INPUT_PORT_NAME: cols_required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: addition
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {self.OUTPUT_PORT_NAME: {port_type: "${port:in}"}}
cols_required = {"asset": "int64"}
if 'column' in self.conf:
retention = {self.conf['column']: "float64", "asset": "int64"}
else:
retention = {"asset": "int64"}
meta_inports = {self.INPUT_PORT_NAME: cols_required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: retention
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.delayed_process = True
self.infer_meta = False
self.SIGNAL_DF = 'signal_df'
self.FEATURE_DF = 'feature_df'
self.OUTPUT_PORT_NAME = 'out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.SIGNAL_DF: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.FEATURE_DF: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
],
PortsSpecSchema.optional: True
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:signal_df}"
},
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'stock_in'
self.OUTPUT_PORT_NAME = 'stock_out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:stock_in}"
}
}
cols_required = {'predict': None, "asset": "int64"}
addition = {}
addition['signal'] = 'float64'
meta_inports = {self.INPUT_PORT_NAME: cols_required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: addition
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'df_in'
self.OUTPUT_PORT_NAME = 'df_out'
self.INPUT_NORM_MODEL_NAME = 'norm_data_in'
self.OUTPUT_NORM_MODEL_NAME = 'norm_data_out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.INPUT_NORM_MODEL_NAME: {
port_type: [
"greenflow_gquant_plugin.transform.data_obj.NormalizationData" # noqa
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:df_in}"
},
self.OUTPUT_NORM_MODEL_NAME: {
port_type: [
"greenflow_gquant_plugin.transform.data_obj.NormalizationData" # noqa
]
},
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_LEFT_NAME = 'left'
self.INPUT_PORT_RIGHT_NAME = 'right'
self.OUTPUT_PORT_NAME = 'merged'
self.delayed_process = True
self.infer_meta = False
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_LEFT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.INPUT_PORT_RIGHT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:left}"
},
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: ["pandas.DataFrame", "cudf.DataFrame"]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "builtins.float"
},
}
meta_inports = {self.INPUT_PORT_NAME: {}}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: {}
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.delayed_process = True
self.INPUT_PORT_NAME = 'stock_in'
self.OUTPUT_PORT_NAME = 'stock_out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:stock_in}"
}
}
cols_required = {'indicator': 'int32'}
addition = {}
if 'indicators' in self.conf:
indicators = self.conf['indicators']
for indicator in indicators:
functionId = indicator['function']
conf = copy.deepcopy(IN_DATA[functionId])
if 'args' in indicator:
if len(conf['args']) != 0:
conf['args'] = indicator['args']
if 'columns' in indicator:
conf['columns'] = indicator['columns']
for col in conf['columns']:
cols_required[col] = 'float64'
if 'outputs' in conf:
for out in conf['outputs']:
out_col = self._compose_name(conf, [out])
addition[out_col] = 'float64'
else:
out_col = self._compose_name(conf, [])
addition[out_col] = 'float64'
meta_inports = {
self.INPUT_PORT_NAME: cols_required
}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: addition
}
}
self.template_ports_setup(
in_ports=port_inports,
out_ports=port_outports
)
self.template_meta_setup(
in_ports=meta_inports,
out_ports=meta_outports
)
def init(self):
TemplateNodeMixin.init(self)
port_type = PortsSpecSchema.port_type
outports = {'window': {port_type: [cp.ndarray, np.ndarray]}}
self.template_ports_setup(out_ports=outports)
meta_outports = {'window': {}}
self.template_meta_setup(out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
port_type = PortsSpecSchema.port_type
inports = {'signal': {port_type: [cp.ndarray, np.ndarray]}}
outports = {'signal_out': {port_type: '${port:signal}'}}
self.template_ports_setup(in_ports=inports, out_ports=outports)
meta_outports = {'signal_out': {}}
self.template_meta_setup(out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'stock_in'
self.OUTPUT_PORT_NAME = 'stock_out'
self.INPUT_MAP_NAME = 'name_map'
self.OUTPUT_ASSET_NAME = 'stock_name'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.INPUT_MAP_NAME: {
port_type: [
"greenflow_gquant_plugin.dataloader.stockMap.StockMap"
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:stock_in}"
},
self.OUTPUT_ASSET_NAME: {
port_type: ['builtins.str']
}
}
cols_required = {"asset": "int64"}
meta_inports = {
self.INPUT_PORT_NAME: cols_required,
self.INPUT_MAP_NAME: {}
}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: {}
},
self.OUTPUT_ASSET_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: {}
}
}
self.template_ports_setup(
in_ports=port_inports,
out_ports=port_outports
)
self.template_meta_setup(
in_ports=meta_inports,
out_ports=meta_outports
)
def init(self):
TemplateNodeMixin.init(self)
self.delayed_process = True
self.infer_meta = False
self.OUTPUT_PORT_NAME = 'out'
self.DIFF_A = 'diff_a'
self.DIFF_B = 'diff_b'
port_type = PortsSpecSchema.port_type
port_inports = {
self.DIFF_A: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.DIFF_B: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:diff_a}"
},
}
col_required = {
'sample_id': 'int64',
'portfolio': 'float64',
}
meta_inports = {
self.DIFF_A: col_required,
self.DIFF_B: col_required
}
output_meta = {
'sample_id': 'int64',
'portfolio': 'float64',
}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: output_meta
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(
in_ports=meta_inports,
out_ports=meta_outports
)
def init(self):
TemplateNodeMixin.init(self)
self.delayed_process = True
port_type = PortsSpecSchema.port_type
self.INPUT_PORT_NAME = "points_df_in"
self.OUTPUT_PORT_NAME = "distance_df"
self.ABS_OUTPUT_PORT_NAME = "distance_abs_df"
port_inports = {
self.INPUT_PORT_NAME: {
port_type: ["pandas.DataFrame"]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:points_df_in}"
},
self.ABS_OUTPUT_PORT_NAME: {
port_type: "${port:points_df_in}"
},
}
req_cols = {
'x': 'float64',
'y': 'float64'
}
meta_inports = {
self.INPUT_PORT_NAME: req_cols
}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: {
'distance_cudf': 'float64',
}
},
self.ABS_OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: {
'distance_abs_cudf': 'float64',
}
}
}
self.template_ports_setup(
in_ports=port_inports,
out_ports=port_outports
)
self.template_meta_setup(
in_ports=meta_inports,
out_ports=meta_outports
)
def init(self):
TemplateNodeMixin.init(self)
port_type = PortsSpecSchema.port_type
inports = {
'in1': {port_type: [cp.ndarray, np.ndarray]},
'in2': {port_type: [cp.ndarray, np.ndarray]}
}
outports = {
'fftconvolve': {port_type: [cp.ndarray, np.ndarray]},
}
self.template_ports_setup(in_ports=inports, out_ports=outports)
meta_outports = {'fftconvolve': {}}
self.template_meta_setup(out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
outports = {
'out1': {
PortsSpecSchema.port_type: [cp.ndarray, np.ndarray]
},
'out2': {
PortsSpecSchema.port_type: [cp.ndarray, np.ndarray],
PortsSpecSchema.optional: True
},
}
self.template_ports_setup(out_ports=outports)
meta_outports = {'out1': {}, 'out2': {}}
self.template_meta_setup(out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
outports = {
'signal': {
PortsSpecSchema.port_type: [cp.ndarray, np.ndarray]
},
'framerate': {
PortsSpecSchema.port_type: float
},
}
self.template_ports_setup(out_ports=outports)
meta_outports = {'signal': {}, 'framerate': {}}
self.template_meta_setup(out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.SHAP_INPUT_PORT_NAME = 'shap_in'
self.MODEL_INPUT_PORT_NAME = 'model_in'
self.DATA_INPUT_PORT_NAME = 'data_in'
self.OUTPUT_PORT_NAME = 'summary_plot'
port_type = PortsSpecSchema.port_type
port_inports = {
self.SHAP_INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.MODEL_INPUT_PORT_NAME: {
port_type: [
"xgboost.Booster", "builtins.dict", "dask_cudf.DataFrame",
"dask.dataframe.DataFrame"
]
},
self.DATA_INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "matplotlib.figure.Figure"
},
}
meta_inports = {
self.MODEL_INPUT_PORT_NAME: {},
self.DATA_INPUT_PORT_NAME: {},
self.SHAP_INPUT_PORT_NAME: {}
}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: {}
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
port_type = PortsSpecSchema.port_type
dy = PortsSpecSchema.dynamic
self.INPUT_PORT_NAME = 'in'
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"dask_cudf.DataFrame", "dask.dataframe.DataFrame",
"builtins.object"
],
dy: {
PortsSpecSchema.DYN_MATCH: True
}
},
}
self.template_ports_setup(in_ports=port_inports, out_ports=None)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'roc_curve'
self.OUTPUT_VALUE_NAME = 'value'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: ["matplotlib.figure.Figure"]
},
self.OUTPUT_VALUE_NAME: {
port_type: ["builtins.float"]
}
}
cols_required = {}
icols = self.get_input_meta()
if 'label' in self.conf:
label = self.conf['label']
labeltype = icols.get(self.INPUT_PORT_NAME, {}).get(label)
cols_required[label] = labeltype
if 'prediction' in self.conf:
cols_required[self.conf['prediction']] = None
retension = {}
meta_inports = {self.INPUT_PORT_NAME: cols_required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: retension
},
self.OUTPUT_VALUE_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: retension
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame"
]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:in}"
},
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'data_in'
self.INPUT_PORT_MODEL_NAME = 'model_in'
self.OUTPUT_PORT_NAME = 'out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
self.INPUT_PORT_MODEL_NAME: {
port_type: ['xgboost.Booster', 'builtins.dict']
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:data_in}"
}
}
meta_inports = {
self.INPUT_PORT_NAME: {},
self.INPUT_PORT_MODEL_NAME: {}
}
predict = self.conf.get('prediction', 'predict')
out_cols = {predict: None}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: out_cols
}
}
self.template_ports_setup(
in_ports=port_inports,
out_ports=port_outports
)
self.template_meta_setup(
in_ports=meta_inports,
out_ports=meta_outports
)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'in'
self.OUTPUT_PORT_NAME = 'model_out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: ['xgboost.Booster', 'builtins.dict']
}
}
cols_required = {}
if 'columns' in self.conf and self.conf.get('include', True):
cols_required = {}
for col in self.conf['columns']:
cols_required[col] = None
meta_inports = {
self.INPUT_PORT_NAME: cols_required,
}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: {}
}
}
self.template_ports_setup(
in_ports=port_inports,
out_ports=port_outports
)
self.template_meta_setup(
in_ports=meta_inports,
out_ports=meta_outports
)
def init(self):
TemplateNodeMixin.init(self)
self.delayed_process = True
self.infer_meta = False
self.LEVERAGE_DF = 'lev_df'
self.INPUT_PORT_NAME = "in"
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {
self.LEVERAGE_DF: {
port_type: "${port:in}"
},
}
sub_dict = {
"date": "datetime64[ns]",
'sample_id': 'int64',
'year': 'int16',
'month': 'int16',
'portfolio': "float64",
}
meta_inports = {self.INPUT_PORT_NAME: sub_dict}
meta_outports = {
self.LEVERAGE_DF: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: sub_dict
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.delayed_process = True
self.infer_meta = False
self.INPUT_PORT_NAME = 'logreturn_df'
self.OUTPUT_PORT_NAME = 'out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:logreturn_df}"
},
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'bardata_in'
self.OUTPUT_PORT_NAME = 'backtest_out'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:bardata_in}"
}
}
cols_required = {"signal": "float64",
"returns": "float64"}
addition = {"strategy_returns": "float64"}
meta_inports = {
self.INPUT_PORT_NAME: cols_required
}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: addition
}
}
self.template_ports_setup(
in_ports=port_inports,
out_ports=port_outports
)
self.template_meta_setup(
in_ports=meta_inports,
out_ports=meta_outports
)
def init(self):
TemplateNodeMixin.init(self)
self.delayed_process = True
self.infer_meta = False
self.INPUT_PORT_NAME = "in"
self.OUTPUT_PORT_NAME = "out"
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
}
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: "${port:in}"
},
}
required = {
"date": "datetime64[ns]",
'sample_id': 'int64',
'year': 'int16',
'month': 'int16',
}
meta_inports = {self.INPUT_PORT_NAME: required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION,
MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME,
MetaDataSchema.META_DATA: {}
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)
def init(self):
TemplateNodeMixin.init(self)
self.INPUT_PORT_NAME = 'stock_in'
self.OUTPUT_PORT_NAME = 'barplot'
port_type = PortsSpecSchema.port_type
port_inports = {
self.INPUT_PORT_NAME: {
port_type: [
"pandas.DataFrame", "cudf.DataFrame",
"dask_cudf.DataFrame", "dask.dataframe.DataFrame"
]
},
}
port_outports = {
self.OUTPUT_PORT_NAME: {
port_type: ["ipywidgets.Image"]
}
}
cols_required = {
"datetime": "datetime64[ns]",
"open": "float64",
"close": "float64",
"high": "float64",
"low": "float64",
"volume": "float64"
}
retension = {}
meta_inports = {self.INPUT_PORT_NAME: cols_required}
meta_outports = {
self.OUTPUT_PORT_NAME: {
MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION,
MetaDataSchema.META_DATA: retension
}
}
self.template_ports_setup(in_ports=port_inports,
out_ports=port_outports)
self.template_meta_setup(in_ports=meta_inports,
out_ports=meta_outports)