lt-tensor 0.0.1a17__py3-none-any.whl → 0.0.1a19__py3-none-any.whl

lt_tensor/config_templates.py

@@ -7,75 +7,79 @@ from lt_tensor.misc_utils import updateDict
 
 class ModelConfig(ABC, OrderedDict):
     _default_settings: Dict[str, Any] = {}
-    _forbidden_list: List[str] = ["_default_settings", "_forbidden_list" "path_name"]
+    _forbidden_list: List[str] = [
+        "_default_settings",
+        "_forbidden_list",
+        "path_name",
+    ]
+    path: Optional[str] = None
 
     def __init__(
         self,
-        settings: Dict[str, Any] = {},
-        path_name: Optional[Union[str, PathLike]] = None,
+        path: Optional[Union[str, PathLike]] = None,
+        **settings,
     ):
-        assert is_dict(settings, False)
-        self._default_settings = settings
-        if path_name is not None and is_pathlike(path_name):
-            if not str(path_name).endswith(".json"):
-                self.path_name = str(Path(path_name, "config.json")).replace("\\", "/")
-            else:
-                self.path_name = str(path_name).replace("\\", "/")
+        self._setup_path_name(path)
+        if self.path is not None:
+            self._default_settings = load_json(self.path, default=settings)
         else:
-            self.path_name = "config.json"
-        self.reset_settings()
+            self._default_settings = settings
+
+        self.set_state_dict(self._default_settings)
 
     def _setup_path_name(self, path_name: Union[str, PathLike]):
         if is_file(path_name):
             self.from_path(path_name)
-            self.path_name = str(path_name).replace("\\", "/")
+            self.path = str(path_name).replace("\\", "/")
         elif is_str(path_name):
-            self.path_name = str(path_name).replace("\\", "/")
-            if not self.path_name.endswith((".json")):
-                self.path_name += ".json"
+            self.path = str(path_name).replace("\\", "/")
+            if not self.path.endswith((".json")):
+                self.path += ".json"
 
     def reset_settings(self):
-        dk_keys = self.__dict__.keys()
-        for s_name, setting in self._default_settings.items():
-            if s_name in self._forbidden_list or s_name not in dk_keys:
-                continue
-            updateDict(self, {s_name: setting})
+        raise NotImplementedError("Not implemented")
 
     def save_config(
         self,
-        path_name: Optional[Union[PathLike, str]] = None,
+        path: Optional[Union[PathLike, str]] = None,
     ):
-        if not is_pathlike(path_name, True):
+        if not is_pathlike(path, True):
             assert (
-                path_name is None
-            ), f"path_name should be a non-empty string or pathlike object! received instead: {path_name}."
-            path_name = self.path_name
+                path is None
+            ), f"path_name should be a non-empty string or pathlike object! received instead: {path}."
+            path = self.path
         else:
-            self._setup_path_name(path_name)
+            self._setup_path_name(path)
 
-        base = self.get_state_dict()
-        save_json(self.path_name, base, indent=2)
+        base = self.state_dict()
+        save_json(self.path, base, indent=2)
 
     def set_value(self, var_name: str, value: str) -> None:
-        assert var_name in self.__dict__, "Value not registered!"
         assert var_name not in self._forbidden_list, "Not allowed!"
         updateDict(self, {var_name: value})
+        self.update({var_name: value})
 
     def get_value(self, var_name: str) -> Any:
         return self.__dict__.get(var_name)
 
-    def __getattribute__(self, name):
-        return self.__dict__.get(name)
+    def set_state_dict(self, new_state: dict[str, str]):
+        new_state = {
+            k: y for k, y in new_state.items() if k not in self._forbidden_list
+        }
+        updateDict(self, new_state)
+        self.update(**new_state)
 
-    def get_state_dict(self):
+    def state_dict(self):
         return {k: y for k, y in self.__dict__.items() if k not in self._forbidden_list}
 
     @classmethod
     def from_dict(
-        cls, dictionary: Dict[str, Any], path: Optional[Union[str, PathLike]] = None
+        cls,
+        dictionary: Dict[str, Any],
+        path: Optional[Union[str, PathLike]] = None,
     ) -> "ModelConfig":
         assert is_dict(dictionary)
