dasmixer-cli 0.6.0a2__py3-none-any.whl

dasmixer/cli/__init__.py

@@ -0,0 +1,3 @@
+"""CLI package for DASMixer."""
+
+# CLI implementation will be added in stage 3

dasmixer/cli/commands/__init__.py

@@ -0,0 +1,3 @@
+"""CLI command modules."""
+
+__all__ = ['project', 'subset', 'import_data']

dasmixer/cli/commands/import_data.py

@@ -0,0 +1,269 @@
+"""CLI commands for importing data files."""
+
+import typer
+from pathlib import Path
+import asyncio
+from typing import Annotated
+from dasmixer.api.project.project import Project
+from dasmixer.api.inputs.registry import registry
+from dasmixer.api.config import config
+from dasmixer.utils.seek_files import seek_files
+
+app = typer.Typer(help="Import data files")
+
+
+@app.command()
+def mgf_pattern(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+    folder: Annotated[str, typer.Option("--folder", "-f", help="Folder to search")] = ...,
+    file_pattern: Annotated[str, typer.Option("--pattern", "-p", help="File pattern (e.g., *.mgf)")] = "*.mgf",
+    id_pattern: Annotated[str, typer.Option("--id-pattern", "-i", help="Sample ID pattern (e.g., {id}_*.mgf)")] = "{id}*.mgf",
+    parser: Annotated[str, typer.Option("--parser", help="Parser name")] = "MGF",
+    group: Annotated[str, typer.Option("--group", "-g", help="Group to assign samples")] = "Control"
+):
+    """
+    Import MGF files using pattern matching.
+    
+    Example:
+        dasmixer project.dasmix import mgf-pattern \\
+            --folder /data/spectra \\
+            --pattern "*.mgf" \\
+            --id-pattern "{id}_run*.mgf" \\
+            --group Control
+    """
+    project_path = Path(project_path)
+    
+    if not project_path.exists():
+        typer.echo(f"Error: Project file not found: {project_path}", err=True)
+        raise typer.Exit(1)
+    
+    folder_path = Path(folder)
+    if not folder_path.exists():
+        typer.echo(f"Error: Folder not found: {folder}", err=True)
+        raise typer.Exit(1)
+    
+    # Find files
+    try:
+        files = seek_files(folder_path, file_pattern, id_pattern)
+    except Exception as e:
+        typer.echo(f"Error searching files: {e}", err=True)
+        raise typer.Exit(1)
+    
+    if not files:
+        typer.echo("No files found matching pattern", err=True)
+        raise typer.Exit(1)
+    
+    # Show found files
+    typer.echo(f"\nFound {len(files)} file(s):")
+    typer.echo("-" * 60)
+    for file_path, sample_id in files:
+        display_id = sample_id or "UNKNOWN"
+        typer.echo(f"  {file_path.name} → Sample ID: {display_id}")
+    
+    if not typer.confirm("\nProceed with import?"):
+        typer.echo("Cancelled")
+        raise typer.Exit(0)
+    
+    # Get parser
+    try:
+        parser_class = registry.get_parser(parser, "spectra")
+    except KeyError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)
+    
+    # Import files
+    async def _import():
+        async with Project(path=project_path, create_if_not_exists=False) as project:
+            # Get or create group
+            subsets = await project.get_subsets()
+            subset = next((s for s in subsets if s.name == group), None)
+            
+            if not subset:
+                subset = await project.add_subset(group)
+                typer.echo(f"✓ Created group: {group}")
+            
+            # Import with progress
+            with typer.progressbar(
+                files,
+                label="Importing",
+                show_pos=True
+            ) as progress:
+                for file_path, sample_id in progress:
+                    # Use filename as sample_id if not detected
+                    if not sample_id:
+                        sample_id = file_path.stem
+                    
+                    try:
+                        # Parse file
+                        parser_instance = parser_class(str(file_path))
+                        spectra_df = await parser_instance.parse_batch()
+                        
+                        # Add sample if not exists
+                        sample = await project.get_sample_by_name(sample_id)
+                        if not sample:
+                            sample = await project.add_sample(
+                                sample_id,
+                                subset_id=subset.id
+                            )
+                        
+                        # Add spectra file
+                        spectra_file_id = await project.add_spectra_file(
+                            sample.id,
+                            parser,
+                            str(file_path)
+                        )
+                        
+                        # Add spectra
+                        await project.add_spectra_batch(spectra_file_id, spectra_df)
+                        
+                    except Exception as e:
+                        typer.echo(f"\n  Error importing {file_path.name}: {e}", err=True)
+            
+            typer.echo(f"\n✓ Imported {len(files)} file(s) successfully")
+    
+    try:
+        asyncio.run(_import())
+        config.update_last_import_folder(folder)
+    except Exception as e:
+        typer.echo(f"\nError during import: {e}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def mgf_file(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+    file: Annotated[str, typer.Option("--file", "-f", help="Path to MGF file")] = ...,
+    sample_id: Annotated[str, typer.Option("--sample-id", "-s", help="Sample ID")] = ...,
+    parser: Annotated[str, typer.Option("--parser", help="Parser name")] = "MGF",
+    group: Annotated[str, typer.Option("--group", "-g", help="Group to assign sample")] = "Control"
+):
+    """
+    Import single MGF file.
+    
+    Example:
+        dasmixer project.dasmix import mgf-file \\
+            --file /data/sample1.mgf \\
+            --sample-id "Sample1" \\
+            --group Control
+    """
+    project_path = Path(project_path)
+    file_path = Path(file)
+    
+    if not project_path.exists():
+        typer.echo(f"Error: Project file not found: {project_path}", err=True)
+        raise typer.Exit(1)
+    
+    if not file_path.exists():
+        typer.echo(f"Error: File not found: {file}", err=True)
+        raise typer.Exit(1)
+    
+    # Get parser
+    try:
+        parser_class = registry.get_parser(parser, "spectra")
+    except KeyError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)
+    
+    # Import file
+    async def _import():
+        async with Project(path=project_path, create_if_not_exists=False) as project:
+            # Get or create group
+            subsets = await project.get_subsets()
+            subset = next((s for s in subsets if s.name == group), None)
+            
+            if not subset:
+                subset = await project.add_subset(group)
+                typer.echo(f"✓ Created group: {group}")
+            
+            typer.echo(f"Importing {file_path.name}...")
+            
+            # Parse file
+            parser_instance = parser_class(str(file_path))
+            spectra_df = await parser_instance.parse_batch()
+            
+            # Add sample if not exists
+            sample = await project.get_sample_by_name(sample_id)
+            if not sample:
+                sample = await project.add_sample(
+                    sample_id,
+                    subset_id=subset.id
+                )
+            
+            # Add spectra file
+            spectra_file_id = await project.add_spectra_file(
+                sample.id,
+                parser,
+                str(file_path)
+            )
+            
+            # Add spectra
+            await project.add_spectra_batch(spectra_file_id, spectra_df)
+            
+            typer.echo(f"✓ Imported {len(spectra_df)} spectra from {file_path.name}")
+            typer.echo(f"  Sample: {sample_id}")
+            typer.echo(f"  Group: {group}")
+    
+    try:
+        asyncio.run(_import())
+        config.update_last_import_folder(str(file_path.parent))
+    except Exception as e:
+        typer.echo(f"Error importing file: {e}", err=True)
+        raise typer.Exit(1)
+
+
+# Note: ident-pattern and ident-file commands will be similar but for identifications
+# They require knowledge of which tool and spectra file to link to
+# Implementation will be added when identification parsers are registered
+
+@app.command()
+def ident_pattern(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+    folder: Annotated[str, typer.Option("--folder", "-f", help="Folder to search")] = ...,
+    file_pattern: Annotated[str, typer.Option("--pattern", "-p", help="File pattern")] = "*.csv",
+    id_pattern: Annotated[str, typer.Option("--id-pattern", "-i", help="Sample ID pattern")] = "{id}*.csv",
+    parser: Annotated[str, typer.Option("--parser", help="Parser name (e.g., PowerNovo2)")] = ...,
+    tool: Annotated[str, typer.Option("--tool", help="Tool name (will be created if not exists)")] = ...
+):
+    """
+    Import identification files using pattern matching.
+    
+    Note: This command requires that corresponding spectra files
+    are already imported for the samples.
+    
+    Example:
+        dasmixer project.dasmix import ident-pattern \\
+            --folder /data/results \\
+            --pattern "*.csv" \\
+            --id-pattern "{id}_powernovo.csv" \\
+            --parser PowerNovo2 \\
+            --tool PowerNovo2
+    """
+    typer.echo("This command will be implemented when identification parsers are ready.")
+    typer.echo("Coming in next development phase.")
+    raise typer.Exit(0)
+
+
+@app.command()
+def ident_file(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+    file: Annotated[str, typer.Option("--file", "-f", help="Path to identification file")] = ...,
+    sample_id: Annotated[str, typer.Option("--sample-id", "-s", help="Sample ID")] = ...,
+    parser: Annotated[str, typer.Option("--parser", help="Parser name")] = ...,
+    tool: Annotated[str, typer.Option("--tool", help="Tool name")] = ...
+):
+    """
+    Import single identification file.
+    
+    Note: This command requires that corresponding spectra file
+    is already imported for the sample.
+    
+    Example:
+        dasmixer project.dasmix import ident-file \\
+            --file /data/sample1_powernovo.csv \\
+            --sample-id "Sample1" \\
+            --parser PowerNovo2 \\
+            --tool PowerNovo2
+    """
+    typer.echo("This command will be implemented when identification parsers are ready.")
+    typer.echo("Coming in next development phase.")
+    raise typer.Exit(0)

