pylegend 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

pylegend/core/tds/pandas_api/frames/pandas_api_groupby_tds_frame.py

@@ -0,0 +1,325 @@
+# Copyright 2025 Goldman Sachs
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from pylegend._typing import (
+    PyLegendOptional,
+    PyLegendUnion,
+    PyLegendList,
+    PyLegendDict,
+    TYPE_CHECKING,
+)
+from pylegend.core.language.pandas_api.pandas_api_aggregate_specification import PyLegendAggInput
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitiveOrPythonPrimitive
+from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import PandasApiBaseTdsFrame
+
+if TYPE_CHECKING:
+    from pylegend.core.tds.pandas_api.frames.pandas_api_tds_frame import PandasApiTdsFrame
+
+
+class PandasApiGroupbyTdsFrame:
+    __base_frame: PandasApiBaseTdsFrame
+    __by: PyLegendUnion[str, PyLegendList[str]]
+    __level: PyLegendOptional[PyLegendUnion[str, int, PyLegendList[str]]]
+    __as_index: bool
+    __sort: bool
+    __group_keys: bool
+    __observed: bool
+    __dropna: bool
+
+    __grouping_column_name_list: PyLegendList[str]
+    __selected_columns: PyLegendOptional[PyLegendList[str]]
+
+    @classmethod
+    def name(cls) -> str:
+        return "groupby"  # pragma: no cover
+
+    def __init__(
+        self,
+        base_frame: PandasApiBaseTdsFrame,
+        by: PyLegendUnion[str, PyLegendList[str]],
+        level: PyLegendOptional[PyLegendUnion[str, int, PyLegendList[str]]] = None,
+        as_index: bool = False,
+        sort: bool = True,
+        group_keys: bool = False,
+        observed: bool = False,
+        dropna: bool = False,
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__by = by
+        self.__level = level
+        self.__as_index = as_index
+        self.__sort = sort
+        self.__group_keys = group_keys
+        self.__observed = observed
+        self.__dropna = dropna
+
+        self.__selected_columns = None
+
+        self.__validate()
+
+    def __validate(self) -> None:
+
+        if self.__level is not None:
+            raise NotImplementedError(
+                "The 'level' parameter of the groupby function is not supported yet. "
+                "Please specify groupby column names using the 'by' parameter."
+            )
+
+        if self.__as_index is not False:
+            raise NotImplementedError(
+                f"The 'as_index' parameter of the groupby function must be False, "
+                f"but got: {self.__as_index} (type: {type(self.__as_index).__name__})"
+            )
+
+        if self.__group_keys is not False:
+            raise NotImplementedError(
+                f"The 'group_keys' parameter of the groupby function must be False, "
+                f"but got: {self.__group_keys} (type: {type(self.__group_keys).__name__})"
+            )
+
+        if self.__observed is not False:
+            raise NotImplementedError(
+                f"The 'observed' parameter of the groupby function must be False, "
+                f"but got: {self.__observed} (type: {type(self.__observed).__name__})"
+            )
+
+        if self.__dropna is not False:
+            raise NotImplementedError(
+                f"The 'dropna' parameter of the groupby function must be False, "
+                f"but got: {self.__dropna} (type: {type(self.__dropna).__name__})"
+            )
+
+        input_cols: PyLegendList[str] = []
+        if isinstance(self.__by, str):
+            input_cols = [self.__by]
+        elif isinstance(self.__by, list):
+            input_cols = self.__by
+        else:
+            raise TypeError(
+                f"The 'by' parameter in groupby function must be a string or a list of strings."
+                f"but got: {self.__by} (type: {type(self.__by).__name__})"
+            )
+
+        if len(input_cols) == 0:
+            raise ValueError("The 'by' parameter in groupby function must contain at least one column name.")
+
+        available_columns = {c.get_name() for c in self.__base_frame.columns()}
+        missing_cols = [col for col in input_cols if col not in available_columns]
+
+        if len(missing_cols) > 0:
+            raise KeyError(
+                f"Column(s) {missing_cols} in groupby function's provided columns list "
+                f"do not exist in the current frame. "
+                f"Current frame columns: {sorted(available_columns)}"
+            )
+
+        self.__grouping_column_name_list = input_cols.copy()
+
+    def __getitem__(self, item: PyLegendUnion[str, PyLegendList[str]]) -> "PandasApiGroupbyTdsFrame":
+        columns_to_select: PyLegendList[str] = []
+
+        if isinstance(item, str):
+            columns_to_select = [item]
+        elif isinstance(item, list):
+            columns_to_select = item
+        else:
+            raise TypeError(
+                f"Column selection after groupby function must be a string or a list of strings, "
+                f"but got: {item} (type: {type(item).__name__})"
+            )
+
+        if len(columns_to_select) == 0:
+            raise ValueError("When performing column selection after groupby, at least one column must be selected.")
+
+        available_columns = {c.get_name() for c in self.__base_frame.columns()}
+        missing_cols = [col for col in columns_to_select if col not in available_columns]
+
+        if len(missing_cols) > 0:
+            raise KeyError(
+                f"Column(s) {missing_cols} selected after groupby do not exist in the current frame. "
+                f"Current frame columns: {sorted(available_columns)}"
+            )
+
+        new_frame = PandasApiGroupbyTdsFrame(
+            base_frame=self.__base_frame,
+            by=self.__by,
+            level=self.__level,
+            as_index=self.__as_index,
+            sort=self.__sort,
+            group_keys=self.__group_keys,
+            observed=self.__observed,
+            dropna=self.__dropna,
+        )
+
+        new_frame.__selected_columns = columns_to_select.copy()
+        return new_frame
+
+    def base_frame(self) -> PandasApiBaseTdsFrame:
+        return self.__base_frame
+
+    def grouping_column_name_list(self) -> PyLegendList[str]:
+        return self.__grouping_column_name_list.copy()
+
+    def selected_columns(self) -> PyLegendOptional[PyLegendList[str]]:
+        if self.__selected_columns is None:
+            return None
+        return self.__selected_columns.copy()
+
+    def aggregate(
+        self,
+        func: PyLegendAggInput,
+        axis: PyLegendUnion[int, str] = 0,
+        *args: PyLegendPrimitiveOrPythonPrimitive,
+        **kwargs: PyLegendPrimitiveOrPythonPrimitive,
+    ) -> "PandasApiTdsFrame":
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunctionTdsFrame
+        from pylegend.core.tds.pandas_api.frames.functions.aggregate_function import AggregateFunction
+
+        aggregated_result: PandasApiAppliedFunctionTdsFrame = PandasApiAppliedFunctionTdsFrame(
+            AggregateFunction(self, func, axis, *args, **kwargs)
+        )
+
+        if self.__sort:
+            from pylegend.core.tds.pandas_api.frames.functions.sort_values_function import SortValuesFunction
+
+            aggregated_result = PandasApiAppliedFunctionTdsFrame(
+                SortValuesFunction(
+                    base_frame=aggregated_result,
+                    by=self.grouping_column_name_list(),
+                    axis=0,
+                    ascending=True,
+                    inplace=False,
+                    kind=None,
+                    na_position="last",
+                    ignore_index=True,
+                    key=None,
+                )
+            )
+
+        return aggregated_result
+
+    def agg(
+        self,
+        func: PyLegendAggInput,
+        axis: PyLegendUnion[int, str] = 0,
+        *args: PyLegendPrimitiveOrPythonPrimitive,
+        **kwargs: PyLegendPrimitiveOrPythonPrimitive,
+    ) -> "PandasApiTdsFrame":
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunctionTdsFrame
+        from pylegend.core.tds.pandas_api.frames.functions.aggregate_function import AggregateFunction
+
+        return PandasApiAppliedFunctionTdsFrame(AggregateFunction(self, func, axis, *args, **kwargs))
+
+    def sum(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in sum function.")
+        if min_count != 0:
+            raise NotImplementedError(f"min_count must be 0 in sum function, but got: {min_count}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in sum function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in sum function.")
+        return self.aggregate("sum", 0)
+
+    def mean(
+        self,
+        numeric_only: bool = False,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in mean function.")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in mean function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in mean function.")
+        return self.aggregate("mean", 0)
+
+    def min(
+        self,
+        numeric_only: bool = False,
+        min_count: int = -1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in min function.")
+        if min_count != -1:
+            raise NotImplementedError(f"min_count must be -1 (default) in min function, but got: {min_count}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in min function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in min function.")
+        return self.aggregate("min", 0)
+
+    def max(
+        self,
+        numeric_only: bool = False,
+        min_count: int = -1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in max function.")
+        if min_count != -1:
+            raise NotImplementedError(f"min_count must be -1 (default) in max function, but got: {min_count}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in max function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in max function.")
+        return self.aggregate("max", 0)
+
+    def std(
+        self,
+        ddof: int = 1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+        numeric_only: bool = False,
+    ) -> "PandasApiTdsFrame":
+        if ddof != 1:
+            raise NotImplementedError(f"Only ddof=1 (Sample Standard Deviation) is supported in std function, but got: {ddof}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in std function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in std function.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in std function.")
+        return self.aggregate("std", 0)
+
+    def var(
+        self,
+        ddof: int = 1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+        numeric_only: bool = False,
+    ) -> "PandasApiTdsFrame":
+        if ddof != 1:
+            raise NotImplementedError(f"Only ddof=1 (Sample Variance) is supported in var function, but got: {ddof}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in var function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in var function.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in var function.")
+        return self.aggregate("var", 0)
+
+    def count(self) -> "PandasApiTdsFrame":
+        return self.aggregate("count", 0)

pylegend/core/tds/pandas_api/frames/pandas_api_tds_frame.py

@@ -16,6 +16,13 @@ from abc import abstractmethod
 from datetime import date, datetime
 from typing import TYPE_CHECKING
 
+from typing_extensions import Concatenate
+
+try:
+    from typing import ParamSpec
+except Exception:
+    from typing_extensions import ParamSpec  # type: ignore
+
 from pylegend._typing import (
     PyLegendCallable,
     PyLegendSequence,
@@ -23,11 +30,13 @@ from pylegend._typing import (
     PyLegendOptional,
     PyLegendList,
     PyLegendSet,
+    PyLegendTuple,
+    PyLegendDict
 )
-from pylegend.core.language.pandas_api.pandas_api_aggregate_specification import PyLegendAggInput
 from pylegend.core.language import (
     PyLegendPrimitive,
 )
+from pylegend.core.language.pandas_api.pandas_api_aggregate_specification import PyLegendAggInput
 from pylegend.core.language.pandas_api.pandas_api_tds_row import PandasApiTdsRow
 from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
 from pylegend.core.language.shared.primitives.integer import PyLegendInteger
@@ -37,11 +46,14 @@ from pylegend.core.tds.tds_frame import PyLegendTdsFrame
 
 if TYPE_CHECKING:
     from pylegend.core.language.pandas_api.pandas_api_series import Series
+    from pylegend.core.tds.pandas_api.frames.pandas_api_groupby_tds_frame import PandasApiGroupbyTdsFrame
 
 __all__: PyLegendSequence[str] = [
     "PandasApiTdsFrame"
 ]
 
+P = ParamSpec("P")
+
 
 class PandasApiTdsFrame(PyLegendTdsFrame):
 
@@ -52,6 +64,14 @@ class PandasApiTdsFrame(PyLegendTdsFrame):
     ) -> PyLegendUnion["PandasApiTdsFrame", "Series"]:
         pass  # pragma: no cover
 
+    @abstractmethod
+    def __setitem__(
+            self,
+            key: str,
+            value: PyLegendUnion["Series", PyLegendPrimitiveOrPythonPrimitive]
+    ) -> None:
+        pass  # pragma: no cover
+
     @abstractmethod
     def assign(
             self,
@@ -104,27 +124,213 @@ class PandasApiTdsFrame(PyLegendTdsFrame):
             index: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]] = None,
             columns: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]] = None,
             level: PyLegendOptional[PyLegendUnion[int, PyLegendInteger, str]] = None,
-            inplace: PyLegendUnion[bool, PyLegendBoolean] = True,
+            inplace: PyLegendUnion[bool, PyLegendBoolean] = False,
             errors: str = "raise",
     ) -> "PandasApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
     def aggregate(
-        self,
-        func: PyLegendAggInput,
-        axis: PyLegendUnion[int, str] = 0,
-        *args: PyLegendPrimitiveOrPythonPrimitive,
-        **kwargs: PyLegendPrimitiveOrPythonPrimitive
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
     ) -> "PandasApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
     def agg(
-        self,
-        func: PyLegendAggInput,
-        axis: PyLegendUnion[int, str] = 0,
-        *args: PyLegendPrimitiveOrPythonPrimitive,
-        **kwargs: PyLegendPrimitiveOrPythonPrimitive
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def merge(
+            self,
+            other: "PandasApiTdsFrame",
+            how: PyLegendOptional[str] = "inner",
+            on: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str]]] = None,
+            left_on: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str]]] = None,
+            right_on: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str]]] = None,
+            left_index: PyLegendOptional[bool] = False,
+            right_index: PyLegendOptional[bool] = False,
+            sort: PyLegendOptional[bool] = False,
+            suffixes: PyLegendOptional[
+                PyLegendUnion[
+                    PyLegendTuple[PyLegendUnion[str, None], PyLegendUnion[str, None]],
+                    PyLegendList[PyLegendUnion[str, None]],
+                ]
+            ] = ("_x", "_y"),
+            indicator: PyLegendOptional[PyLegendUnion[bool, str]] = False,
+            validate: PyLegendOptional[str] = None
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def join(
+            self,
+            other: "PandasApiTdsFrame",
+            on: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str]]] = None,
+            how: PyLegendOptional[str] = "left",
+            lsuffix: str = "",
+            rsuffix: str = "",
+            sort: PyLegendOptional[bool] = False,
+            validate: PyLegendOptional[str] = None
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def rename(
+            self,
+            mapper: PyLegendOptional[PyLegendUnion[PyLegendDict[str, str], PyLegendCallable[[str], str]]] = None,
+            index: PyLegendOptional[PyLegendUnion[PyLegendDict[str, str], PyLegendCallable[[str], str]]] = None,
+            columns: PyLegendOptional[PyLegendUnion[PyLegendDict[str, str], PyLegendCallable[[str], str]]] = None,
+            axis: PyLegendUnion[str, int] = 1,
+            inplace: PyLegendUnion[bool] = False,
+            copy: PyLegendUnion[bool] = True,
+            level: PyLegendOptional[PyLegendUnion[int, str]] = None,
+            errors: str = "ignore",
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def groupby(
+            self,
+            by: PyLegendUnion[str, PyLegendList[str]],
+            level: PyLegendOptional[PyLegendUnion[str, int, PyLegendList[str]]] = None,
+            as_index: bool = False,
+            sort: bool = True,
+            group_keys: bool = False,
+            observed: bool = False,
+            dropna: bool = False,
+    ) -> "PandasApiGroupbyTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def sum(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            min_count: int = 0,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def mean(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def min(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def max(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def std(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            ddof: int = 1,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def var(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            ddof: int = 1,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def count(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def apply(
+            self,
+            func: PyLegendUnion[
+                PyLegendCallable[Concatenate["Series", P], PyLegendPrimitiveOrPythonPrimitive],
+                str
+            ],
+            axis: PyLegendUnion[int, str] = 0,
+            raw: bool = False,
+            result_type: PyLegendOptional[str] = None,
+            args: PyLegendTuple[PyLegendPrimitiveOrPythonPrimitive, ...] = (),
+            by_row: PyLegendUnion[bool, str] = "compat",
+            engine: str = "python",
+            engine_kwargs: PyLegendOptional[PyLegendDict[str, PyLegendPrimitiveOrPythonPrimitive]] = None,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def head(self, n: int = 5) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @property
+    @abstractmethod
+    def shape(self) -> PyLegendTuple[int, int]:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def dropna(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            how: str = "any",
+            thresh: PyLegendOptional[int] = None,
+            subset: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str]]] = None,
+            inplace: bool = False,
+            ignore_index: bool = False
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def fillna(
+            self,
+            value: PyLegendUnion[
+                int, float, str, bool, date, datetime,
+                PyLegendDict[str, PyLegendUnion[int, float, str, bool, date, datetime]]
+            ] = None,  # type: ignore
+            axis: PyLegendOptional[PyLegendUnion[int, str]] = 0,
+            inplace: bool = False,
+            limit: PyLegendOptional[int] = None
     ) -> "PandasApiTdsFrame":
         pass  # pragma: no cover

