Python utils.istext方法代码示例

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def eval_expr(self, toks):
        """Evaluates expressions.

        Currently only works for expressions that also happen to be valid
        python expressions.

        """
        logger.debug("Eval: {}".format(toks))
        try:
            if istext(toks) or isbytes(toks):
                val = self.eval(toks, None, self.defs['values'])
            elif toks.array_values != '':
                val = [self.eval(x, None, self.defs['values'])
                       for x in toks.array_values]
            elif toks.value != '':
                val = self.eval(toks.value, None, self.defs['values'])
            else:
                val = None
            return val

        except Exception:
            logger.debug("    failed eval {} : {}".format(toks, format_exc()))
            return None 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def find(self, name):
        """Search all definitions for the given name.

        """
        res = []
        for f in self.file_defs:
            fd = self.file_defs[f]
            for t in fd:
                typ = fd[t]
                for k in typ:
                    if istext(name):
                        if k == name:
                            res.append((f, t))
                    else:
                        if re.match(name, k):
                            res.append((f, t, k))
        return res 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def __lt__(self, other):
        if not istext(other):
            raise TypeError(self.unorderable_err.format(type(other)))
        return super(newstr, self).__lt__(other) 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def __le__(self, other):
        if not istext(other):
            raise TypeError(self.unorderable_err.format(type(other)))
        return super(newstr, self).__le__(other) 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def __gt__(self, other):
        if not istext(other):
            raise TypeError(self.unorderable_err.format(type(other)))
        return super(newstr, self).__gt__(other) 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def __ge__(self, other):
        if not istext(other):
            raise TypeError(self.unorderable_err.format(type(other)))
        return super(newstr, self).__ge__(other) 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def join(self, iterable_of_bytes):
        errmsg = 'sequence item {0}: expected bytes, {1} found'
        if isbytes(iterable_of_bytes) or istext(iterable_of_bytes):
            raise TypeError(errmsg.format(0, type(iterable_of_bytes)))
        for i, item in enumerate(iterable_of_bytes):
            if istext(item):
                raise TypeError(errmsg.format(i, type(item)))
        return newbytes(super(newbytes, self).join(iterable_of_bytes)) 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def __call__(cls, lib, *args, **kwargs):

        # Identify the library path.
        if istext(lib) or isbytes(lib):
            if os.sep not in lib:
                lib_path = find_library(lib).path
            else:
                lib_path = os.path.realpath(lib)
                assert os.path.isfile(lib_path),\
                    'Provided path does not point to a file'
            backend_cls = cls.backends[kwargs.get('backend', 'ctypes')]

            lib_arch = LibraryPath(lib_path).arch
            py_bitness = 64 if sys.maxsize > 2**32 else 32
            if lib_arch and py_bitness not in lib_arch:
                raise OSError("Library bitness does not match Python's")
            lib = lib_path
        else:
            from .backends import identify_library, get_library_path
            backend = identify_library(lib)
            backend_cls = cls.backends[backend]
            lib_path = get_library_path(lib, backend)

        # Check whether or not this library has already been opened.
        if lib_path in cls.libs:
            return cls.libs[lib_path]

        else:
            obj = super(CLibraryMeta, backend_cls).__call__(lib, *args,
                                                            **kwargs)
            cls.libs[lib_path] = obj
            return obj 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def __init__(self, lib, headers, prefix=None, lock_calls=False,
                 convention='cdll', backend='ctypes', **kwargs):
        # name everything using underscores to avoid name collisions with
        # library

        # Build or store the parser from the header files.
        if isinstance(headers, list):
            self._headers_ = self._build_parser(headers, kwargs)
        elif isinstance(headers, CParser):
            self._headers_ = headers
        else:
            msg = 'Expected a CParser instance or list for headers, not {}'
            raise ValueError(msg.format(type(headers)))
        self._defs_ = self._headers_.defs

        # Create or store the internal representation of the library.
        if istext(lib) or isbytes(lib):
            self._lib_ = self._link_library(lib, convention)
        else:
            self._lib_ = lib

        # Store the list of prefix.
        if prefix is None:
            self._prefix_ = []
        elif isinstance(prefix, list):
            self._prefix_ = prefix
        else:
            self._prefix_ = [prefix]

        self._lock_calls_ = lock_calls
        if lock_calls:
            self._lock_ = RLock()

        self._objs_ = {}
        for k in ['values', 'functions', 'types', 'structs', 'unions',
                  'enums']:
            self._objs_[k] = {}
        self._all_objs_ = {}
        self._structs_ = {}
        self._unions_ = {} 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def arg_c_type(self, arg):
        """Return the type required for the specified argument.

        Parameters
        ----------
        arg : int or unicode
            Name or index of the argument whose type should be returned.

        """
        if istext(arg) or isbytes(arg):
            arg = self.arg_inds[arg]
        return self.lib._get_type(self.sig[1][arg][1]) 

# 需要导入模块: from future import utils [as 别名]
# 或者: from future.utils import istext [as 别名]
def __getitem__(self, n):
        if isinstance(n, int):
            arg = self.args[n]
        elif istext(n) or isbytes(n):
            n = self.find_arg(n)
            arg = self.args[n]
        else:
            raise ValueError("Index must be int or str.")

        if n in self.guessed:
            arg = arg[0]

        return self.lib._extract_val_(arg)