qlam 2.0.0__py3-none-any.whl

qlam-2.0.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: qlam
+Version: 2.0.0
+Summary: Python SDK for Qalam Document Format (.qlm)
+Author: Antigravity
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-python
+Dynamic: summary

qlam-2.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+qlam.py,sha256=ev4OsHnuJrlkF26OtRNPLi2fcejBBcLashBl1MTusCA,6384
+qlam-2.0.0.dist-info/METADATA,sha256=RBxdHfE6iPieXyyKissV-_BPkFQrBCA6eStelKM8178,381
+qlam-2.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+qlam-2.0.0.dist-info/top_level.txt,sha256=6cRi9EdJrS0LfziPMrmuAjl-5JJpqV7eWey0Gvcr84Y,5
+qlam-2.0.0.dist-info/RECORD,,

qlam-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qlam-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qlam

qlam.py

@@ -0,0 +1,180 @@
+import json
+import os
+import struct
+
+class QlmNode:
+    """Represents a structured node block in a QLM document."""
+    def __init__(self, node_type, title, data=None, parent_id=None, asset_bytes=None, display_style=None):
+        self.id = f"node_{os.urandom(8).hex()}"
+        self.parent_id = parent_id
+        self.type = node_type  # text, model3d, image, docx, zip, pdf, etc.
+        self.title = title
+        self.data = data or {}
+        self.display_style = display_style or {"width_ratio": 1.0, "collapsed": False}
+        self.asset_bytes = asset_bytes
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "parent_id": self.parent_id,
+            "type": self.type,
+            "title": self.title,
+            "data": self.data,
+            "display_style": self.display_style
+        }
+
+class QlmDocument:
+    """Core class for compiling and reading unified .qlm files in Python."""
+    def __init__(self, title, author="Anonim"):
+        self.id = f"doc_{os.urandom(8).hex()}"
+        self.metadata = {
+            "title": title,
+            "author": author,
+            "description": "",
+            "language": "tr",
+            "created_at": 0,
+            "version": "2.0.0",
+            "is_encrypted": False,
+            "tags": []
+        }
+        self.nodes = []
+        self.relationships = []
+
+    def add_text(self, title, content, level=3, parent_id=None):
+        node = QlmNode(
+            node_type="text",
+            title=title,
+            data={"content": content, "level": level},
+            parent_id=parent_id
+        )
+        self.nodes.append(node)
+        return node
+
+    def add_embed(self, node_type, title, asset_path, mime_type, parent_id=None):
+        """Embeds any binary file (3D, docx, zip, image, mp4) to the document."""
+        if not os.path.exists(asset_path):
+            raise FileNotFoundError(f"Asset file not found: {asset_path}")
+        
+        with open(asset_path, "rb") as f:
+            data_bytes = f.read()
+
+        node = QlmNode(
+            node_type=node_type,
+            title=title,
+            data={"mime": mime_type, "asset_length": len(data_bytes)},
+            parent_id=parent_id,
+            asset_bytes=data_bytes
+        )
+        self.nodes.append(node)
+        return node
+
+    def compile(self, output_path):
+        """Compiles the document into a high performance manifest-indexed binary QLM document."""
+        buffer = bytearray()
+        
+        # 1. Header (14 bytes)
+        buffer.extend(b"QLAM")
+        # Version (2 bytes) = 2 (u16 little endian)
+        buffer.extend(struct.pack("<H", 2))
+        # Manifest Offset Placeholder (8 bytes, updated at end)
+        manifest_offset_pos = len(buffer)
+        buffer.extend(struct.pack("<Q", 0))
+
+        # 2. Write binary payloads and update node manifests
+        nodes_dict = []
+        for node in self.nodes:
+            node_dict = node.to_dict()
+            if node.asset_bytes:
+                start_byte = len(buffer)
+                buffer.extend(node.asset_bytes)
+                
+                # Update json manifest offsets
+                node_dict["data"]["asset_start_byte"] = start_byte
+                node_dict["data"]["asset_length"] = len(node.asset_bytes)
+
+                # 8-byte alignment padding
+                padding = (8 - (len(buffer) % 8)) % 8
+                buffer.extend(b"\x00" * padding)
+                
+            nodes_dict.append(node_dict)
+
+        # 3. Calculate final manifest offset and write manifest JSON
+        manifest_offset = len(buffer)
+        
+        manifest_doc = {
+            "id": self.id,
+            "metadata": self.metadata,
+            "nodes": nodes_dict,
+            "relationships": self.relationships
+        }
+        
+        manifest_json = json.dumps(manifest_doc).encode("utf-8")
+        buffer.extend(manifest_json)
+
+        # 4. Fill in the header manifest offset
+        struct.pack_into("<Q", buffer, manifest_offset_pos, manifest_offset)
+
+        # 5. Write to file
+        with open(output_path, "wb") as f:
+            f.write(buffer)
+
+        print(f"[QLM] Compiled '{self.metadata['title']}' to {output_path} ({len(buffer)} bytes)")
+
+    @classmethod
+    def load(cls, file_path):
+        """Loads and parses a .qlm document into a Python object."""
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"QLM file not found: {file_path}")
+
+        with open(file_path, "rb") as f:
+            data = f.read()
+
+        if len(data) < 14:
+            raise ValueError("Invalid QLM file: too short")
+
+        # Read magic & version
+        magic = data[0:4]
+        if magic != b"QLAM":
+            raise ValueError(f"Invalid QLM signature: {magic}")
+
+        version = struct.unpack("<H", data[4:6])[0]
+        if version != 2:
+            raise ValueError(f"Unsupported QLM version: {version}")
+
+        # Read manifest offset
+        manifest_offset = struct.unpack("<Q", data[6:14])[0]
+        if manifest_offset >= len(data):
+            raise ValueError("Invalid manifest offset")
+
+        # Parse JSON manifest
+        manifest_json = data[manifest_offset:].decode("utf-8")
+        doc_dict = json.loads(manifest_json)
+
+        # Construct Python QlmDocument instance
+        doc = cls(title=doc_dict["metadata"]["title"])
+        doc.id = doc_dict["id"]
+        doc.metadata = doc_dict["metadata"]
+        doc.relationships = doc_dict.get("relationships", [])
+
+        # Build node tree models and attach internal asset slices
+        for node_dict in doc_dict.get("nodes", []):
+            asset_bytes = None
+            if "asset_start_byte" in node_dict["data"]:
+                start = node_dict["data"]["asset_start_byte"]
+                length = node_dict["data"]["asset_length"]
+                if start + length <= len(data):
+                    # Zero-copy reference slicing of binary file payload
+                    asset_bytes = data[start:start+length]
+
+            node = QlmNode(
+                node_type=node_dict["type"],
+                title=node_dict["title"],
+                data=node_dict["data"],
+                parent_id=node_dict.get("parent_id"),
+                asset_bytes=asset_bytes,
+                display_style=node_dict.get("display_style")
+            )
+            node.id = node_dict["id"]
+            doc.nodes.append(node)
+
+        return doc