ivoryos 1.0.9__py3-none-any.whl → 1.4.4__py3-none-any.whl

ivoryos/utils/serilize.py

@@ -0,0 +1,201 @@
+import ast
+import json
+import inspect
+import logging
+from typing import get_type_hints, Union, Optional, get_origin, get_args
+import sys
+
+import flask
+
+from example.abstract_sdl_example import abstract_sdl as deck
+
+
+
+class ScriptAnalyzer:
+    def __init__(self):
+        self.primitive_types = {
+            'int', 'float', 'str', 'bool', 'tuple', 'list'
+        }
+        self.type_mapping = {
+            int: 'int',
+            float: 'float',
+            str: 'str',
+            bool: 'bool',
+            tuple: 'tuple',
+            list: 'list'
+        }
+
+    def extract_type_from_hint(self, type_hint):
+        """Extract primitive types from type hints, handling Union and Optional"""
+        if type_hint is None:
+            return None
+
+        # Handle Union types (including Optional which is Union[T, None])
+        origin = get_origin(type_hint)
+        if origin is Union:
+            args = get_args(type_hint)
+            types = []
+            for arg in args:
+                if arg is type(None):  # Skip None type
+                    continue
+                if arg in self.type_mapping:
+                    types.append(self.type_mapping[arg])
+                elif hasattr(arg, '__name__') and arg.__name__ in self.primitive_types:
+                    types.append(arg.__name__)
+                else:
+                    return None  # Non-primitive type found
+            return types if types else None
+
+        # Handle direct primitive types
+        if type_hint in self.type_mapping:
+            return [self.type_mapping[type_hint]]
+        elif hasattr(type_hint, '__name__') and type_hint.__name__ in self.primitive_types:
+            return [type_hint.__name__]
+        else:
+            return None  # Non-primitive type
+
+
+    def analyze_method(self, method):
+        """Analyze a single method and extract its signature"""
+        try:
+            sig = inspect.signature(method)
+            type_hints = get_type_hints(method)
+
+            parameters = []
+            type_hint_warning = False
+            user_input_params = []
+
+            for param_name, param in sig.parameters.items():
+                if param_name == 'self':
+                    continue
+
+                param_info = {"name": param_name}
+
+                # Get type hint
+                if param_name in type_hints:
+                    type_list = self.extract_type_from_hint(type_hints[param_name])
+                    if type_list is None:
+                        type_hint_warning = True
+                        user_input_params.append(param_name)
+                        param_info["type"] = ""
+                    else:
+                        param_info["type"] = type_list[0] if len(type_list) == 1 else type_list
+                else:
+                    type_hint_warning = True
+                    user_input_params.append(param_name)
+                    param_info["type"] = ""
+
+                # Get default value
+                if param.default != inspect.Parameter.empty:
+                    param_info["default"] = param.default
+
+                parameters.append(param_info)
+
+            # Get docstring
+            docstring = inspect.getdoc(method)
+
+            method_info = {
+                "docstring": docstring or "",
+                "parameters": parameters
+            }
+
+            return method_info, type_hint_warning
+
+        except Exception as e:
+            print(f"Error analyzing method {method.__name__}: {e}")
+            return None
+
+
+    def analyze_module(self, module, exclude_names=[]):
+        """Analyze module from sys.modules and extract class instances and methods"""
+        exclude_classes = (flask.Blueprint, logging.Logger)
+        # Get all variables in the module that are class instances
+        included = {}
+        excluded = {}
+        failed = {}
+        included_with_warnings = {}
+        for name, obj in vars(module).items():
+            if (
+                    type(obj).__module__ == 'builtins'
+                    or name[0].isupper()
+                    or name.startswith("_")
+                    or isinstance(obj, exclude_classes)
+                    or name in exclude_names
+                    or not hasattr(obj, '__class__')
+            ):
+                excluded[name] = type(obj).__name__
+                continue
+
+            cls = obj.__class__
+
+            try:
+                class_methods, type_hint_warning = self.analyze_class(cls)
+                if class_methods:
+                    if type_hint_warning:
+                        included_with_warnings[name] = class_methods
+                    included[name] = class_methods
+            except Exception as e:
+                failed[name] = str(e)
+                continue
+        return included, included_with_warnings, failed, excluded
+
+    def save_to_json(self, data, output_path):
+        """Save analysis result to JSON file"""
+        with open(output_path, 'w') as f:
+            json.dump(data, f, indent=2)
+
+    def analyze_class(self, cls):
+        class_methods = {}
+        type_hint_flag = False
+        for method_name, method in inspect.getmembers(cls, predicate=callable):
+            if method_name.startswith("_") or method_name.isupper():
+                continue
+            method_info, type_hint_warning = self.analyze_method(method)
+            if type_hint_warning:
+                type_hint_flag = True
+            if method_info:
+                class_methods[method_name] = method_info
+        return class_methods, type_hint_flag
+
+    @staticmethod
+    def print_deck_snapshot(result, with_warnings, failed):
+        print("\nDeck Snapshot:")
+        print("Included Classes:")
+        for name, methods in result.items():
+            print(f"  {name}:")
+            for method_name, method_info in methods.items():
+                print(f"    {method_name}: {method_info}")
+
+        if with_warnings:
+            print("\nClasses with Type Hint Warnings:")
+            for name, methods in with_warnings.items():
+                print(f"  {name}:")
+                for method_name, method_info in methods.items():
+                    print(f"    {method_name}: {method_info}")
+
+        if failed:
+            print("\nFailed Classes:")
+            for name, error in failed.items():
+                print(f"  {name}: {error}")
+
+if __name__ == "__main__":
+
+    _analyzer = ScriptAnalyzer()
+    # module = sys.modules[deck]
+    try:
+
+        result, with_warnings, failed, _ = _analyzer.analyze_module(deck)
+
+        output_path = f"analysis.json"
+        _analyzer.save_to_json(result, output_path)
+
+        print(f"\nAnalysis complete! Results saved to: {output_path}")
+
+
+
+
+        _analyzer.print_deck_snapshot(result, with_warnings, failed)
+
+    except Exception as e:
+        print(f"Error: {e}")
+

