symbolicai 0.20.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

symai/backend/mixin/anthropic.py

@@ -33,7 +33,8 @@ class AnthropicMixin:
            self.model == 'claude-3-opus-20240229' or \
            self.model == 'claude-3-sonnet-20240229' or \
            self.model == 'claude-3-haiku-20240307':
-            return 200_000
+           return 200_000
+        return None
 
     def api_max_response_tokens(self):
         if self.model == 'claude-sonnet-4-0' or \
@@ -53,4 +54,5 @@ class AnthropicMixin:
            self.model == 'clade-3-opus-20240229' or \
            self.model == 'claude-3-sonnet-20240229' or \
            self.model == 'claude-3-haiku-20240307':
-            return 4_096
+           return 4_096
+        return None

symai/backend/mixin/deepseek.py

@@ -8,7 +8,9 @@ class DeepSeekMixin:
     def api_max_context_tokens(self):
         if self.model == 'deepseek-reasoner':
             return 64_000
+        return None
 
     def api_max_response_tokens(self):
         if self.model == 'deepseek-reasoner':
             return 8_000
+        return None

symai/backend/mixin/google.py

@@ -10,7 +10,9 @@ class GoogleMixin:
     def api_max_context_tokens(self):
         if self.model.startswith('gemini-2.5-'):
             return 1_048_576
+        return None
 
     def api_max_response_tokens(self):
         if self.model == 'gemini-2.5-':
             return 65_536
+        return None

symai/backend/mixin/openai.py

@@ -1,3 +1,5 @@
+from ...utils import UserMessage
+
 SUPPORTED_COMPLETION_MODELS = [
     'davinci-002',
 ]
@@ -86,7 +88,9 @@ class OpenAIMixin:
            self.model == 'gpt-4.1-mini' or \
            self.model == 'gpt-4.1-nano':
             return 1_047_576
-        raise ValueError(f'Unsupported model: {self.model}')
+        msg = f'Unsupported model: {self.model}'
+        UserMessage(msg)
+        raise ValueError(msg)
 
     def api_max_response_tokens(self):
         if self.model == 'davinci-002':
@@ -122,7 +126,9 @@ class OpenAIMixin:
            self.model == 'gpt-5-nano' or \
            self.model == 'gpt-5-chat-latest':
             return 128_000
-        raise ValueError(f'Unsupported model: {self.model}')
+        msg = f'Unsupported model: {self.model}'
+        UserMessage(msg)
+        raise ValueError(msg)
 
     def api_embedding_dims(self):
         if self.model == 'text-embedding-ada-002':
@@ -131,4 +137,6 @@ class OpenAIMixin:
             return 1_536
         if self.model == 'text-embedding-3-large':
             return 3_072
-        raise ValueError(f'Unsupported model: {self.model}')
+        msg = f'Unsupported model: {self.model}'
+        UserMessage(msg)
+        raise ValueError(msg)

symai/backend/settings.py

@@ -1,5 +1,4 @@
 import json
-import os
 import sys
 from pathlib import Path
 
@@ -18,6 +17,26 @@ class SymAIConfig:
         self._env_config_dir = self._env_path / '.symai'
         self._home_config_dir = Path.home() / '.symai'
         self._debug_dir = Path.cwd()  # Current working directory for debug mode
+        self._active_paths: dict[str, Path] = {}
+
+    def _canonical_key(self, filename: str | Path) -> str:
+        """Return a canonical identifier for config files regardless of input type."""
+        path = Path(filename)
+        if path.is_absolute() or path.parent != Path():
+            return str(path)
+        return path.name or str(path)
+
+    def _remove_legacy_path_keys(self, key: str) -> None:
+        """Drop legacy Path keys that collide with the canonical key."""
+        target_path = Path(key)
+        target_name = target_path.name or key
+        stale_keys: list[Path] = [
+            existing_key for existing_key in self._active_paths
+            if isinstance(existing_key, Path)
+            and (existing_key.name == target_name or str(existing_key) == key)
+        ]
+        for stale_key in stale_keys:
+            self._active_paths.pop(stale_key, None)
 
     @property
     def config_dir(self) -> Path:
@@ -31,41 +50,59 @@ class SymAIConfig:
         # Finally home directory
         return self._home_config_dir
 
-    def get_config_path(self, filename: str, fallback_to_home: bool = False) -> Path:
+    def get_config_path(self, filename: str | Path, fallback_to_home: bool = False) -> Path:
         """Gets the config path using the priority system or forces fallback to home."""
-        debug_config = self._debug_dir / filename
-        env_config   = self._env_config_dir / filename
-        home_config  = self._home_config_dir / filename
+        input_path = Path(filename)
+        if input_path.is_absolute() or input_path.parent != Path():
+            return input_path
+
+        normalized_filename = self._canonical_key(filename)
+        # Only use the basename for managed directories
+        normalized_filename = Path(normalized_filename).name
+        debug_config = self._debug_dir / normalized_filename
+        env_config   = self._env_config_dir / normalized_filename
+        home_config  = self._home_config_dir / normalized_filename
 
         # Check debug first (only valid for symai.config.json)
-        if filename == 'symai.config.json' and debug_config.exists():
+        if normalized_filename == 'symai.config.json' and debug_config.exists():
             return debug_config
 
         # If forced to fallback, return home config if it exists, otherwise environment
         if fallback_to_home:
-            return home_config if home_config.exists() else env_config
+            if home_config.exists():
+                return home_config
+            return env_config
 
         # Normal priority-based resolution
-        # If environment config doesn't exist, return that path (for creation)
-        if not env_config.exists():
+        if env_config.exists():
             return env_config
-        # Otherwise use environment config
+        if home_config.exists():
+            return home_config
         return env_config
 
-    def load_config(self, filename: str, fallback_to_home: bool = False) -> dict:
+    def load_config(self, filename: str | Path, fallback_to_home: bool = False) -> dict:
         """Loads JSON data from the determined config location."""
         config_path = self.get_config_path(filename, fallback_to_home=fallback_to_home)
+        key = self._canonical_key(filename)
         if not config_path.exists():
+            self._remove_legacy_path_keys(key)
+            self._active_paths.pop(key, None)
             return {}
