Flowfile 0.3.1.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

flowfile_frame/lazy_methods.py

@@ -0,0 +1,201 @@
+import polars as pl
+from functools import wraps
+from typing import Optional, TypeVar, Type, Callable
+from flowfile_frame.utils import _get_function_source
+from flowfile_frame.config import logger
+
+T = TypeVar('T')
+FlowFrameT = TypeVar('FlowFrameT', bound='FlowFrame')
+
+PASSTHROUGH_METHODS = {
+    'collect', 'collect_async', 'profile', 'describe', 'explain',
+    'show_graph', 'fetch', 'collect_schema', 'columns', 'dtypes',
+    'schema', 'width', 'estimated_size', 'n_chunks', 'is_empty',
+    'chunk_lengths', 'get_meta'
+}
+
+
+def create_lazyframe_method_wrapper(method_name: str, original_method: Callable) -> Callable:
+    """
+    Creates a wrapper for a LazyFrame method that properly integrates with FlowFrame.
+
+    Parameters
+    ----------
+    method_name : str
+        Name of the LazyFrame method.
+    original_method : Callable
+        The original LazyFrame method.
+
+    Returns
+    -------
+    Callable
+        A wrapper method appropriate for FlowFrame.
+    """
+    # Determine if the original method returns a LazyFrame based on known method names
+    lazyframe_returning_methods = {
+        "drop", "select", "with_columns", "sort", "filter", "join", "head", "tail",
+        "limit", "drop_nulls", "fill_null", "with_row_index", "group_by", "explode",
+        "unique", "slice", "shift", "reverse", "max", "min", "sum", "mean", "median",
+        "std", "var", "drop_nans", "fill_nan", "interpolate", "null_count", "quantile",
+        "unpivot", "melt", "first", "last"
+    }
+
+    non_lazyframe_methods = {
+        "collect", "collect_schema", "fetch", "columns", "dtypes", "schema", "width",
+        "describe", "explain", "profile", "show_graph"
+    }
+
+    returns_lazyframe = (
+            method_name in lazyframe_returning_methods or
+            (method_name not in non_lazyframe_methods and not method_name.startswith("_"))
+    )
+
+    @wraps(original_method)
+    def wrapper(self, *args, description: Optional[str] = None, **kwargs):
+        # Import here to avoid circular imports
+        from flowfile_frame.flow_frame import generate_node_id
+        new_node_id = generate_node_id()
+
+        if not all([True if not hasattr(arg, "convertable_to_code") else getattr(arg, 'convertable_to_code') for arg in
+                    args]):
+            logger.debug("Warning, could not create a good node")
+            return self.__class__(getattr(self.data, method_name)(arg.expr for arg in args), flow_graph=self.flow_graph)
+
+        # Collect function sources and build representations
+        function_sources = []
+        args_representations = []
+        kwargs_representations = []
+
+        # Process positional arguments
+        for arg in args:
+            if callable(arg) and not isinstance(arg, type):
+                # Try to get function source
+                try:
+                    source, is_module_level = _get_function_source(arg)
+                    if source and hasattr(arg, '__name__') and arg.__name__ != '<lambda>':
+                        function_sources.append(source)
+                        # Use the function name in the representation
+                        args_representations.append(arg.__name__)
+                    else:
+                        # Fallback to repr if we can't get the source
+                        args_representations.append(repr(arg))
+                except:
+                    args_representations.append(repr(arg))
+            else:
+                args_representations.append(repr(arg))
+        # Process keyword arguments
+        for key, value in kwargs.items():
+            if callable(value) and not isinstance(value, type):
+                # Try to get function source
+                try:
+                    source, is_module_level = _get_function_source(value)
+                    if source and hasattr(value, '__name__') and value.__name__ != '<lambda>':
+                        function_sources.append(source)
+                        kwargs_representations.append(f"{key}={value.__name__}")
+                    else:
+                        kwargs_representations.append(f"{key}={repr(value)}")
+                except:
+                    kwargs_representations.append(f"{key}={repr(value)}")
+            else:
+                kwargs_representations.append(f"{key}={repr(value)}")
+
+        # Build parameter string
+        args_str = ", ".join(args_representations)
+        kwargs_str = ", ".join(kwargs_representations)
+
+        if args_str and kwargs_str:
+            params_str = f"{args_str}, {kwargs_str}"
+        elif args_str:
+            params_str = args_str
+        elif kwargs_str:
+            params_str = kwargs_str
+        else:
+            params_str = ""
+
+        # Build the code
+        operation_code = f"input_df.{method_name}({params_str})"
+
+        if function_sources:
+            unique_sources = []
+            seen = set()
+            for source in function_sources:
+                if source not in seen:
+                    seen.add(source)
+                    unique_sources.append(source)
+
+            functions_section = "# Function definitions\n" + "\n\n".join(unique_sources)
+            code = functions_section + "\n#─────SPLIT─────\n\noutput_df = " + operation_code
+        else:
+            code = "output_df = " + operation_code
+
+        # Use provided description or generate a default one
+        if description is None:
+            description = f"{method_name.replace('_', ' ').title()} operation"
+
+        self._add_polars_code(new_node_id, code, description)
+
+        if returns_lazyframe:
+            # Return a new FlowFrame with the result
+            return self._create_child_frame(new_node_id)
+        else:
+            # For methods that don't return a LazyFrame, return the result directly
+            return getattr(self.data, method_name)(*args, **kwargs)
+
+    return wrapper
+
+
+def add_lazyframe_methods(cls):
+    """
+    Class decorator that adds all LazyFrame methods to a class.
+
+    This adds the methods at class creation time, so they are visible to static type checkers.
+    Methods already defined in the class are not overwritten.
+
+    Parameters
+    ----------
+    cls : Type
+        The class to which the methods will be added.
+
+    Returns
+    -------
+    Type
+        The modified class.
+    """
+    # Get methods already defined in the class (including inherited methods)
+    existing_methods = set(dir(cls))
+
+    # Skip properties and private methods
+    skip_methods = {
+        name for name in dir(pl.LazyFrame)
+        if name.startswith('_') or isinstance(getattr(pl.LazyFrame, name), property)
+    }
+
+    # Add all public LazyFrame methods that don't already exist
+    for name in dir(pl.LazyFrame):
+        if name in existing_methods or name in skip_methods:
+            continue
+        attr = getattr(pl.LazyFrame, name)
+        if name in PASSTHROUGH_METHODS:
+            def create_passthrough_method(method_name, method_attr):
+
+                @wraps(method_attr)
+                def passthrough_method(self, *args, **kwargs):
+                    return getattr(self.data, method_name)(*args, **kwargs)
+
+                return passthrough_method
+
+            setattr(cls, name, create_passthrough_method(name, attr))
+
+        else:
+            attr = getattr(pl.LazyFrame, name)
+            if callable(attr):
+                wrapped_method = create_lazyframe_method_wrapper(name, attr)
+                setattr(cls, name, wrapped_method)
+
+    overlap = {
+        name for name in existing_methods
+        if name in dir(pl.LazyFrame) and not name.startswith('_') and callable(getattr(pl.LazyFrame, name))
+    }
+    if overlap:
+        logger.debug(f"Preserved existing methods in {cls.__name__}: {', '.join(sorted(overlap))}")
+    return cls

