pineapple-apple 0.1.0__py3-none-any.whl

apple/__init__.py

@@ -0,0 +1,5 @@
+# Apple DSL — Python pipeline declaration for Pineapple
+from apple._version import __version__
+from apple.flow import Flow, SubFlow
+
+__all__ = ["Flow", "SubFlow", "__version__"]

apple/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

apple/base.py

@@ -0,0 +1,94 @@
+"""Base operator class for Apple DSL.
+
+All generated operator classes inherit from BaseOp. The _apply method records
+operator invocations for later compilation to JSON.
+"""
+from __future__ import annotations
+
+import hashlib
+import inspect
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class OpCall:
+    """Record of a single operator invocation in a flow."""
+    type_name: str
+    params: dict[str, Any]
+    common_input: list[str] = field(default_factory=list)
+    common_output: list[str] = field(default_factory=list)
+    item_input: list[str] = field(default_factory=list)
+    item_output: list[str] = field(default_factory=list)
+    item_defaults: dict[str, Any] | None = None
+    common_defaults: dict[str, Any] | None = None
+    # Engine-level flags
+    recall: bool = False
+    sources: list[str] | None = None
+    skip: str | None = None
+    for_branch_control: bool = False
+    debug: bool = False
+    # Debug info
+    code_info: str = ""
+    # Explicit name (overrides auto-generated name)
+    name: str = ""
+
+    def unique_name(self) -> str:
+        """Return explicit name if set, otherwise generate type_name_HASH6."""
+        if self.name:
+            return self.name
+        h = hashlib.md5(repr(self).encode()).hexdigest()[:6].upper()
+        return f"{self.type_name}_{h}"
+
+
+class BaseOp:
+    """Base class for all operator types in the Apple DSL.
+
+    Subclasses define _name and _params_schema. The __call__ method delegates
+    to _apply, which records the call into the owning flow.
+    """
+    _name: str = ""
+    _params_schema: dict[str, Any] = {}
+
+    def __init__(self, flow: Any):
+        self._flow = flow
+
+    def _apply(
+        self,
+        params: dict[str, Any],
+        common_input: list[str] | None = None,
+        common_output: list[str] | None = None,
+        item_input: list[str] | None = None,
+        item_output: list[str] | None = None,
+        item_defaults: dict[str, Any] | None = None,
+        common_defaults: dict[str, Any] | None = None,
+        recall: bool = False,
+        sources: list[str] | None = None,
+        debug: bool = False,
+        name: str = "",
+    ) -> Any:
+        # Capture caller location for $code_info
+        code_info = ""
+        try:
+            frame = inspect.stack()[1]
+            code_info = f"{frame.filename}:{frame.lineno} in {frame.function}(): .{self._name}(...)"
+        except (IndexError, AttributeError):
+            pass
+
+        call = OpCall(
+            type_name=self._name,
+            params=params,
+            common_input=common_input or [],
+            common_output=common_output or [],
+            item_input=item_input or [],
+            item_output=item_output or [],
+            item_defaults=item_defaults,
+            common_defaults=common_defaults,
+            recall=recall,
+            sources=sources,
+            debug=debug,
+            code_info=code_info,
+            name=name,
+        )
+        self._flow._ops.append(call)
+        return self._flow

apple/compiler.py

