inferlock 0.4.0__tar.gz

inferlock-0.4.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: inferlock
+Version: 0.4.0
+Summary: File encryption and licensing for AI models
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+
+# inferlock
+
+Protect AI model files with encryption and license-based runtime loading.
+
+inferlock encrypts model files and loads them securely with expiration-based licenses.
+
+---
+
+## Features
+
+* Model file encryption
+* Runtime in-memory decryption
+* License-based loading
+* Expiration-based license
+* Single-command packaging
+* Bundle-based distribution
+* CLI-first design
+
+---
+
+## Installation
+
+```bash
+pip install inferlock
+```
+
+or local dev:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Quick Start
+
+Encrypt model and create license:
+
+```bash
+inferlock encrypt model.pt --expire 30d
+```
+
+Output:
+
+```
+model.inferlock/
+ ├── model.inferlock
+ └── license.inferlock
+```
+
+Load model:
+
+```python
+from inferlock import load
+
+model = load("model.inferlock")
+```
+
+---
+
+## CLI Usage
+
+Encrypt model:
+
+```bash
+inferlock encrypt model.pt --expire 30d
+```
+
+Generate license manually:
+
+```bash
+inferlock license model.key --expire 30d
+```
+
+Show bundle info:
+
+```bash
+inferlock info model.inferlock
+```
+
+---
+
+## Device Binding
+
+Bind license to machine:
+
+```bash
+inferlock encrypt model.pt --expire 30d --bind-device
+```
+
+The license will be tied to the current machine's MAC address and cannot be used on other devices.
+
+---
+
+## Bundle Structure
+
+```
+model.inferlock/
+ ├── model.inferlock
+ └── license.inferlock
+```
+
+---
+
+## Python API
+
+Load bundle:
+
+```python
+from inferlock import load
+
+model = load("model.inferlock")
+```
+
+Load manually:
+
+```python
+load("model.inferlock", "license.inferlock")
+```
+
+---
+
+## License Format
+
+```json
+{
+  "key": "...",
+  "expire": "YYYY-MM-DD",
+  "version": 1
+}
+```
+
+## Version
+
+### v0.2.0
+
+* license system
+* expiration support
+* bundle packaging
+* single command encrypt + license
+* auto bundle loader
+
+### v0.3.0
+
+* device binding (MAC)
+* per-device license
+
+### v0.4.0
+
+* signed license
+* tamper protection
+
+### v0.5.0
+
+* encrypted license
+* hidden key
+
+---
+
+## Roadmap
+
+Future features:
+
+* multi-device license
+* trial license
+* offline activation
+* hardware fingerprint
+* bulk license generation
+* license revoke
+* metadata bundle
+* verify command
+
+---
+
+## Example
+
+```bash
+inferlock encrypt yolov7.weights --expire 7d
+```
+
+Load:
+
+```python
+load("yolov7.inferlock")
+```

inferlock-0.4.0/README.md

