pkl-python 0.1.0__py3-none-any.whl

pkl/server.py

@@ -0,0 +1,191 @@
+import atexit
+import os
+import platform
+import select
+import signal
+import stat
+import subprocess
+import warnings
+from pathlib import Path
+from typing import List
+
+import msgpack
+import requests
+
+BINARIES = {
+    ("darwin", "64bit"): "pkl-macos-amd64",
+    ("darwin", "aarch64"): "pkl-macos-aarch64",
+    ("linux", "64bit"): "pkl-linux-amd64",
+    ("linux", "aarch64"): "pkl-linux-aarch64",
+    ("linux", "64bit", "alpine"): "pkl-alpine-linux-amd64",
+}
+PKL_VERSION = "0.25.2"
+BASE_PATH = "https://github.com/apple/pkl/releases/download/"
+
+
+def preexec_function():
+    # Cause the child process to be terminated when the parent exits
+    signal.signal(signal.SIGHUP, signal.SIG_IGN)
+
+
+def detect_system():
+    os_name = platform.system().lower()
+    arch, _ = platform.architecture()
+    return os_name, arch
+
+
+def is_alpine_linux():
+    return os.path.isfile("/etc/alpine-release")
+
+
+def execute_binary(binary_path):
+    subprocess.run([binary_path, "server"], check=True)
+
+
+def download_binary(file, target_fp):
+    url = BASE_PATH + PKL_VERSION + "/" + file
+    response = requests.get(url)
+    with open(target_fp, "wb") as f:
+        f.write(response.content)
+
+
+def get_binary_path():
+    os_name, arch = detect_system()
+    if os_name == "linux" and is_alpine_linux():
+        os_name = "alpine"
+    binary_key = (os_name, arch)
+    if binary_key == ("linux", "64bit") and is_alpine_linux():
+        binary_key += ("alpine",)
+    bin_file = BINARIES.get(binary_key)
+
+    if bin_file is None:
+        raise OSError("No compatible binary found for your system.")
+
+    bin_parent_path = (Path("~/.pkl/bin/") / PKL_VERSION).expanduser()
+    binary_path = bin_parent_path / bin_file
+
+    if not binary_path.exists():
+        binary_path.parent.mkdir(exist_ok=True, parents=True)
+        download_binary(bin_file, binary_path)
+
+    current_permissions = os.stat(binary_path).st_mode
+    new_permissions = current_permissions | stat.S_IXUSR
+    os.chmod(binary_path, new_permissions)
+
+    return binary_path
+
+
+_PROCESSES = []
+
+
+def terminate_processes():
+    for process in _PROCESSES:
+        process.terminate()
+        process.wait()
+
+
+atexit.register(terminate_processes)
+
+
+class PKLServer:
+    def __init__(self):
+        self._process: subprocess.Popen = None
+        self._cmd = [get_binary_path(), "server"]
+        self.next_request_id = 1
+
+    def get_request_id(self):
+        ret = self.next_request_id
+        self.next_request_id += 1
+        return ret
+
+    def start_process(self, debug=False):
+        if self._process:
+            return
+
+        env = os.environ.copy()
+        if debug:
+            env = {"PKL_DEBUG": "1"}
+
+        self._process = subprocess.Popen(
+            self._cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False,
+            bufsize=0,
+            preexec_fn=preexec_function,
+            env=env,
+        )
+        stdout_fd = self._process.stdout.fileno()
+        stderr_fd = self._process.stderr.fileno()
+        os.set_blocking(stdout_fd, False)
+        os.set_blocking(stderr_fd, False)
+        _PROCESSES.append(self._process)
+
+    def check_process(self, is_raise=False):
+        if self._process is None:
+            if is_raise:
+                raise ValueError("Start server first with 'start_process'")
+            return False
+        return True
+
+    def send_message(self, msg_obj):
+        self.check_process(is_raise=True)
+
+        encoded_message = msgpack.packb(msg_obj)
+        self._process.stdin.write(encoded_message)
+        self._process.stdin.flush()
+
+    def receive_message(self, timeout=None, empty_break=False) -> List:
+        self.check_process(is_raise=True)
+
+        stdout = self._process.stdout
+        stderr = self._process.stderr
+        outputs = []
+
+        while True:
+            readable, _, _ = select.select([stdout, stderr], [], [], timeout)
+            if empty_break and len(readable) == 0:
+                return
+
+            for stream in readable:
+                output = stream.read()
+
+                if stream == stdout:
+                    outputs.append(output)
+                else:  # stderr
+                    print(output.decode(), end="")
+
+            if len(outputs) > 0:
+                break
+
+            # Check if the process has terminated
+            if self._process.poll() is not None:
+                print("Process has terminated")
+                break
+
+        assert len(outputs) == 1
+        unpacker = msgpack.Unpacker()
+        unpacker.feed(outputs[0])
+        responses = list(unpacker)
+        return responses
+
+    def receive_with_retry(self, max_retry=5) -> List:
+        response = None
+        retry = 0
+        while response is None and retry <= max_retry:
+            response = self.receive_message()
+            retry += 1
+        if retry == max_retry:
+            warnings.warn("Max retry reached.")
+        return response
+
+    def send_and_receive(self, msg_obj) -> List:
+        self.send_message(msg_obj)
+        response = self.receive_message()
+        return response
+
+    def terminate(self):
+        self._process.terminate()
+        self._process.wait()
+        self._process = None

