compilekv 0.0.0__py3-none-any.whl

compilekv/__init__.py

@@ -0,0 +1,34 @@
+"""Compile Kivy KV files into Python classes.
+
+A library, meant to be imported:
+
+    import compilekv
+    compilekv.compile_file("ui/style.kv")
+
+The conversion is a Swift package compiled to WebAssembly, so the wheel is
+platform independent. `python -m compilekv` exists but is not the interface.
+"""
+
+from .compiler import (
+    Project,
+    collect_directives,
+    compile_file,
+    compile_tree,
+    find_kv_files,
+    output_path_for,
+    source_path_for,
+)
+from .runtime import KvCompileError, KvCompiler, default_compiler
+
+__all__ = [
+    "Project",
+    "KvCompileError",
+    "KvCompiler",
+    "collect_directives",
+    "compile_file",
+    "compile_tree",
+    "default_compiler",
+    "find_kv_files",
+    "output_path_for",
+    "source_path_for",
+]

compilekv/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for ``python -m compilekv``."""
+
+from .cli import run
+
+raise SystemExit(run())

compilekv/cli.py

@@ -0,0 +1,83 @@
+"""Argument parsing for `python -m compilekv`. The library is in compiler.py."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .compiler import Project, compile_file, find_kv_files
+from .runtime import KvCompileError, default_compiler
+
+
+def run(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="compilekv",
+        description="Compile Kivy KV files into Python classes using the CompileKvWasm module.",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        default=["."],
+        help="KV files or directories to compile (defaults to the current directory).",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Output directory, or a file name when compiling a single KV file. "
+        "Defaults to writing next to each .kv.",
+    )
+    parser.add_argument(
+        "--no-recursive",
+        action="store_true",
+        help="Do not descend into subdirectories.",
+    )
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="Only report errors.",
+    )
+    args = parser.parse_args(argv)
+
+    roots = [Path(path) for path in args.paths]
+    for root in roots:
+        if not root.exists():
+            print(f"error: {root} does not exist", file=sys.stderr)
+            return 1
+
+    # Everything is read before anything is written, so a `#:set` in the last
+    # file scanned is still available to the first file generated.
+    project = Project.scan(roots, recursive=not args.no_recursive)
+    if not project.kv_files:
+        print("No .kv files found.", file=sys.stderr)
+        return 1
+
+    compiler = default_compiler()
+    failures = 0
+    for root in roots:
+        for kv_path in find_kv_files(root, recursive=not args.no_recursive):
+            try:
+                written = compile_file(
+                    kv_path,
+                    _target_for(kv_path, root, args.output),
+                    compiler,
+                    project.directives,
+                )
+            except KvCompileError as error:
+                print(f"error: {kv_path}: {error}", file=sys.stderr)
+                failures += 1
+                continue
+            if not args.quiet:
+                print(f"{kv_path} -> {written}")
+
+    return 1 if failures else 0
+
+
+def _target_for(kv_path: Path, root: Path, output: str | None) -> Path | None:
+    """A directory input means a directory output, mirroring the tree under it."""
+    if output is None:
+        return None
+    if root.is_file():
+        return Path(output)
+    return Path(output) / kv_path.parent.relative_to(root)

compilekv/compiler.py

