fugue 0.8.7.dev7__py3-none-any.whl → 0.9.0__py3-none-any.whl

fugue_test/fixtures.py

@@ -0,0 +1,61 @@
+import pytest
+
+_DEFAULT_SCOPE = "module"
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def pandas_session():
+    yield "pandas"
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def native_session():
+    yield "native"
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def dask_session():
+    from fugue_dask.tester import DaskTestBackend
+
+    with DaskTestBackend.generate_session_fixture() as session:
+        yield session
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def duckdb_session():
+    from fugue_duckdb.tester import DuckDBTestBackend
+
+    with DuckDBTestBackend.generate_session_fixture() as session:
+        yield session
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def duckdask_session():
+    from fugue_duckdb.tester import DuckDaskTestBackend
+
+    with DuckDaskTestBackend.generate_session_fixture() as session:
+        yield session
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def ray_session():
+    from fugue_ray.tester import RayTestBackend
+
+    with RayTestBackend.generate_session_fixture() as session:
+        yield session
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def spark_session():
+    from fugue_spark.tester import SparkTestBackend
+
+    with SparkTestBackend.generate_session_fixture() as session:
+        yield session
+
+
+@pytest.fixture(scope=_DEFAULT_SCOPE)
+def sparkconnect_session():
+    from fugue_spark.tester import SparkConnectTestBackend
+
+    with SparkConnectTestBackend.generate_session_fixture() as session:
+        yield session

fugue_version/__init__.py

@@ -1 +1 @@
-__version__ = "0.8.7"
+__version__ = "0.9.0"

fugue-0.8.7.dev7.dist-info/entry_points.txt

@@ -1,17 +0,0 @@
-[fugue.plugins]
-dask = fugue_dask.registry [dask]
-dask_ibis = fugue_dask.ibis_engine [dask,ibis]
-duckdb = fugue_duckdb.registry [duckdb]
-duckdb_ibis = fugue_duckdb.ibis_engine [ibis,duckdb]
-ibis = fugue_ibis [ibis]
-polars = fugue_polars.registry [polars]
-ray = fugue_ray.registry [ray]
-spark = fugue_spark.registry [spark]
-spark_ibis = fugue_spark.ibis_engine [spark,ibis]
-
-[pytest11]
-fugue_test_dask = fugue_test.plugins.dask [dask]
-fugue_test_duckdb = fugue_test.plugins.duckdb [duckdb]
-fugue_test_misc = fugue_test.plugins.misc
-fugue_test_ray = fugue_test.plugins.ray [ray]
-

fugue_dask/ibis_engine.py

@@ -1,62 +0,0 @@
-from typing import Any, Callable
-
-import dask.dataframe as dd
-import ibis
-from ibis.backends.dask import Backend
-from triad.utils.assertion import assert_or_throw
-
-from fugue import DataFrame, DataFrames, ExecutionEngine
-from fugue_dask.dataframe import DaskDataFrame
-from fugue_dask.execution_engine import DaskExecutionEngine
-from fugue_ibis import IbisTable
-from fugue_ibis._utils import to_ibis_schema, to_schema
-from fugue_ibis.execution.ibis_engine import IbisEngine, parse_ibis_engine
-
-
-class DaskIbisEngine(IbisEngine):
-    def __init__(self, execution_engine: ExecutionEngine) -> None:
-        assert_or_throw(
-            isinstance(execution_engine, DaskExecutionEngine),
-            lambda: ValueError(
-                f"DaskIbisEngine must use DaskExecutionEngine ({execution_engine})"
-            ),
-        )
-        super().__init__(execution_engine)
-
-    def select(
-        self, dfs: DataFrames, ibis_func: Callable[[ibis.BaseBackend], IbisTable]
-    ) -> DataFrame:
-        pdfs = {
-            k: self.execution_engine.to_df(v).native  # type: ignore
-            for k, v in dfs.items()
-        }
-        be = _BackendWrapper().connect(pdfs)
-        be.set_schemas(dfs)
-        expr = ibis_func(be)
-        schema = to_schema(expr.schema())
-        result = expr.compile()
-        assert_or_throw(
-            isinstance(result, dd.DataFrame),
-            lambda: ValueError(f"result must be a Dask DataFrame ({type(result)})"),
-        )
-        return DaskDataFrame(result, schema=schema)
-
-
-@parse_ibis_engine.candidate(
-    lambda obj, *args, **kwargs: isinstance(obj, DaskExecutionEngine)
-)
-def _to_dask_ibis_engine(obj: Any, engine: ExecutionEngine) -> IbisEngine:
-    return DaskIbisEngine(engine)
-
-
-class _BackendWrapper(Backend):
-    def set_schemas(self, dfs: DataFrames) -> None:
-        self._schemas = {k: to_ibis_schema(v.schema) for k, v in dfs.items()}
-
-    def table(self, name: str, schema: Any = None):
-        return super().table(
-            name,
-            schema=self._schemas[name]
-            if schema is None and name in self._schemas
-            else schema,
-        )