@@ -0,0 +1,177 @@
+"""Compile a Flow into the Pine JSON config format.
+
+Steps:
+1. Flatten sub_flows into single operator sequence
+2. Lower control flow (if_/elseif_/else_/end_if_) to Lua operators + skip fields
+3. Auto-generate unique operator names: {type_name}_{hash6}
+4. Validate field coverage and write-without-read
+5. Dead-code detection (if output contract declared)
+6. Emit JSON with pipeline_config, pipeline_group, flow_contract
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from apple.base import OpCall
+from apple._version import __version__
+from apple.validator import (
+    ValidationError,
+    detect_dead_code,
+    validate_field_coverage,
+    validate_write_without_read,
+)
+
+
+def compile_flow(flow: Any) -> dict[str, Any]:
+    """Compile a Flow object into a Pine JSON config dict."""
+    # 1. Flatten ops from flow + sub_flows
+    all_ops: list[OpCall] = []
+    sub_flow_boundaries: dict[str, list[int]] = {}  # name -> [start, end)
+
+    if flow._sub_flows:
+        for sf in flow._sub_flows:
+            start = len(all_ops)
+            all_ops.extend(sf._ops)
+            sub_flow_boundaries[sf._name] = [start, len(all_ops)]
+    if flow._ops:
+        start = len(all_ops)
+        all_ops.extend(flow._ops)
+        sub_flow_boundaries[f"_main_{flow._name}"] = [start, len(all_ops)]
+
+    # 2. Generate unique names
+    named_ops: list[tuple[str, OpCall]] = []
+    name_counts: dict[str, int] = {}
+    for op in all_ops:
+        name = op.unique_name()
+        if op.name:
+            # Explicit name — must be unique
+            if name in name_counts:
+                raise ValidationError(
+                    f"duplicate explicit operator name: {name!r}"
+                )
+        if name in name_counts:
+            name_counts[name] += 1
+            name = f"{name}_{name_counts[name]}"
+        else:
+            name_counts[name] = 0
+        named_ops.append((name, op))
+
+    # 3. Validate
+    validate_field_coverage(
+        named_ops,
+        flow._common_input or [],
+        flow._item_input or [],
+    )
+    validate_write_without_read(
+        named_ops,
+        flow._common_input or [],
+        flow._item_input or [],
+    )
+    dead = detect_dead_code(
+        named_ops,
+        flow._common_output,
+        flow._item_output,
+    )
+    if dead:
+        raise ValidationError(
+            f"dead operators detected (output not consumed): {dead}"
+        )
+
+    # 4. Build operators dict
+    operators: dict[str, Any] = {}
+    for name, op in named_ops:
+        entry: dict[str, Any] = {
+            "type_name": op.type_name,
+            "$metadata": {
+                "common_input": op.common_input,
+                "common_output": op.common_output,
+                "item_input": op.item_input,
+                "item_output": op.item_output,
+            },
+        }
+        if op.code_info:
+            entry["$code_info"] = op.code_info
+        if op.recall:
+            entry["recall"] = True
+        if op.sources:
+            entry["sources"] = [
+                _resolve_source(op.sources, named_ops, s)
+                for s in op.sources
+            ]
+        if op.skip:
+            entry["skip"] = op.skip
+        if op.for_branch_control:
+            entry["for_branch_control"] = True
+        if op.item_defaults:
+            entry["item_defaults"] = op.item_defaults
+        if op.common_defaults:
+            entry["common_defaults"] = op.common_defaults
+        if op.debug:
+            entry["debug"] = True
+        # Business params
+        for k, v in op.params.items():
+            entry[k] = v
+        operators[name] = entry
+
+    # 5. Build pipeline_map
+    pipeline_map: dict[str, Any] = {}
+    for sf_name, (start, end) in sub_flow_boundaries.items():
+        pipeline_map[sf_name] = {
+            "pipeline": [named_ops[i][0] for i in range(start, end)]
+        }
+
+    # 6. Build pipeline_group
+    pipeline_group = {
+        "main": {
+            "pipeline": list(pipeline_map.keys())
+        }
+    }
+
+    # 7. Build flow_contract
+    flow_contract: dict[str, Any] = {
+        "common_input": flow._common_input or [],
+        "item_input": flow._item_input or [],
+    }
+    if flow._common_output is not None:
+        flow_contract["common_output"] = flow._common_output
+    else:
+        flow_contract["common_output"] = []
+    if flow._item_output is not None:
+        flow_contract["item_output"] = flow._item_output
+    else:
+        flow_contract["item_output"] = []
+
+    return {
+        "_PINEAPPLE_VERSION": __version__,
+        "_PINEAPPLE_CREATE_TIME": datetime.now(timezone.utc).strftime(
+            "%Y-%m-%dT%H:%M:%SZ"
+        ),
+        "pipeline_config": {
+            "operators": operators,
+            "pipeline_map": pipeline_map,
+        },
+        "pipeline_group": pipeline_group,
+        "flow_contract": flow_contract,
+    }
+
+
+def compile_to_json(flow: Any, indent: int = 2) -> str:
+    """Compile a Flow and return the JSON string."""
+    return json.dumps(compile_flow(flow), indent=indent, ensure_ascii=False)
+
+
+def _resolve_source(
+    source_refs: list[str],
+    named_ops: list[tuple[str, OpCall]],
+    source_type_hint: str,
+) -> str:
+    """Resolve a source reference to the actual named operator.
+
+    Sources in the DSL reference operator type names. We find the matching
+    named operator. If ambiguous, error.
+    """
+    # Source refs are already resolved operator names from the flow
+    # (they get resolved during flow.merge_dedup call which passes recall names)
+    return source_type_hint

apple/control.py

@@ -0,0 +1,91 @@
+"""Control flow constructs for Apple DSL.
+
+Provides if_ / elseif_ / else_ / end_if_ that compile to Lua control
+operators + skip fields, per design_doc/06_json_config.md.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+from apple.base import OpCall
+
+
+@dataclass
+class ControlBlock:
+    """Tracks state for one if/elseif/else/end_if block."""
+    block_id: int  # unique across the flow
+    branches: list[ControlBranch] = field(default_factory=list)
+    closed: bool = False
+
+
+@dataclass
+class ControlBranch:
+    """One branch (if / elseif / else) within a ControlBlock."""
+    kind: str  # "if", "elseif", "else"
+    condition: str | None  # Lua condition string, None for else
+    ctrl_field: str  # e.g. "_if_1", "_elif_2", "_else_3"
+    ctrl_index: int  # global control op counter
+
+
+def extract_fields(condition: str) -> list[str]:
+    """Extract field names referenced in a Lua condition.
+
+    Identifies identifiers that look like common field names (not Lua keywords
+    or literals). Simple heuristic: word tokens that aren't Lua reserved words.
+    """
+    lua_keywords = {
+        "and", "break", "do", "else", "elseif", "end", "false", "for",
+        "function", "goto", "if", "in", "local", "nil", "not", "or",
+        "repeat", "return", "then", "true", "until", "while",
+        "math", "string", "table", "io", "os", "type", "tostring",
+        "tonumber", "print", "pairs", "ipairs", "next", "select",
+        "unpack", "pcall", "xpcall", "error", "assert",
+    }
+    tokens = re.findall(r"[a-zA-Z_]\w*", condition)
+    return list(dict.fromkeys(t for t in tokens if t not in lua_keywords))
+
+
+def make_control_op(
+    branch: ControlBranch,
+    prior_ctrl_fields: list[str],
+    condition: str | None,
+) -> OpCall:
+    """Build the Lua OpCall for a control branch."""
+    common_input = list(prior_ctrl_fields)
+    if condition:
+        common_input.extend(extract_fields(condition))
+    # Deduplicate while preserving order
+    seen: set[str] = set()
+    deduped: list[str] = []
+    for f in common_input:
+        if f not in seen:
+            seen.add(f)
+            deduped.append(f)
+    common_input = deduped
+
+    # Build Lua script
+    if branch.kind == "if":
+        lua_body = f"if ({condition}) then return false else return true end"
+    elif branch.kind == "elseif":
+        prior_check = " and ".join(f"({f} == true)" for f in prior_ctrl_fields)
+        lua_body = f"if ({prior_check}) and ({condition}) then return false else return true end"
+    else:  # else
+        prior_check = " and ".join(f"({f} == true)" for f in prior_ctrl_fields)
+        lua_body = f"if ({prior_check}) then return false else return true end"
+
+    lua_script = f"function evaluate() {lua_body} end"
+
+    return OpCall(
+        type_name="transform_by_lua",
+        params={
+            "lua_script": lua_script,
+            "function_for_item": "",
+            "function_for_common": "evaluate",
+        },
+        common_input=common_input,
+        common_output=[branch.ctrl_field],
+        for_branch_control=True,
+        code_info=f"[{branch.kind}] {condition or ''}",
+    )

