def extract(request, translation_project):
"""generate glossary of common keywords and phrases from translation project"""
template_vars = {
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
if request.method == 'POST' and request.POST['extract']:
extractor = TerminologyExtractor(
accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(
translation_project.project.source_language.code))
for store in translation_project.stores.iterator():
if store.name == 'pootle-terminology.po':
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(
parent=translation_project.directory,
translation_project=translation_project,
name="pootle-terminology.po")
# lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# calculate maximum terms
maxunits = int(
translation_project.getquickstats()['totalsourcewords'] * 0.02)
maxunits = min(
max(settings.MIN_AUTOTERMS, maxunits), settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
unit.add_suggestion(suggestion)
# unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
template_vars['store'] = store
template_vars['termcount'] = len(termunits)
return redirect(translation_project.pootle_path +
'terminology_manage.html')
return render_to_response(
"terminology/extract.html",
template_vars,
context_instance=RequestContext(request))
def extract(request, translation_project):
"""generate glossary of common keywords and phrases from translation project"""
template_vars = {
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
terminology_filename = get_terminology_filename(translation_project)
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
extractor = TerminologyExtractor(accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(translation_project.project.source_language.code))
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(parent=translation_project.directory,
translation_project=translation_project,
name=terminology_filename)
# lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# calculate maximum terms
maxunits = int(translation_project.getquickstats()['totalsourcewords'] * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits), settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
unit.add_suggestion(suggestion) # Touch=True which saves unit on every call
# unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
template_vars['store'] = store
template_vars['termcount'] = len(termunits)
from pootle_misc.baseurl import redirect
return redirect(translation_project.pootle_path + 'terminology_manage.html')
return render_to_response("terminology/extract.html", template_vars, context_instance=RequestContext(request))
def extract(request, translation_project):
"""Generate glossary of common keywords and phrases from translation
project.
"""
ctx = {
'page': 'admin-terminology',
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
terminology_filename = get_terminology_filename(translation_project)
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
extractor = TerminologyExtractor(
accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(
translation_project.project.source_language.code))
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(
parent=translation_project.directory,
translation_project=translation_project,
name=terminology_filename,
)
# Lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# Calculate maximum terms.
maxunits = int(translation_project.get_total_wordcount() * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits),
settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
# Touch=True which saves unit on every call
unit.add_suggestion(suggestion)
# Unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
ctx.update({
'store': store,
'termcount': len(termunits),
})
path_args = split_pootle_path(translation_project.pootle_path)[:2]
return redirect(reverse('pootle-terminology-manage', args=path_args))
return render(request, "translation_projects/terminology/extract.html",
ctx)
def extract(request, translation_project):
"""Generate glossary of common keywords and phrases from translation
project.
"""
ctx = {
'page': 'admin-terminology',
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
terminology_filename = get_terminology_filename(translation_project)
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
extractor = TerminologyExtractor(
accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(translation_project.project.source_language.code)
)
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(
parent=translation_project.directory,
translation_project=translation_project,
name=terminology_filename,
)
# Lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# Calculate maximum terms
source_words = sum(store._get_total_wordcount()
for store in translation_project.stores.iterator())
maxunits = int(source_words * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits),
settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
# Touch=True which saves unit on every call
unit.add_suggestion(suggestion)
# Unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
ctx.update({
'store': store,
'termcount': len(termunits),
})
path_args = split_pootle_path(translation_project.pootle_path)[:2]
return redirect(reverse('pootle-terminology-manage', args=path_args))
return render(request, "translation_projects/terminology/extract.html", ctx)
def extract(request, translation_project):
"""Generate glossary of common keywords and phrases from translation
project.
"""
template_vars = {
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
terminology_extractor_params = {
'accelchars': translation_project.checker.config.accelmarkers,
'sourcelanguage': str(translation_project.project.source_language.code),
}
extractor = TerminologyExtractor(**terminology_extractor_params)
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
create_criteria = {
'parent': translation_project.directory,
'translation_project': translation_project,
'name': get_terminology_filename(translation_project),
}
store, created = Store.objects.get_or_create(**create_criteria)
# lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# calculate maximum terms
maxunits = int(translation_project.getquickstats()['totalsourcewords'] * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits), settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
# Touch=True which saves unit on every call
unit.add_suggestion(suggestion)
# unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
template_vars['store'] = store
template_vars['termcount'] = len(termunits)
from pootle_misc.baseurl import redirect
return redirect(translation_project.pootle_path +
'terminology_manage.html')
return render_to_response("terminology/extract.html", template_vars,
context_instance=RequestContext(request))
