Lokit

The fastest and highest performing localization library.

[!WARNING] Beta Release: lokit is currently in Beta. The API is volatile and subject to rapid, breaking changes prior to the official V1 release.

Supports Python 3.10+.

Unlike legacy tools that wrap XML DOM element trees in memory, Lokit ingests localization formats (.lokit, TMX, XLIFF, PO, XLSX, CSV, JSON, HTML, IDML, DOCX, and PPTX) into one strict structural data model. This enables parsing, robust data manipulation, semantic extraction, and translation-memory features without coupling applications to a source format. Lokit emphasizes bounded streaming and asynchronous processing for large files.

This format type can be easily converted to JSON for interchange with other systems. I've made parsing and data transfers as native as possible by capturing all elements of traditional interchange formats in a common format structure. This allows for much better compatibility, especially in terms of segment matching and leveraging as it uses flattened strings as standard. Tags are preserved but as a common format, meaning the structure parsed from XLIFF will be the same as the structure parsed from HTML.

These legacy file formats have supported vendor-lock in for many year, making it difficult for any client to move to another system. Seeing that this is a major issue across the domain, something new is needed where vendors do not use hidden, legacy technology to lock in their clients. Localization deserves innovation. Lokit is the first open source package that supports direct localization interchange to database ingestion; even outside the Python ecosystem.

The main premise here is a common, structured and type-safe dataclass model structure that is intentionally compatible with any file format, not just localization interchange formats, although these are optimized for performance and memory efficiency due to the verbose nature of XML based formats.

The TMX, XLIFF, and .lokit paths require the native Rust parser included in every wheel. They do not fall back to a second Python file parser. The Python projection layer remains strictly typed and is compiled with mypyc in release wheels.

Core Features

Lokit provides a comprehensive suite of tools for managing localization data:

Native Structural Modeling: Converts interchange formats into a strict, unified Python Data classes, ensuring complete type safety.
Advanced Matching Engine: Provides Exact Matching, Fuzzy Matching (via SequenceMatcher), and In-Context Exact (ICE) Matching leveraging previous and next segment context, as well as with inline tags.
Sub-segment Extraction: Automatically parses and isolates inline tags, properties, and formatting markers, allowing for safe manipulation of text without corrupting code.
Semantic Querying: Easily filter translation units using any attribute, exact ID lookups, or deep nested JSON path querying (where()).
Plural Support: Native extraction and structuring of pluralized translation units, compatible with UI frameworks.
Universal Format Conversion: Instantly import and export between any supported format (e.g., TMX to JSON, HTML to XLIFF) with zero data loss.
Sparse Native Interchange: Round-trip every Lokit model field within explicit v1 safety bounds through the versioned, no-null, streamable .lokit format.
Synchronous and Asynchronous Streaming: Process massive enterprise files natively using Python async generators to keep memory overhead to an absolute minimum.
Native DOCX & PPTX Support: Using C# extensions without external dependencies ensuring no overhead and no data loss.

Type Safety and C-Extensions

The entire library is very strictly typed and mypy compliant, so strict it compiles to C-extensions via mypyc and pre-attached via wheels. Additionally, any XML processing uses C-based packages. Compiling to these extensions has shown a 23% in overall performance increases over pure-python modules with additional benefits such as lower memory usage. C extensions are standard for MacOS (ARM+Intel), Windows, and Linux.

Parsing Performance

When dealing with enterprise-scale localization environments, parsing performance and memory efficiency are paramount. Lokit is designed to be significantly leaner and faster than the industry standard. Current benchmarks show much higher performance than any other localziation library in any other language for parsing localization files.

Benchmarks

To demonstrate converting common file types between localization interchange files, the following shows performance metrics against comparable tools in other programming languages. This parsing stress test used the sequence DOCX -> CSV -> XLIFF -> TMX -> CSV -> XLIFF -> DOCX with a monolingual source.

Language	Library	Total Time (s)	Peak Memory (MB)
Python	Lokit	4.29	393.39
Rust	quick-xml + csv	23.11	26.66
Go	encoding/xml + encoding/csv	23.63	61.88
Node.js	sax	29.9	36.11
Java	Okapi Framework	463.15	952.68

