supremo-lite 0.5.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

supremo_lite/__init__.py

@@ -42,7 +42,11 @@ from .personalize import (
 )
 
 # Import mutagenesis functions
-from .mutagenesis import get_sm_sequences, get_sm_subsequences
+from .mutagenesis import (
+    get_sm_sequences,
+    get_sm_subsequences,
+    get_scrambled_subsequences,
+)
 
 # Import prediction alignment functions
 from .prediction_alignment import align_predictions_by_coordinate
@@ -52,7 +56,7 @@ from .prediction_alignment import align_predictions_by_coordinate
 # This allows users who don't have PyTorch to still use the main package
 
 # Version
-__version__ = "0.5.5"
+__version__ = "1.0.0"
 # Package metadata
 __description__ = (
     "A module for generating personalized genome sequences and in-silico mutagenesis"

supremo_lite/mutagenesis.py

@@ -19,6 +19,94 @@ except ImportError:
     pass  # Already handled in core
 
 
+def _kmer_shuffle(sequence: str, k: int = 1, random_state=None) -> str:
+    """
+    Shuffle a sequence by k-mer chunks, preserving k-mer composition.
+
+    Breaks the sequence into non-overlapping k-mers and shuffles these chunks.
+    This preserves the k-mer frequency counts in the shuffled sequence:
+    - k=1: Shuffle individual nucleotides (preserves mononucleotide/GC composition)
+    - k=2: Shuffle 2-mers (preserves dinucleotide frequencies)
+    - k=3: Shuffle 3-mers (preserves trinucleotide frequencies)
+
+    Note: If sequence length is not divisible by k, the remainder bases are
+    treated as a partial k-mer and shuffled along with the complete k-mers.
+
+    Args:
+        sequence: Input DNA sequence string (ACGT only)
+        k: Size of k-mers to shuffle (default: 1)
+        random_state: Optional numpy random state or seed for reproducibility
+
+    Returns:
+        Shuffled sequence with preserved k-mer composition
+
+    Raises:
+        ValueError: If k < 1
+    """
+    if k < 1:
+        raise ValueError(f"k must be >= 1, got {k}")
+
+    if len(sequence) < k:
+        return sequence
+
+    # Handle random state
+    if random_state is None:
+        rng = np.random.default_rng()
+    elif isinstance(random_state, (int, np.integer)):
+        rng = np.random.default_rng(random_state)
+    else:
+        rng = random_state
+
+    seq = sequence.upper()
+
+    # Calculate how many complete k-mers we can make
+    n_complete_kmers = len(seq) // k
+    kmer_portion_len = n_complete_kmers * k
+
+    # Split into k-mers
+    kmers = [seq[i : i + k] for i in range(0, kmer_portion_len, k)]
+
+    # Include leftover bases as an additional chunk to shuffle
+    leftover = seq[kmer_portion_len:]
+    if leftover:
+        kmers.append(leftover)
+
+    # Shuffle all chunks (including leftover if present)
+    rng.shuffle(kmers)
+
+    return "".join(kmers)
+
+
+def _scramble_region(
+    sequence: str, start: int, end: int, k: int = 1, random_state=None
+) -> str:
+    """
+    Scramble a specific region within a sequence using k-mer shuffle.
+
+    Args:
+        sequence: Full sequence string
+        start: Start position of region to scramble (0-based)
+        end: End position of region to scramble (exclusive)
+        k: Size of k-mers to shuffle (default: 1 for mononucleotide shuffle)
+        random_state: Optional random state for reproducibility
+
+    Returns:
+        Sequence with the specified region scrambled
+    """
+    if start < 0 or end > len(sequence) or start >= end:
+        raise ValueError(
+            f"Invalid region [{start}, {end}) for sequence of length {len(sequence)}"
+        )
+
+    prefix = sequence[:start]
+    region = sequence[start:end]
+    suffix = sequence[end:]
+
+    scrambled_region = _kmer_shuffle(region, k=k, random_state=random_state)
+
+    return prefix + scrambled_region + suffix
+
+
 def _read_bed_file(bed_regions: Union[str, pd.DataFrame]) -> pd.DataFrame:
     """
     Read BED file or validate BED DataFrame format.
@@ -147,7 +235,14 @@ def get_sm_sequences(chrom, start, end, reference_fasta, encoder=None):
     # Create a DataFrame for the metadata
     metadata_df = pd.DataFrame(
         metadata,
-        columns=["chrom", "window_start", "window_end", "variant_pos0", "ref", "alt"],
+        columns=[
+            "chrom",
+            "window_start",
+            "window_end",
+            "variant_offset0",
+            "ref",
+            "alt",
+        ],
     )
 
     return ref_1h, alt_seqs_stacked, metadata_df
@@ -416,7 +511,262 @@ def get_sm_subsequences(
     # Create a DataFrame for the metadata
     metadata_df = pd.DataFrame(
         metadata,
-        columns=["chrom", "window_start", "window_end", "variant_pos0", "ref", "alt"],
+        columns=[
+            "chrom",
+            "window_start",
+            "window_end",
+            "variant_offset0",
+            "ref",
+            "alt",
+        ],
     )
 
     return ref_1h, alt_seqs_stacked, metadata_df
+
+
+def get_scrambled_subsequences(
+    chrom: str,
+    seq_len: int,
+    reference_fasta,
+    bed_regions: Union[str, pd.DataFrame],
+    n_scrambles: int = 1,
+    kmer_size: int = 1,
+    encoder=None,
+    auto_map_chromosomes: bool = False,
+    random_state=None,
+):
+    """
+    Generate sequences with BED-defined regions scrambled using k-mer shuffle.
+
+    This function creates control sequences where specific regions (defined by BED file)
+    are scrambled while preserving (k-1)-mer frequencies. Useful for generating
+    negative controls that maintain sequence composition properties.
+
+    Args:
+        chrom: Chromosome name
+        seq_len: Total sequence length for each window
+        reference_fasta: Reference genome object (pyfaidx.Fasta or dict-like)
+        bed_regions: BED file path or DataFrame defining regions to scramble.
+                    BED format: chrom, start, end (0-based, half-open intervals).
+                    Each BED region is scrambled within its centered seq_len window.
+        n_scrambles: Number of scrambled versions to generate per region (default: 1)
+        kmer_size: Size of k-mers to shuffle (default: 1).
+                   - kmer_size=1: Shuffle individual nucleotides (preserves length only)
+                   - kmer_size=2: Shuffle 2-mers (preserves mononucleotide composition)
+                   - kmer_size=3: Shuffle 3-mers (preserves dinucleotide frequencies)
+                   Higher values preserve more local sequence context.
+        encoder: Optional custom encoding function
+        auto_map_chromosomes: Automatically map chromosome names between reference
+                             and BED file (e.g., 'chr1' <-> '1'). Default: False.
+        random_state: Random seed or numpy random generator for reproducibility.
+
+    Returns:
+        Tuple of (ref_seqs, scrambled_seqs, metadata):
+        - ref_seqs: One-hot encoded reference sequences, shape (N, 4, seq_len)
+        - scrambled_seqs: Scrambled sequences, shape (N * n_scrambles, 4, seq_len)
+        - metadata: DataFrame with columns:
+            - chrom: Chromosome name
+            - window_start: Start of sequence window (0-based)
+            - window_end: End of sequence window (0-based, exclusive)
+            - scramble_start: Start of scrambled region within window (0-based)
+            - scramble_end: End of scrambled region within window (0-based, exclusive)
+            - scramble_idx: Index of this scramble (0 to n_scrambles-1)
+            - ref: Original/reference sequence in scrambled region
+            - alt: Scrambled/alternate sequence in that region
+
+    Raises:
+        ValueError: If bed_regions is not provided, has invalid format, or kmer_size < 1
+    """
+    if bed_regions is None:
+        raise ValueError("bed_regions is required for get_scrambled_subsequences()")
+
+    if kmer_size < 1:
+        raise ValueError(f"kmer_size must be >= 1, got {kmer_size}")
+
+    # Handle random state
+    if random_state is None:
+        rng = np.random.default_rng()
+    elif isinstance(random_state, (int, np.integer)):
+        rng = np.random.default_rng(random_state)
+    else:
+        rng = random_state
+
+    # Parse BED file
+    bed_df = _read_bed_file(bed_regions)
+
+    # Apply chromosome name matching
+    ref_chroms = {chrom}
+    bed_chroms = set(bed_df["chrom"].unique())
+
+    mapping, unmatched = match_chromosomes_with_report(
+        ref_chroms,
+        bed_chroms,
+        verbose=False,
+        auto_map_chromosomes=auto_map_chromosomes,
+    )
+
+    if mapping:
+        bed_df = apply_chromosome_mapping(bed_df, mapping)
+
+    # Filter to target chromosome
+    chrom_bed_regions = bed_df[bed_df["chrom"] == chrom].copy()
+
+    if len(chrom_bed_regions) == 0:
+        warnings.warn(
+            f"No BED regions found for chromosome {chrom}. "
+            f"Returning original unshuffled sequence."
+        )
+        # Return original sequence (unshuffled) centered on chromosome
+        chrom_obj = reference_fasta[chrom]
+        if hasattr(chrom_obj, "__len__"):
+            chrom_len = len(chrom_obj)
+        else:
+            chrom_len = len(str(chrom_obj))
+
+        # Center window on chromosome
+        chrom_center = chrom_len // 2
+        window_start = max(0, chrom_center - seq_len // 2)
+        window_end = min(chrom_len, window_start + seq_len)
+
+        # Adjust if we hit the end
+        if window_end - window_start < seq_len:
+            window_start = max(0, window_end - seq_len)
+
+        # Get reference sequence
+        ref_seq_obj = reference_fasta[chrom][window_start:window_end]
+        if hasattr(ref_seq_obj, "seq"):
+            ref_seq = str(ref_seq_obj.seq)
+        else:
+            ref_seq = str(ref_seq_obj)
+
+        ref_1h = encode_seq(ref_seq, encoder)
+
+        if TORCH_AVAILABLE and isinstance(ref_1h, torch.Tensor):
+            ref_stacked = torch.stack([ref_1h])
+            # Return same sequence for all "scrambled" outputs (but unshuffled)
+            scrambled_stacked = torch.stack([ref_1h] * n_scrambles)
+        else:
+            ref_stacked = np.stack([ref_1h])
+            scrambled_stacked = np.stack([ref_1h] * n_scrambles)
+
+        # Create metadata indicating no scrambling occurred
+        meta_rows = []
+        for i in range(n_scrambles):
+            meta_rows.append(
+                {
+                    "chrom": chrom,
+                    "window_start": window_start,
+                    "window_end": window_end,
+                    "scramble_start": 0,
+                    "scramble_end": 0,  # Empty region indicates no scrambling
+                    "scramble_idx": i,
+                    "ref": ref_seq,
+                    "alt": ref_seq,  # Same as ref when no scrambling
+                }
+            )
+
+        return ref_stacked, scrambled_stacked, pd.DataFrame(meta_rows)
+
+    ref_sequences = []
+    scrambled_sequences = []
+    metadata = []
+
+    # Process each BED region
+    for _, bed_region in chrom_bed_regions.iterrows():
+        region_start = int(bed_region["start"])
+        region_end = int(bed_region["end"])
+        region_center = (region_start + region_end) // 2
+
+        # Calculate sequence window centered on BED region
+        window_start = region_center - seq_len // 2
+        window_end = window_start + seq_len
+
+        # Adjust window to stay within chromosome bounds
+        chrom_obj = reference_fasta[chrom]
+        chrom_len = len(chrom_obj) if hasattr(chrom_obj, "__len__") else len(chrom_obj)
+
+        if window_start < 0:
+            window_start = 0
+            window_end = min(seq_len, chrom_len)
+        elif window_end > chrom_len:
+            window_end = chrom_len
+            window_start = max(0, chrom_len - seq_len)
+
+        # Get reference sequence
+        ref_seq_obj = reference_fasta[chrom][window_start:window_end]
+        if hasattr(ref_seq_obj, "seq"):
+            ref_seq = str(ref_seq_obj.seq)
+        else:
+            ref_seq = str(ref_seq_obj)
+
+        if len(ref_seq) != seq_len:
+            warnings.warn(
+                f"Region {chrom}:{region_start}-{region_end} produces sequence of length "
+                f"{len(ref_seq)} instead of {seq_len}. Skipping."
+            )
+            continue
+
+        # Calculate scramble region relative to window
+        scramble_start_rel = max(0, region_start - window_start)
+        scramble_end_rel = min(seq_len, region_end - window_start)
+
+        if scramble_start_rel >= scramble_end_rel:
+            warnings.warn(
+                f"BED region {chrom}:{region_start}-{region_end} is outside window bounds. Skipping."
+            )
+            continue
+
+        # Store reference sequence
+        ref_1h = encode_seq(ref_seq, encoder)
+        ref_sequences.append(ref_1h)
+
+        # Get original region sequence for metadata
+        original_region = ref_seq[scramble_start_rel:scramble_end_rel]
+
+        # Generate n_scrambles scrambled versions
+        for scramble_idx in range(n_scrambles):
+            scrambled_seq = _scramble_region(
+                ref_seq,
+                scramble_start_rel,
+                scramble_end_rel,
+                k=kmer_size,
+                random_state=rng,
+            )
+
+            scrambled_1h = encode_seq(scrambled_seq, encoder)
+            scrambled_sequences.append(scrambled_1h)
+
+            scrambled_region = scrambled_seq[scramble_start_rel:scramble_end_rel]
+
+            metadata.append(
+                {
+                    "chrom": chrom,
+                    "window_start": window_start,
+                    "window_end": window_end,
+                    "scramble_start": scramble_start_rel,
+                    "scramble_end": scramble_end_rel,
+                    "scramble_idx": scramble_idx,
+                    "ref": original_region,
+                    "alt": scrambled_region,
+                }
+            )
+
+    # Stack sequences
+    if ref_sequences:
+        if TORCH_AVAILABLE and isinstance(ref_sequences[0], torch.Tensor):
+            ref_stacked = torch.stack(ref_sequences)
+            scrambled_stacked = torch.stack(scrambled_sequences)
+        else:
+            ref_stacked = np.stack(ref_sequences)
+            scrambled_stacked = np.stack(scrambled_sequences)
+    else:
+        if TORCH_AVAILABLE:
+            ref_stacked = torch.empty((0, 4, seq_len), dtype=torch.float32)
+            scrambled_stacked = torch.empty((0, 4, seq_len), dtype=torch.float32)
+        else:
+            ref_stacked = np.empty((0, 4, seq_len), dtype=np.float32)
+            scrambled_stacked = np.empty((0, 4, seq_len), dtype=np.float32)
+
+    metadata_df = pd.DataFrame(metadata)
+
+    return ref_stacked, scrambled_stacked, metadata_df

supremo_lite/variant_utils.py

@@ -5,6 +5,7 @@ This module provides functions for reading variants from VCF files
 and other related operations.
 """
 
+import gzip
 import io
 import pandas as pd
 import numpy as np
@@ -14,6 +15,22 @@ from typing import Dict, Optional, List, Tuple, Union
 from dataclasses import dataclass
 
 
+def _open_vcf(path: str, mode: str = "rt"):
+    """
+    Open a VCF file, automatically detecting gzip compression.
+
+    Args:
+        path: Path to VCF file (may be .vcf or .vcf.gz)
+        mode: File mode. Use 'rt' for text reading (default).
+
+    Returns:
+        File handle (context manager compatible)
+    """
+    if path.endswith(".gz"):
+        return gzip.open(path, mode)
+    return open(path, mode.replace("t", "") if "t" in mode else mode)
+
+
 @dataclass
 class BreakendVariant:
     """
@@ -625,13 +642,15 @@ def _count_vcf_header_lines(path: str) -> int:
     - Lines starting with ## (metadata)
     - Line starting with #CHROM (column header)
 
+    Supports both uncompressed (.vcf) and gzip-compressed (.vcf.gz) files.
+
     Args:
         path: Path to VCF file
 
     Returns:
         Number of lines to skip (all ## lines + the #CHROM line)
     """
-    with open(path, "r") as f:
+    with _open_vcf(path, "rt") as f:
         header_count = 0
         for line in f:
             if line.startswith("##"):
@@ -648,6 +667,8 @@ def read_vcf(path, include_info=True, classify_variants=True):
     """
     Read VCF file into pandas DataFrame with enhanced variant classification.
 
+    Supports both uncompressed (.vcf) and gzip-compressed (.vcf.gz) files.
+
     Args:
         path: Path to VCF file
         include_info: Whether to include INFO field (default: True)
@@ -656,11 +677,21 @@ def read_vcf(path, include_info=True, classify_variants=True):
     Returns:
         DataFrame with columns: chrom, pos1, id, ref, alt, [info], [variant_type]
 
+    Raises:
+        FileNotFoundError: If VCF file does not exist
+        ValueError: If VCF file has invalid format or no valid header
+
     Notes:
         - INFO field parsing enables structural variant classification
         - variant_type column uses VCF 4.2 compliant classification
         - Compatible with existing code expecting basic 5-column format
     """
+    import os
+
+    # Validate file exists
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"VCF file not found: {path}")
+
     # Determine columns to read based on parameters
     if include_info:
         usecols = [0, 1, 2, 3, 4, 7]  # Include INFO field