pkl_python-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jungwoo Yang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pkl_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: pkl-python
+Version: 0.1.0
+Summary: Python library for Apple's PKL.
+Author-email: Jungwoo Yang <jwyang0213@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Jungwoo Yang
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/jw-y/pkl
+Project-URL: Bug Reports, https://github.com/jw-y/pkl/issues
+Project-URL: Source, https://github.com/jw-y/pkl
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgpack >=1.0.8
+Provides-Extra: dev
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: isort ; extra == 'dev'
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: pylint ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: tox ; extra == 'dev'
+
+# PKLL - PKL Language Python Binding
+Python binding for [Apple's Pkl language](https://pkl-lang.org/index.html).
+
+### Status
+* Evaluator API: fully functional
+* Code Generation: in development
+
+### TODO
+* [ ] (codgen) binary installation feature
+* [ ] (codgen) fix class order
+* [ ] (codgen) clean up code
+
+## Installation
+
+``` bash
+pip install pkll
+```
+
+## Usage
+### Basic Usage
+Here's how you can start using PKLL to load a PKL module:
+
+```python
+import pkll
+
+config = pkll.load("path/to/pkl/example_module.pkl")
+print(config)
+```
+
+## Advanced Features
+For details on the parameters, refer [Message Passing API](https://pkl-lang.org/main/current/bindings-specification/message-passing-api.html).
+
+```python
+from pkll import load
+
+# Advanced loading with custom environment and properties
+result = load(
+    "path/to/pkl/example_module.pkl"
+    env={"CUSTOM_ENV": "value"},
+    properties={"custom.property": "value"}
+)
+print(result)
+```
+
+### Custom Handler
+It is possible to add custom resources or module handler:
+```python
+import pkll
+from pkll.handler import (
+    ListResponse,
+    ReadModuleResponse,
+    ReadResourceResponse,
+    ResourcesHandler,
+)
+from pkll.msgapi import ClientResourceReader
+
+class CustomModuleHandler(ResourcesHandler):
+    def list_response(self, uri: str) -> ListResponse:
+        return ListResponse(
+            pathElements=[{"name": "foo.pkl", "isDirectory": False}]
+        )
+
+    def read_response(self, uri: str) -> ReadResourceResponse:
+        return ReadModuleResponse(
+            contents="foo = 1",
+        )
+
+config = pkll.load(
+    "./tests/myModule.pkl",
+    allowedModules=["pkl:", "repl:", "file:", "customfs:"],
+    clientModuleReaders=[
+        {
+            "scheme": "customfs",
+            "hasHierarchicalUris": True,
+            "isGlobbable": True,
+            "isLocal": True,
+        }
+    ],
+    debug=True,
+    module_handler=CustomModuleHandler(),
+)
+```
+
+## Contributing
+Contributions are welcome! If you'd like to contribute, please fork the repository and submit a pull request. For major changes, please open an issue first to discuss what you would like to change.
+
+## License
+PKLL is released under the MIT License. See the LICENSE file for more details.
+
+## Contact
+For support or to contribute, please contact jwyang0213@gmail.com or visit our GitHub repository to report issues or submit pull requests.

pkl_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+archive/cmd/pkl-gen-go/pkl-gen-python.py,sha256=Y7uiZRWrH4qLhZ6ikl-P_Y4pKYtVZBw89uzN9WeFuro,4541
+archive/cmd/pkl-gen-python/pkl-gen-python.py,sha256=kVmPt5q3nSWGzbzA0WMuDdB2Rz83sFUpWzbQpQBcjEg,7077
+old/pkl-gen-python/generate.py,sha256=XZZqEpTWLteP8rt6z80Z_Qwrsagc0WXVQWFYzfalZ_Q,3769
+old/pkl-gen-python/main.py,sha256=HUsSaPE8uzR_Z4YbvscWsS-9i6hz3U3iDYHd6dtWwRc,2638
+out/ExtendModule_pkl.py,sha256=i4aoOx5c5c3ASjAztdE-erlWK_G7kzLL5soN3ZupgBs,891
+out/ExtendingOpenClass_pkl.py,sha256=QpkTYHvNA7EC02WXndOBmG0lYCzlEmihsf97xs-GOys,1594
+out/Foo_pkl.py,sha256=WPBK3Oulsbu_nh2gSipc_Q1y7AZ4FsVpMFgXn-Qr55o,1641
+out/Imports_pkl.py,sha256=DMSQLpfKv5M_HL-BdwsNrTfyjYr32EXuTjQ6iGTDYMk,574
+out/MyModule_pkl.py,sha256=s7afVaFY0Z-MIDCePYJO7TaMWF3Rf0gQYxRXVf-CMZA,292
+out/com_example_ExtendedSimple_pkl.py,sha256=RSzZ8iAkOkdf1GLBUOZIO5TxMny3Vidc5V0G9NntVoU,1092
+out/com_example_Simple_pkl.py,sha256=YIr2S15YxjMIhIDhK5QV2SJtEtIoYnuMRwE7axLURYo,1631
+out/lib3_pkl.py,sha256=-vlFnXzn_i8lwwHwo0VGeJyzEl9Xwx6XRjOkGugRZ9M,652
+out/union_pkl.py,sha256=JDfYrRhSR7tksJyeeWs1FzmbvDjxjIyUU3gsbDmvA7A,922
+pkl/VERSION,sha256=6d2FB_S_DG9CRY5BrqgzrQvT9hJycjNe7pv01YVB7Wc,6
+pkl/__init__.py,sha256=xD15PQ7-zsRbWhp0GqyNCv9JcNFF_yH0T01iSVhRoew,6929
+pkl/evaluator.py,sha256=AZvcNgckMc-5Jld-d4EjBSqSC9ZRI-M7iKprtMl1RsQ,8882
+pkl/handler.py,sha256=SOvkb2Y0J0w0uKu4VJTOLr0f-VaFW3sdy2yUzLTAP0Q,823
+pkl/msgapi.py,sha256=PCnPQ64rcwl7GDS80wW-6IC9ZN5Kkv2nuO5Zavlj0CQ,6812
+pkl/parser.py,sha256=lOGJTWoSnR0vxrBcTKxSiiJRBLLAWpsi22wv_NBA06M,8637
+pkl/server.py,sha256=DHYJGzcL86_gjuYq3WT2lsCs0SDaRzKCJOIAlNZeGKM,5214
+scripts/download_binary.py,sha256=iLuL64ZJZqszCW6vQC6looxNm6rkeqzT3JB6essP5ME,978
+scripts/eval.py,sha256=icuXL3Brf1I26GkiWzAbNR2sxwIG97_XGVm6n7rBPa4,917
+tests/test_evaluator.py,sha256=qCMB0bui9SnSOSLfR43f0NHwh1CDzVRIbWx8p_DJqrM,123
+tests/test_parser.py,sha256=qPwsoxC_k2nDqzC6mEE9_s8-9ZNlmuoGwZRWEqaIfR8,975
+tests/test_responses.py,sha256=hD1KbEvq6WdsWLG3QNdujhhmdTQnAfcOnYjjVhug-a4,2855
+tests/test_server.py,sha256=pZapHwM7N33f-1rG65m9eip-2jcv9uD-pUAzUbBESHc,129
+pkl_python-0.1.0.dist-info/LICENSE,sha256=xakNlyP5yr5S03TW66xSAFmKjgc3eC4Dxz0ggbmFzFM,1069
+pkl_python-0.1.0.dist-info/METADATA,sha256=q75Nqyf-S0ExJXdNuz04FyiroaZd6k_tN5ejIAcAP6M,4522
+pkl_python-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pkl_python-0.1.0.dist-info/top_level.txt,sha256=SmMRZ3XJJ2x8VtiVSRQV2E7lEKo3aBGYvkd0IKG6Rjw,34
+pkl_python-0.1.0.dist-info/RECORD,,

pkl_python-0.1.0.dist-info/WHEEL

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

pkl_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+archive
+old
+out
+pkl
+scripts
+tests

scripts/download_binary.py

@@ -0,0 +1,42 @@
+import argparse
+from pathlib import Path
+
+import requests
+
+VERSION = "0.25.2"
+
+BASE_PATH = "https://github.com/apple/pkl/releases/download/"
+filenames = [
+    "pkl-macos-aarch64",
+    "pkl-macos-amd64",
+    "pkl-linux-aarch64",
+    "pkl-linux-amd64",
+    "pkl-alpine-linux-amd64",
+]
+JAVA_FILE = f"https://repo1.maven.org/maven2/org/pkl-lang/pkl-cli-java/{VERSION}/pkl-cli-java-{VERSION}.jar"
+
+
+def main(save_path):
+    urls = [BASE_PATH + VERSION + "/" + file for file in filenames]
+    urls.append(JAVA_FILE)
+
+    for url in urls:
+        file = url.split("/")[-1]
+        fp = save_path / file
+
+        response = requests.get(url)
+        with open(fp, "wb") as f:
+            f.write(response.content)
+
+        print("written to", fp)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "output_path", help="Directory where binaries will be downloaded"
+    )
+
+    args = parser.parse_args()
+
+    main(Path(args.output_path))

scripts/eval.py

@@ -0,0 +1,32 @@
+import argparse
+from pathlib import Path
+from pprint import pprint
+
+import pkll
+
+
+def main(target, force=False, debug=False, is_print=False):
+    target = Path(target)
+
+    if target.is_file():
+        files = [target]
+    elif target.is_dir():
+        files = list(target.glob("*.pkl"))
+    else:
+        raise ValueError(target)
+
+    for f in files:
+        if f.is_file():
+            config = pkll.load(f.absolute().as_uri(), force_render=force, debug=debug)
+            if is_print:
+                pprint(config)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("target")
+    parser.add_argument("--force", "-f", action="store_true")
+    parser.add_argument("--debug", "-d", action="store_true")
+    parser.add_argument("--print", "-p", action="store_true")
+    args = parser.parse_args()
+    main(args.target, force=args.force, debug=args.debug, is_print=args.print)

tests/test_evaluator.py

@@ -0,0 +1,7 @@
+from pkl import Evaluator
+
+
+def test_evaluator():
+    evaluator = Evaluator()
+    evaluator.create()
+    evaluator.close()

tests/test_parser.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+import pytest
+
+import pkl
+
+base_path = Path("./tests/Fixtures")
+
+
+def test_AnyType():
+    file = base_path / "AnyType.pkl"
+    _ = pkl.load(file)
+
+
+def test_ApiTypes():
+    file = base_path / "ApiTypes.pkl"
+    _ = pkl.load(file)
+
+
+def test_Classes():
+    file = base_path / "Classes.pkl"
+    _ = pkl.load(file)
+
+
+def test_Collections():
+    file = base_path / "Collections.pkl"
+    _ = pkl.load(file)
+
+
+def test_ExtendedModule():
+    file = base_path / "ExtendedModule.pkl"
+    _ = pkl.load(file)
+
+
+def test_OpenModule():
+    file = base_path / "OpenModule.pkl"
+    with pytest.raises(Exception):
+        _ = pkl.load(file)
+
+
+def test_Poly():
+    file = base_path / "Poly.pkl"
+    _ = pkl.load(file)
+
+
+def test_UnionTypes():
+    file = base_path / "UnionTypes.pkl"
+    _ = pkl.load(file)
+
+
+def test_lib1():
+    file = base_path / "lib1.pkl"
+    _ = pkl.load(file)
+
+
+def test_types():
+    file = Path("./tests") / "types.pkl"
+    _ = pkl.load(file)

tests/test_responses.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+
+import pytest
+
+import pkl
+from pkl.handler import (
+    ListResponse,
+    ReadModuleResponse,
+    ReadResourceResponse,
+    ResourcesHandler,
+)
+from pkl.msgapi import ClientResourceReader
+
+
+def test_read_modules():
+    class CustomModuleHandler(ResourcesHandler):
+        def list_response(self, uri: str) -> ListResponse:
+            return ListResponse(
+                pathElements=[{"name": "foo.pkl", "isDirectory": False}]
+            )
+
+        def read_response(self, uri: str) -> ReadResourceResponse:
+            return ReadModuleResponse(
+                contents="foo = 1",
+            )
+
+    _ = pkl.load(
+        Path("./tests/myModule.pkl").absolute().as_uri(),
+        allowedModules=["pkl:", "repl:", "file:", "customfs:"],
+        clientModuleReaders=[
+            {
+                "scheme": "customfs",
+                "hasHierarchicalUris": True,
+                "isGlobbable": True,
+                "isLocal": True,
+            }
+        ],
+        debug=True,
+        module_handler=CustomModuleHandler(),
+    )
+
+
+def test_read_modules_error():
+    class CustomModuleHandler(ResourcesHandler):
+        def list_response(self, uri: str) -> ListResponse:
+            return ListResponse(error="list error")
+
+        def read_response(self, uri: str) -> ReadResourceResponse:
+            return ReadModuleResponse(error="read module error")
+
+    with pytest.raises(Exception):
+        _ = pkl.load(
+            Path("./tests/myModule.pkl").absolute().as_uri(),
+            allowedModules=["pkl:", "repl:", "file:", "customfs:"],
+            clientModuleReaders=[
+                {
+                    "scheme": "customfs",
+                    "hasHierarchicalUris": True,
+                    "isGlobbable": True,
+                    "isLocal": True,
+                }
+            ],
+            module_handler=CustomModuleHandler(),
+            debug=True,
+        )
+
+
+def test_read_resources():
+    class CustomResourceHandler(ResourcesHandler):
+        def list_response(self, uri: str) -> ListResponse:
+            return ListResponse(
+                pathElements=[{"name": "foo.txt", "isDirectory": False}]
+            )
+
+        def read_response(self, uri: str) -> ReadResourceResponse:
+            return ReadResourceResponse(
+                contents=b"Hello, World!",
+            )
+
+    _ = pkl.load(
+        Path("./tests/with_read.pkl").absolute().as_uri(),
+        allowedModules=[
+            "pkl:",
+            "repl:",
+            "file:",
+        ],
+        allowedResources=[
+            "customfs:",
+        ],
+        clientResourceReaders=[
+            ClientResourceReader(
+                scheme="customfs",
+                hasHierarchicalUris=True,
+                isGlobbable=True,
+            )
+        ],
+        debug=True,
+        resource_handler=CustomResourceHandler(),
+    )

tests/test_server.py

@@ -0,0 +1,7 @@
+from pkl.server import PKLServer
+
+
+def test_server():
+    server = PKLServer()
+    server.start_process()
+    server.terminate()