tmlat 0.5.1__cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl

mla/__init__.py

@@ -0,0 +1,5 @@
+from .mla import *
+
+__doc__ = mla.__doc__
+if hasattr(mla, "__all__"):
+    __all__ = mla.__all__

mla/__init__.pyi

@@ -0,0 +1,136 @@
+from typing import Optional, Union, Any, BinaryIO, List, Dict, final
+import os
+
+__all__ = [
+    "EntryName", "FileMetadata", "MLAWriter", "MLAReader",
+    "WriterConfig", "ReaderConfig", "SignatureConfig",
+    "PublicKeys", "PrivateKeys", "DEFAULT_COMPRESSION_LEVEL",
+    # Exceptions
+    "MLAError", "WrongMagic", "UnsupportedVersion", "InvalidKeyFormat",
+    "WrongBlockSubFileType", "UTF8ConversionError", "EntryNameTooLong",
+    "WrongArchiveWriterState", "WrongReaderState", "WrongWriterState",
+    "RandError", "PrivateKeyNeeded", "DeserializationError", "SerializationError",
+    "MissingMetadata", "BadAPIArgument", "EndOfStream", "ConfigError",
+    "DuplicateEntryName", "AuthenticatedDecryptionWrongTag", "HKDFInvalidKeyLength",
+    "HPKEError", "InvalidLastTag", "WrongEndMagic", "NoValidSignatureFound",
+    "SignatureVerificationAskedButNoSignatureLayerFound",
+    "MissingEndOfEncryptedInnerLayerMagic", "TruncatedTag", "UnknownTagPosition",
+    "MLAOther"
+]
+
+@final
+class EntryName:
+    def __new__(cls, str_path: str) -> "EntryName": ...
+    @staticmethod
+    def from_path(path: os.PathLike[str]) -> "EntryName": ...
+    @staticmethod
+    def from_arbitrary_bytes(bytes: bytes) -> "EntryName": ...
+    @property
+    def arbitrary_bytes(self) -> bytes: ...
+    def raw_content_to_escaped_string(self) -> str: ...
+    def to_pathbuf(self) -> str: ...
+    def to_pathbuf_escaped_string(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+
+@final
+class FileMetadata:
+    size: Optional[int]
+    hash: Optional[bytes]
+
+@final
+class MLAWriter:
+    def __new__(cls, path: str, config: "WriterConfig") -> "MLAWriter": ...
+    def __repr__(self) -> str: ...
+    def __setitem__(self, key: EntryName, value: bytes) -> None: ...
+    def finalize(self) -> None: ...
+    _buffered_type: Any
+    def add_entry_from(self, key: EntryName, src: Union[str, BinaryIO], chunk_size: int = 4194304) -> None: ...
+    def __enter__(self) -> "MLAWriter": ...
+    def __exit__(self, exc_type: Optional[type] = ..., _exc_value: Optional[BaseException] = ..., _traceback: Optional[Any] = ...) -> bool: ...
+
+@final
+class MLAReader:
+    def __new__(cls, path: str, config: "ReaderConfig") -> "MLAReader": ...
+    def __repr__(self) -> str: ...
+    def __getitem__(self, key: EntryName) -> bytes: ...
+    def __contains__(self, key: EntryName) -> bool: ...
+    def __len__(self) -> int: ...
+    def keys(self) -> List[EntryName]: ...
+    def list_entries(self, include_size: bool = False, include_hash: bool = False) -> Union[List[EntryName], Dict[EntryName, FileMetadata]]: ...
+    def write_entry_to(self, key: EntryName, dest: Union[str, BinaryIO], chunk_size: int = 4194304) -> None: ...
+    def __enter__(self) -> "MLAReader": ...
+    def __exit__(self, _exc_type: Optional[type] = ..., _exc_value: Optional[BaseException] = ..., _traceback: Optional[Any] = ...) -> bool: ...
+
+@final
+class WriterConfig:
+    def __new__(cls, private_keys: "PrivateKeys", public_keys: "PublicKeys") -> "WriterConfig": ...
+    @classmethod
+    def without_encryption_without_signature(cls) -> "WriterConfig": ...
+    @classmethod
+    def with_encryption_without_signature(cls, public_keys: "PublicKeys") -> "WriterConfig": ...
+    @classmethod
+    def without_encryption_with_signature(cls, private_keys: "PrivateKeys") -> "WriterConfig": ...
+    def with_compression_level(self, compression_level: int) -> "WriterConfig": ...
+    def without_compression(self) -> "WriterConfig": ...
+
+@final
+class ReaderConfig:
+    def __new__(cls, private_keys: Optional["PrivateKeys"], signature_config: "SignatureConfig") -> "ReaderConfig": ...
+    @classmethod
+    def without_encryption(cls, signature_config: "SignatureConfig") -> "ReaderConfig": ...
+    @classmethod
+    def with_private_keys_accept_unencrypted(cls, private_keys: "PrivateKeys", signature_config: "SignatureConfig") -> "ReaderConfig": ...
+
+@final
+class SignatureConfig:
+    def __new__(cls, public_keys: "PublicKeys") -> "SignatureConfig": ...
+    @classmethod
+    def without_signature_verification(cls) -> "SignatureConfig": ...
+
+@final
+class PublicKeys:
+    def __new__(cls, *keys: Union[bytes, str]) -> "PublicKeys": ...
+    keys: List[str]
+
+@final
+class PrivateKeys:
+    def __new__(cls, *keys: Union[bytes, str]) -> "PrivateKeys": ...
+    keys: List[str]
+
+# Constants
+DEFAULT_COMPRESSION_LEVEL: int
+
+# Exceptions
+class MLAError(Exception): ...
+class WrongMagic(MLAError): ...
+class UnsupportedVersion(MLAError): ...
+class InvalidKeyFormat(MLAError): ...
+class WrongBlockSubFileType(MLAError): ...
+class UTF8ConversionError(MLAError): ...
+class EntryNameTooLong(MLAError): ...
+class WrongArchiveWriterState(MLAError): ...
+class WrongReaderState(MLAError): ...
+class WrongWriterState(MLAError): ...
+class RandError(MLAError): ...
+class PrivateKeyNeeded(MLAError): ...
+class DeserializationError(MLAError): ...
+class SerializationError(MLAError): ...
+class MissingMetadata(MLAError): ...
+class BadAPIArgument(MLAError): ...
+class EndOfStream(MLAError): ...
+class ConfigError(MLAError): ...
+class DuplicateEntryName(MLAError): ...
+class AuthenticatedDecryptionWrongTag(MLAError): ...
+class HKDFInvalidKeyLength(MLAError): ...
+class HPKEError(MLAError): ...
+class InvalidLastTag(MLAError): ...
+class WrongEndMagic(MLAError): ...
+class NoValidSignatureFound(MLAError): ...
+class SignatureVerificationAskedButNoSignatureLayerFound(MLAError): ...
+class MissingEndOfEncryptedInnerLayerMagic(MLAError): ...
+class TruncatedTag(MLAError): ...
+class UnknownTagPosition(MLAError): ...
+class MLAOther(MLAError): ...

tmlat-0.5.1.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: tmlat
+Version: 0.5.1
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE.md
+Summary: Bindings for MLA Archive manipulation
+Keywords: rust,compression,encryption,signature,pqc
+Home-Page: https://github.com/ANSSI-FR/MLA
+Author-email: ANSSI <opensource@ssi.gouv.fr>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Project-URL: documentation, https://github.com/ANSSI-FR/MLA
+Project-URL: repository, https://github.com/ANSSI-FR/MLA
+
+# MLA Python Bindings
+
+Python bindings for the MLA (Multi-Layer Archive) format, enabling secure, compressed, and signed archives from Python.
+
+## Installation
+
+Install from PyPI:
+
+```sh
+pipx install mla-archive
+```
+
+Or build from source:
+
+**Install maturin:**  
+   `maturin` is a tool for building and publishing Rust-based Python packages.  
+   You can install it via pipx:
+
+   ```sh
+   pipx install maturin
+   ```
+
+**Build the Python wheel:**
+
+```sh
+maturin build --release
+```
+
+This creates a `.whl` file in the `target/wheels/` directory.
+
+**(Alternative) Install directly into a Python virtual environment:**
+
+   ```sh
+   python -m venv .venv
+   source .venv/bin/activate
+   maturin develop
+   ```
+
+This builds and installs the package for development.
+
+## Usage Example
+
+```python
+import mla
+
+def main() -> None:
+    # --- Writing ---
+    config: mla.WriterConfig = mla.WriterConfig.without_encryption_without_signature()
+    with mla.MLAWriter("example.mla", config) as archive:
+        archive[mla.EntryName("hello.txt")] = b"Hello, MLA!"
+        archive[mla.EntryName("data.bin")] = b"\x00\x01\x02"
+    print("Archive written: example.mla")
+
+    # --- Reading ---
+    sig_cfg: mla.SignatureConfig = mla.SignatureConfig.without_signature_verification()
+    config: mla.ReaderConfig = mla.ReaderConfig.without_encryption(sig_cfg)
+    with mla.MLAReader("example.mla", config) as archive:
+        for name in archive.keys():
+            # name is of type EntryName
+            print(f"{name.raw_content_to_escaped_string()}: {archive[name].decode('utf-8')}")
+
+if __name__ == "__main__":
+    main()
+```
+
+## Features
+
+- Create and extract MLA archives from Python
+- Support for compression, encryption, and signatures (if enabled in the archive)
+- Simple dictionary-like API for file access
+- Compatible with archives created by the Rust `mlar` CLI
+
+## API
+
+- `mla.MLAReader(path, config)` — Open an archive for reading
+- `mla.MLAWriter(path, config)` — Open an archive for writing
+- `archive[name] = data` — Add a file (write mode)
+- `archive[name]` — Read a file (read mode)
+- `archive.finalize()` — Finalize and close the archive (write mode)
+- Iteration: `for name in archive: ...`
+
+See [tests](tests) for more usage examples.
+
+## Type stub files
+
+The MLA Python bindings include type stub files (`.pyi`) to provide static type information for tools like `mypy`, IDEs, and linters.
+
+- The bindings expose a native extension module `mla.mla` along with the top-level `mla` package.
+- To support static analysis, there are stub files both for the top-level package (`mla/__init__.pyi`) and the native submodule (`mla/mla.pyi`).
+- These stubs allow type checkers to understand the full API surface, since compiled native modules lack introspectable Python signatures.
+- When developing or modifying the bindings, ensure all `.pyi` files are kept alongside their respective Python or compiled modules so tools can locate them.
+- To verify your stubs correctly match the runtime API (with `mypy` as an example), use:
+
+```sh
+python3 -m mypy.stubtest mla
+```
+
+## Testing
+
+Run the test suite with:
+
+```sh
+pytest
+```

tmlat-0.5.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+mla/__init__.py,sha256=btya5Hbk_481g6E8z0xi35pavTbBBAE8TXbnmukm_UA,95
+mla/__init__.pyi,sha256=m-Yvq6lItHzzlw_iC2h16ba09bHrHPNsC7-G70SzYgA,5671
+mla/mla.cpython-314-i386-linux-gnu.so,sha256=Tmc45ooFNizBhbMBk76YDfUrqtCjhINTWLslzbXLHMg,2858448
+mla/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tmlat-0.5.1.dist-info/METADATA,sha256=9BwrRqETUiZ2pTZ27siObCaCgScR8AxCMOaBZ5N7qGs,3752
+tmlat-0.5.1.dist-info/WHEEL,sha256=SVj-mRhc8RTrK4UpVRzxX8JD-f_LshAVh79WuN6tVL8,139
+tmlat-0.5.1.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+tmlat-0.5.1.dist-info/RECORD,,

tmlat-0.5.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_5_i686
+Tag: cp314-cp314-manylinux1_i686

tmlat-0.5.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.