pkl-python 0.1.11__tar.gz → 0.1.12__tar.gz

{pkl-python-0.1.11 → pkl-python-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pkl-python
-Version: 0.1.11
+Version: 0.1.12
 Summary: Python library for Apple's PKL.
 Author-email: Jungwoo Yang <jwyang0213@gmail.com>
 License: MIT License
@@ -62,7 +62,7 @@ pip install pkl-python
 ```
 
 ### Basic Usage
-Here's how you can start using PKLL to load a PKL module:
+Here's how you can start using `pkl-python` to load a PKL module:
 
 ```python
 import pkl

{pkl-python-0.1.11 → pkl-python-0.1.12}/README.md

@@ -15,7 +15,7 @@ pip install pkl-python
 ```
 
 ### Basic Usage
-Here's how you can start using PKLL to load a PKL module:
+Here's how you can start using `pkl-python` to load a PKL module:
 
 ```python
 import pkl

pkl-python-0.1.12/pkl/VERSION

@@ -0,0 +1 @@
+0.1.12

{pkl-python-0.1.11 → pkl-python-0.1.12}/pkl/__init__.py

@@ -86,11 +86,13 @@ def load(
     if project_dir is PKL_DEFAULT:
         project_dir = _search_project_dir(str(module_uri))
 
-    with EvaluatorManager(parser=parser, debug=debug) as manager:
+    with EvaluatorManager(debug=debug) as manager:
         if (Path(project_dir) / "PklProject").exists():
-            evaluator = manager.new_project_evaluator(project_dir, evaluator_options)
+            evaluator = manager.new_project_evaluator(
+                project_dir, evaluator_options, parser=parser
+            )
         else:
-            evaluator = manager.new_evaluator(evaluator_options)
+            evaluator = manager.new_evaluator(evaluator_options, parser=parser)
         config = evaluator.evaluate_expression(source, expr)
     return config
 

{pkl-python-0.1.11 → pkl-python-0.1.12}/pkl/evaluator_manager.py

@@ -45,6 +45,8 @@ class Evaluator:
         manager: "EvaluatorManager",
         resource_readers: Optional[List[ResourceReader]] = None,
         module_readers: Optional[List[ModuleReader]] = None,
+        *,
+        parser=None,
     ):
         self.evaluatorId = evaluatorId
         self.pending_requests = {}
@@ -55,6 +57,8 @@ class Evaluator:
         self.resource_readers = resource_readers or []
         self.module_readers = module_readers or []
 
+        self.parser = parser or Parser()
+
     def _get_requestId(self):
         res = self._prev_requestId + 1
         self._prev_requestId = res
@@ -79,7 +83,7 @@ class Evaluator:
     def evaluate_expression(self, source: ModuleSource, expr: Optional[str]):
         binary_res = self._evaluate_expression_raw(source, expr)
         decoded = msgpack.unpackb(binary_res, strict_map_key=False)
-        parsed = self._manager._parser.parse(decoded)
+        parsed = self.parser.parse(decoded)
         return parsed
 
     def _evaluate_expression_raw(self, source: ModuleSource, expr: Optional[str]):
@@ -100,7 +104,7 @@ class Evaluator:
         response: EvaluateResponse = self._manager.receive(requestId)
 
         if response.error is not None:
-            raise PklError(response.error)
+            raise PklError("\n" + response.error)
         return response.result
 
     def evaluate_module(self, source: ModuleSource):
@@ -214,7 +218,10 @@ class Evaluator:
 
 class EvaluatorManager:
     def __init__(
-        self, pkl_command: Optional[List[str]] = None, *, parser=None, debug=False
+        self,
+        pkl_command: Optional[List[str]] = None,
+        *,
+        debug=False,
     ):
         self._evaluators: Dict[int, Evaluator] = {}
         self._closed = False
@@ -223,7 +230,6 @@ class EvaluatorManager:
         self._server = PKLServer(pkl_command, debug=debug)
 
         self._prev_id = -100
-        self._parser = parser or Parser()
 
     def send(self, msg: OutgoingMessage):
         obj = msg.to_json()
@@ -258,7 +264,7 @@ class EvaluatorManager:
             self._evaluators[decoded.evaluatorId].handle_request(decoded)
 
     def new_evaluator(
-        self, options: EvaluatorOptions, project: Optional[Project] = None
+        self, options: EvaluatorOptions, project: Optional[Project] = None, parser=None
     ):
         if self._closed:
             raise ValueError("Server closed")
@@ -286,14 +292,17 @@ class EvaluatorManager:
             self,
             resource_readers=options.resourceReaders,
             module_readers=options.moduleReaders,
+            parser=parser,
         )
         self._evaluators[response.evaluatorId] = evaluator
         return evaluator
 