pylegend/extensions/tds/abstract/csv_tds_frame.py

@@ -0,0 +1,95 @@
+# Copyright 2025 Goldman Sachs
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from abc import ABCMeta
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendList,
+)
+from io import StringIO
+from pylegend.core.tds.tds_column import (
+    PrimitiveType,
+    PrimitiveTdsColumn)
+from pylegend.core.tds.tds_frame import FrameToPureConfig, FrameToSqlConfig, PyLegendTdsFrame
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+)
+import pandas as pd
+
+__all__: PyLegendSequence[str] = [
+    "CsvInputFrameAbstract",
+    "tds_columns_from_csv_string"
+]
+
+
+class CsvInputFrameAbstract(PyLegendTdsFrame, metaclass=ABCMeta):
+    __csv_string: str
+
+    def __init__(
+            self,
+            csv_string: str,
+    ) -> None:
+        super().__init__(columns=tds_columns_from_csv_string(csv_string))  # type: ignore[call-arg]
+        self.__csv_string = csv_string
+
+    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+        raise RuntimeError("SQL generation for csv tds frames is not supported yet.")
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        return f"#TDS\n{self.__csv_string}#"
+
+
+def tds_columns_from_csv_string(
+        csv_string: str
+) -> PyLegendList[PrimitiveTdsColumn]:
+    df = pd.read_csv(StringIO(csv_string))
+    tds_columns = []
+    dt = pd.api.types
+
+    for col in df.columns:
+        dtype = df[col].dtype
+
+        if dt.is_bool_dtype(dtype):
+            primitive_type = PrimitiveType.Boolean
+
+        elif dt.is_integer_dtype(dtype):
+            primitive_type = PrimitiveType.Integer
+
+        elif dt.is_float_dtype(dtype):
+            primitive_type = PrimitiveType.Float
+
+        elif is_strict_date_or_datetime(df[col]):
+            primitive_type = PrimitiveType.Date
+
+        else:
+            primitive_type = PrimitiveType.String
+
+        tds_columns.append(
+            PrimitiveTdsColumn(name=col, _type=primitive_type)
+        )
+
+    return tds_columns
+
+
+def is_strict_date_or_datetime(col: pd.Series) -> bool:  # type: ignore[explicit-any]
+    try:
+        pd.to_datetime(col, format="%Y-%m-%d %H:%M:%S", exact=True, errors="raise")
+        return True
+    except (ValueError, TypeError):
+        pass
+
+    try:
+        pd.to_datetime(col, format="%Y-%m-%d", exact=True, errors="raise")
+        return True
+    except (ValueError, TypeError):
+        return False