voxlock 1.0.0__py3-none-any.whl

voxlock/__init__.py

@@ -0,0 +1,5 @@
+"""VoxLock, the best performing voice isolator: keeps the caller's voice and removes the other voices in the room."""
+from .core import SR, Stream, VoxLock, download, load_audio, loud_sample
+
+__version__ = "1.0.0"
+__all__ = ["SR", "Stream", "VoxLock", "download", "load_audio", "loud_sample"]

voxlock/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

voxlock/cli.py

@@ -0,0 +1,31 @@
+"""voxlock call.wav -o caller.wav"""
+import argparse, sys, time
+from pathlib import Path
+import soundfile as sf
+from . import SR, VoxLock, load_audio
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="voxlock", description="Keep the caller's voice, remove the other voices in the room.")
+    ap.add_argument("inputs", nargs="+", help="audio files, any sample rate")
+    ap.add_argument("-o", "--out", help="output file (one input) or folder (several); default: <name>.voxlock.wav")
+    ap.add_argument("--sample", help="a recording of the caller's voice; default: the loudest 3 s in the first 15 s")
+    ap.add_argument("--fp32", action="store_true", help="use the float32 model files")
+    ap.add_argument("--threads", type=int, default=0)
+    a = ap.parse_args(argv)
+    vl = VoxLock(fp16=not a.fp32, threads=a.threads)
+    sample = load_audio(a.sample) if a.sample else None
+    for src in map(Path, a.inputs):
+        if a.out and len(a.inputs) == 1:
+            dst = Path(a.out)
+        elif a.out:
+            dst = Path(a.out) / f"{src.stem}.wav"
+        else:
+            dst = src.with_name(f"{src.stem}.voxlock.wav")
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        x = load_audio(src)
+        t = time.time()
+        sf.write(str(dst), vl.isolate(x, sample), SR)
+        print(f"{src} -> {dst}  ({len(x) / SR:.1f} s in {time.time() - t:.1f} s)", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()

voxlock/core.py

@@ -0,0 +1,117 @@
+"""VoxLock on onnxruntime: isolate a whole call, or stream a live one chunk by chunk.
+
+Streaming and file mode give the same output: only the LSTM state crosses frames, and it is carried over.
+"""
+from pathlib import Path
+import numpy as np
+import onnxruntime as ort
+
+SR, HOP, NFFT, PAD = 16000, 128, 512, 256
+REPO, REVISION = "arbazsiddiqui/voxlock", "770c2e4ede56458ca0ccf977de935e46d6733f2c"
+WIN2 = (0.5 - 0.5 * np.cos(2 * np.pi * np.arange(NFFT) / NFFT)).astype(np.float32) ** 2
+
+def loud_sample(mix, sec=3.0, within=15.0):
+    """The voice sample VoxLock is benchmarked with: the loudest `sec` seconds in the first `within` seconds."""
+    seg = np.asarray(mix, np.float32)[: int(within * SR)]
+    n = len(seg) // 160
+    w = int(sec * SR / 160)
+    if n <= w:
+        return seg
+    e = (seg[: n * 160].reshape(n, 160) ** 2).mean(1)
+    st = int(np.convolve(e, np.ones(w), "valid").argmax()) * 160
+    return seg[st: st + int(sec * SR)]
+
+def load_audio(path):
+    """Any file soundfile reads, as 16 kHz mono float32."""
+    import soundfile as sf, soxr
+    x, sr = sf.read(str(path), dtype="float32", always_2d=True)
+    x = x.mean(1)
+    return (soxr.resample(x, sr, SR) if sr != SR else x).astype(np.float32)
+
+def download(fp16=True):
+    """Fetch the ONNX files from Hugging Face into its cache, once. Returns the folder holding them."""
+    from huggingface_hub import hf_hub_download
+    sfx = "_fp16" if fp16 else ""
+    hf_hub_download(REPO, "config.yaml", revision=REVISION)
+    for name in (f"onnx/enroll{sfx}.onnx", f"onnx/chunk{sfx}.onnx"):
+        path = hf_hub_download(REPO, name, revision=REVISION)
+    return Path(path).parent
+
+class VoxLock:
+    def __init__(self, model_dir=None, fp16=True, threads=0):
+        """model_dir: a folder with enroll*.onnx and chunk*.onnx; None downloads them from Hugging Face.
+        fp16=True uses the 50 MB float16-weight files, False the float32 ones. threads=0 lets onnxruntime choose."""
+        model_dir = Path(model_dir) if model_dir else download(fp16)
+        so = ort.SessionOptions()
+        if threads:
+            so.intra_op_num_threads = threads
+        sfx = "_fp16" if fp16 and (model_dir / "chunk_fp16.onnx").exists() else ""
+        self.enroll = ort.InferenceSession(str(model_dir / f"enroll{sfx}.onnx"), so)
+        self.chunk = ort.InferenceSession(str(model_dir / f"chunk{sfx}.onnx"), so)
+
+    def stream(self, sample):
+        """A live stream locked to the voice in `sample` (about 3 s of the caller, 16 kHz mono)."""
+        return Stream(self, np.asarray(sample, np.float32))
+
+    def isolate(self, audio, sample=None):
+        """The whole call in, the caller out, same length. Without `sample`, uses loud_sample(audio)."""
+        audio = np.asarray(audio, np.float32)
+        s = self.stream(loud_sample(audio) if sample is None else sample)
+        return np.concatenate([s.push(audio, frames_per_run=100), s.flush()])[: len(audio)]
+
+class Stream:
+    def __init__(self, vl, sample):
+        self.vl = vl
+        self.mag, self.ctx = vl.enroll.run(None, {"enroll": sample[None]})
+        self.h = np.zeros((6, 32, 256), np.float32); self.c = np.zeros_like(self.h)
+        self.head = np.zeros(0, np.float32)        # first samples, until the start padding can be built
+        self.buf = None                            # padded input not yet consumed by a frame
+        self.ola = np.zeros(NFFT, np.float32); self.env = np.zeros(NFFT, np.float32)
+        self.dropped = 0                           # leading padded samples still to drop from the output
+        self.n_in = 0
+
+    def _run(self, frames_per_run):
+        out = []
+        while self.buf is not None and len(self.buf) >= NFFT:
+            k = min(frames_per_run, 1 + (len(self.buf) - NFFT) // HOP)
+            seg = self.buf[: (k - 1) * HOP + NFFT]
+            fr, self.h, self.c = self.vl.chunk.run(None, {"wav": seg[None], "enroll_mag": self.mag, "context": self.ctx,
+                                                          "h": self.h, "c": self.c})
+            ola = np.concatenate([self.ola, np.zeros(k * HOP, np.float32)])
+            env = np.concatenate([self.env, np.zeros(k * HOP, np.float32)])
+            for j in range(k):
+                ola[j * HOP: j * HOP + NFFT] += fr[0, j]; env[j * HOP: j * HOP + NFFT] += WIN2
+            done = k * HOP                         # samples no later frame will touch
+            y = ola[:done] / np.where(env[:done] > 1e-11, env[:done], 1.0)
+            self.ola, self.env = ola[done:], env[done:]
+            self.buf = self.buf[done:]
+            cut = min(self.dropped, len(y)); self.dropped -= cut
+            out.append(y[cut:])
+        return np.concatenate(out) if out else np.zeros(0, np.float32)
+
+    def push(self, chunk, frames_per_run=100):
+        """Any number of 16 kHz samples in; the isolated audio that is ready comes out, 24 ms behind the input."""
+        chunk = np.asarray(chunk, np.float32)
+        self.n_in += len(chunk)
+        if self.buf is None:
+            self.head = np.concatenate([self.head, chunk])
+            if len(self.head) <= PAD:
+                return np.zeros(0, np.float32)
+            self.buf = np.concatenate([self.head[1: PAD + 1][::-1], self.head])  # torch.stft centre padding (reflect)
+            self.dropped = PAD
+        else:
+            self.buf = np.concatenate([self.buf, chunk])
+        return self._run(frames_per_run)
+
+    def flush(self):
+        """End of the call: returns the last samples still held back."""
+        if self.buf is None:
+            return np.zeros(0, np.float32)
+        x = np.concatenate([self.buf, self.buf[-PAD - 1: -1][::-1]])  # end padding (reflect)
+        nfr = 1 + (len(x) - NFFT) // HOP
+        x = np.pad(x, (0, max(0, (nfr - 1) * HOP + NFFT - len(x))))
+        self.buf = x
+        y = self._run(100)
+        y = np.concatenate([y, self.ola / np.where(self.env > 1e-11, self.env, 1.0)])
+        self.buf = None
+        return y

voxlock-1.0.0.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: voxlock
+Version: 1.0.0
+Summary: The best performing voice isolator there is: keeps the caller's voice and removes the other voices in the room. Streaming, CPU, ONNX.
+Author-email: Arbaz Siddiqui <arbaz00@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://huggingface.co/arbazsiddiqui/voxlock
+Project-URL: Repository, https://github.com/arbazsiddiqui/voxlock
+Project-URL: Demo, https://arbazsiddiqui.me/voxlock
+Project-URL: Issues, https://github.com/arbazsiddiqui/voxlock/issues
+Keywords: voice isolation,background voice cancellation,target speaker extraction,speech enhancement,voice agents,telephony,speech-to-text,streaming,real-time,onnx
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: huggingface_hub>=0.20
+Requires-Dist: soundfile>=0.12
+Requires-Dist: soxr>=0.3
+Dynamic: license-file
+
+# VoxLock
+
+**The best performing voice isolator there is.** VoxLock is an open-source voice isolation model: it keeps the caller's voice and removes the other voices in the room before speech-to-text hears them. Made for voice agents and phone calls: one input, the call audio, and it picks out the caller by itself. It streams on a CPU with 24 ms of algorithmic latency.
+
+**[Live demo](https://arbazsiddiqui.me/voxlock)** · **[Model on Hugging Face](https://huggingface.co/arbazsiddiqui/voxlock)**
+
+<p>
+  <a href="https://pypi.org/project/voxlock/"><img alt="PyPI" src="https://img.shields.io/pypi/v/voxlock?label=pypi"></a>
+  <a href="https://huggingface.co/arbazsiddiqui/voxlock"><img alt="Hugging Face" src="https://img.shields.io/badge/%F0%9F%A4%97%20model-voxlock-yellow"></a>
+  <a href="https://github.com/arbazsiddiqui/voxlock#results"><img alt="Krisp benchmark WER 4.95%" src="https://img.shields.io/badge/Krisp%20benchmark%20WER-4.95%25-brightgreen"></a>
+  <a href="https://github.com/arbazsiddiqui/voxlock/blob/main/LICENSE"><img alt="License: Apache-2.0" src="https://img.shields.io/badge/license-Apache--2.0-blue"></a>
+</p>
+
+<a href="https://raw.githubusercontent.com/arbazsiddiqui/voxlock/main/assets/demo.mp4"><img src="https://raw.githubusercontent.com/arbazsiddiqui/voxlock/main/assets/demo-play.jpg" alt="The same 6.5 seconds of a call with VoxLock off and on: off, speech-to-text transcribes the other person; on, it transcribes the caller" width="100%"></a>
+
+## Results
+
+<img src="https://raw.githubusercontent.com/arbazsiddiqui/voxlock/main/assets/results.png" alt="VoxLock has the lowest word error rate and leaks the fewest background words on the Krisp Voice Isolation Benchmark" width="100%">
+
+| Model | Access | Word error rate % | Background words leaked / min |
+|---|---|---|---|
+| **VoxLock** | **open** | **4.95** | **0.11** |
+| Krisp VI 2.5 Default | paid | 5.30 | 1.52 |
+| Krisp VI 2.5 Balanced | paid | 5.32 | 2.02 |
+| Krisp VI 2.5 HD | paid | 5.79 | 2.74 |
+| Krisp VI 2.5 Lite | paid | 6.21 | 4.52 |
+| ai-coustics Voice Focus 2.2 L | paid | 6.84 | 0.66 |
+| ai-coustics Voice Focus 2.2 S | paid | 6.91 | 1.00 |
+| Sanas Voice Isolation SE 1.0 | paid | 9.38 | 13.76 |
+| REAL-TSE causal (VoxLock's starting checkpoint) | open | 9.81 | 13.73 |
+| Hush | open | 12.09 | 19.58 |
+| DeepFilterNet3 | open | 13.30 | 22.77 |
+| TIGER | open | 14.72 | 37.24 |
+| No processing | | 23.21 | 66.48 |
+| SAM-Audio small (Meta) | open | 33.77 | 21.15 |
+
+265 real recordings from the [Krisp Voice Isolation Benchmark](https://huggingface.co/datasets/Krisp-AI/VoiceIsolation-Benchmark-Dataset), transcribed with Parakeet TDT 0.6B v2 and scored with the benchmark's published method. **Background words leaked** counts words transcribed while only the background was talking, per minute of that audio.
+
+On real AMI meetings not used in training, with the headset wearer as the caller:
+
+| Model | Access | Word error rate % | Background words leaked / min |
+|---|---|---|---|
+| **VoxLock** | **open** | **10.12** | 2.12 |
+| ai-coustics Voice Focus 2.2 S | paid | 11.85 | **1.06** |
+| ai-coustics Voice Focus 2.2 L | paid | 12.13 | 1.72 |
+| Sanas Voice Isolation SE 1.0 | paid | 13.30 | 5.30 |
+| TIGER | open | 22.84 | 36.85 |
+| DeepFilterNet3 | open | 26.78 | 38.84 |
+| Hush | open | 33.00 | 68.93 |
+| No processing | | 33.03 | 78.34 |
+
+Caller words missed, deletions, insertions and 95% intervals: [bench/results](https://github.com/arbazsiddiqui/voxlock/tree/main/bench/results).
+
+## Use
+
+```bash
+pip install voxlock
+voxlock call.wav -o caller.wav
+```
+
+Any sample rate, mono or stereo. The model, 50 MB, downloads from Hugging Face on first use.
+
+```python
+import voxlock
+
+vl = voxlock.VoxLock()
+call = voxlock.load_audio("call.wav")      # 16 kHz mono float32
+caller = vl.isolate(call)                  # same length as the input
+```
+
+VoxLock keeps the voice in a 3-second sample of the caller. `isolate` takes the loudest 3 seconds in the first 15 seconds of the call, which is how it was benchmarked. Pass `sample=` to choose it yourself.
+
+### Live calls
+
+```python
+stream = vl.stream(sample)                 # about 3 s of the caller, 16 kHz mono
+for chunk in call_audio:                   # 16 kHz float32 chunks of any size
+    send(stream.push(chunk))               # the isolated audio, about 24 ms behind
+send(stream.flush())                       # at the end of the call
+```
+
+The stream needs the sample before it starts. In a voice agent, take the first 3 seconds the caller speaks, or a sample saved from an earlier call, and pass the audio through until then. Streaming gives the same output as `isolate`. With 4 CPU threads on an Apple M2 Pro it runs in real time from 40 ms chunks (`VoxLock(threads=4)`).
+
+### PyTorch
+
+```bash
+git clone https://github.com/arbazsiddiqui/voxlock && cd voxlock
+pip install -r requirements.txt
+huggingface-cli download arbazsiddiqui/voxlock model.safetensors config.yaml --local-dir ckpt
+python isolate.py --ckpt ckpt --in call.wav --out caller.wav
+```
+
+## Training
+
+A 27M causal band-split RNN target-speaker extractor, fine-tuned from the [REAL-TSE challenge baseline](https://github.com/REAL-TSE/wesep-real-tse) on a single NVIDIA L4:
+
+```
+REAL-TSE tfmap_context_causal_100
+  -> simulated calls        4,000 steps   LibriSpeech callers + background talkers in simulated rooms
+  -> real AMI crosstalk     4,000 steps   headset recordings from 40 meetings
+  -> long calls (30 s)        800 steps   callers who talk throughout
+  -> rooms and distances     400 steps   callers near or far from the mic, background voices dry or in the room, room noise
+```
+
+## Repository
+
+| Path | |
+|---|---|
+| `voxlock/` | the `pip install voxlock` package: whole files, streaming, command line |
+| `isolate.py` | PyTorch inference |
+| `export_onnx.py` | ONNX export |
+| `demo/` | the browser demo (`python demo/serve.py`) |
+| `bench/` | benchmark harness, vendor runners, per-file results |
+| `train/` | training scripts and data preparation |
+
+## Acknowledgements
+
+Built on the REAL-TSE challenge baseline and [WeSep](https://github.com/wenet-e2e/wesep) by Shuai Wang, Ke Zhang and co-authors, with [WeSpeaker](https://github.com/wenet-e2e/wespeaker)'s ECAPA model. Trained on [LibriSpeech](https://www.openslr.org/12) and the [AMI Meeting Corpus](https://groups.inf.ed.ac.uk/ami/corpus/).
+
+## License
+
+Apache-2.0.

voxlock-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+voxlock/__init__.py,sha256=sCF_xgojKcUCQjxcNcexaLAkPQIvXlxFMlIixYfrT0g,293
+voxlock/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+voxlock/cli.py,sha256=fRYLksiFU8WZ-rXc4ae83bfRKLkPLbtQ63Cy8J5WfVk,1437
+voxlock/core.py,sha256=7HyQ2d0qRQzrUmmEsGhPkujWtucZTkwR-sb-XE4OigQ,5932
+voxlock-1.0.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+voxlock-1.0.0.dist-info/METADATA,sha256=kUhyeDyLqSwZXATlkixP2gsvX5fq4o_Pg0JFXwmMnMI,7639
+voxlock-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+voxlock-1.0.0.dist-info/entry_points.txt,sha256=xicjS3SJ9AmbFQHT3wznPOdl1cSjXIdHh4ZpRNMVwqc,45
+voxlock-1.0.0.dist-info/top_level.txt,sha256=yKNbTYDfJHagOoPXFjMvdD-fWgJIdciT13eCuN2YFBs,8
+voxlock-1.0.0.dist-info/RECORD,,

voxlock-1.0.0.dist-info/WHEEL

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

voxlock-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+voxlock = voxlock.cli:main

voxlock-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

voxlock-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+voxlock