ArraySplitter 1.3.0__py3-none-any.whl

ArraySplitter/extract.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# @created: 21.02.2024
+# @author: Aleksey Komissarov
+# @contact: ad3002@gmail.com
+
+from collections import Counter
+import argparse
+import logging
+from .core_functions.io.fasta_reader import sc_iter_fasta_file
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def main(fasta_file, output_prefix, distance=0, function='hd'):
+
+    if distance < 0:
+        raise ValueError(f'Distance should be >= 0, but {distance} given')
+    
+    if function not in ['hd', 'ed']:
+        raise ValueError(f'Function should be hd or ed, but {function} given')
+    
+    logging.info(f'Extract monomers from {fasta_file}')
+    monomers = Counter()
+    for header, seq in sc_iter_fasta_file(fasta_file):
+        for monomer in seq.split():
+            monomers[monomer] += 1
+
+    logging.info(f'Found {len(monomers)} uniq monomers with total {sum(monomers.values())} monomers')
+
+    logging.info(f'Filter monomers with distance <= {distance} using {function} function')
+    # if function == 'hd':
+    #     monomers = {k: v for k, v in monomers.items() if v <= distance}
+    # else:
+    #     raise NotImplementedError('Edit distance is not implemented yet')
+    logging.info(f'Found {len(monomers)} monomers with distance <= {distance}')
+
+    output_file = f'{output_prefix}.monomers.tsv'
+    logging.info(f'Save monomers to {output_file}')
+    with open(output_file, "w") as fw:
+        for monomer, count in monomers.most_common(1000000000):
+            fw.write(f'{count}\t{len(monomer)}\t{monomer}\n')
+            
+def run_it():
+    parser = argparse.ArgumentParser(description='Extract monomers from array over edit distance.')
+    parser.add_argument('-i', '--fasta', type=str, help='Fasta file with arrays', required=True)
+    parser.add_argument('-o', '--output', type=str, help='Output prefix', required=True)
+    parser.add_argument('-f', '--function', type=str, help='Distance function hamming (hd) or edit (ed) [hd]', default='hd')
+    parser.add_argument('-d', '--distance', type=int, help='Distance value, you will get monomers over <= distance [0]', default=0)
+    args = parser.parse_args()
+    main(args.fasta, args.output, distance=args.distance, function=args.function)
+
+if __name__ == '__main__':
+    run_it()

