speakable 1.0.0__py3-none-any.whl

speakable/__init__.py

@@ -0,0 +1,4 @@
+from .normalize import normalize
+
+__version__ = "1.0.0"
+__all__ = ["normalize"]

speakable/normalize.py

@@ -0,0 +1,248 @@
+"""Turn LLM output into text a TTS engine can speak correctly.
+
+The problem this solves: an LLM happily returns "**Total: $1,234.56** due on
+2026-11-11 - call Dr. Rao at (555) 123-4567". Feed that straight to TTS and the
+caller hears "asterisk asterisk total dollar one comma two three four".
+"""
+import re
+
+from .numbers import (MONTHS, decimal_to_words, digits_to_words, int_to_words,
+                      ordinal_to_words, year_to_words)
+
+CURRENCIES = {
+    "$": ("dollar", "cent"),
+    "₹": ("rupee", "paisa"),
+    "£": ("pound", "penny"),
+    "€": ("euro", "cent"),
+    "¥": ("yen", "sen"),
+}
+
+ABBREVIATIONS = {
+    "Dr": "Doctor", "Mr": "Mister", "Mrs": "Missus", "Ms": "Miss",
+    "Prof": "Professor", "Jr": "Junior", "Sr": "Senior", "St": "Street",
+    "Ave": "Avenue", "Rd": "Road", "Blvd": "Boulevard", "Ln": "Lane",
+    "Apt": "Apartment", "Ste": "Suite", "Inc": "Incorporated",
+    "Corp": "Corporation", "Ltd": "Limited", "Dept": "Department",
+    "approx": "approximately", "vs": "versus", "etc": "et cetera",
+}
+PHRASES = {
+    "e.g.": "for example", "i.e.": "that is",
+    "a.m.": "AM", "p.m.": "PM",
+    "&": " and ", "%": " percent ", "=": " equals ",
+    "<": " less than ", ">": " greater than ",
+}
+UNITS = {
+    "kg": "kilograms", "mg": "milligrams", "lbs": "pounds", "lb": "pounds",
+    "oz": "ounces", "km": "kilometers", "cm": "centimeters",
+    "mm": "millimeters", "mi": "miles", "ft": "feet", "hrs": "hours",
+    "hr": "hours", "sec": "seconds", "ms": "milliseconds",
+    "kb": "kilobytes", "mb": "megabytes", "gb": "gigabytes",
+    "tb": "terabytes",
+}
+# Acronyms a TTS engine already says correctly as a word.
+PRONOUNCEABLE = {"NASA", "RADAR", "LASER", "SCUBA", "JSON", "YAML", "SOAP",
+                 "REST", "SIP", "RAM", "ROM", "AIDS", "OPEC", "NATO", "SIM"}
+
+_EMOJI = re.compile(
+    "[\U0001F300-\U0001FAFF\U00002600-\U000027BF\U0001F1E6-\U0001F1FF"
+    "\U00002190-\U000021FF\U0000FE00-\U0000FE0F\U00002B00-\U00002BFF]+")
+
+
+def _say_number(raw):
+    """'1,234.5' -> 'one thousand two hundred thirty-four point five'"""
+    raw = raw.replace(",", "")
+    if "." in raw:
+        whole, _, frac = raw.partition(".")
+        return decimal_to_words(whole, frac)
+    return int_to_words(int(raw))
+
+
+_FRACTIONS = {
+    (1, 2): "one half", (1, 3): "one third", (2, 3): "two thirds",
+    (1, 4): "one quarter", (3, 4): "three quarters", (1, 5): "one fifth",
+    (1, 8): "one eighth", (3, 8): "three eighths", (5, 8): "five eighths",
+}
+
+
+def _say_fraction(num, den):
+    if (num, den) in _FRACTIONS:
+        return _FRACTIONS[(num, den)]
+    return "%s over %s" % (int_to_words(num), int_to_words(den))
+
+
+def _strip_markdown(text):
+    text = re.sub(r"```[\s\S]*?```", " ", text)           # fenced code
+    text = re.sub(r"`([^`]*)`", r"\1", text)              # inline code
+    text = re.sub(r"!\[[^\]]*\]\([^)]*\)", " ", text)     # images
+    text = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", text)  # links -> label
+    text = re.sub(r"^\s{0,3}#{1,6}\s*", "", text, flags=re.M)
+    text = re.sub(r"^\s{0,3}>\s?", "", text, flags=re.M)
+    text = re.sub(r"^\s*[-*+]\s+", "", text, flags=re.M)  # bullets
+    text = re.sub(r"^\s*\|.*\|\s*$", " ", text, flags=re.M)
+    text = re.sub(r"^\s*[-*_]{3,}\s*$", " ", text, flags=re.M)
+    text = re.sub(r"(\*\*\*|___)(.+?)\1", r"\2", text, flags=re.S)
+    text = re.sub(r"(\*\*|__)(.+?)\1", r"\2", text, flags=re.S)
+    text = re.sub(r"(?<!\w)([*_])(?!\s)(.+?)(?<!\s)\1(?!\w)", r"\2", text)
+    text = re.sub(r"~~(.+?)~~", r"\1", text)
+    # Streaming or truncated LLM output leaves unpaired markers behind. Any
+    # asterisk that survives the rules above would be spoken aloud, so drop it.
+    text = re.sub(r"\*+", "", text)
+    return text
+
+
+def _say_money(symbol, whole, frac):
+    major, minor = CURRENCIES[symbol]
+    amount = int(whole.replace(",", ""))
+    out = "%s %s%s" % (int_to_words(amount), major,
+                       "" if amount == 1 else "s")
+    if frac and int(frac):
+        cents = int(frac.ljust(2, "0")[:2])
+        if minor == "penny":
+            word = "penny" if cents == 1 else "pence"
+        elif minor == "paisa":
+            word = "paisa" if cents == 1 else "paise"
+        else:
+            word = minor if cents == 1 else minor + "s"
+        out += " and %s %s" % (int_to_words(cents), word)
+    return out
+
+
+def _say_date(y, m, d):
+    if not (1 <= m <= 12 and 1 <= d <= 31):
+        return ""
+    return "%s %s, %s" % (MONTHS[m - 1], ordinal_to_words(d), year_to_words(y))
+
+
+def _say_time(h, mi, meridiem):
+    if h > 23 or mi > 59:
+        return ""
+    if not meridiem and h >= 13:
+        # 24-hour input: nobody says "fourteen o'clock" out loud.
+        h, meridiem = h - 12, "PM"
+    elif not meridiem and h == 0:
+        h, meridiem = 12, "AM"
+    hour = int_to_words(h if h else 12)
+    if mi == 0:
+        body = hour + " o'clock"
+    elif mi < 10:
+        body = "%s oh %s" % (hour, int_to_words(mi))
+    else:
+        body = "%s %s" % (hour, int_to_words(mi))
+    tail = meridiem.upper().replace(".", "")
+    return (body + " " + tail).strip()
+
+
+def _month_name(token):
+    for name in MONTHS:
+        if name.lower().startswith(token[:3].lower()):
+            return name
+    return token
+
+
+def normalize(text, spell_acronyms=False, strip_emoji=True):
+    """Rewrite `text` so a TTS engine speaks it the way a human would."""
+    if not text:
+        return ""
+    t = _strip_markdown(text)
+    if strip_emoji:
+        t = _EMOJI.sub(" ", t)
+
+    # Emails and URLs first, before anything else touches the dots.
+    t = re.sub(r"\b[\w.+-]+@[\w-]+\.[\w.]+\b",
+               lambda m: m.group(0).replace("@", " at ").replace(".", " dot "),
+               t)
+    t = re.sub(r"https?://\S+|\bwww\.\S+",
+               lambda m: re.sub(r"/\S*$", "",
+                                re.sub(r"https?://|www\.", "", m.group(0)))
+               .replace(".", " dot "), t)
+
+    # Dotted numerics before everything numeric, or the phone matcher claims
+    # them: "192.168.1.1" is seven digits and three separators.
+    t = re.sub(r"\b(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\b",
+               lambda m: " dot ".join(int_to_words(int(g))
+                                      for g in m.groups()), t)
+    t = re.sub(r"\bv?(\d+)\.(\d+)\.(\d+)\b",
+               lambda m: " point ".join(int_to_words(int(g))
+                                        for g in m.groups()), t)
+
+    # Dates before phone numbers: 2026-11-11 is digits-and-hyphens too.
+    t = re.sub(r"\b(\d{4})-(\d{2})-(\d{2})\b",
+               lambda m: _say_date(int(m.group(1)), int(m.group(2)),
+                                   int(m.group(3))) or m.group(0), t)
+    t = re.sub(r"\b(\d{1,2})/(\d{1,2})/(\d{4})\b",
+               lambda m: _say_date(int(m.group(3)), int(m.group(1)),
+                                   int(m.group(2))) or m.group(0), t)
+    month_re = "|".join(MONTHS + [m[:3] for m in MONTHS])
+    t = re.sub(r"\b(" + month_re + r")\.?\s+(\d{1,2})(?:st|nd|rd|th)?"
+               r"(?:,?\s*(\d{4}))?\b",
+               lambda m: _month_name(m.group(1)) + " "
+               + ordinal_to_words(int(m.group(2)))
+               + (", " + year_to_words(int(m.group(3))) if m.group(3) else ""),
+               t, flags=re.I)
+
+    # Note: the meridiem deliberately does not absorb a trailing dot, so that
+    # "at 3:30 PM." keeps the sentence-ending period.
+    t = re.sub(r"\b(\d{1,2}):(\d{2})(?:\s*([ap]\.?m))?",
+               lambda m: _say_time(int(m.group(1)), int(m.group(2)),
+                                   m.group(3) or "") or m.group(0),
+               t, flags=re.I)
+
+    def _phone(m):
+        raw = m.group(0).strip()
+        digits = re.sub(r"\D", "", raw)
+        if not 7 <= len(digits) <= 15:
+            return m.group(0)
+        # A digit run alone is not a phone number - "1000-2000" is a range.
+        # Require real phone shape: a country code, parens, two or more
+        # separators, or an unbroken run long enough to be a full number.
+        seps = len(re.findall(r"[\s\-.]", raw))
+        if not (raw.startswith("+") or "(" in raw or seps >= 2
+                or (seps == 0 and len(digits) >= 10)):
+            return m.group(0)
+        return digits_to_words(raw)
+
+    # The leading paren must be inside the match, or "(555) 123-4567" leaves a
+    # stray "(" behind once the digits are rewritten.
+    t = re.sub(r"(?<![\w$.])\+?\(?\d[\d\-.\s()]{6,18}\d\)?(?![\w])", _phone, t)
+
+    t = re.sub(r"#(?=\d)", "number ", t)
+
+    # Ranges, now that whatever is left is not a phone number.
+    t = re.sub(r"\b(\d[\d,]*)\s?-\s?(\d[\d,]*)\b",
+               lambda m: _say_number(m.group(1)) + " to "
+               + _say_number(m.group(2)), t)
+    # A bare leading minus is spoken, not silent. Must follow the range rule,
+    # whose hyphen is preceded by a digit and so is unaffected.
+    t = re.sub(r"(?<![\w\d])-\s?(?=\d)", "negative ", t)
+
+    t = re.sub(r"\b(\d+)/(\d+)\b",
+               lambda m: _say_fraction(int(m.group(1)), int(m.group(2))), t)
+
+    sym = "|".join(re.escape(s) for s in CURRENCIES)
+    t = re.sub("(" + sym + r")\s?(\d[\d,]*)(?:\.(\d{1,2}))?",
+               lambda m: _say_money(m.group(1), m.group(2), m.group(3)), t)
+    t = re.sub(r"(\d[\d,]*(?:\.\d+)?)\s?%",
+               lambda m: _say_number(m.group(1)) + " percent", t)
+    t = re.sub(r"\b(\d+)(?:st|nd|rd|th)\b",
+               lambda m: ordinal_to_words(int(m.group(1))), t)
+    t = re.sub(r"\b(\d[\d,]*(?:\.\d+)?)\s?(" + "|".join(UNITS) + r")\b",
+               lambda m: _say_number(m.group(1)) + " " + UNITS[m.group(2)], t)
+
+    for abbr, full in ABBREVIATIONS.items():
+        t = re.sub(r"\b" + re.escape(abbr) + r"\.", full, t)
+    for src, dst in PHRASES.items():
+        t = t.replace(src, dst)
+
+    t = re.sub(r"\b\d[\d,]*(?:\.\d+)?\b", lambda m: _say_number(m.group(0)), t)
+
+    if spell_acronyms:
+        t = re.sub(r"\b([A-Z]{2,5})\b",
+                   lambda m: m.group(1) if m.group(1) in PRONOUNCEABLE
+                   else " ".join(m.group(1)), t)
+
+    # A bare "#" with no number after it would be read out as "hash".
+    t = re.sub(r"#", " ", t)
+
+    t = re.sub(r"[ \t]+", " ", t)
+    t = re.sub(r"\s+([,.!?;:])", r"\1", t)
+    return re.sub(r"\n{2,}", "\n", t).strip()

