nextrec 0.4.9__py3-none-any.whl → 0.4.10__py3-none-any.whl

nextrec/__version__.py

@@ -1 +1 @@
-__version__ = "0.4.9"
+__version__ = "0.4.10"

nextrec/basic/model.py

@@ -1376,7 +1376,7 @@ class BaseModel(FeatureSet, nn.Module):
                 data=data,
                 batch_size=batch_size,
                 shuffle=False,
-                load_full=False,
+                streaming=True,
                 chunk_size=streaming_chunk_size,
             )
         else:
@@ -1510,7 +1510,7 @@ class BaseModel(FeatureSet, nn.Module):
                 data=data,
                 batch_size=batch_size,
                 shuffle=False,
-                load_full=False,
+                streaming=True,
                 chunk_size=streaming_chunk_size,
             )
         elif not isinstance(data, DataLoader):
@@ -1605,7 +1605,8 @@ class BaseModel(FeatureSet, nn.Module):
                 if collected_frames
                 else pd.DataFrame(columns=pred_columns or [])
             )
-        return pd.DataFrame(columns=pred_columns or [])
+        # Return the actual save path when not returning dataframe
+        return target_path
 
     def save_model(
         self,

nextrec/cli.py

@@ -29,7 +29,7 @@ from typing import Any, Dict, List
 import pandas as pd
 
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
-from nextrec.basic.loggers import setup_logger
+from nextrec.basic.loggers import colorize, format_kv, setup_logger
 from nextrec.data.data_utils import split_dict_random
 from nextrec.data.dataloader import RecDataLoader
 from nextrec.data.preprocessor import DataProcessor
@@ -52,6 +52,17 @@ from nextrec.utils.feature import normalize_to_list
 logger = logging.getLogger(__name__)
 
 
+def log_cli_section(title: str) -> None:
+    logger.info("")
+    logger.info(colorize(f"[{title}]", color="bright_blue", bold=True))
+    logger.info(colorize("-" * 80, color="bright_blue"))
+
+
+def log_kv_lines(items: list[tuple[str, Any]]) -> None:
+    for label, value in items:
+        logger.info(format_kv(label, value))
+
+
 def train_model(train_config_path: str) -> None:
     """
     Train a NextRec model using the provided configuration file.
@@ -74,8 +85,17 @@ def train_model(train_config_path: str) -> None:
     artifact_root = Path(session_cfg.get("artifact_root", "nextrec_logs"))
     session_dir = artifact_root / session_id
     setup_logger(session_id=session_id)
-    logger.info(
-        f"[NextRec CLI] Training start | version={get_nextrec_version()} | session_id={session_id} | artifacts={session_dir.resolve()}"
+
+    log_cli_section("CLI")
+    log_kv_lines(
+        [
+            ("Mode", "train"),
+            ("Version", get_nextrec_version()),
+            ("Session ID", session_id),
+            ("Artifacts", session_dir.resolve()),
+            ("Config", config_file.resolve()),
+            ("Command", " ".join(sys.argv)),
+        ]
     )
 
     processor_path = session_dir / "processor.pkl"
@@ -102,11 +122,53 @@ def train_model(train_config_path: str) -> None:
         cfg.get("model_config", "model_config.yaml"), config_dir
     )
 
+    log_cli_section("Config")
+    log_kv_lines(
+        [
+            ("Train config", config_file.resolve()),
+            ("Feature config", feature_cfg_path),
+            ("Model config", model_cfg_path),
+        ]
+    )
+
     feature_cfg = read_yaml(feature_cfg_path)
     model_cfg = read_yaml(model_cfg_path)
 
+    # Extract id_column from data config for GAUC metrics
+    id_column = data_cfg.get("id_column") or data_cfg.get("user_id_column")
+    id_columns = [id_column] if id_column else []
+
+    log_cli_section("Data")
+    log_kv_lines(
+        [
+            ("Data path", data_path),
+            ("Format", data_cfg.get("format", "auto")),
+            ("Streaming", streaming),
+            ("Target", target),
+            ("ID column", id_column or "(not set)"),
+        ]
+    )
+    if data_cfg.get("valid_ratio") is not None:
+        logger.info(format_kv("Valid ratio", data_cfg.get("valid_ratio")))
+    if data_cfg.get("val_path") or data_cfg.get("valid_path"):
+        logger.info(
+            format_kv(
+                "Validation path",
+                resolve_path(
+                    data_cfg.get("val_path") or data_cfg.get("valid_path"), config_dir
+                ),
+            )
+        )
+
     if streaming:
         file_paths, file_type = resolve_file_paths(str(data_path))
+        log_kv_lines(
+            [
+                ("File type", file_type),
+                ("Files", len(file_paths)),
+                ("Chunk size", dataloader_chunk_size),
+            ]
+        )
         first_file = file_paths[0]
         first_chunk_size = max(1, min(dataloader_chunk_size, 1000))
         chunk_iter = iter_file_chunks(first_file, file_type, first_chunk_size)
@@ -118,14 +180,12 @@ def train_model(train_config_path: str) -> None:
 
     else:
         df = read_table(data_path, data_cfg.get("format"))
+        logger.info(format_kv("Rows", len(df)))
+        logger.info(format_kv("Columns", len(df.columns)))
         df_columns = list(df.columns)
 
     dense_names, sparse_names, sequence_names = select_features(feature_cfg, df_columns)
 
-    # Extract id_column from data config for GAUC metrics
-    id_column = data_cfg.get("id_column") or data_cfg.get("user_id_column")
-    id_columns = [id_column] if id_column else []
-
     used_columns = dense_names + sparse_names + sequence_names + target + id_columns
 
     # keep order but drop duplicates
@@ -141,6 +201,17 @@ def train_model(train_config_path: str) -> None:
         processor, feature_cfg, dense_names, sparse_names, sequence_names
     )
 
+    log_cli_section("Features")
+    log_kv_lines(
+        [
+            ("Dense features", len(dense_names)),
+            ("Sparse features", len(sparse_names)),
+            ("Sequence features", len(sequence_names)),
+            ("Targets", len(target)),
+            ("Used columns", len(unique_used_columns)),
+        ]
+    )
+
     if streaming:
         processor.fit(str(data_path), chunk_size=dataloader_chunk_size)
         processed = None
@@ -244,7 +315,7 @@ def train_model(train_config_path: str) -> None:
             data=train_stream_source,
             batch_size=dataloader_cfg.get("train_batch_size", 512),
             shuffle=dataloader_cfg.get("train_shuffle", True),
-            load_full=False,
+            streaming=True,
             chunk_size=dataloader_chunk_size,
             num_workers=dataloader_cfg.get("num_workers", 0),
         )
@@ -255,7 +326,7 @@ def train_model(train_config_path: str) -> None:
                 data=str(val_data_resolved),
                 batch_size=dataloader_cfg.get("valid_batch_size", 512),
                 shuffle=dataloader_cfg.get("valid_shuffle", False),
-                load_full=False,
+                streaming=True,
                 chunk_size=dataloader_chunk_size,
                 num_workers=dataloader_cfg.get("num_workers", 0),
             )
@@ -264,7 +335,7 @@ def train_model(train_config_path: str) -> None:
                 data=streaming_valid_files,
                 batch_size=dataloader_cfg.get("valid_batch_size", 512),
                 shuffle=dataloader_cfg.get("valid_shuffle", False),
-                load_full=False,
+                streaming=True,
                 chunk_size=dataloader_chunk_size,
                 num_workers=dataloader_cfg.get("num_workers", 0),
             )
@@ -295,6 +366,15 @@ def train_model(train_config_path: str) -> None:
         device,
     )
 
+    log_cli_section("Model")
+    log_kv_lines(
+        [
+            ("Model", model.__class__.__name__),
+            ("Device", device),
+            ("Session ID", session_id),
+        ]
+    )
+
     model.compile(
         optimizer=train_cfg.get("optimizer", "adam"),
         optimizer_params=train_cfg.get("optimizer_params", {}),
@@ -325,13 +405,30 @@ def predict_model(predict_config_path: str) -> None:
     config_dir = config_file.resolve().parent
     cfg = read_yaml(config_file)
 
-    session_cfg = cfg.get("session", {}) or {}
-    session_id = session_cfg.get("id", "masknet_tutorial")
-    artifact_root = Path(session_cfg.get("artifact_root", "nextrec_logs"))
-    session_dir = Path(cfg.get("checkpoint_path") or (artifact_root / session_id))
+    # Checkpoint path is the primary configuration
+    if "checkpoint_path" not in cfg:
+        session_cfg = cfg.get("session", {}) or {}
+        session_id = session_cfg.get("id", "nextrec_session")
+        artifact_root = Path(session_cfg.get("artifact_root", "nextrec_logs"))
+        session_dir = artifact_root / session_id
+    else:
+        session_dir = Path(cfg["checkpoint_path"])
+        # Auto-infer session_id from checkpoint directory name
+        session_cfg = cfg.get("session", {}) or {}
+        session_id = session_cfg.get("id") or session_dir.name
+    
     setup_logger(session_id=session_id)
-    logger.info(
-        f"[NextRec CLI] Predict start | version={get_nextrec_version()} | session_id={session_id} | checkpoint={session_dir.resolve()}"
+
+    log_cli_section("CLI")
+    log_kv_lines(
+        [
+            ("Mode", "predict"),
+            ("Version", get_nextrec_version()),
+            ("Session ID", session_id),
+            ("Checkpoint", session_dir.resolve()),
+            ("Config", config_file.resolve()),
+            ("Command", " ".join(sys.argv)),
+        ]
     )
 
     processor_path = Path(session_dir / "processor.pkl")
@@ -339,24 +436,38 @@ def predict_model(predict_config_path: str) -> None:
         processor_path = session_dir / "processor" / "processor.pkl"
 
     predict_cfg = cfg.get("predict", {}) or {}
-    model_cfg_path = resolve_path(
-        cfg.get("model_config", "model_config.yaml"), config_dir
-    )
-    # feature_cfg_path = resolve_path(
-    #     cfg.get("feature_config", "feature_config.yaml"), config_dir
-    # )
+    
+    # Auto-find model_config in checkpoint directory if not specified
+    if "model_config" in cfg:
+        model_cfg_path = resolve_path(cfg["model_config"], config_dir)
+    else:
+        # Try to find model_config.yaml in checkpoint directory
+        auto_model_cfg = session_dir / "model_config.yaml"
+        if auto_model_cfg.exists():
+            model_cfg_path = auto_model_cfg
+        else:
+            # Fallback to config directory
+            model_cfg_path = resolve_path("model_config.yaml", config_dir)
 
     model_cfg = read_yaml(model_cfg_path)
-    # feature_cfg = read_yaml(feature_cfg_path)
     model_cfg.setdefault("session_id", session_id)
     model_cfg.setdefault("params", {})
 
+    log_cli_section("Config")
+    log_kv_lines(
+        [
+            ("Predict config", config_file.resolve()),
+            ("Model config", model_cfg_path),
+            ("Processor", processor_path),
+        ]
+    )
+
     processor = DataProcessor.load(processor_path)
 
     # Load checkpoint and ensure required parameters are passed
     checkpoint_base = Path(session_dir)
     if checkpoint_base.is_dir():
-        candidates = sorted(checkpoint_base.glob("*.model"))
+        candidates = sorted(checkpoint_base.glob("*.pt"))
         if not candidates:
             raise FileNotFoundError(
                 f"[NextRec CLI Error]: Unable to find model checkpoint: {checkpoint_base}"
@@ -365,7 +476,7 @@ def predict_model(predict_config_path: str) -> None:
         config_dir_for_features = checkpoint_base
     else:
         model_file = (
-            checkpoint_base.with_suffix(".model")
+            checkpoint_base.with_suffix(".pt")
             if checkpoint_base.suffix == ""
             else checkpoint_base
         )
@@ -415,40 +526,78 @@ def predict_model(predict_config_path: str) -> None:
         id_columns = [predict_cfg["id_column"]]
         model.id_columns = id_columns
 
+    effective_id_columns = id_columns or model.id_columns
+    log_cli_section("Features")
+    log_kv_lines(
+        [
+            ("Dense features", len(dense_features)),
+            ("Sparse features", len(sparse_features)),
+            ("Sequence features", len(sequence_features)),
+            ("Targets", len(target_cols)),
+            ("ID columns", len(effective_id_columns)),
+        ]
+    )
+
+    log_cli_section("Model")
+    log_kv_lines(
+        [
+            ("Model", model.__class__.__name__),
+            ("Checkpoint", model_file),
+            ("Device", predict_cfg.get("device", "cpu")),
+        ]
+    )
+
     rec_dataloader = RecDataLoader(
         dense_features=model.dense_features,
         sparse_features=model.sparse_features,
         sequence_features=model.sequence_features,
         target=None,
-        id_columns=id_columns or model.id_columns,
+        id_columns=effective_id_columns,
         processor=processor,
     )
 
     data_path = resolve_path(predict_cfg["data_path"], config_dir)
     batch_size = predict_cfg.get("batch_size", 512)
 
+    log_cli_section("Data")
+    log_kv_lines(
+        [
+            ("Data path", data_path),
+            ("Format", predict_cfg.get("source_data_format", predict_cfg.get("data_format", "auto"))),
+            ("Batch size", batch_size),
+            ("Chunk size", predict_cfg.get("chunk_size", 20000)),
+            ("Streaming", predict_cfg.get("streaming", True)),
+        ]
+    )
+    logger.info("")
     pred_loader = rec_dataloader.create_dataloader(
         data=str(data_path),
         batch_size=batch_size,
         shuffle=False,
-        load_full=predict_cfg.get("load_full", False),
+        streaming=predict_cfg.get("streaming", True),
         chunk_size=predict_cfg.get("chunk_size", 20000),
     )
 
-    output_path = resolve_path(predict_cfg["output_path"], config_dir)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
+    # Build output path: {checkpoint_path}/predictions/{name}.{save_data_format}
+    save_format = predict_cfg.get("save_data_format", predict_cfg.get("save_format", "csv"))
+    pred_name = predict_cfg.get("name", "pred")
+    # Pass filename with extension to let model.predict handle path resolution
+    save_path = f"{pred_name}.{save_format}"
 
     start = time.time()
-    model.predict(
+    logger.info("")
+    result = model.predict(
         data=pred_loader,
         batch_size=batch_size,
         include_ids=bool(id_columns),
         return_dataframe=False,
-        save_path=output_path,
-        save_format=predict_cfg.get("save_format", "csv"),
+        save_path=save_path,
+        save_format=save_format,
         num_workers=predict_cfg.get("num_workers", 0),
     )
     duration = time.time() - start
+    # When return_dataframe=False, result is the actual file path
+    output_path = result if isinstance(result, Path) else checkpoint_base / "predictions" / save_path
     logger.info(f"Prediction completed, results saved to: {output_path}")
     logger.info(f"Total time: {duration:.2f} seconds")
 
@@ -492,8 +641,6 @@ Examples:
     parser.add_argument("--predict_config", help="Prediction configuration file path")
     args = parser.parse_args()
 
-    logger.info(get_nextrec_version())
-
     if not args.mode:
         parser.error("[NextRec CLI Error] --mode is required (train|predict)")
 

nextrec/data/dataloader.py

@@ -102,9 +102,8 @@ class FileDataset(FeatureSet, IterableDataset):
         self.current_file_index = 0
         for file_path in self.file_paths:
             self.current_file_index += 1
-            if self.total_files == 1:
-                file_name = os.path.basename(file_path)
-                logging.info(f"Processing file: {file_name}")
+            # Don't log file processing here to avoid interrupting progress bars
+            # File information is already displayed in the CLI data section
             if self.file_type == "csv":
                 yield from self.read_csv_chunks(file_path)
             elif self.file_type == "parquet":
@@ -190,7 +189,7 @@ class RecDataLoader(FeatureSet):
         ),
         batch_size: int = 32,
         shuffle: bool = True,
-        load_full: bool = True,
+        streaming: bool = False,
         chunk_size: int = 10000,
         num_workers: int = 0,
         sampler=None,
@@ -202,7 +201,7 @@ class RecDataLoader(FeatureSet):
             data: Data source, can be a dict, pd.DataFrame, file path (str), or existing DataLoader.
             batch_size: Batch size for DataLoader.
             shuffle: Whether to shuffle the data (ignored in streaming mode).
-            load_full: If True, load full data into memory; if False, use streaming mode for large files.
+            streaming: If True, use streaming mode for large files; if False, load full data into memory.
             chunk_size: Chunk size for streaming mode (number of rows per chunk).
             num_workers: Number of worker processes for data loading.
             sampler: Optional sampler for DataLoader, only used for distributed training.
@@ -217,7 +216,7 @@ class RecDataLoader(FeatureSet):
                 path=data,
                 batch_size=batch_size,
                 shuffle=shuffle,
-                load_full=load_full,
+                streaming=streaming,
                 chunk_size=chunk_size,
                 num_workers=num_workers,
             )
@@ -230,7 +229,7 @@ class RecDataLoader(FeatureSet):
                 path=data,
                 batch_size=batch_size,
                 shuffle=shuffle,
-                load_full=load_full,
+                streaming=streaming,
                 chunk_size=chunk_size,
                 num_workers=num_workers,
             )
@@ -290,7 +289,7 @@ class RecDataLoader(FeatureSet):
         path: str | os.PathLike | list[str] | list[os.PathLike],
         batch_size: int,
         shuffle: bool,
-        load_full: bool,
+        streaming: bool,
         chunk_size: int = 10000,
         num_workers: int = 0,
     ) -> DataLoader:
@@ -311,8 +310,17 @@ class RecDataLoader(FeatureSet):
                     f"[RecDataLoader Error] Unsupported file extension in list: {suffix}"
                 )
             file_type = "csv" if suffix == ".csv" else "parquet"
+        if streaming:
+            return self.load_files_streaming(
+                file_paths,
+                file_type,
+                batch_size,
+                chunk_size,
+                shuffle,
+                num_workers=num_workers,
+            )
         # Load full data into memory
-        if load_full:
+        else:
             dfs = []
             total_bytes = 0
             for file_path in file_paths:
@@ -325,26 +333,17 @@ class RecDataLoader(FeatureSet):
                     dfs.append(df)
                 except MemoryError as exc:
                     raise MemoryError(
-                        f"[RecDataLoader Error] Out of memory while reading {file_path}. Consider using load_full=False with streaming."
+                        f"[RecDataLoader Error] Out of memory while reading {file_path}. Consider using streaming=True."
                     ) from exc
             try:
                 combined_df = pd.concat(dfs, ignore_index=True)
             except MemoryError as exc:
                 raise MemoryError(
-                    f"[RecDataLoader Error] Out of memory while concatenating loaded data (approx {total_bytes / (1024**3):.2f} GB). Use load_full=False to stream or reduce chunk_size."
+                    f"[RecDataLoader Error] Out of memory while concatenating loaded data (approx {total_bytes / (1024**3):.2f} GB). Use streaming=True or reduce chunk_size."
                 ) from exc
             return self.create_from_memory(
                 combined_df, batch_size, shuffle, num_workers=num_workers
             )
-        else:
-            return self.load_files_streaming(
-                file_paths,
-                file_type,
-                batch_size,
-                chunk_size,
-                shuffle,
-                num_workers=num_workers,
-            )
 
     def load_files_streaming(
         self,

nextrec/models/ranking/deepfm.py

@@ -1,12 +1,11 @@
 """
 Date: create on 27/10/2025
 Checkpoint: edit on 24/11/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 Reference:
-    [1] Guo H, Tang R, Ye Y, et al. DeepFM: A factorization-machine based neural network
-        for CTR prediction[J]. arXiv preprint arXiv:1703.04247, 2017.
-        (https://arxiv.org/abs/1703.04247)
+[1] Guo H, Tang R, Ye Y, et al. DeepFM: A factorization-machine based neural network
+for CTR prediction[J]. arXiv preprint arXiv:1703.04247, 2017.
+(https://arxiv.org/abs/1703.04247)
 
 DeepFM combines a Factorization Machine (FM) for explicit second-order feature
 interactions with a deep MLP for high-order nonlinear patterns. Both parts share

nextrec/models/ranking/eulernet.py

@@ -0,0 +1,365 @@
+"""
+Date: create on 09/11/2025
+Checkpoint: edit on 09/12/2025
+Author: Yang Zhou, zyaztec@gmail.com
+Reference:
+[1] Zhao Z, Zhang H, Tang H, et al. EulerNet: Efficient and Effective Feature
+Interaction Modeling with Euler's Formula. (SIGIR 2021)
+
+EulerNet models feature interactions in the complex domain using Euler's
+formula. Each field embedding is transformed into amplitude and phase,
+then mapped to a complex vector. Feature interactions are captured by
+multiplying complex vectors across fields, which corresponds to multiplying
+amplitudes and summing phases. The resulting complex representation is
+converted back to real-valued features for a linear readout, optionally
+paired with a linear term for first-order signals.
+
+Pipeline:
+  (1) Embed sparse/sequence features with a shared embedding dimension
+  (2) Map embeddings to complex vectors via amplitude/phase transforms
+  (3) Multiply complex vectors across fields (Euler interaction)
+  (4) Concatenate real & imaginary parts and apply a linear regression head
+  (5) Optionally add a linear term and apply the prediction layer
+
+Key Advantages:
+- Efficient higher-order interaction modeling via complex multiplication
+- Compact representation without explicit cross-feature enumeration
+- Works well on sparse high-dimensional feature spaces
+
+EulerNet 使用欧拉公式将特征嵌入映射到复数域，通过复数相乘实现高效的
+特征交互建模，再将复数表示转回实数向量做线性回归，并可选叠加线性项
+以保留一阶信号。
+"""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
+from nextrec.basic.layers import LR, EmbeddingLayer, PredictionLayer
+from nextrec.basic.model import BaseModel
+
+class EulerInteractionLayerPaper(nn.Module):
+    """
+    Paper-aligned Euler Interaction Layer.
+
+    Input:  r, p  (rectangular form) as tensors with shape [B, m, d]
+            where each field j is complex feature: r_j + i p_j.
+
+    Output: r_out, p_out as tensors with shape [B, n, d]
+            representing {o_k}_{k=1..n} (Eq.15) which can be stacked.
+    """
+
+    def __init__(
+        self,
+        *,
+        embedding_dim: int,
+        num_fields: int,
+        num_orders: int,
+        use_implicit: bool = True,
+        norm: str | None = "ln",  # None | "bn" | "ln"
+        eps: float = 1e-9,
+    ):
+        super().__init__()
+        self.d = embedding_dim
+        self.m = num_fields
+        self.n = num_orders
+        self.use_implicit = use_implicit
+        self.eps = eps
+
+        # Explicit part parameters
+        # alpha_{k,j} : shape [n, m, d] (vector-wise coefficients)
+        self.alpha = nn.Parameter(torch.empty(self.n, self.m, self.d))
+        # delta_k, delta'_k : shape [n, d]
+        self.delta_phase = nn.Parameter(torch.zeros(self.n, self.d))
+        self.delta_logmod = nn.Parameter(torch.zeros(self.n, self.d))
+        nn.init.xavier_uniform_(self.alpha)
+
+        # Implicit part parameters
+        if self.use_implicit:
+            # W_k in R^{d x (m*d)} and bias b_k in R^d
+            self.W_r = nn.Parameter(torch.empty(self.n, self.d, self.m * self.d))
+            self.b_r = nn.Parameter(torch.zeros(self.n, self.d))
+            self.W_p = nn.Parameter(torch.empty(self.n, self.d, self.m * self.d))
+            self.b_p = nn.Parameter(torch.zeros(self.n, self.d))
+            nn.init.xavier_uniform_(self.W_r)
+            nn.init.xavier_uniform_(self.W_p)
+        else:
+            self.W, self.b = None, None
+
+        # Normalization
+        # Apply on concatenated [r_k, p_k] per k.
+        self.norm = norm
+        if norm == "bn":
+            self.bn = nn.BatchNorm1d(self.n * self.d * 2)
+            self.ln = None
+        elif norm == "ln":
+            self.ln = nn.LayerNorm(self.d * 2)
+            self.bn = None
+        else:
+            self.bn = None
+            self.ln = None
+
+    def forward(self, r: torch.Tensor, p: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        r, p: [B, m, d]
+        return r_out, p_out: [B, n, d]
+        """
+        B, m, d = r.shape
+        assert m == self.m and d == self.d, f"Expected [B,{self.m},{self.d}] got {r.shape}"
+
+        # Euler Transformation: rectangular -> polar
+        lam = torch.sqrt(r * r + p * p + self.eps)         # [B,m,d]
+        theta = torch.atan2(p, r)              # [B,m,d]
+        log_lam = torch.log(lam + self.eps)               # [B,m,d]
+
+        # Generalized Multi-order Transformation
+        # psi_k = sum_j alpha_{k,j} * theta_j + delta_k
+        # l_k   = exp(sum_j alpha_{k,j} * log(lam_j) + delta'_k)
+        psi = torch.einsum("bmd,nmd->bnd", theta, self.alpha) + self.delta_phase  # [B,n,d]
+        log_l = torch.einsum("bmd,nmd->bnd", log_lam, self.alpha) + self.delta_logmod  # [B,n,d]
+        l = torch.exp(log_l)  # [B,n,d]
+
+        # Inverse Euler Transformation
+        r_hat = l * torch.cos(psi)  # [B,n,d]
+        p_hat = l * torch.sin(psi)  # [B,n,d]
+
+        # Implicit interactions + fusion
+        if self.use_implicit:
+            r_cat = r.reshape(B, self.m * self.d)  # [B, m*d]
+            p_cat = p.reshape(B, self.m * self.d)  # [B, m*d]
+            # For each k: W_k @ r_cat + b_k -> [B,d]
+            r_imp = torch.einsum("bq,ndq->bnd", r_cat, self.W_r) + self.b_r
+            p_imp = torch.einsum("bq,ndq->bnd", p_cat, self.W_p) + self.b_p
+            r_imp = F.relu(r_imp)
+            p_imp = F.relu(p_imp)
+            r_out = r_hat + r_imp
+            p_out = p_hat + p_imp
+        else:
+            r_out, p_out = r_hat, p_hat
+
+        # Optional normalization (paper says BN/LN can be used between layers)
+        if self.bn is not None:
+            x = torch.cat([r_out, p_out], dim=-1).reshape(B, self.n * self.d * 2)
+            x = self.bn(x).reshape(B, self.n, self.d * 2)
+            r_out, p_out = x[..., : self.d], x[..., self.d :]
+        elif self.ln is not None:
+            x = torch.cat([r_out, p_out], dim=-1)  # [B,n,2d]
+            x = self.ln(x)
+            r_out, p_out = x[..., : self.d], x[..., self.d :]
+
+        return r_out, p_out
+
+
+class ComplexSpaceMappingPaper(nn.Module):
+    """
+    Map real embeddings e_j to complex features via Euler's formula (Eq.6-7).
+    For each field j:
+        r_j = mu_j * cos(e_j)
+        p_j = mu_j * sin(e_j)
+    mu_j is field-specific learnable vector (positive via exp).
+    """
+
+    def __init__(self, embedding_dim: int, num_fields: int):
+        super().__init__()
+        self.d = embedding_dim
+        self.m = num_fields
+        self.log_mu = nn.Parameter(torch.zeros(self.m, self.d))  # mu = exp(log_mu)
+
+    def forward(self, e: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        # e: [B, m, d]
+        mu = torch.exp(self.log_mu).unsqueeze(0)  # [1,m,d]
+        r = mu * torch.cos(e)
+        p = mu * torch.sin(e)
+        return r, p
+    
+class EulerNetPaper(nn.Module):
+    """
+    Paper-aligned EulerNet core (embedding -> mapping -> L Euler layers -> linear regression).
+    """
+
+    def __init__(
+        self,
+        *,
+        embedding_dim: int,
+        num_fields: int,
+        num_layers: int = 2,
+        num_orders: int = 8,      # n in paper
+        use_implicit: bool = True,
+        norm: str | None = "ln",  # None | "bn" | "ln"
+    ):
+        super().__init__()
+        self.d = embedding_dim
+        self.m = num_fields
+        self.L = num_layers
+        self.n = num_orders
+
+        self.mapping = ComplexSpaceMappingPaper(embedding_dim, num_fields)
+
+        self.layers = nn.ModuleList([
+            EulerInteractionLayerPaper(
+                embedding_dim=embedding_dim,
+                num_fields=(num_fields if i == 0 else num_orders),  # stack: m -> n -> n ...
+                num_orders=num_orders,
+                use_implicit=use_implicit,
+                norm=norm,
+            )
+            for i in range(num_layers)
+        ])
+
+        # Output regression (Eq.16-17)
+        # After last layer: r,p are [B,n,d]. Concatenate to [B, n*d] each, then regress.
+        self.w = nn.Linear(self.n * self.d, 1, bias=False)  # for real
+        self.w_im = nn.Linear(self.n * self.d, 1, bias=False)  # for imag
+
+    def forward(self, field_emb: torch.Tensor) -> torch.Tensor:
+        """
+        field_emb: [B, m, d] real embeddings e_j
+        return: logits, shape [B,1]
+        """
+        r, p = self.mapping(field_emb)  # [B,m,d]
+
+        # stack Euler interaction layers
+        for layer in self.layers:
+            r, p = layer(r, p)  # -> [B,n,d]
+
+        r_flat = r.reshape(r.size(0), self.n * self.d)
+        p_flat = p.reshape(p.size(0), self.n * self.d)
+
+        z_re = self.w(r_flat)
+        z_im = self.w_im(p_flat)
+        return z_re + z_im  # Eq.17 logits
+
+
+class EulerNet(BaseModel):
+    @property
+    def model_name(self):
+        return "EulerNet"
+
+    @property
+    def default_task(self):
+        return "binary"
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature] | None = None,
+        sparse_features: list[SparseFeature] | None = None,
+        sequence_features: list[SequenceFeature] | None = None,
+        num_layers: int = 2,
+        num_orders: int = 8,
+        use_implicit: bool = True,
+        norm: str | None = "ln",
+        use_linear: bool = False,
+        target: list[str] | str | None = None,
+        task: str | 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=1e-6,
+        dense_l1_reg=1e-5,
+        embedding_l2_reg=1e-5,
+        dense_l2_reg=1e-4,
+        **kwargs,
+    ):
+
+        dense_features = dense_features or []
+        sparse_features = sparse_features or []
+        sequence_features = sequence_features or []
+        optimizer_params = optimizer_params or {}
+        if loss is None:
+            loss = "bce"
+
+        super(EulerNet, self).__init__(
+            dense_features=dense_features,
+            sparse_features=sparse_features,
+            sequence_features=sequence_features,
+            target=target,
+            task=task or self.default_task,
+            device=device,
+            embedding_l1_reg=embedding_l1_reg,
+            dense_l1_reg=dense_l1_reg,
+            embedding_l2_reg=embedding_l2_reg,
+            dense_l2_reg=dense_l2_reg,
+            **kwargs,
+        )
+
+        self.loss = loss
+        self.use_linear = use_linear
+
+        self.linear_features = dense_features + sparse_features + sequence_features
+        self.interaction_features = (
+            [f for f in dense_features if getattr(f, "use_embedding", False)]
+            + sparse_features
+            + sequence_features
+        )
+
+        if len(self.interaction_features) < 2:
+            raise ValueError(
+                "EulerNet requires at least two embedded features for interactions."
+            )
+
+        self.embedding = EmbeddingLayer(features=self.all_features)
+
+        self.num_fields = len(self.interaction_features)
+        self.embedding_dim = self.interaction_features[0].embedding_dim
+        if any(
+            f.embedding_dim != self.embedding_dim for f in self.interaction_features
+        ):
+            raise ValueError(
+                "All interaction features must share the same embedding_dim in EulerNet."
+            )
+
+        self.euler = EulerNetPaper(
+            embedding_dim=self.embedding_dim,
+            num_fields=self.num_fields,
+            num_layers=num_layers,
+            num_orders=num_orders,
+            use_implicit=use_implicit,
+            norm=norm,
+        )
+
+        if self.use_linear:
+            if len(self.linear_features) == 0:
+                raise ValueError(
+                    "EulerNet linear term requires at least one input feature."
+                )
+            linear_dim = self.embedding.get_input_dim(self.linear_features)
+            if linear_dim <= 0:
+                raise ValueError("EulerNet linear input_dim must be positive.")
+            self.linear = LR(linear_dim)
+        else:
+            self.linear = None
+
+        self.prediction_layer = PredictionLayer(task_type=self.task)
+
+        modules = ["euler"]
+        if self.use_linear:
+            modules.append("linear")
+        self.register_regularization_weights(
+            embedding_attr="embedding", include_modules=modules
+        )
+
+        self.compile(
+            optimizer=optimizer,
+            optimizer_params=optimizer_params,
+            loss=loss,
+            loss_params=loss_params,
+        )
+
+    def forward(self, x):
+        field_emb = self.embedding(
+            x=x, features=self.interaction_features, squeeze_dim=False
+        )
+        y_euler = self.euler(field_emb)
+
+        if self.use_linear and self.linear is not None:
+            linear_input = self.embedding(
+                x=x, features=self.linear_features, squeeze_dim=True
+            )
+            y_euler = y_euler + self.linear(linear_input)
+
+        return self.prediction_layer(y_euler)

nextrec/models/ranking/lr.py

@@ -0,0 +1,120 @@
+"""
+Date: create on 09/11/2025
+Checkpoint: edit on 09/12/2025
+Author: Yang Zhou, zyaztec@gmail.com
+Reference:
+[1] Hosmer D W, Lemeshow S, Sturdivant R X. Applied Logistic Regression.
+
+Logistic Regression (LR) is a classic linear baseline for CTR/ranking tasks.
+It maps each feature (dense, sparse, or sequence) into a numeric vector and
+learns a single linear logit. Despite its simplicity, LR is strong for
+high-dimensional sparse data and is commonly used as a baseline or a "wide"
+component in hybrid models.
+
+Pipeline:
+  (1) Embed sparse/sequence fields; project dense fields if configured
+  (2) Concatenate all feature vectors into a single linear input
+  (3) Apply a linear layer to produce logits
+  (4) Use the prediction layer to output task-specific probabilities
+
+Key Advantages:
+- Fast and easy to train
+- Strong baseline for sparse, high-dimensional features
+- Interpretable linear weights
+
+LR 是 CTR/排序任务中最经典的线性基线模型。它将稠密、稀疏以及序列特征
+映射为数值向量后做线性组合，输出 logit。虽然结构简单，但在稀疏高维场景
+依然具有很强的基线效果，并常作为 Wide 端与深模型组合。
+
+处理流程：
+  (1) 稀疏/序列特征做 embedding，稠密特征按需投影
+  (2) 拼接所有特征向量形成线性输入
+  (3) 线性层输出 logit
+  (4) 通过预测层输出任务概率
+
+主要优点：
+- 训练与推理速度快
+- 稀疏高维特征下表现稳定
+- 权重可解释性强
+"""
+
+import torch.nn as nn
+
+from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
+from nextrec.basic.layers import EmbeddingLayer, LR as LinearLayer, PredictionLayer
+from nextrec.basic.model import BaseModel
+
+
+class LR(BaseModel):
+    @property
+    def model_name(self):
+        return "LR"
+
+    @property
+    def default_task(self):
+        return "binary"
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature] | None = None,
+        sparse_features: list[SparseFeature] | None = None,
+        sequence_features: list[SequenceFeature] | None = None,
+        target: list[str] | str | None = None,
+        task: str | 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=1e-6,
+        dense_l1_reg=1e-5,
+        embedding_l2_reg=1e-5,
+        dense_l2_reg=1e-4,
+        **kwargs,
+    ):
+
+        dense_features = dense_features or []
+        sparse_features = sparse_features or []
+        sequence_features = sequence_features or []
+        optimizer_params = optimizer_params or {}
+        if loss is None:
+            loss = "bce"
+
+        super(LR, self).__init__(
+            dense_features=dense_features,
+            sparse_features=sparse_features,
+            sequence_features=sequence_features,
+            target=target,
+            task=task or self.default_task,
+            device=device,
+            embedding_l1_reg=embedding_l1_reg,
+            dense_l1_reg=dense_l1_reg,
+            embedding_l2_reg=embedding_l2_reg,
+            dense_l2_reg=dense_l2_reg,
+            **kwargs,
+        )
+
+        self.loss = loss
+
+        self.embedding = EmbeddingLayer(features=self.all_features)
+        linear_input_dim = self.embedding.input_dim
+        self.linear = LinearLayer(linear_input_dim)
+        self.prediction_layer = PredictionLayer(task_type=self.task)
+
+        self.register_regularization_weights(
+            embedding_attr="embedding", include_modules=["linear"]
+        )
+
+        self.compile(
+            optimizer=optimizer,
+            optimizer_params=optimizer_params,
+            loss=loss,
+            loss_params=loss_params,
+        )
+
+    def forward(self, x):
+        input_linear = self.embedding(
+            x=x, features=self.all_features, squeeze_dim=True
+        )
+        y = self.linear(input_linear)
+        return self.prediction_layer(y)

{nextrec-0.4.9.dist-info → nextrec-0.4.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.4.9
+Version: 0.4.10
 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
@@ -66,7 +66,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.4.9-orange.svg)
+![Version](https://img.shields.io/badge/Version-0.4.10-orange.svg)
 
 中文文档 | [English Version](README_en.md)
 
@@ -99,11 +99,10 @@ NextRec是一个基于PyTorch的现代推荐系统框架，旨在为研究工程
 
 ## NextRec近期进展
 
-- **12/12/2025** 在v0.4.9中加入了[RQ-VAE](/nextrec/models/representation/rqvae.py)模块。配套的[数据集](/dataset/ecommerce_task.csv)和[代码](tutorials/notebooks/zh/使用RQ-VAE构建语义ID.ipynb)已经同步在仓库中
+- **12/12/2025** 在v0.4.10中加入了[RQ-VAE](/nextrec/models/representation/rqvae.py)模块。配套的[数据集](/dataset/ecommerce_task.csv)和[代码](tutorials/notebooks/zh/使用RQ-VAE构建语义ID.ipynb)已经同步在仓库中
 - **07/12/2025** 发布了NextRec CLI命令行工具，它允许用户根据配置文件进行一键训练和推理，我们提供了相关的[教程](/nextrec_cli_preset/NextRec-CLI_zh.md)和[教学代码](/nextrec_cli_preset)
 - **03/12/2025** NextRec获得了100颗🌟！感谢大家的支持
 - **06/12/2025** 在v0.4.1中支持了单机多卡的分布式DDP训练，并且提供了配套的[代码](tutorials/distributed)
-- **23/11/2025** 在v0.2.2中对basemodel进行了逻辑上的大幅重构和流程统一，并且对listwise/pairwise/pointwise损失进行了统一
 - **11/11/2025** NextRec v0.1.0发布，我们提供了10余种Ranking模型，4种多任务模型和4种召回模型，以及统一的训练/日志/指标管理系统
 
 ## 架构
@@ -241,11 +240,11 @@ nextrec --mode=train --train_config=path/to/train_config.yaml
 nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 ```
 
-> 截止当前版本0.4.9，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
+> 截止当前版本0.4.10，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
 
 ## 兼容平台
 
-当前最新版本为0.4.9，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
+当前最新版本为0.4.10，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
 
 | 平台 | 配置 | 
 |------|------|

{nextrec-0.4.9.dist-info → nextrec-0.4.10.dist-info}/RECORD

@@ -1,6 +1,6 @@
 nextrec/__init__.py,sha256=_M3oUqyuvQ5k8Th_3wId6hQ_caclh7M5ad51XN09m98,235
-nextrec/__version__.py,sha256=LdxLMJM_JXsCQBeSvnxCNyGWmINE0yWfna3DQaT41Vs,22
-nextrec/cli.py,sha256=vumtNQww-FXgGa6I90IhEjngL1Y-e0GSuSK442s4M40,19209
+nextrec/__version__.py,sha256=N_k8mdXQaZTz0YYxAgWi2g6nf_GP6B5r8Q49Om9EynA,23
+nextrec/cli.py,sha256=PXRNXMRm_a_1u6StnjsHefq0rKqsc6Mzx3mZmc9553g,23803
 nextrec/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextrec/basic/activation.py,sha256=uzTWfCOtBSkbu_Gk9XBNTj8__s241CaYLJk6l8nGX9I,2885
 nextrec/basic/callback.py,sha256=a6gg7r3x1v0xaOSya9PteLql7I14nepY7gX8tDYtins,14679
@@ -8,13 +8,13 @@ nextrec/basic/features.py,sha256=Wnbzr7UMotgv1Vzeg0o9Po-KKIvYUSYIghoVDfMPx_g,434
 nextrec/basic/layers.py,sha256=GJH2Tx3IkZrYGb7-ET976iHCC28Ubck_NO9-iyY4mDI,28911
 nextrec/basic/loggers.py,sha256=JnQiFvmsVgZ63gqBLR2ZFWrVPzkxRbzWhTdeoiJKcos,6526
 nextrec/basic/metrics.py,sha256=8RswR_3MGvIBkT_n6fnmON2eYH-hfD7kIKVnyJJjL3o,23131
-nextrec/basic/model.py,sha256=bQPRRIOGB_0PNJv3Zr-8mruUMBC7N2dmPWy7r3L45M4,98649
+nextrec/basic/model.py,sha256=OCcV9nTAZukurRISzPGCQM5yJ0Fpph3vOMKb2CPkI68,98685
 nextrec/basic/session.py,sha256=UOG_-EgCOxvqZwCkiEd8sgNV2G1sm_HbzKYVQw8yYDI,4483
 nextrec/data/__init__.py,sha256=YZQjpty1pDCM7q_YNmiA2sa5kbujUw26ObLHWjMPjKY,1194
 nextrec/data/batch_utils.py,sha256=0bYGVX7RlhnHv_ZBaUngjDIpBNw-igCk98DgOsF7T6o,2879
 nextrec/data/data_processing.py,sha256=lKXDBszrO5fJMAQetgSPr2mSQuzOluuz1eHV4jp0TDU,5538
 nextrec/data/data_utils.py,sha256=0Ls1cnG9lBz0ovtyedw5vwp7WegGK_iF-F8e_3DEddo,880
-nextrec/data/dataloader.py,sha256=D2QZDxc9Ic7zkSoaJQBxrjmbHWyJ8d3k0QF3IqLZxfk,18793
+nextrec/data/dataloader.py,sha256=xTORNbaQVa20sk2S3kyV0SSngscvq8bNqHr0AmYjFqM,18768
 nextrec/data/preprocessor.py,sha256=wNjivq2N-iDzBropkp3YfSkN0jSA4l4h81C-ECa6k4c,44643
 nextrec/loss/__init__.py,sha256=-sibZK8QXLblVNWqdqjrPPzMCDyIXSq7yd2eZ57p9Nw,810
 nextrec/loss/listwise.py,sha256=UT9vJCOTOQLogVwaeTV7Z5uxIYnngGdxk-p9e97MGkU,5744
@@ -35,14 +35,14 @@ nextrec/models/ranking/afm.py,sha256=96jGUPL4yTWobMIVBjHpOxl9AtAzCAGR8yw7Sy2JmdQ
 nextrec/models/ranking/autoint.py,sha256=S6Cxnp1q2OErSYqmIix5P-b4qLWR-0dY6TMStuU6WLg,8109
 nextrec/models/ranking/dcn.py,sha256=whkjiKEuadl6oSP-NJdSOCOqvWZGX4EsId9oqlfVpa8,7299
 nextrec/models/ranking/dcn_v2.py,sha256=QnqQbJsrtQp4mtvnBXFUVefKyr4dw-gHNWrCbO26oHw,11163
-nextrec/models/ranking/deepfm.py,sha256=EMAGhPCjJHmxpkoTWaioVgNt2yVB0PzGJpDc8cQlczs,5224
+nextrec/models/ranking/deepfm.py,sha256=aXoK59e2KaaPe5vfyFW4YiHbX4E2iG3gxFCxmWo8RHk,5200
 nextrec/models/ranking/dien.py,sha256=c7Zs85vxhOgKHg5s0QcSLCn1xXCCSD177TMERgM_v8g,18958
 nextrec/models/ranking/din.py,sha256=gdUhuKiKXBNOALbK8fGhlbSeuDT8agcEdNSrC_wveHc,9422
-nextrec/models/ranking/eulernet.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/models/ranking/eulernet.py,sha256=mZTrD8rKbGbWMEeWpTl8mVimytLFJTLM5-LS_I3U6cw,13115
 nextrec/models/ranking/ffm.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextrec/models/ranking/fibinet.py,sha256=_eroddVHooJcaGT8MqS4mUrtv5j4pnTmfI3FoAKOZhs,7919
 nextrec/models/ranking/fm.py,sha256=SsrSKK3y4xg5Lv-t3JLnZan55Hzze2AxAiVPuscy0bk,4536
-nextrec/models/ranking/lr.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/models/ranking/lr.py,sha256=Qf8RozgWlsKjHGVbo-94d2Z_4kMfCXHmvwkYu3WVZjQ,4030
 nextrec/models/ranking/masknet.py,sha256=tY1y2lO0iq82oylPN0SBnL5Bikc8weinFXpURyVT1hE,12373
 nextrec/models/ranking/pnn.py,sha256=FcNIFAw5J0ORGSR6L8ZK7NeXlJPpojwe_SpsxMQqCFw,8174
 nextrec/models/ranking/widedeep.py,sha256=-ghKfe_0puvlI9fBQr8lK3gXkfVvslGwP40AJTGqc7w,5077
@@ -63,8 +63,8 @@ nextrec/utils/embedding.py,sha256=akAEc062MG2cD7VIOllHaqtwzAirQR2gq5iW7oKpGAU,14
 nextrec/utils/feature.py,sha256=rsUAv3ELyDpehVw8nPEEsLCCIjuKGTJJZuFaWB_wrPk,633
 nextrec/utils/model.py,sha256=dYl1XfIZt6aVjNyV2AAhcArwFRMcEAKrjG_pr8AVHs0,1163
 nextrec/utils/torch_utils.py,sha256=AKfYbSOJjEw874xsDB5IO3Ote4X7vnqzt_E0jJny0o8,13468
-nextrec-0.4.9.dist-info/METADATA,sha256=FnndUmBNuNT6Odd_8XTlnW71NmqZ_Wr5lFNmxVwha1k,19463
-nextrec-0.4.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nextrec-0.4.9.dist-info/entry_points.txt,sha256=NN-dNSdfMRTv86bNXM7d3ZEPW2BQC6bRi7QP7i9cIps,45
-nextrec-0.4.9.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
-nextrec-0.4.9.dist-info/RECORD,,
+nextrec-0.4.10.dist-info/METADATA,sha256=b7ILFNk7WRZCg_2ZCx7_SWdU_d3mzN2b5IWTCnB0mbg,19318
+nextrec-0.4.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nextrec-0.4.10.dist-info/entry_points.txt,sha256=NN-dNSdfMRTv86bNXM7d3ZEPW2BQC6bRi7QP7i9cIps,45
+nextrec-0.4.10.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
+nextrec-0.4.10.dist-info/RECORD,,