python-ldapserver

https://uffd.cccv-pages.de/python-ldapserver/
Admin
python-ldapserver is a self-contained pure Python 3 library for implementing special-purpose LDAPv3...
Tokens:13,024
Snippets:83
Trust Score:5.2
Update:6 months ago
Show doc for...
Tokens:
Raw
### do_starttls

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Performs the StartTLS extended operation to upgrade the connection to TLS.

```APIDOC
## do_starttls()

### Description
Do StartTLS extended operation (RFC 4511). Called by handle_extended() if supports_starttls is True.

### Notes
The success response is sent before this method is called. If this method fails, the LDAP connection is immediately terminated.
```

--------------------------------

### Create and Check DN Hierarchy

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Demonstrates creating DN objects and checking their hierarchical relationships using `is_direct_child_of`.

```python
>>> schema = schema.RFC4519_SCHEMA
>>> dn1 = DN(schema, 'uid=jsmith,dc=example,dc=net')
>>> dn2 = DN(schema, 'dc=example,dc=net')
>>> dn3 = DN(schema, 'dc=net')
>>> dn1.is_direct_child_of(dn2)
True
>>> dn1.is_direct_child_of(dn1) or dn1.is_direct_child_of(dn3)
False
```

--------------------------------

### create_entry

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Instantiates an Entry object based on a template, allowing for RDN construction and attribute assignment.

```APIDOC
## create_entry

### Description
Instantiate an Entry object based on a template. Template attributes set to WILDCARD are stripped, and only those attributes may be overwritten.

### Parameters
#### Path Parameters
- **rdn_value** (any) - Required - RDN value for DN construction

### Response
- **Entry** (object) - The instantiated Entry object
```

--------------------------------

### Schema Attributes and Classes

Source: https://uffd.cccv-pages.de/python-ldapserver/master/genindex.html

Documentation for schema-related attributes and classes within the ldapserver library.

```APIDOC
## Schema Components

### Description
Defines the structure and components of the LDAP schema, including attribute types, object classes, and matching rules.

### Attributes
- `matching_rule_definitions`: Definitions for matching rules.
- `matching_rule_use_definitions`: Definitions for the use of matching rules.
- `matching_rules`: A collection of matching rules.
- `object_class_definitions`: Definitions for object classes.
- `object_classes`: A collection of object classes.
- `operational_attribute_types`: Types of operational attributes.

### Classes
- `MatchingRuleDefinition`: Represents a definition for a matching rule.
- `MatchingRuleUseDefinition`: Represents the usage definition of a matching rule.
- `ObjectClass`: Represents an LDAP object class.
- `ObjectClassDefinition`: Represents a definition for an object class.
- `ObjectClassKind`: Represents the kind of an object class.
- `ObjectEntry`: Represents an entry in the schema.
- `OrderingMatchingRule`: Represents an ordering matching rule.
- `PartialAttribute`: Represents a partial attribute.
- `Syntax`: Represents an attribute syntax.
- `SyntaxDefinition`: Represents a definition for an attribute syntax.
```

--------------------------------

### Create RDN from Multiple Assertions

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Shows how to create an RDN object with multiple attribute assertions, formatted according to RFC 4514.

```python
>>> str(RDN(ou='Sales', cn='J.  Smith'))
'ou=Sales+cn=J.  Smith'
```

--------------------------------

### Extract Search Constraints with EntryTemplate

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Use EntryTemplate to define a template for dynamic entries and extract potential search constraints based on search parameters. This is useful for optimizing search operations by pre-filtering potential matches.

```python
>>> subschema = SubschemaSubentry(schema.RFC4519_SCHEMA, 'cn=Subschema')
>>> template = subschema.EntryTemplate('ou=users,dc=example,dc=com', 'cn', objectclass=['person', 'top'], sn=WILDCARD)
>>> template.extract_search_constraints('cn=test,ou=users,dc=example,dc=com', ldap.SearchScope.baseObject, ldap.FilterEqual('sn', b'foobar'))
subschema.AttributeDict(cn=['test'], sn=['foobar'])
```

--------------------------------

### LDAP Server Core Classes and Methods

Source: https://uffd.cccv-pages.de/python-ldapserver/master/genindex.html

This section details core classes like DN, RDN, and LDAPRequestHandler, along with their associated methods and attributes.

```APIDOC
## Classes and Methods Reference

### `ldapserver.DN`

- **`__str__()`**: Returns a string representation of the DN.

### `ldapserver.DNWithUID`

- **`__str__()`**: Returns a string representation of the DN with UID.
- **`dn`**: The distinguished name.

### `ldapserver.RDN`

- **`__str__()`**: Returns a string representation of the RDN.
- **`attribute`**: The attribute of the RDN.
- **`attribute_type`**: The type of the attribute in the RDN.

### `ldapserver.RDNAssertion`

- **`__str__()`**: Returns a string representation of the RDN assertion.
- **`attribute`**: The attribute involved in the assertion.
- **`attribute_type`**: The type of the attribute in the assertion.

### `ldapserver.Entry`

- **`compare(attribute, value)`**: Compares an attribute with a given value.
- **`dn`**: The distinguished name of the entry.

### `ldapserver.EntryTemplate`

- **`create_entry()`**: Creates a new entry.

### `ldapserver.LDAPRequestHandler`

- **`bind_object`**: The object used for binding.
- **`do_bind_sasl_anonymous()`**: Handles anonymous SASL bind requests.
- **`do_bind_sasl_external()`**: Handles external SASL bind requests.
- **`do_bind_sasl_plain()`**: Handles plain SASL bind requests.
- **`do_bind_simple_anonymous()`**: Handles anonymous simple bind requests.
- **`do_bind_simple_authenticated()`**: Handles authenticated simple bind requests.
- **`do_bind_simple_unauthenticated()`**: Handles unauthenticated simple bind requests.
- **`do_compare()`**: Handles compare requests.
- **`do_password_modify()`**: Handles password modify requests.
- **`do_search()`**: Handles search requests.
- **`do_starttls()`**: Handles StartTLS requests.
- **`do_whoami()`**: Handles whoami requests.

### `ldapserver.SubschemaSubentry`

- **`dn`**: The distinguished name of the subschema subentry.
- **`AttributeDict`**: A dictionary-like object for attributes.

```