apple/flow.py

@@ -0,0 +1,236 @@
+"""Flow and SubFlow classes for Apple DSL pipeline declaration.
+
+Usage:
+    flow = Flow(
+        name="example",
+        common_input=["user_id", "user_age"],
+        item_output=["item_score"],
+    )
+    flow.recall_static(
+        item_output=["item_id", "item_score"],
+        items=[{"item_id": "a", "item_score": 1.0}],
+    )
+    flow.filter_condition(
+        item_input=["item_status"],
+        field="item_status", value="offline",
+    )
+    json_config = flow.compile()
+"""
+from __future__ import annotations
+
+import inspect
+import sys
+from typing import Any
+
+from apple.base import BaseOp, OpCall
+from apple.compiler import compile_flow, compile_to_json
+from apple.control import (
+    ControlBlock,
+    ControlBranch,
+    extract_fields,
+    make_control_op,
+)
+
+
+def _capture_code_info(type_name: str, stack_depth: int = 2) -> str:
+    """Capture the caller's source location for $code_info.
+
+    Walks up the call stack to find the first frame outside apple/ package,
+    which is the user's DSL code.
+    """
+    try:
+        frame = inspect.stack()[stack_depth]
+        filename = frame.filename
+        lineno = frame.lineno
+        func_name = frame.function
+        return f"{filename}:{lineno} in {func_name}(): .{type_name}(...)"
+    except (IndexError, AttributeError):
+        return ""
+
+
+class _FlowBase:
+    """Shared chaining logic for Flow and SubFlow."""
+
+    def __init__(self, name: str):
+        self._name = name
+        self._ops: list[OpCall] = []
+        # Control flow state
+        self._ctrl_counter = 0
+        self._ctrl_stack: list[ControlBlock] = []
+
+    def __getattr__(self, name: str) -> Any:
+        """Dynamic operator dispatch: flow.some_op(...) creates an OpCall."""
+        if name.startswith("_"):
+            raise AttributeError(name)
+
+        def op_caller(**kwargs: Any) -> _FlowBase:
+            return self._add_op(name, **kwargs)
+
+        return op_caller
+
+    def _add_op(self, type_name: str, **kwargs: Any) -> _FlowBase:
+        """Record an operator call."""
+        # Capture caller location for $code_info
+        code_info = _capture_code_info(type_name)
+
+        # Separate metadata kwargs from business params
+        meta_keys = {
+            "name", "common_input", "common_output", "item_input", "item_output",
+            "item_defaults", "common_defaults", "sources", "debug",
+        }
+        meta = {}
+        params = {}
+        for k, v in kwargs.items():
+            if k in meta_keys:
+                meta[k] = v
+            elif k == "recall":
+                # Accept but ignore — recall is now type-driven from prefix
+                pass
+            else:
+                params[k] = v
+
+        # Recall is inferred from operator name prefix, not user-passed
+        is_recall = type_name.startswith("recall_")
+
+        call = OpCall(
+            type_name=type_name,
+            params=params,
+            common_input=meta.get("common_input", []),
+            common_output=meta.get("common_output", []),
+            item_input=meta.get("item_input", []),
+            item_output=meta.get("item_output", []),
+            item_defaults=meta.get("item_defaults"),
+            common_defaults=meta.get("common_defaults"),
+            recall=is_recall,
+            sources=meta.get("sources"),
+            debug=meta.get("debug", False),
+            code_info=code_info,
+            name=meta.get("name", ""),
+        )
+
+        # Apply skip field if inside a control block
+        if self._ctrl_stack:
+            block = self._ctrl_stack[-1]
+            if block.branches:
+                branch = block.branches[-1]
+                call.skip = branch.ctrl_field
+                if branch.ctrl_field not in call.common_input:
+                    call.common_input = [branch.ctrl_field] + call.common_input
+
+        self._ops.append(call)
+        return self
+
+    # --- Control flow ---
+
+    def if_(self, condition: str) -> _FlowBase:
+        """Start an if block."""
+        self._ctrl_counter += 1
+        block = ControlBlock(block_id=self._ctrl_counter)
+        ctrl_field = f"_if_{block.block_id}"
+
+        branch = ControlBranch(
+            kind="if",
+            condition=condition,
+            ctrl_field=ctrl_field,
+            ctrl_index=self._ctrl_counter,
+        )
+        block.branches.append(branch)
+        self._ctrl_stack.append(block)
+
+        # Emit the control operator
+        ctrl_op = make_control_op(branch, [], condition)
+        self._ops.append(ctrl_op)
+        return self
+
+    def elseif_(self, condition: str) -> _FlowBase:
+        """Add an elseif branch."""
+        if not self._ctrl_stack:
+            raise ValueError("elseif_ without matching if_")
+        block = self._ctrl_stack[-1]
+        if block.closed:
+            raise ValueError("elseif_ after end_if_")
+
+        self._ctrl_counter += 1
+        prior_fields = [b.ctrl_field for b in block.branches]
+        ctrl_field = f"_elif_{self._ctrl_counter}"
+
+        branch = ControlBranch(
+            kind="elseif",
+            condition=condition,
+            ctrl_field=ctrl_field,
+            ctrl_index=self._ctrl_counter,
+        )
+        block.branches.append(branch)
+
+        ctrl_op = make_control_op(branch, prior_fields, condition)
+        self._ops.append(ctrl_op)
+        return self
+
+    def else_(self) -> _FlowBase:
+        """Add an else branch."""
+        if not self._ctrl_stack:
+            raise ValueError("else_ without matching if_")
+        block = self._ctrl_stack[-1]
+        if block.closed:
+            raise ValueError("else_ after end_if_")
+
+        self._ctrl_counter += 1
+        prior_fields = [b.ctrl_field for b in block.branches]
+        ctrl_field = f"_else_{self._ctrl_counter}"
+
+        branch = ControlBranch(
+            kind="else",
+            condition=None,
+            ctrl_field=ctrl_field,
+            ctrl_index=self._ctrl_counter,
+        )
+        block.branches.append(branch)
+
+        ctrl_op = make_control_op(branch, prior_fields, None)
+        self._ops.append(ctrl_op)
+        return self
+
+    def end_if_(self) -> _FlowBase:
+        """Close the current if block."""
+        if not self._ctrl_stack:
+            raise ValueError("end_if_ without matching if_")
+        block = self._ctrl_stack.pop()
+        block.closed = True
+        return self
+
+
+class SubFlow(_FlowBase):
+    """A reusable fragment of operator declarations.
+
+    SubFlows don't declare input/output contracts — that's done at the
+    top-level Flow.
+    """
+    pass
+
+
+class Flow(_FlowBase):
+    """A complete pipeline declaration with input/output contract."""
+
+    def __init__(
+        self,
+        name: str,
+        common_input: list[str] | None = None,
+        item_input: list[str] | None = None,
+        common_output: list[str] | None = None,
+        item_output: list[str] | None = None,
+        sub_flows: list[SubFlow] | None = None,
+    ):
+        super().__init__(name)
+        self._common_input = common_input or []
+        self._item_input = item_input or []
+        self._common_output = common_output
+        self._item_output = item_output
+        self._sub_flows = sub_flows or []
+
+    def compile(self) -> str:
+        """Compile this flow to a JSON config string."""
+        return compile_to_json(self)
+
+    def compile_dict(self) -> dict[str, Any]:
+        """Compile this flow to a JSON config dict."""
+        return compile_flow(self)