@@ -670,12 +701,38 @@ def read_vcf(path, include_info=True, classify_variants=True):
         base_columns = ["chrom", "pos1", "id", "ref", "alt"]
 
     # Count header lines for VCF line tracking (needed for vcf_line column)
-    header_count = _count_vcf_header_lines(path)
+    try:
+        header_count = _count_vcf_header_lines(path)
+    except Exception as e:
+        raise ValueError(f"Failed to parse VCF header in {path}: {e}")
+
+    if header_count == 0:
+        raise ValueError(
+            f"VCF file {path} appears to have no header lines. "
+            "Valid VCF files must start with ##fileformat or #CHROM header."
+        )
 
     # Read VCF using pandas with comment='#' to skip all header lines automatically
-    df = pd.read_table(
-        path, comment="#", header=None, names=base_columns, usecols=usecols
-    )
+    try:
+        df = pd.read_table(
+            path,
+            comment="#",
+            header=None,
+            names=base_columns,
+            usecols=usecols,
+            on_bad_lines="warn",
+        )
+    except pd.errors.EmptyDataError:
+        warnings.warn(f"VCF file {path} contains no data rows after header.")
+        empty_cols = base_columns + (["variant_type"] if classify_variants else [])
+        return pd.DataFrame(columns=empty_cols)
+
+    # Handle empty DataFrame
+    if len(df) == 0:
+        warnings.warn(f"VCF file {path} contains no variant records.")
+        if classify_variants:
+            df["variant_type"] = pd.Series(dtype=str)
+        return df
 
     # Add VCF line numbers for debugging (1-indexed, accounting for header lines)
     # Line number = header_lines + 1 (for 1-indexing) + row_index
