Python common.Language类代码示例

    def test_Language(self):
        from clld.db.models.common import Language

        d = Language(id='abc')
        assert d.glottocode is None
        assert d.iso_code is None
        assert d.__solr__(None)

    def test_Versioning(self):
        from clld.db.models.common import Language, Identifier, LanguageIdentifier
        from clld.db.meta import VersionedDBSession

        l = Language(id='abc', name='Old Name', jsondata={'i': 2})
        VersionedDBSession.add(l)
        VersionedDBSession.flush()
        self.assertEqual(l.version, 1)

        l.name = 'New Name'
        l.description = 'New Description'
        VersionedDBSession.flush()
        self.assertEqual(l.version, 2)

        History = l.__history_mapper__.class_
        res = VersionedDBSession.query(History).filter(History.pk == l.pk).all()
        self.assertEqual(res[0].name, 'Old Name')

        li = LanguageIdentifier(
            identifier=Identifier(id='asd', type='wals'),
            language=l)
        VersionedDBSession.flush()
        VersionedDBSession.delete(li)
        VersionedDBSession.delete(l)
        VersionedDBSession.flush()

def test_Data(db):
    from clld.db.models.common import Language, Language_data

    l = Language(id='abc', name='Name')
    l.data.append(Language_data(key='abstract', value='c'))
    DBSession.add(l)
    DBSession.flush()
    DBSession.refresh(l)
    assert l.datadict()['abstract'] == 'c'

    def test_Base(self):
        l = Language(id='abc', name='Name')
        VersionedDBSession.add(l)
        VersionedDBSession.flush()
        VersionedDBSession.expunge(l)
        l = Language.get('abc')
        self.assertEqual(l.name, 'Name')
        assert not list(l.history())

        # a bit of a hack to test the human readable representations.
        # we exploit the fact, that on py2, string and unicode comparison does type
        # coercion, while on py3, the two methods should actually return the same string.
        self.assertEqual(l.__str__(), l.__unicode__())
        Language().__str__()

def test_Base(db):
    l = Language(id='abc', name='Name')
    VersionedDBSession.add(l)
    VersionedDBSession.flush()
    VersionedDBSession.expunge(l)
    l = Language.get('abc', session=VersionedDBSession)
    assert l.name == 'Name'
    assert not list(l.history())

    # a bit of a hack to test the human readable representations.
    # we exploit the fact, that on py2, string and unicode comparison does type
    # coercion, while on py3, the two methods should actually return the same string.
    assert l.__str__() == l.__unicode__()
    Language().__str__()
    assert repr(l) == "<Language 'abc'>" if PY3 else "<Language u'abc'>"

 def get_identifier_objs(self, type_):
     if getattr(type_, 'value', type_) == IdentifierType.glottolog.value:
         return [
             Identifier(name=self.id, type=IdentifierType.glottolog.value)]
     #elif type_ == IdentifierType.iso and :
     #    return
     return Language.get_identifier_objs(self, type_)

 def test_CLLDRequest(self):
     self.assertTrue(isinstance(self.env['request'].purl, URL))
     c = self.env['request'].db.query(Contribution).first()
     self.env['request'].resource_url(c, ext='geojson')
     self.assertEqual(None, self.env['request'].ctx_for_url('/some/path/to/nowhere'))
     self.env['request'].file_url(Language_files(id='1', object=Language.first()))
     assert self.env['request'].get_datatable('valuesets', ValueSet)

 def __init__(self, req, model, language=None, **kw):
     super(Sources, self).__init__(req, model, **kw)
     if language:
         self.language = language
     elif 'language' in req.params:
         self.language = Language.get(req.params['language'])
     else:
         self.language = None

def update(args):
    count = 0
    for url, glottocode in args.json.items():
        lang = Language.get(glottocode, default=None)
        if lang:
            count += 1
            lang.update_jsondata(languagelandscape=url)
    print 'assigned', count, 'languagelandscape urls'

    def __init__(self, req, model, language=None, **kw):
        if language:
            self.language = language
        elif 'language' in req.params:
            self.language = Language.get(req.params['language'])
        else:
            self.language = None

        DataTable.__init__(self, req, model, **kw)

def test_CLLDRequest(env):
    assert isinstance(env['request'].purl, URL)
    c = env['request'].db.query(Contribution).first()
    env['request'].resource_url(c, ext='geojson')
    assert env['request'].ctx_for_url('/some/path/to/nowhere') is None
    assert env['request'].ctx_for_url('/')
    env['request'].file_url(Language_files(id='1', object=Language.first()))
    assert env['request'].get_datatable('valuesets', ValueSet)
    assert env['request'].blog is None

 def __init__(self, req, *args, **kw):
     Parameters.__init__(self, req, *args, **kw)
     if kw.get('languages'):
         self.languages = kw['languages']
     elif 'languages' in req.params:
         self.languages = nfilter([
             Language.get(id_, default=None)
             for id_ in req.params['languages'].split(',')])
     else:
         self.languages = []
     self._langs = [
         aliased(ValueSet, name='l%s' % i) for i in range(len(self.languages))]

    def test_Versioning(self):
        from clld.db.models.common import Language, Language_data
        from clld.db.meta import VersionedDBSession

        l = Language(id='abc', name='Old Name', jsondata={'i': 2})
        VersionedDBSession.add(l)
        VersionedDBSession.flush()
        self.assertEqual(l.version, 1)

        l.name = 'New Name'
        l.description = 'New Description'
        VersionedDBSession.flush()
        self.assertEqual(l.version, 2)

        History = l.__history_mapper__.class_
        res = VersionedDBSession.query(History).filter(History.pk == l.pk).all()
        self.assertEqual(res[0].name, 'Old Name')

        l.data.append(Language_data(key='k', value='v'))
        VersionedDBSession.flush()
        assert l.datadict()
        VersionedDBSession.delete(l)
        VersionedDBSession.flush()

def test_Base_jsondata(db):
    l = Language(id='abc', name='Name')
    VersionedDBSession.add(l)
    VersionedDBSession.flush()
    l.update_jsondata(a=1)
    assert 'a' in l.jsondata
    l.update_jsondata(b=1)
    assert 'b' in l.jsondata and 'a' in l.jsondata
    assert 'b' in l.__json__(None)['jsondata']

def test_CsvMixin(db):
    l1 = Language(id='abc', name='Name', latitude=12.4, jsondata=dict(a=None))
    DBSession.add(l1)
    DBSession.flush()
    l1 = Language.csv_query(DBSession).first()
    cols = l1.csv_head()
    row = l1.to_csv()
    for k, v in zip(cols, row):
        if k == 'jsondata':
            assert 'a' in json.loads(v)
    l2 = Language.from_csv(row)
    assert pytest.approx(l1.latitude) == l2.latitude
    row[cols.index('latitude')] = '3,5'
    l2 = Language.from_csv(row)
    assert l2.latitude < l1.latitude