From: Frank Brehm Date: Mon, 4 Jan 2021 16:13:39 +0000 (+0100) Subject: Removing pointless modules X-Git-Url: https://git.uhu-banane.org/?a=commitdiff_plain;h=1cca8ca1e05f2a698f5494a4ce8b91fb86e582c4;p=pixelpark%2Fldap-migration.git Removing pointless modules --- diff --git a/lib/ldap_migration/idict.py b/lib/ldap_migration/idict.py deleted file mode 100644 index a1a0e75..0000000 --- a/lib/ldap_migration/idict.py +++ /dev/null @@ -1,387 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -""" -@author: Frank Brehm -@contact: frank@brehm-online.com -@copyright: © 2020 by Frank Brehm, Berlin -@summary: A module for providing a dict with case insensitive keys. -""" -from __future__ import absolute_import - -# Standard module -import logging -import copy - -try: - from collections.abc import MutableMapping -except ImportError: - from collections import MutableMapping - -# Third party modules - -# Own modules -from fb_tools.common import pp -from fb_tools.errors import FbError -from fb_tools.obj import FbBaseObject - -__version__ = '0.1.5' - -LOG = logging.getLogger(__name__) - - -# ============================================================================= -class WrongKeyTypeError(TypeError, FbError): - - # ------------------------------------------------------------------------- - def __init__(self, key): - - self.key = key - - # ------------------------------------------------------------------------- - def __str__(self): - - msg = "Key {key!r} must be of type 'str', but is of type {cls!r} instead." - return msg.format(key=self.key, cls=self.key.__class__.__name__) - - -# ============================================================================= -class WrongCompareClassError(TypeError, FbError): - - # ------------------------------------------------------------------------- - def __init__(self, other): - - self.other_class = other.__class__.__name__ - - # ------------------------------------------------------------------------- - def __str__(self): - - msg = "Object {!r} is not a CaseInsensitiveDict object." - return msg.format(self.other_class) - - -# ============================================================================= -class CaseInsensitiveKeyError(KeyError, FbError): - - # ------------------------------------------------------------------------- - def __init__(self, key): - - self.key = key - - # ------------------------------------------------------------------------- - def __str__(self): - - msg = "Key {!r} not existing in CaseInsensitiveDict." - return msg.format(self.key) - - -# ============================================================================= -class CaseInsensitiveDict(MutableMapping): - """ - A dictionary, where the keys are insensitive strings. - The keys MUST be of type string! - It works like a dict. - """ - - wrong_type_msg = "Key {key!r} must be of type 'str', but is of type {cls!r} instead." - - # ------------------------------------------------------------------------- - def __init__(self, **kwargs): - '''Use the object dict''' - self._map = dict() - - for key in kwargs: - self._set_item(key, kwargs[key]) - - # ------------------------------------------------------------------------- - def _set_item(self, key, value): - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - key = okey - break - - self._map[key] = value - - # ------------------------------------------------------------------------- - def _get_item(self, key): - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - return self._map[okey] - - raise CaseInsensitiveKeyError(key) - - # ------------------------------------------------------------------------- - def get(self, key): - return self._get_item(key) - - # ------------------------------------------------------------------------- - def _del_item(self, key, strict=True): - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - del self._map[okey] - return - - if strict: - raise CaseInsensitiveKeyError(key) - - return - - # ------------------------------------------------------------------------- - # The next five methods are requirements of the ABC. - def __setitem__(self, key, value): - self._set_item(key, value) - - # ------------------------------------------------------------------------- - def __getitem__(self, key): - return self._get_item(key) - - # ------------------------------------------------------------------------- - def __delitem__(self, key): - self._del_item(key) - - # ------------------------------------------------------------------------- - def __iter__(self): - - for key in self.keys(): - yield key - - # ------------------------------------------------------------------------- - def __len__(self): - return len(self._map) - - # ------------------------------------------------------------------------- - # The next methods aren't required, but nice for different purposes: - def __str__(self): - '''returns simple dict representation of the mapping''' - return str(self._map) - - # ------------------------------------------------------------------------- - def __repr__(self): - '''echoes class, id, & reproducible representation in the REPL''' - return '{}, {}({})'.format( - super(CaseInsensitiveDict, self).__repr__(), - self.__class__.__name__, - self._map) - - # ------------------------------------------------------------------------- - def __contains__(self, key): - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - return True - - return False - - # ------------------------------------------------------------------------- - def keys(self): - - return sorted(self._map.keys(), key=str.lower) - - # ------------------------------------------------------------------------- - def items(self): - - item_list = [] - - for key in sorted(self._map.keys(), key=str.lower): - value = self._map[key] - item_list.append((key, value)) - - return item_list - - # ------------------------------------------------------------------------- - def values(self): - - value_list = [] - - for key in sorted(self._map.keys(), key=str.lower): - value_list.append(self._map[key]) - - return value_list - - # ------------------------------------------------------------------------- - def __eq__(self, other): - - if not isinstance(other, CaseInsensitiveDict): - raise WrongCompareClassError(other) - - if len(self) != len(other): - return False - - # First compare keys - my_keys = [] - other_keys = [] - - for key in self.keys(): - my_keys.append(key) - - for key in other.keys(): - other_keys.append(key) - - if my_keys != other_keys: - return False - - # Now compare values - for key in self.keys(): - if self[key] != other[key]: - return False - - return True - - # ------------------------------------------------------------------------- - def __ne__(self, other): - - if not isinstance(other, CaseInsensitiveDict): - raise WrongCompareClassError(other) - - if self.__eq__(other): - return True - - return False - - # ------------------------------------------------------------------------- - def pop(self, key, *args): - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - key = okey - break - - return self._map.pop(key, *args) - - # ------------------------------------------------------------------------- - def popitem(self): - - if not len(self._map): - return None - - key = self.keys()[0] - value = self._map[key] - del self._map[key] - return (key, value) - - # ------------------------------------------------------------------------- - def clear(self): - self._map = dict() - - # ------------------------------------------------------------------------- - def setdefault(self, key, default): - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - return self._map[okey] - - self._set_item(key, default) - return default - - # ------------------------------------------------------------------------- - def update(self, other): - - if isinstance(other, CaseInsensitiveDict) or isinstance(other, dict): - for key in other.keys(): - self._set_item(key, other[key]) - return - - for tokens in other: - key = tokens[0] - value = tokens[1] - self._set_item(key, value) - - # ------------------------------------------------------------------------- - def as_dict(self, short=True): - - res = {} - for key in self._map.keys(): - value = self._map[key] - if isinstance(value, (FbBaseObject, CaseInsensitiveDict)): - res[key] = value.as_dict(short=short) - else: - res[key] = copy.copy(value) - - return res - - # ------------------------------------------------------------------------- - def __copy__(self): - - new_dict = self.__class__() - for key in self._map.keys(): - new_dict[key] = copy.copy(self._map[key]) - - return new_dict - - # ------------------------------------------------------------------------- - def get_key(self, key, strict=True): - """Getting the saved value of the key in correct form.""" - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - return okey - - if strict: - raise CaseInsensitiveKeyError(key) - - return None - - # ------------------------------------------------------------------------- - def set_key(self, key, *args): - - if not isinstance(key, str): - raise WrongKeyTypeError(key) - - value = None - - if len(args) > 1: - msg = "Wrong arguments {!r} in calling set_key(), at most one optional argument " - msg += "may be given." - raise AttributeError(msg.format(args)) - elif len(args) == 1: - value = args[0] - - for okey in self._map.keys(): - if okey.lower() == key.lower(): - if okey == key: - if len(args) == 1: - self._map[key] = value - else: - if len(args) < 1: - # Taking the old value - value = self._map[okey] - del self._map[okey] - self._map[key] = value - return - - # Given key not found - if len(args) == 1: - self._map[key] = value - else: - raise CaseInsensitiveKeyError(key) - - -# ============================================================================= -if __name__ == "__main__": - - pass - -# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4 list diff --git a/lib/ldap_migration/istringset.py b/lib/ldap_migration/istringset.py deleted file mode 100644 index 55f85b0..0000000 --- a/lib/ldap_migration/istringset.py +++ /dev/null @@ -1,513 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -""" -@author: Frank Brehm -@contact: frank@brehm-online.com -@copyright: © 2020 by Frank Brehm, Berlin -@summary: A module for providing a mutable set with case insensitive sting items. -""" -from __future__ import absolute_import - -# Standard module -import logging - -try: - from collections.abc import MutableSet -except ImportError: - from collections import MutableSet - -# Third party modules - -# Own modules -from fb_tools.errors import FbError - -__version__ = '0.1.1' - -LOG = logging.getLogger(__name__) - -# ============================================================================= -class WrongItemTypeError(TypeError, FbError): - """Exeception class for the case, that a given parameter ist not of type str.""" - - # ------------------------------------------------------------------------- - def __init__(self, item): - - self.item = item - super(WrongItemTypeError, self).__init__() - - # ------------------------------------------------------------------------- - def __str__(self): - - msg = "Key {item!r} must be of type 'str', but is of type {cls!r} instead." - return msg.format(item=self.item, cls=self.item.__class__.__name__) - - -# ============================================================================= -class WrongCompareSetClassError(TypeError, FbError): - """Exeception class for the case, that a given class ist not of an - instance of CaseInsensitiveStringSet.""" - - # ------------------------------------------------------------------------- - def __init__(self, other): - - self.other_class = other.__class__.__name__ - super(WrongCompareSetClassError, self).__init__() - - # ------------------------------------------------------------------------- - def __str__(self): - - msg = "Object {!r} is not a CaseInsensitiveStringSet object." - return msg.format(self.other_class) - - -# ============================================================================= -class CaseInsensitiveStringSet(MutableSet): - """ - A mutable set, where the strings are insensitive strings. - The items MUST be of type string! - It works like a set. - """ - - wrong_type_msg = "Item {item!r} must be of type 'str', but is of type {cls!r} instead." - - # ------------------------------------------------------------------------- - def __init__(self, iterable): - - self._items = {} - - for item in iterable: - - if not isinstance(item, str): - raise WrongItemTypeError(item) - - self.add(item) - - # ------------------------------------------------------------------------- - # Mandatory methods (ABC methods) - - # ------------------------------------------------------------------------- - def __iter__(self): - - for key in sorted(self._items.keys()): - yield self._items[key] - - # ------------------------------------------------------------------------- - def __contains__(self, value): - """ The 'in' operator.""" - - if not isinstance(value, str): - raise WrongItemTypeError(value) - - ival = value.lower() - if ival in self._items: - return True - return False - - # ------------------------------------------------------------------------- - def __len__(self): - return len(self._items) - - # ------------------------------------------------------------------------- - def add(self, value): - - if not isinstance(value, str): - raise WrongItemTypeError(value) - - ival = value.lower() - self._items[ival] = value - - # ------------------------------------------------------------------------- - def discard(self, value): - - ival = value.lower() - if ival in self._items: - del self._items[ival] - - # ------------------------------------------------------------------------- - # Nice to have methods - - # ------------------------------------------------------------------------- - def issubset(self, other): - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - for item in self._items: - if item not in other: - return False - - return True - - # ------------------------------------------------------------------------- - def __le__(self, other): - """The '<=' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - return self.issubset(other) - - # ------------------------------------------------------------------------- - def __eq__(self, other): - """The '==' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - if len(self) != len(other): - return False - - for item in self._items: - if item not in other: - return False - - return True - - # ------------------------------------------------------------------------- - def __ne__(self, other): - """The '!=' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - if self == other: - return False - return True - - # ------------------------------------------------------------------------- - def __lt__(self, other): - """The '<' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - ret = True - for item in self._items: - if item not in other: - ret = False - if ret: - if len(self) != len(other): - return True - return False - - # ------------------------------------------------------------------------- - def __gt__(self, other): - """The '>' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - if self.__le__(other): - return False - return True - - # ------------------------------------------------------------------------- - def __ge__(self, other): - """The '>=' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - if self.__lt__(other): - return False - return True - - # ------------------------------------------------------------------------- - def __copy__(self): - - empty = [] - new_set = self.__class__(empty) - for item in self: - new_set.add(item) - - return new_set - - # ------------------------------------------------------------------------- - def copy(self): - return self.__copy__() - - # ------------------------------------------------------------------------- - def values(self): - - ret = [] - for item in self: - ret.append(item) - return ret - - # ------------------------------------------------------------------------- - def __str__(self): - - if len(self) == 0: - return "{}()".format(self.__class__.__name__) - - ret = "{}(".format(self.__class__.__name__) - ret += ', '.join(map(lambda x: "{!r}".format(x), self.values())) - ret += ')' - - return ret - - # ------------------------------------------------------------------------- - def __repr__(self): - return str(self) - - # ------------------------------------------------------------------------- - def union(self, *others): - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - new_set = self.__copy__() - for other in others: - for item in other: - if item not in new_set: - new_set.add(item) - - return new_set - - # ------------------------------------------------------------------------- - def __or__(self, *others): - """The '|' operator.""" - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - return self.union(*others) - - # ------------------------------------------------------------------------- - def intersection(self, *others): - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - empty = [] - new_set = self.__class__(empty) - for item in self: - do_add = True - for other in others: - if item not in other: - do_add = False - if do_add: - new_set.add(item) - - return new_set - - # ------------------------------------------------------------------------- - def __and__(self, *others): - """The '&' operator.""" - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - return self.intersection(*others) - - # ------------------------------------------------------------------------- - def difference(self, *others): - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - empty = [] - new_set = self.__class__(empty) - for item in self: - do_add = True - for other in others: - if item in other: - do_add = False - if do_add: - new_set.add(item) - - return new_set - - # ------------------------------------------------------------------------- - def __sub__(self, *others): - """The '-' operator.""" - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - return self.difference(*others) - - # ------------------------------------------------------------------------- - def symmetric_difference(self, other): - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - empty = [] - new_set = self.__class__(empty) - - for item in self: - if item not in other: - new_set.add(item) - - for item in other: - if item not in self: - new_set.add(item) - - return new_set - - # ------------------------------------------------------------------------- - def __xor__(self, other): - """The '^' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - return self.symmetric_difference(other) - - # ------------------------------------------------------------------------- - def isdisjoint(self, other): - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - for item in self: - if item in other: - return False - - for item in other: - if item in self: - return False - - return True - - # ------------------------------------------------------------------------- - def update(self, *others): - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - for other in others: - for item in other: - if item not in self: - self.add(item) - - # ------------------------------------------------------------------------- - def __ior__(self, *others): - """The '|=' operator.""" - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - self.update(*others) - - # ------------------------------------------------------------------------- - def intersection_update(self, *others): - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - for item in self: - for other in others: - if item not in other: - self.discard(item) - break - - # ------------------------------------------------------------------------- - def __iand__(self, *others): - """The '&=' operator.""" - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - self.intersection_update(*others) - - # ------------------------------------------------------------------------- - def difference_update(self, *others): - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - for item in self: - for other in others: - if item in other: - self.discard(item) - break - - # ------------------------------------------------------------------------- - def __isub__(self, *others): - """The '-=' operator.""" - - for other in others: - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - self.difference_update(*others) - - # ------------------------------------------------------------------------- - def symmetric_difference_update(self, other): - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - for item in self: - if item in other: - self.discard(item) - - for item in other: - if item not in self: - self.add(item) - - # ------------------------------------------------------------------------- - def __ixor__(self, other): - """The '|=' operator.""" - - if not isinstance(other, CaseInsensitiveStringSet): - raise WrongCompareSetClassError(other) - - self.symmetric_difference_update(other) - - # ------------------------------------------------------------------------- - def remove(self, value): - - ival = value.lower() - if ival in self._items: - del self._items[ival] - return - - raise KeyError(value) - - # ------------------------------------------------------------------------- - def pop(self): - - if len(self) == 0: - raise IndexError("pop() from empty list") - - key = self._items.keys()[0] - value = self._items[key] - del self._items[key] - - return value - - # ------------------------------------------------------------------------- - def clear(self): - - self._items = {} - - # ------------------------------------------------------------------------- - def as_list(self): - - ret = [] - for item in self: - ret.append(item) - - return ret - - -# ============================================================================= -if __name__ == "__main__": - - pass - -# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4 list