Source code for openerp_proxy.utils

# -*- encoding: utf-8 -*-
import os
import six
import json
import functools

__all__ = ('ustr',

# Python 2/3 workaround in raw_input
    xinput = raw_input
except NameError:
    xinput = input

# Check if anyfield is installed
# and import function which converts SField instances to functions
    from anyfield import toFn as normalizeSField
except ImportError:
    def normalizeSField(fn):
        return fn

[docs]def makedirs(path): """ os.makedirs wrapper. No errors raised if directory already exists :param str path: directory path to create """ try: os.makedirs(path) except os.error: pass
[docs]def json_read(file_path): """ Read specified json file """ with open(file_path, 'rt') as json_data: data = json.load(json_data) return data
[docs]def json_write(file_path, *args, **kwargs): """ Write data to specified json file Note, this function uses dumps function to convert data to json first, and write only if conversion is successfule. This allows to avoid loss of data when rewriting file. """ # note, using dumps instead of dump, because we need to check if data will # be dumped correctly. using dump on incorect data, causes file to be half # written, and thus broken json_data = json.dumps(*args, **kwargs) with open(file_path, 'wt') as json_file: json_file.write(json_data)
[docs]def wpartial(func, *args, **kwargs): """Wrapped partial, same as functools.partial decorator, but also calls functools.wrap on its result thus shwing correct function name and representation. """ partial = functools.partial(func, *args, **kwargs) return functools.wraps(func)(partial)
def preprocess_args(*args, **kwargs): """ Skip all args, and kwargs that set to None Mostly for internal usage. Used to workaround xmlrpc None restrictions """ kwargs = {key: val for key, val in kwargs.items() if val is not None} # TODO: review this! It may bring errors xargs = list(args[:]) while xargs and xargs[-1] is None: xargs.pop() return xargs, kwargs def stdcall(fn): """ Simple decorator for server methods, that supports standard call If method supports call like ``method(ids, <args>, context=context, <kwargs>)``, then it may be decrated by this decorator to appear in dir(record) and dir(recordlist) calls, thus making it available for autocompletition in ipython or other python shells """ fn.__x_stdcall__ = True return fn
[docs]class UConverter(object): """ Simple converter to unicode Create instance with specified list of encodings to be used to try to convert value to unicode Example:: ustr = UConverter(['utf-8', 'cp-1251']) my_unicode_str = ustr(b'hello - привет') """ default_encodings = ['utf-8', 'ascii'] def __init__(self, hint_encodings=None): if hint_encodings: self.encodings = hint_encodings else: self.encodings = self.default_encodings[:] def __call__(self, value): """ Convert value to unicode :param value: the value to convert :raise: UnicodeError if value cannot be coerced to unicode :return: unicode string representing the given value """ # it is unicode if isinstance(value, six.text_type): return value # it is not binary type (str for python2 and bytes for python3) if not isinstance(value, six.binary_type): try: value = six.text_type(value) except Exception: # Cannot directly convert to unicode. So let's try to convert # to binary, and that try diferent encoding to it try: value = six.binary_type(value) except: raise UnicodeError('unable to convert to unicode %r' '' % (value,)) else: return value # value is binary type (str for python2 and bytes for python3) for ln in self.encodings: try: res = six.text_type(value, ln) except Exception: pass else: return res raise UnicodeError('unable to convert to unicode %r' % (value,))
# default converter instance ustr = UConverter() # DirMixIn class implementation. To be able to use super calls to __dir__ in # subclasses (Py 2/3 support) # code is based on # try: object.__dir__ except AttributeError: class DirMixIn(object): """ Mix-in to make implementing __dir__ method in subclasses simpler """ def __dir__(self): def get_attrs(obj): import types if not hasattr(obj, '__dict__'): return [] # slots only if not isinstance(obj.__dict__, (dict, types.DictProxyType)): raise TypeError("%s.__dict__ is not a dictionary" "" % obj.__name__) return obj.__dict__.keys() def dir2(obj): attrs = set() if not hasattr(obj, '__bases__'): # obj is an instance if not hasattr(obj, '__class__'): # slots return sorted(get_attrs(obj)) klass = obj.__class__ attrs.update(get_attrs(klass)) else: # obj is a class klass = obj for cls in klass.__bases__: attrs.update(get_attrs(cls)) attrs.update(dir2(cls)) attrs.update(get_attrs(obj)) return list(attrs) return dir2(self) else: # There are no need to implement any aditional logic for Python 3.3+, # because there base class 'object' already have implemented # '__dir__' method, which could be accessed via super() by subclasses
[docs] class DirMixIn: pass
[docs]class AttrDict(dict, DirMixIn): """ Simple class to make dictionary able to use attribute get operation to get elements it contains using syntax like: >>> d = AttrDict(arg1=1, arg2='hello') >>> print(d.arg1) 1 >>> print(d.arg2) hello >>> print(d['arg2']) hello >>> print(d['arg1']) 1 """ def __getattr__(self, name): res = None try: res = super(AttrDict, self).__getitem__(name) except KeyError as e: raise AttributeError(str(e)) return res def __dir__(self): res = super(AttrDict, self).__dir__() + list(self.keys()) return list(set(res))