jazari 0.0.1__py3-none-any.whl

jazari/config_generator.py

@@ -0,0 +1,38 @@
+import os, yaml
+from pathlib import Path
+from rich.console import Console
+# Config helpers
+# defining the path to the config file: ~/.jazari/config.yaml
+CONFIG_DIR = os.path.join(Path.home(), '.jazari')
+CONFIG_FILE = os.path.join(CONFIG_DIR, 'config.yaml')
+console = Console()
+
+def load_config():
+    '''
+    Loading config file if exists, otherwise returns empty dict.
+    '''
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, 'r') as f:
+                return yaml.safe_load(f) or {}
+        except Exception as e:
+            console.print(f'[yellow]Warning: Could not read config file: {e}[/yellow]')
+    
+    return {}
+
+def get_config_default(key, CONFIG, default_value):
+    '''
+    Helper to get a default value from config or fall back to a hardcoded one.
+    '''
+    return CONFIG.get(key, default_value)
+
+def make_config_dir(new_config):
+    # Creating directory if doesn't exist
+    Path(CONFIG_DIR).mkdir(parents = True, exist_ok=True)
+
+    # Writing config to the yaml file
+    with open(CONFIG_FILE, 'w') as f:
+        yaml.dump(new_config, f, default_flow_style=False)
+    
+    console.print(f'\n[bold green]✅ Configuration saved![/bold green]')
+    console.print('You can now run jobs without specifying these flags.')

jazari/main.py

