kaia-foundation 3.7.3__tar.gz

kaia_foundation-3.7.3/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: kaia-foundation
+Version: 3.7.3
+Summary: Utilities used in Kaia project
+Author-email: Yuri Okulovsky <yuri.okulovsky@gmail.com>
+License-Expression: LGPL-3.0-or-later
+Project-URL: repository, https://github.com/okulovsky/kaia/tree/main/foundation_kaia
+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: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Development Status :: 4 - Beta
+Requires-Python: <4.0,>=3.10
+Requires-Dist: yo_fluq
+Requires-Dist: requests
+Requires-Dist: jsonpickle
+Requires-Dist: Jinja2
+Requires-Dist: flask

kaia_foundation-3.7.3/foundation_kaia/fork/__init__.py

@@ -0,0 +1 @@
+from .fork import Fork

kaia_foundation-3.7.3/foundation_kaia/fork/fork.py

@@ -0,0 +1,56 @@
+import threading
+import subprocess
+import sys
+import pickle
+import atexit
+import time
+from uuid import uuid4
+from typing import Callable
+from ..misc import Loc
+
+
+class Fork:
+    def __init__(self, method: Callable, raise_if_exited: bool = True):
+        self.method = method
+        self.process: subprocess.Popen|None = None
+        self.monitor_thread = None
+        self.exception_raised = False
+        self.raise_if_exited = raise_if_exited
+
+    def start(self):
+        try:
+            path = Loc.temp_folder / ('fork_' + str(uuid4()))
+            with open(path, 'wb') as stream:
+                pickle.dump(self.method, stream)
+        except Exception as ex:
+            raise ValueError(f"Cannot pickle {self.method} to run in fork") from ex
+        self.process = subprocess.Popen(
+            [
+                sys.executable,
+                '-m',
+                'foundation_kaia.fork.fork_worker',
+                str(self.method),
+                str(path)
+            ],
+        )
+        atexit.register(self.terminate)
+
+        if self.raise_if_exited:
+            self.monitor_thread = threading.Thread(target=self._monitor_process, daemon=True)
+            self.monitor_thread.start()
+
+        return self
+
+    def _monitor_process(self):
+        while True:
+            if self.process.poll() is not None:
+                if not self.exception_raised:
+                    raise RuntimeError(f"Subprocess for {str(self.method)} exited unexpectedly with code {self.process.returncode}")
+                break
+            time.sleep(0.1)
+
+    def terminate(self):
+        if self.process and self.process.poll() is None:
+            self.exception_raised = True
+            self.process.terminate()
+            self.process.wait()

kaia_foundation-3.7.3/foundation_kaia/fork/fork_worker.py

@@ -0,0 +1,26 @@
+import sys
+import pickle
+import os
+import traceback
+
+if __name__ == '__main__':
+    name = sys.argv[1]
+    file = sys.argv[2]
+
+    try:
+        with open(file, 'rb') as stream:
+            method = pickle.load(stream)
+        os.unlink(file)
+    except:
+        print(f"Subprocess for {name}: cannot read entry point", file=sys.stderr)
+        print(traceback.format_exc(), file=sys.stderr)
+        raise
+
+    try:
+        method()
+    except:
+        print(f"Subprocess for {name}: exception in entry point", file=sys.stderr)
+        print(traceback.format_exc(), file=sys.stderr)
+        raise
+
+

kaia_foundation-3.7.3/foundation_kaia/marshalling/__init__.py

@@ -0,0 +1,6 @@
+from .endpoint import endpoint
+from .server import Server
+from .api import Api, bind_to_api
+from .test_api import TestApi
+from .api_utils import ApiUtils
+from .signature_processor import SignatureProcessor

kaia_foundation-3.7.3/foundation_kaia/marshalling/api.py

@@ -0,0 +1,41 @@
+from typing import *
+from .marshalling_metadata import MarshallingMetadata
+from .api_binding import ApiBinding
+from .api_utils import ApiUtils
+
+def bind_to_api(api_type: Type):
+    def decorator(cls):
+        metadata = MarshallingMetadata.get_endpoints_from_type(api_type)
+        abs_methods = set(cls.__abstractmethods__)
+        for meta in metadata:
+            if meta.name not in abs_methods:
+                raise ValueError(f"{meta.name} is present in API but absent/not marked as abstract in {api_type}")
+            abs_methods.remove(meta.name)
+        cls.__abstractmethods__ = frozenset(abs_methods)
+        cls.__api_endpoints__ = metadata
+        return cls
+    return decorator
+
+
+class Api:
+    def __init__(self, address: str):
+        ApiUtils.check_address(address)
+        self.address = address
+
+        for meta in type(self).__api_endpoints__:
+            setattr(self, meta.name, ApiBinding(address, meta))
+
+
+    def wait(self, max_time_in_seconds=10):
+        ApiUtils.wait_for_reply(
+            f'http://{self.address}/heartbeat',
+            max_time_in_seconds,
+        )
+
+
+
+
+
+
+
+