Using another package, `translate-toolkit`, as a reference as it is the de-facto and feature-rich standard for localization file format parsing and conversion in Python for comparison, we benchmarked lokit's modules against its equivalents. In a stress-test benchmark on a +600 MB `.TMX` file containing over **550,000 segments**, converting to normalized JSON file over 3 iterations yielded the following comparative averages:

Library	Avg Duration	Peak Memory	Memory Efficiency
lokit	13.57s	135.9 MB	15x Less Memory
translate-toolkit	20.30s	2,034.5 MB	~2.0 GB

Tests for both covered from TMX to JSON with inline tag sanitization in both using the respective packages' tooling.

The major focus on memory safety allows for parallel processing of events, making it suitable for large-scale localization workflows and backend systems.

Note: this package is not a replacement or substitution for the already amazing translate-toolkit. The functionality is quite differet across both libraries and have their own use cases.

SDK Usage Reference

Lokit operates around a central BaseStructure dataclass model, which standardizes localization units and segments. This instructs better standardization and branching in a more language native way compared to XML based file formats. Parsing SDKs are added for both extraction and export tasks for localization interchange formats along with common file types.

Installation

Install lokit via pip:

pip install lokit-python

Basic Parsing and Conversion

Converting files synchronously is straightforward through the modular lokit API. Import the package once, then use lokit.parse and lokit.parse.write.

import lokit

document = lokit.parse.tmx("path/to/source.tmx")
document = lokit.parse.lokit("path/to/catalog.lokit")
document = lokit.parse.docx("path/to/document.docx")
document = lokit.parse.pptx("path/to/presentation.pptx")
documents = lokit.parse.files(["memory.tmx", "catalog.xliff", "messages.po"])

lokit.parse.write.xliff(document, "path/to/target.xliff")
lokit.export.lokit(document, "path/to/catalog.lokit")
document.export.csv("path/to/target.csv")

Native `.lokit` interchange

.lokit is Lokit's lossless interchange format for the documented BaseStructure domain. It uses a compact, line-oriented syntax inspired by TOON's readability, but it is a distinct localization schema. Missing optional values are omitted instead of encoded as null; present empty strings, zeroes, and empty optional objects remain distinguishable and round-trip exactly. Version 1 represents signed 64-bit integers and limits canonical physical lines to 1 MiB; out-of-domain values fail explicitly and never replace an existing output.

@lokit 1
document {
  source_locale = "en-US"
  target_locale = "fr-FR"
}
unit "home.title" {
  source = "Welcome"
  target = "Bienvenue"
  status = translated
}

All three API styles are available in synchronous and asynchronous form:

import lokit

document = lokit.parse.lokit("messages.lokit")
stream = lokit.stream.lokit("messages.lokit")
lokit.export.lokit(document, "copy.lokit")


async def copy_catalog() -> None:
    units = [unit async for unit in lokit.parse.async_.lokit("messages.lokit")]
    await lokit.export.async_.lokit(document, "async-copy.lokit")
    assert units

Full consumption closes async readers automatically. For an intentional early exit, use the returned bounded bridge as an async context manager so its reader is closed immediately:

async with lokit.stream.async_.lokit("messages.lokit") as units:
    async for unit_id, data in units:
        print(unit_id, data.source)
        break

The complete grammar, field mapping, canonicalization rules, and compatibility policy are in docs/lokit-format.md; implementation decisions are in docs/lokit-architecture.md, and reproducible measurements are in docs/lokit-performance.md. The standalone Rust language server and editor setup are documented in tools/lokit-lsp/README.md.

Dictionary projections

Interchange dictionary rows are separate from JSON-i18n documents and from newline-delimited JSON output. lokit.stream.to_dict yields rows lazily; lokit.parse.to_dict materializes the same rows. The default schema is source_language, target_language, source, target, and domain, and a multilingual unit yields one row per target locale in document order.

import lokit
from lokit.types import DictField, StringMode

rows = lokit.parse.to_dict("messages.tmx")

for row in lokit.stream.to_dict(
    "messages.xliff",
    target_language="fr",
    strings=StringMode.RAW,
    fields=(
        DictField.UNIT_ID,
        DictField.SOURCE_LOCALE,
        DictField.TARGET_LOCALE,
        DictField.SOURCE,
        DictField.TARGET,
        DictField.DOMAIN,
    ),
):
    print(row)