apple/validator.py

@@ -0,0 +1,129 @@
+"""DSL-side validation for Apple flows.
+
+Checks:
+1. Field coverage: every operator input must come from flow contract or upstream output.
+2. Write-without-read: writing a field that already exists without reading it.
+3. Dead code detection: operators whose output is not consumed by flow output or downstream.
+"""
+from __future__ import annotations
+
+from apple.base import OpCall
+
+
+class ValidationError(Exception):
+    """Raised when DSL validation fails."""
+    pass
+
+
+def validate_field_coverage(
+    ops: list[tuple[str, OpCall]],
+    flow_common_input: list[str],
+    flow_item_input: list[str],
+) -> None:
+    """Check that every operator input is provided by flow contract or upstream output."""
+    available_common: set[str] = set(flow_common_input)
+    available_item: set[str] = set(flow_item_input)
+
+    for name, op in ops:
+        # Check common inputs
+        for field in op.common_input:
+            if field.startswith("_"):
+                continue  # internal control fields handled by compiler
+            if field not in available_common:
+                raise ValidationError(
+                    f"operator {name!r}: common_input field {field!r} not provided "
+                    f"by flow contract or upstream output"
+                )
+        # Check item inputs
+        for field in op.item_input:
+            if field.startswith("_"):
+                continue
+            if field not in available_item:
+                raise ValidationError(
+                    f"operator {name!r}: item_input field {field!r} not provided "
+                    f"by flow contract or upstream output"
+                )
+        # Register outputs
+        available_common.update(op.common_output)
+        available_item.update(op.item_output)
+
+
+def validate_write_without_read(
+    ops: list[tuple[str, OpCall]],
+    flow_common_input: list[str],
+    flow_item_input: list[str],
+) -> None:
+    """Detect writing a field that already exists (from upstream operator output)
+    without reading it. Flow-contract inputs are not flagged — operators are
+    allowed to output fields that match flow inputs without reading them."""
+    # Track fields written by operators (not flow contract)
+    written_by_ops_common: set[str] = set()
+    written_by_ops_item: set[str] = set()
+
+    for name, op in ops:
+        for field in op.common_output:
+            if field.startswith("_"):
+                continue
+            if field in written_by_ops_common and field not in op.common_input:
+                raise ValidationError(
+                    f"operator {name!r}: writes common field {field!r} "
+                    f"without reading it (field already exists from upstream)"
+                )
+        for field in op.item_output:
+            if field.startswith("_"):
+                continue
+            if field in written_by_ops_item and field not in op.item_input:
+                raise ValidationError(
+                    f"operator {name!r}: writes item field {field!r} "
+                    f"without reading it (field already exists from upstream)"
+                )
+        written_by_ops_common.update(op.common_output)
+        written_by_ops_item.update(op.item_output)
+
+
+def detect_dead_code(
+    ops: list[tuple[str, OpCall]],
+    flow_common_output: list[str] | None,
+    flow_item_output: list[str] | None,
+) -> list[str]:
+    """Detect operators whose output is never consumed.
+
+    Returns list of dead operator names. Only checks if flow output contract
+    is declared (non-None).
+    """
+    if flow_common_output is None and flow_item_output is None:
+        return []
+
+    # Build set of "needed" fields
+    needed_common: set[str] = set(flow_common_output or [])
+    needed_item: set[str] = set(flow_item_output or [])
+
+    # Also, fields consumed by downstream operators are needed
+    for _, op in ops:
+        needed_common.update(op.common_input)
+        needed_item.update(op.item_input)
+
+    dead: list[str] = []
+    for name, op in ops:
+        if op.for_branch_control:
+            continue  # control ops are never dead
+        if op.recall:
+            continue  # recall ops are always needed
+        if not op.common_output and not op.item_output:
+            continue  # observe ops (no output at all) are exempt
+
+        produces_needed = False
+        for field in op.common_output:
+            if field in needed_common:
+                produces_needed = True
+                break
+        if not produces_needed:
+            for field in op.item_output:
+                if field in needed_item:
+                    produces_needed = True
+                    break
+
+        if not produces_needed and (op.common_output or op.item_output):
+            dead.append(name)
+
+    return dead

