nextrec 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

nextrec/__version__.py

@@ -1 +1 @@
-__version__ = "0.2.3"
+__version__ = "0.2.4"

nextrec/models/ranking/autoint.py

@@ -1,12 +1,57 @@
 """
 Date: create on 09/11/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Checkpoint: edit on 24/11/2025
+Author: Yang Zhou,zyaztec@gmail.com
 Reference:
-    [1] Song W, Shi C, Xiao Z, et al. Autoint: Automatic feature interaction learning via 
-        self-attentive neural networks[C]//Proceedings of the 28th ACM international conference 
-        on information and knowledge management. 2019: 1161-1170.
-        (https://arxiv.org/abs/1810.11921)
+[1] Song W, Shi C, Xiao Z, et al. Autoint: Automatic feature interaction learning via 
+self-attentive neural networks[C]//Proceedings of the 28th ACM international conference 
+on information and knowledge management. 2019: 1161-1170.
+(https://arxiv.org/abs/1810.11921)
+
+AutoInt is a CTR prediction model that leverages multi-head self-attention
+to automatically learn high-order feature interactions in an explicit and
+interpretable way. Instead of relying on manual feature engineering or
+implicit MLP-based transformations, AutoInt models feature dependencies
+by attending over all embedded fields and capturing their contextual
+relationships.
+
+In each Interacting Layer:
+  (1) Each field embedding is projected into multiple attention heads
+  (2) Scaled dot-product attention computes feature-to-feature interactions
+  (3) Outputs are aggregated and passed through residual connections
+  (4) Layer Normalization ensures stable optimization
+
+By stacking multiple Interacting Layers, AutoInt progressively discovers
+higher-order feature interactions, while maintaining transparency since
+attention weights explicitly show which features interact.
+
+Key Advantages:
+- Explicit modeling of high-order feature interactions
+- Multi-head attention enhances representation diversity
+- Residual structure facilitates deep interaction learning
+- Attention weights provide interpretability of feature relations
+- Eliminates heavy manual feature engineering
+
+AutoInt 是一个 CTR 预估模型，通过多头自注意力机制显式学习高阶特征交互，
+并具有良好的可解释性。不同于依赖人工特征工程或 MLP 隐式建模的方法，
+AutoInt 通过对所有特征 embedding 进行注意力计算，捕捉特征之间的上下文依赖关系。
+
+在每个 Interacting Layer（交互层）中：
+  (1) 每个特征 embedding 通过投影分成多个注意力头
+  (2) 使用缩放点积注意力计算特征间交互权重
+  (3) 将多头输出进行聚合，并使用残差连接
+  (4) Layer Normalization 确保训练稳定性
+
+通过堆叠多个交互层，AutoInt 能逐步学习更高阶的特征交互；
+同时由于注意力权重可视化，模型具有明确的可解释能力，
+能展示哪些特征之间的关系最重要。
+
+主要优点：
+- 显式建模高阶特征交互
+- 多头机制增强表示能力
+- 残差结构支持深层交互学习
+- 注意力权重天然具备可解释性
+- 减少繁重的人工特征工程工作
 """
 
 import torch
@@ -80,7 +125,6 @@ class AutoInt(BaseModel):
         
         # Project embeddings to attention embedding dimension
         num_fields = len(self.interaction_features)
-        total_embedding_dim = sum([f.embedding_dim for f in self.interaction_features])
         
         # If embeddings have different dimensions, project them to att_embedding_dim
         self.need_projection = not all(f.embedding_dim == att_embedding_dim for f in self.interaction_features)

nextrec/models/ranking/masknet.py

