black & isort

Author: AntSimi

doc/conf.py

@@ -96,9 +96,9 @@
 master_doc = "index"
 
 # General information about the project.
-project = u"py-eddy-tracker"
-copyright = u"2019, A. Delepoulle & E. Mason"
-author = u"A. Delepoulle & E. Mason"
+project = "py-eddy-tracker"
+copyright = "2019, A. Delepoulle & E. Mason"
+author = "A. Delepoulle & E. Mason"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -272,8 +272,8 @@
     (
         master_doc,
         "py-eddy-tracker.tex",
-        u"py-eddy-tracker Documentation",
-        u"A. Delepoulle \\& E. Mason",
+        "py-eddy-tracker Documentation",
+        "A. Delepoulle \\& E. Mason",
         "manual",
     ),
 ]
@@ -304,7 +304,7 @@
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    (master_doc, "py-eddy-tracker", u"py-eddy-tracker Documentation", [author], 1)
+    (master_doc, "py-eddy-tracker", "py-eddy-tracker Documentation", [author], 1)
 ]
 
 # If true, show URL addresses after external links.
@@ -320,7 +320,7 @@
     (
         master_doc,
         "py-eddy-tracker",
-        u"py-eddy-tracker Documentation",
+        "py-eddy-tracker Documentation",
         author,
         "py-eddy-tracker",
         "One line description of project.",

examples/06_grid_manipulation/pet_advect.py

@@ -139,7 +139,9 @@ def update(i_frame, t_step):
 )
 for time_step in (10800, 21600, 43200, 86400):
     x, y = x0.copy(), y0.copy()
-    kw_advect = dict(nb_step=int(50 * 86400 / time_step), time_step=time_step, u_name="u", v_name="v")
+    kw_advect = dict(
+        nb_step=int(50 * 86400 / time_step), time_step=time_step, u_name="u", v_name="v"
+    )
     g.advect(x, y, **kw_advect).__next__()
     g.advect(x, y, **kw_advect, backward=True).__next__()
     d = ((x - x0) ** 2 + (y - y0) ** 2) ** 0.5
@@ -158,7 +160,12 @@ def update(i_frame, t_step):
 time_step = 10800
 for duration in (5, 50, 100):
     x, y = x0.copy(), y0.copy()
-    kw_advect = dict(nb_step=int(duration * 86400 / time_step), time_step=time_step, u_name="u", v_name="v")
+    kw_advect = dict(
+        nb_step=int(duration * 86400 / time_step),
+        time_step=time_step,
+        u_name="u",
+        v_name="v",
+    )
     g.advect(x, y, **kw_advect).__next__()
     g.advect(x, y, **kw_advect, backward=True).__next__()
     d = ((x - x0) ** 2 + (y - y0) ** 2) ** 0.5

examples/06_grid_manipulation/pet_lavd.py

@@ -110,7 +110,9 @@ def save(self, *args, **kwargs):
 step_by_day = 3
 # Compute step of advection every 4h
 nb_step = 2
-kw_p = dict(nb_step=nb_step, time_step=86400 / step_by_day / nb_step, u_name="u", v_name="v")
+kw_p = dict(
+    nb_step=nb_step, time_step=86400 / step_by_day / nb_step, u_name="u", v_name="v"
+)
 # Start a generator which at each iteration return new position at next time step
 particule = g.advect(x, y, **kw_p, rk4=True)
 

examples/07_cube_manipulation/pet_fsle_med.py

@@ -142,7 +142,9 @@ def build_triplet(x, y, step=0.02):
 used = zeros(x.shape[0], dtype="bool")
 
 # advection generator
-kw = dict(t_init=t0, nb_step=1, backward=backward, mask_particule=used, u_name="u", v_name="v")
+kw = dict(
+    t_init=t0, nb_step=1, backward=backward, mask_particule=used, u_name="u", v_name="v"
+)
 p = c.advect(x, y, time_step=86400 / time_step_by_days, **kw)
 
 # We check at each step of advection if particle distance is over `dist_max`

examples/07_cube_manipulation/pet_particles_drift.py

@@ -20,7 +20,7 @@
     "longitude",
     "latitude",
     "time",
-    unset=True
+    unset=True,
 )
 
 # %%
@@ -43,4 +43,4 @@
 ax.plot(x, y, lw=3)
 ax.set_title("10 days particle paths")
 ax.set_xlim(31, 35), ax.set_ylim(32, 34.5)
-ax.grid()
+ax.grid()

examples/16_network/pet_follow_particle.py

@@ -95,7 +95,13 @@ def save(self, *args, **kwargs):
 a.txt.set_position((25, 31))
 
 step = 0.25
-kw_p = dict(nb_step=2, time_step=86400 * step * 0.5, t_init=t_snapshot - 2 * step, u_name="u", v_name="v")
+kw_p = dict(
+    nb_step=2,
+    time_step=86400 * step * 0.5,
+    t_init=t_snapshot - 2 * step,
+    u_name="u",
+    v_name="v",
+)
 
 mappables = dict()
 particules = c.advect(x, y, **kw_p)

src/py_eddy_tracker/appli/network.py

@@ -54,7 +54,9 @@ def build_network():
         memory=args.memory,
     )
     group = n.group_observations(
-        min_overlap=args.min_overlap, minimal_area=args.minimal_area, hybrid_area=args.hybrid_area
+        min_overlap=args.min_overlap,
+        minimal_area=args.minimal_area,
+        hybrid_area=args.hybrid_area,
     )
     n.build_dataset(group).write_file(filename=args.out)
 
