byllm 0.4.8__py2.py3-none-any.whl

byllm/types.jac

@@ -0,0 +1,471 @@
+"""Type definitions for LLM interactions.
+
+This module defines the types used in the LLM interactions, including messages,
+tools, and tool calls. It provides a structured way to represent messages,
+tool calls, and tools that can be used in LLM requests and responses.
+"""
+import base64;
+import mimetypes;
+import os;
+import from contextlib { suppress }
+import from enum { StrEnum }
+import from io { BytesIO }
+import from typing { Callable, TypeAlias, get_type_hints }
+
+import from PIL.Image { Image as PILImageCls }
+import from PIL.Image { open as open_image }
+
+import from litellm.types.utils { Message as LiteLLMMessage }
+import from pydantic { TypeAdapter }
+import from .schema { tool_to_schema }
+
+# The message can be a jaclang defined message or what ever the llm
+# returned object that was feed back to the llm as it was given (dict).
+glob MessageType:
+    TypeAlias = 'Message | LiteLLMMessage';
+
+"""Enum for message roles in LLM interactions."""
+enum MessageRole ( StrEnum ) {
+    SYSTEM = "system",
+    USER = "user",
+    ASSISTANT = "assistant",
+    TOOL = "tool"
+}
+
+"""Message class for LLM interactions."""
+obj Message {
+    has role: MessageRole;
+    has content: str | list[Media];
+
+    """Convert the message to a dictionary."""
+    def to_dict()  -> dict[str, object] {
+        if isinstance(self.content, str) {
+            return {"role": self.role.value, "content": self.content,};
+        }
+        media_contents = [];
+        for media in self.content {
+            media_contents.extend(media.to_dict());
+            return {"role": self.role.value, "content": media_contents,};
+        }
+    }
+}
+
+"""Result of a tool call in LLM interactions."""
+obj ToolCallResultMsg(Message) {
+    has tool_call_id: str;
+    has name: str;  # Function name.
+
+    """Post-initialization to set the role of the message."""
+    def postinit()  -> None {
+        self.role = MessageRole.TOOL;  # Maybe this should be an assertion?
+    }
+
+    """Convert the tool call result message to a dictionary."""
+    def to_dict()  -> dict[str, object] {
+        return {
+            "role": self.role.value,
+            "content": self.content,
+            "tool_call_id": self.tool_call_id,
+            "name": self.name,
+
+        };
+    }
+}
+
+"""Tool class for LLM interactions."""
+obj Tool {
+    has func: Callable;
+    has description: str = "";
+    has params_desc: dict[str, str] = None;  # type: ignore
+
+    """Post-initialization to validate the function."""
+    def postinit()  -> None {
+        annotations = get_type_hints(self.func);
+        with suppress(Exception) {
+            self.func.__annotations__ = annotations;
+        }
+
+        self.description = Tool.get_func_description(self.func);
+
+        if hasattr(self.func, "_jac_semstr_inner") {
+            self.params_desc = self.func._jac_semstr_inner;  # type: ignore
+        } else {
+            self.params_desc = {
+                name: str(type) for (name, type) in annotations.items()
+            };
+        }
+    }
+
+    """Call the tool function with the provided arguments."""
+    def __call__( *args: list , **kwargs: dict)  -> object {
+        # If there is an error with the finish tool, we throw the exception.
+        # Since it's the user's responsibility to handle it.
+        if self.is_finish_tool() {
+            return self.func(*args, **kwargs);
+        }
+        try {
+            # TODO: Shoud I json serialize or this is fine?
+            return self.func(*args, **kwargs);
+        } except Exception as e {
+            # For the LLM if the tool failed, it'll see the error message
+            # and make decision based on that.
+            return str(e);
+        }
+    }
+
+    """Return the name of the tool function."""
+    def get_name()  -> str {
+        return self.func.__name__;
+    }
+
+    """Get the description of the function."""
+    static def get_func_description(func: Callable) -> str {
+        if hasattr(func, "_jac_semstr") {
+            return func._jac_semstr;  # type: ignore
+
+        }
+        return func.__doc__ or func.__name__;
+    }
+
+    """Create a finish tool that returns the final output."""
+    static def make_finish_tool(resp_type: type) -> Tool {
+        def finish_tool(final_output: object) -> object {
+            return TypeAdapter(resp_type).validate_python(final_output);
+        }
+
+        finish_tool.__annotations__["return"] = resp_type;
+        finish_tool.__annotations__["final_output"] = resp_type;
+        return Tool(
+            func=finish_tool,
+            description="This tool is used to finish the tool calls and return the final output.",
+            params_desc={"final_output": "The final output of the tool calls.",},
+        );
+    }
+
+    """Check if the tool is a finish tool."""
+    def is_finish_tool()  -> bool {
+        return self.get_name() == "finish_tool";
+    }
+
+    """Return the JSON schema for the tool function."""
+    def get_json_schema()  -> dict[str, object] {
+        return tool_to_schema(self.func, self.description, self.params_desc);
+    }
+
+    """Parse the arguments from JSON to the function's expected format."""
+    def parse_arguments(args_json: dict) -> dict {
+        args = {};
+
+        annotations: dict = {};
+        try {
+            annotations = self.func.__annotations__;
+        } except AttributeError {
+            annotations = get_type_hints(self.func);
+        }
+        for (arg_name, arg_json) in args_json.items() {
+            if arg_type := annotations.get(arg_name) {
+                args[arg_name] = TypeAdapter(arg_type).validate_python(arg_json);
+            }
+        }
+        return args;
+    }
+}
+
+"""Tool call class for LLM interactions."""
+obj ToolCall {
+    has call_id: str;
+    has tool: Tool;
+    has args: dict;
+
+    """Call the tool with the provided arguments."""
+    def __call__()  -> ToolCallResultMsg {
+        if self.args is not None {
+            result = self.tool(**self.args);
+        } else {
+            raise ValueError("args is None, Expected a dictionary") ;
+        }
+        return ToolCallResultMsg(
+            role=MessageRole.TOOL,
+            content=str(result),
+            tool_call_id=self.call_id,
+            name=self.tool.get_name(),
+        );
+    }
+
+    """Return the string representation of the tool call."""
+    def __str__()  -> str {
+        params = ", ".join(f"{k}={v}" for (k, v) in self.args.items());
+        return f"{self.tool.get_name()}({params})";
+    }
+
+    """Check if the tool is a finish tool."""
+    def is_finish_call()  -> bool {
+        return self.tool.is_finish_tool();
+    }
+
+    """Get the output from the finish tool call."""
+    def get_output()  -> object {
+        assert (self.is_finish_call()) , "This method should only be called for finish tools.";
+        return self.tool(**self.args);
+    }
+}
+
+"""Mock tool call for testing purposes."""
+obj MockToolCall {
+    has tool: Callable;
+    has args: dict;
+
+    """Convert the mock tool call to a ToolCall."""
+    def to_tool_call()  -> ToolCall {
+        args_parsed = Tool(self.tool).parse_arguments(self.args);
+        return ToolCall(
+            call_id="",  # Call ID is not used in mock calls.
+            tool=Tool(self.tool),
+            args=args_parsed,
+        );
+    }
+}
+
+"""Result of the completion from the LLM."""
+obj CompletionResult {
+    has output: object;
+    has tool_calls: list[ToolCall];
+}
+
+# -----------------------------------------------------------------------------
+# Media content types
+# -----------------------------------------------------------------------------
+"""Base class for message content."""
+obj Media {
+    """Convert the content to a dictionary."""
+    def to_dict()  -> list[dict] {
+        raise NotImplementedError("Subclasses must implement this method.") ;
+    }
+}
+
+"""Class representing text content in a message."""
+obj Text(Media) {
+    has text: str;
+
+    """Convert the text content to a dictionary."""
+    def to_dict()  -> list[dict] {
+        return [{"type": "text", "text": self.text}];
+    }
+}
+
+"""Class representing an image."""
+obj Image(Media) {
+    has url:
+        (
+            "str | bytes | bytearray | memoryview | BytesIO | IO[bytes] | ""os.PathLike[str] | os.PathLike[bytes] | PILImageCls"
+        );  # type: ignore[name-defined]
+
+    has mime_type: str | None = None;
+
+    """Normalize input into a data URL or leave remote/data URLs as-is.
+
+    Supported inputs:
+    - HTTP(S)/GS URLs (left as-is)
+    - Data URLs (data:...)
+    - Local file paths (opened and encoded to data URL)
+    - Bytes / bytearray / memoryview
+    - File-like objects (BytesIO or any IO[bytes])
+    - os.PathLike
+    - PIL.Image.Image instances
+    """
+    def postinit()  -> None {
+        value = self.url;
+
+        # Handle path-like inputs by converting to string
+        if isinstance(value, os.PathLike) {
+            value = os.fspath(value);
+        }
+
+        # Remote or data URLs: keep as-is (trim whitespace)
+        if isinstance(value, str) {
+            s = value.strip();
+            if s.startswith(("http://", "https://", "gs://", "data:")) {
+                self.url = s;
+                return;
+            }
+            # Treat as local file path
+            if not os.path.exists(s) {
+                raise ValueError(f"Image file does not exist: {s}") ;
+            }
+            image = open_image(s);
+            fmt = image.format or "PNG";
+            # Determine MIME type with WEBP special-case for py<3.13
+            self.mime_type = self._format_to_mime(fmt);
+            with BytesIO() as buffer {
+                image.save(buffer, format=fmt);
+                data = buffer.getvalue();
+                self.url = self._data_url_from_bytes(data, fmt);
+                return;
+            }
+        }
+
+        # PIL Image instance
+        if isinstance(value, PILImageCls) {
+            fmt = value.format or "PNG";
+            with BytesIO() as buffer {
+                value.save(buffer, format=fmt);
+                data = buffer.getvalue();
+                self.url = self._data_url_from_bytes(data, fmt);
+                return;
+            }
+        }
+
+        # Bytes-like object
+        if isinstance(value, (bytes, bytearray, memoryview)) {
+            raw = bytes(value);
+            # Probe format via PIL to set correct MIME
+            img = open_image(BytesIO(raw));
+            fmt = img.format or "PNG";
+            # Use bytes as-is (avoid re-encode) if PIL detects same format as content
+            # Otherwise, re-encode to the detected format to be safe.
+            try {
+                self.url = self._data_url_from_bytes(raw, fmt);
+            } except Exception {
+                with BytesIO() as buffer {
+                    img.save(buffer, format=fmt);
+                    self.url = self._data_url_from_bytes(buffer.getvalue(), fmt);
+                }
+            }
+            return;
+        }
+
+        # File-like object (e.g., BytesIO, IO[bytes])
+        if hasattr(value, "read") and callable(value.read) {
+            # Safely read without permanently moving the cursor
+            stream: IO[bytes] = value;  # type: ignore[assignment]
+            pos = None;
+            try {
+                pos = stream.tell();  # type: ignore[attr-defined]
+            } except Exception {
+                pos = None;
+            }
+            try {
+                # Prefer getvalue if available (e.g., BytesIO)
+                if hasattr(stream, "getvalue") and callable(stream.getvalue) {
+                    raw = stream.getvalue();  # type: ignore[call-arg]
+                } else {
+                    if hasattr(stream, "seek") {
+                        with suppress(Exception) {
+                            stream.seek(0);
+                        }
+                    }
+                    raw = stream.read();
+                }
+                img = open_image(BytesIO(raw));
+                fmt = img.format or "PNG";
+                self.url = self._data_url_from_bytes(raw, fmt);
+            } finally {
+                if pos is not None and hasattr(stream, "seek") {
+                    with suppress(Exception) {
+                        stream.seek(pos);
+                    }
+                }
+            }
+            return;
+        }
+
+        # If we reach here, the input type isn't supported
+        raise TypeError(
+            "Unsupported Image input type. Provide a URL/path string, data URL, bytes, ""BytesIO, file-like object, os.PathLike, or PIL.Image.Image."
+        ) ;
+    }
+
+    """Map a PIL format name to a MIME type with sensible fallbacks."""
+    def _format_to_mime(fmt: str | None) -> str {
+        fmt = (fmt or "PNG").upper();
+        if fmt == "WEBP" {
+            return "image/webp";
+        }
+        if fmt == "JPEG" or fmt == "JPG" {
+            return "image/jpeg";
+        }
+        if fmt == "PNG" {
+            return "image/png";
+        }
+        # Try mimetypes (uses extension mapping)
+        mime = mimetypes.types_map.get("." + fmt.lower());
+        return mime or "image/png";
+    }
+
+    def _data_url_from_bytes(data: bytes, fmt: str | None) -> str {
+        mime = self.mime_type or self._format_to_mime(fmt);
+        # Ensure mime_type is set on the instance for downstream usage
+        self.mime_type = mime;
+        b64 = base64.b64encode(data).decode("utf-8");
+        return f"data:{mime};base64,{b64}";
+    }
+
+    """Convert the image to a dictionary."""
+    def to_dict()  -> list[dict] {
+        image_url = {"url": self.url};
+        if self.mime_type {
+            image_url["format"] = self.mime_type;
+        }
+        return [{"type": "image_url", "image_url": image_url,}];
+    }
+}
+
+# Ref: https://cookbook.openai.com/examples/gpt_with_vision_for_video_understanding
+"""Class representing a video."""
+obj Video(Media) {
+    has path: str;
+    has fps: int = 1;
+    has _base64frames: list[str] | None = None;
+
+    """Post-initialization to ensure the path is a string."""
+    def postinit()  -> None {
+        if not os.path.exists(self.path) {
+            raise ValueError(f"Video file does not exist: {self.path}") ;
+        }
+    }
+
+    """Load video frames as base64-encoded images."""
+    def load_frames()  -> None {
+        try {
+            import cv2;
+        } except ImportError {
+            raise ImportError(
+                "OpenCV is required to process video files.""Install `pip install byllm[video]` for video capabilities."
+            ) ;
+        }
+
+        self._base64frames = [];
+        video = cv2.VideoCapture(self.path);
+        total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT));
+
+        target_fps = self.fps;
+        source_fps = video.get(cv2.CAP_PROP_FPS);
+        frames_to_skip = (
+            int(source_fps / target_fps) - 1 if target_fps < source_fps else 1
+        );
+
+        curr_frame = 0;
+        while curr_frame < total_frames - 1 {
+            video.set(cv2.CAP_PROP_POS_FRAMES, curr_frame);
+            (success, frame) = video.read();
+            if not success {
+                raise ValueError("Failed to read video frame.") ;
+            }
+            (_, buffer) = cv2.imencode(".jpg", frame);
+            self._base64frames.append(base64.b64encode(buffer).decode("utf-8"));
+            curr_frame += frames_to_skip;
+        }
+    }
+
+    """Convert the video to a dictionary."""
+    def to_dict()  -> list[dict] {
+        if self._base64frames is None {
+            self.load_frames();
+        }
+        assert (self._base64frames is not None) , "Frames must be loaded before conversion.";
+        return [
+            {"type": "image_url", "image_url": f"data:image/jpeg;base64,{frame}",}
+            for frame in self._base64frames
+        ];
+    }
+}

