Drop support for Python 3.5

Author: florentx

CHANGES.rst

@@ -8,6 +8,8 @@ Changelog
 * Use a Web session for JSON-RPC requests
   when Requests is installed.
 
+* Drop support for Python 3.5
+
 
 2.2.1 (2025-09-24)
 ~~~~~~~~~~~~~~~~~~

README.rst

@@ -32,7 +32,7 @@ Key features:
 - simplified syntax for search ``domain`` and ``fields``
 - full API accessible on the ``Client.env`` environment
 - the module can be imported and used as a library: ``from odooly import Client``
-- supports Python 3.5 and above
+- supports Python 3.6 and above
 
 
 

odooly.py

@@ -211,7 +211,7 @@ def format_exception(exc_type, exc, tb, limit=None, chain=True,
             message = str(server_error['arguments'][0])
         except Exception:
             message = str(server_error['arguments'])
-        fault = '%s: %s' % (server_error['name'], message)
+        fault = f"{server_error['name']}: {message}"
         exc_type = server_error.get('exception_type', 'internal_error')
         if exc_type != 'internal_error' or message.startswith('FATAL:'):
             server_tb = None
@@ -247,7 +247,7 @@ def read_config(section=None):
         server = shlex.split(env.get('options', ''))
     else:
         protocol = env.get('protocol', 'xmlrpc')
-        server = '%s://%s:%s/%s' % (scheme, env['host'], env['port'], protocol)
+        server = f"{scheme}://{env['host']}:{env['port']}/{protocol}"
     return (server, env['database'], env['username'], env.get('password'))
 
 
@@ -320,7 +320,7 @@ def searchargs(params, kwargs=None):
         if isinstance(term, str) and term not in DOMAIN_OPERATORS:
             m = _term_re.match(term.strip())
             if not m:
-                raise ValueError('Cannot parse term %r' % term)
+                raise ValueError(f"Cannot parse term {term!r}")
             (field, operator, value) = m.groups()
             try:
                 value = literal_eval(value)
@@ -366,7 +366,7 @@ def dispatch_jsonrpc(url, service_name, method, args):
         'jsonrpc': '2.0',
         'method': 'call',
         'params': {'service': service_name, 'method': method, 'args': args},
-        'id': '%04x%010x' % (os.getpid(), (int(time.time() * 1E6) % 2**40)),
+        'id': f"{os.getpid():04x}{int(time.time() * 1E6) % 2**40:010x}",
     }
     resp = http_post(url, json.dumps(data).encode('ascii'))
     if resp.get('error'):
@@ -379,7 +379,7 @@ class partial(functools.partial):
 
     def __repr__(self):
         # Hide arguments
-        return '%s(%r, ...)' % (self.__class__.__name__, self.func)
+        return f"{self.__class__.__name__}({self.func!r}, ...)"
 
 
 class Error(Exception):
@@ -411,15 +411,15 @@ def __init__(self, client, endpoint, methods, verbose=False):
         self._verbose = verbose
 
     def __repr__(self):
-        return "<Service '%s|%s'>" % (self._rpcpath, self._endpoint)
+        return f"<Service '{self._rpcpath}|{self._endpoint}'>"
     __str__ = __repr__
 
     def __dir__(self):
         return sorted(self._methods)
 
     def __getattr__(self, name):
         if name not in self._methods:
-            raise AttributeError("'Service' object has no attribute %r" % name)
+            raise AttributeError(f"'Service' object has no attribute {name!r}")
         if self._verbose:
             def sanitize(args):
                 if self._endpoint != 'db' and len(args) > 2:
@@ -430,17 +430,17 @@ def sanitize(args):
 
             def wrapper(self, *args):
                 snt = ', '.join([repr(arg) for arg in sanitize(args)])
-                snt = '%s.%s(%s)' % (self._endpoint, name, snt)
+                snt = f"{self._endpoint}.{name}({snt})"
                 if len(snt) > maxcol:
-                    suffix = '... L=%s' % len(snt)
+                    suffix = f"... L={len(snt)}"
                     snt = snt[:maxcol - len(suffix)] + suffix
