lingpy package¶

Subpackages¶

Submodules¶

lingpy.basictypes module¶

class lingpy.basictypes.aligned(iterable)¶

Bases: lingpy.basictypes._strings

property a¶

lingpy.basictypes.integer(x)¶

class lingpy.basictypes.lists(iterable, sep=' + ')¶

Bases: lingpy.basictypes._strings

change(i, item)¶

extend(other)¶: Extend list by appending elements from the iterable.

lingpy.cache module¶

Implements the lingpy cache.

Some operations in lingpy may be time consuming, so we provide a mechanism to cache the results of these operations.

lingpy.cache.dump(data, filename, d=PosixPath('/home/mattis/.cache/lingpy/2.6.9'))¶

lingpy.cache.load(filename, d=PosixPath('/home/mattis/.cache/lingpy/2.6.9'))¶

lingpy.cache.path(filename, d=PosixPath('/home/mattis/.cache/lingpy/2.6.9'))¶

lingpy.cli module¶

class lingpy.cli.Command¶

Bases: object

Base class for subcommands of the lingpy command line interface.

help = None¶

output(args, content)¶

classmethod subparser(parser)¶: Hook to define subcommand arguments.

class lingpy.cli.CommandMeta(name, bases, dct)¶

Bases: type

A metaclass which keeps track of subclasses, if they have all-lowercase names.

lingpy.cli.add_align_method_option(p)¶

lingpy.cli.add_cognate_identifier_option(p, default)¶

lingpy.cli.add_format_option(p, default, choices)¶

lingpy.cli.add_method_option(p, default, choices, spec='')¶

lingpy.cli.add_mode_option(p, choices)¶

lingpy.cli.add_option(parser, name_, default_, help_, short_opt=None, **kw)¶

lingpy.cli.add_shared_args(p)¶

lingpy.cli.add_strings_option(p, n)¶

lingpy.cli.add_tree_calc_option(p)¶

class lingpy.cli.alignments¶

Bases: lingpy.cli.Command

Carry out alignment analysis of a wordlist file with readily detected cognates.

classmethod subparser(p)¶: Hook to define subcommand arguments.

lingpy.cli.get_parser()¶

class lingpy.cli.help¶

Bases: lingpy.cli.Command

Show help for commands.

classmethod subparser(parser)¶: Hook to define subcommand arguments.

class lingpy.cli.lexstat¶

Bases: lingpy.cli.Command

classmethod subparser(p)¶: Hook to define subcommand arguments.

lingpy.cli.main(*args)¶: LingPy command line interface.

class lingpy.cli.multiple¶

Bases: lingpy.cli.Command

Multiple alignment console interface for LingPy.

classmethod subparser(p)¶: Hook to define subcommand arguments.

class lingpy.cli.pairwise¶

Bases: lingpy.cli.Command

Run pairwise analyses from command line in LingPy

Notes

Currently, the following options are supported:

run normal analyses without sound class strings
run sound-class based analyses

Furthermore, input output is handled as follows:

define user input using psa-formats in lingpy
define user output (stdout, file)

classmethod subparser(p)¶: Hook to define subcommand arguments.

class lingpy.cli.profile¶

Bases: lingpy.cli.Command

classmethod subparser(p)¶: Hook to define subcommand arguments.

class lingpy.cli.settings¶

Bases: lingpy.cli.Command

classmethod subparser(p)¶: Hook to define subcommand arguments.

class lingpy.cli.wordlist¶

Bases: lingpy.cli.Command

Load a wordlist and carry out simple checks.

classmethod subparser(p)¶: Hook to define subcommand arguments.

lingpy.config module¶

Configuration management for lingpy.

Various aspects of lingpy can be configured and customized by the user. This is done with configuration files in the user’s config dir.

lingpy.log module¶

Logging utilities

class lingpy.log.CustomFilter(name='')¶

Bases: logging.Filter

filter(record)¶

Determine if the specified record is to be logged.

Returns True if the record should be logged, or False otherwise. If deemed appropriate, the record may be modified in-place.

class lingpy.log.Logging(level=10, logger=None)¶

Bases: object

A context manager to execute a block of code at a specific logging level.

lingpy.log.debug(msg, **kw)¶

lingpy.log.deprecated(old, new)¶

lingpy.log.error(msg, **kw)¶

lingpy.log.file_written(fname, logger=None)¶

lingpy.log.get_level()¶

lingpy.log.get_logger(config_dir=None, force_default_config=False, test=False)¶

Get a logger configured according to the lingpy log config file.

Note: If no logging configuration file exists, it will be created.

Parameters

config_dir – Directory in which to look for/create the log config file.
force_default_config – Configure the logger using the default config.
test – Force reconfiguration of the logger.

Returns

A logger.

lingpy.log.info(msg, **kw)¶

lingpy.log.missing_module(name, logger=None)¶

lingpy.log.warning(msg)¶

lingpy.settings module¶

Module handels all global parameters used in a LingPy session.

lingpy.settings.rc(rval=None, rcParams_=None, **keywords)¶

Function changes parameters globally set for LingPy sessions.

Parameters

rval : string (default=None)

Use this keyword to specify a return-value for the rc-function.

schema : {“ipa”, “asjp”}

