PySDM 3.0.0rc20__tar.gz → 3.0.0rc22__tar.gz

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/.github/workflows/precommit.yml

@@ -29,7 +29,7 @@ jobs:
           pip install pre-commit
           pre-commit clean
           pre-commit autoupdate
-          pre-commit run --all-files
+          pre-commit run --all-files --show-diff-on-failure
       - if: ${{ failure() }}
         run: git diff
 

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/.github/workflows/tests.yml

@@ -73,9 +73,7 @@ jobs:
       with:
         python-version: ${{ matrix.python-version }}
         setup-name: nonunit-tests-${{ matrix.platform }}-${{ matrix.python-version }}
-    - run: |
-        # TODO #1160 https://github.com/pylint-dev/pylint/issues/9099
-        pip install "pylint<3.0.0" nbqa
+    - run: pip install pylint nbqa
     - run: |
         # TODO #682
         pylint --unsafe-load-any-extension=y --disable=fixme,invalid-name,missing-function-docstring,missing-class-docstring,protected-access,duplicate-code $(git ls-files '*.py' | grep -v -e ^examples -e ^tutorials)

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/.github/workflows/urlcheck.yml

@@ -11,21 +11,15 @@ on:
 jobs:
   url-check:
     runs-on: ubuntu-24.04
-    continue-on-error: true
     steps:
       - uses: actions/checkout@v4.1.6
       - name: URLs-checker
+        id: urlcheck
         uses: urlstechie/urlchecker-action@master
         with:
-          # A subfolder or path to navigate to in the present or cloned repository
-          # subfolder: docs
-
           # A comma-separated list of file types to cover in the URL checks
           file_types: .md,.py,.json,.ipynb,.yaml,.yml,.jinja2,.toml
 
-          # Choose whether to include file with no URLs in the prints.
-          print_all: false
-
           # Choose whether to print a more verbose end summary with files and broken URLs.
           verbose: true
 
@@ -42,4 +36,4 @@ jobs:
           exclude_patterns: http://purl.org,http://www.w3.org,https://doi.org/10.1175/
 
           # A comma separated list of file patterns (direct paths work as well) to exclude
-          exclude_files: docs/generate_html.py,.github/workflows/precommit.yml
+          exclude_files: docs/generate_html.py,.github/workflows/urlcheck.yml

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/.pre-commit-config.yaml

@@ -4,7 +4,7 @@ default_stages: [pre-commit]
 
 repos:
   - repo: https://github.com/psf/black
-    rev: 25.1.0
+    rev: 26.1.0
     hooks:
       - id: black
 
@@ -14,7 +14,7 @@ repos:
 #      - id: isort
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -28,9 +28,10 @@ repos:
     - id: detect-missing-init
       args: ['--create', "--track", "--python-folders", "tests,PySDM,examples/PySDM_examples"]
 
-  - repo: https://github.com/open-atmos/devops_tests
-    rev: v0.0.2
-    hooks:
-      - id: check-badges
-        name: check badges
-        args: [--fix-header, --repo-name=PySDM]
+  # TODO #1794
+  # - repo: https://github.com/open-atmos/devops_tests
+  #   rev: v0.0.2
+  #   hooks:
+  #     - id: check-badges
+  #       name: check badges
+  #       args: [--fix-header, --repo-name=PySDM]

pysdm-3.0.0rc22/.pylintrc

@@ -0,0 +1,8 @@
+[DESIGN]
+max-positional-arguments=7
+max-args=20
+
+[OPTIONS]
+# TODO #682
+disable=
+    possibly-used-before-assignment #used-before-assignment still active

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/.zenodo.json

@@ -97,10 +97,6 @@
       "affiliation": "California Institute of Technology, Pasadena, CA, USA",
       "name": "Mints, Mikhail"
     },
-    {
-      "affiliation": "AGH University of Krakow, Kraków, Poland",
-      "name": "Magnuszewski, Paweł"
-    },
     {
       "affiliation": "University of Warsaw, Poland",
       "name": "Makulska, Agnieszka"
@@ -136,6 +132,11 @@
       "name": "Ward, Ryan X.",
       "orcid": "0000-0003-2317-3310"
     },
