def translate_locale_component(locale, component, index, language=None):
if index == 1:
language = language or get_language()
location = first(
Location.select({
"location_type": "country",
"code": component
}))
if location is not None:
location_name = translations(location,
language=language,
discard_generic_translation=True)
if not location_name and language != "en":
location_name = translations(location,
"en",
discard_generic_translation=True)
return " - " + location_name
return base_translate_locale_component(locale,
component,
index,
language=language)
def get_audio_uri(file, encoding):
if isinstance(encoding, basestring):
# Format requested by file extension
if encoding.startswith("."):
# The source file already matches the requested file extension,
# use it as is
if file.file_extension == encoding:
return file.get_uri()
# Otherwise, use the first encoder that matches the given file
# extension
encoder = first(enc
for enc in Configuration.instance.audio_encoders
if enc.extension == encoding)
# Format requested by the user defined encoder ID (ie. mp3-128)
else:
encoder = AudioEncoder.require_instance(identifier=encoding)
else:
encoder = encoding
if encoder is None:
return None
else:
return "/audio/%d/%s%s" % (file.id, encoder.identifier,
encoder.extension)
def _process_record(self, record, parent=None, context=None):
from woost.extensions.locations.location import Location
context = context.copy() if context else {}
code = record["code"]
location = None
if "full_code" in context:
context["full_code"] += "-" + code
else:
context["full_code"] = code
if self._should_add_location(record, parent, context):
# Update an existing location
if parent:
location = first(child for child in parent.locations
if child.code == code)
else:
location = first(
Location.select([
Location.parent.equal(None),
Location.code.equal(code)
]))
# Create a new location
if location is None:
location = Location()
location.parent = parent
location.code = code
location.insert()
location.location_type = record["type"]
for lang, value in record["name"].iteritems():
if isinstance(value, str):
value = value.decode("utf-8")
location.set("location_name", value, lang)
# Process child records
children = record.get("locations")
if children:
for child_record in children:
self._process_record(child_record, location, context)
def create_configuration(self):
return self._create(
Configuration,
qname="woost.configuration",
secret_key=random_string(10),
default_language=self.languages[0],
languages=self.languages,
backoffice_language=first(
language for language in self.languages
if language in Configuration.backoffice_language.enumeration))
def normalization(self, value):
if isinstance(value, str):
country = first(
Location.select({
"location_type": "country",
"code": value.upper()
}))
if country is not None:
value = country
return value
def add_url_shortener_reference(e):
if e.source.enabled:
TwitterPublicationTarget.add_member(
schema.Reference(
"url_shortener",
shadows_attribute=True,
type=URLShortener,
related_end=schema.Collection(),
listed_by_default=False,
# Default to the first defined service, if one exists
default=schema.DynamicDefault(
lambda: first(URLShortener.select()))))
def _fix_value(self, target, member, value, error=None):
error = error or first(member.get_errors(value))
if error:
if self.errors == "raise":
raise error
elif self.errors == "set_none":
value = None
elif self.errors == "set_default":
value = member.produce_default(target)
return value
def by_abs_path(cls, path):
if not path or not path[0]:
raise ValueError(
"Location.by_abs_path() requires one or more location codes")
location = first(cls.select({"code": path[0], "parent": None}))
for x in path[1:]:
if location is None:
return None
location = location.get_child_location(x, recursive=False)
return location
def by_code(cls, *code):
if not code or not code[0]:
raise ValueError(
"Location.by_code() requires one or more location codes"
)
location = first(cls.select([Location.code.equal(code[0])]))
for x in code[1:]:
if location is None:
return None
location = location.get_child_location(x)
return location
def submit(self):
if self.action == "close":
self.go_back()
form_data = self.form_data
subset = form_data["subset"]
languages = set(form_data["published_languages"])
targets = form_data["publication_targets"]
check = (self.action == "check")
results = self.results
if check:
og = OpenGraphExtension.instance
for target in targets:
if check:
posts = target.feed_posts()
for publishable in subset:
for language in sorted(languages & set(target.languages)):
if check:
try:
with language_context(language):
uri = og.get_properties(publishable)["og:url"]
results.append((
publishable,
target,
language,
first(
post
for post in posts
if post.get("link") == uri
)
))
except Exception, ex:
results.append((publishable, target, language, ex))
else:
try:
with language_context(language):
target.publish(publishable)
except Exception, ex:
results.append((publishable, target, language, ex))
else:
results.append((publishable, target, language, None))
def by_path(cls, *path):
warn(
"Location.by_path is deprecated, use Location.by_full_path instead",
DeprecationWarning,
stacklevel=2)
if not path or not path[0]:
raise ValueError(
"Location.by_path() requires one or more location codes")
location = first(cls.select([Location.code.equal(path[0])]))
for x in path[1:]:
if location is None:
return None
location = location.get_child_location(x, recursive=False)
return location
def by_code(cls, *code):
warn(
"Location.by_code is deprecated, use Location.by_full_path instead",
DeprecationWarning,
stacklevel=2)
if not code or not code[0]:
raise ValueError(
"Location.by_code() requires one or more location codes")
location = first(cls.select([Location.code.equal(code[0])]))
for x in code[1:]:
if location is None:
return None
location = location.get_child_location(x)
return location
def get_cache_expiration_for_type(cls):
expiration = None
for member in cls.iter_members():
if member.affects_cache_expiration:
if isinstance(member, schema.Date):
threshold = date.today()
else:
threshold = datetime.now()
instance = first(
cls.select(member.greater(threshold),
order=member,
cached=False))
if instance is not None:
expiration = nearest_expiration(expiration,
instance.get(member))
return expiration
from cocktail import schema
from cocktail.html.datadisplay import display_factory
from cocktail.iteration import first
from .configuration import Configuration
from .rendering import ImageFactory
def _iter_block_image_factories():
for factory in Configuration.instance.image_factories:
if factory.applicable_to_blocks:
yield factory
def _block_image_factories_enumeration(ctx):
return list(_iter_block_image_factories())
_block_image_factories_default = schema.DynamicDefault(
lambda: first(_iter_block_image_factories())
)
_mandatory_dropdown = display_factory(
"cocktail.html.DropdownSelector",
empty_option_displayed = False
)
class BlockImageFactoryReference(schema.Reference):
def __init__(self, *args, **kwargs):
kwargs.setdefault("required", True)
kwargs.setdefault("type", ImageFactory)
kwargs.setdefault("enumeration", _block_image_factories_enumeration)
class ImageFactory(Item):
visible_from_root = False
members_order = [
"title", "identifier", "renderer", "default_format", "effects",
"fallback", "applicable_to_blocks"
]
title = schema.String(translated=True, descriptive=True)
identifier = schema.String(unique=True,
indexed=True,
normalized_index=False)
renderer = schema.Reference(
required=True,
type=Renderer,
related_end=schema.Collection(),
default=schema.DynamicDefault(lambda: first(_get_site_renderers())),
enumeration=lambda ctx: _get_site_renderers(),
edit_control="cocktail.html.DropdownSelector")
default_format = schema.String(
enumeration=["JPEG", "PNG", "GIF"],
translatable_enumeration=False,
edit_control="cocktail.html.DropdownSelector")
effects = schema.Collection(
items="woost.models.rendering.ImageEffect",
bidirectional=True,
integral=True,
)
fallback = schema.Reference(type="woost.models.rendering.ImageFactory",
bidirectional=True)
fallback_referers = schema.Collection(
items="woost.models.rendering.ImageFactory",
bidirectional=True,
visible=False,
synchronizable=False)
applicable_to_blocks = schema.Boolean(required=True,
default=True,
indexed=True)
def render(self, item):
image = self.renderer.render(item)
if image is None:
if self.fallback:
image = self.fallback.render(item)
else:
if self.effects:
if isinstance(image, basestring):
image = Image.open(image)
for effect in self.effects:
image = effect.apply(image)
return image
cache_invalidators = frozenset((identifier, renderer, effects, fallback))
@event_handler
def handle_changing(cls, e):
from woost.models.rendering.request \
import clear_image_cache_after_commit
if e.source.is_inserted and e.member in cls.cache_invalidators:
clear_image_cache_after_commit(factory=e.source)
for referer in e.source.fallback_referers:
clear_image_cache_after_commit(factory=referer)
@event_handler
def handle_related(cls, e):
from woost.models.rendering.request \
import clear_image_cache_after_commit
if e.source.is_inserted and e.member in cls.cache_invalidators:
clear_image_cache_after_commit(factory=e.source)
for referer in e.source.fallback_referers:
clear_image_cache_after_commit(factory=referer)
@event_handler
def handle_unrelated(cls, e):
from woost.models.rendering.request \
import clear_image_cache_after_commit
if e.source.is_inserted and e.member in cls.cache_invalidators:
clear_image_cache_after_commit(factory=e.source)
for referer in e.source.fallback_referers:
clear_image_cache_after_commit(factory=referer)
@event_handler
def handle_deleting(cls, e):
from woost.models.rendering.request \
import clear_image_cache_after_commit
clear_image_cache_after_commit(factory=e.source)
for referer in e.source.fallback_referers:
clear_image_cache_after_commit(factory=referer)
def instance(cls):
return first(cls.select())