@@ -0,0 +1,185 @@
+# inferlock
+
+Protect AI model files with encryption and license-based runtime loading.
+
+inferlock encrypts model files and loads them securely with expiration-based licenses.
+
+---
+
+## Features
+
+* Model file encryption
+* Runtime in-memory decryption
+* License-based loading
+* Expiration-based license
+* Single-command packaging
+* Bundle-based distribution
+* CLI-first design
+
+---
+
+## Installation
+
+```bash
+pip install inferlock
+```
+
+or local dev:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Quick Start
+
+Encrypt model and create license:
+
+```bash
+inferlock encrypt model.pt --expire 30d
+```
+
+Output:
+
+```
+model.inferlock/
+ ├── model.inferlock
+ └── license.inferlock
+```
+
+Load model:
+
+```python
+from inferlock import load
+
+model = load("model.inferlock")
+```
+
+---
+
+## CLI Usage
+
+Encrypt model:
+
+```bash
+inferlock encrypt model.pt --expire 30d
+```
+
+Generate license manually:
+
+```bash
+inferlock license model.key --expire 30d
+```
+
+Show bundle info:
+
+```bash
+inferlock info model.inferlock
+```
+
+---
+
+## Device Binding
+
+Bind license to machine:
+
+```bash
+inferlock encrypt model.pt --expire 30d --bind-device
+```
+
+The license will be tied to the current machine's MAC address and cannot be used on other devices.
+
+---
+
+## Bundle Structure
+
+```
+model.inferlock/
+ ├── model.inferlock
+ └── license.inferlock
+```
+
+---
+
+## Python API
+
+Load bundle:
+
+```python
+from inferlock import load
+
+model = load("model.inferlock")
+```
+
+Load manually:
+
+```python
+load("model.inferlock", "license.inferlock")
+```
+
+---
+
+## License Format
+
+```json
+{
+  "key": "...",
+  "expire": "YYYY-MM-DD",
+  "version": 1
+}
+```
+
+## Version
+
+### v0.2.0
+
+* license system
+* expiration support
+* bundle packaging
+* single command encrypt + license
+* auto bundle loader
+
+### v0.3.0
+
+* device binding (MAC)
+* per-device license
+
+### v0.4.0
+
+* signed license
+* tamper protection
+
+### v0.5.0
+
+* encrypted license
+* hidden key
+
+---
+
+## Roadmap
+
+Future features:
+
+* multi-device license
+* trial license
+* offline activation
+* hardware fingerprint
+* bulk license generation
+* license revoke
+* metadata bundle
+* verify command
+
+---
+
+## Example
+
+```bash
+inferlock encrypt yolov7.weights --expire 7d
+```
+
+Load:
+
+```python
+load("yolov7.inferlock")
+```

inferlock-0.4.0/inferlock/__init__.py

@@ -0,0 +1,7 @@
+"""InferLock - File encryption and licensing for AI models."""
+
+from .crypto import encrypt_bytes, decrypt_bytes
+from .format import pack_file, unpack_file
+from .loader import load_model as load
+
+__version__ = "0.1.0"