flowfile_frame/list_name_space.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+from typing import Any, Optional, Union, TYPE_CHECKING, List, TypeVar, Callable, Sequence, Literal
+
+import polars as pl
+
+
+# --- TYPE CHECKING IMPORTS ---
+if TYPE_CHECKING:
+    from flowfile_frame.expr import Expr, _get_expr_and_repr, col, lit
+    from polars._typing import IntoExprColumn, NullBehavior, ListToStructWidthStrategy
+    from datetime import date, datetime, time
+
+
+class ExprListNameSpace:
+    """Namespace for list related expressions."""
+
+    def __init__(self, parent_expr: 'Expr', parent_repr_str: str):
+        self.parent = parent_expr
+        self.expr = parent_expr.expr.list if parent_expr.expr is not None else None
+        self.parent_repr_str = parent_repr_str
+
+    def _create_next_expr(self, *args, method_name: str, result_expr: Optional[pl.Expr], is_complex: bool = True, **kwargs) -> 'Expr':
+        from flowfile_frame.expr import Expr
+        """Creates a new Expr instance, appending method call to repr string."""
+        args_repr = ", ".join(repr(a) for a in args)
+        kwargs_repr = ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())
+
+        if args_repr and kwargs_repr:
+            args_str = f"{args_repr}, {kwargs_repr}"
+        elif args_repr:
+            args_str = args_repr
+        elif kwargs_repr:
+            args_str = kwargs_repr
+        else:
+            args_str = ""
+
+        new_repr = f"{self.parent_repr_str}.list.{method_name}({args_str})"
+
+        # Create new instance, inheriting current agg_func status by default
+        new_expr_instance = Expr(
+            result_expr,
+            self.parent.column_name,
+            repr_str=new_repr,
+            initial_column_name=self.parent._initial_column_name,
+            selector=None,
+            agg_func=self.parent.agg_func,
+            is_complex=is_complex,
+            convertable_to_code=self.parent.convertable_to_code
+        )
+        return new_expr_instance
+
+    def all(self) -> Expr:
+        res_expr = self.expr.all() if self.expr is not None else None
+        return self._create_next_expr(method_name="all", result_expr=res_expr)
+
+    def any(self) -> Expr:
+        res_expr = self.expr.any() if self.expr is not None else None
+        return self._create_next_expr(method_name="any", result_expr=res_expr)
+
+    def len(self) -> Expr:
+        res_expr = self.expr.len() if self.expr is not None else None
+        return self._create_next_expr(method_name="len", result_expr=res_expr)
+
+    def drop_nulls(self) -> Expr:
+        res_expr = self.expr.drop_nulls() if self.expr is not None else None
+        return self._create_next_expr(method_name="drop_nulls", result_expr=res_expr)
+
+    def sample(
+            self,
+            n: int | IntoExprColumn | None = None,
+            *,
+            fraction: float | IntoExprColumn | None = None,
+            with_replacement: bool = False,
+            shuffle: bool = False,
+            seed: int | None = None,
+    ) -> Expr:
+        if n is not None and fraction is not None:
+            raise ValueError("cannot specify both `n` and `fraction`")
+
+        res_expr = None
+        if self.expr is not None:
+            try:
+                if fraction is not None:
+                    expr_fraction = fraction.expr if hasattr(fraction, 'expr') else fraction
+                    res_expr = self.expr.sample(n=None, fraction=expr_fraction,
+                                                with_replacement=with_replacement,
+                                                shuffle=shuffle, seed=seed)
+                else:
+                    expr_n = n.expr if hasattr(n, 'expr') else (1 if n is None else n)
+                    res_expr = self.expr.sample(n=expr_n, fraction=None,
+                                                with_replacement=with_replacement,
+                                                shuffle=shuffle, seed=seed)
+            except Exception as e:
+                print(f"Warning: Could not create polars expression for list.sample(): {e}")
+
+        return self._create_next_expr(
+            n if n is not None else None,
+            method_name="sample",
+            result_expr=res_expr,
+            fraction=fraction,
+            with_replacement=with_replacement,
+            shuffle=shuffle,
+            seed=seed
+        )
+
+    def sum(self) -> Expr:
+        res_expr = self.expr.sum() if self.expr is not None else None
+        return self._create_next_expr(method_name="sum", result_expr=res_expr)
+
+    def max(self) -> Expr:
+        res_expr = self.expr.max() if self.expr is not None else None
+        return self._create_next_expr(method_name="max", result_expr=res_expr)
+
+    def min(self) -> Expr:
+        res_expr = self.expr.min() if self.expr is not None else None
+        return self._create_next_expr(method_name="min", result_expr=res_expr)
+
+    def mean(self) -> Expr:
+        res_expr = self.expr.mean() if self.expr is not None else None
+        return self._create_next_expr(method_name="mean", result_expr=res_expr)
+
+    def median(self) -> Expr:
+        res_expr = self.expr.median() if self.expr is not None else None
+        return self._create_next_expr(method_name="median", result_expr=res_expr)
+
+    def std(self, ddof: int = 1) -> Expr:
+        res_expr = self.expr.std(ddof=ddof) if self.expr is not None else None
+        return self._create_next_expr(method_name="std", result_expr=res_expr, ddof=ddof)
+
+    def var(self, ddof: int = 1) -> Expr:
+        res_expr = self.expr.var(ddof=ddof) if self.expr is not None else None
+        return self._create_next_expr(method_name="var", result_expr=res_expr, ddof=ddof)
+
+    def sort(self, *, descending: bool = False, nulls_last: bool = False) -> Expr:
+        res_expr = self.expr.sort(descending=descending, nulls_last=nulls_last) if self.expr is not None else None
+        return self._create_next_expr(method_name="sort", result_expr=res_expr, descending=descending, nulls_last=nulls_last)
+
+    def reverse(self) -> Expr:
+        res_expr = self.expr.reverse() if self.expr is not None else None
+        return self._create_next_expr(method_name="reverse", result_expr=res_expr)
+
+    def unique(self, *, maintain_order: bool = False) -> Expr:
+        res_expr = self.expr.unique(maintain_order=maintain_order) if self.expr is not None else None
+        return self._create_next_expr(method_name="unique", result_expr=res_expr, maintain_order=maintain_order)
+
+    def n_unique(self) -> Expr:
+        res_expr = self.expr.n_unique() if self.expr is not None else None
+        return self._create_next_expr(method_name="n_unique", result_expr=res_expr)
+
+    def concat(self, other: list[Expr | str] | Expr | str | pl.Series | list[Any]) -> Expr:
+        res_expr = None
+        other_expr = None
+
+        # Handle different types of 'other'
+        if isinstance(other, (Expr, str)):
+            if isinstance(other, Expr):
+                other_expr = other.expr
+            else:
+                other_expr = pl.col(other)
+        elif isinstance(other, pl.Series):
+            other_expr = pl.lit(other)
+        elif isinstance(other, list):
+            if len(other) > 0 and isinstance(other[0], (Expr, str, pl.Series)):
+                # List of expressions
+                other_expr = [o.expr if hasattr(o, 'expr') else (pl.col(o) if isinstance(o, str) else o) for o in other]
+            else:
+                # List of values
+                other_expr = pl.lit(other)
+
+        # Create the polars expression if possible
+        if self.expr is not None and other_expr is not None:
+            try:
+                if isinstance(other_expr, list):
+                    # Insert self.expr at the beginning
+                    all_exprs = [self.parent.expr] + other_expr
+                    res_expr = pl.concat_list(all_exprs)
+                else:
+                    res_expr = self.expr.concat(other_expr)
+            except Exception as e:
+                print(f"Warning: Could not create polars expression for list.concat(): {e}")
+
+        return self._create_next_expr(other, method_name="concat", result_expr=res_expr)
+
+    def get(self, index: int | Expr | str, *, null_on_oob: bool = False) -> Expr:
+        index_expr = index.expr if hasattr(index, 'expr') else index
+        res_expr = self.expr.get(index_expr, null_on_oob=null_on_oob) if self.expr is not None else None
+        return self._create_next_expr(index, method_name="get", result_expr=res_expr, null_on_oob=null_on_oob)
+
+    def gather(self, indices: Expr | pl.Series | list[int] | list[list[int]], *, null_on_oob: bool = False) -> Expr:
+        indices_expr = indices
+        if isinstance(indices, list):
+            indices_expr = pl.Series(indices)
+        elif hasattr(indices, 'expr'):
+            indices_expr = indices.expr
+
+        res_expr = self.expr.gather(indices_expr, null_on_oob=null_on_oob) if self.expr is not None else None
+        return self._create_next_expr(indices, method_name="gather", result_expr=res_expr, null_on_oob=null_on_oob)
+
+    def gather_every(self, n: int | IntoExprColumn, offset: int | IntoExprColumn = 0) -> Expr:
+        n_expr = n.expr if hasattr(n, 'expr') else n
+        offset_expr = offset.expr if hasattr(offset, 'expr') else offset
+
+        res_expr = self.expr.gather_every(n_expr, offset_expr) if self.expr is not None else None
+        return self._create_next_expr(n, method_name="gather_every", result_expr=res_expr, offset=offset)
+
+    def first(self) -> Expr:
+        res_expr = self.expr.first() if self.expr is not None else None
+        return self._create_next_expr(method_name="first", result_expr=res_expr)
+
+    def last(self) -> Expr:
+        res_expr = self.expr.last() if self.expr is not None else None
+        return self._create_next_expr(method_name="last", result_expr=res_expr)
+
+    def contains(self, item: float | str | bool | int | date | datetime | time | IntoExprColumn) -> Expr:
+        item_expr = item.expr if hasattr(item, 'expr') else item
+        res_expr = self.expr.contains(item_expr) if self.expr is not None else None
+        return self._create_next_expr(item, method_name="contains", result_expr=res_expr)
+
+    def join(self, separator: IntoExprColumn, *, ignore_nulls: bool = True) -> Expr:
+        separator_expr = separator.expr if hasattr(separator, 'expr') else separator
+        res_expr = self.expr.join(separator_expr, ignore_nulls=ignore_nulls) if self.expr is not None else None
+        return self._create_next_expr(separator, method_name="join", result_expr=res_expr, ignore_nulls=ignore_nulls)
+
+    def arg_min(self) -> Expr:
+        res_expr = self.expr.arg_min() if self.expr is not None else None
+        return self._create_next_expr(method_name="arg_min", result_expr=res_expr)
+
+    def arg_max(self) -> Expr:
+        res_expr = self.expr.arg_max() if self.expr is not None else None
+        return self._create_next_expr(method_name="arg_max", result_expr=res_expr)
+
+    def diff(self, n: int = 1, null_behavior: NullBehavior = "ignore") -> Expr:
+        res_expr = self.expr.diff(n, null_behavior) if self.expr is not None else None
+        return self._create_next_expr(method_name="diff", result_expr=res_expr, n=n, null_behavior=null_behavior)
+
+    def shift(self, n: int | IntoExprColumn = 1) -> Expr:
+        n_expr = n.expr if hasattr(n, 'expr') else n
+        res_expr = self.expr.shift(n_expr) if self.expr is not None else None
+        return self._create_next_expr(n, method_name="shift", result_expr=res_expr)
+
+    def slice(self, offset: int | str | Expr, length: int | str | Expr | None = None) -> Expr:
+        offset_expr = offset.expr if hasattr(offset, 'expr') else offset
+        length_expr = length.expr if hasattr(length, 'expr') and length is not None else length
+
+        res_expr = self.expr.slice(offset_expr, length_expr) if self.expr is not None else None
+        return self._create_next_expr(offset, length, method_name="slice", result_expr=res_expr)
+
+    def head(self, n: int | str | Expr = 5) -> Expr:
+        n_expr = n.expr if hasattr(n, 'expr') else n
+        res_expr = self.expr.head(n_expr) if self.expr is not None else None
+        return self._create_next_expr(n, method_name="head", result_expr=res_expr)
+
+    def tail(self, n: int | str | Expr = 5) -> Expr:
+        n_expr = n.expr if hasattr(n, 'expr') else n
+        res_expr = self.expr.tail(n_expr) if self.expr is not None else None
+        return self._create_next_expr(n, method_name="tail", result_expr=res_expr)
+
+    def explode(self) -> Expr:
+        res_expr = self.expr.explode() if self.expr is not None else None
+        return self._create_next_expr(method_name="explode", result_expr=res_expr)
+
+    def count_matches(self, element: Any) -> Expr:
+        element_expr = element.expr if hasattr(element, 'expr') else element
+        res_expr = self.expr.count_matches(element_expr) if self.expr is not None else None
+        return self._create_next_expr(element, method_name="count_matches", result_expr=res_expr)
+
+    def to_array(self, width: int) -> Expr:
+        res_expr = self.expr.to_array(width) if self.expr is not None else None
+        return self._create_next_expr(width, method_name="to_array", result_expr=res_expr)
+
+    def to_struct(
+            self,
+            n_field_strategy: ListToStructWidthStrategy = "first_non_null",
+            fields: Sequence[str] | Callable[[int], str] | None = None,
+            upper_bound: int = 0,
+    ) -> Expr:
+        res_expr = None
+
+        if self.expr is not None:
+            try:
+                if isinstance(fields, Sequence):
+                    res_expr = self.expr.to_struct(fields=fields)
+                else:
+                    res_expr = self.expr.to_struct(
+                        n_field_strategy=n_field_strategy,
+                        fields=fields,
+                        upper_bound=upper_bound
+                    )
+            except Exception as e:
+                print(f"Warning: Could not create polars expression for list.to_struct(): {e}")
+
+        return self._create_next_expr(
+            method_name="to_struct",
+            result_expr=res_expr,
+            n_field_strategy=n_field_strategy,
+            fields=fields,
+            upper_bound=upper_bound,
+        )
+
+    def eval(self, expr: Expr, *, parallel: bool = False) -> Expr:
+        expr_inner = expr.expr if hasattr(expr, 'expr') else expr
+        res_expr = self.expr.eval(expr_inner, parallel=parallel) if self.expr is not None else None
+        return self._create_next_expr(expr, method_name="eval", result_expr=res_expr, parallel=parallel)
+
+    def set_union(self, other: Any) -> Expr:
+        other_expr = other.expr if hasattr(other, 'expr') else other
+        res_expr = self.expr.set_union(other_expr) if self.expr is not None else None
+        return self._create_next_expr(other, method_name="set_union", result_expr=res_expr)
+
+    def set_difference(self, other: Any) -> Expr:
+        other_expr = other.expr if hasattr(other, 'expr') else other
+        res_expr = self.expr.set_difference(other_expr) if self.expr is not None else None
+        return self._create_next_expr(other, method_name="set_difference", result_expr=res_expr)
+
+    def set_intersection(self, other: Any) -> Expr:
+        other_expr = other.expr if hasattr(other, 'expr') else other
+        res_expr = self.expr.set_intersection(other_expr) if self.expr is not None else None
+        return self._create_next_expr(other, method_name="set_intersection", result_expr=res_expr)
+
+    def set_symmetric_difference(self, other: Any) -> Expr:
+        other_expr = other.expr if hasattr(other, 'expr') else other
+        res_expr = self.expr.set_symmetric_difference(other_expr) if self.expr is not None else None
+        return self._create_next_expr(other, method_name="set_symmetric_difference", result_expr=res_expr)

