def __init__(self, req, *args, **kw):
Values.__init__(self, req, *args, **kw)
self._langs = {}
if self.contribution:
for lang in self.contribution.source_languages.split():
lang = lang.lower()
self._langs[lang] = aliased(Value_data, name=lang)
def __init__(self, req, *args, **kw):
Values.__init__(self, req, *args, **kw)
self._langs = {}
if self.contribution:
for lang in self.contribution.source_languages.split():
lang = lang.lower()
self._langs[lang] = aliased(Value_data, name=lang)
def __init__(self, req, model, parameter=None, pair=None):
Values.__init__(self, req, model, parameter=parameter)
if pair:
self.pair = pair
elif 'pair' in req.params:
self.pair = Pair.get(req.params['pair'])
else:
self.pair = None
def col_defs(self):
if self.parameter:
return [
LinkCol(self,
'sample',
model_col=Sample.name,
get_object=lambda i: i.valueset.language),
Col(self,
'region',
model_col=Sample.region,
get_object=lambda i: i.valueset.language,
format=lambda i: i.valueset.language.region),
FamilyCol(self,
'family',
get_object=lambda i: i.valueset.language.languoid,
model_col=Languoid.family_name,
choices=get_distinct_values(Languoid.family_name)),
Col(self, 'value', model_col=Measurement.value),
LinkToMapCol(self,
'#',
get_object=lambda i: i.valueset.language),
]
if self.language:
return [
LinkCol(self,
'measure',
model_col=Parameter.name,
get_object=lambda i: i.valueset.parameter),
Col(self,
'description',
get_object=lambda i: i.valueset.parameter,
model_col=Parameter.description),
Col(self, 'value', model_col=Measurement.value),
]
return Values.col_defs(self)
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query\
.outerjoin(NameCategory)\
.outerjoin(NameHabitat)\
.outerjoin(Name.uses)\
.options(
contains_eager(Name.uses),
joinedload(Name.habitats),
joinedload(Name.categories))
if not self.language and not self.parameter:
query = query.join(ValueSet.language).join(ValueSet.parameter)
if self.parameter:
query = query.join(Languoid.lineage).options(
joinedload(Value.valueset).joinedload(
ValueSet.language).joinedload(Languoid.lineage))
else:
query = query.options(
joinedload(Value.valueset, ValueSet.parameter,
Parameter._files))
return query.options(
joinedload(Value.valueset).joinedload(ValueSet.parameter),
joinedload(Name.references).joinedload(NameReference.source))
def base_query(self, query):
query = Values.base_query(self, query)
if self.parameter:
query = query\
.outerjoin(Counterpart.cognateset)\
.outerjoin(LexibankLanguage.family)
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.family:
if self.feature:
query = query.filter(
common.ValueSet.parameter_pk == int(self.feature.pk))
query = query.join(GrambankLanguage).join(Family).filter(
GrambankLanguage.family == self.family)
query = query.options(
joinedload(common.Value.valueset).joinedload(
common.ValueSet.parameter),
joinedload(common.Value.domainelement),
)
else:
if self.language:
query = query.options(
joinedload(common.Value.valueset).joinedload(
common.ValueSet.parameter),
joinedload(common.Value.domainelement),
)
if self.parameter:
query = query\
.join(common.ValueSet.contribution)\
.join(common.Contribution.contributor_assocs)\
.join(common.ContributionContributor.contributor)\
.options(
joinedload(common.Value.valueset, common.ValueSet.language),
joinedload(common.Value.valueset)
.joinedload(common.ValueSet.contribution)
.joinedload(common.Contribution.contributor_assocs)
.joinedload(common.ContributionContributor.contributor))
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.pair:
query = query.join(ValueSet.parameter)
return query.filter(waabValue.pair_pk == self.pair.pk)
if self.parameter:
return query.join(waabValue.pair)
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query.options(
joinedload_all(common.Value.valueset, common.ValueSet.parameter),
joinedload(common.Value.domainelement),
)
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query.options(
joinedload_all(common.Value.valueset,
common.ValueSet.parameter),
joinedload(common.Value.domainelement),
)
return query
def test_Values(self):
from clld.web.datatables.value import Values
dt = self.handle_dt(Values, common.Value)
self.assertTrue(isinstance(dt.options, dict))
self.set_request_properties(params={
'sSearch_0': '> 1',
'sSearch_1': 's',
'iSortingCols': '3',
'iSortCol_0': '0',
'sSortDir_0': 'desc',
'iSortCol_1': '1',
'sSortDir_1': 'desc',
'iSortCol_2': '2',
'sSortDir_2': 'desc',
})
dt = Values(self.env['request'], common.Value)
dt.get_query()
def base_query(self, query):
query = Values.base_query(self, query)
if not self.parameter:
query = query.join(common.ValueSet.parameter).join(
models.Param.contribution)
if self.module:
query = query.filter(models.CLDFDataset.module == self.module)
return query
def base_query(self, query):
query = Values.base_query(self, query)
if not self.language and not self.parameter:
query = query\
.join(ValueSet.language)\
.join(ValueSet.parameter)\
.options(
joinedload(Value.valueset, ValueSet.language),
joinedload(Value.valueset, ValueSet.parameter))
return query
def base_query(self, query):
if not any([self.language, self.parameter, self.contribution]):
return query\
.join(common.ValueSet)\
.join(common.Parameter)\
.join(common.Language)\
.options(
joinedload(common.Value.valueset).joinedload(common.ValueSet.parameter),
joinedload(common.Value.valueset).joinedload(common.ValueSet.language))
else:
return Values.base_query(self, query)
def test_Values(self):
from clld.web.datatables.value import Values
dt = self.handle_dt(Values, common.Value)
self.assertTrue(isinstance(dt.options, dict))
self.set_request_properties(
params={
'sSearch_0': '> 1',
'sSearch_1': 's',
'iSortingCols': '3',
'iSortCol_0': '0',
'sSortDir_0': 'desc',
'iSortCol_1': '1',
'sSortDir_1': 'desc',
'iSortCol_2': '2',
'sSortDir_2': 'desc',
})
dt = Values(self.env['request'], common.Value)
dt.get_query()
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query\
.outerjoin(SpeciesCategory, SpeciesCategory.species_pk == Parameter.pk)\
.outerjoin(
Category,
and_(
SpeciesCategory.category_pk == Category.pk,
Category.language_pk == self.language.pk))
return query.options(joinedload_all(
Value.valueset, ValueSet.parameter, Species.categories))
def col_defs(self):
if self.parameter:
return [
LinkCol(self, 'form', model_col=Counterpart.name),
LinkCol(
self,
'language',
model_col=LexibankLanguage.name,
get_object=lambda i: i.valueset.language),
MaybeLinkCol(
self,
'family',
model_col=Family.name,
get_object=lambda i: i.valueset.language.family),
MaybeLinkCol(
self,
'cognate_set',
model_col=Cognateset.name,
get_object=lambda i: i.cognateset),
Col(self, 'loan', model_col=Counterpart.loan),
]
if self.contribution:
return [
LinkCol(self, 'form', model_col=Counterpart.name),
LinkCol(
self,
'concept',
model_col=Concept.name,
get_object=lambda i: i.valueset.parameter),
Col(self, 'annotation', model_col=Value.description),
MaybeLinkCol(
self,
'cognate_set',
model_col=Cognateset.name,
get_object=lambda i: i.cognateset),
Col(self, 'loan', model_col=Counterpart.loan),
RefsCol(self, 'source'),
]
if self.language:
return [
LinkCol(self, 'form', model_col=Counterpart.name),
LinkCol(
self,
'concept',
model_col=Concept.name,
get_object=lambda i: i.valueset.parameter),
LinkCol(
self,
'wordlist',
model_col=Wordlist.name,
get_object=lambda i: i.valueset.contribution),
]
return Values.col_defs(self)
def col_defs(self):
cols = Values.col_defs(self)
if (self.parameter and self.parameter.contribution.id == 'Wordlist') \
or self.module == 'Wordlist':
cols.append(AudioCol(self, 'audio'))
if (self.parameter and self.parameter.contribution.id == 'StructureDataset') \
or self.module == 'StructureDataset':
cols.append(
category_col(self, get_object=lambda i: i.valueset.parameter))
return [
col for col in cols if not isinstance(col, DetailsRowLinkCol)
and not isinstance(col, RefsCol)
]
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query.options(
joinedload(common.Value.valueset).joinedload(common.ValueSet.parameter),
joinedload(common.Value.domainelement),
)
elif self.parameter:
query = query.outerjoin(Family).options(
joinedload(common.Value.valueset)
.joinedload(common.ValueSet.language)
.joinedload(sailsLanguage.family))
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query.options(
joinedload_all(common.Value.valueset, common.ValueSet.parameter),
joinedload(common.Value.domainelement),
)
elif self.parameter:
query = query.outerjoin(Family)\
.options(joinedload_all(
common.Value.valueset,
common.ValueSet.language,
sailsLanguage.family))
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.parameter:
return query.join(Family, isouter=True).options(
joinedload(Value.valueset).joinedload(ValueSet.language), )
elif self.contribution:
return query.options(
joinedload(Value.valueset).joinedload(ValueSet.parameter),
joinedload(Value.valueset).joinedload(ValueSet.language),
joinedload(Value.valueset).joinedload(ValueSet.contribution),
joinedload(Value.domainelement),
)
else:
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.contribution:
query = query.join(ValueSet.parameter)
for lang, alias in self._langs.items():
query = query.outerjoin(
alias,
and_(alias.key == 'lang_' + lang, alias.object_pk == Concept.pk))
query = query.options(
joinedload(Value.data),
joinedload_all(Value.valueset, ValueSet.parameter))
elif self.parameter:
pass
else:
query = query.join(ValueSet.parameter)
query = query.options(joinedload_all(Value.valueset, ValueSet.parameter))
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.contribution:
query = query.join(ValueSet.parameter)
for lang, alias in self._langs.items():
query = query.outerjoin(
alias,
and_(alias.key == 'lang_' + lang,
alias.object_pk == Concept.pk))
query = query.options(
joinedload(Value.data),
joinedload_all(Value.valueset, ValueSet.parameter))
elif self.parameter:
pass
else:
query = query.join(ValueSet.parameter)
query = query.options(
joinedload_all(Value.valueset, ValueSet.parameter))
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query.options(
joinedload_all(common.Value.valueset, common.ValueSet.parameter),
joinedload(common.Value.domainelement),
)
if self.parameter:
query = query\
.join(common.ValueSet.contribution)\
.join(common.Contribution.contributor_assocs)\
.join(common.ContributionContributor.contributor)\
.options(
joinedload(common.Value.valueset, common.ValueSet.language),
joinedload_all(
common.Value.valueset,
common.ValueSet.contribution,
common.Contribution.contributor_assocs,
common.ContributionContributor.contributor))
return query
def base_query(self, query):
query = Values.base_query(self, query)
if self.language:
query = query\
.outerjoin(NameCategory)\
.outerjoin(NameHabitat)\
.outerjoin(Name.uses)\
.options(
contains_eager(Name.uses),
joinedload(Name.habitats),
joinedload(Name.categories))
if not self.language and not self.parameter:
query = query.join(ValueSet.language).join(ValueSet.parameter)
if self.parameter:
query = query.join(Languoid.lineage).options(
joinedload_all(Value.valueset, ValueSet.language, Languoid.lineage)
)
else:
query = query.options(joinedload(
Value.valueset, ValueSet.parameter, Parameter._files))
return query.options(
joinedload_all(Value.valueset, ValueSet.parameter),
joinedload_all(Name.references, NameReference.source))
def xhr_query(self):
res = Values.xhr_query(self)
if self._type:
res['type'] = self._type
return res
def __init__(self, req, model, eid=None, **kw):
self._type = req.params.get('type', kw.pop('type', ''))
Values.__init__(self, req, model, eid=eid, **kw)
self.eid = self.eid + self._type
def xhr_query(self):
res = Values.xhr_query(self) or {}
if self.pair:
res['pair'] = self.pair.id
return res
def __init__(self, req, model, eid=None, **kw):
self._type = req.params.get('type', kw.pop('type', ''))
Values.__init__(self, req, model, eid=eid, **kw)
self.eid = self.eid + self._type
def xhr_query(self):
res = Values.xhr_query(self)
if self._type:
res['type'] = self._type
return res
def base_query(self, query):
query = Values.base_query(self, query)
if not self.language and not self.parameter:
query = query.join(ValueSet.language).join(ValueSet.parameter)
return query
def xhr_query(self):
res = Values.xhr_query(self)
if self.ff:
res['ff'] = 1
return res
def base_query(self, query):
query = Values.base_query(self, query)
if self.parameter:
query = query.join(Sample.languoid)
return query
def xhr_query(self):
res = Values.xhr_query(self)
if self.feature:
res['feature'] = self.feature.id
return res
def base_query(self, query):
query = Values.base_query(self, query)
query = query.join(common.DomainElement)
if not any({self.language, self.contribution, self.parameter}):
query = query.join(common.Language)
return query.distinct()
def __init__(self, req, *args, **kw):
self.feature = kw.pop('feature', None)
if (not self.feature) and 'feature' in req.params:
self.feature = common.Parameter.get(req.params['feature'])
Values.__init__(self, req, *args, **kw)
def __init__(self, req, model, **kw):
Values.__init__(self, req, model, **kw)
self.ff = False
if kw.get('ff') or 'ff' in req.params:
self.ff = True
