Skip to content

AliasDict

AliasDict - Pseudo dictionary with supports aliases for keys.

Class AliasDict contains the following methods:

  • get - Get value by alias.
  • add - Add a new key and value pair.
  • update - Update the value of an existing key.
  • delete - Delete the value associated with the key and all its aliases.
  • add_alias - Add a new alias to an existing set.
  • delete_alias - Remove the alias from the existing set.
  • has_key - Check if the alias exists.
  • has_value - Check if the value exists.
  • items - Returns a generator of list of AliasDict elements grouped into tuples.
  • keys - Get a generator of list of all aliases.
  • values - Get a generator of list of all values.

AliasDict

Pseudo dictionary with supports aliases for keys.

Source code in src/xloft/types/alias_dict.py 
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
class AliasDict:
    """Pseudo dictionary with supports aliases for keys."""

    def __init__(self, *args: tuple[set[str | int | float], Any]) -> None:  # noqa: D107
        self.__dict__["_store"] = []
        self.__dict__["_aliases"] = set()  # for uniqueness check
        if len(args) > 0:
            for item in args:
                if not self._aliases.isdisjoint(item[0]):
                    err_msg = "In some keys, aliases are repeated."
                    raise KeyError(err_msg)
                self._aliases.update(item[0])
                self._store.append(copy.deepcopy(list(item)))

    def __repr__(self) -> str:
        """Called by the repr built-in function.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> repr(ad)
            'AliasDict([({"English", "en"}, "lemmatize_en_all")])'

        Returns:
            Returns raw data used for internal representation in python.
        """
        store = self.__dict__["_store"]
        source_data = [tuple(item) for item in store]
        return f"AliasDict({source_data})"

    def __str__(self) -> str:
        """Get a string representation of dictionary.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> str(ad)
            '[({"English", "en"}, "lemmatize_en_all")]'

        Returns:
            String representation of dictionary.
        """
        store = self.__dict__["_store"]
        return str([tuple(item) for item in store])

    def __bool__(self) -> bool:
        """Called when checking for truth.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> bool(ad)
            True

        Returns:
            Boolean value.
        """
        return len(self.__dict__["_store"]) > 0

    def __len__(self) -> int:
        """Get the number of elements in the dictionary.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> len(ad)
            1

        Returns:
            The number of elements in the dictionary.
        """
        return len(self.__dict__["_store"])

    def __getattr__(self, name: str) -> None:
        """Blocked Getter."""
        raise AttributeDoesNotGetValueError(name)

    def __setattr__(self, name: str, value: Any) -> None:
        """Blocked Setter."""
        raise AttributeDoesNotSetValueError(name)

    def __delattr__(self, name: str) -> None:
        """Blocked Deleter."""
        raise AttributeCannotBeDeleteError(name)

    def __getitem__(self, alias: str | int | float) -> Any:
        """Get the value by named index.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad["en"]
            "lemmatize_en_all"

        Args:
            alias (str | int | float): Alias of the conditional key.

        Returns:
            Return the value for alias, else KeyError.
        """
        for item in self.__dict__["_store"]:
            if alias in item[0]:
                return copy.deepcopy(item[1])

        raise KeyError(f"Alias `{alias}` is missing.")

    def __setitem__(self, alias: str | int | float, value: Any) -> None:
        """Update the value at the named index or add a new one if the alias is missing.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad["en"] = "Hello world!"
            >>> ad["English"]
            "Hello world!"
            >>> ad["new key"] = "I'm new key"
            >>> ad["new key"]
            "I'm new key"

        Args:
            alias (str | int | float): Alias of the conditional key.
            value (Any): Value associated with alias.

        Returns:
            `None` or `KeyError` if alias is missing.
        """
        try:
            self.update(alias, value)
        except KeyError:
            self.add({alias}, value)

    def __delitem__(self, alias: str | int | float) -> None:
        """Delete an element by index.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> del ad["en"]
            >>> ad.get("English")
            None

        Args:
            alias (str | int | float): Alias of the conditional key.

        Returns:
            `None` or `KeyError` if alias is missing.
        """
        self.delete(alias)

    def get(self, alias: str | int | float, default: Any = None) -> Any:
        """Return the value for alias if alias is in the dictionary, else default.

        If there is no alias, return the default value.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad.get("en")
            "lemmatize_en_all"

        Args:
            alias (str | int | float): Alias of the conditional key.
            default (Any): Value by default.

        Returns:
            Return the value for alias if alias is in the dictionary, else default.
        """
        for item in self.__dict__["_store"]:
            if alias in item[0]:
                return copy.deepcopy(item[1])

        return default

    def add(self, aliases: set[str | int | float], value: Any) -> None:
        """Add a new conditional key and value.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad.add({"Russian", "ru"}, "lemmatize_ru_all")
            >>> ad.get("ru")
            "lemmatize_ru_all"

        Args:
            aliases (set[str | int | float]): List (set) aliases of key.
            value (Any): Value associated with alias.

        Returns:
            `None` or `KeyError` if some aliases already exist.
        """
        if not self._aliases.isdisjoint(aliases):
            err_msg = "Some aliases already exist."
            raise KeyError(err_msg)

        self._store.append([aliases, copy.deepcopy(value)])
        self._aliases.update(aliases)

    def update(self, alias: str | int | float, value: Any) -> None:
        """Update value for existing alias.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad.update("en", "Hello world!")
            >>> ad.get("English")
            "Hello world!"

        Args:
            alias (str | int | float): Alias of the conditional key.
            value (Any): Value associated with alias.

        Returns:
            `None` or `KeyError` if alias is missing.
        """
        for item in self.__dict__["_store"]:
            if alias in item[0]:
                item[1] = copy.deepcopy(value)
                return

        err_msg = f"Alias `{alias}` is missing."
        raise KeyError(err_msg)

    def delete(self, alias: str | int | float) -> None:
        """Delete the value associated with the alias and all its siblings.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad.delete("en")
            >>> ad.get("English")
            None

        Args:
            alias (str | int | float): Alias of the conditional key.

        Returns:
            `None` or `KeyError` if alias is missing.
        """
        for item in self.__dict__["_store"]:
            if alias in item[0]:
                self.__dict__["_aliases"] = {alias for alias in self.__dict__["_aliases"] if alias not in item[0]}
                self.__dict__["_store"] = [item for item in self.__dict__["_store"] if alias not in item[0]]
                return

        err_msg = f"Alias `{alias}` is missing."
        raise KeyError(err_msg)

    def add_alias(
        self,
        alias: str | int | float,
        new_alias: str | int | float,
    ) -> None:
        """Add a new alias to an existing set.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English"}, "lemmatize_en_all")])
            >>> ad.add_alias("English", "en")
            >>> ad.get("en")
            "lemmatize_en_all"

        Args:
            alias (str | int | float): Existing alias.
            new_alias (str | int | float): The alias that needs to be added to the existing set.

        Returns:
            `None` or `KeyError` if alias is missing or if new alias is already exists.
        """
        if new_alias in self.__dict__["_aliases"]:
            err_msg = f"New Alias `{new_alias}` is already exists!"
            raise KeyError(err_msg)

        for item in self.__dict__["_store"]:
            if alias in item[0]:
                item[0].add(new_alias)
                self._aliases.add(new_alias)
                return

        err_msg = f"Alias `{alias}` is missing."
        raise KeyError(err_msg)

    def delete_alias(self, alias: str | int | float) -> None:
        """Remove the alias from the existing set.

        If the alias was the last one, then the value associated with it is deleted.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad.delete_alias("en")
            >>> ad.keys()
            ["English"]

        Args:
            alias (str | int | float): Existing alias.

        Returns:
            `None` or `KeyError` if alias is missing.
        """
        for item in self.__dict__["_store"]:
            if alias in item[0]:
                if len(item[0]) == 1:
                    self._store = [item for item in self._store if alias not in item[0]]
                else:
                    item[0].remove(alias)
                self._aliases.remove(alias)
                return

        err_msg = f"Alias `{alias}` is missing."
        raise KeyError(err_msg)

    def has_key(self, alias: str | int | float) -> bool:
        """Check if the alias exists.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad.has_key("en")
            True

        Args:
            alias (str | int | float): Some alias.

        Returns:
            True if the key exists, otherwise False.
        """
        return alias in self.__dict__["_aliases"]

    def has_value(self, value: Any) -> bool:
        """Check if the value exists.

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> ad.has_value("lemmatize_en_all")
            True

        Args:
            value (Any): Value associated with alias.

        Returns:
            True if the value exists, otherwise False.
        """
        is_exists = False
        for item in self.__dict__["_store"]:
            if value == item[1]:
                is_exists = True
                break

        return is_exists

    def items(self) -> Generator[tuple[list[str | int | float], Any]]:
        """Returns a generator of list containing a tuple for each key-value pair.

        This is convenient for use in a `for` loop.
        If you need to get a list, do it list(instance.items()).

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> for aliases, value in ad.items():
            ...     print(f"Aliases: {aliases}, Value: {value}")
            "Key: ['English', 'en'], Value: lemmatize_en_all"

        Returns:
            Returns a list containing a tuple for each key-value pair.
            Type: `list[tuple[list[str | int | float], Any]]` or `[]`.
        """
        store = self.__dict__["_store"]
        return ((list(item[0]), copy.deepcopy(item[1])) for item in store)

    def keys(self) -> Generator[str | int | float]:
        """Get a generator of list of all aliases.

        If you need to get a list, do it list(instance.keys()).

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> list(ad.keys())
            ["English", "en"]

        Returns:
            List of all aliases.
        """
        aliases = self.__dict__["_aliases"]
        return (item for item in aliases)

    def values(self) -> Generator[Any]:
        """Get a generator of list of all values.

        If you need to get a list, do it list(instance.values()).

        Examples:
            >>> from xloft import AliasDict
            >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
            >>> list(ad.values())
            ["lemmatize_en_all"]

        Returns:
            List of all values.
        """
        store = self.__dict__["_store"]
        return (copy.deepcopy(item[1]) for item in store)

