def format(self, license, work_dict=None, locale='en'):
gettext = ugettext_for_locale(locale)
work_dict = work_dict or {}
work_title = work_dict.get('work_title', False)
actor_href = work_dict.get('actor_href', '').strip()
actor = work_dict.get('name', '').strip()
template = TEMPLATE_ENV.get_template('cc0.html')
work_jurisdiction = work_dict.get('work_jurisdiction')
country_name = None
if work_jurisdiction not in ('', '-', None, False):
if work_jurisdiction.lower() in mappers.COUNTRY_MAP:
country_name = gettext(
mappers.COUNTRY_MAP[work_jurisdiction.lower()])
# Crappy fallback to this CSV. We should homogenize these
# things...
elif work_jurisdiction.upper() in util.CODE_COUNTRY_MAP:
country_name = gettext(
util.CODE_COUNTRY_MAP[work_jurisdiction.upper()])
rendered_template = template.render(
{"gettext": gettext,
"license": license,
"actor": actor,
"actor_href": actor_href,
"work_jurisdiction": work_jurisdiction,
"publisher": actor_href or "[_:publisher]",
"country_name": country_name,
"work_title": work_title,
"form": work_dict})
return util.remove_blank_lines(rendered_template)
def send_license_info_email(license_title, license_html,
recipient_email, locale):
"""
Send license information email to a user.
Arguments:
- license_title: title of the license
- license_html: copy-paste license HTML
- recipient_email: the user that is getting this email
- locale: language email should be sent in
Returns:
A boolean specifying whether or not the email sent successfully
"""
gettext = ugettext_for_locale(locale)
email_body = gettext(LICENSE_INFO_EMAIL_BODY) % {
'license_title': license_title,
'license_html': license_html}
try:
send_email(
'*****@*****.**', [recipient_email],
translate(
LICENSE_INFO_EMAIL_SUBJECT,
target_language=negotiate_locale(locale)),
email_body)
return True
except smtplib.SMTPException:
return False
def cctrans(locale, logical_key, **trans_values):
"""
A method for translating via logical keys
"""
ugettext = ugettext_for_locale(locale)
return string.Template(ugettext(logical_key)).substitute(
trans_values)
def format(self, license, work_dict=None, locale='en'):
work_dict = work_dict or {}
gettext = ugettext_for_locale(locale)
dctype = None
if work_dict.get('format'):
dctype = _translate_dctype(work_dict['format'].lower())
image_header = IMAGE_HEADER_TEMPLATE % {
'license_url':
license.uri,
'util.Creative_Commons_License':
util.escape(gettext(u'Creative Commons License')),
'license_logo':
license.logo
}
body_template = gettext(
u'This %(work_type)s is in the '
u'<a rel="license" href="http://creativecommons.org/licenses/publicdomain/">Public Domain</a>.'
)
body_vars = {'work_type': process_work_type(gettext, dctype)}
message = image_header + body_template % body_vars
return message
def legalcodes(self, language='en'):
"""
Return a list of
[(legalcode_uri, legalcode_lang, legalcode_lang_translated)]
for this license.
If this is a single-legalcode option, it'll probably return
[(legalcode_uri, None, None)]
"""
if self._legalcodes.has_key(language):
return self._legalcodes[language]
gettext = ugettext_for_locale(language)
legalcodes = set()
for legalcode, lang in rdf_helper.get_license_legalcodes(self.uri):
if lang is None:
translated_lang = None
# <terrible_fixable_hacks>
# We should probably add lang.sr_CYRL and lang.sr_LATN messages
elif lang == 'sr-Cyrl':
translated_lang = gettext('Serbian')
elif lang == 'sr-Latn':
translated_lang = 'srpski (latinica)'
# </terrible_fixable_hacks>
else:
translated_lang = gettext(
mappers.LANG_MAP[locale_to_lower_upper(lang)])
legalcodes.add((legalcode, lang, translated_lang))
self._legalcodes[language] = legalcodes
return legalcodes
def active_languages():
"""Return a sequence of dicts, where each element consists of the
following keys:
* code: the language code
* name: the translated name of this language
for each available language."""
global _ACTIVE_LANGUAGES
if _ACTIVE_LANGUAGES:
return _ACTIVE_LANGUAGES
# get a list of avaialable translations
domain = base.queryUtility(ITranslationDomain,
ccorg_i18n_setup.I18N_DOMAIN)
lang_codes = set(domain.getCatalogsInfo().keys())
# determine the intersection of available translations and
# launched jurisdiction locales
launched_locales = set()
jurisdictions = cclicense_functions.get_valid_jurisdictions()
for jurisdiction in jurisdictions:
query_string = ('PREFIX dc: <http://purl.org/dc/elements/1.1/> '
'SELECT ?lang WHERE {'
' <%s> dc:language ?lang}') % jurisdiction
query = RDF.Query(str(query_string), query_language='sparql')
this_juri_locales = set([
locale_to_lower_upper(str(result['lang']))
for result in query.execute(rdf_helper.JURI_MODEL)
])
# Append those locales that are applicable to this domain
launched_locales.update(lang_codes.intersection(this_juri_locales))
# XXX: Have to hack in Esperanto here because it's technically an
# "Unported" language but there is no unported RDF jurisdiction in
# jurisdictions.rdf..
launched_locales.add('eo')
# make our sequence have a predictable order
launched_locales = list(launched_locales)
# this loop is long hand for clarity; it's only done once, so
# the additional performance cost should be negligible
result = []
for code in launched_locales:
if code == 'test': continue
gettext = ugettext_for_locale(negotiate_locale(code))
name = gettext(mappers.LANG_MAP[code])
result.append(dict(code=code, name=name))
result = sorted(result, key=lambda lang: lang['name'].lower())
_ACTIVE_LANGUAGES = result
return result
def send_license_info_email(license_title, license_html, recipient_email,
locale):
"""
Send license information email to a user.
Arguments:
- license_title: title of the license
- license_html: copy-paste license HTML
- recipient_email: the user that is getting this email
- locale: language email should be sent in
Returns:
A boolean specifying whether or not the email sent successfully
"""
gettext = ugettext_for_locale(locale)
email_body = gettext(LICENSE_INFO_EMAIL_BODY) % {
'license_title': license_title,
'license_html': license_html
}
try:
send_email(
'*****@*****.**', [recipient_email],
translate(LICENSE_INFO_EMAIL_SUBJECT,
target_language=negotiate_locale(locale)), email_body)
return True
except smtplib.SMTPException:
return False
def get_well_translated_langs(threshold=TRANSLATION_THRESHOLD,
trans_file=DEFAULT_CSV_FILE,
append_english=True):
"""
Get an alphebatized and name-rendered list of all languages above
a certain threshold of translation.
Keyword arguments:
- threshold: percentage that languages should be translated at or above
- trans_file: specify from which CSV file we're gathering statistics.
Used for testing, You probably don't need this.
- append_english: Add English to the list, even if it's completely
"untranslated" (since English is the default for messages,
nobody translates it)
Returns:
An alphebatized sequence of dicts, where each element consists
of the following keys:
- code: the language code
- name: the translated name of this language
for each available language.
An unsorted set of all qualified language codes
"""
from cc.i18n import mappers
cache_key = (threshold, trans_file, append_english)
if CACHED_WELL_TRANSLATED_LANGS.has_key(cache_key):
return CACHED_WELL_TRANSLATED_LANGS[cache_key]
trans_stats = get_all_trans_stats(trans_file)
qualified_langs = set([
lang for lang, data in trans_stats.iteritems()
if data['percent_trans'] >= threshold])
# Add english if necessary.
if not 'en' in qualified_langs and append_english:
qualified_langs.add('en')
# this loop is long hand for clarity; it's only done once, so
# the additional performance cost should be negligible
result = []
for code in qualified_langs:
from cc.i18n.gettext_i18n import ugettext_for_locale
gettext = ugettext_for_locale(code)
if code in mappers.LANG_MAP:
# we have a translation for this name...
name = gettext(mappers.LANG_MAP[code])
result.append(dict(code=code, name=name))
result = sorted(result, key=lambda lang: lang['name'].lower())
CACHED_WELL_TRANSLATED_LANGS[cache_key] = result
return result
def _base_context(request, target_lang=None):
context = {
"request": request,
"target_lang": (target_lang or util.get_target_lang_from_request(request)),
"gettext": ugettext_for_locale(target_lang),
"active_languages": get_well_translated_langs(),
}
context.update(util.rtl_context_stuff(target_lang))
return context
def test_compile_mo_files():
"""
Test that compile_mo_files compiles translations which actually
have the appropriate output
"""
output_dir = tempfile.mkdtemp()
fake_podir = pkg_resources.resource_filename('cc.i18n.tests', 'fake_podir')
compile_mo_files(fake_podir, output_dir)
expected_translations = {
'en': {
'New Zealand':
'New Zealand',
'Sampling':
'Sampling',
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.'):
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.')
},
'pt': {
'New Zealand':
'Nova Zel\xc3\xa2ndia',
'Sampling':
'Sampling',
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.'):
('A obra %(work_title)s de %(work_author)s '
'foi licenciada com uma Licen\xc3\xa7a '
'<a rel="license" href="%(license_url)s">Creative Commons - '
'%(license_name)s</a>.')
},
'es': {
'New Zealand':
'Nueva Zelanda',
'Sampling':
'Sampling',
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.'):
('%(work_title)s por %(work_author)s '
'se encuentra bajo una Licencia '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s</a>.')
}
}
for language, expected_translations in expected_translations.iteritems():
gettext = ugettext_for_locale(language, output_dir)
for msgid, expected_translation in expected_translations.iteritems():
assert gettext(msgid) == expected_translation.decode('utf-8')
def _base_context(request, target_lang=None):
context = {
'request': request,
'target_lang': (target_lang
or util.get_target_lang_from_request(request)),
'gettext': ugettext_for_locale(target_lang),
'active_languages': get_well_translated_langs(),
}
context.update(util.rtl_context_stuff(target_lang))
return context
def _base_context(request, target_lang=None):
context = {
'request': request,
'target_lang': (
target_lang
or util.get_target_lang_from_request(request)),
'gettext': ugettext_for_locale(target_lang),
'active_languages': get_well_translated_langs(),
}
context.update(util.rtl_context_stuff(target_lang))
return context
def render(template, context, locale=None):
if locale:
set_locale(locale)
jinja = render_jinja(
TEMPLATE_PATH,
globals={'gettext' : ugettext_for_locale(LOCALE)},
extensions=['jinja2.ext.i18n'],
encoding='utf-8',
)
jinja._lookup.filters.update(TEMPLATE_FILTERS)
template = jinja._lookup.get_template(template)
return template.render(**context)
def description(self, language='en'):
if language == '':
language = 'en' # why not?
gettext = ugettext_for_locale(language)
return gettext("""\
Use the option "International" if you desire a license using language
and terminology from international treaties. If the licenses have
been ported to your jurisdiction and you feel that your jurisdiction's
ported licenses account for some aspect of local legislation that the
international licenses do not, then you may want to consider
<a href="http://wiki.creativecommons.org/Frequently_Asked_Questions#Should_I_choose_an_international_license_or_a_ported_license.3F">which
license is better suited for your needs</a>.""")
def description(self, language='en'):
if language == '':
language = 'en' # why not?
gettext = ugettext_for_locale(language)
return gettext(
"""\
Use the option "International" if you desire a license using language
and terminology from international treaties. If the licenses have
been ported to your jurisdiction and you feel that your jurisdiction's
ported licenses account for some aspect of local legislation that the
international licenses do not, then you may want to consider
<a href="http://wiki.creativecommons.org/Frequently_Asked_Questions#Should_I_choose_an_international_license_or_a_ported_license.3F">which
license is better suited for your needs</a>.""")
def convert_file(filename):
gettext = ugettext_for_locale('en')
graph = load_graph(os.path.abspath(filename))
for subject, predicate, obj in graph.triples((
None, None, None)):
if hasattr(obj, 'language') and obj.language == 'i18n':
graph.remove((subject, predicate, obj))
new_obj = Literal(
TRANSLATION_BIT_RE.sub(
lambda x: '${' + gettext(x.groups()[0]) + '}',
str(obj)),
lang='i18n')
graph.add((subject, predicate, new_obj))
save_graph(graph, os.path.abspath(filename))
def get_xmp_info(request_form, license, locale):
ugettext = ugettext_for_locale(locale)
# assemble the necessary information for the XMP file before rendering
year = ('field_year' in request_form and request_form['field_year']) or ""
creator = ('field_creator' in request_form
and request_form['field_creator']) or None
work_type = workType(
('field_format' in request_form and request_form['field_format'])
or "")
work_url = ('field_url' in request_form
and request_form['field_url']) or None
# determine the license notice
if ('publicdomain' in license.uri):
notice = "This %s is dedicated to the public domain." % (work_type)
copyrighted = False
else:
if creator:
notice = "Copyright %s %s. " % (
year,
creator,
)
else:
notice = ""
i18n_work = ugettext('work')
work_notice_template = ugettext(
u'This %(work_type)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
work_notice = work_notice_template % {
'license_name': license.title(locale_to_lower_lower(locale)),
'license_url': license.uri,
'work_type': i18n_work
}
notice = notice + work_notice
copyrighted = True
return {
'copyrighted': copyrighted,
'notice': notice,
'license_url': license.uri,
'license': license,
'work_url': work_url
}
def test_compile_mo_files():
"""
Test that compile_mo_files compiles translations which actually
have the appropriate output
"""
output_dir = tempfile.mkdtemp()
fake_podir = pkg_resources.resource_filename(
'cc.i18n.tests', 'fake_podir')
compile_mo_files(fake_podir, output_dir)
expected_translations = {
'en': {
'New Zealand': 'New Zealand',
'Sampling': 'Sampling',
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.'):
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.')},
'pt': {
'New Zealand': 'Nova Zel\xc3\xa2ndia',
'Sampling': 'Sampling',
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.'):
('A obra %(work_title)s de %(work_author)s '
'foi licenciada com uma Licen\xc3\xa7a '
'<a rel="license" href="%(license_url)s">Creative Commons - '
'%(license_name)s</a>.')},
'es': {
'New Zealand': 'Nueva Zelanda',
'Sampling': 'Sampling',
('%(work_title)s by %(work_author)s is licensed under a '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s License</a>.'):
('%(work_title)s por %(work_author)s '
'se encuentra bajo una Licencia '
'<a rel="license" href="%(license_url)s">Creative Commons '
'%(license_name)s</a>.')}}
for language, expected_translations in expected_translations.iteritems():
gettext = ugettext_for_locale(language, output_dir)
for msgid, expected_translation in expected_translations.iteritems():
assert gettext(msgid) == expected_translation.decode('utf-8')
def render_template(request, locale, template_path, context):
"""
Render a template with the request in the response.
Also stores data for unit testing purposes if appropriate.
"""
template = TEMPLATE_ENV.get_template(template_path)
context['request'] = request
context['locale'] = locale
if not 'gettext' in context:
context['gettext'] = ugettext_for_locale(locale)
rendered = template.render(context)
if TESTS_ENABLED:
TEST_TEMPLATE_CONTEXT[template_path] = context
return rendered
def render_template(request, locale, template_path, context):
"""
Render a template with the request in the response.
Also stores data for unit testing purposes if appropriate.
"""
template = TEMPLATE_ENV.get_template(template_path)
context['request'] = request
context['locale'] = locale
if not 'gettext' in context:
context['gettext'] = ugettext_for_locale(locale)
rendered = template.render(context)
if TESTS_ENABLED:
TEST_TEMPLATE_CONTEXT[template_path] = context
return rendered
def get_xmp_info(request_form, license, locale):
ugettext = ugettext_for_locale(locale)
# assemble the necessary information for the XMP file before rendering
year = ('field_year' in request_form and
request_form['field_year']) or ""
creator = ('field_creator' in request_form and
request_form['field_creator']) or None
work_type = workType(('field_format' in request_form and
request_form['field_format']) or "")
work_url = ('field_url' in request_form and
request_form['field_url']) or None
# determine the license notice
if ('publicdomain' in license.uri):
notice = "This %s is dedicated to the public domain." % (work_type)
copyrighted = False
else:
if creator:
notice = "Copyright %s %s. " % (year, creator,)
else:
notice = ""
i18n_work = ugettext('work')
work_notice_template = ugettext(
u'This %(work_type)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
work_notice = work_notice_template % {
'license_name': license.title(locale_to_lower_lower(locale)),
'license_url': license.uri,
'work_type': i18n_work}
notice = notice + work_notice
copyrighted = True
return {
'copyrighted': copyrighted,
'notice':notice,
'license_url':license.uri,
'license':license,
'work_url':work_url}
def answers(self, language='en'):
if language == '':
language = 'en' # why not?
gettext = ugettext_for_locale(language)
answers = []
for jurisdiction in self._jurisdictions:
# Answers format is
# (label, id/key, description)
# And jurisdictions don't need a description ;)
juris_code = str(jurisdiction.rstrip('/').split('/')[-1])
answers.append((gettext(mappers.COUNTRY_MAP[juris_code.lower()]),
juris_code, None))
answers = sorted(answers, key=lambda answer: answer[1])
if answers:
answers = [(gettext('International'), '', None)] + answers
return answers
def answers(self, language='en'):
if language == '':
language = 'en' # why not?
gettext = ugettext_for_locale(language)
answers = []
for jurisdiction in self._jurisdictions:
# Answers format is
# (label, id/key, description)
# And jurisdictions don't need a description ;)
juris_code = str(jurisdiction.rstrip('/').split('/')[-1])
answers.append(
(gettext(mappers.COUNTRY_MAP[juris_code.lower()]),
juris_code, None))
answers = sorted(answers, key=lambda answer: answer[1])
if answers:
answers = [(gettext('International'), '', None)] + answers
return answers
def inverse_translate(string, target_language, domain='cc_org'):
"""
Translate something like "Foo ${bar} baz", where we actually
preserve "Foo " and " baz" and translate "${bar} (using "bar" as
the msgid)
>>> from cc.i18n import ccorg_i18n_setup
>>> translated_string = inverse_translate(
... 'foo ${country.pt} baz ${license.GPL_name_full}',
... target_language='en_US')
>>> translated_string == 'foo Portugal baz GNU General Public License'
"""
gettext = ugettext_for_locale(target_language)
string = unicode_cleaner(string)
translated_string = u''
last_pos = 0
for match in TRANSLATION_BIT_RE.finditer(string):
translated_string += string[last_pos:match.start()]
msgid = match.group(1)
translated_string += gettext(msgid)
last_pos = match.end()
translated_string += string[last_pos:]
return translated_string
def format(self, license, work_dict=None, locale='en'):
work_dict = work_dict or {}
gettext = ugettext_for_locale(locale)
dctype = None
if work_dict.get('format'):
dctype = _translate_dctype(work_dict['format'].lower())
image_header = IMAGE_HEADER_TEMPLATE % {
'license_url': license.uri,
'util.Creative_Commons_License': util.escape(gettext(
u'Creative Commons License')),
'license_logo': license.logo}
body_template = gettext(
u'This %(work_type)s is in the '
u'<a rel="license" href="http://creativecommons.org/licenses/publicdomain/">Public Domain</a>.')
body_vars = {'work_type': process_work_type(gettext, dctype)}
message = image_header + body_template % body_vars
return message
def inverse_translate(string, target_language, domain='cc_org'):
"""
Translate something like "Foo ${bar} baz", where we actually
preserve "Foo " and " baz" and translate "${bar} (using "bar" as
the msgid)
>>> from cc.i18n import ccorg_i18n_setup
>>> translated_string = inverse_translate(
... 'foo ${country.pt} baz ${license.GPL_name_full}',
... target_language='en_US')
>>> translated_string == 'foo Portugal baz GNU General Public License'
"""
gettext = ugettext_for_locale(target_language)
string = unicode_cleaner(string)
translated_string = u''
last_pos = 0
for match in TRANSLATION_BIT_RE.finditer(string):
translated_string += string[last_pos:match.start()]
msgid = match.group(1)
translated_string += gettext(msgid)
last_pos = match.end()
translated_string += string[last_pos:]
return translated_string
def legalcodes(self, language='en'):
"""
Return a list of
[(legalcode_uri, legalcode_lang, legalcode_lang_translated)]
for this license.
If this is a single-legalcode option, it'll probably return
[(legalcode_uri, None, None)]
"""
if self._legalcodes.has_key(language):
return self._legalcodes[language]
gettext = ugettext_for_locale(language)
legalcodes = set()
for legalcode, lang in rdf_helper.get_license_legalcodes(self.uri):
if lang is None:
translated_lang = None
# <terrible_fixable_hacks>
# We should probably add lang.sr_CYRL and lang.sr_LATN messages
elif lang == 'sr-Cyrl':
translated_lang = gettext('Serbian')
elif lang == 'sr-Latn':
translated_lang = 'srpski (latinica)'
# </terrible_fixable_hacks>
else:
translated_lang = gettext(
mappers.LANG_MAP[locale_to_lower_upper(lang)])
legalcodes.add(
(legalcode, lang, translated_lang))
self._legalcodes[language] = legalcodes
return legalcodes
def format(self, license, work_dict=None, locale='en'):
gettext = ugettext_for_locale(locale)
work_dict = work_dict or {}
work_title = work_dict.get('work_title', False)
actor_href = work_dict.get('actor_href', '').strip()
actor = work_dict.get('name', '').strip()
template = TEMPLATE_ENV.get_template('cc0.html')
work_jurisdiction = work_dict.get('work_jurisdiction')
country_name = None
if work_jurisdiction not in ('', '-', None, False):
if work_jurisdiction.lower() in mappers.COUNTRY_MAP:
country_name = gettext(
mappers.COUNTRY_MAP[work_jurisdiction.lower()])
# Crappy fallback to this CSV. We should homogenize these
# things...
elif work_jurisdiction.upper() in util.CODE_COUNTRY_MAP:
country_name = gettext(
util.CODE_COUNTRY_MAP[work_jurisdiction.upper()])
rendered_template = template.render({
"gettext": gettext,
"license": license,
"actor": actor,
"actor_href": actor_href,
"work_jurisdiction": work_jurisdiction,
"publisher": actor_href or "[_:publisher]",
"country_name": country_name,
"work_title": work_title,
"form": work_dict
})
return util.remove_blank_lines(rendered_template)
try:
import json
except ImportError:
import simplejson as json
LOCALE = 'en_US'
TEMPLATE_PATH = os.path.join(os.path.dirname(__file__), 'templates')
__all__ = ['set_locale', 'render', 'response']
def set_locale(locale):
global LOCALE
LOCALE = locale
TEMPLATE_GLOBALS = {
'gettext' : ugettext_for_locale(LOCALE),
}
TEMPLATE_FILTERS = {
'get_permissions_link': get_permissions_link,
'add_qs_parameter': add_qs_parameter,
}
def render(template, context, locale=None):
if locale:
set_locale(locale)
jinja = render_jinja(
TEMPLATE_PATH,
globals={'gettext' : ugettext_for_locale(LOCALE)},
extensions=['jinja2.ext.i18n'],
encoding='utf-8',
def label(self, language='en'):
if language == '':
language = 'en' # why not?
gettext = ugettext_for_locale(language)
return gettext("Jurisdiction of your license")
def format(self, license, work_dict=None, locale='en'):
"""
Return an HTML + RDFa string of text for the license.
work_dict takes the following keys:
- work_title: Name of the work
- author_title: Original author of the work
- author_href: Link to the original author of the work
- curator_title: The person who identified this work
- curator_href: Link to the person who identified this work
- waive_cc0: Whether the author has also waived their rights
under CC0 (boolean)
"""
gettext = ugettext_for_locale(locale)
# Property gathering
# ------------------
work_dict = work_dict or {}
work_title = work_dict.get('work_title', False)
author_title = work_dict.get('author_title', '').strip()
author_href = work_dict.get('author_href', '').strip()
curator_title = work_dict.get('curator_title', '').strip()
curator_href = work_dict.get('curator_href', '').strip()
waive_cc0 = work_dict.get('waive_cc0', False)
# Find the "body" template
# ------------------------
has_author = bool(author_title or author_href)
has_curator = bool(curator_title or curator_href)
# All (work_title and author and curator)
if work_title and has_author and has_curator:
body_msg = PDMARK_WORKTITLE_AUTHOR_CURATOR
# Only work_title
elif work_title and not has_author and not has_curator:
body_msg = PDMARK_WORKTITLE
# Only author
elif has_author and not work_title and not has_curator:
body_msg = PDMARK_AUTHOR
# Only curator
elif has_curator and not work_title and not has_author:
body_msg = PDMARK_CURATOR
# work_title and author
elif work_title and has_author and not has_curator:
body_msg = PDMARK_WORKTITLE_AUTHOR
# work_title and curator
elif work_title and has_curator and not has_author:
body_msg = PDMARK_WORKTITLE_CURATOR
# author and curator
elif has_author and has_curator and not work_title:
body_msg = PDMARK_AUTHOR_CURATOR
# plain
else:
body_msg = PDMARK_PLAIN
# Translate the body
# ------------------
mapping = {}
if work_title:
mapping['work_title'] = u'<span property="dct:title">%s</span>' % (
util.escape(work_title))
if has_author:
if author_title and author_href:
mapping['author'] = PDMARK_AUTHOR_LINK % (
{
'author_title': util.escape(author_title),
'author_href': util.escape(author_href)
})
elif author_title and not author_href:
mapping['author'] = PDMARK_AUTHOR_NOLINK % ({
'author_title':
util.escape(author_title)
})
elif author_href and not author_title:
mapping['author'] = PDMARK_AUTHOR_ONLYLINK % ({
'author_href':
util.escape(author_href)
})
if has_curator:
if curator_title and curator_href:
mapping['curator'] = PDMARK_CURATOR_LINK % (
{
'curator_title': util.escape(curator_title),
'curator_href': util.escape(curator_href)
})
elif curator_title and not curator_href:
mapping['curator'] = PDMARK_CURATOR_NOLINK % ({
'curator_title':
util.escape(curator_title)
})
elif curator_href and not curator_title:
mapping['curator'] = PDMARK_CURATOR_ONLYLINK % ({
'curator_href':
util.escape(curator_href)
})
body = gettext(body_msg) % mapping
# Add the header and footers
# --------------------------
output_sections = []
# XXX: Norms guidelines may affect opening <p>?
if work_title or has_author or has_curator:
output_sections.append(
u'<p xmlns:dct="http://purl.org/dc/terms/">')
else:
output_sections.append(u'<p>')
# Add logos
output_sections.append(PDMARK_LOGO_HTML)
if waive_cc0:
output_sections.append(CC0_LOGO_HTML)
output_sections.append(u'<br />')
# Add body
output_sections.append(body)
# Add footer
output_sections.append(u'</p>')
return u'\n'.join(output_sections)
# To the extent possible under law, the author(s) have dedicated all
# copyright and related and neighboring rights to this software to the
# public domain worldwide. This software is distributed without any
# warranty.
#
# You should have received a copy of the CC0 Public Domain Dedication along
# with this software. If not, see
# <http://creativecommons.org/publicdomain/zero/1.0/>.
import re
import sys
from cc.i18n import gettext_i18n
gettext = gettext_i18n.ugettext_for_locale('en')
def countspace(some_str):
"""Count leading whitespace"""
counter = 0
for char in some_str:
if char == " ":
counter += 1
else:
break
return counter
def nicer_args(args):
arglines = args.strip().splitlines()
def format(self, license, work_dict=None, locale='en'):
"""Return an HTML + RDFa string serialization for the license,
optionally incorporating the work metadata and locale."""
gettext = ugettext_for_locale(locale)
work_dict = work_dict or {}
image_header = IMAGE_HEADER_TEMPLATE % {
'license_url':
license.uri,
'util.Creative_Commons_License':
util.escape(gettext(u'Creative Commons License')),
'license_logo':
license.logo
}
dctype = None
if work_dict.get('format'):
dctype = _translate_dctype(work_dict['format'].lower())
body_vars = {
'license_url':
license.uri,
'license_name':
util.escape(license.title(locale_to_lower_lower(locale)))
}
if ((work_dict.get('attribution_url')
or work_dict.get('attribution_name'))
and work_dict.get('worktitle')):
body_template = gettext(
u'%(work_title)s by %(work_author)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
body_vars.update({
'work_title':
process_work_title(dctype, work_dict['worktitle']),
'work_author':
process_work_author(work_dict.get('attribution_url'),
work_dict.get('attribution_name'))
})
elif work_dict.get('attribution_url') \
or work_dict.get('attribution_name'):
body_template = gettext(
u'This %(work_type)s by %(work_author)s is licensed under '
u'a <a rel="license" href="%(license_url)s">Creative '
u'Commons %(license_name)s License</a>.')
body_vars.update({
'work_type':
process_work_type(gettext, dctype),
'work_author':
process_work_author(work_dict.get('attribution_url'),
work_dict.get('attribution_name'))
})
elif work_dict.get('worktitle'):
body_template = gettext(
u'%(work_title)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
body_vars.update({
'work_title':
process_work_title(dctype, work_dict['worktitle'])
})
else:
body_template = gettext(
u'This %(work_type)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
body_vars.update({'work_type': process_work_type(gettext, dctype)})
message = image_header + body_template % body_vars
if work_dict.get('source_work'):
source_work_template = gettext(
u'Based on a work at %(source_link)s.')
source_domain = urlparse(work_dict['source_work'])[1]
if not source_domain.strip():
source_domain = work_dict['source_work']
source_work = source_work_template % {
'source_link': SOURCE_LINK_TEMPLATE % {
'source_work': util.escape(work_dict['source_work']),
'source_domain': util.escape(source_domain)
}
}
message = message + "<br />" + source_work
if work_dict.get('more_permissions_url'):
more_perms_template = gettext(
u'Permissions beyond the scope of this license may be '
u'available at %(more_perms_link)s.')
more_perms = more_perms_template % {
'more_perms_link': MORE_PERMS_LINK_TEMPATE % {
'more_permissions_url':
util.escape(work_dict['more_permissions_url'])
}
}
message = message + "<br />" + more_perms
return message
def format(self, license, work_dict=None, locale='en'):
"""Return an HTML + RDFa string serialization for the license,
optionally incorporating the work metadata and locale."""
gettext = ugettext_for_locale(locale)
work_dict = work_dict or {}
localized_deed = license.uri
default_lang = license.jurisdiction.default_language
if not default_lang:
default_lang = "en"
if locale != default_lang:
localized_deed += "deed." + locale
image_header = IMAGE_HEADER_TEMPLATE % {
'license_url': localized_deed,
'util.Creative_Commons_License': util.escape(
gettext(u'Creative Commons License')),
'license_logo': license.logo}
dctype = None
if work_dict.get('format'):
dctype = _translate_dctype(work_dict['format'].lower())
body_vars = {
'license_url': localized_deed,
'license_name': util.escape(
license.title(locale_to_lower_lower(locale)))}
if ((work_dict.get('attribution_url')
or work_dict.get('attribution_name'))
and work_dict.get('worktitle')):
body_template = gettext(
u'%(work_title)s by %(work_author)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
body_vars.update(
{'work_title': process_work_title(
dctype, work_dict['worktitle']),
'work_author': process_work_author(
work_dict.get('attribution_url'),
work_dict.get('attribution_name'))})
elif work_dict.get('attribution_url') \
or work_dict.get('attribution_name'):
body_template = gettext(
u'This %(work_type)s by %(work_author)s is licensed under '
u'a <a rel="license" href="%(license_url)s">Creative '
u'Commons %(license_name)s License</a>.')
body_vars.update(
{'work_type': process_work_type(gettext, dctype),
'work_author': process_work_author(
work_dict.get('attribution_url'),
work_dict.get('attribution_name'))})
elif work_dict.get('worktitle'):
body_template = gettext(
u'%(work_title)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
body_vars.update(
{'work_title': process_work_title(
dctype, work_dict['worktitle'])})
else:
body_template = gettext(
u'This %(work_type)s is licensed under a '
u'<a rel="license" href="%(license_url)s">Creative Commons '
u'%(license_name)s License</a>.')
body_vars.update(
{'work_type': process_work_type(gettext, dctype)})
message = image_header + body_template % body_vars
if work_dict.get('source_work'):
source_work_template = gettext(
u'Based on a work at %(source_link)s.')
source_domain = urlparse(work_dict['source_work'])[1]
if not source_domain.strip():
source_domain = work_dict['source_work']
source_work = source_work_template % {
'source_link': SOURCE_LINK_TEMPLATE % {
'source_work': util.escape(work_dict['source_work']),
'source_domain': util.escape(source_domain)}}
message = message + "<br />" + source_work
if work_dict.get('more_permissions_url'):
more_perms_template = gettext(
u'Permissions beyond the scope of this license may be '
u'available at %(more_perms_link)s.')
more_perms = more_perms_template % {
'more_perms_link': MORE_PERMS_LINK_TEMPATE % {
'more_permissions_url': util.escape(
work_dict['more_permissions_url'])}}
message = message + "<br />" + more_perms
return message
def label(self, language='en'):
if language == '':
language = 'en' # why not?
gettext = ugettext_for_locale(language)
return gettext("Jurisdiction of your license")
def active_languages():
"""Return a sequence of dicts, where each element consists of the
following keys:
* code: the language code
* name: the translated name of this language
for each available language."""
global _ACTIVE_LANGUAGES
if _ACTIVE_LANGUAGES:
return _ACTIVE_LANGUAGES
# get a list of avaialable translations
domain = base.queryUtility(ITranslationDomain, ccorg_i18n_setup.I18N_DOMAIN)
lang_codes = set(domain.getCatalogsInfo().keys())
# determine the intersection of available translations and
# launched jurisdiction locales
launched_locales = set()
jurisdictions = cclicense_functions.get_valid_jurisdictions()
for jurisdiction in jurisdictions:
query_string = (
'PREFIX dc: <http://purl.org/dc/elements/1.1/> '
'SELECT ?lang WHERE {'
' <%s> dc:language ?lang}') % jurisdiction
query = RDF.Query(
str(query_string),
query_language='sparql')
this_juri_locales = set(
[locale_to_lower_upper(str(result['lang']))
for result in query.execute(rdf_helper.JURI_MODEL)])
# Append those locales that are applicable to this domain
launched_locales.update(lang_codes.intersection(this_juri_locales))
# XXX: Have to hack in Esperanto here because it's technically an
# "Unported" language but there is no unported RDF jurisdiction in
# jurisdictions.rdf..
launched_locales.add('eo')
# make our sequence have a predictable order
launched_locales = list(launched_locales)
# this loop is long hand for clarity; it's only done once, so
# the additional performance cost should be negligible
result = []
for code in launched_locales:
if code == 'test': continue
gettext = ugettext_for_locale(negotiate_locale(code))
name = gettext(mappers.LANG_MAP[code])
result.append(dict(code=code, name=name))
result = sorted(result, key=lambda lang: lang['name'].lower())
_ACTIVE_LANGUAGES = result
return result
def format(self, license, work_dict=None, locale='en'):
"""
Return an HTML + RDFa string of text for the license.
work_dict takes the following keys:
- work_title: Name of the work
- author_title: Original author of the work
- author_href: Link to the original author of the work
- curator_title: The person who identified this work
- curator_href: Link to the person who identified this work
- waive_cc0: Whether the author has also waived their rights
under CC0 (boolean)
"""
gettext = ugettext_for_locale(locale)
# Property gathering
# ------------------
work_dict = work_dict or {}
work_title = work_dict.get('work_title', False)
author_title = work_dict.get('author_title', '').strip()
author_href = work_dict.get('author_href', '').strip()
curator_title = work_dict.get('curator_title', '').strip()
curator_href = work_dict.get('curator_href', '').strip()
waive_cc0 = work_dict.get('waive_cc0', False)
# Find the "body" template
# ------------------------
has_author = bool(author_title or author_href)
has_curator = bool(curator_title or curator_href)
# All (work_title and author and curator)
if work_title and has_author and has_curator:
body_msg = PDMARK_WORKTITLE_AUTHOR_CURATOR
# Only work_title
elif work_title and not has_author and not has_curator:
body_msg = PDMARK_WORKTITLE
# Only author
elif has_author and not work_title and not has_curator:
body_msg = PDMARK_AUTHOR
# Only curator
elif has_curator and not work_title and not has_author:
body_msg = PDMARK_CURATOR
# work_title and author
elif work_title and has_author and not has_curator:
body_msg = PDMARK_WORKTITLE_AUTHOR
# work_title and curator
elif work_title and has_curator and not has_author:
body_msg = PDMARK_WORKTITLE_CURATOR
# author and curator
elif has_author and has_curator and not work_title:
body_msg = PDMARK_AUTHOR_CURATOR
# plain
else:
body_msg = PDMARK_PLAIN
# Translate the body
# ------------------
mapping = {}
if work_title:
mapping['work_title'] = u'<span property="dct:title">%s</span>' % (
util.escape(work_title))
if has_author:
if author_title and author_href:
mapping['author'] = PDMARK_AUTHOR_LINK % (
{'author_title': util.escape(author_title),
'author_href': util.escape(author_href)})
elif author_title and not author_href:
mapping['author'] = PDMARK_AUTHOR_NOLINK % (
{'author_title': util.escape(author_title)})
elif author_href and not author_title:
mapping['author'] = PDMARK_AUTHOR_ONLYLINK % (
{'author_href': util.escape(author_href)})
if has_curator:
if curator_title and curator_href:
mapping['curator'] = PDMARK_CURATOR_LINK % (
{'curator_title': util.escape(curator_title),
'curator_href': util.escape(curator_href)})
elif curator_title and not curator_href:
mapping['curator'] = PDMARK_CURATOR_NOLINK % (
{'curator_title': util.escape(curator_title)})
elif curator_href and not curator_title:
mapping['curator'] = PDMARK_CURATOR_ONLYLINK % (
{'curator_href': util.escape(curator_href)})
body = gettext(body_msg) % mapping
# Add the header and footers
# --------------------------
output_sections = []
# XXX: Norms guidelines may affect opening <p>?
if work_title or has_author or has_curator:
output_sections.append(
u'<p xmlns:dct="http://purl.org/dc/terms/">')
else:
output_sections.append(u'<p>')
# Add logos
output_sections.append(PDMARK_LOGO_HTML)
if waive_cc0:
output_sections.append(CC0_LOGO_HTML)
output_sections.append(u'<br />')
# Add body
output_sections.append(body)
# Add footer
output_sections.append(u'</p>')
return u'\n'.join(output_sections)
