snakemake-executor-plugin-aws-batch-flex 0.1.0__py3-none-any.whl

snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/METADATA

@@ -0,0 +1,343 @@
+Metadata-Version: 2.5
+Name: snakemake-executor-plugin-aws-batch-flex
+Version: 0.1.0
+Summary: Snakemake executor plugin for AWS Batch that runs every rule in its own container image
+Project-URL: Homepage, https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex
+Project-URL: Documentation, https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex#getting-started
+Project-URL: Issues, https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/issues
+Project-URL: Changelog, https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/CHANGELOG.md
+Author: Stephen Smith
+License: MIT
+License-File: LICENSE
+Keywords: aws,aws-batch,bioinformatics,executor,plugin,snakemake
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.11
+Requires-Dist: boto3>=1.34
+Requires-Dist: pyyaml
+Requires-Dist: snakemake-interface-common<2,>=1.17.4
+Requires-Dist: snakemake-interface-executor-plugins<10,>=9.3.2
+Requires-Dist: snakemake-interface-storage-plugins<5,>=4.0.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-xdist; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Requires-Dist: snakemake; extra == 'test'
+Requires-Dist: snakemake-storage-plugin-fs; extra == 'test'
+Requires-Dist: snakemake-storage-plugin-s3; extra == 'test'
+Description-Content-Type: text/markdown
+
+# snakemake-executor-plugin-aws-batch-flex
+
+Run [Snakemake](https://snakemake.readthedocs.io) workflows on [AWS Batch](https://aws.amazon.com/batch/),
+with each step running in whatever container image you choose: a stock image from Docker Hub,
+quay.io/biocontainers, your own ECR repository, and so on. The images don't need Snakemake or
+Python inside them.
+
+In plain terms: you write a workflow on your own computer, and this plugin sends each step to
+AWS, where machines are started for you, run the step in its container, save the results to S3
+(Amazon's file storage) and shut down again when there's nothing left to do. You pay only while
+machines are running.
+
+How it works, briefly: a copy of Snakemake is built into the machine image (an "AMI") that the
+AWS machines start from, and every job gets read access to it. That's why your containers don't
+need it. On Fargate (AWS's serverless option, no machines to manage) Snakemake is installed into
+the container when the job starts instead.
+
+**How it differs from the aws-batch plugin.** The other AWS Batch executor in the Snakemake
+plugin catalog,
+[snakemake-executor-plugin-aws-batch](https://github.com/snakemake/snakemake-executor-plugin-aws-batch), runs
+`snakemake` inside each job's container, so every image a rule uses needs Snakemake and the S3
+storage plugin installed; the usual biocontainers and stock images can't be used as they are.
+This plugin brings Snakemake to the job instead, so each rule can use any image, and conda envs
+work in images without conda. It also sets up the AWS side in one command, mixes EC2, Spot and
+Fargate queues in one run, can run Snakemake itself on AWS (`smkflex run`), retries jobs that
+ran out of memory with more, and reports what each rule used, with the memory and threads to give it.
+
+This page takes you from nothing to a finished test run ([Getting started](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex#getting-started)),
+then shows how to run your own workflow and what you can set on each rule. The rest is in three
+more pages:
+
+- [Guide](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md): published pipelines, moving from a cluster, long runs with `smkflex`,
+  conda, the usage table, Spot and Fargate, private images, and troubleshooting;
+- [Reference](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/reference.md): every profile setting and `smkflex` command, IAM, what has been
+  tested, and the limits;
+- [Setup and upkeep](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/setup.md): university and company accounts, updating the machine image,
+  setting up by hand, and removing everything.
+
+## Getting started
+
+These steps take you from nothing to a finished test run, in under an hour. They assume you're
+comfortable typing commands into a terminal, but not that you know AWS or Snakemake.
+
+It has been tested on Linux. On Windows, use [WSL](https://learn.microsoft.com/windows/wsl/install)
+and run everything inside it. macOS should work but hasn't been tried.
+
+### 1. What you need
+
+- An AWS account. Setting this up costs very little: building the machine image runs one small
+  machine for about 10 minutes, and keeping the image costs well under $1 a month. The test run
+  in step 5 costs a few cents. If your account comes from your university or company, read
+  [University and company accounts](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/setup.md#university-and-company-accounts) first.
+- Somewhere to run commands: your laptop is fine. When you run `snakemake` it has to stay on
+  (and online) until the workflow finishes, because it's what tells AWS what to do next;
+  `smkflex run` hands that to AWS instead (see [Long runs](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#long-runs-smkflex)).
+
+### 2. Install the tools
+
+Install [Miniforge](https://github.com/conda-forge/miniforge#install) if you don't already have
+`conda`. Then get this repository and create an environment with everything you need (Python,
+Snakemake, Terraform, the AWS command-line tool and `snakedeploy`):
+
+```bash
+git clone https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex.git
+cd snakemake-executor-plugin-aws-batch-flex
+conda env create -f environment.yml
+conda activate smk-aws
+pip install -e .
+```
+
+Run `conda activate smk-aws` again in every new terminal before the steps below.
+
+Check it worked: `snakemake --version` should print a version number (9.x), and
+`snakemake --help | grep aws-batch-flex` should list this plugin's settings.
+
+### 3. Connect to your AWS account
+
+The command-line tools need an access key. In the [AWS console](https://console.aws.amazon.com/):
+
+1. Go to **IAM** > **Users** > **Create user**. Give it a name (e.g. `snakemake-admin`).
+2. On the permissions page choose **Attach policies directly** and tick **AdministratorAccess**.
+   (Setup creates machines, roles, a queue and a bucket, which needs broad permissions. Don't
+   use your account's root login for this.)
+3. Open the new user > **Security credentials** > **Create access key** > **Command Line
+   Interface (CLI)**. Copy the access key ID and secret access key.
+
+Then in your terminal:
+
+```bash
+aws configure
+```
+
+Paste the two keys when asked. For the region, pick the one closest to you, e.g. `eu-west-1`
+(Ireland) or `us-east-1` (N. Virginia), and use the same one everywhere below. Leave the output
+format empty.
+
+Check it worked: `aws sts get-caller-identity` should print your account number. (If you log in
+through a university or company page instead, follow
+[University and company accounts](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/setup.md#university-and-company-accounts) for this step.)
+
+### 4. Set up AWS
+
+One script does the rest of the setup. It finds your account's network, builds a machine image
+with Snakemake on it (plus conda and pandas, which most published pipelines need), creates the
+queue, roles and bucket with Terraform, and installs a Snakemake profile called `smkflex` in
+`~/.config/snakemake/smkflex/`. A profile is a settings file: it tells Snakemake to use this
+plugin, your queue and your bucket, and because it's installed by name, `snakemake --profile
+smkflex` works in any folder. Use the region you picked in step 3:
+
+```bash
+bash scripts/setup.sh --region eu-west-1
+```
+
+It asks twice before creating anything. The first time is before building the machine image,
+which takes 10 to 20 minutes. The second is after showing what Terraform will create (about 20
+new resources, nothing changed or removed). At the end it checks the whole setup and says
+`All good.`. If it stops halfway, fix what it says and run the same command again: it carries on
+where it stopped.
+
+Options: `--fargate` also creates a Fargate queue and `--spot` a cheaper Spot queue (see
+[Spot and Fargate queues](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#spot-and-fargate-queues)), `--extra-package NAME` adds a Python
+package to the image, and `--no-conda` leaves conda out. `bash scripts/setup.sh --help` lists the
+rest. To do each step by hand instead, see [Setting up by hand](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/setup.md#setting-up-by-hand).
+
+Nothing is running (or costing money) yet: machines start when jobs arrive and stop when the
+queue is empty.
+
+### 5. Run the test workflow
+
+```bash
+cd examples/smoke-test
+snakemake --profile smkflex
+```
+
+What happens: Snakemake uploads the workflow to S3 and submits two jobs. The first time, AWS has
+to start a machine, so the jobs show as waiting for a few minutes. Then each job runs in its own
+container (`debian:12`, which has no Python) and writes its result to S3. When it's finished
+you'll see `3 of 3 steps (100%) done`, followed by a table of what the run used.
+
+Download the results from the bucket and look at them:
+
+```bash
+smkflex pull results --profile smkflex
+cat results/hello.txt results/sum.txt
+```
+
+The first says hello from Debian and `image has NO python3`; the second is `45`. A few minutes
+later the machine shuts itself down.
+
+### 6. Set a budget alert
+
+Before running real pipelines, set a budget alert, so a mistake (a huge job, or a forgotten
+setting) costs an email rather than a surprise bill. In the AWS console, **Billing and Cost
+Management** > **Budgets** > **Create budget** > **Use a template** > **Monthly cost budget**:
+enter an amount (e.g. $50) and your email address. AWS then mails you at 85% and 100% of it, and
+when the month's forecast goes over. It takes two minutes and costs nothing.
+
+As a rough guide: compute costs about $0.05 per vCPU-hour on normal instances (a third of that
+on Spot), so a job using 4 vCPUs for an hour costs about $0.20. The published RNA-seq pipeline
+in [Running a published pipeline](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#running-a-published-pipeline) ran its 53 test jobs for about
+$0.10; a real run with 20 samples of 30 million reads should be a few dollars (an estimate, not
+measured). S3 storage is about $0.02 per GB per month. The table at the end of every run shows
+what that run used (see [What a run used](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#what-a-run-used)).
+
+That's the setup done. Next, depending on what you're running:
+
+- a workflow of your own: [Your own workflow](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex#your-own-workflow);
+- a pipeline from the Snakemake workflow catalog: [Running a published pipeline](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#running-a-published-pipeline);
+- a pipeline you've been running on a cluster: read [Your own workflow](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex#your-own-workflow),
+  then [Coming from a cluster](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#coming-from-a-cluster).
+
+## Running your workflows
+
+### Your own workflow
+
+A Snakemake workflow is a file called `Snakefile` made of rules. Each rule says what files it
+makes (`output`), what it needs (`input`), which container to use, and the command to run:
+
+```python
+rule count_lines:
+    input: "data/reads.txt"
+    output: "results/count.txt"
+    container: "docker://debian:12"
+    resources: mem_mb=1000
+    shell: "wc -l < {input} > {output}"
+```
+
+Snakemake works out the order from the file names, and with this plugin each rule runs as a
+Batch job. The [Snakemake tutorial](https://snakemake.readthedocs.io/en/stable/tutorial/tutorial.html)
+explains rules, wildcards and the rest; everything in it works here, with the differences listed
+under [Limits](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/reference.md#limits).
+
+Each workflow lives in its own project folder, and its files live in your S3 bucket: jobs read
+their inputs from there, never from your computer, so upload them first, and write their outputs
+there. Put the `Snakefile` in a new folder and,
+in that folder:
+
+```bash
+smkflex init                     # gives this project its own folder in the bucket
+smkflex push data                # uploads data/reads.txt to it
+snakemake --profile smkflex      # runs the workflow
+smkflex pull results             # downloads results/ from it
+```
+
+`smkflex init` writes the project's own settings file, `profiles/default/config.yaml`, with the
+project's folder in the bucket (`s3://YOUR-BUCKET/snakemake/<folder name>`, so each project's
+`results/` stay apart), and adds `data/`, `results/` and the like to the folder's `.gitignore`.
+Snakemake loads that file by itself, on top of the `smkflex` profile, so it's also the place for
+anything this workflow needs (memory, conda, retries, see [Tuning jobs](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#tuning-jobs)); the
+`smkflex` profile keeps what's the same for every workflow (your queue, bucket and roles).
+
+`data` is only this example's folder: push whatever files and folders your rules and sample
+sheets name (`smkflex push reads samples.tsv`), and pull whichever outputs you want
+(`smkflex pull results/qc`). `push` and `pull` skip files that are already there with the same
+size (`--dry-run` only lists them) and also take absolute paths (see
+[Coming from a cluster](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/guide.md#coming-from-a-cluster)); paths that go up out of the project folder
+(`../raw`) can't be mapped to storage, so use an absolute path for those. If something you push
+isn't in `.gitignore`, `push` says so, since `smkflex run` would otherwise send it along with
+the workflow.
+`export SNAKEMAKE_PROFILE=smkflex` saves typing `--profile` every time. `examples/conformance/`
+has one small workflow per feature (scripts, conda, checkpoints, Fargate, ...) if you want to
+see more.
+
+### Resources per rule
+
+Everything about a job is set on its rule. An example with every option in the table below (a real
+rule only needs the few it uses):
+
+```python
+rule align:
+    input: "data/{sample}.fq"
+    output: "results/{sample}.sam"
+    container: "docker://quay.io/biocontainers/bwa:0.7.17--h7132678_9"
+    threads: 8
+    retries: 4
+    resources:
+        mem_mb=16000,
+        runtime=120,                          # minutes
+        batch_shm_mb=4096,                    # EC2 only
+        disk_mb=100000,                       # Fargate only
+        gpu=1,                                # needs a queue with GPU machines
+        batch_queue="smkflex-big-queue",
+        batch_platform="ec2",                 # only if the queue can't be looked up
+        batch_tags="stage=align,project=rnaseq",
+        batch_spot_retries=3,                 # Spot queues
+        batch_priority=500,                   # fair-share queues
+        batch_script_python="host",           # script: rules only
+        # batch_entrypoint='["python3"]',     # only if the image's registry can't be read
+        # batch_job_definition="my-jobdef",   # instead of the plugin's own; it then sets the image
+    shell: "bwa mem -t {threads} ref.fa {input} > {output}"
+```
+
+| On the rule | What it does on AWS |
+|---|---|
+| `container: "docker://..."` | The image the job runs in. Any registry works (Docker Hub, quay.io, ghcr.io, ECR...); `docker://` is optional. Rules without one use `aws-batch-flex-default-image`. Images with an `ENTRYPOINT` work too: Batch can't change it, so the plugin reads it from the registry and gives the jobs a command it runs. |
+| `threads: 8` | Number of vCPUs requested. On EC2, a job bigger than the largest machine the queue may start waits forever (the plugin warns after `runnable-warn-minutes`). On Fargate, vCPUs and memory are rounded up to the nearest size Fargate offers (at most 16 vCPUs and 120 GiB). |
+| `mem_mb=16000` (or `mem_mib`) | Memory requested, a hard limit. Snakemake itself runs inside the job too, so 256 MiB is added (`mem-overhead-mib`). Without it (many published pipelines don't set it), `default-resources` applies, or else 2048 MiB. A job that goes over it is stopped; with `--retries 2` (or `retries: 2` in the profile) it's retried with twice the memory, then four times (`oom-memory-factor`). The end-of-run table shows what each rule really used. |
+| `retries: 2` | Not a resource but a rule setting (or `retries: 2` in the profile for every rule): how many times Snakemake runs a failed job again. A job that ran out of memory gets more on each retry (`oom-memory-factor`), and `attempt` lets a rule raise anything itself, e.g. `mem_mb=lambda wildcards, attempt: 4000 * attempt` (then the rule's own figure is used, not doubled on top). Jobs that lost their Spot machine are restarted by Batch instead (`batch_spot_retries`) and don't use these up. |
+| `runtime=120` | Minutes before Batch stops the job (timeout); `"2h"` also works. To give every rule a timeout, put `runtime` in `default-resources`. |
+| `batch_shm_mb=4096` | Size of `/dev/shm` (Docker's default is 64 MB), for tools that use shared memory, e.g. bwa-mem2 or PyTorch data loaders. What's stored there counts towards `mem_mb`. EC2 only. `shared_memory_size_mb` also works. |
+| `disk_mb=100000` (or `disk_mib`) | Fargate only: disk space for the job, up to 200 GiB, rounded up to 25 GiB steps. Without it, Snakemake asks for twice the size of the job's input files, and jobs get at least 20 GiB (or `ephemeral-storage-gib`). On EC2 it's ignored: jobs share their machine's disk (see [Limits](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/reference.md#limits)). |
+| `gpu=1` | Number of GPUs (needs a queue with GPU instances; untested). |
+| `batch_queue="other-queue"` | Send this rule to a different queue than the profile's. EC2, Spot and Fargate queues can be mixed in one workflow; the plugin works out which is which. |
+| `batch_platform="fargate"` | Force the platform instead of detecting it from the queue (only needed if the plugin isn't allowed to look the queue up). |
+| `batch_tags="k=v,k2=v2"` | Extra tags on this rule's jobs, e.g. for cost reports. Overrides profile tags with the same key. |
+| `batch_spot_retries=0` | How often Batch retries this rule's job if its Spot instance is taken away (0-9; default from the profile, 2). `aws_batch_spot_attempts` (retries + 1) also works. |
+| `batch_priority=500` | Scheduling priority, 0-9999, higher first. Only on queues with a fair-share policy. `aws_batch_scheduling_priority` also works. |
+| `batch_job_definition="name"` | Use an existing job definition for this rule (see the `job-definition` setting). |
+| `batch_script_python="host"` | For Python `script:` rules: use Snakemake's own Python instead of the image's. |
+| `batch_entrypoint='["python3"]'` | The image's `ENTRYPOINT`, for when the plugin can't read it from the registry (it then warns at the start): a private registry without `registry-credentials`, or no network to it. `'[]'` for none. |
+
+To change resources without editing the Snakefile (for a published pipeline, say), use
+Snakemake's `set-resources`, `set-threads` and `default-resources` in the project's
+`profiles/default/config.yaml`:
+
+```yaml
+default-resources: [mem_mb=4000]   # rules that set no memory
+max-threads: 8                     # caps rules written for big cluster nodes
+set-resources:
+  align:
+    batch_queue: smkflex-big-queue
+    mem_mb: 32000
+```
+
+Snakemake features that work as usual (each has a small example in `examples/conformance/`):
+`shell:` commands; `script:` files in Python, R or bash; `run:` blocks; `conda:` environments and
+wrappers (`wrapper:`); `retries: 2`, and resources that grow with each attempt, e.g.
+`mem_mb=lambda wildcards, attempt: 4000 * attempt`; `group:` (grouped rules run as one Batch job,
+so they must share an image), `checkpoint`, `temp()`, `directory()`, `shadow:`, `log:` and
+`benchmark:`.
+
+### Most-used settings
+
+Plugin settings go in a profile as `aws-batch-flex-NAME: value` (or on the command line as
+`--aws-batch-flex-NAME value`); `setup.sh` writes the usual ones. The ones people change most:
+
+| Setting (`aws-batch-flex-...`) | What it's for |
+|---|---|
+| `queue` | The Batch queue jobs go to. |
+| `default-image` | The image for rules that have no `container:`. |
+| `conda-cache` | Reuse built conda envs: per machine (default), or kept in S3 for later runs. |
+| `oom-memory-factor` | How much more memory a job gets when it's retried after running out (default 2×). |
+| `spot-retries` | How many times Batch restarts a job whose Spot machine was taken back. |
+| `tags` | Extra tags on every job, e.g. to see costs by project. |
+
+All of them, with their defaults, are in the [Reference](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/docs/reference.md#profile-settings).
+
+## License
+
+MIT, see [LICENSE](https://github.com/SSmith-NUIG/snakemake-executor-plugin-aws-batch-flex/blob/main/LICENSE).

snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+snakemake_executor_plugin_aws_batch_flex/__init__.py,sha256=IaA5sFRnG1S-L7AfxLRHYH5iLa2YOuYaf1eGfj700is,393
+snakemake_executor_plugin_aws_batch_flex/bootstrap.py,sha256=TPxveniyGoeQLLiNzGenFvzMxxvy_67mfRVwbRe0-Fs,16930
+snakemake_executor_plugin_aws_batch_flex/bundle.py,sha256=0iYdR6QLBx-_DawAv0RI4UJokIci43DTlYQvAI5fUks,6572
+snakemake_executor_plugin_aws_batch_flex/check.py,sha256=waQLzSH2-nhMtlWBHUcVdqm6WyAD5-j9DggTVG7emhM,6379
+snakemake_executor_plugin_aws_batch_flex/condacache.py,sha256=Gv83M200P-DvrkgbEOGHp_slv1ldax24HLZZOJCuN7Q,7347
+snakemake_executor_plugin_aws_batch_flex/executor.py,sha256=0yI0akVDd7jo0TiZDOherLDpcQnN1eZfQg7DtoMz7fw,34807
+snakemake_executor_plugin_aws_batch_flex/headjob.py,sha256=AK9LpqVTayg2F4BiNaQiL3cuWQcmIl27lVxvdHErhrc,8535
+snakemake_executor_plugin_aws_batch_flex/hints.py,sha256=ZWabgkHF7PZKd1HU7ThCvLzozH4Yj4Wu6zUtsO9Ld5k,4794
+snakemake_executor_plugin_aws_batch_flex/hostenv.py,sha256=Flov0jppi3ov4-ZG-qe3wMym_KH9EQeKZfyYx2NBUb4,9801
+snakemake_executor_plugin_aws_batch_flex/imageinfo.py,sha256=-7Xr1gz2XfrgngNtoIpB2NY3kE-U6bMmmTqlF1FIgFk,10472
+snakemake_executor_plugin_aws_batch_flex/jobdefs.py,sha256=UyZAQk_dXijHfPGSDnFcz4WY4Xnlhte4Rs95QGnzYIE,9244
+snakemake_executor_plugin_aws_batch_flex/jobfixes.py,sha256=Hh-lxScLYwit7l-_zvf_JMPNr_EQGduSTcLu04D1qMU,2754
+snakemake_executor_plugin_aws_batch_flex/jobmonitor.py,sha256=MI-iwqXefYGgQpNvhu61L_Rc35nN25_D3MEij3Hx424,5179
+snakemake_executor_plugin_aws_batch_flex/naming.py,sha256=bUOBos191s6RkcqvE3G63Gjo1RWmwQvCLczTv0CRK_Q,612
+snakemake_executor_plugin_aws_batch_flex/orphans.py,sha256=AKKtyxmIvZn96TUd1R2bY1Ui1U1qzsiowS6d4rq7z9c,2155
+snakemake_executor_plugin_aws_batch_flex/patches.py,sha256=Yc3oubCC1KQKkMsGxJ1b3kMJCvWceAnmSijTt2rf2iM,9498
+snakemake_executor_plugin_aws_batch_flex/preflight.py,sha256=tijLDpkOL1dvl7Dure2BKro9btekjzDBgxXpVilsIWM,7934
+snakemake_executor_plugin_aws_batch_flex/profiles.py,sha256=0AZ4tC6Y7Qufwv8iq1TxZ9f65TncBYMnQL0K1fSfS8g,4013
+snakemake_executor_plugin_aws_batch_flex/remote.py,sha256=v0ZolXefM7ntqLCulKRVnCYIA_BHNLfeYN7-bU0G1h8,20231
+snakemake_executor_plugin_aws_batch_flex/settings.py,sha256=AHa4pnfIEmOEEbABzngP2-dCb8e1X5vwlA9kjN2aAoY,19507
+snakemake_executor_plugin_aws_batch_flex/sizing.py,sha256=y5FydaAfboMrwtkaguW7Vj5SsBWXdRdJ5b4ZuVmn6a8,2494
+snakemake_executor_plugin_aws_batch_flex/sources.py,sha256=storqscP60B0Ws_JF8QpcdtLVqPax_xklHMqro5LgNc,3850
+snakemake_executor_plugin_aws_batch_flex/tags.py,sha256=kEM53RdqrhQPHrpoaNEric9JOVdyXmR0W0afNWvoULQ,2500
+snakemake_executor_plugin_aws_batch_flex/transfer.py,sha256=K8z2hhMESuTm82JAi9D8jlXHTChLzUe1qA-Y9CreqiQ,8666
+snakemake_executor_plugin_aws_batch_flex/usage.py,sha256=NXvuxV3BZJvoKtwdKhYIA2C1sAAk_XuqtyEEq48cKaE,11183
+snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/METADATA,sha256=a7UTJpDusgJo-Ek0EiqjIUmNE4OVQWr6iT9A-IS8Qw8,21919
+snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/entry_points.txt,sha256=mJmQ6XSjNHpTd77Sq1E2NpJ4BveLpqtjdBanp8_Ht3w,167
+snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/licenses/LICENSE,sha256=Hibr4Ms3FAwzr2RXkjai7WjC4nfp5ZNeu1hJxRaEi4g,1070
+snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/RECORD,,

snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/WHEEL

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

snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+smkflex = snakemake_executor_plugin_aws_batch_flex.remote:main
+snakemake-batch-flex-host-env = snakemake_executor_plugin_aws_batch_flex.hostenv:main

snakemake_executor_plugin_aws_batch_flex-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stephen Smith
+
+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.