_cdata()

Complexity

Conditions

5

Size

Total Lines

11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	1

1 Method

Rating	Name	Duplication	Size	Complexity
A	_bytes()	0	4	2

"""This module focuses on improvements to the Python libtcod API.
"""
from __future__ import absolute_import as _

import os as _os

Unused os imported as _os

import sys as _sys

import platform as _platform

Unused platform imported as _platform

import weakref as _weakref

Unused weakref imported as _weakref

import functools as _functools

Unused functools imported as _functools

import numpy as _np

The import numpy could not be resolved.

Unused numpy imported as _np

from tcod.libtcod import lib, ffi, BKGND_DEFAULT, BKGND_SET

The name BKGND_DEFAULT does not seem to exist in module tcod.libtcod.

The name BKGND_SET does not seem to exist in module tcod.libtcod.

Unused BKGND_SET imported from tcod.libtcod

Unused BKGND_DEFAULT imported from tcod.libtcod

Unused lib imported from tcod.libtcod

def _unpack_char_p(char_p):

This function should have a docstring.

    if char_p == ffi.NULL:
        return ''
    return ffi.string(char_p).decode()


def _int(int_or_str):
    'return an integer where a single character string may be expected'
    if isinstance(int_or_str, str):
        return ord(int_or_str)
    if isinstance(int_or_str, bytes):
        return int_or_str[0]
    return int(int_or_str) # check for __count__


if _sys.version_info[0] == 2: # Python 2
    def _bytes(string):

This function should have a docstring.

        if isinstance(string, unicode):

Undefined variable 'unicode'

            return string.encode()
        return string

    def _unicode(string):

This function should have a docstring.

        if not isinstance(string, unicode):

Undefined variable 'unicode'

            return string.decode('latin-1')
        return string

else: # Python 3
    def _bytes(string):

This function should have a docstring.

        if isinstance(string, str):
            return string.encode()
        return string

    def _unicode(string):

This function should have a docstring.

        if isinstance(string, bytes):
            return string.decode('latin-1')
        return string


def _fmt_bytes(string):

This function should have a docstring.

    return _bytes(string).replace(b'%', b'%%')

def _fmt_unicode(string):

This function should have a docstring.

    return _unicode(string).replace(u'%', u'%%')


class _PropagateException():
    """ context manager designed to propagate exceptions outside of a cffi
    callback context.  normally cffi suppresses the exception

    when propagate is called this class will hold onto the error until the
    control flow leaves the context, then the error will be raised

    with _PropagateException as propagate:
    # give propagate as onerror parameter for ffi.def_extern
    """

    def __init__(self):
        self.exc_info = None # (exception, exc_value, traceback)

    def propagate(self, *exc_info):
        """ set an exception to be raised once this context exits

        if multiple errors are caught, only keep the first exception raised
        """
        if not self.exc_info:
            self.exc_info = exc_info

    def __enter__(self):
        """ once in context, only the propagate call is needed to use this
        class effectively
        """
        return self.propagate

    def __exit__(self, type, value, traceback):

This seems to re-define the built-in type.

        """ if we're holding on to an exception, raise it now

        prefers our held exception over any current raising error

        self.exc_info is reset now in case of nested manager shenanigans
        """
        if self.exc_info:
            type, value, traceback = self.exc_info

It seems like you are trying to unpack a non-sequence, which was defined at line 74.

The tuple unpacking with sequence seems to be unbalanced; 3 value(s) for 0 label(s)

It seems like you are trying to unpack a non-sequence, which was defined at line 99.

            self.exc_info = None
        if type:
            # Python 2/3 compatible throw
            exception = type(value)
            exception.__traceback__ = traceback
            raise exception


class _CDataWrapper(object):

This class should have a docstring.

    def __init__(self, *args, **kargs):
        self.cdata = self._get_cdata_from_args(*args, **kargs)
        if self.cdata == None:
            self.cdata = ffi.NULL
        super(_CDataWrapper, self).__init__()

    def _get_cdata_from_args(self, *args, **kargs):

This method should have a docstring.

This method could be written as a function/class method.

        if len(args) == 1 and isinstance(args[0], ffi.CData) and not kargs:
            return args[0]
        else:
            return None


    def __hash__(self):
        return hash(self.cdata)

    def __eq__(self, other):
        try:
            return self.cdata == other.cdata
        except AttributeError:
            return NotImplemented

    def __getattr__(self, attr):
        if 'cdata' in self.__dict__:
            return getattr(self.__dict__['cdata'], attr)
        raise AttributeError(attr)

    def __setattr__(self, attr, value):
        if hasattr(self, 'cdata') and hasattr(self.cdata, attr):
            setattr(self.cdata, attr, value)
        else:
            super(_CDataWrapper, self).__setattr__(attr, value)