Change the basic schema for sequence comparison. When switching to “asjp”, this means that sequences will be treated as sequences in ASJP code, otherwise, they will be treated as sequences written in basic IPA.

rcParams_ : Allow passing in a plain dict for testing.

Notes

This function is the standard way to communicate with the rcParams dictionary which is not imported as a default. If you want to see which parameters there are, you can load the rcParams dictonary directly:

>>> from lingpy.settings import rcParams

However, be careful when changing the values. They might produce some unexpected behavior.

Examples

Import LingPy:

>>> from lingpy import *

Switch from IPA transcriptions to ASJP transcriptions:

>>> rc(schema="asjp")

You can check which “basic orthography” is currently loaded:

>>> rc(basic_orthography)
'asjp'
>>> rc(schema='ipa')
>>> rc(basic_orthography)
'fuzzy'

lingpy.util module¶

class lingpy.util.TemporaryPath(suffix='')¶: Bases: object

class lingpy.util.TextFile(path, log=True)¶: Bases: object

lingpy.util.as_string(obj, pprint=False)¶

lingpy.util.charstring(id_, char='X', cls='-')¶

lingpy.util.combinations2(iterable)¶: Convenience shortcut

lingpy.util.data_path(*comps)¶

lingpy.util.dotjoin(*args, **kw)¶

Convenience shortcut. Strings to be joined do not have to be passed as list or tuple.

Notes

An implicit conversion of objects to strings is performed as well.

lingpy.util.identity(x)¶

lingpy.util.join(sep, *args, **kw)¶

Convenience shortcut. Strings to be joined do not have to be passed as list or tuple.

Notes

An implicit conversion of objects to strings is performed as well.

lingpy.util.lines_to_text(lines)¶

lingpy.util.lingpy_path(*comps)¶

lingpy.util.multicombinations2(iterable)¶

Convenience shortcut, for the name, see the Wikipedia article on Combination.

https://en.wikipedia.org/wiki/Combination#Number_of_combinations_with_repetition

lingpy.util.nexus_slug(s)¶

Converts a string to a nexus “safe” representation (i.e. removes many unicode characters and removes some punctuation characters).

Parameters: s : str

A string to convert to a nexus safe format.
Returns: s : str

A string containing a nexus safe label.

lingpy.util.random_choices(population, weights=None, cum_weights=None, k=1)¶

Return a population sample from weighted elements.

In particular, return a k sized list of elements chosen from population with replacement and according to a list of weights. If a weights sequence is specified, selections are made according to the relative weights. Alternatively, if a cum_weights sequence is given, the selections are made according to the cumulative weights. For example, the relative weights [10, 5, 30, 5] are equivalent to the cumulative weights [10, 15, 45, 50]. Internally, the relative weights are converted to the cumulative weights before making selections, so supplying the cumulative weights saves work.

This function is compatible with the random.choices() function available in Python’s standard library from version 3.6 on. It can be replaced by the standard implementation once the version requirement is updated.

Parameters

population: list :

A list of elements from which the element(s) will be drawn.

weights: list :

A list of any numeric type with the relative weight of each element. Either weights or cum_weights must be provided.

cum_weights: list :

A list of any numeric type with the accumulated weight of each element. Either weights or cum_weights must be provided.

k: int :

The number of elements to be drawn, with replacement.

Returns

sample: list :

A list of elements randomly drawn according to the specified weights.

lingpy.util.read_config_file(path, **kw)¶: Read lines of a file ignoring commented lines and empty lines.

lingpy.util.read_text_file(path, normalize=None, lines=False)¶

Read a text file encoded in utf-8.

Parameters

path : { Path, str }

File-system path of the file.

normalize : { None, “NFC”, “NFC” }

If not None a valid unicode normalization mode must be passed.

lines : bool (default=False)

Flag signalling whether to return a list of lines (without the line-separation character).

Returns

file_content : { list, str }

File content as unicode object or list of lines as unicode objects.

Notes

The whole file is read into memory.

lingpy.util.setdefaults(d, **kw)¶

Shortcut for a common idiom, setting multiple default values at once.

Parameters

d : dict

Dictionary to be updated.

kw : dict

Dictionary with default values.

lingpy.util.tabjoin(*args, **kw)¶

Convenience shortcut. Strings to be joined do not have to be passed as list or tuple.

Notes

An implicit conversion of objects to strings is performed as well.

lingpy.util.write_text_file(path, content, normalize=None, log=True)¶

Write a text file encoded in utf-8.

Parameters

path : {str, Path}

File-system path of the file.

content : str

The text content to be written.

normalize : { None, “NFC”, “NFD” } (default=False)

If not None a valid unicode normalization mode must be passed.

log : bool (default=True)

Indicate whether you want to log the result of the file writing process.

Module contents¶

LingPy package for quantitative tasks in historical linguistics.

Documentation is available in the docstrings. Online documentation is available at http://lingpy.org

Subpackages¶

algorithm — Basic Algorithms for Sequence Comparison align — Specific Algorithms Alignment Analyses basic — Basic Classes for Language Comparison compare — Basic Modules for Language Comparison convert — Functions for Format Conversion data — Data Handling evaluate — Basic Classes and Functions for Algorithm Evaluation read — Basic Functions for Data Input sequence — Basic Functions for Sequence Modeling thirdparty — Temporary Forks of Third-Party-Modules