Enable C4 and apply unsafe-fixes

Author: hoxbro

examples/getting_started/1-Introduction.ipynb

@@ -167,7 +167,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "taxi_dropoffs = {hour:arr for hour, arr in np.load('../assets/hourly_taxi_data.npz').items()}\n",
+    "taxi_dropoffs = dict(np.load('../assets/hourly_taxi_data.npz').items())\n",
     "print('Hours: {hours}'.format(hours=', '.join(taxi_dropoffs.keys())))\n",
     "print(f'Taxi data contains {len(taxi_dropoffs)} arrays (one per hour).\\nDescription of the first array:\\n')\n",
     "np.info(taxi_dropoffs['0'])"

examples/user_guide/15-Large_Data.ipynb

@@ -287,10 +287,10 @@
     "num=10000\n",
     "np.random.seed(1)\n",
     "\n",
-    "dists = {cat: pd.DataFrame(dict([('x',np.random.normal(x,s,num)),\n",
-    "                                 ('y',np.random.normal(y,s,num)),\n",
-    "                                 ('val',val),\n",
-    "                                 ('cat',cat)]))\n",
+    "dists = {cat: pd.DataFrame({'x': np.random.normal(x,s,num),\n",
+    "                            'y': np.random.normal(y,s,num),\n",
+    "                            'val': val,\n",
+    "                            'cat': cat})\n",
     "         for x,  y,  s,  val, cat in\n",
     "         [(  2,  2, 0.03, 10, \"d1\"),\n",
     "          (  2, -2, 0.10, 20, \"d2\"),\n",

examples/user_guide/Colormaps.ipynb

@@ -267,7 +267,7 @@
     "\n",
     "\n",
     "def format_list(l):\n",
-    "    print(' '.join(sorted([k for k in l])))"
+    "    print(' '.join(sorted(l)))"
    ]
   },
   {

holoviews/core/accessors.py

@@ -685,7 +685,7 @@ def info(self, show_defaults=False):
 
     def _holomap_opts(self, *args, clone=None, **kwargs):
         apply_groups, _, _ = util.deprecated_opts_signature(args, kwargs)
-        data = dict([(k, v.opts(*args, **kwargs)) for k, v in self._obj.data.items()])
+        data = {k: v.opts(*args, **kwargs) for k, v in self._obj.data.items()}
 
         # By default do not clone in .opts method
         if apply_groups if clone is None else clone:
@@ -714,7 +714,7 @@ def _dynamicmap_opts(self, *args, **kwargs):
                 obj.callback = self._obj.callback
                 self._obj.callback = dmap.callback
             dmap = self._obj
-            dmap.data = dict([(k, v.opts(*args, **kwargs)) for k, v in self._obj.data.items()])
+            dmap.data = {k: v.opts(*args, **kwargs) for k, v in self._obj.data.items()}
         return dmap
 
     def _base_opts(self, *args, **kwargs):

holoviews/core/data/__init__.py

@@ -1193,10 +1193,10 @@ def transform(self, *args, **kwargs):
         if drop:
             kdims = [ds.get_dimension(d) for d in new_data if d in ds.kdims]
             vdims = [ds.get_dimension(d) or d for d in new_data if d not in ds.kdims]
-            data = dict([(dimension_name(d), values) for d, values in new_data.items()])
+            data = {dimension_name(d): values for d, values in new_data.items()}
             return ds.clone(data, kdims=kdims, vdims=vdims)
         else:
-            new_data = dict([(dimension_name(d), values) for d, values in new_data.items()])
+            new_data = {dimension_name(d): values for d, values in new_data.items()}
             data = ds.interface.assign(ds, new_data)
             data, drop = data if isinstance(data, tuple) else (data, [])
             kdims = [kd for kd in self.kdims if kd.name not in drop]
@@ -1288,7 +1288,7 @@ def columns(self, dimensions=None):
             dimensions = self.dimensions()
         else:
             dimensions = [self.get_dimension(d, strict=True) for d in dimensions]
-        return dict([(d.name, self.dimension_values(d)) for d in dimensions])
+        return {d.name: self.dimension_values(d) for d in dimensions}
 
     @property
     def to(self):

holoviews/core/data/dictionary.py

@@ -44,7 +44,7 @@ def init(cls, eltype, data, kdims, vdims):
         ):
             raise ValueError("DictInterface could not find specified dimensions in the data.")
         elif isinstance(data, tuple):
-            data = {d: v for d, v in zip(dimensions, data, strict=None)}
+            data = dict(zip(dimensions, data, strict=None))
         elif util.is_dataframe(data) and all(d in data for d in dimensions):
             data = {d: data[d] for d in dimensions}
         elif isinstance(data, np.ndarray):
@@ -77,7 +77,7 @@ def init(cls, eltype, data, kdims, vdims):
             isinstance(data, tuple(t for t in interface.types if t is not None))
             for interface in cls.interfaces.values()
         ):
