def __init__(self):
self.heading_style = deepcopy(self.heading_style)
self.regular_style = deepcopy(self.regular_style)
def joiner(glue):
return (lambda value: glue.join(
str(self.export_value(item)) for item in value))
multiline = joiner(u"\n")
def multiline_mapping(value):
return u"\n".join(u"%s: %s" % (k, v) for k, v in value.iteritems())
def multiline_count(value):
return u"\n".join(u"%s: %s" % (k, v)
for k, v in value.most_common())
self.type_exporters = TypeMapping(
((object, lambda value: str(value)), (str, None),
(type(None), lambda value: ""), (bool, None), (int, None),
(float, None), (Decimal, None), (tuple, joiner(u", ")),
(list, multiline), (set, multiline), (ListWrapper, multiline),
(SetWrapper, multiline), (Counter, multiline_count),
(dict, multiline_mapping), (DictWrapper, multiline_mapping)))
self.member_type_exporters = TypeMapping(
((Member, description_or_raw_value), ))
self.member_exporters = {}
self.member_column_types = {}
def __init__(self):
self.icon_repositories = [(resource_filename("woost.views",
"resources/images/icons"),
"/resources/images/icons")]
self.file_resolvers = TypeMapping()
self.file_resolvers[Item] = self._resolve_item
self.file_resolvers[Publishable] = self._resolve_publishable
self.file_resolvers[Document] = self._resolve_document
self.file_resolvers[File] = self._resolve_file
self.name_resolution_cache = ResourceLoader(load=self._find_icon)
class GenericMethod(object):
def __init__(self, default=None, name=None):
self.default = default
self.name = name
self.implementations = TypeMapping()
def __repr__(self):
if self.name:
return "%s <%s>" % (self.__class__.__name__, self.name)
else:
return self.__class__.__name__
def __call__(self, instance, *args, **kwargs):
impl = self.implementations.get(instance.__class__, self.default)
if impl is None:
raise TypeError("Can't find an implementation of %s for %s" %
(self, instance.__class__.__name__))
return impl(instance, *args, **kwargs)
def implementation_for(self, cls):
def decorator(function):
self.implementations[cls] = function
return function
return decorator
class VideoPlayerSettings(Item):
instantiable = True
visible_from_root = False
player_initialization = TypeMapping()
members_order = [
"title", "width", "height", "autoplay", "show_player_controls"
]
title = schema.String(
listed_by_default = False,
required = True,
unique = True,
indexed = True,
normalized_index = True,
full_text_indexed = True,
descriptive = True,
translated = True
)
width = schema.Integer(
required = True,
default = 480,
listed_by_default = False
)
height = schema.Integer(
required = True,
default = 385,
listed_by_default = False
)
autoplay = schema.Boolean(
required = True,
default = False,
listed_by_default = False
)
show_player_controls = schema.Boolean(
required = True,
default = True,
listed_by_default = False
)
def create_player(self, video):
player = templates.new(video.video_player)
player_initialization = self.player_initialization.get(video.__class__)
if player_initialization:
player_initialization(player, self, video)
return player
class GenericClassMethod(object):
def __init__(self, default):
self.default = default
self.implementations = TypeMapping()
def __call__(self, cls, *args, **kwargs):
impl = self.implementations.get(cls, self.default)
return impl(cls, *args, **kwargs)
def implementation_for(self, cls):
def decorator(function):
self.implementations[cls] = function
return function
return decorator
def __init__(self, default):
self.default = default
self.implementations = TypeMapping()
def __init__(self, default=None, name=None):
self.default = default
self.name = name
self.implementations = TypeMapping()
def __init__(self):
self._type_mapping = TypeMapping()
class ViewFactory(object):
_type_mapping = None
def __init__(self):
self._type_mapping = TypeMapping()
def _normalize_view(self, value, item, **parameters):
if isinstance(value, basestring):
view = templates.new(value)
view.item = item
elif isinstance(value, ViewFactory):
view = value.create_view(item, **parameters)
elif isinstance(value, type):
view = value()
view.item = item
elif callable(value):
view = value(item, parameters)
# Set any remaining parameters as attributes of the resulting view
if view:
for key, value in parameters.iteritems():
setattr(view, key, value)
return view
def create_view(self, item, **parameters):
view = None
for cls, handlers in self._type_mapping.iter_by_type(item.__class__):
for id, handler in handlers:
view = self._normalize_view(handler, item, **parameters)
if view is not None:
return view
raise ValueError("Can't create view for item: %s" % item)
def register(self, cls, id, handler):
handlers = self._type_mapping.get(cls, recursive=False)
if handlers is None:
handlers = []
self._type_mapping[cls] = handlers
handlers.append((id, handler))
def register_first(self, cls, id, handler):
handlers = self._type_mapping.get(cls, recursive=False)
if handlers is None:
handlers = []
self._type_mapping[cls] = handlers
handlers.insert(0, (id, handler))
def register_before(self, cls, anchor, id, handler):
handlers = self._type_mapping.get(cls, recursive=False)
if handlers is None:
handlers = []
self._type_mapping[cls] = handlers
new_handlers = []
added = False
for prev_id, prev_handler in handlers:
if prev_id == anchor:
new_handlers.append((id, handler))
added = True
new_handlers.append((prev_id, prev_handler))
self._type_mapping[cls] = new_handlers
if not added:
raise ValueError("Can't register %s before %s: "
"no such handler for type %s in %s" %
(id, anchor, cls, self))
def register_after(self, cls, anchor, id, handler):
handlers = self._type_mapping.get(cls, recursive=False)
if handlers is None:
handlers = []
self._type_mapping[cls] = handlers
new_handlers = []
added = False
for prev_id, prev_handler in handlers:
new_handlers.append((prev_id, prev_handler))
if prev_id == anchor:
new_handlers.append((id, handler))
added = True
self._type_mapping[cls] = new_handlers
if not added:
raise ValueError("Can't register %s after %s: "
"no such handler for type %s in %s" %
(id, anchor, cls, self))
def replace(self, cls, id, handler):
handlers = self._type_mapping.get(cls, recursive=False)
if handlers is None:
handlers = []
self._type_mapping[cls] = handlers
replaced = False
for i, handler_data in enumerate(handlers):
prev_id, prev_handler = handler_data
if prev_id == id:
handlers[i] = (id, handler)
replaced = True
break
if not replaced:
raise ValueError("Can't replace %s: "
"no such handler for type %s in %s" %
(id, cls, self))
def unregister(self, cls, id):
handlers = self._type_mapping.get(cls, recursive=False)
if handlers is None:
handlers = []
self._type_mapping[cls] = handlers
new_handlers = []
for prev_id, prev_handler in handlers:
if prev_id != id:
new_handlers.append((prev_id, prev_handler))
self._type_mapping[cls] = new_handlers
class IconResolver(object):
"""An object that chooses icons for CMS items.
@ivar icon_format: The image format that icons are stored in. Takes the
same values accepted by PIL images.
@type icon_format: str
@ivar icon_repositories: A list of the directory/URL tuples to search for
icons, in descending order of preference.
@type icon_repositories: str list
@ivar file_resolvers: A mapping of types and icon resolution functions.
This allows to override the icon resolution machinery for certain
content types. Resolution functions should take as parameters a content
type and (optionally) an item, and return a list of possible icon file
names that would be a match for them.
@type file_resolvers: (L{Item<woost.models.Item>} class, callable)
L{TypeMapping<cocktail.typemapping.TypeMapping>}
@ivar name_resolution_cache: A cache that stores the result of the
L{find_icon} method given a list of possible names produced by the
L{file_resolvers} mapping.
@type: L{ResourceLoader<cocktail.resourceloader.ResourceLoader>}
"""
icon_format = "png"
_icon_extension = None
icon_repositories = []
file_resolvers = None
name_resolution_cache = None
def __init__(self):
self.icon_repositories = [(resource_filename("woost.views",
"resources/images/icons"),
"/resources/images/icons")]
self.file_resolvers = TypeMapping()
self.file_resolvers[Item] = self._resolve_item
self.file_resolvers[Publishable] = self._resolve_publishable
self.file_resolvers[Document] = self._resolve_document
self.file_resolvers[File] = self._resolve_file
self.name_resolution_cache = ResourceLoader(load=self._find_icon)
def _get_icon_extension(self):
return self._icon_extension or self.icon_format
def _set_icon_extension(self, extension):
self._icon_extension = extension
icon_extension = property(
_get_icon_extension,
_set_icon_extension,
doc="""The file extension for icon files. If a explicit value is not
provided, it will be infered from L{icon_format}.
@type: str
""")
def find_icon(self, item, size):
"""Obtains the path to the icon file that best represents the indicated
CMS item or content type.
The default implementation searches for icons in the directories
specified by the L{icon_repositories} property, in order, returning the
first icon whose name matches the name of one of the item's classes.
Also, publishable items and files are special cased, to take their
resource and MIME types into account.
@param item: The item or content type to obtain the icon for.
@type item: L{Item<woost.models.Item>} instance or class
@param size: The size of the icon to look for, in pixels.
@type size: int
@return: The path to the best matching icon, or None if no matching
icon is found.
@rtype: str
"""
if isinstance(item, type):
content_type = item
item = None
else:
content_type = item.__class__
file_resolver = self.file_resolvers.get(content_type)
if file_resolver is not None:
file_names = file_resolver(content_type, item)
if file_names:
key = (size, tuple(file_names))
return self.name_resolution_cache.request(key)
return None
def find_icon_path(self, item, size):
match = self.find_icon(item, size)
if match:
return match[0]
def find_icon_url(self, item, size):
match = self.find_icon(item, size)
if match:
return match[1]
def _find_icon(self, key):
size, file_names = key
repositories = self.icon_repositories
size_str = "%dx%d" % (size, size)
icon_ext = "." + self.icon_extension
for repo_path, repo_url in repositories:
for file_name in file_names:
icon_path = os.path.join(repo_path, size_str,
file_name + icon_ext)
if os.path.exists(icon_path):
icon_url = "%s/%s/%s" % (repo_url.rstrip("/"), size_str,
file_name + icon_ext)
return (icon_path, icon_url)
return None
def _resolve_item(self, content_type, item):
return [
"type-" + cls.full_name.replace(".", "-")
for cls in content_type.ascend_inheritance(True)
if cls is not PersistentObject
]
def _resolve_publishable(self, content_type, item):
file_names = self._resolve_item(content_type, item)
if item is not None:
# Use a distinct icon for home pages
if item.is_home_page():
file_names.insert(0, "home")
# Apply icons based on the item's resource type (but icons for
# subclasses of Publishable / File still take precedence)
try:
pos = file_names.index("type-woost-models-file-File")
except ValueError:
pos = file_names.index(
"type-woost-models-publishable-Publishable")
if item.resource_type:
file_names.insert(pos, "resource-type-" + item.resource_type)
return file_names
def _resolve_document(self, content_type, item):
file_names = self._resolve_publishable(content_type, item)
if item is not None and item.redirection_mode:
file_names.insert(0, "redirection")
return file_names
def _resolve_file(self, content_type, item):
file_names = self._resolve_publishable(content_type, item)
if item is not None and item.mime_type:
mime = item.mime_type.replace("/", "-").replace(".", "-")
file_names.insert(0, "mime-" + mime)
return file_names
class Exporter:
heading_style = {"font": Font(bold=True)}
regular_style = {}
def __init__(self):
self.heading_style = deepcopy(self.heading_style)
self.regular_style = deepcopy(self.regular_style)
def joiner(glue):
return (lambda value: glue.join(
str(self.export_value(item)) for item in value))
multiline = joiner(u"\n")
def multiline_mapping(value):
return u"\n".join(u"%s: %s" % (k, v) for k, v in value.iteritems())
def multiline_count(value):
return u"\n".join(u"%s: %s" % (k, v)
for k, v in value.most_common())
self.type_exporters = TypeMapping(
((object, lambda value: str(value)), (str, None),
(type(None), lambda value: ""), (bool, None), (int, None),
(float, None), (Decimal, None), (tuple, joiner(u", ")),
(list, multiline), (set, multiline), (ListWrapper, multiline),
(SetWrapper, multiline), (Counter, multiline_count),
(dict, multiline_mapping), (DictWrapper, multiline_mapping)))
self.member_type_exporters = TypeMapping(
((Member, description_or_raw_value), ))
self.member_exporters = {}
self.member_column_types = {}
def get_member_is_translated(self, member: Member) -> bool:
return member.translated
def get_columns(self, members: Sequence[Member],
languages: Sequence[str]) -> Sequence["Column"]:
columns = []
for member in members:
columns.extend(self.get_member_columns(member, languages))
return columns
def get_member_columns(self, member: Member,
languages: Sequence[str]) -> Sequence["Column"]:
column_type = (self.member_column_types.get(member) or MemberColumn)
if self.get_member_is_translated(member):
for language in languages:
yield column_type(self, member, language)
else:
yield column_type(self, member)
def get_member_heading(self, member: Member, language: str) -> str:
if language:
return u"%s (%s)" % (translations(member),
translate_locale(language))
else:
return translations(member)
def export_member_value(self,
obj: SchemaObject,
member: Member,
value: Any,
language: str = None) -> Any:
exporter = self.member_exporters.get(member.name)
if exporter is None:
exporter = self.member_type_exporters.get(member.__class__)
if exporter is not None:
value = exporter(obj, member, value, language)
return value
def export_value(self, value: Any) -> str:
exporter = self.type_exporters.get(value.__class__)
if exporter is None:
return value
else:
return exporter(value)
def create_workbook(self,
objects: Iterable[SchemaObject],
members: Sequence[Member] = None,
languages: Sequence[str] = None):
workbook = Workbook(write_only=True)
sheet = workbook.create_sheet()
if languages is None:
languages = [get_language()]
# Determine columns
columns = self.get_columns(members, languages)
# Column headings
header = []
for column in columns:
cell = WriteOnlyCell(sheet, value=column.heading)
self.apply_style(cell, column.heading_style or self.heading_style)
header.append(cell)
sheet.append(header)
# Cells
for obj in objects:
row = []
for column in columns:
cell_value = self.export_value(column.get_cell_value(obj))
cell = WriteOnlyCell(sheet, value=cell_value)
self.apply_style(
cell,
column.get_cell_style(obj) or self.regular_style)
row.append(cell)
sheet.append(row)
return workbook
def apply_style(self, cell: WriteOnlyCell, style: Mapping):
for key, value in style.items():
setattr(cell, key, value)