Remove filter_input function

Author: tsmbland

src/muse/agents/agent.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
 from typing import Callable
 
 import xarray as xr
@@ -65,18 +64,15 @@ def __init__(
     def filter_input(
         self,
         dataset: xr.Dataset | xr.DataArray,
-        year: Sequence[int] | int | None = None,
         **kwargs,
     ) -> xr.Dataset | xr.DataArray:
         """Filter inputs for usage in agent.
 
         For instance, filters down to agent's region, etc.
         """
-        from muse.utilities import filter_input
-
         if "region" in dataset.dims and "region" not in kwargs:
             kwargs["region"] = self.region
-        return filter_input(dataset, year=year, **kwargs)
+        return dataset.sel(**kwargs)
 
     @abstractmethod
     def next(

src/muse/constraints.py

@@ -311,8 +311,6 @@ def max_capacity_expansion(
 
             \Gamma_t^{r, i} \geq 0
     """
-    from muse.utilities import filter_input
-
     # case with technology and region in asset dimension
     if capacity.region.dims != ():
         names = [u for u in capacity.asset.coords if capacity[u].dims == ("asset",)]
@@ -335,12 +333,7 @@ def max_capacity_expansion(
     replacement = replacement.drop_vars(
         [u for u in replacement.coords if u not in replacement.dims]
     )
-    techs = filter_input(
-        technologies[
-            ["max_capacity_addition", "max_capacity_growth", "total_capacity_limit"]
-        ],
-        technology=replacement,
-    ).drop_vars("technology")
+    techs = technologies.sel(technology=replacement).drop_vars("technology")
     regions = getattr(capacity, "region", None)
     if regions is not None and "region" in technologies.dims:
         techs = techs.sel(region=regions)

src/muse/costs.py

@@ -54,7 +54,6 @@
 from muse.commodities import is_enduse, is_fuel, is_material, is_pollutant
 from muse.quantities import production_amplitude
 from muse.timeslices import broadcast_timeslice, distribute_timeslice, get_level
-from muse.utilities import filter_input
 
 
 def cost(func):
@@ -113,7 +112,7 @@ def environmental_costs(
     multiplied by their prices.
     """
     environmentals = is_pollutant(technologies.comm_usage)
-    prices_environmental = filter_input(prices, commodity=environmentals)
+    prices_environmental = prices.sel(commodity=environmentals)
     result = (production * prices_environmental).sum("commodity")
     assert "timeslice" in result.dims
     return result
@@ -129,7 +128,7 @@ def fuel_costs(
     multiplied by their prices.
     """
     fuels = is_fuel(technologies.comm_usage)
-    prices_fuel = filter_input(prices, commodity=fuels)
+    prices_fuel = prices.sel(commodity=fuels)
     result = (consumption * prices_fuel).sum("commodity")
     assert "timeslice" in result.dims
     return result
@@ -145,7 +144,7 @@ def material_costs(
     multiplied by their prices.
     """
     material = is_material(technologies.comm_usage)
-    prices_material = filter_input(prices, commodity=material)
+    prices_material = prices.sel(commodity=material)
     result = (consumption * prices_material).sum("commodity")
     assert "timeslice" in result.dims
     return result
@@ -292,7 +291,7 @@ def net_present_value(
 
     # Revenue (annual)
     products = is_enduse(technologies.comm_usage)
-    prices_non_env = filter_input(prices, commodity=products)
+    prices_non_env = prices.sel(commodity=products)
     revenues = (production * prices_non_env).sum("commodity")
     if aggregate_timeslices:
         revenues = revenues.sum("timeslice")

src/muse/quantities.py

@@ -231,15 +231,12 @@ def maximum_production(
         filters and the set of technologies in `capacity`.
     """
     from muse.commodities import is_enduse
-    from muse.utilities import filter_input
 
-    capa = filter_input(
-        capacity, **{k: v for k, v in filters.items() if k in capacity.dims}
+    capa = capacity.sel(**{k: v for k, v in filters.items() if k in capacity.dims})
+    ftechs = technologies.sel(
+        **{k: v for k, v in filters.items() if k in technologies.dims}
     )
 
-    ftechs = filter_input(
-        technologies, **{k: v for k, v in filters.items() if k in technologies.dims}
-    )
     result = (
         broadcast_timeslice(capa, level=timeslice_level)
         * distribute_timeslice(ftechs.fixed_outputs, level=timeslice_level)
@@ -275,14 +272,10 @@ def capacity_in_use(
         Capacity-in-use for each technology, whittled down by the filters.
     """
     from muse.commodities import is_enduse
-    from muse.utilities import filter_input
-
-    prod = filter_input(
-        production, **{k: v for k, v in filters.items() if k in production.dims}
-    )
 
-    ftechs = filter_input(
-        technologies, **{k: v for k, v in filters.items() if k in technologies.dims}
+    prod = production.sel(**{k: v for k, v in filters.items() if k in production.dims})
+    ftechs = technologies.sel(
+        **{k: v for k, v in filters.items() if k in technologies.dims}
     )
 
     factor = 1 / (ftechs.fixed_outputs * ftechs.utilization_factor)
@@ -338,17 +331,14 @@ def minimum_production(
         the filters and the set of technologies in `capacity`.
     """
     from muse.commodities import is_enduse
-    from muse.utilities import filter_input
 
-    capa = filter_input(
-        capacity, **{k: v for k, v in filters.items() if k in capacity.dims}
-    )
+    capa = capacity.sel(**{k: v for k, v in filters.items() if k in capacity.dims})
 
     if "minimum_service_factor" not in technologies:
         return broadcast_timeslice(xr.zeros_like(capa), level=timeslice_level)
 
-    ftechs = filter_input(
-        technologies, **{k: v for k, v in filters.items() if k in technologies.dims}
+    ftechs = technologies.sel(
+        **{k: v for k, v in filters.items() if k in technologies.dims}
     )
     result = (
         broadcast_timeslice(capa, level=timeslice_level)

src/muse/utilities.py

@@ -298,35 +298,9 @@ def clean_assets(assets: xr.Dataset, year: int):
 
 def filter_input(
     dataset: xr.Dataset | xr.DataArray,
-    year: int | Iterable[int] | None = None,
     **kwargs,
 ) -> xr.Dataset | xr.DataArray:
     """Filter inputs, selecting data for the specified year."""
-    if year is None:
-        setyear: set[int] = set()
-    else:
-        try:
-            setyear = {int(year)}  # type: ignore
-        except TypeError:
-            setyear = set(int(u) for u in year)  # type: ignore
-    withyear = (
-        "year" in dataset.dims
-        and year is not None
-        and setyear.issubset(dataset.year.values)
-    )
-    if withyear:
-        kwargs["year"] = year
-        year = None
-    dataset = dataset.sel(**kwargs)
-    if withyear and "year" not in dataset.dims and "year" in dataset.coords:
-        dataset = dataset.drop_vars("year")
-
-    if "year" in dataset.dims and year is not None:
-        dataset = dataset.interp(year=year)
-        if "year" not in dataset.dims and "year" in dataset.coords:
-            dataset = dataset.drop_vars("year")
-        elif "year" in dataset.dims:
-            dataset = dataset.ffill("year")
     return dataset