dasmixer/cli/commands/import_project.py

@@ -0,0 +1,75 @@
+"""CLI command for importing/merging another project."""
+
+import typer
+from pathlib import Path
+from typing import Annotated
+import asyncio
+from dasmixer.api.project.project import Project
+
+app = typer.Typer(help="Merge another project into this one")
+
+
+@app.command()
+def import_project(
+    project_path: Annotated[str, typer.Argument(help="Target project (.dasmix)")],
+    source_path: Annotated[str, typer.Argument(help="Source project to import from (.dasmix)")],
+    tool_match: Annotated[str, typer.Option(help="Tool merge strategy: 'parser'|'name'|'none'")] = "parser",
+    no_subset_match: Annotated[bool, typer.Option("--no-subset-match", help="Do not merge subsets by name")] = False,
+    no_sample_match: Annotated[bool, typer.Option("--no-sample-match", help="Do not merge samples by name")] = False,
+    update_settings: Annotated[bool, typer.Option("--update-settings", help="Replace target settings with source")] = False,
+    conflict_suffix: Annotated[str, typer.Option(help="Suffix for conflicting names")] = "_1",
+):
+    """Merge another project into target project."""
+    tgt = Path(project_path)
+    src = Path(source_path)
+    
+    if not tgt.exists():
+        typer.echo(f"Error: target project not found: {tgt}", err=True)
+        raise typer.Exit(1)
+    
+    if not src.exists():
+        typer.echo(f"Error: source project not found: {src}", err=True)
+        raise typer.Exit(1)
+    
+    # Convert tool_match
+    if tool_match == "none":
+        tool_match_value = None
+    elif tool_match == "name":
+        tool_match_value = "name"
+    else:
+        tool_match_value = "parser"
+    
+    # Show summary
+    typer.echo(f"Target: {tgt}")
+    typer.echo(f"Source: {src}")
+    typer.echo(f"Tool match: {tool_match_value}")
+    typer.echo(f"Merge subsets: {not no_subset_match}")
+    typer.echo(f"Merge samples: {not no_sample_match}")
+    typer.echo(f"Update settings: {update_settings}")
+    typer.echo(f"Conflict suffix: {conflict_suffix}")
+    
+    if not typer.confirm("Proceed with merge?"):
+        typer.echo("Cancelled")
+        raise typer.Exit(0)
+    
+    async def _run():
+        async with Project(path=tgt, create_if_not_exists=False) as project:
+            def status_callback(table: str, fraction: float):
+                typer.echo(f"  [{fraction*100:3.0f}%] Importing {table}...")
+            
+            await project.import_project(
+                source_path=src,
+                tool_match=tool_match_value,
+                subset_match=not no_subset_match,
+                sample_match=not no_sample_match,
+                project_settings_match=update_settings,
+                conflict_suffix=conflict_suffix,
+                status_callback=status_callback,
+            )
+    
+    try:
+        asyncio.run(_run())
+        typer.echo("✓ Import complete")
+    except Exception as e:
+        typer.echo(f"Error during import: {e}", err=True)
+        raise typer.Exit(1)