ivoryos/utils/task_runner.py

@@ -1,7 +1,10 @@
+import inspect
+import asyncio
 import threading
 import time
 from datetime import datetime
 
+from ivoryos.utils.decorators import BUILDING_BLOCKS
 from ivoryos.utils.db_models import db, SingleStep
 from ivoryos.utils.global_config import GlobalConfig
 
@@ -18,8 +21,7 @@ class TaskRunner:
         self.globals_dict = globals_dict
         self.lock = global_config.runner_lock
 
-
-    def run_single_step(self, component, method, kwargs, wait=True, current_app=None):
+    async def run_single_step(self, component, method, kwargs, wait=True, current_app=None):
         global deck
         if deck is None:
             deck = global_config.deck
@@ -28,18 +30,18 @@ class TaskRunner:
         if not self.lock.acquire(blocking=False):
             current_status = global_config.runner_status
             current_status["status"] = "busy"
+            current_status["output"] = "busy"
             return current_status
 
-
         if wait:
-            output = self._run_single_step(component, method, kwargs, current_app)
+            output = await self._run_single_step(component, method, kwargs, current_app)
         else:
-            print("running with thread")
-            thread = threading.Thread(
-                target=self._run_single_step, args=(component, method, kwargs, current_app)
-            )
-            thread.start()
-            time.sleep(0.1)
+            # Create background task properly
+            async def background_runner():
+                await self._run_single_step(component, method, kwargs, current_app)
+
+            asyncio.create_task(background_runner())
+            await asyncio.sleep(0.1)  # Change time.sleep to await asyncio.sleep
             output = {"status": "task started", "task_id": global_config.runner_status.get("id")}
 
         return output
@@ -48,34 +50,82 @@ class TaskRunner:
         if component.startswith("deck."):
             component = component.split(".")[1]
             instrument = getattr(deck, component)
+            function_executable = getattr(instrument, method)
+        elif component.startswith("blocks."):
+            component = component.split(".")[1]
+            function_executable = BUILDING_BLOCKS[component][method]["func"]
         else:
             temp_connections = global_config.defined_variables
             instrument = temp_connections.get(component)
-        function_executable = getattr(instrument, method)
+            function_executable = getattr(instrument, method)
         return function_executable
 
-    def _run_single_step(self, component, method, kwargs, current_app=None):
+    async def _run_single_step(self, component, method, kwargs, current_app=None):
         try:
             function_executable = self._get_executable(component, deck, method)
-            method_name = f"{function_executable.__self__.__class__.__name__}.{function_executable.__name__}"
+            method_name = f"{component}.{method}"
         except Exception as e:
             self.lock.release()
-            return {"status": "error", "msg": e.__str__()}
+            return {"status": "error", "msg": str(e)}
 
-        # with self.lock:
+        # Flask context is NOT async → just use normal "with"
         with current_app.app_context():
-            step = SingleStep(method_name=method_name, kwargs=kwargs, run_error=False, start_time=datetime.now())
+            step = SingleStep(
+                method_name=method_name,
+                kwargs=kwargs,
+                run_error=None,
+                start_time=datetime.now()
+            )
             db.session.add(step)
-            db.session.commit()
-            global_config.runner_status = {"id":step.id, "type": "task"}
+            db.session.flush()
+            global_config.runner_status = {"id": step.id, "type": "task"}
+
             try:
-                output = function_executable(**kwargs)
+                kwargs = self._convert_kwargs_type(kwargs, function_executable)
+
+                if inspect.iscoroutinefunction(function_executable):
+                    output = await function_executable(**kwargs)
+                else:
+                    output = function_executable(**kwargs)
+
                 step.output = output
                 step.end_time = datetime.now()
+                success = True
             except Exception as e:
-                step.run_error = e.__str__()
+                step.run_error = str(e)
                 step.end_time = datetime.now()
+                success = False
+                output = str(e)
             finally:
                 db.session.commit()
                 self.lock.release()