StringMode.SANITIZED returns plain text. StringMode.RAW reconstructs the source-format inline XML, including original tag names, attributes, and inline payloads. The asynchronous equivalents are lokit.stream.async_.to_dict and lokit.parse.async_.to_dict. Existing JSON-i18n parsing remains available as lokit.parse.json_i18n; use lokit.stream.write_jsonl when a JSONL file is the desired output.

Splitting multilingual documents

Materialized documents split into independent single-target models. A one-shot streaming document uses a context manager backed by bounded native .lokit spools, so it never duplicates the source iterator or retains the whole import in memory.

from pathlib import Path

import lokit

document = lokit.parse.tmx("multilingual.tmx", progress=False)
for locale, localized in document.split_targets().items():
    localized.export.xliff(Path("out") / f"messages-{locale}.xliff")

stream = lokit.stream.xliff("multilingual.xliff")
with stream.split_targets(include_missing=False) as localized_streams:
    for locale, localized in localized_streams.items():
        localized.export.lokit(Path("out") / f"messages-{locale}.lokit")

The streaming split files are valid only inside the context. Pass an explicit tuple of target locales to either split_targets method to select a subset.

Asynchronous Streaming for Large Interchange Files

For files spanning hundreds of megabytes, parsing the entire DOM structure into memory is inefficient. Lokit supports stream-parsing natively.

Here is a complete scripting example. It can be reduced to a few lines, but the wrapper functions make each stage explicit. The stream APIs keep document-level attributes such as language codes immutable while yielding translation units incrementally. The other parsers use the same common typed model.

import asyncio
import os

import lokit

input_dir = "data/language_tmx"
output_dir = "data/out"


async def convert_to_json(filepath: str):
    print(f"Starting: {filepath}")
    output = f"{output_dir}/{os.path.splitext(os.path.basename(filepath))[0]}.json"
    await lokit.stream.async_.write_jsonl(
        filepath=filepath,
        output=output,
    )
    print(f"Completed: {output}")


async def process():
    if not os.path.exists(output_dir):
        os.makedirs(output_dir, exist_ok=True)

    files = [os.path.join(input_dir, i) for i in os.listdir(input_dir)]
    tasks = [convert_to_json(filepath=file) for file in files]
    await asyncio.gather(*tasks)


if __name__ == "__main__":
    asyncio.run(process())

Advanced Querying and Matching

The Lokit logic wrapper provides access to the powerful matching engine and data manipulation features. This does not substitute for enterprise database semantic search but can be used as an after-step for evaluating matching results after retrieving translation units from a semantic/vector database.

import lokit

engine = lokit.Lokit.parse("path/to/source.xliff")

button_units = engine.where("extensions.component", "checkout_button")

results = engine.fuzzy_find("Complete your purchase", limit=5, threshold=0.75)
for match in results:
    print(f"Match found: {match.unit_id} (Score: {match.score})")

ice_match = engine.match(
    source="Submit",
    target_unit_id="submit_btn_1",
    previous_source="Enter your email",
    require_context=True
)

Structured API Paths

The preferred public API is available from a single package import:

import lokit

document = lokit.parse.file("path/to/source.tmx")
documents = lokit.parse.files(["path/to/source.tmx", "path/to/source.xliff"])
document = lokit.parse.lokit("path/to/source.lokit")
document = lokit.parse.csv("path/to/source.csv", source_locale="en-US")
document = lokit.parse.docx("path/to/source.docx")
streamed_tmx = lokit.stream.tmx("path/to/source.tmx")
streamed_lokit = lokit.stream.lokit("path/to/source.lokit")
streamed_docx = lokit.stream.docx("path/to/source.docx")


async def stream_to_json() -> None:
    await lokit.stream.async_.write_jsonl("path/to/source.tmx", "path/to/out.jsonl")

lokit.parse.write.csv(document, "path/to/target.csv")
lokit.export.lokit(document, "path/to/target.lokit")
document.export.xliff("path/to/target.xliff")
document.export.docx("path/to/translated.docx", source_docx="path/to/source.docx")