dasmixer/cli/commands/portable.py

@@ -0,0 +1,54 @@
+"""CLI commands for portable project utilities (checkpoint, vacuum)."""
+
+import typer
+from pathlib import Path
+from typing import Annotated
+import asyncio
+from dasmixer.api.project.project import Project
+
+app = typer.Typer(help="Portable project utilities")
+
+
+@app.command()
+def checkpoint(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+):
+    """Save uncommitted WAL changes into the main database file."""
+    path = Path(project_path)
+    if not path.exists():
+        typer.echo(f"Error: file not found: {path}", err=True)
+        raise typer.Exit(1)
+
+    async def _run():
+        async with Project(path=path, create_if_not_exists=False) as project:
+            await project.save(checkpoint=True)
+
+    try:
+        asyncio.run(_run())
+        typer.echo(f"✓ Checkpoint done: {path}")
+    except Exception as e:
+        typer.echo(f"Error during checkpoint: {e}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def vacuum(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+):
+    """Compact the database file by running SQLite VACUUM."""
+    path = Path(project_path)
+    if not path.exists():
+        typer.echo(f"Error: file not found: {path}", err=True)
+        raise typer.Exit(1)
+
+    async def _run():
+        async with Project(path=path, create_if_not_exists=False) as project:
+            await project.save(checkpoint=True)
+            await project.vacuum()
+
+    try:
+        asyncio.run(_run())
+        typer.echo(f"✓ Vacuum complete: {path}")
+    except Exception as e:
+        typer.echo(f"Error during vacuum: {e}", err=True)
+        raise typer.Exit(1)

dasmixer/cli/commands/project.py

@@ -0,0 +1,49 @@
+"""CLI commands for project management."""
+
+import typer
+from pathlib import Path
+from typing import Annotated
+import asyncio
+from dasmixer.api.project.project import Project
+from dasmixer.api.config import config
+
+app = typer.Typer(help="Create new project")
+
+
+@app.callback(invoke_without_command=True)
+def create_project(
+    ctx: typer.Context,
+    project_path: Annotated[
+        str,
+        typer.Argument(help="Path to .dasmix project file to create"),
+    ],
+):
+    """
+    Create new empty project with default Control group.
+    """
+    path = Path(project_path)
+
+    # Check if file exists
+    if path.exists():
+        if not typer.confirm(f"File {path} exists. Overwrite?"):
+            typer.echo("Cancelled")
+            raise typer.Exit(0)
+        path.unlink()
+
+    # Create project
+    async def _create():
+        async with Project(path=path, create_if_not_exists=True) as project:
+            await project.add_subset(
+                "Control",
+                details="Default control group",
+                display_color="#3B82F6",
+            )
+            typer.echo(f"✓ Created project: {path}")
+            typer.echo("✓ Added default group: Control")
+
+    try:
+        asyncio.run(_create())
+        config.add_recent_project(str(path))
+    except Exception as e:
+        typer.echo(f"Error creating project: {e}", err=True)
+        raise typer.Exit(1)

dasmixer/cli/commands/subset.py

@@ -0,0 +1,130 @@
+"""CLI commands for managing comparison groups (subsets)."""
+
+import typer
+from pathlib import Path
+import asyncio
+from dasmixer.api.project.project import Project
+from typing import Annotated
+
+app = typer.Typer(help="Manage comparison groups")
+
+
+@app.command()
+def add(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+    name: Annotated[str, typer.Option("--name", "-n", help="Group name")] = ...,
+    details: Annotated[
+        str | None,
+        typer.Option("--details", "-d", help="Group description")
+    ] = None,
+    color: Annotated[
+        str | None,
+        typer.Option("--color", "-c", help="Display color (hex, e.g., #FF5733)")
+    ] = None
+):
+    """Add new comparison group to project."""
+    project_path = Path(project_path)
+    
+    if not project_path.exists():
+        typer.echo(f"Error: Project file not found: {project_path}", err=True)
+        raise typer.Exit(1)
+    
+    async def _add():
+        async with Project(path=project_path, create_if_not_exists=False) as project:
+            subset = await project.add_subset(name, details, color)
+            typer.echo(f"✓ Added group: {subset.name} (id={subset.id})")
+            if details:
+                typer.echo(f"  Description: {details}")
+            if color:
+                typer.echo(f"  Color: {color}")
+    
+    try:
+        asyncio.run(_add())
+    except ValueError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.echo(f"Error adding group: {e}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def delete(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")],
+    name: Annotated[str, typer.Option("--name", "-n", help="Group name to delete")] = ...
+):
+    """Delete comparison group from project."""
+    project_path = Path(project_path)
+    
+    if not project_path.exists():
+        typer.echo(f"Error: Project file not found: {project_path}", err=True)
+        raise typer.Exit(1)
+    
+    async def _delete():
+        async with Project(path=project_path, create_if_not_exists=False) as project:
+            # Find subset by name
+            subsets = await project.get_subsets()
+            subset = next((s for s in subsets if s.name == name), None)
+            
+            if not subset:
+                typer.echo(f"Error: Group '{name}' not found", err=True)
+                raise typer.Exit(1)
+            
+            # Confirm deletion
+            if not typer.confirm(f"Delete group '{name}'?"):
+                typer.echo("Cancelled")
+                raise typer.Exit(0)
+            
+            await project.delete_subset(subset.id)
+            typer.echo(f"✓ Deleted group: {name}")
+    
+    try:
+        asyncio.run(_delete())
+    except ValueError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)
+    except typer.Exit:
+        raise
+    except Exception as e:
+        typer.echo(f"Error deleting group: {e}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_subsets(
+    project_path: Annotated[str, typer.Argument(help="Path to .dasmix project file")]
+):
+    """List all comparison groups in project."""
+    project_path = Path(project_path)
+    
+    if not project_path.exists():
+        typer.echo(f"Error: Project file not found: {project_path}", err=True)
+        raise typer.Exit(1)
+    
+    async def _list():
+        async with Project(path=project_path, create_if_not_exists=False) as project:
+            subsets = await project.get_subsets()
+            
+            if not subsets:
+                typer.echo("No groups found in project")
+                return
+            
+            typer.echo("\nComparison Groups:")
+            typer.echo("=" * 60)
+            
+            for subset in subsets:
+                typer.echo(f"\n{subset.name} (ID: {subset.id})")
+                if subset.details:
+                    typer.echo(f"  Description: {subset.details}")
+                if subset.display_color:
+                    typer.echo(f"  Color: {subset.display_color}")
+                
+                # Count samples in this group
+                samples = await project.get_samples(subset_id=subset.id)
+                typer.echo(f"  Samples: {len(samples)}")
+    
+    try:
+        asyncio.run(_list())
+    except Exception as e:
+        typer.echo(f"Error listing groups: {e}", err=True)
+        raise typer.Exit(1)

