daktilo 0.1.0__tar.gz

daktilo-0.1.0/LICENSE

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

daktilo-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: daktilo
+Version: 0.1.0
+Summary: Transcribe audio recordings with Sawalni API
+Author-email: Omar Kamali <omar@omneitylabs.com>
+License-Expression: MIT
+Project-URL: Homepage, https://api.sawalni.com
+Project-URL: Documentation, https://api.sawalni.com/docs
+Project-URL: Examples, https://github.com/omneity-labs/starter-transcription
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1,>=0.27
+Dynamic: license-file
+
+# Daktilo
+
+**Multilingual audio transcription, with Darija and Amazigh support.**
+
+Turn an audio recording into text with [Sawalni API](https://api.sawalni.com). Use it for interviews, voice notes or the transcript step of a caption workflow. Built by [Omneity Labs](https://www.omneitylabs.com).
+
+## Quick start
+
+```sh
+pip install daktilo
+export SAWALNI_API_KEY="your-key"
+daktilo transcribe interview.wav --output transcript.txt
+```
+
+[Create an API key](https://api.sawalni.com) and enable transcription access. Requests use API credits. This package calls the hosted service; it does not run a model locally.
+
+## Python
+
+```python
+from pathlib import Path
+from daktilo import Daktilo
+
+with Daktilo() as client:
+    result = client.transcribe("interview.wav")
+
+Path("transcript.txt").write_text(result["text"], encoding="utf-8")
+print(result.get("language"))
+print(result.get("warnings", []))
+```
+
+The response preserves the service's text, detected language, segments, warnings and usage when available. Review the words before using the transcript for captions or another downstream task.
+
+## Languages
+
+Daktilo supports Darija, Amazigh and major languages including Arabic, English, French, Spanish, German, Italian, Portuguese, Chinese, Japanese, Korean, Russian, Turkish and Dutch. Leave `language` unset for automatic selection, especially for Amazigh and mixed-language audio recordings.
+
+The API currently accepts forced hints `ar`, `ary`, `en`, `fr`, `es`, `de`, `it`, `pt`, `zh`, `ja`, `ko`, `ru`, `tr` and `nl`. A forced Amazigh hint such as `shi` is not accepted; use automatic selection. Language availability does not imply the same accuracy for every variety, accent or audio recording.
+
+```sh
+daktilo transcribe interview.wav --language ary --json --output result.json
+```
+
+```python
+with Daktilo() as client:
+    result = client.transcribe("interview.wav", language="ary")
+```
+
+## From transcript to timed captions
+
+```text
+Audio recording → Daktilo → Review transcript → Sawalign → SRT captions
+```
+
+Need word timings or subtitles? [Sawalign](https://pypi.org/project/sawalign/) aligns your reviewed transcript to the same audio recording. The [Python and TypeScript starter](https://github.com/omneity-labs/starter-transcription) covers the full workflow.
+
+## Client reference
+
+`Daktilo(api_key=None, base_url="https://api.sawalni.com/v1", timeout=300)` uses `SAWALNI_API_KEY` when no key is supplied. Use it as a context manager or call `close()`.
+
+`transcribe(audio, language=None, model="daktilo")` accepts a local file path and returns the response dictionary. The default model follows the service's Daktilo alias. HTTP errors raise `httpx.HTTPStatusError`; connection failures raise `httpx.RequestError`. Uploads are not automatically retried.
+
+Audio recordings must be at most 128 MiB and 30 minutes. The service validates duration. Inspect `warnings` and any segment truncation flags before downstream use. Empty recognized text can be a valid result for silence. The client preserves it.
+
+Keep API keys in your terminal or server environment. Python 3.10 or later. MIT license.
+
+[API reference](https://api.sawalni.com/docs) · [Runnable starter](https://github.com/omneity-labs/starter-transcription)

daktilo-0.1.0/README.md

@@ -0,0 +1,66 @@
+# Daktilo
+
+**Multilingual audio transcription, with Darija and Amazigh support.**
+
+Turn an audio recording into text with [Sawalni API](https://api.sawalni.com). Use it for interviews, voice notes or the transcript step of a caption workflow. Built by [Omneity Labs](https://www.omneitylabs.com).
+
+## Quick start
+
+```sh
+pip install daktilo
+export SAWALNI_API_KEY="your-key"
+daktilo transcribe interview.wav --output transcript.txt
+```
+
+[Create an API key](https://api.sawalni.com) and enable transcription access. Requests use API credits. This package calls the hosted service; it does not run a model locally.
+
+## Python
+
+```python
+from pathlib import Path
+from daktilo import Daktilo
+
+with Daktilo() as client:
+    result = client.transcribe("interview.wav")
+
+Path("transcript.txt").write_text(result["text"], encoding="utf-8")
+print(result.get("language"))
+print(result.get("warnings", []))
+```
+
+The response preserves the service's text, detected language, segments, warnings and usage when available. Review the words before using the transcript for captions or another downstream task.
+
+## Languages
+
+Daktilo supports Darija, Amazigh and major languages including Arabic, English, French, Spanish, German, Italian, Portuguese, Chinese, Japanese, Korean, Russian, Turkish and Dutch. Leave `language` unset for automatic selection, especially for Amazigh and mixed-language audio recordings.
+
+The API currently accepts forced hints `ar`, `ary`, `en`, `fr`, `es`, `de`, `it`, `pt`, `zh`, `ja`, `ko`, `ru`, `tr` and `nl`. A forced Amazigh hint such as `shi` is not accepted; use automatic selection. Language availability does not imply the same accuracy for every variety, accent or audio recording.
+
+```sh
+daktilo transcribe interview.wav --language ary --json --output result.json
+```
+
+```python
+with Daktilo() as client:
+    result = client.transcribe("interview.wav", language="ary")
+```
+
+## From transcript to timed captions
+
+```text
+Audio recording → Daktilo → Review transcript → Sawalign → SRT captions
+```
+
+Need word timings or subtitles? [Sawalign](https://pypi.org/project/sawalign/) aligns your reviewed transcript to the same audio recording. The [Python and TypeScript starter](https://github.com/omneity-labs/starter-transcription) covers the full workflow.
+
+## Client reference
+
+`Daktilo(api_key=None, base_url="https://api.sawalni.com/v1", timeout=300)` uses `SAWALNI_API_KEY` when no key is supplied. Use it as a context manager or call `close()`.
+
+`transcribe(audio, language=None, model="daktilo")` accepts a local file path and returns the response dictionary. The default model follows the service's Daktilo alias. HTTP errors raise `httpx.HTTPStatusError`; connection failures raise `httpx.RequestError`. Uploads are not automatically retried.
+
+Audio recordings must be at most 128 MiB and 30 minutes. The service validates duration. Inspect `warnings` and any segment truncation flags before downstream use. Empty recognized text can be a valid result for silence. The client preserves it.
+
+Keep API keys in your terminal or server environment. Python 3.10 or later. MIT license.
+
+[API reference](https://api.sawalni.com/docs) · [Runnable starter](https://github.com/omneity-labs/starter-transcription)

daktilo-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "daktilo"
+version = "0.1.0"
+description = "Transcribe audio recordings with Sawalni API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Omar Kamali", email = "omar@omneitylabs.com"}]
+dependencies = ["httpx>=0.27,<1"]
+
+[project.scripts]
+daktilo = "daktilo.cli:main"
+
+[project.urls]
+Homepage = "https://api.sawalni.com"
+Documentation = "https://api.sawalni.com/docs"
+Examples = "https://github.com/omneity-labs/starter-transcription"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+daktilo = ["py.typed"]

daktilo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

daktilo-0.1.0/src/daktilo/__init__.py

@@ -0,0 +1,3 @@
+from .client import Daktilo
+__version__ = "0.1.0"
+__all__ = ["Daktilo"]

daktilo-0.1.0/src/daktilo/cli.py

@@ -0,0 +1,28 @@
+import argparse
+import json
+import sys
+from pathlib import Path
+from . import Daktilo
+
+
+def main():
+    parser=argparse.ArgumentParser(description="Transcribe an audio recording with Daktilo")
+    sub=parser.add_subparsers(dest="command",required=True)
+    cmd=sub.add_parser("transcribe")
+    cmd.add_argument("audio",type=Path)
+    cmd.add_argument("--language",help="Optional language hint; omit for automatic selection")
+    cmd.add_argument("--model",default="daktilo")
+    cmd.add_argument("--output",type=Path)
+    cmd.add_argument("--json",action="store_true",dest="as_json")
+    args=parser.parse_args()
+    with Daktilo() as client:
+        result=client.transcribe(args.audio,language=args.language,model=args.model)
+    output=json.dumps(result,ensure_ascii=False,indent=2) if args.as_json else result["text"]
+    if args.output:
+        args.output.write_text(output,encoding="utf-8")
+    else:
+        print(output)
+    for warning in result.get("warnings",[]):
+        print("Warning:",warning,file=sys.stderr)
+    if result.get("truncated") or any(x.get("truncated") for x in result.get("segments",[]) if isinstance(x,dict)):
+        print("Warning: transcription is incomplete; review before alignment.",file=sys.stderr)

daktilo-0.1.0/src/daktilo/client.py

@@ -0,0 +1,47 @@
+import os
+from pathlib import Path
+from typing import Any
+import httpx
+
+
+class Daktilo:
+    """Audio transcription through Sawalni API. Uploads are not retried."""
+    def __init__(self, api_key: str | None = None, *,
+                 base_url: str = "https://api.sawalni.com/v1",
+                 timeout: float = 300, transport: httpx.BaseTransport | None = None):
+        key = api_key or os.environ.get("SAWALNI_API_KEY")
+        if not key:
+            raise ValueError("Set SAWALNI_API_KEY or pass api_key")
+        self._http = httpx.Client(base_url=base_url.rstrip("/")+"/",
+            headers={"Authorization":f"Bearer {key}"}, timeout=timeout,
+            transport=transport, follow_redirects=False)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def transcribe(self, audio: str | Path, *, language: str | None = None,
+                   model: str = "daktilo") -> dict[str, Any]:
+        """Return text and the service's language, segments, warnings and usage."""
+        if language is not None and not language.strip():
+            raise ValueError("language must not be empty; omit it for automatic selection")
+        path = Path(audio)
+        data = {"model":model}
+        if language is not None:
+            data["language"] = language
+        with path.open("rb") as stream:
+            size = os.fstat(stream.fileno()).st_size
+            if size == 0 or size > 128*1024*1024:
+                raise ValueError("Audio recording must contain 1 byte to 128 MiB")
+            response = self._http.post("speech/transcribe",
+                files={"audio":(path.name,stream,"application/octet-stream")},data=data)
+        response.raise_for_status()
+        result = response.json()
+        if not isinstance(result,dict) or not isinstance(result.get("text"),str):
+            raise ValueError("Invalid transcription response: missing text")
+        return result

daktilo-0.1.0/src/daktilo.egg-info/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: daktilo
+Version: 0.1.0
+Summary: Transcribe audio recordings with Sawalni API
+Author-email: Omar Kamali <omar@omneitylabs.com>
+License-Expression: MIT
+Project-URL: Homepage, https://api.sawalni.com
+Project-URL: Documentation, https://api.sawalni.com/docs
+Project-URL: Examples, https://github.com/omneity-labs/starter-transcription
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1,>=0.27
+Dynamic: license-file
+
+# Daktilo
+
+**Multilingual audio transcription, with Darija and Amazigh support.**
+
+Turn an audio recording into text with [Sawalni API](https://api.sawalni.com). Use it for interviews, voice notes or the transcript step of a caption workflow. Built by [Omneity Labs](https://www.omneitylabs.com).
+
+## Quick start
+
+```sh
+pip install daktilo
+export SAWALNI_API_KEY="your-key"
+daktilo transcribe interview.wav --output transcript.txt
+```
+
+[Create an API key](https://api.sawalni.com) and enable transcription access. Requests use API credits. This package calls the hosted service; it does not run a model locally.
+
+## Python
+
+```python
+from pathlib import Path
+from daktilo import Daktilo
+
+with Daktilo() as client:
+    result = client.transcribe("interview.wav")
+
+Path("transcript.txt").write_text(result["text"], encoding="utf-8")
+print(result.get("language"))
+print(result.get("warnings", []))
+```
+
+The response preserves the service's text, detected language, segments, warnings and usage when available. Review the words before using the transcript for captions or another downstream task.
+
+## Languages
+
+Daktilo supports Darija, Amazigh and major languages including Arabic, English, French, Spanish, German, Italian, Portuguese, Chinese, Japanese, Korean, Russian, Turkish and Dutch. Leave `language` unset for automatic selection, especially for Amazigh and mixed-language audio recordings.
+
+The API currently accepts forced hints `ar`, `ary`, `en`, `fr`, `es`, `de`, `it`, `pt`, `zh`, `ja`, `ko`, `ru`, `tr` and `nl`. A forced Amazigh hint such as `shi` is not accepted; use automatic selection. Language availability does not imply the same accuracy for every variety, accent or audio recording.
+
+```sh
+daktilo transcribe interview.wav --language ary --json --output result.json
+```
+
+```python
+with Daktilo() as client:
+    result = client.transcribe("interview.wav", language="ary")
+```
+
+## From transcript to timed captions
+
+```text
+Audio recording → Daktilo → Review transcript → Sawalign → SRT captions
+```
+
+Need word timings or subtitles? [Sawalign](https://pypi.org/project/sawalign/) aligns your reviewed transcript to the same audio recording. The [Python and TypeScript starter](https://github.com/omneity-labs/starter-transcription) covers the full workflow.
+
+## Client reference
+
+`Daktilo(api_key=None, base_url="https://api.sawalni.com/v1", timeout=300)` uses `SAWALNI_API_KEY` when no key is supplied. Use it as a context manager or call `close()`.
+
+`transcribe(audio, language=None, model="daktilo")` accepts a local file path and returns the response dictionary. The default model follows the service's Daktilo alias. HTTP errors raise `httpx.HTTPStatusError`; connection failures raise `httpx.RequestError`. Uploads are not automatically retried.
+
+Audio recordings must be at most 128 MiB and 30 minutes. The service validates duration. Inspect `warnings` and any segment truncation flags before downstream use. Empty recognized text can be a valid result for silence. The client preserves it.
+
+Keep API keys in your terminal or server environment. Python 3.10 or later. MIT license.
+
+[API reference](https://api.sawalni.com/docs) · [Runnable starter](https://github.com/omneity-labs/starter-transcription)

daktilo-0.1.0/src/daktilo.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/daktilo/__init__.py
+src/daktilo/cli.py
+src/daktilo/client.py
+src/daktilo/py.typed
+src/daktilo.egg-info/PKG-INFO
+src/daktilo.egg-info/SOURCES.txt
+src/daktilo.egg-info/dependency_links.txt
+src/daktilo.egg-info/entry_points.txt
+src/daktilo.egg-info/requires.txt
+src/daktilo.egg-info/top_level.txt
+tests/test_client.py

daktilo-0.1.0/src/daktilo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

daktilo-0.1.0/src/daktilo.egg-info/entry_points.txt

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

daktilo-0.1.0/src/daktilo.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx<1,>=0.27

daktilo-0.1.0/src/daktilo.egg-info/top_level.txt

@@ -0,0 +1 @@
+daktilo

daktilo-0.1.0/tests/test_client.py

@@ -0,0 +1,43 @@
+import tempfile
+import unittest
+from pathlib import Path
+import httpx
+from daktilo import Daktilo
+
+class Tests(unittest.TestCase):
+    def setUp(self):
+        self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup)
+        self.path=Path(self.tmp.name)/"test.wav";self.path.write_bytes(b"RIFF-fixture")
+    def client(self,handler):
+        c=Daktilo("fixture-key",transport=httpx.MockTransport(handler));self.addCleanup(c.close);return c
+    def test_response_and_multipart(self):
+        def handler(req):
+            self.assertEqual(req.url.path,"/v1/speech/transcribe")
+            self.assertEqual(req.headers["Authorization"],"Bearer fixture-key")
+            self.assertIn(b"RIFF-fixture",req.content);self.assertIn(b"daktilo",req.content)
+            self.assertNotIn(b'name="language"',req.content)
+            return httpx.Response(200,json={"text":"أزول", "language":"shi", "warnings":["example"],"segments":[]})
+        result=self.client(handler).transcribe(self.path)
+        self.assertEqual(result["text"],"أزول");self.assertEqual(result["warnings"],["example"])
+    def test_hint(self):
+        def handler(req):
+            self.assertIn(b'name="language"',req.content);self.assertIn(b"ary",req.content)
+            return httpx.Response(200,json={"text":"سلام"})
+        self.assertEqual(self.client(handler).transcribe(self.path,language="ary")["text"],"سلام")
+    def test_no_retry(self):
+        seen=[]
+        def handler(req):seen.append(req);return httpx.Response(503)
+        with self.assertRaises(httpx.HTTPStatusError):self.client(handler).transcribe(self.path)
+        self.assertEqual(len(seen),1)
+    def test_silence_preserved(self):
+        self.assertEqual(self.client(lambda req:httpx.Response(200,json={"text":""})).transcribe(self.path),{"text":""})
+    def test_invalid_response(self):
+        with self.assertRaises(ValueError):self.client(lambda req:httpx.Response(200,json={})).transcribe(self.path)
+    def test_empty_file(self):
+        self.path.write_bytes(b"")
+        with self.assertRaises(ValueError):self.client(lambda req:self.fail()).transcribe(self.path)
+    def test_redirect(self):
+        with self.assertRaises(httpx.HTTPStatusError):self.client(lambda req:httpx.Response(302,headers={"Location":"https://other.invalid"})).transcribe(self.path)
+    def test_invalid_hint(self):
+        with self.assertRaises(ValueError):self.client(lambda req:self.fail()).transcribe(self.path,language=" ")
+if __name__=="__main__":unittest.main()