+    {
+      "affiliation": "University of California Davis, Davis, CA, USA",
+      "name": "Ware, Emma C.",
+      "orcid": "0009-0000-6556-9730"
+    },
     {
       "affiliation": "AGH University of Krakow, Kraków, Poland",
       "name": "Wroński, Michał"

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 3.0.0rc20
+Version: 3.0.0rc22
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License-Expression: GPL-3.0-only

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/chemistry_methods.py

@@ -350,7 +350,8 @@ class ChemistryMethods(BackendMethods):
 
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False, "cache": False}})
-    def equilibrate_H_body(  # pylint: disable=too-many-arguments,too-many-locals
+    def equilibrate_H_body(  # pylint: disable=too-many-locals
+        *,
         within_tolerance,
         pH2H,
         H2pH,

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/collisions_methods.py

@@ -42,9 +42,9 @@ def flag_zero_multiplicity(j, k, multiplicity, healthy):
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def coalesce(  # pylint: disable=too-many-arguments
+def coalesce(
     i, j, k, cid, multiplicity, gamma, attributes, coalescence_rate
-):
+):  # pylint: disable=too-many-positional-arguments
     atomic_add(coalescence_rate, cid, gamma[i] * multiplicity[k])
     new_n = multiplicity[j] - gamma[i] * multiplicity[k]
     if new_n > 0:
@@ -62,7 +62,7 @@ def coalesce(  # pylint: disable=too-many-arguments
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
 def compute_transfer_multiplicities(
     gamma, j, k, multiplicity, particle_mass, fragment_mass_i, max_multiplicity
-):  # pylint: disable=too-many-arguments
+):
     overflow_flag = False
     gamma_j_k = 0
     take_from_j_test = multiplicity[k]
@@ -96,7 +96,7 @@ def compute_transfer_multiplicities(
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
 def get_new_multiplicities_and_update_attributes(
     j, k, attributes, multiplicity, take_from_j, new_mult_k
-):  # pylint: disable=too-many-arguments
+):
     for a in range(len(attributes)):
         attributes[a, k] *= multiplicity[k]
         attributes[a, k] += take_from_j * attributes[a, j]
@@ -122,7 +122,7 @@ def round_multiplicities_to_ints_and_update_attributes(
     nk,
     attributes,
     multiplicity,
-):  # pylint: disable=too-many-arguments
+):
     multiplicity[j] = max(round(nj), 1)
     multiplicity[k] = max(round(nk), 1)
     factor_j = nj / multiplicity[j]
@@ -133,7 +133,7 @@ def round_multiplicities_to_ints_and_update_attributes(
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def break_up(  # pylint: disable=too-many-arguments,c,too-many-locals
+def break_up(  # pylint: disable=c,too-many-locals,too-many-positional-arguments
     i,
     j,
     k,
@@ -190,7 +190,7 @@ def break_up_while(
     breakup_rate_deficit,
     warn_overflows,
     particle_mass,
-):  # pylint: disable=too-many-arguments,unused-argument,too-many-locals
+):  # pylint: disable=too-many-locals,too-many-positional-arguments
     gamma_deficit = gamma[i]
     overflow_flag = False
     while gamma_deficit > 0:
@@ -330,7 +330,6 @@ class CollisionsMethods(BackendMethods):
     @cached_property
     def _scale_prob_for_adaptive_sdm_gamma_body(self):
         @numba.njit(**self.default_jit_flags)
-        # pylint: disable=too-many-arguments,too-many-locals
         def body(
             prob,
             idx,
@@ -343,7 +342,7 @@ class CollisionsMethods(BackendMethods):
             is_first_in_pair,
             stats_n_substep,
             stats_dt_min,
-        ):
+        ):  # pylint: disable=too-many-locals,too-many-positional-arguments
             """Modified parameters are: `dt_left[cell_id]`, `prob[pair_id]`,
             `stats_n_substep[cell_id]`, `stats_dt_min[cell_id]`;
             `dt_todo[cell_id]` is a local temporary array of time steps to be taken in each cell,
@@ -522,7 +521,6 @@ class CollisionsMethods(BackendMethods):
     @cached_property
     def _compute_gamma_body(self):
         @numba.njit(**self.default_jit_flags)
-        # pylint: disable=too-many-arguments,too-many-locals
         def body(
             prob,
             rand,
@@ -534,7 +532,7 @@ class CollisionsMethods(BackendMethods):
             collision_rate,
             is_first_in_pair,
             out,
-        ):
+        ):  # pylint: disable=too-many-locals,too-many-positional-arguments
             """
             return in "out" array gamma (see: http://doi.org/10.1002/qj.441, section 5)
             formula:
@@ -633,7 +631,6 @@ class CollisionsMethods(BackendMethods):
     @cached_property
     def _normalize_body(self):
         @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
-        # pylint: disable=too-many-arguments
         def body(prob, cell_id, cell_idx, cell_start, norm_factor, timestep, dv):
             n_cell = cell_start.shape[0] - 1
             for i in range(n_cell):
@@ -649,8 +646,9 @@ class CollisionsMethods(BackendMethods):
 
         return body
 
-    # pylint: disable=too-many-arguments
-    def normalize(self, prob, cell_id, cell_idx, cell_start, norm_factor, timestep, dv):
+    def normalize(
+        self, prob, cell_id, cell_idx, cell_start, norm_factor, timestep, dv
+    ):  # pylint: disable=too-many-positional-arguments
         return self._normalize_body(
             prob.data,
             cell_id.data,
@@ -681,7 +679,6 @@ class CollisionsMethods(BackendMethods):
 
     @staticmethod
     @numba.njit(**conf.JIT_FLAGS)
-    # pylint: disable=too-many-arguments
     def _counting_sort_by_cell_id_and_update_cell_start(
         new_idx, idx, cell_id, cell_idx, length, cell_start
     ):
@@ -698,7 +695,6 @@ class CollisionsMethods(BackendMethods):
 
     @staticmethod
     @numba.njit(**conf.JIT_FLAGS)
-    # pylint: disable=too-many-arguments
     def _parallel_counting_sort_by_cell_id_and_update_cell_start(
         new_idx, idx, cell_id, cell_idx, length, cell_start, cell_start_p
     ):
@@ -743,7 +739,7 @@ class CollisionsMethods(BackendMethods):
     @cached_property
     def _linear_collection_efficiency_body(self):
         @numba.njit(**self.default_jit_flags)
-        # pylint: disable=too-many-arguments,too-many-locals
+        # pylint: disable=too-many-locals
         def body(params, output, radii, is_first_in_pair, idx, length, unit):
             A, B, D1, D2, E1, E2, F1, F2, G1, G2, G3, Mf, Mg = params
             output[:] = 0

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/condensation_methods.py

@@ -255,7 +255,7 @@ class CondensationMethods(BackendMethods):
         calculate_ml_new,
     ):
         @numba.njit(**jit_flags)
-        def step_impl(  # pylint: disable=too-many-arguments,too-many-locals
+        def step_impl(  # pylint: disable=too-many-positional-arguments,too-many-locals
             attributes,
             cell_idx,
             thd,
@@ -377,7 +377,7 @@ class CondensationMethods(BackendMethods):
         RH_rtol,
     ):
         @numba.njit(**jit_flags)
-        def minfun(  # pylint: disable=too-many-arguments,too-many-locals
+        def minfun(  # pylint: disable=too-many-positional-arguments,too-many-locals
             x_new, x_old, timestep, kappa, f_org, rd3, temperature, RH, Fk, Fd
         ):
             """
@@ -407,7 +407,7 @@ class CondensationMethods(BackendMethods):
             )
 
         @numba.njit(**jit_flags)
-        def calculate_ml_new(  # pylint: disable=too-many-branches,too-many-arguments,too-many-locals
+        def calculate_ml_new(  # pylint: disable=too-many-branches,too-many-positional-arguments,too-many-locals
             attributes,
             timestep,
             fake,
@@ -544,9 +544,9 @@ class CondensationMethods(BackendMethods):
                             b,
                             fa,
                             fb,
-                            rtol_x,
-                            max_iters,
-                            formulae.trivia__within_tolerance,
+                            rtol=rtol_x,
+                            max_iter=max_iters,
+                            within_tolerance=formulae.trivia__within_tolerance,
                         )
                         if iters_taken in (-1, max_iters):
                             if not fake:
@@ -643,7 +643,7 @@ class CondensationMethods(BackendMethods):
         step = CondensationMethods.make_step(jit_flags, step_impl)
 
         @numba.njit(**jit_flags)
-        def solve(  # pylint: disable=too-many-arguments,too-many-locals
+        def solve(  # pylint: disable=too-many-positional-arguments,too-many-locals
             attributes,
             cell_idx,
             thd,

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/deposition_methods.py

@@ -8,7 +8,6 @@ import numpy as np
 
 from PySDM.backends.impl_common.backend_methods import BackendMethods
 
-
 # TODO #1524
 # pylint: disable=too-many-arguments,too-many-locals,too-many-statements
 
@@ -125,7 +124,7 @@ class DepositionMethods(BackendMethods):  # pylint:disable=too-few-public-method
             multiplicity,
             sub_time_step,
             mass_of_dry_air,
-        ):
+        ):  # pylint: disable=too-many-positional-arguments
             latent_heat_sub = formulae.latent_heat_sublimation__ls(temperature)
             delta_rv = 0
             for i, ksi in enumerate(multiplicity):

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/displacement_methods.py

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-positional-arguments
 """
 CPU implementation of backend methods for particle displacement (advection and sedimentation)
 """
@@ -12,7 +13,6 @@ from ...impl_common.backend_methods import BackendMethods
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-# pylint: disable=too-many-arguments
 def calculate_displacement_body_common(
     dim, droplet, scheme, _l, _r, displacement, courant, position_in_cell, n_substeps
 ):
@@ -26,7 +26,6 @@ def calculate_displacement_body_common(
 class DisplacementMethods(BackendMethods):
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False, "cache": False}})
-    # pylint: disable=too-many-arguments
     def calculate_displacement_body_1d(
         dim, scheme, displacement, courant, cell_origin, position_in_cell, n_substeps
     ):
@@ -49,7 +48,6 @@ class DisplacementMethods(BackendMethods):
 
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False, "cache": False}})
-    # pylint: disable=too-many-arguments
     def calculate_displacement_body_2d(
         dim, scheme, displacement, courant, cell_origin, position_in_cell, n_substeps
     ):
@@ -78,7 +76,6 @@ class DisplacementMethods(BackendMethods):
 
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False, "cache": False}})
-    # pylint: disable=too-many-arguments
     def calculate_displacement_body_3d(
         dim, scheme, displacement, courant, cell_origin, position_in_cell, n_substeps
     ):
@@ -148,7 +145,6 @@ class DisplacementMethods(BackendMethods):
     @cached_property
     def _flag_precipitated_body(self):
         @numba.njit(**{**self.default_jit_flags, "parallel": False})
-        # pylint: disable=too-many-arguments
         def body(
             cell_origin,
             position_in_cell,
@@ -183,7 +179,6 @@ class DisplacementMethods(BackendMethods):
     @cached_property
     def _flag_out_of_column_body(self):
         @numba.njit(**{**self.default_jit_flags, "parallel": False})
-        # pylint: disable=too-many-arguments
         def body(
             cell_origin, position_in_cell, idx, length, healthy, domain_top_level_index
         ):
@@ -201,7 +196,6 @@ class DisplacementMethods(BackendMethods):
 
         return body
 
-    # pylint: disable=too-many-arguments
     def flag_precipitated(
         self,
         *,
@@ -229,7 +223,6 @@ class DisplacementMethods(BackendMethods):
             displacement.data,
         )
 
-    # pylint: disable=too-many-arguments
     def flag_out_of_column(
         self,
         cell_origin,

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/fragmentation_methods.py

@@ -10,7 +10,7 @@ from PySDM.backends.impl_common.backend_methods import BackendMethods
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def straub_Nr(  # pylint: disable=too-many-arguments,unused-argument
+def straub_Nr(  # pylint: disable=too-many-positional-arguments
     i,
     Nr1,
     Nr2,
@@ -19,7 +19,7 @@ def straub_Nr(  # pylint: disable=too-many-arguments,unused-argument
     Nrt,
     CW,
     gam,
-):  # pylint: disable=too-many-branches`
+):
     if gam[i] * CW[i] >= 7.0:
         Nr1[i] = 0.088 * (gam[i] * CW[i] - 7.0)
     if CW[i] >= 21.0:
@@ -33,7 +33,7 @@ def straub_Nr(  # pylint: disable=too-many-arguments,unused-argument
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def straub_mass_remainder(  # pylint: disable=too-many-arguments,unused-argument
+def straub_mass_remainder(  # pylint: disable=too-many-positional-arguments
     i, vl, ds, mu1, sigma1, mu2, sigma2, mu3, sigma3, d34, Nr1, Nr2, Nr3, Nr4
 ):
     # pylint: disable=too-many-arguments, too-many-locals
@@ -49,7 +49,7 @@ def straub_mass_remainder(  # pylint: disable=too-many-arguments,unused-argument
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def ll82_Nr(  # pylint: disable=too-many-arguments,unused-argument
+def ll82_Nr(
     i,
     Rf,
     Rs,
@@ -120,10 +120,14 @@ class FragmentationMethods(BackendMethods):
         return body
 
     def slams_fragmentation(
-        self, n_fragment, frag_volume, x_plus_y, probs, rand, vmin, nfmax
-    ):  # pylint: disable=too-many-arguments
+        self, *, n_fragment, frag_volume, x_plus_y, probs, rand, vmin, nfmax
+    ):
         self._slams_fragmentation_body(
-            n_fragment.data, frag_volume.data, x_plus_y.data, probs.data, rand.data
+            n_fragment=n_fragment.data,
+            frag_volume=frag_volume.data,
+            x_plus_y=x_plus_y.data,
+            probs=probs.data,
+            rand=rand.data,
         )
         self._fragmentation_limiters_body(
             n_fragment=n_fragment.data,
@@ -324,10 +328,12 @@ class FragmentationMethods(BackendMethods):
 
         @numba.njit(**self.default_jit_flags)
         def body(
-            *, CW, gam, ds, v_max, frag_volume, rand, Nr1, Nr2, Nr3, Nr4, Nrt, d34
-        ):  # pylint: disable=too-many-arguments,too-many-locals
+            CW, gam, ds, v_max, frag_volume, rand, Nr1, Nr2, Nr3, Nr4, Nrt, d34
+        ):  # pylint: disable=too-many-arguments,too-many-locals,too-many-positional-arguments
             for i in numba.prange(len(frag_volume)):  # pylint: disable=not-an-iterable
-                straub_Nr(i, Nr1, Nr2, Nr3, Nr4, Nrt, CW, gam)
+                straub_Nr(
+                    i, Nr1=Nr1, Nr2=Nr2, Nr3=Nr3, Nr4=Nr4, Nrt=Nrt, CW=CW, gam=gam
+                )
                 sigma1 = ff.fragmentation_function__params_sigma1(CW[i])
                 mu1 = ff.fragmentation_function__params_mu1(sigma1)
                 sigma2 = ff.fragmentation_function__params_sigma2(CW[i])
@@ -336,19 +342,19 @@ class FragmentationMethods(BackendMethods):
                 mu3 = ff.fragmentation_function__params_mu3(ds[i])
                 straub_mass_remainder(
                     i,
-                    v_max,
-                    ds,
-                    mu1,
-                    sigma1,
-                    mu2,
-                    sigma2,
-                    mu3,
-                    sigma3,
-                    d34,
-                    Nr1,
-                    Nr2,
-                    Nr3,
-                    Nr4,
+                    vl=v_max,
+                    ds=ds,
+                    mu1=mu1,
+                    sigma1=sigma1,
+                    mu2=mu2,
+                    sigma2=sigma2,
+                    mu3=mu3,
+                    sigma3=sigma3,
+                    d34=d34,
+                    Nr1=Nr1,
+                    Nr2=Nr2,
+                    Nr3=Nr3,
+                    Nr4=Nr4,
                 )
                 Nrt[i] = Nr1[i] + Nr2[i] + Nr3[i] + Nr4[i]
 
@@ -382,8 +388,8 @@ class FragmentationMethods(BackendMethods):
 
         @numba.njit(**self.default_jit_flags)
         def body(
-            *, CKE, W, W2, St, ds, dl, dcoal, frag_volume, rand, Rf, Rs, Rd, tol
-        ):  # pylint: disable=too-many-branches,too-many-locals,too-many-statements
+            CKE, W, W2, St, ds, dl, dcoal, frag_volume, rand, Rf, Rs, Rd, tol
+        ):  # pylint: disable=too-many-branches,too-many-locals,too-many-statements,too-many-positional-arguments
             for i in numba.prange(len(frag_volume)):  # pylint: disable=not-an-iterable
                 if dl[i] <= 0.4e-3:
                     frag_volume[i] = dcoal[i] ** 3 * ff.constants.PI / 6
@@ -392,11 +398,11 @@ class FragmentationMethods(BackendMethods):
                 else:
                     ll82_Nr(i, Rf, Rs, Rd, CKE, W, W2)
                     if rand[i] <= Rf[i]:  # filament breakup
-                        (H1, mu1, sigma1) = ff.fragmentation_function__params_f1(
+                        H1, mu1, sigma1 = ff.fragmentation_function__params_f1(
                             dl[i], dcoal[i]
                         )
-                        (H2, mu2, sigma2) = ff.fragmentation_function__params_f2(ds[i])
-                        (H3, mu3, sigma3) = ff.fragmentation_function__params_f3(
+                        H2, mu2, sigma2 = ff.fragmentation_function__params_f2(ds[i])
+                        H3, mu3, sigma3 = ff.fragmentation_function__params_f3(
                             ds[i], dl[i]
                         )
                         H1 = H1 * mu1
@@ -422,10 +428,10 @@ class FragmentationMethods(BackendMethods):
                             frag_volume[i] = np.exp(lnarg)
 
                     elif rand[i] <= Rf[i] + Rs[i]:  # sheet breakup
-                        (H1, mu1, sigma1) = ff.fragmentation_function__params_s1(
+                        H1, mu1, sigma1 = ff.fragmentation_function__params_s1(
                             dl[i], ds[i], dcoal[i]
                         )
-                        (H2, mu2, sigma2) = ff.fragmentation_function__params_s2(
+                        H2, mu2, sigma2 = ff.fragmentation_function__params_s2(
                             dl[i], ds[i], St[i]
                         )
                         H1 = H1 * mu1
@@ -445,10 +451,10 @@ class FragmentationMethods(BackendMethods):
                             frag_volume[i] = np.exp(lnarg)
 
                     else:  # disk breakup
-                        (H1, mu1, sigma1) = ff.fragmentation_function__params_d1(
+                        H1, mu1, sigma1 = ff.fragmentation_function__params_d1(
                             W[i], dl[i], dcoal[i], CKE[i]
                         )
-                        (H2, mu2, sigma2) = ff.fragmentation_function__params_d2(
+                        H2, mu2, sigma2 = ff.fragmentation_function__params_d2(
                             ds[i], dl[i], CKE[i]
                         )
                         H1 = H1 * mu1
@@ -478,7 +484,7 @@ class FragmentationMethods(BackendMethods):
         ff = self.formulae_flattened
 
         @numba.njit(**self.default_jit_flags)
-        def body(*, mu, sigma, frag_volume, rand):  # pylint: disable=too-many-arguments
+        def body(mu, sigma, frag_volume, rand):  # pylint: disable=too-many-arguments
             for i in numba.prange(len(frag_volume)):  # pylint: disable=not-an-iterable
                 frag_volume[i] = mu + sigma * ff.trivia__erfinv_approx(rand[i])
 
@@ -490,7 +496,7 @@ class FragmentationMethods(BackendMethods):
 
         @numba.njit(**self.default_jit_flags)
         # pylint: disable=too-many-arguments
-        def body(*, scale, frag_volume, x_plus_y, rand, fragtol):
+        def body(scale, frag_volume, x_plus_y, rand, fragtol):
             for i in numba.prange(len(frag_volume)):  # pylint: disable=not-an-iterable
                 frag_volume[i] = ff.fragmentation_function__frag_volume(
                     scale, rand[i], x_plus_y[i], fragtol

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/freezing_methods.py

@@ -130,7 +130,7 @@ class FreezingMethods(BackendMethods):
         )
 
         @numba.njit(**self.default_jit_flags)
-        def body(  # pylint: disable=unused-argument,too-many-arguments
+        def body(  # pylint: disable=unused-argument,too-many-positional-arguments
             rand,
             attributes,
             timestep,

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/methods/seeding_methods.py

@@ -11,7 +11,7 @@ class SeedingMethods(BackendMethods):  # pylint: disable=too-few-public-methods
     @cached_property
     def _seeding(self):
         @numba.njit(**{**self.default_jit_flags, "parallel": False})
-        def body(  # pylint: disable=too-many-arguments
+        def body(  # pylint: disable=too-many-positional-arguments
             idx,
             multiplicity,
             extensive_attributes,

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/test_helpers/scipy_ode_condensation_solver.py

@@ -95,7 +95,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         return np.sum(n * jit_formulae.diffusion_coordinate__mass(x)) / m_d_mean
 
     @numba.njit(**{**JIT_FLAGS, **{"parallel": False}})
-    def _impl(  # pylint: disable=too-many-arguments,too-many-locals
+    def _impl(  # pylint: disable=too-many-positional-arguments,too-many-locals
         dy_dt,
         x,
         T,
@@ -166,7 +166,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         )
 
     @numba.njit(**{**JIT_FLAGS, **{"parallel": False}})
-    def _odesys(  # pylint: disable=too-many-arguments,too-many-locals
+    def _odesys(  # pylint: disable=too-many-positional-arguments,too-many-locals
         t,
         y,
         kappa,
@@ -222,7 +222,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         )
         return dy_dt
 
-    def solve(  # pylint: disable=too-many-arguments,too-many-locals,unused-argument
+    def solve(  # pylint: disable=too-many-positional-arguments,too-many-locals,unused-argument
         attributes,
         cell_idx,
         thd,

{pysdm-3.0.0rc20 → pysdm-3.0.0rc22}/PySDM/backends/impl_numba/toms748.py

@@ -1,4 +1,4 @@
-# pylint: disable=invalid-name,too-many-arguments,too-many-locals,too-many-branches,too-many-statements
+# pylint: disable=invalid-name,too-many-locals,too-many-branches,too-many-statements
 """
 Numba-based TOM 748 root-finding algorithm implementation adapted from Maciej Waruszewski's
 libcloudph++ version (GPL) which in turn was based on Boost implementation
@@ -88,7 +88,9 @@ def quadratic_interpolate(a, b, d, fa, fb, fd, count):
 
 
 @numba.njit(**{**JIT_FLAGS, **{"parallel": False}})
-def cubic_interpolate(a, b, d, e, fa, fb, fd, fe):
+def cubic_interpolate(
+    a, b, d, e, fa, fb, fd, fe
+):  # pylint: disable=too-many-positional-arguments
     q11 = (d - e) * fd / (fe - fd)
     q21 = (b - d) * fb / (fd - fb)
     q31 = (a - b) * fa / (fb - fa)
@@ -112,7 +114,9 @@ def tol_check(a, b, rtol, within_tolerance):
 
 
 @numba.njit(**{**JIT_FLAGS, **{"parallel": False}})
-def toms748_solve(f, args, ax, bx, fax, fbx, rtol, max_iter, within_tolerance):
+def toms748_solve(
+    f, args, ax, bx, fax, fbx, rtol, max_iter, within_tolerance
+):  # pylint: disable=too-many-positional-arguments
     count = max_iter
     mu = 0.5
     a = ax