--------------------------------

### EntryTemplate.match_search

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Determines if entries based on a template might match specific search parameters.

```APIDOC
## SEARCH EntryTemplate.match_search

### Description
Return whether entries based on this template might match the search parameters.

### Parameters
#### Path Parameters
- **base_obj** (str) - Required - DN of the base entry
- **scope** (ldap.SearchScope) - Required - Scope of base_obj
- **filter_obj** (ldap.Filter) - Required - Search filter

### Response
#### Success Response (200)
- **result** (bool) - True if entries based on this template might match the SEARCH parameters or False if they do not match.
```

--------------------------------

### Ordering Matching Rules

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Details about ordering matching rules.

```APIDOC
## Ordering Matching Rule Class

### `OrderingMatchingRule`

#### Description
Represents an ordering matching rule.

#### Methods
* **`match_less`**(_attribute_values_, _assertion_value_)
  * Description: Return whether any attribute value is less than assertion value.
  * Returns: bool
  * Raises: **exceptions.LDAPError**
* **`match_greater_or_equal`**(_attribute_values_, _assertion_value_)
  * Description: Return whether any attribute value is greater than or equal to assertion value.
  * Returns: bool
  * Raises: **exceptions.LDAPError**

#### Attributes
* **definition**: Corresponding `MatchingRuleDefinition` object.

```

--------------------------------

### Matching Rule Methods

Source: https://uffd.cccv-pages.de/python-ldapserver/master/genindex.html

Details on various matching rule methods available in the AttributeType and related classes.

```APIDOC
## Matching Rule Methods

### Description
Provides methods for comparing and matching attribute values based on different rules.

### Methods
- `match_approx()`: Checks for approximate matches.
- `match_equal()`: Checks for exact equality.
- `match_extensible()`: Checks for extensible matches.
- `match_greater_or_equal()`: Checks if a value is greater than or equal to another.
- `match_less()`: Checks if a value is less than another.
- `match_less_or_equal()`: Checks if a value is less than or equal to another.
- `match_substr()`: Checks for substring matches.
```

--------------------------------

### Represent ObjectClassDefinition as RFC4512 string

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Returns the string representation of an object class definition.

```text
( 2.5.6.0 NAME ‘top’ DESC ‘top of the superclass chain’ ABSTRACT MUST objectClass )
```

--------------------------------

### Entry.compare

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Performs a compare operation on an LDAP entry attribute.

```APIDOC
## COMPARE Entry.compare

### Description
Return the result of the COMPARE operation applied to the entry.

### Parameters
#### Path Parameters
- **dn** (str) - Required - DN of the entry to be compared
- **attribute** (str) - Required - Attribute OID or short descriptive name
- **value** (bytes) - Required - Assertion value

### Response
#### Success Response (200)
- **result** (bool) - True/False if COMPARE operation evaluates to TRUE/FALSE.
```

--------------------------------

### Represent MatchingRuleUseDefinition as RFC4512 string

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Returns the string representation of a matching rule use definition.

```text
( 2.5.13.0 NAME ‘objectIdentifierMatch’ APPLIES ( supportedControl $ supportedExtension $ supportedFeatures $ supportedApplicationContext ) )
```

--------------------------------

### Attribute and Object Class Properties

Source: https://uffd.cccv-pages.de/python-ldapserver/master/genindex.html

Details on properties related to attribute types and object classes.

```APIDOC
## Attribute and Object Class Properties

### Description
Properties associated with attribute types and object classes, including their names, OIDs, and modification constraints.

### Attribute Properties
- `name`: The name of the attribute type.
- `names`: A list of names for the attribute type.
- `oid`: The Object Identifier (OID) of the attribute type.
- `ordering`: Specifies the ordering for the attribute type.

### Object Class Properties
- `may`: Optional attributes that may be included in the object class.
- `must`: Required attributes for the object class.
- `no_user_modification`: Indicates if user modification is disallowed.
- `obsolete`: Indicates if the attribute type or object class is obsolete.

### Other Properties
- `matchingRule`: The matching rule used for an extensible match.
- `matchValue`: The value used in an extensible match.
- `object_attribute`: An attribute of the DN.
- `object_attribute_type`: The type of an attribute of the DN.
- `object_value`: The value of the DN.
- `objectName`: The name of an object in a search result entry.

```

--------------------------------

### LDAP Server Exceptions

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

This section details the various exceptions that can be raised by the LDAP server, indicating specific error conditions encountered during operation.

