gooddata-pandas 1.15.1.dev4__py3-none-any.whl → 1.34.1.dev1__py3-none-any.whl

gooddata_pandas/_version.py

@@ -1,7 +1,4 @@
 # (C) 2021 GoodData Corporation
-try:
-    from importlib import metadata
-except ImportError:
-    import importlib_metadata as metadata  # type: ignore # mypy issue #1153
+from importlib import metadata
 
 __version__: str = metadata.version("gooddata-pandas")

gooddata_pandas/data_access.py

@@ -6,7 +6,7 @@ from typing import Any, Optional, Union
 from gooddata_sdk import (
     Attribute,
     AttributeFilter,
-    CatalogWorkspaceContent,
+    CatalogAttribute,
     ExecutionDefinition,
     ExecutionResponse,
     Filter,
@@ -16,6 +16,7 @@ from gooddata_sdk import (
     ObjId,
     TableDimension,
 )
+from gooddata_sdk.utils import IdObjType, filter_for_attributes_labels
 
 from gooddata_pandas.utils import (
     ColumnsDef,
@@ -119,10 +120,7 @@ class ExecutionDefinitionBuilder:
         if index_by is None:
             return
 
-        if not isinstance(index_by, dict):
-            _index_by = {self._DEFAULT_INDEX_NAME: index_by}
-        else:
-            _index_by = index_by
+        _index_by = {self._DEFAULT_INDEX_NAME: index_by} if not isinstance(index_by, dict) else index_by
 
         for index_name, index_def in _index_by.items():
             if isinstance(index_def, str) and (index_def in self._col_to_attr_idx):
@@ -208,11 +206,14 @@ class ExecutionDefinitionBuilder:
                         raise ValueError(f"AttributeFilter instance referencing metric [{_filter.label}]")
                     else:
                         _filter.label = _str_to_obj_id(_filter.label) or _filter.label
-                elif isinstance(_filter, MetricValueFilter) and isinstance(_filter.metric, str):
-                    if _filter.metric in self._col_to_metric_idx:
-                        # Metric is referenced by local_id which was already generated during creation of columns
-                        # When Metric filter contains ObjId reference, it does not need to be modified
-                        _filter.metric = self._metrics[self._col_to_metric_idx[_filter.metric]].local_id
+                elif (
+                    isinstance(_filter, MetricValueFilter)
+                    and isinstance(_filter.metric, str)
+                    and _filter.metric in self._col_to_metric_idx
+                ):
+                    # Metric is referenced by local_id which was already generated during creation of columns
+                    # When Metric filter contains ObjId reference, it does not need to be modified
+                    _filter.metric = self._metrics[self._col_to_metric_idx[_filter.metric]].local_id
 
         return filters
 
@@ -311,27 +312,32 @@ def _extract_for_metrics_only(response: ExecutionResponse, cols: list, col_to_me
     """
     exec_def = response.exec_def
     result = response.read_result(len(exec_def.metrics))
-    data = dict()
+    if len(result.data) == 0:
+        return {col: [] for col in cols}
+
+    return {col: [result.data[col_to_metric_idx[col]]] for col in cols}
 
-    for col in cols:
-        data[col] = [result.data[col_to_metric_idx[col]]]
 
-    return data
+def _find_attribute(attributes: list[CatalogAttribute], id_obj: IdObjType) -> Union[CatalogAttribute, None]:
+    for attribute in attributes:
+        if attribute.find_label(id_obj) is not None:
+            return attribute
+    return None
 
 
-def _typed_result(catalog: CatalogWorkspaceContent, attribute: Attribute, result_values: list[Any]) -> list[Any]:
+def _typed_result(attributes: list[CatalogAttribute], attribute: Attribute, result_values: list[Any]) -> list[Any]:
     """
     Internal function to convert result_values to proper data types.
 
     Args:
-        catalog (CatalogWorkspaceContent): The catalog workspace content.
+        attributes (list[CatalogAttribute]): The catalog of attributes.
         attribute (Attribute): The attribute for which the typed result will be computed.
         result_values (list[Any]): A list of raw values.
 
     Returns:
         list[Any]: A list of converted values with proper data types.
     """
-    catalog_attribute = catalog.find_label_attribute(attribute.label)
+    catalog_attribute = _find_attribute(attributes, attribute.label)
     if catalog_attribute is None:
         raise ValueError(f"Unable to find attribute {attribute.label} in catalog")
     return [_typed_attribute_value(catalog_attribute, value) for value in result_values]
@@ -339,7 +345,7 @@ def _typed_result(catalog: CatalogWorkspaceContent, attribute: Attribute, result
 
 def _extract_from_attributes_and_maybe_metrics(
     response: ExecutionResponse,
-    catalog: CatalogWorkspaceContent,
+    attributes: list[CatalogAttribute],
     cols: list[str],
     col_to_attr_idx: dict[str, int],
     col_to_metric_idx: dict[str, int],
@@ -382,12 +388,12 @@ def _extract_from_attributes_and_maybe_metrics(
         for idx_name in index:
             rs = result.get_all_header_values(attribute_dim, safe_index_to_attr_idx[idx_name])
             attribute = index_to_attribute[idx_name]
-            index[idx_name] += _typed_result(catalog, attribute, rs)
+            index[idx_name] += _typed_result(attributes, attribute, rs)
         for col in cols:
             if col in col_to_attr_idx:
                 rs = result.get_all_header_values(attribute_dim, col_to_attr_idx[col])
                 attribute = col_to_attribute[col]
-                data[col] += _typed_result(catalog, attribute, rs)
+                data[col] += _typed_result(attributes, attribute, rs)
             elif col_to_metric_idx[col] < len(result.data):
                 data[col] += result.data[col_to_metric_idx[col]]
         if result.is_complete(attribute_dim):
@@ -437,14 +443,18 @@ def compute_and_extract(
     exec_def = response.exec_def
     cols = list(columns.keys())
 
-    catalog = sdk.catalog_workspace_content.get_full_catalog(workspace_id)
-
     if not exec_def.has_attributes():
         return _extract_for_metrics_only(response, cols, col_to_metric_idx), dict()
     else:
+        filter_query = filter_for_attributes_labels(exec_def.attributes)
+        # if there is to many labels then all attributes are fetched and no rsql filter is used
+        # it prevention again 414 Request-URI Too Long
+        attributes = sdk.catalog_workspace_content.get_attributes_catalog(
+            workspace_id, include=["labels", "datasets"], rsql_filter=filter_query
+        )
         return _extract_from_attributes_and_maybe_metrics(
             response,
-            catalog,
+            attributes,
             cols,
             col_to_attr_idx,
             col_to_metric_idx,

gooddata_pandas/dataframe.py

@@ -1,8 +1,7 @@
 # (C) 2021 GoodData Corporation
 from __future__ import annotations
 
-from typing import Optional, Tuple, Union
-from warnings import warn
+from typing import Optional, Union
 
 import pandas
 from gooddata_api_client import models
@@ -184,15 +183,6 @@ class DataFrameFactory:
 
         return self.for_items(columns, filter_by=filter_by, auto_index=auto_index)
 
-    def for_insight(self, insight_id: str, auto_index: bool = True) -> pandas.DataFrame:
-        warn(
-            "This method is deprecated and it will be removed in v1.20.0 release. "
-            "Please use 'for_visualization' method instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.for_visualization(insight_id, auto_index)
-
     def result_cache_metadata_for_exec_result_id(self, result_id: str) -> ResultCacheMetadata:
         """
         Retrieves result cache metadata for given :result_id:
@@ -212,7 +202,7 @@ class DataFrameFactory:
         result_size_dimensions_limits: ResultSizeDimensions = (),
         result_size_bytes_limit: Optional[int] = None,
         page_size: int = _DEFAULT_PAGE_SIZE,
-    ) -> Tuple[pandas.DataFrame, DataFrameMetadata]:
+    ) -> tuple[pandas.DataFrame, DataFrameMetadata]:
         """
         Creates a data frame using an execution definition.
 
@@ -269,8 +259,9 @@ class DataFrameFactory:
         result_size_dimensions_limits: ResultSizeDimensions = (),
         result_size_bytes_limit: Optional[int] = None,
         use_local_ids_in_headers: bool = False,
+        use_primary_labels_in_attributes: bool = False,
         page_size: int = _DEFAULT_PAGE_SIZE,
-    ) -> Tuple[pandas.DataFrame, DataFrameMetadata]:
+    ) -> tuple[pandas.DataFrame, DataFrameMetadata]:
         """
             Retrieves a DataFrame and DataFrame metadata for a given execution result identifier.
 
@@ -298,6 +289,7 @@ class DataFrameFactory:
             result_size_dimensions_limits (ResultSizeDimensions): A tuple containing maximum size of result dimensions.
             result_size_bytes_limit (Optional[int]): Maximum size of result in bytes.
             use_local_ids_in_headers (bool): Use local identifier in headers.
+            use_primary_labels_in_attributes (bool): Use primary labels in attributes.
             page_size (int): Number of records per page.
 
         Returns:
@@ -322,5 +314,6 @@ class DataFrameFactory:
             result_size_dimensions_limits=result_size_dimensions_limits,
             result_size_bytes_limit=result_size_bytes_limit,
             use_local_ids_in_headers=use_local_ids_in_headers,
+            use_primary_labels_in_attributes=use_primary_labels_in_attributes,
             page_size=page_size,
         )