inferlock-0.4.0/inferlock/cli.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+import argparse
+import base64
+import datetime
+import json
+import os
+
+from .crypto import encrypt_bytes
+from .format import pack_file, unpack_file
+from .license import create_license as create_license_bytes, parse_license, get_device_id
+
+
+def parse_expire(expire: str) -> datetime.datetime:
+    """Parse expiration string to datetime."""
+    if expire.endswith('d'):
+        days = int(expire[:-1])
+        return datetime.datetime.now() + datetime.timedelta(days=days)
+    try:
+        return datetime.datetime.strptime(expire, "%Y-%m-%d")
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"Invalid expire format: {expire}")
+
+
+def cmd_encrypt(args):
+    with open(args.input, 'rb') as f:
+        data = f.read()
+
+    # Generate random 32-byte key and base64 encode
+    key_bytes = os.urandom(32)
+    key_b64 = base64.b64encode(key_bytes).decode('utf-8')
+
+    # Encrypt file using the generated key
+    encrypted = encrypt_bytes(data, key_b64)
+
+    header = {
+        "format": "inferlock-v1",
+        "original_name": args.input,
+    }
+    packed = pack_file(header, encrypted)
+
+    # Determine bundle directory name
+    if args.output:
+        bundle_dir = args.output
+    else:
+        base_name = os.path.splitext(args.input)[0]
+        bundle_dir = f"{base_name}.inferlock"
+
+    # Ensure bundle_dir ends with .inferlock
+    if not bundle_dir.endswith(".inferlock"):
+        bundle_dir = f"{bundle_dir}.inferlock"
+
+    os.makedirs(bundle_dir, exist_ok=True)
+
+    # Save encrypted model inside as "model.inferlock"
+    model_path = os.path.join(bundle_dir, "model.inferlock")
+    with open(model_path, 'wb') as f:
+        f.write(packed)
+
+    # Save license inside as "license.inferlock" (if expire provided)
+    if args.expire:
+        device = get_device_id() if args.bind_device else None
+        license_bytes = create_license_bytes(key_b64, args.expire, device)
+        license_path = os.path.join(bundle_dir, args.license_name)
+        with open(license_path, 'wb') as f:
+            f.write(license_bytes)
+        print(f"Encrypted: {args.input} -> {bundle_dir}/")
+        print(f"Files: model.inferlock, {args.license_name}")
+    else:
+        print(f"Encrypted: {args.input} -> {bundle_dir}/model.inferlock")
+
+
+def cmd_license(args):
+    with open(args.keyfile, 'r') as f:
+        key = f.read().strip()
+
+    device = get_device_id() if args.bind_device else None
+    license_bytes = create_license_bytes(key, args.expire, device)
+
+    output = args.output if args.output else "license.inferlock"
+    with open(output, 'wb') as f:
+        f.write(license_bytes)
+
+    print(f"License created: {output}")
+
+
+def print_bundle_info(bundle_path):
+    """Print bundle information."""
+    print(f"Model bundle: {bundle_path}")
+
+    # Check if license.inferlock exists in bundle
+    license_path = os.path.join(bundle_path, "license.inferlock")
+    if os.path.exists(license_path):
+        with open(license_path, 'rb') as f:
+            license_data = f.read()
+
+        license_dict = parse_license(license_data)
+
+        print(f"Expire: {license_dict.get('expire', 'unknown')}")
+        print(f"Version: {license_dict.get('version', 'unknown')}")
+
+        if "device" in license_dict:
+            print("Device bound: yes")
+        else:
+            print("Device bound: no")
+    else:
+        print("No license found")
+
+
+def cmd_info(args):
+    print_bundle_info(args.input)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="InferLock CLI")
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    encrypt_parser = subparsers.add_parser('encrypt', help='Encrypt a file')
+    encrypt_parser.add_argument('input', help='Input file')
+    encrypt_parser.add_argument('--expire', help='Expiration (30d, 7d, 2026-12-01)')
+    encrypt_parser.add_argument('-o', '--output', help='Output file')
+    encrypt_parser.add_argument('--password', help='Password')
+    encrypt_parser.add_argument('--bind-device', action='store_true', help='Bind license to device')
+    encrypt_parser.add_argument('--license-name', default='license.inferlock', help='License filename inside bundle')
+    encrypt_parser.set_defaults(func=cmd_encrypt)
+
+    license_parser = subparsers.add_parser('license', help='Create license')
+    license_parser.add_argument('keyfile', help='Key file (.key)')
+    license_parser.add_argument('--expire', required=True, help='Expiration (30d, 7d, 2026-12-01)')
+    license_parser.add_argument('-o', '--output', help='Output file')
+    license_parser.add_argument('--bind-device', action='store_true', help='Bind license to device')
+    license_parser.set_defaults(func=cmd_license)
+
+    info_parser = subparsers.add_parser('info', help='Show file info')
+    info_parser.add_argument('input', help='Input .inferlock file')
+    info_parser.set_defaults(func=cmd_info)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

inferlock-0.4.0/inferlock/crypto.py

@@ -0,0 +1,61 @@
+import os
+from typing import Tuple
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.backends import default_backend
+
+
+# Constants
+KEY_SIZE = 32  # 256 bits
+SALT_SIZE = 16
+NONCE_SIZE = 12  # 96 bits for GCM
+ITERATIONS = 600_000
+
+
+def _derive_key(password: str, salt: bytes) -> bytes:
+    """Derive a 256-bit key from password using PBKDF2-HMAC-SHA256."""
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=KEY_SIZE,
+        salt=salt,
+        iterations=ITERATIONS,
+        backend=default_backend(),
+    )
+    return kdf.derive(password.encode('utf-8'))
+
+
+def encrypt_bytes(data: bytes, password: str) -> bytes:
+    """
+    Encrypt bytes using AES-256-GCM with password-derived key.
+
+    Returns salt + nonce + ciphertext + tag (16 bytes).
+    """
+    salt = os.urandom(SALT_SIZE)
+    nonce = os.urandom(NONCE_SIZE)
+    key = _derive_key(password, salt)
+
+    aesgcm = AESGCM(key)
+    ciphertext = aesgcm.encrypt(nonce, data, None)
+
+    return salt + nonce + ciphertext
+
+
+def decrypt_bytes(data: bytes, password: str) -> bytes:
+    """
+    Decrypt bytes using AES-256-GCM with password-derived key.
+
+    Expects salt + nonce + ciphertext + tag (16 bytes).
+    """
+    if len(data) < SALT_SIZE + NONCE_SIZE + 16:
+        raise ValueError("Data too short to contain valid encrypted content")
+
+    salt = data[:SALT_SIZE]
+    nonce = data[SALT_SIZE:SALT_SIZE + NONCE_SIZE]
+    ciphertext = data[SALT_SIZE + NONCE_SIZE:]
+
+    key = _derive_key(password, salt)
+
+    aesgcm = AESGCM(key)
+    return aesgcm.decrypt(nonce, ciphertext, None)