```APIDOC
## LDAP Server Exceptions

This section details the various exceptions that can be raised by the LDAP server, indicating specific error conditions encountered during operation.

### LDAPBusy

#### Description
Indicates that the server is too busy to service the operation. (RFC 4511)

### LDAPUnavailable

#### Description
Indicates that the server is shutting down or a subsystem necessary to complete the operation is offline. (RFC 4511)

### LDAPUnwillingToPerform

#### Description
Indicates that the server is unwilling to perform the operation. (RFC 4511)

### LDAPLoopDetect

#### Description
Indicates that the server has detected an internal loop (e.g., while dereferencing aliases or chaining an operation). (RFC 4511)

### LDAPNamingViolation

#### Description
Indicates that the entry’s name violates naming restrictions. (RFC 4511)

### LDAPObjectClassViolation

#### Description
Indicates that the entry violates object class restrictions. (RFC 4511)

### LDAPNotAllowedOnNonLeaf

#### Description
Indicates that the operation is inappropriately acting upon a non-leaf entry. (RFC 4511)

### LDAPNotAllowedOnRDN

#### Description
Indicates that the operation is inappropriately attempting to remove a value that forms the entry’s relative distinguished name. (RFC 4511)

### LDAPEntryAlreadyExists

#### Description
Indicates that the request cannot be fulfilled (added, moved, or renamed) as the target entry already exists. (RFC 4511)

### LDAPObjectClassModsProhibited

#### Description
Indicates that an attempt to modify the object class(es) of an entry’s ‘objectClass’ attribute is prohibited. (RFC 4511)

### LDAPAffectsMultipleDSAs

#### Description
Indicates that the operation cannot be performed as it would affect multiple servers (DSAs). (RFC 4511)

### LDAPOther

#### Description
Indicates the server has encountered an internal error. (RFC 4511)
```

--------------------------------

### Syntax.encode

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Encodes a native value into its LDAP-specific encoding.

```APIDOC
## encode

### Description
Encode value to its LDAP-specific encoding.

### Parameters
#### Request Body
- **value** (any) - Required - Native value

### Response
#### Success Response (200)
- **encoded_value** (bytes) - LDAP-specific encoding
```

--------------------------------

### Extensible Matching

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Functions for extensible matching of attribute values.

```APIDOC
## Extensible Matching

### `match_extensible`

#### Description
Return whether any attribute value matches the assertion value using a specified matching rule.

#### Parameters
* **attribute_values** (_List_ _of_ _any_) – Attribute values (type according to syntax)
* **assertion_value** (_bytes_) – Assertion value
* **matching_rule** (`EqualityMatchingRule`, `OrderingMatchingRule`, `SubstrMatchingRule` or None) – Optional matching rule, if None `AttributeType.equality` is used

#### Returns
* **bool** - True if any attribute values matches, False otherwise

#### Raises
* **exceptions.LDAPError** – if the result is undefined
```

--------------------------------

### Built-in Schemas

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Provides access to various pre-defined LDAP schemas.

```APIDOC
## Built-in Schemas

- **ldapserver.schema.RFC4512_SCHEMA**
- **ldapserver.schema.CORE_SCHEMA**
- **ldapserver.schema.RFC4519_SCHEMA**
- **ldapserver.schema.RFC4523_SCHEMA**
- **ldapserver.schema.RFC4524_SCHEMA**
- **ldapserver.schema.COSINE_SCHEMA**
- **ldapserver.schema.RFC3112_SCHEMA**
- **ldapserver.schema.RFC2079_SCHEMA**: Implements the labeledURIObject object class and the labeledURI attribute type.
- **ldapserver.schema.RFC2798_SCHEMA**: Implements the inetOrgPerson object class and its attribute types.
- **ldapserver.schema.INETORG_SCHMEA**
- **ldapserver.schema.RFC2307BIS_SCHEMA**: Implements draft-howard-rfc2307bis-02 (updated/extended NIS schema).
```

--------------------------------

### SyntaxDefinition Class

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Represents an LDAP syntax definition, providing methods for encoding and decoding values between native and LDAP-specific formats.

```APIDOC
## SyntaxDefinition

### Description
Represents an LDAP syntax definition. Provides functionality to encode native values to LDAP-specific bytes and decode LDAP-specific bytes back to native values.

### Methods
- **encode(schema, value)**: Encodes a native value to LDAP-specific bytes.
- **decode(schema, raw_value)**: Decodes LDAP-specific bytes to a native value.

### Parameters
#### encode
- **schema** (Schema) - Required - Schema context for encoding.
- **value** (any) - Required - Native value to encode.

#### decode
- **schema** (Schema) - Required - Schema context for decoding.
- **raw_value** (bytes) - Required - LDAP-specific encoding to decode.

### Response
#### encode
- **Returns** (bytes) - LDAP-specific encoding of the value.

#### decode
- **Returns** (any) - Native value.
- **Raises** (exceptions.LDAPError) - If raw_value is invalid.
```

--------------------------------

### SubstrMatchingRule.match_extensible

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Checks if any attribute values match a provided substring assertion.

```APIDOC
## match_extensible

### Description
Return whether any attribute value matches the substring assertion in assertion_value.

### Parameters
#### Request Body
- **attribute_values** (List of any) - Required - Attribute values (type according to attribute’s syntax)
- **assertion_value** (Tuple) - Required - 3-tuple with initial substring, any substrings and final substring

### Response
#### Success Response (200)
- **result** (bool) - True if any attribute values matches, False otherwise

### Errors
- **exceptions.LDAPError** - if the result is undefined
```

--------------------------------

### do_whoami

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Performs the 'Who am I?' extended operation to retrieve the current authorization identity.

```APIDOC
## do_whoami()

### Description
Do “Who am I?” extended operation (RFC 4532).

### Response
- **Returns** (str) - Current authorization identity (authzid) or empty string for anonymous sessions.
```

--------------------------------

### LDAP Schema Definitions

Source: https://uffd.cccv-pages.de/python-ldapserver/master/genindex.html

This section covers classes and attributes related to LDAP schema definitions, including AttributeType, ObjectClass, and Syntax.