@@ -0,0 +1,329 @@
+import typer, sys, os, tempfile, subprocess, netrc, shutil, getpass
+
+from typing import Optional
+from pathlib import Path
+
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+from rich import box
+
+from jazari.slurm_generator import generate_sbatch_script
+from jazari.config_generator import load_config, get_config_default, make_config_dir, CONFIG_FILE
+
+# Initializing Rich console for pretty printing
+console = Console()
+
+# Load config at start.
+CONFIG = load_config()
+
+# --- HELPER FUNCTIONS ---
+
+def get_current_user() -> str:
+    """Returns the current username, robustly on Linux environments."""
+    try:
+        return os.environ['USER']
+    except KeyError:
+        return getpass.getuser()
+
+def get_wandb_api_key() -> Optional[str]:
+    """
+    Attempts to read the W&B API key from the local ~/.netrc file.
+    """
+    try:
+        login_info = netrc.netrc().authenticators("api.wandb.ai")
+        if login_info:
+            username, _, api_key = login_info
+            console.print(f"[dim]Found W&B API key for user: {username}[/dim]")
+            return api_key
+        else:
+            return None
+    except FileNotFoundError:
+        return None
+    except Exception as e:
+        console.print(f"[dim bold red]Warning: Could not read W&B credentials: {e}[/dim]")
+        return None
+
+# --- COMMAND FUNCTIONS (No decorators here) ---
+
+def status_command():
+    """
+    View the status of active Slurm jobs for the current user.
+    """
+    # 1. Check if squeue exists available
+    if not shutil.which("squeue"):
+        console.print("[bold red]Error:[/bold red] 'squeue' command not found.")
+        console.print("Are you running this on a Slurm login node?")
+        sys.exit(1)
+
+    user = get_current_user()
+
+    # 2. Define the squeue command
+    # -u: Filter by user
+    # -h: No header (we'll make our own)
+    # -o: Custom format with '|' delimiter.
+    #     %i=ID, %j=Name, %T=State, %M=Time Used, %D=Nodes, %R=Reason/Nodelist
+    squeue_cmd = ["squeue", "-u", user, "-h", "-o", "%i|%j|%T|%M|%D|%R"]
+
+    try:
+        # 3. Run the command and capture output
+        result = subprocess.run(squeue_cmd, check=True, capture_output=True, text=True)
+        output_lines = result.stdout.strip().split('\n')
+
+        # Remove empty lines if squeue returned nothing
+        output_lines = [line for line in output_lines if line.strip()]
+
+        if not output_lines:
+             console.print(f"\n[dim]No active jobs found for user: [bold]{user}[/bold][/dim]\n")
+             return
+
+        # 4. Build the Rich Table
+        table = Table(
+            title=f"🐘 Cluster Activity for user: [bold green]{user}[/bold green]",
+            box=box.ROUNDED,
+            header_style="bold blue",
+            expand=True
+        )
+        table.add_column("Job ID", style="cyan", no_wrap=True)
+        table.add_column("Name")
+        table.add_column("State")
+        table.add_column("Time Used", justify="right")
+        table.add_column("Nodes", justify="right")
+        table.add_column("Nodelist / Reason", style="dim")
+
+        # 5. Parse output and add rows
+        for line in output_lines:
+            try:
+                job_id, name, state, time_used, nodes, reason = line.split('|')
+
+                # Color-code the state
+                if state == "RUNNING":
+                    state_formatted = f"[bold green]{state}[/bold green]"
+                elif state == "PENDING":
+                    state_formatted = f"[yellow]{state}[/yellow]"
+                else:
+                    state_formatted = f"[red]{state}[/red]"
+
+                table.add_row(job_id, name, state_formatted, time_used, nodes, reason)
+            except ValueError:
+                # Handle rare cases where splitting fails
+                continue
+
+        console.print(table)
+
+    except subprocess.CalledProcessError as e:
+         console.print(f"[bold red]Error running squeue:[/bold red] {e.stderr}")
+
+def kill_command(
+        job_id: Optional[str] = typer.Argument(None, help = 'Job ID to cancel.'),
+        cancel_all: bool = typer.Option(False, '--all', help = 'Cancel ALL active jobs.')
+):
+    # Cancel a specific job or all jobs
+    if not shutil.which("scancel"):
+        console.print("[bold red]Error:[/bold red] 'scancel' command not found.")
+        console.print("Are you running this on a Slurm login node?")
+        sys.exit(1)
+    
+    user = get_current_user()
+
+    if cancel_all:
+        if not Confirm.ask(f"[bold red]⚠️  DANGER:[/bold red] Cancel ALL jobs for '{user}'?"):
+             sys.exit(0)
+        subprocess.run(["scancel", "-u", user], check=True)
+        console.print(f"[bold green]💥 All jobs cancelled.[/bold green]")
+        return
+
+    if job_id:
+        subprocess.run(["scancel", job_id], check=True)
+        console.print(f"[bold green]💥 Signal sent to cancel job {job_id}.[/bold green]")
+        return
+
+    console.print("[yellow]Usage: jazari kill <JOB_ID> or jazari kill --all[/yellow]")
+
+def logs_command(
+    job_id: Optional[str] = typer.Argument(None, help="Job ID to view."),
+    tail: bool = typer.Option(False, "--tail", "-f", help="Follow output live."),
+    error: bool = typer.Option(False, "--error", "-e", help="View .err log instead of .out")
+):
+    """View or follow job logs."""
+    log_dir = Path("logs")
+    if not log_dir.exists():
+        console.print("[red]Error: 'logs/' directory not found.[/red]")
+        sys.exit(1)
+
+    suffix = ".err" if error else ".out"
+    target_file = None
+
+    if job_id:
+        matching = list(log_dir.glob(f"*{job_id}{suffix}"))
+        if not matching:
+             console.print(f"[red]No log found for Job {job_id}[/red]")
+             sys.exit(1)
+        target_file = matching[0]
+    else:
+        # Find latest
+        files = list(log_dir.glob(f"*{suffix}"))
+        if not files:
+             console.print(f"[yellow]No {suffix} files found.[/yellow]")
+             return
+        files.sort(key=os.path.getmtime)
+        target_file = files[-1]
+
+    console.print(f"[dim]Viewing: {target_file}[/dim]")
+    cmd = ["tail", "-f", str(target_file)] if tail else ["cat", str(target_file)]
+    
+    try:
+        subprocess.run(cmd, check=True)
+    except KeyboardInterrupt:
+        console.print("\n[dim]Stopped.[/dim]")
+
+def init_command():
+    """
+    Initialize Jazari config for this cluster.
+    Interactively asks the user for defaults and saves them to ~/.jazari/config.yaml.
+    """
+    console.print('[bold blue]Welcome to Jazari setup.[/bold blue]')
+    console.print(f"This will create a configuration file at [dim]{CONFIG_FILE}[/dim]\n")
+
+    # 1. Ask for Slurm Account
+    # We use the current config value as the default prompt if it exists.
+    default_account = CONFIG.get("account", "")
+    account = Prompt.ask(
+        "Enter your default Slurm account (e.g., def-user)",
+        default=default_account
+    )
+
+    # 2. Ask for default time limit
+    default_time = CONFIG.get("time", "01:00:00")
+    time_limit = Prompt.ask(
+        "Enter default time limit (D-HH:MM)",
+        default=default_time
+    )
+
+    # 3. Ask for W&B tracking default
+    default_wandb = CONFIG.get("track_wandb", False)
+    track_wandb = Confirm.ask(
+        "Enable W&B tracking by default?",
+        default=default_wandb
+    )
+
+    # Prepare the config dictionary
+    new_config = {
+        "account": account,
+        "time": time_limit,
+        "track_wandb": track_wandb
+    }
+
+    make_config_dir(new_config)
+
+    console.print(f"\n[bold green]✅ Configuration saved![/bold green]")
+    console.print("You can now run jobs without specifying these flags.")
+
+def run_command(
+    # The default values for these arguments are now pulled dynamically from the
+    # CONFIG dictionary using the get_config_default helper.
+    command:     list[str]      = typer.Argument(..., help="The command to run (e.g., python train.py --batch 64). Use '--' before it if it has flags."),
+    nodes:       int            = typer.Option(get_config_default("nodes", CONFIG, 1), '--nodes', '-N', help='Number of nodes.'),
+    gpus:        int            = typer.Option(get_config_default("gpus", CONFIG, 1), '--gpus', '-G', help='GPUs per node.'),
+    cpus:        int            = typer.Option(get_config_default("cpus", CONFIG, 1), '--cpus', '-c', help='CPUs per task/GPU'),
+    time:        str            = typer.Option(get_config_default("time", CONFIG, '01:00:00'), '--time', '-t', help='Time limit (D-HH:MM)'),
+    name:        str            = typer.Option('jazari_run', '--name', '-n', help='Job name'),
+    account:     Optional[str]  = typer.Option(get_config_default("account", CONFIG, None), "--account", "-A", help="Slurm account to charge."),
+    track_wandb: bool           = typer.Option(get_config_default("track_wandb", CONFIG, False), "--track-wandb", help="Auto-configure W&B."),
+    push_to_hub: Optional[str]  = typer.Option(None, "--push-to-hub", help="Hugging Face repo ID to upload model to (e.g. 'my-org/my-model)."),   
+    pull_data:   Optional[str]  = typer.Option(None, '--pull-data', help='Huggingface dataset ID to download.'),
+    dry_run:     bool           = typer.Option(False, '--dry-run', help='Print sbatch script without submitting.'),
+    ):
+    '''
+    Launch a distributed training job.
+    '''
+    if not command:
+        console.print("[bold red]Error:[/bold red] You must provide a command to run.")
+        sys.exit(1)
+
+    log_dir = "logs"
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir, exist_ok=True)
+
+    full_command_str = ' '.join(command)
+
+    # --- Weights & Biases ---
+    wandb_key = None
+    if track_wandb:
+        console.print("[dim]W&B tracking enabled.[/dim]")
+        wandb_key = get_wandb_api_key()
+        if not wandb_key:
+            console.print("[bold yellow]Warning:[/bold yellow] Could not find W&B API key locally.")
+            console.print("Please run [green]wandb login[/green] on this machine first.")
+    # -----------------
+
+    console.print(f'[bold]🐘 Generating Slurm script for: {name}[/bold]')
+
+    sbatch_content = generate_sbatch_script(
+        nodes           = nodes,
+        gpus_per_node   = gpus,
+        cpus_per_task   = cpus,
+        time_limit      = time,
+        job_name        = name,
+        account_name    = account,
+        wandb_api_key   = wandb_key,
+        hf_repo_id      = push_to_hub,
+        hf_dataset_id   = pull_data,
+        user_command    = full_command_str
+    )
+
+    if dry_run:
+        console.print('\n[yellow]--- DRY RUN: Generated #SBATCH Script ---[/yellow]')
+        syntax = Syntax(sbatch_content, 'bash', theme = 'monokai', line_numbers = True)
+        console.print(syntax)
+        console.print('[yellow]-----------------------------------------------[/yellow]')
+    else:
+        console.print("[dim]Submitting to Slurm scheduler...[/dim]")
+
+        # --- Submission ---
+        with tempfile.NamedTemporaryFile(mode='w+', suffix=".sh", delete=False) as temp_file:
+            temp_script_path = temp_file.name
+            temp_file.write(sbatch_content)
+
+        try:
+            result = subprocess.run(
+                ["sbatch", temp_script_path],
+                check=True,
+                capture_output=True,
+                text=True
+            )
+            # Extract the job ID from the output "Submitted batch job 12345"
+            job_id = result.stdout.strip().split()[-1]
+            console.print(f"[bold green]✅ Job submitted successfully![/bold green] (ID: [bold]{job_id}[/bold])")
+            console.print(f"[dim]View logs: cat logs/{name}-{job_id}.out[/dim]")
+
+        except subprocess.CalledProcessError as e:
+            console.print("[bold red]❌ Failed to submit job.[/bold red]")
+            console.print(f"Sbatch error: {e.stderr}")
+        except FileNotFoundError:
+             console.print("\n[bold red]❌ Error:[/bold red] 'sbatch' command not found.")
+             console.print("Are you running this on a Slurm login node?")
+        finally:
+            if os.path.exists(temp_script_path):
+                os.unlink(temp_script_path)
+
+# --- APP DEFINITION AND COMMAND REGISTRATION ---
+
+# Initializing the Typer app
+app = typer.Typer(
+    name="jazari",
+    help="🐘 The orchestration layer for modern Slurm clusters.",
+    add_completion=False,
+    no_args_is_help=True
+)
+
+# Explicitly register the commands
+app.command(name="status")(status_command)
+app.command(name="kill")(kill_command)
+app.command(name="logs")(logs_command)
+app.command(name="init")(init_command)
+app.command(name="run")(run_command)
+
+if __name__ == "__main__":
+    app()

