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 LDIF input into a single list. of 2-tuples (dn,entry). It can be a memory hog!

handle(dn, entry)

Append single record to dictionary of 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':['top','person'],'cn':['Michael Stroeder'],'sn':['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()