Console

Complexity

Total Complexity

36

Size/Duplication

Total Lines	244
Duplicated Lines	0 %

Importance

Changes	12
Bugs	0	Features	1

27 Methods

Rating	Name	Duplication	Size	Complexity
A	unpack_color()	0	6	1
A	_from_cdata()	0	8	2
A	__init__()	0	4	1
A	blit()	0	5	1
A	height()	0	4	1
A	get_height_rect()	0	8	1
A	vline()	0	6	1
A	put_char()	0	10	1
A	__exit__()	0	6	1
A	bg()	0	9	1
A	print_rect()	0	14	2
A	__enter__()	0	12	2
A	rect()	0	6	1
A	default_fg()	0	5	1
A	hline()	0	6	1
A	default_alignment()	0	4	1
A	_init_setup_console_data()	0	22	3
A	ch()	0	9	1
A	clear()	0	4	1
A	set_key_color()	0	3	1
A	__bool__()	0	3	1
A	print_frame()	0	14	1
A	default_bg()	0	5	1
A	default_bg_blend()	0	4	1
A	fg()	0	9	1
A	width()	0	4	1
A	print_()	0	12	2

This module should have a docstring.

from __future__ import absolute_import

import sys

import numpy as np

The import numpy could not be resolved.

from tcod.tcod import _cdata
from tcod.libtcod import ffi, lib
from tcod.libtcod import 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

if sys.version_info[0] == 2: # Python 2
    def _fmt(string):

This function should have a docstring.

        if not isinstance(string, unicode):

Undefined variable 'unicode'

            string = string.decode('latin-1')
        return string.replace(u'%', u'%%')
else:
    def _fmt(string):
        """Return a string that escapes 'C printf' side effects."""
        return string.replace('%', '%%')


class _ChBufferArray(np.ndarray):
    """Numpy subclass designed to access libtcod's character buffer.

    This class needs to modify the char_t.cf attribute as a side effect so that
    libtcod will select the correct characters on flush.
    """

    def __new__(cls, ch_array, cf_array):
        self = ch_array.view(cls)
        self._cf_array = cf_array
        return self

    def __array_finalize__(self, obj):
        if obj is None:
            return
        self._cf_array = None

    def __repr__(self):
        return repr(self.view(np.ndarray))

The Instance of _ChBufferArray does not seem to have a member named view.

    def __getitem__(self, index):
        """Slicing this array also slices its _cf_array attribute."""
        array = np.ndarray.__getitem__(self, index)
        if self._cf_array is None or array.size == 1:
            return array.view(np.ndarray)
        array._cf_array = self._cf_array[index]
        return array

    def _covert_ch_to_cf(self, index, ch_arr):
        """Apply a set of Unicode variables to libtcod's special format.

        _cf_array should be the same shape as ch_arr after being sliced by
        index.
        """
        if lib.TCOD_ctx.max_font_chars == 0:
            return # libtcod not initialized
        ch_table = ffi.buffer(
            lib.TCOD_ctx.ascii_to_tcod[0:lib.TCOD_ctx.max_font_chars])
        ch_table = np.frombuffer(ch_table, np.intc)
        self._cf_array[index] = ch_table[ch_arr.ravel()].reshape(ch_arr.shape)

    def __setitem__(self, index, value):
        """Properly set up the char_t.cf variables as a side effect."""
        np.ndarray.__setitem__(self, index, value)
        if self._cf_array is not None:
            self._covert_ch_to_cf(index, self[index])


class Console(object):
    """
    Args:
        width (int): Width of the new Console.
        height (int): Height of the new Console.

    .. versionadded:: 2.0
    """

    def __init__(self, width, height):
        self.cdata = ffi.gc(lib.TCOD_console_new(width, height),
                            lib.TCOD_console_delete)
        self._init_setup_console_data()

    @classmethod
    def _from_cdata(cls, cdata):

This method should have a docstring.

        if isinstance(cdata, cls):
            return cdata
        self = object.__new__(cls)
        self.cdata = cdata
        self._init_setup_console_data()
        return self

    def _init_setup_console_data(self):
        """Setup numpy arrays over libtcod data buffers."""
        import numpy

The import numpy could not be resolved.

The variable numpy seems to be unused.

        if self.cdata == ffi.NULL:
            self._console_data = lib.TCOD_ctx.root
        else:
            self._console_data = ffi.cast('TCOD_console_data_t *', self.cdata)

        def unpack_color(image_cdata):
            """return a (height, width, 3) shaped array from an image struct"""
            color_data = lib.TCOD_image_get_colors(image_cdata)
            color_buffer = ffi.buffer(color_data[0:self.width * self.height])
            array = np.frombuffer(color_buffer, np.uint8)
            return array.reshape((self.height, self.width, 3))

        self._fg = unpack_color(self._console_data.fg_colors)
        self._bg = unpack_color(self._console_data.bg_colors)

        buf = self._console_data.ch_array
        buf = ffi.buffer(buf[0:self.width * self.height])
        self._ch = np.frombuffer(buf, np.intc).reshape((self.height,
                                                        self.width))

    @property
    def width(self):
        """int: The width of this Console. (read-only)"""
        return lib.TCOD_console_get_width(self.cdata)

    @property
    def height(self):
        """int: The height of this Console. (read-only)"""
        return lib.TCOD_console_get_height(self.cdata)

    @property
    def bg(self):
        """A numpy uint8 array with the shape (height, width, 3).

        You can change the consoles background colors by using this array.

        Index this array with ``console.bg[y, x, channel]``
        """
        return self._bg

    @property
    def fg(self):
        """A numpy uint8 array with the shape (height, width, 3).

        You can change the consoles foreground colors by using this array.

        Index this array with ``console.fg[y, x, channel]``
        """
        return self._fg

    @property
    def ch(self):
        """A numpy int array with the shape (height, width).

        You can change the consoles character codes by using this array.

        Index this array with ``console.ch[y, x]``
        """
        return self._ch

    @property
    def default_bg(self):
        """Tuple[int, int, int]: The default background color."""
        color = self._console_data.back
        return color.r, color.g, color.b
    @default_bg.setter
    def default_bg(self, color):