@@ -97,7 +99,7 @@ def divide_network():
             window=args.window,
             min_overlap=args.min_overlap,
             minimal_area=args.minimal_area,
-            hybrid_area=args.hybrid_area
+            hybrid_area=args.hybrid_area,
         ),
     )
     n.write_file(filename=args.out)

src/py_eddy_tracker/dataset/grid.py

@@ -1980,7 +1980,15 @@ def interp(self, grid_name, lons, lats, method="bilinear"):
             self.x_c, self.y_c, g, m, lons, lats, nearest=method == "nearest"
         )
 
-    def uv_for_advection(self, u_name=None, v_name=None, time_step=600, h_name=None, backward=False, factor=1):
+    def uv_for_advection(
+        self,
+        u_name=None,
+        v_name=None,
+        time_step=600,
+        h_name=None,
+        backward=False,
+        factor=1,
+    ):
         """
         Get U,V to be used in degrees with precomputed time step
 
@@ -1990,7 +1998,7 @@ def uv_for_advection(self, u_name=None, v_name=None, time_step=600, h_name=None,
         :param int time_step: Number of second for each advection
         """
         if h_name is not None:
-            u_name, v_name = 'u', 'v'
+            u_name, v_name = "u", "v"
             if u_name not in self.vars:
                 self.add_uv(h_name)
                 self.vars.pop(h_name, None)

src/py_eddy_tracker/observations/groups.py

@@ -351,7 +351,15 @@ def keep_tracks_by_date(self, date, nb_days):
         return self.extract_with_mask(mask)
 
     def particle_candidate_atlas(
-        self, cube, space_step, dt, start_intern=False, end_intern=False, callback_coherence=None, finalize_coherence=None, **kwargs
+        self,
+        cube,
+        space_step,
+        dt,
+        start_intern=False,
+        end_intern=False,
+        callback_coherence=None,
+        finalize_coherence=None,
+        **kwargs
     ):
         """Select particles within eddies, advect them, return target observation and associated percentages
 
@@ -383,7 +391,9 @@ def particle_candidate_atlas(
         kw_coherence = dict(space_step=space_step, dt=dt, c=cube)
         kw_coherence.update(kwargs)
         for t in times:
-            logger.info("Coherence for time step : %s in [%s:%s]", t, times[0], times[-1])
+            logger.info(
+                "Coherence for time step : %s in [%s:%s]", t, times[0], times[-1]
+            )
             # Get index for origin
             i = t - t_start
             indexs0 = i_sort[i_start[i] : i_end[i]]
@@ -393,15 +403,37 @@ def particle_candidate_atlas(
             if indexs0.size == 0 or indexs1.size == 0:
                 continue
 
-            results.append(callback_coherence(self, i_target, pct, indexs0, indexs1, start_intern, end_intern, t_start=t, **kw_coherence))
+            results.append(
+                callback_coherence(
+                    self,
+                    i_target,
+                    pct,
+                    indexs0,
+                    indexs1,
+                    start_intern,
+                    end_intern,
+                    t_start=t,
+                    **kw_coherence
+                )
+            )
             indexs[results[-1]] = indexs0, indexs1
 
         if finalize_coherence is not None:
             finalize_coherence(results, indexs, i_target, pct)
         return i_target, pct
 
     @classmethod
-    def fill_coherence(cls, network, i_targets, percents, i_origin, i_end, start_intern, end_intern, **kwargs):
+    def fill_coherence(
+        cls,
+        network,
+        i_targets,
+        percents,
+        i_origin,
+        i_end,
+        start_intern,
+        end_intern,
+        **kwargs
+    ):
         """_summary_
 
         :param array i_targets: global target
@@ -412,21 +444,29 @@ def fill_coherence(cls, network, i_targets, percents, i_origin, i_end, start_int
         :param bool end_intern: Use intern or extern contour at end of advection
         """
         # Get contour data
-        contours_start = [network[label][i_origin] for label in cls.intern(start_intern)]
+        contours_start = [
+            network[label][i_origin] for label in cls.intern(start_intern)
+        ]
         contours_end = [network[label][i_end] for label in cls.intern(end_intern)]
         # Compute local coherence
-        i_local_targets, local_percents = particle_candidate_step(contours_start=contours_start, contours_end=contours_end,**kwargs)
+        i_local_targets, local_percents = particle_candidate_step(
+            contours_start=contours_start, contours_end=contours_end, **kwargs
+        )
         # Store
-        cls.merge_particle_result(i_targets, percents, i_local_targets, local_percents, i_origin, i_end)
-    
+        cls.merge_particle_result(
+            i_targets, percents, i_local_targets, local_percents, i_origin, i_end
+        )
+
     @staticmethod
-    def merge_particle_result(i_targets, percents, i_local_targets, local_percents, i_origin, i_end):
+    def merge_particle_result(
+        i_targets, percents, i_local_targets, local_percents, i_origin, i_end
+    ):
         """Copy local result in merged result with global indexation
 
         :param array i_targets: global target
-        :param array percents: 
+        :param array percents:
         :param array i_local_targets: local index target
-        :param array local_percents: 
+        :param array local_percents:
         :param array i_origin: indices of origins
         :param array i_end: indices of ends
         """