pkl-python 0.1.0__tar.gz

pkl-python-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,91 @@
+# 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/archive/cmd/pkl-gen-go/pkl-gen-python.py

@@ -0,0 +1,102 @@
+from typing import Optional
+import argparse
+import sys
+import os
+from pathlib import Path
+
+VERSION = "development"
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generates Python bindings for a Pkl module")
+    
+    # Positional argument for module
+    parser.add_argument('module', help="The module for which to generate bindings", nargs="?")
+
+    # Optional arguments
+    parser.add_argument('--generator-settings', help="The path to a generator settings file", default="")
+    parser.add_argument('--output-path', help="The output directory to write generated sources into", default="")
+    parser.add_argument('--base-path', help="The base path used to determine relative output", default="")
+    parser.add_argument('--mapping', action='append', help="The mapping of a Pkl module name to a Python package name", default=[])
+    parser.add_argument('--suppress-format-warning', action='store_true', help="Suppress warnings around formatting issues")
+    parser.add_argument('--allowed-modules', action='append', help="URI patterns that determine which modules can be loaded and evaluated", default=[])
+    parser.add_argument('--allowed-resources', action='append', help="URI patterns that determine which resources can be loaded and evaluated", default=[])
+    parser.add_argument('--project-dir', help="The project directory to load dependency and evaluator settings from", default="")
+    parser.add_argument('--dry-run', action='store_true', help="Print out the names of the files that will be generated, but don't write any files")
+    # parser.add_argument('--version', action='store_true', help="Print the version and exit")
+
+    return parser.parse_args()
+
+def find_project_dir(start_path: str) -> Optional[str]:
+    current_path = Path(start_path)
+    while current_path != current_path.parent:
+        if (current_path / "PklProject").exists():
+            return str(current_path)
+        current_path = current_path.parent
+    return None
+
+
+// Loads the settings for controlling codegen.
+// Uses a Pkl evaluator that is separate from what's used for actually running codegen.
+func loadGeneratorSettings(generatorSettingsPath string, projectDirFlag string) (*generatorsettings.GeneratorSettings, error) {
+	projectDir := findProjectDir(projectDirFlag)
+	var evaluator pkl.Evaluator
+	var err error
+	if projectDir != "" {
+		evaluator, err = pkl.NewProjectEvaluator(context.Background(), projectDir, pkl.PreconfiguredOptions)
+	} else {
+		evaluator, err = pkl.NewEvaluator(context.Background(), pkl.PreconfiguredOptions)
+	}
+	if err != nil {
+		panic(err)
+	}
+	var source *pkl.ModuleSource
+	if generatorSettingsPath != "" {
+		source = pkl.FileSource(generatorSettingsPath)
+	} else if fileExists("generator-settings.pkl") {
+		source = pkl.FileSource("generator-settings.pkl")
+	} else {
+		source = generatorSettingsSource()
+	}
+	return generatorsettings.Load(context.Background(), evaluator, source)
+}
+
+def load_generator_settings(generator_settings_path, project_dir_flag):
+    project_dir = find_project_dir(project_dir_flag)
+    evaluator = None  # Placeholder for evaluator initialization
+    # Initialize your evaluator here based on project_dir, if applicable
+
+    settings_path = generator_settings_path if generator_settings_path else "generator-settings.pkl"
+    if not os.path.exists(settings_path):
+        # Fallback to a default source or handle error
+        print("Settings file not found.")
+        return None
+
+    with open(settings_path, 'r') as settings_file:
+        settings = json.load(settings_file)
+        # Assuming the settings file is in JSON format
+        # For YAML, use `settings = yaml.safe_load(settings_file)`
+
+    # Placeholder: Load and return the settings using the evaluator
+    # This part of the logic will depend on how you intend to use the settings and the evaluator
+    return settings
+
+
+def main():
+    args = parse_args()
+
+    if not args.module:
+        print("Error: Module name is required.")
+        sys.exit(1)
+
+    project_dir = find_project_dir(os.getcwd())
+    evaluator = PklEvaluator(project_dir)
+    settings = {}
+    if args.generator_settings:
+        settings = load_generator_settings(args.generator_settings, project_dir)
+
+    # Placeholder for the main logic to generate Python bindings.
+    # You would need to implement this based on how the Python bindings are generated from Pkl files.
+    print(f"Generating bindings for module: {args.module} with settings: {settings} and output path: {args.output_path}")
+
+if __name__ == "__main__":
+    main()

pkl-python-0.1.0/archive/cmd/pkl-gen-python/pkl-gen-python.py