jazari/slurm_generator.py

@@ -0,0 +1,43 @@
+import os
+from typing import Optional
+from jinja2 import Environment, FileSystemLoader
+
+# Setting up the jinya environment to load templates from the templates folder.
+base_dir        = os.path.dirname(os.path.abspath(__file__))
+template_dir    = os.path.join(base_dir, "templates")
+env             = Environment(loader = FileSystemLoader(template_dir), trim_blocks = True, lstrip_blocks = True)
+
+def generate_sbatch_script(
+        nodes:          int,
+        gpus_per_node:  int,
+        cpus_per_task:  int,
+        time_limit:     str,
+        job_name:       str,
+        account_name:   Optional[str],
+        wandb_api_key:  Optional[str],
+        hf_repo_id:     Optional[str],
+        hf_dataset_id:  Optional[str],
+        user_command:   str
+):
+    '''
+    Loads the master template and renders it with user parameters.
+    '''
+    
+    # loading the template file
+    template                = env.get_template('sbatch_master.sh.j2')
+
+    # inflating placeholders
+    rendered_script         = template.render(
+        nodes               = nodes,
+        gpus_per_node       = gpus_per_node,
+        cpus_per_task       = cpus_per_task,
+        time_limit          = time_limit,
+        job_name            = job_name,
+        account_name        = account_name,
+        wandb_api_key       = wandb_api_key,
+        hf_repo_id          = hf_repo_id,
+        hf_dataset_id       = hf_dataset_id,
+        user_command_script = user_command
+    )
+
+    return rendered_script