inferlock-0.4.0/inferlock/format.py

@@ -0,0 +1,31 @@
+import json
+from typing import Tuple
+
+DELIMITER = b"INFERLOCK"
+
+
+def pack_file(header: dict, data: bytes) -> bytes:
+    """
+    Pack a file with JSON header + delimiter + data.
+
+    Format: header_json + b"INFERLOCK" + data
+    """
+    header_bytes = json.dumps(header).encode('utf-8')
+    return header_bytes + DELIMITER + data
+
+
+def unpack_file(file_bytes: bytes) -> Tuple[dict, bytes]:
+    """
+    Unpack a file into header dict and data bytes.
+
+    Expects: header_json + b"INFERLOCK" + data
+    """
+    delimiter_pos = file_bytes.find(DELIMITER)
+    if delimiter_pos == -1:
+        raise ValueError("Missing delimiter in file data")
+
+    header_bytes = file_bytes[:delimiter_pos]
+    header = json.loads(header_bytes.decode('utf-8'))
+    encrypted_bytes = file_bytes[delimiter_pos + len(DELIMITER):]
+
+    return header, encrypted_bytes

inferlock-0.4.0/inferlock/license.py

@@ -0,0 +1,199 @@
+import base64
+import hashlib
+import json
+import uuid
+from datetime import datetime, timedelta
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives import serialization
+
+_PK = "..."  # Base64 encoded Ed25519 public key
+
+
+def _parse_expire(expire: str) -> datetime:
+    """Parse expiration string to datetime."""
+    if expire.endswith('d'):
+        days = int(expire[:-1])
+        return datetime.now() + timedelta(days=days)
+    try:
+        return datetime.strptime(expire, "%Y-%m-%d")
+    except ValueError:
+        raise ValueError(f"Invalid expire format: {expire}")
+
+
+def create_license(key: str, expire: str, device: str = None, private_key: str = None) -> bytes:
+    """
+    Create license bytes.
+
+    Args:
+        key: License key string
+        expire: Expiration string (30d, 7d, YYYY-MM-DD)
+        device: Optional device ID to bind license
+        private_key: Base64 encoded private key for signing (optional)
+
+    Returns:
+        JSON license bytes with optional signature
+    """
+    expire_dt = _parse_expire(expire)
+
+    license_data = {
+        "key": key,
+        "expire": expire_dt.strftime("%Y-%m-%d"),
+        "version": 1,
+    }
+
+    if device:
+        license_data["device"] = device
+
+    if private_key:
+        license_json = json.dumps(license_data).encode('utf-8')
+        signature = sign_data(private_key, license_json)
+        return json.dumps({
+            "data": license_data,
+            "signature": signature
+        }).encode('utf-8')
+
+    return json.dumps(license_data).encode('utf-8')
+
+
+def parse_license(data: bytes) -> dict:
+    """
+    Parse license bytes to dict.
+
+    Args:
+        data: License bytes
+
+    Returns:
+        License dictionary (handles both old and new formats)
+    """
+    parsed = json.loads(data.decode('utf-8'))
+
+    # New format with signature
+    if "data" in parsed:
+        return parsed["data"]
+
+    # Old format (backward compatible)
+    return parsed
+
+
+def _v(data: bytes) -> dict:
+    """
+    Verify license signature and return license data.
+
+    Args:
+        data: License bytes
+
+    Returns:
+        License dictionary
+
+    Raises:
+        Exception: Invalid license signature
+    """
+    parsed = json.loads(data.decode('utf-8'))
+
+    # New format with signature
+    if "signature" in parsed:
+        license_data = "data" in parsed and parsed["data"] or parsed
+        license_json = json.dumps(license_data).encode('utf-8')
+
+        if not verify_signature(_PK, license_json, parsed["signature"]):
+            raise Exception("Invalid license signature")
+
+        return license_data
+
+    # Old format (backward compatible)
+    return parsed
+
+
+def is_expired(license_dict: dict) -> bool:
+    """
+    Check if license is expired.
+
+    Args:
+        license_dict: License dictionary
+
+    Returns:
+        True if expired, False otherwise
+    """
+    expire_at = datetime.strptime(license_dict["expire"], "%Y-%m-%d")
+    return datetime.now() >= expire_at
+
+
+def get_device_id() -> str:
+    """
+    Get unique device identifier.
+
+    Returns:
+        Hex string of hashed MAC address
+    """
+    mac = uuid.getnode()
+    hashed = hashlib.sha256(str(mac).encode()).hexdigest()
+    return hashed
+
+
+def generate_keypair() -> tuple[str, str]:
+    """
+    Generate Ed25519 keypair.
+
+    Returns:
+        Tuple of (private_key_b64, public_key_b64) as base64 strings
+    """
+    private_key = ed25519.Ed25519PrivateKey.generate()
+    public_key = private_key.public_key()
+
+    private_bytes = private_key.private_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PrivateFormat.Raw,
+        encryption_algorithm=serialization.NoEncryption()
+    )
+
+    public_bytes = public_key.public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw
+    )
+
+    return (
+        base64.b64encode(private_bytes).decode('utf-8'),
+        base64.b64encode(public_bytes).decode('utf-8')
+    )
+
+
+def sign_data(private_key: str, data_bytes: bytes) -> str:
+    """
+    Sign data bytes with Ed25519 private key.
+
+    Args:
+        private_key: Base64 encoded private key
+        data_bytes: Data to sign
+
+    Returns:
+        Base64 encoded signature
+    """
+    private_bytes = base64.b64decode(private_key)
+    private_key_obj = ed25519.Ed25519PrivateKey.from_private_bytes(private_bytes)
+
+    signature = private_key_obj.sign(data_bytes)
+    return base64.b64encode(signature).decode('utf-8')
+
+
+def verify_signature(public_key: str, data_bytes: bytes, signature: str) -> bool:
+    """
+    Verify signature with Ed25519 public key.
+
+    Args:
+        public_key: Base64 encoded public key
+        data_bytes: Original data
+        signature: Base64 encoded signature
+
+    Returns:
+        True if signature is valid, False otherwise
+    """
+    public_bytes = base64.b64decode(public_key)
+    public_key_obj = ed25519.Ed25519PublicKey.from_public_bytes(public_bytes)
+
+    signature_bytes = base64.b64decode(signature)
+
+    try:
+        public_key_obj.verify(signature_bytes, data_bytes)
+        return True
+    except Exception:
+        return False

