pyjuiz 0.0.2__tar.gz

pyjuiz-0.0.2/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: pyjuiz
+Version: 0.0.2
+Summary: Python binding interface for JUIZ robot middleware components
+Home-page: https://github.com/juiz
+Author: ysuga
+Author-email: ysuga@ysuga.net
+License: MIT
+Keywords: robot,middleware
+Classifier: Programming Language :: Python :: 3.10
+Requires-Dist: yaml
+Requires-Dist: httpx
+Requires-Dist: pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

pyjuiz-0.0.2/juiz/__init__.py

@@ -0,0 +1,5 @@
+
+# from . import proxy
+from .juiz import *
+
+from .decorators import juiz_process, juiz_container, juiz_container_process, juiz_component_container, juiz_component_container_process

pyjuiz-0.0.2/juiz/__main__.py

@@ -0,0 +1,131 @@
+
+import argparse
+import juiz
+import json
+
+def _get_system(option):
+    return juiz.proxy.SystemProxy(juiz.proxy.HttpProxy(option.host, option.port))
+
+def sys_handler(args):
+    print('system:', args)
+    
+    
+    
+def proc_list_handler(option):
+    s = _get_system(option)
+    ps = s.processes()
+    print([p.identifier() for p in ps])
+    
+def proc_call_handler(option):
+    s = _get_system(option)
+    p = s.process(option.identifier)
+    body = json.loads(option.body)
+    print(p.call(body))
+    
+def proc_exec_handler(option):
+    s = _get_system(option)
+    p = s.process(option.identifier)
+    print(p.execute())
+    
+def proc_prof_handler(option):
+    s = _get_system(option)
+    p = s.process(option.identifier)
+    print(p.profile_full())
+    
+def setup_process_parser(proc_parser):
+    proc_subparsers = proc_parser.add_subparsers()
+    p_l_parser = proc_subparsers.add_parser('list')
+    p_l_parser.set_defaults(handler=proc_list_handler)
+    
+    p_p_parser = proc_subparsers.add_parser('profile')
+    p_p_parser.add_argument('identifier', help='process ID')
+    p_p_parser.set_defaults(handler=proc_prof_handler)
+    
+    p_c_parser = proc_subparsers.add_parser('call')
+    p_c_parser.add_argument('identifier', help='process ID')
+    p_c_parser.add_argument('body', help='body json')
+    p_c_parser.set_defaults(handler=proc_call_handler)
+
+    
+def cont_list_handler(option):
+    s = _get_system(option)
+    cs = s.containers()
+    print([c.identifier() for c in cs])
+    
+def cont_prof_handler(option):
+    s = _get_system(option)
+    c = s.container(option.identifier)
+    print(c.profile_full())
+    
+def setup_container_parser(cont_parser):
+    cont_subparsers = cont_parser.add_subparsers()
+    c_l_parser = cont_subparsers.add_parser('list')
+    c_l_parser.set_defaults(handler=cont_list_handler)
+    
+    c_p_parser =  cont_subparsers.add_parser('profile')
+    c_p_parser.add_argument('identifier', help='container ID')
+    c_p_parser.set_defaults(handler=cont_prof_handler)
+    
+    setup_container_process_parser(cont_subparsers.add_parser('process'))
+        
+        
+    
+def c_p_l_handler(option):
+    s = _get_system(option)
+    c = s.container(option.identifier)
+    ps = c.processes()
+    print([p.identifier() for p in ps])
+    
+    
+def c_p_c_handler(option):
+    s = _get_system(option)
+    c = s.container(option.identifier)
+    p = c.process(option.process_identifier)
+    body = json.loads(option.body)
+    print(p.call(body))
+    
+def c_p_e_handler(option):
+    s = _get_system(option)
+    c = s.container(option.identifier)
+    p = c.process(option.process_identifier)
+    print(p.execute())
+    
+def setup_container_process_parser(c_ps_parser):
+    c_ps_parser.add_argument('identifier', help='container ID')
+    c_ps_subparsers = c_ps_parser.add_subparsers()
+    
+    c_ps_list_parser = c_ps_subparsers.add_parser('list')
+    c_ps_list_parser.set_defaults(handler=c_p_l_handler)
+
+    c_ps_call_parser = c_ps_subparsers.add_parser('call')
+    c_ps_call_parser.add_argument('process_identifier', help='container process id')
+    c_ps_call_parser.add_argument('body', help='data')
+    c_ps_call_parser.set_defaults(handler=c_p_c_handler)
+
+    c_ps_e_parser = c_ps_subparsers.add_parser('execute')
+    c_ps_e_parser.add_argument('process_identifier', help='container process id')
+    c_ps_e_parser.set_defaults(handler=c_p_e_handler)
+    
+def main():
+    parser = argparse.ArgumentParser(
+        prog='juiz',
+        description='juiz test program',
+    )
+    parser.add_argument('--host', default='localhost')
+    parser.add_argument('--port', default=8000)
+    subparsers = parser.add_subparsers()
+    sysparser = subparsers.add_parser('system', help='system command')
+    sysparser.add_argument('profile', help='system profile')
+    sysparser.set_defaults(handler=sys_handler)
+    
+    setup_process_parser(subparsers.add_parser('process', help='process command'))
+    setup_container_parser(subparsers.add_parser('container', help='container command'))
+    
+    
+    option = parser.parse_args()
+        
+    if hasattr(option, 'handler'):
+        option.handler(option)
+
+if __name__ == '__main__':
+    main()