fugue_duckdb/ibis_engine.py

@@ -1,56 +0,0 @@
-from typing import Any, Callable, Dict, Optional, Tuple
-
-import ibis
-from ibis.backends.pandas import Backend
-
-from fugue import DataFrame, DataFrames, ExecutionEngine
-from fugue.collections.sql import StructuredRawSQL, TempTableName
-from fugue_ibis import IbisTable
-from fugue_ibis._utils import to_ibis_schema
-from fugue_ibis.execution.ibis_engine import IbisEngine, parse_ibis_engine
-
-from .execution_engine import DuckDBEngine, DuckExecutionEngine
-
-
-class DuckDBIbisEngine(IbisEngine):
-    def select(
-        self, dfs: DataFrames, ibis_func: Callable[[ibis.BaseBackend], IbisTable]
-    ) -> DataFrame:
-        be = _BackendWrapper().connect({})
-        be.set_schemas(dfs)
-        expr = ibis_func(be)
-        sql = StructuredRawSQL.from_expr(
-            str(
-                ibis.postgres.compile(expr).compile(
-                    compile_kwargs={"literal_binds": True}
-                )
-            ),
-            prefix='"<tmpdf:',
-            suffix='>"',
-            dialect="postgres",
-        )
-
-        engine = DuckDBEngine(self.execution_engine)
-        _dfs = DataFrames({be._name_map[k][0].key: v for k, v in dfs.items()})
-        return engine.select(_dfs, sql)
-
-
-@parse_ibis_engine.candidate(
-    lambda obj, *args, **kwargs: isinstance(obj, DuckExecutionEngine)
-    or (isinstance(obj, str) and obj in ["duck", "duckdb"])
-)
-def _to_duck_ibis_engine(obj: Any, engine: ExecutionEngine) -> Optional[IbisEngine]:
-    return DuckDBIbisEngine(engine)
-
-
-class _BackendWrapper(Backend):
-    def set_schemas(self, dfs: DataFrames) -> None:
-        self._schemas = {k: to_ibis_schema(v.schema) for k, v in dfs.items()}
-        self._name_map: Dict[str, Tuple[TempTableName, IbisTable]] = {}
-
-    def table(self, name: str, schema: Any = None) -> IbisTable:
-        if name not in self._name_map:
-            tn = TempTableName()
-            tb = ibis.table(self._schemas[name], name=(str(tn)))
-            self._name_map[name] = (tn, tb)
-        return self._name_map[name][1]

fugue_ibis/execution/ibis_engine.py

@@ -1,49 +0,0 @@
-from abc import abstractmethod
-from typing import Any, Callable
-
-import ibis
-
-from fugue import AnyDataFrame, DataFrame, DataFrames, EngineFacet, ExecutionEngine
-from fugue._utils.registry import fugue_plugin
-
-from .._compat import IbisTable
-
-
-@fugue_plugin
-def parse_ibis_engine(obj: Any, engine: ExecutionEngine) -> "IbisEngine":
-    if isinstance(obj, IbisEngine):
-        return obj
-    raise NotImplementedError(
-        f"Ibis execution engine can't be parsed from {obj}."
-        " You may need to register a parser for it."
-    )
-
-
-class IbisEngine(EngineFacet):
-    """The abstract base class for different ibis execution implementations.
-
-    :param execution_engine: the execution engine this ibis engine will run on
-    """
-
-    @property
-    def is_distributed(self) -> bool:  # pragma: no cover
-        return self.execution_engine.is_distributed
-
-    def to_df(self, df: AnyDataFrame, schema: Any = None) -> DataFrame:
-        raise NotImplementedError  # pragma: no cover
-
-    @abstractmethod
-    def select(
-        self, dfs: DataFrames, ibis_func: Callable[[ibis.BaseBackend], IbisTable]
-    ) -> DataFrame:  # pragma: no cover
-        """Execute the ibis select expression.
-
-        :param dfs: a collection of dataframes that must have keys
-        :param ibis_func: the ibis compute function
-        :return: result of the ibis function
-
-        .. note::
-
-            This interface is experimental, so it is subjected to change.
-        """
-        raise NotImplementedError