dasmixer/cli/main.py

@@ -0,0 +1,47 @@
+"""
+DASMixer CLI — entry point for the `dasmixer-cli` command.
+
+Provides command-line tools for project management without GUI.
+"""
+
+import typer
+from typing import Annotated
+from pathlib import Path
+
+from dasmixer.versions import APP_VERSION
+from dasmixer.cli.commands import project, subset, import_data
+from dasmixer.cli.commands import portable
+from dasmixer.cli.commands import import_project as import_project_cmd
+
+app = typer.Typer(
+    name="dasmixer-cli",
+    help="DASMixer CLI — manage projects without GUI",
+    add_completion=False,
+)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool,
+        typer.Option("--version", "-v", help="Show version and exit"),
+    ] = False,
+):
+    """DASMixer CLI — управление проектами без GUI."""
+    if version:
+        typer.echo(f"DASMixer CLI {APP_VERSION}")
+        raise typer.Exit(0)
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+
+
+app.add_typer(project.app, name="create", help="Create new project")
+app.add_typer(subset.app, name="subset", help="Manage comparison groups")
+app.add_typer(import_data.app, name="import", help="Import data files")
+app.add_typer(portable.app, name="checkpoint", help="Save WAL to database file")
+app.add_typer(portable.app, name="vacuum", help="Compact database file")
+app.add_typer(import_project_cmd.app, name="import-project", help="Merge another project into this one")
+
+if __name__ == "__main__":
+    app()