speakable/numbers.py

@@ -0,0 +1,104 @@
+"""English number-to-words. No dependencies, so the API has no cold-start cost."""
+
+_ONES = [
+    "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
+    "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
+    "sixteen", "seventeen", "eighteen", "nineteen",
+]
+_TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
+         "eighty", "ninety"]
+_SCALES = [(10**12, "trillion"), (10**9, "billion"), (10**6, "million"),
+           (10**3, "thousand")]
+
+_ORDINALS = {
+    "one": "first", "two": "second", "three": "third", "four": "fourth",
+    "five": "fifth", "six": "sixth", "seven": "seventh", "eight": "eighth",
+    "nine": "ninth", "ten": "tenth", "eleven": "eleventh", "twelve": "twelfth",
+    "thirteen": "thirteenth", "fourteen": "fourteenth", "fifteen": "fifteenth",
+    "sixteen": "sixteenth", "seventeen": "seventeenth",
+    "eighteen": "eighteenth", "nineteen": "nineteenth", "twenty": "twentieth",
+    "thirty": "thirtieth", "forty": "fortieth", "fifty": "fiftieth",
+    "sixty": "sixtieth", "seventy": "seventieth", "eighty": "eightieth",
+    "ninety": "ninetieth", "hundred": "hundredth", "thousand": "thousandth",
+    "million": "millionth", "billion": "billionth", "zero": "zeroth",
+}
+
+MONTHS = ["January", "February", "March", "April", "May", "June", "July",
+          "August", "September", "October", "November", "December"]
+
+
+def _under_hundred(n: int) -> str:
+    if n < 20:
+        return _ONES[n]
+    tens, ones = divmod(n, 10)
+    return _TENS[tens] + (f"-{_ONES[ones]}" if ones else "")
+
+
+def _under_thousand(n: int) -> str:
+    hundreds, rest = divmod(n, 100)
+    parts = []
+    if hundreds:
+        parts += [_ONES[hundreds], "hundred"]
+    if rest:
+        parts.append(_under_hundred(rest))
+    return " ".join(parts)
+
+
+def int_to_words(n: int) -> str:
+    """1234 -> 'one thousand two hundred thirty-four'"""
+    if n < 0:
+        return "negative " + int_to_words(-n)
+    if n == 0:
+        return "zero"
+    parts = []
+    for value, name in _SCALES:
+        if n >= value:
+            chunk, n = divmod(n, value)
+            parts += [int_to_words(chunk), name]
+    if n:
+        parts.append(_under_thousand(n))
+    return " ".join(parts)
+
+
+def digits_to_words(s: str) -> str:
+    """'555' -> 'five five five'. For phone numbers and codes."""
+    out = []
+    for ch in s:
+        if ch.isdigit():
+            out.append(_ONES[int(ch)])
+        elif ch == "+":
+            out.append("plus")
+        elif ch in "-.()":
+            continue
+        else:
+            out.append(ch)
+    return " ".join(out)
+
+
+def decimal_to_words(whole: str, frac: str) -> str:
+    """'3', '14' -> 'three point one four'"""
+    head = int_to_words(int(whole)) if whole else "zero"
+    return f"{head} point {digits_to_words(frac)}"
+
+
+def ordinal_to_words(n: int) -> str:
+    """3 -> 'third', 21 -> 'twenty-first'"""
+    words = int_to_words(n)
+    head, sep, last = words.rpartition("-")
+    if not sep:
+        head, sep, last = words.rpartition(" ")
+    if last in _ORDINALS:
+        return head + sep + _ORDINALS[last]
+    return words + "th"
+
+
+def year_to_words(y: int) -> str:
+    """2026 -> 'twenty twenty-six', 1905 -> 'nineteen oh five'"""
+    if 1100 <= y < 2000 or 2010 <= y < 2100:
+        hi, lo = divmod(y, 100)
+        if lo == 0:
+            return f"{int_to_words(hi)} hundred"
+        if lo < 10:
+            return f"{int_to_words(hi)} oh {_ONES[lo]}"
+        return f"{int_to_words(hi)} {_under_hundred(lo)}"
+    return int_to_words(y)