fugue_ibis/execution/pandas_backend.py

@@ -1,54 +0,0 @@
-from typing import Any, Callable
-
-import ibis
-import pandas as pd
-from ibis.backends.pandas import Backend
-from triad.utils.assertion import assert_or_throw
-
-from fugue import (
-    DataFrame,
-    DataFrames,
-    ExecutionEngine,
-    NativeExecutionEngine,
-    PandasDataFrame,
-)
-from fugue_ibis._utils import to_ibis_schema, to_schema
-
-from .._compat import IbisTable
-from .ibis_engine import IbisEngine, parse_ibis_engine
-
-
-class PandasIbisEngine(IbisEngine):
-    def select(
-        self, dfs: DataFrames, ibis_func: Callable[[ibis.BaseBackend], IbisTable]
-    ) -> DataFrame:  # pragma: no cover
-        pdfs = {k: v.as_pandas() for k, v in dfs.items()}
-        be = _BackendWrapper().connect(pdfs)
-        be.set_schemas(dfs)
-        expr = ibis_func(be)
-        schema = to_schema(expr.schema())
-        result = expr.execute()
-        assert_or_throw(
-            isinstance(result, pd.DataFrame), "result must be a pandas DataFrame"
-        )
-        return PandasDataFrame(result, schema=schema)
-
-
-@parse_ibis_engine.candidate(
-    lambda obj, *args, **kwargs: isinstance(obj, NativeExecutionEngine)
-)
-def _pd_to_ibis_engine(obj: Any, engine: ExecutionEngine) -> IbisEngine:
-    return PandasIbisEngine(engine)
-
-
-class _BackendWrapper(Backend):
-    def set_schemas(self, dfs: DataFrames) -> None:
-        self._schemas = {k: to_ibis_schema(v.schema) for k, v in dfs.items()}
-
-    def table(self, name: str, schema: Any = None):
-        return super().table(
-            name,
-            schema=self._schemas[name]
-            if schema is None and name in self._schemas
-            else schema,
-        )

fugue_ibis/extensions.py