kaia_foundation-3.7.3/foundation_kaia/marshalling/api_binding.py

@@ -0,0 +1,35 @@
+from .marshalling_metadata import MarshallingMetadata
+from .format import Format
+import requests
+
+class ApiBinding:
+    def __init__(self,
+                 address: str,
+                 metadata: MarshallingMetadata,
+                 ):
+        self.metadata = metadata
+        self.address = address
+
+    def __call__(self, *args, **kwargs):
+        address = f'http://{self.address}{self.metadata.get_endpoint_address()}'
+        arguments = self.metadata.signature.to_kwargs_only(*args, **kwargs)
+        data = dict(
+            arguments = Format.encode(arguments),
+        )
+
+        reply = requests.request(
+            self.metadata.endpoint.method,
+            address,
+            json = data,
+        )
+        if reply.status_code == 200:
+            result = Format.decode(reply.json())
+            return result['result']
+        try:
+            error = reply.json()
+        except:
+            raise ValueError(f"Call to {address} caused unprocessed error on the server\n\n{reply.text}")
+        if 'error' not in error:
+            raise ValueError(f"Call to {address} caused unprocessed error on the server\n\n{error}")
+        raise ValueError(f"Call to {address} caused exception:\n\n{error['error']}")
+

kaia_foundation-3.7.3/foundation_kaia/marshalling/api_utils.py

@@ -0,0 +1,36 @@
+import datetime
+import re
+import time
+import requests
+
+class ApiUtils:
+    @staticmethod
+    def check_address(address):
+        if not re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d{1,5}', address):
+            raise ValueError(f'Address must be IP:port, no protocol, no trailing slash, but was:\n{address}')
+
+
+    @staticmethod
+    def wait_for_reply(url, time_in_seconds, endpoint_name=''):
+        reply = None
+        if endpoint_name == '':
+            endpoint_name = url
+        begin = datetime.datetime.now()
+        for i in range(time_in_seconds * 100):
+            time.sleep(0.01)
+            if i>2 and (datetime.datetime.now()-begin).total_seconds() > time_in_seconds:
+                break
+            try:
+                reply = requests.get(url)
+            except:
+                continue
+            if reply.status_code == 200:
+                break
+        if reply is None:
+            raise ValueError(
+                f"Endpoint {endpoint_name} was not reacheable within {time_in_seconds} seconds")
+        if reply.status_code != 200:
+            raise ValueError(
+                f"Endpoint {endpoint_name} was reacheable, but returned bad status code {reply.status_code}\n{reply.text}")
+
+

kaia_foundation-3.7.3/foundation_kaia/marshalling/endpoint.py

@@ -0,0 +1,26 @@
+from functools import wraps
+from dataclasses import dataclass
+
+
+@dataclass
+class EndpointMetadata:
+    url: str|None
+    method: str
+    json_pickle_result: bool
+
+
+def endpoint(
+        *,
+        url: str|None = None,
+        method = 'POST',
+        json_pickle_result: bool = False
+    ):
+    def decorator(func):
+        # Add the metadata as an attribute of the function
+        func._metadata = EndpointMetadata(url, method, json_pickle_result)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

kaia_foundation-3.7.3/foundation_kaia/marshalling/format.py