-                print('--> ' + snt)
+                print(f"--> {snt}")
                 res = self._dispatch(name, args)
                 rcv = str(res)
                 if len(rcv) > maxcol:
-                    suffix = '... L=%s' % len(rcv)
+                    suffix = f"... L={len(rcv)}"
                     rcv = rcv[:maxcol - len(suffix)] + suffix
-                print('<-- ' + rcv)
+                print(f"<-- {rcv}")
                 return res
         else:
             wrapper = lambda s, *args: s._dispatch(name, args)
@@ -497,8 +497,7 @@ def __bool__(self):
     __hash__ = object.__hash__
 
     def __repr__(self):
-        return "<Env '%s@%s'>" % (self.user.login if self.uid else '',
-                                  self.db_name)
+        return f"<Env '{self.user.login if self.uid else ''}@{self.db_name}'>"
 
     def check_uid(self, uid, password):
         """Check if ``(uid, password)`` is valid.
@@ -541,10 +540,10 @@ def _auth(self, user, password):
             if not password and uid is not False:
                 from getpass import getpass
                 if user is None:
-                    name = 'admin' if uid == SUPERUSER_ID else ('UID %d' % uid)
+                    name = 'admin' if uid == SUPERUSER_ID else f'UID {uid}'
                 else:
                     name = user
-                password = getpass('Password for %r: ' % name)
+                password = getpass(f"Password for {name!r}: ")
         # Check if password is valid
         uid = self.check_uid(uid, password) if (uid and not verified) else uid
         if uid is None:
@@ -784,7 +783,7 @@ def _get(self, name, check=True):
         if model_names:
             errmsg = 'Model not found.  These models exist:'
         else:
-            errmsg = 'Model not found: %s' % (name,)
+            errmsg = f'Model not found: {name}'
         raise Error('\n * '.join([errmsg] + model_names))
 
     def modules(self, name='', installed=None):
@@ -820,23 +819,23 @@ def _upgrade(self, modules, button):
         ir_module = self._get('ir.module.module', False)
         updated, added = ir_module.update_list()
         if added:
-            print('%s module(s) added to the list' % added)
+            print(f'{added} module(s) added to the list')
         # Find modules
         sel = modules and ir_module.search([('name', 'in', modules)])
         mods = ir_module.read([_pending_state], 'name state')
         if sel:
             # Safety check
             if any(mod['name'] not in modules for mod in mods):
                 raise Error('Pending actions:\n' + '\n'.join(
-                    ('  %(state)s\t%(name)s' % mod) for mod in mods))
+                    f"  {mod['state']}\t{mod['name']}" for mod in mods))
             if button == 'button_uninstall':
                 # Safety check
                 names = ir_module.read([('id', 'in', sel.ids),
                                         'state != installed',
                                         'state != to upgrade',
                                         'state != to remove'], 'name')
                 if names:
-                    raise Error('Not installed: %s' % ', '.join(names))
+                    raise Error(f"Not installed: {', '.join(names)}")
                 if self.client.version_info < 7.0:
                     # A trick to uninstall dependent add-ons
                     sel.write({'state': 'to remove'})
@@ -849,13 +848,13 @@ def _upgrade(self, modules, button):
                 print('Already up-to-date: %s' %
                       self.modules([('id', 'in', sel.ids)]))
             elif modules:
-                raise Error('Module(s) not found: %s' % ', '.join(modules))
-            print('%s module(s) updated' % updated)
+                raise Error(f"Module(s) not found: {', '.join(modules)}")
+            print(f'{updated} module(s) updated')
             return
-        print('%s module(s) selected' % len(sel))
-        print('%s module(s) to process:' % len(mods))
+        print(f'{len(sel)} module(s) selected')
+        print(f'{len(mods)} module(s) to process:')
         for mod in mods:
-            print('  %(state)s\t%(name)s' % mod)
+            print(f"  {mod['state']}\t{mod['name']}")
 
         # Empty the cache for this database
         self.refresh()
@@ -943,7 +942,7 @@ def get_service(name):
         self.server_version = ver = get_service('db').server_version()
         self.major_version = re.search(r'\d+\.?\d*', ver).group()
         self.version_info = float_version = float(self.major_version)
-        assert float_version > 6.0, 'Not supported: %s' % ver
+        assert float_version > 6.0, f'Not supported: {ver}'
         # Create the RPC services
         self.db = get_service('db')
         self.common = get_service('common')
@@ -983,7 +982,7 @@ def from_config(cls, environment, user=None, verbose=False):
         return client
 
     def __repr__(self):
-        return "<Client '%s#%s'>" % (self._server, self.env.db_name)
+        return f"<Client '{self._server}#{self.env.db_name}'>"
 
     def close(self):
         for conn in self._connections:
@@ -1026,7 +1025,7 @@ def login(self, user, password=None, database=None):
         try:
             self._login(user, password=password, database=database)
         except Error as exc:
-            print('%s: %s' % (exc.__class__.__name__, exc))
+            print(f"{exc.__class__.__name__}: {exc}")
         else:
             # Register the new globals()
             self.connect()
@@ -1043,11 +1042,11 @@ def connect(self, env_name=None):
         self._globals['env'] = client.env
         self._globals['self'] = client.env.user if client.env.uid else None
         # Tweak prompt
-        sys.ps1 = '%s >>> ' % (env_name,)
+        sys.ps1 = f'{env_name} >>> '
         sys.ps2 = '... '.rjust(len(sys.ps1))
         # Logged in?
         if client.env.uid:
-            print('Logged in as %r' % (client.env.user.login,))
+            print(f'Logged in as {client.env.user.login!r}')
 
     @classmethod
     def _set_interactive(cls, global_vars={}):
@@ -1138,7 +1137,7 @@ def _new(cls, env, name):
         return m
 
     def __repr__(self):
-        return "<Model '%s'>" % (self._name,)
+        return f"<Model '{self._name}'>"
 
     def keys(self):
         """Return the keys of the model."""
@@ -1220,12 +1219,12 @@ def get(self, domain, *args, **kwargs):
             rec = self.env.ref(domain)
             if not rec:
                 return None
-            assert rec._model is self, 'Model mismatch %r %r' % (rec, self)
+            assert rec._model is self, f'Model mismatch {rec!r} {self!r}'
             return rec
         assert issearchdomain(domain)       # a search domain
         ids = self._execute('search', domain)
         if len(ids) > 1:
-            raise ValueError('domain matches too many records (%d)' % len(ids))
+            raise ValueError(f'domain matches too many records ({len(ids)})')
         return Record(self, ids[0]) if ids else None
 
     def create(self, values):
@@ -1327,7 +1326,7 @@ def _unbrowse_values(self, values):
             field_type = self._fields[key]['type']
             if hasattr(value, 'id'):
                 if field_type == 'reference':
-                    new_values[key] = '%s,%s' % (value._name, value.id)
+                    new_values[key] = f'{value._name},{value.id}'
                 else:
                     new_values[key] = value = value.id
             if field_type in ('one2many', 'many2many'):
@@ -1350,7 +1349,7 @@ def _get_external_ids(self, ids=None):
                                                   ['module', 'name', 'res_id'])
         res = {}
         for rec in existing:
-            res['%(module)s.%(name)s' % rec] = self.get(rec['res_id'])
+            res[f"{rec['module']}.{rec['name']}"] = self.get(rec['res_id'])
         return res
 
     def __getattr__(self, attr):
@@ -1363,7 +1362,7 @@ def __getattr__(self, attr):
         if attr == '_keys':
             return _memoize(self, attr, sorted(self._fields))
         if attr.startswith('_'):
-            raise AttributeError("'Model' object has no attribute %r" % attr)
+            raise AttributeError(f"'Model' object has no attribute {attr!r}")
 
         def wrapper(self, *params, **kwargs):
             """Wrapper for client.execute(%r, %r, *params, **kwargs)."""
@@ -1412,11 +1411,10 @@ def __new__(cls, res_model, arg):
 
     def __repr__(self):
         if len(self.ids) > 16:
-            ids = 'length=%d' % len(self.ids)
+            ids = f'length={len(self.ids)}'
         else:
             ids = self.id
-        return "<%s '%s,%s'>" % (self.__class__.__name__,
-                                 self._name, ids)
+        return f"<{self.__class__.__name__} '{self._name},{ids}'>"
 
     def __dir__(self):
         attrs = set(self.__dict__) | set(self._model._keys)
@@ -1511,7 +1509,7 @@ def ensure_one(self):
         recs = self.union()
         if len(recs.id) == 1:
             return recs[0]
-        raise ValueError("Expected singleton: %s" % self)
+        raise ValueError(f"Expected singleton: {self}")
 
     def exists(self):
         """Return a subset of records that exist."""
@@ -1720,7 +1718,7 @@ def __getattr__(self, attr):
         if attr in self._model._keys:
             return self.read(attr)
         if attr.startswith('_'):
-            errmsg = "'RecordList' object has no attribute %r" % attr
+            errmsg = f"'RecordList' object has no attribute {attr!r}"
             raise AttributeError(errmsg)
 
         def wrapper(self, *params, **kwargs):
@@ -1730,10 +1728,10 @@ def wrapper(self, *params, **kwargs):
 
     def __setattr__(self, attr, value):
         if attr in self._model._keys or attr == 'id':
-            msg = "attribute %r is read-only; use 'RecordList.write' instead."
+            msg = f"attribute {attr!r} is read-only; use 'RecordList.write' instead."
         else:
-            msg = "has no attribute %r"
-        raise AttributeError("'RecordList' object %s" % msg % attr)
+            msg = f"has no attribute {attr!r}"
+        raise AttributeError("'RecordList' object " + msg)
 
     def __eq__(self, other):
         return (isinstance(other, RecordList) and
@@ -1759,9 +1757,9 @@ def __str__(self):
     def _get_name(self):
         try:
             (id_name,) = self._execute('name_get', [self.id])
-            name = '%s' % (id_name[1],)
+            name = f'{id_name[1]}'
         except Exception:
-            name = '%s,%d' % (self._name, self.id)
+            name = f'{self._name},{self.id}'
         self.__dict__['_idnames'] = [(self.id, name)]
         return _memoize(self, '_Record__name', name)
 
@@ -1827,7 +1825,7 @@ def _set_external_id(self, xml_id):
         domain = ['|', '&', ('module', '=', mod), ('name', '=', name),
                   '&', ('model', '=', self._name), ('res_id', '=', self.id)]
         if self.env['ir.model.data'].search(domain):
-            raise ValueError('ID %r collides with another entry' % xml_id)
+            raise ValueError(f'ID {xml_id!r} collides with another entry')
         self.env['ir.model.data'].create({
             'model': self._name,
             'res_id': self.id,
@@ -1841,7 +1839,7 @@ def __getattr__(self, attr):
         if attr == '_Record__name':
             return self._get_name()
         if attr.startswith('_'):
-            raise AttributeError("'Record' object has no attribute %r" % attr)
+            raise AttributeError(f"'Record' object has no attribute {attr!r}")
 
         def wrapper(self, *params, **kwargs):
             """Wrapper for client.execute(%r, %r, %d, *params, **kwargs)."""
@@ -1856,7 +1854,7 @@ def __setattr__(self, attr, value):
         if attr == '_external_id':
             return self._set_external_id(value)
         if attr not in self._model._keys:
-            raise AttributeError("'Record' object has no attribute %r" % attr)
+            raise AttributeError(f"'Record' object has no attribute {attr!r}")
         if attr == 'id':
             raise AttributeError("'Record' object attribute 'id' is read-only")
         self.write({attr: value})
@@ -1933,10 +1931,10 @@ def main(interact=_interact):
         help='read connection settings from the given section')
     parser.add_option(
         '-c', '--config', default=None,
-        help='specify alternate config file (default: %r)' % CONF_FILE)
+        help=f'specify alternate config file (default: {CONF_FILE!r})')
     parser.add_option(
         '--server', default=None,
-        help='full URL of the server (default: %s)' % DEFAULT_URL)
+        help=f'full URL of the server (default: {DEFAULT_URL})')
     parser.add_option('-d', '--db', default=DEFAULT_DB, help='database')
     parser.add_option('-u', '--user', default=None, help='username')
     parser.add_option(