@@ -1,203 +0,0 @@
-from typing import Any, Callable, Dict
-
-import ibis
-from fugue import DataFrame, DataFrames, Processor, WorkflowDataFrame
-from fugue.exceptions import FugueWorkflowCompileError
-from fugue.workflow.workflow import WorkflowDataFrames
-from triad import assert_or_throw, extension_method
-
-from ._utils import LazyIbisObject, _materialize
-from .execution.ibis_engine import parse_ibis_engine
-
-from ._compat import IbisTable
-
-
-def run_ibis(
-    ibis_func: Callable[[ibis.BaseBackend], IbisTable],
-    ibis_engine: Any = None,
-    **dfs: WorkflowDataFrame,
-) -> WorkflowDataFrame:
-    """Run an ibis workflow wrapped in ``ibis_func``
-
-    :param ibis_func: the function taking in an ibis backend, and returning
-      an Ibis TableExpr
-    :param ibis_engine: an object that together with |ExecutionEngine|
-      can determine :class:`~fugue_ibis.execution.ibis_engine.IbisEngine`
-      , defaults to None
-    :param dfs: dataframes in the same workflow
-    :return: the output workflow dataframe
-
-    .. admonition:: Examples
-
-        .. code-block:: python
-
-            import fugue as FugueWorkflow
-            from fugue_ibis import run_ibis
-
-            def func(backend):
-                t = backend.table("tb")
-                return t.mutate(b=t.a+1)
-
-            dag = FugueWorkflow()
-            df = dag.df([[0]], "a:int")
-            result = run_ibis(func, tb=df)
-            result.show()
-    """
-    wdfs = WorkflowDataFrames(**dfs)
-    return wdfs.workflow.process(
-        wdfs,
-        using=_IbisProcessor,
-        params=dict(ibis_func=ibis_func, ibis_engine=ibis_engine),
-    )
-
-
-@extension_method
-def as_ibis(df: WorkflowDataFrame) -> IbisTable:
-    """Convert the Fugue workflow dataframe to an ibis table for ibis
-    operations.
-
-    :param df: the Fugue workflow dataframe
-    :return: the object representing the ibis table
-
-    .. admonition:: Examples
-
-        .. code-block:: python
-
-            # non-magical approach
-            import fugue as FugueWorkflow
-            from fugue_ibis import as_ibis, as_fugue
-
-            dag = FugueWorkflow()
-            df1 = dag.df([[0]], "a:int")
-            df2 = dag.df([[1]], "a:int")
-            idf1 = as_ibis(df1)
-            idf2 = as_ibis(df2)
-            idf3 = idf1.union(idf2)
-            result = idf3.mutate(b=idf3.a+1)
-            as_fugue(result).show()
-
-        .. code-block:: python
-
-            # magical approach
-            import fugue as FugueWorkflow
-            import fugue_ibis  # must import
-
-            dag = FugueWorkflow()
-            idf1 = dag.df([[0]], "a:int").as_ibis()
-            idf2 = dag.df([[1]], "a:int").as_ibis()
-            idf3 = idf1.union(idf2)
-            result = idf3.mutate(b=idf3.a+1).as_fugue()
-            result.show()
-
-    .. note::
-
-        The magic is that when importing ``fugue_ibis``, the functions
-        ``as_ibis`` and ``as_fugue`` are added to the correspondent classes
-        so you can use them as if they are parts of the original classes.
-
-        This is an idea similar to patching. Ibis uses this programming model
-        a lot. Fugue provides this as an option.
-
-    .. note::
-
-        The returned object is not really a ``TableExpr``, it's a 'super lazy'
-        object that will be translated into ``TableExpr`` at run time.
-        This is because to compile an ibis execution graph, the input schemas
-        must be known. However, in Fugue, this is not always true. For example
-        if the previous step is to pivot a table, then the output schema can be
-        known at runtime. So in order to be a part of Fugue, we need to be able to
-        construct ibis expressions before knowing the input schemas.
-    """
-    return LazyIbisObject(df)  # type: ignore
-
-
-@extension_method(class_type=LazyIbisObject)
-def as_fugue(
-    expr: IbisTable,
-    ibis_engine: Any = None,
-) -> WorkflowDataFrame:
-    """Convert a lazy ibis object to Fugue workflow dataframe
-
-    :param expr: the actual instance should be LazyIbisObject
-    :return: the Fugue workflow dataframe
-
-    .. admonition:: Examples
-
-        .. code-block:: python
-
-            # non-magical approach
-            import fugue as FugueWorkflow
-            from fugue_ibis import as_ibis, as_fugue
-
-            dag = FugueWorkflow()
-            df1 = dag.df([[0]], "a:int")
-            df2 = dag.df([[1]], "a:int")
-            idf1 = as_ibis(df1)
-            idf2 = as_ibis(df2)
-            idf3 = idf1.union(idf2)
-            result = idf3.mutate(b=idf3.a+1)
-            as_fugue(result).show()
-
-        .. code-block:: python
-
-            # magical approach
-            import fugue as FugueWorkflow
-            import fugue_ibis  # must import
-
-            dag = FugueWorkflow()
-            idf1 = dag.df([[0]], "a:int").as_ibis()
-            idf2 = dag.df([[1]], "a:int").as_ibis()
-            idf3 = idf1.union(idf2)
-            result = idf3.mutate(b=idf3.a+1).as_fugue()
-            result.show()
-
-    .. note::
-
-        The magic is that when importing ``fugue_ibis``, the functions
-        ``as_ibis`` and ``as_fugue`` are added to the correspondent classes
-        so you can use them as if they are parts of the original classes.
-
-        This is an idea similar to patching. Ibis uses this programming model
-        a lot. Fugue provides this as an option.
-
-    .. note::
-
-        The returned object is not really a ``TableExpr``, it's a 'super lazy'
-        object that will be translated into ``TableExpr`` at run time.
-        This is because to compile an ibis execution graph, the input schemas
-        must be known. However, in Fugue, this is not always true. For example
-        if the previous step is to pivot a table, then the output schema can be
-        known at runtime. So in order to be a part of Fugue, we need to be able to
-        construct ibis expressions before knowing the input schemas.
-    """
-
-    def _func(
-        be: ibis.BaseBackend,
-        lazy_expr: LazyIbisObject,
-        ctx: Dict[int, Any],
-    ) -> IbisTable:
-        return _materialize(
-            lazy_expr, {k: be.table(f"_{id(v)}") for k, v in ctx.items()}
-        )
-
-    assert_or_throw(
-        isinstance(expr, LazyIbisObject),
-        FugueWorkflowCompileError("expr must be a LazyIbisObject"),
-    )
-    _lazy_expr: LazyIbisObject = expr  # type: ignore
-    _ctx = _lazy_expr._super_lazy_internal_ctx
-    _dfs = {f"_{id(v)}": v for _, v in _ctx.items()}
-    return run_ibis(
-        lambda be: _func(be, _lazy_expr, _ctx), ibis_engine=ibis_engine, **_dfs
-    )
-
-
-class _IbisProcessor(Processor):
-    def process(self, dfs: DataFrames) -> DataFrame:
-        ibis_func = self.params.get_or_throw("ibis_func", Callable)
-        ibis_engine = self.params.get_or_none("ibis_engine", object)
-        ie = parse_ibis_engine(
-            self.execution_engine if ibis_engine is None else ibis_engine,
-            self.execution_engine,
-        )
-        return ie.select(dfs, ibis_func)

