lldap-py 0.1.0__py3-none-any.whl

lldap/__init__.py

@@ -0,0 +1,76 @@
+"""LLDAP-py - Simple Python interface for managing LLDAP servers."""
+
+__version__ = "0.1.0"
+
+from .config import Config
+from .client import LLDAPClient
+from .users import UserManager
+from .groups import GroupManager
+from .exceptions import LLDAPError, AuthenticationError, ConnectionError, GraphQLError, ValidationError
+
+
+class LLDAPManager(UserManager, GroupManager):
+    """Simplified LLDAP manager combining user and group management.
+    
+    This is the main interface for interacting with LLDAP servers.
+    Pass connection values in the constructor and use methods for operations.
+    """
+    
+    def __init__(
+        self,
+        http_url: str, # (http(s)://<host>:<port>)
+        username: str = None,
+        password: str = None,
+        token: str = None,
+        refresh_token: str = None,
+    ):
+        """Initialize LLDAP Manager with connection details.
+        
+        Args:
+            http_url: HTTP URL of LLDAP server (e.g., "http://localhost:17170")
+            username: Admin username (default: "admin")
+            password: Admin password
+            token: Authentication token (if already authenticated)
+            refresh_token: Refresh token for token renewal
+            
+        Raises:
+            AuthenticationError: If connection/authentication fails
+        """
+        self.config = Config(
+            http_url=http_url,
+            username=username,
+            password=password,
+            token=token,
+            refresh_token=refresh_token,
+        )
+        
+        try:
+            self.config.validate()
+        except LLDAPError:
+            raise
+        
+        self.client = LLDAPClient(self.config)
+        
+        # Authenticate on initialization
+        try:
+            self.client.authenticate()
+        except (AuthenticationError, ConnectionError):
+            raise
+    
+    def close(self):
+        """Close the session."""
+        if hasattr(self.client, 'session'):
+            self.client.session.close()
+
+
+__all__ = [
+    "LLDAPManager",
+    "LLDAPClient",
+    "LLDAPError",
+    "UserManager",
+    "GroupManager",
+    "AuthenticationError",
+    "ConnectionError",
+    "ValidationError",
+    "GraphQLError",
+]

lldap/client.py