ArraySplitter/main.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+ArraySplitter - Main entry point with subcommands.
+"""
+
+import argparse
+import sys
+
+
+def run_it():
+    """Main entry point with subcommands."""
+    
+    parser = argparse.ArgumentParser(
+        description="ArraySplitter - De novo decomposition and analysis of satellite DNA arrays",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Split arrays into monomers (default action)
+  arraysplitter split -i arrays.fa -o output_prefix
+  
+  # Split with predefined cuts
+  arraysplitter split -i arrays.fa -o output_prefix -c ATG,CGCG
+  
+  # Classify arrays into families (uses .lengths file from split step)
+  arraysplitter classify -i output_prefix.lengths -o classification
+  
+  # Rotate monomers
+  arraysplitter rotate -i decomposed.fa -o rotated.fa
+  
+  # Extract unique monomers
+  arraysplitter extract -i decomposed.fa -o monomers
+
+For help on specific commands:
+  arraysplitter <command> -h
+"""
+    )
+    
+    subparsers = parser.add_subparsers(
+        dest='command',
+        help='Available commands'
+    )
+    
+    # Split command (decomposition)
+    parser_split = subparsers.add_parser(
+        'split',
+        help='Split arrays into monomers (decomposition)'
+    )
+    parser_split.add_argument("-i", "--input", help="Input file", required=True)
+    parser_split.add_argument("-o", "--output", help="Output prefix", required=True)
+    parser_split.add_argument(
+        "--format",
+        help="Input format: fasta, trf, satellome [fasta]",
+        default="fasta",
+        choices=["fasta", "trf", "satellome"]
+    )
+    parser_split.add_argument(
+        "-c", "--cuts",
+        help="Comma-separated list of predefined cut sequences (e.g., ATG,ATGATG)",
+        default=None
+    )
+    parser_split.add_argument(
+        "-d", "--depth",
+        help="Depth for hint discovery (default: 100)",
+        type=int,
+        default=100
+    )
+    parser_split.add_argument(
+        "-t", "--threads",
+        help="Number of threads (currently not used)",
+        type=int,
+        default=4
+    )
+    parser_split.add_argument(
+        "-v", "--verbose",
+        help="Verbose output",
+        action="store_true"
+    )
+    
+    # Classify command
+    parser_classify = subparsers.add_parser(
+        'classify',
+        help='Classify arrays into families based on decomposition patterns'
+    )
+    parser_classify.add_argument("-i", "--input", help="Input .lengths file from decomposition", required=True)
+    parser_classify.add_argument("-o", "--output", help="Output prefix", required=True)
+    parser_classify.add_argument(
+        "-s", "--similarity",
+        help="Similarity threshold for clustering (0-1, default: 0.8)",
+        type=float,
+        default=0.8
+    )
+    parser_classify.add_argument(
+        "-v", "--verbose",
+        help="Verbose output",
+        action="store_true"
+    )
+    
+    # Rotate command
+    parser_rotate = subparsers.add_parser(
+        'rotate',
+        help='Rotate monomers to start from the same position'
+    )
+    parser_rotate.add_argument("-i", "--fasta", help="Input FASTA file", required=True)
+    parser_rotate.add_argument("-o", "--output", help="Output file", required=True)
+    parser_rotate.add_argument(
+        "-s", "--start",
+        help="Starting kmer for rotation [None]",
+        default=None
+    )
+    
+    # Extract command
+    parser_extract = subparsers.add_parser(
+        'extract',
+        help='Extract and count unique monomers'
+    )
+    parser_extract.add_argument("-i", "--fasta", help="Input FASTA file", required=True)
+    parser_extract.add_argument("-o", "--output", help="Output prefix", required=True)
+    parser_extract.add_argument(
+        "-m", "--min",
+        help="Minimum monomer frequency [1]",
+        type=int,
+        default=1
+    )
+    
+    # Parse arguments
+    args = parser.parse_args()
+    
+    # Show help if no command specified
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+    
+    # Import and run the appropriate module
+    if args.command == 'split':
+        from .decompose import main as decompose_main
+        import os
+        
+        if not os.path.isfile(args.input):
+            print(f"Error: Input file {args.input} not found")
+            sys.exit(1)
+        
+        # Parse cuts if provided
+        predefined_cuts = args.cuts.split(',') if args.cuts else None
+        
+        decompose_main(
+            args.input,
+            args.output,
+            args.format,
+            args.threads,
+            predefined_cuts,
+            args.depth,
+            args.verbose
+        )
+    
+    elif args.command == 'classify':
+        from .classify import classify_arrays
+        import os
+        
+        if not os.path.isfile(args.input):
+            print(f"Error: Input file {args.input} not found")
+            sys.exit(1)
+        
+        if not args.input.endswith('.lengths'):
+            print(f"Warning: Input file should be a .lengths file from ArraySplitter decomposition")
+        
+        classify_arrays(
+            args.input,
+            args.output,
+            similarity_threshold=args.similarity,
+            verbose=args.verbose
+        )
+    
+    elif args.command == 'rotate':
+        from .rotate import main as rotate_main
+        
+        rotate_main(args.fasta, args.output, starting_kmer=args.start)
+    
+    elif args.command == 'extract':
+        from .extract import main as extract_main
+        
+        extract_main(args.fasta, args.output, min_tf=args.min)
+    
+    else:
+        print(f"Error: Unknown command '{args.command}'")
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run_it()