async def export_xlsx() -> None:
    await lokit.parse.write.async_.xlsx(document, "path/to/target.xlsx")

CsvExtractor = lokit.parsers.extractors.csv

Predefined conversions live under lokit.quick_parse for fast one-liner conversions:

import lokit

stats = lokit.quick_parse.tmx_to_csv("path/to/source.tmx", "path/to/target.csv")
lokit.quick_parse.csv_to_xliff("path/to/source.csv", "path/to/target.xliff")

PostgreSQL API

Lokit is the first localization package to have native support for storing translations in local and enterprise databases. Fast and effeciant TM matching is also included out of the box.

Here's an example of how easy it is to ingest and use the TM database:

import lokit


async def load_and_match() -> None:
    tm = await lokit.database.connect("postgresql://localhost/lokit_tm")
    async with tm:
        await tm.setup()

        stream = lokit.stream.tmx("translation_memory.tmx")
        await tm.load(stream)

        results = await tm.match(
            source="Roses are red",
            source_locale="en-US",
            target_locale="fr-FR",
            limit=5,
            threshold=0.5,
        )
        print(results[0].unit_id, results[0].kind, results[0].score)

The database stores plain source and target text in PostgreSQL, uses pg_trgm for exact and fuzzy lookup, and reconstructs Lokit Data objects with tags, comments, metadata, and adjacent context. This supports plain-string matching with tag and metadata propagation.

The stable row serializers and ordered schema statements are public for custom SQL loaders and migration tools such as Alembic:

from alembic import op

from lokit.database import database_schema_statements

for statement in database_schema_statements(partitioned=True):
    op.execute(statement)

import lokit
from lokit.database import iter_serialized_units

document = lokit.stream.tmx("translation_memory.tmx")
for serialized in iter_serialized_units(document, project="checkout", domain="web"):
    unit_row = serialized.unit
    tag_rows = serialized.tags

lokit.database.serialization also exports the typed insert/fetch row models, serialize_unit, and deserialize_unit for integrations that own their SQL execution and retrieval lifecycle.

Enterprise Database Support

With the above local database ingestion and runtime logic, Lokit has direct connection APIs to external enterprise services. Currently supporting AWS (RDS & Aurora), GCP (Cloud SQL & AlloyDB) along with serverless platforms Supabase and Neon. Pipeline is support and enabled by default but configurable. Dual read and write URIs are also accepted for maximum performance while a single URI can still be used for simplicity or where it is not supported in the service used.

The API includes a full backend framework for handling localization database operations including matching, tag, pluralization and properity propigation, read and writes, and concurrent data handeling to and from the database server. All in async and with concurrency where supported by the service.

Lokit can handle direct streaming from legacy interchange formats to enterprise databses with complete customization, no hidden dependencies, no boilerplate and highly optimized data flows.

Lokit is the first ever package to support this in any language ecosystem.

import lokit

tm_rds = await lokit.database.connect(
    "postgresql://user:pass@instance.rds.amazonaws.com:5432/tm?sslmode=require"
)

tm_aurora = await lokit.database.connect(
    "postgresql://user:pass@cluster.rds.amazonaws.com:5432/tm?sslmode=require",
    reader_uri="postgresql://user:pass@cluster-ro.rds.amazonaws.com:5432/tm?sslmode=require"
)

tm_gcp = await lokit.database.connect(
    "postgresql://user:pass@/tm?host=/cloudsql/project:region:instance"
)

tm_supabase = await lokit.database.connect(
    "postgresql://postgres.project-ref:pass@aws-0-region.pooler.supabase.com:6543/postgres?sslmode=require",
    pipeline=False
)

tm_neon = await lokit.database.connect(
    "postgresql://user:pass@ep-cool-darkness-123456.us-east-2.aws.neon.tech/tm?sslmode=require",
    pipeline=False
)

Supported Formats for Parsing

TMX
XLIFF
PO/POT
XLSX
CSV
JSON
HTML
IDML
DOCX
PPTX

Learn More

Visit the official homepage at lokit.org, more detailed documentation is to come before the V1 release.

localization lokit lokit-format l10n i18n translation translation-memory translation-memory-database tmx tmx-parser xliff xliff-parser gettext po idml docx pptx xlsx csv json html type-safe async streaming mypy mypyc backend-localization parsing parsers localization-parsers performance internationalization backend memory-safe translate-toolkit-alternative postgresql-localization python-i18n-tools rust extensions

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