This method should have a docstring.

        self._console_data.back = color

    @property
    def default_fg(self):
        """Tuple[int, int, int]: The default foreground color."""
        color = self._console_data.fore
        return color.r, color.g, color.b
    @default_fg.setter
    def default_fg(self, color):

This method should have a docstring.

        self._console_data.fore = color

    @property
    def default_bg_blend(self):
        """int: The default blending mode."""
        return self._console_data.bkgnd_flag
    @default_bg_blend.setter
    def default_bg_blend(self, value):

This method should have a docstring.

        self._console_data.bkgnd_flag = value

    @property
    def default_alignment(self):
        """int: The default text alignment."""
        return self._console_data.alignment
    @default_alignment.setter
    def default_alignment(self, value):

This method should have a docstring.

        self._console_data.alignment = value

    def clear(self):
        """Reset this console to its default colors and the space character.
        """
        lib.TCOD_console_clear(self.cdata)

    def put_char(self, x, y, ch, bg_blend=BKGND_DEFAULT):
        """Draw the character c at x,y using the default colors and a blend mode.

This line is too long as per the coding-style (81/79).

        Args:
            x (int): Character x position from the left.
            y (int): Character y position from the top.
            ch (int): Character code to draw.  Must be in integer form.
            bg_blend (int): Blending mode to use, defaults to BKGND_DEFAULT.
        """
        lib.TCOD_console_put_char(self.cdata, x, y, ch, bg_blend)

    def print_(self, x, y, string, bg_blend=BKGND_DEFAULT, alignment=None):
        """Print a color formatted string on a console.

        Args:
            x (int): Character x position from the left.
            y (int): Character y position from the top.
            string (Text): A unicode string optionaly using color codes.
        """
        alignment = self.default_alignment if alignment is None else alignment

        lib.TCOD_console_print_ex_utf(self.cdata, x, y,
                                      bg_blend, alignment, _fmt(string))

    def print_rect(self, x, y, width, height, string,
                   bg_blend=BKGND_DEFAULT, alignment=None):
        """Print a string constrained to a rectangle.

        If h > 0 and the bottom of the rectangle is reached,
        the string is truncated. If h = 0,
        the string is only truncated if it reaches the bottom of the console.

        Returns:
            int: The number of lines of text once word-wrapped.
        """
        alignment = self.default_alignment if alignment is None else alignment
        return lib.TCOD_console_print_rect_ex_utf(self.cdata,
            x, y, width, height, bg_blend, alignment, _fmt(string))

    def get_height_rect(self, x, y, width, height, string):
        """Return the height of this text once word-wrapped into this rectangle.

This line is too long as per the coding-style (80/79).

        Returns:
            int: The number of lines of text once word-wrapped.
        """
        return lib.TCOD_console_get_height_rect_utf(
            self.cdata, x, y, width, height, _fmt(string))

    def rect(self, x, y, width, height, clear, bg_blend=BKGND_DEFAULT):
        """Draw a the background color on a rect optionally clearing the text.

        If clr is True the affected tiles are changed to space character.
        """
        lib.TCOD_console_rect(self.cdata, x, y, width, height, clear, bg_blend)

    def hline(self, x, y, width, bg_blend=BKGND_DEFAULT):
        """Draw a horizontal line on the console.

        This always uses the character 196, the horizontal line character.
        """
        lib.TCOD_console_hline(self.cdata, x, y, width, bg_blend)

    def vline(self, x, y, height, bg_blend=BKGND_DEFAULT):
        """Draw a vertical line on the console.

        This always uses the character 179, the vertical line character.
        """
        lib.TCOD_console_vline(self.cdata, x, y, height, bg_blend)

    def print_frame(self, x, y, width, height, string='',
                    clear=True, bg_blend=BKGND_DEFAULT):
        """Draw a framed rectangle with optinal text.

        This uses the default background color and blend mode to fill the
        rectangle and the default foreground to draw the outline.

        string will be printed on the inside of the rectangle, word-wrapped.

        Note:
            This method does not support Unicode outside of the 0-255 range.
        """
        lib.TCOD_console_print_frame(self.cdata, x, y, width, height,
                                     clear, bg_blend, string.encode('latin-1'))

    def blit(self, x, y, width, height,
             dest, dest_x, dest_y, fg_alpha=1.0, bg_alpha=1.0):
        """Blit this console from x,y,w,h to the console dst at xdst,ydst."""
        lib.TCOD_console_blit(self.cdata, x, y, width, height,
                              _cdata(dest), dest_x, dest_y, fg_alpha, bg_alpha)

    def set_key_color(self, color):
        """Set a consoles blit transparent color."""
        lib.TCOD_console_set_key_color(self.cdata, color)

    def __enter__(self):
        """Context manage the root console.

        When the root console is used in a context, the grapical window will
        close once the context is left as if :any:`tcod.console_delete` was
        called on it.

        This is useful for some Python IDE's, such as IDLE.
        """
        if self.cdata != ffi.NULL:
            raise NotImplementedError('Only the root console has a context.')
        return self

    def __exit__(self, *args):
        """Closes the graphical window on exit.

        Some tcod functions may have undefined behaviour after this point.
        """
        lib.TCOD_console_delete(self.cdata)

    def __bool__(self):
        """Mimic libtcod behavior."""
        return self.cdata != ffi.NULL

    __nonzero__ = __bool__