pyjuiz-0.0.2/juiz/decorators.py

@@ -0,0 +1,248 @@
+import datetime
+import inspect
+import functools
+import io
+
+from .juiz import *
+from PIL.Image import Image
+class PyJuizProcessArgumentUnknownTypeError(Exception): pass
+class PyJuizContainerArgumentUnknownTypeError(Exception): pass
+
+def allow_no_arg_decorator(decorator_function):
+    def wrapper(*args, **kwargs):
+        
+        if len(args) != 0 and callable(args[0]):
+            decorated_function= args[0]
+            return functools.wraps(decorated_function)(decorator_function(decorated_function))
+        else:
+            def _wrapper(decorated_function):
+                return functools.wraps(decorated_function)(decorator_function(decorated_function, *args, **kwargs))
+            return _wrapper
+    return wrapper
+
+
+class JuizProcess(object):
+    def __init__(self, proc):
+        self.__proc = proc
+        self.name = proc.__name__
+        self.signature = inspect.signature(proc)
+        self._manifest = ProcessManifest.new(self.name).set_description(proc.__doc__)
+        for p in self.signature.parameters:
+            param = self.signature.parameters[p]
+            param_type = param.annotation
+            param_default = param.default
+            if param_type is inspect._empty:
+                if isinstance(param_default, int):
+                    param_type = int
+                elif isinstance(param_default, bool):
+                    param_type = bool
+                elif isinstance(param_default, float):
+                    param_type = float
+                elif isinstance(param_default, list):
+                    param_type = list
+                elif isinstance(param_default, str):
+                    param_type = str
+                elif isinstance(param_default, dict):
+                    param_type = dict
+                else:
+                    raise PyJuizProcessArgumentUnknownTypeError()
+            if param_default is inspect._empty:
+                if param_type == int:
+                    param_default = 0
+                elif param_type == float:
+                    param_default = 0.0
+                elif param_type == dict:
+                    param_default = {}
+                elif param_type == list:
+                    param_default = []
+                elif param_type == bool:
+                    param_default = False
+                elif param_type == str:
+                    param_default = ""
+                elif param_type == Image:
+                    param_default =  None
+                else:
+                    raise PyJuizProcessArgumentUnknownTypeError()
+                
+            # print('p:', param.name, param.default, param.kind, param.annotation, param)
+            if param_type == int:
+                self._manifest.add_int_arg(param.name, "", param_default)
+            elif param_type == float:
+                self._manifest.add_float_arg(param.name, "", param_default)
+            elif param_type == bool:
+                self._manifest.add_bool_arg(param.name, "", param_default)
+            elif param_type == str:
+                self._manifest.add_string_arg(param.name, "", param_default)
+            elif param_type == dict:
+                self._manifest.add_object_arg(param.name, "", param_default)
+            elif param_type == list:
+                self._manifest.add_array_arg(param.name, "", param_default)
+            elif param_type == Image:
+                self._manifest.add_image_arg(param.name, "", param_default)
+    def manifest(self):
+        return self._manifest.into_value()
+        
+    def __call__(self, *args, **kwargs):
+        return convert_process_result(self.__proc(*args, **kwargs))
+    
+@allow_no_arg_decorator
+def juiz_process(process_function, description="Default Description"):
+    return JuizProcess(process_function)
+
+class JuizContainer(object):
+    def __init__(self, proc):
+        self.__proc = proc
+        self.name = proc.__name__
+        self.signature = inspect.signature(proc)
+        self._manifest = ContainerManifest.new(self.name).set_description(proc.__doc__)
+        for p in self.signature.parameters:
+            param = self.signature.parameters[p]
+            param_type = param.annotation
+            param_default = param.default
+            if param_type is inspect._empty:
+                if isinstance(param_default, int):
+                    param_type = int
+                elif isinstance(param_default, bool):
+                    param_type = bool
+                elif isinstance(param_default, float):
+                    param_type = float
+                elif isinstance(param_default, list):
+                    param_type = list
+                elif isinstance(param_default, str):
+                    param_type = str
+                elif isinstance(param_default, dict):
+                    param_type = dict
+                elif isinstance(param_default, Image):
+                    param_type = Image
+                else:
+                    raise PyJuizProcessArgumentUnknownTypeError()
+            if param_default is inspect._empty:
+                if param_type == int:
+                    param_default = 0
+                elif param_type == float:
+                    param_default = 0.0
+                elif param_type == dict:
+                    param_default = {}
+                elif param_type == list:
+                    param_default = []
+                elif param_type == bool:
+                    param_default = False
+                elif param_type == str:
+                    param_default = ""
+                elif param_type == Image:
+                    param_default =  None
+                else:
+                    raise PyJuizProcessArgumentUnknownTypeError()
+                
+            # print('p:', param.name, param.default, param.kind, param.annotation, param)
+            if param_type == int:
+                self._manifest.add_int_arg(param.name, "", param_default)
+            elif param_type == float:
+                self._manifest.add_float_arg(param.name, "", param_default)
+            elif param_type == bool:
+                self._manifest.add_bool_arg(param.name, "", param_default)
+            elif param_type == str:
+                self._manifest.add_string_arg(param.name, "", param_default)
+            elif param_type == dict:
+                self._manifest.add_object_arg(param.name, "", param_default)
+            elif param_type == list:
+                self._manifest.add_array_arg(param.name, "", param_default)
+            elif param_type == Image:
+                self._manifest.add_image_arg(param.name, "", param_default)
+    def manifest(self):
+        return self._manifest.into_value()
+        
+    def __call__(self, *args, **kwargs):
+        return self.__proc(*args, **kwargs)
+    
+@allow_no_arg_decorator
+def juiz_container(constructor_function, description="Default Description"):
+    return JuizContainer(constructor_function)
+
+@allow_no_arg_decorator
+def juiz_component_container(constructor_function, description="Default Description"):
+    return JuizContainer(constructor_function)
+
+class JuizContainerProcess(object):
+    def __init__(self, proc, container_type):
+        self.__proc = proc
+        self.name = proc.__name__
+        self.signature = inspect.signature(proc)
+        self._manifest = ProcessManifest.new(self.name).set_description(proc.__doc__).set_container_type(container_type)
+        for i, p in enumerate(self.signature.parameters):
+            if i == 0:
+                continue
+            param = self.signature.parameters[p]
+            param_type = param.annotation
+            param_default = param.default
+            if param_type is inspect._empty:
+                if isinstance(param_default, int):
+                    param_type = int
+                elif isinstance(param_default, bool):
+                    param_type = bool
+                elif isinstance(param_default, float):
+                    param_type = float
+                elif isinstance(param_default, list):
+                    param_type = list
+                elif isinstance(param_default, str):
+                    param_type = str
+                elif isinstance(param_default, dict):
+                    param_type = dict
+                elif isinstance(param_default, Image):
+                    param_type = Image
+                else:
+                    raise PyJuizProcessArgumentUnknownTypeError()
+            if param_default is inspect._empty:
+                if param_type == int:
+                    param_default = 0
+                elif param_type == float:
+                    param_default = 0.0
+                elif param_type == dict:
+                    param_default = {}
+                elif param_type == list:
+                    param_default = []
+                elif param_type == bool:
+                    param_default = False
+                elif param_type == str:
+                    param_default = ""
+                elif param_type == Image:
+                    param_default = None
+                else:
+                    print('Param Type Unknown:', param_type)
+                    raise PyJuizProcessArgumentUnknownTypeError()
+                
+            # print('p:', param.name, param.default, param.kind, param.annotation, param)
+            if param_type == int:
+                self._manifest.add_int_arg(param.name, "", param_default)
+            elif param_type == float:
+                self._manifest.add_float_arg(param.name, "", param_default)
+            elif param_type == bool:
+                self._manifest.add_bool_arg(param.name, "", param_default)
+            elif param_type == str:
+                self._manifest.add_string_arg(param.name, "", param_default)
+            elif param_type == dict:
+                self._manifest.add_object_arg(param.name, "", param_default)
+            elif param_type == list:
+                self._manifest.add_array_arg(param.name, "", param_default)
+            elif param_type == Image:
+                self._manifest.add_image_arg(param.name, "", param_default)
+    def manifest(self):
+        return self._manifest.into_value()
+        
+    def __call__(self, *args, **kwargs):
+        return convert_process_result(self.__proc(*args, **kwargs))
+
+def convert_process_result(retval):
+    # if isinstance(retval, Image):
+    #     output = io.BytesIO()
+    #     retval.save(output, format='PNG')
+    #     return output.getvalue() # Hex Data
+    return retval
+
+@allow_no_arg_decorator
+def juiz_container_process(constructor_function, container_type:str, description="Default Description"):
+    return JuizContainerProcess(constructor_function, container_type)
+
+@allow_no_arg_decorator
+def juiz_component_container_process(constructor_function, container_type:str, description="Default Description"):
+    return JuizContainerProcess(constructor_function, container_type)

