Features

A feature is some aspect of language, e.g. the size of its phoneme inventory.

In cltoolkit, a Feature is an object bundling some metadata with a python callable accepting a cltoolkit.models.Language instance as its sole argument, and returning the value computed for this language.

A FeatureCollection of predefined features is available in FEATURES.

class cltoolkit.features.collection.Feature(id, name, function, type=None, note=None, categories=None, requires=None)

Variables

• id – str

• name – str

• function – callable

See also

get_callable()

Parameters

function (typing.Union[str, dict, typing.Callable]) –

class cltoolkit.features.collection.FeatureCollection(items, **kw)

A collection of Feature instances.

dump(path)

Dump feature specifications as JSON file.

classmethod load(path)

Load feature specifications from a JSON file (e.g. as created with FeatureCollection.dump)

cltoolkit.features.collection.get_callable(s)

A “feature function” can be specified in 3 ways:

• as Python callable object

• as string of dot-separated names, where the part up to the last dot is taken as Python module spec, and the last name as symbol to be looked up in this module

• as dict with keys class, args, kwargs, where class is interpreted as above, and args and kwargs are passed into the imported class to initialize an instance, the __call__ method of which will be used as “feature function”.

Parameters

s (typing.Union[str, dict, typing.Callable]) –

Return type

typing.Callable

Requirements

Features may have different requirements regarding the kind of data needed to perform the computation. These requirements can be expressed (and enforced) by decorating the callable (function or method) using the cltoolkit.features.requires() decorator, parametrized with the appropriate callables from the cltoolkit.features.reqs module - or any other callable accepting a cltoolkit.models.Language instance as argument, returning True if the requirement is met.

exception cltoolkit.features.reqs.MissingRequirement

Exception raised by requires() (before calling the decorated function) when a requirement is not met

cltoolkit.features.reqs.inventory(language)

Make sure a language has a precomputed sound inventory.

cltoolkit.features.reqs.graphemes(language)

Make sure a language has segmented forms, i.e. lists of graphemes for each form.

cltoolkit.features.reqs.concepts(language)

Make sure a language has forms linked to concepts, i.e. senses with Concepticon mapping.

cltoolkit.features.reqs.requires(*what)

Decorator to specify requirements of a feature callable.

@requires(graphemes)
def count_tokens(language):
    return 5

cltoolkit.features.reqs.inventory_with_occurrences(language)

Make sure a language has a precomputed sound inventory with occurrence lists per sound.

Phonological features

Miscellaneous phonological features found in typological databases.

class cltoolkit.features.phonology.WithInventory(*args, **kw)

Base class for feature callables requiring access to a phoneme inventory.

class cltoolkit.features.phonology.InventoryQuery(attr)

Compute the length/sizte of some attribute of a sound inventory.

number_of_consonants = InventoryQuery('consonants')

class cltoolkit.features.phonology.YesNoQuery(attr)

Compute whether an inventory has some property.

has_tones = YesNoQuery('tones')

class cltoolkit.features.phonology.Ratio(attr1, attr2)

Computes the ratio between sizes of two properties of an inventory.

class cltoolkit.features.phonology.StartsWithSound(concepts, features, concept_label=None, sound_label=None)

Check if a language has a form for {} starting with {}.

Note

Parametrized instances of this class can be used to check for certain cases of sound symbolism, or geographic / areal trends in languages to have word forms for certain concepts starting in certain words.

See also

sound_match()

mother_with_m = StartsWithSound(["MOTHER"], [["bilabial", "nasal"]], sound_label='[m]')

Parameters

• concepts (typing.List[str]) –

• features (typing.List[typing.List[str]]) –

• concept_label (typing.Optional[str]) –

• sound_label (typing.Optional[str]) –

cltoolkit.features.phonology.sound_match(sound, features)

Match a sound by a subset of features.

Note