-            return output
+
+            return dict(success=success, output=output)
+
+    @staticmethod
+    def _convert_kwargs_type(kwargs, function_executable):
+        def convert_guess(str_value):
+            str_value = str_value.strip()
+            if str_value.isdigit() or (str_value.startswith('-') and str_value[1:].isdigit()):
+                return int(str_value)
+            try:
+                return float(str_value)
+            except ValueError:
+                return str_value
+
+        sig = inspect.signature(function_executable)
+        converted = {}
+
+        for name, value in kwargs.items():
+            if name in sig.parameters:
+                param = sig.parameters[name]
+                if param.annotation != inspect.Parameter.empty:
+                    # convert using type hint
+                    try:
+                        converted[name] = param.annotation(value)
+                    except Exception:
+                        converted[name] = value
+                else:
+                    # no type hint → guess
+                    converted[name] = convert_guess(value)
+        return converted

ivoryos/utils/utils.py

@@ -1,6 +1,7 @@
 import ast
 import importlib
 import inspect
+import json
 import logging
 import os
 import pickle
@@ -11,10 +12,11 @@ from collections import Counter
 
 import flask
 from flask import session
+from flask_login import current_user
 from flask_socketio import SocketIO
 
 from ivoryos.utils.db_models import Script
-
+from ivoryos.utils.decorators import BUILDING_BLOCKS
 
 def get_script_file():
     """Get script from Flask session and returns the script"""
@@ -24,7 +26,7 @@ def get_script_file():
         s.__dict__.update(**session_script)
         return s
     else:
-        return Script(author=session.get('user'))
+        return Script(author=current_user.get_id(),)
 
 
 def post_script_file(script, is_dict=False):
@@ -104,7 +106,8 @@ def _inspect_class(class_object=None, debug=False):
             try:
                 annotation = inspect.signature(method)
                 docstring = inspect.getdoc(method)
-                functions[function] = dict(signature=annotation, docstring=docstring)
+                coroutine = inspect.iscoroutinefunction(method)
+                functions[function] = dict(signature=annotation, docstring=docstring, coroutine=coroutine,)
 
             except Exception:
                 pass
@@ -140,6 +143,7 @@ def _get_type_from_parameters(arg, parameters):
 def _convert_by_str(args, arg_types):
     """
     Converts a value to type through eval(f'{type}("{args}")')
+    v1.3.4 TODO try str lastly, otherwise it's always converted to str
     """
     if type(arg_types) is not list:
         arg_types = [arg_types]
@@ -150,6 +154,7 @@ def _convert_by_str(args, arg_types):
                 return args
             except Exception:
                 raise TypeError(f"Input type error: cannot convert '{args}' to {arg_type}.")
+    return args
 
 
 def _convert_by_class(args, arg_types):
@@ -347,8 +352,8 @@ def create_deck_snapshot(deck, save: bool = False, output_path: str = '', exclud
             for name, class_type in items.items():
                 print(f"  {name}: {class_type}")
 
-        print_section("✅ INCLUDED", deck_summary["included"])
-        print_section("❌ FAILED", deck_summary["failed"])
+        print_section("✅ INCLUDED MODULES", deck_summary["included"])
+        print_section("❌ FAILED MODULES", deck_summary["failed"])
         print("\n")
 
     print_deck_snapshot(deck_summary)
@@ -363,6 +368,28 @@ def create_deck_snapshot(deck, save: bool = False, output_path: str = '', exclud
     return deck_snapshot
 
 
+def create_block_snapshot(save: bool = False, output_path: str = ''):
+    block_snapshot = {}
+    included = {}
+    failed = {}
+    for category, data in BUILDING_BLOCKS.items():
+        key = f"blocks.{category}"
+        block_snapshot[key] = {}
+
+        for func_name, meta in data.items():
+            func = meta["func"]
+            block_snapshot[key][func_name] = {
+                "signature": meta["signature"],
+                "docstring": meta["docstring"],
+                "coroutine": meta["coroutine"],
+                "path": f"{func.__module__}.{func.__qualname__}"
+            }
+    if block_snapshot:
+        print(f"\n=== ✅ BUILDING_BLOCKS ({len(block_snapshot)}) ===")
+        for category, blocks in block_snapshot.items():
+            print(f"  {category}: ", ",".join(blocks.keys()))
+    return block_snapshot
+
 def load_deck(pkl_name: str):
     """
     Loads a pickled deck snapshot from disk on offline mode
@@ -419,4 +446,21 @@ def get_local_ip():
         ip = '127.0.0.1'
     finally:
         s.close()
-    return ip
+    return ip
+
+
+def safe_dump(obj):
+    try:
+        json.dumps(obj)
+        return obj
+    except (TypeError, OverflowError):
+        return repr(obj)  # store readable representation
+
+
+def create_module_snapshot(module):
+    classes = inspect.getmembers(module, inspect.isclass)
+    api_variables = {}
+    for i in classes:
+        # globals()[i[0]] = i[1]
+        api_variables[i[0]] = i[1]
+    return api_variables

ivoryos/version.py

@@ -1 +1 @@
-__version__ = "1.0.9"
+__version__ = "1.4.4"