@@ -683,9 +740,22 @@ def read_vcf(path, include_info=True, classify_variants=True):
 
     # Validate that pos1 column is numeric
     if not pd.api.types.is_numeric_dtype(df["pos1"]):
-        raise ValueError(
-            f"Position column (second column) must be numeric, got {df['pos1'].dtype}"
-        )
+        # Try to convert, providing helpful error message
+        try:
+            df["pos1"] = pd.to_numeric(df["pos1"], errors="coerce")
+            invalid_rows = df[df["pos1"].isna()]
+            if len(invalid_rows) > 0:
+                warnings.warn(
+                    f"Found {len(invalid_rows)} rows with non-numeric positions in {path}. "
+                    f"First invalid at VCF line {invalid_rows.iloc[0]['vcf_line']}. "
+                    "These rows will be removed."
+                )
+                df = df.dropna(subset=["pos1"])
+                df["pos1"] = df["pos1"].astype(int)
+        except Exception as e:
+            raise ValueError(
+                f"Position column must be numeric in {path}, conversion failed: {e}"
+            )
 
     # Filter out multiallelic variants (ALT alleles containing commas)
     df = _filter_multiallelic_variants(df)
@@ -775,6 +845,8 @@ def get_vcf_chromosomes(path):
     """
     Get list of chromosomes in VCF file without loading all variants.
 
+    Supports both uncompressed (.vcf) and gzip-compressed (.vcf.gz) files.
+
     Args:
         path: Path to VCF file
 
@@ -782,7 +854,7 @@ def get_vcf_chromosomes(path):
         Set of chromosome names found in the VCF file
     """
     chromosomes = set()
