Intro to the core interfaces of mloda¶

# Load all available plugins into the python environment
from mloda.user import PluginLoader

plugin_loader = PluginLoader.all()


# Since there are potentially many plugins loaded, we'll focus on specific categories for clarity.
# Here, we demonstrate by listing the available 'read' and 'sql' plugins.
print(plugin_loader.list_loaded_modules("read"))
print(plugin_loader.list_loaded_modules("sql"))

# Step 3: Request Data Using the Defined Access Collection and Desired Features
from mloda.user import mloda
from mloda_plugins.compute_framework.base_implementations.pyarrow.table import PyArrowTable


all_features = order_features + payment_features + location_features + categorical_features

# Retrieve data based on the specified feature list and access collection
result = mloda.run_all(all_features, data_access_collection=data_access_collection, compute_frameworks={PyArrowTable})

# Display the first five entries of each result table and its type
for data in result:
    print(data[:2], type(data))

# The data is initially loaded as a Pyarrow table. However, we can easily load it also as a PandasDataFrame.
from mloda_plugins.compute_framework.base_implementations.pandas.dataframe import PandasDataFrame

# Request data using the Pandas compute framework
result = mloda.run_all(
    all_features, data_access_collection=data_access_collection, compute_frameworks={PandasDataFrame}
)

# Display the first five entries of each result table and its type
for data in result:
    print(data[:2], type(data))

# Define features with specific compute frameworks
order_id = Feature(name="order_id", compute_framework="PandasDataFrame")
product_id = Feature(name="product_id", compute_framework="PyArrowTable")
specific_framework_feature_list: List[Feature | str] = [order_id, product_id]

# Request data for the defined features
result = mloda.run_all(specific_framework_feature_list, data_access_collection=data_access_collection)

# Display the first few rows and data types of the results
for res in result:
    print("The resulting data structure differs based on the compute framework:")
    print("\n", res[:3], type(res))

# Demonstrating mloda's Flexibility with Different Data Technologies

# Import required modules
from typing import Any, List, Optional, Set

from mloda.provider import FeatureGroup, FeatureSet
from mloda.user import Feature, FeatureName, Options, Index, Link, JoinSpec
from mloda_plugins.feature_group.input_data.read_file_feature import ReadFileFeature


# Define the index for the join
index = Index(("order_id",))


# Extend ReadFileFeature to provide index columns
class ReadFileFeatureJoin(ReadFileFeature):
    @classmethod
    def index_columns(cls) -> Optional[List[Index]]:
        return [index]


# Define the link between the features using JoinSpec
link = Link.inner(JoinSpec(ReadFileFeatureJoin, index), JoinSpec(ReadFileFeatureJoin, index))


# Create an example feature group to demonstrate joining
class ExampleMlLifeCycleJoin(FeatureGroup):
    # Define input features with different compute frameworks
    def input_features(self, options: Options, feature_name: FeatureName) -> Optional[Set[Feature]]:
        quantity = Feature(name="quantity", compute_framework="PandasDataFrame")
        product_id = Feature(name="product_id", compute_framework="PyArrowTable")
        return {product_id, quantity}

    # Perform calculations on the joined data
    @classmethod
    def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:
        print(
            "Data from two different sources is now combined into one feature within one data technology: \n",
            data,
            type(data),
            "\n",
        )
        return {"ExampleMlLifeCycleJoin": [1, 2, 3]}


# Run the pipeline
result = mloda.run_all(["ExampleMlLifeCycleJoin"], data_access_collection=data_access_collection, links={link})


# Display the final result
print(
    "Final result: ",
    result[0],
    "\nNote: As no specific compute framework was defined for the result, the output could be in either format.",
)

# Summary: mloda's abstraction layer enables complex process pipelines that handle different data technologies.
# This decouples processes from the underlying data structure, ensuring flexibility and scalability.