-            data = {k: v for k, v in zip(dimensions, zip(*data, strict=None), strict=None)}
+            data = dict(zip(dimensions, zip(*data, strict=None), strict=None))
         elif (
             isinstance(data, dict)
             and not any(isinstance(v, np.ndarray) for v in data.values())
@@ -240,7 +240,7 @@ def concat(cls, datasets, dimensions, vdims):
 
         template = datasets[0][1]
         dims = dimensions + template.dimensions()
-        return dict([(d.name, np.concatenate(columns[d.name])) for d in dims])
+        return {d.name: np.concatenate(columns[d.name]) for d in dims}
 
     @classmethod
     def mask(cls, dataset, mask, mask_value=np.nan):
@@ -261,12 +261,10 @@ def sort(cls, dataset, by=None, reverse=False):
         else:
             arrays = [dataset.dimension_values(d) for d in by]
             sorting = util.arglexsort(arrays)
-        return dict(
-            [
-                (d, v if isscalar(v) else (v[sorting][::-1] if reverse else v[sorting]))
-                for d, v in dataset.data.items()
-            ]
-        )
+        return {
+            d: v if isscalar(v) else (v[sorting][::-1] if reverse else v[sorting])
+            for d, v in dataset.data.items()
+        }
 
     @classmethod
     def range(cls, dataset, dimension):
@@ -299,7 +297,7 @@ def assign(cls, dataset, new_data):
     @classmethod
     def reindex(cls, dataset, kdims, vdims):
         dimensions = [dataset.get_dimension(d).name for d in kdims + vdims]
-        return dict([(d, dataset.dimension_values(d)) for d in dimensions])
+        return {d: dataset.dimension_values(d) for d in dimensions}
 
     @classmethod
     def groupby(cls, dataset, dimensions, container_type, group_type, **kwargs):
@@ -329,15 +327,12 @@ def groupby(cls, dataset, dimensions, container_type, group_type, **kwargs):
         grouped_data = []
         for unique_key in util.unique_iterator(keys):
             mask = cls.select_mask(dataset, dict(zip(dimensions, unique_key, strict=None)))
-            group_data = dict(
-                (
-                    d.name,
-                    dataset.data[d.name]
-                    if isscalar(dataset.data[d.name])
-                    else dataset.data[d.name][mask],
-                )
+            group_data = {
+                d.name: dataset.data[d.name]
+                if isscalar(dataset.data[d.name])
+                else dataset.data[d.name][mask]
                 for d in kdims + vdims
-            )
+            }
             group_data = group_type(group_data, **group_kwargs)
             grouped_data.append((unique_key, group_data))
 
@@ -389,7 +384,7 @@ def aggregate(cls, dataset, kdims, function, **kwargs):
         kdims = [dataset.get_dimension(d, strict=True).name for d in kdims]
         vdims = dataset.dimensions("value", label="name")
         groups = cls.groupby(dataset, kdims, list, dict)
-        aggregated = dict([(k, []) for k in kdims + vdims])
+        aggregated = {k: [] for k in kdims + vdims}
 
         dropped = []
         for key, group in groups:

holoviews/core/data/grid.py

@@ -57,15 +57,15 @@ def init(cls, eltype, data, kdims, vdims):
                 and len(data[-1].shape) == (ndims + 1)
             ):
                 value_array = data[-1]
-                data = {d: v for d, v in zip(dimensions, data[:-1], strict=None)}
+                data = dict(zip(dimensions, data[:-1], strict=None))
                 data[vdim_tuple] = value_array
             else:
-                data = {d: v for d, v in zip(dimensions, data, strict=None)}
+                data = dict(zip(dimensions, data, strict=None))
         elif isinstance(data, list) and data == []:
             if len(kdims) == 1:
-                data = dict([(d, []) for d in dimensions])
+                data = {d: [] for d in dimensions}
             else:
-                data = dict([(d.name, np.array([])) for d in kdims])
+                data = {d.name: np.array([]) for d in kdims}
                 if len(vdims) == 1:
                     data[vdims[0].name] = np.zeros((0, 0))
                 else:
@@ -74,15 +74,15 @@ def init(cls, eltype, data, kdims, vdims):
             isinstance(data, tuple(t for t in interface.types if t is not None))
             for interface in cls.interfaces.values()
         ):
-            data = {k: v for k, v in zip(dimensions, zip(*data, strict=None), strict=None)}
+            data = dict(zip(dimensions, zip(*data, strict=None), strict=None))
         elif isinstance(data, np.ndarray):
             if data.shape == (0, 0) and len(vdims) == 1:
                 array = data
-                data = dict([(d.name, np.array([])) for d in kdims])
+                data = {d.name: np.array([]) for d in kdims}
                 data[vdims[0].name] = array
             elif data.shape == (0, 0, len(vdims)):
                 array = data
-                data = dict([(d.name, np.array([])) for d in kdims])
+                data = {d.name: np.array([]) for d in kdims}
                 data[vdim_tuple] = array
             else:
                 if data.ndim == 1:

holoviews/core/data/image.py

@@ -217,7 +217,7 @@ def select(cls, dataset, selection_mask=None, **selection):
         coords = tuple(
             selection[kd.name] if kd.name in selection else slice(None) for kd in dataset.kdims
         )
-        if not any([isinstance(el, slice) for el in coords]):
+        if not any(isinstance(el, slice) for el in coords):
             return dataset.data[dataset.sheet2matrixidx(*coords)]
 
         # Apply slices

holoviews/core/data/interface.py

@@ -236,7 +236,7 @@ def initialize(cls, eltype, data, kdims, vdims, datatype=None):
             elif interface.multi and any(
                 cls.interfaces[dt].multi for dt in datatype if dt in cls.interfaces
             ):
-                data = [d for d in data.interface.split(data, None, None, "columns")]
+                data = list(data.interface.split(data, None, None, "columns"))
             elif interface.gridded and any(cls.interfaces[dt].gridded for dt in datatype):
                 new_data = []
                 for kd in data.kdims:

holoviews/core/data/narwhals.py

@@ -335,7 +335,7 @@ def select(cls, dataset, selection_mask=None, **selection):
         df = dataset.data
         only_scalar_selection = True
         if selection_mask is None:
-            column_sel = {k: v for k, v in selection.items()}
+            column_sel = dict(selection.items())
             if column_sel:
                 only_scalar_selection = all(isinstance(v, (str, int)) for v in column_sel.values())
                 selection_mask = cls.select_mask(dataset, column_sel)