@@ -0,0 +1,67 @@
+import json
+import pickle
+import base64
+import jsonpickle
+
+
+
+class NoTupleJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, tuple):
+            raise TypeError("Tuples are not allowed in JSON serialization.")
+        return super().default(obj)
+
+
+class Format:
+    CONTROL_FIELD = '@type'
+    CONTENT_FIELD = '@content'
+
+    @staticmethod
+    def check_json(obj):
+        if obj is None:
+            return True
+        if isinstance(obj, str) or isinstance(obj, int) or isinstance(obj, float) or isinstance(obj, bool):
+            return True
+        if isinstance(obj, list):
+            return all(Format.check_json(z) for z in obj)
+        if isinstance(obj, dict):
+            return all(Format.check_json(z) for z in obj.values())
+        return False
+
+    @staticmethod
+    def encode(data: dict, use_json_pickle: bool = False):
+        result = {}
+        for key, value in data.items():
+            if Format.check_json(value):
+                result[key] = value
+            else:
+                if use_json_pickle:
+                    result[key] = {
+                        Format.CONTROL_FIELD: 'jsonpickle',
+                        Format.CONTENT_FIELD: json.loads(jsonpickle.dumps(value))
+                    }
+                else:
+                    s = base64.b64encode(pickle.dumps(value)).decode('ascii')
+                    result[key] = {
+                        Format.CONTROL_FIELD: 'base64', Format.CONTENT_FIELD: s
+                    }
+        return result
+
+    @staticmethod
+    def decode(data: dict):
+        result = {}
+        for key in data:
+            if (
+                isinstance(data[key], dict) and
+                Format.CONTROL_FIELD in data[key] and
+                Format.CONTENT_FIELD in data[key]
+            ):
+                if data[key][Format.CONTROL_FIELD] == 'base64':
+                    result[key] =  pickle.loads(base64.b64decode(data[key][Format.CONTENT_FIELD]))
+                elif data[key][Format.CONTROL_FIELD] == 'jsonpickle':
+                    result[key] = jsonpickle.loads(json.dumps(data[key][Format.CONTENT_FIELD]))
+                else:
+                    raise ValueError("only @type=base64 and @type=jsonpickle is supported")
+            else:
+                result[key] = data[key]
+        return result

kaia_foundation-3.7.3/foundation_kaia/marshalling/marshalling_metadata.py

@@ -0,0 +1,38 @@
+from typing import *
+from dataclasses import dataclass
+from .signature_processor import SignatureProcessor
+from .endpoint import EndpointMetadata
+
+@dataclass
+class MarshallingMetadata:
+    name: str
+    method: Callable
+    endpoint: EndpointMetadata
+    signature: SignatureProcessor
+
+    def get_endpoint_address(self):
+        if self.endpoint.url is None:
+            return '/'+self.name
+        return self.endpoint.url
+
+    @staticmethod
+    def _get_endpoints(_obj, _type) -> tuple['MarshallingMetadata',...]:
+        result = []
+        for attr_name, attr_value in _type.__dict__.items():
+            if not hasattr(attr_value,'_metadata'):
+                continue
+            result.append(MarshallingMetadata(
+                attr_name,
+                getattr(_obj, attr_name) if _obj is not None else None,
+                attr_value._metadata,
+                SignatureProcessor.from_signature(attr_value)
+            ))
+        return tuple(result)
+
+    @staticmethod
+    def get_endpoints_from_object(obj) -> tuple['MarshallingMetadata',...]:
+        return MarshallingMetadata._get_endpoints(obj, type(obj))
+
+    @staticmethod
+    def get_endpoints_from_type(type: Type) -> tuple['MarshallingMetadata',...]:
+        return MarshallingMetadata._get_endpoints(None, type)

kaia_foundation-3.7.3/foundation_kaia/marshalling/server.py

@@ -0,0 +1,43 @@
+from .marshalling_metadata import MarshallingMetadata
+from flask import Flask
+from .server_binding import ServerBinding
+
+
+class Server:
+    def __init__(self, port: int, *objects):
+        self.objects = objects
+        self.port = port
+        metadata = []
+        for object in objects:
+            metadata.extend(MarshallingMetadata.get_endpoints_from_object(object))
+        self.metadata = tuple(metadata)
+
+    def create_alternative_binding(self, name: str, address: str):
+        meta = [m for m in self.metadata if m.get_endpoint_address() == address]
+        if len(meta) != 1:
+            raise ValueError(f"Too much/none ({len(meta)} endpoints for address {address}")
+        return ServerBinding(meta[0], name)
+
+    def bind_endpoints(self, app: Flask):
+        for metadata in self.metadata:
+            app.add_url_rule(
+                metadata.get_endpoint_address(),
+                view_func=ServerBinding(metadata),
+                methods=[metadata.endpoint.method]
+            )
+
+    def bind_heartbeat(self, app: Flask):
+        app.add_url_rule('/heartbeat', view_func=self.heartbeat, methods=['GET'])
+
+    def bind_app(self, app: Flask):
+        self.bind_endpoints(app)
+        self.bind_heartbeat(app)
+
+
+    def heartbeat(self):
+        return 'OK'
+
+    def __call__(self):
+        app = Flask('RPC_'+'_'.join(type(o).__name__ for o in self.objects))
+        self.bind_app(app)
+        app.run('0.0.0.0', self.port)

kaia_foundation-3.7.3/foundation_kaia/marshalling/server_binding.py