fugue_spark/ibis_engine.py

@@ -1,45 +0,0 @@
-from typing import Any, Callable
-
-import ibis
-from pyspark.sql import DataFrame as PySparkDataFrame
-from triad.utils.assertion import assert_or_throw
-
-from fugue import DataFrame, DataFrames, ExecutionEngine
-from fugue_ibis import IbisTable
-from fugue_ibis._utils import to_schema
-from fugue_ibis.execution.ibis_engine import IbisEngine, parse_ibis_engine
-from fugue_spark.dataframe import SparkDataFrame
-from fugue_spark.execution_engine import SparkExecutionEngine
-
-
-class SparkIbisEngine(IbisEngine):
-    def __init__(self, execution_engine: ExecutionEngine) -> None:
-        assert_or_throw(
-            isinstance(execution_engine, SparkExecutionEngine),
-            lambda: ValueError(
-                f"SparkIbisEngine must use SparkExecutionEngine ({execution_engine})"
-            ),
-        )
-        super().__init__(execution_engine)
-
-    def select(
-        self, dfs: DataFrames, ibis_func: Callable[[ibis.BaseBackend], IbisTable]
-    ) -> DataFrame:
-        for k, v in dfs.items():
-            self.execution_engine.register(v, k)  # type: ignore
-        con = ibis.pyspark.connect(self.execution_engine.spark_session)  # type: ignore
-        expr = ibis_func(con)
-        schema = to_schema(expr.schema())
-        result = expr.compile()
-        assert_or_throw(
-            isinstance(result, PySparkDataFrame),
-            lambda: ValueError(f"result must be a PySpark DataFrame ({type(result)})"),
-        )
-        return SparkDataFrame(result, schema=schema)
-
-
-@parse_ibis_engine.candidate(
-    lambda obj, *args, **kwargs: isinstance(obj, SparkExecutionEngine)
-)
-def _spark_to_ibis_engine(obj: Any, engine: ExecutionEngine) -> IbisEngine:
-    return SparkIbisEngine(engine)

fugue_test/ibis_suite.py