jazari-0.0.1.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: jazari
+Version: 0.0.1
+Summary: The orchestration layer for modern Slurm clusters.
+Author-email: Levent Ozbek <levent@jazari.run>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: annotated-types==0.7.0
+Requires-Dist: certifi==2025.11.12
+Requires-Dist: charset-normalizer==3.4.4
+Requires-Dist: click==8.3.1
+Requires-Dist: gitdb==4.0.12
+Requires-Dist: GitPython==3.1.45
+Requires-Dist: idna==3.11
+Requires-Dist: Jinja2==3.1.6
+Requires-Dist: markdown-it-py==4.0.0
+Requires-Dist: MarkupSafe==3.0.3
+Requires-Dist: mdurl==0.1.2
+Requires-Dist: packaging==25.0
+Requires-Dist: platformdirs==4.5.0
+Requires-Dist: pydantic==2.12.5
+Requires-Dist: pydantic_core==2.41.5
+Requires-Dist: Pygments==2.19.2
+Requires-Dist: PyYAML==6.0.3
+Requires-Dist: requests==2.32.5
+Requires-Dist: rich==14.2.0
+Requires-Dist: sentry-sdk==2.46.0
+Requires-Dist: shellingham==1.5.4
+Requires-Dist: smmap==5.0.2
+Requires-Dist: typer==0.20.0
+Requires-Dist: typing-inspection==0.4.2
+Requires-Dist: typing_extensions==4.15.0
+Requires-Dist: urllib3==2.5.0
+Requires-Dist: wandb==0.17.0
+Requires-Dist: huggingface_hub>=0.23.0
+Dynamic: license-file
+
+# 🐘 Jazari
+
+**The orchestration layer for modern Slurm clusters.**
+
+Jazari is a command-line tool that makes launching distributed AI/ML training jobs on high-performance computing (HPC) clusters as easy as running a script on your laptop.
+
+It abstracts away the complexity of writing Slurm (`#SBATCH`) scripts, handling multi-node networking, and managing environment variables.
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Why Jazari?
+
+If you are a researcher using a university or national supercomputer (like Compute Canada/Digital Alliance), you know the pain:
+
+* **The Script Nightmare:** Copy-pasting old bash scripts, accidentally leaving in wrong parameters, and debugging obscure `sbatch` errors.
+* **Networking Headaches:** Manually figuring out how to get PyTorch DDP to find the master node's IP address across multiple machines.
+* **Experiment Fragmentation:** Having a 4-node training run spawn 4 separate experiments in Weights & Biases.
+* **Slurm Arcana:** Remembering obscure flags for accounts, time formats, and memory allocation.
+
+**Jazari solves this.** You write your Python training script, and Jazari handles the rest.
+
+---
+
+## ✨ Key Features
+
+* **🚀 One-Command Launch:** Go from Python script to running distributed job with a single CLI command.
+* **🤖 Automatic Slurm Generation:** Uses robust Jinja2 templates to generate correct, safe `#SBATCH` scripts on the fly.
+* **🧠 Zero-Config DDP Networking:** Automatically resolves master IP, ports, and world size for PyTorch Distributed Data Parallel.
+* **📈 Seamless Weights & Biases:** Securely propagates your local API key and ensures multi-node jobs log as a single, clean run.
+* **⚙️ User "Init" Profiles:** Save your default account, time limits, and preferences once and never type them again.
+* **🎨 Beautiful CLI:** Modern, color-coded output with rich error reporting.
+
+---
+
+## 🛠️ Installation
+
+Jazari is designed to be installed in a virtual environment on your cluster's login node.
+
+```bash
+# 1. Clone the repository
+git clone [https://github.com/levoz92/jazari.git](https://github.com/levoz92/jazari.git)
+cd jazari
+
+# 2. Create and activate a virtual environment (recommended)
+python3 -m venv venv
+source venv/bin/activate
+
+# 3. Install in editable mode
+pip install -e .
+```
+
+Verify the installation:
+```bash
+jazari --help
+```
+
+---
+
+## ⚡ Quick Start
+
+### 1. One-Time Setup
+
+On your cluster login node, run the init command to save your defaults (like your allocation account).
+
+```bash
+jazari init
+```
+
+### 2. Create a Python Script
+
+Here is a minimal PyTorch DDP example (`train.py`):
+
+```python
+import os
+import torch
+import torch.distributed as dist
+
+def main():
+    # 1. Initialize Process Group (Jazari sets all necessary env vars)
+    dist.init_process_group(backend="nccl")
+    
+    rank = dist.get_rank()
+    world_size = dist.get_world_size()
+    print(f"👋 Hello from rank {rank} of {world_size} on node {os.uname().nodename}!")
+
+    # Your training loop here...
+
+    # 3. Clean up
+    dist.destroy_process_group()
+
+if __name__ == "__main__":
+    main()
+```
+
+### 3. Launch It!
+
+Run your script on 2 nodes with 4 GPUs per node (8 GPUs total).
+
+```bash
+jazari run -N 2 -G 4 --name "my-big-run" --track-wandb python train.py --batch-size 128
+```
+
+**That's it.** Jazari will generate the script, submit it to Slurm, and stream the output.
+
+---
+
+## 📖 Usage Reference
+
+### `jazari init`
+Interactively configure your default settings. These are saved to `~/.jazari/config.yaml`.
+
+### `jazari run [OPTIONS] COMMAND`
+
+| Option | Shorthand | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `--nodes` | `-N` | Number of compute nodes to request. | `1` (or config default) |
+| `--gpus` | `-G` | Number of GPUs per node. | `1` (or config default) |
+| `--cpus` | `-c` | Number of CPU cores per task. | `1` (or config default) |
+| `--time` | `-t` | Time limit in `D-HH:MM` format (e.g., `0-02:30` for 2.5 hours). | `01:00:00` (or config default) |
+| `--account`| `-A` | Slurm account to charge (e.g., `def-user`). | Config default |
+| `--name` | `-n` | Name for the job in Slurm and W&B. | `jazari_run` |
+| `--track-wandb` | | Auto-configure Weights & Biases environment. | `False` (or config default) |
+| `--dry-run` | | Print the generated generated `#SBATCH` script to stdout without submitting. | `False` |
+
+---
+
+## 📄 License
+
+This project is licensed under the [MIT License](LICENSE) - see the LICENSE file for details.