-        return ModelConfig(dictionary, path)
+        return ModelConfig(path, **dictionary)
 
     @classmethod
     def from_path(cls, path_name: PathLike) -> "ModelConfig":
@@ -102,4 +106,4 @@ class ModelConfig(ABC, OrderedDict):
             )
             assert files, "No config file found in the provided directory!"
             settings.update(load_json(files[-1], {}, errors="ignore"))
-        return ModelConfig(settings, path_name)
+        return ModelConfig(path_name, **settings)

lt_tensor/model_zoo/audio_models/__init__.py

@@ -1,2 +1,3 @@
 from . import diffwave, istft, hifigan
 
+__all__ = ["diffwave", "istft", "hifigan"]

lt_tensor/model_zoo/audio_models/diffwave/__init__.py

@@ -1,29 +1,19 @@
-__all__ = ["DiffWave", "SpectrogramUpsampler", "DiffusionEmbedding"]
+__all__ = ["DiffWave", "DiffWaveConfig", "SpectrogramUpsample", "DiffusionEmbedding"]
 
 import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
+from lt_tensor.torch_commons import *
+from torch.nn import functional as F
 from lt_tensor.config_templates import ModelConfig
 from lt_tensor.torch_commons import *
 from lt_tensor.model_base import Model
 from math import sqrt
 from lt_utils.common import *
 
-F.t
-
 
 class DiffWaveConfig(ModelConfig):
-    # Training params
-    batch_size = 16
-    learning_rate = 2e-4
-    max_grad_norm = None
-    # Data params
-    sample_rate = 24000
+    # Model params
     n_mels = 80
-    n_fft = 1024
     hop_samples = 256
-    # Model params
     residual_layers = 30
     residual_channels = 64
     dilation_cycle_length = 10
@@ -37,11 +27,30 @@ class DiffWaveConfig(ModelConfig):
 
     def __init__(
         self,
-        settings: Dict[str, Any] = {},
-        path_name: Optional[Union[str, PathLike]] = None,
+        n_mels = 80,
+        hop_samples = 256,
+        residual_layers = 30,
+        residual_channels = 64,
+        dilation_cycle_length = 10,
+        unconditional = False,
+        noise_schedule: list[int] = np.linspace(1e-4, 0.05, 50).tolist(),
+        interpolate_cond = False,
+        interpolation_mode: Literal[
+            "nearest", "linear", "bilinear", "bicubic", "trilinear", "area", "nearest-exact"
+        ] = "nearest",
     ):
-        self._forbidden_list.extend()
-        super().__init__(settings, path_name)
+        settings = {
+            "n_mels": n_mels,
+            "hop_samples": hop_samples,
+            "residual_layers": residual_layers,
+            "dilation_cycle_length": dilation_cycle_length,
+            "residual_channels": residual_channels,
+            "unconditional": unconditional,
+            "noise_schedule": noise_schedule,
+            "interpolate": interpolate_cond,
+            "interpolation_mode": interpolation_mode,
+        }
+        super().__init__(**settings)
 
 
 def Conv1d(*args, **kwargs):
@@ -86,7 +95,7 @@ class DiffusionEmbedding(Model):
         return table
 
 
-class SpectrogramUpsampler(Model):
+class SpectrogramUpsample(Model):
     def __init__(self):
         super().__init__()
         self.conv1 = nn.ConvTranspose2d(1, 1, [3, 32], stride=[1, 16], padding=[1, 8])
@@ -162,7 +171,7 @@ class DiffWave(Model):
         if self.params.unconditional:  # use unconditional model
             self.spectrogram_upsample = None
         else:
-            self.spectrogram_upsample = SpectrogramUpsampler()
+            self.spectrogram_upsample = SpectrogramUpsample()
 
         self.residual_layers = nn.ModuleList(
             [

lt_tensor/model_zoo/audio_models/hifigan/__init__.py

@@ -1,18 +1,63 @@
-__all__ = ["HifiganGenerator"]
+__all__ = ["HifiganGenerator", "HifiganConfig"]
 from lt_utils.common import *
 from lt_tensor.torch_commons import *
 from lt_tensor.model_zoo.residual import ConvNets
 from torch.nn import functional as F
 
-import torch
-import torch.nn.functional as F
-import torch.nn as nn
-
 
 def get_padding(kernel_size, dilation=1):
     return int((kernel_size * dilation - dilation) / 2)
 
 
+from lt_tensor.config_templates import ModelConfig
+
+
+class HifiganConfig(ModelConfig):
+    # Training params
+    in_channels: int = 80
+    upsample_rates: List[Union[int, List[int]]] = [8, 8]
+    upsample_kernel_sizes: List[Union[int, List[int]]] = [16, 16]
+    upsample_initial_channel: int = 512
+    resblock_kernel_sizes: List[Union[int, List[int]]] = [3, 7, 11]
+    resblock_dilation_sizes: List[Union[int, List[int]]] = [
+        [1, 3, 5],
+        [1, 3, 5],
+        [1, 3, 5],
+    ]
+
+    activation: nn.Module = nn.LeakyReLU(0.1)
+    resblock: int = 0
+
+    def __init__(
+        self,
+        in_channels: int = 80,
+        upsample_rates: List[Union[int, List[int]]] = [8, 8],
+        upsample_kernel_sizes: List[Union[int, List[int]]] = [16, 16],
+        upsample_initial_channel: int = 512,
+        resblock_kernel_sizes: List[Union[int, List[int]]] = [3, 7, 11],
+        resblock_dilation_sizes: List[Union[int, List[int]]] = [
+            [1, 3, 5],
+            [1, 3, 5],
+            [1, 3, 5],
+        ],
+        activation: nn.Module = nn.LeakyReLU(0.1),
+        resblock: int = 0,
+        *args,
+        **kwargs,
+    ):
+        settings = {
+            "in_channels": in_channels,
+            "upsample_rates": upsample_rates,
+            "upsample_kernel_sizes": upsample_kernel_sizes,
+            "upsample_initial_channel": upsample_initial_channel,
+            "resblock_kernel_sizes": resblock_kernel_sizes,
+            "resblock_dilation_sizes": resblock_dilation_sizes,
+            "activation": activation,
+            "resblock": resblock,
+        }
+        super().__init__(**settings)
+
+
 class ResBlock1(ConvNets):
     def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
         super().__init__()
@@ -142,23 +187,23 @@ class ResBlock2(ConvNets):
 
 
 class HifiganGenerator(ConvNets):
-    def __init__(self, h):
+    def __init__(self, cfg: HifiganConfig = HifiganConfig()):
         super().__init__()
-        self.h = h
-        self.num_kernels = len(h.resblock_kernel_sizes)
-        self.num_upsamples = len(h.upsample_rates)
+        self.cfg = cfg
+        self.num_kernels = len(cfg.resblock_kernel_sizes)
+        self.num_upsamples = len(cfg.upsample_rates)
         self.conv_pre = weight_norm(
-            nn.Conv1d(80, h.upsample_initial_channel, 7, 1, padding=3)
+            nn.Conv1d(cfg.in_channels, cfg.upsample_initial_channel, 7, 1, padding=3)
         )
-        resblock = ResBlock1 if h.resblock == "1" else ResBlock2
-        self.activation = nn.LeakyReLU(0.1)
+        resblock = ResBlock1 if cfg.resblock == 0 else ResBlock2
+        self.activation = cfg.activation
         self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(h.upsample_rates, h.upsample_kernel_sizes)):
+        for i, (u, k) in enumerate(zip(cfg.upsample_rates, cfg.upsample_kernel_sizes)):
             self.ups.append(
                 weight_norm(
                     nn.ConvTranspose1d(
-                        h.upsample_initial_channel // (2**i),
-                        h.upsample_initial_channel // (2 ** (i + 1)),
+                        cfg.upsample_initial_channel // (2**i),
+                        cfg.upsample_initial_channel // (2 ** (i + 1)),
                         k,
                         u,
                         padding=(k - u) // 2,
@@ -168,17 +213,17 @@ class HifiganGenerator(ConvNets):
 
         self.resblocks = nn.ModuleList()
         for i in range(len(self.ups)):
-            ch = h.upsample_initial_channel // (2 ** (i + 1))
+            ch = cfg.upsample_initial_channel // (2 ** (i + 1))
             for j, (k, d) in enumerate(
-                zip(h.resblock_kernel_sizes, h.resblock_dilation_sizes)
+                zip(cfg.resblock_kernel_sizes, cfg.resblock_dilation_sizes)
             ):
-                self.resblocks.append(resblock(h, ch, k, d))
+                self.resblocks.append(resblock(ch, k, d))
 
         self.conv_post = weight_norm(nn.Conv1d(ch, 1, 7, 1, padding=3))
         self.ups.apply(self.init_weights)
         self.conv_post.apply(self.init_weights)
 
-    def forward(self, x):
+    def forward(self, x: Tensor):
         x = self.conv_pre(x)
         for i in range(self.num_upsamples):
             x = self.ups[i](self.activation(x))

lt_tensor/model_zoo/audio_models/istft/__init__.py

@@ -1,8 +1,61 @@
-__all__ = ["iSTFTGenerator"]
+__all__ = ["iSTFTNetGenerator", "iSTFTNetConfig"]
 from lt_utils.common import *
 from lt_tensor.torch_commons import *
 from lt_tensor.model_zoo.residual import ConvNets
 from torch.nn import functional as F
+from lt_tensor.config_templates import ModelConfig
+
+
+class iSTFTNetConfig(ModelConfig):
+    # Training params
+    in_channels: int = 80
+    upsample_rates: List[Union[int, List[int]]] = [8, 8]
+    upsample_kernel_sizes: List[Union[int, List[int]]] = [16, 16]
+    upsample_initial_channel: int = 512
+    resblock_kernel_sizes: List[Union[int, List[int]]] = [3, 7, 11]
+    resblock_dilation_sizes: List[Union[int, List[int]]] = [
+        [1, 3, 5],
+        [1, 3, 5],
+        [1, 3, 5],
+    ]
+
+    activation: nn.Module = nn.LeakyReLU(0.1)
+    resblock: int = 0
+    gen_istft_n_fft: int = 16
+    sampling_rate: Number = 24000
+
+    def __init__(
+        self,
+        in_channels: int = 80,
+        upsample_rates: List[Union[int, List[int]]] = [8, 8],
+        upsample_kernel_sizes: List[Union[int, List[int]]] = [16, 16],
+        upsample_initial_channel: int = 512,
+        resblock_kernel_sizes: List[Union[int, List[int]]] = [3, 7, 11],
+        resblock_dilation_sizes: List[Union[int, List[int]]] = [
+            [1, 3, 5],
+            [1, 3, 5],
+            [1, 3, 5],
+        ],
+        activation: nn.Module = nn.LeakyReLU(0.1),
+        resblock: int = 0,
+        gen_istft_n_fft: int = 16,
+        sampling_rate: Number = 24000,
+        *args,
+        **kwargs,
+    ):
+        settings = {
+            "in_channels": in_channels,
+            "upsample_rates": upsample_rates,
+            "upsample_kernel_sizes": upsample_kernel_sizes,
+            "upsample_initial_channel": upsample_initial_channel,
+            "resblock_kernel_sizes": resblock_kernel_sizes,
+            "resblock_dilation_sizes": resblock_dilation_sizes,
+            "activation": activation,
+            "resblock": resblock,
+            "gen_istft_n_fft": gen_istft_n_fft,
+            "sampling_rate": sampling_rate,
+        }
+        super().__init__(**settings)
 
 
 def get_padding(ks, d):
@@ -10,9 +63,8 @@ def get_padding(ks, d):
 
 
 class ResBlock1(ConvNets):
-    def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5)):
+    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
         super().__init__()
-        self.h = h
         self.convs1 = nn.ModuleList(
             [
                 weight_norm(
@@ -95,10 +147,10 @@ class ResBlock1(ConvNets):
             x = xt + x
         return x
 
+
 class ResBlock2(ConvNets):
-    def __init__(self, h, channels, kernel_size=3, dilation=(1, 3)):
+    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
         super().__init__()
-        self.h = h
         self.convs = nn.ModuleList(
             [
                 weight_norm(
@@ -134,25 +186,25 @@ class ResBlock2(ConvNets):
         return x
 
 
-class iSTFTGenerator(ConvNets):
-    def __init__(self, h):
+class iSTFTNetGenerator(ConvNets):
+    def __init__(self, cfg: iSTFTNetConfig = iSTFTNetConfig()):
         super().__init__()
-        self.h = h
-        self.num_kernels = len(h.resblock_kernel_sizes)
-        self.num_upsamples = len(h.upsample_rates)
+        self.cfg = cfg
+        self.num_kernels = len(cfg.resblock_kernel_sizes)
+        self.num_upsamples = len(cfg.upsample_rates)
         self.conv_pre = weight_norm(
-            nn.Conv1d(80, h.upsample_initial_channel, 7, 1, padding=3)
+            nn.Conv1d(cfg.in_channels, cfg.upsample_initial_channel, 7, 1, padding=3)
         )
-        resblock = ResBlock1 if h.resblock == "1" else ResBlock2
+        resblock = ResBlock1 if cfg.resblock == 0 else ResBlock2
 
         self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(h.upsample_rates, h.upsample_kernel_sizes)):
-            if h.sampling_rate % 16000:
+        for i, (u, k) in enumerate(zip(cfg.upsample_rates, cfg.upsample_kernel_sizes)):
+            if cfg.sampling_rate % 16000:
                 self.ups.append(
                     weight_norm(
                         nn.ConvTranspose1d(
-                            h.upsample_initial_channel // (2**i),
-                            h.upsample_initial_channel // (2 ** (i + 1)),
+                            cfg.upsample_initial_channel // (2**i),
+                            cfg.upsample_initial_channel // (2 ** (i + 1)),
                             k,
                             u,
                             padding=(k - u) // 2,
@@ -163,8 +215,8 @@ class iSTFTGenerator(ConvNets):
                 self.ups.append(
                     weight_norm(
                         nn.ConvTranspose1d(
-                            h.upsample_initial_channel // (2**i),
-                            h.upsample_initial_channel // (2 ** (i + 1)),
+                            cfg.upsample_initial_channel // (2**i),
+                            cfg.upsample_initial_channel // (2 ** (i + 1)),
                             k,
                             u,
                             padding=(u // 2 + u % 2),
@@ -175,19 +227,19 @@ class iSTFTGenerator(ConvNets):
 
         self.resblocks = nn.ModuleList()
         for i in range(len(self.ups)):
-            ch = h.upsample_initial_channel // (2 ** (i + 1))
+            ch = cfg.upsample_initial_channel // (2 ** (i + 1))
             for j, (k, d) in enumerate(
-                zip(h.resblock_kernel_sizes, h.resblock_dilation_sizes)
+                zip(cfg.resblock_kernel_sizes, cfg.resblock_dilation_sizes)
             ):
-                self.resblocks.append(resblock(h, ch, k, d))
+                self.resblocks.append(resblock(ch, k, d))
 
-        self.post_n_fft = h.gen_istft_n_fft
+        self.post_n_fft = cfg.gen_istft_n_fft
         self.conv_post = weight_norm(
             nn.Conv1d(ch, self.post_n_fft + 2, 7, 1, padding=3)
         )
         self.ups.apply(self.init_weights)
         self.conv_post.apply(self.init_weights)
-        self.activation = nn.LeakyReLU(0.1)
+        self.activation = cfg.activation
         self.reflection_pad = torch.nn.ReflectionPad1d((1, 0))
 
     def forward(self, x):

{lt_tensor-0.0.1a17.dist-info → lt_tensor-0.0.1a19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lt-tensor
-Version: 0.0.1a17
+Version: 0.0.1a19
 Summary: General utilities for PyTorch and others. Built for general use.
 Home-page: https://github.com/gr1336/lt-tensor/
 Author: gr1336

{lt_tensor-0.0.1a17.dist-info → lt_tensor-0.0.1a19.dist-info}/RECORD

@@ -1,5 +1,5 @@
 lt_tensor/__init__.py,sha256=XxNCGcVL-haJyMpifr-GRaamo32R6jmqe3iOuS4ecfs,469
-lt_tensor/config_templates.py,sha256=xWZhktYVlkwvJVreqyACpWo-lJ5htG9vTZyqZ6OexzA,3899
+lt_tensor/config_templates.py,sha256=9hLt7OLq3z1y8FKNoGY_sIJHHnVoXsLcuI4x2zoE0Q4,3634
 lt_tensor/losses.py,sha256=zvkCOnE5XpF3v6ymivRIdqPTsMM5zc94ZMom7YDi3zM,4946
 lt_tensor/lr_schedulers.py,sha256=LSZzqrOOLzSthD8k-W4cYPJt0vCjmHkiJkLr5e3yRTE,3659
 lt_tensor/math_ops.py,sha256=TkD4WQG42KsQ9Fg7FXOjf8f-ixtW0apf2XjaooecVx4,2257
@@ -18,14 +18,14 @@ lt_tensor/model_zoo/fusion.py,sha256=usC1bcjQRNivDc8xzkIS5T1glm78OLcs2V_tPqfp-eI
 lt_tensor/model_zoo/pos_encoder.py,sha256=3d1EYLinCU9UAy-WuEWeYMGhMqaGknCiQ5qEmhw_UYM,4487
 lt_tensor/model_zoo/residual.py,sha256=i5V4ju7DB3WesKBVm6KH_LyPoKGDUOyo2Usfs-PyP58,9394
 lt_tensor/model_zoo/transformer.py,sha256=HUFoFFh7EQJErxdd9XIxhssdjvNVx2tNGDJOTUfwG2A,4301
-lt_tensor/model_zoo/audio_models/__init__.py,sha256=CmoakfBLoxqtJuYc1NYrB_z0x1kS2WQNaYQRmCaC5ko,40
-lt_tensor/model_zoo/audio_models/diffwave/__init__.py,sha256=8DbKJpQ44s9iPlajfs7_A2N1diYGXzkhet_wS4hX6mU,7421
-lt_tensor/model_zoo/audio_models/hifigan/__init__.py,sha256=BOBZSK2HFOdMcFyjrzwZi_TeAtBGIcpb8pQxiGlwLEE,12302
-lt_tensor/model_zoo/audio_models/istft/__init__.py,sha256=o7Ie1qI22u_g9t1252PX4vl4uF6JHynAJryuz2lAZE0,12920
+lt_tensor/model_zoo/audio_models/__init__.py,sha256=MoG9YjxLyvscq_6njK1ljGBletK9iedBXt66bplzW-s,83
+lt_tensor/model_zoo/audio_models/diffwave/__init__.py,sha256=vSrQJ0NXYvTbjOyjLjiMNy95Ib7VO1BJ5UqhoQ7dzYo,8032
+lt_tensor/model_zoo/audio_models/hifigan/__init__.py,sha256=JNebaYO3nsyyqpYCCOyL13zY2uxLY3NOCeNynF6-96k,13940
+lt_tensor/model_zoo/audio_models/istft/__init__.py,sha256=JdFChpPhURaI2qb9mDV6vzDcZN757FBGGtgzN3vxtJ0,14821
 lt_tensor/processors/__init__.py,sha256=4b9MxAJolXiJfSm20ZEspQTDm1tgLazwlPWA_jB1yLM,63
 lt_tensor/processors/audio.py,sha256=SMqNSl4Den-x1awTCQ8-TcR-0jPiv5lDaUpU93SRRaw,14749
-lt_tensor-0.0.1a17.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
-lt_tensor-0.0.1a17.dist-info/METADATA,sha256=nHIAMKShjCnhr2KdEiAhi8IIqP9PoTWnGHgsSfNcTDs,1033
-lt_tensor-0.0.1a17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lt_tensor-0.0.1a17.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
-lt_tensor-0.0.1a17.dist-info/RECORD,,
+lt_tensor-0.0.1a19.dist-info/licenses/LICENSE,sha256=HUnu_iSPpnDfZS_PINhO3AoVizJD1A2vee8WX7D7uXo,11358
+lt_tensor-0.0.1a19.dist-info/METADATA,sha256=lkXND2y0Ue6-y_1LDUcpbPWEJ9jnUG71zJMfcSwKdJs,1033
+lt_tensor-0.0.1a19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lt_tensor-0.0.1a19.dist-info/top_level.txt,sha256=35FuhFeXnUyvHWdbVHGPh0hS8euofafnJ_GJAVSF4Kk,10
+lt_tensor-0.0.1a19.dist-info/RECORD,,