# `ldif` LDIF parser and generator

This module parses and generates LDAP data in the format LDIF. It is implemented in pure Python and does not rely on any non-standard modules. Therefore it can be used stand-alone without the rest of the python-ldap package.

See also

RFC 2849 - The LDAP Data Interchange Format (LDIF) - Technical Specification

## Functions

ldif.CreateLDIF(dn, record, base64_attrs=None, cols=76)

  Create LDIF single formatted record including trailing empty line. This is a compatibility function.

  dn

    string-representation of distinguished name

  record

    Either a dictionary holding the LDAP entry {attrtype:record} or a list with a modify list like for LDAPObject.modify().

  base64_attrs

    list of attribute types to be base64-encoded in any case

  cols

    Specifies how many columns a line may have before it’s folded into many lines.

  Deprecated since version 3.0: `ldif.CreateLDIF()` is deprecated. It will be removed in version 3.1. Use `ldif.LDIFWriter.unparse()` with a file or `io.StringIO` instead.

ldif.ParseLDIF(f, ignore_attrs=None, maxentries=0)

  Parse LDIF records read from file. This is a compatibility function.

  Deprecated since version 3.0: `ldif.ParseLDIF()` is deprecated. It will be removed in version 3.1. Use the `all_records` attribute of the returned value of `ldif.LDIFRecordList.parse()` instead.

## Classes

class ldif.LDIFWriter(output_file, base64_attrs=None, cols=76, line_sep='\n')

  Write LDIF entry or change records to file object Copy LDIF input to a file output object containing all data retrieved via URLs

  unparse(dn, record)
    dn

      string-representation of distinguished name

    record

      Either a dictionary holding the LDAP entry {attrtype:record} or a list with a modify list like for LDAPObject.modify().

class ldif.LDIFParser(input_file, ignored_attr_types=None, max_entries=0, process_url_schemes=None, line_sep='\n')

  Base class for a LDIF parser. Applications should sub-class this class and override method handle() to implement something meaningful.

  Public class attributes:

  records_read

    Counter for records processed so far

  handle(dn, entry)

    Process a single content LDIF record. This method should be implemented by applications using LDIFParser.

  handle_modify(dn, modops, controls=None)

    Process a single LDIF record representing a single modify operation. This method should be implemented by applications using LDIFParser.

  parse()

    Invokes LDIFParser.parse_entry_records() for backward compatibility

  parse_entry_records()

    Continuously read and parse LDIF entry records

class ldif.LDIFRecordList(input_file, ignored_attr_types=None, max_entries=0, process_url_schemes=None)

  Collect all records of a LDIF file. It can be a memory hog!

  Records are stored in `all_records` as a single list of 2-tuples (dn, entry), after calling `parse()`.

  all_records

    List storing parsed records.

  handle(dn, entry)

    Append a single record to the list of all records (`all_records`).

  handle_modify(dn, modops, controls=None)

    Process a single LDIF record representing a single modify operation. This method should be implemented by applications using LDIFParser.

class ldif.LDIFCopy(input_file, output_file, ignored_attr_types=None, max_entries=0, process_url_schemes=None, base64_attrs=None, cols=76, line_sep='\n')

  Copy LDIF input to LDIF output containing all data retrieved via URLs

  handle(dn, entry)

    Write single LDIF record to output file.

## Example

The following example demonstrates how to write LDIF output of an LDAP entry with `ldif` module.

    >>> import sys, ldif
    >>> entry={'objectClass': [b'top', b'person'], 'cn': [b'Michael Stroeder'], 'sn': [b'Stroeder']}
    >>> dn='cn=Michael Stroeder,ou=Test'
    >>> ldif_writer=ldif.LDIFWriter(sys.stdout)
    >>> ldif_writer.unparse(dn, entry)
    dn: cn=Michael Stroeder,ou=Test
    cn: Michael Stroeder
    objectClass: top
    objectClass: person
    sn: Stroeder

The following example demonstrates how to parse an LDIF file with `ldif` module, skip some entries and write the result to stdout.

    import sys
    from ldif import LDIFParser,LDIFWriter

    SKIP_DN = ["uid=foo,ou=People,dc=example,dc=com",
       "uid=bar,ou=People,dc=example,dc=com"]

    class MyLDIF(LDIFParser):
       def __init__(self,input,output):
          LDIFParser.__init__(self,input)
          self.writer = LDIFWriter(output)

       def handle(self,dn,entry):
          if dn in SKIP_DN:
            return
          self.writer.unparse(dn,entry)

    parser = MyLDIF(open("input.ldif", 'rb'), sys.stdout)
    parser.parse()