lokit_python-0.5.2.tar.gz (304.2 kB view details)

Uploaded Aug 16, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

lokit_python-0.5.2-cp314-cp314-win_amd64.whl (3.4 MB view details)

Uploaded Aug 16, 2026 CPython 3.14Windows x86-64

lokit_python-0.5.2-cp314-cp314-manylinux_2_28_x86_64.whl (4.0 MB view details)

Uploaded Aug 16, 2026 CPython 3.14manylinux: glibc 2.28+ x86-64

lokit_python-0.5.2-cp314-cp314-macosx_11_0_arm64.whl (3.6 MB view details)

Uploaded Aug 16, 2026 CPython 3.14macOS 11.0+ ARM64

lokit_python-0.5.2-cp314-cp314-macosx_10_15_x86_64.whl (3.9 MB view details)

Uploaded Aug 16, 2026 CPython 3.14macOS 10.15+ x86-64

lokit_python-0.5.2-cp313-cp313-win_amd64.whl (3.3 MB view details)

Uploaded Aug 16, 2026 CPython 3.13Windows x86-64

lokit_python-0.5.2-cp313-cp313-manylinux_2_28_x86_64.whl (3.9 MB view details)

Uploaded Aug 16, 2026 CPython 3.13manylinux: glibc 2.28+ x86-64

lokit_python-0.5.2-cp313-cp313-macosx_11_0_arm64.whl (3.6 MB view details)

Uploaded Aug 16, 2026 CPython 3.13macOS 11.0+ ARM64

lokit_python-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl (3.9 MB view details)

Uploaded Aug 16, 2026 CPython 3.13macOS 10.13+ x86-64

lokit_python-0.5.2-cp312-cp312-win_amd64.whl (3.3 MB view details)

Uploaded Aug 16, 2026 CPython 3.12Windows x86-64

lokit_python-0.5.2-cp312-cp312-manylinux_2_28_x86_64.whl (4.0 MB view details)

Uploaded Aug 16, 2026 CPython 3.12manylinux: glibc 2.28+ x86-64

lokit_python-0.5.2-cp312-cp312-macosx_11_0_arm64.whl (3.6 MB view details)

Uploaded Aug 16, 2026 CPython 3.12macOS 11.0+ ARM64

lokit_python-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl (3.9 MB view details)

Uploaded Aug 16, 2026 CPython 3.12macOS 10.13+ x86-64

lokit_python-0.5.2-cp311-cp311-win_amd64.whl (3.3 MB view details)

Uploaded Aug 16, 2026 CPython 3.11Windows x86-64

lokit_python-0.5.2-cp311-cp311-manylinux_2_28_x86_64.whl (3.9 MB view details)

Uploaded Aug 16, 2026 CPython 3.11manylinux: glibc 2.28+ x86-64

lokit_python-0.5.2-cp311-cp311-macosx_11_0_arm64.whl (3.6 MB view details)

Uploaded Aug 16, 2026 CPython 3.11macOS 11.0+ ARM64

lokit_python-0.5.2-cp311-cp311-macosx_10_12_x86_64.whl (3.8 MB view details)

Uploaded Aug 16, 2026 CPython 3.11macOS 10.12+ x86-64

lokit_python-0.5.2-cp310-cp310-win_amd64.whl (3.3 MB view details)

Uploaded Aug 16, 2026 CPython 3.10Windows x86-64

lokit_python-0.5.2-cp310-cp310-manylinux_2_28_x86_64.whl (3.9 MB view details)

Uploaded Aug 16, 2026 CPython 3.10manylinux: glibc 2.28+ x86-64

lokit_python-0.5.2-cp310-cp310-macosx_11_0_arm64.whl (3.6 MB view details)

Uploaded Aug 16, 2026 CPython 3.10macOS 11.0+ ARM64

lokit_python-0.5.2-cp310-cp310-macosx_10_12_x86_64.whl (3.8 MB view details)

Uploaded Aug 16, 2026 CPython 3.10macOS 10.12+ x86-64

File details

Details for the file lokit_python-0.5.2.tar.gz.