dasmixer_cli-0.6.0a2.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: dasmixer-cli
+Version: 0.6.0a2
+Summary: DASMixer CLI — command-line tools for project management
+Author: gluck
+Author-email: glucksistemi@gmail.com
+Requires-Python: <4.0, >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: dasmixer-core (==0.5.0)
+Project-URL: Homepage, https://github.com/protdb/dasmixer
+Description-Content-Type: text/markdown
+
+# DASMixer CLI
+
+Command-line tools for managing DASMixer projects without a graphical interface.
+
+## Installation
+
+```bash
+pip install dasmixer-cli
+```
+
+## Usage
+
+```bash
+dasmixer-cli --help
+dasmixer-cli create path/to/project.dasmix
+dasmixer-cli subset list path/to/project.dasmix
+dasmixer-cli subset add path/to/project.dasmix --name "Treatment" --color "#FF5733"
+dasmixer-cli import mgf-file path/to/project.dasmix --sample "Sample1" --file spectra.mgf
+dasmixer-cli import mgf-pattern path/to/project.dasmix --sample "Sample1" --folder ./spectra/ --pattern "*.mgf"
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `create <project>` | Create a new empty project |
+| `subset list <project>` | List comparison groups |
+| `subset add <project> --name` | Add a comparison group |
+| `subset delete <project> --name` | Delete a comparison group |
+| `import mgf-file <project>` | Import a single MGF file |
+| `import mgf-pattern <project>` | Batch import MGF files by pattern |
+| `import ident-file <project>` | Import an identification file |
+| `import ident-pattern <project>` | Batch import identification files |
+
+Documentation: https://github.com/protdb/dasmixer

dasmixer_cli-0.6.0a2.dist-info/RECORD

@@ -0,0 +1,12 @@
+dasmixer/cli/__init__.py,sha256=gR3zobxDodV8MRqOYZi5q79IfxtsZiJc8Kuh85cIFCs,79
+dasmixer/cli/commands/__init__.py,sha256=UUXhyaTxmBs62aQzk21wEnjbeV7ieB8WI6yEonAg_yE,75
+dasmixer/cli/commands/import_data.py,sha256=h1VflVla2xSStURSMaOFkf5WIAanjhD_DX0H8UuIgOU,10259
+dasmixer/cli/commands/import_project.py,sha256=XmeLNGVa_yzyg_VBjXzcD0aIu28qe-eSOhfk_7LVSzw,2924
+dasmixer/cli/commands/portable.py,sha256=s8wG0tc25paW4f6Clhem7T4RKB4stQNROUsWdrG9-4I,1665
+dasmixer/cli/commands/project.py,sha256=GoIXrZljp3U0vZFGE4AvncqEEaeBVBXy6w0LE0fYeDQ,1389
+dasmixer/cli/commands/subset.py,sha256=qUL25wsVD3iCph1uPyIy1THBim7tN6sKDiY9X3vpDtc,4463
+dasmixer/cli/main.py,sha256=Kq7Nu4rd-B_K6C6wcMNv5DiXkL3aFb5uf8ArbNXOtPA,1518
+dasmixer_cli-0.6.0a2.dist-info/METADATA,sha256=74ZauIAkmuCi7-HzWN7pX22rZgnhX-4yg5HByOyVKWo,1768
+dasmixer_cli-0.6.0a2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dasmixer_cli-0.6.0a2.dist-info/entry_points.txt,sha256=a4KExsoM5TAa1-M7059iMIH3u9VerPOAyCF4mQz-so0,54
+dasmixer_cli-0.6.0a2.dist-info/RECORD,,

dasmixer_cli-0.6.0a2.dist-info/WHEEL

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

dasmixer_cli-0.6.0a2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dasmixer-cli=dasmixer.cli.main:app
+