```APIDOC
## LDAP Schema Definitions

### `ldapserver.schema.AttributeType`

- **`__str__()`**: Returns a string representation of the attribute type.
- **`decode(value)`**: Decodes a value according to the attribute type's syntax.
- **`definition`**: The definition of the attribute type.
- **`compatible_matching_rules`**: List of compatible matching rules.
- **`compatible_syntaxes`**: List of compatible syntaxes.

### `ldapserver.schema.AttributeTypeDefinition`

- **`__str__()`**: Returns a string representation of the attribute type definition.
- **`ABSTRACT`**: Indicates if the attribute type is abstract.
- **`desc`**: Description of the attribute type.
- **`directoryOperation`**: Usage in directory operations.
- **`distributedOperation`**: Usage in distributed operations.
- **`dSAOperation`**: Usage in DSA operations.

### `ldapserver.schema.AttributeTypeUsage`

- **`directoryOperation`**: Usage in directory operations.
- **`distributedOperation`**: Usage in distributed operations.
- **`dSAOperation`**: Usage in DSA operations.

### `ldapserver.schema.EqualityMatchingRule`

- **`definition`**: The definition of the matching rule.
- **`compatible_attribute_types`**: List of compatible attribute types.
- **`compatible_syntaxes`**: List of compatible syntaxes.

### `ldapserver.schema.MatchingRuleDefinition`

- **`__str__()`**: Returns a string representation of the matching rule definition.
- **`compatability_tag`**: Compatibility tag for the matching rule.
- **`desc`**: Description of the matching rule.

### `ldapserver.schema.MatchingRuleUseDefinition`

- **`__str__()`**: Returns a string representation of the matching rule use definition.
- **`applies`**: Indicates if the rule applies.
- **`desc`**: Description of the matching rule use.

### `ldapserver.schema.ObjectClass`

- **`definition`**: The definition of the object class.

### `ldapserver.schema.ObjectClassDefinition`

- **`__str__()`**: Returns a string representation of the object class definition.
- **`desc`**: Description of the object class.

### `ldapserver.schema.ObjectClassKind`

- **`ABSTRACT`**: Indicates if the object class is abstract.
- **`AUXILIARY`**: Indicates if the object class is auxiliary.

### `ldapserver.schema.OrderingMatchingRule`

- **`definition`**: The definition of the matching rule.
- **`compatible_attribute_types`**: List of compatible attribute types.
- **`compatible_syntaxes`**: List of compatible syntaxes.

### `ldapserver.schema.Schema`

- **`attribute_type_definitions`**: List of attribute type definitions.
- **`attribute_types`**: List of attribute types.

### `ldapserver.schema.SubstrMatchingRule`

- **`definition`**: The definition of the matching rule.
- **`compatible_attribute_types`**: List of compatible attribute types.
- **`compatible_syntaxes`**: List of compatible syntaxes.

### `ldapserver.schema.Syntax`

- **`__str__()`**: Returns a string representation of the syntax.
- **`decode(value)`**: Decodes a value according to the syntax.
- **`definition`**: The definition of the syntax.
- **`compatible_matching_rules`**: List of compatible matching rules.

### `ldapserver.schema.SyntaxDefinition`

- **`__str__()`**: Returns a string representation of the syntax definition.
- **`compatability_tags`**: Compatibility tags for the syntax.
- **`desc`**: Description of the syntax.

### Constants

- **`CORE_SCHEMA`**: Core schema definition.
- **`COSINE_SCHEMA`**: COSINE schema definition.

```

--------------------------------

### Schema API

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Classes for defining and interacting with LDAP schemas, including object classes and attribute types.

```APIDOC
## Schema, ObjectClass, and AttributeType

### Description
Manages LDAP schema definitions, including validation rules and attribute type definitions.

### Key Classes
- **Schema**: Container for all schema definitions.
- **ObjectClass**: Defines an LDAP object class.
- **AttributeType**: Defines an LDAP attribute type and its matching rules.

### Key Methods
- **AttributeType.encode()**: Encodes an attribute value.
- **AttributeType.decode()**: Decodes an attribute value.
- **Schema.extend()**: Extends the current schema with new definitions.
```

--------------------------------

### LDAP Error Exceptions

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

List of standard LDAP error classes used for exception handling.

```APIDOC
## LDAP Error Classes

The following exceptions are defined for LDAP operations:

- LDAPError, LDAPOperationsError, LDAPProtocolError, LDAPTimeLimitExceeded, LDAPSizeLimitExceeded, LDAPAuthMethodNotSupported, LDAPStrongerAuthRequired, LDAPAdminLimitExceeded, LDAPUnavailableCriticalExtension, LDAPConfidentialityRequired, LDAPNoSuchAttribute, LDAPUndefinedAttributeType, LDAPInappropriateMatching, LDAPConstraintViolation, LDAPAttributeOrValueExists, LDAPInvalidAttributeSyntax, LDAPNoSuchObject, LDAPAliasProblem, LDAPInvalidDNSyntax, LDAPAliasDereferencingProblem, LDAPInappropriateAuthentication, LDAPInvalidCredentials, LDAPInsufficientAccessRights, LDAPBusy, LDAPUnavailable, LDAPUnwillingToPerform, LDAPLoopDetect, LDAPNamingViolation, LDAPObjectClassViolation, LDAPNotAllowedOnNonLeaf, LDAPNotAllowedOnRDN, LDAPEntryAlreadyExists, LDAPObjectClassModsProhibited, LDAPAffectsMultipleDSAs, LDAPOther
```

--------------------------------

### LDAP Filter and Entry Structures

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Definitions for LDAP filter types and search result entry components.