@@ -0,0 +1,51 @@
+from .marshalling_metadata import MarshallingMetadata
+from .format import Format
+import flask
+import traceback
+
+
+class ServerBinding:
+    def __init__(self,
+                 meta :MarshallingMetadata,
+                 custom_method_name: str|None = None
+                 ):
+        self.meta = meta
+        self.custom_method_name = custom_method_name
+
+    @property
+    def __name__(self):
+        if self.custom_method_name is None:
+            return self.meta.name
+        return self.custom_method_name
+
+    def _get_arguments(self, kwargs, data):
+        arguments = Format.decode(data['arguments'])
+        for key, value in kwargs.items():
+            if key in arguments:
+                raise ValueError(f"{key} is provided via address and via json")
+            arguments[key] = value
+        return arguments
+
+    def _process(self, kwargs, arguments):
+        arguments = self._get_arguments(kwargs, arguments)
+        result = self.meta.method(**arguments)
+        result = dict(result=result, error = None)
+        result = Format.encode(result, self.meta.endpoint.json_pickle_result)
+        return result
+
+    def __call__(self, **kwargs):
+        data = flask.request.json
+        try:
+            return flask.jsonify(self._process(kwargs, data))
+        except:
+            tb = traceback.format_exc()
+            print(tb)
+            return flask.jsonify(dict(result=None, error=tb)), 500
+
+
+
+
+
+
+
+

kaia_foundation-3.7.3/foundation_kaia/marshalling/signature_processor.py

@@ -0,0 +1,57 @@
+import inspect
+from dataclasses import dataclass
+from collections import OrderedDict
+
+@dataclass
+class SignatureProcessor:
+    mandatory: tuple[str,...]
+    optional: tuple[str,...]
+    open: bool
+
+    def to_kwargs_only(self, *args, **kwargs):
+        all = self.mandatory + self.optional
+        if len(args) > len(all):
+            raise ValueError(f"args has {len(args)} arguments, while there are only {len(all)} arguments")
+        result = OrderedDict()
+        for i, arg in enumerate(args):
+            name = all[i]
+            if name in kwargs:
+                raise ValueError(f"Args at index {i} conflicts with kwargs {name}")
+            result[name] = arg
+
+        for key, value in kwargs.items():
+            result[key] = value
+
+        mandatory_seen = set()
+        for key in result:
+            if key in self.mandatory:
+                mandatory_seen.add(key)
+            elif key in self.optional:
+                pass
+            else:
+                if not open:
+                    raise ValueError(f"Argument `{key}` is not in fields, and the signature is not open")
+
+        if len(mandatory_seen) < len(self.mandatory):
+            not_seen = ", ".join([f'`{c}`' for c in self.mandatory if c not in mandatory_seen])
+            raise TypeError(f"Not all mandatory arguments are provided: missing {not_seen}")
+
+        return result
+
+    @staticmethod
+    def from_signature(method):
+        signature = inspect.signature(method)
+        mandatory = list()
+        optional = list()
+        open = False
+        for i,(p,v) in enumerate(signature.parameters.items()):
+            if i == 0 and v.name=='self':
+                continue
+            if v.kind == inspect.Parameter.VAR_KEYWORD:
+                open = True
+            else:
+                if v.default == inspect._empty:
+                    mandatory.append(v.name)
+                else:
+                    optional.append(v.name)
+        return SignatureProcessor(tuple(mandatory), tuple(optional), open)

kaia_foundation-3.7.3/foundation_kaia/marshalling/test_api.py

@@ -0,0 +1,28 @@
+from typing import TypeVar, Generic, Callable
+from .server import Server
+from .api import Api
+from ..fork import Fork
+
+
+TApi = TypeVar('TApi')
+
+class TestApi(Generic[TApi]):
+    def __init__(self,
+                 api_factory: Callable[[str], Api],
+                 server: Server
+                 ):
+        self.api_factory = api_factory
+        self.server = server
+        self.fork = None
+
+    def __enter__(self) -> TApi:
+        self.fork = Fork(self.server).start()
+        api = self.api_factory(f'127.0.0.1:{self.server.port}')
+        api.wait()
+        return api
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.fork is not None:
+            self.fork.terminate()
+
+

kaia_foundation-3.7.3/foundation_kaia/misc/__init__.py

@@ -0,0 +1 @@
+from .loc import Loc, Locator

kaia_foundation-3.7.3/foundation_kaia/misc/loc.py