__bool__()

Called when checking for truth.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> bool(ad)
True

Returns:

Type Description
bool

Boolean value.
Source code in src/xloft/types/alias_dict.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
def __bool__(self) -> bool:
    """Called when checking for truth.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> bool(ad)
        True

    Returns:
        Boolean value.
    """
    return len(self.__dict__["_store"]) > 0

__delattr__(name)

Blocked Deleter.

Source code in src/xloft/types/alias_dict.py 
117
118
119
def __delattr__(self, name: str) -> None:
    """Blocked Deleter."""
    raise AttributeCannotBeDeleteError(name)

__delitem__(alias)

Delete an element by index.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> del ad["en"]
>>> ad.get("English")
None

Parameters:

Name Type Description Default
alias str | int | float

Alias of the conditional key.

 required

Returns:

Type Description
None

None or KeyError if alias is missing.
Source code in src/xloft/types/alias_dict.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def __delitem__(self, alias: str | int | float) -> None:
    """Delete an element by index.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> del ad["en"]
        >>> ad.get("English")
        None

    Args:
        alias (str | int | float): Alias of the conditional key.

    Returns:
        `None` or `KeyError` if alias is missing.
    """
    self.delete(alias)

__getattr__(name)

Blocked Getter.

Source code in src/xloft/types/alias_dict.py 
109
110
111
def __getattr__(self, name: str) -> None:
    """Blocked Getter."""
    raise AttributeDoesNotGetValueError(name)