ArraySplitter/rotate.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# @created: 21.02.2024
+# @author: Aleksey Komissarov
+# @contact: ad3002@gmail.com
+
+import argparse
+
+from .core_functions.tools.rotation import rotate_arrays
+
+from .core_functions.io.fasta_reader import sc_iter_fasta_file
+
+def main(fasta_file, output_file, starting_kmer=None):
+
+    arrays = []
+    for ii, (header, seq) in enumerate(sc_iter_fasta_file(fasta_file)):
+        arrays.append(seq)
+
+    new_arrays = rotate_arrays(arrays, starting_kmer=starting_kmer)
+    
+    with open(output_file, "w") as fw:
+        for ii, (header, seq) in enumerate(sc_iter_fasta_file(fasta_file)):
+            fw.write(f'>{header}\n{" ".join(new_arrays[ii])}\n')
+            
+def run_it():
+    parser = argparse.ArgumentParser(description='Rotate arrays to start from the same position.')
+    parser.add_argument('-i', '--fasta', type=str, help='Fasta file', required=True)
+    parser.add_argument('-o', '--output', type=str, help='Output file', required=True)
+    parser.add_argument('-s', '--start', type=str, help='Starting kmer for rotation [None]', default=None)
+    args = parser.parse_args()
+    main(args.fasta, args.output, starting_kmer=args.start)
+
+if __name__ == '__main__':
+    run_it()

