Fix dataset chunking.

enstools/encoding/dataset_encoding.py

+import chunk
 import os
 from copy import deepcopy
 from pathlib import Path

enstools/encoding/variable_encoding.py

+from abc import ABC
 
 from .definitions import lossy_compressors_and_modes
 import logging
 
-from typing import Mapping, Union
+from typing import Mapping, Union, Protocol
 
 import hdf5plugin
 
@@ -21,7 +22,6 @@ class _Mapping(Mapping):
     """
     Subclass to implement dunder methods that are mandatory for Mapping to avoid repeating the code everywhere.
     """
-
     def __init__(self) -> None:
         super().__init__()
         self._kwargs = {}
@@ -55,19 +55,6 @@ class Encoding(_Mapping):
     def __repr__(self):
         return f"{self.__class__.__name__}({self.to_string()})"
 
-    def set_chunk_sizes(self, chunk_sizes: tuple) -> None:
-        """
-        Method to add chunksizes into the encoding dictionary.
-        Parameters
-        ----------
-        chunk_sizes
-
-        Returns
-        -------
-
-        """
-        self._kwargs["chunksizes"] = chunk_sizes
-
 
 class VariableEncoding(_Mapping):
     """
@@ -97,7 +84,6 @@ class VariableEncoding(_Mapping):
     >>> VariableEncoding(backend="snappy", compression_level=9)
 
     """
-
     def __new__(cls,
                 specification: str = None,
                 compressor: str = None,
@@ -131,14 +117,12 @@ class NullEncoding(Encoding):
 
 class LosslessEncoding(Encoding):
     def __init__(self, backend: str, compression_level: int):
-        super().__init__()
         self.backend = backend if backend is not None else rules.LOSSLESS_DEFAULT_BACKEND
         self.compression_level = compression_level if compression_level is not None \
             else rules.LOSSLESS_DEFAULT_COMPRESSION_LEVEL
 
         self.check_validity()
-        # Trying to convert it to a dictionary already here.
-        self._kwargs = dict(self.encoding())
+        self._kwargs = self.encoding()
 
     def check_validity(self) -> bool:
         if self.backend not in definitions.lossless_backends:
@@ -164,16 +148,13 @@ class LosslessEncoding(Encoding):
 
 class LossyEncoding(Encoding):
     def __init__(self, compressor: str, mode: str, parameter: Union[float, int]):
-        super().__init__()
         self.compressor = compressor
         self.mode = mode
 
         self.parameter = parameter
 
         self.check_validity()
-
-        # Trying to convert it to a dictionary already here.
-        self._kwargs = dict(self.encoding())
+        self._kwargs = self.encoding()
 
     def check_validity(self):
         # Check compressor validity
@@ -265,6 +246,48 @@ def parse_variable_specification(var_spec: str) -> Encoding:
         raise InvalidCompressionSpecification(f"Invalid specification {var_spec!r}")
 
 
+# class VariableEncoding(_Mapping):
+#     """
+#     Class to encapsulate compression specification parameters for a single variable.
+#
+#     It stores the compressor, the mode and the parameter.
+#
+#     It has a method to create a new instance from a specification string,
+#     a method to get the corresponding specification string from an existing object
+#     and a method to obtain the corresponding mapping expected by h5py.
+#
+#     """
+#
+#     def __init__(self, specification: Specification):
+#         # Init basic components
+#         self.specification = specification
+#
+#         self._kwargs = self.filter_mapping()
+#
+#     @staticmethod
+#     def from_string(string: str) -> 'VariableEncoding':
+#         specification = parse_variable_specification(string)
+#         """
+#         Method to create a specification object from a specification string
+#         """
+#         return VariableEncoding(specification)
+#
+#     def to_string(self) -> str:
+#         """
+#         Method to obtain a specification string from a specification object
+#         """
+#         return self.specification.to_string()
+#
+#     def filter_mapping(self) -> Mapping:
+#         """
+#         Method to get the corresponding FilterRefBase expected by h5py/xarray
+#         """
+#
+#         return self.specification.encoding()
+#
+#     def description(self):
+#         self.specification.description()
+
 def get_variable_encoding(
         specification: str = None,
         compressor: str = None,