inferlock-0.4.0/inferlock/loader.py

@@ -0,0 +1,67 @@
+import io
+import os
+
+from .crypto import decrypt_bytes
+from .format import unpack_file
+from .license import _v, is_expired, get_device_id
+
+
+def load_model(path: str, license: str = None):
+    """
+    Load a model from an encrypted .inferlock file or bundle directory.
+
+    Args:
+        path: Path to .inferlock file or bundle directory
+        license: Path to license.inferlock file (required if path is file)
+
+    Returns:
+        Loaded model object
+    """
+    # Handle bundle directory
+    if os.path.isdir(path):
+        model_path = os.path.join(path, "model.inferlock")
+        license_path = os.path.join(path, "license.inferlock")
+    else:
+        # Handle file path
+        if not license:
+            raise Exception("License required")
+        model_path = path
+        license_path = license
+
+    # Read and parse license
+    with open(license_path, 'rb') as f:
+        license_data = f.read()
+
+    try:
+        license_dict = _v(license_data)
+    except Exception:
+        raise Exception("License validation failed")
+
+    # Check expiration
+    if is_expired(license_dict):
+        raise Exception("License validation failed")
+
+    # Check device binding
+    if "device" in license_dict:
+        current_device = get_device_id()
+        if current_device != license_dict["device"]:
+            raise Exception("License validation failed")
+
+    # Extract key from license
+    key = license_dict["key"]
+
+    # Read and decrypt model
+    with open(model_path, 'rb') as f:
+        file_bytes = f.read()
+
+    header, encrypted = unpack_file(file_bytes)
+    decrypted = decrypt_bytes(encrypted, key)
+
+    original_name = header.get("original_name", "")
+
+    if original_name.endswith(".pt"):
+        import torch
+        return torch.load(io.BytesIO(decrypted))
+
+    # Default: return bytes for other formats
+    return decrypted