@@ -1,92 +0,0 @@
-# pylint: disable-all
-from unittest import TestCase
-
-import ibis
-from fugue import ExecutionEngine, FugueWorkflow, register_default_sql_engine
-from fugue_ibis import IbisEngine, as_fugue, as_ibis, run_ibis
-
-
-class IbisTests(object):
-    """Ibis test suite.
-    Any new engine from :class:`~fugue_ibis.execution.ibis_engine.IbisEngine`
-    should also pass this test suite.
-    """
-
-    class Tests(TestCase):
-        @classmethod
-        def setUpClass(cls):
-            register_default_sql_engine(lambda engine: engine.sql_engine)
-            cls._engine = cls.make_engine(cls)
-            cls._ibis_engine = cls.make_ibis_engine(cls)
-
-        @property
-        def engine(self) -> ExecutionEngine:
-            return self._engine  # type: ignore
-
-        @property
-        def ibis_engine(self) -> ExecutionEngine:
-            return self._ibis_engine  # type: ignore
-
-        @classmethod
-        def tearDownClass(cls):
-            cls._engine.stop()
-
-        def make_engine(self) -> ExecutionEngine:  # pragma: no cover
-            raise NotImplementedError
-
-        def make_ibis_engine(self) -> IbisEngine:  # pragma: no cover
-            raise NotImplementedError
-
-        def test_run_ibis(self):
-            def _test1(con: ibis.BaseBackend) -> ibis.Expr:
-                tb = con.table("a")
-                return tb
-
-            def _test2(con: ibis.BaseBackend) -> ibis.Expr:
-                tb = con.table("a")
-                return tb.mutate(c=tb.a + tb.b)
-
-            dag = FugueWorkflow()
-            df = dag.df([[0, 1], [2, 3]], "a:long,b:long")
-            res = run_ibis(_test1, ibis_engine=self.ibis_engine, a=df)
-            res.assert_eq(df)
-            df = dag.df([[0, 1], [2, 3]], "a:long,b:long")
-            res = run_ibis(_test2, ibis_engine=self.ibis_engine, a=df)
-            df2 = dag.df([[0, 1, 1], [2, 3, 5]], "a:long,b:long,c:long")
-            res.assert_eq(df2)
-            dag.run(self.engine)
-
-        def test_run_as_ibis(self):
-            dag = FugueWorkflow()
-            df = dag.df([[0, 1], [2, 3]], "a:long,b:long")
-            idf = as_ibis(df)
-            res = as_fugue(idf)
-            res.assert_eq(df)
-            dag.run(self.engine)
-
-            dag = FugueWorkflow()
-            df1 = dag.df([[0, 1], [2, 3]], "a:long,b:long")
-            df2 = dag.df([[0, ["x"]], [3, ["y"]]], "a:long,c:[str]")
-            idf1 = as_ibis(df1)
-            idf2 = as_ibis(df2)
-            idf = idf1.inner_join(idf2, idf1.a == idf2.a)[idf1, idf2.c]
-            res = as_fugue(idf)
-            expected = dag.df([[0, 1, ["x"]]], "a:long,b:long,c:[str]")
-            res.assert_eq(expected, check_order=True, check_schema=True)
-            dag.run(self.engine)
-
-            dag = FugueWorkflow()
-            idf1 = dag.df([[0, 1], [2, 3]], "a:long,b:long").as_ibis()
-            idf2 = dag.df([[0, ["x"]], [3, ["y"]]], "a:long,c:[str]").as_ibis()
-            res = idf1.inner_join(idf2, idf1.a == idf2.a)[idf1, idf2.c].as_fugue()
-            expected = dag.df([[0, 1, ["x"]]], "a:long,b:long,c:[str]")
-            res.assert_eq(expected, check_order=True, check_schema=True)
-            dag.run(self.engine)
-
-        def test_literal(self):
-            dag = FugueWorkflow()
-            idf1 = dag.df([[0, 1], [2, 3]], "a:long,b:long").as_ibis()
-            res = idf1.mutate(c=idf1.b + 10).as_fugue()
-            expected = dag.df([[0, 1, 11], [2, 3, 13]], "a:long,b:long,c:long")
-            res.assert_eq(expected, check_order=True, check_schema=True)
-            dag.run(self.engine)

fugue_test/plugins/dask/__init__.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-from .fixtures import fugue_dask_client

fugue_test/plugins/dask/fixtures.py

@@ -1,12 +0,0 @@
-import pytest
-
-
-@pytest.fixture(scope="session")
-def fugue_dask_client():
-    from dask.distributed import Client
-    import dask
-
-    with Client(processes=True, n_workers=3, threads_per_worker=1) as client:
-        dask.config.set({"dataframe.shuffle.method": "tasks"})
-        dask.config.set({"dataframe.convert-string": False})
-        yield client

fugue_test/plugins/duckdb/__init__.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-from .fixtures import fugue_duckdb_connection

fugue_test/plugins/duckdb/fixtures.py

@@ -1,9 +0,0 @@
-import pytest
-
-
-@pytest.fixture(scope="session")
-def fugue_duckdb_connection():
-    import duckdb
-
-    with duckdb.connect() as connection:
-        yield connection

fugue_test/plugins/misc/__init__.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-from .fixtures import tmp_mem_dir