pkl-python 0.1.0__py3-none-any.whl

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()

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()

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()

old/pkl-gen-python/main.py

@@ -0,0 +1,94 @@
+import argparse
+import logging
+from pathlib import Path
+from urllib.request import pathname2url
+import pkll
+
+# Mock-up classes and functions to match the TypeScript functionality
+# These would need to be implemented or adapted for your specific use case
+# from src import newEvaluator, PreconfiguredOptions
+# from generated import GeneratorSettings, load as loadGeneratorSettings
+# from generate import generateTypescript
+
+from generate import generate_python, GeneratorSettings
+
+logger = logging.getLogger()
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+
+def setup_logger(verbose):
+    if verbose:
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.INFO)
+
+
+def cli_handler(pkl_modules, settings_file_path, output_directory, dry_run, verbose):
+    setup_logger(verbose)
+
+    if not pkl_modules:
+        logger.error("You must provide at least one file to evaluate.")
+        return
+
+    settings_file = settings_file_path or (Path.cwd() / "generator-settings.pkl")
+    if not settings_file.exists():
+        settings_file = None
+
+    if settings_file:
+        logger.info(f"Using settings file at {settings_file}")
+    else:
+        logger.info("No settings file found, using default settings.")
+
+    if settings_file:
+        settings = pkll.load(pathname2url(str(settings_file)))
+    else:
+        settings = GeneratorSettings(dry_run=dry_run, output_directory=output_directory)
+
+    generate_python(pkl_modules, settings, verbose)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate TypeScript from PKL modules."
+    )
+    parser.add_argument(
+        "pklModules",
+        metavar="PklModule",
+        type=str,
+        nargs="+",
+        help="Pkl module to evaluate",
+    )
+    parser.add_argument(
+        "-s",
+        "--settings-file",
+        type=str,
+        help="Path to the generator-settings.pkl file",
+    )
+    parser.add_argument(
+        "-o",
+        "--output-directory",
+        type=str,
+        help="Directory to write generated files into",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Evaluate the Pkl modules but do not write them anywhere",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable debug logging"
+    )
+
+    args = parser.parse_args()
+
+    cli_handler(
+        pkl_modules=args.pklModules,
+        settings_file_path=Path(args.settings_file) if args.settings_file else None,
+        output_directory=args.output_directory,
+        dry_run=args.dry_run,
+        verbose=args.verbose,
+    )
+
+
+if __name__ == "__main__":
+    main()

out/ExtendModule_pkl.py

@@ -0,0 +1,29 @@
+# Code generated from Pkl module `ExtendModule`. DO NOT EDIT.
+from enum import Enum
+from typing import Dict, List, Literal, Optional, Union
+from dataclasses import dataclass
+import pkll
+from . import MyModule_pkl
+
+_NO_DEFAULT = object()
+
+@dataclass
+class ExtendModule(MyModule_pkl.MyModule):
+    bar: str = _NO_DEFAULT
+
+    _registered_identifier: str = "ExtendModule"
+
+    def __post_init__(self):
+        no_default_list = [("bar", self.bar)]
+        for n, x in no_default_list:
+            if x is _NO_DEFAULT:
+                raise TypeError(f"__init__ missing 1 required argument: '{n}'")
+
+    @classmethod
+    def load_pkl(cls, source: str):
+        # Load the Pkl module at the given source and evaluate it into `ExtendModule.Module`.
+        # - Parameter source: The source of the Pkl module.
+        config = pkll.load(source)
+        return cls(**config._asdict())
+
+breakpoint()

out/ExtendingOpenClass_pkl.py

@@ -0,0 +1,57 @@
+# Code generated from Pkl module `ExtendingOpenClass`. DO NOT EDIT.
+from enum import Enum
+from typing import Dict, List, Literal, Optional, Union
+from dataclasses import dataclass
+import pkll
+from . import lib3_pkl
+
+_NO_DEFAULT = object()
+
+@dataclass
+class MyClass(MyOpenClass):
+    myBoolean: bool = _NO_DEFAULT
+
+    myStr: str = "mystr"
+
+    _registered_identifier: str = "ExtendingOpenClass#MyClass"
+
+    def __post_init__(self):
+        no_default_list = [("myBoolean", self.myBoolean)]
+        for n, x in no_default_list:
+            if x is _NO_DEFAULT:
+                raise TypeError(f"__init__ missing 1 required argument: '{n}'")
+
+@dataclass
+class MyOpenClass:
+    myStr: str
+
+    _registered_identifier: str = "ExtendingOpenClass#MyOpenClass"
+
+@dataclass
+class MyClass2(lib3_pkl.GoGoGo):
+    myBoolean: bool = _NO_DEFAULT
+
+    duck: Literal["quack"] = "quack"
+
+    _registered_identifier: str = "ExtendingOpenClass#MyClass2"
+
+    def __post_init__(self):
+        no_default_list = [("myBoolean", self.myBoolean)]
+        for n, x in no_default_list:
+            if x is _NO_DEFAULT:
+                raise TypeError(f"__init__ missing 1 required argument: '{n}'")
+
+@dataclass
+class ExtendingOpenClass:
+    res1: MyClass
+
+    res2: MyClass2
+
+    _registered_identifier: str = "ExtendingOpenClass"
+
+    @classmethod
+    def load_pkl(cls, source: str):
+        # Load the Pkl module at the given source and evaluate it into `ExtendingOpenClass.Module`.
+        # - Parameter source: The source of the Pkl module.
+        config = pkll.load(source)
+        return cls(**config._asdict())

out/Foo_pkl.py

@@ -0,0 +1,61 @@
+# Code generated from Pkl module `Foo`. DO NOT EDIT.
+from typing import Dict, List, Literal, Optional, Union
+from dataclasses import dataclass
+import pkll
+
+_NO_DEFAULT = object()
+
+@dataclass
+class Animal(Being):
+    name: str = _NO_DEFAULT
+
+    _registered_identifier: str = "Foo#Animal"
+
+    def __post_init__(self):
+        no_default_list = [("name", self.name)]
+        for n, x in no_default_list:
+            if x is _NO_DEFAULT:
+                raise TypeError(f"__init__ missing 1 required argument: '{n}'")
+
+@dataclass
+class Being:
+    exists: bool
+
+    _registered_identifier: str = "Foo#Being"
+
+@dataclass
+class Bird(Animal):
+    flies: bool = _NO_DEFAULT
+
+    _registered_identifier: str = "Foo#Bird"
+
+    def __post_init__(self):
+        no_default_list = [("flies", self.flies)]
+        for n, x in no_default_list:
+            if x is _NO_DEFAULT:
+                raise TypeError(f"__init__ missing 1 required argument: '{n}'")
+
+@dataclass
+class Dog(Animal):
+    barks: bool = _NO_DEFAULT
+
+    _registered_identifier: str = "Foo#Dog"
+
+    def __post_init__(self):
+        no_default_list = [("barks", self.barks)]
+        for n, x in no_default_list:
+            if x is _NO_DEFAULT:
+                raise TypeError(f"__init__ missing 1 required argument: '{n}'")
+
+@dataclass
+class Foo:
+    animals: List[Animal]
+
+    _registered_identifier: str = "Foo"
+
+    @classmethod
+    def load_pkl(cls, source: str):
+        # Load the Pkl module at the given source and evaluate it into `Foo.Module`.
+        # - Parameter source: The source of the Pkl module.
+        config = pkll.load(source)
+        return cls(**config._asdict())