@@ -0,0 +1,144 @@
+"""Find .kv files, run them through wasm, write the .py."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+from .runtime import KvCompiler, default_compiler
+
+
+def output_path_for(kv_path: str | Path, output: str | Path | None = None) -> Path:
+    """Where `kv_path` is written. `output` may be a directory or a file name."""
+    kv_path = Path(kv_path)
+    if output is None:
+        return kv_path.with_suffix(".py")
+    output = Path(output)
+    if output.is_dir() or not output.suffix:
+        return output / kv_path.with_suffix(".py").name
+    return output
+
+
+def source_path_for(kv_path: str | Path) -> Path:
+    """The hand written .py beside the .kv, whose contents get extended."""
+    return Path(kv_path).with_suffix(".py")
+
+
+# `#: set` with a space is as valid as `#:set`.
+SHARED_DIRECTIVE = re.compile(r"^#:\s*(set|import)\s+\S+\s+\S.*$")
+
+
+def collect_directives(paths: Iterable[str | Path]) -> str:
+    """The `#:set` and `#:import` lines from every given file.
+
+    KV puts both in one namespace shared by everything Builder loads -- a
+    theme file defines the constants, one widget file imports a helper another
+    one uses -- so compiling any file needs the directives from all of them.
+
+    Python files are worth reading for the same reason: KV passed to
+    `Builder.load_string()` carries directives that the .kv files rely on.
+    """
+    lines: list[str] = []
+    for path in paths:
+        try:
+            source = Path(path).read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        for line in source.splitlines():
+            stripped = line.strip()
+            if SHARED_DIRECTIVE.match(stripped) and stripped not in lines:
+                lines.append(stripped)
+    return "\n".join(lines)
+
+
+@dataclass(frozen=True)
+class Project:
+    """The .kv files to compile, and everything they share.
+
+    Gathered in full before anything is generated, so a file can use a
+    `#:set` from a file that comes later in the walk -- a theme file is
+    usually last alphabetically and always needed first.
+    """
+
+    kv_files: tuple[Path, ...]
+    directives: str
+
+    @classmethod
+    def scan(cls, roots: str | Path | Iterable[str | Path], recursive: bool = True) -> "Project":
+        if isinstance(roots, (str, Path)):
+            roots = [roots]
+        roots = [Path(root) for root in roots]
+
+        kv_files: list[Path] = []
+        for root in roots:
+            for path in find_kv_files(root, recursive=recursive):
+                if path not in kv_files:
+                    kv_files.append(path)
+
+        # Python files can hold KV too, inside Builder.load_string(), and the
+        # directives in it are shared with every .kv file.
+        sources = list(kv_files)
+        pattern = "**/*.py" if recursive else "*.py"
+        for root in roots:
+            directory = root if root.is_dir() else root.parent
+            sources.extend(sorted(p for p in directory.glob(pattern) if p.is_file()))
+
+        return cls(tuple(kv_files), collect_directives(sources))
+
+
+def compile_file(
+    kv_path: str | Path,
+    output: str | Path | None = None,
+    compiler: KvCompiler | None = None,
+    directives: str = "",
+) -> Path:
+    """Compile one .kv, extending the .py next to it. Returns the file written."""
+    kv_path = Path(kv_path)
+    target = output_path_for(kv_path, output)
+    compiler = compiler or default_compiler()
+
+    source = source_path_for(kv_path)
+    py_source = source.read_text(encoding="utf-8") if source.is_file() else ""
+
+    generated = compiler.compile_source(
+        kv_path.read_text(encoding="utf-8"), py_source, directives
+    )
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(generated, encoding="utf-8")
+    return target
+
+
+def find_kv_files(root: str | Path, recursive: bool = True) -> list[Path]:
+    """The .kv files under `root`, or `root` itself if it is one."""
+    root = Path(root)
+    if root.is_file():
+        return [root]
+    pattern = "**/*.kv" if recursive else "*.kv"
+    return sorted(p for p in root.glob(pattern) if p.is_file())
+
+
+def compile_tree(
+    root: str | Path,
+    output_dir: str | Path | None = None,
+    recursive: bool = True,
+    compiler: KvCompiler | None = None,
+) -> list[Path]:
+    """Compile every .kv under `root` into `output_dir`. Returns what was written."""
+    root = Path(root)
+    compiler = compiler or default_compiler()
+
+    # Scan the whole tree before writing anything.
+    project = Project.scan(root, recursive=recursive)
+
+    written = []
+    for kv_path in project.kv_files:
+        target = None
+        if output_dir is not None:
+            # Mirror the tree under root so same-named .kv files cannot collide.
+            relative = kv_path.parent.relative_to(root) if root.is_dir() else Path()
+            target = Path(output_dir) / relative
+        written.append(compile_file(kv_path, target, compiler, project.directives))
+    return written

compilekv/runtime.py

@@ -0,0 +1,122 @@
+"""Wrapper around the CompileKvWasm module. Strings in, strings out."""
+
+from __future__ import annotations
+
+import threading
+from functools import lru_cache
+from importlib import resources
+from pathlib import Path
+
+from wasmtime import Engine, Instance, Linker, Module, Store, WasiConfig
+
+WASM_FILENAME = "compilekv.wasm"
+
+_default_compiler: "KvCompiler | None" = None
+_default_lock = threading.Lock()
+
+
+def default_compiler() -> "KvCompiler":
+    """The process-wide compiler shared by every caller."""
+    global _default_compiler
+    with _default_lock:
+        if _default_compiler is None:
+            _default_compiler = KvCompiler()
+        return _default_compiler
+
+
+class KvCompileError(RuntimeError):
+    """Raised when the wasm module fails to convert a KV source string."""
+
+
+def _default_wasm_path() -> Path:
+    return Path(str(resources.files(__package__).joinpath(WASM_FILENAME)))
+
+
+@lru_cache(maxsize=None)
+def _compile_module(path: str, fingerprint: tuple[int, int]) -> tuple[Engine, Module]:
+    """Compile once per process; `fingerprint` is (mtime, size) to catch rebuilds."""
+    del fingerprint
+    engine = Engine()
+    return engine, Module.from_file(engine, path)
+
+
+class KvCompiler:
+    """One wasm instance with its own linear memory."""
+
+    def __init__(self, wasm_path: str | Path | None = None) -> None:
+        path = Path(wasm_path) if wasm_path is not None else _default_wasm_path()
+        if not path.is_file():
+            raise FileNotFoundError(
+                f"wasm module not found at {path}. "
+                "Build it with `python setup.py build_wasm` or reinstall compilekv."
+            )
+        self.wasm_path = path
+        self._lock = threading.Lock()
+
+        stat = path.stat()
+        engine, module = _compile_module(str(path), (stat.st_mtime_ns, stat.st_size))
+
+        self._store = Store(engine)
+        self._store.set_wasi(WasiConfig())
+
+        linker = Linker(engine)
+        linker.define_wasi()
+        self._instance: Instance = linker.instantiate(self._store, module)
+
+        exports = self._instance.exports(self._store)
+        self._memory = exports["memory"]
+        self._alloc = exports["kv_alloc"]
+        self._dealloc = exports["kv_dealloc"]
+        self._convert = exports["kv_convert"]
+        self._result_ptr = exports["kv_result_ptr"]
+        self._result_len = exports["kv_result_len"]
+        self._result_free = exports["kv_result_free"]
+
+        # A reactor is initialized explicitly, not through `_start`.
+        exports["_initialize"](self._store)
+
+    def _write(self, data: bytes) -> tuple[int, int]:
+        if not data:
+            return 0, 0
+        pointer = self._alloc(self._store, len(data))
+        self._memory.write(self._store, data, pointer)
+        return pointer, len(data)
+
+    def _take_result(self) -> str:
+        pointer = self._result_ptr(self._store)
+        length = self._result_len(self._store)
+        if not length:
+            return ""
+        return bytes(self._memory.read(self._store, pointer, pointer + length)).decode("utf-8")
+
+    def compile_source(
+        self, kv_source: str, py_source: str = "", directives: str = ""
+    ) -> str:
+        """Convert KV source to Python.
+
+        `py_source` is the existing .py, if any. `directives` holds `#:set`
+        and `#:import` lines from other KV files, which KV shares across a
+        project.
+        """
+        with self._lock:
+            kv_ptr, kv_len = self._write(kv_source.encode("utf-8"))
+            py_ptr, py_len = self._write(py_source.encode("utf-8"))
+            const_ptr, const_len = self._write(directives.encode("utf-8"))
+            try:
+                status = self._convert(
+                    self._store, kv_ptr, kv_len, py_ptr, py_len, const_ptr, const_len
+                )
+                output = self._take_result()
+                self._result_free(self._store)
+            finally:
+                for pointer, length in (
+                    (kv_ptr, kv_len),
+                    (py_ptr, py_len),
+                    (const_ptr, const_len),
+                ):
+                    if length:
+                        self._dealloc(self._store, pointer, length)
+
+        if status != 0:
+            raise KvCompileError(output or "unknown error")
+        return output

compilekv-0.0.0.dist-info/METADATA

@@ -0,0 +1,324 @@
+Metadata-Version: 2.4
+Name: compilekv
+Version: 0.0.0
+Summary: Compile Kivy KV files into Python classes using a Swift WebAssembly module
+Author-email: psychowasp <psychowaspx@gmail.com>
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE.txt
+Requires-Dist: wasmtime>=25
+Dynamic: license-file
+
+# compilekv
+
+**An importable Python module.** `import compilekv` and call it from your own
+code — a build step, an editor plugin, a test fixture, whatever. It compiles
+Kivy `.kv` files into plain Python classes, so widgets can be built without
+`Builder`.
+
+## Why WebAssembly
+
+The conversion is [KvToPyClass](KvToPyClass/), a Swift package. Shipping that
+as a native binary would mean a wheel per platform, built on a machine with a
+Swift toolchain, and no wheel at all for anything you did not build for — which
+is fine for a command line tool you install yourself, and useless for a module
+other people import.
+
+Compiled to wasm instead, the conversion is just data: one
+`compilekv-0.1.0-py3-none-any.whl` that installs and imports anywhere Python
+runs. Python owns the filesystem — it walks the tree, reads the `.kv` and any
+existing `.py`, and writes the result. The wasm module only ever sees and
+returns strings, so nothing in it is platform specific.
+
+The one native piece is the `wasmtime` runtime, which publishes wheels for
+macOS (x86_64, arm64), Linux (x86_64, aarch64; glibc and musl), Windows
+(amd64, arm64) and Android.
+
+## Usage
+
+compilekv is a library. Import it and call the helpers:
+
+```python
+from compilekv import compile_file, compile_tree, find_kv_files
+
+compile_tree("ui/")                    # every .kv under a directory, in place
+compile_tree("ui/", "build/")          # ... or into a separate tree
+compile_file("ui/style.kv")            # one file
+compile_file("ui/style.kv", "build/")  # ... written to build/style.py
+```
+
+Each `style.kv` compiles to `style.py`. Give an output directory and the tree
+under the input is mirrored into it, so `ui/panels/style.kv` becomes
+`build/panels/style.py` and same-named files in different directories cannot
+collide. Pass a path with a suffix instead and it is used verbatim as the file
+name.
+
+### Extending, not replacing
+
+The `.py` **next to the `.kv`** is the source. It is read whether or not you
+compile into a separate output directory, and the result is that file with the
+generated code folded in: imports the rules need are added to the ones already
+there, a class the KV defines is merged with the same-named class in place, and
+rules with no matching class are appended. Everything else -- module docstring,
+constants, helper functions, unrelated classes -- stays where you put it.
+
+Inside a class the author's body is the starting point, so properties,
+annotations, the class docstring, nested classes and hand written methods all
+survive. A generated method replaces the one it shares a name with, with one
+exception: `__init__` is **appended to**, not replaced. Your setup runs first,
+then the widget tree:
+
+```python
+def __init__(self, **kwargs):
+    super().__init__(**kwargs)
+    self.counter = 0          # yours
+    self._bindings = []       # generated from here down
+    self.orientation = "vertical"
+    ...
+```
+
+Your signature and your `super()` call are the ones kept. Everything from
+`self._bindings = []` onwards is treated as output from a previous run and
+replaced, which is what keeps regenerating from stacking copies of the tree.
+
+A `<Name>:` rule styles a class that already exists, so its bases come from
+your Python; `<Name@Base>:` declares them inline. With neither, it falls back
+to `Widget`.
+
+Output is deterministic and regenerating is idempotent -- compiling twice
+leaves the files byte for byte identical, which keeps generated code reviewable
+in version control.
+
+One consequence of extending rather than replacing: compiling **in place**,
+where the source and the output are the same file, cannot tell a class it
+emitted last run from one you wrote, so deleting a rule leaves its class
+behind. Compile into an output directory for a file that only ever reflects
+the current `.kv`.
+
+For direct control over the strings, skipping the file layer entirely:
+
+```python
+from compilekv import default_compiler
+
+python_source = default_compiler().compile_source(kv_source, existing_py_source)
+```
+
+`compile_source` raises `KvCompileError` with the parser's message when the KV
+is invalid.
+
+### One wasm module per process
+
+Compiling the wasm module takes a few seconds against ~3 ms per conversion, so
+it happens once. `default_compiler()` returns a process-wide instance shared by
+every caller, so any number of modules can import compilekv and convert as often
+as they like without reloading:
+
+```python
+# module_a.py                      # module_b.py
+from compilekv import compile_file  import compilekv
+compile_file("a.kv")                compilekv.compile_file("b.kv")
+# ^ pays the load                   # ^ ~1 ms, same instance
+```
+
+Conversions are serialized on the instance's own lock, so sharing it across
+threads is safe. `KvCompiler()` still builds an isolated instance with its own
+linear memory when you want one; the compiled module is cached either way.
+
+### Command line
+
+Secondary, for one-off runs. No console script is installed.
+
+```console
+$ python -m compilekv [paths...] [-o OUT] [--no-recursive] [-q]
+```
+
+`-o` is a directory when the input is one, mirroring its layout, and may be a
+file name when compiling a single `.kv`.
+
+## Tests
+
+```console
+$ COMPILEKV_SKIP_WASM_BUILD=1 uv run --group dev pytest
+```
+
+Drop the environment variable to rebuild the wasm module first. The suite covers
+the wasm ABI, the file walking layer, and the CLI, and finishes with a round trip
+that prints both inputs and the generated output.
+
+## Building from source
+
+The wheel bundles a prebuilt `compilekv.wasm`. Rebuilding it needs a Swift
+toolchain plus a matching [Swift SDK for WebAssembly](https://www.swift.org/documentation/articles/wasm-getting-started.html),
+`KvToPyClass/` is vendored in this repo and referenced by relative path, so no
+extra checkout is needed.
+
+```console
+$ python scripts/build_wasm.py    # just the wasm module
+$ python -m build --wheel         # wasm + wheel
+```
+
+The build picks a wasm SDK matching the active toolchain, falling back to
+`swiftly run +<version>` when the default toolchain is a different version.
+Override with `COMPILEKV_SWIFT`, `COMPILEKV_WASM_SDK`, or set
+`COMPILEKV_SKIP_WASM_BUILD=1` to reuse the module already in `src/compilekv/`.
+
+The module is ~46 MB because Swift's Foundation is statically linked (about
+36 MB of that is Foundation's data tables); the wheel compresses to ~18 MB.
+
+## Wasm ABI
+
+The Swift package builds as a WASI reactor exporting:
+
+| Export | Purpose |
+| --- | --- |
+| `kv_alloc(size) -> ptr` | allocate an input buffer in linear memory |
+| `kv_dealloc(ptr, size)` | release one |
+| `kv_convert(kv_ptr, kv_len, py_ptr, py_len) -> status` | convert; 0 on success, 1 on error |
+| `kv_result_ptr()` / `kv_result_len()` | the generated source, or the error message |
+| `kv_result_free()` | release the result buffer |
+
+### `root`, `self`, and bindings
+
+`root` in KV is the widget the rule applies to, so it becomes `self`:
+
+```kv
+<Card>:
+    Label:
+        text: root.title
+```
+
+```python
+label_1.text = self.title
+self.bind(title=label_1.setter("text"))
+```
+
+`self` is the widget whose block the value was written in, so under a child
+it is that child, not the rule:
+
+```kv
+<Card>:
+    Label:
+        height: self.texture_size[1]
+```
+
+```python
+label_1.height = label_1.texture_size[1]
+label_1.bind(texture_size=_callback_0)
+```
+
+The `bind` call is only emitted when the attribute is a Kivy property of
+whichever object it is read from. That is answered by the widget registry for
+anything Kivy ships, by the rule for a widget another rule defines, and by the
+class itself for one in your `.py` -- `title = StringProperty("")` binds,
+`title = "x"` does not, because `bind()` on a non-property raises. A widget
+from outside the module cannot be checked, so it is assumed bindable. In a
+mixed expression the bindable names are bound and the rest are read once.
+
+### Directives
+
+KV's `#:set` directives are substituted into the generated code, since there is
+no Builder at runtime to resolve them:
+
+```kv
+#:set plex_16 sp(16)
+
+<Item>:
+    font_size: plex_16
+```
+
+```python
+from kivy.metrics import sp
+...
+self.font_size = sp(16)
+```
+
+The file that declares a `#:set` also publishes it, so `.kv` files loaded at
+runtime still resolve the name -- Builder only knows the directives from files
+it has already parsed:
+
+```python
+from kivy.lang.parser import global_idmap
+
+global_idmap["plex_16"] = sp(16)
+```
+
+Only the declaring file does this; one that merely uses the constant gets the
+substituted value and nothing else.
+
+`#:import` becomes a real import, but only for the names the generated code
+actually reads:
+
+```kv
+#:import get_font_name carbonkivy.utils.get_font_name
+```
+
+```python
+from carbonkivy.utils import get_font_name
+```
+
+KV puts both kinds in one namespace shared by everything Builder loads, so the
+whole project is read before anything is written. `Project.scan(roots)` walks
+every `.kv` -- and every `.py`, since KV passed to `Builder.load_string()`
+carries directives the `.kv` files rely on -- and `compile_tree` and
+`python -m compilekv` both go through it. Nothing depends on which file is
+walked first. A `#:set` in the file itself wins over a shared one.
+`collect_directives(paths)` exposes the gathering, and
+`compile_file(..., directives=...)` takes the result.
+
+### Declared property types
+
+A bare unquoted word normally becomes a string, but not when the property it is
+assigned to cannot hold one. `font_size: SOME_GLOBAL` on a `NumericProperty`
+emits the name, not `"SOME_GLOBAL"`. The type comes from the widget registry or
+from the property your class declares, so `my_size = NumericProperty()` in your
+`.py` is taken into account.
+
+### Canvas
+
+A canvas layer becomes a `with` block, the way it is written by hand:
+
+```kv
+<Card>:
+    canvas.before:
+        Color:
+            rgba: (1, 0, 0, 1)
+        Rectangle:
+            pos: self.pos
+            size: self.size
+```
+
+```python
+with self.canvas.before:
+    Color(rgba=(1, 0, 0, 1))
+    self.rectangle_1 = Rectangle(pos=self.pos, size=self.size)
+self.bind(pos=_callback_1, size=_callback_2)
+```
+
+An instruction whose properties track something is named so the bindings have
+an object to update; the rest stay anonymous. Child widgets get their own
+canvas blocks, where `self` is that child.
+
+### Factory registration
+
+Every generated class is registered, so other KV files and `Builder` can
+resolve it by name:
+
+```python
+Factory.register("MyButton", cls=MyButton)
+```
+
+Existing registrations in your `.py` are left alone rather than duplicated.
+
+A widget the KV references that Kivy does not ship and this module does not
+define is assumed to be a custom widget registered elsewhere, so it is taken
+off the Factory instead of guessed at with a `kivy.uix` import:
+
+```python
+MyWidget = Factory.MyWidget
+```
+
+This is a plain constant, not `type MyWidget = Factory.MyWidget`. The PEP 695
+form resolves lazily, which would be nicer, but a `TypeAliasType` is not
+callable and the generated code has to construct the widget. The constant is
+read at import time, so the widget must be registered by then.

compilekv-0.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+compilekv/__init__.py,sha256=Iy31Fe314YgXot8QmSbhahpp_FAPVHvTOsWW6eS_J0I,755
+compilekv/__main__.py,sha256=uCxLeKybEIMwwIaDUc072zPbY93L8llRrJkp7pP_jjY,94
+compilekv/cli.py,sha256=NkXJtp_PCeZLdQSyXTOkoA0Ba4o3tTrLwts7nXlJVDg,2665
+compilekv/compilekv.wasm,sha256=VNswOvuodYnnvKBkltINdGknmYE4WbBMtACVQ39Uwco,54575107
+compilekv/compiler.py,sha256=-pidtSxoqQrrleVxK2J2XMMmHb91mrheGCLLjJyStHg,5043
+compilekv/runtime.py,sha256=IqUMFtMKHPFO06k4-eo0cYDJJ8k59zcwaO5OvyS9aUE,4282
+compilekv-0.0.0.dist-info/licenses/LICENSE,sha256=1ang70jO8tCyRHiKyfow8CwzWT5VVqzmi_FciPsP3Cw,1068
+compilekv-0.0.0.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+compilekv-0.0.0.dist-info/METADATA,sha256=RLxzwsFF8Z2NWdweJxrVdgNZ8qcAjDXIDRsLm6MyfjQ,11418
+compilekv-0.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+compilekv-0.0.0.dist-info/top_level.txt,sha256=wvY5qbspjpgq24GkezGcU2ZdgpdUZYfbrCCUeT78cTc,10
+compilekv-0.0.0.dist-info/RECORD,,

compilekv-0.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
+

compilekv-0.0.0.dist-info/licenses/LICENSE

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

compilekv-0.0.0.dist-info/licenses/LICENSE.txt

@@ -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.

compilekv-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+compilekv