File metadata

Download URL: lokit_python-0.5.2.tar.gz
Upload date: Aug 16, 2026
Size: 304.2 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for lokit_python-0.5.2.tar.gz
Algorithm	Hash digest
SHA256	`12f1cd7282291da2a41fdaec7a9bf557ca49be81e164f064b6ce8b3a6a2811e5`
MD5	`dbc9f6f089af90f3f78daf49e84fdf17`
BLAKE2b-256	`d354fd2c7bef4df6ec3e057d9b25ee51f64419ca50dd5437557b8279baecfd62`

Algorithm	Hash digest
SHA256	`e430d6c0460c4336496240807323bec0c26edec9f438957af1e5b093b7f0ce1a`
MD5	`4575d45b1e1bf390d5bba35a641ea9d4`
BLAKE2b-256	`e7df2dd45729c956a8a06a9a7efdb314b5dd070d7956e256c2a2310c02199fb0`

Algorithm	Hash digest
SHA256	`e9d357eb67225cfdec339d16f402308cde3f5c229e0f89e6a1b47470ec1b48f2`
MD5	`3908ad0ba603e01e99b5b4c048fa8345`
BLAKE2b-256	`2145978553d74254f5a97581972c465ac06c249df68a9fab27997e0140406241`

Algorithm	Hash digest
SHA256	`73848ca338102b857ad022f854b54a22a8cc3c25a1bd573b4d1d6609a272af6f`
MD5	`94999710210f43c8e7af20f40d5d5ff7`
BLAKE2b-256	`f0419c81e08dee2b070ad3a7be0c05c5e744a30d61c3eff1a4992d5841033a16`

Algorithm	Hash digest
SHA256	`df999940bf33a6d0247415086c068d6f8ac7e86672290757cbee90c8da86c43c`
MD5	`ce152658889f603e756db6924725cf42`
BLAKE2b-256	`8e55ccbf59251833446ba433fa12c24b84c273b45d7679554374b041bec8fb3a`

Algorithm	Hash digest
SHA256	`999cfe191bee886da5999edf341e1472c2a0b510f368f9b9678e4341d738373d`
MD5	`91d35d9f3edf8830d9baf7e343e12012`
BLAKE2b-256	`ae0a308c34fda9e982aab93c545a97eca5abbbfff9aa5672eab3054801694541`

Algorithm	Hash digest
SHA256	`8dd7bb9cb71fc57f09202e2d46cf5fa792a22097dc45852d7790b6189f1cb1c6`
MD5	`c2fd6ba40a6e20ac386f00492c1a94b3`
BLAKE2b-256	`78300c93121c41344cdefc8782106fb1e56a2df200e4ead7b5a350aac676b51b`

Algorithm	Hash digest
SHA256	`c479737fb60a912c4d01ecbf6a698340898bb6f22af303c217d3bb3778e77cda`
MD5	`e7bd239398b9cb565489307a3064cf22`
BLAKE2b-256	`6bf2bfff6c3cc597627f845c95933af40c6ce3cd9224086a53e8f23bdbdffad3`

Algorithm	Hash digest
SHA256	`5a35bfb44a611d80f6d40677ae8d6ef813e3079d087c2a0e04a9d4dd3f9d2b91`
MD5	`a3c417056c4c0e85b41cc9c0ddf1380d`
BLAKE2b-256	`c90c0c614d9496540a4a3a57d720a6113263f887f4cdb329d19ecdf545c1b41a`

Algorithm	Hash digest
SHA256	`86cf4e21a90e8ebb67a42f547b1ad4a824982f3a71decf3a2b3d2e216bb1bc09`
MD5	`c5413dd16e51fcccc5ae522ecea4812c`
BLAKE2b-256	`cf226b05369e3c1c5ea02245b1296ebfefb0731395b297fcad0143d37ea96dac`

Algorithm	Hash digest
SHA256	`bdbc6fc680260fa70f2574d99fbe176adb5da9e23c31ba951cb29428320be41d`
MD5	`c381690dd129483ab9206a9c960402ff`
BLAKE2b-256	`977b5c3d57d91814cb9b3169487d9f7d6869e5a5fe2710b635a561771a110380`

