Пример #1
0
def test_empty_aware_iterable_recursive():
    i = _get_iterable("1,2,3")
    e = make_empty_aware(i)
    ee = make_empty_aware(_wrap_iterable(e, True))
    assert "1,2,3" == ",".join(ee)
    i = _get_iterable("1,2,3")
    e = make_empty_aware(i)
    ee = make_empty_aware(_wrap_iterable(e, False))
    assert "1t,2t,3t" == ",".join(ee)
Пример #2
0
 def __init__(  # noqa: C901
         self,
         df: Any = None,
         schema: Any = None,
         metadata: Any = None):
     try:
         if df is None:
             idf: Iterable[Any] = []
             orig_schema: Optional[Schema] = None
         elif isinstance(df, IterableDataFrame):
             idf = df.native
             orig_schema = df.schema
         elif isinstance(df, DataFrame):
             idf = df.as_array_iterable(type_safe=False)
             orig_schema = df.schema
         elif isinstance(df, Iterable):
             idf = df
             orig_schema = None
         else:
             raise ValueError(
                 f"{df} is incompatible with IterableDataFrame")
         schema, pos = _get_schema_change(orig_schema, schema)
         super().__init__(schema, metadata)
         self._pos = pos
         self._native = make_empty_aware(self._preprocess(idf))
     except Exception as e:
         raise FugueDataFrameInitError from e
Пример #3
0
 def __init__(  # noqa: C901
         self,
         df: Any = None,
         schema: Any = None,
         metadata: Any = None):
     try:
         if isinstance(df, Iterable):
             self._native = make_empty_aware(self._dfs_wrapper(df))
             orig_schema: Optional[Schema] = None
             if not self._native.empty:
                 orig_schema = self._native.peek().schema
         else:
             raise ValueError(
                 f"{df} is incompatible with LocalDataFrameIterableDataFrame"
             )
         if orig_schema is None and schema is None:
             raise FugueDataFrameInitError(
                 "schema is not provided and the input is empty")
         elif orig_schema is None and schema is not None:
             pass
         elif orig_schema is not None and schema is None:
             schema = orig_schema
         else:
             schema = Schema(schema) if not isinstance(schema,
                                                       Schema) else schema
             assert_or_throw(
                 orig_schema == schema,
                 lambda:
                 f"iterable schema {orig_schema} is different from {schema}",
             )
         super().__init__(schema, metadata)
     except FugueDataFrameError:
         raise
     except Exception as e:
         raise FugueDataFrameInitError from e
Пример #4
0
def test_empty_aware_iterable():
    i = _get_iterable("1,2,3")
    e = make_empty_aware(i)
    assert not e.empty
    assert "1,2,3" == ",".join(e)
    assert e.empty

    i = _get_iterable("1")
    e = EmptyAwareIterable(i)
    assert not e.empty
    assert not e.empty
    assert "1" == ",".join(e)
    assert e.empty

    e = EmptyAwareIterable([])
    assert e.empty
    assert "" == ",".join(e)
    assert e.empty
    raises(StopIteration, lambda: e.peek())

    i = _get_iterable("1,2,3")
    e = EmptyAwareIterable(i)
    assert not e.empty
    assert "1,2" == ",".join(itertools.islice(e, 2))
    assert not e.empty
    assert "3" == ",".join(itertools.islice(e, 2))
    assert e.empty

    i = _get_iterable("1,2,3")
    e = EmptyAwareIterable(iter(i))
    assert not e.empty
    assert "1" == e.peek()
    assert "1,2" == ",".join(itertools.islice(e, 2))
    assert not e.empty
    assert "3" == e.peek()
    assert "3" == ",".join(itertools.islice(e, 2))
    assert e.empty
Пример #5
0
 def to_input_data(self,
                   df: DataFrame) -> EmptyAwareIterable[Dict[str, Any]]:
     return make_empty_aware(df.as_dict_iterable())
Пример #6
0
 def to_input_data(self, df: DataFrame) -> EmptyAwareIterable[List[Any]]:
     return make_empty_aware(df.as_array_iterable(type_safe=True))