def getlanguage(code):
"""This returns a language class.
@param code: The ISO 639 language code
"""
if code:
code = code.replace("-", "_").replace("@", "_").lower()
try:
try:
if code is None:
raise ImportError("Can't determine language code")
exec("from translate.lang import %s" % code)
exec("langclass = %s.%s" % (code, code))
return langclass(code)
except SyntaxError, e:
# Someone is probably trying to import a language of which the code
# is a reserved word in python (like Icelandic (is) / Oriya (or))
# The convention to handle these is to have it in a file like
# code_is, for example.
exec("from translate.lang import %s%s" % (prefix, code))
exec("langclass = %s%s.%s%s" % (prefix, code, prefix, code))
return langclass(code)
except ImportError, e:
if code and code.startswith(prefix):
code = code[: len(prefix)]
simplercode = data.simplercode(code)
if simplercode:
relatedlanguage = getlanguage(simplercode)
if isinstance(relatedlanguage, common.Common):
relatedlanguage = relatedlanguage.__class__(code)
return relatedlanguage
else:
return common.Common(code)
def getlanguage(code):
"""This returns a language class.
:param code: The ISO 639 language code
"""
if code:
code = code.replace("-", "_").replace("@", "_").lower()
try:
if code is None:
raise ImportError("Can't determine language code")
if code in ('or', 'is'):
internal_code = prefix + code
else:
internal_code = code
module = __import__("translate.lang.%s" % internal_code, globals(), {},
internal_code)
langclass = getattr(module, internal_code)
return langclass(code)
except ImportError, e:
simplercode = data.simplercode(code)
if simplercode:
relatedlanguage = getlanguage(simplercode)
if isinstance(relatedlanguage, common.Common):
relatedlanguage = relatedlanguage.__class__(code)
return relatedlanguage
else:
return common.Common(code)
def getlanguage(code):
"""This returns a language class.
@param code: The ISO 639 language code
"""
if code:
code = code.replace("-", "_").replace("@", "_")
try:
try:
if code is None:
raise ImportError ("Can't determine language code")
exec("from translate.lang import %s" % code)
exec("langclass = %s.%s" % (code, code))
return langclass(code)
except SyntaxError, e:
# Someone is probably trying to import a language of which the code
# is a reserved word in python (like Icelandic (is) / Oriya (or))
# The convention to handle these is to have it in a file like
# code_is, for example.
exec("from translate.lang import %s%s" % (prefix, code))
exec("langclass = %s%s.%s%s" % (prefix, code, prefix, code))
return langclass(code)
except ImportError, e:
if code and code.startswith(prefix):
code = code[:len(prefix)]
simplercode = data.simplercode(code)
if simplercode:
relatedlanguage = getlanguage(simplercode)
if isinstance(relatedlanguage, common.Common):
relatedlanguage = relatedlanguage.__class__(code)
return relatedlanguage
else:
return common.Common(code)
def getlanguage(code):
"""This returns a language class.
:param code: The ISO 639 language code
"""
if code:
code = code.replace("-", "_").replace("@", "_").lower()
try:
if code is None:
raise ImportError("Can't determine language code")
if code in ('or', 'is', 'as'):
internal_code = prefix + code
else:
internal_code = code
module = __import__("translate.lang.%s" % internal_code, globals(), {},
internal_code)
langclass = getattr(module, internal_code)
return langclass(code)
except ImportError as e:
simplercode = data.simplercode(code)
if simplercode:
relatedlanguage = getlanguage(simplercode)
if isinstance(relatedlanguage, common.Common):
relatedlanguage = relatedlanguage.__class__(code)
return relatedlanguage
else:
return common.Common(code)
def _handle_source_lang(self, request, response):
language = request.id
result = self._loads_safe(response)
if result:
self.source_lang = language
#logging.debug("source language %s supported" % language)
self.emit('source-lang-changed', self.source_lang)
else:
lang = data.simplercode(language)
if lang:
self.lang_negotiate(lang, self._handle_source_lang)
else:
self.source_lang = None
logging.debug("source language %s not supported" % language)
def length_difference(cls, length):
"""Returns an estimate to a likely change in length relative to an
English string of length length."""
# This is just a rudimentary heuristic guessing that most translations
# will be somewhat longer than the source language
expansion_factor = 0
code = cls.code
while code:
expansion_factor = data.expansion_factors.get(cls.code, 0)
if expansion_factor:
break
code = data.simplercode(code)
else:
expansion_factor = 0.1 # default
constant = max(5, int(40 * expansion_factor))
# The default: return 5 + length/10
return constant + int(expansion_factor * length)
def length_difference(cls, length):
"""Returns an estimate to a likely change in length relative to an
English string of length length."""
# This is just a rudimentary heuristic guessing that most translations
# will be somewhat longer than the source language
expansion_factor = 0
code = cls.code
while code:
expansion_factor = data.expansion_factors.get(cls.code, 0)
if expansion_factor:
break
code = data.simplercode(code)
else:
expansion_factor = 0.1 # default
constant = max(5, int(40*expansion_factor))
# The default: return 5 + length/10
return constant + int(expansion_factor * length)
def __new__(cls, code):
"""This returns the language class for the given code, following a
singleton like approach (only one object per language)."""
code = code or ""
# First see if a language object for this code already exists
if code in cls._languages:
return cls._languages[code]
# No existing language. Let's build a new one and keep a copy
language = cls._languages[code] = object.__new__(cls)
language.code = code
while code:
langdata = data.get_language(code)
if langdata:
language.fullname, language.nplurals, language.pluralequation = langdata
break
code = data.simplercode(code)
return language
def __new__(cls, code):
"""This returns the language class for the given code, following a
singleton like approach (only one object per language)."""
code = code or ""
# First see if a language object for this code already exists
if code in cls._languages:
return cls._languages[code]
# No existing language. Let's build a new one and keep a copy
language = cls._languages[code] = object.__new__(cls)
language.code = code
while code:
langdata = data.get_language(code)
if langdata:
language.fullname, language.nplurals, \
language.pluralequation = langdata
break
code = data.simplercode(code)
return language
def set_source_lang(self, language):
language = language.lower().replace('-', '_').replace('@', '_')
if not self._languages:
# for some reason we don't (yet) have supported languages
self.source_lang = language
# we'll redo this once we have languages
return
if language in self._languages:
self.source_lang = language
logging.debug("source language %s supported" % language)
self.emit('source-lang-changed', self.source_lang)
else:
lang = data.simplercode(language)
if lang:
self.set_source_lang(lang)
else:
self.source_lang = None
logging.debug("source language %s not supported" % language)
def set_source_lang(self, language):
language = language.lower().replace('-', '_').replace('@', '_')
if not self._languages:
# for some reason we don't (yet) have supported languages
self.source_lang = language
# we'll redo this once we have languages
return
if language in self._languages:
self.source_lang = language
logging.debug("source language %s supported" % language)
self.emit('source-lang-changed', self.source_lang)
else:
lang = data.simplercode(language)
if lang:
self.set_source_lang(lang)
else:
self.source_lang = None
logging.debug("source language %s not supported" % language)
def __new__(cls, code):
"""This returns the language class for the given code, following a
singleton like approach (only one object per language)."""
code = code or ""
# First see if a language object for this code already exists
if code in cls._languages:
return cls._languages[code]
# No existing language. Let's build a new one and keep a copy
language = cls._languages[code] = object.__new__(cls)
language.code = code
while code:
langdata = data.languages.get(code, None)
if langdata:
language.fullname, language.nplurals, language.pluralequation = langdata
break
code = data.simplercode(code)
if not code:
# print >> sys.stderr, "Warning: No information found about language code %s" % code
pass
return language
def __new__(cls, code):
"""This returns the language class for the given code, following a
singleton like approach (only one object per language)."""
code = code or ""
# First see if a language object for this code already exists
if code in cls._languages:
return cls._languages[code]
# No existing language. Let's build a new one and keep a copy
language = cls._languages[code] = object.__new__(cls)
language.code = code
while code:
langdata = data.get_language(code)
if langdata:
language.fullname, language.nplurals, \
language.pluralequation = langdata
break
code = data.simplercode(code)
if not code:
# message suppressed by default at level info
logger.info("No information found about language code %s", code)
pass
return language