@@ -0,0 +1,235 @@
+import argparse
+import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict
+from textwrap import dedent
+
+import pkll
+
+
+def file_exists(filepath):
+    return Path(filepath).exists()
+
+
+def do_find_project_dir(directory: Path) -> Path:
+    if (directory / "PklProject").exists():
+        return directory
+    parent = directory.parent
+    if parent == directory:
+        return Path()
+    return do_find_project_dir(parent)
+
+
+def find_project_dir(project_dir_flag: str) -> Path:
+    if project_dir_flag:
+        return Path(project_dir_flag).resolve()
+    cwd = Path.cwd()
+    return do_find_project_dir(cwd)
+
+
+def load_generator_settings(generator_settings_path: str, project_dir_flag: str):
+    project_dir = find_project_dir(project_dir_flag)
+    if project_dir:
+        print(f"Project directory found: {project_dir}")
+    else:
+        print("No specific project directory found, using current working directory.")
+
+    if generator_settings_path:
+        settings_path = Path(generator_settings_path)
+    else:
+        settings_path = project_dir / "generator-settings.pkl"
+        if not settings_path.exists():
+            print("Generator settings file not found. Using default settings...")
+            raise NotImplementedError
+
+    print(f"Loading settings from: {settings_path}")
+
+    config = pkll.load(settings_path.absolute().as_uri(), allowedResources=["file:"])
+    return config
+
+
+def generate_dry_run(tmp_file_path: str, output_path: str, settings) -> None:
+    #filenames = evaluate_pkl("output.files.toMap().keys.toList()", tmp_file_path)
+    filenames = pkll.load(Path(tmp_file_path).as_uri(), expr="output.files.toMap().keys.toList()")
+    
+    print("Dry run; printing filenames but not writing files to disk")
+    for filename in filenames:
+        if settings.basePath and filename.startswith(settings.basePath):
+            #filename = filename[len(settings.basePath) :]
+            filename = Path(filename).relative_to(settings.basePath)
+        else:
+            continue
+        print(Path(output_path) / filename)
+
+
+def generate_python(
+    pkl_module_path: str, settings, output_path: str, dry_run: bool
+) -> None:
+    module_to_evaluate = dedent(
+        f"""\
+        amends "{Path(settings.generatorScriptPath).absolute()}"
+        import "{Path(pkl_module_path).absolute()}" as theModule
+
+        moduleToGenerate = theModule
+    """
+    )
+    module_to_evaluate = dedent(
+        """\
+        import "{}" as Generator
+        import "{}" as theModule
+
+        local gen = new Generator {{
+          codegenSettings {{
+            packageMappings {{
+                {}
+            }}
+            {}
+            structTags {{
+                {}
+            }}
+          }}
+          moduleToGenerate = theModule
+        }}
+        output = gen.output\
+    """.format(
+            Path(settings.generatorScriptPath).absolute(),
+            Path(pkl_module_path).absolute(),
+            "\\n".join(f'["{k}"] = "{v}"' for k, v in settings.packageMappings),
+            f'basePath = "{settings.basePath}"' if settings.basePath else "",
+            "\\n".join(f'["{k}"] = "{v}"' for k, v in settings.structTags),
+        )
+    )
+    module_to_evaluate = dedent(
+        """\
+        amends "{}"
+        import "{}" as theModule
+
+        codegenSettings = new {{
+            packageMappings {{
+                {}
+            }}
+            {}
+            structTags {{
+                {}
+            }}
+        }}
+        moduleToGenerate = theModule
+    """.format(
+            Path(settings.generatorScriptPath).absolute(),
+            Path(pkl_module_path).absolute(),
+            "\\n".join(f'["{k}"] = "{v}"' for k, v in settings.packageMappings),
+            f'basePath = "{settings.basePath}"' if settings.basePath else "",
+            "\\n".join(f'["{k}"] = "{v}"' for k, v in settings.structTags),
+        )
+    )
+
+    with tempfile.NamedTemporaryFile(suffix=".pkl") as tmp_file:
+        tmp_file.write(module_to_evaluate.encode())
+        tmp_file.flush()
+        print("module tmp file:", tmp_file.name)
+
+        if dry_run or settings.dryRun:
+            generate_dry_run(tmp_file.name, output_path, settings)
+            return
+
+        config = pkll.load(
+            Path(tmp_file.name).as_uri(),
+            expr="output",
+            allowedResources=["env:", "prop:", "package:", "projectpackage:", "file:"],
+            debug=True,
+        )
+        print(config)
+    breakpoint()
+
+
+def main():
+    # Create the parser
+    parser = argparse.ArgumentParser(
+        description="Generates Python bindings for a Pkl module."
+    )
+
+    # Positional arguments
+    parser.add_argument("module", help="The Pkl module to process.")
+
+    # Optional arguments
+    parser.add_argument(
+        "--generator-settings",
+        default="",
+        help="The path to a generator settings file.",
+    )
+    parser.add_argument(
+        "--output-path",
+        default="",
+        help="The output directory to write generated sources into.",
+    )
+    parser.add_argument(
+        "--base-path",
+        default="",
+        help="The base path used to determine relative output paths.",
+    )
+    parser.add_argument(
+        "--generate-script",
+        default="",
+        help="The Generate.pkl script to use for code generation.",
+    )
+    parser.add_argument(
+        "--project-dir",
+        default="",
+        help="The project directory to load dependency and evaluator settings from.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print out the names of the files that will be generated, but don't write any files.",
+    )
+
+    # Flags
+    parser.add_argument(
+        "--suppress-format-warning",
+        action="store_true",
+        help="Suppress warnings around formatting issues.",
+    )
+    parser.add_argument(
+        "--version", action="store_true", help="Print the version of the tool and exit."
+    )
+
+    # Repeatable arguments
+    parser.add_argument(
+        "--mapping",
+        action="append",
+        nargs=2,
+        metavar=("PKL_MODULE_NAME", "PYTHON_PACKAGE_NAME"),
+        help="Mapping of a Pkl module name to a Python package name. This option can be repeated.",
+    )
+    parser.add_argument(
+        "--allowed-modules",
+        action="append",
+        help="URI patterns that determine which modules can be loaded and evaluated. Can be repeated.",
+    )
+    parser.add_argument(
+        "--allowed-resources",
+        action="append",
+        help="URI patterns that determine which resources can be read and evaluated. Can be repeated.",
+    )
+
+    # Parse the arguments
+    args = parser.parse_args()
+
+    if args.version:
+        print("Version placeholder")  # Replace with actual version logic
+        sys.exit()
+
+    settings = load_generator_settings(args.generator_settings, args.project_dir)
+
+    if not args.output_path:
+        output_path = os.getcwd()
+    else:
+        output_path = args.output_path
+
+    generate_python(args.module, settings, output_path, args.dry_run)
+
+
+if __name__ == "__main__":
+    main()