```APIDOC
## LDAP Data Structures

### FilterLessOrEqual
- **attribute** (string) - The attribute to compare.
- **value** (string) - The value to compare against.

### FilterSubstrings
- **attribute** (string) - The attribute to search.
- **initial_substring** (string) - The starting substring.
- **any_substrings** (list) - List of intermediate substrings.
- **final_substring** (string) - The ending substring.

### FilterExtensibleMatch
- **matchingRule** (string) - The matching rule OID.
- **type** (string) - The attribute type.
- **matchValue** (string) - The value to match.
- **dnAttributes** (boolean) - Whether to match DN attributes.

### SearchResultEntry
- **objectName** (string) - The distinguished name of the entry.
- **attributes** (list) - List of PartialAttribute objects.

### PartialAttribute
- **type** (string) - The attribute type.
- **vals** (list) - List of attribute values.
```

--------------------------------

### RDN and RDNAssertion API

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Methods for managing Relative Distinguished Names and individual assertions.

```APIDOC
## RDN Class

### Description
Represents a Relative Distinguished Name consisting of one or more RDNAssertion objects.

### Methods
- **from_str(schema, expr)**: Parse string representation of an RDN according to RFC 4514.
- **__str__()**: Return string representation of RDN.

## RDNAssertion Class

### Description
Represents an individual assertion within an RDN.

### Methods
- **from_str(schema, expr)**: Parse string representation of an RDN assertion according to RFC 4514.
- **__str__()**: Return string representation of the assertion.
```

--------------------------------

### Equality Matching

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Functions for checking exact equality between attribute values and an assertion value.

```APIDOC
## Equality Matching

### `match_equal`

#### Description
Return whether any attribute value equals the assertion value.

#### Parameters
* **attribute_values** (_List_ _of_ _any_) – Attribute values (type according to syntax)
* **assertion_value** (_bytes_) – Assertion value

#### Returns
* **bool** - True if any attribute values matches, False otherwise

#### Raises
* **exceptions.LDAPError** – if the result is undefined
```

--------------------------------

### LDAP Filter Classes

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Base class and subclasses for constructing LDAP search filters according to RFC4515.

```APIDOC
## class ldapserver.ldap.Filter

### Description
Base class for filters in SEARCH operations. All subclasses implement `__str__` according to RFC4515 “String Representation of Search Filters”.

## class ldapserver.ldap.FilterAnd(_filters=None)

### Description
AND conjunction of multiple filters `(&filters...)
Supports RFC4526: Empty AND filters (`(&)`) are considered valid and evaluate to TRUE.

### Parameters
#### Request Body
- **_filters_** (List[Filter]) - Required - A list of filters to AND together.

## class ldapserver.ldap.FilterOr(_filters=None)

### Description
OR conjunction of multiple filters `(|filters...)
Supports RFC4526: Empty OR filters (`(|)`) are considered valid and evaluate to FALSE.

### Parameters
#### Request Body
- **_filters_** (List[Filter]) - Required - A list of filters to OR together.

## class ldapserver.ldap.FilterNot(_filter=None)

### Description
Negation of a filter `(!filter)`.

### Parameters
#### Request Body
- **_filter_** (Filter) - Required - The filter to negate.

## class ldapserver.ldap.FilterPresent(_attribute=None)

### Description
Attribute present filter `(attribute=*)

### Parameters
#### Request Body
- **_attribute_** (str) - Required - The attribute name to check for presence.

## class ldapserver.ldap.FilterEqual(_attribute=None, _value=None)

### Description
Attribute equal filter `(attribute=value)`.

### Parameters
#### Request Body
- **_attribute_** (str) - Required - The attribute name.
- **_value_** (bytes) - Required - The value to compare against.

## class ldapserver.ldap.FilterApproxMatch(_attribute=None, _value=None)

### Description
Attribute approximately equal filter `(attribute~=value)`.

### Parameters
#### Request Body
- **_attribute_** (str) - Required - The attribute name.
- **_value_** (bytes) - Required - The value to compare approximately.

## class ldapserver.ldap.FilterGreaterOrEqual(_attribute=None, _value=None)

### Description
Attribute greater or equal filter `(attribute>=value)`.

### Parameters
#### Request Body
- **_attribute_** (str) - Required - The attribute name.
- **_value_** (bytes) - Required - The value to compare against.

## class ldapserver.ldap.FilterLessOrEqual(_attribute=None, _value=None)

### Description
Attribute less or equal filter `(attribute<=value)`.

### Parameters
#### Request Body
- **_attribute_** (str) - Required - The attribute name.
- **_value_** (bytes) - Required - The value to compare against.

## class ldapserver.ldap.FilterSubstrings(*args, **kwargs)

### Description
Attribute substrings filter `(attribute=initial*any1*any2*final)`.

### Properties
- **initial_substring** (bytes) - Initial substring. None if there is no initial substring or if the filter is invalid.
- **any_substrings** (List[bytes]) - List of “any” substrings (may be empty).
- **final_substring** (bytes) - Final substring. None if there is no final substring or if the filter is invalid.

## class ldapserver.ldap.FilterExtensibleMatch(*args, **kwargs)

### Description
Extensible match filter `(attribute:caseExactMatch:=value)`.

### Parameters
- **matchingRule** (str or None) - Matching rule OID or short descriptive name (optional).
- **type** (str or None) - Attribute type OID or short descriptive name (optional).
- **matchValue** (bytes) - Assertion value (encoded with LDAP-specific encoding according to matching rule syntax).
- **dnAttributes** (bool) - Apply matching to all RDN assertions in addition to attribute values (e.g. `(dc:dn:=example)` matches `cn=test,dc=example,dc=com` even if it has no `dc` attribute, because `dc=example` is part of its DN).
```

--------------------------------

### Equality Matching Rule Class

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Details about equality matching rules.

```APIDOC
## Equality Matching Rule Class