flowfile_frame/selectors.py

@@ -51,6 +51,9 @@ class Selector:
         # Expr init will handle creating the 'pl.sum(selector)' repr
         return Expr(expr=None, selector=self, agg_func="sum")
 
+    def expr(self):
+        return eval(self.repr_str)
+
     def mean(self) -> 'Expr':
         """Create an expression to average columns selected by this selector."""
         return Expr(expr=None, selector=self, agg_func="mean")

flowfile_frame/series.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+import polars as pl
+from typing import Any, Optional, Union, List
+
+
+class Series:
+    """
+    A wrapper around polars.Series that represents itself as the code to create it.
+    """
+
+    def __init__(
+            self,
+            name: str | list | pl.Series | None = None,
+            values: list | None = None,
+            dtype: Any = None,
+            **kwargs  # Ignored parameters
+    ):
+        """
+        Initialize a FlowSeries with the same API as pl.Series.
+        """
+        # Store the original arguments for proper representation
+        self._name = name
+        self._values = values
+        self._dtype = dtype
+
+        # Handle the different initialization forms
+        if isinstance(name, pl.Series):
+            self._s = name
+            # Update our attributes to match the series
+            self._name = name.name
+            self._values = name.to_list()
+            self._dtype = name.dtype
+        elif isinstance(name, (list, tuple)) and values is None:
+            self._s = pl.Series(values=name, dtype=dtype)
+            self._name = ""  # Default name is empty string
+            self._values = name
+        else:
+            self._s = pl.Series(name=name, values=values, dtype=dtype)
+
+    def __repr__(self) -> str:
+        """
+        Return a string that looks like the code to create this Series.
+        Example: pl.Series("c", [1, 2, 3])
+        """
+        # Format name
+        if self._name:
+            name_str = f'"{self._name}"'
+        else:
+            name_str = '""'
+
+        # Format values
+        if self._values is None:
+            values_str = "[]"
+        elif len(self._values) <= 10:
+            values_str = str(self._values)
+        else:
+            # Show first few elements for long lists
+            sample = self._values[:3]
+            values_str = f"[{', '.join(map(str, sample))}, ...]"
+
+        # Format dtype if provided
+        dtype_str = ""
+        if self._dtype is not None:
+            dtype_str = f", dtype={self._dtype}"
+
+        return f"pl.Series({name_str}, {values_str}{dtype_str})"
+
+    def __str__(self) -> str:
+        """Same as __repr__."""
+        return self.__repr__()