-    with open(path, "r") as f:
+    with _open_vcf(path, "rt") as f:
         for line in f:
             if line.startswith("##"):
                 continue
@@ -800,6 +872,8 @@ def read_vcf_chromosome(
     """
     Read VCF file for a specific chromosome only with enhanced variant classification.
 
+    Supports both uncompressed (.vcf) and gzip-compressed (.vcf.gz) files.
+
     Args:
         path: Path to VCF file
         target_chromosome: Chromosome name to filter for
@@ -813,7 +887,7 @@ def read_vcf_chromosome(
     chromosome_lines = []
     header_line = None
 
-    with open(path, "r") as f:
+    with _open_vcf(path, "rt") as f:
         for line in f:
             if line.startswith("##"):
                 continue

{supremo_lite-0.5.5.dist-info → supremo_lite-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supremo_lite
-Version: 0.5.5
+Version: 1.0.0
 Summary: A lightweight memory first, model agnostic version of SuPreMo
 License: MIT
 License-File: LICENSE

{supremo_lite-0.5.5.dist-info → supremo_lite-1.0.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
-supremo_lite/__init__.py,sha256=mKgstoebv8o-3d0h1RasW5OpBmUaOlxqt7pJNYcMxRU,1660
+supremo_lite/__init__.py,sha256=hRuX97N2VKbfbMm0J_F1eryacJphc920pUQ9N60vFpY,1705
 supremo_lite/chromosome_utils.py,sha256=rOjS3IQXmjBYZG949C5eG1zWprTOdhPVg4oW8GLbCek,10938
 supremo_lite/core.py,sha256=-OmQEAS5J2rhocXC4aHYWaZZE2N8MX942SePMLoQ6Xc,1190
 supremo_lite/mock_models/__init__.py,sha256=YQcL3oOoe0WJW5y_LtpuhmYIlx-_xS8raB1Mty5wtF4,3672
 supremo_lite/mock_models/testmodel_1d.py,sha256=0CqLuAwxthz_sn_2v0C5XHu8q42dZO7EIzo9aX1hJ2U,6056
 supremo_lite/mock_models/testmodel_2d.py,sha256=swSEEkORf7sjlZQ7XakY3qGGeRomVpiLZZbice6zziw,7011
-supremo_lite/mutagenesis.py,sha256=p5oc4apcCm4AnGoYmSlbTKG6uS7xVNX2EoJ8322cu8M,16260
+supremo_lite/mutagenesis.py,sha256=Cm4ZXLa3TcrEaNkuw_m9leXclEAFRtRUt9NEhVScWyA,28873
 supremo_lite/personalize.py,sha256=w3Bv0xwikHbpZlXkgXWB4lo6XzzbzrrKSJqrrC-rTRs,126389
 supremo_lite/prediction_alignment.py,sha256=rmpZDE-PK9-CqsXjlVw0J0KJqZXuPPl55IceF76gj-s,43020
 supremo_lite/sequence_utils.py,sha256=yl-ghw9mGEGjiIYCBZ-4-S-CpXDjsP6suGuVVdww1mY,4147
-supremo_lite/variant_utils.py,sha256=9B-IiUBIWYipoB2Sa7OJmhmLNVCjykMmdL3Mm4n9wvw,60663
-supremo_lite-0.5.5.dist-info/METADATA,sha256=adDo5VH2nXYF-J6R1gT3rqelY-LUFFhv3V3DG-CTXhg,9025
-supremo_lite-0.5.5.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-supremo_lite-0.5.5.dist-info/licenses/LICENSE,sha256=QoRjddrQkzdNXNq7EQbRtWGvOKv1h031CG8wreXDa00,1079
-supremo_lite-0.5.5.dist-info/RECORD,,
+supremo_lite/variant_utils.py,sha256=pEp2i83q7lLcyboAOIY88mFDw0Zfr0fFv4bL38ROZP0,63257
+supremo_lite-1.0.0.dist-info/METADATA,sha256=eNFfDv6BkIJxHuMY9HsB-j4mGBUUNr9NediUiMa7Qo8,9025
+supremo_lite-1.0.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+supremo_lite-1.0.0.dist-info/licenses/LICENSE,sha256=QoRjddrQkzdNXNq7EQbRtWGvOKv1h031CG8wreXDa00,1079
+supremo_lite-1.0.0.dist-info/RECORD,,

{supremo_lite-0.5.5.dist-info → supremo_lite-1.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any