| Name | dicta JSON |
| Version |
1.2.3
JSON |
| download |
| home_page | None |
| Summary | A 'dict' subclass that detects changes in its data structure. It triggers a callback and/or exports its data to a JSON file if the data has changed. |
| upload_time | 2025-01-04 14:40:00 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.8 |
| license | MIT License Copyright (c) 2023 Peter Wendl 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. |
| keywords |
callback
dict
fileimport
json
listener
nested-objects
serialization
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# Dicta
**Dicta** is a subclass of Python's `dict` that behaves like a normal nested dictionary but with added key features:
- Detects changes in its data structure and triggers a callback (optional).
- Automatically syncs its data with a JSON file (optional).
- Imports and exports data from JSON files.
## Features
- Behaves like a regular `dict` and supports all `dict`, `list`, `tuple`, and `set` methods.
- Supports nesting of various data types including `dict`, `list`, `tuple`, `set`, and custom objects.
- Optionally encodes non-serializable objects to a binary string when writing data to a file.
- Decodes binary strings back to non-serializable objects when reading from a file.
- Imports additional data from JSON files.
- Exports data to JSON files.
## Installation
To install Dicta, use pip:
```bash
pip install dicta
```
## Usage
Here's how to use Dicta:
```python
import dicta
# Core functionality:
# Declare the 'Dicta' class.
my_dicta = dicta.Dicta()
# Set a sync file path.
my_dicta.bind_file("data.json")
# Define a callback method
def callback():
print("Data changed!")
print(my_dicta)
# Bind the callback method to dicta
my_dicta.bind_callback(callback)
# Add data as you would with a normal dict:
my_dicta.update({"key": "value"})
my_dicta.update(key2="value2", key3="value3")
my_dicta["entities"] = {}
my_dicta["entities"]["persons"] = []
my_dicta["entities"]["persons"].append({"name": "john", "age": 23})
my_dicta["entities"]["persons"].append({"name": "peter", "age": 24})
# Use regular dict methods
del my_dicta["entities"]["persons"][0:1]
my_dicta["entities"].pop("persons")
# Dicta methods:
# Import data from a file:
my_dicta.pull("additional_data_file.json")
# Export the data to a file
my_dicta.push("data_backup.json")
# Get string representation of the Dicta
print(my_dicta.stringify())
# Get dict representation of the Dicta
dict_representation = my_dicta.dictify()
# Activate binary serialization to store sets or custom data objects in a sync file
my_dicta.set_serializer(True)
my_dicta["set"] = {1,2,4,5}
my_dicta["set"].add(6)
```
## Reference
### Dicta Class
```python
Dicta(*args, **kwargs)
Dicta(dict)
Dicta(key=value,key2=value)
```
A ```dict``` subclass.
#### **Parameters**
- **args** (Optional)
- **kwargs** (Optional)
#### **Return**
- **Dicta Class**
---
### Methods
#### Dicta Methods
##### Dicta.bind_callback()
```python
Dicta.bind_callback(callback)
```
Sets the callback method for the Dicta Class. Pass an event argument (optional) to receive the data modification event:
```python
def my_callback():
print(dicta)
Dicta.bind_callback(my_callback)
```
or
```python
def my_callback(event):
print(event)
Dicta.bind_callback(my_callback)
```
###### **Parameter**
- **callback** *(method)*
###### **Callback**
- **event** *(dict)*
---
##### Dicta.bind_file()
```python
Dicta.bind_file(path, reset=False)
```
Sets the sync file to automatically store the data on data change. If `reset=False` (default) old data will remain and will be updated with new data . If `reset=True` the data wil be cleared when `syncFile()` is called.
**Data sync is monodirectional!** Though the data is automatically synced to your syncfile data is not synced to your dicta instance if filedata changes. Use Dicta.sync_file() to pull data from file into your dict.
**Sync will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization manually with `Dicta.set_serializer(True)`.
If you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.
###### **Parameter**
- **path** *(string)*
- **reset** *(bool) (optional / default = False)*
---
##### Dicta.pull()
```python
Dicta.pull(path=None)
```
Import data from a given JSON file (if *path* argument is given) or the binded sync file (if no *path* argument is given) into your Dicta instance. New data will be added to the DictObsercer, old data remains but will be overwritten if dict keys match.
```python
Dicta.pull() >> pulls data from the file that was binded with Dicta.bind_file(path)
Dicta.pull('my/path.json') >> pulls data from the file at the given path
```
###### **Parameter**
- **path** *(string) (optional / default = None)*
---
##### Dicta.push()
```python
Dicta.push(path, reset=True)
```
Export/Push data to a file. If `reset=True` the file will be cleared before pushing (default). If `reset=False` the data will be updated.
**This will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization by calling `Dicta.set_serializer(True)` before.
If you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.
###### **Parameter**
- **path** (string)
- **reset** *(bool) (optional / default = True)*
---
##### Dicta.clear_file()
```python
Dicta.clear_file(path=None)
```
Clear a file.
```python
Dicta.clear_file() >> Clears the binded sync file.
Dicta.clear_file('my/path.json') >> Clears the file at a given path.
```
###### **Parameter**
- **path** *(string) (optional / default = None)*
---
##### Dicta.remove_file()
```python
Dicta.remove_file(path=None)
```
Remove a data file.
```python
Dicta.remove_file() >> Removes the binded sync file.
Dicta.remove_file('my/path.json') >> Removes the file at a given path.
```
###### **Parameter**
- **path** *(string) (optional / default = None)*
---
##### Dicta.dictify()
```python
Dicta.dictify()
```
Returns a plain dict representation of the data without Dicta functionality.
###### **Parameter**
- None
###### **Return**
- **dict**
---
##### Dicta.stringify()
```python
Dicta.stringify(returnBinaries=False)
```
Returns a string representation of the data in Dicta.
**This will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization by calling `Dicta.set_serializer(True)` before.
If you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.
For better readability serialized objects won´t be returned by default and are replaced by a the `'<serialized-object>'` hook. If you want to return the binaries set the `return_binaries`parameter to `True`.
###### **Parameter**
- **return_binaries** *(bool) (default = False)*
###### **Return**
- **string**
---
##### Dicta.set_serializer()
```python
Dicta.set_serializer(binary_serializer=False, serializer_hook='<serialized-object>')
```
For security reasons binary serialization of non-serializable objects is deactivated by default. You can activate or deactivate binary serialization with this method (default=False).
If you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a dict labeled with the key `'<serialized-object>'`. In case you need this key for your data structure, define a custom serializer-hook by using the `serializer_hook` parameter (optional). If you don´t use the `serializer_hook` parameter the default hook `'<serialized-object>'` will be used.
###### Parameter
- **binary_serializer** *(bool) (default = False)*
- **serializer_hook** *(string) (optional / default = '\<serialized-object>')*
###### Example
```python
myDicta.set_serializer(True)
myDicta.set_serializer(True, '<my_serialzer_hook>')
```
---
#### Data Type Methods
Behaves like a regular nested dict and supports all data type methods. Adding, removing, modifiying and accessing of nested elements should work out of the box. For example:
---
##### NestedDict.update()
```python
NestedDict.update(*args, *kwargs)
```
---
##### NestedDict.clear()
```python
NestedDict.clear()
```
---
##### NestedDict.pop()
```python
NestedDict.pop(key)
```
---
##### NestedDict.popitem()
```python
NestedDict.popitem(key)
```
---
##### NestedDict.setdefault()
```python
NestedDict.setdefault(key, default=None)
```
and so forth: keys(), iter() …
---
##### NestedList.append()
```python
NestedList.append(item)
```
and so forth: pop()…
---
#### Deprecated Methods
##### Dicta.import_data(*args,**kwargs)
```python
Dicta.import_data(dict)
Dicta.import_data(key=value,key2=value2…)
```
Import data as dict or key/value pairs. Same as Dica.update(*args,**kwargs)
---
##### Dicta.sync_file()
```python
Dicta.sync_file()
```
Pulls data from the binded sync file into your Dicta instance.
---
##### Dicta.import_file()
```python
Dicta.import_file(path)
```
Import data from a file. New data will be added to the DictObsercer, old data remains but will be overwritten if dict keys match.
---
##### Dicta.export_file()
```python
Dicta.export_file(path, reset=True)
```
Export data to a file. If `reset=True` the data wil be cleared when `export_file()` (default) is called . If `reset=False` the data will be updated.
**This will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization by calling `Dicta.set_serializer(True)` before.
If you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.
###### **Parameter**
- **path** (string)
- **reset** *(bool) (optional / default = True)*
---
## Dependencies
- os
- re
- json
- pickle
- inspect
Raw data
{
"_id": null,
"home_page": null,
"name": "dicta",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "callback, dict, fileimport, json, listener, nested-objects, serialization",
"author": null,
"author_email": "Peter Wendl <dev@peterwendl.de>",
"download_url": "https://files.pythonhosted.org/packages/b9/a3/c50c290f8f59c570f4dc26f10c76a8aa51c13cf8aa5b0e9e5e2be42d1213/dicta-1.2.3.tar.gz",
"platform": null,
"description": "# Dicta\n\n**Dicta** is a subclass of Python's `dict` that behaves like a normal nested dictionary but with added key features:\n\n- Detects changes in its data structure and triggers a callback (optional).\n- Automatically syncs its data with a JSON file (optional).\n- Imports and exports data from JSON files.\n\n## Features\n\n- Behaves like a regular `dict` and supports all `dict`, `list`, `tuple`, and `set` methods.\n- Supports nesting of various data types including `dict`, `list`, `tuple`, `set`, and custom objects.\n- Optionally encodes non-serializable objects to a binary string when writing data to a file.\n- Decodes binary strings back to non-serializable objects when reading from a file.\n- Imports additional data from JSON files.\n- Exports data to JSON files.\n\n## Installation\n\nTo install Dicta, use pip:\n\n```bash\npip install dicta\n```\n\n## Usage\n\nHere's how to use Dicta:\n\n```python\nimport dicta\n\n# Core functionality:\n\n# Declare the 'Dicta' class.\nmy_dicta = dicta.Dicta()\n\n# Set a sync file path.\nmy_dicta.bind_file(\"data.json\")\n\n# Define a callback method\ndef callback():\n print(\"Data changed!\")\n print(my_dicta)\n\n# Bind the callback method to dicta\nmy_dicta.bind_callback(callback)\n\n# Add data as you would with a normal dict:\nmy_dicta.update({\"key\": \"value\"})\nmy_dicta.update(key2=\"value2\", key3=\"value3\")\nmy_dicta[\"entities\"] = {}\nmy_dicta[\"entities\"][\"persons\"] = []\nmy_dicta[\"entities\"][\"persons\"].append({\"name\": \"john\", \"age\": 23})\nmy_dicta[\"entities\"][\"persons\"].append({\"name\": \"peter\", \"age\": 24})\n\n# Use regular dict methods\ndel my_dicta[\"entities\"][\"persons\"][0:1]\nmy_dicta[\"entities\"].pop(\"persons\")\n\n# Dicta methods:\n\n# Import data from a file:\nmy_dicta.pull(\"additional_data_file.json\")\n\n# Export the data to a file\nmy_dicta.push(\"data_backup.json\")\n\n# Get string representation of the Dicta\nprint(my_dicta.stringify())\n\n# Get dict representation of the Dicta\ndict_representation = my_dicta.dictify()\n\n# Activate binary serialization to store sets or custom data objects in a sync file\nmy_dicta.set_serializer(True)\nmy_dicta[\"set\"] = {1,2,4,5}\nmy_dicta[\"set\"].add(6)\n```\n\n## Reference\n\n### Dicta Class\n\n```python\nDicta(*args, **kwargs)\nDicta(dict)\nDicta(key=value,key2=value)\n```\n\nA ```dict``` subclass.\n\n#### **Parameters**\n\n- **args** (Optional)\n- **kwargs** (Optional)\n\n#### **Return**\n\n- **Dicta Class**\n\n---\n\n### Methods\n\n#### Dicta Methods\n\n##### Dicta.bind_callback()\n\n```python\nDicta.bind_callback(callback)\n```\n\nSets the callback method for the Dicta Class. Pass an event argument (optional) to receive the data modification event:\n\n```python\ndef my_callback(): \n print(dicta)\nDicta.bind_callback(my_callback)\n```\n\nor\n\n```python\ndef my_callback(event): \n print(event)\nDicta.bind_callback(my_callback)\n```\n\n###### **Parameter**\n\n- **callback** *(method)*\n\n###### **Callback**\n\n- **event** *(dict)*\n\n---\n\n##### Dicta.bind_file()\n\n```python\nDicta.bind_file(path, reset=False)\n```\n\nSets the sync file to automatically store the data on data change. If `reset=False` (default) old data will remain and will be updated with new data . If `reset=True` the data wil be cleared when `syncFile()` is called.\n\n**Data sync is monodirectional!** Though the data is automatically synced to your syncfile data is not synced to your dicta instance if filedata changes. Use Dicta.sync_file() to pull data from file into your dict.\n\n**Sync will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization manually with `Dicta.set_serializer(True)`.\n\nIf you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.\n\n###### **Parameter**\n\n- **path** *(string)*\n- **reset** *(bool) (optional / default = False)*\n\n---\n\n##### Dicta.pull()\n\n```python\nDicta.pull(path=None) \n```\n\nImport data from a given JSON file (if *path* argument is given) or the binded sync file (if no *path* argument is given) into your Dicta instance. New data will be added to the DictObsercer, old data remains but will be overwritten if dict keys match.\n\n```python\nDicta.pull() >> pulls data from the file that was binded with Dicta.bind_file(path)\nDicta.pull('my/path.json') >> pulls data from the file at the given path \n```\n\n###### **Parameter**\n\n- **path** *(string) (optional / default = None)*\n\n---\n\n##### Dicta.push()\n\n```python\nDicta.push(path, reset=True)\n```\n\nExport/Push data to a file. If `reset=True` the file will be cleared before pushing (default). If `reset=False` the data will be updated.\n\n**This will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization by calling `Dicta.set_serializer(True)` before.\n\nIf you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.\n\n###### **Parameter**\n\n- **path** (string)\n- **reset** *(bool) (optional / default = True)*\n\n---\n\n##### Dicta.clear_file()\n\n```python\nDicta.clear_file(path=None)\n```\n\nClear a file.\n\n```python\nDicta.clear_file() >> Clears the binded sync file.\nDicta.clear_file('my/path.json') >> Clears the file at a given path.\n```\n\n###### **Parameter**\n\n- **path** *(string) (optional / default = None)*\n\n---\n\n##### Dicta.remove_file()\n\n```python\nDicta.remove_file(path=None)\n```\n\nRemove a data file.\n\n```python\nDicta.remove_file() >> Removes the binded sync file.\nDicta.remove_file('my/path.json') >> Removes the file at a given path.\n```\n\n###### **Parameter**\n\n- **path** *(string) (optional / default = None)*\n\n---\n\n##### Dicta.dictify()\n\n```python\nDicta.dictify()\n```\n\nReturns a plain dict representation of the data without Dicta functionality.\n\n###### **Parameter**\n\n- None\n\n###### **Return**\n\n- **dict**\n\n---\n\n##### Dicta.stringify()\n\n```python\nDicta.stringify(returnBinaries=False)\n```\n\nReturns a string representation of the data in Dicta.\n\n**This will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization by calling `Dicta.set_serializer(True)` before.\n\nIf you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.\n\nFor better readability serialized objects won\u00b4t be returned by default and are replaced by a the `'<serialized-object>'` hook. If you want to return the binaries set the `return_binaries`parameter to `True`.\n\n###### **Parameter**\n\n- **return_binaries** *(bool) (default = False)*\n\n###### **Return**\n\n- **string**\n\n---\n\n##### Dicta.set_serializer()\n\n```python\nDicta.set_serializer(binary_serializer=False, serializer_hook='<serialized-object>')\n```\n\nFor security reasons binary serialization of non-serializable objects is deactivated by default. You can activate or deactivate binary serialization with this method (default=False).\n\nIf you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a dict labeled with the key `'<serialized-object>'`. In case you need this key for your data structure, define a custom serializer-hook by using the `serializer_hook` parameter (optional). If you don\u00b4t use the `serializer_hook` parameter the default hook `'<serialized-object>'` will be used.\n\n###### Parameter\n\n- **binary_serializer** *(bool) (default = False)*\n- **serializer_hook** *(string) (optional / default = '\\<serialized-object>')*\n\n###### Example\n\n```python\nmyDicta.set_serializer(True)\nmyDicta.set_serializer(True, '<my_serialzer_hook>')\n```\n\n---\n\n#### Data Type Methods\n\nBehaves like a regular nested dict and supports all data type methods. Adding, removing, modifiying and accessing of nested elements should work out of the box. For example:\n\n---\n\n##### NestedDict.update()\n\n```python\nNestedDict.update(*args, *kwargs)\n```\n\n---\n\n##### NestedDict.clear()\n\n```python\nNestedDict.clear()\n```\n\n---\n\n##### NestedDict.pop()\n\n```python\nNestedDict.pop(key)\n```\n\n---\n\n##### NestedDict.popitem()\n\n```python\nNestedDict.popitem(key)\n```\n\n---\n\n##### NestedDict.setdefault()\n\n```python\nNestedDict.setdefault(key, default=None)\n```\n\nand so forth: keys(), iter() \u2026\n\n---\n\n##### NestedList.append()\n\n```python\nNestedList.append(item)\n```\n\nand so forth: pop()\u2026\n\n---\n\n#### Deprecated Methods\n\n##### Dicta.import_data(*args,**kwargs)\n\n```python\nDicta.import_data(dict)\nDicta.import_data(key=value,key2=value2\u2026)\n```\n\nImport data as dict or key/value pairs. Same as Dica.update(*args,**kwargs)\n\n---\n\n##### Dicta.sync_file()\n\n```python\nDicta.sync_file()\n```\n\nPulls data from the binded sync file into your Dicta instance.\n\n---\n\n##### Dicta.import_file()\n\n```python\nDicta.import_file(path)\n```\n\nImport data from a file. New data will be added to the DictObsercer, old data remains but will be overwritten if dict keys match.\n\n---\n\n##### Dicta.export_file()\n\n```python\nDicta.export_file(path, reset=True)\n```\n\nExport data to a file. If `reset=True` the data wil be cleared when `export_file()` (default) is called . If `reset=False` the data will be updated.\n\n**This will fail if your dict contains non-serializable objects and binary serialization is not activated.** For security reasons this is deactivated by default. You can activate binary serialization by calling `Dicta.set_serializer(True)` before.\n\nIf you activate the binary-serializer all non-serializable objects will be encoded to a binary string and packed into a `dict` labeled with the key `'<serialized-object>'`. See the reference for `Dicta.set_serializer()`.\n\n###### **Parameter**\n\n- **path** (string)\n- **reset** *(bool) (optional / default = True)*\n\n---\n\n## Dependencies\n\n- os\n- re\n- json\n- pickle\n- inspect\n",
"bugtrack_url": null,
"license": "MIT License Copyright (c) 2023 Peter Wendl 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.",
"summary": "A 'dict' subclass that detects changes in its data structure. It triggers a callback and/or exports its data to a JSON file if the data has changed.",
"version": "1.2.3",
"project_urls": {
"Homepage": "https://github.com/mextex/dicta"
},
"split_keywords": [
"callback",
" dict",
" fileimport",
" json",
" listener",
" nested-objects",
" serialization"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "00cc8a82f813e13441c360425f8909559cf31434d22842dd8430bab5358b05b3",
"md5": "8b8fcad931dd84208b52d1d04ae911eb",
"sha256": "4c30f8859df3f75af90f2d31ec834df5614d735a41dff94dd1bf4d39b5fc2cfa"
},
"downloads": -1,
"filename": "dicta-1.2.3-py3-none-any.whl",
"has_sig": false,
"md5_digest": "8b8fcad931dd84208b52d1d04ae911eb",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 10828,
"upload_time": "2025-01-04T14:39:55",
"upload_time_iso_8601": "2025-01-04T14:39:55.371926Z",
"url": "https://files.pythonhosted.org/packages/00/cc/8a82f813e13441c360425f8909559cf31434d22842dd8430bab5358b05b3/dicta-1.2.3-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "b9a3c50c290f8f59c570f4dc26f10c76a8aa51c13cf8aa5b0e9e5e2be42d1213",
"md5": "44f7d8c3cb92f2601d8d343baa3f77b8",
"sha256": "d43345101c5771b24bf1743459431ef893d7e3de385de8995fca0ad5e32e194a"
},
"downloads": -1,
"filename": "dicta-1.2.3.tar.gz",
"has_sig": false,
"md5_digest": "44f7d8c3cb92f2601d8d343baa3f77b8",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 11401,
"upload_time": "2025-01-04T14:40:00",
"upload_time_iso_8601": "2025-01-04T14:40:00.103951Z",
"url": "https://files.pythonhosted.org/packages/b9/a3/c50c290f8f59c570f4dc26f10c76a8aa51c13cf8aa5b0e9e5e2be42d1213/dicta-1.2.3.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-01-04 14:40:00",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "mextex",
"github_project": "dicta",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "dicta"
}