pyjuiz-0.0.2/juiz/juiz.py

@@ -0,0 +1,178 @@
+from dataclasses import dataclass, asdict
+from typing import List, Any, Optional
+from PIL.Image import Image
+
+@dataclass
+class ArgumentManifest:
+    type_name: str
+    name: str
+    default: Any
+    description: str = ""
+    
+    @classmethod
+    def new(cls, type_name, name, description, default_value):
+        return ArgumentManifest(type_name=type_name, name=name, default=default_value, description=description )
+
+@dataclass
+class ProcessManifest:
+    
+    type_name: str
+    arguments: List[ArgumentManifest]
+    description: str = ""
+    factory: str = "process_factory"
+    use_demo: bool = False
+    language: str = "python"
+    name: Optional[str] = None
+    container_name: Optional[str] = None
+    container_type: Optional[str] = None
+    
+    @classmethod
+    def new(cls, type_name):
+        return ProcessManifest(type_name=type_name, arguments=[])
+        
+    def set_name(self, n):
+        self.name = n
+        return self
+    
+    def set_description(self, desc):
+        self.description = desc
+        return self
+        
+    def set_language(self, language:str):
+        self.language = language
+        return self
+    
+    def set_factory(self, factory:str):
+        self.factory = factory
+        return self
+    
+    def set_container_type(self, container_type:str):
+        self.container_type = container_type
+        return self
+    
+    def set_container_name(self, container_name:Optional[str]):
+        self.container_name = container_name
+        return self
+        
+    def add_argument(self, argument_manifest):
+        self.arguments.append(argument_manifest)
+        return self
+
+    def add_bool_arg(self, name, description, default_value:bool):
+        self.add_argument(ArgumentManifest.new("Bool", name, description, default_value))
+        return self
+    
+    def add_int_arg(self, name, description, default_value:int):
+        self.add_argument(ArgumentManifest.new("Int", name, description, default_value))
+        return self
+        
+    def add_float_arg(self, name, description, default_value:float):
+        self.add_argument(ArgumentManifest.new("Float", name, description, default_value))
+        return self
+        
+    def add_string_arg(self, name, description, default_value:str):
+        self.add_argument(ArgumentManifest.new("String", name, description, default_value))
+        return self
+
+    def add_object_arg(self, name, description, default_value: dict):
+        self.add_argument(ArgumentManifest.new("Object", name, description, default_value))
+        return self
+    
+    def add_array_arg(self, name, description, default_value: list):
+        self.add_argument(ArgumentManifest.new("Array", name, description, default_value))
+        return self
+        
+    def add_image_arg(self, name, description, default_value: object):
+        self.add_argument(ArgumentManifest.new("Image", name, description, default_value))
+        
+    def into_value(self):
+        return asdict(self, dict_factory=lambda x: {k: v for (k, v) in x if v is not None})
+    
+@dataclass
+class ContainerManifest:
+    type_name: str
+    args: dict
+    processes: List[ProcessManifest] 
+    arguments: List[ArgumentManifest]
+    language: str = "python"
+    factory: str = "container_factory"
+    description: str = ""
+    parent_type_name: Optional[str] = None
+    parent_name: Optional[str] = None
+    name: Optional[str] = None
+    
+    @classmethod
+    def new(cls, type_name):
+        return ContainerManifest(type_name=type_name, args={}, processes=[], arguments=[])
+    
+    def add_process(self, process_manifest: ProcessManifest):
+        self.processes.append(process_manifest\
+            .set_container_type(self.type_name)\
+            .set_container_name(self.name))
+        return self
+    
+    def set_description(self, desc): 
+        self.description = desc
+        return self
+    
+    def into_value(self):
+        return asdict(self, dict_factory=lambda x: {k: v for (k, v) in x if v is not None})
+    
+    def add_argument(self, argument_manifest):
+        self.arguments.append(argument_manifest)
+        return self
+    
+    def add_bool_arg(self, name, description, default_value:bool):
+        self.add_argument(ArgumentManifest.new("bool", name, description, default_value))
+        return self
+    
+    def add_int_arg(self, name, description, default_value:int):
+        self.add_argument(ArgumentManifest.new("int", name, description, default_value))
+        return self
+        
+    def add_float_arg(self, name, description, default_value:float):
+        self.add_argument(ArgumentManifest.new("float", name, description, default_value))
+        return self
+        
+    def add_string_arg(self, name, description, default_value:str):
+        self.add_argument(ArgumentManifest.new("string", name, description, default_value))
+        return self
+
+    def add_object_arg(self, name, description, default_value: dict):
+        self.add_argument(ArgumentManifest.new("object", name, description, default_value))
+        return self
+    
+    def add_array_arg(self, name, description, default_value: list):
+        self.add_argument(ArgumentManifest.new("array", name, description, default_value))
+        return self
+    
+    def add_image_arg(self, name, description, default_value: object):
+        self.add_argument(ArgumentManifest.new("image", name, description, default_value))
+        
+@dataclass
+class ComponentManifest:
+    type_name: str
+    containers: List[ContainerManifest]
+    processes: List[ProcessManifest]
+    description: str = ""
+    language: str = "python"
+    
+    @classmethod
+    def new(cls, type_name):
+        return ComponentManifest(type_name=type_name, containers=[], processes=[])
+    
+    def set_description(self, desc):
+        self.description = desc
+        return self
+    
+    def set_language(self, lang):
+        self.language = lang
+        return self
+    
+    def add_container(self, c):
+        self.containers.append(c)
+        return self
+    
+    def add_process(self, p: ProcessManifest):
+        self.processes.append(p)
+        return self

