| Name | mgdl-simple-cache JSON |
| Version |
1.2.1
JSON |
| download |
| home_page | None |
| Summary | Simple Cache is a lightweight cache manager designed to simplify caching operations using providers. It offers a convenient way to store and retrieve cached data efficiently in Python applications. |
| upload_time | 2024-04-12 23:51:36 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.6 |
| license | Copyright (c) 2024 Adaías Magdiel 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 |
cache
caching
deta
deta space
development
utility
tool
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
|
# Simple Cache
[](https://badge.fury.io/py/mgdl-simple-cache)
Simple Cache is a lightweight caching manager crafted to streamline caching operations using various providers. It provides a convenient solution for storing and efficiently retrieving cached data within Python applications. It's highly extensible, allowing you to enhance its functionality with custom providers tailored to your specific use cases. Additionally, creating a new provider is straightforward and seamless.
## Table of Contents
- [Installation](#installation)
- [Purpose](#purpose)
- [Available Providers](#available-providers)
- [Usage](#usage)
- [Get Data](#get-data)
- [Set Data](#set-data)
- [Set Data Validation](#set-data-validation)
- [Documentation](#documentation)
- [SimpleCache](#simplecache)
- [Decorator `attach`](#decorator-attach)
- [How to Use](#how-to-use)
- [Decorator Documentation](#decorator-documentation)
- [Providers](#providers)
- [Provider (ABC)](#provider-abc)
- [DetaProvider](#detaprovider)
- [FileProvider](#fileprovider)
- [Testing](#testing)
- [Coverage](#coverage)
- [License](#license)
- [Contribution](#contribution)
## Installation
Install Simple Cache via pip:
```bash
pip install mgdl-simple-cache
```
## Purpose
In modern data-driven applications, caching plays a pivotal role in boosting performance by minimizing the necessity to frequently retrieve data from external sources. Simple Cache endeavors to simplify this procedure by offering a user-friendly interface for effectively managing cached data.
## Available Providers
- **[DetaProvider](#detaprovider)**: Use [Deta Base](https://deta.space/docs/en/build/reference/deta-base/) service to manage the cache.
- **[FileProvider](#fileprovider)**: Manage the cache in the file system using Python's pickle objects.
## Usage
To use the Simple Cache library, follow these steps:
1. **Choose a Provider**: Simple Cache provides different providers for storing cache data. See all available providers [here](#providers). Alternatively, you can implement your own provider by subclassing the `Provider` abstract class.
2. **Initialize the Provider**: Initialize the chosen provider with the necessary parameters. For example, if you are using the `DetaProvider`, you need to provide the Deta project key and optionally the table name:
```python
from simple_cache.providers import DetaProvider
provider = DetaProvider(deta_key="your_deta_project_key", table_name="cache_table")
```
Check the [providers section](#providers) to see the signature of all parameters that are available for each provider.
3. **Create a SimpleCache Instance**: Create an instance of `SimpleCache` by passing the initialized provider:
```python
from simple_cache import SimpleCache
cache = SimpleCache(provider)
```
It's possible to initialize the Provider with no arguments and initialize the Provider later using the SimpleCache instance:
```python
from simple_cache import SimpleCache
from simple_cache.providers import FileProvider
provider = FileProvider()
cache = SimpleCache(provider=provider)
...
cache.init(cache_dir=Path('path/to/directory')) # This will set the cache directory in FileProvider
```
4. **Usage**:
- **Get Data**: To retrieve data from the cache, use the `get` method. If the data is not found in the cache or has expired, you can provide a callback function to generate the data and set it in the cache:
```python
data = cache.get(key="some_key", action=some_function, expire_in=timedelta(minutes=5))
```
- **Set Data**: To set data in the cache, use the `set` method. You can specify an optional expiration time for the data:
```python
cache.set(key="some_key", value=some_value, expire_in=timedelta(hours=1))
```
- **Set Data Validation**: You can mark data as valid or invalid in the cache using the `set_validate` method:
```python
cache.set_validate(key="some_key", valid=True)
```
## Documentation
### SimpleCache
The `SimpleCache` class provides a simplified interface for interacting with cache providers. It acts as a wrapper around a specific cache provider instance. It includes methods to initialize the cache provider, retrieve data from the cache, set data in the cache, and mark data as valid or invalid.
- `__init__(self, provider: Provider) -> None`: Initialize the SimpleCache instance with the specified cache provider.
- `init(self, **kwargs)`: Initialize the cache provider with the given parameters.
- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieve data from the cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.
- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Set data in the cache with the specified key and value. Optionally, you can specify an expiration time for the data.
- `set_validate(self, key: str, valid: bool, silent: bool = True) -> None`: Mark data in the cache as valid or invalid.
### Decorator `attach`
The `attach` decorator is a powerful feature of Simple Cache that allows you to store the result of a function in the cache, reducing the need to repeatedly execute the function. This is especially useful for operations that are time or resource-intensive, such as API calls or database queries.
#### How to Use
To use the `attach` decorator, you need to apply it to a function that you want to cache. Here's an example of how to do this:
```python
from datetime import timedelta
from simple_cache import SimpleCache
from simple_cache.providers import DetaProvider
# Initialize the cache provider
provider = DetaProvider(deta_key="your_deta_project_key", table_name="cache_table")
cache = SimpleCache(provider)
# Define a function that you want to cache
@cache.attach(key="my_function_result", expire_in=timedelta(minutes=5)) # The expire_in argument is optional
def my_function():
# Simulate an operation that is time or resource-intensive
result = "Result of the function"
return result
# The first call to the function will store the result in the cache
print(my_function())
# Subsequent calls within the expiration time will use the cached result
print(my_function())
# To invalidate the cache just use the set_validate function
cache.set_validate(key="my_function_result", valid=False)
```
In this example, the function `my_function` is decorated with `@cache.attach`, which means that its result will be stored in the cache with the key `"my_function_result"` and will expire after 5 minutes. On the first call to the function, the result is calculated and stored in the cache. On subsequent calls within the expiration time, the cached result is returned, avoiding the need to recalculate the result.
#### Decorator Documentation
- `attach(self, key: str, expire_in: Optional[timedelta] = None)`: Decorator to store the result of a function in the cache.
- `key (str)`: The unique key for the cache.
- `expire_in (Optional[timedelta])`: The expiration time for the cache.
This decorator is an efficient way to improve the performance of your Python applications, reducing the need for repetitive and resource-intensive operations.
### Providers
#### Provider (ABC)
The `Provider` class is an abstract base class defining the interface for cache providers. It includes the following abstract methods:
- `init(self, **kwargs)`: Initialize the provider with the given parameters. This method should be implemented by subclasses.
- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieve data from the cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.
- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Set data in the cache with the specified key and value. Optionally, you can specify an expiration time for the data.
- `set_validate(self, key: str, valid: bool, silent: bool = True)
#### DetaProvider
The `DetaProvider` class is a concrete implementation of the `Provider` interface that stores cache data in Deta Base. It includes methods to initialize the provider, retrieve data from the cache, set data in the cache, and mark data as valid or invalid.
- `__init__(self, deta_key: Optional[str] = None, table_name: Optional[str] = None)`: Initialize the Deta provider with the specified Deta project key and table name.
- `init(self, **kwargs) -> None`: Initialize the Deta provider with the given parameters. If no table name is provided, a default table name is used.
- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieve data from the Deta cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.
- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Set data in the Deta cache with the specified key and value. Optionally, you can specify an expiration time for the data.
- `set_validate(self, key: str, valid: bool, silent: bool = True) -> None`: Mark data in the Deta cache as valid or invalid.
#### FileProvider
The `FileProvider` class is a concrete implementation of the `Provider` interface that stores cache data in files on the local file system using Python's pickle system. It includes methods to initialize the provider, retrieve data from the cache, set data in the cache, and mark data as valid or invalid.
- `__init__(self, cache_dir: Optional[PathLike] = None)`: Initializes the FileProvider with the specified cache directory.
- `init(self, **kwargs) -> None`: Initializes the FileProvider with the given parameters. The parameters are the same from the constructor.
- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieves data from the file-based cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.
- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Sets data in the file-based cache with the specified key and value. Optionally, you can specify an expiration time for the data.
- `set_validate(self, key: str, valid: bool, silent: bool = True) -> None`: Marks data in the file-based cache as valid or invalid.
## Testing
If you wish to contribute to this project, simply install the development dependencies:
```bash
pip install -r requirements.dev.txt
```
And you need to rename the `config.py.example` to `config.py` and fill the `deta_key` var with a valid Deta Key:
> The `config.py` file is already in `.gitignore` so don't worry about exposing your key.
```python
# config.py
deta_key = "a0abcyxz_aSecretValue" # Change to a valid Deta Key
```
> I know I can use a `.env` for this, but I'm trying to make it as simple as possible to run the tests without an external dependency.
Finally, you can run this command to execute the tests:
```bash
pytest -vvsx # Increased verbosity, shows the stdout, breaks at the first failure
```
### Coverage
If you would like to include coverage, just run `pytest` command with the coverage options:
```bash
pytest --cov=simple_cache --cov-report=html -vvsx
```
## License
This project is licensed under the terms of the MIT license. See the [LICENSE](./LICENSE) file for details.
## Contribution
Contributions are welcome! Feel free to open issues or submit pull requests to enhance this project. Your feedback and contributions help make Simple Cache even better.
Raw data
{
"_id": null,
"home_page": null,
"name": "mgdl-simple-cache",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.6",
"maintainer_email": null,
"keywords": "cache, caching, deta, deta space, development, utility, tool",
"author": null,
"author_email": "Ada\u00edas Magdiel <eu@adaiasmagdiel.com>",
"download_url": "https://files.pythonhosted.org/packages/21/01/438cb05e44e622ce8fb92e8236ca80d403f86e418a828eab8a580849825e/mgdl-simple-cache-1.2.1.tar.gz",
"platform": null,
"description": "# Simple Cache\r\n\r\n[](https://badge.fury.io/py/mgdl-simple-cache)\r\n\r\n\r\nSimple Cache is a lightweight caching manager crafted to streamline caching operations using various providers. It provides a convenient solution for storing and efficiently retrieving cached data within Python applications. It's highly extensible, allowing you to enhance its functionality with custom providers tailored to your specific use cases. Additionally, creating a new provider is straightforward and seamless.\r\n\r\n## Table of Contents\r\n\r\n- [Installation](#installation)\r\n- [Purpose](#purpose)\r\n- [Available Providers](#available-providers)\r\n- [Usage](#usage)\r\n - [Get Data](#get-data)\r\n - [Set Data](#set-data)\r\n - [Set Data Validation](#set-data-validation)\r\n- [Documentation](#documentation)\r\n - [SimpleCache](#simplecache)\r\n - [Decorator `attach`](#decorator-attach)\r\n - [How to Use](#how-to-use)\r\n - [Decorator Documentation](#decorator-documentation)\r\n - [Providers](#providers)\r\n - [Provider (ABC)](#provider-abc)\r\n - [DetaProvider](#detaprovider)\r\n - [FileProvider](#fileprovider)\r\n- [Testing](#testing)\r\n - [Coverage](#coverage)\r\n- [License](#license)\r\n- [Contribution](#contribution)\r\n\r\n## Installation\r\n\r\nInstall Simple Cache via pip:\r\n\r\n```bash\r\npip install mgdl-simple-cache\r\n```\r\n\r\n## Purpose\r\n\r\nIn modern data-driven applications, caching plays a pivotal role in boosting performance by minimizing the necessity to frequently retrieve data from external sources. Simple Cache endeavors to simplify this procedure by offering a user-friendly interface for effectively managing cached data.\r\n\r\n## Available Providers\r\n\r\n- **[DetaProvider](#detaprovider)**: Use [Deta Base](https://deta.space/docs/en/build/reference/deta-base/) service to manage the cache.\r\n\r\n- **[FileProvider](#fileprovider)**: Manage the cache in the file system using Python's pickle objects.\r\n\r\n## Usage\r\n\r\nTo use the Simple Cache library, follow these steps:\r\n\r\n1. **Choose a Provider**: Simple Cache provides different providers for storing cache data. See all available providers [here](#providers). Alternatively, you can implement your own provider by subclassing the `Provider` abstract class.\r\n\r\n2. **Initialize the Provider**: Initialize the chosen provider with the necessary parameters. For example, if you are using the `DetaProvider`, you need to provide the Deta project key and optionally the table name:\r\n\r\n```python\r\nfrom simple_cache.providers import DetaProvider\r\n\r\nprovider = DetaProvider(deta_key=\"your_deta_project_key\", table_name=\"cache_table\")\r\n```\r\n\r\nCheck the [providers section](#providers) to see the signature of all parameters that are available for each provider.\r\n\r\n3. **Create a SimpleCache Instance**: Create an instance of `SimpleCache` by passing the initialized provider:\r\n\r\n```python\r\nfrom simple_cache import SimpleCache\r\n\r\ncache = SimpleCache(provider)\r\n```\r\n\r\nIt's possible to initialize the Provider with no arguments and initialize the Provider later using the SimpleCache instance:\r\n\r\n```python\r\nfrom simple_cache import SimpleCache\r\nfrom simple_cache.providers import FileProvider\r\n\r\nprovider = FileProvider()\r\ncache = SimpleCache(provider=provider)\r\n\r\n...\r\n\r\ncache.init(cache_dir=Path('path/to/directory')) # This will set the cache directory in FileProvider\r\n```\r\n\r\n4. **Usage**:\r\n\r\n - **Get Data**: To retrieve data from the cache, use the `get` method. If the data is not found in the cache or has expired, you can provide a callback function to generate the data and set it in the cache:\r\n\r\n ```python\r\n data = cache.get(key=\"some_key\", action=some_function, expire_in=timedelta(minutes=5))\r\n ```\r\n\r\n - **Set Data**: To set data in the cache, use the `set` method. You can specify an optional expiration time for the data:\r\n\r\n ```python\r\n cache.set(key=\"some_key\", value=some_value, expire_in=timedelta(hours=1))\r\n ```\r\n\r\n - **Set Data Validation**: You can mark data as valid or invalid in the cache using the `set_validate` method:\r\n\r\n ```python\r\n cache.set_validate(key=\"some_key\", valid=True)\r\n ```\r\n\r\n## Documentation\r\n\r\n### SimpleCache\r\n\r\nThe `SimpleCache` class provides a simplified interface for interacting with cache providers. It acts as a wrapper around a specific cache provider instance. It includes methods to initialize the cache provider, retrieve data from the cache, set data in the cache, and mark data as valid or invalid.\r\n\r\n- `__init__(self, provider: Provider) -> None`: Initialize the SimpleCache instance with the specified cache provider.\r\n- `init(self, **kwargs)`: Initialize the cache provider with the given parameters.\r\n- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieve data from the cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.\r\n- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Set data in the cache with the specified key and value. Optionally, you can specify an expiration time for the data.\r\n- `set_validate(self, key: str, valid: bool, silent: bool = True) -> None`: Mark data in the cache as valid or invalid.\r\n\r\n### Decorator `attach`\r\n\r\nThe `attach` decorator is a powerful feature of Simple Cache that allows you to store the result of a function in the cache, reducing the need to repeatedly execute the function. This is especially useful for operations that are time or resource-intensive, such as API calls or database queries.\r\n\r\n#### How to Use\r\n\r\nTo use the `attach` decorator, you need to apply it to a function that you want to cache. Here's an example of how to do this:\r\n\r\n```python\r\nfrom datetime import timedelta\r\nfrom simple_cache import SimpleCache\r\nfrom simple_cache.providers import DetaProvider\r\n\r\n# Initialize the cache provider\r\nprovider = DetaProvider(deta_key=\"your_deta_project_key\", table_name=\"cache_table\")\r\ncache = SimpleCache(provider)\r\n\r\n# Define a function that you want to cache\r\n@cache.attach(key=\"my_function_result\", expire_in=timedelta(minutes=5)) # The expire_in argument is optional\r\ndef my_function():\r\n # Simulate an operation that is time or resource-intensive\r\n result = \"Result of the function\"\r\n return result\r\n\r\n# The first call to the function will store the result in the cache\r\nprint(my_function())\r\n\r\n# Subsequent calls within the expiration time will use the cached result\r\nprint(my_function())\r\n\r\n# To invalidate the cache just use the set_validate function\r\ncache.set_validate(key=\"my_function_result\", valid=False)\r\n```\r\n\r\nIn this example, the function `my_function` is decorated with `@cache.attach`, which means that its result will be stored in the cache with the key `\"my_function_result\"` and will expire after 5 minutes. On the first call to the function, the result is calculated and stored in the cache. On subsequent calls within the expiration time, the cached result is returned, avoiding the need to recalculate the result.\r\n\r\n#### Decorator Documentation\r\n\r\n- `attach(self, key: str, expire_in: Optional[timedelta] = None)`: Decorator to store the result of a function in the cache.\r\n - `key (str)`: The unique key for the cache.\r\n - `expire_in (Optional[timedelta])`: The expiration time for the cache.\r\n\r\nThis decorator is an efficient way to improve the performance of your Python applications, reducing the need for repetitive and resource-intensive operations.\r\n\r\n### Providers\r\n\r\n#### Provider (ABC)\r\n\r\nThe `Provider` class is an abstract base class defining the interface for cache providers. It includes the following abstract methods:\r\n\r\n- `init(self, **kwargs)`: Initialize the provider with the given parameters. This method should be implemented by subclasses.\r\n- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieve data from the cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.\r\n- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Set data in the cache with the specified key and value. Optionally, you can specify an expiration time for the data.\r\n- `set_validate(self, key: str, valid: bool, silent: bool = True)\r\n\r\n#### DetaProvider\r\n\r\nThe `DetaProvider` class is a concrete implementation of the `Provider` interface that stores cache data in Deta Base. It includes methods to initialize the provider, retrieve data from the cache, set data in the cache, and mark data as valid or invalid.\r\n\r\n- `__init__(self, deta_key: Optional[str] = None, table_name: Optional[str] = None)`: Initialize the Deta provider with the specified Deta project key and table name.\r\n- `init(self, **kwargs) -> None`: Initialize the Deta provider with the given parameters. If no table name is provided, a default table name is used.\r\n- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieve data from the Deta cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.\r\n- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Set data in the Deta cache with the specified key and value. Optionally, you can specify an expiration time for the data.\r\n- `set_validate(self, key: str, valid: bool, silent: bool = True) -> None`: Mark data in the Deta cache as valid or invalid.\r\n\r\n#### FileProvider\r\n\r\nThe `FileProvider` class is a concrete implementation of the `Provider` interface that stores cache data in files on the local file system using Python's pickle system. It includes methods to initialize the provider, retrieve data from the cache, set data in the cache, and mark data as valid or invalid.\r\n\r\n- `__init__(self, cache_dir: Optional[PathLike] = None)`: Initializes the FileProvider with the specified cache directory.\r\n- `init(self, **kwargs) -> None`: Initializes the FileProvider with the given parameters. The parameters are the same from the constructor.\r\n- `get(self, key: str, action: Callable[[], str], expire_in: Optional[timedelta] = None) -> CacheData`: Retrieves data from the file-based cache with the specified key. If the data is not found or has expired, the provided action function is executed to generate the data.\r\n- `set(self, key: str, value: Any, expire_in: Optional[timedelta] = None) -> CacheData`: Sets data in the file-based cache with the specified key and value. Optionally, you can specify an expiration time for the data.\r\n- `set_validate(self, key: str, valid: bool, silent: bool = True) -> None`: Marks data in the file-based cache as valid or invalid.\r\n\r\n## Testing\r\n\r\nIf you wish to contribute to this project, simply install the development dependencies:\r\n\r\n```bash\r\npip install -r requirements.dev.txt\r\n```\r\n\r\nAnd you need to rename the `config.py.example` to `config.py` and fill the `deta_key` var with a valid Deta Key:\r\n\r\n> The `config.py` file is already in `.gitignore` so don't worry about exposing your key.\r\n\r\n```python\r\n# config.py\r\ndeta_key = \"a0abcyxz_aSecretValue\" # Change to a valid Deta Key\r\n```\r\n\r\n> I know I can use a `.env` for this, but I'm trying to make it as simple as possible to run the tests without an external dependency.\r\n\r\nFinally, you can run this command to execute the tests:\r\n\r\n```bash\r\npytest -vvsx # Increased verbosity, shows the stdout, breaks at the first failure\r\n```\r\n\r\n### Coverage\r\n\r\nIf you would like to include coverage, just run `pytest` command with the coverage options:\r\n\r\n```bash\r\npytest --cov=simple_cache --cov-report=html -vvsx\r\n```\r\n\r\n## License\r\n\r\nThis project is licensed under the terms of the MIT license. See the [LICENSE](./LICENSE) file for details.\r\n\r\n## Contribution\r\n\r\nContributions are welcome! Feel free to open issues or submit pull requests to enhance this project. Your feedback and contributions help make Simple Cache even better.\r\n",
"bugtrack_url": null,
"license": "Copyright (c) 2024 Ada\u00edas Magdiel 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": "Simple Cache is a lightweight cache manager designed to simplify caching operations using providers. It offers a convenient way to store and retrieve cached data efficiently in Python applications.",
"version": "1.2.1",
"project_urls": {
"Homepage": "https://github.com/AdaiasMagdiel/simple-cache",
"Issues": "https://github.com/AdaiasMagdiel/simple-cache/issues"
},
"split_keywords": [
"cache",
" caching",
" deta",
" deta space",
" development",
" utility",
" tool"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "2166bbfe5d8d335545bdcd1611cd60595cef338f46ea7fd0874b777a5dd42dd1",
"md5": "adf2deb47264e8c8da5deb42033ebedc",
"sha256": "46429fb5c6c6be70fcba4461fb1f16a9a3fe9161df8924b526a8e0f16d1b9b8c"
},
"downloads": -1,
"filename": "mgdl_simple_cache-1.2.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "adf2deb47264e8c8da5deb42033ebedc",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.6",
"size": 12338,
"upload_time": "2024-04-12T23:51:35",
"upload_time_iso_8601": "2024-04-12T23:51:35.558656Z",
"url": "https://files.pythonhosted.org/packages/21/66/bbfe5d8d335545bdcd1611cd60595cef338f46ea7fd0874b777a5dd42dd1/mgdl_simple_cache-1.2.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2101438cb05e44e622ce8fb92e8236ca80d403f86e418a828eab8a580849825e",
"md5": "e76b4f9183470989af204b80ed2fcd8a",
"sha256": "20e41b5ed394417cbf09005739a5e06afb3b46eaee2701aaba8d69c00acda2c7"
},
"downloads": -1,
"filename": "mgdl-simple-cache-1.2.1.tar.gz",
"has_sig": false,
"md5_digest": "e76b4f9183470989af204b80ed2fcd8a",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.6",
"size": 11195,
"upload_time": "2024-04-12T23:51:36",
"upload_time_iso_8601": "2024-04-12T23:51:36.840803Z",
"url": "https://files.pythonhosted.org/packages/21/01/438cb05e44e622ce8fb92e8236ca80d403f86e418a828eab8a580849825e/mgdl-simple-cache-1.2.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-04-12 23:51:36",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "AdaiasMagdiel",
"github_project": "simple-cache",
"travis_ci": false,
"coveralls": true,
"github_actions": false,
"requirements": [],
"lcname": "mgdl-simple-cache"
}