pineapple_apple-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: pineapple-apple
+Version: 0.1.0
+Summary: Apple DSL — Python pipeline declaration for Pineapple engine
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.10

pineapple_apple-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+apple/__init__.py,sha256=fKlL71YG0YFVGLJwyEbkvd_GC3LBvxgDZhBJlY1hwws,180
+apple/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+apple/base.py,sha256=kBcbnWSh4HZCoOTDwLlDAEAdzWUCLw_IpLOnZ6scFx4,3009
+apple/compiler.py,sha256=6YMM9PBCTwSFw2KZKvoCY0t5fW2vx-EHRGIw0f4n6dw,5551
+apple/control.py,sha256=YH2njcBibmzfdsNUcshdGHAl2h4-Hj6YBv1KQ8GgiKQ,3155
+apple/flow.py,sha256=N2IBJJ8dcYsSWBTbEyO1aUhG89agVPqZOzhOV1Wpcgs,7374
+apple/validator.py,sha256=sUt-Ot11mb43hmhaNLB1zNnQsB-PWpN25nzCIpe8_5o,4736
+pineapple_apple-0.1.0.dist-info/METADATA,sha256=D1W2l6cQtTkE27iqvEgEK0I7aFE0SAZxQiOtquD6KmM,208
+pineapple_apple-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pineapple_apple-0.1.0.dist-info/licenses/LICENSE,sha256=L7XribiMHrSXRde_qCXbpC2RoaSVWWbjM-OpZpTE6p8,10761
+pineapple_apple-0.1.0.dist-info/RECORD,,

pineapple_apple-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pineapple_apple-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+                                 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 the 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 the 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 any 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
+
+   Copyright 2025 Liam Huang
+
+   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.