jazari-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+jazari/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jazari/config_generator.py,sha256=BBg10poQLHIGy95frLdivNF4xhml6xeuWL7BWketm8g,1270
+jazari/main.py,sha256=Xb2MSMDyCWm1QQobPK28u-NKeKmWWwa_HzjFMuyXWRQ,12636
+jazari/slurm_generator.py,sha256=m5F76NqzMIwO4lL7MnyMWtuJTdj5Qv5qIN-P93CVKzM,1485
+jazari-0.0.1.dist-info/licenses/LICENSE,sha256=OvKjjZV2nvR_v2QrhWR4TMgvtDmZYfZLFSt3bk1q6QA,1068
+jazari-0.0.1.dist-info/METADATA,sha256=TqnlHeTjswRoosVf1-Xhg6t7vTIcYPvHaBjDBQ0rF2o,5826
+jazari-0.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+jazari-0.0.1.dist-info/entry_points.txt,sha256=9vYDaHn1_jBw_cMNC9ZKl4vRk3n2aDQ5dHL0cM8tEfE,43
+jazari-0.0.1.dist-info/top_level.txt,sha256=NY_Ke0lfKudUMc5w4rycAxzHKSgTUkhYqcmdFMYrya4,7
+jazari-0.0.1.dist-info/RECORD,,

jazari-0.0.1.dist-info/WHEEL

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

jazari-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jazari = jazari.main:app

jazari-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Levent Ozbek
+
+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.

jazari-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+jazari