gooddata_pandas/result_convertor.py

@@ -1,14 +1,14 @@
 # (C) 2022 GoodData Corporation
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
+from typing import Any, Callable, Optional, Union, cast
 
 import pandas
 from attrs import define, field, frozen
 from gooddata_sdk import BareExecutionResponse, ExecutionResult, ResultCacheMetadata, ResultSizeDimensions
 
 _DEFAULT_PAGE_SIZE = 100
-_DataHeaders = List[List[Any]]
-_DataArray = List[Union[int, None]]
-LabelOverrides = Dict[str, Dict[str, Dict[str, str]]]
+_DataHeaders = list[list[Any]]
+_DataArray = list[Union[int, None]]
+LabelOverrides = dict[str, dict[str, dict[str, str]]]
 
 
 @frozen
@@ -26,10 +26,10 @@ class _DataWithHeaders:
             Per-dimension grand total headers.
     """
 
-    data: List[_DataArray]
-    data_headers: Tuple[_DataHeaders, Optional[_DataHeaders]]
-    grand_totals: Tuple[Optional[List[_DataArray]], Optional[List[_DataArray]]]
-    grand_total_headers: Tuple[Optional[List[Dict[str, _DataHeaders]]], Optional[List[Dict[str, _DataHeaders]]]]
+    data: list[_DataArray]
+    data_headers: tuple[_DataHeaders, Optional[_DataHeaders]]
+    grand_totals: tuple[Optional[list[_DataArray]], Optional[list[_DataArray]]]
+    grand_total_headers: tuple[Optional[list[dict[str, _DataHeaders]]], Optional[list[dict[str, _DataHeaders]]]]
 
 
 @define
@@ -46,10 +46,10 @@ class _AccumulatedData:
         grand_totals_headers (List[Optional[_DataHeaders]]): Holds the headers for grand total data arrays.
     """
 