@@ -0,0 +1,103 @@
+import traceback
+from pathlib import Path
+import shutil
+from uuid import uuid4
+import os
+
+class TempFile:
+    def __init__(self, path: Path, dont_delete: bool):
+        self.path = path
+        self.dont_delete = dont_delete
+
+    def __enter__(self):
+        os.makedirs(self.path.parent, exist_ok=True)
+        if self.path.is_file():
+            os.unlink(self.path)
+        return self.path
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self.dont_delete:
+            if self.path.is_file():
+                try:
+                    os.unlink(self.path)
+                except:
+                    print("Cannot delete test file:\n"+traceback.format_exc())
+
+
+class TempFolder:
+    def __init__(self, path: Path, dont_delete: bool = False):
+        self.path = path
+        self.dont_delete = dont_delete
+
+    def __enter__(self):
+        if self.path.is_dir():
+            shutil.rmtree(self.path)
+        os.makedirs(self.path)
+        return self.path
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self.dont_delete and self.path.is_dir():
+            shutil.rmtree(self.path, ignore_errors=True)
+
+
+class Locator:
+    def __init__(self, root_path: Path|None = None):
+        if root_path is None:
+            root_path = Path(__file__).parent.parent.parent
+        self._root_path = root_path
+
+    def _make_and_return(self, path) -> Path:
+        os.makedirs(path, exist_ok=True)
+        return path
+
+    @property
+    def data_folder(self) -> Path:
+        return self._make_and_return(self._root_path/'data')
+
+    @property
+    def resources_folder(self) -> Path:
+        return self._make_and_return(self._root_path/'data/resources')
+
+    @property
+    def cache_folder(self) -> Path:
+        return self._make_and_return(self._root_path/'temp/brainbox_cache')
+
+    @property
+    def temp_folder(self) -> Path:
+        return self._make_and_return(self._root_path/'temp')
+
+    @property
+    def test_folder(self) -> Path:
+        return self._make_and_return(self._root_path/'temp/tests')
+
+    @property
+    def self_test_path(self) -> Path:
+        return self._make_and_return(self._root_path/'data/brainbox_self_test')
+
+    @property
+    def db_path(self) -> Path:
+        return self.data_folder/'brainbox.db'
+
+    @property
+    def root_folder(self) -> Path:
+        return self._root_path
+
+
+    def create_test_file(self, extension_without_leading_dot: str|None = None, subfolder: str|None = None, dont_delete: bool = False) -> TempFile:
+        path = self.test_folder
+        if subfolder is not None:
+            path /= subfolder
+        name = str(uuid4())
+        if extension_without_leading_dot is not None:
+            name+= '.'+extension_without_leading_dot
+        path/=name
+        return TempFile(path, dont_delete)
+
+    def create_test_folder(self, subfolder: str|None = None, dont_delete: bool = False) -> TempFolder:
+        path = self.test_folder
+        if subfolder is not None:
+            path /= subfolder
+        path /= str(uuid4())
+        return TempFolder(path, dont_delete)
+
+Loc = Locator()

kaia_foundation-3.7.3/foundation_kaia/prompters/__init__.py

@@ -0,0 +1,7 @@
+from .abstract_prompter import IPrompter
+from .address import Address, IAddressElement, DefaultElement
+from .address_builder import AddressBuilder, AddressBuilderGC
+from .prompter import Prompter
+from .template_parts import ITemplatePart, ConstantTemplatePart, AddressTemplatePart, SubpromptPropagationTemplatePart
+from .referrer import Referrer
+from .jinja_prompter import JinjaPrompter

kaia_foundation-3.7.3/foundation_kaia/prompters/abstract_prompter.py

@@ -0,0 +1,9 @@
+from typing import TypeVar, Generic
+from abc import ABC, abstractmethod
+
+T = TypeVar('T')
+
+class IPrompter(ABC, Generic[T]):
+    @abstractmethod
+    def __call__(self, obj: T) -> str:
+        pass

kaia_foundation-3.7.3/foundation_kaia/prompters/address.py