@@ -1,20 +1,142 @@
 """
 Date: create on 09/11/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Checkpoint: edit on 24/11/2025
+Author: Yang Zhou, zyaztec@gmail.com
 Reference:
-    [1] Pan Z, Sun F, Liu J, et al. MaskNet: Introducing feature-wise gating blocks for high-dimensional
-        sparse recommendation data (CCF-Tencent CTR competition solution, 2020).
+[1] Wang Z, She Q, Zhang J. MaskNet: Introducing Feature-Wise
+Multiplication to CTR Ranking Models by Instance-Guided Mask.
+
+MaskNet is a CTR prediction model that introduces instance-guided,
+feature-wise multiplicative interactions into deep ranking networks.
+Instead of relying solely on additive feature interactions from MLPs,
+MaskNet generates a personalized “mask” vector for each instance based
+on its embedding representation. This mask selectively scales hidden
+features through element-wise multiplication, enabling the network to
+emphasize informative dimensions and suppress irrelevant noise.
+
+Each MaskBlock consists of:
+  (1) Instance-Guided Mask Generation (two-layer MLP)
+  (2) Feature-wise Multiplication with hidden representations
+  (3) Layer Normalization and nonlinear transformation
+
+By stacking (SerialMaskNet) or parallelizing (ParallelMaskNet) multiple
+MaskBlocks, MaskNet enhances expressive power while remaining efficient,
+improving CTR performance without heavy feature engineering.
+
+Key Advantages:
+- Learns higher-order interactions via multiplicative gating
+- Instance-adaptive feature importance modulation
+- Better discrimination of informative vs. noisy dimensions
+- Flexible architecture for both sequential and parallel design
+
+MaskNet 是一种用于 CTR 预估的模型，它在深度排序网络中引入了
+基于实例（Instance-Guided）的特征级逐元素（Feature-wise）
+乘法交互机制。
+
+与传统仅依赖 MLP 的加性特征交互不同，MaskNet 会根据每个样本的
+embedding 表示生成一个个性化的 “mask” 向量，通过逐元素的乘法
+选择性地放大有效特征维度、抑制无关或噪声特征。
+
+每个 MaskBlock 包含以下关键步骤：
+  (1) 基于当前样本 embedding 的双层 MLP Mask 生成
+  (2) Mask 与隐藏表示之间的逐元素乘法交互
+  (3) Layer Normalization 与非线性变换
+
+通过串联（SerialMaskNet）或并联（ParallelMaskNet）
+多个 MaskBlock，MaskNet 在保持高效的同时显著增强了特征表达能力，
+在无需大量特征工程的情况下提升 CTR 模型性能。
+
+核心优势：
+- 通过乘法门控学习高阶特征交互关系
+- 针对每个样本自适应调整特征重要性
+- 有效区分信息特征与噪声特征
+- 支持灵活的串行与并行网络结构设计
 """
 
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
 
 from nextrec.basic.model import BaseModel
-from nextrec.basic.layers import EmbeddingLayer, LR, MLP, PredictionLayer
+from nextrec.basic.layers import EmbeddingLayer, MLP, PredictionLayer
 from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
 
 