-    data: List[_DataArray] = field(init=False, factory=list)
-    data_headers: List[Optional[_DataHeaders]] = field(init=False, factory=lambda: [None, None])
-    grand_totals: List[Optional[List[_DataArray]]] = field(init=False, factory=lambda: [None, None])
-    grand_totals_headers: List[Optional[List[Dict[str, _DataHeaders]]]] = field(
+    data: list[_DataArray] = field(init=False, factory=list)
+    data_headers: list[Optional[_DataHeaders]] = field(init=False, factory=lambda: [None, None])
+    grand_totals: list[Optional[list[_DataArray]]] = field(init=False, factory=lambda: [None, None])
+    grand_totals_headers: list[Optional[list[dict[str, _DataHeaders]]]] = field(
         init=False, factory=lambda: [None, None]
     )
     total_of_grant_totals_processed: bool = field(init=False, default=False)
@@ -125,7 +125,7 @@ class _AccumulatedData:
             # if dims are empty then data contain total of column and row grandtotals so extend existing data array
             if len(dims) == 0:
                 if not self.total_of_grant_totals_processed:
-                    grand_totals_item = cast(List[_DataArray], self.grand_totals[0])
+                    grand_totals_item = cast(list[_DataArray], self.grand_totals[0])
                     for total_idx, total_data in enumerate(grand_total["data"]):
                         grand_totals_item[total_idx].extend(total_data)
                     self.total_of_grant_totals_processed = True
@@ -151,7 +151,7 @@ class _AccumulatedData:
                 # grand totals are already initialized and the code is paging in the direction that reveals
                 # additional grand total values; append them accordingly; no need to consider total headers:
                 # that is because only the grand total data is subject to paging
-                grand_totals_item = cast(List[_DataArray], self.grand_totals[opposite_dim])
+                grand_totals_item = cast(list[_DataArray], self.grand_totals[opposite_dim])
                 if opposite_dim == 0:
                     # have column totals and paging 'to the right'; totals for the new columns are revealed so
                     # extend existing data arrays
@@ -198,14 +198,18 @@ class DataFrameMetadata:
                           execution response.
     """
 
-    row_totals_indexes: List[List[int]]
+    row_totals_indexes: list[list[int]]
     execution_response: BareExecutionResponse
+    primary_labels_from_index: dict[int, dict[str, str]]
+    primary_labels_from_columns: dict[int, dict[str, str]]
 
     @classmethod
     def from_data(
         cls,
-        headers: Tuple[_DataHeaders, Optional[_DataHeaders]],
+        headers: tuple[_DataHeaders, Optional[_DataHeaders]],
         execution_response: BareExecutionResponse,
+        primary_labels_from_index: dict[int, dict[str, str]],
+        primary_labels_from_columns: dict[int, dict[str, str]],
     ) -> "DataFrameMetadata":
         """This method constructs a DataFrameMetadata object from data headers and an execution response.
 
@@ -219,6 +223,8 @@ class DataFrameMetadata:
         return cls(
             row_totals_indexes=row_totals_indexes,
             execution_response=execution_response,
+            primary_labels_from_index=primary_labels_from_index,
+            primary_labels_from_columns=primary_labels_from_columns,
         )
 
 
@@ -304,8 +310,10 @@ def _read_complete_execution_result(
 def _create_header_mapper(
     response: BareExecutionResponse,
     dim: int,
+    primary_attribute_labels_mapping: dict[int, dict[str, str]],
     label_overrides: Optional[LabelOverrides] = None,
     use_local_ids_in_headers: bool = False,
+    use_primary_labels_in_attributes: bool = False,
 ) -> Callable[[Any, Optional[int]], Optional[str]]:
     """
     Prepares a header mapper function which translates header structures into appropriate labels used
@@ -314,9 +322,12 @@ def _create_header_mapper(
     Args:
         response (BareExecutionResponse): Response structure to gather dimension header details.
         dim (int): Dimension id.
+        primary_attribute_labels_mapping (Dict[int, Dict[str, str]]): Dict to be filled by mapping of primary labels to
+            custom labels per level identified by integer.
         label_overrides (Optional[LabelOverrides]): Label overrides. Defaults to None.
         use_local_ids_in_headers (bool): Use local identifiers of header attributes and metrics. Optional.
             Defaults to False.
+        use_primary_labels_in_attributes (bool): Use primary labels in attributes. Optional. Defaults to False.
 
     Returns:
         Callable[[Any, Optional[int]], Optional[str]]: Mapper function.
@@ -334,7 +345,14 @@ def _create_header_mapper(
             pass
         elif "attributeHeader" in header:
             if "labelValue" in header["attributeHeader"]:
-                label = header["attributeHeader"]["labelValue"]
+                label_value = header["attributeHeader"]["labelValue"]
+                primary_label_value = header["attributeHeader"]["primaryLabelValue"]
+                label = primary_label_value if use_primary_labels_in_attributes else label_value
+                if header_idx is not None:
+                    if header_idx in primary_attribute_labels_mapping:
+                        primary_attribute_labels_mapping[header_idx][primary_label_value] = label_value
+                    else:
+                        primary_attribute_labels_mapping[header_idx] = {primary_label_value: label_value}
                 # explicitly handle '(empty value)' if it's None otherwise it's not recognizable in final MultiIndex
                 # backend represents ^^^ by "" (datasource value is "") or None (datasource value is NULL) therefore
                 # if both representation are used it's necessary to set label to unique header label (space) to avoid
@@ -372,11 +390,12 @@ def _create_header_mapper(
 
 def _headers_to_index(
     dim_idx: int,
-    headers: Tuple[_DataHeaders, Optional[_DataHeaders]],
+    headers: tuple[_DataHeaders, Optional[_DataHeaders]],
     response: BareExecutionResponse,
     label_overrides: LabelOverrides,
     use_local_ids_in_headers: bool = False,
-) -> Optional[pandas.Index]:
+    use_primary_labels_in_attributes: bool = False,
+) -> tuple[Optional[pandas.Index], dict[int, dict[str, str]]]:
     """Converts headers to a pandas MultiIndex.
 
     This function converts the headers present in the response to a pandas MultiIndex (can be used in pandas dataframes)
@@ -388,18 +407,26 @@ def _headers_to_index(
         response (BareExecutionResponse): The execution response object with all data.
         label_overrides (LabelOverrides): A dictionary containing label overrides for the headers.
         use_local_ids_in_headers (bool, optional): If True, uses local Ids in headers, otherwise not. Defaults to False.
+        use_primary_labels_in_attributes (bool, optional): If True, uses primary labels in attributes, otherwise not.
+            Defaults to False.
 
     Returns:
-        Optional[pandas.Index]: A pandas MultiIndex object created from the headers, or None if the headers are empty.
+        Tuple[Optional[pandas.Index], Dict[int, Dict[str, str]]: A pandas MultiIndex object created from the headers
+        with primary attribute labels mapping as Dict, or None with empty Dict if the headers are empty.
     """
+    # dict of primary labels and it's custom labels for attributes per level as key
+    primary_attribute_labels_mapping: dict[int, dict[str, str]] = {}
+
     if len(response.dimensions) <= dim_idx or not len(response.dimensions[dim_idx]["headers"]):
-        return None
+        return None, primary_attribute_labels_mapping
 
     mapper = _create_header_mapper(
         response=response,
         dim=dim_idx,
         label_overrides=label_overrides,
         use_local_ids_in_headers=use_local_ids_in_headers,
+        use_primary_labels_in_attributes=use_primary_labels_in_attributes,
+        primary_attribute_labels_mapping=primary_attribute_labels_mapping,
     )
 
     return pandas.MultiIndex.from_arrays(
@@ -408,10 +435,10 @@ def _headers_to_index(
             for header_idx, header_group in enumerate(cast(_DataHeaders, headers[dim_idx]))
         ],
         names=[mapper(dim_header, None) for dim_header in (response.dimensions[dim_idx]["headers"])],
-    )
+    ), primary_attribute_labels_mapping
 
 
-def _merge_grand_totals_into_data(extract: _DataWithHeaders) -> Union[_DataArray, List[_DataArray]]:
+def _merge_grand_totals_into_data(extract: _DataWithHeaders) -> Union[_DataArray, list[_DataArray]]:
     """
     Merges grand totals into the extracted data. This function will mutate the extracted data,
     extending the rows and columns with grand totals. Going with mutation here so as not to copy arrays around.
@@ -422,7 +449,7 @@ def _merge_grand_totals_into_data(extract: _DataWithHeaders) -> Union[_DataArray
     Returns:
         Union[_DataArray, List[_DataArray]]: Mutated data with rows and columns extended with grand totals.
     """
-    data: List[_DataArray] = extract.data
+    data: list[_DataArray] = extract.data
 
     if extract.grand_totals[0] is not None:
         # column totals are computed into extra rows, one row per column total
@@ -438,7 +465,7 @@ def _merge_grand_totals_into_data(extract: _DataWithHeaders) -> Union[_DataArray
     return data
 
 
-def _merge_grand_total_headers_into_headers(extract: _DataWithHeaders) -> Tuple[_DataHeaders, Optional[_DataHeaders]]:
+def _merge_grand_total_headers_into_headers(extract: _DataWithHeaders) -> tuple[_DataHeaders, Optional[_DataHeaders]]:
     """Merges grand total headers into data headers. This function will mutate the extracted data.
 
     Args:
@@ -448,12 +475,12 @@ def _merge_grand_total_headers_into_headers(extract: _DataWithHeaders) -> Tuple[
         Tuple[_DataHeaders, Optional[_DataHeaders]]:
             A tuple containing the modified data headers and the grand total headers if present.
     """
-    headers: Tuple[_DataHeaders, Optional[_DataHeaders]] = extract.data_headers
+    headers: tuple[_DataHeaders, Optional[_DataHeaders]] = extract.data_headers
 
     for dim_idx, grand_total_headers in enumerate(extract.grand_total_headers):
         if grand_total_headers is None:
             continue
-        header = cast(List[List[Any]], headers[dim_idx])
+        header = cast(list[list[Any]], headers[dim_idx])
         for level, grand_total_header in enumerate(grand_total_headers):
             header[level].extend(grand_total_header["headers"])
 
@@ -467,8 +494,9 @@ def convert_execution_response_to_dataframe(
     result_size_dimensions_limits: ResultSizeDimensions,
     result_size_bytes_limit: Optional[int] = None,
     use_local_ids_in_headers: bool = False,
+    use_primary_labels_in_attributes: bool = False,
     page_size: int = _DEFAULT_PAGE_SIZE,
-) -> Tuple[pandas.DataFrame, DataFrameMetadata]:
+) -> tuple[pandas.DataFrame, DataFrameMetadata]:
     """
     Converts execution result to a pandas dataframe, maintaining the dimensionality of the result.
 
@@ -480,6 +508,8 @@ def convert_execution_response_to_dataframe(
         result_size_dimensions_limits (ResultSizeDimensions): Dimension limits for the dataframe.
         result_size_bytes_limit (Optional[int], default=None): Size limit in bytes for the dataframe.
         use_local_ids_in_headers (bool, default=False): Use local ids in headers if True, else use default settings.
+        use_primary_labels_in_attributes (bool, default=False): Use primary labels in attributes if True, else use
+            default settings.
         page_size (int, default=_DEFAULT_PAGE_SIZE): Size of the page.
 
     Returns:
@@ -495,22 +525,33 @@ def convert_execution_response_to_dataframe(
     full_data = _merge_grand_totals_into_data(extract)
     full_headers = _merge_grand_total_headers_into_headers(extract)
 
+    index, primary_labels_from_index = _headers_to_index(
+        dim_idx=0,
+        headers=full_headers,
+        response=execution_response,
+        label_overrides=label_overrides,
+        use_local_ids_in_headers=use_local_ids_in_headers,
+        use_primary_labels_in_attributes=use_primary_labels_in_attributes,
+    )
+
+    columns, primary_labels_from_columns = _headers_to_index(
+        dim_idx=1,
+        headers=full_headers,
+        response=execution_response,
+        label_overrides=label_overrides,
+        use_local_ids_in_headers=use_local_ids_in_headers,
+        use_primary_labels_in_attributes=use_primary_labels_in_attributes,
+    )
+
     df = pandas.DataFrame(
         data=full_data,
-        index=_headers_to_index(
-            dim_idx=0,
-            headers=full_headers,
-            response=execution_response,
-            label_overrides=label_overrides,
-            use_local_ids_in_headers=use_local_ids_in_headers,
-        ),
-        columns=_headers_to_index(
-            dim_idx=1,
-            headers=full_headers,
-            response=execution_response,
-            label_overrides=label_overrides,
-            use_local_ids_in_headers=use_local_ids_in_headers,
-        ),
+        index=index,
+        columns=columns,
     )
 
-    return df, DataFrameMetadata.from_data(headers=full_headers, execution_response=execution_response)
+    return df, DataFrameMetadata.from_data(
+        headers=full_headers,
+        execution_response=execution_response,
+        primary_labels_from_index=primary_labels_from_index,
+        primary_labels_from_columns=primary_labels_from_columns,
+    )

gooddata_pandas/utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import hashlib
 import uuid
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 import pandas
 from gooddata_sdk import (
@@ -20,8 +20,8 @@ from pandas import Index, MultiIndex
 
 LabelItemDef = Union[Attribute, ObjId, str]
 DataItemDef = Union[Attribute, Metric, ObjId, str]
-IndexDef = Union[LabelItemDef, Dict[str, LabelItemDef]]
-ColumnsDef = Dict[str, DataItemDef]
+IndexDef = Union[LabelItemDef, dict[str, LabelItemDef]]
+ColumnsDef = dict[str, DataItemDef]
 
 # register external pandas types to converters
 IntegerConverter.set_external_fnc(lambda self, value: pandas.to_numeric(value))