The major idea of this function is to allow for the convenient matching of some sounds by defining them in terms of a part of their features alone. E.g., [m] and its variants can be defined as [“bilabial”, “nasal”], since we do not care about the rest of the features.

cltoolkit.features.phonology.is_voiced(sound)

Check if a sound is voiced or not.

cltoolkit.features.phonology.is_glide(sound)

Check if sound is a glide or a liquid.

cltoolkit.features.phonology.is_implosive(sound)

This groups stops and affricates into a group of sounds.

cltoolkit.features.phonology.stop_like(sound)

This groups stops and affricates into a group of sounds.

cltoolkit.features.phonology.is_uvular(sound)

Check if a sound is uvular or not.

class cltoolkit.features.phonology.PlosiveFricativeVoicing(*args, **kw)

See also

WALS 4A - Voicing in Plosives and Fricatives

class cltoolkit.features.phonology.HasPtk(*args, **kw)

See also

WALS 5A - Voicing and Gaps in Plosive Systems

class cltoolkit.features.phonology.HasUvular(*args, **kw)

See also

WALS 6A - Uvular Consonants

class cltoolkit.features.phonology.HasGlottalized(*args, **kw)

See also

WALS 7A - Glottalized Consonants

class cltoolkit.features.phonology.HasLaterals(*args, **kw)

See also

WALS 8A - Lateral Consonants

class cltoolkit.features.phonology.HasEngma(*args, **kw)

See also

WALS 9A - The Velar Nasal

class cltoolkit.features.phonology.HasSoundsWithFeature(attr, features)

Does the inventory contain at least one {}.

prenasalized_consonants = phonology.HasSoundsWithFeature("consonants", [["pre-nasalized"]])

class cltoolkit.features.phonology.HasRoundedVowels(*args, **kw)

See also

WALS 11A - Front Rounded Vowels

cltoolkit.features.phonology.syllable_complexity(forms_with_sounds)

Compute the major syllabic patterns for a language.

Note

The computation follows the automated syllabification process described in List (2014) based on sonority. Based on this syllabification, we calculate the number of consonants preceding the syllable nucleus and those following it. For a given syllable, we store the form, the consonantal sounds, and the index of the syllable in the word. These values are returned in the form of two dictionaries, in which the number of sounds is the key.

class cltoolkit.features.phonology.WithSyllableComplexity(*args, **kw)

class cltoolkit.features.phonology.SyllableStructure(*args, **kw)

See also

• syllable_complexity()

• WALS 12A - Syllable Structure

class cltoolkit.features.phonology.SyllableOnset(*args, **kw)

See also

• syllable_complexity()

• APiCS 118 - Syllable onsets

class cltoolkit.features.phonology.SyllableOffset(*args, **kw)

See also

• syllable_complexity()

• APiCS 119 - Syllable codas

class cltoolkit.features.phonology.LacksCommonConsonants(*args, **kw)

See also

WALS 18A - Absence of Common Consonants

class cltoolkit.features.phonology.HasUncommonConsonants(*args, **kw)

See also

WALS 19A - Presence of Uncommon Consonants

Lexical features

Miscellaneous features for lexical data.

class cltoolkit.features.lexicon.ConceptComparison(alist, blist, ablist=None, alabel=None, blabel=None)

Virtual base class for features comparing lexical data via concepts.

Parameters

• alist (typing.List[str]) –

• blist (typing.List[str]) –

• ablist (typing.Optional[typing.List[str]]) –

• alabel (typing.Optional[str]) –

• blabel (typing.Optional[str]) –

class cltoolkit.features.lexicon.Colexification(*args, **kw)

Computes if two concepts are expressed with the same form in a language (i.e. if they are colexified).

class cltoolkit.features.lexicon.PartialColexification(*args, **kw)

Computes if two concepts are partially colexified, i.e. if a form for the first concept is contained in a form for the second concept.

class cltoolkit.features.lexicon.SharedSubstring(*args, **kw)

Computes if forms for the two concepts share a substring (of length >= 3).