Odooly 2.6.2__tar.gz → 2.6.3__tar.gz

{odooly-2.6.2 → odooly-2.6.3}/CHANGES.rst

@@ -2,6 +2,12 @@ Changelog
 ---------
 
 
+2.6.3 (2026-03-18)
+~~~~~~~~~~~~~~~~~~
+
+* Improve output coloring.  Do not color Python keywords and built-ins.
+
+
 2.6.2 (2026-03-17)
 ~~~~~~~~~~~~~~~~~~
 

{odooly-2.6.2 → odooly-2.6.3/Odooly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Odooly
-Version: 2.6.2
+Version: 2.6.3
 Summary: Versatile tool for Odoo
 Home-page: http://odooly.readthedocs.org/
 Author: Florent Xicluna

{odooly-2.6.2/Odooly.egg-info → odooly-2.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Odooly
-Version: 2.6.2
+Version: 2.6.3
 Summary: Versatile tool for Odoo
 Home-page: http://odooly.readthedocs.org/
 Author: Florent Xicluna

{odooly-2.6.2 → odooly-2.6.3}/odooly.py

@@ -28,7 +28,7 @@ try:
 except ImportError:
     requests = None
 
-__version__ = '2.6.2'
+__version__ = '2.6.3'
 __all__ = ['Client', 'Env', 'HTTPSession', 'WebAPI', 'Service', 'Json2',
            'Printer', 'Error', 'ServerError',
            'BaseModel', 'Model', 'BaseRecord', 'Record', 'RecordList',
@@ -132,7 +132,7 @@ for query in sql_queries:
 log(str({'queries': sql_queries, 'result': result}))
 result[:] = []
 """
-colorize = color_bold = color_comment = str
+color_bold = color_comment = color_py = color_repr = str
 http_context = None
 
 if os.getenv('ODOOLY_SSL_UNVERIFIED'):
@@ -225,12 +225,12 @@ def _memoize(inst, attr, value, doc_values=None):
 
 # Simplified ast.literal_eval which does not parse operators
 def _convert(node):
-    if isinstance(node, _ast.Constant):
+    if isinstance(node, _ast.Constant) and node.value.__class__ is not complex:
         return node.value
     if isinstance(node, _ast.Tuple):
         return tuple(map(_convert, node.elts))
     if isinstance(node, _ast.List):
-        return list(map(_convert, node.elts))
+        return [*map(_convert, node.elts)]
     if isinstance(node, _ast.Dict):
         return {_convert(k): _convert(v)
                 for (k, v) in zip(node.keys, node.values)}
@@ -242,10 +242,8 @@ def _convert(node):
     raise ValueError('malformed or disallowed expression')
 
 
-def literal_eval(expression, _octal_digits=frozenset('01234567')):
+def literal_eval(expression):
     node = compile(expression, '<unknown>', 'eval', _ast.PyCF_ONLY_AST)
-    if expression[:1] == '0' and expression[1:2] in _octal_digits:
-        raise SyntaxError('unsupported octal notation')
     return _convert(node.body)
 
 
@@ -419,7 +417,7 @@ class Printer:
         xch = message[:self.cols - len(suffix)] + suffix
         print(color_comment(f"{_prefix} {xch}"))
 
-    print_sent = functools.partialmethod(_print_, _prefix='-->')
+    print_sent = functools.partialmethod(_print_, _prefix='  >')
     print_recv = functools.partialmethod(_print_, _prefix='<--')
 
     def __bool__(self):
@@ -452,7 +450,7 @@ class WebAPI:
         self._dispatch = client._proxy_web(endpoint)
         self._server = urljoin(client._server, '/')
         self._endpoint = f'/{endpoint}'
-        self._methods = methods
+        self._methods = [*methods]
         self._printer = client._printer
 
     def __repr__(self):
@@ -802,7 +800,7 @@ class Env:
 
     def refresh(self):
         db_key, preserve = (self.db_name, self.client._server), ('auth', Env)
-        for key in list(self._cache):
+        for key in [*self._cache]:
             if key[1:] == db_key and key[0] not in preserve and self._cache[key] != self:
                 del self._cache[key]
         self._access_models = None
@@ -884,7 +882,7 @@ class Env:
                 method, [ids] = 'search_read', searchargs(params[:1])
             else:
                 order_ids = kwargs.pop('order', False) and params[0]
-                ids = sorted(set(params[0]) - {False})
+                ids = sorted({*params[0]} - {False})
                 if not ids and order_ids:
                     return [False] * len(order_ids)
             if not ids:
@@ -1091,7 +1089,7 @@ class Env:
         if not self.db_name and (not self.uid or login == self.user.login) and self.session_info.get('db'):
             empty_db_key = (self.db_name, self.client._server)
             self.db_name = self.session_info['db']
-            for key in list(self._cache):
+            for key in [*self._cache]:
                 if key[1:] == empty_db_key:
                     self._cache_set(key[0], self._cache[key])
         print(f'Session authenticated for {login!r}' if self.session_info['uid'] else 'Failed')
@@ -1306,7 +1304,7 @@ class Client:
             try:
                 cls._saved_config[environment] = read_config(environment)
             except Exception:
-                envs = list(cls._saved_config)
+                envs = [*cls._saved_config]
                 if cls._config_file.exists():
                     envs += [env for env in read_config() if env not in cls._saved_config]
                 raise Error("No such environment.\nAvailable: " + ", ".join(envs))
@@ -1480,7 +1478,7 @@ class Client:
 
     @classmethod
     def _set_interactive(cls, global_vars={}):
-        global colorize, color_bold, color_comment
+        global color_bold, color_comment, color_py, color_repr
         # Don't call multiple times
         del Client._set_interactive
         assert not cls._is_interactive()
@@ -1488,11 +1486,11 @@ class Client:
             global_vars[name] = globals()[name]
         try:  # Python >= 3.14
             from _pyrepl.utils import disp_str, gen_colors, _colorize
-            colorize = lambda v: "".join(disp_str(v, colors=[*gen_colors(v)])[0])
-            colorize.__name__ = colorize.__qualname__ = 'colorize'
-            color_bold = colorize('def _').split()[1].replace('_', '{}').format
-            color_comment = colorize('#').replace('#', '{}').format
-            global_vars |= {'colorize': colorize, 'decolor': _colorize.decolor}
+            color_py = color_repr = lambda v: "".join(disp_str(v, colors=[*gen_colors(v)])[0])
+            color_py.__name__ = color_py.__qualname__ = 'color_python'
+            color_bold = color_py('def _').split()[1].replace('_', '{}').format
+            color_comment = color_py('#').replace('#', '{}').format
+            global_vars |= {'color_py': color_py, 'decolor': _colorize.decolor}
         except ImportError:
             pass
         cls._globals = global_vars
@@ -1512,7 +1510,6 @@ class Client:
         and no country is set into the database.
         Login if successful.
         """
-        extra = (login, country_code) if login != ADMIN_USER or country_code else ()
         self.database.create(master_pwd=passwd, name=database, lang=lang,
                              password=user_password, demo=demo, login=login,
                              country_code=country_code, phone='')
@@ -1524,10 +1521,9 @@ class Client:
         The superadmin `passwd` and `database` are mandatory.
         Login if successful.
         """
-        extra = (neutralize_database,) if neutralize_database else ()
+        extra = {"neutralize_database": neutralize_database} if neutralize_database else {}
         if extra and self.version_info < 16.0:
             raise Error("Argument 'neutralize_database' is not supported")
-        extra = {"neutralize_database": extra[0]} if extra else {}
         self.database.duplicate(master_pwd=passwd, name=self.env.db_name,
                                 new_name=database, **extra)
         # Copy the cache for authentication
@@ -1634,7 +1630,7 @@ class Model(BaseModel):
         methods = doc_dict.get('methods') or {}
         result = []
         for key, vals in methods.items():
-            arg_names = list(vals['parameters'])
+            arg_names = [*vals['parameters']]
             if 'model' not in vals.get('api', ()):
                 arg_names.insert(0, 'ids')
             result.append((key, arg_names))
@@ -1913,14 +1909,14 @@ class BaseRecord(BaseModel):
 
     def __sub__(self, other):
         self._check_model(other, '-')
-        other_ids = set(other.ids)
+        other_ids = {*other.ids}
         ids = [idn for (id_, idn) in zip(self.ids, self._idnames)
                if id_ not in other_ids]
         return RecordList(self._model, ids)
 
     def __and__(self, other):
         self._check_model(other, '&')
-        other_ids = set(other.ids)
+        other_ids = {*other.ids}
         self_set = self.union()
         ids = [idn for (id_, idn) in zip(self_set.ids, self_set._idnames)
                if id_ in other_ids]
@@ -1938,19 +1934,19 @@ class BaseRecord(BaseModel):
 
     def __lt__(self, other):
         self._check_model(other, '<')
-        return set(self.ids) < set(other.ids)
+        return {*self.ids} < {*other.ids}
 
     def __le__(self, other):
         self._check_model(other, '<=')
-        return set(self.ids).issubset(other.ids)
+        return {*self.ids}.issubset(other.ids)
 
     def __gt__(self, other):
         self._check_model(other, '>')
-        return set(self.ids) > set(other.ids)
+        return {*self.ids} > {*other.ids}
 
     def __ge__(self, other):
         self._check_model(other, '>=')
-        return set(self.ids).issuperset(other.ids)
+        return {*self.ids}.issuperset(other.ids)
 
     def __int__(self):
         return int(self.ensure_one().id)
@@ -2008,7 +2004,7 @@ class BaseRecord(BaseModel):
             raise TypeError(f"Mixing apples and oranges: {self} {oper} {other}")
 
     def _concat_ids(self, args):
-        ids = list(self._idnames)
+        ids = [*self._idnames]
         for other in args:
             self._check_model(other, '+')
             ids.extend(other._idnames)
@@ -2026,7 +2022,7 @@ class BaseRecord(BaseModel):
         """
         ids = self._concat_ids(args)
         if len(ids) > 1:
-            seen = set()
+            seen = {*()}
             uniqids = []
             for idn in ids:
                 id_, name = idn if isinstance(idn, (list, tuple)) else (idn, None)
@@ -2269,7 +2265,7 @@ class Record(BaseRecord):
         else:
             idnames = [(arg, name)] = [arg]
         Ids, Id1 = self.env._class_ids
-        attrs = {'id': Id1(arg), 'ids': Ids([arg]), '_idnames': idnames, '_cached_keys': set()}
+        attrs = {'id': Id1(arg), 'ids': Ids([arg]), '_idnames': idnames, '_cached_keys': {*()}}
         if name is not None:
             attrs['_Record__name'] = attrs['display_name'] = name
         self.__dict__.update(attrs)
@@ -2335,7 +2331,7 @@ class Record(BaseRecord):
         exist, only one of them is returned (randomly).
         """
         xml_ids = self._model._get_external_ids(self.ids)
-        return list(xml_ids)[0] if xml_ids else False
+        return [*xml_ids][0] if xml_ids else False
 
     def _set_external_id(self, xml_id):
         """Set the External ID of this record."""
@@ -2407,7 +2403,7 @@ def _interact(global_vars, use_pprint=True, usage=USAGE):
         pass  # IOError if file missing, or other error
 
     if use_pprint:
-        pp = lambda obj: print(colorize(pprint.pformat(obj, **PP_FORMAT)))
+        pp = lambda obj: print(color_repr(pprint.pformat(obj, **PP_FORMAT)))
 
         def displayhook(value, _printer=pp, _builtins=builtins):
             # Pretty-format the output
@@ -2419,7 +2415,7 @@ def _interact(global_vars, use_pprint=True, usage=USAGE):
     def excepthook(exc_type, exc, tb):
         # Print readable errors
         msg = ''.join(format_exception(exc_type, exc, tb, chain=False, **exfmt))
-        print(colorize(msg.rstrip()))
+        print(color_repr(msg.rstrip()))
     sys.excepthook = excepthook
 
     builtins.usage = type('Usage', (), {'__call__': lambda s: print(usage),
@@ -2484,7 +2480,7 @@ def main(interact=_interact):
         return
 
     global_vars = Client._set_interactive()
-    print(colorize(USAGE))
+    print(color_repr(USAGE))
 
     connect_client(args)
     return interact(global_vars) if interact else global_vars

odooly-2.6.3/odooly_run.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+"""Connect to an Odoo server."""
+# Colorize command-line output
+import builtins
+import keyword
+import io
+import os
+import re
+import token as T
+import tokenize
+import unicodedata
+
+import odooly
+
+BUILTINS = {name for name in dir(builtins) if name[:1] != '_'}
+T_STRING = {getattr(T, tk) for tk in dir(T) if 'STRING' in tk}
+T_MIDDLE = {getattr(T, tk) for tk in dir(T) if 'STRING_MIDDLE' in tk}
+KEYWORDS = {*keyword.kwlist}
+SOFTKEYW = {*getattr(keyword, 'softkwlist', ())}
+J_SPECIAL = {'false', 'null', 'true'}
+CONSTANTS = {'False', 'None', 'True'}
+DEF_CLASS = {'def', 'class'}
+
+
+class THEME:  # Default theme
+    keyword = '\x1b[1;34m'
+    builtin = '\x1b[36m'
+    comment = '\x1b[31m'
+    string = '\x1b[32m'
+    number = '\x1b[33m'
+    op = '\x1b[0m'  # No color
+    definition = '\x1b[1m'
+    reset = '\x1b[0m'
+
+
+def gen_colors(value, theme, keywords=KEYWORDS):
+    """Generate color tuples (start, end, color)."""
+    sio = io.StringIO(value)
+    line_offsets = [..., 0] + [sio.tell() for __ in sio]
+    sio.seek(0)
+
+    bracket_level = is_def_name = 0
+    yield None, 0, theme.reset
+    try:
+        for token in tokenize.generate_tokens(sio.readline):
+            if token.start == token.end:
+                continue
+            color, end_offset = None, 0
+            if token.type in T_STRING:
+                if token.type in T_MIDDLE and token.string[-1:] in '{}':
+                    end_offset += 1
+                color = theme.string
+            elif token.type == T.COMMENT:
+                color = theme.comment
+            elif token.type == T.NUMBER:
+                color = theme.number
+            elif token.type == T.OP:
+                if token.string in '([{':
+                    bracket_level += 1
+                elif token.string in ')]}':
+                    bracket_level -= 1
+                color = theme.op
+            elif token.type == T.NAME:
+                if token.string in keywords:
+                    is_def_name = token.string in DEF_CLASS
+                    color = theme.keyword
+                elif keywords is not KEYWORDS:
+                    continue
+                elif is_def_name:
+                    is_def_name = False
+                    color = theme.definition
+                elif token.string in SOFTKEYW and not bracket_level:
+                    color = theme.keyword  # soft_keyword
+                elif token.string in BUILTINS:
+                    color = theme.builtin
+            if color is not None:
+                start = line_offsets[token.start[0]] + token.start[1]
+                end = line_offsets[token.end[0]] + token.end[1] + end_offset
+                yield start, end, color
+    except (SyntaxError, tokenize.TokenError):
+        pass
+    yield None, None, theme.reset
+
+
+def _apply_colors(value, theme, keywords):
+    output = ''
+    if value:
+        __, end, c_reset = next(colors := gen_colors(value, theme=theme, keywords=keywords))
+
+        while (last_pos := end) is not None:
+            start, end, color = next(colors)
+            if start is None:
+                output += _escape(value[last_pos:])
+            else:
+                output += _escape(value[last_pos:start]) + color + _escape(value[start:end]) + c_reset
+    return output
+
+
+def _escape(value):
+    if value.isascii():
+        return value
+    result = ''
+    for char in value:
+        if char > '\x7f' and unicodedata.category(char)[:1] == 'C':
+            char = rf'\u{ord(char):04x}'
+        result += char
+    return result
+
+
+def color_python(value):
+    """Colorize Python syntax."""
+    return _apply_colors(value, THEME(), KEYWORDS)
+
+
+def color_repr(value):
+    """Colorize string representation."""
+    return _apply_colors(value, THEME(), CONSTANTS)
+
+
+def color_json(value):
+    """Colorize JSON representation."""
+    return _apply_colors(value, THEME(), J_SPECIAL)
+
+
+def patch_colors(module):
+    """Set functions to color output."""
+    global THEME
+    try:  # Python >= 3.14
+        from _pyrepl.utils import BUILTINS, THEME
+        BUILTINS |= {'Client', 'client', 'env', 'self'}
+    except ImportError:
+        pass
+
+    module.color_repr = color_repr
+    if module.color_py is not str:  # Python >= 3.14
+        return {'color_repr': color_repr}
+    theme = THEME()
+    module.color_py = color_python
+    module.color_bold = f'{theme.definition}{{}}{theme.reset}'.format
+    module.color_comment = f'{theme.comment}{{}}{theme.reset}'.format
+    decolor = odooly.partial(re.compile(r'\x1b\[[;\d]+m').sub, '')
+    return {'color_py': color_python, 'color_repr': color_repr, 'decolor': decolor}
+
+
+def main():
+    args = odooly.get_parser().parse_args()
+
+    if args.config:
+        odooly.Client._config_file = odooly.Path.cwd() / args.config
+    if args.list_env:
+        print('Available settings:  ' + ' '.join(odooly.read_config()))
+        return
+
+    global_vars = odooly.Client._set_interactive()
+    if odooly.color_py is not str or (os.getenv('FORCE_COLOR') and not os.getenv('NO_COLOR')):
+        global_vars.update(patch_colors(odooly))
+
+    print(odooly.color_repr(odooly.USAGE))
+    odooly.connect_client(args)
+    odooly._interact(global_vars)
+
+
+if __name__ == '__main__':
+    main()

odooly-2.6.2/odooly_run.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-"""Connect to an Odoo server."""
-# Colorize command-line output for Python <= 3.13
-import builtins
-import keyword
-import io
-import os
-import pathlib
-import re
-import token as T
-import tokenize
-import unicodedata
-
-import odooly
-
-BUILTINS = {str(name) for name in dir(builtins) if name[:1] != '_'}
-T_STRING = {getattr(T, tk) for tk in dir(T) if 'STRING' in tk}
-T_MIDDLE = {getattr(T, tk) for tk in dir(T) if 'STRING_MIDDLE' in tk}
-
-issoftkeyword = getattr(keyword, 'issoftkeyword', lambda t: False)
-
-
-class THEME:  # Default theme
-    keyword = '\x1b[1;34m'
-    builtin = '\x1b[36m'
-    comment = '\x1b[31m'
-    string = '\x1b[32m'
-    number = '\x1b[33m'
-    op = '\x1b[0m'  # No color
-    definition = '\x1b[1m'
-    reset = '\x1b[0m'
-
-
-def gen_colors(value, theme=THEME()):
-    """Generate color tuples (start, end, color, reset_color)."""
-    sio = io.StringIO(value)
-    line_lengths = [0] + [len(line) for line in sio.readlines()]
-    for i in range(1, len(line_lengths)):
-        line_lengths[i] += line_lengths[i-1]
-
-    sio.seek(0)
-    bracket_level = is_def_name = 0
-    try:
-        for token in tokenize.generate_tokens(sio.readline):
-            if token.start == token.end:
-                continue
-            color, end_offset = None, -1
-            if token.type in T_STRING:
-                if token.type in T_MIDDLE and token.string.endswith(('{', '}')):
-                    end_offset += 1
-                color = theme.string
-            elif token.type == T.COMMENT:
-                color = theme.comment
-            elif token.type == T.NUMBER:
-                color = theme.number
-            elif token.type == T.OP:
-                if token.string in '([{':
-                    bracket_level += 1
-                elif token.string in ')]}':
-                    bracket_level -= 1
-                color = theme.op
-            elif token.type == T.NAME:
-                if is_def_name:
-                    is_def_name = False
-                    color = theme.definition
-                elif keyword.iskeyword(token.string):
-                    if token.string in ('def', 'class'):
-                        is_def_name = True
-                    color = theme.keyword
-                elif issoftkeyword(token.string) and not bracket_level:
-                    color = theme.keyword  # soft_keyword
-                elif token.string in BUILTINS:
-                    color = theme.builtin
-            if color is not None:
-                start = line_lengths[token.start[0] - 1] + token.start[1]
-                end = line_lengths[token.end[0] - 1] + token.end[1] + end_offset
-                yield start, end, color, theme.reset
-    except (SyntaxError, tokenize.TokenError):
-        pass
-    yield None, None, None, None
-
-
-def colorize(value):
-    """Colorize Python syntax."""
-    output = ''
-    if value:
-        start, end, color, c_reset = next(colors := gen_colors(value))
-
-        for idx, char in enumerate(value):
-            if start == idx:
-                output += color
-
-            if char > '\x7f' and unicodedata.category(char)[:1] == 'C':
-                char = rf'\u{ord(char):04x}'
-            output += char
-
-            if end == idx:
-                output += c_reset
-                start, end, color, c_reset = next(colors)
-    return output
-
-
-def patch_colors(module):
-    """Set functions to color output."""
-    module.colorize = colorize
-    module.color_bold = f'{THEME.definition}{{}}{THEME.reset}'.format
-    module.color_comment = f'{THEME.comment}{{}}{THEME.reset}'.format
-    decolor = odooly.partial(re.compile(r'\x1b\[[;\d]+m').sub, '')
-    return {'colorize': colorize, 'decolor': decolor}
-
-
-def main():
-    args = odooly.get_parser().parse_args()
-
-    if args.config:
-        odooly.Client._config_file = odooly.Path.cwd() / args.config
-    if args.list_env:
-        print('Available settings:  ' + ' '.join(odooly.read_config()))
-        return
-
-    global_vars = odooly.Client._set_interactive()
-    if os.getenv('FORCE_COLOR') and not os.getenv('NO_COLOR') and odooly.colorize is str:
-        global_vars.update(patch_colors(odooly))  # Python <= 3.13
-
-    print(odooly.colorize(odooly.USAGE))
-    odooly.connect_client(args)
-    odooly._interact(global_vars)
-
-
-if __name__ == '__main__':
-    main()