+class InstanceGuidedMask(nn.Module):
+    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim, hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, output_dim)
+
+    def forward(self, v_emb_flat: torch.Tensor) -> torch.Tensor:
+        # v_emb_flat: [batch, features count * embedding_dim] 
+        x = self.fc1(v_emb_flat)
+        x = F.relu(x)
+        v_mask = self.fc2(x)
+        return v_mask
+
+class MaskBlockOnEmbedding(nn.Module):
+    def __init__(
+        self,
+        num_fields: int,
+        embedding_dim: int,
+        mask_hidden_dim: int,
+        hidden_dim: int,
+    ):
+        super().__init__()
+        self.num_fields = num_fields
+        self.embedding_dim = embedding_dim
+        self.input_dim = num_fields * embedding_dim  # input_dim = features count * embedding_dim
+        self.ln_emb = nn.LayerNorm(embedding_dim)
+        self.mask_gen = InstanceGuidedMask(input_dim=self.input_dim, hidden_dim=mask_hidden_dim, output_dim=self.input_dim,)
+        self.ffn = nn.Linear(self.input_dim, hidden_dim)
+        self.ln_hid = nn.LayerNorm(hidden_dim)
+
+    # different from MaskBlockOnHidden: input is field embeddings
+    def forward(self, field_emb: torch.Tensor, v_emb_flat: torch.Tensor) -> torch.Tensor:
+        B = field_emb.size(0)
+        norm_emb = self.ln_emb(field_emb)        # [B, features count, embedding_dim]
+        norm_emb_flat = norm_emb.view(B, -1)     # [B, features count * embedding_dim]
+        v_mask = self.mask_gen(v_emb_flat)       # [B, features count * embedding_dim]
+        v_masked_emb = v_mask * norm_emb_flat    # [B, features count * embedding_dim]
+        hidden = self.ffn(v_masked_emb)          # [B, hidden_dim]
+        hidden = self.ln_hid(hidden)
+        hidden = F.relu(hidden)
+
+        return hidden
+
+
+class MaskBlockOnHidden(nn.Module):
+    def __init__(
+        self,
+        num_fields: int,
+        embedding_dim: int,
+        mask_hidden_dim: int,
+        hidden_dim: int,
+    ):
+        super().__init__()
+        self.num_fields = num_fields
+        self.embedding_dim = embedding_dim
+        self.hidden_dim = hidden_dim
+        self.v_emb_dim = num_fields * embedding_dim
+
+        self.ln_input = nn.LayerNorm(hidden_dim)
+        self.ln_output = nn.LayerNorm(hidden_dim)
+
+        self.mask_gen = InstanceGuidedMask(input_dim=self.v_emb_dim, hidden_dim=mask_hidden_dim, output_dim=hidden_dim,)
+        self.ffn = nn.Linear(hidden_dim, hidden_dim)
+
+    # different from MaskBlockOnEmbedding: input is hidden representation
+    def forward(self, hidden_in: torch.Tensor, v_emb_flat: torch.Tensor) -> torch.Tensor:
+        norm_hidden = self.ln_input(hidden_in)  
+        v_mask = self.mask_gen(v_emb_flat)
+        v_masked_hid = v_mask * norm_hidden     
+        out = self.ffn(v_masked_hid)  
+        out = self.ln_output(out)
+        out = F.relu(out)
+        return out
+
+
 class MaskNet(BaseModel):
     @property
     def model_name(self):
@@ -23,28 +145,38 @@ class MaskNet(BaseModel):
     @property
     def task_type(self):
         return "binary"
-    
-    def __init__(self,
-                 dense_features: list[DenseFeature] | list = [],
-                 sparse_features: list[SparseFeature] | list = [],
-                 sequence_features: list[SequenceFeature] | list = [],
-                 num_blocks: int = 3,
-                 mask_hidden_dim: int = 64,
-                 block_dropout: float = 0.1,
-                 mlp_params: dict = {},
-                 target: list[str] | list = [],
-                 optimizer: str = "adam",
-                 optimizer_params: dict = {},
-                 loss: str | nn.Module | None = "bce",
-                 loss_params: dict | list[dict] | None = None,
-                 device: str = 'cpu',
-                 embedding_l1_reg=1e-6,
-                 dense_l1_reg=1e-5,
-                 embedding_l2_reg=1e-5,
-                 dense_l2_reg=1e-4,
-                 **kwargs):
-        
-        super(MaskNet, self).__init__(
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature] | None = None,
+        sparse_features: list[SparseFeature] | None = None,
+        sequence_features: list[SequenceFeature] | None = None,
+        model_type: str = "parallel",         # "serial" or "parallel"
+        num_blocks: int = 3,
+        mask_hidden_dim: int = 64,
+        block_hidden_dim: int = 256,
+        block_dropout: float = 0.0,
+        mlp_params: dict | None = None,
+        target: list[str] | None = None,
+        optimizer: str = "adam",
+        optimizer_params: dict | None = None,
+        loss: str | nn.Module | None = "bce",
+        loss_params: dict | list[dict] | None = None,
+        device: str = "cpu",
+        embedding_l1_reg: float = 1e-6,
+        dense_l1_reg: float = 1e-5,
+        embedding_l2_reg: float = 1e-5,
+        dense_l2_reg: float = 1e-4,
+        **kwargs,
+    ):
+        dense_features = dense_features or []
+        sparse_features = sparse_features or []
+        sequence_features = sequence_features or []
+        target = target or []
+        mlp_params = mlp_params or {}
+        optimizer_params = optimizer_params or {}
+
+        super().__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
@@ -56,45 +188,99 @@ class MaskNet(BaseModel):
             embedding_l2_reg=embedding_l2_reg,
             dense_l2_reg=dense_l2_reg,
             early_stop_patience=20,
-            **kwargs
+            **kwargs,
         )
 
