# provides a simple and efficient way to remove duplicates from an iterable (even with unhashable elements, optional order preservation)
## pip install screwduplicates
#### Tested against Windows 10 / Python 3.10 / Anaconda
### Duplicate Removal:
It effectively removes duplicate elements from an iterable, ensuring that the returned iterable only contains unique values. This can be useful in scenarios where duplicate values need to be eliminated to avoid redundant or incorrect data.
### Flexibility:
The function accepts a wide range of iterable types, including lists, tuples, and custom iterable objects. It can handle both hashable and unhashable elements, accommodating diverse data types.
### Order Preservation:
The function provides an option to preserve the original order of elements in the iterable by setting the keep_order parameter to True. This is valuable when the order of elements matters, such as maintaining the sequence of items in a list.
### Error Handling:
If the input iterable contains unhashable elements, the function gracefully handles the TypeError that arises during the conversion to a set. Instead of raising an error, it automatically switches to preserving order and includes a representation of the unhashable element in the output.
```python
testdict = {
"List": [5, 4, 1, 2, 2, 3, 4, 5],
"Set": {1, 2, 3, 4, 5},
"Tuple": (1, 3, 4, 2, 3, 4, 5, 5, 5, 2, 2, 1),
"Dictionary": {"a": 1, "b": 2, "c": 3},
"String": "Hello",
"Bytes": b"Hello",
"Bytearray": bytearray(b"Hello"),
"List of strings": ["Hello", "World", "Hello"],
"List of numbers": [2.5, 3.5, 1.5, 2.5, 3.5],
"Empty list": [],
"Set of strings": {"apple", "banana", "cherry"},
"Set of numbers": {1, 2, 3, 4, 5},
"Tuple of strings": ("apple", "banana", "cherry", "banana", "banana"),
"Tuple of numbers": (3, 4, 5, 1, 2, 3, 4, 2, 3, 4, 2, 3, 4, 5),
"Dictionary with numbers": {1: "one", 2: "two", 3: "three"},
"Dictionary with strings": {"a": "apple", "b": "banana", "c": "cherry"},
"List of mixed types": [1, "a", 2.5, True, True, True, 1, "a", "Hello"],
"Set of mixed types": {1, "a", 2.5, True, "Hello"},
"Tuple of mixed types": (1, "a", 2.5, True, "Hello", 1, "a", 2.5),
"Nested list": [[1, 2], [3, 4], [5, 6], [1, 2], [3, 4], [3, 4], [5, 6]],
"Nested set": {frozenset({1, 2}), frozenset({3, 4}), frozenset({5, 6})},
"Nested tuple": ((1, 2), (3, 4), (5, 6), (3, 4)),
"List with None value": [1, None, 3, None, 5],
"Set with None value": {1, None, 3, None, 5},
"Tuple with None value": (1, None, 3, None, 5),
"List with boolean values": [True, False, True],
"Set with boolean values": {True, False},
"Tuple with boolean values": (True, False, True),
"List with repeated values": [1, 1, 1, 1, 1],
"Set with repeated values": {1, 1, 1, 1, 1},
"Tuple with repeated values": (1, 1, 1, 1, 1),
"List with mixed types and duplicates": [1, "a", 2, "a", 3, True, 3],
"Set with mixed types and duplicates": {1, "a", 2, "a", 3, True},
"Tuple with mixed types and duplicates": (1, "a", 2, "a", 3, True),
"List with empty strings": ["", "World", "World", "Hello", "World"],
"Set with empty strings": {"", "World", "Hello", "World", "World"},
}
from screwduplicates import del_duplicates
for key, item in testdict.items():
print(f"\n---------------\n{key}:")
print(f"Original: {item}")
print(f"dont't keep order: {del_duplicates(item, keep_order=False)}")
print(f"Keep order: {del_duplicates(item, keep_order=True)}")
---------------
List:
Original: [5, 4, 1, 2, 2, 3, 4, 5]
dont't keep order: [1, 2, 3, 4, 5]
Keep order: [5, 4, 1, 2, 3]
---------------
Set:
Original: {1, 2, 3, 4, 5}
dont't keep order: {1, 2, 3, 4, 5}
Keep order: {1, 2, 3, 4, 5}
---------------
Tuple:
Original: (1, 3, 4, 2, 3, 4, 5, 5, 5, 2, 2, 1)
dont't keep order: (1, 2, 3, 4, 5)
Keep order: (1, 3, 4, 2, 5)
---------------
Dictionary:
Original: {'a': 1, 'b': 2, 'c': 3}
dont't keep order: {'a': 1, 'b': 2, 'c': 3}
Keep order: {'a': 1, 'b': 2, 'c': 3}
---------------
String:
Original: Hello
dont't keep order: loeH
Keep order: Helo
---------------
Bytes:
Original: b'Hello'
dont't keep order: b'Hleo'
Keep order: b'Helo'
---------------
Bytearray:
Original: bytearray(b'Hello')
dont't keep order: bytearray(b'Hleo')
Keep order: bytearray(b'Helo')
---------------
List of strings:
Original: ['Hello', 'World', 'Hello']
dont't keep order: ['World', 'Hello']
Keep order: ['Hello', 'World']
---------------
List of numbers:
Original: [2.5, 3.5, 1.5, 2.5, 3.5]
dont't keep order: [1.5, 2.5, 3.5]
Keep order: [2.5, 3.5, 1.5]
---------------
Empty list:
Original: []
dont't keep order: []
Keep order: []
---------------
Set of strings:
Original: {'cherry', 'banana', 'apple'}
dont't keep order: {'cherry', 'banana', 'apple'}
Keep order: {'cherry', 'banana', 'apple'}
---------------
Set of numbers:
Original: {1, 2, 3, 4, 5}
dont't keep order: {1, 2, 3, 4, 5}
Keep order: {1, 2, 3, 4, 5}
---------------
Tuple of strings:
Original: ('apple', 'banana', 'cherry', 'banana', 'banana')
dont't keep order: ('cherry', 'banana', 'apple')
Keep order: ('apple', 'banana', 'cherry')
---------------
Tuple of numbers:
Original: (3, 4, 5, 1, 2, 3, 4, 2, 3, 4, 2, 3, 4, 5)
dont't keep order: (1, 2, 3, 4, 5)
Keep order: (3, 4, 5, 1, 2)
---------------
Dictionary with numbers:
Original: {1: 'one', 2: 'two', 3: 'three'}
dont't keep order: {1: 'one', 2: 'two', 3: 'three'}
Keep order: {1: 'one', 2: 'two', 3: 'three'}
---------------
Dictionary with strings:
Original: {'a': 'apple', 'b': 'banana', 'c': 'cherry'}
dont't keep order: {'a': 'apple', 'b': 'banana', 'c': 'cherry'}
Keep order: {'a': 'apple', 'b': 'banana', 'c': 'cherry'}
---------------
List of mixed types:
Original: [1, 'a', 2.5, True, True, True, 1, 'a', 'Hello']
dont't keep order: [1, 2.5, 'a', 'Hello']
Keep order: [1, 'a', 2.5, 'Hello']
---------------
Set of mixed types:
Original: {1, 2.5, 'a', 'Hello'}
dont't keep order: {1, 2.5, 'a', 'Hello'}
Keep order: {1, 2.5, 'a', 'Hello'}
---------------
Tuple of mixed types:
Original: (1, 'a', 2.5, True, 'Hello', 1, 'a', 2.5)
dont't keep order: (1, 2.5, 'a', 'Hello')
Keep order: (1, 'a', 2.5, 'Hello')
---------------
Nested list:
Original: [[1, 2], [3, 4], [5, 6], [1, 2], [3, 4], [3, 4], [5, 6]]
dont't keep order: [[1, 2], [3, 4], [5, 6]]
Keep order: [[1, 2], [3, 4], [5, 6]]
---------------
Nested set:
Original: {frozenset({3, 4}), frozenset({5, 6}), frozenset({1, 2})}
dont't keep order: {frozenset({3, 4}), frozenset({5, 6}), frozenset({1, 2})}
Keep order: {frozenset({3, 4}), frozenset({5, 6}), frozenset({1, 2})}
---------------
Nested tuple:
Original: ((1, 2), (3, 4), (5, 6), (3, 4))
dont't keep order: ((1, 2), (3, 4), (5, 6))
Keep order: ((1, 2), (3, 4), (5, 6))
---------------
List with None value:
Original: [1, None, 3, None, 5]
dont't keep order: [1, 3, None, 5]
Keep order: [1, None, 3, 5]
---------------
Set with None value:
Original: {1, 3, None, 5}
dont't keep order: {1, 3, None, 5}
Keep order: {1, 3, None, 5}
---------------
Tuple with None value:
Original: (1, None, 3, None, 5)
dont't keep order: (1, 3, None, 5)
Keep order: (1, None, 3, 5)
---------------
List with boolean values:
Original: [True, False, True]
dont't keep order: [False, True]
Keep order: [True, False]
---------------
Set with boolean values:
Original: {False, True}
dont't keep order: {False, True}
Keep order: {False, True}
---------------
Tuple with boolean values:
Original: (True, False, True)
dont't keep order: (False, True)
Keep order: (True, False)
---------------
List with repeated values:
Original: [1, 1, 1, 1, 1]
dont't keep order: [1]
Keep order: [1]
---------------
Set with repeated values:
Original: {1}
dont't keep order: {1}
Keep order: {1}
---------------
Tuple with repeated values:
Original: (1, 1, 1, 1, 1)
dont't keep order: (1,)
Keep order: (1,)
---------------
List with mixed types and duplicates:
Original: [1, 'a', 2, 'a', 3, True, 3]
dont't keep order: [3, 1, 2, 'a']
Keep order: [True, 'a', 2, 3]
---------------
Set with mixed types and duplicates:
Original: {'a', 1, 2, 3}
dont't keep order: {'a', 1, 2, 3}
Keep order: {'a', 1, 2, 3}
---------------
Tuple with mixed types and duplicates:
Original: (1, 'a', 2, 'a', 3, True)
dont't keep order: (3, 1, 2, 'a')
Keep order: (True, 'a', 2, 3)
---------------
List with empty strings:
Original: ['', 'World', 'World', 'Hello', 'World']
dont't keep order: ['', 'World', 'Hello']
Keep order: ['', 'World', 'Hello']
---------------
Set with empty strings:
Original: {'', 'World', 'Hello'}
dont't keep order: {'', 'World', 'Hello'}
Keep order: {'', 'World', 'Hello'}
```
Raw data
{
"_id": null,
"home_page": "https://github.com/hansalemaos/screwduplicates",
"name": "screwduplicates",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "remove,duplicates",
"author": "Johannes Fischer",
"author_email": "aulasparticularesdealemaosp@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/9b/82/94d03047577d051639bb2dabf02f79e020080e55ad5284e47bf94f1b7ad4/screwduplicates-0.11.tar.gz",
"platform": null,
"description": "\r\n# provides a simple and efficient way to remove duplicates from an iterable (even with unhashable elements, optional order preservation)\r\n\r\n## pip install screwduplicates\r\n\r\n#### Tested against Windows 10 / Python 3.10 / Anaconda\r\n\r\n### Duplicate Removal: \r\n\r\nIt effectively removes duplicate elements from an iterable, ensuring that the returned iterable only contains unique values. This can be useful in scenarios where duplicate values need to be eliminated to avoid redundant or incorrect data.\r\n\r\n### Flexibility: \r\n\r\nThe function accepts a wide range of iterable types, including lists, tuples, and custom iterable objects. It can handle both hashable and unhashable elements, accommodating diverse data types.\r\n\r\n### Order Preservation: \r\n\r\nThe function provides an option to preserve the original order of elements in the iterable by setting the keep_order parameter to True. This is valuable when the order of elements matters, such as maintaining the sequence of items in a list.\r\n\r\n### Error Handling: \r\n\r\nIf the input iterable contains unhashable elements, the function gracefully handles the TypeError that arises during the conversion to a set. Instead of raising an error, it automatically switches to preserving order and includes a representation of the unhashable element in the output.\r\n\r\n\r\n```python\r\ntestdict = {\r\n \"List\": [5, 4, 1, 2, 2, 3, 4, 5],\r\n \"Set\": {1, 2, 3, 4, 5},\r\n \"Tuple\": (1, 3, 4, 2, 3, 4, 5, 5, 5, 2, 2, 1),\r\n \"Dictionary\": {\"a\": 1, \"b\": 2, \"c\": 3},\r\n \"String\": \"Hello\",\r\n \"Bytes\": b\"Hello\",\r\n \"Bytearray\": bytearray(b\"Hello\"),\r\n \"List of strings\": [\"Hello\", \"World\", \"Hello\"],\r\n \"List of numbers\": [2.5, 3.5, 1.5, 2.5, 3.5],\r\n \"Empty list\": [],\r\n \"Set of strings\": {\"apple\", \"banana\", \"cherry\"},\r\n \"Set of numbers\": {1, 2, 3, 4, 5},\r\n \"Tuple of strings\": (\"apple\", \"banana\", \"cherry\", \"banana\", \"banana\"),\r\n \"Tuple of numbers\": (3, 4, 5, 1, 2, 3, 4, 2, 3, 4, 2, 3, 4, 5),\r\n \"Dictionary with numbers\": {1: \"one\", 2: \"two\", 3: \"three\"},\r\n \"Dictionary with strings\": {\"a\": \"apple\", \"b\": \"banana\", \"c\": \"cherry\"},\r\n \"List of mixed types\": [1, \"a\", 2.5, True, True, True, 1, \"a\", \"Hello\"],\r\n \"Set of mixed types\": {1, \"a\", 2.5, True, \"Hello\"},\r\n \"Tuple of mixed types\": (1, \"a\", 2.5, True, \"Hello\", 1, \"a\", 2.5),\r\n \"Nested list\": [[1, 2], [3, 4], [5, 6], [1, 2], [3, 4], [3, 4], [5, 6]],\r\n \"Nested set\": {frozenset({1, 2}), frozenset({3, 4}), frozenset({5, 6})},\r\n \"Nested tuple\": ((1, 2), (3, 4), (5, 6), (3, 4)),\r\n \"List with None value\": [1, None, 3, None, 5],\r\n \"Set with None value\": {1, None, 3, None, 5},\r\n \"Tuple with None value\": (1, None, 3, None, 5),\r\n \"List with boolean values\": [True, False, True],\r\n \"Set with boolean values\": {True, False},\r\n \"Tuple with boolean values\": (True, False, True),\r\n \"List with repeated values\": [1, 1, 1, 1, 1],\r\n \"Set with repeated values\": {1, 1, 1, 1, 1},\r\n \"Tuple with repeated values\": (1, 1, 1, 1, 1),\r\n \"List with mixed types and duplicates\": [1, \"a\", 2, \"a\", 3, True, 3],\r\n \"Set with mixed types and duplicates\": {1, \"a\", 2, \"a\", 3, True},\r\n \"Tuple with mixed types and duplicates\": (1, \"a\", 2, \"a\", 3, True),\r\n \"List with empty strings\": [\"\", \"World\", \"World\", \"Hello\", \"World\"],\r\n \"Set with empty strings\": {\"\", \"World\", \"Hello\", \"World\", \"World\"},\r\n}\r\nfrom screwduplicates import del_duplicates\r\nfor key, item in testdict.items():\r\n print(f\"\\n---------------\\n{key}:\")\r\n print(f\"Original: {item}\")\r\n print(f\"dont't keep order: {del_duplicates(item, keep_order=False)}\")\r\n print(f\"Keep order: {del_duplicates(item, keep_order=True)}\")\r\n\r\n---------------\r\nList:\r\nOriginal: [5, 4, 1, 2, 2, 3, 4, 5]\r\ndont't keep order: [1, 2, 3, 4, 5]\r\nKeep order: [5, 4, 1, 2, 3]\r\n---------------\r\nSet:\r\nOriginal: {1, 2, 3, 4, 5}\r\ndont't keep order: {1, 2, 3, 4, 5}\r\nKeep order: {1, 2, 3, 4, 5}\r\n---------------\r\nTuple:\r\nOriginal: (1, 3, 4, 2, 3, 4, 5, 5, 5, 2, 2, 1)\r\ndont't keep order: (1, 2, 3, 4, 5)\r\nKeep order: (1, 3, 4, 2, 5)\r\n---------------\r\nDictionary:\r\nOriginal: {'a': 1, 'b': 2, 'c': 3}\r\ndont't keep order: {'a': 1, 'b': 2, 'c': 3}\r\nKeep order: {'a': 1, 'b': 2, 'c': 3}\r\n---------------\r\nString:\r\nOriginal: Hello\r\ndont't keep order: loeH\r\nKeep order: Helo\r\n---------------\r\nBytes:\r\nOriginal: b'Hello'\r\ndont't keep order: b'Hleo'\r\nKeep order: b'Helo'\r\n---------------\r\nBytearray:\r\nOriginal: bytearray(b'Hello')\r\ndont't keep order: bytearray(b'Hleo')\r\nKeep order: bytearray(b'Helo')\r\n---------------\r\nList of strings:\r\nOriginal: ['Hello', 'World', 'Hello']\r\ndont't keep order: ['World', 'Hello']\r\nKeep order: ['Hello', 'World']\r\n---------------\r\nList of numbers:\r\nOriginal: [2.5, 3.5, 1.5, 2.5, 3.5]\r\ndont't keep order: [1.5, 2.5, 3.5]\r\nKeep order: [2.5, 3.5, 1.5]\r\n---------------\r\nEmpty list:\r\nOriginal: []\r\ndont't keep order: []\r\nKeep order: []\r\n---------------\r\nSet of strings:\r\nOriginal: {'cherry', 'banana', 'apple'}\r\ndont't keep order: {'cherry', 'banana', 'apple'}\r\nKeep order: {'cherry', 'banana', 'apple'}\r\n---------------\r\nSet of numbers:\r\nOriginal: {1, 2, 3, 4, 5}\r\ndont't keep order: {1, 2, 3, 4, 5}\r\nKeep order: {1, 2, 3, 4, 5}\r\n---------------\r\nTuple of strings:\r\nOriginal: ('apple', 'banana', 'cherry', 'banana', 'banana')\r\ndont't keep order: ('cherry', 'banana', 'apple')\r\nKeep order: ('apple', 'banana', 'cherry')\r\n---------------\r\nTuple of numbers:\r\nOriginal: (3, 4, 5, 1, 2, 3, 4, 2, 3, 4, 2, 3, 4, 5)\r\ndont't keep order: (1, 2, 3, 4, 5)\r\nKeep order: (3, 4, 5, 1, 2)\r\n---------------\r\nDictionary with numbers:\r\nOriginal: {1: 'one', 2: 'two', 3: 'three'}\r\ndont't keep order: {1: 'one', 2: 'two', 3: 'three'}\r\nKeep order: {1: 'one', 2: 'two', 3: 'three'}\r\n---------------\r\nDictionary with strings:\r\nOriginal: {'a': 'apple', 'b': 'banana', 'c': 'cherry'}\r\ndont't keep order: {'a': 'apple', 'b': 'banana', 'c': 'cherry'}\r\nKeep order: {'a': 'apple', 'b': 'banana', 'c': 'cherry'}\r\n---------------\r\nList of mixed types:\r\nOriginal: [1, 'a', 2.5, True, True, True, 1, 'a', 'Hello']\r\ndont't keep order: [1, 2.5, 'a', 'Hello']\r\nKeep order: [1, 'a', 2.5, 'Hello']\r\n---------------\r\nSet of mixed types:\r\nOriginal: {1, 2.5, 'a', 'Hello'}\r\ndont't keep order: {1, 2.5, 'a', 'Hello'}\r\nKeep order: {1, 2.5, 'a', 'Hello'}\r\n---------------\r\nTuple of mixed types:\r\nOriginal: (1, 'a', 2.5, True, 'Hello', 1, 'a', 2.5)\r\ndont't keep order: (1, 2.5, 'a', 'Hello')\r\nKeep order: (1, 'a', 2.5, 'Hello')\r\n---------------\r\nNested list:\r\nOriginal: [[1, 2], [3, 4], [5, 6], [1, 2], [3, 4], [3, 4], [5, 6]]\r\ndont't keep order: [[1, 2], [3, 4], [5, 6]]\r\nKeep order: [[1, 2], [3, 4], [5, 6]]\r\n---------------\r\nNested set:\r\nOriginal: {frozenset({3, 4}), frozenset({5, 6}), frozenset({1, 2})}\r\ndont't keep order: {frozenset({3, 4}), frozenset({5, 6}), frozenset({1, 2})}\r\nKeep order: {frozenset({3, 4}), frozenset({5, 6}), frozenset({1, 2})}\r\n---------------\r\nNested tuple:\r\nOriginal: ((1, 2), (3, 4), (5, 6), (3, 4))\r\ndont't keep order: ((1, 2), (3, 4), (5, 6))\r\nKeep order: ((1, 2), (3, 4), (5, 6))\r\n---------------\r\nList with None value:\r\nOriginal: [1, None, 3, None, 5]\r\ndont't keep order: [1, 3, None, 5]\r\nKeep order: [1, None, 3, 5]\r\n---------------\r\nSet with None value:\r\nOriginal: {1, 3, None, 5}\r\ndont't keep order: {1, 3, None, 5}\r\nKeep order: {1, 3, None, 5}\r\n---------------\r\nTuple with None value:\r\nOriginal: (1, None, 3, None, 5)\r\ndont't keep order: (1, 3, None, 5)\r\nKeep order: (1, None, 3, 5)\r\n---------------\r\nList with boolean values:\r\nOriginal: [True, False, True]\r\ndont't keep order: [False, True]\r\nKeep order: [True, False]\r\n---------------\r\nSet with boolean values:\r\nOriginal: {False, True}\r\ndont't keep order: {False, True}\r\nKeep order: {False, True}\r\n---------------\r\nTuple with boolean values:\r\nOriginal: (True, False, True)\r\ndont't keep order: (False, True)\r\nKeep order: (True, False)\r\n---------------\r\nList with repeated values:\r\nOriginal: [1, 1, 1, 1, 1]\r\ndont't keep order: [1]\r\nKeep order: [1]\r\n---------------\r\nSet with repeated values:\r\nOriginal: {1}\r\ndont't keep order: {1}\r\nKeep order: {1}\r\n---------------\r\nTuple with repeated values:\r\nOriginal: (1, 1, 1, 1, 1)\r\ndont't keep order: (1,)\r\nKeep order: (1,)\r\n---------------\r\nList with mixed types and duplicates:\r\nOriginal: [1, 'a', 2, 'a', 3, True, 3]\r\ndont't keep order: [3, 1, 2, 'a']\r\nKeep order: [True, 'a', 2, 3]\r\n---------------\r\nSet with mixed types and duplicates:\r\nOriginal: {'a', 1, 2, 3}\r\ndont't keep order: {'a', 1, 2, 3}\r\nKeep order: {'a', 1, 2, 3}\r\n---------------\r\nTuple with mixed types and duplicates:\r\nOriginal: (1, 'a', 2, 'a', 3, True)\r\ndont't keep order: (3, 1, 2, 'a')\r\nKeep order: (True, 'a', 2, 3)\r\n---------------\r\nList with empty strings:\r\nOriginal: ['', 'World', 'World', 'Hello', 'World']\r\ndont't keep order: ['', 'World', 'Hello']\r\nKeep order: ['', 'World', 'Hello']\r\n---------------\r\nSet with empty strings:\r\nOriginal: {'', 'World', 'Hello'}\r\ndont't keep order: {'', 'World', 'Hello'}\r\nKeep order: {'', 'World', 'Hello'}\r\n\r\n\r\n```\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "provides a simple and efficient way to remove duplicates from an iterable (even with unhashable elements, optional order preservation)",
"version": "0.11",
"project_urls": {
"Homepage": "https://github.com/hansalemaos/screwduplicates"
},
"split_keywords": [
"remove",
"duplicates"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "5798f7cc590145b2ef94e4e8cc98318710d729b1b6f4b733eb1530fc115d2f85",
"md5": "0a73b1a8457d6d7159e6b5a04e182bbb",
"sha256": "a828f3db355cd342545d45cb3e6b4c312de4a0e786577546c17b45df8ff24754"
},
"downloads": -1,
"filename": "screwduplicates-0.11-py3-none-any.whl",
"has_sig": false,
"md5_digest": "0a73b1a8457d6d7159e6b5a04e182bbb",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 8213,
"upload_time": "2023-06-29T18:46:08",
"upload_time_iso_8601": "2023-06-29T18:46:08.481254Z",
"url": "https://files.pythonhosted.org/packages/57/98/f7cc590145b2ef94e4e8cc98318710d729b1b6f4b733eb1530fc115d2f85/screwduplicates-0.11-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "9b8294d03047577d051639bb2dabf02f79e020080e55ad5284e47bf94f1b7ad4",
"md5": "e52246fe1575586f9eb6b58f9e23753c",
"sha256": "44174c46090533bf949d2ebc29730b6022734f5ae035b3b9493819155e3a7e42"
},
"downloads": -1,
"filename": "screwduplicates-0.11.tar.gz",
"has_sig": false,
"md5_digest": "e52246fe1575586f9eb6b58f9e23753c",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 6359,
"upload_time": "2023-06-29T18:46:10",
"upload_time_iso_8601": "2023-06-29T18:46:10.576498Z",
"url": "https://files.pythonhosted.org/packages/9b/82/94d03047577d051639bb2dabf02f79e020080e55ad5284e47bf94f1b7ad4/screwduplicates-0.11.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-06-29 18:46:10",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "hansalemaos",
"github_project": "screwduplicates",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"requirements": [],
"lcname": "screwduplicates"
}
JSON