@@ -0,0 +1,100 @@
+from abc import ABC, abstractmethod
+
+class IAddressElement(ABC):
+    @abstractmethod
+    def get(self, obj):
+        pass
+
+    @abstractmethod
+    def set(self, obj, value):
+        pass
+
+    @staticmethod
+    def translate(element) -> 'IAddressElement':
+        if isinstance(element, IAddressElement):
+            return element
+        return DefaultElement(element)
+
+
+
+class DefaultElement(IAddressElement):
+    def __init__(self, element):
+        self.element = element
+
+    def get(self, obj):
+        if isinstance(self.element, str) and hasattr(obj, self.element):
+            return getattr(obj, self.element)
+        if hasattr(obj, '__getitem__'):
+            getitem = getattr(obj, '__getitem__')
+            if callable(getitem):
+                return getitem(self.element)
+        raise ValueError(f"Obj {obj} cannot be addressed with {self.element}")
+
+    def set(self, obj, value):
+        if hasattr(obj, '__setitem__'):
+            setitem = getattr(obj, '__setitem__')
+            if callable(setitem):
+                setitem(obj, self.element, value)
+                return
+        if isinstance(self.element, str):
+            setattr(obj, self.element, value)
+            return
+        raise ValueError(f"Obj {obj} cannot be set with address `{self.element}`")
+
+    def __str__(self):
+        if isinstance(self.element, str):
+            return self.element
+        return f'[{self.element}]'
+
+
+class Address:
+    def __init__(self, *address):
+        from .address_builder import AddressBuilder
+        if len(address) == 1:
+            if isinstance(address[0], AddressBuilder):
+                self.address = address[0]._address_builder_stored_address.address
+            elif isinstance(address[0], Address):
+                self.address = address[0].address
+            else:
+                self.address = (IAddressElement.translate(address[0]), )
+        else:
+            self.address: tuple[IAddressElement,...] = tuple(IAddressElement.translate(a) for a in address)
+
+    def get(self, obj):
+        result = obj
+        for index, element in enumerate(self.address):
+            try:
+                result = element.get(result)
+            except Exception as exc:
+                raise ValueError(f"Address {self} failed at {index} for object\n{obj}") from exc
+        return result
+
+    def set(self, obj, value):
+        obj = self.pop().get(obj)
+        self.address[-1].set(obj, value)
+
+    def append(self, value: str|IAddressElement):
+        if isinstance(value, str):
+            value= IAddressElement.translate(value)
+        elif isinstance(value, IAddressElement):
+            pass
+        else:
+            raise ValueError("Expected string or IAddressElement")
+        return Address(*(self.address+(value,)))
+
+    def pop(self) -> 'Address':
+        if len(self.address) == 0:
+            raise ValueError("Can't pop from empty address")
+        return Address(*self.address[:-1])
+
+    def is_empty(self):
+        return len(self.address) == 0
+
+    def __str__(self):
+        return '.'.join(str(a) for a in self.address)
+
+    @staticmethod
+    def parse(s: str):
+        parts = s.split('.')
+        parts = [DefaultElement(e) for e in parts]
+        return Address(*parts)

kaia_foundation-3.7.3/foundation_kaia/prompters/address_builder.py

@@ -0,0 +1,72 @@
+from typing import *
+from .address import DefaultElement, Address
+from uuid import uuid4
+from enum import IntEnum
+
+
+class AddressBuilderGC:
+    class Dimension(IntEnum):
+        address = 0
+        operator = 1
+        subprompt = 2
+        misc = 100
+
+    cache: dict['AddressBuilderGC.Dimension', dict[str,Any]] = {}
+
+    @staticmethod
+    def record(dimension: 'AddressBuilderGC.Dimension', id: str, value: Any):
+        if dimension not in AddressBuilderGC.cache:
+            AddressBuilderGC.cache[dimension] = {}
+        AddressBuilderGC.cache[dimension][id] = value
+
+    @staticmethod
+    def find(dimension: 'AddressBuilderGC.Dimension', id: str):
+        if dimension not in AddressBuilderGC.cache:
+            return None
+        if id not in AddressBuilderGC.cache[dimension]:
+            return None
+        return AddressBuilderGC.cache[dimension][id]
+
+
+RESERVED_FIELDS = {
+    '_address_builder_stored_address',
+    '_address_builder_uuid',
+    '__str__',
+    '__truediv__',
+}
+
+class AddressBuilder:
+    def __init__(self, address: Address|None = None):
+        self._address_builder_uuid = 'id'+str(uuid4()).replace('-','')
+        self._address_builder_stored_address = address if address is not None else Address()
+        AddressBuilderGC.record(
+            AddressBuilderGC.Dimension.address,
+            self._address_builder_uuid,
+            self._address_builder_stored_address
+        )
+
+    def __str__(self):
+        return f'<<{self._address_builder_uuid}>>'
+
+    def __getattribute__(self, item):
+        if item in RESERVED_FIELDS:
+            return super().__getattribute__(item)
+        return AddressBuilder(self._address_builder_stored_address.append(DefaultElement(item)))
+
+    def __truediv__(self, other):
+        AddressBuilderGC.record(
+            AddressBuilderGC.Dimension.operator,
+            self._address_builder_uuid,
+            other
+        )
+        return self.__str__()
+
+    def __invert__(self):
+        AddressBuilderGC.record(
+            AddressBuilderGC.Dimension.subprompt,
+            self._address_builder_uuid,
+            True
+        )
+        return self.__str__()
+
+

