Repository: data-engineering-collective/plateau (language: python)

Issue:
Rename code to `plateau`
We should change the module itself completely to `plateau` but not make any API breaking changes.


Discussion / hints:

Fix patch:
diff --git a/.codecov.yml b/.codecov.yml
index 4ea514c1..458da4e7 100644
--- a/.codecov.yml
+++ b/.codecov.yml
@@ -7,5 +7,5 @@ coverage:
         threshold: 0.1
 
 ignore:
-  - kartothek/io/testing/*
-  - kartothek/core/_deprecation.py
+  - plateau/io/testing/*
+  - plateau/core/_deprecation.py
diff --git a/.coveragerc b/.coveragerc
index 2b244bb2..71c8b695 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,7 +1,7 @@
 # .coveragerc to control coverage.py
 [run]
 branch = True
-source = kartothek
+source = plateau
 
 [report]
 # Regexes for lines to exclude from consideration
@@ -24,7 +24,7 @@ ignore_errors = True
 
 omit =
     tests/*
-    kartothek/io/testing/*
+    plateau/io/testing/*
     */__init__.py
     */*/__init__.py
-    kartothek/core/_deprecation.py
+    plateau/core/_deprecation.py
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f84cd30a..44b9c1ce 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -89,19 +89,19 @@ jobs:
       - name: Conda Install conda-requirements.txt
         # run this AFTER pyarrow, since this is less restrictive (so conda doesn't spend too much time downgrading)
         run: mamba install --file=conda-requirements.txt
-      - name: Pip Install kartothek
+      - name: Pip Install plateau
         run: pip install --no-deps .
       - name: Test import
         run: |
-          python -c "import kartothek"
-          python -c "import kartothek.api"
-          python -c "import kartothek.api.dataset"
-          python -c "import kartothek.api.serialization"
-          python -c "import kartothek.core"
-          python -c "import kartothek.io"
-          python -c "import kartothek.io_components"
-          python -c "import kartothek.serialization"
-          python -c "import kartothek.utils"
+          python -c "import plateau"
+          python -c "import plateau.api"
+          python -c "import plateau.api.dataset"
+          python -c "import plateau.api.serialization"
+          python -c "import plateau.core"
+          python -c "import plateau.io"
+          python -c "import plateau.io_components"
+          python -c "import plateau.serialization"
+          python -c "import plateau.utils"
       - name: Conda install test requirements
         run: mamba install
               -c conda-forge
@@ -134,7 +134,7 @@ jobs:
       - name: Codecov
         uses: codecov/codecov-action@v2.1.0
         with:
-          # NOTE: `token` is not required, because the kartothek repo is public
+          # NOTE: `token` is not required, because the plateau repo is public
           file: ./coverage.xml
           name: pytest-numfocus_nightly_${{ matrix.numfocus_nightly }}-os_${{ matrix.os }}-pyarrow_${{ matrix.pyarrow }}-python_${{ matrix.python }}
 
@@ -157,7 +157,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           tag_name: ${{ github.ref }}
-          release_name: Kartothek ${{ github.ref }}
+          release_name: plateau ${{ github.ref }}
           body_path: release_notes.md
           draft: false
           prerelease: false
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 131b081d..c56ddc49 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -22,7 +22,7 @@ jobs:
           miniforge-version: 4.11.0-0
           use-mamba: true
           environment-file: docs/environment-docs.yml
-          activate-environment: kartothek-docs
+          activate-environment: plateau-docs
           python-version: 3.8
 
       - name: List conda
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index e727b09b..b22b90d5 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -32,4 +32,4 @@ repos:
     hooks:
     -   id: mypy
         verbose: true
-        files: kartothek
+        files: plateau
diff --git a/CHANGES.rst b/CHANGES.rst
index c25fbb13..59795bf1 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -2,9 +2,14 @@
 Changelog
 =========
 
+plateau 4.0.4 (2022-02-XX)
+==========================
+
+* Fork and rename the project as `plateau` (flat files, flat land).
 
 Kartothek 4.0.3 (2021-06-10)
 ============================
+
 * Pin dask to not use 2021.5.1 and 2020.6.0 (#475)
 
 Kartothek 4.0.2 (2021-06-07)
@@ -27,13 +32,13 @@ This is a major release of kartothek with breaking API changes.
 * Removal of complex user input (see gh427)
 * Removal of multi table feature
 * Removal of `kartothek.io.merge` module
-* class :class:`~kartothek.core.dataset.DatasetMetadata` now has an attribute called `schema` which replaces the previous attribute `table_meta` and returns only a single schema
+* class ``kartothek.core.dataset.DatasetMetadata`` now has an attribute called `schema` which replaces the previous attribute `table_meta` and returns only a single schema
 * All outputs which previously returned a sequence of dictionaries where each key-value pair would correspond to a table-data pair now returns only one :class:`pandas.DataFrame`
 * All read pipelines will now automatically infer the table to read such that it is no longer necessary to provide `table` or `table_name` as an input argument
 * All writing pipelines which previously supported a complex user input type now expose an argument `table_name` which can be used to continue usage of legacy datasets (i.e. datasets with an intrinsic, non-trivial table name). This usage is discouraged and we recommend users to migrate to a default table name (i.e. leave it None / `table`)
 * All pipelines which previously accepted an argument `tables` to select the subset of tables to load no longer accept this keyword. Instead the to-be-loaded table will be inferred
 * Trying to read a multi-tabled dataset will now cause an exception telling users that this is no longer supported with kartothek 4.0
-* The dict schema for :meth:`~kartothek.core.dataset.DatasetMetadataBase.to_dict` and :meth:`~kartothek.core.dataset.DatasetMetadata.from_dict` changed replacing a dictionary in `table_meta` with the simple `schema`
+* The dict schema for ``kartothek.core.dataset.DatasetMetadataBase.to_dict`` and ``kartothek.core.dataset.DatasetMetadata.from_dict`` changed replacing a dictionary in `table_meta` with the simple `schema`
 * All pipeline arguments which previously accepted a dictionary of sequences to describe a table specific subset of columns now accept plain sequences (e.g. `columns`, `categoricals`)
 * Remove the following list of deprecated arguments for io pipelines
   * label_filter
@@ -41,13 +46,13 @@ This is a major release of kartothek with breaking API changes.
   * load_dynamic_metadata
   * load_dataset_metadata
   * concat_partitions_on_primary_index
-* Remove `output_dataset_uuid` and `df_serializer` from :func:`kartothek.io.eager.commit_dataset` since these arguments didn't have any effect
-* Remove `metadata`, `df_serializer`, `overwrite`, `metadata_merger` from :func:`kartothek.io.eager.write_single_partition`
-* :func:`~kartothek.io.eager.store_dataframes_as_dataset` now requires a list as an input
+* Remove `output_dataset_uuid` and `df_serializer` from ``kartothek.io.eager.commit_dataset`` since these arguments didn't have any effect
+* Remove `metadata`, `df_serializer`, `overwrite`, `metadata_merger` from ``kartothek.io.eager.write_single_partition``
+* ``kartothek.io.eager.store_dataframes_as_dataset`` now requires a list as an input
 * Default value for argument `date_as_object` is now universally set to ``True``. The behaviour for `False` will be deprecated and removed in the next major release
-* No longer allow to pass `delete_scope` as a delayed object to :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf`
-* :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf` and :func:`~kartothek.io.dask.dataframe.store_dataset_from_ddf` now return a `dd.core.Scalar` object. This enables all `dask.DataFrame` graph optimizations by default.
-* Remove argument `table_name` from :func:`~kartothek.io.dask.dataframe.collect_dataset_metadata`
+* No longer allow to pass `delete_scope` as a delayed object to ``kartothek.io.dask.dataframe.update_dataset_from_ddf``
+* ``kartothek.io.dask.dataframe.update_dataset_from_ddf`` and :func:``kartothek.io.dask.dataframe.store_dataset_from_ddf`` now return a `dd.core.Scalar` object. This enables all `dask.DataFrame` graph optimizations by default.
+* Remove argument `table_name` from ``kartothek.io.dask.dataframe.collect_dataset_metadata``
 
 
 Version 3.20.0 (2021-03-15)
@@ -55,13 +60,13 @@ Version 3.20.0 (2021-03-15)
 
 This will be the final release in the 3.X series. Please ensure your existing
 codebase does not raise any DeprecationWarning from kartothek and migrate your
-import paths ahead of time to the new :mod:`kartothek.api` modules to ensure a
+import paths ahead of time to the new ``kartothek.api`` modules to ensure a
 smooth migration to 4.X.
 
-* Introduce :mod:`kartothek.api` as the public definition of the API. See also :doc:`versioning`.
+* Introduce ``kartothek.api`` as the public definition of the API. See also :doc:`versioning`.
 * Introduce `DatasetMetadataBase.schema` to prepare deprecation of `table_meta`
-* :func:`~kartothek.io.eager.read_dataset_as_dataframes` and
-  :func:`~kartothek.io.iter.read_dataset_as_dataframes__iterator` now correctly return
+* ``kartothek.io.eager.read_dataset_as_dataframes`` and
+  ``kartothek.io.iter.read_dataset_as_dataframes__iterator`` now correctly return
   categoricals as requested for misaligned categories.
 
 
@@ -69,7 +74,7 @@ Version 3.19.1 (2021-02-24)
 ===========================
 
 * Allow ``pyarrow==3`` as a dependency.
-* Fix a bug in :func:`~kartothek.io_components.utils.align_categories` for dataframes
+* Fix a bug in ``kartothek.io_components.utils.align_categories`` for dataframes
   with missings and of non-categorical dtype.
 * Fix an issue with the cube index validation introduced in v3.19.0 (#413).
 
@@ -81,8 +86,8 @@ Version 3.19.0 (2021-02-12)
   dask.dataframe might not update all secondary indices, resulting in a corrupt
   state after the update
 * Expose compression type and row group chunk size in Cube interface via optional
-  parameter of type :class:`~kartothek.serialization.ParquetSerializer`.
-* Add retries to  :func:`~kartothek.serialization._parquet.ParquetSerializer.restore_dataframe`
+  parameter of type ``kartothek.serialization.ParquetSerializer``.
+* Add retries to ``kartothek.serialization._parquet.ParquetSerializer.restore_dataframe``
   IOErrors on long running ktk + dask tasks have been observed. Until the root cause is fixed,
   the serialization is retried to gain more stability.
 
@@ -90,8 +95,8 @@ Version 3.18.0 (2021-01-25)
 ===========================
 
 * Add ``cube.suppress_index_on`` to switch off the default index creation for dimension columns
-* Fixed the import issue of zstd module for `kartothek.core _zmsgpack`.
-* Fix a bug in `kartothek.io_components.read.dispatch_metapartitions_from_factory` where
+* Fixed the import issue of zstd module for ``kartothek.core _zmsgpack``.
+* Fix a bug in ``kartothek.io_components.read.dispatch_metapartitions_from_factory`` where
   `dispatch_by=[]` would be treated like `dispatch_by=None`, not merging all dataset partitions into
   a single partitions.
 
@@ -121,18 +126,18 @@ Version 3.17.0 (2020-11-23)
 Improvements
 ^^^^^^^^^^^^
 * Improve performance for "in" predicate literals using long object lists as values
-* :func:`~kartothek.io.eager.commit_dataset` now allows to modify the user
+* ``kartothek.io.eager.commit_dataset`` now allows to modify the user
   metadata without adding new data.
 
 Bugfixes
 ^^^^^^^^
-* Fix an issue where :func:`~kartothek.io.dask.dataframe.collect_dataset_metadata` would return
+* Fix an issue where ``kartothek.io.dask.dataframe.collect_dataset_metadata`` would return
   improper rowgroup statistics
-* Fix an issue where :func:`~kartothek.io.dask.dataframe.collect_dataset_metadata` would execute
+* Fix an issue where ``kartothek.io.dask.dataframe.collect_dataset_metadata`` would execute
   ``get_parquet_metadata`` at graph construction time
-* Fix a bug in `kartothek.io.eager_cube.remove_partitions` where all partitions were removed
+* Fix a bug in ``kartothek.io.eager_cube.remove_partitions`` where all partitions were removed
   instead of non at all.
-* Fix a bug in :meth:`~kartothek.core.dataset.DatasetMetadataBase.get_indices_as_dataframe` which would
+* Fix a bug in ``kartothek.core.dataset.DatasetMetadataBase.get_indices_as_dataframe`` which would
   raise an ``IndexError`` if indices were empty or had not been loaded
 
 Version 3.16.0 (2020-09-29)
@@ -157,15 +162,15 @@ Version 3.15.0 (2020-09-28)
 
 New functionality
 ^^^^^^^^^^^^^^^^^
-* Add :func:`~kartothek.io.dask.dataframe.store_dataset_from_ddf` to offer write
+* Add ``kartothek.io.dask.dataframe.store_dataset_from_ddf`` to offer write
   support of a dask dataframe without update support. This forbids or explicitly
   allows overwrites and does not update existing datasets.
 * The ``sort_partitions_by`` feature now supports multiple columns. While this
   has only marginal effect for predicate pushdown, it may be used to improve the
   parquet compression.
 * ``build_cube_from_dataframe`` now supports the ``shuffle`` methods offered by
-  :func:`~kartothek.io.dask.dataframe.store_dataset_from_ddf` and
-  :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf` but writes the
+  ``kartothek.io.dask.dataframe.store_dataset_from_ddf`` and
+  ``kartothek.io.dask.dataframe.update_dataset_from_ddf`` but writes the
   output in the cube format
 
 Improvements
@@ -219,7 +224,7 @@ Version 3.11.0 (2020-07-15)
 New functionality
 ^^^^^^^^^^^^^^^^^
 
-* Add :meth:`~kartothek.io_components.metapartition.MetaPartition.get_parquet_metadata` and :func:`~kartothek.io.dask.dataframe.collect_dataset_metadata`, enabling users to collect information about the Parquet metadata of a dataset (#306)
+* Add ``kartothek.io_components.metapartition.MetaPartition.get_parquet_metadata`` and ``kartothek.io.dask.dataframe.collect_dataset_metadata``, enabling users to collect information about the Parquet metadata of a dataset (#306)
 
 Bug fixes
 ^^^^^^^^^
@@ -239,7 +244,7 @@ Improvements
 Bug fixes
 ^^^^^^^^^
 
-* Ensure that the empty (sentinel) DataFrame used in :func:`~kartothek.io.eager.read_table`
+* Ensure that the empty (sentinel) DataFrame used in `kartothek.io.eager.read_table``
   also has the correct behaviour when using the ``categoricals`` argument.
 
 
@@ -258,14 +263,14 @@ Improvements
 ^^^^^^^^^^^^
 * Arrow 0.17.X support
 * Significant performance improvements for shuffle operations in
-  :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf`
+  ``kartothek.io.dask.dataframe.update_dataset_from_ddf``
   for large dask.DataFrames with many payload columns by using in-memory
   compression during the shuffle operation.
-* Allow calling :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf`
+* Allow calling ``kartothek.io.dask.dataframe.update_dataset_from_ddf``
   without `partition_on` when `shuffle=True`.
-* :func:`~kartothek.io.dask.dataframe.read_dataset_as_ddf` supports kwarg ``dispatch_by``
+* ``kartothek.io.dask.dataframe.read_dataset_as_ddf`` supports kwarg ``dispatch_by``
   to control the internal partitioning structure when creating a dataframe.
-* :func:`~kartothek.io.dask.dataframe.read_dataset_as_ddf` and :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf`
+* ``kartothek.io.dask.dataframe.read_dataset_as_ddf`` and ``kartothek.io.dask.dataframe.update_dataset_from_ddf``
   now allow the keyword ``table`` to be optional, using the default SINGLE_TABLE identifier.
   (recommended since the multi table dataset support is in sunset).
 
@@ -308,7 +313,7 @@ Improvements
 ^^^^^^^^^^^^
 
 * Add keyword argument `dask_index_on` which reconstructs a dask index from an kartothek index when loading the dataset
-* Add method :func:`~kartothek.core.index.IndexBase.observed_values` which returns an array of all observed values of the index column
+* Add method ``kartothek.core.index.IndexBase.observed_values`` which returns an array of all observed values of the index column
 * Updated and improved documentation w.r.t. guides and API documentation
 
 Bug fixes
@@ -318,7 +323,7 @@ Bug fixes
 * No longer trigger the SettingWithCopyWarning when using bucketing
 * GH228 Fix an issue where empty header creation from a pyarrow schema would not
   normalize the schema which causes schema violations during update.
-* Fix an issue where :func:`~kartothek.io.eager.create_empty_dataset_header`
+* Fix an issue where ``kartothek.io.eager.create_empty_dataset_header``
   would not accept a store factory.
 
 
@@ -332,13 +337,13 @@ Improvements
 * Decrease scheduling overhead for dask based pipelines
 * Performance improvements for categorical data when using pyarrow>=0.15.0
 * Dask is now able to calculate better size estimates for the following classes:
-    * :class:`~kartothek.core.dataset.DatasetMetadata`
-    * :class:`~kartothek.core.factory.DatasetFactory`
-    * :class:`~kartothek.io_components.metapartition.MetaPartition`
-    * :class:`~kartothek.core.index.ExplicitSecondaryIndex`
-    * :class:`~kartothek.core.index.PartitionIndex`
-    * :class:`~kartothek.core.partition.Partition`
-    * :class:`~kartothek.core.common_metadata.SchemaWrapper`
+    * ``kartothek.core.dataset.DatasetMetadata``
+    * ``kartothek.core.factory.DatasetFactory``
+    * ``kartothek.io_components.metapartition.MetaPartition``
+    * ``kartothek.core.index.ExplicitSecondaryIndex``
+    * ``kartothek.core.index.PartitionIndex``
+    * ``kartothek.core.partition.Partition``
+    * ``kartothek.core.common_metadata.SchemaWrapper``
 
 
 Version 3.6.2 (2019-12-17)
@@ -347,11 +352,11 @@ Version 3.6.2 (2019-12-17)
 Improvements
 ^^^^^^^^^^^^
 
-* Add more explicit typing to :mod:`kartothek.io.eager`.
+* Add more explicit typing to ``kartothek.io.eager``.
 
 Bug fixes
 ^^^^^^^^^
-* Fix an issue where :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf` would create a column named "_KTK_HASH_BUCKET" in the dataset
+* Fix an issue where ``kartothek.io.dask.dataframe.update_dataset_from_ddf`` would create a column named "_KTK_HASH_BUCKET" in the dataset
 
 
 Version 3.6.1 (2019-12-11)
@@ -367,7 +372,7 @@ Version 3.6.0 (2019-12-03)
 
 New functionality
 ^^^^^^^^^^^^^^^^^
-- The partition on shuffle algorithm in :func:`~kartothek.io.dask.dataframe.update_dataset_from_ddf` now supports
+- The partition on shuffle algorithm in ``kartothek.io.dask.dataframe.update_dataset_from_ddf`` now supports
   producing deterministic buckets based on hashed input data.
 
 Bug fixes
@@ -379,8 +384,8 @@ Bug fixes
 Version 3.5.1 (2019-10-25)
 ==========================
 - Fix potential ``pyarrow.lib.ArrowNotImplementedError`` when trying to store or pickle empty
-  :class:`~kartothek.core.index.ExplicitSecondaryIndex` objects
-- Fix pickling of :class:`~kartothek.core.index.ExplicitSecondaryIndex` unloaded in
+  ``kartothek.core.index.ExplicitSecondaryIndex`` objects
+- Fix pickling of ``kartothek.core.index.ExplicitSecondaryIndex`` unloaded in
   `dispatch_metapartitions_from_factory`
 
 
@@ -390,14 +395,14 @@ Version 3.5.0 (2019-10-21)
 New functionality
 ^^^^^^^^^^^^^^^^^
 - Add support for pyarrow 0.15.0
-- Additional functions in `kartothek.serialization` module for dealing with predicates
-  * :func:`~kartothek.serialization.check_predicates`
-  * :func:`~kartothek.serialization.filter_predicates_by_column`
-  * :func:`~kartothek.serialization.columns_in_predicates`
+- Additional functions in ``kartothek.serialization`` module for dealing with predicates
+  * ``kartothek.serialization.check_predicates``
+  * ``kartothek.serialization.filter_predicates_by_column``
+  * ``kartothek.serialization.columns_in_predicates``
 - Added available types for type annotation when dealing with predicates
-  * `~kartothek.serialization.PredicatesType`
-  * `~kartothek.serialization.ConjunctionType`
-  * `~kartothek.serialization.LiteralType`
+  * ``kartothek.serialization.PredicatesType``
+  * ``kartothek.serialization.ConjunctionType``
+  * ``kartothek.serialization.LiteralType``
 - Make ``kartothek.io.*read_table*`` methods use default table name if unspecified
 - ``MetaPartition.parse_input_to_metapartition`` accepts dicts and list of tuples equivalents as ``obj`` input
 - Added `secondary_indices` as a default argument to the `write` pipelines
@@ -408,7 +413,7 @@ Bug fixes
 - ``MetaPartition.load_dataframes`` now raises if table in ``columns`` argument doesn't exist
 - require ``urlquote>=1.1.0`` (where ``urlquote.quoting`` was introduced)
 - Improve performance for some cases where predicates are used with the `in` operator.
-- Correctly preserve :class:`~kartothek.core.index.ExplicitSecondaryIndex` dtype when index is empty
+- Correctly preserve :class:``kartothek.core.index.ExplicitSecondaryIndex`` dtype when index is empty
 - Fixed DeprecationWarning in pandas ``CategoricalDtype``
 - Fixed broken docstring for `store_dataframes_as_dataset`
 - Internal operations no longer perform schema validations. This will improve
@@ -434,7 +439,7 @@ Version 3.4.0 (2019-09-17)
 
 Version 3.3.0 (2019-08-15)
 ==========================
-- Fix rejection of bool predicates in :func:`~kartothek.serialization.filter_array_like` when bool columns contains
+- Fix rejection of bool predicates in ``kartothek.serialization.filter_array_like`` when bool columns contains
   ``None``
 - Streamline behavior of `store_dataset_from_ddf` when passing empty ddf.
 - Fix an issue where a segmentation fault may be raised when comparing MetaPartition instances
@@ -445,21 +450,21 @@ Version 3.2.0 (2019-07-25)
 ==========================
 - Fix gh:66 where predicate pushdown may evalute false results if evaluated
   using improper types. The behavior now is to raise in these situations.
-- Predicate pushdown and :func:`~kartothek.serialization.filter_array_like` will now properly handle pandas Categoricals.
-- Add :meth:`~kartothek.io.dask.bag.read_dataset_as_dataframe_bag`
-- Add `kartothek.io.dask.bag.read_dataset_as_metapartitions_bag`
+- Predicate pushdown and ``kartothek.serialization.filter_array_like`` will now properly handle pandas Categoricals.
+- Add ``kartothek.io.dask.bag.read_dataset_as_dataframe_bag``
+- Add ``kartothek.io.dask.bag.read_dataset_as_metapartitions_bag``
 
 
 Version 3.1.1 (2019-07-12)
 ==========================
 
-- make :func:`~kartothek.io.dask.bag.build_dataset_indices__bag` more efficient
-- make :func:`~kartothek.io.eager.build_dataset_indices` more efficient
-- fix pseudo-private :meth:`~kartothek.io_components.read.dispatch_metapartitions` handling of
+- make ``kartothek.io.dask.bag.build_dataset_indices__bag`` more efficient
+- make ``kartothek.io.eager.build_dataset_indices`` more efficient
+- fix pseudo-private ``kartothek.io_components.read.dispatch_metapartitions`` handling of
   ``concat_partitions_on_primary_index``
-- fix internal errors if querying (e.g. via :meth:`~kartothek.io.eager.read_dataset_as_dataframes`) with
+- fix internal errors if querying (e.g. via ``kartothek.io.eager.read_dataset_as_dataframes``) with
   ``datetime.date`` predicates that use the dataset index; this affects all code paths using
-  :meth:`~kartothek.io_components.metapartition.MetaPartition.load_dataframes`
+  ``kartothek.io_components.metapartition.MetaPartition.load_dataframes``
 
 
 Version 3.1.0 (2019-07-10)
@@ -470,17 +475,17 @@ Version 3.1.0 (2019-07-10)
 - remove ``funcsigs`` requirement
 - Implement reference ``io.eager`` implementation, adding the functions:
 
-    - :meth:`~kartothek.io.eager.garbage_collect_dataset`
-    - :meth:`~kartothek.io.eager.build_dataset_indices`
-    - :meth:`~kartothek.io.eager.update_dataset_from_dataframes`
+    - ``kartothek.io.eager.garbage_collect_dataset``
+    - ``kartothek.io.eager.build_dataset_indices``
+    - ``kartothek.io.eager.update_dataset_from_dataframes``
 
 - fix ``_apply_partition_key_predicates`` ``FutureWarning``
-- serialize :class:`~kartothek.core.index.ExplicitSecondaryIndex` to parquet
+- serialize ``kartothek.core.index.ExplicitSecondaryIndex`` to parquet
 - improve messages for schema violation errors
 - Ensure binary column names are read as type ``str``:
 
-    - Ensure dataframe columns are of type ``str`` in :func:`~kartothek.core.common_metadata.empty_dataframe_from_schema`
-    - Testing: create :func:`~kartothek.io.testing.read.test_binary_column_metadata` which checks column names stored as
+    - Ensure dataframe columns are of type ``str`` in ``kartothek.core.common_metadata.empty_dataframe_from_schema``
+    - Testing: create ``kartothek.io.testing.read.test_binary_column_metadata`` which checks column names stored as
       ``bytes`` objects are read as type ``str``
 
 - fix issue where it was possible to add an index to an existing dataset by using update functions and partition indices
@@ -488,20 +493,20 @@ Version 3.1.0 (2019-07-10)
 
 - fix issue where unreferenced files were not being removed when deleting an entire dataset
 
-- support nested :class:`~kartothek.io_components.metapartition.MetaPartition`
-  in :meth:`~kartothek.io_components.metapartition.MetaPartition.add_metapartition`.
+- support nested ``kartothek.io_components.metapartition.MetaPartition``
+  in ``kartothek.io_components.metapartition.MetaPartition.add_metapartition``.
   This fixes issue https://github.com/JDASoftwareGroup/kartothek/issues/40 .
 
-- Add :meth:`~kartothek.io.dask.bag.build_dataset_indices__bag`
+- Add ``kartothek.io.dask.bag.build_dataset_indices__bag``
 
-- Return `dask.bag.Item` object from :meth:`~kartothek.io.dask.bag.store_bag_as_dataset` to avoid misoptimization
+- Return `dask.bag.Item` object from ``kartothek.io.dask.bag.store_bag_as_dataset`` to avoid misoptimization
 
 **Breaking:**
 
-- categorical normalization was moved from :meth:`~kartothek.core.common_metadata.make_meta` to
-  :meth:`~kartothek.core.common_metadata.normalize_type`.
-- :meth:`kartothek.core.common_metadata.SchemaWrapper.origin` is now a set of of strings instead of a single string
-- ``Partition.from_v2_dict`` was removed, use :meth:`kartothek.core.partition.Partition.from_dict` instead
+- categorical normalization was moved from ``kartothek.core.common_metadata.make_meta`` to
+  ``kartothek.core.common_metadata.normalize_type``.
+- ``kartothek.core.common_metadata.SchemaWrapper.origin`` is now a set of of strings instead of a single string
+- ``Partition.from_v2_dict`` was removed, use ``kartothek.core.partition.Partition.from_dict`` instead
 
 
 Version 3.0.0 (2019-05-02)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f716caf3..36cee7ec 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -15,8 +15,8 @@ If you've found a bug, please report it to the issue tracker and
 To get started, set up a new virtual environment and install all requirements
 
 ```bash
-virtualenv kartothek-dev --python=python3.6
-source kartothek-dev/bin/activate
+virtualenv plateau-dev --python=python3.9
+source plateau-dev/bin/activate
 pip install -e .
 pip install -r test-requirements.txt
 ```
@@ -60,5 +60,5 @@ If you prefer to perform manual formatting and linting, you can run the necessar
 toolchain like this
 
 ```bash
-./format_code.sh
+pre-commit run -a
 ```
diff --git a/LICENSE.txt b/LICENSE.txt
index 29eb624e..e78a1ef4 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,5 +1,7 @@
 MIT License
 
+Copyright (c) 2022 The plateau contributors.
+Copyright (c) 2020-2021 The kartothek contributors.
 Copyright (c) 2019 JDA Software, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
diff --git a/asv_bench/asv.conf.json b/asv_bench/asv.conf.json
index fe9e2d1d..785da4fe 100644
--- a/asv_bench/asv.conf.json
+++ b/asv_bench/asv.conf.json
@@ -1,8 +1,8 @@
 {
     "version": 1,
-    "project": "kartothek",
+    "project": "plateau",
     
-    "project_url": "https://github.com/JDASoftwareGroup/kartothek",
+    "project_url": "https://github.com/data-engineering-collective/plateau",
     "repo": ".",
     "environment_type": "virtualenv",
     "env_dir": ".asv/env",
diff --git a/asv_bench/benchmarks/filter.py b/asv_bench/benchmarks/filter.py
index 118a6f2a..59856a4a 100644
--- a/asv_bench/benchmarks/filter.py
+++ b/asv_bench/benchmarks/filter.py
@@ -1,8 +1,5 @@
-from kartothek.serialization._generic import (
-    filter_array_like,
-    filter_df_from_predicates,
-)
-from kartothek.serialization.testing import get_dataframe_not_nested
+from plateau.serialization._generic import filter_array_like, filter_df_from_predicates
+from plateau.serialization.testing import get_dataframe_not_nested
 
 
 class TimeFilterDF:
diff --git a/asv_bench/benchmarks/index.py b/asv_bench/benchmarks/index.py
index a55cd4df..a69db473 100644
--- a/asv_bench/benchmarks/index.py
+++ b/asv_bench/benchmarks/index.py
@@ -14,8 +14,8 @@
 import pyarrow as pa
 import storefact
 
-from kartothek.core.index import ExplicitSecondaryIndex
-from kartothek.io_components.metapartition import MetaPartition
+from plateau.core.index import ExplicitSecondaryIndex
+from plateau.io_components.metapartition import MetaPartition
 
 from .config import AsvBenchmarkConfig
 
diff --git a/asv_bench/benchmarks/metapartition.py b/asv_bench/benchmarks/metapartition.py
index f7213e33..cef6fce7 100644
--- a/asv_bench/benchmarks/metapartition.py
+++ b/asv_bench/benchmarks/metapartition.py
@@ -8,8 +8,8 @@
 import numpy as np
 import pandas as pd
 
-from kartothek.core.common_metadata import make_meta
-from kartothek.io_components.metapartition import MetaPartition
+from plateau.core.common_metadata import make_meta
+from plateau.io_components.metapartition import MetaPartition
 
 from .config import AsvBenchmarkConfig
 
diff --git a/asv_bench/benchmarks/predicate_pushdown.py b/asv_bench/benchmarks/predicate_pushdown.py
index 54af3ee6..bfd4cbf6 100644
--- a/asv_bench/benchmarks/predicate_pushdown.py
+++ b/asv_bench/benchmarks/predicate_pushdown.py
@@ -1,7 +1,7 @@
 from storefact import get_store_from_url
 
-from kartothek.serialization import ParquetSerializer
-from kartothek.serialization.testing import get_dataframe_not_nested
+from plateau.serialization import ParquetSerializer
+from plateau.serialization.testing import get_dataframe_not_nested
 
 
 class TimeRestore:
diff --git a/asv_bench/benchmarks/schema.py b/asv_bench/benchmarks/schema.py
index 5a03eb8e..6b9dc657 100644
--- a/asv_bench/benchmarks/schema.py
+++ b/asv_bench/benchmarks/schema.py
@@ -3,12 +3,12 @@
 
 from copy import deepcopy
 
-from kartothek.core.common_metadata import (
+from plateau.core.common_metadata import (
     make_meta,
     validate_compatible,
     validate_shared_columns,
 )
-from kartothek.core.testing import get_dataframe_alltypes
+from plateau.core.testing import get_dataframe_alltypes
 
 from .config import AsvBenchmarkConfig
 
diff --git a/asv_bench/benchmarks/write.py b/asv_bench/benchmarks/write.py
index 68799075..80dadd50 100644
--- a/asv_bench/benchmarks/write.py
+++ b/asv_bench/benchmarks/write.py
@@ -6,10 +6,10 @@
 
 from storefact import get_store_from_url
 
-from kartothek.core.common_metadata import make_meta
-from kartothek.core.testing import get_dataframe_alltypes
-from kartothek.io_components.metapartition import MetaPartition
-from kartothek.io_components.write import (
+from plateau.core.common_metadata import make_meta
+from plateau.core.testing import get_dataframe_alltypes
+from plateau.io_components.metapartition import MetaPartition
+from plateau.io_components.write import (
     persist_common_metadata,
     store_dataset_from_partitions,
 )
diff --git a/docs/conf.py b/docs/conf.py
index 436c49be..d690a508 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -6,9 +6,9 @@
 
 from sphinx.ext import apidoc
 
-from kartothek import __version__ as version
+from plateau import __version__ as version
 
-package = "kartothek"
+package = "plateau"
 
 nitpicky = True
 
@@ -56,7 +56,7 @@
 master_doc = "index"
 
 # General information about the project.
-project = "kartothek"
+project = "plateau"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -76,15 +76,15 @@
 html_static_path = ["_static"]
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "kartothek-doc"
+htmlhelp_basename = "plateau-doc"
 
 
 # -- External mapping ------------------------------------------------------------
 python_version = ".".join(map(str, sys.version_info[0:2]))
 
 nitpick_ignore = [
-    ("py:class", "kartothek.core._mixins.CopyMixin"),
-    ("py:class", "kartothek.serialization.LiteralValue"),
+    ("py:class", "plateau.core._mixins.CopyMixin"),
+    ("py:class", "plateau.serialization.LiteralValue"),
     ("py:class", "dask.delayed.Delayed"),
     # Literals
     ("py:class", "exact"),
@@ -126,6 +126,6 @@
     "dask.dataframe.core.DataFrame": "dask.dataframe.DataFrame",
     "dask.dataframe.core.Series": "dask.dataframe.Series",
     "dask.bag.core.Bag": "dask.bag.Bag",
-    "kartothek.serialization._generic": "kartothek.serialization",
-    "kartothek.serialization._parquet": "kartothek.serialization",
+    "plateau.serialization._generic": "plateau.serialization",
+    "plateau.serialization._parquet": "plateau.serialization",
 }
diff --git a/docs/environment-docs.yml b/docs/environment-docs.yml
index 388a4179..0239f50e 100644
--- a/docs/environment-docs.yml
+++ b/docs/environment-docs.yml
@@ -1,4 +1,4 @@
-name: kartothek-docs
+name: plateau-docs
 channels:
   - conda-forge
 dependencies:
diff --git a/docs/guide/dask_indexing.rst b/docs/guide/dask_indexing.rst
index 1032de6c..8ad68a0d 100644
--- a/docs/guide/dask_indexing.rst
+++ b/docs/guide/dask_indexing.rst
@@ -13,7 +13,7 @@ Calculating a dask index is usually a very expensive operation which requires da
     import pandas as pd
     from tempfile import TemporaryDirectory
 
-    from kartothek.api.dataset import store_dataframes_as_dataset
+    from plateau.api.dataset import store_dataframes_as_dataset
 
     dataset_dir = TemporaryDirectory()
 
@@ -40,7 +40,7 @@ Calculating a dask index is usually a very expensive operation which requires da
     :okwarning:
 
     import dask.dataframe as dd
-    from kartothek.api.dataset import update_dataset_from_ddf, read_dataset_as_ddf
+    from plateau.api.dataset import update_dataset_from_ddf, read_dataset_as_ddf
 
     df
 
@@ -48,7 +48,7 @@ Calculating a dask index is usually a very expensive operation which requires da
     ddf_indexed = ddf.set_index("B")
 
     dm = update_dataset_from_ddf(
-        # The key is to reset the index first and let kartothek do the rest
+        # The key is to reset the index first and let plateau do the rest
         ddf_indexed.reset_index(),
         table="table",
         dataset_uuid="dataset_ddf_with_index",
diff --git a/docs/guide/examples.rst b/docs/guide/examples.rst
index 3b4102e3..ee61c1b5 100644
--- a/docs/guide/examples.rst
+++ b/docs/guide/examples.rst
@@ -17,7 +17,7 @@ Setup a store
     :okwarning:
 
     import pandas as pd
-    from kartothek.api.dataset import read_table, store_dataframes_as_dataset
+    from plateau.api.dataset import read_table, store_dataframes_as_dataset
 
     df = pd.DataFrame({"Name": ["Paul", "Lisa"], "Age": [32, 29]})
 
@@ -51,7 +51,7 @@ Write
     :okwarning:
 
     import pandas as pd
-    from kartothek.api.dataset import store_dataframes_as_dataset
+    from plateau.api.dataset import store_dataframes_as_dataset
 
     #  Now, define the actual partitions. This list will, most of the time,
     # be the intermediate result of a previously executed pipeline which e.g. pulls
@@ -64,7 +64,7 @@ Write
         pd.DataFrame({"A": range(10, 20)}),
     ]
 
-    # The pipeline will return a :class:`~kartothek.core.dataset.DatasetMetadata` object
+    # The pipeline will return a :class:`~plateau.core.dataset.DatasetMetadata` object
     #  which refers to the created dataset
     dataset = store_dataframes_as_dataset(
         dfs=input_list_of_partitions,
@@ -82,7 +82,7 @@ Read
 .. ipython:: python
 
     import pandas as pd
-    from kartothek.api.dataset import read_dataset_as_dataframes
+    from plateau.api.dataset import read_dataset_as_dataframes
 
     #  Create the pipeline with a minimal set of configs
     list_of_partitions = read_dataset_as_dataframes(
@@ -110,14 +110,14 @@ Write
     :okwarning:
 
     import pandas as pd
-    from kartothek.api.dataset import store_dataframes_as_dataset__iter
+    from plateau.api.dataset import store_dataframes_as_dataset__iter
 
     input_list_of_partitions = [
         pd.DataFrame({"A": range(10)}),
         pd.DataFrame({"A": range(10, 20)}),
     ]
 
-    # The pipeline will return a :class:`~kartothek.core.dataset.DatasetMetadata` object
+    # The pipeline will return a :class:`~plateau.core.dataset.DatasetMetadata` object
     #  which refers to the created dataset
     dataset = store_dataframes_as_dataset__iter(
         input_list_of_partitions,
@@ -135,7 +135,7 @@ Read
     :okwarning:
 
     import pandas as pd
-    from kartothek.api.dataset import read_dataset_as_dataframes__iterator
+    from plateau.api.dataset import read_dataset_as_dataframes__iterator
 
     #  Create the pipeline with a minimal set of configs
     list_of_partitions = read_dataset_as_dataframes__iterator(
@@ -166,7 +166,7 @@ Write
     :okwarning:
 
     import pandas as pd
-    from kartothek.api.dataset import store_delayed_as_dataset
+    from plateau.api.dataset import store_delayed_as_dataset
 
     input_list_of_partitions = [
         pd.DataFrame({"A": range(10)}),
@@ -197,7 +197,7 @@ Read
 
     import dask
     import pandas as pd
-    from kartothek.api.dataset import read_dataset_as_delayed
+    from plateau.api.dataset import read_dataset_as_delayed
 
     tasks = read_dataset_as_delayed(dataset_uuid="MyFirstDatasetDask", store=store_url)
     tasks
diff --git a/docs/guide/getting_started.rst b/docs/guide/getting_started.rst
index 81febdec..90fb93e4 100644
--- a/docs/guide/getting_started.rst
+++ b/docs/guide/getting_started.rst
@@ -5,7 +5,7 @@ Getting Started
 ===============
 
 
-When working with Kartothek tables as a Python user, we will use :class:`~pandas.DataFrame`
+When working with plateau tables as a Python user, we will use :class:`~pandas.DataFrame`
 as the user-facing type.
 
 We typically expect that the contents of a dataset are
@@ -63,7 +63,7 @@ what follows is the filepath).
 
 .. admonition:: Storage locations
 
-    `storefact`_ offers support for several stores in Kartothek, these can be created using the
+    `storefact`_ offers support for several stores in plateau, these can be created using the
     function `storefact.get_store_from_url` with one of the following prefixes:
 
     - ``hfs``: Local filesystem
@@ -73,7 +73,7 @@ what follows is the filepath).
 Interface
 ---------
 
-Kartothek can write to any location that
+plateau can write to any location that
 fulfills the `simplekv.KeyValueStore interface
 <https://simplekv.readthedocs.io/en/latest/#simplekv.KeyValueStore>`_  as long as they
 support `ExtendedKeyspaceMixin
@@ -88,13 +88,13 @@ Writing data to storage
 =======================
 
 Now that we have some data and a location to store it in, we can persist it as a
-dataset. To do so, we will use :func:`~kartothek.io.eager.store_dataframes_as_dataset`
+dataset. To do so, we will use :func:`~plateau.io.eager.store_dataframes_as_dataset`
 to store the ``DataFrame`` ``df`` that we already have in memory.
 
 .. ipython:: python
     :okwarning:
 
-    from kartothek.api.dataset import store_dataframes_as_dataset
+    from plateau.api.dataset import store_dataframes_as_dataset
 
     df.dtypes.equals(another_df.dtypes)  # both have the same schema
 
@@ -106,11 +106,11 @@ to store the ``DataFrame`` ``df`` that we already have in memory.
 .. admonition:: Scheduling backends
 
     The import path of this function already gives us a hint about the general
-    structuring of the Kartothek modules. In :mod:`kartothek.io` we have all
+    structuring of the plateau modules. In :mod:`plateau.io` we have all
     the building blocks to build data pipelines that read and write from/to storages.
     The next module level (e.g. ``eager``) describes the scheduling backend.
 
-    The scheduling backends `currently supported` by Kartothek are:
+    The scheduling backends `currently supported` by plateau are:
 
     - ``eager`` runs all execution immediately and on the local machine.
     - ``iter`` executes operations on the dataset using a generator/iterator interface.
@@ -122,8 +122,8 @@ to store the ``DataFrame`` ``df`` that we already have in memory.
       for the respective `dask`_ collections.
 
 
-After calling :func:`~kartothek.io.eager.store_dataframes_as_dataset`,
-a :class:`~kartothek.core.dataset.DatasetMetadata` object is returned.
+After calling :func:`~plateau.io.eager.store_dataframes_as_dataset`,
+a :class:`~plateau.core.dataset.DatasetMetadata` object is returned.
 This class holds information about the structure and schema of the dataset.
 
 .. ipython:: python
@@ -144,7 +144,7 @@ See :ref:`type_system` for more information.
 To store multiple dataframes into a dataset, it is possible to pass a collection of
 dataframes; the exact format will depend on the I/O backend used.
 
-Kartothek assumes these dataframes are different chunks of the same table and
+plateau assumes these dataframes are different chunks of the same table and
 will therefore be required to have the same schema. A ``ValueError`` will be
 thrown otherwise.
 For example,
@@ -187,22 +187,22 @@ Reading data from storage
 =========================
 
 After we have written the data, we may want to read it back in again. For this we can
-use :func:`~kartothek.io.eager.read_table`. This method returns the complete
+use :func:`~plateau.io.eager.read_table`. This method returns the complete
 table of the dataset as a pandas DataFrame.
 
 .. ipython:: python
 
-    from kartothek.api.dataset import read_table
+    from plateau.api.dataset import read_table
 
     read_table("a_unique_dataset_identifier", store_url)
 
 
 We can also read a dataframe iteratively, using
-:func:`~kartothek.io.iter.read_dataset_as_dataframes__iterator`. This will return a generator of :class:`pandas.DataFrame` where every element represents one file. For example,
+:func:`~plateau.io.iter.read_dataset_as_dataframes__iterator`. This will return a generator of :class:`pandas.DataFrame` where every element represents one file. For example,
 
 .. ipython:: python
 
-    from kartothek.api.dataset import read_dataset_as_dataframes__iterator
+    from plateau.api.dataset import read_dataset_as_dataframes__iterator
 
     for partition_index, df in enumerate(
         read_dataset_as_dataframes__iterator(
@@ -214,18 +214,18 @@ We can also read a dataframe iteratively, using
         print(f"Data: \n{df}")
 
 Respectively, the ``dask.delayed`` back-end provides the function
-:func:`~kartothek.io.dask.delayed.read_dataset_as_delayed`, which has a very similar
-interface to the :func:`~kartothek.io.iter.read_dataset_as_dataframes__iterator`
+:func:`~plateau.io.dask.delayed.read_dataset_as_delayed`, which has a very similar
+interface to the :func:`~plateau.io.iter.read_dataset_as_dataframes__iterator`
 function but returns a collection of ``dask.delayed`` objects.
 
 
 .. admonition:: Filtering using predicates
 
     It is possible to filter data during reads using simple predicates by using
-    the ``predicates`` argument. Technically speaking, Kartothek supports predicates
+    the ``predicates`` argument. Technically speaking, plateau supports predicates
     in `disjunctive normal form <https://en.wikipedia.org/wiki/Disjunctive_normal_form>`_.
 
-    When this argument is defined, Kartothek uses the Apache Parquet metadata
+    When this argument is defined, plateau uses the Apache Parquet metadata
     as well as indices and partition information to speed up queries when possible.
     How this works is a complex topic, see :ref:`efficient_querying`.
 
diff --git a/docs/guide/mutating_datasets.rst b/docs/guide/mutating_datasets.rst
index 065749f9..32536edb 100644
--- a/docs/guide/mutating_datasets.rst
+++ b/docs/guide/mutating_datasets.rst
@@ -4,13 +4,13 @@ Mutating Datasets
 =================
 
 It's possible to update existing data
-by adding new physical partitions to them and deleting or replacing old partitions. Kartothek
+by adding new physical partitions to them and deleting or replacing old partitions. plateau
 provides update functions that generally have the prefix `update_dataset` in their names.
-For example, :func:`~kartothek.io.eager.update_dataset_from_dataframes` is the update
+For example, :func:`~plateau.io.eager.update_dataset_from_dataframes` is the update
 function for the ``eager`` backend.
 
 To see updating in action, let's first set up a storage location and store
-some data there with Kartothek.
+some data there with plateau.
 
 .. ipython:: python
     :suppress:
@@ -21,7 +21,7 @@ some data there with Kartothek.
     from tempfile import TemporaryDirectory
     from storefact import get_store_from_url
 
-    from kartothek.api.dataset import store_dataframes_as_dataset
+    from plateau.api.dataset import store_dataframes_as_dataset
 
     dataset_dir = TemporaryDirectory()
 
@@ -56,12 +56,12 @@ Appending Data
 --------------
 
 Now, we create ``another_df`` with the same schema as our intial dataframe
-``df`` and update it using the ``eager`` backend by calling :func:`~kartothek.io.eager.update_dataset_from_dataframes`:
+``df`` and update it using the ``eager`` backend by calling :func:`~plateau.io.eager.update_dataset_from_dataframes`:
 
 .. ipython:: python
     :okwarning:
 
-    from kartothek.api.dataset import update_dataset_from_dataframes
+    from plateau.api.dataset import update_dataset_from_dataframes
 
     another_df = pd.DataFrame(
         {
@@ -91,7 +91,7 @@ previous contents.
 
 .. ipython:: python
 
-    from kartothek.api.dataset import read_table
+    from plateau.api.dataset import read_table
 
     updated_df = read_table(dataset_uuid=dm.uuid, store=store_url)
     updated_df
@@ -135,7 +135,7 @@ the partition ``B=2013-01-02[...]`` has in fact been removed.
     on any column(s); however this is **not at all advised** since the effect will simply be to
     remove **all** previous partitions and replace them with the ones in the update.
 
-    If the intention of the user is to delete the entire dataset, using :func:`kartothek.io.eager.delete_dataset`
+    If the intention of the user is to delete the entire dataset, using :func:`plateau.io.eager.delete_dataset`
     would be a much better, cleaner and safer way to go about doing so.
 
 
@@ -208,7 +208,7 @@ with one update:
     read_table(dm.uuid, store_url)
 
 
-As can be seen in the example above, the resultant dataframe from :func:`~kartothek.io.eager.read_table`
+As can be seen in the example above, the resultant dataframe from :func:`~plateau.io.eager.read_table`
 consists of two rows corresponding to ``B=2013-01-02`` (from ``df``) and four rows corresponding to ``B=2013-01-03`` from ``modified_df``.
 Thus, the original partition with the two rows corresponding to ``B=2013-01-03`` from ``df``
 has been completely replaced.
@@ -218,17 +218,17 @@ has been completely replaced.
 Garbage collection
 ------------------
 
-When Kartothek is executing an operation, it makes sure to not
+When plateau is executing an operation, it makes sure to not
 commit changes to the dataset until the operation has been succesfully completed. If a
 write operation does not succeed for any reason, although there may be new files written
 to storage, those files will not be used by the dataset as they will not be referenced in
-the Kartothek metadata. Thus, when the user reads the dataset, no new data will
+the plateau metadata. Thus, when the user reads the dataset, no new data will
 appear in the output.
 
-Similarly, when deleting a partition, Kartothek only removes the reference of that file
+Similarly, when deleting a partition, plateau only removes the reference of that file
 from the metadata.
 
-These temporary files will remain in storage until a Kartothek  garbage collection
+These temporary files will remain in storage until a plateau  garbage collection
 function is called on the dataset.
 If a dataset is updated on a regular basis, it may be useful to run garbage collection
 periodically to decrease unnecessary storage use.
@@ -236,12 +236,12 @@ periodically to decrease unnecessary storage use.
 An example of garbage collection is shown below.
 A little above, near the end of the delete section,
 we removed two partitions for the dataset with uuid `replace_partition`.
-The removed files remain in storage but are untracked by Kartothek.
+The removed files remain in storage but are untracked by plateau.
 When garbage collection is called, the files are removed.
 
 .. ipython:: python
 
-    from kartothek.api.dataset import garbage_collect_dataset
+    from plateau.api.dataset import garbage_collect_dataset
     from storefact import get_store_from_url
 
     store = get_store_from_url(store_url)
@@ -273,7 +273,7 @@ The mutating operation will update all indices that currently exist for the data
 
     new_df = pd.DataFrame({"payload": range(10), "i1": 1, "i2": "c"})
 
-If we do not specify anything, kartothek will infer the indices and update them correctly
+If we do not specify anything, plateau will infer the indices and update them correctly
 
 .. ipython:: python
     :okwarning:
diff --git a/docs/guide/partitioning.rst b/docs/guide/partitioning.rst
index 6a1c31c9..8203a137 100644
--- a/docs/guide/partitioning.rst
+++ b/docs/guide/partitioning.rst
@@ -4,7 +4,7 @@
 Partitioning
 ============
 
-As we have already seen, writing data in Kartothek amounts to writing
+As we have already seen, writing data in plateau amounts to writing
 partitions, which in the underlying key-value store translates to writing files
 to the storage layer in a structured manner.
 
@@ -13,7 +13,7 @@ of written data didn't require reading through an entire dataset to be able to
 identify and access the required subset. This is where *explicitly* partitioning by
 table columns helps.
 
-Kartothek is designed primarily for storing large datasets consistently. One way
+plateau is designed primarily for storing large datasets consistently. One way
 to do this is to structure the data well, this can be done by
 explicitly partitioning the dataset by select columns.
 
@@ -22,7 +22,7 @@ which makes reading as well as mutating (replacing or deleting) subsets of data
 more efficient as only a select amount of files need to be read.
 
 To see explicit partitioning in action, let's set up some data and a storage location
-first and store the data there with Kartothek:
+first and store the data there with plateau:
 
 .. ipython:: python
 
@@ -32,7 +32,7 @@ first and store the data there with Kartothek:
     from tempfile import TemporaryDirectory
     from storefact import get_store_from_url
 
-    from kartothek.api.dataset import store_dataframes_as_dataset
+    from plateau.api.dataset import store_dataframes_as_dataset
 
     dataset_dir = TemporaryDirectory()
 
@@ -56,7 +56,7 @@ first and store the data there with Kartothek:
     df
 
 
-Kartothek allows users to explicitly partition their data by the values of table
+plateau allows users to explicitly partition their data by the values of table
 columns such that, for a given input partition, all the rows with the same value of the
 column all get written to the same partition. To do this, we use the
 ``partition_on`` keyword argument:
@@ -105,7 +105,7 @@ can be read as just the 2 logical partitions by using the argument
 ``dispatch_by=["E", "F"]`` at reading time).
 
 
-As noted above, when data is appended to a dataset, Kartothek guarantees it has
+As noted above, when data is appended to a dataset, plateau guarantees it has
 the proper schema and partitioning.
 
 The order of columns provided in ``partition_on`` is important, as the partition
@@ -126,7 +126,7 @@ number of physical input partitions.
 
     import dask.dataframe as dd
     import numpy as np
-    from kartothek.api.dataset import update_dataset_from_ddf
+    from plateau.api.dataset import update_dataset_from_ddf
 
     df = pd.DataFrame(
         {
diff --git a/docs/index.rst b/docs/index.rst
index 76536426..7639bf15 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -1,18 +1,18 @@
 ================================================
-kartothek - manage tabular data in object stores
+plateau - manage tabular data in object stores
 ================================================
 
 :Release: |release|
 :Date: |today|
 
 
-Kartothek is a Python library to manage (create, read, update, delete) large
+plateau is a Python library to manage (create, read, update, delete) large
 amounts of tabular data in a blob store. It stores data as datasets, which
 it presents as pandas DataFrames to the user. Datasets are a collection of
-files with the same schema that reside in a blob store. Kartothek uses a
+files with the same schema that reside in a blob store. plateau uses a
 metadata definition to handle these datasets efficiently. For distributed
-access and manipulation of datasets, Kartothek offers a `Dask
-<https://dask.org>`_ interface (:mod:`kartothek.io.dask`).
+access and manipulation of datasets, plateau offers a `Dask
+<https://dask.org>`_ interface (:mod:`plateau.io.dask`).
 
 Storing data distributed over multiple files in a blob store (S3, ABS, GCS,
 etc.) allows for a fast, cost-efficient and highly scalable data
@@ -20,23 +20,16 @@ infrastructure. A downside of storing data solely in an object store is that the
 storages themselves give little to no guarantees beyond the consistency of a
 single file. In particular, they cannot guarantee the consistency of your
 dataset. If we demand a consistent state of our dataset at all times, we need to
-track the state of the dataset. Kartothek frees us from having to do this
+track the state of the dataset. plateau frees us from having to do this
 manually.
 
-The :mod:`kartothek.io` module provides building blocks to create and modify
-these datasets in data pipelines. Kartothek handles I/O, tracks dataset
+The :mod:`plateau.io` module provides building blocks to create and modify
+these datasets in data pipelines. plateau handles I/O, tracks dataset
 partitions and selects subsets of data transparently.
 
 To get started, have a look at our :doc:`guide/getting_started` guide,
 head to the description of the :doc:`spec/format_specification` or head straight to the API documentation :doc:`api`.
 
-What is a (real) Kartothek?
----------------------------
-
-A Kartothek (or more modern: Zettelkasten/Katalogkasten) is a tool to organize
-(high-level) information extracted from a source of information.
-
-
 .. toctree::
    :maxdepth: 2
    :caption: Guides
diff --git a/docs/spec/efficient_querying.rst b/docs/spec/efficient_querying.rst
index 850fc92b..0089fed1 100644
--- a/docs/spec/efficient_querying.rst
+++ b/docs/spec/efficient_querying.rst
@@ -4,8 +4,8 @@
 Efficient Querying
 ==================
 
-In general, Kartothek should know as early as possible which data to exclude, so
-Kartothek doesn't have to read and transfer it. If you're going to query a
+In general, plateau should know as early as possible which data to exclude, so
+plateau doesn't have to read and transfer it. If you're going to query a
 dataset a lot, you should consider storing it in an optimized layout. See
 :ref:`writing`.
 
@@ -15,24 +15,24 @@ dataset a lot, you should consider storing it in an optimized layout. See
 Background
 ----------
 
-To understand how to query efficiently, you should understand Kartothek's
+To understand how to query efficiently, you should understand plateau's
 querying process:
 
-When querying data, Kartothek tries to apply the given predicates as early as
+When querying data, plateau tries to apply the given predicates as early as
 possible, so it has to read and parse as few parquet files as possible:
 
-- During partition pruning, Kartothek looks if there exists an index for the
+- During partition pruning, plateau looks if there exists an index for the
   filtered column. This may either be if we partitioned the column (primary
-  index) or if we generated a secondary index for it. Kartothek then combines
+  index) or if we generated a secondary index for it. plateau then combines
   the results for multiple columns.
-- In the resulting set of Parquet files, Kartothek looks at the Parquet
+- In the resulting set of Parquet files, plateau looks at the Parquet
   metadata, which states the range of values for each column in this file. If
   there are multiple row groups, each one specifies the range of values inside
-  it. Kartothek checks if the queried data is in the range of a row group and
+  it. plateau checks if the queried data is in the range of a row group and
   therefore if this row group is loaded. This process is called Predicate
   Pushdown.
 
-Kartothek then fetches these row groups and filters the resulting Pandas
+plateau then fetches these row groups and filters the resulting Pandas
 dataframes for the conditions that could not be (completely) resolved by
 then.
 
@@ -50,7 +50,7 @@ include the following in your query:
   or secondary indices)
 * specific selection of columns
 
-Through restrictions on partitioned columns and indexed columns, Kartothek can
+Through restrictions on partitioned columns and indexed columns, plateau can
 significantly reduce the number of parquet files to look at. The selection of
 columns allows it to transfer only a subset of the data.
 
@@ -67,15 +67,15 @@ dataset is partitioned by ``A`` and a secondary index for ``B`` was generated.
 
 .. code-block:: python
 
-    df = kartothek.io.eager.read_table(
+    df = plateau.io.eager.read_table(
         store=some_store,
         predicates=[[("A", ">=", 5), ("A", "<", 10), ("B", "==", 100), ("C", "<", 0)]],
     )
 
-- Kartothek looks into the index for ``B`` to find the relevant Parquet files.
+- plateau looks into the index for ``B`` to find the relevant Parquet files.
 - It filters the Parquet files for the ones, that lie in the partitions ``A=5``
   to ``A=9``.
-- The Parquet files are filtered by looking at their footer. Kartothek can see
+- The Parquet files are filtered by looking at their footer. plateau can see
   there if the range of values for column ``C`` match the searched values.
 - The relevant files are loaded and filtered with Pandas for ``C < 0``.
 
@@ -99,7 +99,7 @@ refine them based on your results.
 * Avoid string columns. Try to use a more specific datatype. See
   :doc:`type_system` for more information on possible column types.
 
-See :func:`kartothek.io.dask.dataframe.update_dataset_from_ddf` for more
+See :func:`plateau.io.dask.dataframe.update_dataset_from_ddf` for more
 information.
 
 
diff --git a/docs/spec/format_specification.rst b/docs/spec/format_specification.rst
index af031423..545e3357 100644
--- a/docs/spec/format_specification.rst
+++ b/docs/spec/format_specification.rst
@@ -95,7 +95,7 @@ components that are separated by a single dot each:
 
  * The UUID of the dataset. This should be a string that hasn't been used yet
    for prefixing any other file in the storage location. One may use the
-   Python function :func:`~kartothek.core.uuid.gen_uuid()` (UUID type 4) to generate
+   Python function :func:`~plateau.core.uuid.gen_uuid()` (UUID type 4) to generate
    such a UUID but the only requirement here is that there is no other file in
    the target location that has the same prefix.
  * The identifier ``by-dataset-metadata``. The character sequence
@@ -103,7 +103,7 @@ components that are separated by a single dot each:
    than main metadata files for datasets.
  * The suffix json or msgpack.zstd to describe the file format
    (msgpack.zstd denotes a zstd compressed msgpack file in a
-   Kartothek dataset).
+   plateau dataset).
 
 Example:
 ::
@@ -121,7 +121,7 @@ The table schema information consists of thee components:
 
  * The UUID of the dataset. This should be a string that hasn't been used yet
    for prefixing any other file in the storage location. One may use the
-   :func:`~kartothek.core.uuid.gen_uuid()` (UUID type 4) to generate such a UUID.
+   :func:`~plateau.core.uuid.gen_uuid()` (UUID type 4) to generate such a UUID.
  * The table identifier
  * The string _common_metadata
 
@@ -141,7 +141,7 @@ These files must consist of the following forward-slash separated components:
 
  * The UUID of the dataset. This should be a string that hasn't been used yet
    for prefixing any other file in the storage location. One may use the
-   :func:`~kartothek.core.uuid.gen_uuid()` (UUID type 4) to generate such a UUID.
+   :func:`~plateau.core.uuid.gen_uuid()` (UUID type 4) to generate such a UUID.
  * The table identifier
  * (optional) partition content encoding
  * The partition identifier.
@@ -176,7 +176,7 @@ These files must consist of the following dot-separated components:
 
  * The UUID of the dataset. This should be a string that hasn't been used yet
    for prefixing any other file in the storage location. One may use the
-   :func:`~kartothek.core.uuid.gen_uuid()` (UUID type 4) to generate such a UUID.
+   :func:`~plateau.core.uuid.gen_uuid()` (UUID type 4) to generate such a UUID.
  * A hard coded identifier ``indices``
  * The name of the field used in the index
  * A url encoded ISO 8601 timestamp (format ``YYYY-MM-DDTHH:MM:SS.ffffff``)
diff --git a/docs/spec/indexing.rst b/docs/spec/indexing.rst
index c6b5eeb8..21e5d3a9 100644
--- a/docs/spec/indexing.rst
+++ b/docs/spec/indexing.rst
@@ -3,13 +3,13 @@
 Indexing
 ========
 
-Kartothek uses different types of `inverted file indices`_ to enable efficient partition pruning and improve query performance, see also :doc:`efficient_querying` for more hints on how to optimize performance. This section describes the different types of indices, how to create them and how to interact with them
+plateau uses different types of `inverted file indices`_ to enable efficient partition pruning and improve query performance, see also :doc:`efficient_querying` for more hints on how to optimize performance. This section describes the different types of indices, how to create them and how to interact with them
 
 
 Principle in-memory representation
 ----------------------------------
 
-All currently supported kartothek index types are inverted indices and are mapping observed values of a given field to a list of partitions where they were observed.
+All currently supported plateau index types are inverted indices and are mapping observed values of a given field to a list of partitions where they were observed.
 
 .. ipython:: python
 
@@ -19,11 +19,11 @@ Where, in this example, the value ``1`` is found in exactly one partition which
 
 Users typically do not interact with indices directly since querying a dataset will automatically load and interact with the indices. For some applications it is still quite useful to interact with them directly.
 
-All indices implement :class:`~kartothek.core.index.IndexBase` which allows the user to interact with the indices in some useful ways.
+All indices implement :class:`~plateau.core.index.IndexBase` which allows the user to interact with the indices in some useful ways.
 
 .. ipython:: python
 
-    from kartothek.api.dataset import IndexBase
+    from plateau.api.dataset import IndexBase
 
     index = IndexBase(column="FieldName", index_dct=index_dct)
 
@@ -39,17 +39,17 @@ All indices implement :class:`~kartothek.core.index.IndexBase` which allows the
 Partition Indices
 -----------------
 
-The first index type kartothek offers is a partition index. The partition index is created by partitioning a dataset in a hive-like partition scheme.
+The first index type plateau offers is a partition index. The partition index is created by partitioning a dataset in a hive-like partition scheme.
 
 .. ipython:: python
     :suppress:
 
     import string
     import pandas as pd
-    from kartothek.api.dataset import ensure_store
+    from plateau.api.dataset import ensure_store
 
     store = ensure_store("hmemory://")
-    from kartothek.api.dataset import store_dataframes_as_dataset
+    from plateau.api.dataset import store_dataframes_as_dataset
 
 .. ipython:: python
     :okwarning:
diff --git a/docs/spec/parallel_dask.rst b/docs/spec/parallel_dask.rst
index 61ceebba..0dbca393 100644
--- a/docs/spec/parallel_dask.rst
+++ b/docs/spec/parallel_dask.rst
@@ -4,45 +4,45 @@
 Parallel Execution with Dask
 ============================
 
-You should understand :ref:`Kartothek's Querying Process <querying_process>`.
+You should understand :ref:`plateau's Querying Process <querying_process>`.
 
 Queries
 -------
 
-Kartothek executes queries with a task for every parquet file to read. But
-Kartothek doesn't read every file. It filters them by the predicate's
+plateau executes queries with a task for every parquet file to read. But
+plateau doesn't read every file. It filters them by the predicate's
 restrictions on partitions and indexed columns.
 
 The example dataset in the following pictures is partitioned on column ``A``.
 The bottom half shows the existing parquet files; the upper half shows the
 querying process with the (possibly) created tasks. We filter the data for
-``A=2 AND B="b"``. Kartothek only processes the files ``A=2/label1.parquet``
+``A=2 AND B="b"``. plateau only processes the files ``A=2/label1.parquet``
 and ``A=2/label2.parquet`` because of the restriction on the partitioned column
 ``A``.
 
 .. image:: /images/kartothek_read_dispatch.png
   :width: 600
-  :alt: Kartothek dispatches tasks by parquet file
+  :alt: plateau dispatches tasks by parquet file
 
 
-Kartothek matches every file's range of values (stated in the parquet footer)
+plateau matches every file's range of values (stated in the parquet footer)
 against the query.
 
-Kartothek rules out the existence of a row with ``B="b"`` in ``A=2/label1.parquet``
+plateau rules out the existence of a row with ``B="b"`` in ``A=2/label1.parquet``
 as the Parquet statistics state both the minimum and maximum of column ``B`` to
-be ``"a"``. Thus, Kartothek doesn't read this file and only reads
+be ``"a"``. Thus, plateau doesn't read this file and only reads
 ``A=2/label2.parquet``.
 
 .. image:: /images/kartothek_read_pushdown.png
   :width: 600
-  :alt: Kartothek pushes down parts of the query to the parquet layer
+  :alt: plateau pushes down parts of the query to the parquet layer
 
 If a file's range of values doesn't match, the task returns an empty Dataframe.
 Otherwise, the task loads the file and filter its data.
 
 .. image:: /images/kartothek_read_final.png
   :width: 600
-  :alt: Kartothek filters the resulting dataframes in every task
+  :alt: plateau filters the resulting dataframes in every task
 
 The loaded dataframes then make up the result.
 
@@ -64,8 +64,8 @@ network between the workers. More information can be found in `Dask's
 documentation <https://docs.dask.org/en/latest/dataframe-groupby.html>`_.
 
 At the end of either case, the results of the writes are collected and finally
-atomically committed to Kartothek's dataset.
+atomically committed to plateau's dataset.
 
 .. image:: /images/kartothek_partition_on.png
   :width: 600
-  :alt: Kartothek's storing process
\ No newline at end of file
+  :alt: plateau's storing process
diff --git a/docs/spec/serialization.rst b/docs/spec/serialization.rst
index 8c566168..eaa41aa5 100644
--- a/docs/spec/serialization.rst
+++ b/docs/spec/serialization.rst
@@ -10,12 +10,12 @@ Serialisation to bytes
 ----------------------
 
 For the serialsation, we need to pick a format serializer, you either use
-:func:`~kartothek.serialization.default_serializer` or explicitly select a serializer,
-e.g. :class:`~kartothek.serialization.ParquetSerializer`.
+:func:`~plateau.serialization.default_serializer` or explicitly select a serializer,
+e.g. :class:`~plateau.serialization.ParquetSerializer`.
 
 .. code:: python
 
-    from kartothek.api.serialization import ParquetSerializer
+    from plateau.api.serialization import ParquetSerializer
 
     serializer = ParquetSerializer()
     df = ...
@@ -30,7 +30,7 @@ one is determined from the filename.
 
 .. code:: python
 
-    from kartothek.api.serialization import DataFrameSerializer
+    from plateau.api.serialization import DataFrameSerializer
 
     df = DataFrameSerializer.restore_dataframe(store, "file.parquet")
 
@@ -38,7 +38,7 @@ one is determined from the filename.
 Supported data types
 --------------------
 
-Kartothek generally does not impose any restrictions on the data types to be used as long as they are compatible and in alignment with the :doc:`pyarrow pandas integration<python/pandas>`.
+plateau generally does not impose any restrictions on the data types to be used as long as they are compatible and in alignment with the :doc:`pyarrow pandas integration<python/pandas>`.
 
 For a detailed explanation about how types are handled, please consult :doc:`type_system`.
 
@@ -71,7 +71,7 @@ The predicate expression can be provided to the `predicates` keyword argument of
 
 .. note::
 
-    All kartothek reading pipelines are exposing this `predicates` argument as well where it is not only used for predicate pushdown but also for partition pruning. See :doc:`efficient_querying` for details.
+    All plateau reading pipelines are exposing this `predicates` argument as well where it is not only used for predicate pushdown but also for partition pruning. See :doc:`efficient_querying` for details.
 
 
 Literals, operators and typing
@@ -93,8 +93,8 @@ Filtering for missing values / nulls is supported with operators `==`, `!=` and
 
 See also
 --------
-* :class:`~kartothek.serialization.DataFrameSerializer`
-* :class:`~kartothek.serialization.ParquetSerializer`
+* :class:`~plateau.serialization.DataFrameSerializer`
+* :class:`~plateau.serialization.ParquetSerializer`
 * :doc:`efficient_querying`
 * :doc:`type_system`
 
diff --git a/docs/spec/storage_layout.rst b/docs/spec/storage_layout.rst
index 64589e98..6c9717f7 100644
--- a/docs/spec/storage_layout.rst
+++ b/docs/spec/storage_layout.rst
@@ -4,18 +4,18 @@
 Storage Layout
 ==============
 
-Kartothek structures your data using these concepts:
+plateau structures your data using these concepts:
 
-- One whole unit of data that Kartothek manages is called a *dataset*.
+- One whole unit of data that plateau manages is called a *dataset*.
 - A dataset consists of one or more *tables* that each have a *schema*. 
 - Table rows are partitioned by any number of columns: Rows having the same combination
   of values in these columns are grouped together.
 - A partition consists of one or more Parquet files, which contain a chunk of rows that
   were written at a time.
-- Kartothek can also generate an index for any number of columns, which speeds up finding
+- plateau can also generate an index for any number of columns, which speeds up finding
   the relevant Parquet files for specific values for the indexed column.
 
-A general Kartothek storage layout thus looks as follows::
+A general plateau storage layout thus looks as follows::
 
   ─ <dataset_uuid>.by-dataset-metadata.json
   ─ <dataset_uuid>/
@@ -60,4 +60,4 @@ Where:
 - ``<dataset_uuid>.by-dataset-metadata.json`` contains the ``DatasetMetadata`` you have seen above.
 - ``<tableN>`` contains the data for any tables in the dataset, partitioned by N >= 0 columns. The directory structure will be N folders deep.
 - ``_common_metadata`` contains the table schema of ``dfN.parquet``. It is always identical for all Parquet files of a table.
-- ``indices`` contains a database index for each index column, for quick lookup of rows where the column value matches a given value.
\ No newline at end of file
+- ``indices`` contains a database index for each index column, for quick lookup of rows where the column value matches a given value.
diff --git a/docs/spec/store_interface.rst b/docs/spec/store_interface.rst
index df25a845..e492996f 100644
--- a/docs/spec/store_interface.rst
+++ b/docs/spec/store_interface.rst
@@ -17,17 +17,17 @@ or network nodes sensibly. A prime Example is the ``simplekv.memory.DictStore``
 which uses a simple python dictionary as a backend store. It is technically
 possible to (de-)serialize the store but once it is deserialized in another
 process, or another node, the store looses its meaning since the stores are
-isolated per process, node, etc. Kartothek does not verify semantics of a given
+isolated per process, node, etc. plateau does not verify semantics of a given
 store but only verifies whether or not the store implements the pickle protocol.
 
 For all cases where the ``KeyValueStore`` does not implement the pickle
-protocol, or some more complex logic is required to initialize it, kartothek
+protocol, or some more complex logic is required to initialize it, plateau
 also accepts _factories_ which must be a callable returning a ``KeyValueStore``
-(see also ``kartothek.core.typing.StoreFactory``).
+(see also ``plateau.core.typing.StoreFactory``).
 
 For convenience we also offer a `storefact`_ integration and accept store urls
 which proves another easy level of access and is well suited for ad-hoc
 investigations.
 
 .. _simplekv: https://simplekv.readthedocs.io/
-.. _storefact: https://storefact.readthedocs.io/
\ No newline at end of file
+.. _storefact: https://storefact.readthedocs.io/
diff --git a/docs/spec/type_system.rst b/docs/spec/type_system.rst
index ce6adf2b..b84d8335 100644
--- a/docs/spec/type_system.rst
+++ b/docs/spec/type_system.rst
@@ -4,24 +4,24 @@
 Table type system
 =================
 
-This document explains the type system of Kartothek.
+This document explains the type system of plateau.
 
 
 Motivation
 ----------
-To understand why and how the type system was designed, we illustrate the requirements and use cases Kartothek should
+To understand why and how the type system was designed, we illustrate the requirements and use cases plateau should
 cover:
 
-- **simplicity:** For the average programmer, it should be possible to understand the semantics of Kartothek quickly.
+- **simplicity:** For the average programmer, it should be possible to understand the semantics of plateau quickly.
 - **optimized data representation:** Data providers (humans and software) should be able to pick a memory representation
   that is sufficient to hold the data in question (e.g. pick an 8-bit unsigned integer if you only have integer up to
   255).
 - **lifecycle management:** A dataset may be used for many months and can be extended over this time. Also, the
   software used with the dataset might change.
 - **efficiency:** Data written once should not be altered if not really necessary.
-- **stability:** Kartothek is made for production use. It should provide stable, predicable outputs and must not crash
+- **stability:** plateau is made for production use. It should provide stable, predicable outputs and must not crash
   or lead other libraries to behave in an expected way.
-- **compatibility:** Kartothek is not the only software in the stack and must play nicely with others (also see `Related
+- **compatibility:** plateau is not the only software in the stack and must play nicely with others (also see `Related
   Type Systems`_).
 
 
@@ -39,7 +39,7 @@ used when interacting with other languages like `R`_, `Julia`_ and `Java`_.
 
 .. note::
 
-   Most user interaction with Kartothek are likely done by using `Pandas`_ DataFrames. Please consolidate the pyarrow
+   Most user interaction with plateau are likely done by using `Pandas`_ DataFrames. Please consolidate the pyarrow
    documentation on `Type differences <https://arrow.apache.org/docs/python/pandas.html#type-differences>`_ to see how
    different `Pandas`_ constructs map to `Apache Arrow`_.
 
@@ -187,7 +187,7 @@ We currently do not implement a normalization. This might change in future metad
 .. warning::
 
    Because no normalization is implemented for different decimal precisions, we strongly advice against using them in
-   Kartothek.
+   plateau.
 
 Date
 ~~~~
@@ -221,7 +221,7 @@ metadata version.
      data and arithmetics. Use "midn" as a time (e.g. ``2019-05-21 00:00:00``) and most features including `Pandas`_
      support work as expected.
    - **extension types:** Using `Extension Types`_ would make it possible to have proper, fast date types in `Pandas`_.
-     Note that this would also require to either convert them back and forth before/after the Kartothek interaction or
+     Note that this would also require to either convert them back and forth before/after the plateau interaction or
      to teach pyarrow about them.
 
 Time
@@ -248,15 +248,15 @@ ranges. So, no normalization is implemented for timestamps.
 
 .. note::
 
-  For compatibility reasons, `kartothek` coerces timestamps to `us` accuracy, effectively truncating the timestamp. If the timestamp actually has a higher accuracy, arrow raises an exception, rejecting it
+  For compatibility reasons, `plateau` coerces timestamps to `us` accuracy, effectively truncating the timestamp. If the timestamp actually has a higher accuracy, arrow raises an exception, rejecting it
 
   .. ipython:: python
     :suppress:
     :okwarning:
 
     import pandas as pd
-    from kartothek.api.serialization import ParquetSerializer
-    from kartothek.api.dataset import ensure_store
+    from plateau.api.serialization import ParquetSerializer
+    from plateau.api.dataset import ensure_store
 
     store = ensure_store("memory://")
     ser = ParquetSerializer()
@@ -541,7 +541,7 @@ Python programmers can encounter different types systems, some examples are:
 
   - `Format - Logical Types <https://github.com/apache/parquet-format/blob/master/LogicalTypes.md>`_
 
-Kartothek aims to be as compatible as possible with them.
+plateau aims to be as compatible as possible with them.
 
 
 .. _Apache Arrow: https://arrow.apache.org/
diff --git a/docs/versioning.rst b/docs/versioning.rst
index 874a0576..8011846c 100644
--- a/docs/versioning.rst
+++ b/docs/versioning.rst
@@ -18,8 +18,8 @@ trigger an increase of the *major* version number.
 Library API
 -----------
 
-Kartothek exposes a dedicated module to highlight which functions, classes, etc. are considered stable API and are publicly available. We intend to apply [semantic
-versioning](https://semver.org) to the best of our ability for the API exposed in :mod:`kartothek.api`. See also :doc:`api`.
+plateau exposes a dedicated module to highlight which functions, classes, etc. are considered stable API and are publicly available. We intend to apply [semantic
+versioning](https://semver.org) to the best of our ability for the API exposed in :mod:`plateau.api`. See also :doc:`api`.
 
 We are aware that the API not only consists of the signatures of functions and
 types of objects exposed by a library but as well by its behaviour. Many changes
diff --git a/kartothek/api/dataset.py b/kartothek/api/dataset.py
deleted file mode 100644
index 0f9184e0..00000000
--- a/kartothek/api/dataset.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from kartothek.core import *  # noqa: F401, F403
-from kartothek.core.utils import *  # noqa: F401, F403
-from kartothek.io.dask.bag import *  # noqa: F401, F403
-from kartothek.io.dask.dataframe import *  # noqa: F401, F403
-from kartothek.io.dask.delayed import *  # noqa: F401, F403
-from kartothek.io.eager import *  # noqa: F401, F403
-from kartothek.io.iter import *  # noqa: F401, F403
diff --git a/kartothek/api/serialization.py b/kartothek/api/serialization.py
deleted file mode 100644
index 5d11bf60..00000000
--- a/kartothek/api/serialization.py
+++ /dev/null
@@ -1,1 +0,0 @@
-from kartothek.serialization import *  # noqa: F401, F403
diff --git a/kartothek/core/__init__.py b/kartothek/core/__init__.py
deleted file mode 100644
index 40a9511a..00000000
--- a/kartothek/core/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from kartothek.core.common_metadata import *  # noqa: F401, F403
-from kartothek.core.dataset import *  # noqa: F401, F403
-from kartothek.core.factory import *  # noqa: F401, F403
-from kartothek.core.index import *  # noqa: F401, F403
-from kartothek.core.typing import *  # noqa: F401, F403
-from kartothek.core.utils import *  # noqa: F401, F403
diff --git a/kartothek/utils/__init__.py b/kartothek/utils/__init__.py
deleted file mode 100644
index 5ff2d794..00000000
--- a/kartothek/utils/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""
-Utilities that are not kartothek-specific but are required to archive certain tasks.
-"""
diff --git a/kartothek/__init__.py b/plateau/__init__.py
similarity index 100%
rename from kartothek/__init__.py
rename to plateau/__init__.py
diff --git a/kartothek/api/__init__.py b/plateau/api/__init__.py
similarity index 100%
rename from kartothek/api/__init__.py
rename to plateau/api/__init__.py
diff --git a/plateau/api/dataset.py b/plateau/api/dataset.py
new file mode 100644
index 00000000..f940f1d3
--- /dev/null
+++ b/plateau/api/dataset.py
@@ -0,0 +1,7 @@
+from plateau.core import *  # noqa: F401, F403
+from plateau.core.utils import *  # noqa: F401, F403
+from plateau.io.dask.bag import *  # noqa: F401, F403
+from plateau.io.dask.dataframe import *  # noqa: F401, F403
+from plateau.io.dask.delayed import *  # noqa: F401, F403
+from plateau.io.eager import *  # noqa: F401, F403
+from plateau.io.iter import *  # noqa: F401, F403
diff --git a/plateau/api/serialization.py b/plateau/api/serialization.py
new file mode 100644
index 00000000..f433c4c8
--- /dev/null
+++ b/plateau/api/serialization.py
@@ -0,0 +1,1 @@
+from plateau.serialization import *  # noqa: F401, F403
diff --git a/plateau/core/__init__.py b/plateau/core/__init__.py
new file mode 100644
index 00000000..2707763e
--- /dev/null
+++ b/plateau/core/__init__.py
@@ -0,0 +1,6 @@
+from plateau.core.common_metadata import *  # noqa: F401, F403
+from plateau.core.dataset import *  # noqa: F401, F403
+from plateau.core.factory import *  # noqa: F401, F403
+from plateau.core.index import *  # noqa: F401, F403
+from plateau.core.typing import *  # noqa: F401, F403
+from plateau.core.utils import *  # noqa: F401, F403
diff --git a/kartothek/core/_compat.py b/plateau/core/_compat.py
similarity index 100%
rename from kartothek/core/_compat.py
rename to plateau/core/_compat.py
diff --git a/kartothek/core/_deprecation.py b/plateau/core/_deprecation.py
similarity index 100%
rename from kartothek/core/_deprecation.py
rename to plateau/core/_deprecation.py
diff --git a/kartothek/core/_mixins.py b/plateau/core/_mixins.py
similarity index 100%
rename from kartothek/core/_mixins.py
rename to plateau/core/_mixins.py
diff --git a/kartothek/core/_time.py b/plateau/core/_time.py
similarity index 87%
rename from kartothek/core/_time.py
rename to plateau/core/_time.py
index 218a9061..e4d02360 100644
--- a/kartothek/core/_time.py
+++ b/plateau/core/_time.py
@@ -1,7 +1,7 @@
 """
 Functions to get the current time.
 
-kartothek modules that need to get the current time should do so only
+plateau modules that need to get the current time should do so only
 via this module. This allows test to monkeypatch the methods
 in this module to fake certain fixed times.
 """
diff --git a/kartothek/core/_zmsgpack.py b/plateau/core/_zmsgpack.py
similarity index 100%
rename from kartothek/core/_zmsgpack.py
rename to plateau/core/_zmsgpack.py
diff --git a/kartothek/core/common_metadata.py b/plateau/core/common_metadata.py
similarity index 99%
rename from kartothek/core/common_metadata.py
rename to plateau/core/common_metadata.py
index 2472dcc4..ee78e3b1 100644
--- a/kartothek/core/common_metadata.py
+++ b/plateau/core/common_metadata.py
@@ -14,10 +14,10 @@
 import simplejson
 from simplekv import KeyValueStore
 
-from kartothek.core import naming
-from kartothek.core._compat import load_json
-from kartothek.core.naming import SINGLE_TABLE
-from kartothek.core.utils import ensure_string_type
+from plateau.core import naming
+from plateau.core._compat import load_json
+from plateau.core.naming import SINGLE_TABLE
+from plateau.core.utils import ensure_string_type
 
 _logger = logging.getLogger()
 
diff --git a/kartothek/core/dataset.py b/plateau/core/dataset.py
similarity index 95%
rename from kartothek/core/dataset.py
rename to plateau/core/dataset.py
index e770868c..d47306d8 100644
--- a/kartothek/core/dataset.py
+++ b/plateau/core/dataset.py
@@ -8,29 +8,25 @@
 import pyarrow as pa
 import simplejson
 
-import kartothek.core._time
-from kartothek.core import naming
-from kartothek.core._compat import load_json
-from kartothek.core._mixins import CopyMixin
-from kartothek.core._zmsgpack import packb, unpackb
-from kartothek.core.common_metadata import SchemaWrapper, read_schema_metadata
-from kartothek.core.docs import default_docs
-from kartothek.core.index import (
+import plateau.core._time
+from plateau.core import naming
+from plateau.core._compat import load_json
+from plateau.core._mixins import CopyMixin
+from plateau.core._zmsgpack import packb, unpackb
+from plateau.core.common_metadata import SchemaWrapper, read_schema_metadata
+from plateau.core.docs import default_docs
+from plateau.core.index import (
     ExplicitSecondaryIndex,
     IndexBase,
     PartitionIndex,
     filter_indices,
 )
-from kartothek.core.naming import (
-    EXTERNAL_INDEX_SUFFIX,
-    PARQUET_FILE_SUFFIX,
-    SINGLE_TABLE,
-)
-from kartothek.core.partition import Partition
-from kartothek.core.typing import StoreInput
-from kartothek.core.urlencode import decode_key, quote_indices
-from kartothek.core.utils import ensure_store, verify_metadata_version
-from kartothek.serialization import PredicatesType, columns_in_predicates
+from plateau.core.naming import EXTERNAL_INDEX_SUFFIX, PARQUET_FILE_SUFFIX, SINGLE_TABLE
+from plateau.core.partition import Partition
+from plateau.core.typing import StoreInput
+from plateau.core.urlencode import decode_key, quote_indices
+from plateau.core.utils import ensure_store, verify_metadata_version
+from plateau.serialization import PredicatesType, columns_in_predicates
 
 _logger = logging.getLogger(__name__)
 
@@ -131,7 +127,7 @@ def tables(self) -> List[str]:
         tables = list(iter(next(iter(self.partitions.values())).files.keys()))
         if len(tables) > 1:
             raise RuntimeError(
-                f"Dataset {self.uuid} has tables {tables} but read support for multi tabled dataset was dropped with kartothek 4.0."
+                f"Dataset {self.uuid} has tables {tables} but read support for multi tabled dataset was dropped with plateau 4.0."
             )
         return tables
 
@@ -278,7 +274,7 @@ def load_index(self: T, column: str, store: StoreInput) -> T:
 
         Returns
         -------
-        dataset_metadata: :class:`~kartothek.core.dataset.DatasetMetadata`
+        dataset_metadata: :class:`~plateau.core.dataset.DatasetMetadata`
             Mutated metadata object with the loaded index.
         """
         if self.partition_keys and column in self.partition_keys:
@@ -314,7 +310,7 @@ def load_all_indices(self: T, store: StoreInput) -> T:
 
         Returns
         -------
-        dataset_metadata: :class:`~kartothek.core.dataset.DatasetMetadata`
+        dataset_metadata: :class:`~plateau.core.dataset.DatasetMetadata`
             Mutated metadata object with the loaded indices.
         """
         indices = {
@@ -564,7 +560,7 @@ def load_from_store(
 
         Returns
         -------
-        dataset_metadata: :class:`~kartothek.core.dataset.DatasetMetadata`
+        dataset_metadata: :class:`~plateau.core.dataset.DatasetMetadata`
             Parsed metadata.
         """
         key1 = naming.metadata_key_from_uuid(uuid)
@@ -840,7 +836,7 @@ def create_partition_key(
     filename: str = "data",
 ):
     """
-    Create partition key for a kartothek partition
+    Create partition key for a plateau partition
 
     Parameters
     ----------
@@ -867,7 +863,7 @@ class DatasetMetadataBuilder(CopyMixin):
     """
     Incrementally build up a dataset.
 
-    In constrast to a :class:`kartothek.core.dataset.DatasetMetadata` instance,
+    In constrast to a :class:`plateau.core.dataset.DatasetMetadata` instance,
     this object is mutable and may not be a full dataset (e.g. partitions don't
     need to be fully materialised).
     """
@@ -919,13 +915,13 @@ def add_partition(self, name, partition):
         ----------
         name: str
             Identifier of the partition.
-        partition: :class:`kartothek.core.partition.Partition`
+        partition: :class:`plateau.core.partition.Partition`
             The partition to add.
         """
 
         if len(partition.files) > 1:
             raise RuntimeError(
-                f"Dataset {self.uuid} has tables {sorted(partition.files.keys())} but read support for multi tabled dataset was dropped with kartothek 4.0."
+                f"Dataset {self.uuid} has tables {sorted(partition.files.keys())} but read support for multi tabled dataset was dropped with plateau 4.0."
             )
 
         self.partitions[name] = partition
@@ -940,7 +936,7 @@ def add_embedded_index(self, column, index):
         ----------
         column: str
             Name of the indexed column
-        index: kartothek.core.index.IndexBase
+        index: plateau.core.index.IndexBase
             The actual index object
         """
 
@@ -1071,5 +1067,5 @@ def _add_creation_time(
     dataset_object: Union[DatasetMetadataBase, DatasetMetadataBuilder]
 ):
     if "creation_time" not in dataset_object.metadata:
-        creation_time = kartothek.core._time.datetime_utcnow().isoformat()
+        creation_time = plateau.core._time.datetime_utcnow().isoformat()
         dataset_object.metadata["creation_time"] = creation_time
diff --git a/kartothek/core/docs.py b/plateau/core/docs.py
similarity index 96%
rename from kartothek/core/docs.py
rename to plateau/core/docs.py
index 1c5c39b2..8d4f0c0e 100644
--- a/kartothek/core/docs.py
+++ b/plateau/core/docs.py
@@ -23,7 +23,7 @@
         (depending on the matches this might be more than two values)""",
     "metadata_merger": """
     metadata_merger: Optional[Callable]
-         By default partition metadata is combined using the :func:`~kartothek.io_components.utils.combine_metadata` function.
+         By default partition metadata is combined using the :func:`~plateau.io_components.utils.combine_metadata` function.
          You can supply a callable here that implements a custom merge operation on the metadata dictionaries
          (depending on the matches this might be more than two values).""",
     "table": """
@@ -59,8 +59,8 @@
             the jobs will fetch their data individually and will *not* shuffle
             data in memory / over network.""",
     "df_serializer": """
-    df_serializer : Optional[kartothek.serialization.DataFrameSerializer]
-        A pandas DataFrame serialiser from `kartothek.serialization`""",
+    df_serializer : Optional[plateau.serialization.DataFrameSerializer]
+        A pandas DataFrame serialiser from `plateau.serialization`""",
     "output_dataset_uuid": """
     output_dataset_uuid: Optional[str]
         UUID of the newly created dataset""",
@@ -105,7 +105,7 @@
         form of a dictionary, e.g.: `[{'column_1': 'value_1'}, {'column_1': 'value_2'}].
         Each query filter will be given to: func: `dataset.query` and the returned
         partitions will be deleted. If no scope is given nothing will be deleted.
-        For `kartothek.io.dask.update.update_dataset.*` a delayed object resolving to
+        For `plateau.io.dask.update.update_dataset.*` a delayed object resolving to
         a list of dicts is also accepted.""",
     "categoricals": """
     categoricals
@@ -150,7 +150,7 @@
     sort_partitions_by: str
         Provide a column after which the data should be sorted before storage to enable predicate pushdown.""",
     "factory": """
-    factory: kartothek.core.factory.DatasetFactory
+    factory: plateau.core.factory.DatasetFactory
         A DatasetFactory holding the store and UUID to the source dataset.""",
     "partition_size": """
     partition_size: Optional[int]
diff --git a/kartothek/core/factory.py b/plateau/core/factory.py
similarity index 96%
rename from kartothek/core/factory.py
rename to plateau/core/factory.py
index 59752e8d..9d64dede 100644
--- a/kartothek/core/factory.py
+++ b/plateau/core/factory.py
@@ -3,9 +3,9 @@
 import copy
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, cast
 
-from kartothek.core.dataset import DatasetMetadata, DatasetMetadataBase
-from kartothek.core.typing import StoreInput
-from kartothek.core.utils import lazy_store
+from plateau.core.dataset import DatasetMetadata, DatasetMetadataBase
+from plateau.core.typing import StoreInput
+from plateau.core.utils import lazy_store
 
 if TYPE_CHECKING:
     from simplekv import KeyValueStore
@@ -39,7 +39,7 @@ def __init__(
 
             from functools import partial
             from storefact import get_store_from_url
-            from kartothek.io.eager import read_table
+            from plateau.io.eager import read_table
 
             ds_factory = DatasetFactory(
                 dataset_uuid="my_test_dataset",
diff --git a/kartothek/core/index.py b/plateau/core/index.py
similarity index 96%
rename from kartothek/core/index.py
rename to plateau/core/index.py
index bccdb1c6..046c594f 100644
--- a/kartothek/core/index.py
+++ b/plateau/core/index.py
@@ -10,15 +10,15 @@
 import pyarrow.parquet as pq
 from toolz.itertoolz import partition_all
 
-import kartothek.core._time
-from kartothek.core import naming
-from kartothek.core._mixins import CopyMixin
-from kartothek.core.common_metadata import normalize_type
-from kartothek.core.docs import default_docs
-from kartothek.core.typing import StoreInput
-from kartothek.core.urlencode import quote
-from kartothek.core.utils import ensure_store
-from kartothek.serialization import (
+import plateau.core._time
+from plateau.core import naming
+from plateau.core._mixins import CopyMixin
+from plateau.core.common_metadata import normalize_type
+from plateau.core.docs import default_docs
+from plateau.core.typing import StoreInput
+from plateau.core.urlencode import quote
+from plateau.core.utils import ensure_store
+from plateau.serialization import (
     PredicatesType,
     check_predicates,
     filter_array_like,
@@ -69,7 +69,7 @@ def __init__(
         if column == _PARTITION_COLUMN_NAME:
             raise ValueError(
                 "Cannot create an index for column {} due to an internal implementation conflict. "
-                "Please contact a kartothek maintainer if you receive this error message".format(
+                "Please contact a plateau maintainer if you receive this error message".format(
                     column
                 )
             )
@@ -89,7 +89,7 @@ def __init__(
 
         self.column = column
         self.dtype = dtype
-        self.creation_time = kartothek.core._time.datetime_utcnow()
+        self.creation_time = plateau.core._time.datetime_utcnow()
         self.index_dct: IndexDictType
 
         self.index_dct = {}
@@ -114,7 +114,7 @@ def __init__(
                 if n_collisions:
                     _logger.warning(
                         (
-                            "Value normalization for index column {} resulted in {} collision(s). Kartothek merged "
+                            "Value normalization for index column {} resulted in {} collision(s). plateau merged "
                             "the affected partition lists, but you may want to check if this was desired."
                         ).format(column, n_collisions)
                     )
@@ -226,7 +226,7 @@ def eval_operator(self, op: str, value: ValueType) -> Set[str]:
         op: str
             A string representation of the operator to be evaluated. Supported are
             "==", "<=", ">=", "<", ">", "in"
-            For details, see documentation of kartothek.serialization
+            For details, see documentation of plateau.serialization
         value: object
             The value to be evaluated
         Returns
@@ -297,12 +297,12 @@ def update(self, index: "IndexBase", inplace: bool = False) -> "IndexBase":
 
         Parameters
         ----------
-        index: [kartothek.core.index.IndexBase]
+        index: [plateau.core.index.IndexBase]
             The index which should be added to this one
         """
         if not isinstance(index, IndexBase):
             raise TypeError(
-                "Need to input an kartothek.core.index.IndexBase object, instead got `{}`".format(
+                "Need to input an plateau.core.index.IndexBase object, instead got `{}`".format(
                     type(index)
                 )
             )
@@ -473,7 +473,7 @@ def as_flat_series(
         Examples
         --------
         >>> import pyarrow as pa
-        >>> from kartothek.core.index import ExplicitSecondaryIndex
+        >>> from plateau.core.index import ExplicitSecondaryIndex
         >>> index1 = ExplicitSecondaryIndex(
         ...     column="col", index_dct={1: ["part_1", "part_2"]}, dtype=pa.int64()
         ... )
@@ -559,7 +559,7 @@ class PartitionIndex(IndexBase):
     A PartitionIndex is usually constructed by parsing the partition filenames which encode index information.
 
     The constructor for this class should usually not be called explicitly but indices should be created by e.g.
-    :meth:`kartothek.core.dataset.DatasetMetadataBase.load_partition_indices`
+    :meth:`plateau.core.dataset.DatasetMetadataBase.load_partition_indices`
     """
 
     def __init__(
@@ -659,7 +659,7 @@ def from_v2(column: str, dct_or_str: Union[str, IndexDictType]) -> "IndexBase":
 
         Returns
         -------
-        index: [kartothek.core.index.ExplicitSecondaryIndex]
+        index: [plateau.core.index.ExplicitSecondaryIndex]
         """
         if isinstance(dct_or_str, str):
             # External index
@@ -738,7 +738,7 @@ def load(self, store: StoreInput):
 
         Returns
         -------
-        index: [kartothek.core.index.ExplicitSecondaryIndex]
+        index: [plateau.core.index.ExplicitSecondaryIndex]
         """
         if self.loaded:
             return self
@@ -825,12 +825,12 @@ def remove_partitions_from_indices(
     index_dict: _MULTI_COLUMN_INDEX_DCT_TYPE, partitions: List[str]
 ):
     """
-    Remove a given list of partitions from a kartothek index dictionary
+    Remove a given list of partitions from a plateau index dictionary
 
     Parameters
     ----------
     index_dict
-        A dictionary holding kartothek indices
+        A dictionary holding plateau indices
     partitions
         A list of partition labels which should be removed form the index objects
     """
@@ -842,7 +842,7 @@ def remove_partitions_from_indices(
 
 def filter_indices(index_dict: _MULTI_COLUMN_INDEX_DCT_TYPE, partitions: Iterable[str]):
     """
-    Filter a kartothek index dictionary such that only the provided list of partitions is included
+    Filter a plateau index dictionary such that only the provided list of partitions is included
     in the index dictionary
 
     All indices must be embedded!
@@ -850,7 +850,7 @@ def filter_indices(index_dict: _MULTI_COLUMN_INDEX_DCT_TYPE, partitions: Iterabl
     Parameters
     ----------
     index_dict:
-        A dictionary holding kartothek indices
+        A dictionary holding plateau indices
     partition_list:
         A list of partition labels which are allowed in the output dictionary
     """
diff --git a/kartothek/core/naming.py b/plateau/core/naming.py
similarity index 100%
rename from kartothek/core/naming.py
rename to plateau/core/naming.py
diff --git a/kartothek/core/partition.py b/plateau/core/partition.py
similarity index 100%
rename from kartothek/core/partition.py
rename to plateau/core/partition.py
diff --git a/kartothek/core/typing.py b/plateau/core/typing.py
similarity index 100%
rename from kartothek/core/typing.py
rename to plateau/core/typing.py
diff --git a/kartothek/core/urlencode.py b/plateau/core/urlencode.py
similarity index 96%
rename from kartothek/core/urlencode.py
rename to plateau/core/urlencode.py
index f66bfda1..6791ae64 100644
--- a/kartothek/core/urlencode.py
+++ b/plateau/core/urlencode.py
@@ -26,7 +26,7 @@ def decode_key(
     key: str,
 ) -> Union[Tuple[str, str, List, str], Tuple[str, None, List, None]]:
     """
-    Split a given key into its kartothek components `{dataset_uuid}/{table}/{key_indices}/{filename}`
+    Split a given key into its plateau components `{dataset_uuid}/{table}/{key_indices}/{filename}`
 
     Example:
         `uuid/table/index_col=1/index_col=2/partition_label.parquet`
diff --git a/kartothek/core/utils.py b/plateau/core/utils.py
similarity index 92%
rename from kartothek/core/utils.py
rename to plateau/core/utils.py
index ff15839a..85a00dfc 100644
--- a/kartothek/core/utils.py
+++ b/plateau/core/utils.py
@@ -5,8 +5,8 @@
 from simplekv import KeyValueStore
 from storefact import get_store_from_url
 
-from kartothek.core.naming import MAX_METADATA_VERSION, MIN_METADATA_VERSION
-from kartothek.core.typing import StoreFactory, StoreInput
+from plateau.core.naming import MAX_METADATA_VERSION, MIN_METADATA_VERSION
+from plateau.core.typing import StoreFactory, StoreInput
 
 __all__ = ("ensure_store", "lazy_store")
 
@@ -107,6 +107,6 @@ def lazy_store(store: StoreInput) -> StoreFactory:
         except Exception as exc:
             raise TypeError(
                 """KeyValueStore not serializable.
-Please consult https://kartothek.readthedocs.io/en/stable/spec/store_interface.html for more information."""
+Please consult https://plateau.readthedocs.io/en/stable/spec/store_interface.html for more information."""
             ) from exc
         return partial(_identity, store)
diff --git a/kartothek/core/uuid.py b/plateau/core/uuid.py
similarity index 82%
rename from kartothek/core/uuid.py
rename to plateau/core/uuid.py
index d70e0a27..844aaf73 100644
--- a/kartothek/core/uuid.py
+++ b/plateau/core/uuid.py
@@ -1,7 +1,7 @@
 """
-UUID generation mechanism used in Kartothek.
+UUID generation mechanism used in plateau.
 
-Using these routines ensures compatibility w/ Kartothek as well as the application of best practices.
+Using these routines ensures compatibility w/ plateau as well as the application of best practices.
 """
 
 
diff --git a/kartothek/io/__init__.py b/plateau/io/__init__.py
similarity index 100%
rename from kartothek/io/__init__.py
rename to plateau/io/__init__.py
diff --git a/kartothek/io/dask/__init__.py b/plateau/io/dask/__init__.py
similarity index 100%
rename from kartothek/io/dask/__init__.py
rename to plateau/io/dask/__init__.py
diff --git a/kartothek/io/dask/_shuffle.py b/plateau/io/dask/_shuffle.py
similarity index 93%
rename from kartothek/io/dask/_shuffle.py
rename to plateau/io/dask/_shuffle.py
index 79184a63..0a693af9 100644
--- a/kartothek/io/dask/_shuffle.py
+++ b/plateau/io/dask/_shuffle.py
@@ -6,11 +6,11 @@
 import numpy as np
 import pandas as pd
 
-from kartothek.core.typing import StoreFactory
-from kartothek.io.dask.compression import pack_payload, unpack_payload_pandas
-from kartothek.io_components.metapartition import MetaPartition
-from kartothek.io_components.write import write_partition
-from kartothek.serialization import DataFrameSerializer
+from plateau.core.typing import StoreFactory
+from plateau.io.dask.compression import pack_payload, unpack_payload_pandas
+from plateau.io_components.metapartition import MetaPartition
+from plateau.io_components.write import write_partition
+from plateau.serialization import DataFrameSerializer
 
 _KTK_HASH_BUCKET = "__KTK_HASH_BUCKET"
 
@@ -82,7 +82,7 @@ def shuffle_store_dask_partitions(
         We apply important pre storage processing like sorting data, applying
         final partitioning (at this time there should be only one group in the
         payload data but using the ``MetaPartition.partition_on`` guarantees the
-        appropriate data structures kartothek expects are created.).
+        appropriate data structures plateau expects are created.).
         After the preprocessing is done, the data is serialized and stored as
         parquet. The applied function will return an (empty) MetaPartition with
         indices and metadata which will then be used to commit the dataset.
diff --git a/kartothek/io/dask/_sizeof.py b/plateau/io/dask/_sizeof.py
similarity index 58%
rename from kartothek/io/dask/_sizeof.py
rename to plateau/io/dask/_sizeof.py
index 0ceaf9f9..89eeb346 100644
--- a/kartothek/io/dask/_sizeof.py
+++ b/plateau/io/dask/_sizeof.py
@@ -6,12 +6,12 @@ def _dct_sizeof(obj):
 
 
 def register_sizeof_ktk_classes():
-    from kartothek.core.dataset import DatasetMetadata
-    from kartothek.core.factory import DatasetFactory
-    from kartothek.io_components.metapartition import MetaPartition
-    from kartothek.core.index import ExplicitSecondaryIndex, PartitionIndex
-    from kartothek.core.partition import Partition
-    from kartothek.core.common_metadata import SchemaWrapper
+    from plateau.core.dataset import DatasetMetadata
+    from plateau.core.factory import DatasetFactory
+    from plateau.io_components.metapartition import MetaPartition
+    from plateau.core.index import ExplicitSecondaryIndex, PartitionIndex
+    from plateau.core.partition import Partition
+    from plateau.core.common_metadata import SchemaWrapper
 
     dask_sizeof.register(DatasetMetadata, _dct_sizeof)
     dask_sizeof.register(DatasetFactory, _dct_sizeof)
diff --git a/kartothek/io/dask/_utils.py b/plateau/io/dask/_utils.py
similarity index 100%
rename from kartothek/io/dask/_utils.py
rename to plateau/io/dask/_utils.py
diff --git a/kartothek/io/dask/bag.py b/plateau/io/dask/bag.py
similarity index 89%
rename from kartothek/io/dask/bag.py
rename to plateau/io/dask/bag.py
index aa24b8bd..588b6a7b 100644
--- a/kartothek/io/dask/bag.py
+++ b/plateau/io/dask/bag.py
@@ -4,26 +4,26 @@
 import dask.bag as db
 from dask.delayed import Delayed
 
-from kartothek.core import naming
-from kartothek.core.docs import default_docs
-from kartothek.core.factory import DatasetFactory, _ensure_factory
-from kartothek.core.typing import StoreInput
-from kartothek.core.utils import lazy_store
-from kartothek.core.uuid import gen_uuid
-from kartothek.io.dask._utils import (
+from plateau.core import naming
+from plateau.core.docs import default_docs
+from plateau.core.factory import DatasetFactory, _ensure_factory
+from plateau.core.typing import StoreInput
+from plateau.core.utils import lazy_store
+from plateau.core.uuid import gen_uuid
+from plateau.io.dask._utils import (
     _cast_categorical_to_index_cat,
     _get_data,
     _maybe_get_categoricals_from_index,
 )
-from kartothek.io_components.index import update_indices_from_partitions
-from kartothek.io_components.metapartition import (
+from plateau.io_components.index import update_indices_from_partitions
+from plateau.io_components.metapartition import (
     SINGLE_TABLE,
     MetaPartition,
     parse_input_to_metapartition,
 )
-from kartothek.io_components.read import dispatch_metapartitions_from_factory
-from kartothek.io_components.utils import normalize_args, raise_if_indices_overlap
-from kartothek.io_components.write import (
+from plateau.io_components.read import dispatch_metapartitions_from_factory
+from plateau.io_components.utils import normalize_args, raise_if_indices_overlap
+from plateau.io_components.write import (
     raise_if_dataset_exists,
     store_dataset_from_partitions,
 )
@@ -179,10 +179,10 @@ def store_bag_as_dataset(
 ):
     """
     Transform and store a dask.bag of dictionaries containing
-    dataframes to a kartothek dataset in store.
+    dataframes to a plateau dataset in store.
 
     This is the dask.bag-equivalent of
-    :func:`~kartothek.io.dask.delayed.store_delayed_as_dataset`. See there
+    :func:`~plateau.io.dask.delayed.store_delayed_as_dataset`. See there
     for more detailed documentation on the different possible input types.
 
     Parameters
@@ -241,7 +241,7 @@ def build_dataset_indices__bag(
     factory: Optional[DatasetFactory] = None,
 ) -> Delayed:
     """
-    Function which builds a :class:`~kartothek.core.index.ExplicitSecondaryIndex`.
+    Function which builds a :class:`~plateau.core.index.ExplicitSecondaryIndex`.
 
     This function loads the dataset, computes the requested indices and writes
     the indices to the dataset. The dataset partitions itself are not mutated.
diff --git a/kartothek/io/dask/compression.py b/plateau/io/dask/compression.py
similarity index 100%
rename from kartothek/io/dask/compression.py
rename to plateau/io/dask/compression.py
diff --git a/kartothek/io/dask/dataframe.py b/plateau/io/dask/dataframe.py
similarity index 95%
rename from kartothek/io/dask/dataframe.py
rename to plateau/io/dask/dataframe.py
index 271a13d6..e3003125 100644
--- a/kartothek/io/dask/dataframe.py
+++ b/plateau/io/dask/dataframe.py
@@ -16,31 +16,31 @@
 import numpy as np
 import pandas as pd
 
-from kartothek.core.common_metadata import empty_dataframe_from_schema
-from kartothek.core.docs import default_docs
-from kartothek.core.factory import DatasetFactory, _ensure_factory
-from kartothek.core.naming import DEFAULT_METADATA_VERSION
-from kartothek.core.typing import StoreFactory, StoreInput
-from kartothek.io.dask.compression import pack_payload, unpack_payload_pandas
-from kartothek.io_components.metapartition import (
+from plateau.core.common_metadata import empty_dataframe_from_schema
+from plateau.core.docs import default_docs
+from plateau.core.factory import DatasetFactory, _ensure_factory
+from plateau.core.naming import DEFAULT_METADATA_VERSION
+from plateau.core.typing import StoreFactory, StoreInput
+from plateau.io.dask.compression import pack_payload, unpack_payload_pandas
+from plateau.io_components.metapartition import (
     _METADATA_SCHEMA,
     SINGLE_TABLE,
     MetaPartition,
     parse_input_to_metapartition,
 )
-from kartothek.io_components.read import dispatch_metapartitions_from_factory
-from kartothek.io_components.update import update_dataset_from_partitions
-from kartothek.io_components.utils import (
+from plateau.io_components.read import dispatch_metapartitions_from_factory
+from plateau.io_components.update import update_dataset_from_partitions
+from plateau.io_components.utils import (
     _ensure_compatible_indices,
     normalize_args,
     validate_partition_keys,
 )
-from kartothek.io_components.write import (
+from plateau.io_components.write import (
     raise_if_dataset_exists,
     store_dataset_from_partitions,
     write_partition,
 )
-from kartothek.serialization import DataFrameSerializer, PredicatesType
+from plateau.serialization import DataFrameSerializer, PredicatesType
 
 from ._shuffle import shuffle_store_dask_partitions
 from ._utils import _maybe_get_categoricals_from_index
@@ -159,10 +159,10 @@ def _shuffle_docs(func):
 
     .. admonition:: Behavior without ``shuffle==False``
 
-        In the case without ``partition_on`` every dask partition is mapped to a single kartothek partition
+        In the case without ``partition_on`` every dask partition is mapped to a single plateau partition
 
-        In the case with ``partition_on`` every dask partition is mapped to N kartothek partitions, where N
-        depends on the content of the respective partition, such that every resulting kartothek partition has
+        In the case with ``partition_on`` every dask partition is mapped to N plateau partitions, where N
+        depends on the content of the respective partition, such that every resulting plateau partition has
         only a single value in the respective ``partition_on`` columns.
 
     .. admonition:: Behavior with ``shuffle==True``
@@ -495,7 +495,7 @@ def collect_dataset_metadata(
     Parameters
     ----------
     predicates
-      Kartothek predicates to apply filters on the data for which to gather statistics
+      plateau predicates to apply filters on the data for which to gather statistics
 
       .. warning::
           Filtering will only be applied for predicates on indices.
diff --git a/kartothek/io/dask/delayed.py b/plateau/io/dask/delayed.py
similarity index 90%
rename from kartothek/io/dask/delayed.py
rename to plateau/io/dask/delayed.py
index 162f58df..1f1abef4 100644
--- a/kartothek/io/dask/delayed.py
+++ b/plateau/io/dask/delayed.py
@@ -5,34 +5,34 @@
 from dask import delayed
 from dask.delayed import Delayed
 
-from kartothek.core import naming
-from kartothek.core.docs import default_docs
-from kartothek.core.factory import _ensure_factory
-from kartothek.core.naming import DEFAULT_METADATA_VERSION
-from kartothek.core.typing import StoreInput
-from kartothek.core.utils import lazy_store
-from kartothek.core.uuid import gen_uuid
-from kartothek.io_components.delete import (
+from plateau.core import naming
+from plateau.core.docs import default_docs
+from plateau.core.factory import _ensure_factory
+from plateau.core.naming import DEFAULT_METADATA_VERSION
+from plateau.core.typing import StoreInput
+from plateau.core.utils import lazy_store
+from plateau.core.uuid import gen_uuid
+from plateau.io_components.delete import (
     delete_common_metadata,
     delete_indices,
     delete_top_level_metadata,
 )
-from kartothek.io_components.gc import delete_files, dispatch_files_to_gc
-from kartothek.io_components.metapartition import (
+from plateau.io_components.gc import delete_files, dispatch_files_to_gc
+from plateau.io_components.metapartition import (
     SINGLE_TABLE,
     MetaPartition,
     parse_input_to_metapartition,
 )
-from kartothek.io_components.read import dispatch_metapartitions_from_factory
-from kartothek.io_components.update import update_dataset_from_partitions
-from kartothek.io_components.utils import (
+from plateau.io_components.read import dispatch_metapartitions_from_factory
+from plateau.io_components.update import update_dataset_from_partitions
+from plateau.io_components.utils import (
     _ensure_compatible_indices,
     normalize_arg,
     normalize_args,
     raise_if_indices_overlap,
     validate_partition_keys,
 )
-from kartothek.io_components.write import (
+from plateau.io_components.write import (
     raise_if_dataset_exists,
     store_dataset_from_partitions,
     write_partition,
@@ -161,11 +161,11 @@ def read_dataset_as_delayed_metapartitions(
 ):
     """
     A collection of dask.delayed objects to retrieve a dataset from store where each
-    partition is loaded as a :class:`~kartothek.io_components.metapartition.MetaPartition`.
+    partition is loaded as a :class:`~plateau.io_components.metapartition.MetaPartition`.
 
     .. seealso:
 
-        :func:`~kartothek.io.dask.read_dataset_as_delayed`
+        :func:`~plateau.io.dask.read_dataset_as_delayed`
 
     Parameters
     ----------
@@ -277,9 +277,9 @@ def update_dataset_from_delayed(
 ):
     """
     A dask.delayed graph to add and store a list of dictionaries containing
-    dataframes to a kartothek dataset in store. The input should be a list
+    dataframes to a plateau dataset in store. The input should be a list
     (or splitter pipeline) containing
-    :class:`~kartothek.io_components.metapartition.MetaPartition`. If you want to use this
+    :class:`~plateau.io_components.metapartition.MetaPartition`. If you want to use this
     pipeline step for just deleting partitions without adding new ones you
     have to give an empty meta partition as input (``[Metapartition(None)]``).
 
@@ -346,7 +346,7 @@ def store_delayed_as_dataset(
 ) -> Delayed:
     """
     Transform and store a list of dictionaries containing
-    dataframes to a kartothek dataset in store.
+    dataframes to a plateau dataset in store.
 
     Parameters
     ----------
diff --git a/kartothek/io/eager.py b/plateau/io/eager.py
similarity index 90%
rename from kartothek/io/eager.py
rename to plateau/io/eager.py
index 01afc569..8ba5444c 100644
--- a/kartothek/io/eager.py
+++ b/plateau/io/eager.py
@@ -4,46 +4,46 @@
 import pandas as pd
 from simplekv import KeyValueStore
 
-from kartothek.core.common_metadata import (
+from plateau.core.common_metadata import (
     empty_dataframe_from_schema,
     make_meta,
     store_schema_metadata,
 )
-from kartothek.core.dataset import DatasetMetadata, DatasetMetadataBuilder
-from kartothek.core.docs import default_docs
-from kartothek.core.factory import DatasetFactory, _ensure_factory
-from kartothek.core.naming import (
+from plateau.core.dataset import DatasetMetadata, DatasetMetadataBuilder
+from plateau.core.docs import default_docs
+from plateau.core.factory import DatasetFactory, _ensure_factory
+from plateau.core.naming import (
     DEFAULT_METADATA_STORAGE_FORMAT,
     DEFAULT_METADATA_VERSION,
     PARQUET_FILE_SUFFIX,
     get_partition_file_prefix,
 )
-from kartothek.core.typing import StoreInput
-from kartothek.core.utils import lazy_store
-from kartothek.io.iter import store_dataframes_as_dataset__iter
-from kartothek.io_components.delete import (
+from plateau.core.typing import StoreInput
+from plateau.core.utils import lazy_store
+from plateau.io.iter import store_dataframes_as_dataset__iter
+from plateau.io_components.delete import (
     delete_common_metadata,
     delete_indices,
     delete_top_level_metadata,
 )
-from kartothek.io_components.gc import delete_files, dispatch_files_to_gc
-from kartothek.io_components.index import update_indices_from_partitions
-from kartothek.io_components.metapartition import (
+from plateau.io_components.gc import delete_files, dispatch_files_to_gc
+from plateau.io_components.index import update_indices_from_partitions
+from plateau.io_components.metapartition import (
     SINGLE_TABLE,
     MetaPartition,
     parse_input_to_metapartition,
 )
-from kartothek.io_components.read import dispatch_metapartitions_from_factory
-from kartothek.io_components.update import update_dataset_from_partitions
-from kartothek.io_components.utils import (
+from plateau.io_components.read import dispatch_metapartitions_from_factory
+from plateau.io_components.update import update_dataset_from_partitions
+from plateau.io_components.utils import (
     _ensure_compatible_indices,
     align_categories,
     normalize_args,
     sort_values_categorical,
     validate_partition_keys,
 )
-from kartothek.io_components.write import raise_if_dataset_exists
-from kartothek.serialization import DataFrameSerializer
+from plateau.io_components.write import raise_if_dataset_exists
+from plateau.serialization import DataFrameSerializer
 
 __all__ = (
     "delete_dataset",
@@ -125,7 +125,7 @@ def read_dataset_as_dataframes(
     .. code ::
 
         >>> import storefact
-        >>> from kartothek.io.eager import read_dataset_as_dataframes
+        >>> from plateau.io.eager import read_dataset_as_dataframes
 
         >>> store = storefact.get_store_from_url('s3://bucket_with_dataset')
 
@@ -164,7 +164,7 @@ def read_dataset_as_metapartitions(
     dispatch_by=None,
 ):
     """
-    Read a dataset as a list of :class:`kartothek.io_components.metapartition.MetaPartition`.
+    Read a dataset as a list of :class:`plateau.io_components.metapartition.MetaPartition`.
 
     Every element of the list corresponds to a physical partition.
 
@@ -173,7 +173,7 @@ def read_dataset_as_metapartitions(
 
     Returns
     -------
-    List[kartothek.io_components.metapartition.MetaPartition]
+    List[plateau.io_components.metapartition.MetaPartition]
         Returns a tuple of the loaded dataframe and the dataset metadata
 
     Examples
@@ -183,7 +183,7 @@ def read_dataset_as_metapartitions(
     .. code ::
 
         >>> import storefact
-        >>> from kartothek.io.eager import read_dataset_as_dataframe
+        >>> from plateau.io.eager import read_dataset_as_dataframe
 
         >>> store = storefact.get_store_from_url('s3://bucket_with_dataset')
 
@@ -243,7 +243,7 @@ def read_table(
     .. code ::
 
         >>> import storefact
-        >>> from kartothek.io.eager import read_table
+        >>> from plateau.io.eager import read_table
 
         >>> store = storefact.get_store_from_url('s3://bucket_with_dataset')
 
@@ -303,15 +303,15 @@ def commit_dataset(
 
     1. Add previously written partitions to this dataset
 
-        If for some reasons, the existing pipelines are not sufficient but you need more control, you can write the files outside of a kartothek pipeline and commit them whenever you choose to.
+        If for some reasons, the existing pipelines are not sufficient but you need more control, you can write the files outside of a plateau pipeline and commit them whenever you choose to.
 
         This should be used in combination with
-        :func:`~kartothek.io.eager.write_single_partition` and :func:`~kartothek.io.eager.create_empty_dataset_header`.
+        :func:`~plateau.io.eager.write_single_partition` and :func:`~plateau.io.eager.create_empty_dataset_header`.
 
         .. code::
 
             import pandas as pd
-            from kartothek.io.eager import write_single_partition, commit_dataset
+            from plateau.io.eager import write_single_partition, commit_dataset
 
             store = "hfs://my_store"
 
@@ -499,7 +499,7 @@ def create_empty_dataset_header(
 ):
     """
     Create an dataset header without any partitions. This may be used in combination
-    with :func:`~kartothek.io.eager.write_single_partition` to create implicitly partitioned datasets.
+    with :func:`~plateau.io.eager.write_single_partition` to create implicitly partitioned datasets.
 
     .. note::
 
@@ -565,7 +565,7 @@ def write_single_partition(
     be used for highly concurrent dataset writes.
 
     For datasets with explicit partitions, the dataset header can be updated by calling
-    :func:`kartothek.io.eager.commit_dataset` with the output of this function.
+    :func:`plateau.io.eager.commit_dataset` with the output of this function.
 
     .. note::
 
@@ -583,11 +583,11 @@ def write_single_partition(
     Parameters
     ----------
     data: Dict
-        The input is defined according to :func:`~kartothek.io_components.metapartition.parse_input_to_metapartition`
+        The input is defined according to :func:`~plateau.io_components.metapartition.parse_input_to_metapartition`
 
     Returns
     -------
-    An empty :class:`~kartothek.io_components.metapartition.MetaPartition` referencing the new files
+    An empty :class:`~plateau.io_components.metapartition.MetaPartition` referencing the new files
     """
     if data is None:
         raise TypeError("The parameter `data` is not optional")
@@ -639,7 +639,7 @@ def update_dataset_from_dataframes(
     factory: Optional[DatasetFactory] = None,
 ) -> DatasetMetadata:
     """
-    Update a kartothek dataset in store at once, using a list of dataframes.
+    Update a plateau dataset in store at once, using a list of dataframes.
 
     Useful for datasets which do not fit into memory.
 
@@ -650,7 +650,7 @@ def update_dataset_from_dataframes(
 
     Returns
     -------
-    The dataset metadata object (:class:`~kartothek.core.dataset.DatasetMetadata`).
+    The dataset metadata object (:class:`~plateau.core.dataset.DatasetMetadata`).
 
     See Also
     --------
@@ -704,7 +704,7 @@ def update_dataset_from_dataframes(
 @normalize_args
 def build_dataset_indices(store, dataset_uuid, columns, factory=None):
     """
-    Function which builds a :class:`~kartothek.core.index.ExplicitSecondaryIndex`.
+    Function which builds a :class:`~plateau.core.index.ExplicitSecondaryIndex`.
 
     This function loads the dataset, computes the requested indices and writes
     the indices to the dataset. The dataset partitions itself are not mutated.
diff --git a/kartothek/io/iter.py b/plateau/io/iter.py
similarity index 87%
rename from kartothek/io/iter.py
rename to plateau/io/iter.py
index 81bd8ee3..f74caf92 100644
--- a/kartothek/io/iter.py
+++ b/plateau/io/iter.py
@@ -1,28 +1,28 @@
 from functools import partial
 from typing import cast
 
-from kartothek.core.docs import default_docs
-from kartothek.core.factory import _ensure_factory
-from kartothek.core.naming import (
+from plateau.core.docs import default_docs
+from plateau.core.factory import _ensure_factory
+from plateau.core.naming import (
     DEFAULT_METADATA_STORAGE_FORMAT,
     DEFAULT_METADATA_VERSION,
     SINGLE_TABLE,
 )
-from kartothek.core.uuid import gen_uuid
-from kartothek.io_components.metapartition import (
+from plateau.core.uuid import gen_uuid
+from plateau.io_components.metapartition import (
     MetaPartition,
     parse_input_to_metapartition,
 )
-from kartothek.io_components.read import dispatch_metapartitions_from_factory
-from kartothek.io_components.update import update_dataset_from_partitions
-from kartothek.io_components.utils import (
+from plateau.io_components.read import dispatch_metapartitions_from_factory
+from plateau.io_components.update import update_dataset_from_partitions
+from plateau.io_components.utils import (
     _ensure_compatible_indices,
     normalize_args,
     raise_if_indices_overlap,
     sort_values_categorical,
     validate_partition_keys,
 )
-from kartothek.io_components.write import (
+from plateau.io_components.write import (
     raise_if_dataset_exists,
     store_dataset_from_partitions,
 )
@@ -50,11 +50,11 @@ def read_dataset_as_metapartitions__iterator(
     """
 
     A Python iterator to retrieve a dataset from store where each
-    partition is loaded as a :class:`~kartothek.io_components.metapartition.MetaPartition`.
+    partition is loaded as a :class:`~plateau.io_components.metapartition.MetaPartition`.
 
     .. seealso:
 
-        :func:`~kartothek.io_components.read.read_dataset_as_dataframes__iterator`
+        :func:`~plateau.io_components.read.read_dataset_as_dataframes__iterator`
 
     Parameters
     ----------
@@ -135,7 +135,7 @@ def read_dataset_as_dataframes__iterator(
     .. code ::
 
         >>> import storefact
-        >>> from kartothek.io.iter import read_dataset_as_dataframes__iterator
+        >>> from plateau.io.iter import read_dataset_as_dataframes__iterator
 
         >>> store = storefact.get_store_from_url('s3://bucket_with_dataset')
 
@@ -185,7 +185,7 @@ def update_dataset_from_dataframes__iter(
     table_name: str = SINGLE_TABLE,
 ):
     """
-    Update a kartothek dataset in store iteratively, using a generator of dataframes.
+    Update a plateau dataset in store iteratively, using a generator of dataframes.
 
     Useful for datasets which do not fit into memory.
 
@@ -194,7 +194,7 @@ def update_dataset_from_dataframes__iter(
 
     Returns
     -------
-    The dataset metadata object (:class:`~kartothek.core.dataset.DatasetMetadata`).
+    The dataset metadata object (:class:`~plateau.core.dataset.DatasetMetadata`).
 
     See Also
     --------
@@ -276,7 +276,7 @@ def store_dataframes_as_dataset__iter(
 
     Returns
     -------
-    dataset: kartothek.core.dataset.DatasetMetadata
+    dataset: plateau.core.dataset.DatasetMetadata
         The stored dataset.
 
     """
@@ -306,10 +306,10 @@ def store_dataframes_as_dataset__iter(
             store=store, dataset_uuid=dataset_uuid, df_serializer=df_serializer
         )
 
-        # Add `kartothek.io_components.metapartition.MetaPartition` object to list to track partitions
+        # Add `plateau.io_components.metapartition.MetaPartition` object to list to track partitions
         new_partitions.append(mp)
 
-    # Store metadata and return `kartothek.DatasetMetadata` object
+    # Store metadata and return `plateau.DatasetMetadata` object
     return store_dataset_from_partitions(
         partition_list=new_partitions,
         dataset_uuid=dataset_uuid,
diff --git a/kartothek/io_components/__init__.py b/plateau/io_components/__init__.py
similarity index 100%
rename from kartothek/io_components/__init__.py
rename to plateau/io_components/__init__.py
diff --git a/kartothek/io_components/delete.py b/plateau/io_components/delete.py
similarity index 89%
rename from kartothek/io_components/delete.py
rename to plateau/io_components/delete.py
index bff631bd..4390f8a8 100644
--- a/kartothek/io_components/delete.py
+++ b/plateau/io_components/delete.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
 
-from kartothek.core import naming
-from kartothek.core.naming import metadata_key_from_uuid
+from plateau.core import naming
+from plateau.core.naming import metadata_key_from_uuid
 
 
 def delete_common_metadata(dataset_factory):
diff --git a/kartothek/io_components/gc.py b/plateau/io_components/gc.py
similarity index 94%
rename from kartothek/io_components/gc.py
rename to plateau/io_components/gc.py
index dd925df4..0a92b8aa 100644
--- a/kartothek/io_components/gc.py
+++ b/plateau/io_components/gc.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
 
-from kartothek.core.factory import _ensure_factory
-from kartothek.core.naming import TABLE_METADATA_FILE
+from plateau.core.factory import _ensure_factory
+from plateau.core.naming import TABLE_METADATA_FILE
 
 
 def dispatch_files_to_gc(dataset_uuid, store_factory, chunk_size, factory):
diff --git a/kartothek/io_components/index.py b/plateau/io_components/index.py
similarity index 84%
rename from kartothek/io_components/index.py
rename to plateau/io_components/index.py
index 93771d20..ddc07fb2 100644
--- a/kartothek/io_components/index.py
+++ b/plateau/io_components/index.py
@@ -3,10 +3,10 @@
 
 import logging
 
-from kartothek.core import naming
-from kartothek.core.index import ExplicitSecondaryIndex
-from kartothek.io_components.metapartition import MetaPartition
-from kartothek.io_components.write import persist_indices
+from plateau.core import naming
+from plateau.core.index import ExplicitSecondaryIndex
+from plateau.io_components.metapartition import MetaPartition
+from plateau.io_components.write import persist_indices
 
 _logger = logging.getLogger(__name__)
 
diff --git a/kartothek/io_components/metapartition.py b/plateau/io_components/metapartition.py
similarity index 96%
rename from kartothek/io_components/metapartition.py
rename to plateau/io_components/metapartition.py
index 4d1e8ee7..b9adad9d 100644
--- a/kartothek/io_components/metapartition.py
+++ b/plateau/io_components/metapartition.py
@@ -26,29 +26,25 @@
 import pyarrow as pa
 from simplekv import KeyValueStore
 
-from kartothek.core import naming
-from kartothek.core.common_metadata import (
+from plateau.core import naming
+from plateau.core.common_metadata import (
     SchemaWrapper,
     make_meta,
     normalize_column_order,
     read_schema_metadata,
     validate_compatible,
 )
-from kartothek.core.docs import default_docs
-from kartothek.core.index import ExplicitSecondaryIndex, IndexBase
-from kartothek.core.index import merge_indices as merge_indices_algo
-from kartothek.core.naming import get_partition_file_prefix
-from kartothek.core.partition import Partition
-from kartothek.core.typing import StoreInput
-from kartothek.core.urlencode import decode_key, quote_indices
-from kartothek.core.utils import (
-    ensure_store,
-    ensure_string_type,
-    verify_metadata_version,
-)
-from kartothek.core.uuid import gen_uuid
-from kartothek.io_components.utils import align_categories
-from kartothek.serialization import (
+from plateau.core.docs import default_docs
+from plateau.core.index import ExplicitSecondaryIndex, IndexBase
+from plateau.core.index import merge_indices as merge_indices_algo
+from plateau.core.naming import get_partition_file_prefix
+from plateau.core.partition import Partition
+from plateau.core.typing import StoreInput
+from plateau.core.urlencode import decode_key, quote_indices
+from plateau.core.utils import ensure_store, ensure_string_type, verify_metadata_version
+from plateau.core.uuid import gen_uuid
+from plateau.io_components.utils import align_categories
+from plateau.serialization import (
     DataFrameSerializer,
     PredicatesType,
     default_serializer,
@@ -202,7 +198,7 @@ def __next__(self):
 
 class MetaPartition(Iterable):
     """
-    Wrapper for kartothek partition which includes additional information
+    Wrapper for plateau partition which includes additional information
     about the parent dataset
     """
 
@@ -219,13 +215,13 @@ def __init__(
         logical_conjunction: Optional[List[Tuple[Any, str, Any]]] = None,
     ):
         """
-        Initialize the :mod:`kartothek.io` base class MetaPartition.
+        Initialize the :mod:`plateau.io` base class MetaPartition.
 
-        The `MetaPartition` is used as a wrapper around the kartothek
+        The `MetaPartition` is used as a wrapper around the plateau
         `Partition` and primarily deals with dataframe manipulations,
         in- and output to store.
 
-        The :class:`kartothek.io_components.metapartition` is immutable, i.e. all member
+        The :class:`plateau.io_components.metapartition` is immutable, i.e. all member
         functions will return a new MetaPartition object where the new
         attribute is changed
 
@@ -242,7 +238,7 @@ def __init__(
             A dictionary including the materialized in-memory DataFrames
             corresponding to the file references in `files`.
         indices
-            Kartothek index dictionary,
+            plateau index dictionary,
         metadata_version
         table_meta
             The dataset table schemas
@@ -400,13 +396,13 @@ def from_partition(
         table_name: str = SINGLE_TABLE,
     ):
         """
-        Transform a kartothek :class:`~kartothek.core.partition.Partition` into a
-        :class:`~kartothek.io_components.metapartition.MetaPartition`.
+        Transform a plateau :class:`~plateau.core.partition.Partition` into a
+        :class:`~plateau.io_components.metapartition.MetaPartition`.
 
         Parameters
         ----------
         partition
-            The kartothek partition to be wrapped
+            The plateau partition to be wrapped
         data
             A dictionaries with materialised :class:`~pandas.DataFrame`
         indices : dict
@@ -419,7 +415,7 @@ def from_partition(
 
         Returns
         -------
-        :class:`~kartothek.io_components.metapartition.MetaPartition`
+        :class:`~plateau.io_components.metapartition.MetaPartition`
         """
         return MetaPartition(
             label=partition.label,
@@ -486,7 +482,7 @@ def add_metapartition(
     @staticmethod
     def from_dict(dct):
         """
-        Create a :class:`~kartothek.io_components.metapartition.MetaPartition` from a dictionary.
+        Create a :class:`~plateau.io_components.metapartition.MetaPartition` from a dictionary.
 
         Parameters
         ----------
@@ -1063,7 +1059,7 @@ def partition_on(self, partition_on: Union[str, Sequence[str]]):
         Examples::
 
             >>> import pandas as pd
-            >>> from kartothek.io_components.metapartition import MetaPartition
+            >>> from plateau.io_components.metapartition import MetaPartition
             >>> mp = MetaPartition(
             ...     label='partition_label',
             ...     data={
@@ -1288,7 +1284,7 @@ def get_parquet_metadata(self, store: StoreInput) -> pd.DataFrame:
         store
           A factory function providing a KeyValueStore
         table_name
-          Name of the kartothek table for which the statistics should be retrieved
+          Name of the plateau table for which the statistics should be retrieved
 
         Returns
         -------
@@ -1374,7 +1370,7 @@ def parse_input_to_metapartition(
     table_name
         The table name assigned to the partitions
     metadata_version
-        The kartothek dataset specification version
+        The plateau dataset specification version
     """
 
     if obj is None:
diff --git a/kartothek/io_components/read.py b/plateau/io_components/read.py
similarity index 94%
rename from kartothek/io_components/read.py
rename to plateau/io_components/read.py
index 34f50706..4f58dcfa 100644
--- a/kartothek/io_components/read.py
+++ b/plateau/io_components/read.py
@@ -2,11 +2,11 @@
 
 import pandas as pd
 
-from kartothek.core.factory import DatasetFactory
-from kartothek.core.typing import StoreInput
-from kartothek.io_components.metapartition import MetaPartition
-from kartothek.io_components.utils import normalize_args
-from kartothek.serialization import (
+from plateau.core.factory import DatasetFactory
+from plateau.core.typing import StoreInput
+from plateau.io_components.metapartition import MetaPartition
+from plateau.io_components.utils import normalize_args
+from plateau.serialization import (
     PredicatesType,
     check_predicates,
     columns_in_predicates,
diff --git a/kartothek/io_components/update.py b/plateau/io_components/update.py
similarity index 84%
rename from kartothek/io_components/update.py
rename to plateau/io_components/update.py
index cf9a549c..fc29cfad 100644
--- a/kartothek/io_components/update.py
+++ b/plateau/io_components/update.py
@@ -1,14 +1,14 @@
 # -*- coding: utf-8 -*-
 """
 This module contains logic to update an existing dataset. Update means adding
-new partitions and deleting existing partitions. Kartothek does not allow an
+new partitions and deleting existing partitions. plateau does not allow an
 update of the content of existing partitions.
 """
 
 
-from kartothek.core.index import PartitionIndex
-from kartothek.core.utils import ensure_store
-from kartothek.io_components.write import store_dataset_from_partitions
+from plateau.core.index import PartitionIndex
+from plateau.core.utils import ensure_store
+from plateau.io_components.write import store_dataset_from_partitions
 
 
 def _get_partitions(dataset, query_params):
diff --git a/kartothek/io_components/utils.py b/plateau/io_components/utils.py
similarity index 97%
rename from kartothek/io_components/utils.py
rename to plateau/io_components/utils.py
index 9c908c3a..3ffd163d 100644
--- a/kartothek/io_components/utils.py
+++ b/plateau/io_components/utils.py
@@ -9,10 +9,10 @@
 import decorator
 import pandas as pd
 
-from kartothek.core.dataset import DatasetMetadata, DatasetMetadataBase
-from kartothek.core.factory import _ensure_factory
-from kartothek.core.typing import StoreFactory, StoreInput
-from kartothek.core.utils import ensure_store, lazy_store
+from plateau.core.dataset import DatasetMetadata, DatasetMetadataBase
+from plateau.core.factory import _ensure_factory
+from plateau.core.typing import StoreFactory, StoreInput
+from plateau.core.utils import ensure_store, lazy_store
 
 try:
     from typing_extensions import Literal  # type: ignore
diff --git a/kartothek/io_components/write.py b/plateau/io_components/write.py
similarity index 94%
rename from kartothek/io_components/write.py
rename to plateau/io_components/write.py
index 5de5f9fa..a9babaf0 100644
--- a/kartothek/io_components/write.py
+++ b/plateau/io_components/write.py
@@ -3,31 +3,31 @@
 
 from simplekv import KeyValueStore
 
-from kartothek.core import naming
-from kartothek.core.common_metadata import (
+from plateau.core import naming
+from plateau.core.common_metadata import (
     SchemaWrapper,
     read_schema_metadata,
     store_schema_metadata,
     validate_compatible,
 )
-from kartothek.core.dataset import DatasetMetadataBuilder
-from kartothek.core.factory import DatasetFactory
-from kartothek.core.index import ExplicitSecondaryIndex, IndexBase, PartitionIndex
-from kartothek.core.typing import StoreFactory, StoreInput
-from kartothek.core.utils import ensure_store
-from kartothek.io_components.metapartition import (
+from plateau.core.dataset import DatasetMetadataBuilder
+from plateau.core.factory import DatasetFactory
+from plateau.core.index import ExplicitSecondaryIndex, IndexBase, PartitionIndex
+from plateau.core.typing import StoreFactory, StoreInput
+from plateau.core.utils import ensure_store
+from plateau.io_components.metapartition import (
     SINGLE_TABLE,
     MetaPartition,
     MetaPartitionInput,
     parse_input_to_metapartition,
     partition_labels_from_mps,
 )
-from kartothek.io_components.utils import (
+from plateau.io_components.utils import (
     combine_metadata,
     extract_duplicates,
     sort_values_categorical,
 )
-from kartothek.serialization import DataFrameSerializer
+from plateau.serialization import DataFrameSerializer
 
 SINGLE_CATEGORY = SINGLE_TABLE
 
diff --git a/kartothek/serialization/__init__.py b/plateau/serialization/__init__.py
similarity index 100%
rename from kartothek/serialization/__init__.py
rename to plateau/serialization/__init__.py
diff --git a/kartothek/serialization/_csv.py b/plateau/serialization/_csv.py
similarity index 100%
rename from kartothek/serialization/_csv.py
rename to plateau/serialization/_csv.py
diff --git a/kartothek/serialization/_generic.py b/plateau/serialization/_generic.py
similarity index 99%
rename from kartothek/serialization/_generic.py
rename to plateau/serialization/_generic.py
index 4e00c00c..ceb0cb93 100644
--- a/kartothek/serialization/_generic.py
+++ b/plateau/serialization/_generic.py
@@ -22,7 +22,7 @@
 from pandas.api.types import is_list_like
 from simplekv import KeyValueStore
 
-from kartothek.serialization._util import _check_contains_null
+from plateau.serialization._util import _check_contains_null
 
 from ._util import ensure_unicode_string_type
 
@@ -221,7 +221,7 @@ def filter_predicates_by_column(
 
     .. ipython:: python
 
-        from kartothek.serialization import filter_predicates_by_column
+        from plateau.serialization import filter_predicates_by_column
 
         predicates = [[("A", "==", 1), ("B", "<", 5)], [("C", "==", 4)]]
 
diff --git a/kartothek/serialization/_io_buffer.py b/plateau/serialization/_io_buffer.py
similarity index 99%
rename from kartothek/serialization/_io_buffer.py
rename to plateau/serialization/_io_buffer.py
index faa492e5..c88f807e 100644
--- a/kartothek/serialization/_io_buffer.py
+++ b/plateau/serialization/_io_buffer.py
@@ -12,7 +12,7 @@
 
 class BufferReadError(IOError):
     """
-    Internal kartothek error while attempting to read from buffer
+    Internal plateau error while attempting to read from buffer
     """
 
     pass
diff --git a/kartothek/serialization/_parquet.py b/plateau/serialization/_parquet.py
similarity index 98%
rename from kartothek/serialization/_parquet.py
rename to plateau/serialization/_parquet.py
index 2bcfb910..65842635 100644
--- a/kartothek/serialization/_parquet.py
+++ b/plateau/serialization/_parquet.py
@@ -75,7 +75,7 @@ def _reset_dictionary_columns(table, exclude=None):
 
 class ParquetReadError(IOError):
     """
-    Internal kartothek error while attempting to read Parquet file
+    Internal plateau error while attempting to read Parquet file
     """
 
     pass
@@ -116,15 +116,15 @@ class ParquetSerializer(DataFrameSerializer):
     .. ipython:: python
         :suppress:
 
-        from kartothek.core.utils import ensure_store
+        from plateau.core.utils import ensure_store
         import pandas as pd
-        from kartothek.serialization import ParquetSerializer
+        from plateau.serialization import ParquetSerializer
 
         store = ensure_store("hmemory://")
 
     * `pandas.Categorical`
 
-        Kartothek offers the keyword argument `categories` which contains a list of field names which are supposed to retrieved as a `pandas.Categorical`.
+        plateau offers the keyword argument `categories` which contains a list of field names which are supposed to retrieved as a `pandas.Categorical`.
 
         See also :ref:`Dictionary Encoding`
 
@@ -290,7 +290,7 @@ def restore_dataframe(
         predicates: Optional[PredicatesType] = None,
         date_as_object: bool = False,
     ) -> pd.DataFrame:
-        # https://github.com/JDASoftwareGroup/kartothek/issues/407  We have been seeing weird `IOError`s while reading
+        # https://github.com/JDASoftwareGroup/plateau/issues/407  We have been seeing weird `IOError`s while reading
         # Parquet files from Azure Blob Store. These errors have caused long running computations to fail.
         # The workaround is to retry the serialization here and gain more stability for long running tasks.
         # This code should not live forever, it should be removed once the underlying cause has been resolved.
diff --git a/kartothek/serialization/_util.py b/plateau/serialization/_util.py
similarity index 100%
rename from kartothek/serialization/_util.py
rename to plateau/serialization/_util.py
diff --git a/plateau/utils/__init__.py b/plateau/utils/__init__.py
new file mode 100644
index 00000000..19c3eb9e
--- /dev/null
+++ b/plateau/utils/__init__.py
@@ -0,0 +1,3 @@
+"""
+Utilities that are not plateau-specific but are required to archive certain tasks.
+"""
diff --git a/kartothek/utils/converters.py b/plateau/utils/converters.py
similarity index 100%
rename from kartothek/utils/converters.py
rename to plateau/utils/converters.py
diff --git a/kartothek/utils/pandas.py b/plateau/utils/pandas.py
similarity index 100%
rename from kartothek/utils/pandas.py
rename to plateau/utils/pandas.py
diff --git a/kartothek/utils/store.py b/plateau/utils/store.py
similarity index 100%
rename from kartothek/utils/store.py
rename to plateau/utils/store.py
diff --git a/pyproject.toml b/pyproject.toml
index 91fc8674..271b0149 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,6 +16,6 @@ exclude = '''
 multi_line_output = 3
 include_trailing_comma = true
 line_length = 88
-known_first_party = "kartothek"
+known_first_party = "plateau"
 skip_glob = '\.eggs/*,\.git/*,\.venv/*,build/*,dist/*'
 default_section = 'THIRDPARTY'
diff --git a/reference-data/arrow-compat/batch_generate_references.sh b/reference-data/arrow-compat/batch_generate_references.sh
index 317cd9d3..2616c376 100755
--- a/reference-data/arrow-compat/batch_generate_references.sh
+++ b/reference-data/arrow-compat/batch_generate_references.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-# Note: this assumes you have kartothek installed in your current environment and you are using conda
+# Note: this assumes you have plateau installed in your current environment and you are using conda
 
 PYARROW_VERSIONS="0.14.1 0.15.0 0.16.0 0.17.1 1.0.1 2.0.0 3.0.0"
 
diff --git a/reference-data/arrow-compat/generate_reference.py b/reference-data/arrow-compat/generate_reference.py
index fe6ddadc..39eef264 100755
--- a/reference-data/arrow-compat/generate_reference.py
+++ b/reference-data/arrow-compat/generate_reference.py
@@ -4,8 +4,8 @@
 import pyarrow as pa
 from storefact import get_store_from_url
 
-from kartothek.core.testing import get_dataframe_alltypes
-from kartothek.serialization import ParquetSerializer
+from plateau.core.testing import get_dataframe_alltypes
+from plateau.serialization import ParquetSerializer
 
 if __name__ == "__main__":
     ser = ParquetSerializer()
diff --git a/setup.py b/setup.py
index 76427e14..a69a91f1 100644
--- a/setup.py
+++ b/setup.py
@@ -11,27 +11,22 @@ def get_install_requirements(path):
     return [req for req in content.split("\n") if req != "" and not req.startswith("#")]
 
 
-def setup_package():
-    setup(
-        name="kartothek",
-        author="Blue Yonder GmbH",
-        install_requires=get_install_requirements("requirements.txt"),
-        tests_require=get_install_requirements("test-requirements.txt"),
-        packages=find_packages(exclude=["tests*"]),
-        classifiers=[
-            "Development Status :: 5 - Production/Stable",
-            "Programming Language :: Python",
-            "Programming Language :: Python :: 3",
-            "Programming Language :: Python :: 3.6",
-            "Programming Language :: Python :: 3.7",
-            "Programming Language :: Python :: 3.8",
-        ],
-        use_scm_version=True,
-        long_description=open("README.md", "r").read(),
-        long_description_content_type="text/markdown",
-        python_requires=">=3.6",
-    )
-
-
-if __name__ == "__main__":
-    setup_package()
+setup(
+    name="plateau",
+    author="data engineering collective",
+    install_requires=get_install_requirements("requirements.txt"),
+    tests_require=get_install_requirements("test-requirements.txt"),
+    packages=find_packages(exclude=["tests*"]),
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+    ],
+    use_scm_version=True,
+    long_description=open("README.md", "r").read(),
+    long_description_content_type="text/markdown",
+    python_requires=">=3.6",
+)


Test patch:
diff --git a/kartothek/core/testing.py b/plateau/core/testing.py
similarity index 96%
rename from kartothek/core/testing.py
rename to plateau/core/testing.py
index 64b1dc25..741fddb4 100644
--- a/kartothek/core/testing.py
+++ b/plateau/core/testing.py
@@ -13,7 +13,7 @@
 import pandas as pd
 from hypothesis.errors import NonInteractiveExampleWarning
 
-from kartothek.core.uuid import gen_uuid_object
+from plateau.core.uuid import gen_uuid_object
 
 TIME_TO_FREEZE = datetime.datetime(2000, 1, 1, 1, 1, 1, 1)
 TIME_TO_FREEZE_ISO = "2000-01-01T01:01:01.000001"
@@ -159,11 +159,11 @@ def _maximum_single_nan(arr):
 @contextlib.contextmanager
 def cm_frozen_time(time_to_freeze):
     """
-    Context manager to monkeypatch kartothek.core._time.* to return
+    Context manager to monkeypatch plateau.core._time.* to return
     a fixed datetime value `time_to_freeze`.
     """
-    with mock.patch("kartothek.core._time.datetime_now") as mock_now, mock.patch(
-        "kartothek.core._time.datetime_utcnow"
+    with mock.patch("plateau.core._time.datetime_now") as mock_now, mock.patch(
+        "plateau.core._time.datetime_utcnow"
     ) as mock_utcnow:
         mock_now.return_value = time_to_freeze
         mock_utcnow.return_value = time_to_freeze
diff --git a/kartothek/io/testing/__init__.py b/plateau/io/testing/__init__.py
similarity index 100%
rename from kartothek/io/testing/__init__.py
rename to plateau/io/testing/__init__.py
diff --git a/kartothek/io/testing/delete.py b/plateau/io/testing/delete.py
similarity index 100%
rename from kartothek/io/testing/delete.py
rename to plateau/io/testing/delete.py
diff --git a/kartothek/io/testing/gc.py b/plateau/io/testing/gc.py
similarity index 100%
rename from kartothek/io/testing/gc.py
rename to plateau/io/testing/gc.py
diff --git a/kartothek/io/testing/index.py b/plateau/io/testing/index.py
similarity index 97%
rename from kartothek/io/testing/index.py
rename to plateau/io/testing/index.py
index 73e0e310..701131b7 100644
--- a/kartothek/io/testing/index.py
+++ b/plateau/io/testing/index.py
@@ -4,8 +4,8 @@
 import pytest
 from toolz.dicttoolz import valmap
 
-from kartothek.core.factory import DatasetFactory
-from kartothek.io.eager import store_dataframes_as_dataset
+from plateau.core.factory import DatasetFactory
+from plateau.io.eager import store_dataframes_as_dataset
 
 
 def assert_index_dct_equal(dict1, dict2):
diff --git a/kartothek/io/testing/read.py b/plateau/io/testing/read.py
similarity index 97%
rename from kartothek/io/testing/read.py
rename to plateau/io/testing/read.py
index bf5cddd4..b2be1446 100644
--- a/kartothek/io/testing/read.py
+++ b/plateau/io/testing/read.py
@@ -1,17 +1,17 @@
 """
-This module is a collection of tests which should be implemented by all kartothek
+This module is a collection of tests which should be implemented by all plateau
 **read** backends. The tests are not subject to the semantic versioning scheme and may change with minor or even patch releases.
 
 To use the tests of this module, add the following import statement to your test module and ensure that the following fixtures are available in your test environment.
 
 ```
-from kartothek.io.testing.read import *  # noqa
+from plateau.io.testing.read import *  # noqa
 ```
 
 Fixtures required to be implemented:
 
 * ``output_type`` - One of {`dataframe`, `metpartition`, `table`} to define the outptu type of the returned result.
-* ``bound_load_dataframes`` - A callable which will retrieve the partitions in the format specified by ``output_type``. The callable should accept all keyword arguments expected for a kartothek reader.
+* ``bound_load_dataframes`` - A callable which will retrieve the partitions in the format specified by ``output_type``. The callable should accept all keyword arguments expected for a plateau reader.
 
 Source test data
 
@@ -36,9 +36,9 @@
 import pytest
 from storefact import get_store_from_url
 
-from kartothek.io.eager import store_dataframes_as_dataset
-from kartothek.io.iter import store_dataframes_as_dataset__iter
-from kartothek.io_components.metapartition import SINGLE_TABLE, MetaPartition
+from plateau.io.eager import store_dataframes_as_dataset
+from plateau.io.iter import store_dataframes_as_dataset__iter
+from plateau.io_components.metapartition import SINGLE_TABLE, MetaPartition
 
 
 @pytest.fixture(params=[True, False], ids=["use_categoricals", "no_categoricals"])
@@ -91,8 +91,8 @@ def store_input_types(request, tmpdir):
 
 
 def test_store_input_types(store_input_types, bound_load_dataframes):
-    from kartothek.io.eager import store_dataframes_as_dataset
-    from kartothek.serialization.testing import get_dataframe_not_nested
+    from plateau.io.eager import store_dataframes_as_dataset
+    from plateau.serialization.testing import get_dataframe_not_nested
 
     dataset_uuid = "dataset_uuid"
     df = get_dataframe_not_nested(10)
diff --git a/kartothek/io/testing/update.py b/plateau/io/testing/update.py
similarity index 97%
rename from kartothek/io/testing/update.py
rename to plateau/io/testing/update.py
index 62d891e5..a3e6218c 100644
--- a/kartothek/io/testing/update.py
+++ b/plateau/io/testing/update.py
@@ -9,15 +9,12 @@
 import pandas as pd
 import pytest
 
-from kartothek.api.dataset import read_dataset_as_ddf
-from kartothek.core.dataset import DatasetMetadata
-from kartothek.core.naming import DEFAULT_METADATA_VERSION
-from kartothek.core.testing import TIME_TO_FREEZE_ISO
-from kartothek.io.eager import (
-    read_dataset_as_metapartitions,
-    store_dataframes_as_dataset,
-)
-from kartothek.io.iter import read_dataset_as_dataframes__iterator
+from plateau.api.dataset import read_dataset_as_ddf
+from plateau.core.dataset import DatasetMetadata
+from plateau.core.naming import DEFAULT_METADATA_VERSION
+from plateau.core.testing import TIME_TO_FREEZE_ISO
+from plateau.io.eager import read_dataset_as_metapartitions, store_dataframes_as_dataset
+from plateau.io.iter import read_dataset_as_dataframes__iterator
 
 
 def test_update_dataset_with_partitions(
@@ -513,7 +510,7 @@ def test_update_secondary_indices_subset(store_factory, bound_update_dataset):
     )
 
     df2 = pd.DataFrame({"A": range(10), "indexed": 2})
-    # secondary index is omitted. Kartothek should pick it up regardless
+    # secondary index is omitted. plateau should pick it up regardless
     bound_update_dataset(df2, dataset_uuid=dataset_uuid, store=store_factory)
 
     dm = DatasetMetadata.load_from_store(
@@ -524,7 +521,7 @@ def test_update_secondary_indices_subset(store_factory, bound_update_dataset):
     assert sorted(obs_values) == [1, 2]
 
     with pytest.raises(ValueError, match="Incorrect indices provided"):
-        # secondary index is omitted. Kartothek should pick it up regardless
+        # secondary index is omitted. plateau should pick it up regardless
         bound_update_dataset(
             df2, dataset_uuid=dataset_uuid, store=store_factory, secondary_indices="A"
         )
diff --git a/kartothek/io/testing/utils.py b/plateau/io/testing/utils.py
similarity index 95%
rename from kartothek/io/testing/utils.py
rename to plateau/io/testing/utils.py
index fb5c4f0f..5f8d260e 100644
--- a/kartothek/io/testing/utils.py
+++ b/plateau/io/testing/utils.py
@@ -4,7 +4,7 @@
 import pandas as pd
 from pyarrow.parquet import ParquetFile
 
-from kartothek.io.eager import store_dataframes_as_dataset
+from plateau.io.eager import store_dataframes_as_dataset
 
 
 def create_dataset(dataset_uuid, store_factory, metadata_version):
diff --git a/kartothek/io/testing/write.py b/plateau/io/testing/write.py
similarity index 98%
rename from kartothek/io/testing/write.py
rename to plateau/io/testing/write.py
index 1995a945..9b04cdb3 100644
--- a/kartothek/io/testing/write.py
+++ b/plateau/io/testing/write.py
@@ -11,11 +11,11 @@
 import pytest
 from storefact import get_store_from_url
 
-from kartothek.core.dataset import DatasetMetadata
-from kartothek.core.uuid import gen_uuid
-from kartothek.io.eager import read_table
-from kartothek.io_components.metapartition import MetaPartition
-from kartothek.serialization import DataFrameSerializer
+from plateau.core.dataset import DatasetMetadata
+from plateau.core.uuid import gen_uuid
+from plateau.io.eager import read_table
+from plateau.io_components.metapartition import MetaPartition
+from plateau.serialization import DataFrameSerializer
 
 
 class NoPickle:
@@ -53,7 +53,7 @@ def store_input_types(request, tmpdir):
 
 
 def test_store_input_types(store_input_types, bound_store_dataframes):
-    from kartothek.serialization.testing import get_dataframe_not_nested
+    from plateau.serialization.testing import get_dataframe_not_nested
 
     dataset_uuid = "dataset_uuid"
     df = get_dataframe_not_nested(10)
diff --git a/kartothek/serialization/testing.py b/plateau/serialization/testing.py
similarity index 100%
rename from kartothek/serialization/testing.py
rename to plateau/serialization/testing.py
diff --git a/tests/conftest.py b/tests/conftest.py
index be0d9c19..51ab8171 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -12,25 +12,25 @@
 import storefact
 
 # fmt: off
-pytest.register_assert_rewrite("kartothek.io.testing")
+pytest.register_assert_rewrite("plateau.io.testing")
 # fmt: on
 
-from kartothek.core.common_metadata import make_meta  # noqa: E402
-from kartothek.core.factory import DatasetFactory  # noqa: E402
-from kartothek.core.testing import (  # noqa: E402
+from plateau.core.common_metadata import make_meta  # noqa: E402
+from plateau.core.factory import DatasetFactory  # noqa: E402
+from plateau.core.testing import (  # noqa: E402
     TIME_TO_FREEZE,
     cm_frozen_time,
     get_dataframe_alltypes,
     get_dataframe_not_nested,
 )
-from kartothek.io_components.metapartition import (  # noqa: E402
+from plateau.io_components.metapartition import (  # noqa: E402
     MetaPartition,
     gen_uuid,
     parse_input_to_metapartition,
 )
-from kartothek.core.utils import lazy_store  # noqa: E402
-from kartothek.io_components.write import store_dataset_from_partitions  # noqa: E402
-from kartothek.serialization import ParquetSerializer  # noqa: E402
+from plateau.core.utils import lazy_store  # noqa: E402
+from plateau.io_components.write import store_dataset_from_partitions  # noqa: E402
+from plateau.serialization import ParquetSerializer  # noqa: E402
 
 
 pd.options.mode.chained_assignment = "raise"
@@ -40,7 +40,7 @@
 def frozen_time():
     """
     Depend on this fixture to set the time to TIME_TO_FREEZE
-    by patching kartothek.core._time.* with mock objects.
+    by patching plateau.core._time.* with mock objects.
 
     Note: you only need one of the fixtures `frozen_time`,
     `distributed_frozen_time`, or `frozen_time_em`:
@@ -162,7 +162,7 @@ def _f(suffix):
             pytest.skip("{} not provided".format(env_name))
 
         container = "tests-{component}-{py_major}-{py_minor}-{suffix}".format(
-            component="kartothek",
+            component="plateau",
             py_major=sys.version_info.major,
             py_minor=sys.version_info.minor,
             suffix=suffix,
@@ -186,7 +186,7 @@ def module_store(tmpdir_factory):
 
 @pytest.fixture
 def mock_uuid(mocker):
-    uuid = mocker.patch("kartothek.core.uuid._uuid_hook_str")
+    uuid = mocker.patch("plateau.core.uuid._uuid_hook_str")
     uuid.return_value = "auto_dataset_uuid"
     return uuid
 
@@ -195,16 +195,16 @@ def mock_uuid(mocker):
 def mock_default_metadata_version(mocker, backend_identifier):
     mock_metadata_version = 1
 
-    # Mock `kartothek.core.utils.verify_metadata_version`
+    # Mock `plateau.core.utils.verify_metadata_version`
     def patched__verify_metadata_version(metadata_version):
         pass
 
     mocker.patch(
-        "kartothek.core.utils._verify_metadata_version",
+        "plateau.core.utils._verify_metadata_version",
         patched__verify_metadata_version,
     )
 
-    # Mock `kartothek.io_components.metapartition.parse_input_to_metapartition`
+    # Mock `plateau.io_components.metapartition.parse_input_to_metapartition`
     def patched__parse_input_to_metapartition(
         obj, table_name, metadata_version=None, *args, **kwargs
     ):
@@ -226,7 +226,7 @@ def patched__parse_input_to_metapartition(
             raise AssertionError("Traversed through mock. Original error: {}".format(e))
 
     mocker.patch(
-        "kartothek.io.{backend_identifier}.parse_input_to_metapartition".format(
+        "plateau.io.{backend_identifier}.parse_input_to_metapartition".format(
             backend_identifier=backend_identifier
         ),
         patched__parse_input_to_metapartition,
@@ -430,7 +430,7 @@ def meta_partitions_evaluation_files_only(
 @pytest.fixture(scope="session")
 def dataset(meta_partitions_files_only, store_session_factory):
     """
-    Create a proper kartothek dataset in store with two partitions
+    Create a proper plateau dataset in store with two partitions
 
     """
     with cm_frozen_time(TIME_TO_FREEZE):
@@ -455,7 +455,7 @@ def dataset_factory(dataset, store_session_factory):
 @pytest.fixture(scope="session")
 def dataset_partition_keys(meta_partitions_dataframe, store_session_factory):
     """
-    Create a proper kartothek dataset in store with two partitions
+    Create a proper plateau dataset in store with two partitions
 
     """
     with cm_frozen_time(TIME_TO_FREEZE):
@@ -487,7 +487,7 @@ def dataset_with_index(
     meta_partitions_dataframe, store_session_factory, metadata_version
 ):
     """
-    Create a proper kartothek dataset in store with two partitions
+    Create a proper plateau dataset in store with two partitions
 
     """
     with cm_frozen_time(TIME_TO_FREEZE):
@@ -519,7 +519,7 @@ def dataset_with_index_factory(dataset_with_index, store_session_factory):
 @pytest.fixture(scope="function")
 def dataset_function(meta_partitions_files_only_function, store):
     """
-    Create a proper kartothek dataset in store with two partitions
+    Create a proper plateau dataset in store with two partitions
 
     """
     with cm_frozen_time(TIME_TO_FREEZE):
diff --git a/tests/core/test_builder.py b/tests/core/test_builder.py
index 0c511458..4f09136d 100644
--- a/tests/core/test_builder.py
+++ b/tests/core/test_builder.py
@@ -4,11 +4,11 @@
 import pytest
 import simplejson
 
-import kartothek.core._zmsgpack as msgpack
-from kartothek.core.dataset import DatasetMetadata, DatasetMetadataBuilder
-from kartothek.core.index import ExplicitSecondaryIndex
-from kartothek.core.partition import Partition
-from kartothek.core.testing import TIME_TO_FREEZE_ISO
+import plateau.core._zmsgpack as msgpack
+from plateau.core.dataset import DatasetMetadata, DatasetMetadataBuilder
+from plateau.core.index import ExplicitSecondaryIndex
+from plateau.core.partition import Partition
+from plateau.core.testing import TIME_TO_FREEZE_ISO
 
 
 @pytest.mark.parametrize("explicit_partitions", [True, False])
diff --git a/tests/core/test_common_metadata.py b/tests/core/test_common_metadata.py
index 80920e1c..27a0fa81 100644
--- a/tests/core/test_common_metadata.py
+++ b/tests/core/test_common_metadata.py
@@ -14,7 +14,7 @@
 from dask.dataframe.utils import make_meta as dask_make_meta
 from packaging.version import parse as parse_version
 
-from kartothek.core.common_metadata import (
+from plateau.core.common_metadata import (
     SchemaWrapper,
     _diff_schemas,
     _get_common_metadata_key,
@@ -25,7 +25,7 @@
     validate_compatible,
     validate_shared_columns,
 )
-from kartothek.serialization import ParquetSerializer
+from plateau.serialization import ParquetSerializer
 
 try:
     arrow_version = parse_version(pa.__version__)
@@ -533,7 +533,7 @@ def test_make_meta_column_normalization_pyarrow_schema():
     # GH228
     df = pd.DataFrame(
         [{"part": 1, "id": 1, "col1": "abc"}, {"part": 2, "id": 2, "col1": np.nan}],
-        # Kartothek normalizes field order s.t. partition keys are first and the
+        # plateau normalizes field order s.t. partition keys are first and the
         # rest is alphabetically. This is reverse.
         columns=["col1", "id", "part"],
     )
diff --git a/tests/core/test_dataset_dyn_part.py b/tests/core/test_dataset_dyn_part.py
index a4dbb4c6..c8c3d56a 100644
--- a/tests/core/test_dataset_dyn_part.py
+++ b/tests/core/test_dataset_dyn_part.py
@@ -8,13 +8,13 @@
 import simplejson
 import storefact
 
-from kartothek.core.common_metadata import (
+from plateau.core.common_metadata import (
     _get_common_metadata_key,
     make_meta,
     store_schema_metadata,
 )
-from kartothek.core.dataset import DatasetMetadata, create_partition_key, naming
-from kartothek.core.urlencode import quote_indices, unquote_indices
+from plateau.core.dataset import DatasetMetadata, create_partition_key, naming
+from plateau.core.urlencode import quote_indices, unquote_indices
 
 
 def test_create_partition_key():
@@ -308,7 +308,7 @@ def test_dynamic_partitions_quote(store, metadata_version):
 def test_dask_partitions(metadata_version):
     """
     Create partitions for one table with dask
-    and check that it can be read with kartothek
+    and check that it can be read with plateau
     """
     import dask.dataframe
 
diff --git a/tests/core/test_dataset_explicit_part.py b/tests/core/test_dataset_explicit_part.py
index 94eccf9d..fe49332e 100644
--- a/tests/core/test_dataset_explicit_part.py
+++ b/tests/core/test_dataset_explicit_part.py
@@ -10,11 +10,11 @@
 import pytest
 import simplejson
 
-import kartothek.core._zmsgpack as msgpack
-from kartothek.core.common_metadata import make_meta, store_schema_metadata
-from kartothek.core.dataset import DatasetMetadata
-from kartothek.core.index import ExplicitSecondaryIndex, PartitionIndex
-from kartothek.core.testing import cm_frozen_time
+import plateau.core._zmsgpack as msgpack
+from plateau.core.common_metadata import make_meta, store_schema_metadata
+from plateau.core.dataset import DatasetMetadata
+from plateau.core.index import ExplicitSecondaryIndex, PartitionIndex
+from plateau.core.testing import cm_frozen_time
 
 # Basic functionality tests.
 #
@@ -98,7 +98,7 @@ def test_raise_multitable(metadata_version):
 
     with pytest.raises(
         RuntimeError,
-        match=r"Dataset uuid has tables.*but read support for multi tabled dataset was dropped with kartothek 4\.0\.",
+        match=r"Dataset uuid has tables.*but read support for multi tabled dataset was dropped with plateau 4\.0\.",
     ):
         DatasetMetadata.from_dict(expected)
 
diff --git a/tests/core/test_docs.py b/tests/core/test_docs.py
index 07f499b2..02403f02 100644
--- a/tests/core/test_docs.py
+++ b/tests/core/test_docs.py
@@ -3,26 +3,26 @@
 
 import pytest
 
-from kartothek.core.docs import _PARAMETER_MAPPING, default_docs
-from kartothek.io.dask.bag import (
+from plateau.core.docs import _PARAMETER_MAPPING, default_docs
+from plateau.io.dask.bag import (
     build_dataset_indices__bag,
     read_dataset_as_dataframe_bag,
     read_dataset_as_metapartitions_bag,
     store_bag_as_dataset,
 )
-from kartothek.io.dask.dataframe import (
+from plateau.io.dask.dataframe import (
     read_dataset_as_ddf,
     store_dataset_from_ddf,
     update_dataset_from_ddf,
 )
-from kartothek.io.dask.delayed import (
+from plateau.io.dask.delayed import (
     delete_dataset__delayed,
     read_dataset_as_delayed,
     read_dataset_as_delayed_metapartitions,
     store_delayed_as_dataset,
     update_dataset_from_delayed,
 )
-from kartothek.io.eager import (
+from plateau.io.eager import (
     build_dataset_indices,
     commit_dataset,
     create_empty_dataset_header,
@@ -35,7 +35,7 @@
     update_dataset_from_dataframes,
     write_single_partition,
 )
-from kartothek.io.iter import (
+from plateau.io.iter import (
     read_dataset_as_dataframes__iterator,
     read_dataset_as_metapartitions__iterator,
     store_dataframes_as_dataset__iter,
diff --git a/tests/core/test_factory.py b/tests/core/test_factory.py
index 8606640e..f445aaaa 100644
--- a/tests/core/test_factory.py
+++ b/tests/core/test_factory.py
@@ -1,4 +1,4 @@
-from kartothek.core.factory import DatasetFactory
+from plateau.core.factory import DatasetFactory
 
 
 def test_repr(store_factory):
diff --git a/tests/core/test_index.py b/tests/core/test_index.py
index c502b167..7b6733e9 100644
--- a/tests/core/test_index.py
+++ b/tests/core/test_index.py
@@ -14,8 +14,8 @@
 from hypothesis import assume, given
 from pandas.testing import assert_series_equal
 
-from kartothek.core.index import ExplicitSecondaryIndex, IndexBase, merge_indices
-from kartothek.core.testing import get_numpy_array_strategy
+from plateau.core.index import ExplicitSecondaryIndex, IndexBase, merge_indices
+from plateau.core.testing import get_numpy_array_strategy
 
 
 @pytest.mark.parametrize("inplace", [True, False])
@@ -591,7 +591,7 @@ def test_index_normalize_during_init_warn_collision(collision, caplog):
     warn = [
         t[2]
         for t in caplog.record_tuples
-        if t[0] == "kartothek.core.index" and t[1] == logging.WARN
+        if t[0] == "plateau.core.index" and t[1] == logging.WARN
     ]
 
     if collision:
diff --git a/tests/core/test_msgpack.py b/tests/core/test_msgpack.py
index 57758da3..c38cc8fc 100644
--- a/tests/core/test_msgpack.py
+++ b/tests/core/test_msgpack.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-from kartothek.core._zmsgpack import packb, unpackb
+from plateau.core._zmsgpack import packb, unpackb
 
 
 def test_msgpack():
diff --git a/tests/core/test_partition.py b/tests/core/test_partition.py
index 3772f855..2938d64a 100644
--- a/tests/core/test_partition.py
+++ b/tests/core/test_partition.py
@@ -2,7 +2,7 @@
 
 import pytest
 
-from kartothek.core.partition import Partition
+from plateau.core.partition import Partition
 
 
 def test_roundtrip():
diff --git a/tests/core/test_testing.py b/tests/core/test_testing.py
index eae08064..1141b026 100644
--- a/tests/core/test_testing.py
+++ b/tests/core/test_testing.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 
-from kartothek.core.testing import get_dataframe_alltypes
+from plateau.core.testing import get_dataframe_alltypes
 
 
 def test_get_dataframe_alltypes():
diff --git a/tests/core/test_urlencode.py b/tests/core/test_urlencode.py
index 7d195942..2d8e9666 100644
--- a/tests/core/test_urlencode.py
+++ b/tests/core/test_urlencode.py
@@ -2,8 +2,8 @@
 
 from urllib.parse import quote as quote_python
 
-from kartothek.core.urlencode import quote as quote_ktk
-from kartothek.core.urlencode import unquote as unquote_ktk
+from plateau.core.urlencode import quote as quote_ktk
+from plateau.core.urlencode import unquote as unquote_ktk
 
 TEST_STRING = "Test string with lots of special characters !@#$%^&*+=()[]\\{}<>?|'\"-_~`☺✌☕file.par"
 
diff --git a/tests/core/test_utils.py b/tests/core/test_utils.py
index 98f94bf4..e020c89e 100644
--- a/tests/core/test_utils.py
+++ b/tests/core/test_utils.py
@@ -5,7 +5,7 @@
 from simplekv.decorator import PrefixDecorator
 from storefact import get_store_from_url
 
-from kartothek.core.utils import ensure_store, lazy_store
+from plateau.core.utils import ensure_store, lazy_store
 
 
 class NoPickle:
diff --git a/tests/io/dask/bag/test_index.py b/tests/io/dask/bag/test_index.py
index 747235a7..326693d2 100644
--- a/tests/io/dask/bag/test_index.py
+++ b/tests/io/dask/bag/test_index.py
@@ -3,8 +3,8 @@
 
 import pytest
 
-from kartothek.io.dask.bag import build_dataset_indices__bag
-from kartothek.io.testing.index import *  # noqa: F4
+from plateau.io.dask.bag import build_dataset_indices__bag
+from plateau.io.testing.index import *  # noqa: F4
 
 
 def _build_indices(*args, **kwargs):
diff --git a/tests/io/dask/bag/test_read.py b/tests/io/dask/bag/test_read.py
index 9083e2a6..d59fddb5 100644
--- a/tests/io/dask/bag/test_read.py
+++ b/tests/io/dask/bag/test_read.py
@@ -4,12 +4,12 @@
 import pandas as pd
 import pytest
 
-from kartothek.io.dask.bag import (
+from plateau.io.dask.bag import (
     read_dataset_as_dataframe_bag,
     read_dataset_as_metapartitions_bag,
 )
-from kartothek.io.iter import store_dataframes_as_dataset__iter
-from kartothek.io.testing.read import *  # noqa
+from plateau.io.iter import store_dataframes_as_dataset__iter
+from plateau.io.testing.read import *  # noqa
 
 
 @pytest.fixture(params=["dataframe"])
diff --git a/tests/io/dask/bag/test_write.py b/tests/io/dask/bag/test_write.py
index 8a99bd94..42268e08 100644
--- a/tests/io/dask/bag/test_write.py
+++ b/tests/io/dask/bag/test_write.py
@@ -3,8 +3,8 @@
 import dask.bag as db
 import pytest
 
-from kartothek.io.dask.bag import store_bag_as_dataset
-from kartothek.io.testing.write import *  # noqa
+from plateau.io.dask.bag import store_bag_as_dataset
+from plateau.io.testing.write import *  # noqa
 
 
 def _store_dataframes(df_list, *args, **kwargs):
diff --git a/tests/io/dask/conftest.py b/tests/io/dask/conftest.py
index 5391b1af..257b4864 100644
--- a/tests/io/dask/conftest.py
+++ b/tests/io/dask/conftest.py
@@ -5,8 +5,8 @@
 import pytest
 from distributed import Client
 
-import kartothek.core._time
-from kartothek.core.testing import cm_frozen_time
+import plateau.core._time
+from plateau.core.testing import cm_frozen_time
 
 _client = None
 
@@ -26,7 +26,7 @@ def setup_dask_distributed():
 def cm_distributed_frozen_time():
     global _client
     assert _client is not None
-    _client.run(_freeze_time_on_worker, kartothek.core._time.datetime_now())
+    _client.run(_freeze_time_on_worker, plateau.core._time.datetime_now())
     try:
         yield
     finally:
@@ -50,11 +50,11 @@ def _freeze_time_on_worker(freeze_time):
     # it runs the "enter" part of the cm_frozen_time context manager.
     # It saves the context manager to be able to call __exit__ on it later
     # in _unfreeze_time_on_worker.
-    kartothek.core._time._datetime_utcnow_orig = kartothek.core._time.datetime_utcnow
+    plateau.core._time._datetime_utcnow_orig = plateau.core._time.datetime_utcnow
     cm = cm_frozen_time(freeze_time)
-    kartothek.core._time._time_patcher = cm
+    plateau.core._time._time_patcher = cm
     cm.__enter__()
 
 
 def _unfreeze_time_on_worker():
-    kartothek.core._time._time_patcher.__exit__(None, None, None)
+    plateau.core._time._time_patcher.__exit__(None, None, None)
diff --git a/tests/io/dask/dataframe/test_compression.py b/tests/io/dask/dataframe/test_compression.py
index 75a319d1..c18fcb98 100644
--- a/tests/io/dask/dataframe/test_compression.py
+++ b/tests/io/dask/dataframe/test_compression.py
@@ -3,7 +3,7 @@
 import pandas.testing as pdt
 import pytest
 
-from kartothek.io.dask.compression import (
+from plateau.io.dask.compression import (
     pack_payload,
     pack_payload_pandas,
     unpack_payload,
diff --git a/tests/io/dask/dataframe/test_hashing.py b/tests/io/dask/dataframe/test_hashing.py
index dd32ec07..30d8242b 100644
--- a/tests/io/dask/dataframe/test_hashing.py
+++ b/tests/io/dask/dataframe/test_hashing.py
@@ -1,7 +1,7 @@
 import pandas as pd
 import pandas.testing as pdt
 
-from kartothek.io.dask.dataframe import hash_dataset
+from plateau.io.dask.dataframe import hash_dataset
 
 
 def test_hash_dataset(dataset_with_index_factory):
diff --git a/tests/io/dask/dataframe/test_read.py b/tests/io/dask/dataframe/test_read.py
index 176e4b7c..da54abb7 100644
--- a/tests/io/dask/dataframe/test_read.py
+++ b/tests/io/dask/dataframe/test_read.py
@@ -10,11 +10,11 @@
 from pandas import testing as pdt
 from pandas.testing import assert_frame_equal
 
-from kartothek.core.testing import get_dataframe_not_nested
-from kartothek.io.dask.dataframe import read_dataset_as_ddf
-from kartothek.io.eager import store_dataframes_as_dataset
-from kartothek.io.testing.read import *  # noqa
-from kartothek.io_components.metapartition import SINGLE_TABLE
+from plateau.core.testing import get_dataframe_not_nested
+from plateau.io.dask.dataframe import read_dataset_as_ddf
+from plateau.io.eager import store_dataframes_as_dataset
+from plateau.io.testing.read import *  # noqa
+from plateau.io_components.metapartition import SINGLE_TABLE
 
 
 @pytest.fixture()
diff --git a/tests/io/dask/dataframe/test_shuffle.py b/tests/io/dask/dataframe/test_shuffle.py
index 9c949299..60959e37 100644
--- a/tests/io/dask/dataframe/test_shuffle.py
+++ b/tests/io/dask/dataframe/test_shuffle.py
@@ -6,10 +6,10 @@
 import pandas.testing as pdt
 import pytest
 
-from kartothek.core.factory import DatasetFactory
-from kartothek.io.dask._shuffle import _KTK_HASH_BUCKET, _hash_bucket
-from kartothek.io.dask.dataframe import store_dataset_from_ddf, update_dataset_from_ddf
-from kartothek.io.iter import read_dataset_as_dataframes__iterator
+from plateau.core.factory import DatasetFactory
+from plateau.io.dask._shuffle import _KTK_HASH_BUCKET, _hash_bucket
+from plateau.io.dask.dataframe import store_dataset_from_ddf, update_dataset_from_ddf
+from plateau.io.iter import read_dataset_as_dataframes__iterator
 
 
 @pytest.mark.parametrize("col", ["range", "range_duplicated", "random"])
diff --git a/tests/io/dask/dataframe/test_stats.py b/tests/io/dask/dataframe/test_stats.py
index fc5bdebb..899cd694 100644
--- a/tests/io/dask/dataframe/test_stats.py
+++ b/tests/io/dask/dataframe/test_stats.py
@@ -1,13 +1,10 @@
 import pandas as pd
 import pytest
 
-from kartothek.io.dask.dataframe import collect_dataset_metadata
-from kartothek.io.eager import (
-    store_dataframes_as_dataset,
-    update_dataset_from_dataframes,
-)
-from kartothek.io_components.metapartition import _METADATA_SCHEMA
-from kartothek.serialization import ParquetSerializer
+from plateau.io.dask.dataframe import collect_dataset_metadata
+from plateau.io.eager import store_dataframes_as_dataset, update_dataset_from_dataframes
+from plateau.io_components.metapartition import _METADATA_SCHEMA
+from plateau.serialization import ParquetSerializer
 
 
 def test_collect_dataset_metadata(store_session_factory, dataset):
diff --git a/tests/io/dask/dataframe/test_update.py b/tests/io/dask/dataframe/test_update.py
index 5dd64c5e..3bb7c827 100644
--- a/tests/io/dask/dataframe/test_update.py
+++ b/tests/io/dask/dataframe/test_update.py
@@ -5,8 +5,8 @@
 import pandas as pd
 import pytest
 
-from kartothek.io.dask.dataframe import update_dataset_from_ddf
-from kartothek.io.testing.update import *  # noqa
+from plateau.io.dask.dataframe import update_dataset_from_ddf
+from plateau.io.testing.update import *  # noqa
 
 
 @pytest.fixture
diff --git a/tests/io/dask/delayed/test_delete.py b/tests/io/dask/delayed/test_delete.py
index e31c2212..9e751d12 100644
--- a/tests/io/dask/delayed/test_delete.py
+++ b/tests/io/dask/delayed/test_delete.py
@@ -3,8 +3,8 @@
 import dask
 import pytest
 
-from kartothek.io.dask.delayed import delete_dataset__delayed
-from kartothek.io.testing.delete import *  # noqa
+from plateau.io.dask.delayed import delete_dataset__delayed
+from plateau.io.testing.delete import *  # noqa
 
 
 def _delete(*args, **kwargs):
diff --git a/tests/io/dask/delayed/test_gc.py b/tests/io/dask/delayed/test_gc.py
index 02c23fc5..2f639829 100644
--- a/tests/io/dask/delayed/test_gc.py
+++ b/tests/io/dask/delayed/test_gc.py
@@ -3,8 +3,8 @@
 import dask
 import pytest
 
-from kartothek.io.dask.delayed import garbage_collect_dataset__delayed
-from kartothek.io.testing.gc import *  # noqa
+from plateau.io.dask.delayed import garbage_collect_dataset__delayed
+from plateau.io.testing.gc import *  # noqa
 
 
 def _run_garbage_collect(*args, **kwargs):
diff --git a/tests/io/dask/delayed/test_read.py b/tests/io/dask/delayed/test_read.py
index 3ead1b15..4923fd85 100644
--- a/tests/io/dask/delayed/test_read.py
+++ b/tests/io/dask/delayed/test_read.py
@@ -3,8 +3,8 @@
 
 import pytest
 
-from kartothek.io.dask.delayed import read_dataset_as_delayed
-from kartothek.io.testing.read import *  # noqa
+from plateau.io.dask.delayed import read_dataset_as_delayed
+from plateau.io.testing.read import *  # noqa
 
 
 @pytest.fixture(params=["table"])
diff --git a/tests/io/dask/delayed/test_update.py b/tests/io/dask/delayed/test_update.py
index ba4ba7c9..0d7eb331 100644
--- a/tests/io/dask/delayed/test_update.py
+++ b/tests/io/dask/delayed/test_update.py
@@ -3,8 +3,8 @@
 import dask
 import pytest
 
-from kartothek.io.dask.delayed import update_dataset_from_delayed
-from kartothek.io.testing.update import *  # noqa
+from plateau.io.dask.delayed import update_dataset_from_delayed
+from plateau.io.testing.update import *  # noqa
 
 
 @pytest.fixture
diff --git a/tests/io/dask/delayed/test_write.py b/tests/io/dask/delayed/test_write.py
index 8c41c909..db71ffea 100644
--- a/tests/io/dask/delayed/test_write.py
+++ b/tests/io/dask/delayed/test_write.py
@@ -4,9 +4,9 @@
 import dask.bag as db
 import pytest
 
-from kartothek.io.dask.bag import store_bag_as_dataset
-from kartothek.io.dask.delayed import store_delayed_as_dataset
-from kartothek.io.testing.write import *  # noqa
+from plateau.io.dask.bag import store_bag_as_dataset
+from plateau.io.dask.delayed import store_delayed_as_dataset
+from plateau.io.testing.write import *  # noqa
 
 
 def _store_dataframes(execution_mode, df_list, *args, **kwargs):
diff --git a/tests/io/eager/test_commit.py b/tests/io/eager/test_commit.py
index b172751a..5d451b10 100644
--- a/tests/io/eager/test_commit.py
+++ b/tests/io/eager/test_commit.py
@@ -5,9 +5,9 @@
 import pytest
 from pandas.testing import assert_frame_equal
 
-from kartothek.core.common_metadata import make_meta
-from kartothek.core.dataset import DatasetMetadata
-from kartothek.io.eager import (
+from plateau.core.common_metadata import make_meta
+from plateau.core.dataset import DatasetMetadata
+from plateau.io.eager import (
     commit_dataset,
     create_empty_dataset_header,
     read_table,
@@ -86,7 +86,7 @@ def test_commit_dataset_from_metapartition(dataset_function, store):
 def test_commit_dataset_from_nested_metapartition(store):
     """
     Check it is possible to use `commit_dataset` with nested metapartitions as input.
-    Original issue: https://github.com/JDASoftwareGroup/kartothek/issues/40
+    Original issue: https://github.com/JDASoftwareGroup/plateau/issues/40
     """
 
     df = pd.DataFrame({"a": [1, 1, 2, 2], "b": [3, 4, 5, 6]})
diff --git a/tests/io/eager/test_delete.py b/tests/io/eager/test_delete.py
index a2199ac2..a7ea6123 100644
--- a/tests/io/eager/test_delete.py
+++ b/tests/io/eager/test_delete.py
@@ -1,7 +1,7 @@
 import pytest
 
-from kartothek.io.eager import delete_dataset
-from kartothek.io.testing.delete import *  # noqa
+from plateau.io.eager import delete_dataset
+from plateau.io.testing.delete import *  # noqa
 
 
 def _delete_store_factory(dataset_uuid, store_factory):
diff --git a/tests/io/eager/test_gc.py b/tests/io/eager/test_gc.py
index 83ef4d1c..2db864d2 100644
--- a/tests/io/eager/test_gc.py
+++ b/tests/io/eager/test_gc.py
@@ -2,8 +2,8 @@
 
 import pytest
 
-from kartothek.io.eager import garbage_collect_dataset
-from kartothek.io.testing.gc import *  # noqa: F4
+from plateau.io.eager import garbage_collect_dataset
+from plateau.io.testing.gc import *  # noqa: F4
 
 
 @pytest.fixture()
diff --git a/tests/io/eager/test_index.py b/tests/io/eager/test_index.py
index dbc532fe..941ab015 100644
--- a/tests/io/eager/test_index.py
+++ b/tests/io/eager/test_index.py
@@ -2,8 +2,8 @@
 
 import pytest
 
-from kartothek.io.eager import build_dataset_indices
-from kartothek.io.testing.index import *  # noqa: F4
+from plateau.io.eager import build_dataset_indices
+from plateau.io.testing.index import *  # noqa: F4
 
 
 @pytest.fixture()
diff --git a/tests/io/eager/test_read.py b/tests/io/eager/test_read.py
index 72a1d8cc..58e2eba3 100644
--- a/tests/io/eager/test_read.py
+++ b/tests/io/eager/test_read.py
@@ -5,12 +5,12 @@
 import pandas.testing as pdt
 import pytest
 
-from kartothek.io.eager import (
+from plateau.io.eager import (
     read_dataset_as_dataframes,
     read_table,
     store_dataframes_as_dataset,
 )
-from kartothek.io.testing.read import *  # noqa
+from plateau.io.testing.read import *  # noqa
 
 
 @pytest.fixture(
@@ -131,7 +131,7 @@ def test_write_and_read_default_table_name(store_session):
 
 @pytest.mark.parametrize("partition_on", [None, ["A", "B"]])
 def test_read_or_predicates(store_factory, partition_on):
-    # https://github.com/JDASoftwareGroup/kartothek/issues/295
+    # https://github.com/JDASoftwareGroup/plateau/issues/295
     dataset_uuid = "test"
     df = pd.DataFrame({"A": range(10), "B": ["A", "B"] * 5, "C": range(-10, 0)})
 
diff --git a/tests/io/eager/test_update.py b/tests/io/eager/test_update.py
index 77a68c6c..efd81c0a 100644
--- a/tests/io/eager/test_update.py
+++ b/tests/io/eager/test_update.py
@@ -3,13 +3,13 @@
 import pyarrow as pa
 import pytest
 
-from kartothek.io.eager import (
+from plateau.io.eager import (
     commit_dataset,
     create_empty_dataset_header,
     update_dataset_from_dataframes,
     write_single_partition,
 )
-from kartothek.io.testing.update import *  # noqa: F40
+from plateau.io.testing.update import *  # noqa: F40
 
 
 @pytest.fixture()
diff --git a/tests/io/eager/test_write.py b/tests/io/eager/test_write.py
index c9a674cd..de23e7c0 100644
--- a/tests/io/eager/test_write.py
+++ b/tests/io/eager/test_write.py
@@ -5,16 +5,16 @@
 import pandas as pd
 import pytest
 
-from kartothek.core.common_metadata import make_meta, read_schema_metadata
-from kartothek.core.dataset import DatasetMetadata
-from kartothek.core.uuid import gen_uuid
-from kartothek.io.eager import (
+from plateau.core.common_metadata import make_meta, read_schema_metadata
+from plateau.core.dataset import DatasetMetadata
+from plateau.core.uuid import gen_uuid
+from plateau.io.eager import (
     create_empty_dataset_header,
     store_dataframes_as_dataset,
     write_single_partition,
 )
-from kartothek.io.testing.write import *  # noqa: F40
-from kartothek.io_components.metapartition import MetaPartition
+from plateau.io.testing.write import *  # noqa: F40
+from plateau.io_components.metapartition import MetaPartition
 
 
 def _store_dataframes(dfs, **kwargs):
diff --git a/tests/io/iter/test_read.py b/tests/io/iter/test_read.py
index ccf6f804..98baef1c 100644
--- a/tests/io/iter/test_read.py
+++ b/tests/io/iter/test_read.py
@@ -2,11 +2,11 @@
 
 import pytest
 
-from kartothek.io.iter import (
+from plateau.io.iter import (
     read_dataset_as_dataframes__iterator,
     read_dataset_as_metapartitions__iterator,
 )
-from kartothek.io.testing.read import *  # noqa
+from plateau.io.testing.read import *  # noqa
 
 
 @pytest.fixture(params=["dataframe"])
diff --git a/tests/io/iter/test_update.py b/tests/io/iter/test_update.py
index 0f0e56ad..3f5ce21d 100644
--- a/tests/io/iter/test_update.py
+++ b/tests/io/iter/test_update.py
@@ -3,8 +3,8 @@
 import pandas as pd
 import pytest
 
-from kartothek.io.iter import update_dataset_from_dataframes__iter
-from kartothek.io.testing.update import *  # noqa
+from plateau.io.iter import update_dataset_from_dataframes__iter
+from plateau.io.testing.update import *  # noqa
 
 
 @pytest.fixture()
diff --git a/tests/io/iter/test_write.py b/tests/io/iter/test_write.py
index 71061737..0fb5c36c 100644
--- a/tests/io/iter/test_write.py
+++ b/tests/io/iter/test_write.py
@@ -2,8 +2,8 @@
 
 import pytest
 
-from kartothek.io.iter import store_dataframes_as_dataset__iter
-from kartothek.io.testing.write import *  # noqa
+from plateau.io.iter import store_dataframes_as_dataset__iter
+from plateau.io.testing.write import *  # noqa
 
 
 def _store_dataframes(df_list, *args, **kwargs):
diff --git a/tests/io_components/test_dataset.py b/tests/io_components/test_dataset.py
index 3975f9f1..a5dc1851 100644
--- a/tests/io_components/test_dataset.py
+++ b/tests/io_components/test_dataset.py
@@ -8,8 +8,8 @@
 import pandas as pd
 import pandas.testing as pdt
 
-from kartothek.core.dataset import DatasetMetadata
-from kartothek.core.index import ExplicitSecondaryIndex
+from plateau.core.dataset import DatasetMetadata
+from plateau.core.index import ExplicitSecondaryIndex
 
 
 def test_dataset_get_indices_as_dataframe_partition_keys_only(
diff --git a/tests/io_components/test_dataset_metadata_factory.py b/tests/io_components/test_dataset_metadata_factory.py
index 2d7c57b8..3b546eb4 100644
--- a/tests/io_components/test_dataset_metadata_factory.py
+++ b/tests/io_components/test_dataset_metadata_factory.py
@@ -5,7 +5,7 @@
 import pytest
 from simplekv import KeyValueStore
 
-from kartothek.core.factory import DatasetFactory
+from plateau.core.factory import DatasetFactory
 
 
 class CountStore(KeyValueStore):
diff --git a/tests/io_components/test_metapartition.py b/tests/io_components/test_metapartition.py
index 0d552132..0653ba41 100644
--- a/tests/io_components/test_metapartition.py
+++ b/tests/io_components/test_metapartition.py
@@ -6,18 +6,18 @@
 import pandas.testing as pdt
 import pytest
 
-from kartothek.core.common_metadata import make_meta, store_schema_metadata
-from kartothek.core.index import ExplicitSecondaryIndex
-from kartothek.core.naming import DEFAULT_METADATA_VERSION
-from kartothek.core.testing import get_dataframe_not_nested
-from kartothek.io_components.metapartition import (
+from plateau.core.common_metadata import make_meta, store_schema_metadata
+from plateau.core.index import ExplicitSecondaryIndex
+from plateau.core.naming import DEFAULT_METADATA_VERSION
+from plateau.core.testing import get_dataframe_not_nested
+from plateau.io_components.metapartition import (
     SINGLE_TABLE,
     MetaPartition,
     _unique_label,
     parse_input_to_metapartition,
     partition_labels_from_mps,
 )
-from kartothek.serialization import DataFrameSerializer, ParquetSerializer
+from plateau.serialization import DataFrameSerializer, ParquetSerializer
 
 
 def test_store_single_dataframe_as_partition(store, metadata_version):
diff --git a/tests/io_components/test_read.py b/tests/io_components/test_read.py
index a33a1a61..e7fd9bce 100644
--- a/tests/io_components/test_read.py
+++ b/tests/io_components/test_read.py
@@ -5,9 +5,9 @@
 import pandas as pd
 import pytest
 
-from kartothek.io.eager import store_dataframes_as_dataset
-from kartothek.io_components.metapartition import SINGLE_TABLE, MetaPartition
-from kartothek.io_components.read import dispatch_metapartitions
+from plateau.io.eager import store_dataframes_as_dataset
+from plateau.io_components.metapartition import SINGLE_TABLE, MetaPartition
+from plateau.io_components.read import dispatch_metapartitions
 
 
 def test_dispatch_metapartitions(dataset, store_session):
diff --git a/tests/io_components/test_utils.py b/tests/io_components/test_utils.py
index f17fc5b6..22095e83 100644
--- a/tests/io_components/test_utils.py
+++ b/tests/io_components/test_utils.py
@@ -8,7 +8,7 @@
 import pytest
 from storefact import get_store_from_url
 
-from kartothek.io_components.utils import (
+from plateau.io_components.utils import (
     align_categories,
     combine_metadata,
     extract_duplicates,
diff --git a/tests/io_components/test_write.py b/tests/io_components/test_write.py
index 86086405..29d62a2d 100644
--- a/tests/io_components/test_write.py
+++ b/tests/io_components/test_write.py
@@ -5,11 +5,11 @@
 import pandas as pd
 import pytest
 
-from kartothek.core.dataset import DatasetMetadata
-from kartothek.core.index import ExplicitSecondaryIndex
-from kartothek.core.testing import TIME_TO_FREEZE_ISO
-from kartothek.io_components.metapartition import MetaPartition
-from kartothek.io_components.write import (
+from plateau.core.dataset import DatasetMetadata
+from plateau.core.index import ExplicitSecondaryIndex
+from plateau.core.testing import TIME_TO_FREEZE_ISO
+from plateau.io_components.metapartition import MetaPartition
+from plateau.io_components.write import (
     raise_if_dataset_exists,
     store_dataset_from_partitions,
 )
diff --git a/tests/serialization/conftest.py b/tests/serialization/conftest.py
index 155c0bb9..1a10f2e2 100644
--- a/tests/serialization/conftest.py
+++ b/tests/serialization/conftest.py
@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from kartothek.serialization.testing import BINARY_COLUMNS, get_dataframe_not_nested
+from plateau.serialization.testing import BINARY_COLUMNS, get_dataframe_not_nested
 
 
 class FakeStore:
diff --git a/tests/serialization/test_arrow_compat.py b/tests/serialization/test_arrow_compat.py
index e9bf7714..05a6a47b 100644
--- a/tests/serialization/test_arrow_compat.py
+++ b/tests/serialization/test_arrow_compat.py
@@ -8,8 +8,8 @@
 import pytest
 from storefact import get_store_from_url
 
-from kartothek.core.testing import get_dataframe_alltypes
-from kartothek.serialization import ParquetSerializer
+from plateau.core.testing import get_dataframe_alltypes
+from plateau.serialization import ParquetSerializer
 
 KNOWN_ARROW_VERSIONS = [
     "0.12.1",
@@ -61,7 +61,7 @@ def test_arrow_compat(arrow_version, reference_store, mocker):
     executing `generate_reference.py` or `batch_generate_reference.sh`.
     """
 
-    uuid_hook = mocker.patch("kartothek.core.uuid._uuid_hook_object")
+    uuid_hook = mocker.patch("plateau.core.uuid._uuid_hook_object")
     uuid_hook.return_value = uuid.UUID(
         bytes=b"\x82\xd6\xc1\x06Z\x08\x11\xe9\x85eJ\x00\x07\xf8\n\x10"
     )
diff --git a/tests/serialization/test_classes.py b/tests/serialization/test_classes.py
index 7e3f9ccf..fff90286 100644
--- a/tests/serialization/test_classes.py
+++ b/tests/serialization/test_classes.py
@@ -1,6 +1,6 @@
 import pytest
 
-from kartothek.serialization import CsvSerializer, ParquetSerializer
+from plateau.serialization import CsvSerializer, ParquetSerializer
 
 
 @pytest.mark.parametrize(
diff --git a/tests/serialization/test_dataframe.py b/tests/serialization/test_dataframe.py
index ed45953e..422c75ea 100644
--- a/tests/serialization/test_dataframe.py
+++ b/tests/serialization/test_dataframe.py
@@ -11,13 +11,13 @@
 import pytest
 from pyarrow.parquet import ParquetFile
 
-from kartothek.serialization import (
+from plateau.serialization import (
     CsvSerializer,
     DataFrameSerializer,
     ParquetSerializer,
     default_serializer,
 )
-from kartothek.serialization._util import ensure_unicode_string_type
+from plateau.serialization._util import ensure_unicode_string_type
 
 TYPE_STABLE_SERIALISERS = [ParquetSerializer()]
 
diff --git a/tests/serialization/test_filter.py b/tests/serialization/test_filter.py
index 21a8b14a..ac9fd996 100644
--- a/tests/serialization/test_filter.py
+++ b/tests/serialization/test_filter.py
@@ -5,7 +5,7 @@
 import pytest
 from pandas import testing as pdt
 
-from kartothek.serialization import filter_array_like, filter_df_from_predicates
+from plateau.serialization import filter_array_like, filter_df_from_predicates
 
 
 @pytest.fixture(
diff --git a/tests/serialization/test_io_buffer.py b/tests/serialization/test_io_buffer.py
index 35cae6f7..d45ee92f 100644
--- a/tests/serialization/test_io_buffer.py
+++ b/tests/serialization/test_io_buffer.py
@@ -2,7 +2,7 @@
 
 import pytest
 
-from kartothek.serialization._io_buffer import BlockBuffer
+from plateau.serialization._io_buffer import BlockBuffer
 
 
 class _ReadRecordWrapper:
diff --git a/tests/serialization/test_parquet.py b/tests/serialization/test_parquet.py
index 9977fc83..f3f07681 100644
--- a/tests/serialization/test_parquet.py
+++ b/tests/serialization/test_parquet.py
@@ -9,14 +9,14 @@
 import storefact
 from pyarrow.parquet import ParquetFile
 
-from kartothek.serialization import DataFrameSerializer, ParquetSerializer
-from kartothek.serialization._parquet import (
+from plateau.serialization import DataFrameSerializer, ParquetSerializer
+from plateau.serialization._parquet import (
     MAX_NB_RETRIES,
     ParquetReadError,
     _predicate_accepts,
     _reset_dictionary_columns,
 )
-from kartothek.serialization._util import _check_contains_null
+from plateau.serialization._util import _check_contains_null
 
 
 @pytest.fixture
@@ -46,7 +46,7 @@ def chunk_size(request, mocker):
         # Test for a chunk size of one and mock the filter_df call. This way we can ensure that
         # the predicate for IO is properly evaluated and pushed down
         mocker.patch(
-            "kartothek.serialization._parquet.filter_df",
+            "plateau.serialization._parquet.filter_df",
             new=lambda x, *args, **kwargs: x,
         )
     return chunk_size
@@ -465,7 +465,7 @@ def test_reset_dict_cols(store):
 
 def test_retry_on_IOError(monkeypatch, caplog, store):
     """
-    See https://github.com/JDASoftwareGroup/kartothek/issues/407 :
+    See https://github.com/JDASoftwareGroup/plateau/issues/407 :
     We are testing a retry-workaround for the above issue here. Once the issue is resolved,
     this test and the workaround can be removed.
     """
@@ -496,7 +496,7 @@ def patched__restore_dataframe(**kwargs):
 
 def test_retries_on_IOError_logs(monkeypatch, caplog, store):
     """
-    See https://github.com/JDASoftwareGroup/kartothek/issues/407 :
+    See https://github.com/JDASoftwareGroup/plateau/issues/407 :
     We are testing a retry-workaround for the above issue here. Once the issue is resolved,
     this test and the workaround can be removed.
     """
@@ -522,7 +522,7 @@ def patched__restore_dataframe(**kwargs):
 
 def test_retry_fail_on_other_error(monkeypatch, caplog, store):
     """
-    See https://github.com/JDASoftwareGroup/kartothek/issues/407 :
+    See https://github.com/JDASoftwareGroup/plateau/issues/407 :
     We are testing a retry-workaround for the above issue here. Once the issue is resolved,
     this test and the workaround can be removed.
 
diff --git a/tests/serialization/test_util.py b/tests/serialization/test_util.py
index 919ab90a..e4dd80bf 100644
--- a/tests/serialization/test_util.py
+++ b/tests/serialization/test_util.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 import pytest
 
-from kartothek.serialization._util import ensure_unicode_string_type
+from plateau.serialization._util import ensure_unicode_string_type
 
 
 @pytest.mark.parametrize(
diff --git a/tests/test_docs.py b/tests/test_docs.py
index accfc246..8dc95fab 100644
--- a/tests/test_docs.py
+++ b/tests/test_docs.py
@@ -11,7 +11,7 @@ def test_docs_use_api():
         with open(file_) as fd:
             content = fd.read()
 
-        pattern = r"(from|import) kartothek\.(?!(api))"
+        pattern = r"(from|import) plateau\.(?!(api))"
         import re
 
         if re.search(pattern, content):
diff --git a/tests/utils/test_converters.py b/tests/utils/test_converters.py
index 2744e303..c1b3536d 100644
--- a/tests/utils/test_converters.py
+++ b/tests/utils/test_converters.py
@@ -2,7 +2,7 @@
 import pyarrow as pa
 import pytest
 
-from kartothek.utils.converters import (
+from plateau.utils.converters import (
     converter_str,
     converter_str_set,
     converter_str_set_optional,
diff --git a/tests/utils/test_pandas.py b/tests/utils/test_pandas.py
index bb8927bb..86d95a17 100644
--- a/tests/utils/test_pandas.py
+++ b/tests/utils/test_pandas.py
@@ -4,7 +4,7 @@
 import pandas.testing as pdt
 import pytest
 
-from kartothek.utils.pandas import (
+from plateau.utils.pandas import (
     aggregate_to_lists,
     concat_dataframes,
     drop_sorted_duplicates_keep_last,
diff --git a/tests/utils/test_store.py b/tests/utils/test_store.py
index a6c90aa9..ed1c7253 100644
--- a/tests/utils/test_store.py
+++ b/tests/utils/test_store.py
@@ -5,7 +5,7 @@
 import pytest
 import storefact
 
-from kartothek.utils.store import (
+from plateau.utils.store import (
     _azure_bbs_content_md5,
     _azure_cc_content_md5,
     _has_azure_bbs,