__getitem__(alias)

Get the value by named index.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad["en"]
"lemmatize_en_all"

Parameters:

Name Type Description Default
alias str | int | float

Alias of the conditional key.

 required

Returns:

Type Description
Any

Return the value for alias, else KeyError.
Source code in src/xloft/types/alias_dict.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
def __getitem__(self, alias: str | int | float) -> Any:
    """Get the value by named index.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad["en"]
        "lemmatize_en_all"

    Args:
        alias (str | int | float): Alias of the conditional key.

    Returns:
        Return the value for alias, else KeyError.
    """
    for item in self.__dict__["_store"]:
        if alias in item[0]:
            return copy.deepcopy(item[1])

    raise KeyError(f"Alias `{alias}` is missing.")

__len__()

Get the number of elements in the dictionary.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> len(ad)
1

Returns:

Type Description
int

The number of elements in the dictionary.
Source code in src/xloft/types/alias_dict.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
def __len__(self) -> int:
    """Get the number of elements in the dictionary.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> len(ad)
        1

    Returns:
        The number of elements in the dictionary.
    """
    return len(self.__dict__["_store"])

__repr__()

Called by the repr built-in function.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> repr(ad)
'AliasDict([({"English", "en"}, "lemmatize_en_all")])'

Returns:

Type Description
str