### `EqualityMatchingRule`

#### Description
Represents an equality matching rule.

#### Methods
* **`match_extensible`**(_attribute_values_, _assertion_value_)
  * Description: Return whether any attribute value matches the assertion value.
  * Returns: bool
  * Raises: **exceptions.LDAPError**
* **`match_equal`**(_attribute_values_, _assertion_value_)
  * Description: Return whether any attribute value equals the assertion value.
  * Returns: bool
  * Raises: **exceptions.LDAPError**
* **`match_approx`**(_attribute_values_, _assertion_value_)
  * Description: Return whether any attribute value approximately equals the assertion value.
  * Returns: bool
  * Raises: **exceptions.LDAPError**

#### Attributes
* **definition**: Corresponding `MatchingRuleDefinition` object.
* **oid**: Numeric OID of matching rule (string, e.g. `'2.5.13.2'`).
* **syntax**: Syntax of assertion values. For `schema.SubstrMatchingRule.match_substr` the syntax of the attribute’s equality matching rule is used instead.
* **names**: List of short descriptive names of the matching rule (list of strings, e.g. `['caseIgnoreMatch']`).
* **ref**: Preferred name of matching rule (first item of `names` or `oid`, e.g. `'caseIgnoreMatch'`).
* **compatible_syntaxes**: Set of all compatible syntaxes within the schema whose values the matching rule can be applied to.
* **compatible_attribute_types**: Set of all compatible attribute types within the schema whose values the matching rule can be applied to.
```

--------------------------------

### Substring Matching

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Functions for matching attribute values against substrings.

```APIDOC
## Substring Matching Functions

### Description
Provides functions to match attribute values based on initial, any, and final substrings.

### `match_substr`

#### Parameters
* **attribute_values** (_List_ _of_ _any_) – Attribute values (type according to syntax)
* **inital_substring** (_bytes_ _or_ _None_) – Substring to match the beginning (optional)
* **any_substrings** (_list_ _of_ _bytes_) – List of substrings to match between initial and final in order
* **final_substring** (_bytes_ _or_ _None_) – Substring to match the end (optional)

#### Returns
* **bool** - True if any attribute values matches, False otherwise

#### Raises
* **exceptions.LDAPError** – if the result is undefined
```

--------------------------------

### ObjectClassDefinition from_str

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Decodes a string representation into an ObjectClassDefinition object, adhering to RFC4512.

```APIDOC
## classmethod _from_str(_string_)

### Description
Decode object class definition string according to RFC4512.

### Method
classmethod

### Parameters
#### Path Parameters
- **_string_** (str) - Required - The string representation of the object class definition.

### Response
#### Success Response (200)
- **ObjectClassDefinition** (ObjectClassDefinition) - The decoded object class definition object.

### See Also
- `__str__` for the string format.
```

--------------------------------

### LDAP BIND Operations

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Methods for performing LDAP BIND operations using various authentication mechanisms.

```APIDOC
## BIND Operations

### do_bind_simple_anonymous()
- Performs simple anonymous authentication.
- Returns: Bind object on success.
- Raises: exceptions.LDAPInvalidCredentials

### do_bind_simple_unauthenticated(dn)
- Performs simple unauthenticated authentication.
- Parameters: dn (str) - Required
- Returns: Bind object on success.
- Raises: exceptions.LDAPInvalidCredentials

### do_bind_simple_authenticated(dn, password)
- Performs simple name/password authentication.
- Parameters: dn (str) - Required, password (bytes) - Required
- Returns: Bind object on success.
- Raises: exceptions.LDAPInvalidCredentials

### do_bind_sasl_anonymous(trace_info=None)
- Performs SASL ANONYMOUS authentication.
- Parameters: trace_info (str) - Optional
- Returns: Bind object on success.
- Raises: exceptions.LDAPError

### do_bind_sasl_plain(identity, password, authzid=None)
- Performs SASL PLAIN authentication.
- Parameters: identity (str) - Required, password (str) - Required, authzid (str) - Optional
- Returns: Bind object on success.
- Raises: exceptions.LDAPError

### do_bind_sasl_external(authzid=None)
- Performs SASL EXTERNAL authentication.
- Parameters: authzid (str) - Optional
- Returns: Bind object on success.
- Raises: exceptions.LDAPError
```

--------------------------------

### Represent AttributeTypeDefinition as RFC4512 string

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Returns the string representation of an attribute type definition.

```text
( 2.5.4.3 NAME ( ‘cn’ ‘commonName’ ) DESC ‘RFC4519: common name(s) for which the entity is known by’ SUP name )
```

--------------------------------

### LDAP Syntax Definition String Representation

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Represents an LDAP syntax definition string according to RFC4512. Used for defining data types within the schema.

```python
( 1.3.6.1.4.1.1466.115.121.1.15 DESC ‘Directory String’ )
```

--------------------------------

### do_compare

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Performs an LDAP COMPARE operation to check an attribute value for a given DN.

```APIDOC
## do_compare(dn, attribute, value)

### Description
Lookup object for COMPARE operation.

### Parameters
- **dn** (str) - Required - Distinguished name of the LDAP entry
- **attribute** (str) - Required - Attribute type
- **value** (bytes) - Required - Attribute value

### Response
- **Returns** (Entry or None) - The first object for which Entry.compare does not raise LDAPNoSuchObject.

### Errors
- **exceptions.LDAPError** - Raised on error.
```

--------------------------------

### Less Than or Equal To Matching

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Functions for checking if attribute values are less than or equal to an assertion value.

```APIDOC
## Less Than or Equal To Matching

### `match_less_or_equal`