kaia_foundation-3.7.3/foundation_kaia/prompters/jinja_prompter.py

@@ -0,0 +1,42 @@
+from jinja2 import Template, Environment, meta
+from typing import Generic
+from .abstract_prompter import IPrompter, T
+from dataclasses import is_dataclass
+from copy import copy
+import re
+class JinjaPrompter(IPrompter, Generic[T]):
+    def __init__(self, template: str, prettify_newlines: bool = True):
+        self._template_text = template.replace('<<', '{{').replace('>>', '}}')
+        self._template = Template(self._template_text)
+        self._prettify_newlines = prettify_newlines
+
+    @staticmethod
+    def normalize_newlines(text: str) -> str:
+        text = re.sub(r'\n{2,}', '\n\n', text)
+        text = re.sub(r'(?<!\n)\n(?!\n)', ' ', text)
+        return text
+
+    def get_variables(self):
+        env = Environment()
+        parsed_content = env.parse(self._template_text)
+        variables = meta.find_undeclared_variables(parsed_content)
+        return variables
+
+    def __call__(self, obj: T) -> str:
+        values = {}
+        if is_dataclass(obj):
+            if isinstance(obj, type):
+                pass
+            else:
+                values = copy(obj.__dict__)
+        elif isinstance(obj, dict):
+            values = copy(obj)
+        values['_'] = obj
+        s = self._template.render(**values)
+
+        if self._prettify_newlines:
+            s = JinjaPrompter.normalize_newlines(s)
+
+        return s
+
+

kaia_foundation-3.7.3/foundation_kaia/prompters/prompter.py

@@ -0,0 +1,44 @@
+from .abstract_prompter import IPrompter, T, Generic
+from .address import Address
+from .template_parts import ITemplatePart, ConstantTemplatePart
+import re
+
+class Parser:
+    def __init__(self):
+        self.parts = []
+
+    def parse_next(self, part: str):
+        if part.startswith('<<') and part.endswith('>>'):
+            uid = part[2:-2]
+            token = ITemplatePart.parse_gc(uid)
+            self.parts.append(token)
+        else:
+            if part != '':
+                self.parts.append(ConstantTemplatePart(part))
+
+    def finalize(self):
+        return tuple(self.parts)
+
+
+
+def _parse(template: str) -> tuple[ITemplatePart,...]:
+    parser = Parser()
+    parts = re.split('(<<[^>]+>>)', template)
+    for p in parts:
+        parser.parse_next(p)
+    return parser.finalize()
+
+
+class Prompter(IPrompter[T], Generic[T]):
+    def __init__(self, template: str|tuple[ITemplatePart,...]):
+        if isinstance(template, str):
+            self.template = _parse(template)
+        else:
+            self.template = template
+
+    def __call__(self, obj: T) -> str:
+        return ''.join(part.to_str(obj) for part in self.template)
+
+    def to_readable_string(self):
+        return ''.join(p.to_readable_expression() for p in self.template)
+

kaia_foundation-3.7.3/foundation_kaia/prompters/referrer.py

@@ -0,0 +1,17 @@
+from .address_builder import AddressBuilder
+from typing import TypeVar, Generic
+
+T = TypeVar('T')
+
+class Referrer(Generic[T]):
+    @property
+    def ref(self) -> T:
+        return AddressBuilder()
+
+    def list_to_bullet_points(self, bullet_point = '* '):
+        def _f(value):
+            return '\n'.join(bullet_point+s for s in value)
+        return _f
+
+
+

