holado 0.6.5__tar.gz → 0.7.1__tar.gz

{holado-0.6.5 → holado-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.6.5
+Version: 0.7.1
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.7.1/packaging/VERSION

@@ -0,0 +1 @@
+0.7.1

{holado-0.6.5 → holado-0.7.1}/src/holado/holado_config.py

@@ -1,3 +1,4 @@
+import logging
 
 #################################################
 # HolAdo (Holistic Automation do)
@@ -39,4 +40,8 @@ class Config(object):
     UNIQUE_SYMBOL = u"#"
     NOT_APPLICABLE_SYMBOL = u"N/A"
     NONE_SYMBOL = u"None"
+    
+    # Default log levels
+    log_level_grpc_request = logging.INFO
+    log_level_rest_request = logging.INFO
 

{holado-0.6.5 → holado-0.7.1}/src/holado_core/common/tables/converters/table_converter.py

@@ -113,21 +113,22 @@ class TableConverter(object):
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Converting Name/Value table to dict (table = {table})")
 
-        # Verify table structure
-        TableManager.verify_table_is_name_value_table(table)
-        
         res = {}
-        for row in table.rows:
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace("Converting row (%s)", row)
+        if table is not None:
+            # Verify table structure
+            TableManager.verify_table_is_name_value_table(table)
             
-            name = row.get_cell(0).content
-            value = row.get_cell(1).content
-            
-            if name in res:
-                raise FunctionalException("Name '{}' appears several times in table".format(name))
-            else:
-                res[name] = value
+            for row in table.rows:
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace("Converting row (%s)", row)
+                
+                name = row.get_cell(0).content
+                value = row.get_cell(1).content
+                
+                if name in res:
+                    raise FunctionalException("Name '{}' appears several times in table".format(name))
+                else:
+                    res[name] = value
                 
         if Tools.do_log(logger, logging.DEBUG):
             logger.debug(f"Converting Name/Value table to dict (table = {table}) => {res}")

{holado-0.6.5 → holado-0.7.1}/src/holado_core/common/tools/tools.py

@@ -78,11 +78,11 @@ class Tools(object):
         return Tools.indent_string(indent, "".join(list_format))
     
     @classmethod
-    def represent_object(cls, obj, indent=0, *, do_indent_first_line=True, full_details=False, access_type=AccessType.Public):
-        return cls.__represent_object(obj, indent, do_indent_first_line, full_details, access_type, [])
+    def represent_object(cls, obj, indent=0, *, do_indent_first_line=True, full_details=False, access_type=AccessType.Public, max_level=3):
+        return cls.__represent_object(obj, indent, do_indent_first_line, full_details, access_type, max_level, [])
     
     @classmethod
-    def __represent_object(cls, obj, indent, do_indent_first_line, full_details, access_type, _internal):
+    def __represent_object(cls, obj, indent, do_indent_first_line, full_details, access_type, max_level, _internal):
         from holado_core.common.tools.converters.converter import Converter
         
         if Converter.is_primitive(obj) and not Converter.is_dict(obj) and not Converter.is_list(obj):
@@ -102,7 +102,7 @@ class Tools(object):
                     keys = list(obj.keys())
                     for key in keys:
                         # logger.print(f"+++++ Tools.__represent_object:     key: {key}")
-                        val_str = cls.__represent_object(obj[key], 0, True, full_details, access_type, _internal)
+                        val_str = cls.__represent_object(obj[key], 0, True, full_details, access_type, max_level-1, _internal)
                         if '\n' in val_str:
                             res_list.append(f"    {key}:")
                             res_list.append(Tools.indent_string(4, val_str))
@@ -116,7 +116,7 @@ class Tools(object):
                     for el in obj:
                     # for index, el in enumerate(obj):
                     #     logger.print(f"+++++ Tools.__represent_object:     index: {index}")
-                        el_str = cls.__represent_object(el, 0, True, full_details, access_type, _internal)
+                        el_str = cls.__represent_object(el, 0, True, full_details, access_type, max_level-1, _internal)
                         if '\n' in el_str:
                             res_list.append("    {")
                             res_list.append(Tools.indent_string(4, el_str))
@@ -133,9 +133,10 @@ class Tools(object):
                     # logger.print(f"+++++ Tools.__represent_object: {str(type(obj))} is object with {attributes=}")
                     if attributes:
                         res_list = [f"{str(type(obj))}({id_obj})"] if full_details else [f"{str(type(obj))}"]
-                        for name, value in attributes:
-                            # logger.print(f"+++++ Tools.__represent_object:     attribute '{name}'")
-                            res_list.append(f"    {name}: {cls.__represent_object(value, 4, False, full_details, access_type, _internal)}")
+                        if max_level > 0:
+                            for name, value in attributes:
+                                # logger.print(f"+++++ Tools.__represent_object:     attribute '{name}'")
+                                res_list.append(f"    {name}: {cls.__represent_object(value, 4, False, full_details, access_type, max_level-1, _internal)}")
                         res = "\n".join(res_list)
                     else:
                         res = f"{obj} [{str(type(obj))}({id_obj})]" if full_details else f"{obj}"

{holado-0.6.5 → holado-0.7.1}/src/holado_db/tools/db/clients/base/db_client.py

@@ -23,15 +23,17 @@ from holado_core.common.tables.table import Table
 from holado_db.tools.db.query.base.query_builder import QueryBuilder
 from holado_data.data.generator.base import BaseGenerator
 from holado_python.standard_library.typing import Typing
+from holado.common.handlers.object import Object
 
 logger = logging.getLogger(__name__)
 
 
-class DBClient(object):
+class DBClient(Object):
     __metaclass__ = abc.ABCMeta
 
     def __init__(self, name, connect_kwargs, with_cursor=True, auto_commit=True):
-        self.__name = name
+        super().__init__(name)
+        
         self.__connect_kwargs = connect_kwargs
         self.__with_cursor = with_cursor
         self.__auto_commit = auto_commit
@@ -41,10 +43,6 @@ class DBClient(object):
         self.__audit_manager = None
         self.__column_names_by_table = {}
     
-    @property
-    def name(self):
-        return self.__name
-    
     @property
     def query_builder(self) -> QueryBuilder:
         return self.__query_builder

{holado-0.6.5 → holado-0.7.1}/src/holado_db/tools/db/clients/sqlite/sqlite_client.py

@@ -48,7 +48,7 @@ class SQLite3Client(DBClient):
             database = connect_kwargs.pop("database")
             return sqlite3.connect(database, **connect_kwargs)
         except Exception as exc:
-            raise FunctionalException(f"Failed to connect with kwargs={kwargs}.\nUsage:\n{Tools.indent_string(4, sqlite3.connect.__doc__)}") from exc
+            raise FunctionalException(f"Failed to connect with kwargs={kwargs}.\nUsage:\n{Tools.indent_string(4, sqlite3.connect.__doc__)}") from exc  # @UndefinedVariable
         
     def _get_sql_placeholder(self):
         return "?"

{holado-0.6.5 → holado-0.7.1}/src/holado_grpc/api/rpc/grpc_client.py

@@ -18,6 +18,8 @@ from holado_value.common.tables.converters.value_table_converter import ValueTab
 from holado_core.common.tools.tools import Tools
 import time
 from holado.holado_config import Config
+from holado.common.handlers.object import Object
+from holado.common.handlers.undefined import undefined_argument, undefined_value
 
 logger = logging.getLogger(__name__)
 
@@ -36,7 +38,7 @@ except Exception as exc:
 # os.environ["GRPC_TRACE"] = "all"
 
 
-class GRpcClient(object):
+class GRpcClient(Object):
     """
     gRPC client
     
@@ -49,7 +51,7 @@ class GRpcClient(object):
     
     if with_grpc_requests:
         def __init__(self, name, endpoint, **kwargs):
-            self.__name = name
+            super().__init__(name)
             self.__endpoint = endpoint
             self.__kwargs = kwargs
             self.__client = grpc_requests.client.get_by_endpoint(endpoint, **kwargs)
@@ -57,6 +59,8 @@ class GRpcClient(object):
             self.__func_grpc_services = None
             self.__func_protobuf_converter = None
             self.__func_protobuf_messages = None
+            
+            self.__request_log_level = Config.log_level_grpc_request
         
         def initialize(self, func_grpc_services, func_protobuf_converter, func_protobuf_messages):
             self.__func_grpc_services = func_grpc_services
@@ -75,22 +79,28 @@ class GRpcClient(object):
         def __protobuf_messages(self):
             return self.__func_protobuf_messages()
         
-        @property
-        def name(self):
-            return self.__name
-        
         @property    
         def internal_client(self) -> grpc_requests.client.Client:
             return self.__client
         
-        def request(self, service, method, request, raw_output=False, **kwargs):
+        @property
+        def request_log_level(self):
+            return self.__request_log_level
+        
+        @request_log_level.setter
+        def request_log_level(self, log_level):
+            self.__request_log_level = log_level
+        
+        def request(self, service, method, request, raw_output=False, result_on_statuses=undefined_argument, **kwargs):
             """
             :param request: request data in json or proto format
             :param raw_output: if method should return a proto object or a json oject (default: False)
             :param kwargs: other arguments for underlying grpc_requests method, or further underlying grpc method (ex: 'timeout')
             :returns: if raw_output==True, returns a proto object, else returns a json object with proto data
             """
-            logger.info(f"Requesting {service}.{method} with data [{request}] (raw_output: {raw_output} ; kwargs:{kwargs})")
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Requesting {service}.{method} with data [{request}] (raw_output: {raw_output} ; kwargs:{kwargs})")
+            res = undefined_value
             
             # Set a default timeout
             raise_on_timeout = False
@@ -110,6 +120,17 @@ class GRpcClient(object):
                 except Exception as exc:
                     last_exc = exc
                     exc_str = str(exc)
+                    
+                    # Manage result on statuses
+                    if result_on_statuses is not undefined_argument:
+                        for status, status_result in result_on_statuses.items():
+                            if f"status = StatusCode.{status.name}" in exc_str:
+                                res = status_result
+                                break
+                        if res is not undefined_value:
+                            success = True
+                            break
+                    
                     msg_list = [
                         f"Request failed (try {try_nb}):",
                         f"    method: {service}.{method}",
@@ -139,6 +160,7 @@ class GRpcClient(object):
                     success = True
                     break
             
+            # If still in error after all tries, raise an exception with last exception message
             if not success:
                 if "status = " in exc_msg:
                     raise FunctionalException(exc_msg) from last_exc
@@ -149,17 +171,20 @@ class GRpcClient(object):
             # Note: this step is done manually since grpc_requests has some limitations when raw_output=False:
             #     - Field with default values are not set in json result
             #     - Some field types are badly managed (ex: uint64 fields appear as string in json)
-            if raw_output == True:
-                if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
-                    return list(res_proto)
-                else:
-                    return res_proto
-            else:
-                if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
-                    res = [self.__protobuf_converter.convert_protobuf_object_to_json_object(cur_res) for cur_res in res_proto]
+            if res is undefined_value:
+                if raw_output == True:
+                    if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
+                        res = list(res_proto)
+                    else:
+                        res = res_proto
                 else:
-                    res = self.__protobuf_converter.convert_protobuf_object_to_json_object(res_proto)
-                return res
+                    if isinstance(res_proto, grpc._channel._MultiThreadedRendezvous):
+                        res = [self.__protobuf_converter.convert_protobuf_object_to_json_object(cur_res) for cur_res in res_proto]
+                    else:
+                        res = self.__protobuf_converter.convert_protobuf_object_to_json_object(res_proto)
+            if Tools.do_log(logger, self.request_log_level):
+                logger.log(self.request_log_level, f"Request {service}.{method} with data [{request}] (raw_output: {raw_output} ; kwargs:{kwargs})  => {res}")
+            return res
                 
         def get_request_data_type_fullname(self, service, method):
             method_descriptor = self.__grpc_services.get_method_descriptor(service, method)

{holado-0.6.5 → holado-0.7.1}/src/holado_json/ipc/json.py

@@ -29,7 +29,7 @@ def create_name_value_table_from_json(json_value, recursive=False, uncollapse_li
     converter = JsonConverter()
     json_value = converter.to_json(json_value)
     
-    name_values = __convert_json_value_2_name_values(json_value, recursive=recursive, uncollapse_list=uncollapse_list)
+    name_values = convert_json_value_2_name_values(json_value, recursive=recursive, uncollapse_list=uncollapse_list)
     for name, value in name_values:
         res.add_row(cells_content=(name, value))
     
@@ -51,7 +51,7 @@ def create_table_with_header_from_json(json_value, recursive=False, uncollapse_l
     for json_val in json_list:
         json_val = converter.to_json(json_val)
         
-        name_values = __convert_json_value_2_name_values(json_val, recursive=recursive, uncollapse_list=uncollapse_list)
+        name_values = convert_json_value_2_name_values(json_val, recursive=recursive, uncollapse_list=uncollapse_list)
         
         # Add new columns if needed
         for name, value in name_values:
@@ -68,9 +68,17 @@ def create_table_with_header_from_json(json_value, recursive=False, uncollapse_l
         
     return res
     
-def __convert_json_value_2_name_values(json_value, recursive=False, uncollapse_list=False):
+def convert_json_value_2_name_values(json_value, recursive=False, uncollapse_list=False, as_dict=False, sorted_=False):
+    """Convert json object as a list of (name, value).
+    If as_dict is True, the result is a dict of {name:value}
+    """
     res = []
     __fill_name_values_with_json_value(res, None, json_value, recursive=recursive, uncollapse_list=uncollapse_list)
+    
+    if sorted_:
+        res = sorted(res)
+    if as_dict:
+        res = {e[0]:e[1] for e in res}
     return res
     
 def __fill_name_values_with_json_value(res, name_prefix, json_value, recursive=False, uncollapse_list=False):
@@ -123,3 +131,16 @@ def set_object_attributes_with_json_dict(obj, json_value):
         else:
             raise FunctionalException(f"Object doesn't have attribute '{attr_name}' (object type: {Typing.get_object_class_fullname(obj)})")
 
+
+def update_json_object_with_missing_attributes(json_obj, json_ref, recursive=False):
+    if not isinstance(json_obj, dict):
+        raise TechnicalException(f"json object is expected to be a dict (obtained: {Typing.get_object_class_fullname(json_obj)}")
+    if not isinstance(json_ref, dict):
+        raise TechnicalException(f"json reference is expected to be a dict (obtained: {Typing.get_object_class_fullname(json_ref)}")
+
+    for key, value in json_ref.items():
+        if key not in json_obj:
+            json_obj[key] = value
+        elif recursive and isinstance(json_obj[key], dict) and isinstance(value, dict):
+            update_json_object_with_missing_attributes(json_obj[key], value, recursive=recursive)
+    

{holado-0.6.5 → holado-0.7.1}/src/holado_rest/api/rest/rest_client.py

@@ -18,6 +18,8 @@ from holado_core.common.tools.tools import Tools
 import json
 from holado_core.common.tools.converters.converter import Converter
 from holado_json.ipc.json_converter import JsonConverter
+from holado.common.handlers.object import Object
+from holado.holado_config import Config
 
 logger = logging.getLogger(__name__)
 
@@ -31,7 +33,7 @@ except Exception as exc:
     with_requests = False
 
 
-class RestClient(object):
+class RestClient(Object):
     """
     REST client
     """
@@ -41,14 +43,20 @@ class RestClient(object):
         return with_requests
     
     def __init__(self, name, url, headers=None):
-        self.__name = name
+        super().__init__(name)
         self.__url = url.rstrip('/')
         self.__headers = headers if headers is not None else {}
         self.__kwargs = {}
-    
+            
+        self.__request_log_level = Config.log_level_rest_request
+        
     @property
-    def name(self):
-        return self.__name
+    def request_log_level(self):
+        return self.__request_log_level
+    
+    @request_log_level.setter
+    def request_log_level(self, log_level):
+        self.__request_log_level = log_level
     
     def authenticate_by_user(self, user, pwd):
         if Tools.do_log(logger, logging.DEBUG):
@@ -66,7 +74,14 @@ class RestClient(object):
             raise TechnicalException(f"Unmanaged SSL arguments: {unexpected_keys}")
         
         self.__kwargs.update(ssl_kwargs)
-        
+    
+    def add_parameters_to_path(self, path, parameters:dict):
+        res = path
+        if parameters:
+            res += "&" if '?' in res else "?"
+            res += "&".join([f"{k}={v}" for k,v in parameters.items()])
+        return res
+    
     def response_result(self, response, status_ok=200):
         # Get result
         if response.status_code == 204:
@@ -87,7 +102,8 @@ class RestClient(object):
         
         return res
     
-    def request(self, method, path, **kwargs):
+    def request(self, method, path, path_parameters=None, **kwargs):
+        path = self.add_parameters_to_path(path, path_parameters)
         url = self.__build_url(path=path)
         r_kwargs = self.__build_kwargs(**kwargs)
         
@@ -98,27 +114,27 @@ class RestClient(object):
         except Exception as exc:
             raise TechnicalException(f"[{self.name}] Failed to process {method} '{url}' with arguments {r_kwargs}") from exc
         
-        if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"[{self.name}] {method} on url '{url}' => {res}")
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"[{self.name}] {method} on url '{url}' => {Tools.represent_object(res, 4)}")
+        elif Tools.do_log(logger, self.request_log_level):
+            logger.log(self.request_log_level, f"[{self.name}] {method} on url '{url}' => {Tools.represent_object(res, 4, max_level=1)}")
         return res
         
-    def delete(self, path, data=None, **kwargs):
-        return self.request("DELETE", path, data=data, **kwargs)
+    def delete(self, path, data=None, path_parameters=None, **kwargs):
+        return self.request("DELETE", path, path_parameters=path_parameters, data=data, **kwargs)
         
-    def get(self, path, data=None, **kwargs):
-        return self.request("GET", path, data=data, **kwargs)
+    def get(self, path, data=None, path_parameters=None, **kwargs):
+        return self.request("GET", path, path_parameters=path_parameters, data=data, **kwargs)
         
-    def patch(self, path, data=None, **kwargs):
-        return self.request("PATCH", path, data=data, **kwargs)
+    def patch(self, path, data=None, path_parameters=None, **kwargs):
+        return self.request("PATCH", path, path_parameters=path_parameters, data=data, **kwargs)
         
-    def post(self, path, data=None, json=None, **kwargs):
-        return self.request("POST", path, data=data, json=json, **kwargs)
-        
-    def put(self, path, data=None, **kwargs):
-        return self.request("PUT", path, data=data, **kwargs)
+    def post(self, path, data=None, json=None, path_parameters=None, **kwargs):
+        return self.request("POST", path, path_parameters=path_parameters, data=data, json=json, **kwargs)
         
+    def put(self, path, data=None, path_parameters=None, **kwargs):
+        return self.request("PUT", path, path_parameters=path_parameters, data=data, **kwargs)
+    
     def __build_url(self, path):
         return f"{self.__url}/{path.lstrip('/')}" 
         

{holado-0.6.5 → holado-0.7.1}/src/holado_rest/api/rest/rest_manager.py

@@ -32,9 +32,9 @@ class RestManager(object):
         self.__default_client_class = default_client_class
     
     def new_client(self, name, **kwargs):
-        if name is None:
-            name = f"RestClient({kwargs})"
         url = kwargs.pop("url")
+        if name is None:
+            name = f"RestClient({url})"
         headers = Tools.pop_sub_kwargs(kwargs, "headers.")
         authentication = Tools.pop_sub_kwargs(kwargs, "authentication.")
         ssl_kwargs = Tools.pop_sub_kwargs(kwargs, "ssl.")

{holado-0.6.5 → holado-0.7.1}/src/holado_test/scenario/step_tools.py

@@ -241,7 +241,7 @@ class StepTools(object):
                     if ValueTableManager.is_value_table(value):
                         res = value
                     elif isinstance(value, TableWithHeader):
-                        res = ValueTableConverter.convert_table_with_header_2_value_table_with_header(value, do_eval_once=do_eval_once)
+                        res = ValueTableConverter.convert_table_2_value_table(value, do_eval_once=do_eval_once)
                     elif isinstance(value, Table):
                         raise FunctionalException(f"The table in variable '{cell_content}' is expected to be with header")
         elif isinstance(table, Table):        

{holado-0.6.5 → holado-0.7.1}/src/holado_value/common/tables/converters/value_table_converter.py

@@ -48,6 +48,8 @@ class ValueTableConverter(TableConverter):
     
     @classmethod
     def convert_value_table_2_table(cls, table):
+        ValueTableManager.verify_is_value_table(table)
+        
         if isinstance(table, ValueTableWithHeader):
             res = TableWithHeader()
             res.header = copy.copy(table.header)
@@ -58,15 +60,6 @@ class ValueTableConverter(TableConverter):
             res.add_row(cells_content=cells_content)
         return res
     
-    @classmethod
-    def convert_table_with_header_2_value_table_with_header(cls, table, do_eval_once=True):
-        res = ValueTableWithHeader()
-        res.header = TableRow(cells_content=table.header.cells_content)
-        for row in table:
-            cells_content = [f"'{cc}'" if isinstance(cc, str) else f"{cc}" for cc in row.cells_content]
-            res.add_row(cells_content=cells_content, do_eval_once=do_eval_once)
-        return res
-        
     @classmethod
     def convert_table_with_header_to_dict_list(cls, table, as_generator=False):
         if not ValueTableManager.is_value_table(table):
@@ -123,36 +116,43 @@ class ValueTableConverter(TableConverter):
     
     @classmethod
     def convert_name_value_table_2_dict(cls, table, with_original_value_content = False):
+        if not ValueTableManager.is_value_table(table):
+            return TableConverter.convert_name_value_table_2_dict(table)
+        
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Converting Name/Value table to dict (table = {table})")
-
-        # Verify table structure
-        ValueTableManager.verify_table_is_name_value_table(table)
-        ValueTableManager.verify_is_value_table(table)
         
         res = {}
-        for row in table.rows:
-            if row.get_cell(1).value_type not in [ValueTypes.NotApplicable]:
-                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                    logger.trace("Converting row (%s)", row)
-                
-                name = row.get_cell(0).value
-                if with_original_value_content:
-                    value = row.get_cell(1).content
-                else:
-                    value = row.get_cell(1).value
-                
-                if name in res:
-                    raise FunctionalException("Name '{}' appears several times in table".format(name))
-                else:
-                    res[name] = value
-                
+        if table is not None:
+            # Verify table structure
+            ValueTableManager.verify_table_is_name_value_table(table)
+            ValueTableManager.verify_is_value_table(table)
+            
+            for row in table.rows:
+                if row.get_cell(1).value_type not in [ValueTypes.NotApplicable]:
+                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                        logger.trace("Converting row (%s)", row)
+                    
+                    name = row.get_cell(0).value
+                    if with_original_value_content:
+                        value = row.get_cell(1).content
+                    else:
+                        value = row.get_cell(1).value
+                    
+                    if name in res:
+                        raise FunctionalException("Name '{}' appears several times in table".format(name))
+                    else:
+                        res[name] = value
+        
         if Tools.do_log(logger, logging.DEBUG):
             logger.debug(f"Converting Name/Value table to dict (table = {table}) => {res}")
         return res
         
     @classmethod
     def convert_name_value_table_2_list_and_dict(cls, table, with_original_value_content = False):
+        # if not ValueTableManager.is_value_table(table):
+        #     return TableConverter.convert_name_value_table_2_list_and_dict(table)
+        
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Converting Name/Value table to list and dict (table = {table})")
 
@@ -186,6 +186,9 @@ class ValueTableConverter(TableConverter):
  
     @classmethod
     def convert_name_value_table_2_json_object(cls, table, converter=None):
+        if not ValueTableManager.is_value_table(table):
+            return TableConverter.convert_name_value_table_2_json_object(table, converter=converter)
+        
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Converting Name/Value table to json object (table = {table})")
         if converter is None:
@@ -226,6 +229,9 @@ class ValueTableConverter(TableConverter):
 
     @classmethod
     def convert_x_name_value_table_2_list_x_values(cls, table, x_name, with_original_value_content = False):
+        # if not ValueTableManager.is_value_table(table):
+        #     return TableConverter.convert_x_name_value_table_2_list_x_values(table, x_name)
+        
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Converting {x_name}/Name/Value table to list of {x_name} and values dict (table = {table})")
 

holado-0.6.5/packaging/VERSION

@@ -1 +0,0 @@
-0.6.5