coalib.parsing package


coalib.parsing.CliParsing module


Checks if there are any conflicting arguments passed.

Parameters:sections – The {section_name: section_object} dictionary to check conflicts for.
Returns:True if no conflicts occur.
Raises:SystemExit – If there are conflicting arguments (exit code: 2)
coalib.parsing.CliParsing.parse_cli(arg_list=None, origin='/home/docs/checkouts/', arg_parser=None, key_value_delimiters=('=', ':'), comment_seperators=(), key_delimiters=(', ', ), section_override_delimiters=('.', ))[source]

Parses the CLI arguments and creates sections out of it.

  • arg_list – The CLI argument list.
  • origin – Directory used to interpret relative paths given as argument.
  • arg_parser – Instance of ArgParser that is used to parse none-setting arguments.
  • key_value_delimiters – Delimiters to separate key and value in setting arguments.
  • comment_seperators – Allowed prefixes for comments.
  • key_delimiters – Delimiter to separate multiple keys of a setting argument.
  • section_override_delimiters – The delimiter to delimit the section from the key name (e.g. the ‘.’ in sect.key = value).

A dictionary holding section names as keys and the sections themselves as value.

coalib.parsing.CliParsing.parse_custom_settings(sections, custom_settings_list, origin, line_parser)[source]

Parses the custom settings given to coala via -S something=value.

  • sections – The Section dictionary to add to (mutable).
  • custom_settings_list – The list of settings strings.
  • origin – The originating directory.
  • line_parser – The LineParser to use.

coalib.parsing.ConfParser module

class coalib.parsing.ConfParser.ConfParser(key_value_delimiters=('=', ), comment_seperators=('#', ), key_delimiters=(', ', ' '), section_name_surroundings=mappingproxy({'[': ']'}), remove_empty_iter_elements=True)[source]

Bases: object

get_section(name, create_if_not_exists=False)[source]
parse(input_data, overwrite=False)[source]

Parses the input and adds the new data to the existing.

  • input_data – The filename to parse from.
  • overwrite – If True, wipes all existing Settings inside this instance and adds only the newly parsed ones. If False, adds the newly parsed data to the existing one (and overwrites already existing keys with the newly parsed values).

A dictionary with (lowercase) section names as keys and their Setting objects as values.

coalib.parsing.DefaultArgParser module

class coalib.parsing.DefaultArgParser.CustomFormatter(prog, indent_increment=2, max_help_position=24, width=None)[source]

Bases: argparse.RawDescriptionHelpFormatter

A Custom Formatter that will keep the metavars in the usage but remove them in the more detailed arguments section.


This function creates an ArgParser to parse command line arguments.

Parameters:formatter_class – Formatting the arg_parser output into a specific form. For example: In the manpage format.

coalib.parsing.Globbing module

coalib.parsing.Globbing.fnmatch(name, globs)[source]

Tests whether name matches one of the given globs.

  • name – File or directory name
  • globs – Glob string with wildcards or list of globs

Boolean: Whether or not name is matched by glob

Glob Syntax:

  • ‘[seq]’: Matches any character in seq. Cannot be empty. Any

    special character looses its special meaning in a set.

  • ‘[!seq]’: Matches any character not in seq. Cannot be empty. Any

    special character looses its special meaning in a set.

  • ‘(seq_a|seq_b)’: Matches either sequence_a or sequence_b as a whole.

    More than two or just one sequence can be given.

  • ‘?’: Matches any single character.

  • ‘*’: Matches everything but os.sep.

  • ‘**’: Matches everything.


Iterates all filesystem paths that get matched by the glob pattern. Syntax is equal to that of fnmatch.

Parameters:pattern – Glob pattern with wildcards
Returns:List of all file names that match pattern

Escapes the given string with [c] pattern. Examples:

>>> from coalib.parsing.Globbing import glob_escape
>>> glob_escape('test (1)')
'test [(]1[)]'
>>> glob_escape('test folder?')
'test folder[?]'
>>> glob_escape('test*folder')
Parameters:input_string – String that is to be escaped with [ ].
Returns:Escaped string in which all the special glob characters ()[]|?* are escaped.

Checks whether pattern has any wildcards.

Parameters:pattern – Glob pattern that may contain wildcards
Returns:Boolean: Whether or not there are wildcards in pattern

Iterates all filesystem paths that get matched by the glob pattern. Syntax is equal to that of fnmatch.

Parameters:pattern – Glob pattern with wildcards
Returns:Iterator that yields all file names that match pattern
coalib.parsing.Globbing.relative_flat_glob(dirname, basename)[source]

Non-recursive glob for one directory. Does not accept wildcards.

  • dirname – Directory name
  • basename – Basename of a file in dir of dirname

List containing Basename if the file exists

coalib.parsing.Globbing.relative_recursive_glob(dirname, pattern)[source]

Recursive Glob for one directory and all its (nested) subdirectories. Accepts only ‘**’ as pattern.

  • dirname – Directory name
  • pattern – The recursive wildcard ‘**’

Iterator that yields all the (nested) subdirectories of the given dir

coalib.parsing.Globbing.relative_wildcard_glob(dirname, pattern)[source]

Non-recursive glob for one directory. Accepts wildcards.

  • dirname – Directory name
  • pattern – Glob pattern with wildcards

List of files in the dir of dirname that match the pattern


Translates a pattern into a regular expression.

Parameters:pattern – Glob pattern with wildcards
Returns:Regular expression with the same meaning

coalib.parsing.LineParser module

class coalib.parsing.LineParser.LineParser(key_value_delimiters=('=', ), comment_separators=('#', ), key_delimiters=(', ', ' '), section_name_surroundings=None, section_override_delimiters=('.', ))[source]

Bases: object


Note that every value in the returned tuple besides the value is unescaped. This is so since the value is meant to be put into a Setting later thus the escapes may be needed there.

Parameters:line – The line to parse.
Returns:section_name (empty string if it’s no section name), [(section_override, key), ...], value, comment

Module contents

The StringProcessing module contains various functions for extracting information out of strings.

Most of them support regexes for advanced pattern matching.