arraysplitter-1.3.0.dist-info/METADATA

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: ArraySplitter
+Version: 1.3.0
+Summary: De Novo Decomposition of Satellite DNA Arrays into Monomers within Telomere-to-Telomere Assemblies
+Home-page: https://github.com/aglabx/ArraySplitter
+Author: Aleksey Komissarov
+Author-email: ad3002@gmail.com
+License: BSD
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyExp
+Requires-Dist: editdistance
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ArraySplitter: De Novo Decomposition of Satellite DNA Arrays
+
+Decomposes satellite DNA arrays into monomers within telomere-to-telomere (T2T) assemblies. Ideal for analyzing centromeric and pericentromeric regions on monomeric level.
+
+**Status:** Production ready. Successfully handles arrays from kilobase to megabase scale.
+
+**Key Features:**
+- De novo monomer identification without prior knowledge
+- Automatic orientation to canonical form (A>T, C>G)
+- Integrated monomer rotation for standardized comparison
+- Classification of arrays into repeat families
+- Structural importance scoring to identify centromeric and other functional regions
+
+**Performance:** CHM13v2.0 assembly (13K arrays > 1Kb) processes in ~3 hours (single-threaded)
+
+## Installation
+
+**Prerequisites**
+
+* Python 3.6 or later
+
+**Installation with pip:**
+
+```bash
+pip install arraysplitter
+```
+
+## Tool Overview
+
+ArraySplitter provides a unified command-line interface with multiple subcommands:
+
+### Main Command: `arraysplitter`
+
+```bash
+arraysplitter <command> [options]
+```
+
+Available commands:
+- `split` - Decompose arrays into monomers
+- `classify` - Group arrays into families based on patterns
+- `rotate` - Normalize monomer orientation
+- `extract` - Extract and count unique monomers
+
+### 1. `arraysplitter split` - Array Decomposition
+
+Performs de novo decomposition of satellite DNA arrays into individual monomers.
+
+**Usage:**
+```bash
+# Basic decomposition
+arraysplitter split -i arrays.fa -o output_prefix
+
+# With predefined cut sequences
+arraysplitter split -i arrays.fa -o output_prefix -c ATG,CGCG
+```
+
+**Output files:**
+- `.decomposed.fasta` - Monomers with orientation and rotation applied
+- `.monomers.tsv` - Detailed table with monomer information
+- `.lengths` - Fragment lengths for each array
+
+**Features:**
+- Automatic canonical orientation (A>T, C>G)
+- Integrated rotation (monomers start with cut sequence)
+- Flank detection and labeling
+- Perfect reconstruction guarantee
+
+### 2. `arraysplitter classify` - Family Classification
+
+Groups arrays into families based on cut sequences and decomposition patterns. Identifies structurally important regions.
+
+**Usage:**
+```bash
+# Classify using lengths file from split step
+arraysplitter classify -i output_prefix.lengths -o classification
+
+# With custom similarity threshold
+arraysplitter classify -i output_prefix.lengths -o classification -s 0.9
+```
+
+**Output files:**
+- `.families.tsv` - Array assignments with stability metrics
+- `.family_stats.tsv` - Basic statistics per family
+- `.family_summary.tsv` - Detailed family analysis with structural importance scores
+- `.features.json` - Complete feature data
+
+**Key metrics:**
+- **Step stability**: Consistency of monomer length differences
+- **Local variability**: Sliding window analysis (10kb windows)
+- **Structural importance score**: Combined metric (0-1) identifying potential functional regions
+
+### 3. `arraysplitter rotate` - Monomer Normalization
+
+Rotates monomers to start with the same sequence pattern.
+
+**Usage:**
+```bash
+# Auto-detect best rotation
+arraysplitter rotate -i monomers.fa -o rotated.fa
+
+# With specific starting sequence
+arraysplitter rotate -i monomers.fa -o rotated.fa -s ATTCC
+```
+
+### 4. `arraysplitter extract` - Monomer Analysis
+
+Extracts unique monomers and calculates frequencies.
+
+**Usage:**
+```bash
+arraysplitter extract -i monomers.fa -o stats_prefix
+```
+
+**Output format:**
+```
+<length> <frequency> <sequence>
+```
+
+## Complete Workflow Example
+
+```bash
+# Step 1: Decompose arrays into monomers
+arraysplitter split -i centromere_arrays.fa -o centromere
+
+# Step 2: Classify arrays into families and identify structural regions
+arraysplitter classify -i centromere.lengths -o centromere_families
+
+# Step 3: Extract and count unique monomers (optional)
+arraysplitter extract -i centromere.decomposed.fasta -o centromere_monomers
+
+# Step 4: Additional rotation if needed (optional)
+arraysplitter rotate -i centromere.decomposed.fasta -o centromere.rotated.fa -s ATTCC
+```
+
+### Output Analysis
+
+After classification, examine the `.family_summary.tsv` file to identify:
+- Families with high structural importance scores (>0.8) - potential centromeric regions
+- Families with low step variability - structurally conserved regions
+- Most stable arrays within each family - best representatives for further study
+
+## Algorithm Description
+
+ArraySplitter employs a novel de novo algorithm for decomposing satellite DNA arrays into constituent monomers without prior knowledge of the monomer sequences. The algorithm is specifically designed to handle the challenges of centromeric and pericentromeric regions in telomere-to-telomere assemblies.
+
+### Overview
+
+The algorithm uses a frequency suffix tree (fs_tree) approach to identify optimal cut sequences that split tandem repeat arrays into individual monomer units. It handles variable-length monomers (polymorphic repeats) common in biological sequences and automatically orients sequences to canonical form for comparability.
+
+### Detailed Algorithm Steps
+
+#### 1. Canonical Orientation
+Arrays are first oriented to canonical form using the rules:
+- Primary: A > T (arrays with more A's than T's are kept as-is)
+- Secondary: C > G (if A=T, arrays with more C's than G's are kept as-is)
+- Arrays not in canonical form are reverse complemented
+
+#### 2. All Nucleotide Analysis
+The algorithm analyzes all nucleotides (A, C, T, G) to avoid bias from single nucleotide selection. Each nucleotide serves as an anchor point for building frequency suffix trees.
+
+#### 3. Frequency Suffix Tree Construction
+The core data structure is a frequency suffix tree that efficiently identifies repetitive patterns:
+
+- **Starting positions**: All positions containing each nucleotide become root nodes
+- **Iterative extension**: The tree grows by extending sequences one nucleotide at a time (A/C/G/T)
+- **Frequency filtering**: Only branches exceeding a dynamic cutoff threshold are retained:
+  - Arrays > 1MB: cutoff = 1000
+  - Arrays > 100KB: cutoff = 250
+  - Arrays > 10KB: cutoff = 10
+  - Arrays ≤ 10KB: cutoff = 3
+- **Heap-based optimization**: Uses a priority queue to efficiently process high-frequency patterns first
+
+#### 4. Candidate Cut Sequence Generation
+From the frequency suffix tree, the algorithm extracts potential cut sequences:
+- For each sequence length (up to a configurable depth, default 100)
+- Identifies the sequence with maximum coverage (highest frequency)
+- Generates a ranked list of candidate cut sequences
+
+#### 5. Optimal Cut Selection
+The algorithm evaluates each candidate cut sequence by:
+- Splitting the array at all occurrences of the cut sequence
+- Calculating period distribution between cuts
+- Handling perfect/near-perfect repeats (≥80% empty parts between cuts)
+- Computing scores with tie-breaking rules:
+  1. Prefer cuts producing fewer segments
+  2. Prefer smaller fundamental periods (using GCD)
+- The cut sequence becomes the START of each monomer (biologically relevant)
+
+#### 6. Monomer Construction
+- First fragment (before any cut) is treated as left flank
+- Each monomer is built as: cut_sequence + following_part
+- Last fragment <70% of average length is treated as right flank
+- All monomers are automatically rotated to start with the cut sequence
+- Ensures all output monomers are directly comparable
+
+### Key Features
+
+1. **De novo approach**: No prior knowledge of monomer sequences required
+2. **Variable-length monomers**: Handles polymorphic repeats naturally
+3. **Canonical orientation**: All arrays oriented consistently (A>T, C>G)
+4. **Integrated rotation**: Monomers automatically aligned to cut sequence
+5. **Family classification**: Groups arrays by cut patterns and variability
+6. **Structural scoring**: Identifies centromeric and functional regions
+
+### Performance Characteristics
+
+- **Optimized for**: 100Kb scale arrays
+- **Scalability**: Successfully handles megabase-scale arrays (largest ~5 minutes)
+- **Benchmarking**: CHM13v20 assembly (13K arrays > 1Kb) processes in ~3 hours
+- **Current limitation**: Single-threaded (parallelization planned)
+
+### Classification Algorithm
+
+ArraySplitter includes a classification system that groups arrays into families based on:
+
+1. **Cut sequence identity**: Arrays with different cuts belong to different families
+2. **Pattern similarity**: Within same cut, arrays are clustered by:
+   - Mean monomer length
+   - Length variability
+   - Step stability (consistency between consecutive monomers)
+3. **Structural importance scoring**:
+   - High step stability (consistent monomer spacing)
+   - Low local variability (stable regions in 10kb windows)
+   - Consistency across arrays in family
+   - Score 0-1 (higher = more structurally important)
+
+### Applications
+
+The algorithm is particularly well-suited for:
+- Analyzing centromeric and pericentromeric regions in T2T assemblies
+- Identifying structurally important genomic regions
+- Studying satellite DNA evolution and variation
+- Discovering novel tandem repeat families
+- Quantifying monomer composition and variability
+- Finding stable regions for functional studies
+
+## Contact
+
+For questions or support: ad3002@gmail.com