Returns raw data used for internal representation in python.
Source code in src/xloft/types/alias_dict.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
def __repr__(self) -> str:
    """Called by the repr built-in function.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> repr(ad)
        'AliasDict([({"English", "en"}, "lemmatize_en_all")])'

    Returns:
        Returns raw data used for internal representation in python.
    """
    store = self.__dict__["_store"]
    source_data = [tuple(item) for item in store]
    return f"AliasDict({source_data})"

__setattr__(name, value)

Blocked Setter.

Source code in src/xloft/types/alias_dict.py 
113
114
115
def __setattr__(self, name: str, value: Any) -> None:
    """Blocked Setter."""
    raise AttributeDoesNotSetValueError(name)

__setitem__(alias, value)

Update the value at the named index or add a new one if the alias is missing.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad["en"] = "Hello world!"
>>> ad["English"]
"Hello world!"
>>> ad["new key"] = "I'm new key"
>>> ad["new key"]
"I'm new key"

Parameters:

Name Type Description Default
alias str | int | float

Alias of the conditional key.

 required
value Any

Value associated with alias.

 required

Returns:

Type Description
None

None or KeyError if alias is missing.
Source code in src/xloft/types/alias_dict.py 
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
def __setitem__(self, alias: str | int | float, value: Any) -> None:
    """Update the value at the named index or add a new one if the alias is missing.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad["en"] = "Hello world!"
        >>> ad["English"]
        "Hello world!"
        >>> ad["new key"] = "I'm new key"
        >>> ad["new key"]
        "I'm new key"

    Args:
        alias (str | int | float): Alias of the conditional key.
        value (Any): Value associated with alias.

    Returns:
        `None` or `KeyError` if alias is missing.
    """
    try:
        self.update(alias, value)
    except KeyError:
        self.add({alias}, value)

__str__()

Get a string representation of dictionary.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> str(ad)
'[({"English", "en"}, "lemmatize_en_all")]'

Returns:

Type Description
str

String representation of dictionary.
Source code in src/xloft/types/alias_dict.py 
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def __str__(self) -> str:
    """Get a string representation of dictionary.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> str(ad)
        '[({"English", "en"}, "lemmatize_en_all")]'

    Returns:
        String representation of dictionary.
    """
    store = self.__dict__["_store"]
    return str([tuple(item) for item in store])

add(aliases, value)

Add a new conditional key and value.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad.add({"Russian", "ru"}, "lemmatize_ru_all")
>>> ad.get("ru")
"lemmatize_ru_all"

Parameters:

Name Type Description Default
aliases set[str | int | float]

List (set) aliases of key.

 required
value Any

Value associated with alias.

 required

Returns:

Type Description
None

None or KeyError if some aliases already exist.
Source code in src/xloft/types/alias_dict.py 
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
def add(self, aliases: set[str | int | float], value: Any) -> None:
    """Add a new conditional key and value.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad.add({"Russian", "ru"}, "lemmatize_ru_all")
        >>> ad.get("ru")
        "lemmatize_ru_all"

    Args:
        aliases (set[str | int | float]): List (set) aliases of key.
        value (Any): Value associated with alias.

    Returns:
        `None` or `KeyError` if some aliases already exist.
    """
    if not self._aliases.isdisjoint(aliases):
        err_msg = "Some aliases already exist."
        raise KeyError(err_msg)

    self._store.append([aliases, copy.deepcopy(value)])
    self._aliases.update(aliases)

add_alias(alias, new_alias)

Add a new alias to an existing set.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English"}, "lemmatize_en_all")])
>>> ad.add_alias("English", "en")
>>> ad.get("en")
"lemmatize_en_all"

Parameters:

Name Type Description Default
alias str | int | float

Existing alias.

 required
new_alias str | int | float

The alias that needs to be added to the existing set.

 required

Returns:

Type Description
None