inferlock-0.4.0/inferlock.egg-info/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: inferlock
+Version: 0.4.0
+Summary: File encryption and licensing for AI models
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+
+# inferlock
+
+Protect AI model files with encryption and license-based runtime loading.
+
+inferlock encrypts model files and loads them securely with expiration-based licenses.
+
+---
+
+## Features
+
+* Model file encryption
+* Runtime in-memory decryption
+* License-based loading
+* Expiration-based license
+* Single-command packaging
+* Bundle-based distribution
+* CLI-first design
+
+---
+
+## Installation
+
+```bash
+pip install inferlock
+```
+
+or local dev:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Quick Start
+
+Encrypt model and create license:
+
+```bash
+inferlock encrypt model.pt --expire 30d
+```
+
+Output:
+
+```
+model.inferlock/
+ ├── model.inferlock
+ └── license.inferlock
+```
+
+Load model:
+
+```python
+from inferlock import load
+
+model = load("model.inferlock")
+```
+
+---
+
+## CLI Usage
+
+Encrypt model:
+
+```bash
+inferlock encrypt model.pt --expire 30d
+```
+
+Generate license manually:
+
+```bash
+inferlock license model.key --expire 30d
+```
+
+Show bundle info:
+
+```bash
+inferlock info model.inferlock
+```
+
+---
+
+## Device Binding
+
+Bind license to machine:
+
+```bash
+inferlock encrypt model.pt --expire 30d --bind-device
+```
+
+The license will be tied to the current machine's MAC address and cannot be used on other devices.
+
+---
+
+## Bundle Structure
+
+```
+model.inferlock/
+ ├── model.inferlock
+ └── license.inferlock
+```
+
+---
+
+## Python API
+
+Load bundle:
+
+```python
+from inferlock import load
+
+model = load("model.inferlock")
+```
+
+Load manually:
+
+```python
+load("model.inferlock", "license.inferlock")
+```
+
+---
+
+## License Format
+
+```json
+{
+  "key": "...",
+  "expire": "YYYY-MM-DD",
+  "version": 1
+}
+```
+
+## Version
+
+### v0.2.0
+
+* license system
+* expiration support
+* bundle packaging
+* single command encrypt + license
+* auto bundle loader
+
+### v0.3.0
+
+* device binding (MAC)
+* per-device license
+
+### v0.4.0
+
+* signed license
+* tamper protection
+
+### v0.5.0
+
+* encrypted license
+* hidden key
+
+---
+
+## Roadmap
+
+Future features:
+
+* multi-device license
+* trial license
+* offline activation
+* hardware fingerprint
+* bulk license generation
+* license revoke
+* metadata bundle
+* verify command
+
+---
+
+## Example
+
+```bash
+inferlock encrypt yolov7.weights --expire 7d
+```
+
+Load:
+
+```python
+load("yolov7.inferlock")
+```

inferlock-0.4.0/inferlock.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+inferlock/__init__.py
+inferlock/cli.py
+inferlock/crypto.py
+inferlock/format.py
+inferlock/license.py
+inferlock/loader.py
+inferlock.egg-info/PKG-INFO
+inferlock.egg-info/SOURCES.txt
+inferlock.egg-info/dependency_links.txt
+inferlock.egg-info/entry_points.txt
+inferlock.egg-info/requires.txt
+inferlock.egg-info/top_level.txt

inferlock-0.4.0/inferlock.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

inferlock-0.4.0/inferlock.egg-info/entry_points.txt

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

inferlock-0.4.0/inferlock.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography

inferlock-0.4.0/inferlock.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+dist
+inferlock
+log-model
+venv

inferlock-0.4.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "inferlock"
+version = "0.4.0"
+description = "File encryption and licensing for AI models"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "cryptography",
+]
+
+[project.scripts]
+inferlock = "inferlock.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

inferlock-0.4.0/setup.cfg

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