pkl-python-0.1.0/old/pkl-gen-python/generate.py

@@ -0,0 +1,112 @@
+import os
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import sys
+import pkll
+
+# Assuming 'Evaluator' and 'GeneratorSettings' are classes you will define or adapt in Python
+# from src.evaluator.evaluator import Evaluator
+# from generated import GeneratorSettings
+import logging
+
+logger = logging.getLogger()
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+chalk = logging  # Simplified representation; in Python, you might use colorama or termcolor for colored output
+
+class GeneratorSettings:
+    """
+    GeneratorSettings holds configuration for generating TypeScript files from PKL modules.
+    Attributes:
+        output_directory (str|None): The output path to write generated files into.
+        dry_run (bool|None): If true, evaluates the PKL modules but does not write any files.
+        generator_script_path (str|None): The Generator.pkl script to use for code generation.
+    """
+    def __init__(self, output_directory=None, dry_run=None, generator_script_path=None):
+        self.output_directory = output_directory
+        self.dry_run = dry_run
+        self.generator_script_path = generator_script_path
+
+
+def to_absolute_path(path: str) -> Path:
+    return Path(path).resolve()
+
+
+def generate_python(
+    pkl_module_paths: list, settings: GeneratorSettings, verbose: bool,
+):
+    logger.info(
+        f"Generating TypeScript sources for modules {', '.join(pkl_module_paths)}"
+    )
+
+    pkl_module_paths = [to_absolute_path(path) for path in pkl_module_paths]
+
+    if settings.generator_script_path:
+        if ":" in settings.generator_script_path:
+            settings.generator_script_path = Path(settings.generator_script_path)
+        else:
+            settings.generator_script_path = to_absolute_path(
+                settings.generator_script_path
+            )
+        logger.warning(
+            f"Using custom generator script: {settings.generator_script_path}"
+        )
+    else:
+        # Adjust the path as necessary for your project structure
+        settings.generator_script_path = (
+            Path(__file__).parent / "../codegen/src/Generator.pkl"
+        )
+
+    with TemporaryDirectory() as tmp_dir:
+        output_dir = to_absolute_path(
+            settings.output_directory if settings.output_directory else ".out"
+        )
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        for index, pkl_input_module in enumerate(pkl_module_paths):
+            module_to_evaluate = f"""
+amends "{settings.generator_script_path}"
+
+import "{pkl_input_module}" as theModule
+
+moduleToGenerate = theModule
+            """
+
+            if logger.getEffectiveLevel() <= logging.DEBUG:
+                logger.info(
+                    f"""
+Evaluating temp Pkl module:
+---
+{module_to_evaluate}
+                """
+                )
+
+            tmp_file_path = Path(tmp_dir) / f"pkl-gen-python-{index}.pkl"
+            with open(tmp_file_path, "w", encoding="utf-8") as tmp_file:
+                tmp_file.write(module_to_evaluate)
+
+            files = pkll.load(tmp_file_path.as_uri(), debug=verbose)
+
+            for filename, contents in files.items():
+                path = output_dir / filename
+                if not settings.dry_run:
+                    with open(path, "w", encoding="utf-8") as file:
+                        file.write(contents)
+                logger.info(f"Generated: {path}")
+
+
+# Mockup classes to complete the example
+class Evaluator:
+    async def evaluate_output_files(self, uri):
+        return {"example.ts": "const example = true;"}
+
+
+# Example usage
+def main():
+    settings = GeneratorSettings(output_directory="path/to/output", dry_run=False)
+    generate_python(
+        ["path/to/module1", "path/to/module2"], settings
+    )
+
+
+if __name__ == "__main__":
+    main()