None or KeyError if alias is missing or if new alias is already exists.
Source code in src/xloft/types/alias_dict.py 
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
def add_alias(
    self,
    alias: str | int | float,
    new_alias: str | int | float,
) -> None:
    """Add a new alias to an existing set.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English"}, "lemmatize_en_all")])
        >>> ad.add_alias("English", "en")
        >>> ad.get("en")
        "lemmatize_en_all"

    Args:
        alias (str | int | float): Existing alias.
        new_alias (str | int | float): The alias that needs to be added to the existing set.

    Returns:
        `None` or `KeyError` if alias is missing or if new alias is already exists.
    """
    if new_alias in self.__dict__["_aliases"]:
        err_msg = f"New Alias `{new_alias}` is already exists!"
        raise KeyError(err_msg)

    for item in self.__dict__["_store"]:
        if alias in item[0]:
            item[0].add(new_alias)
            self._aliases.add(new_alias)
            return

    err_msg = f"Alias `{alias}` is missing."
    raise KeyError(err_msg)

delete(alias)

Delete the value associated with the alias and all its siblings.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad.delete("en")
>>> ad.get("English")
None

Parameters:

Name Type Description Default
alias str | int | float

Alias of the conditional key.

 required

Returns:

Type Description
None

None or KeyError if alias is missing.
Source code in src/xloft/types/alias_dict.py 
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
def delete(self, alias: str | int | float) -> None:
    """Delete the value associated with the alias and all its siblings.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad.delete("en")
        >>> ad.get("English")
        None

    Args:
        alias (str | int | float): Alias of the conditional key.

    Returns:
        `None` or `KeyError` if alias is missing.
    """
    for item in self.__dict__["_store"]:
        if alias in item[0]:
            self.__dict__["_aliases"] = {alias for alias in self.__dict__["_aliases"] if alias not in item[0]}
            self.__dict__["_store"] = [item for item in self.__dict__["_store"] if alias not in item[0]]
            return

    err_msg = f"Alias `{alias}` is missing."
    raise KeyError(err_msg)

delete_alias(alias)

Remove the alias from the existing set.

If the alias was the last one, then the value associated with it is deleted.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad.delete_alias("en")
>>> ad.keys()
["English"]

Parameters:

Name Type Description Default
alias str | int | float

Existing alias.

 required

Returns:

Type Description
None

None or KeyError if alias is missing.
Source code in src/xloft/types/alias_dict.py 
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
def delete_alias(self, alias: str | int | float) -> None:
    """Remove the alias from the existing set.

    If the alias was the last one, then the value associated with it is deleted.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad.delete_alias("en")
        >>> ad.keys()
        ["English"]

    Args:
        alias (str | int | float): Existing alias.

    Returns:
        `None` or `KeyError` if alias is missing.
    """
    for item in self.__dict__["_store"]:
        if alias in item[0]:
            if len(item[0]) == 1:
                self._store = [item for item in self._store if alias not in item[0]]
            else:
                item[0].remove(alias)
            self._aliases.remove(alias)
            return

    err_msg = f"Alias `{alias}` is missing."
    raise KeyError(err_msg)

get(alias, default=None)

Return the value for alias if alias is in the dictionary, else default.

If there is no alias, return the default value.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad.get("en")
"lemmatize_en_all"

Parameters:

Name Type Description Default
alias str | int | float

Alias of the conditional key.

 required
default Any

Value by default.

 None

Returns:

Type Description
Any

Return the value for alias if alias is in the dictionary, else default.
Source code in src/xloft/types/alias_dict.py 
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
def get(self, alias: str | int | float, default: Any = None) -> Any:
    """Return the value for alias if alias is in the dictionary, else default.

    If there is no alias, return the default value.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad.get("en")
        "lemmatize_en_all"

    Args:
        alias (str | int | float): Alias of the conditional key.
        default (Any): Value by default.

    Returns:
        Return the value for alias if alias is in the dictionary, else default.
    """
    for item in self.__dict__["_store"]:
        if alias in item[0]:
            return copy.deepcopy(item[1])

    return default

has_key(alias)

Check if the alias exists.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad.has_key("en")
True

Parameters:

Name Type Description Default
alias str | int | float

Some alias.

 required

Returns:

Type Description
bool

True if the key exists, otherwise False.
Source code in src/xloft/types/alias_dict.py 
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
def has_key(self, alias: str | int | float) -> bool:
    """Check if the alias exists.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad.has_key("en")
        True

    Args:
        alias (str | int | float): Some alias.

    Returns:
        True if the key exists, otherwise False.
    """
    return alias in self.__dict__["_aliases"]

has_value(value)

