DirectoryCreationError

Complexity

Total Complexity

4

Size/Duplication

Total Lines	26
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	message()	0	3	1
A	from_exception()	0	9	2
A	__init__()	0	3	1

import os
import errno


class FileActionsException(Exception):
    '''
    Base class for file-actions exceptions
    '''
    code = None
    template = 'Unhandled error.'

    def __init__(self, message=None, path=None):
        self.path = path
        message = self.template.format(self) if message is None else message
        super(FileActionsException, self).__init__(message)


class InvalidDirnameError(FileActionsException):
    '''
    Exception raised when a new directory name is invalid.

    :property name: name which raised this Exception
    '''
    code = 'directory-invalid-name'
    template = 'Clipboard item {0.name!r} is not valid.'

    def __init__(self, message=None, path=None, name=None):
        self.name = name
        super(InvalidDirnameError, self).__init__(message, path)


class DirectoryCreationError(FileActionsException):
    '''
    Exception raised when a new directory creation fails.

    :property name: name which raised this Exception
    '''
    code = 'directory-mkdir-error'
    template = 'Clipboard item {0.name!r} is not valid.'

    def __init__(self, message=None, path=None, name=None):
        self.name = name
        super(DirectoryCreationError, self).__init__(message, path)

    @property
    def message(self):
        return self.args[0]

    @classmethod
    def from_exception(cls, exception, *args, **kwargs):
        message = None
        if isinstance(exception, OSError):
            message = '%s (%s)' % (
                os.strerror(exception.errno),
                errno.errorcode[exception.errno]
                )
        return cls(message, *args, **kwargs)


class ClipboardException(FileActionsException):
    '''
    Base class for clipboard exceptions.

    :property path: item path which raised this Exception
    :property clipboard: :class Clipboard: instance
    '''
    code = 'clipboard-invalid'
    template = 'Clipboard is invalid.'

    def __init__(self, message=None, path=None, clipboard=None):
        self.clipboard = clipboard
        super(ClipboardException, self).__init__(message, path)


class ItemIssue(tuple):
    '''
    Item/error issue
    '''
    @property
    def item(self):
        return self[0]

    @property
    def error(self):
        return self[1]

    @property
    def message(self):
        if isinstance(self.error, OSError):
            return '%s (%s)' % (
                os.strerror(self.error.errno),
                errno.errorcode[self.error.errno]
                )

        # ensure full path is never returned
        text = str(self.error)
        text = text.replace(self.item.path, self.item.name)
        return text


class InvalidClipboardItemsError(ClipboardException):
    '''
    Exception raised when a clipboard item is not valid.

    :property path: item path which raised this Exception
    '''
    pair_class = ItemIssue
    code = 'clipboard-invalid-items'
    template = 'Clipboard has invalid items.'

    def __init__(self, message=None, path=None, clipboard=None, issues=()):
        self.issues = list(map(self.pair_class, issues))
        supa = super(InvalidClipboardItemsError, self)
        supa.__init__(message, path, clipboard)

    def append(self, item, error):
        self.issues.append(self.pair_class((item, error)))


class InvalidClipboardModeError(ClipboardException):
    '''
    Exception raised when a clipboard mode is not valid.

    :property mode: mode which raised this Exception
    '''
    code = 'clipboard-invalid-mode'
    template = 'Clipboard mode {0.path!r} is not valid.'

    def __init__(self, message=None, path=None, clipboard=None, mode=None):
        self.mode = mode
        supa = super(InvalidClipboardModeError, self)
        supa.__init__(message, path, clipboard)


class InvalidClipboardSizeError(ClipboardException):
    '''
    Exception raised when a clipboard size exceeds cookie limit.

    :property max_cookies: maximum allowed size
    '''
    code = 'clipboard-invalid-size'
    template = 'Clipboard has too many items.'

    def __init__(self, message=None, path=None, clipboard=None, max_cookies=0):
        self.max_cookies = max_cookies
        supa = super(InvalidClipboardSizeError, self)
        supa.__init__(message, path, clipboard)