+        if loss is None:
+            loss = "bce"
         self.loss = loss
-        if self.loss is None:
-            self.loss = "bce"
-            
-        self.mask_features = sparse_features + sequence_features
-        if len(self.mask_features) == 0:
-            raise ValueError("MaskNet requires at least one sparse/sequence feature.")
+
+        self.dense_features = dense_features
+        self.sparse_features = sparse_features
+        self.sequence_features = sequence_features
+        self.mask_features = self.sparse_features + self.sequence_features + self.dense_features
+        assert len(self.mask_features) > 0, "MaskNet requires at least one feature for masking."
 
         self.embedding = EmbeddingLayer(features=self.mask_features)
+
         self.num_fields = len(self.mask_features)
-        self.embedding_dim = self.mask_features[0].embedding_dim
-        if any(f.embedding_dim != self.embedding_dim for f in self.mask_features):
-            raise ValueError("MaskNet expects identical embedding_dim across mask_features.")
 
-        self.num_blocks = max(1, num_blocks)
-        self.field_dim = self.num_fields * self.embedding_dim
-
-        self.linear = LR(self.field_dim)
-        self.mask_generators = nn.ModuleList()
-        for _ in range(self.num_blocks):
-            self.mask_generators.append(
-                nn.Sequential(
-                    nn.Linear(self.field_dim, mask_hidden_dim),
-                    nn.ReLU(),
-                    nn.Linear(mask_hidden_dim, self.num_fields)
+        self.embedding_dim = getattr(self.mask_features[0], "embedding_dim", None)
+        assert self.embedding_dim is not None, "MaskNet requires mask_features to have 'embedding_dim' defined."
+
+        for f in self.mask_features:
+            edim = getattr(f, "embedding_dim", None)
+            if edim is None or edim != self.embedding_dim:
+                raise ValueError(
+                    f"MaskNet expects identical embedding_dim across all mask_features, "
+                    f"but got {edim} for feature {getattr(f, 'name', type(f))}."
                 )
+
+        self.v_emb_dim = self.num_fields * self.embedding_dim
+
+        self.model_type = model_type.lower()
+        assert self.model_type in ("serial", "parallel"), "model_type must be either 'serial' or 'parallel'."
+
+        self.num_blocks = max(1, num_blocks)
+        self.block_hidden_dim = block_hidden_dim
+        self.block_dropout = nn.Dropout(block_dropout) if block_dropout > 0 else nn.Identity()
+
+        if self.model_type == "serial":
+            self.first_block = MaskBlockOnEmbedding(
+                num_fields=self.num_fields,
+                embedding_dim=self.embedding_dim,
+                mask_hidden_dim=mask_hidden_dim,
+                hidden_dim=block_hidden_dim,
+            )
+
+            self.hidden_blocks = nn.ModuleList(
+                [
+                    MaskBlockOnHidden(
+                        num_fields=self.num_fields,
+                        embedding_dim=self.embedding_dim,
+                        mask_hidden_dim=mask_hidden_dim,
+                        hidden_dim=block_hidden_dim,
+                    )
+                    for _ in range(self.num_blocks - 1)
+                ]
+            )
+
+            self.mask_blocks = nn.ModuleList([self.first_block, *self.hidden_blocks])
+            self.output_layer = nn.Linear(block_hidden_dim, 1)
+            self.final_mlp = None
+
+        else:  # parallel
+            self.mask_blocks = nn.ModuleList(
+                [
+                    MaskBlockOnEmbedding(
+                        num_fields=self.num_fields,
+                        embedding_dim=self.embedding_dim,
+                        mask_hidden_dim=mask_hidden_dim,
+                        hidden_dim=block_hidden_dim,
+                    )
+                    for _ in range(self.num_blocks)
+                ]
             )
 
-        self.block_dropout = nn.Dropout(block_dropout)
-        self.final_mlp = MLP(input_dim=self.field_dim * self.num_blocks, **mlp_params)
+            self.final_mlp = MLP(
+                input_dim=self.num_blocks * block_hidden_dim,
+                **mlp_params,
+            )
+            self.output_layer = None
+
         self.prediction_layer = PredictionLayer(task_type=self.task_type)
 
-        self._register_regularization_weights(
-            embedding_attr='embedding',
-            include_modules=['linear', 'mask_generators', 'final_mlp']
-        )
+        if self.model_type == "serial":
+            self._register_regularization_weights(
+                embedding_attr="embedding",
+                include_modules=["mask_blocks", "output_layer"],
+            )
+        # serial
+        else:
+            self._register_regularization_weights(
+                embedding_attr="embedding",
+                include_modules=["mask_blocks", "final_mlp"],
+            )
 
         self.compile(
             optimizer=optimizer,
@@ -103,25 +289,31 @@ class MaskNet(BaseModel):
             loss_params=loss_params,
         )
 
-    def forward(self, x):
+    def forward(self, x: dict[str, torch.Tensor]) -> torch.Tensor:
         field_emb = self.embedding(x=x, features=self.mask_features, squeeze_dim=False)
-        flat_input = field_emb.flatten(start_dim=1)
-        y_linear = self.linear(flat_input)
-
-        block_input = field_emb
-        mask_input = flat_input
-        block_outputs = []
-        for mask_gen in self.mask_generators:
-            mask_logits = mask_gen(mask_input)
-            mask = torch.sigmoid(mask_logits).unsqueeze(-1)
-            masked_emb = block_input * mask
-            block_output = self.block_dropout(masked_emb.flatten(start_dim=1))
-            block_outputs.append(block_output)
-            mask_input = block_output
-            block_input = masked_emb.view_as(field_emb)
-
-        stacked = torch.cat(block_outputs, dim=1)
-        y_deep = self.final_mlp(stacked)
-
-        y = y_linear + y_deep
-        return self.prediction_layer(y)
+        B = field_emb.size(0)
+        v_emb_flat = field_emb.view(B, -1)  # flattened embeddings 
+
+        if self.model_type == "parallel":
+            block_outputs = []
+            for block in self.mask_blocks:
+                h = block(field_emb, v_emb_flat)  # [B, block_hidden_dim]
+                h = self.block_dropout(h)
+                block_outputs.append(h)
+
+            concat_hidden = torch.cat(block_outputs, dim=-1)
+            logit = self.final_mlp(concat_hidden)  # [B, 1]
+
+        # serial
+        else: 
+            hidden = self.first_block(field_emb, v_emb_flat)
+            hidden = self.block_dropout(hidden)
+
+            for block in self.hidden_blocks:
+                hidden = block(hidden, v_emb_flat)
+                hidden = self.block_dropout(hidden)
+
+            logit = self.output_layer(hidden)  # [B, 1]
+
+        y = self.prediction_layer(logit)
+        return y

{nextrec-0.2.3.dist-info → nextrec-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.2.3
+Version: 0.2.4
 Summary: A comprehensive recommendation library with match, ranking, and multi-task learning models
 Project-URL: Homepage, https://github.com/zerolovesea/NextRec
 Project-URL: Repository, https://github.com/zerolovesea/NextRec
@@ -61,7 +61,7 @@ Description-Content-Type: text/markdown
 ![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)
 ![PyTorch](https://img.shields.io/badge/PyTorch-1.10+-ee4c2c.svg)
 ![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)
-![Version](https://img.shields.io/badge/Version-0.2.3-orange.svg)
+![Version](https://img.shields.io/badge/Version-0.2.4-orange.svg)
 
 English | [中文版](README_zh.md)
 

{nextrec-0.2.3.dist-info → nextrec-0.2.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 nextrec/__init__.py,sha256=CvocnY2uBp0cjNkhrT6ogw0q2bN9s1GNp754FLO-7lo,1117
-nextrec/__version__.py,sha256=PNiDER4qM19h9zdsdfgKt2_dT4WgYK7EguJ8RU2qA_g,22
+nextrec/__version__.py,sha256=SBl2EPFW-ltPvQ7vbVWItyAsz3aKYIpjO7vcfr84GkU,22
 nextrec/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextrec/basic/activation.py,sha256=9EfYmwE0brTSKwx_0FIGQ_rybFBT9n_G-UWA7NAhMsI,2804
 nextrec/basic/callback.py,sha256=qkq3k8rP0g4BW2C3FSCdVt_CyCcJwJ-rUXjhT2p4LP8,1035
@@ -32,14 +32,14 @@ nextrec/models/multi_task/ple.py,sha256=otP6oLgzrJhwkLFItzNE-AtIPouObDkafRvWzTCx
 nextrec/models/multi_task/share_bottom.py,sha256=LL5HBVlvvBzHV2fLBRQMGIwpqmlxILTgU4c51XyTCo4,4517
 nextrec/models/ranking/__init__.py,sha256=-qe34zQEVwmxeTPGYCa6gbql9quT8DwB7-buHfA7Iig,428
 nextrec/models/ranking/afm.py,sha256=r9m1nEnc0m5d4pMtOxRMqOaXaBNCEkjJBFB-5wSHeFA,4540
-nextrec/models/ranking/autoint.py,sha256=GYzRynjn6Csq4b3qYIFWxLQ4Yl57_OQBeF2IY0Zhr9Q,5654
+nextrec/models/ranking/autoint.py,sha256=TyA45mnXP7pZHhY6AbyK84qLpniGFXst7v7E_RlYiZM,7754
 nextrec/models/ranking/dcn.py,sha256=dUV5GbHypBGc9vVozk6aGYfIXq23c0deX-HFnIhZueg,4208
 nextrec/models/ranking/deepfm.py,sha256=y28yJxF__TZR3O1G2ufKZVtBRLgCgmlXWqvPgLzwm3U,3510
 nextrec/models/ranking/dien.py,sha256=E6s9TDwQfGSwtzzh8hG2F5gwgVxzVZPcptYvHLNzOLA,8475
 nextrec/models/ranking/din.py,sha256=j5tkT5k91CbsMlMr5vJOySrcY2_rFGxmEgJJ0McW7-Q,7196
 nextrec/models/ranking/fibinet.py,sha256=X6CbQbritvq5jql_Tvs4bn_tRla2zpWPplftZv8k6f0,4853
 nextrec/models/ranking/fm.py,sha256=3Qx_Fgowegr6UPQtEeTmHtOrbWzkvqH94ZTjOqRLu-E,2961
-nextrec/models/ranking/masknet.py,sha256=Bu0mZl2vKqcGnqCuUjPHjPRd1f-cDTeVwFj8Y_6v3C8,4639
+nextrec/models/ranking/masknet.py,sha256=hU3m270vd9DWH2_Hh1hYiCGaF9fKC3eIsWQLSA-Gdf8,12215
 nextrec/models/ranking/pnn.py,sha256=5RxIKdxD0XcGq-b_QDdwGRwk6b_5BQjyMvCw3Ibv2Kk,4957
 nextrec/models/ranking/widedeep.py,sha256=b6ctElaZPv5WSYDA4piYUBo3je0eJpWpWECwcuWavM4,3716
 nextrec/models/ranking/xdeepfm.py,sha256=I00J5tfE4tPluqeW-qrNtE4V_9fC7-rgFvA0Fxqka7o,4274
@@ -47,7 +47,7 @@ nextrec/utils/__init__.py,sha256=6x3OZbqks2gtgJd00y_-Y8QiAT42x5t14ARHQ-ULQDo,350
 nextrec/utils/embedding.py,sha256=yxYSdFx0cJITh3Gf-K4SdhwRtKGcI0jOsyBgZ0NLa_c,465
 nextrec/utils/initializer.py,sha256=ffYOs5QuIns_d_-5e40iNtg6s1ftgREJN-ueq_NbDQE,1647
 nextrec/utils/optimizer.py,sha256=85ifoy2IQgjPHOqLqr1ho7XBGE_0ry1yEB9efS6C2lM,2446
-nextrec-0.2.3.dist-info/METADATA,sha256=SpkwkLdg4MQLeysCCr_0fJXak-Vo139Cz3HFLXR-4Z0,11425
-nextrec-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nextrec-0.2.3.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
-nextrec-0.2.3.dist-info/RECORD,,
+nextrec-0.2.4.dist-info/METADATA,sha256=VurhzAYPQ_PbBi6WJFHvgbbk08OVd_1udwLPHxqApag,11425
+nextrec-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nextrec-0.2.4.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
+nextrec-0.2.4.dist-info/RECORD,,