speakable-1.0.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: speakable
+Version: 1.0.0
+Summary: Text normalization for voice agents - turn LLM output into text a TTS engine speaks correctly.
+Author: Divyajeet
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Divyajeet01/speakable
+Project-URL: Issues, https://github.com/Divyajeet01/speakable/issues
+Keywords: tts,text-to-speech,voice-agent,normalization,livekit,speech,nlp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: api
+Requires-Dist: fastapi>=0.110; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.27; extra == "api"
+Requires-Dist: pydantic>=2.0; extra == "api"
+Dynamic: license-file
+
+# Speakable
+
+**Text normalization for voice agents.** Turn LLM output into text a TTS engine
+speaks correctly.
+
+Your LLM returns this:
+
+```
+**Invoice #42**: $1,234.56 due 2026-11-11. Call Dr. Rao at (555) 123-4567
+before 3:30 PM. Save 15%! 🎉
+```
+
+Your TTS engine says *"asterisk asterisk invoice hash forty two asterisk
+asterisk colon dollar one comma two three four point five six..."*
+
+Speakable returns this:
+
+```
+Invoice number forty-two: one thousand two hundred thirty-four dollars and
+fifty-six cents due November eleventh, twenty twenty-six. Call Doctor Rao at
+five five five one two three four five six seven before three thirty PM.
+Save fifteen percent!
+```
+
+Pure Python, zero dependencies in the core, ~1.5 ms for a typical utterance.
+
+## What it handles
+
+| Input | Output |
+|---|---|
+| `**bold**`, `# headings`, `` `code` ``, `[link](url)` | stripped to plain text |
+| `$1,234.56` / `₹500` / `£20` / `€99` | `one thousand two hundred thirty-four dollars and fifty-six cents` |
+| `2026-11-11`, `11/11/2026`, `Nov 11, 2026` | `November eleventh, twenty twenty-six` |
+| `3:30 PM`, `9:05 a.m.`, `14:00` | `three thirty PM`, `nine oh five AM`, `two o'clock PM` |
+| `(555) 123-4567`, `+1 555-123-4567` | digit-by-digit, the way a human reads a number aloud |
+| `15%`, `2.5%` | `fifteen percent`, `two point five percent` |
+| `1st`, `21st`, `3rd` | `first`, `twenty-first`, `third` |
+| `5kg`, `10mi`, `3hrs` | `five kilograms`, `ten miles`, `three hours` |
+| `Dr.`, `Inc.`, `vs.`, `etc.` | `Doctor`, `Incorporated`, `versus`, `et cetera` |
+| `john@example.com`, `https://acme.io/help` | `john at example dot com`, `acme dot io` |
+| 🎉 and friends | removed |
+| `API` (opt-in) | `A P I`, skipping acronyms TTS already says right |
+| `10-20`, `1000-2000` | `ten to twenty` (ranges, not phone numbers) |
+| `-45` | `negative forty-five` |
+| `192.168.1.1`, `v1.2.3` | `one hundred ninety-two dot ...`, `one point two point three` |
+| `**unclosed bold` | unpaired markers dropped, not spoken |
+| `3/4`, `5/16` | `three quarters`, `five over sixteen` |
+
+## Library use
+
+```python
+from speakable import normalize
+
+normalize("Pay $20 by 2026-01-05.")
+# 'Pay twenty dollars by January fifth, twenty twenty-six.'
+
+normalize("The API is up", spell_acronyms=True)
+# 'The A P I is up'
+```
+
+`normalize(text, spell_acronyms=False, strip_emoji=True)` is the whole API.
+It is idempotent — running it twice changes nothing.
+
+## Use it in a LiveKit agent
+
+The one line that matters, right before synthesis:
+
+```python
+from speakable import normalize
+
+async def on_llm_response(text: str):
+    await tts.say(normalize(text))
+```
+
+## HTTP API
+
+```bash
+pip install -r requirements.txt
+uvicorn app:app --reload          # docs at http://127.0.0.1:8000/docs
+```
+
+```bash
+curl -X POST http://127.0.0.1:8000/normalize \
+  -H 'Content-Type: application/json' \
+  -d '{"text": "Pay $20 by 2026-01-05."}'
+```
+
+```json
+{
+  "text": "Pay twenty dollars by January fifth, twenty twenty-six.",
+  "original": "Pay $20 by 2026-01-05.",
+  "chars_in": 22,
+  "chars_out": 54,
+  "took_ms": 0.9
+}
+```
+
+`POST /normalize/batch` takes `{"texts": [...]}` for up to 100 strings at once.
+`GET /health` for liveness.
+
+Set `RAPIDAPI_PROXY_SECRET` to reject any traffic that didn't come through the
+marketplace proxy. `MAX_CHARS` and `MAX_BATCH` bound request size.
+
+## Docker
+
+```bash
+docker build -t speakable .
+docker run -p 8000:8000 speakable
+```
+
+## Tests
+
+```bash
+python tests/test_normalize.py     # 28 cases, no pytest required
+```
+
+## Why this exists
+
+Every voice agent hits this. The LLM is trained on written English and emits
+markdown, digits and abbreviations; TTS engines are built for prose. The gap
+between them is where callers hear "asterisk" out loud. Most teams end up with
+a pile of ad-hoc regexes that handle their own demo and break on the next one.
+
+This is that pile, written once, tested, and ordered correctly — the ordering
+is most of the difficulty. Dates have to run before phone numbers, because
+`2026-11-11` is also digits-and-hyphens. Emails have to run before anything
+touches a dot. Currency has to run before plain integers.
+
+## Not handled (yet)
+
+Non-English locales, Indian digit grouping (lakh/crore), roman numerals, and
+mathematical expressions. PRs welcome.
+
+## License
+
+MIT.

speakable-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+speakable/__init__.py,sha256=2uidMrukGHK_TU7T-GG14sUQ6RwfjwmsskQ8hVXZ2TY,80
+speakable/normalize.py,sha256=eT5NCX0Is1uSAjoCqDtiQW009F9zgyBs2A7tk-EIUUM,10211
+speakable/numbers.py,sha256=PiBiUQtiuGJqoxlxpLcXhR02SKKzwmYQGhK-jWtOHAY,3527
+speakable-1.0.0.dist-info/licenses/LICENSE,sha256=ko7FedI8XAMhFmALSmsLDTDh6b32syvJ0oYIejnIPdM,1087
+speakable-1.0.0.dist-info/METADATA,sha256=nkGbRskKEmDwTBA-QnrRaTTvMb9bvoUPcJVGM2WWWOg,5369
+speakable-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+speakable-1.0.0.dist-info/top_level.txt,sha256=GFKQ2FXkJ7uv0Zbudrly4S9NCZ8L5cfHOtggZBiNKu0,10
+speakable-1.0.0.dist-info/RECORD,,

speakable-1.0.0.dist-info/WHEEL

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

speakable-1.0.0.dist-info/licenses/LICENSE

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

speakable-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+speakable