imt-ring 1.6.47__tar.gz → 1.7.1__tar.gz

{imt_ring-1.6.47 → imt_ring-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: imt-ring
-Version: 1.6.47
+Version: 1.7.1
 Summary: RING: Recurrent Inertial Graph-based Estimator
 Author-email: Simon Bachhuber <simon.bachhuber@fau.de>
 Project-URL: Homepage, https://github.com/SimiPixel/ring

{imt_ring-1.6.47 → imt_ring-1.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "imt-ring"
-version = "1.6.47"
+version = "1.7.1"
 authors = [
   { name="Simon Bachhuber", email="simon.bachhuber@fau.de" },
 ]

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/imt_ring.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: imt-ring
-Version: 1.6.47
+Version: 1.7.1
 Summary: RING: Recurrent Inertial Graph-based Estimator
 Author-email: Simon Bachhuber <simon.bachhuber@fau.de>
 Project-URL: Homepage, https://github.com/SimiPixel/ring

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/imt_ring.egg-info/SOURCES.txt

@@ -31,6 +31,18 @@ src/ring/algorithms/generator/motion_artifacts.py
 src/ring/algorithms/generator/pd_control.py
 src/ring/algorithms/generator/setup_fns.py
 src/ring/algorithms/generator/types.py
+src/ring/extras/__init__.py
+src/ring/extras/backend.py
+src/ring/extras/colab.py
+src/ring/extras/dataloader.py
+src/ring/extras/dataloader_torch.py
+src/ring/extras/hdf5.py
+src/ring/extras/interactive_viewer.py
+src/ring/extras/normalizer.py
+src/ring/extras/randomize_sys.py
+src/ring/extras/torch_loss_fn.py
+src/ring/extras/register_gym_envs/__init__.py
+src/ring/extras/register_gym_envs/saddle.py
 src/ring/io/__init__.py
 src/ring/io/examples.py
 src/ring/io/test_examples.py
@@ -83,18 +95,9 @@ src/ring/sys_composer/delete_sys.py
 src/ring/sys_composer/inject_sys.py
 src/ring/sys_composer/morph_sys.py
 src/ring/utils/__init__.py
-src/ring/utils/backend.py
 src/ring/utils/batchsize.py
-src/ring/utils/colab.py
-src/ring/utils/dataloader.py
-src/ring/utils/dataloader_torch.py
-src/ring/utils/hdf5.py
-src/ring/utils/normalizer.py
 src/ring/utils/path.py
-src/ring/utils/randomize_sys.py
 src/ring/utils/utils.py
-src/ring/utils/register_gym_envs/__init__.py
-src/ring/utils/register_gym_envs/saddle.py
 tests/test_algebra.py
 tests/test_base.py
 tests/test_custom_joints.py

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/ring/__init__.py

@@ -35,12 +35,12 @@ def RING(lam: list[int] | None, Ts: float | None, **kwargs) -> ml.AbstractFilter
         >>> import ring
         >>> import numpy as np
         >>>
-        >>> T  : int       = 30        # sequence length     [s]
-        >>> Ts : float     = 0.01      # sampling interval   [s]
-        >>> B  : int       = 1         # batch size
-        >>> lam: list[int] = [0, 1, 2] # parent array
-        >>> N  : int       = len(lam)  # number of bodies
-        >>> T_i: int       = int(T/Ts) # number of timesteps
+        >>> T  : int       = 30         # sequence length     [s]
+        >>> Ts : float     = 0.01       # sampling interval   [s]
+        >>> B  : int       = 1          # batch size
+        >>> lam: list[int] = [-1, 0, 1] # parent array
+        >>> N  : int       = len(lam)   # number of bodies
+        >>> T_i: int       = int(T/Ts)  # number of timesteps
         >>>
         >>> X = np.zeros((B, T_i, N, 9))
         >>> # where X is structured as follows:

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/ring/algorithms/_random.py

@@ -41,30 +41,48 @@ def random_angle_over_time(
     cdf_bins_min: int = 5,
     cdf_bins_max: Optional[int] = None,
     interpolation_method: str = "cosine",
+    include_standstills_prob: float = 0.0,  # 0.0 means no standstills
+    include_standstills_t_min: float = 0.5,
+    include_standstills_t_max: float = 5.0,
 ) -> jax.Array:
     def body_fn_outer(val):
         i, t, phi, key_t, key_ang, ANG = val
 
-        key_t, consume_t = random.split(key_t)
+        key_t, consume_t, consume_standstill = random.split(key_t, 3)
         key_ang, consume_ang = random.split(key_ang)
         rom_halfsize_float = _to_float(rom_halfsize, t)
         rom_lower = ANG_0 - rom_halfsize_float
         rom_upper = ANG_0 + rom_halfsize_float
-        dt, phi = _resolve_range_of_motion(
-            range_of_motion,
-            range_of_motion_method,
-            rom_lower,
-            rom_upper,
-            _to_float(dang_min, t),
-            _to_float(dang_max, t),
-            _to_float(delta_ang_min, t),
-            _to_float(delta_ang_max, t),
-            t_min,
-            _to_float(t_max, t),
-            phi,
-            consume_t,
-            consume_ang,
-            max_iter,
+
+        is_standstill = jax.random.bernoulli(
+            consume_standstill, include_standstills_prob
+        )
+        dt, phi = jax.lax.cond(
+            is_standstill,
+            lambda: (
+                jax.random.uniform(
+                    consume_t,
+                    minval=include_standstills_t_min,
+                    maxval=include_standstills_t_max,
+                ),
+                phi,
+            ),
+            lambda: _resolve_range_of_motion(
+                range_of_motion,
+                range_of_motion_method,
+                rom_lower,
+                rom_upper,
+                _to_float(dang_min, t),
+                _to_float(dang_max, t),
+                _to_float(delta_ang_min, t),
+                _to_float(delta_ang_max, t),
+                t_min,
+                _to_float(t_max, t),
+                phi,
+                consume_t,
+                consume_ang,
+                max_iter,
+            ),
         )
         t += dt
 
@@ -119,7 +137,8 @@ def random_angle_over_time(
 
 # APPROVED
 def random_position_over_time(
-    key: random.PRNGKey,
+    key_t: random.PRNGKey,
+    key_value: random.PRNGKey,
     POS_0: float,
     pos_min: float | TimeDependentFloat,
     pos_max: float | TimeDependentFloat,
@@ -135,19 +154,14 @@ def random_position_over_time(
     cdf_bins_min: int = 5,
     cdf_bins_max: Optional[int] = None,
     interpolation_method: str = "cosine",
+    include_standstills_prob: float = 0.0,  # 0.0 means no standstills
+    include_standstills_t_min: float = 0.5,
+    include_standstills_t_max: float = 5.0,
 ) -> jax.Array:
     def body_fn_inner(val):
         i, t, t_pre, x, x_pre, key = val
         dt = t - t_pre
 
-        def sample_dx_squared(key):
-            key, consume = random.split(key)
-            dx = (
-                random.uniform(consume) * (2 * dpos_max * t_max**2)
-                - dpos_max * t_max**2
-            )
-            return key, dx
-
         def sample_dx(key):
             key, consume1, consume2 = random.split(key, 3)
             sign = random.choice(consume1, jnp.array([-1.0, 1.0]))
@@ -182,24 +196,43 @@ def random_position_over_time(
         return jnp.logical_not(break_if_true1 | break_if_true2)
 
     def body_fn_outer(val):
-        i, t, t_pre, x, x_pre, key, POS = val
-        key, consume = random.split(key)
-        t += random.uniform(consume, minval=t_min, maxval=_to_float(t_max, t_pre))
+        i, t, t_pre, x, x_pre, key_t, key_value, POS = val
+        key_t, consume_t, consume_standstill = random.split(key_t, 3)
 
-        # that zero resets the max_it count
-        val_inner = (0, t, t_pre, x, x_pre, key)
-        _, t, t_pre, x, x_pre, key = jax.lax.while_loop(
-            cond_fn_inner, body_fn_inner, val_inner
+        is_standstill = jax.random.bernoulli(
+            consume_standstill, include_standstills_prob
+        )
+
+        def is_standstill_branch():
+            dt = random.uniform(
+                consume_t,
+                minval=include_standstills_t_min,
+                maxval=include_standstills_t_max,
+            )
+            t = t_pre + dt
+            return 0, t, t_pre, x, x_pre, key_value
+
+        def no_standstill_branch():
+            dt = random.uniform(consume_t, minval=t_min, maxval=_to_float(t_max, t_pre))
+            t = t_pre + dt
+            # that zero resets the max_it count
+            val_inner = (0, t, t_pre, x, x_pre, key_value)
+            return jax.lax.while_loop(cond_fn_inner, body_fn_inner, val_inner)
+
+        _, t, t_pre, x, x_pre, key_value = jax.lax.cond(
+            is_standstill,
+            is_standstill_branch,
+            no_standstill_branch,
         )
 
         POS_i = jnp.array([[jnp.floor(t / Ts) * Ts, x]])
         POS = jax.lax.dynamic_update_slice_in_dim(POS, POS_i, start_index=i, axis=0)
         t_pre = t
         x_pre = x
-        return i + 1, t, t_pre, x, x_pre, key, POS
+        return i + 1, t, t_pre, x, x_pre, key_t, key_value, POS
 
     def cond_fn_outer(val):
-        i, t, t_pre, x, x_pre, key, POS = val
+        i, t, t_pre, x, x_pre, key_t, key_value, POS = val
         return t <= T
 
     # preallocate POS array
@@ -207,7 +240,7 @@ def random_position_over_time(
     POS = jnp.zeros((int(T // t_min) + 1, 2))
     POS = POS.at[0, 1].set(POS_0)
 
-    val_outer = (1, 0.0, 0.0, POS_0, POS_0, key, POS)
+    val_outer = (1, 0.0, 0.0, POS_0, POS_0, key_t, key_value, POS)
     end, *_, consume, POS = jax.lax.while_loop(cond_fn_outer, body_fn_outer, val_outer)
     POS = jnp.where(
         (jnp.arange(len(POS)) < end)[:, None],

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/ring/algorithms/custom_joints/rr_imp_joint.py

@@ -23,11 +23,10 @@ def register_rr_imp_joint(
         return ring.Transform.create(rot=rot)
 
     def _draw_rr_imp(config, key_t, key_value, dt, N, _):
-        key_t1, key_t2 = jax.random.split(key_t)
         key_value1, key_value2 = jax.random.split(key_value)
-        q_traj_pri = _draw_rxyz(config, key_t1, key_value1, dt, N, _)
+        q_traj_pri = _draw_rxyz(config, key_t, key_value1, dt, N, _)
         q_traj_res = _draw_rxyz(
-            replace(config_res, T=config.T), key_t2, key_value2, dt, N, _
+            replace(config_res, T=config.T), key_t, key_value2, dt, N, _
         )
         # scale to be within bounds
         q_traj_res = q_traj_res * (jnp.deg2rad(ang_max_deg) / jnp.pi)

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/ring/algorithms/generator/base.py

@@ -1,5 +1,6 @@
 from dataclasses import replace
 from functools import partial
+import json
 import logging
 import random
 from typing import Callable, Optional
@@ -136,6 +137,14 @@ class RCMG:
               affecting joint motion behavior.
         """  # noqa: E501
 
+        # capture all funtion arguments before creating local variables
+        to_json_kwargs = locals()
+        # the purpose is to not capture the RCMG itself since we want to make it
+        # serialisable in the first place
+        to_json_kwargs.pop("self")
+        to_json_kwargs.pop("sys")
+        to_json_kwargs.pop("config")
+
         # add some default values
         randomize_hz_kwargs_defaults = dict(add_dt=True)
         randomize_hz_kwargs_defaults.update(randomize_hz_kwargs)
@@ -186,6 +195,11 @@ class RCMG:
 
         self._disable_tqdm = disable_tqdm
 
+        # store arguments that fully define the RCMG objects for use in `.to_json`
+        self._to_json_sys = sys
+        self._to_json_mconfig = config
+        self._to_json_kwargs = to_json_kwargs
+
     def _compute_repeats(self, sizes: int | list[int]) -> list[int]:
         "how many times the generators are repeated to create a batch of `sizes`"
 
@@ -355,6 +369,21 @@ class RCMG:
 
         return generator
 
+    def serialise_to_dict(self) -> dict:
+        dict_representation = {
+            "system": [_sys.to_str(warn=False) for _sys in self._to_json_sys],
+            "motion_configs": [_config.__dict__ for _config in self._to_json_mconfig],
+            "kwargs": self._to_json_kwargs,
+        }
+        return dict_representation
+
+    def serialise_to_json(self, path_of_json: str) -> None:
+        with open(path_of_json, "w") as file:
+            json.dump(self.serialise_to_dict(), file, indent=4)
+
+    def from_json(self, path_to_json: str) -> "RCMG":
+        raise NotImplementedError
+
 
 def _copy_dicts(f) -> dict:
     def _f(*args, **kwargs):
@@ -526,7 +555,7 @@ def draw_random_q(
     sys: base.System,
     config: jcalc.MotionConfig,
     N: int | None,
-) -> tuple[types.Xy, types.OutputExtras]:
+) -> tuple[jax.random.PRNGKey, jax.Array]:
 
     key_start = key
     # build generalized coordintes vector `q`

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/ring/algorithms/jcalc.py

@@ -174,6 +174,16 @@ class MotionConfig:
         default_factory=lambda: dict()
     )
 
+    # fields related to simulating standstills (no motion time periods)
+    # these are "Joint Standstills" so the standstills are calculated on
+    # a joint level, for each joint independently
+    # This means that a `standstills_prob` of 20% means that each joint
+    # has at each dt \in [t_min, t_max] drawing process a probability of
+    # 20% that it will just stay at its current joint value
+    include_standstills_prob: float = 0.0  # in %; 0% means no standstills
+    include_standstills_t_min: float = 0.5
+    include_standstills_t_max: float = 5.0
+
     def is_feasible(self) -> bool:
         return _is_feasible_config1(self)
 
@@ -791,12 +801,15 @@ def _draw_rxyz(
         config.cdf_bins_min,
         config.cdf_bins_max,
         config.interpolation_method,
+        config.include_standstills_prob,
+        config.include_standstills_t_min,
+        config.include_standstills_t_max,
     )
 
 
 def _draw_pxyz(
     config: MotionConfig,
-    _: jax.random.PRNGKey,
+    key_t: jax.random.PRNGKey,
     key_value: jax.random.PRNGKey,
     dt: float | jax.Array,
     N: int | None,
@@ -811,6 +824,7 @@ def _draw_pxyz(
     )
     max_iter = 100
     return _random.random_position_over_time(
+        key_t,
         key_value,
         POS_0,
         config.cor_pos_min if cor else config.pos_min,
@@ -827,6 +841,9 @@ def _draw_pxyz(
         config.cdf_bins_min,
         config.cdf_bins_max,
         config.interpolation_method,
+        config.include_standstills_prob,
+        config.include_standstills_t_min,
+        config.include_standstills_t_max,
     )
 
 
@@ -840,7 +857,6 @@ def _draw_spherical(
 ) -> jax.Array:
     # NOTE: We draw 3 euler angles and then build a quaternion.
     # Not ideal, but i am unaware of a better way.
-    @jax.vmap
     def draw_euler_angles(key_t, key_value):
         return _draw_rxyz(
             config,
@@ -853,8 +869,9 @@ def _draw_spherical(
             free_spherical=True,
         )
 
-    triple = lambda key: jax.random.split(key, 3)
-    euler_angles = draw_euler_angles(triple(key_t), triple(key_value)).T
+    euler_angles = jax.vmap(draw_euler_angles, in_axes=(None, 0))(
+        key_t, jax.random.split(key_value, 3)
+    ).T
     q = maths.quat_euler(euler_angles)
     return q
 
@@ -867,7 +884,6 @@ def _draw_saddle(
     N: int | None,
     _: jax.Array,
 ) -> jax.Array:
-    @jax.vmap
     def draw_euler_angles(key_t, key_value):
         return _draw_rxyz(
             config,
@@ -880,14 +896,15 @@ def _draw_saddle(
             free_spherical=False,
         )
 
-    double = lambda key: jax.random.split(key)
-    yz_euler_angles = draw_euler_angles(double(key_t), double(key_value)).T
+    yz_euler_angles = jax.vmap(draw_euler_angles, in_axes=(None, 0))(
+        key_t, jax.random.split(key_value)
+    ).T
     return yz_euler_angles
 
 
 def _draw_p3d_and_cor(
     config: MotionConfig,
-    _: jax.random.PRNGKey,
+    key_t: jax.random.PRNGKey,
     key_value: jax.random.PRNGKey,
     dt: float | jax.Array,
     N: int | None,
@@ -896,7 +913,7 @@ def _draw_p3d_and_cor(
 ) -> jax.Array:
     keys = jax.random.split(key_value, 3)
 
-    def draw(key, xyz: str):
+    def draw(key_value, xyz: str):
         return _draw_pxyz(
             replace(
                 config,
@@ -905,8 +922,8 @@ def _draw_p3d_and_cor(
                 pos0_min=getattr(config, f"pos0_min_p3d_{xyz}"),
                 pos0_max=getattr(config, f"pos0_max_p3d_{xyz}"),
             ),
-            None,
-            key,
+            key_t,
+            key_value,
             dt,
             N,
             None,
@@ -919,26 +936,26 @@ def _draw_p3d_and_cor(
 
 def _draw_p3d(
     config: MotionConfig,
-    _: jax.random.PRNGKey,
+    key_t: jax.random.PRNGKey,
     key_value: jax.random.PRNGKey,
     dt: float | jax.Array,
     N: int | None,
     __: jax.Array,
 ) -> jax.Array:
-    return _draw_p3d_and_cor(config, _, key_value, dt, N, None, cor=False)
+    return _draw_p3d_and_cor(config, key_t, key_value, dt, N, None, cor=False)
 
 
 def _draw_cor(
     config: MotionConfig,
-    _: jax.random.PRNGKey,
+    key_t: jax.random.PRNGKey,
     key_value: jax.random.PRNGKey,
     dt: float | jax.Array,
     N: int | None,
     __: jax.Array,
 ) -> jax.Array:
     key_value1, key_value2 = jax.random.split(key_value)
-    q_free = _draw_free(config, _, key_value1, dt, N, None)
-    q_p3d = _draw_p3d_and_cor(config, _, key_value2, dt, N, None, cor=True)
+    q_free = _draw_free(config, key_t, key_value1, dt, N, None)
+    q_p3d = _draw_p3d_and_cor(config, key_t, key_value2, dt, N, None, cor=True)
     return jnp.concatenate((q_free, q_p3d), axis=1)
 
 
@@ -952,7 +969,7 @@ def _draw_free(
 ) -> jax.Array:
     key_value1, key_value2 = jax.random.split(key_value)
     q = _draw_spherical(config, key_t, key_value1, dt, N, None)
-    pos = _draw_p3d(config, None, key_value2, dt, N, None)
+    pos = _draw_p3d(config, key_t, key_value2, dt, N, None)
     return jnp.concatenate((q, pos), axis=1)
 
 
@@ -975,7 +992,7 @@ def _draw_free_2d(
         enable_range_of_motion=False,
         free_spherical=True,
     )[:, None]
-    pos_yz = _draw_p3d(config, None, key_value2, dt, N, None)[:, :2]
+    pos_yz = _draw_p3d(config, key_t, key_value2, dt, N, None)[:, :2]
     return jnp.concatenate((angle_x, pos_yz), axis=1)
 
 

{imt_ring-1.6.47 → imt_ring-1.7.1}/src/ring/base.py

@@ -981,6 +981,7 @@ class System(_Base):
 
     def render(
         self,
+        qs: Optional[jax.Array | list[jax.Array]] = None,
         xs: Optional[Transform | list[Transform]] = None,
         camera: Optional[str] = None,
         show_pbar: bool = True,
@@ -1001,7 +1002,7 @@ class System(_Base):
             list[np.ndarray]: Stacked rendered frames. Length == len(xs).
         """
         return ring.rendering.render(
-            self, xs, camera, show_pbar, backend, render_every_nth, **scene_kwargs
+            self, qs, xs, camera, show_pbar, backend, render_every_nth, **scene_kwargs
         )
 
     def render_prediction(

imt_ring-1.7.1/src/ring/extras/interactive_viewer.py

@@ -0,0 +1,114 @@
+import multiprocessing
+import time
+from typing import Optional
+
+import fire
+import jax.numpy as jnp
+import numpy as np
+
+import ring
+from ring import System
+
+
+class InteractiveViewer:
+    def __init__(self, sys: ring.System, **scene_kwargs):
+        self._mp_dict = multiprocessing.Manager().dict()
+        self._geom_dict = multiprocessing.Manager().dict()
+        self.update_q(np.array(ring.State.create(sys).q))
+        self.process = multiprocessing.Process(
+            target=self._worker,
+            args=(self._mp_dict, self._geom_dict, sys.to_str(), scene_kwargs),
+        )
+        self.process.start()
+
+    def update_q(self, q: np.ndarray):
+        self._mp_dict["q"] = q
+
+    def make_geometry_transparent(self, body_number: int, geom_number: int):
+        geom_name = f"body{body_number}_geom{geom_number}"
+        # the value is not used
+        self._geom_dict[geom_name] = None
+
+    def _worker(self, mp_dict, geom_dict, sys_str, scene_kwargs):
+        from ring.rendering import base_render
+
+        sys = System.from_str(sys_str)
+        while base_render._scene is None or base_render._scene._renderer.is_alive:
+            sys.render(jnp.array(mp_dict["q"]), interactive=True, **scene_kwargs)
+
+            if len(geom_dict) > 0:
+                model = base_render._scene._model
+                processed = []
+                for geom_name in list(geom_dict.keys()):
+                    # Get the geometry ID
+                    geom_id = model.geom(geom_name).id
+                    # Set transparency to 0 (fully transparent)
+                    model.geom_rgba[geom_id, 3] = 0
+                    print(f"Made geom with name={geom_name} transparent (worker)")
+                    processed.append(geom_name)
+
+                for geom_name in processed:
+                    geom_dict.pop(geom_name)
+
+    def __enter__(self):
+        return self
+
+    def close(self):
+        self.process.terminate()
+        self.process.join()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
+def _fire_main(path_sys_xml: str, path_qs_np: Optional[str] = None, **scene_kwargs):
+    """View motion given by trajectory of minimal coordinates in interactive viewer.
+
+    Args:
+        path_sys_xml (str): Path to xml file defining the system.
+        path_qs_np (str | None, optional): Path to numpy array containing the timeseries of minimal coordinates with
+            shape (T, DOF) where DOF is equal to `sys.q_size()`. Each minimal coordiante is from parent
+            to child. So for example a `spherical` joint that connects the first body to the worldbody
+            has a minimal coordinate of a quaternion that gives from worldbody to first body. The sampling
+            rate of the motion is inferred from the `sys.dt` attribute. If `None` (default), then simply renders the
+            unarticulated pose of the system.
+    """  # noqa: E501
+
+    sys = ring.System.from_xml(path_sys_xml)
+    if path_qs_np is None:
+        qs = np.array(ring.State.create(sys).q)[None]
+    else:
+        qs: np.ndarray = np.load(path_qs_np)
+
+    assert qs.ndim == 2, f"qs.shape = {qs.shape}"
+    T, Q = qs.shape
+    assert Q == sys.q_size(), f"Q={Q} != sys.q_size={sys.q_size()}"
+    dt_target = sys.dt
+
+    with InteractiveViewer(sys, width=640, height=480, **scene_kwargs) as viewer:
+        dt = dt_target
+        last_t = time.time()
+        t = -1
+
+        while True:
+            t = (t + 1) % T
+
+            while dt < dt_target:
+                time.sleep(0.001)
+                dt = time.time() - last_t
+
+            last_t = time.time()
+            viewer.update_q(qs[t])
+            dt = time.time() - last_t
+
+            # process will be stopped if the window is closed
+            if not viewer.process.is_alive():
+                break
+
+
+def main():
+    fire.Fire(_fire_main)
+
+
+if __name__ == "__main__":
+    main()