#### Description
Return whether any attribute value is less than or equal to assertion value.

#### Parameters
* **attribute_values** (_List_ _of_ _any_) – Attribute values (type according to syntax)
* **assertion_value** (_bytes_) – Assertion value

#### Returns
* **bool** - True if any attribute values matches, False otherwise

#### Raises
* **exceptions.LDAPError** – if the result is undefined
```

--------------------------------

### MatchingRuleDefinition Class

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Represents an LDAP matching rule definition, providing methods to perform equality, ordering, and substring matching operations.

```APIDOC
## MatchingRuleDefinition

### Description
Represents an LDAP matching rule definition. Provides methods to evaluate attribute values against assertion values based on the rule type (EQUALITY, ORDERING, SUBSTR).

### Methods
- **match_equal(schema, attribute_values, assertion_value)**: Checks equality.
- **match_approx(schema, attribute_values, assertion_value)**: Checks approximate equality.
- **match_less(schema, attribute_values, assertion_value)**: Checks if value is less than assertion.
- **match_greater_or_equal(schema, attribute_values, assertion_value)**: Checks if value is greater than or equal to assertion.
- **match_substr(schema, attribute_values, initial_substring, any_substrings, final_substring)**: Checks substring matching.

### Parameters
- **schema** (Schema) - Required - Schema context.
- **attribute_values** (list) - Required - Values to match against.
- **assertion_value** (any) - Required - Value to compare.

