Merge pull request #170 from curveresearch/pylint

Pylint

curvesim/__main__.py

@@ -31,11 +31,10 @@ def _python_info():
     str:
         Implementation name, version, and platform
     """
-    return "{} {} on {}".format(
-        platform.python_implementation(),
-        platform.python_version(),
-        platform.system(),
-    )
+    impl = platform.python_implementation()
+    version = platform.python_version()
+    system = platform.system()
+    return f"{impl} {version} on {system}"
 
 
 if __name__ == "__main__":

curvesim/iterators/param_samplers/parameterized_pool_iterator.py

@@ -14,6 +14,7 @@ class ParameterizedPoolIterator(ParameterSampler):
     Iterates over pools with all possible combinations of the input parameters.
     """
 
+    # pylint: disable-next=unused-argument
     def __new__(cls, pool, variable_params, fixed_params=None, pool_map=None):
         """
         Returns a pool-specific ParameterizedPoolIterator subclass.
@@ -46,6 +47,7 @@ def __new__(cls, pool, variable_params, fixed_params=None, pool_map=None):
 
         return super().__new__(subclass)
 
+    # pylint: disable-next=unused-argument
     def __init__(self, pool, variable_params, fixed_params=None, pool_map=None):
         """
         Parameters
@@ -144,21 +146,24 @@ def _pool_type(self):
 
 class ParameterizedCurvePoolIterator(CurvePoolMixin, ParameterizedPoolIterator):
     """
-    :class:`ParameterizedPoolIterator` parameter sampler specialized for Curve pools.
+    :class:`ParameterizedPoolIterator` parameter sampler specialized
+    for Curve pools.
     """
 
 
 class ParameterizedCurveMetaPoolIterator(CurveMetaPoolMixin, ParameterizedPoolIterator):
     """
-    :class:`ParameterizedPoolIterator` parameter sampler specialized for Curve meta-pools.
+    :class:`ParameterizedPoolIterator` parameter sampler specialized
+    for Curve meta-pools.
     """
 
 
 class ParameterizedCurveCryptoPoolIterator(
     CurveCryptoPoolMixin, ParameterizedPoolIterator
 ):
     """
-    :class:`ParameterizedPoolIterator` parameter sampler specialized for Curve crypto pools.
+    :class:`ParameterizedPoolIterator` parameter sampler specialized
+    for Curve crypto pools.
     """
 
 

curvesim/iterators/param_samplers/pool_mixins.py

@@ -1,4 +1,11 @@
-from curvesim.pool.sim_interface import SimCurvePool, SimCurveMetaPool
+"""
+These mixins extend Curve pool classes for the purpose of generating iterables
+of pool instances configured by different simulation parameters.
+
+Each mixin defines a different pool type and a set of special attribute setters.
+"""
+
+from curvesim.pool.sim_interface import SimCurveMetaPool, SimCurvePool
 
 
 class CurvePoolMixin:
@@ -13,6 +20,12 @@ def _pool_type(self):
 
     @property
     def setters(self):
+        """
+        Returns
+        -------
+        dict
+            A dictionary containing the special setters for the pool parameters.
+        """
         return {"D": stableswap_D_to_balances}
 
 
@@ -28,6 +41,12 @@ def _pool_type(self):
 
     @property
     def setters(self):
+        """
+        Returns
+        -------
+        dict
+            A dictionary containing the special setters for the pool parameters.
+        """
         return {"D": stableswap_D_to_balances, "D_base": stableswap_D_base_to_balances}
 
 
@@ -43,23 +62,59 @@ def _pool_type(self):
 
     @property
     def setters(self):
+        """
+        Returns
+        -------
+        dict
+            A dictionary containing the special setters for the pool parameters.
+        """
         return {"D": cryptoswap_D_to_balances}
 
 
 def stableswap_D_to_balances(pool, D):