byllm-0.4.8.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: byllm
+Version: 0.4.8
+Summary: byLLM Provides Easy to use APIs for different LLM Providers to be used with Jaseci's Jaclang Programming Language.
+License: MIT
+Keywords: llm,jaclang,jaseci,byLLM
+Author: Jason Mars
+Author-email: jason@mars.ninja
+Maintainer: Jason Mars
+Maintainer-email: jason@mars.ninja
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: tools
+Provides-Extra: video
+Requires-Dist: jaclang (>=0.9.3)
+Requires-Dist: litellm (>=1.75.5.post1,<1.80.0)
+Requires-Dist: loguru (>=0.7.2,<0.8.0)
+Requires-Dist: pillow (>=10.4.0,<10.5.0)
+Description-Content-Type: text/markdown
+
+<div align="center">
+    <img src="../docs/docs/assets/byLLM_name_logo.png" height="150">
+
+  [About byLLM] | [Get started] | [Usage docs] | [Research Paper]
+</div>
+
+[About byLLM]: https://www.jac-lang.org/learn/jac-byllm/with_llm/
+[Get started]: https://www.jac-lang.org/learn/jac-byllm/quickstart/
+[Usage docs]: https://www.jac-lang.org/learn/jac-byllm/usage/
+[Research Paper]: https://arxiv.org/abs/2405.08965
+
+# byLLM : Prompt Less, Smile More!
+
+[![PyPI version](https://img.shields.io/pypi/v/byllm.svg)](https://pypi.org/project/byllm/) [![tests](https://github.com/jaseci-labs/jaseci/actions/workflows/test-jaseci.yml/badge.svg?branch=main)](https://github.com/jaseci-labs/jaseci/actions/workflows/test-jaseci.yml) [![Discord](https://img.shields.io/badge/Discord-Join%20Server-blue?logo=discord)](https://discord.gg/6j3QNdtcN6)
+
+byLLM is an innovative AI integration framework built for the Jaseci ecosystem, implementing the cutting-edge Meaning Typed Programming (MTP) paradigm. MTP revolutionizes AI integration by embedding prompt engineering directly into code semantics, making AI interactions more natural and maintainable. While primarily designed to complement the Jac programming language, byLLM also provides a powerful Python library interface.
+
+Installation is simple via PyPI:
+
+```bash
+pip install byllm
+```
+
+## Basic Example
+
+Consider building an application that translates english to other languages using an LLM. This can be simply built as follows:
+
+```python
+import from byllm.lib { Model }
+
+glob llm = Model(model_name="gpt-4o");
+
+def translate_to(language: str, phrase: str) -> str by llm();
+
+with entry {
+    output = translate_to(language="Welsh", phrase="Hello world");
+    print(output);
+}
+```
+
+This simple piece of code replaces traditional prompt engineering without introducing additional complexity.
+
+## Power of Types with LLMs
+
+Consider a program that detects the personality type of a historical figure from their name. This can eb built in a way that LLM picks from an enum and the output strictly adhere this type.
+
+```python
+import from byllm.lib { Model }
+glob llm = Model(model_name="gemini/gemini-2.0-flash");
+
+enum Personality {
+    INTROVERT, EXTROVERT, AMBIVERT
+}
+
+def get_personality(name: str) -> Personality by llm();
+
+with entry {
+    name = "Albert Einstein";
+    result = get_personality(name);
+    print(f"{result} personality detected for {name}");
+}
+```
+
+> Similarly, custom types can be used as output types which force the LLM to adhere to the specified type and produce a valid result.
+
+## Control! Control! Control!
+
+Even if we are elimination prompt engineering entierly, we allow specific ways to enrich code semantics through **docstrings** and **semstrings**.
+
+```python
+"""Represents the personal record of a person"""
+obj Person {
+    has name: str;
+    has dob: str;
+    has ssn: str;
+}
+
+sem Person.name = "Full name of the person";
+sem Person.dob = "Date of Birth";
+sem Person.ssn = "Last four digits of the Social Security Number of a person";
+
+"""Calculate eligibility for various services based on person's data."""
+def check_eligibility(person: Person, service_type: str) -> bool by llm();
+
+```
+
+Docstrings naturally enhance the semantics of their associated code constructs, while the `sem` keyword provides an elegant way to enrich the meaning of class attributes and function arguments. Our research shows these concise semantic strings are more effective than traditional multi-line prompts.
+
+## How well does byLLM work?
+
+byLLM is built using the underline priciple of Meaning Typed Programming and we shown our evaluation data compared with two such AI integration frameworks for python, such as DSPy and LMQL. We show significant performance gain against LMQL while allowing on par or better performance to DSPy, while having a lower cost and faster runtime.
+
+<div align="center">
+    <img src="../docs/docs/assets/correctness_comparison.png" alt="Correctness Comparison" width="600" style="max-width: 100%;">
+    <br>
+    <em>Figure: Correctness comparison of byLLM with DSPy and LMQL on benchmark tasks.</em>
+</div>
+
+**📚 Full Documentation**: [Jac byLLM Documentation](https://www.jac-lang.org/learn/jac-byllm/with_llm/)
+
+**🎮 Complete Examples**:
+- [Fantasy Trading Game](https://www.jac-lang.org/learn/examples/mtp_examples/fantasy_trading_game/) - Interactive RPG with AI-generated characters
+- [RPG Level Generator](https://www.jac-lang.org/learn/examples/mtp_examples/rpg_game/) - AI-powered game level creation
+- [RAG Chatbot Tutorial](https://www.jac-lang.org/learn/examples/rag_chatbot/Overview/) - Building chatbots with document retrieval
+
+**🔬 Research**: The research journey of MTP is available on [Arxiv](https://arxiv.org/abs/2405.08965) and accepted for OOPSLA 2025.
+
+## Quick Links
+
+- [Getting Started Guide](https://www.jac-lang.org/learn/jac-byllm/quickstart/)
+- [Jac Language Documentation](https://www.jac-lang.org/)
+- [GitHub Repository](https://github.com/jaseci-labs/jaseci)
+
+## Contributing
+
+We welcome contributions to byLLM! Whether you're fixing bugs, improving documentation, or adding new features, your help is appreciated.
+
+Areas we actively seek contributions:
+- 🐛 Bug fixes and improvements
+- 📚 Documentation enhancements
+- ✨ New examples and tutorials
+- 🧪 Test cases and benchmarks
+
+Please see our [Contributing Guide](https://www.jac-lang.org/internals/contrib/) for detailed instructions.
+
+If you find a bug or have a feature request, please [open an issue](https://github.com/jaseci-labs/jaseci/issues/new/choose).
+
+## Community
+
+Join our vibrant community:
+- [Discord Server](https://discord.gg/6j3QNdtcN6) - Chat with the team and community
+
+## License
+
+This project is licensed under the MIT License.
+
+### Third-Party Dependencies
+
+byLLM integrates with various LLM providers (OpenAI, Anthropic, Google, etc.) through LiteLLM.
+
+## Cite our research
+
+
+> Jayanaka L. Dantanarayana, Yiping Kang, Kugesan Sivasothynathan, Christopher Clarke, Baichuan Li, Savini
+Kashmira, Krisztian Flautner, Lingjia Tang, and Jason Mars. 2025. MTP: A Meaning-Typed Language Ab-
+straction for AI-Integrated Programming. Proc. ACM Program. Lang. 9, OOPSLA2, Article 314 (October 2025),
+29 pages. https://doi.org/10.1145/3763092
+
+
+## Jaseci Contributors
+
+<a href="https://github.com/jaseci-labs/jaseci/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=jaseci-labs/jaseci" />
+</a>
+

byllm-0.4.8.dist-info/RECORD

@@ -0,0 +1,11 @@
+byllm/__init__.py,sha256=cHwW8H7h-wNwtk_e6CVMquikcP9izlW3SLvcG3VeOVk,709
+byllm/lib.py,sha256=WjFCRhM-R4O3w9joAHM8Lm70uKoDWGmCItPTzt69iWs,274
+byllm/llm.jac,sha256=1Tu0TCClkW08O_vJeeMYWG3B7auUA9ac1_HugGxz5-I,13135
+byllm/mtir.jac,sha256=8Kp3A6qjUsZ2tx0t3bebzYQ-9-Y9ocz-Cwqu9XEdr-s,6720
+byllm/plugin.py,sha256=9t_nhrUwm35fUB2yEicATQ6kPQivex0Hmy3PAPrmIx8,1608
+byllm/schema.jac,sha256=L6jnI-Td03HwNa7-7m6MkNSgH5obcp9DjE6qtptUgOI,9035
+byllm/types.jac,sha256=7LVzaTM9WLKLCHoKa5VehpLkqBgMgljs7lWFGqvLdR8,15625
+byllm-0.4.8.dist-info/METADATA,sha256=8g6qrroI8HNwbncUmlyznsmLk9sZJuxc8ZXN7HKd_JM,7743
+byllm-0.4.8.dist-info/WHEEL,sha256=MICUlqIgkuEnKh9OWy254Ca7q2MHOW-q0u36TZR60nU,92
+byllm-0.4.8.dist-info/entry_points.txt,sha256=j4qdGR-j4plBBZcCeIWW_tLjchtDWWsADNCrfo7qUOM,37
+byllm-0.4.8.dist-info/RECORD,,

byllm-0.4.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py2.py3-none-any

byllm-0.4.8.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[jac]
+byllm=byllm.plugin:JacRuntime
+