-    def new_project_evaluator(self, project_dir: str, options: EvaluatorOptions):
-        project_evaluator = self.new_evaluator(PreconfiguredOptions())
+    def new_project_evaluator(
+        self, project_dir: str, options: EvaluatorOptions, parser=None
+    ):
+        project_evaluator = self.new_evaluator(PreconfiguredOptions(), parser=parser)
         project = load_project_from_evaluator(project_evaluator, project_dir)
-        evaluator = self.new_evaluator(options, project)
+        evaluator = self.new_evaluator(options, project, parser)
         return evaluator
 
     def _get_start_requestId(self):

{pkl-python-0.1.11 → pkl-python-0.1.12}/pkl/parser.py

@@ -1,10 +1,9 @@
 import sys
 import types
-from collections import namedtuple
 from dataclasses import dataclass, make_dataclass
 from datetime import timedelta
 from enum import Enum, auto
-from typing import Any, List, Literal
+from typing import Generic, List, Literal, TypeVar
 
 # create module for lookup
 _lookup_module = types.ModuleType(__name__ + "._lookup")
@@ -44,10 +43,14 @@ CODE_ENTRY = 0x11
 CODE_ELEMENT = 0x12
 
 
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+
 @dataclass
-class Pair:
-    first: Any
-    second: Any
+class Pair(Generic[T1, T2]):
+    first: T1
+    second: T2
 
 
 @dataclass
@@ -94,13 +97,8 @@ class Regex:
 class Parser:
     def __init__(
         self,
+        namespace=None,
         force_render=False,
-        *,
-        typed_dynamic_result_type=ResultType.DATACLASS,
-        pair_result_type=ResultType.DATACLASS,
-        datasize_result_type=ResultType.DATACLASS,
-        regex_result_type=ResultType.DATACLASS,
-        intseq_result_type=ResultType.DATACLASS,
     ):
         self.type_handlers = {
             CODE_TYPED_DYNAMIC: self.parse_typed_dynamic,
@@ -120,18 +118,9 @@ class Parser:
             CODE_ENTRY: self.parse_entry,
             CODE_ELEMENT: self.parse_element,
         }
-        self._dataclass_cache = {}
-        self._namedtuple_cache = {
-            "__Pair__": namedtuple("Pair", ["first", "second"]),
-            "__DataSize__": namedtuple("DataSize", ["value", "unit"]),
-            "__Regex__": namedtuple("Regex", ["pattern"]),
-        }
-        self._force_render = force_render
-        self._typed_dynamic_result_type = typed_dynamic_result_type
-        self._pair_result_type = pair_result_type
-        self._datasize_result_type = datasize_result_type
-        self._regex_result_type = regex_result_type
-        self._intseq_result_type = intseq_result_type
+        self.namespace = namespace
+        self.dataclass_cache = {}
+        self.force_render = force_render
 
     def parse(self, obj):
         return self.handle_type(obj)
@@ -151,12 +140,12 @@ class Parser:
         return obj
 
     def get_dataclass_class(self, class_name: str, keys: List[str]):
-        if class_name not in self._dataclass_cache:
+        if class_name not in self.dataclass_cache:
             dynamic_class = make_dataclass(class_name, keys)
             dynamic_class.__module__ = _lookup_module.__name__
             setattr(_lookup_module, class_name, dynamic_class)
-            self._dataclass_cache[class_name] = dynamic_class
-        dynamic_class = self._dataclass_cache[class_name]
+            self.dataclass_cache[class_name] = dynamic_class
+        dynamic_class = self.dataclass_cache[class_name]
         return dynamic_class
 
     def parse_typed_dynamic(self, obj):
@@ -166,7 +155,7 @@ class Parser:
         property_list = list(map(self.handle_type, members))
 
         if CODE_ELEMENT in member_types:  # has element