-        with open(config_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
+        with config_path.open(encoding='utf-8') as f:
+            config = json.load(f)
+        self._remove_legacy_path_keys(key)
+        self._active_paths[key] = config_path
+        return config
 
-    def save_config(self, filename: str, data: dict, fallback_to_home: bool = False) -> None:
+    def save_config(self, filename: str | Path, data: dict, fallback_to_home: bool = False) -> None:
         """Saves JSON data to the determined config location."""
         config_path = self.get_config_path(filename, fallback_to_home=fallback_to_home)
-        os.makedirs(config_path.parent, exist_ok=True)
-        with open(config_path, 'w', encoding='utf-8') as f:
+        key = self._canonical_key(filename)
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with config_path.open('w', encoding='utf-8') as f:
             json.dump(data, f, indent=4)
+        self._remove_legacy_path_keys(key)
+        self._active_paths[key] = config_path
 
     def migrate_config(self, filename: str, updates: dict) -> None:
         """Updates existing configuration with new fields."""
@@ -73,6 +110,36 @@ class SymAIConfig:
         config.update(updates)
         self.save_config(filename, config)
 
+    def get_active_path(self, filename: str | Path) -> Path:
+        """Returns the last path used to read or write the given config file."""
+        key = self._canonical_key(filename)
+        cached = self._active_paths.get(key)
+        if cached is not None:
+            return cached
+        for legacy_key, cached_path in list(self._active_paths.items()):
+            if isinstance(legacy_key, Path) and (
+                legacy_key.name == key or str(legacy_key) == key
+            ):
+                self._active_paths.pop(legacy_key, None)
+                self._active_paths[key] = cached_path
+                return cached_path
+        return self.get_config_path(filename)
+
+    def get_active_config_dir(self) -> Path:
+        """Returns the directory backing the active symai configuration."""
+        symai_key = self._canonical_key('symai.config.json')
+        cached = self._active_paths.get(symai_key)
+        if cached is not None:
+            return cached.parent
+        for legacy_key, cached_path in list(self._active_paths.items()):
+            if isinstance(legacy_key, Path) and (
+                legacy_key.name == symai_key or str(legacy_key) == symai_key
+            ):
+                self._active_paths.pop(legacy_key, None)
+                self._active_paths[symai_key] = cached_path
+                return cached_path.parent
+        return self.config_dir
+
 SYMAI_CONFIG = {}
 SYMSH_CONFIG = {}
 SYMSERVER_CONFIG = {}

symai/chat.py

@@ -1,6 +1,5 @@
 import logging
 import re
-from typing import Optional
 
 from loguru import logger
 
@@ -13,6 +12,7 @@ from .post_processors import ConsolePostProcessor, StripPostProcessor
 from .pre_processors import ConsoleInputPreProcessor
 from .prompts import MemoryCapabilities, SymbiaCapabilities
 from .symbol import Expression, Symbol
+from .utils import UserMessage
 
 logging.getLogger('charset_normalizer').setLevel(logging.ERROR)
 
@@ -45,10 +45,10 @@ class ChatBot(Expression):
         self.detect_memory_usage = InContextClassification(MemoryCapabilities())
         self._last_user_input: str = ''
 
-    def repeat(self, query, **kwargs):
+    def repeat(self, query, **_kwargs):
         return self.narrate('Symbia does not understand and asks to repeat and give more context.', prompt=query)
 
-    def narrate(self, message: str, context: str = None, category: str = None, end: bool = False, **kwargs) -> Symbol:
+    def narrate(self, message: str, context: str | None = None, category: str | None = None, end: bool = False, **kwargs) -> Symbol:
         reflection = context if context is not None else ''
         ltmem_recall = 'No memories retrieved.'
         stmem_recall = '\n'.join(self.short_term_memory.recall())
@@ -73,7 +73,8 @@ class ChatBot(Expression):
             if do == 'SAVE':
                 self.long_term_memory(f'{self.name}: {reflection}', operation='add', top_k=self.long_term_mem_top_k, index_name=self.index_name)
                 self.long_term_memory('save', operation='config', index_name=self.index_name)
-                if self.verbose: logger.debug(f'Store new long-term memory:\n{reflection}\n')
+                if self.verbose:
+                    logger.debug(f'Store new long-term memory:\n{reflection}\n')
                 message = f'{self.name} inform the user that the memory was stored.'
             elif do == 'DUPLICATE':
                 message = f'{self.name} engages the user in a conversation about the duplicate topic, showing the user she remembered the past interaction.'
@@ -86,7 +87,8 @@ class ChatBot(Expression):
 
         reply = f'{self.name}: {self._narration(message, self._last_user_input, reflection, context, ltmem_recall, stmem_recall, **kwargs)}'
 
-        if end: print('\n\n', reply)
+        if end:
+            UserMessage(f'\n\n{reply}', text="extensity")
 
         return Symbol(reply)
 
@@ -118,8 +120,8 @@ class ChatBot(Expression):
     @staticmethod
     def _init_custom_input_postprocessor(that):
         class CustomInputPostProcessor(ConsolePostProcessor):
-            def __call__(self, rsp, argument):
-                that.short_term_memory.store(f'User: {str(rsp)}')
+            def __call__(self, rsp, _argument):
+                that.short_term_memory.store(f'User: {rsp!s}')
                 return rsp
         return CustomInputPostProcessor
 
@@ -157,108 +159,130 @@ The chatbot always reply in the following format
         @core.zero_shot(prompt=prompt, **kwargs)
         def _func(_) -> str:
             pass
-        if self.verbose: logger.debug(f'Narration:\n{prompt}\n')
-        res = _func(self)
-        res = res.replace(f'{self.name}: ', '').strip()
-        return res
+        if self.verbose:
+            logger.debug(f'Narration:\n{prompt}\n')
+        return _func(self).replace(f'{self.name}: ', '').strip()
 
 class SymbiaChat(ChatBot):
     def __init__(self, name: str = 'Symbia', verbose: bool = False, **kwargs):
         super().__init__(name=name, verbose=verbose, **kwargs)
         self.message = self.narrate(f'{self.name} introduces herself, writes a greeting message and asks how to help.', context=None)
 
-    def forward(self, usr: Optional[str] = None) -> Symbol:
+    def forward(self, usr: str | None = None) -> Symbol:
         loop = True
         ask_input = True
         if usr:
             ask_input = False
             usr = self._to_symbol(usr)
 
-        # added step-by-step interaction with the user if input is provided
         while loop:
-            # if no input is provided, ask for input
-            if ask_input:
-                usr = self.input(self.message)
-            else:
-                loop = False # break the loop after the first iteration
-
+            usr, loop = self._resolve_user_input(usr, loop, ask_input)
             self._last_user_input = usr
-            if self.verbose: logger.debug(f'User:\n{usr}\n')
-
-            if len(str(usr)) > 0:
-                ctxt = str(self.detect_capability(usr))
-            else:
-                ctxt = '[DK]'
+            self._log_verbose('User', usr)
 
-            if self.verbose: logger.debug(f'In-context:\n{ctxt}\n')
+            ctxt = self._context_from_user(usr)
+            self._log_verbose('In-context', ctxt)
 
-            if '[EXIT]' in ctxt:
-                self.message = self.narrate(f'{self.name} writes friendly goodbye message.', context=None, end=True)
+            if self._handle_exit_context(ctxt):
                 break
-            elif '[HELP]' in ctxt:
-                reflection = self._extract_reflection(ctxt)
-                self.message = self.narrate(f'{self.name} ', context=reflection)
-            elif '[RECALL]' in ctxt:
-                reflection = self._extract_reflection(ctxt)
-                category = self._extract_category(ctxt)
-                self.message = self.narrate(f'{self.name} uses replies based on what has been recovered from the memory.', context=ctxt, category=category)
-            elif '[DK]' in ctxt:
-                reflection = self._extract_reflection(ctxt)
-                self.message = self.narrate(f'{self.name} is not sure about the message and references and asks the user for more context.', context=reflection)
 
-            else:
-                try:
-                    if '[SYMBOLIC]' in ctxt:
-                        q = usr.extract("mathematical formula that WolframAlpha can solve")
-                        rsp = self.interfaces['symbolic'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user and provides the solution of the math problem.', context=rsp)
-                    elif '[SEARCH]' in ctxt:
-                        q = usr.extract('user query request')
-                        rsp = self.interfaces['search'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user based on the online search results.', context=rsp)
-                    elif '[SCRAPER]' in ctxt:
-                        q = usr.extract('URL from text')
-                        q = q.convert('proper URL, example: https://www.google.com')
-                        rsp = self.interfaces['scraper'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user and narrates its findings.', context=rsp)
-                    elif '[SPEECH-TO-TEXT]' in ctxt:
-                        q = usr.extract('extract file path')
-                        rsp = self.interfaces['stt'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user and transcribes the content of the audio file.', context=rsp)
-                    elif '[TEXT-TO-IMAGE]' in ctxt:
-                        q = usr.extract('text for image creation')
-                        rsp = self.interfaces['drawing'](q)
-                        self.message = self.narrate('Symbia replies to the user and provides the image URL.', context=rsp)
-                    elif '[FILE]' in ctxt:
-                        file_path = usr.extract('extract file path')
-                        q = usr.extract('user question')
-                        rsp = self.interfaces['file'](file_path)
-                        self.message = self.narrate(f'{self.name} replies to the user and outlines and relies to the user query.', context=rsp)
-                    else:
-                        q = usr.extract('user query request')
-                        reflection = self._extract_reflection(ctxt)
-                        self.message = self.narrate(f'{self.name} tries to interpret the response, and if unclear asks the user to restate the statement or add more context.', context=reflection)
-
-                except Exception as e:
-                    reflection = self._extract_reflection(ctxt)
-                    self.message = self.narrate(f'{self.name} apologizes and explains the user what went wrong.', context=str(e))
+            if self._handle_reflection_context(ctxt):
+                continue
+
+            self._handle_interface_context(usr, ctxt)
 
         return self.message
 
+    def _resolve_user_input(self, usr: Symbol | None, loop: bool, ask_input: bool) -> tuple[Symbol, bool]:
+        if ask_input:
+            usr = self.input(self.message)
+        else:
+            loop = False
+        return usr, loop
+
+    def _log_verbose(self, title: str, content) -> None:
+        if self.verbose:
+            logger.debug(f'{title}:\n{content}\n')
+
+    def _context_from_user(self, usr: Symbol) -> str:
+        text = str(usr)
+        if len(text) == 0:
+            return '[DK]'
+        return str(self.detect_capability(usr))
+
+    def _handle_exit_context(self, ctxt: str) -> bool:
+        if '[EXIT]' in ctxt:
+            self.message = self.narrate(f'{self.name} writes friendly goodbye message.', context=None, end=True)
+            return True
+        return False
+
+    def _handle_reflection_context(self, ctxt: str) -> bool:
+        if '[HELP]' in ctxt:
+            reflection = self._extract_reflection(ctxt)
+            self.message = self.narrate(f'{self.name} ', context=reflection)
+            return True
+        if '[RECALL]' in ctxt:
+            reflection = self._extract_reflection(ctxt)
+            category = self._extract_category(ctxt)
+            self.message = self.narrate(f'{self.name} uses replies based on what has been recovered from the memory.', context=ctxt, category=category)
+            return True
+        if '[DK]' in ctxt:
+            reflection = self._extract_reflection(ctxt)
+            self.message = self.narrate(f'{self.name} is not sure about the message and references and asks the user for more context.', context=reflection)
+            return True
+        return False
+
+    def _handle_interface_context(self, usr: Symbol, ctxt: str) -> None:
+        try:
+            if '[SYMBOLIC]' in ctxt:
+                q = usr.extract("mathematical formula that WolframAlpha can solve")
+                rsp = self.interfaces['symbolic'](q)
+                self.message = self.narrate(f'{self.name} replies to the user and provides the solution of the math problem.', context=rsp)
+            elif '[SEARCH]' in ctxt:
+                q = usr.extract('user query request')
+                rsp = self.interfaces['search'](q)
+                self.message = self.narrate(f'{self.name} replies to the user based on the online search results.', context=rsp)
+            elif '[SCRAPER]' in ctxt:
+                q = usr.extract('URL from text')
+                q = q.convert('proper URL, example: https://www.google.com')
+                rsp = self.interfaces['scraper'](q)
+                self.message = self.narrate(f'{self.name} replies to the user and narrates its findings.', context=rsp)
+            elif '[SPEECH-TO-TEXT]' in ctxt:
+                q = usr.extract('extract file path')
+                rsp = self.interfaces['stt'](q)
+                self.message = self.narrate(f'{self.name} replies to the user and transcribes the content of the audio file.', context=rsp)
+            elif '[TEXT-TO-IMAGE]' in ctxt:
+                q = usr.extract('text for image creation')
+                rsp = self.interfaces['drawing'](q)
+                self.message = self.narrate('Symbia replies to the user and provides the image URL.', context=rsp)
+            elif '[FILE]' in ctxt:
+                file_path = usr.extract('extract file path')
+                q = usr.extract('user question')
+                rsp = self.interfaces['file'](file_path)
+                self.message = self.narrate(f'{self.name} replies to the user and outlines and relies to the user query.', context=rsp)
+            else:
+                q = usr.extract('user query request')
+                reflection = self._extract_reflection(ctxt)
+                self.message = self.narrate(f'{self.name} tries to interpret the response, and if unclear asks the user to restate the statement or add more context.', context=reflection)
+
+        except Exception as e:
+            reflection = self._extract_reflection(ctxt)
+            self.message = self.narrate(f'{self.name} apologizes and explains the user what went wrong.', context=str(e))
+
     def _extract_reflection(self, msg: str) -> str:
         res = re.findall(r'\(([^)]+)\)', msg)
         if len(res) > 0:
             return res.pop()
-        return
+        return None
 
     def _extract_category(self, msg: str) -> str:
         res = re.findall(r'\[([^]]+)\]', msg)
         if len(res) > 0:
             return res.pop()
-        return
+        return None
 
     def _memory_scratchpad(self, context, short_term_memory, long_term_memory):
-        scratchpad = f'''
+        return f'''
     [REFLECT](
 Query:      {self._last_user_input}
 Reflection: {self._extract_reflection(context)}
@@ -272,7 +296,6 @@ Reflection: {self._extract_reflection(context)}
 {long_term_memory}
 )
 '''
-        return scratchpad
 
 def run() -> None:
     chat = SymbiaChat()

symai/collect/__init__.py

@@ -1,2 +1,8 @@
+from .dynamic import create_object_from_string
 from .pipeline import CollectionRepository, rec_serialize
-from .dynamic import create_object_from_string
+
+__all__ = [
+    "CollectionRepository",
+    "create_object_from_string",
+    "rec_serialize",
+]

symai/collect/dynamic.py

@@ -1,5 +1,5 @@
-import re
 import ast
+import re
 
 
 class DynamicClass:
@@ -20,7 +20,7 @@ def create_dynamic_class(class_name, **kwargs):
 
 def parse_custom_class_instances(s):
     pattern = r"(\w+)\((.*?)\)"
-    if type(s) != str:
+    if not isinstance(s, str):
         return s
     matches = re.finditer(pattern, s)
 
@@ -29,79 +29,87 @@ def parse_custom_class_instances(s):
         class_args = match.group(2)
         try:
             parsed_args = ast.literal_eval(f'{{{class_args}}}')
-        except:
+        except (ValueError, SyntaxError):
             parsed_args = create_object_from_string(class_args)
         class_instance = create_dynamic_class(class_name, **parsed_args)
         s = s.replace(match.group(0), repr(class_instance))
 
     return s
 
-# TODO: fix to properly parse nested lists and dicts
-def create_object_from_string(str_class):
-    def updated_attributes_process(str_class):
-        # Regular expression to extract key-value pairs
-        attr_pattern = r"(\w+)=(\[.*?\]|\{.*?\}|'.*?'|None|\w+)"
-        attributes = re.findall(attr_pattern, str_class)
-
-        # Create an instance of the dynamic class with initial attributes
-        updated_attributes = []
-        # remove string up until 'content='
-        content = str_class.split('ChatCompletionMessage(content=')[-1].split(", role=")[0][1:-1]
-        updated_attributes.append(('content', content))
-        for key, value in attributes:
-            if key.startswith("'") and key.endswith("'"):
-                key = key.strip("'")
-            if key.startswith('"') and key.endswith('"'):
-                key = key.strip('"')
-            if value.startswith("'") and value.endswith("'"):
-                value = value.strip("'")
-            if value.startswith('"') and value.endswith('"'):
-                value = value.strip('"')
-
-            if value.startswith('[') and value.endswith(']'):
-                value = parse_value(value)
-                dir(value)
-                if hasattr(value, '__dict__'):
-                    for k in value.__dict__.keys():
-                        v = getattr(value, k)
-                        if type(v) == str:
-                            value[k.strip("'")] = v.strip("'")
-            elif value.startswith('{') and value.endswith('}'):
-                value = parse_value(value)
-                new_value = {}
-                for k in value.keys():
-                    v = value[k]
-                    if type(v) == str:
-                        v = v.strip("'")
-                    new_value[k.strip("'")] = v
-                value = new_value
-            updated_attributes.append((key, value))
-        return updated_attributes
-
-    def parse_value(value):
-        try:
-            value = parse_custom_class_instances(value)
-            if type(value) != str:
-                return value
-            if value.startswith('['):
-                value = value[1:-1]
-                values = value.split(',')
-                return [parse_value(v.strip()) for v in values]
-            elif value.startswith('{'):
-                value = value[1:-1]
-                values = value.split(',')
-                return {k.strip(): parse_value(v.strip()) for k, v in [v.split(':', 1) for v in values]}
-            res = ast.literal_eval(value)
-            if isinstance(res, dict):
-                return {k: parse_value(v) for k, v in res.items()}
-            elif isinstance(res, list) or isinstance(res, tuple) or isinstance(res, set):
-                return [parse_value(v) for v in res]
-            else:
-                return res
-        except:
+
+def _strip_quotes(text):
+    if not isinstance(text, str):
+        return text
+    if text.startswith("'") and text.endswith("'"):
+        return text.strip("'")
+    if text.startswith('"') and text.endswith('"'):
+        return text.strip('"')
+    return text
+
+
+def _extract_content(str_class):
+    return str_class.split('ChatCompletionMessage(content=')[-1].split(", role=")[0][1:-1]
+
+
+def _parse_value(value):
+    try:
+        value = parse_custom_class_instances(value)
+        if not isinstance(value, str):
             return value
+        if value.startswith('['):
+            inner_values = value[1:-1]
+            values = inner_values.split(',')
+            return [_parse_value(v.strip()) for v in values]
+        if value.startswith('{'):
+            inner_values = value[1:-1]
+            values = inner_values.split(',')
+            return {k.strip(): _parse_value(v.strip()) for k, v in [v.split(':', 1) for v in values]}
+        result = ast.literal_eval(value)
+        if isinstance(result, dict):
+            return {k: _parse_value(v) for k, v in result.items()}
+        if isinstance(result, (list, tuple, set)):
+            return [_parse_value(v) for v in result]
+        return result
+    except (ValueError, SyntaxError):
+        return value
+
+
+def _process_list_value(raw_value):
+    parsed_value = _parse_value(raw_value)
+    dir(parsed_value)
+    if hasattr(parsed_value, '__dict__'):
+        for key in parsed_value.__dict__:
+            value = getattr(parsed_value, key)
+            if isinstance(value, str):
+                parsed_value[key.strip("'")] = value.strip("'")
+    return parsed_value
+
+
+def _process_dict_value(raw_value):
+    parsed_value = _parse_value(raw_value)
+    new_value = {}
+    for key, value in parsed_value.items():
+        stripped_value = value.strip("'") if isinstance(value, str) else value
+        new_value[key.strip("'")] = stripped_value
+    return new_value
+
+
+def _collect_attributes(str_class):
+    attr_pattern = r"(\w+)=(\[.*?\]|\{.*?\}|'.*?'|None|\w+)"
+    attributes = re.findall(attr_pattern, str_class)
+    updated_attributes = [('content', _extract_content(str_class))]
+    for key, raw_value in attributes:
+        attr_key = _strip_quotes(key)
+        attr_value = _strip_quotes(raw_value)
+        if attr_value.startswith('[') and attr_value.endswith(']'):
+            attr_value = _process_list_value(attr_value)
+        elif attr_value.startswith('{') and attr_value.endswith('}'):
+            attr_value = _process_dict_value(attr_value)
+        updated_attributes.append((attr_key, attr_value))
+    return updated_attributes
 
-    updated_attributes = updated_attributes_process(str_class)
-    obj = DynamicClass(**{key: parse_value(value) for key, value in updated_attributes})
 
-    return obj
+# TODO: fix to properly parse nested lists and dicts
+def create_object_from_string(str_class):
+    updated_attributes = _collect_attributes(str_class)
+    return DynamicClass(**{key: _parse_value(value) for key, value in updated_attributes})