mirror of
https://github.com/ynput/ayon-core.git
synced 2025-12-25 21:32:15 +01:00
393 lines
11 KiB
Python
393 lines
11 KiB
Python
# :coding: utf-8
|
|
# :copyright: Copyright (c) 2014 ftrack
|
|
|
|
from builtins import str
|
|
import sys
|
|
import traceback
|
|
|
|
import ftrack_api.entity.base
|
|
|
|
|
|
class Error(Exception):
|
|
'''ftrack specific error.'''
|
|
|
|
default_message = 'Unspecified error occurred.'
|
|
|
|
def __init__(self, message=None, details=None):
|
|
'''Initialise exception with *message*.
|
|
|
|
If *message* is None, the class 'default_message' will be used.
|
|
|
|
*details* should be a mapping of extra information that can be used in
|
|
the message and also to provide more context.
|
|
|
|
'''
|
|
if message is None:
|
|
message = self.default_message
|
|
|
|
self.message = message
|
|
self.details = details
|
|
if self.details is None:
|
|
self.details = {}
|
|
|
|
self.traceback = traceback.format_exc()
|
|
|
|
def __str__(self):
|
|
'''Return string representation.'''
|
|
keys = {}
|
|
for key, value in self.details.items():
|
|
if isinstance(value, str):
|
|
value = value.encode(sys.getfilesystemencoding())
|
|
keys[key] = value
|
|
|
|
return str(self.message.format(**keys))
|
|
|
|
|
|
class AuthenticationError(Error):
|
|
'''Raise when an authentication error occurs.'''
|
|
|
|
default_message = 'Authentication error.'
|
|
|
|
|
|
class ServerError(Error):
|
|
'''Raise when the server reports an error.'''
|
|
|
|
default_message = 'Server reported error processing request.'
|
|
|
|
|
|
class ServerCompatibilityError(ServerError):
|
|
'''Raise when server appears incompatible.'''
|
|
|
|
default_message = 'Server incompatible.'
|
|
|
|
|
|
class NotFoundError(Error):
|
|
'''Raise when something that should exist is not found.'''
|
|
|
|
default_message = 'Not found.'
|
|
|
|
|
|
class NotUniqueError(Error):
|
|
'''Raise when unique value required and duplicate detected.'''
|
|
|
|
default_message = 'Non-unique value detected.'
|
|
|
|
|
|
class IncorrectResultError(Error):
|
|
'''Raise when a result is incorrect.'''
|
|
|
|
default_message = 'Incorrect result detected.'
|
|
|
|
|
|
class NoResultFoundError(IncorrectResultError):
|
|
'''Raise when a result was expected but no result was found.'''
|
|
|
|
default_message = 'Expected result, but no result was found.'
|
|
|
|
|
|
class MultipleResultsFoundError(IncorrectResultError):
|
|
'''Raise when a single result expected, but multiple results found.'''
|
|
|
|
default_message = 'Expected single result, but received multiple results.'
|
|
|
|
|
|
class EntityTypeError(Error):
|
|
'''Raise when an entity type error occurs.'''
|
|
|
|
default_message = 'Entity type error.'
|
|
|
|
|
|
class UnrecognisedEntityTypeError(EntityTypeError):
|
|
'''Raise when an unrecognised entity type detected.'''
|
|
|
|
default_message = 'Entity type "{entity_type}" not recognised.'
|
|
|
|
def __init__(self, entity_type, **kw):
|
|
'''Initialise with *entity_type* that is unrecognised.'''
|
|
kw.setdefault('details', {}).update(dict(
|
|
entity_type=entity_type
|
|
))
|
|
super(UnrecognisedEntityTypeError, self).__init__(**kw)
|
|
|
|
|
|
class OperationError(Error):
|
|
'''Raise when an operation error occurs.'''
|
|
|
|
default_message = 'Operation error.'
|
|
|
|
|
|
class InvalidStateError(Error):
|
|
'''Raise when an invalid state detected.'''
|
|
|
|
default_message = 'Invalid state.'
|
|
|
|
|
|
class InvalidStateTransitionError(InvalidStateError):
|
|
'''Raise when an invalid state transition detected.'''
|
|
|
|
default_message = (
|
|
'Invalid transition from {current_state!r} to {target_state!r} state '
|
|
'for entity {entity!r}'
|
|
)
|
|
|
|
def __init__(self, current_state, target_state, entity, **kw):
|
|
'''Initialise error.'''
|
|
kw.setdefault('details', {}).update(dict(
|
|
current_state=current_state,
|
|
target_state=target_state,
|
|
entity=entity
|
|
))
|
|
super(InvalidStateTransitionError, self).__init__(**kw)
|
|
|
|
|
|
class AttributeError(Error):
|
|
'''Raise when an error related to an attribute occurs.'''
|
|
|
|
default_message = 'Attribute error.'
|
|
|
|
|
|
class ImmutableAttributeError(AttributeError):
|
|
'''Raise when modification of immutable attribute attempted.'''
|
|
|
|
default_message = (
|
|
'Cannot modify value of immutable {attribute.name!r} attribute.'
|
|
)
|
|
|
|
def __init__(self, attribute, **kw):
|
|
'''Initialise error.'''
|
|
kw.setdefault('details', {}).update(dict(
|
|
attribute=attribute
|
|
))
|
|
super(ImmutableAttributeError, self).__init__(**kw)
|
|
|
|
|
|
class CollectionError(Error):
|
|
'''Raise when an error related to collections occurs.'''
|
|
|
|
default_message = 'Collection error.'
|
|
|
|
def __init__(self, collection, **kw):
|
|
'''Initialise error.'''
|
|
kw.setdefault('details', {}).update(dict(
|
|
collection=collection
|
|
))
|
|
super(CollectionError, self).__init__(**kw)
|
|
|
|
|
|
class ImmutableCollectionError(CollectionError):
|
|
'''Raise when modification of immutable collection attempted.'''
|
|
|
|
default_message = (
|
|
'Cannot modify value of immutable collection {collection!r}.'
|
|
)
|
|
|
|
|
|
class DuplicateItemInCollectionError(CollectionError):
|
|
'''Raise when duplicate item in collection detected.'''
|
|
|
|
default_message = (
|
|
'Item {item!r} already exists in collection {collection!r}.'
|
|
)
|
|
|
|
def __init__(self, item, collection, **kw):
|
|
'''Initialise error.'''
|
|
kw.setdefault('details', {}).update(dict(
|
|
item=item
|
|
))
|
|
super(DuplicateItemInCollectionError, self).__init__(collection, **kw)
|
|
|
|
|
|
class ParseError(Error):
|
|
'''Raise when a parsing error occurs.'''
|
|
|
|
default_message = 'Failed to parse.'
|
|
|
|
|
|
class EventHubError(Error):
|
|
'''Raise when issues related to event hub occur.'''
|
|
|
|
default_message = 'Event hub error occurred.'
|
|
|
|
|
|
class EventHubConnectionError(EventHubError):
|
|
'''Raise when event hub encounters connection problem.'''
|
|
|
|
default_message = 'Event hub is not connected.'
|
|
|
|
|
|
class EventHubPacketError(EventHubError):
|
|
'''Raise when event hub encounters an issue with a packet.'''
|
|
|
|
default_message = 'Invalid packet.'
|
|
|
|
|
|
class PermissionDeniedError(Error):
|
|
'''Raise when permission is denied.'''
|
|
|
|
default_message = 'Permission denied.'
|
|
|
|
|
|
class LocationError(Error):
|
|
'''Base for errors associated with locations.'''
|
|
|
|
default_message = 'Unspecified location error'
|
|
|
|
|
|
class ComponentNotInAnyLocationError(LocationError):
|
|
'''Raise when component not available in any location.'''
|
|
|
|
default_message = 'Component not available in any location.'
|
|
|
|
|
|
class ComponentNotInLocationError(LocationError):
|
|
'''Raise when component(s) not in location.'''
|
|
|
|
default_message = (
|
|
'Component(s) {formatted_components} not found in location {location}.'
|
|
)
|
|
|
|
def __init__(self, components, location, **kw):
|
|
'''Initialise with *components* and *location*.'''
|
|
if isinstance(components, ftrack_api.entity.base.Entity):
|
|
components = [components]
|
|
|
|
kw.setdefault('details', {}).update(dict(
|
|
components=components,
|
|
formatted_components=', '.join(
|
|
[str(component) for component in components]
|
|
),
|
|
location=location
|
|
))
|
|
|
|
super(ComponentNotInLocationError, self).__init__(**kw)
|
|
|
|
|
|
class ComponentInLocationError(LocationError):
|
|
'''Raise when component(s) already exists in location.'''
|
|
|
|
default_message = (
|
|
'Component(s) {formatted_components} already exist in location '
|
|
'{location}.'
|
|
)
|
|
|
|
def __init__(self, components, location, **kw):
|
|
'''Initialise with *components* and *location*.'''
|
|
if isinstance(components, ftrack_api.entity.base.Entity):
|
|
components = [components]
|
|
|
|
kw.setdefault('details', {}).update(dict(
|
|
components=components,
|
|
formatted_components=', '.join(
|
|
[str(component) for component in components]
|
|
),
|
|
location=location
|
|
))
|
|
|
|
super(ComponentInLocationError, self).__init__(**kw)
|
|
|
|
|
|
class AccessorError(Error):
|
|
'''Base for errors associated with accessors.'''
|
|
|
|
default_message = 'Unspecified accessor error'
|
|
|
|
|
|
class AccessorOperationFailedError(AccessorError):
|
|
'''Base for failed operations on accessors.'''
|
|
|
|
default_message = 'Operation {operation} failed: {error}'
|
|
|
|
def __init__(
|
|
self, operation='', resource_identifier=None, error=None, **kw
|
|
):
|
|
kw.setdefault('details', {}).update(dict(
|
|
operation=operation,
|
|
resource_identifier=resource_identifier,
|
|
error=error
|
|
))
|
|
super(AccessorOperationFailedError, self).__init__(**kw)
|
|
|
|
|
|
class AccessorUnsupportedOperationError(AccessorOperationFailedError):
|
|
'''Raise when operation is unsupported.'''
|
|
|
|
default_message = 'Operation {operation} unsupported.'
|
|
|
|
|
|
class AccessorPermissionDeniedError(AccessorOperationFailedError):
|
|
'''Raise when permission denied.'''
|
|
|
|
default_message = (
|
|
'Cannot {operation} {resource_identifier}. Permission denied.'
|
|
)
|
|
|
|
|
|
class AccessorResourceIdentifierError(AccessorError):
|
|
'''Raise when a error related to a resource_identifier occurs.'''
|
|
|
|
default_message = 'Resource identifier is invalid: {resource_identifier}.'
|
|
|
|
def __init__(self, resource_identifier, **kw):
|
|
kw.setdefault('details', {}).update(dict(
|
|
resource_identifier=resource_identifier
|
|
))
|
|
super(AccessorResourceIdentifierError, self).__init__(**kw)
|
|
|
|
|
|
class AccessorFilesystemPathError(AccessorResourceIdentifierError):
|
|
'''Raise when a error related to an accessor filesystem path occurs.'''
|
|
|
|
default_message = (
|
|
'Could not determine filesystem path from resource identifier: '
|
|
'{resource_identifier}.'
|
|
)
|
|
|
|
|
|
class AccessorResourceError(AccessorError):
|
|
'''Base for errors associated with specific resource.'''
|
|
|
|
default_message = 'Unspecified resource error: {resource_identifier}'
|
|
|
|
def __init__(self, operation='', resource_identifier=None, error=None,
|
|
**kw):
|
|
kw.setdefault('details', {}).update(dict(
|
|
operation=operation,
|
|
resource_identifier=resource_identifier
|
|
))
|
|
super(AccessorResourceError, self).__init__(**kw)
|
|
|
|
|
|
class AccessorResourceNotFoundError(AccessorResourceError):
|
|
'''Raise when a required resource is not found.'''
|
|
|
|
default_message = 'Resource not found: {resource_identifier}'
|
|
|
|
|
|
class AccessorParentResourceNotFoundError(AccessorResourceError):
|
|
'''Raise when a parent resource (such as directory) is not found.'''
|
|
|
|
default_message = 'Parent resource is missing: {resource_identifier}'
|
|
|
|
|
|
class AccessorResourceInvalidError(AccessorResourceError):
|
|
'''Raise when a resource is not the right type.'''
|
|
|
|
default_message = 'Resource invalid: {resource_identifier}'
|
|
|
|
|
|
class AccessorContainerNotEmptyError(AccessorResourceError):
|
|
'''Raise when container is not empty.'''
|
|
|
|
default_message = 'Container is not empty: {resource_identifier}'
|
|
|
|
|
|
class StructureError(Error):
|
|
'''Base for errors associated with structures.'''
|
|
|
|
default_message = 'Unspecified structure error'
|
|
|
|
|
|
class ConnectionClosedError(Error):
|
|
'''Raise when attempt to use closed connection detected.'''
|
|
|
|
default_message = "Connection closed."
|