+    """
+    Sets the balance for each token in the pool based on the provided
+    invariant value.
+
+    Parameters
+    ----------
+    pool : instance of _pool_type
+    D : int
+        The invariant value.
+    """
     rates = pool.rates
     n = pool.n
     pool.balances = [D // n * 10**18 // r for r in rates]
 
 
 def stableswap_D_base_to_balances(pool, D_base):
+    """
+    Sets the balance for each token in the basepool based on the provided
+    invariant value.
+
+    Parameters
+    ----------
+    pool : instance of _pool_type
+    D_base : int
+        The invariant value for the basepool.
+    """
     basepool = pool.basepool
     rates = basepool.rates
     n = basepool.n
     basepool.balances = [D_base // n * 10**18 // r for r in rates]
 
 
 def cryptoswap_D_to_balances(pool, D):
+    """
+    Sets the balance for each token in the pool based on the provided
+    invariant value.
+
+    Parameters
+    ----------
+    pool : instance of _pool_type
+    D : int
+        The invariant value.
+    """
     n = pool.n
     price_scale = pool.price_scale
     precisions = pool.precisions

curvesim/iterators/price_samplers/price_volume.py

@@ -27,7 +27,15 @@ class PriceVolume(PriceSampler):
     An iterator that retrieves price/volume and iterates over timepoints in the data.
     """
 
-    def __init__(self, assets, days=60, data_dir="data", src="coingecko", end=None):
+    def __init__(
+        self,
+        assets,
+        *,
+        days=60,
+        data_dir="data",
+        src="coingecko",
+        end=None,
+    ):
         """
         Retrieves price/volume data and prepares it for iteration.
 

curvesim/metrics/metrics.py

@@ -84,8 +84,10 @@ def config(self):
     def __init__(self, pool, **kwargs):
         super().__init__(pool.assets.symbols)
 
-    def compute_arb_metrics(self, price_sample, trade_data, **kwargs):
+    def compute_arb_metrics(self, **kwargs):
         """Computes all metrics for each timestamp in an individual run."""
+        price_sample = kwargs["price_sample"]
+        trade_data = kwargs["trade_data"]
 
         prices = DataFrame(price_sample.prices.to_list(), index=price_sample.index)
 
@@ -104,7 +106,6 @@ def _compute_profits(self, price_df, trade_df):
         Computes arbitrageur profits and pool fees for a single row of data (i.e.,
         a single timestamp) in units of the chosen numeraire, `self.numeraire`.
         """
-        get_price = self.get_market_price
         numeraire = self.numeraire
 
         profit = []
@@ -115,14 +116,16 @@ def _compute_profits(self, price_df, trade_df):
             pool_profit = 0
 
             for trade in trade_row:
-                market_price = get_price(trade.coin_in, trade.coin_out, prices)
+                market_price = self.get_market_price(
+                    trade.coin_in, trade.coin_out, prices
+                )
                 arb = trade.amount_out - trade.amount_in * market_price
                 fee = trade.fee
 
                 if trade.coin_out != numeraire:
-                    price = get_price(trade.coin_out, numeraire, prices)
-                    arb = arb * price
-                    fee = fee * price
+                    price = self.get_market_price(trade.coin_out, numeraire, prices)
+                    arb *= price
+                    fee *= price
 
                 arb_profit += arb
                 pool_profit += fee
@@ -177,21 +180,23 @@ def pool_config(self):
 
         return config
 
-    def get_stableswap_pool_volume(self, trade_data, **kwargs):
+    def get_stableswap_pool_volume(self, **kwargs):
         """
         Records trade volume for stableswap non-meta-pools.
         """
+        trade_data = kwargs["trade_data"]
 
         def per_timestamp_function(trades):
-            return sum([trade.amount_in for trade in trades]) / 10**18
+            return sum(trade.amount_in for trade in trades) / 10**18
 
         return self._get_volume(trade_data, per_timestamp_function)
 
-    def get_stableswap_metapool_volume(self, trade_data, **kwargs):
+    def get_stableswap_metapool_volume(self, **kwargs):
         """
         Records trade volume for stableswap meta-pools. Only includes trades involving
         the meta-asset (basepool-only trades are ignored).
         """
+        trade_data = kwargs["trade_data"]
 
         meta_asset = self._pool.assets.symbols[0]
 
@@ -255,11 +260,12 @@ def pool_config(self):
             [SimCurveMetaPool, SimCurvePool, SimCurveRaiPool], ss_config
         )
 
-    def get_stableswap_balance(self, pool_state, **kwargs):
+    def get_stableswap_balance(self, **kwargs):
         """
         Computes pool balance metrics for each timestamp in an individual run.
         Used for any stableswap pool.
         """
+        pool_state = kwargs["pool_state"]
         balance = pool_state.apply(self._compute_stableswap_balance, axis=1)
         return DataFrame(balance, columns=["pool_balance"])
 
@@ -271,7 +277,7 @@ def _compute_stableswap_balance(self, pool_state_row):
         self.set_pool_state(pool_state_row)
         pool = self._pool
 
-        xp = array(pool._xp())
+        xp = array(pool._xp())  # pylint: disable=protected-access
         n = pool.n
         bal = 1 - sum(abs(xp / sum(xp) - 1 / n)) / (2 * (n - 1) / n)
 
@@ -344,11 +350,14 @@ def pool_config(self):
             },
         }
 
-    def get_stableswap_pool_value(self, pool_state, price_sample, **kwargs):
+    def get_stableswap_pool_value(self, **kwargs):
         """
         Computes all metrics for each timestamp in an individual run.
         Used for non-meta stableswap pools.
         """
+        pool_state = kwargs["pool_state"]
+        price_sample = kwargs["price_sample"]
+
         reserves = DataFrame(
             pool_state.balances.to_list(),
             index=pool_state.index,
@@ -366,11 +375,14 @@ def get_stableswap_pool_value(self, pool_state, price_sample, **kwargs):
         results.columns = list(self.config["plot"]["metrics"])
         return results.astype("float64")
 
-    def get_stableswap_metapool_value(self, pool_state, price_sample, **kwargs):
+    def get_stableswap_metapool_value(self, **kwargs):
         """
         Computes all metrics for each timestamp in an individual run.
         Used for stableswap metapools.
         """
+        pool_state = kwargs["pool_state"]
+        price_sample = kwargs["price_sample"]
+
         max_coin = self._pool.max_coin
         pool = self._pool
 
@@ -471,13 +483,15 @@ def pool_config(self):
 
     def __init__(self, pool, factor=10**8, **kwargs):
         self._factor = factor
-        super().__init__(pool)
+        super().__init__(pool, **kwargs)
 
-    def get_curve_LD(self, pool_state, **kwargs):
+    def get_curve_LD(self, **kwargs):
         """
         Computes liquidity density for each timestamp in an individual run.
         Used for all Curve pools.
         """
+        pool_state = kwargs["pool_state"]
+
         coin_pairs = get_pairs(
             self._pool.coin_names
         )  # for metapool, uses only meta assets
@@ -538,5 +552,6 @@ class Timestamp(Metric):
     def config(self):
         return {"functions": {"metrics": self._get_timestamp}}
 
-    def _get_timestamp(self, price_sample, **kwargs):
+    def _get_timestamp(self, **kwargs):
+        price_sample = kwargs["price_sample"]
         return DataFrame(price_sample.timestamp)

curvesim/metrics/results/make_results.py

@@ -16,7 +16,13 @@ def make_results(data_per_run, data_per_trade, summary_data, metrics):
     factors = get_factors(data_per_run)
     plot_config = combine_plot_configs(metrics)
 
-    return SimResults(data_per_run, data_per_trade, summary_data, factors, plot_config)
+    return SimResults(
+        data_per_run=data_per_run,
+        data_per_trade=data_per_trade,
+        summary_data=summary_data,
+        factors=factors,
+        plot_config=plot_config,
+    )
 
 
 def combine_plot_configs(metrics):

curvesim/metrics/results/sim_results.py

@@ -19,6 +19,7 @@ class SimResults:
 
     def __init__(
         self,
+        *,
         data_per_run,
         data_per_trade,
         summary_data,