Algorithm	Hash digest
SHA256	`3c8db3e835a18bdbe437a1df28b613d5ff1dc85bbf45d4c8c3f18d8bfb64eaa0`
MD5	`9b3f03d3f0c0e64274356f3c334cc0a3`
BLAKE2b-256	`a2f1c9a92bf18bb0f815e4425c6ccfb6769f5ec4531dee4204d32617ae864347`

Algorithm	Hash digest
SHA256	`7ed27fc15cb5ca74906a25870bc5e25a37e50d153a048b4f90d1d0959490fd76`
MD5	`104d5ea52e323fe07c542be57dc0b463`
BLAKE2b-256	`c8a9d8b513fc1c750452d66ac3dd47c8a0c3fcfa47d33e633765f5a99e305f0c`

Algorithm	Hash digest
SHA256	`5d487d533266e70802613c36e1897a3e97080610fdbce8faab72a1b966612f19`
MD5	`1554679526e2b57291ee045bbbf496b5`
BLAKE2b-256	`9afde689ebe7fa8f737702dd010cc20046b56a87164b2c512331d63e387e268f`

Algorithm	Hash digest
SHA256	`560088d298c660deaf71ba912d7eb51e202719d71694bf394f2b9e32b4d5cdcc`
MD5	`e593a381b5416fdf6d603f376ebf22fe`
BLAKE2b-256	`ef1a89b53ff1fb22197a11ecbaffd59e9043c06dfcdbde6433a451c0f0482f84`

Algorithm	Hash digest
SHA256	`96894b6c35d8d870a201a61ab435e0753b5fa5f3f1d80522b117a94a98de47b3`
MD5	`e04c90eb55b71578725fdf1609b11eac`
BLAKE2b-256	`c8901a694c37f36220b151e7bbd03ba4141da9e345648517a8635c03a53f95fa`

Algorithm	Hash digest
SHA256	`b058d47fb25b26e0cbb93d3ee36cbf1fc4c1abec0d690eb0e6f9cd23e79b207d`
MD5	`dcef637cb0a2b05e9800e5648020b7ef`
BLAKE2b-256	`9b7907a57d78952edef537f827151b67fcd11ae68eec6c656f515705cbeee7e6`

Algorithm	Hash digest
SHA256	`a536d776fd25cdf8814fa94de71f1a4c8a7f1a87f275f6908781f85d0564592d`
MD5	`3eaab11d088982da4daad163774ff772`
BLAKE2b-256	`64698d1d0080f982cae8e70203e6a1fcdc185b823434867d99acad7e25eeef82`

Algorithm	Hash digest
SHA256	`97b3429a9549aaf1608a78109033330ea2e51b8de342adb4cafce6412e2a8957`
MD5	`46efbf8488782c8745946c7482756a9d`
BLAKE2b-256	`24df7a678f37d7c16565ebaf11fbe050f5c7abf5ccf2617d37b3b13b39f8b9ef`

Algorithm	Hash digest
SHA256	`5be79f95e6d579430ebf3321dc7c19693988a603adb7f69dd5da431955d93b08`
MD5	`859f10b07634dea23d7f7adf8e9bf529`
BLAKE2b-256	`1a5976d083bbfd490695c756b46b735b2df1dedbccb0699150dbc2241ec3b55c`

Algorithm	Hash digest
SHA256	`2cb0cbf06f73b9b5a6b6a0f6ccc70e0b5f0fdad217c219fa5f375ccb66b16007`
MD5	`bd593bd62cc33afaf8304c572df2a81d`
BLAKE2b-256	`b03515f5670bc49608a613a5f68110a0990eea7622bfb0825abd8b28275903bc`

lokit-python 0.5.2

Lokit

Core Features

Type Safety and C-Extensions

Parsing Performance

SDK Usage Reference

Installation

Basic Parsing and Conversion

Native .lokit interchange

Dictionary projections

Splitting multilingual documents

Asynchronous Streaming for Large Interchange Files

Advanced Querying and Matching

Structured API Paths

PostgreSQL API

Enterprise Database Support

Supported Formats for Parsing

Learn More

Project links

Key dates

1 maintainer

GitHub Statistics

License expression

Requires

Provides Extra

Tags

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

Native `.lokit` interchange