Check if the value exists.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad.has_value("lemmatize_en_all")
True

Parameters:

Name Type Description Default
value Any

Value associated with alias.

 required

Returns:

Type Description
bool

True if the value exists, otherwise False.
Source code in src/xloft/types/alias_dict.py 
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
def has_value(self, value: Any) -> bool:
    """Check if the value exists.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad.has_value("lemmatize_en_all")
        True

    Args:
        value (Any): Value associated with alias.

    Returns:
        True if the value exists, otherwise False.
    """
    is_exists = False
    for item in self.__dict__["_store"]:
        if value == item[1]:
            is_exists = True
            break

    return is_exists

items()

Returns a generator of list containing a tuple for each key-value pair.

This is convenient for use in a for loop. If you need to get a list, do it list(instance.items()).

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> for aliases, value in ad.items():
...     print(f"Aliases: {aliases}, Value: {value}")
"Key: ['English', 'en'], Value: lemmatize_en_all"

Returns:

Name Type Description
Generator[tuple[list[str | int | float], Any]]

Returns a list containing a tuple for each key-value pair.
Type Generator[tuple[list[str | int | float], Any]]

list[tuple[list[str | int | float], Any]] or [].
Source code in src/xloft/types/alias_dict.py 
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
def items(self) -> Generator[tuple[list[str | int | float], Any]]:
    """Returns a generator of list containing a tuple for each key-value pair.

    This is convenient for use in a `for` loop.
    If you need to get a list, do it list(instance.items()).

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> for aliases, value in ad.items():
        ...     print(f"Aliases: {aliases}, Value: {value}")
        "Key: ['English', 'en'], Value: lemmatize_en_all"

    Returns:
        Returns a list containing a tuple for each key-value pair.
        Type: `list[tuple[list[str | int | float], Any]]` or `[]`.
    """
    store = self.__dict__["_store"]
    return ((list(item[0]), copy.deepcopy(item[1])) for item in store)

keys()

Get a generator of list of all aliases.

If you need to get a list, do it list(instance.keys()).

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> list(ad.keys())
["English", "en"]

Returns:

Type Description
Generator[str | int | float]

List of all aliases.
Source code in src/xloft/types/alias_dict.py 
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
def keys(self) -> Generator[str | int | float]:
    """Get a generator of list of all aliases.

    If you need to get a list, do it list(instance.keys()).

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> list(ad.keys())
        ["English", "en"]

    Returns:
        List of all aliases.
    """
    aliases = self.__dict__["_aliases"]
    return (item for item in aliases)

update(alias, value)

Update value for existing alias.

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> ad.update("en", "Hello world!")
>>> ad.get("English")
"Hello world!"

Parameters:

Name Type Description Default
alias str | int | float

Alias of the conditional key.

 required
value Any

Value associated with alias.

 required

Returns:

Type Description
None

None or KeyError if alias is missing.
Source code in src/xloft/types/alias_dict.py 
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
def update(self, alias: str | int | float, value: Any) -> None:
    """Update value for existing alias.

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> ad.update("en", "Hello world!")
        >>> ad.get("English")
        "Hello world!"

    Args:
        alias (str | int | float): Alias of the conditional key.
        value (Any): Value associated with alias.

    Returns:
        `None` or `KeyError` if alias is missing.
    """
    for item in self.__dict__["_store"]:
        if alias in item[0]:
            item[1] = copy.deepcopy(value)
            return

    err_msg = f"Alias `{alias}` is missing."
    raise KeyError(err_msg)

values()

Get a generator of list of all values.

If you need to get a list, do it list(instance.values()).

Examples:

>>> from xloft import AliasDict
>>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
>>> list(ad.values())
["lemmatize_en_all"]

Returns:

Type Description
Generator[Any]

List of all values.
Source code in src/xloft/types/alias_dict.py 
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
def values(self) -> Generator[Any]:
    """Get a generator of list of all values.

    If you need to get a list, do it list(instance.values()).

    Examples:
        >>> from xloft import AliasDict
        >>> ad = AliasDict([({"English", "en"}, "lemmatize_en_all")])
        >>> list(ad.values())
        ["lemmatize_en_all"]

    Returns:
        List of all values.
    """
    store = self.__dict__["_store"]
    return (copy.deepcopy(item[1]) for item in store)