mage-ai 0.9.70__py3-none-any.whl → 0.9.71__py3-none-any.whl

mage_ai/data_preparation/models/widget/__init__.py

@@ -8,6 +8,7 @@ import pandas as pd
 from mage_ai.data_preparation.models.block import Block
 from mage_ai.data_preparation.models.constants import DATAFRAME_SAMPLE_COUNT_PREVIEW
 from mage_ai.shared.hash import merge_dict
+from mage_ai.shared.parsers import convert_matrix_to_dataframe
 from mage_ai.shared.strings import is_number
 
 from .charts import (
@@ -22,9 +23,11 @@ from .constants import (
     VARIABLE_NAME_INDEX,
     VARIABLE_NAME_LIMIT,
     VARIABLE_NAME_METRICS,
+    VARIABLE_NAME_ORDER_BY,
     VARIABLE_NAME_TIME_INTERVAL,
     VARIABLE_NAME_X,
     VARIABLE_NAME_Y,
+    VARIABLE_NAME_Y_SORT_ORDER,
     VARIABLE_NAMES_BY_CHART_TYPE,
     ChartType,
 )
@@ -99,8 +102,17 @@ class Widget(Block):
                 else:
                     dfs.append(input_var)
 
-        should_use_no_code = x_values is None and y_values is None and \
-            (group_by_columns or metrics)
+        arr = []
+        for d in dfs:
+            if isinstance(d, list):
+                arr += d
+            else:
+                arr.append(d)
+        dfs = [convert_matrix_to_dataframe(d) for d in arr]
+
+        should_use_no_code = (
+            x_values is None and y_values is None and (group_by_columns or metrics)
+        )
 
         if should_use_no_code and len(dfs) == 0:
             return data
@@ -153,13 +165,11 @@ class Widget(Block):
                     data = build_x_y(df, group_by_columns, metrics)
             else:
                 for var_name_orig, _var_name in self.output_variable_names:
-                    data.update(
-                        {
-                            var_name_orig: encode_values_in_list(
-                                convert_to_list(variables[var_name_orig])
-                            ),
-                        }
-                    )
+                    data.update({
+                        var_name_orig: encode_values_in_list(
+                            convert_to_list(variables[var_name_orig])
+                        ),
+                    })
         elif ChartType.PIE_CHART == chart_type:
             arr1 = []
             data_key = VARIABLE_NAME_X
@@ -188,20 +198,30 @@ class Widget(Block):
                         value_counts[key] = 0
                     value_counts[key] += 1
 
-            buckets = int(self.configuration.get(VARIABLE_NAME_BUCKETS, MAX_BUCKETS))
+            buckets = int(self.configuration.get(VARIABLE_NAME_BUCKETS) or MAX_BUCKETS)
             arr = sorted(
                 list(zip(value_counts.values(), value_counts.keys())),
                 reverse=True,
             )[:buckets]
             data[data_key] = {k: v for v, k in arr}
         elif ChartType.TABLE == chart_type:
-            limit_config = self.configuration.get(VARIABLE_NAME_LIMIT) or \
-                DATAFRAME_SAMPLE_COUNT_PREVIEW
+            limit_config = (
+                self.configuration.get(VARIABLE_NAME_LIMIT) or DATAFRAME_SAMPLE_COUNT_PREVIEW
+            )
             if is_number(limit_config):
                 limit_config = int(limit_config)
 
             if should_use_no_code:
-                df = dfs[0].iloc[:limit_config]
+                df = dfs[0]
+                order_by = self.configuration.get(VARIABLE_NAME_ORDER_BY)
+                if order_by:
+                    df.sort_values(
+                        by=order_by,
+                        ascending=self.configuration.get(VARIABLE_NAME_Y_SORT_ORDER)
+                        != 'descending',
+                        inplace=True,
+                    )
+                df = df.iloc[:limit_config]
                 if group_by_columns:
                     data[VARIABLE_NAME_X] = group_by_columns
                     data[VARIABLE_NAME_Y] = df[group_by_columns].to_numpy()
@@ -214,14 +234,15 @@ class Widget(Block):
                         if var_name_orig in [VARIABLE_NAME_Y, VARIABLE_NAME_INDEX]:
                             limit = limit_config
 
-                        data.update(
-                            {
-                                var_name_orig: encode_values_in_list(
-                                    convert_to_list(arr, limit=limit)
-                                ),
-                            }
-                        )
-        elif chart_type in [ChartType.TIME_SERIES_BAR_CHART, ChartType.TIME_SERIES_LINE_CHART]:
+                        data.update({
+                            var_name_orig: encode_values_in_list(
+                                convert_to_list(arr, limit=limit)
+                            ),
+                        })
+        elif chart_type in [
+            ChartType.TIME_SERIES_BAR_CHART,
+            ChartType.TIME_SERIES_LINE_CHART,
+        ]:
             if should_use_no_code:
                 df = dfs[0]
                 if group_by_columns and metrics:
@@ -269,16 +290,19 @@ class Widget(Block):
         decorated_functions_y = []
         test_functions = []
 
-        results = merge_dict(dict(
-            columns=self._block_decorator(decorated_functions_columns),
-            configuration=self._block_decorator(decorated_functions_configuration),
-            data_source=self._block_decorator(decorated_functions_data_source),
-            render=self._block_decorator_render(decorated_functions_render),
-            test=self._block_decorator(test_functions),
-            x=self._block_decorator(decorated_functions_x),
-            xy=self._block_decorator(decorated_functions_xy),
-            y=self._block_decorator(decorated_functions_y),
-        ), outputs_from_input_vars)
+        results = merge_dict(
+            dict(
+                columns=self._block_decorator(decorated_functions_columns),
+                configuration=self._block_decorator(decorated_functions_configuration),
+                data_source=self._block_decorator(decorated_functions_data_source),
+                render=self._block_decorator_render(decorated_functions_render),
+                test=self._block_decorator(test_functions),
+                x=self._block_decorator(decorated_functions_x),
+                xy=self._block_decorator(decorated_functions_xy),
+                y=self._block_decorator(decorated_functions_y),
+            ),
+            outputs_from_input_vars,
+        )
 
         inputs_vars_use = list()
         if input_vars is not None:
@@ -290,8 +314,7 @@ class Widget(Block):
         metrics = chart_configuration_settings['metrics']
 
         if custom_code is not None and custom_code.strip():
-            if not group_by_columns or not metrics:
-                exec(custom_code, results)
+            exec(custom_code, results)
         elif self.content is not None:
             exec(self.content, results)
         elif os.path.exists(self.file_path):
@@ -354,18 +377,16 @@ class Widget(Block):
         else:
             item = None
 
-            if input_vars_from_data_source is not None and \
-                    isinstance(input_vars_from_data_source, list) and \
-                    len(input_vars_from_data_source) >= 1:
-
+            if (
+                input_vars_from_data_source is not None
+                and isinstance(input_vars_from_data_source, list)
+                and len(input_vars_from_data_source) >= 1
+            ):
                 item = input_vars_from_data_source[0]
             else:
                 item = input_vars_from_data_source
 
-            if item is not None and \
-                    isinstance(item, list) and \
-                    len(item) >= 1:
-
+            if item is not None and isinstance(item, list) and len(item) >= 1:
                 item = item[0]
 
             if item is not None:
@@ -431,6 +452,7 @@ class Widget(Block):
                     render = function(*args_inner, **kwargs_inner)
 
                     return merge_dict(dict(render=render), kwargs or {})
+
                 decorated_functions.append(func)
 
             return inner

mage_ai/data_preparation/models/widget/charts.py

@@ -44,11 +44,13 @@ def build_buckets(min_value, max_value, max_buckets):
         min_v = min_value + (i * bucket_interval)
         max_v = min_value + ((i + 1) * bucket_interval)
         if max_value >= min_v:
-            buckets.append(dict(
-                max_value=max_v,
-                min_value=min_v,
-                values=[],
-            ))
+            buckets.append(
+                dict(
+                    max_value=max_v,
+                    min_value=min_v,
+                    values=[],
+                )
+            )
 
     return buckets, bucket_interval
 
@@ -69,10 +71,12 @@ def build_histogram_data(arr, max_buckets):
     y = []
 
     for idx, bucket in enumerate(buckets):
-        x.append(dict(
-            max=bucket['max_value'],
-            min=bucket['min_value'],
-        ))
+        x.append(
+            dict(
+                max=bucket['max_value'],
+                min=bucket['min_value'],
+            )
+        )
         y.append(dict(value=count[idx]))
 
     return dict(
@@ -81,6 +85,14 @@ def build_histogram_data(arr, max_buckets):
     )
 
 
+def convert_to_datetime(dt):
+    if len(str(dt)) == 10 and str(dt).isdigit():
+        return datetime.fromtimestamp(int(dt))
+    elif type(dt) is np.datetime64:
+        return pd.to_datetime(dt.astype(datetime)).to_pydatetime()
+    return dt
+
+
 def build_time_series_buckets(
     df,
     datetime_column,
@@ -94,8 +106,9 @@ def build_time_series_buckets(
         return []
 
     datetimes = datetimes.unique()
-    min_value_datetime = datetimes.min()
-    max_value_datetime = datetimes.max()
+    datetimes_are_timestamps = all([len(str(dt)) == 10 and str(dt).isdigit() for dt in datetimes])
+    min_value_datetime = convert_to_datetime(datetimes.min())
+    max_value_datetime = convert_to_datetime(datetimes.max())
 
     if type(min_value_datetime) is str:
         min_value_datetime = dateutil.parser.parse(min_value_datetime)
@@ -104,12 +117,7 @@ def build_time_series_buckets(
 
     # If you manually convert the datetime column to a datetime, Pandas will use numpy.datetime64
     # type. This type does not have the methods year, month, day, etc that is used down below.
-    datetimes_temp = []
-    for dt in datetimes:
-        if type(dt) is np.datetime64:
-            datetimes_temp.append(pd.to_datetime(dt.astype(datetime)).to_pydatetime())
-        else:
-            datetimes_temp.append(dt)
+    datetimes_temp = [convert_to_datetime(dt) for dt in datetimes]
     datetimes = datetimes_temp
     if type(min_value_datetime) is np.datetime64:
         min_value_datetime = pd.to_datetime(min_value_datetime.astype(datetime)).to_pydatetime()
@@ -169,8 +177,14 @@ def build_time_series_buckets(
         start_datetime = datetime(year, 1, 1, 0, 0, 0)
 
     df_copy = df.copy()
-    df_copy[datetime_column] = \
-        pd.to_datetime(df[datetime_column]).apply(lambda x: x if pd.isnull(x) else x.timestamp())
+    if datetimes_are_timestamps:
+        df_copy[datetime_column] = df[datetime_column].apply(
+            lambda x: x if pd.isnull(x) else int(x)
+        )
+    else:
+        df_copy[datetime_column] = pd.to_datetime(df[datetime_column]).apply(
+            lambda x: x if pd.isnull(x) else x.timestamp()
+        )
 
     values = [[] for _ in metrics]
     buckets = []
@@ -182,9 +196,9 @@ def build_time_series_buckets(
         now + TIME_INTERVAL_TO_TIME_DELTA[time_interval]
     ).timestamp() - now.timestamp()
 
-    number_of_buckets = math.ceil(
-        max_value_datetime_ts - min_value_datetime.timestamp()
-    ) / interval_seconds
+    number_of_buckets = (
+        math.ceil(max_value_datetime_ts - min_value_datetime.timestamp()) / interval_seconds
+    )
 
     max_buckets_to_use = max_buckets or MAX_BUCKETS
 
@@ -204,11 +218,10 @@ def build_time_series_buckets(
         )
         buckets.append(max_date.timestamp())
 
-        df_in_range = df_copy[(
-            df_copy[datetime_column] >= min_date_ts
-        ) & (
-            df_copy[datetime_column] < max_date.timestamp()
-        )]
+        df_in_range = df_copy[
+            (df_copy[datetime_column] >= min_date_ts)
+            & (df_copy[datetime_column] < max_date.timestamp())
+        ]
 
         for idx, metric in enumerate(metrics):
             aggregation = metric['aggregation']

mage_ai/data_preparation/models/widget/constants.py

@@ -4,9 +4,11 @@ from dateutil.relativedelta import relativedelta
 
 VARIABLE_NAME_BUCKETS = 'buckets'
 VARIABLE_NAME_GROUP_BY = 'group_by'
+VARIABLE_NAME_ORDER_BY = 'order_by'
 VARIABLE_NAME_INDEX = 'index'
 VARIABLE_NAME_LIMIT = 'limit'
 VARIABLE_NAME_METRICS = 'metrics'
+VARIABLE_NAME_Y_SORT_ORDER = 'y_sort_order'
 VARIABLE_NAME_TIME_INTERVAL = 'time_interval'
 VARIABLE_NAME_X = 'x'
 VARIABLE_NAME_Y = 'y'

mage_ai/data_preparation/models/widget/utils.py

@@ -13,13 +13,13 @@ def clean_series(series, column_type=None, dropna=True):
     if dropna:
         series_cleaned = series_cleaned.dropna()
 
-    if column_type is int:
+    if column_type is float:
+        series_cleaned = series_cleaned.astype(float)
+    else:
         try:
             series_cleaned = series_cleaned.astype(float).astype(np.int64)
         except ValueError:
             series_cleaned = series_cleaned.astype(float)
-    elif column_type is float:
-        series_cleaned = series_cleaned.astype(float)
 
     return series_cleaned
 

mage_ai/data_preparation/preferences.py

@@ -101,12 +101,12 @@ class Preferences:
         config_dict: Dict = None,
         user: User = None,
     ):
-        self.repo_path = repo_path or get_repo_path()
+        self.repo_path = repo_path or get_repo_path(user=user)
         self.preferences_file_path = os.path.join(self.repo_path, PREFERENCES_FILE)
         self.user = user
         project_preferences = dict()
         try:
-            if user and user.preferences and user.git_settings is None:
+            if user and user.preferences and user.get_git_settings(self.repo_path) is None:
                 project_preferences = user.preferences
             elif config_dict:
                 project_preferences = config_dict
@@ -120,7 +120,7 @@ class Preferences:
         # Git settings
         project_sync_config = project_preferences.get('sync_config', dict())
         if user:
-            user_git_settings = user.git_settings or {}
+            user_git_settings = user.get_git_settings(self.repo_path) or {}
             project_sync_config = merge_dict(project_sync_config, user_git_settings)
 
         self.sync_config = build_sync_config(project_sync_config)

mage_ai/data_preparation/repo_manager.py

@@ -8,20 +8,25 @@ from typing import Dict, Optional
 from warnings import warn
 
 import ruamel.yaml
-import yaml
 from jinja2 import Template
 
 from mage_ai.cluster_manager.constants import ClusterType
 from mage_ai.data_preparation.templates.utils import copy_template_directory
 from mage_ai.settings import INITIAL_METADATA, settings
-from mage_ai.settings.repo import DEFAULT_MAGE_DATA_DIR, MAGE_DATA_DIR_ENV_VAR
+from mage_ai.settings.repo import (
+    DEFAULT_MAGE_DATA_DIR,
+    MAGE_DATA_DIR_ENV_VAR,
+    PROJECT_METADATA_FILENAME,
+)
 from mage_ai.settings.repo import get_data_dir as get_data_dir_new
 from mage_ai.settings.repo import get_metadata_path
 from mage_ai.settings.repo import get_repo_name as get_repo_name_new
 from mage_ai.settings.repo import get_repo_path as get_repo_path_new
 from mage_ai.settings.repo import get_variables_dir
 from mage_ai.settings.repo import set_repo_path as set_repo_path_new
+from mage_ai.settings.utils import base_repo_path
 from mage_ai.shared.environments import is_debug
+from mage_ai.shared.yaml import load_yaml, trim_strings
 
 yml = ruamel.yaml.YAML()
 yml.preserve_quotes = True
@@ -42,10 +47,16 @@ class RepoConfig:
         self,
         repo_path: str = None,
         config_dict: Dict = None,
+        context_data: Dict = None,
         root_project: bool = False,
+        user=None,
     ):
         self.root_project = root_project
-        self.repo_path = repo_path or get_repo_path_new(root_project=self.root_project)
+        self.repo_path = repo_path or get_repo_path_new(
+            context_data=context_data,
+            root_project=self.root_project,
+            user=user,
+        )
         self.repo_name = os.path.basename(self.repo_path)
         self.project_uuid = None
         self.project_type = None
@@ -77,14 +88,14 @@ class RepoConfig:
         self.workspace_shared_config = None
 
         from mage_ai.data_preparation.shared.utils import get_template_vars
+
         try:
             if not config_dict:
                 if os.path.exists(self.metadata_path):
                     with open(self.metadata_path) as f:
-                        config_file = Template(f.read()).render(
-                            **get_template_vars()
-                        )
-                        repo_config = yaml.full_load(config_file) or {}
+                        config_file = Template(f.read()).render(**get_template_vars())
+                        repo_config = load_yaml(config_file) or {}
+                        repo_config = trim_strings(repo_config)
                 else:
                     repo_config = dict()
             else:
@@ -117,8 +128,9 @@ class RepoConfig:
 
             # Executor configs
             self.ai_config = repo_config.get('ai_config', dict())
-            self.azure_container_instance_config = \
-                repo_config.get('azure_container_instance_config')
+            self.azure_container_instance_config = repo_config.get(
+                'azure_container_instance_config'
+            )
             self.ecs_config = repo_config.get('ecs_config')
             self.emr_config = repo_config.get('emr_config') or dict()
             self.features = repo_config.get('features', {})
@@ -132,15 +144,21 @@ class RepoConfig:
             self.openai_api_key = repo_config.get('openai_api_key')
             self.pipelines = repo_config.get('pipelines')
             self.retry_config = repo_config.get('retry_config')
-            self.workspace_config_defaults = repo_config.get('workspace_config_defaults')
-            self.workspace_initial_metadata = repo_config.get('workspace_initial_metadata')
+            self.workspace_config_defaults = repo_config.get(
+                'workspace_config_defaults'
+            )
+            self.workspace_initial_metadata = repo_config.get(
+                'workspace_initial_metadata'
+            )
 
             self.ldap_config = repo_config.get('ldap_config')
 
             self.s3_bucket = None
             self.s3_path_prefix = None
-            if self.remote_variables_dir is not None and \
-                    self.remote_variables_dir.startswith('s3://'):
+            if (
+                self.remote_variables_dir is not None
+                and self.remote_variables_dir.startswith('s3://')
+            ):
                 path_parts = self.remote_variables_dir.replace('s3://', '').split('/')
                 self.s3_bucket = path_parts.pop(0)
                 self.s3_path_prefix = '/'.join(path_parts)
@@ -149,7 +167,9 @@ class RepoConfig:
 
             self.logging_config = repo_config.get('logging_config', dict())
 
-            self.variables_retention_period = repo_config.get('variables_retention_period')
+            self.variables_retention_period = repo_config.get(
+                'variables_retention_period'
+            )
         except Exception as err:
             traceback.print_exc()
             if is_debug():
@@ -208,7 +228,7 @@ class RepoConfig:
             spark_config=self.spark_config,
             variables_dir=self.remote_variables_dir if remote else self.variables_dir,
             variables_retention_period=self.variables_retention_period,
-            workspace_config_defaults=self.workspace_config_defaults
+            workspace_config_defaults=self.workspace_config_defaults,
         )
 
     def save(self, **kwargs) -> None:
@@ -278,18 +298,31 @@ def init_repo(
     get_repo_config(repo_path, root_project=root_project).save(**new_config)
 
 
-def get_repo_config(repo_path: str = None, root_project: bool = False) -> RepoConfig:
-    return RepoConfig(repo_path=repo_path, root_project=root_project)
+def get_repo_config(
+    repo_path: str = None,
+    context_data: Dict = None,
+    root_project: bool = False,
+    user=None,
+) -> RepoConfig:
+    return RepoConfig(
+        repo_path=repo_path,
+        context_data=context_data,
+        root_project=root_project,
+        user=user,
+    )
 
 
-def get_project_type(repo_path=None) -> ProjectType:
+def get_project_type(repo_config: RepoConfig = None, repo_path: str = None) -> ProjectType:
     from mage_ai.settings.repo import MAGE_PROJECT_TYPE_ENV_VAR
+
     try:
         project_type_from_env = os.getenv(MAGE_PROJECT_TYPE_ENV_VAR)
         if project_type_from_env:
             return ProjectType(project_type_from_env)
         else:
-            return get_repo_config(repo_path=repo_path).project_type
+            if repo_config is None:
+                repo_config = get_repo_config(repo_path=repo_path)
+            return repo_config.project_type
     except Exception:
         # default to standalone project type
         return ProjectType.STANDALONE
@@ -297,6 +330,7 @@ def get_project_type(repo_path=None) -> ProjectType:
 
 def get_cluster_type(repo_path=None) -> Optional[ClusterType]:
     from mage_ai.settings.repo import MAGE_CLUSTER_TYPE_ENV_VAR
+
     try:
         cluster_type_from_env = os.getenv(MAGE_CLUSTER_TYPE_ENV_VAR)
         if cluster_type_from_env:
@@ -310,7 +344,7 @@ def get_cluster_type(repo_path=None) -> Optional[ClusterType]:
 
 def set_project_uuid_from_metadata() -> None:
     global project_uuid
-    metadata_path = get_metadata_path(root_project=True)
+    metadata_path = os.path.join(base_repo_path(), PROJECT_METADATA_FILENAME)
     if os.path.exists(metadata_path):
         with open(metadata_path, 'r', encoding='utf-8') as f:
             config = yml.load(f) or {}
@@ -366,7 +400,7 @@ def get_repo_path() -> str:
     warn(
         'repo_manager.get_repo_path is deprecated. Please use mage_ai.settings.repo.get_repo_path',
         DeprecationWarning,
-        stacklevel=2
+        stacklevel=2,
     )
     return get_repo_path_new()
 

mage_ai/data_preparation/storage/base_storage.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
-from typing import Dict, List
+from typing import Dict, List, Optional, Union
 
 import pandas as pd
 import polars as pl
@@ -67,7 +67,7 @@ class BaseStorage(ABC):
     def read_json_file(
         self,
         file_path: str,
-        default_value: Dict = None,
+        default_value: Optional[Union[Dict, List]] = None,
         raise_exception: bool = False,
     ) -> Dict:
         """

mage_ai/data_preparation/storage/gcs_storage.py

@@ -55,10 +55,13 @@ class GCSStorage(BaseStorage):
         Example block output path in GCS:
             gs://mage_demo/pipelines/example_pipeline/.variables/example_block/output_0/
         """
-        blobs = self.bucket.list_blobs(
-            prefix=path,
-            max_results=max_results,
-        )
+        try:
+            blobs = self.bucket.list_blobs(
+                prefix=path,
+                max_results=max_results,
+            )
+        except Exception:
+            return []
         keys = []
         for blob in blobs:
             # Avoid finding files recursevively in the dir path.

mage_ai/data_preparation/storage/local_storage.py

@@ -2,7 +2,7 @@ import json
 import os
 import shutil
 from contextlib import contextmanager
-from typing import Dict, List
+from typing import Dict, List, Optional, Union
 
 import aiofiles
 import pandas as pd
@@ -11,6 +11,7 @@ import simplejson
 
 from mage_ai.data_preparation.models.file import File
 from mage_ai.data_preparation.storage.base_storage import BaseStorage
+from mage_ai.settings.server import DEBUG_FILE_IO
 from mage_ai.shared.environments import is_debug
 from mage_ai.shared.parsers import encode_complex
 
@@ -26,7 +27,7 @@ class LocalStorage(BaseStorage):
         max_results: int = None,
     ) -> List[str]:
         paths = []
-        if not os.path.exists(path):
+        if not os.path.exists(path) or not os.path.isdir(path):
             return paths
 
         if max_results is not None:
@@ -57,9 +58,11 @@ class LocalStorage(BaseStorage):
     def read_json_file(
         self,
         file_path: str,
-        default_value: Dict = None,
+        default_value: Optional[Union[Dict, List]] = None,
         raise_exception: bool = False,
     ) -> Dict:
+        if DEBUG_FILE_IO and '.variables' in file_path:
+            print(f'[READ JSON FILE]: {file_path}')
         if not self.path_exists(file_path):
             return default_value or {}
         with open(file_path) as file:

mage_ai/data_preparation/storage/s3_storage.py

@@ -39,8 +39,11 @@ class S3Storage(BaseStorage):
         if not path.endswith('/'):
             path += '/'
         path = s3_url_path(path)
-        keys = self.client.listdir(path, suffix=suffix, max_results=max_results)
-        return [k[len(path):].rstrip('/') for k in keys]
+        try:
+            keys = self.client.listdir(path, suffix=suffix, max_results=max_results)
+            return [k[len(path):].rstrip('/') for k in keys]
+        except Exception:
+            return []
 
     def makedirs(self, path: str, **kwargs) -> None:
         pass

mage_ai/data_preparation/templates/data_exporters/streaming/oracledb.yaml

@@ -0,0 +1,8 @@
+connector_type: oracledb
+user: 'test'
+password: '123456'
+host: 'host_name'
+port: 1521
+table: 'exported_table'
+service_name: 'service_name'
+mode: 'thin'