### Response
- **Returns** (bool) - True if match is found, False otherwise.
- **Raises** (exceptions.LDAPError) - If the result is undefined.
```

--------------------------------

### LDAP Matching Rule Definition String Representation

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Represents an LDAP matching rule definition string according to RFC4512. Used for defining how attribute values are compared.

```python
( 2.5.13.2 NAME ‘caseIgnoreMatch’ SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
```

--------------------------------

### LDAP Filter Components

Source: https://uffd.cccv-pages.de/python-ldapserver/master/genindex.html

This section details the classes representing different components of LDAP filters.

```APIDOC
## LDAP Filter Components

### `ldapserver.ldap.FilterApproxMatch`

- **`attribute`**: The attribute for approximate matching.

### `ldapserver.ldap.FilterEqual`

- **`attribute`**: The attribute for equality matching.

### `ldapserver.ldap.FilterExtensibleMatch`

- **`dnAttributes`**: Indicates if DN attributes are used.

### `ldapserver.ldap.FilterLessOrEqual`

- **`attribute`**: The attribute for less-or-equal matching.

### `ldapserver.ldap.FilterPresent`

- **`attribute`**: The attribute to check for presence.

### `ldapserver.ldap.FilterSubstrings`

- **`any_substrings`**: Indicates if any substring matches.
- **`attribute`**: The attribute for substring matching.

### `ldapserver.ldap.SearchScope`

- **`baseObject`**: Represents the base object scope.

```

--------------------------------

### Syntax.decode

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Decodes an LDAP-specific encoded value into a native value.

```APIDOC
## decode

### Description
Decode LDAP-specific encoding of a value.

### Parameters
#### Request Body
- **raw_value** (bytes) - Required - LDAP-specific encoding

### Response
#### Success Response (200)
- **decoded_value** (any) - Native value
```

--------------------------------

### SubstrMatchingRule.match_substr

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Checks if any attribute values match a substring assertion based on initial, any, and final substrings.

```APIDOC
## match_substr

### Description
Return whether any attribute value matches the substring assertion.

### Parameters
#### Request Body
- **attribute_values** (List of any) - Required - Attribute values (type according to attribute’s syntax)
- **inital_substring** (any) - Optional - Substring to match the beginning
- **any_substrings** (list of any) - Required - List of substrings to match between initial and final in order
- **final_substring** (any) - Optional - Substring to match the end

### Response
#### Success Response (200)
- **result** (bool) - True if any attribute values matches, False otherwise

### Errors
- **exceptions.LDAPError** - if the result is undefined
```

--------------------------------

### LDAP Error Exceptions

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

This section lists the various LDAP error exceptions that can be raised. Each exception corresponds to a specific LDAP result code and provides a way to signal errors to the client.

```APIDOC
## LDAP Errors

LDAP response messages carry a result code and an optional diagnostic message. The subclasses of `ldapserver.exceptions.LDAPError` represent the possible (non-success) result codes. Raising an `ldapserver.exceptions.LDAPError` instance in a handler method of `ldapserver.LDAPRequestHandler` aborts the request processing and sends an appropriate response message with the corresponding result code and (if any) the diagnostic message.

### Exception Hierarchy

*   `ldapserver.exceptions.LDAPError` (Base class for all LDAP errors)
    *   `ldapserver.exceptions.LDAPOperationsError` (Operation not properly sequenced)
    *   `ldapserver.exceptions.LDAPProtocolError` (Malformed server data)
    *   `ldapserver.exceptions.LDAPTimeLimitExceeded` (Client-specified time limit exceeded)
    *   `ldapserver.exceptions.LDAPSizeLimitExceeded` (Client-specified size limit exceeded)
    *   `ldapserver.exceptions.LDAPAuthMethodNotSupported` (Unsupported authentication method)
    *   `ldapserver.exceptions.LDAPStrongerAuthRequired` (Stronger authentication required)
    *   `ldapserver.exceptions.LDAPAdminLimitExceeded` (Administrative limit exceeded)
    *   `ldapserver.exceptions.LDAPUnavailableCriticalExtension` (Unrecognized critical control)
    *   `ldapserver.exceptions.LDAPConfidentialityRequired` (Data confidentiality protection required)
    *   `ldapserver.exceptions.LDAPNoSuchAttribute` (Attribute not found in entry)
    *   `ldapserver.exceptions.LDAPUndefinedAttributeType` (Unrecognized attribute description)
    *   `ldapserver.exceptions.LDAPInappropriateMatching` (Inappropriate matching rule used)
    *   `ldapserver.exceptions.LDAPConstraintViolation` (Attribute value violates data model constraints)
    *   `ldapserver.exceptions.LDAPAttributeOrValueExists` (Attribute or value to be added already exists)
    *   `ldapserver.exceptions.LDAPInvalidAttributeSyntax` (Attribute value does not conform to syntax)
    *   `ldapserver.exceptions.LDAPNoSuchObject` (Object does not exist in DIT)
    *   `ldapserver.exceptions.LDAPAliasProblem` (Alias dereferencing problem)
    *   `ldapserver.exceptions.LDAPInvalidDNSyntax` (LDAPDN or RelativeLDAPDN has invalid syntax)
    *   `ldapserver.exceptions.LDAPAliasDereferencingProblem` (Problem dereferencing alias)
    *   `ldapserver.exceptions.LDAPInappropriateAuthentication` (Inappropriate authentication attempt)
    *   `ldapserver.exceptions.LDAPInvalidCredentials` (Invalid credentials provided)
    *   `ldapserver.exceptions.LDAPInsufficientAccessRights` (Insufficient access rights)
    *   `ldapserver.exceptions.LDAPBusy` (Server is busy)
```

--------------------------------

### ObjectClassDefinition API

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Defines the structure and properties of an LDAP object class.

```APIDOC
## ObjectClassDefinition

### Description
Represents an LDAP object class definition as per RFC4512.

### Parameters
- **oid** (string) - Required - Numeric OID
- **name** (list of strings) - Optional - Short descriptive names
- **desc** (string) - Optional - Description
- **obsolete** (bool) - Optional - Obsolete status
- **sup** (list of strings) - Optional - Superior object classes
- **kind** (ObjectClassKind) - Optional - Kind of object class (ABSTRACT, STRUCTURAL, AUXILIARY)
- **must** (list of strings) - Optional - Required attribute types
- **may** (list of strings) - Optional - Optional attribute types

### Methods
- **__str__()**: Returns RFC4512 compliant string representation.
```

--------------------------------

### LDAP Search Result Entry and Partial Attribute

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Represents an entry in an LDAP search result and its attributes.

```APIDOC
## class ldapserver.ldap.SearchResultEntry(*args, **kwargs)

### Description
Represents an entry in an LDAP search result.

### Attributes
- **objectName** (str) - The distinguished name of the entry.
- **attributes** (List[PartialAttribute]) - A list of attributes associated with the entry.

## class ldapserver.ldap.PartialAttribute(*args, **kwargs)

### Description
Represents a partial attribute within an LDAP search result entry.

### Attributes
- **type** (str) - The type of the attribute.
- **vals** (List[bytes]) - A list of values for the attribute.
```

--------------------------------

### LDAP SEARCH Operation

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Method for performing LDAP SEARCH operations.

```APIDOC
## SEARCH Operation

### do_search(baseobj, scope, filterobj)
- Returns result candidates for a SEARCH operation.
- Parameters:
  - baseobj (str) - Required - Distinguished name of the LDAP entry.
  - scope (ldap.SearchScope) - Required - Search scope.
  - filterobj (ldap.Filter) - Required - Filter object.
- Returns: Iterable of Entry.
- Raises: exceptions.LDAPError
```

--------------------------------

### DN Class API

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Methods for managing LDAP Distinguished Names, including parsing, string representation, and hierarchy checks.

```APIDOC
## DN Class

### Description
Represents a Distinguished Name consisting of zero or more RDN objects.

### Methods
- **from_str(schema, expr)**: Parse string representation of a DN according to RFC 4514. Returns a DN object.
- **__str__()**: Return string representation of DN according to RFC 4514.
- **is_direct_child_of(base)**: Return whether self is a direct child of base (DN).
- **in_subtree_of(base)**: Return whether self is in the subtree of base (DN).

### Properties
- **object_attribute**: Attribute name of the first RDN.
- **object_attribute_type**: schema.AttributeType of the first RDN.
- **object_value**: Attribute value of the first RDN.
```

--------------------------------

### Entry.search

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Performs a search operation on an LDAP entry based on provided scope and filter criteria.

```APIDOC
## SEARCH Entry.search

### Description
Return SEARCH result for the entry if it matches the operation parameters.

### Parameters
#### Path Parameters
- **base_obj** (str) - Required - DN of the base entry
- **scope** (ldap.SearchScope) - Required - Scope of base_obj
- **filter_obj** (ldap.Filter) - Required - Search filter
- **attributes** (list of str) - Required - Requested attributes
- **types_only** (bool) - Required - Omit values in ldap.PartialAttribute

### Response
#### Success Response (200)
- **result** (ldap.SearchResultEntry or None) - SEARCH result for the entry if it matches the operation parameters, None otherwise.
```

--------------------------------

### Approximate Equality Matching

Source: https://uffd.cccv-pages.de/python-ldapserver/master/api.html

Functions for checking approximate equality between attribute values and an assertion value.

```APIDOC
## Approximate Equality Matching

### `match_approx`

#### Description
Return whether any attribute value approximately equals the assertion value.

#### Parameters
* **attribute_values** (_List_ _of_ _any_) – Attribute values (type according to syntax)
* **assertion_value** (_bytes_) – Assertion value

#### Returns
* **bool** - True if any attribute values matches, False otherwise

#### Raises
* **exceptions.LDAPError** – if the result is undefined
```
Tokens:
Raw