-            if len(member_types) > 1 and not self._force_render:
+            if len(member_types) > 1 and not self.force_render:
                 raise ValueError(
                     "Cannot render object with both elements and properties/entries.\n"
                     "\tUse 'force_render=True'"
@@ -177,19 +166,16 @@ class Parser:
 
         # only properties and entries
         members = {k: v for m in property_list for k, v in m.items()}
-        result_type = self._typed_dynamic_result_type
         class_name = full_class_name.split("#")[-1].split(".")[-1]
-        if result_type == ResultType.DATACLASS:
-            dynamic_class = self.get_dataclass_class(class_name, members.keys())
-            res = dynamic_class(*members.values())
-            return res
-        elif result_type == ResultType.NAMEDTUPLE:
-            res = namedtuple(class_name, members.keys())(*members.values())
-            return res
-        elif result_type == ResultType.DICTIONARY:
-            return {full_class_name: members}
+
+        if self.namespace is not None:
+            if class_name not in self.namespace:
+                raise ValueError(f"'namespace' provided but '{class_name}' not found")
+            clazz = self.namespace[class_name]
         else:
-            raise ValueError(f"invalid result_type: '{result_type}'")
+            clazz = self.get_dataclass_class(class_name, members.keys())
+        res = clazz(*members.values())
+        return res
 
     def parse_map(self, obj):
         members = obj[1]
@@ -213,42 +199,16 @@ class Parser:
         return Duration(value, unit)
 
     def parse_pair(self, obj):
-        if self._pair_result_type == ResultType.DATACLASS:
-            return Pair(obj[1], obj[2])
-        elif self._pair_result_type == ResultType.NAMEDTUPLE:
-            return self._namedtuple_cache["__Pair__"](obj[1], obj[2])
-        elif self._pair_result_type == ResultType.LIST:
-            return [obj[1], obj[2]]
-        elif self._pair_result_type == ResultType.TUPLE:
-            return (obj[1], obj[2])
-        else:
-            raise ValueError(f"ResultType '{self._pair_result_type}' not supported")
+        return Pair(obj[1], obj[2])
 
     def parse_datasize(self, obj):
-        if self._datasize_result_type == ResultType.DATACLASS:
-            return DataSize(obj[1], obj[2])
-        elif self._datasize_result_type == ResultType.NAMEDTUPLE:
-            return self._namedtuple_cache["__DataSize__"](obj[1], obj[2])
-        elif self._datasize_result_type == ResultType.TUPLE:
-            return (obj[1], obj[2])
-        else:
-            raise ValueError(f"ResultType '{self._datasize_result_type}' not supported")
+        return DataSize(obj[1], obj[2])
 
     def parse_intseq(self, obj):
-        if self._intseq_result_type == ResultType.DATACLASS:
-            return IntSeq(obj[1], obj[2], obj[3])
-        elif self._intseq_result_type == ResultType.RANGE:
-            return range(obj[1], obj[2], obj[3])
-        else:
-            raise ValueError(f"ResultType '{self._intseq_result_type}' not supported")
+        return IntSeq(obj[1], obj[2], obj[3])
 
     def parse_regex(self, obj):
-        if self._datasize_result_type == ResultType.DATACLASS:
-            return Regex(obj[1])
-        elif self._datasize_result_type == ResultType.NAMEDTUPLE:
-            return self._namedtuple_cache["__Regex__"](obj[1])
-        else:
-            raise ValueError(f"ResultType '{self._datasize_result_type}' not supported")
+        return Regex(obj[1])
 
     def parse_class(self, obj):
         return

{pkl-python-0.1.11 → pkl-python-0.1.12}/pkl/server.py

@@ -129,12 +129,11 @@ class PKLServer:
         return msg
 
     def _receive(self, stream):
-        msg = self._read(stream)
         while True:
-            self.unpacker.feed(msg)
             for unpacked in self.unpacker:
                 return unpacked
             msg = self._read(stream)
+            self.unpacker.feed(msg)
 
     def receive(self):
         if self.closed:

{pkl-python-0.1.11 → pkl-python-0.1.12}/pkl_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pkl-python
-Version: 0.1.11
+Version: 0.1.12
 Summary: Python library for Apple's PKL.
 Author-email: Jungwoo Yang <jwyang0213@gmail.com>
 License: MIT License
@@ -62,7 +62,7 @@ pip install pkl-python
 ```
 
 ### Basic Usage
-Here's how you can start using PKLL to load a PKL module:
+Here's how you can start using `pkl-python` to load a PKL module:
 
 ```python
 import pkl

pkl-python-0.1.11/pkl/VERSION

@@ -1 +0,0 @@
-0.1.11