arraysplitter-1.3.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+ArraySplitter/__init__.py,sha256=h8Fz1eD4MXGpCgKpn1RqfA_t7dfCg6O8Vx0ysxCMdHE,169
+ArraySplitter/classify.py,sha256=9OkmGecGvEa40mmIK4BPblVpuRBfZFS7oWbkETJ2idQ,21023
+ArraySplitter/decompose.py,sha256=Voqcwgquy6-lSnVjusjPrKiszxG5x0SIhmjrtGCTVvo,70530
+ArraySplitter/extract.py,sha256=bqlC8E6MjndMCBa44Zvv23gXmH2yr7IdQBXnc5foqhM,2300
+ArraySplitter/main.py,sha256=GTOI6Ca38-Ws_a127MbLtPnSzKPBKrDFHS48_1Tey54,5709
+ArraySplitter/rotate.py,sha256=ZvH2WDnRlfeqbXtUDmrgqE2CQEGe5qKDVR-my_uKkLA,1231
+ArraySplitter/core_functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ArraySplitter/core_functions/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ArraySplitter/core_functions/io/block_file.py,sha256=AI7HVxUFAhLSw7-G1hHORShemyGO1-FpfohDKbOV1Ug,4764
+ArraySplitter/core_functions/io/fasta_reader.py,sha256=ivG-2aPBPxSh5WkcWgZUDyrQrGq8uOBiakGUu1eC6zg,1388
+ArraySplitter/core_functions/io/satellome_reader.py,sha256=E7aBxrpF2SMPF3tKMZpNBmTCKkjjIZCF0Cnlpo1bES8,559
+ArraySplitter/core_functions/io/tab_file.py,sha256=TcmO0iKf5mNoCbuQbR3ZQKXV5Xsc8kr6dhk8C8FDMlw,6231
+ArraySplitter/core_functions/io/trf_reader.py,sha256=L7HL2mfxQAA2gBsksFj7EJSZIt4JZ0ENKaub7CFSo8A,2111
+ArraySplitter/core_functions/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ArraySplitter/core_functions/models/trf_model.py,sha256=hK44KXf8fdcfS__i5UmvOr4xnh-AeWeVhvXiINnOqXc,8012
+ArraySplitter/core_functions/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ArraySplitter/core_functions/tools/anchor_graph.py,sha256=MrPbsw95dExh9HbASxnQgey_lJc8yHn7-ni-IijT0xo,23754
+ArraySplitter/core_functions/tools/fs_tree.py,sha256=OHvamldtHW_7VEiWg7XiJ7Xwml2gmTACiZrGnP3WL6c,4655
+ArraySplitter/core_functions/tools/parsers.py,sha256=J_rtt384ycfgrWlgrazb3qj7Sr0waWj7yShlril5rqM,6766
+ArraySplitter/core_functions/tools/rotation.py,sha256=v_-3gkx8AR10RDCNMO82Pok1ZbqT2Zy9asyWZ6Ib_v8,3109
+ArraySplitter/core_functions/tools/sequences.py,sha256=v74uHp1nTF_UvMRefYmJfMbnzdurRn995C06hugoSa4,441
+arraysplitter-1.3.0.dist-info/licenses/LICENSE,sha256=m2dY1BxIk3gKB3jSa8kDtlSnNfW68VumXAQzGacCtvc,1063
+arraysplitter-1.3.0.dist-info/METADATA,sha256=E-rQhLl9Cn-xcF9hYuuhjyXxRURf2ca8trtgd8cAa_E,10177
+arraysplitter-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+arraysplitter-1.3.0.dist-info/entry_points.txt,sha256=H8EDFoNSqnM6J8m2w97H8HKjzAqs-iNTrIHk87-kfhY,60
+arraysplitter-1.3.0.dist-info/top_level.txt,sha256=zk1yzRnjygCl8ZF8rx3w4WSWdW8FUw1-MqSk-s3NOHY,14
+arraysplitter-1.3.0.dist-info/RECORD,,

arraysplitter-1.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

arraysplitter-1.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+arraysplitter = ArraySplitter.main:run_it

arraysplitter-1.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 aglabx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arraysplitter-1.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ArraySplitter