kaia_foundation-3.7.3/foundation_kaia/prompters/template_parts.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass
+from typing import *
+from abc import ABC, abstractmethod
+from .address_builder import AddressBuilderGC
+from .address import Address
+from .abstract_prompter import IPrompter
+from .referrer import Referrer
+
+class ITemplatePart(ABC):
+    @abstractmethod
+    def to_str(self, value: Any) -> str:
+        pass
+
+    @abstractmethod
+    def to_readable_expression(self) -> str:
+        pass
+
+    @staticmethod
+    def parse_gc(uid: str):
+        address = AddressBuilderGC.find(AddressBuilderGC.Dimension.address, uid)
+        if address is None:
+            raise ValueError(f"Cannot find uid {uid} in the cache")
+        if AddressBuilderGC.find(AddressBuilderGC.Dimension.subprompt, uid):
+            return SubpromptPropagationTemplatePart(address)
+        else:
+            return AddressTemplatePart(
+                address,
+                AddressBuilderGC.find(AddressBuilderGC.Dimension.operator, uid),
+                AddressBuilderGC.find(AddressBuilderGC.Dimension.misc, uid),
+            )
+
+
+@dataclass
+class ConstantTemplatePart(ITemplatePart):
+    value: str
+
+    def to_str(self, value: Any) -> str:
+        return self.value
+
+    def to_readable_expression(self) -> str:
+        return self.value
+
+@dataclass
+class AddressTemplatePart(ITemplatePart):
+    address: Address
+    formatter: Callable[[Any], str]|None = None
+    misc: Any = None
+
+    def to_str(self, value: Any) -> str:
+        result = self.address.get(value)
+        if self.formatter is not None:
+            result = self.formatter(result)
+        return str(result)
+
+    def to_readable_expression(self) -> str:
+        return '{{'+self.address.__str__()+'}}'
+
+@dataclass
+class SubpromptPropagationTemplatePart(ITemplatePart):
+    address: Address
+
+    def to_str(self, value: Any):
+        return self.address.get(value)(value)
+
+    def to_readable_expression(self) -> str:
+        return '{{'+self.address.__str__()+"(_)}}"
+

kaia_foundation-3.7.3/kaia_foundation.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: kaia-foundation
+Version: 3.7.3
+Summary: Utilities used in Kaia project
+Author-email: Yuri Okulovsky <yuri.okulovsky@gmail.com>
+License-Expression: LGPL-3.0-or-later
+Project-URL: repository, https://github.com/okulovsky/kaia/tree/main/foundation_kaia
+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: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Development Status :: 4 - Beta
+Requires-Python: <4.0,>=3.10
+Requires-Dist: yo_fluq
+Requires-Dist: requests
+Requires-Dist: jsonpickle
+Requires-Dist: Jinja2
+Requires-Dist: flask

kaia_foundation-3.7.3/kaia_foundation.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+README.md
+pyproject.toml
+foundation_kaia/__init__.py
+foundation_kaia/fork/__init__.py
+foundation_kaia/fork/fork.py
+foundation_kaia/fork/fork_worker.py
+foundation_kaia/marshalling/__init__.py
+foundation_kaia/marshalling/api.py
+foundation_kaia/marshalling/api_binding.py
+foundation_kaia/marshalling/api_utils.py
+foundation_kaia/marshalling/endpoint.py
+foundation_kaia/marshalling/format.py
+foundation_kaia/marshalling/marshalling_metadata.py
+foundation_kaia/marshalling/server.py
+foundation_kaia/marshalling/server_binding.py
+foundation_kaia/marshalling/signature_processor.py
+foundation_kaia/marshalling/test_api.py
+foundation_kaia/misc/__init__.py
+foundation_kaia/misc/loc.py
+foundation_kaia/prompters/__init__.py
+foundation_kaia/prompters/abstract_prompter.py
+foundation_kaia/prompters/address.py
+foundation_kaia/prompters/address_builder.py
+foundation_kaia/prompters/jinja_prompter.py
+foundation_kaia/prompters/prompter.py
+foundation_kaia/prompters/referrer.py
+foundation_kaia/prompters/template_parts.py
+kaia_foundation.egg-info/PKG-INFO
+kaia_foundation.egg-info/SOURCES.txt
+kaia_foundation.egg-info/dependency_links.txt
+kaia_foundation.egg-info/requires.txt
+kaia_foundation.egg-info/top_level.txt

kaia_foundation-3.7.3/kaia_foundation.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kaia_foundation-3.7.3/kaia_foundation.egg-info/requires.txt

@@ -0,0 +1,5 @@
+yo_fluq
+requests
+jsonpickle
+Jinja2
+flask

kaia_foundation-3.7.3/kaia_foundation.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+foundation_kaia

kaia_foundation-3.7.3/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kaia-foundation"
+description = "Utilities used in Kaia project"
+version = "3.7.3"
+requires-python = ">=3.10, <4.0"
+license = "LGPL-3.0-or-later"
+authors = [
+    {name = "Yuri Okulovsky", email = "yuri.okulovsky@gmail.com"}
+]
+
+dependencies = [
+    "yo_fluq",
+    "requests",
+    "jsonpickle",
+    "Jinja2",
+    "flask"
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Information Technology",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Development Status :: 4 - Beta"
+]
+
+[project.urls]
+repository = "https://github.com/okulovsky/kaia/tree/main/foundation_kaia"
+
+[tool.setuptools.packages.find]
+where = ["."]

kaia_foundation-3.7.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+