Low-Level Extraction Interface

The low level extraction interface can be used to extract from directories or files directly. Normally this is not needed as the command line tools can do that for you.

Extraction Functions

The extraction functions are what the command line tools use internally to extract strings.

babel.messages.extract.extract_from_dir(dirname=None, method_map=[('**.py', 'python')], options_map=None, keywords={'N_': None, '_': None, 'dgettext': (2,), 'dngettext': (2, 3), 'gettext': None, 'ngettext': (1, 2), 'npgettext': ((1, 'c'), 2, 3), 'pgettext': ((1, 'c'), 2), 'ugettext': None, 'ungettext': (1, 2)}, comment_tags=(), callback=None, strip_comment_tags=False)

Extract messages from any source files found in the given directory.

This function generates tuples of the form (filename, lineno, message, comments, context).

Which extraction method is used per file is determined by the method_map parameter, which maps extended glob patterns to extraction method names. For example, the following is the default mapping:

>>> method_map = [
...     ('**.py', 'python')
... ]

This basically says that files with the filename extension “.py” at any level inside the directory should be processed by the “python” extraction method. Files that don’t match any of the mapping patterns are ignored. See the documentation of the pathmatch function for details on the pattern syntax.

The following extended mapping would also use the “genshi” extraction method on any file in “templates” subdirectory:

>>> method_map = [
...     ('**/templates/**.*', 'genshi'),
...     ('**.py', 'python')
... ]

The dictionary provided by the optional options_map parameter augments these mappings. It uses extended glob patterns as keys, and the values are dictionaries mapping options names to option values (both strings).

The glob patterns of the options_map do not necessarily need to be the same as those used in the method mapping. For example, while all files in the templates folders in an application may be Genshi applications, the options for those files may differ based on extension:

>>> options_map = {
...     '**/templates/**.txt': {
...         'template_class': 'genshi.template:TextTemplate',
...         'encoding': 'latin-1'
...     },
...     '**/templates/**.html': {
...         'include_attrs': ''
...     }
... }
Parameters:
  • dirname – the path to the directory to extract messages from. If not given the current working directory is used.
  • method_map – a list of (pattern, method) tuples that maps of extraction method names to extended glob patterns
  • options_map – a dictionary of additional options (optional)
  • keywords – a dictionary mapping keywords (i.e. names of functions that should be recognized as translation functions) to tuples that specify which of their arguments contain localizable strings
  • comment_tags – a list of tags of translator comments to search for and include in the results
  • callback – a function that is called for every file that message are extracted from, just before the extraction itself is performed; the function is passed the filename, the name of the extraction method and and the options dictionary as positional arguments, in that order
  • strip_comment_tags – a flag that if set to True causes all comment tags to be removed from the collected comments.
See:

pathmatch

babel.messages.extract.extract_from_file(method, filename, keywords={'N_': None, '_': None, 'dgettext': (2, ), 'dngettext': (2, 3), 'gettext': None, 'ngettext': (1, 2), 'npgettext': ((1, 'c'), 2, 3), 'pgettext': ((1, 'c'), 2), 'ugettext': None, 'ungettext': (1, 2)}, comment_tags=(), options=None, strip_comment_tags=False)

Extract messages from a specific file.

This function returns a list of tuples of the form (lineno, message, comments, context).

Parameters:
  • filename – the path to the file to extract messages from
  • method – a string specifying the extraction method (.e.g. “python”)
  • keywords – a dictionary mapping keywords (i.e. names of functions that should be recognized as translation functions) to tuples that specify which of their arguments contain localizable strings
  • comment_tags – a list of translator tags to search for and include in the results
  • strip_comment_tags – a flag that if set to True causes all comment tags to be removed from the collected comments.
  • options – a dictionary of additional options (optional)
Returns:

list of tuples of the form (lineno, message, comments, context)

Return type:

list[tuple[int, str|tuple[str], list[str], str|None]

babel.messages.extract.extract(method, fileobj, keywords={'N_': None, '_': None, 'dgettext': (2, ), 'dngettext': (2, 3), 'gettext': None, 'ngettext': (1, 2), 'npgettext': ((1, 'c'), 2, 3), 'pgettext': ((1, 'c'), 2), 'ugettext': None, 'ungettext': (1, 2)}, comment_tags=(), options=None, strip_comment_tags=False)

Extract messages from the given file-like object using the specified extraction method.

This function returns tuples of the form (lineno, message, comments, context).

The implementation dispatches the actual extraction to plugins, based on the value of the method parameter.

>>> source = b'''# foo module
... def run(argv):
...    print(_('Hello, world!'))
... '''
>>> from babel._compat import BytesIO
>>> for message in extract('python', BytesIO(source)):
...     print(message)
(3, u'Hello, world!', [], None)
Parameters:
  • method – an extraction method (a callable), or a string specifying the extraction method (.e.g. “python”); if this is a simple name, the extraction function will be looked up by entry point; if it is an explicit reference to a function (of the form package.module:funcname or package.module.funcname), the corresponding function will be imported and used
  • fileobj – the file-like object the messages should be extracted from
  • keywords – a dictionary mapping keywords (i.e. names of functions that should be recognized as translation functions) to tuples that specify which of their arguments contain localizable strings
  • comment_tags – a list of translator tags to search for and include in the results
  • options – a dictionary of additional options (optional)
  • strip_comment_tags – a flag that if set to True causes all comment tags to be removed from the collected comments.
Raises:

ValueError – if the extraction method is not registered

Returns:

iterable of tuples of the form (lineno, message, comments, context)

Return type:

Iterable[tuple[int, str|tuple[str], list[str], str|None]

Language Parsing

The language parsing functions are used to extract strings out of source files. These are automatically being used by the extraction functions but sometimes it can be useful to register wrapper functions, then these low level functions can be invoked.

New functions can be registered through the setuptools entrypoint system.

babel.messages.extract.extract_python(fileobj, keywords, comment_tags, options)

Extract messages from Python source code.

It returns an iterator yielding tuples in the following form (lineno, funcname, message, comments).

Parameters:
  • fileobj – the seekable, file-like object the messages should be extracted from
  • keywords – a list of keywords (i.e. function names) that should be recognized as translation functions
  • comment_tags – a list of translator tags to search for and include in the results
  • options – a dictionary of additional options (optional)
Return type:

iterator

babel.messages.extract.extract_javascript(fileobj, keywords, comment_tags, options)

Extract messages from JavaScript source code.

Parameters:
  • fileobj – the seekable, file-like object the messages should be extracted from
  • keywords – a list of keywords (i.e. function names) that should be recognized as translation functions
  • comment_tags – a list of translator tags to search for and include in the results
  • options

    a dictionary of additional options (optional) Supported options are: * jsx – set to false to disable JSX/E4X support. * template_string – set to false to disable ES6

    template string support.
babel.messages.extract.extract_nothing(fileobj, keywords, comment_tags, options)

Pseudo extractor that does not actually extract anything, but simply returns an empty list.