pyjuiz-0.0.2/juiz/proxy/__init__.py

@@ -0,0 +1,403 @@
+import httpx
+import json, io
+from PIL import Image
+from io import BytesIO
+
+
+class UnsupportedMediaTypeError(Exception): pass
+class BadRequestError(Exception): pass
+class ForbiddenError(Exception): pass
+class NotFoundError(Exception): pass
+class RequestTimeoutError(Exception): pass
+class InternalServerError(Exception): pass
+
+
+error_code_and_ex={
+    415: UnsupportedMediaTypeError,
+    400: BadRequestError,
+    403: ForbiddenError,
+    404: NotFoundError,
+    408: RequestTimeoutError,
+    500: InternalServerError,
+}
+
+class CRUDProxy():
+    
+    def __init__(self):
+        pass
+    
+    def _url(self, class_name, function_name, param_dict: dict=None):
+        if param_dict is None:
+            return f'/api/{class_name}/{function_name}'
+        else:
+            return f'/api/{class_name}/{function_name}?' + '&'.join([f'{k}={v}' for k, v in param_dict.items()])
+    
+    def read(self, class_name, function_name, param_dict={}):
+        pass
+    
+    def delete(self, class_name, function_name, param_dict={}):
+        pass
+    
+    def create(self, class_name, function_name, body, param_dict={}):
+        pass
+    
+    def update(self, class_name, function_name, body, param_dict={}):
+        pass
+    
+class HttpProxy(CRUDProxy):
+    
+    def __init__(self, host, port):
+        self._host = host
+        self._port = port
+        self._base_url = 'http://' + self._host + ':' + str(self._port)
+        pass
+
+    def _do_response(self, response):
+        if response.status_code == 200:
+            ct = response.headers.get('content-type', None)
+            if ct and ct == 'application/json':
+                return response.json()
+            elif ct and ct == 'image/png':
+                return Image.open(BytesIO(response.content)).convert('RGB')
+        else:
+            raise error_code_and_ex[response.status_code]()
+    
+    def read(self, class_name, function_name, param_dict={}):
+        url = self._url(class_name, function_name, param_dict)
+        return self._get(url)
+    
+    def delete(self, class_name, function_name, param_dict={}):
+        url = self._url(class_name, function_name, param_dict)
+        return self._delete(url)
+    
+    def create(self, class_name, function_name, body: dict, param_dict: dict={}):
+        url = self._url(class_name, function_name, param_dict)
+        return self._post(url, body)
+    
+    def update(self, class_name, function_name, body, param_dict={}, profile=None):
+        url = self._url(class_name, function_name, param_dict)
+        return self._patch(url, body, profile=profile)
+    
+    def _get(self, url):
+        with httpx.Client() as client:
+            return self._do_response(client.get(self._base_url + url))                
+        return None
+
+    def _delete(self, url):
+        with httpx.Client() as client:
+            return self._do_response(client.delete(self._base_url + url))                
+        return None
+
+    def create(self, url, data):
+        with httpx.Client() as client:
+            return self._do_response(client.create(self._base_url + url,
+                                    data=json.dumps(data),
+                                   headers={"Content-Type": "application/json"}
+                                   ))
+        return None
+        
+    def _post(self, url, data):
+        with httpx.Client() as client:
+            return self._do_response(client.post(self._base_url + url,
+                                    data=json.dumps(data),
+                                   headers={"Content-Type": "application/json"}
+                                   ))
+        return None
+
+    def _patch(self, url, data, profile=None):
+        with httpx.Client() as client:
+            img_key_value = None
+            serializable_data = {}
+            if isinstance(data, Image.Image):
+                #print('prof:', profile)
+                pass
+            else:
+                for k, v in data.items():
+                    if isinstance(v, Image.Image):
+                        img_key_value = (k, v)
+                    else:
+                        serializable_data[k] = v
+            if img_key_value is not None:
+                output = io.BytesIO()
+                img_key_value[1].save(output, 'PNG')
+                files = {}
+                for k, v in serializable_data.items():
+                    files[k] = (None, v, "application/json")
+                files[img_key_value[0]] = (None, output.getvalue(), "image/png")
+                return self._do_response(client.put(self._base_url + url,
+                            # data=json.dumps(serializable_data),
+                            headers={"Content-Type": "multipart/form-data; boundary=+++"},
+                            #files={img_key_value[0]: (None, output.getvalue(), "image/png")}))
+                            files=files))
+            else:
+                return self._do_response(client.patch(self._base_url + url,
+                                        data=json.dumps(data),
+                                    headers={"Content-Type": "application/json"}
+                                    )) 
+        return None
+
+class SystemProxy():
+
+    def __init__(self, base_proxy: CRUDProxy):
+        self.crud = base_proxy
+        self._processes = None
+        self._containers = None
+        self._container_processes = None
+        pass
+
+    def profile_full(self, update=False):
+        return self.crud.read('system', 'profile_full')
+
+    def create_process(self, type_name, name, use_memo=True):
+        return self.crud.create('/api/process/', {
+            "type_name": type_name,
+            "name": name,
+            "use_memo": use_memo})
+        
+    def processes(self):
+        ps = self.crud.read('process', 'list')
+        self._processes = [ProcessProxy.new(self, pid) for pid in ps]
+        return self._processes.copy()
+
+    def process(self, id):
+        ps = self.crud.read('process', 'list')
+        for pid in ps:
+            if pid == id:
+                return ProcessProxy.new(self, pid)
+        return None            
+        
+    def containers(self, update=False):
+        ps = self.crud.read('container', 'list')
+        self._containers = [ContainerProxy.new(self, pid) for pid in ps]
+        return self._containers
+
+    def container(self, id):
+        cs = self.crud.read('container', 'list')
+        for pid in cs:
+            if pid == id:
+                return ContainerProxy.new(self, pid)
+        return None            
+    
+    def container_processes(self, update=False):
+        ps = self.crud.read('container_process','list')
+        if self._container_processes is None or update:
+            self._container_processes = [ContainerProcessProxy(self, p) for p in ps]
+        return self._container_processes
+
+    
+class ObjectProxy(object):
+    
+    def __init__(self, system_proxy, class_name, identifier):
+        self.system = system_proxy
+        self._id = identifier
+        self._cn = class_name
+        self._profile = None
+        self._name = id_to_name(identifier) if identifier is not None else None
+        self._type_name = None
+        
+    def profile_full(self, update=False):
+        if self._profile is None or update:
+            self._profile = self.system.crud.read(self._cn, 'profile_full', {'identifier': self._id})
+        return self._profile
+
+    def identifier(self, update=False):
+        return self._id
+    
+    def name(self):
+        if self._name is None:
+            self._name = id_to_name(self._id)
+        return self._name
+    
+    def type_name(self):
+        if self._type_name is None:
+            self._type_name = id_to_type_name(self._id)
+        return self._type_name
+        
+
+    def destroy(self):
+        return self._system_proxy.delete('/api/' + self._class_name + '/destroy?identifier=' + self._identifier)
+
+class ProcessProxy(ObjectProxy):
+    def __init__(self, name, host, port, protocol='http'):
+        if protocol is None:
+            super().__init__(None, 'process', None)
+            self._name = name
+        elif protocol == 'http':
+            super().__init__(SystemProxy(HttpProxy(host,port)), 'process', None)
+            self._name = None
+            for p in self.system.processes():
+                if p.name() == name:
+                    self._id = p.identifier()
+                    return
+            
+    def __repr__(self):
+        return f'ProcessProxy("{self.identifier()}")'
+    
+    @classmethod
+    def new(cls, system_proxy, identifier):
+        p = ProcessProxy(None, None, None, protocol=None)
+        p.system = system_proxy
+        p._id = identifier
+        return p
+    
+    def call(self, *args, **kwargs):
+        prof = self.profile_full()
+        if len(args) == 1:
+            arg_prof = prof['arguments']
+            body = {
+                arg_prof[0]['name']: args[0]
+            }
+        elif 'body' in kwargs.keys():
+            body = kwargs['body']
+        else:
+            body = {}
+            args_prof = prof['arguments']
+            for a, a_prof in zip(args, args_prof):
+                if isinstance(a, Image.Image):
+                    body[a_prof['name']] = a
+                else:
+                    body[a_prof['name']] = json.dumps(a)
+            for k, v in kwargs.items():
+                body[k] = v
+        return self.system.crud.update(self._cn, 'call', body, {'identifier': self._id}, profile=self._profile)
+    
+    def __call__(self, *args, **kwargs):
+        return self.call(*args, **kwargs)
+
+    def execute(self):
+        return self.system.crud.update(self._cn, 'execute', {}, {'identifier': self._id})
+    
+    def p_apply(self, arg_name: str, value: dict): 
+        return self.system.crud.update(self._cn, 'p_apply', {'arg_name': arg_name, 'value': value}, {'identifier': self._id})
+
+class ContainerProxy(ObjectProxy):
+        
+    def __init__(self, name, host, port, protocol='http'):
+        if protocol is None:
+            super().__init__(None, 'container', None)
+            self._name = name
+        elif protocol == 'http':
+            super().__init__(SystemProxy(HttpProxy(host,port)), 'container', None)
+            self._name = None
+            for c in self.system.containers():
+                # print(c.type_name(), name)
+                if c.type_name() == name:
+                    self._id = c.identifier()
+                    return
+                
+    @classmethod
+    def new(cls, system_proxy, identifier):
+        p = ContainerProxy(None, None, None, protocol=None)
+        p.system = system_proxy
+        p._id = identifier
+        return p
+    
+    def __repr__(self):
+        return f'ContainerProxy("{self.identifier()}")'
+    
+    def processes(self):
+        pids = self.profile_full()['processes']
+        return [ContainerProcessProxy(self.system, pid) for pid in pids]
+        
+    def process(self, id):
+        pids = self.profile_full()['processes']
+        for pid in pids:
+            if pid == id:
+                return ContainerProcessProxy(self.system, pid)
+        return None          
+    
+    def __getattr__(self, name):
+        # search process by name:
+        ps = self.processes()
+        for p in ps:
+            if p.type_name() == name:
+                return p
+        for p in ps:
+            if p.name()  == name:
+                return p
+        raise AttributeError(self, name)
+    
+
+class ContainerProcessProxy(ObjectProxy):
+    def __init__(self, system_proxy, identifier):
+        super().__init__(system_proxy, 'container_process', identifier)    
+
+    def __repr__(self):
+        return f'ContainerProcess("{self.identifier()}")'
+
+    def call(self, *args, **kwargs):
+        prof = self.profile_full()
+        if len(args) == 1:
+            arg_prof = prof['arguments']
+            body = {
+                arg_prof[0]['name']: args[0]
+            }
+            #body = args[0]
+        elif 'body' in kwargs.keys():
+            body = kwargs['body']
+        else:
+            body = {}
+            args_prof = prof['arguments']
+            for a, a_prof in zip(args, args_prof):
+                if isinstance(a, Image.Image):
+                    body[a_prof['name']] = a
+                else:
+                    body[a_prof['name']] = json.dumps(a)
+            for k, v in kwargs.items():
+                body[k] = v
+            #body = kwargs
+        return self.system.crud.update(self._cn, 'call', body, {'identifier': self._id}, profile=self.profile_full())
+
+    def __call__(self, *args, **kwargs):
+        return self.call(*args, **kwargs)
+    
+    def execute(self):
+        return self.system.crud.update(self._cn, 'execute', {}, {'identifier': self._id}, profile=self._profile)
+
+    def p_apply(self, arg_name: str, value: dict): 
+        return self.system.crud.update(self._cn, 'p_apply', {'arg_name': arg_name, 'value': value}, {'identifier': self._id})
+
+
+class IdentifierStruct(object):
+
+    def __init__(self, broker_type, broker_name, class_name, type_name, name):
+        self.broker_type = broker_type
+        self.broker_name = broker_name
+        self.class_name = class_name
+        self.type_name = type_name
+        self.name = name
+
+    @classmethod
+    def fromIdentifier(self, id):
+        s, type_name = id.split('::')
+        broker_type, s2 = s.split('://')
+        broker_name, class_name, name = s2.split('/')
+        return IdentifierStruct(broker_type, broker_name, class_name, type_name, name)
+
+    def to_id(self):
+        return f'{self.broker_type}://{self.broker_name}/{self.class_name}/{self.name}::{self.type_name}'
+
+    def __repr__(self):
+        return f'IdentifierStruct(broker_type="{self.broker_type}",broker_name="{self.broker_name}",class_name="{self.class_name}",type_name="{self.type_name}",name="{self.name}")'
+
+
+def id_to_name(id: str):
+    if id.find('://') > 0: # 通常IDフォーマット。プロトコルあり
+        # print('id=', id)
+        broker_type, id_body = id.split('://')
+        broker_name, class_name, name_and_type = id_body.split('/')
+        name, type_name = name_and_type.split('::')
+        return name
+    
+
+def id_to_type_name(id: str):
+    if id.find('://') > 0: # 通常IDフォーマット。プロトコルあり
+        # print('id=', id)
+        broker_type, id_body = id.split('://')
+        broker_name, class_name, name_and_type = id_body.split('/')
+        name, type_name = name_and_type.split('::')
+        return type_name
+
+if __name__ == '__main__':
+    i = 'core://core/process/hoge_process_name0::hoge_process'
+    print(id_to_name(i))