@@ -0,0 +1,213 @@
+import json
+from typing import Optional, Dict, Any, Tuple
+import requests
+from .config import Config
+from .exceptions import (
+    AuthenticationError,
+    ConnectionError,
+    GraphQLError,
+)
+
+
+class LLDAPClient:
+    """Client for interacting with LLDAP server via GraphQL API."""
+    
+    def __init__(self, config: Config):
+        """Initialize LLDAP client.
+        
+        Args:
+            config: Configuration object
+        """
+        self.config = config
+        self.session = requests.Session()
+        self._authenticated = False
+    
+    def authenticate(self) -> Tuple[str, str]:
+        """Authenticate and get tokens.
+        
+        Returns:
+            Tuple of (token, refresh_token)
+            
+        Raises:
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+        """
+        if self.config.token:
+            # Already have a token
+            return self.config.token, self.config.refresh_token or ""
+        
+        if self.config.refresh_token:
+            # Use refresh token to get new token
+            token = self.refresh_token(self.config.refresh_token)
+            self.config.token = token
+            return token, self.config.refresh_token
+        
+        # Use username and password
+        url = self.config.get_endpoint_url("auth")
+        payload = {
+            "username": self.config.username,
+            "password": self.config.password,
+        }
+        
+        try:
+            response = self.session.post(
+                url,
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            )
+            
+            if response.status_code != 200:
+                raise AuthenticationError(f"Authentication failed: {response.text}")
+            
+            data = response.json()
+            token = data.get("token")
+            refresh_token = data.get("refreshToken")
+            
+            if not token:
+                raise AuthenticationError("No token in response")
+            
+            self.config.token = token
+            self.config.refresh_token = refresh_token
+            self._authenticated = True
+            
+            return token, refresh_token
+            
+        except requests.RequestException as e:
+            raise ConnectionError(f"Connection error: {e}")
+    
+    def refresh_token(self, refresh_token: str) -> str:
+        """Get a new token using refresh token.
+        
+        Args:
+            refresh_token: Refresh token
+            
+        Returns:
+            New authentication token
+            
+        Raises:
+            AuthenticationError: If token refresh fails
+            ConnectionError: If connection fails
+        """
+        url = self.config.get_endpoint_url("refresh")
+        
+        try:
+            response = self.session.get(
+                url,
+                cookies={"refresh_token": refresh_token},
+            )
+            
+            if response.status_code != 200:
+                raise AuthenticationError(f"Token refresh failed: {response.text}")
+            
+            data = response.json()
+            token = data.get("token")
+            
+            if not token:
+                raise AuthenticationError("No token in refresh response")
+            
+            return token
+            
+        except requests.RequestException as e:
+            raise ConnectionError(f"Connection error: {e}")
+    
+    def logout(self) -> bool:
+        """Logout and invalidate refresh token.
+        
+        Returns:
+            True if successful
+            
+        Raises:
+            ConnectionError: If connection fails
+        """
+        if not self.config.refresh_token:
+            return False
+        
+        url = self.config.get_endpoint_url("logout")
+        
+        try:
+            response = self.session.get(
+                url,
+                cookies={"refresh_token": self.config.refresh_token},
+            )
+            return response.status_code == 200
+            
+        except requests.RequestException as e:
+            raise ConnectionError(f"Connection error: {e}")
+    
+    def query(
+        self,
+        query: str,
+        variables: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Execute a GraphQL query.
+        
+        Args:
+            query: GraphQL query string
+            variables: Query variables
+            
+        Returns:
+            GraphQL response data
+            
+        Raises:
+            GraphQLError: If query returns errors
+            ConnectionError: If connection fails
+        """
+        # Ensure we're authenticated
+        if not self.config.token:
+            self.authenticate()
+        
+        url = self.config.get_endpoint_url("graphql")
+        
+        payload = {
+            "query": query,
+            "variables": variables or {},
+        }
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.config.token}",
+        }
+        
+        data = json.dumps(payload)
+        
+        try:
+            response = self.session.post(url, data=data, headers=headers)
+            
+            # Check for HTTP errors
+            if response.status_code == 401:
+                raise AuthenticationError(
+                    "Authentication failed. Token may be expired. Try logging in again."
+                )
+            elif response.status_code != 200:
+                raise ConnectionError(
+                    f"HTTP {response.status_code}: {response.text}"
+                )
+            
+            result = response.json()
+            
+            # Check for GraphQL errors
+            if "errors" in result:
+                error_messages = [err.get("message", str(err)) for err in result["errors"]]
+                raise GraphQLError("; ".join(error_messages))
+            
+            return result
+            
+        except requests.RequestException as e:
+            raise ConnectionError(f"Connection error: {e}")
+    
+    def ensure_authenticated(self) -> None:
+        """Ensure client is authenticated, authenticate if not."""
+        if not self.config.token:
+            self.authenticate()
+    
+    def ensure_ldap_connection(self) -> bool:
+        from ldap3 import Server, Connection, ALL, MODIFY_REPLACE
+        if (self.config.ldap_server is not None) and (self.config.ldap_base_dn is not None):
+            conn = None
+            try:
+                server = Server(self.config.ldap_server, get_info=ALL)
+                conn = Connection(server, self.config.ldap_bind_dn, self.config.ldap_bind_password, auto_bind=True)
+            except Exception:
+                return False
+            return True
+        return False

lldap/config.py

@@ -0,0 +1,46 @@
+
+from typing import Optional, Dict
+from .exceptions import ConfigurationError
+
+
+class Config:
+    def __init__(
+        self,
+        http_url: Optional[str] = "http://localhost:17170",
+        username: Optional[str] = "admin",
+        password: Optional[str] = None,
+        token: Optional[str] = None,
+        refresh_token: Optional[str] = None,
+        user_dn: Optional[str] = None,
+        ldap_server: Optional[str] = None,
+        endpoints: Optional[Dict[str, str]] = None,
+    ):
+
+        self.http_url = http_url
+        self.username = username
+        self.password = password
+        self.token = token
+        self.refresh_token = refresh_token
+        self.user_dn = user_dn
+        self.ldap_server = ldap_server
+        self.endpoints = endpoints or {
+            "auth": "/auth/simple/login",
+            "graphql": "/api/graphql",
+            "logout": "/auth/logout",
+            "refresh": "/auth/refresh",
+        }
+
+    def validate(self) -> None:
+        """Validate that required configuration is present."""
+        has_token = bool(self.token)
+        has_credentials = bool(self.username and self.password)
+        has_refresh = bool(self.refresh_token)
+
+        if not (has_token or has_credentials or has_refresh):
+            raise ConfigurationError(
+                "Missing authentication: provide either token, refresh_token, or username+password"
+            )
+
+    def get_endpoint_url(self, endpoint: str) -> str:
+        """Get full URL for an endpoint."""
+        return f"{self.http_url}{self.endpoints[endpoint]}"

lldap/exceptions.py

@@ -0,0 +1,31 @@
+"""Exception classes for LLDAP."""
+
+
+class LLDAPError(Exception):
+    """Base exception for all LLDAP errors."""
+    pass
+
+
+class AuthenticationError(LLDAPError):
+    """Raised when authentication fails."""
+    pass
+
+
+class ConnectionError(LLDAPError):
+    """Raised when connection to LLDAP server fails."""
+    pass
+
+
+class GraphQLError(LLDAPError):
+    """Raised when GraphQL query returns an error."""
+    pass
+
+
+class ConfigurationError(LLDAPError):
+    """Raised when configuration is invalid or missing."""
+    pass
+
+
+class ValidationError(LLDAPError):
+    """Raised when input validation fails."""
+    pass

lldap/groups.py

@@ -0,0 +1,160 @@
+"""Group management operations."""
+
+from typing import List, Dict, Any, Optional, Union
+from .client import LLDAPClient
+from .exceptions import ValidationError
+from .models import Group, User
+
+# BASE_GROUP_ATTRIBUTES = ["groupid", "creationDate", "uuid", "displayName"]
+
+
+
+class GroupManager:
+    """Manages group operations."""
+    
+    def __init__(self, client: LLDAPClient):
+        """Initialize group manager.
+        
+        Args:
+            client: LLDAP client instance
+        """
+        self.client = client
+    
+    def list_groups(self) -> List[Group]:
+        """Get list of all groups.
+        
+        Returns:
+            List of group objects
+        """
+        query = "{groups{id creationDate uuid displayName}}"
+        result = self.client.query(query)
+        groups = []
+        for grp in result.get("data", {}).get("groups", []):
+            groups.append(Group(
+                groupid=grp["id"],
+                creation_date=grp["creationDate"],
+                uuid=grp["uuid"],
+                display_name=grp["displayName"],
+            ))
+        return groups
+    
+    def create_group(self, name: str) -> Dict[str, Any]:
+        """Create a new group.
+        
+        Args:
+            name: Group display name
+            
+        Returns:
+            Created group data
+        """
+        query = """
+        mutation createGroup($group:String!){
+            createGroup(name:$group){id}
+        }
+        """
+        variables = {"group": name}
+        result = self.client.query(query, variables)
+        # return created group data
+        return result.get("data", {}).get("createGroup", {})
+    
+    def fetch_group_by_id(self, group_id: int) -> Optional[Group]:
+        for group in self.list_groups():
+            if group.groupid == group_id:
+                return group
+        return None
+
+    
+    def get_group_id(self, name: str) -> Optional[int]:
+        """Get group ID by display name.
+        
+        Args:
+            name: Group display name
+            
+        Returns:
+            Group ID or None if not found
+        """
+        groups = self.list_groups()
+        for group in groups:
+            if group.display_name == name:
+                return group.groupid
+        return None
+    
+    def _resolve_group_id(self, group_identifier: Union[str, int]) -> int:
+        """Resolve group name or ID to group ID.
+        
+        Args:
+            group_identifier: Either group name (str) or group ID (int)
+            
+        Returns:
+            Group ID
+            
+        Raises:
+            ValidationError: If group not found or invalid type
+        """
+        if isinstance(group_identifier, int):
+            return group_identifier
+        elif isinstance(group_identifier, str):
+            group_id = self.get_group_id(group_identifier)
+            if group_id is None:
+                raise ValidationError(f"Group not found: {group_identifier}")
+            return group_id
+        else:
+            raise ValidationError(f"Group identifier must be str (name) or int (id), got {type(group_identifier).__name__}")
+    
+    def delete_group(self, group_identifier: Union[str, int]) -> bool:
+        """Delete a group by name or ID.
+        
+        Args:
+            group_identifier: Group name (str) or group ID (int)
+            
+        Returns:
+            True if successful
+            
+        Raises:
+            ValidationError: If group not found
+        """
+        group_id = self._resolve_group_id(group_identifier)
+        
+        query = """
+        mutation deleteGroup($id:Int!){
+            deleteGroup(groupId:$id){ok}
+        }
+        """
+        variables = {"id": group_id}
+        result = self.client.query(query, variables)
+        return result.get("data", {}).get("deleteGroup", {}).get("ok", False)
+    
+    def list_group_users(self, group_identifier: Union[str, int]) -> List[User]:
+        """List users in a group by name or ID.
+        
+        Args:
+            group_identifier: Group name (str) or group ID (int)
+            
+        Returns:
+            List of User objects
+            
+        Raises:
+            ValidationError: If group not found
+        """
+        group_id = self._resolve_group_id(group_identifier)
+        
+        query = """
+        query listUsersByGroupName($id:Int!){
+            group:group(groupId:$id){users{id email displayName firstName lastName avatar}}
+        }
+        """
+        variables = {"id": group_id}
+        result = self.client.query(query, variables)
+        users_data = result.get("data", {}).get("group", {}).get("users", [])
+
+        return [User(
+            user_id=user["id"],
+            email=user["email"],
+            display_name=user["displayName"],
+            first_name=user["firstName"],
+            last_name=user["lastName"],
+            avatar=user.get("avatar")
+        ) for user in users_data]
+
+    
+    

lldap/models.py

@@ -0,0 +1,27 @@
+
+from typing import Optional
+
+class User:
+        """Represents a user entity."""
+        def __init__(self, user_id: str, email: str, display_name: str, first_name: str, last_name: str, avatar: Optional[str]):
+            self.user_id = user_id
+            self.email = email
+            self.display_name = display_name
+            self.first_name = first_name
+            self.last_name = last_name
+            self.avatar = avatar
+        def __repr__(self):
+            return f"<User id={self.user_id} email={self.email} name={self.display_name}>"
+
+class Group:
+        """Represents a group entity."""
+        def __init__(self, groupid: int, creation_date: str, uuid: str, display_name: str):
+            self.groupid = groupid
+            self.creation_date = creation_date
+            self.uuid = uuid
+            self.display_name = display_name
+            self.creation_date = creation_date
+        def __repr__(self):
+            return f"<Group id={self.groupid} name={self.display_name} uuid={self.uuid}>"
+        
+

lldap/users.py

@@ -0,0 +1,204 @@
+"""User management operations."""
+
+import re
+from typing import List, Dict, Any, Optional
+from .client import LLDAPClient
+from .exceptions import ValidationError
+from .models import User, Group
+
+class UserManager:
+    """Manages user operations."""
+    
+    def __init__(self, client: LLDAPClient):
+        """Initialize user manager.
+        
+        Args:
+            client: LLDAP client instance
+        """
+        self.client = client
+    
+    def list_users(self) -> List[User]:
+        """Get list of all users.
+        
+        Returns:
+            List of user objects
+        """
+        query = "{users{id creationDate uuid email displayName firstName lastName, avatar}}"
+        result = self.client.query(query)
+        users = []
+        for usr in result.get("data", {}).get("users", []):
+            users.append(User(
+                user_id=usr["id"],
+                email=usr["email"],
+                display_name=usr["displayName"],
+                first_name=usr["firstName"],
+                last_name=usr["lastName"],
+                avatar=usr.get("avatar"),
+            ))
+        return users
+    
+    
+    def get_user_id_by_email(self, email: str) -> Optional[str]:
+        """Get user ID from email address.
+        
+        Args:
+            email: Email address
+            
+        Returns:
+            User ID or None if not found
+        """
+        query = "{users{id email}}"
+        result = self.client.query(query)
+        users = self.list_users()
+        
+        for user in users:
+            if user.email == email:
+                return user.user_id
+        
+        return None
+    
+
+    
+    def create_user(
+        self,
+        user_id: str,
+        email: str,
+        display_name: Optional[str] = None,
+        first_name: Optional[str] = None,
+        last_name: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a new user.
+        
+        Args:
+            user_id: User ID
+            email: Email address
+            display_name: Display name
+            first_name: First name
+            last_name: Last name
+            avatar_path: Path to avatar image file (JPEG)
+            
+        Returns:
+            Created user data
+        """
+        query = """
+        mutation createUser($user:CreateUserInput!){
+            createUser(user:$user){id email displayName firstName lastName avatar}
+        }
+        """
+        
+        variables = {
+            "user": {
+                "id": user_id,
+                "email": email,
+                "displayName": display_name or "",
+                "firstName": first_name or "",
+                "lastName": last_name or "",
+                "avatar": None,
+            }
+        }
+        
+        
+        result = self.client.query(query, variables)
+        return result.get("data", {}).get("createUser", {})
+    
+    def delete_user(self, user_id: str) -> bool:
+        """Delete a user.
+        
+        Args:
+            user_id: User ID
+            
+        Returns:
+            True if successful
+        """
+        query = """
+        mutation deleteUser($userId:String!){
+            deleteUser(userId:$userId){ok}
+        }
+        """
+        variables = {"userId": user_id}
+        result = self.client.query(query, variables)
+        return result.get("data", {}).get("deleteUser", {}).get("ok", False)
+    
+    def list_user_attributes(self, user_id: str) -> List[str]:
+        """List attributes for a user.
+        
+        Args:
+            user_id: User ID
+            
+        Returns:
+            List of attribute names
+        """
+        query = """
+        query getUserInfo($id:String!){
+            user(userId:$id){attributes{name}}
+        }
+        """
+        variables = {"id": user_id}
+        result = self.client.query(query, variables)
+        attributes = result.get("data", {}).get("user", {}).get("attributes", [])
+        names = [attr["name"] for attr in attributes]
+        return sorted(names)
+    
+    
+    
+    def list_user_groups(self, user_id: str) -> List[str]:
+        """List groups that a user belongs to.
+        
+        Args:
+            user_id: User ID
+            
+        Returns:
+            List of group display names
+        """
+        query = """
+        query listGroupsByUserId($id:String!){
+            user(userId:$id){groups{displayName}}
+        }
+        """
+        variables = {"id": user_id}
+        result = self.client.query(query, variables)
+        groups = result.get("data", {}).get("user", {}).get("groups", [])
+        return [group["displayName"] for group in groups]
+    
+    def add_user_to_group(self, user_id: str, group_id: int) -> bool:
+        """Add user to a group.
+        
+        Args:
+            user_id: User ID
+            group_id: Group ID (integer)
+            
+        Returns:
+            True if successful
+        """
+        query = """
+        mutation addUserToGroup($userId:String!,$groupId:Int!){
+            addUserToGroup(userId:$userId,groupId:$groupId){ok}
+        }
+        """
+        variables = {"userId": user_id, "groupId": group_id}
+        result = self.client.query(query, variables)
+        return result.get("data", {}).get("addUserToGroup", {}).get("ok", False)
+    
+    def remove_user_from_group(self, user_id: str, group_id: int) -> bool:
+        """Remove user from a group.
+        
+        Args:
+            user_id: User ID
+            group_id: Group ID (integer)
+            
+        Returns:
+            True if successful
+        """
+        query = """
+        mutation removeUserFromGroup($userId:String!,$groupId:Int!){
+            removeUserFromGroup(userId:$userId,groupId:$groupId){ok}
+        }
+        """
+        variables = {"userId": user_id, "groupId": group_id}
+        result = self.client.query(query, variables)
+        return result.get("data", {}).get("removeUserFromGroup", {}).get("ok", False)
+    
+ 
+    
+    
+

lldap_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: lldap-py
+Version: 0.1.0
+Summary: Python tool for managing LLDAP servers
+Home-page: https://github.com/luca2618/lldap-py
+Author: Lucas Sylvester
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Systems Administration :: Authentication/Directory :: LDAP
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: click>=8.0.0
+Requires-Dist: ldap3>=2.9.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# lldap-py
+
+Python client library for managing LLDAP servers  [lldap/lldap](https://github.com/lldap/lldap)
+
+## Usage
+
+This package provides a Python interface to interact with LLDAP servers for user and group management. The idea is that it would be used in an onboarding/offboarding automation script and make similar automation tasks easier.
+
+## Requirements
+- Python 3.8+
+- requests
+- ldap3
+- toml
+- click
+
+## TODO
+- Maybe improve error handling and passing of graphql errors to the user.
+- Add more examples and documentation.
+- Check coverage of tests
+- Add support for direct LDAP operations alongside GraphQL(Mainly for password management, to be used for initial random password generation).
+- Test against https (and ldaps connections for above point).
+- Add support for costum user and group attributes.
+
+## Credit
+This project is heavely inspired by and uses alot of code from [Zepmann/lldap-cli](https://github.com/Zepmann/lldap-cli) and [JaidenW/LLDAP-Discord](https://github.com/JaidenW/LLDAP-Discord)
+
+
+## License
+
+MIT

lldap_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+lldap/__init__.py,sha256=I2OsG5GibcAa471_9iiGe7LYqOiaA6vqS7kw6BOjAb4,2261
+lldap/client.py,sha256=_TkxfiPeT7meBxUilPZloTqtZ5_32BbGa1pp9XuM9QM,6978
+lldap/config.py,sha256=r7SNn7KjTrlUIfKyhYKaG8QHiUwnanzy0Qn8Wm6TmuU,1605
+lldap/exceptions.py,sha256=EwqhuchbNKKHb0qNtHk0pOlt4BouV0FbrmHHpzVTov8,646
+lldap/groups.py,sha256=gMpOkRulAID-sMzhdY2_3amTXnoo4rsLV1PsTWHZvRg,5066
+lldap/models.py,sha256=DuWXGveqQG1Ae1QU77hrCwTr_pxyUiKCcmUFHuGJMO4,1059
+lldap/users.py,sha256=iPnBtBHC8ompgnlH2HY6J6ci5bduXFdrB_ULbfxc-no,6108
+lldap_py-0.1.0.dist-info/licenses/LICENSE,sha256=0r3XKhURGT6PVzcrhPXg3NtusjrTWEOjR9UH-_QKBe0,1099
+lldap_py-0.1.0.dist-info/METADATA,sha256=keilo5G3P4CTbb83nc7V_LZ5_TTyEvNHQOPdsJne4YE,2039
+lldap_py-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lldap_py-0.1.0.dist-info/top_level.txt,sha256=uxlPt9-Bi-TwywkVi52Y6LfC2zFwJm1ZwLa8zfSi-6Y,6
+lldap_py-0.1.0.dist-info/RECORD,,

lldap_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lldap_py-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LLDAP-py Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lldap_py-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lldap