pyjuiz-0.0.2/pyjuiz.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: pyjuiz
+Version: 0.0.2
+Summary: Python binding interface for JUIZ robot middleware components
+Home-page: https://github.com/juiz
+Author: ysuga
+Author-email: ysuga@ysuga.net
+License: MIT
+Keywords: robot,middleware
+Classifier: Programming Language :: Python :: 3.10
+Requires-Dist: yaml
+Requires-Dist: httpx
+Requires-Dist: pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

pyjuiz-0.0.2/pyjuiz.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+juiz/__init__.py
+juiz/__main__.py
+juiz/decorators.py
+juiz/juiz.py
+juiz/proxy/__init__.py
+pyjuiz.egg-info/PKG-INFO
+pyjuiz.egg-info/SOURCES.txt
+pyjuiz.egg-info/dependency_links.txt
+pyjuiz.egg-info/requires.txt
+pyjuiz.egg-info/top_level.txt

pyjuiz-0.0.2/pyjuiz.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyjuiz-0.0.2/pyjuiz.egg-info/requires.txt

@@ -0,0 +1,3 @@
+yaml
+httpx
+pillow

pyjuiz-0.0.2/pyjuiz.egg-info/top_level.txt

@@ -0,0 +1 @@
+juiz

pyjuiz-0.0.2/setup.cfg

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

pyjuiz-0.0.2/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="pyjuiz",
+    version="0.0.2",
+    description='Python binding interface for JUIZ robot middleware components',
+    url='https://github.com/juiz',
+    author='ysuga',
+    author_email='ysuga@ysuga.net',
+    license='MIT',
+    keywords='robot,middleware',
+    install_requires=["yaml", "httpx", "pillow"],
+    extras_require={
+        #"develop": ["dev-packageA", "dev-packageB"]
+    },
+    packages=find_packages(),
+    classifiers=[
+        'Programming Language :: Python :: 3.10',
+    ],
+)