semvec/pypi-packages huggingface dataset:
regressive-imagery-dictionary 0.2.0
The Regressive Imagery Dictionary (RID) is a coding scheme for text analysis that is designed to measure "primordial" and conceptual content.
License: MIT


rid
~~~~~~~~~~~

"The Regressive Imagery Dictionary (RID) is a coding scheme for text analysis
that is designed to measure 'primordial' and conceptual content. Primordial
thought is the kind of free-form, associative thinking involved in fantasy
and dreams. Like Freud's id, I guess. Conceptual (or secondary) thought is
logical, reality-based and focused on problem solving."

via: John Wiseman (http://lemonodor.com/archives/001511.html)
pysmartcache 3.0.1
Automatic caching and caching invalidation for callables
License: MIT

[![Travis](https://travis-ci.com/filwaitman/pysmartcache.svg?branch=master)](https://travis-ci.com/filwaitman/pysmartcache)
[![Codecov](https://codecov.io/gh/filwaitman/pysmartcache/branch/master/graph/badge.svg)](https://codecov.io/gh/filwaitman/pysmartcache)
[![PyPI](https://img.shields.io/pypi/v/pysmartcache.svg)](https://pypi.python.org/pypi/pysmartcache/)
[![License](https://img.shields.io/pypi/l/pysmartcache.svg)](https://pypi.python.org/pypi/pysmartcache/)
[![Python versions](https://img.shields.io/pypi/pyversions/pysmartcache.svg)](https://pypi.python.org/pypi/pysmartcache/)
[![PyPI downloads per month](https://img.shields.io/pypi/dm/pysmartcache.svg)](https://pypi.python.org/pypi/pysmartcache/)


# pysmartcache

PySmartCache is a [memoizer](https://en.wikipedia.org/wiki/Memoization) implementation with lasers.

Idea is quite simple: you just need to decorate your function/method with `@cache()`, and `pysmartcache` will take care of the rest (caching based on arguments, cache invalidation, helpers for cache purge, cache refresh and cache invalidation, and so on).

For instance, change this:
```python
def calculate_universe_mass(some_parameter, another_parameter, whatever):
    return 42
```

to this:
```python
from pysmartcache import cache
@cache()
def calculate_universe_mass(some_parameter, another_parameter, whatever):
    return 42
```

Seriously. That's it. =P

For more dense details please refer to [the docs](https://github.com/filwaitman/pysmartcache/blob/master/doc.md).


## Development:

### Run linter:
```bash
pip install -r requirements_dev.txt
isort -rc .
tox -e lint
```

### Run tests via `tox`:
```bash
pip install -r requirements_dev.txt
tox
```

### Release a new major/minor/patch version:
```bash
pip install -r requirements_dev.txt
bump2version <PART>  # <PART> can be either 'patch' or 'minor' or 'major'
```

### Upload to PyPI:
```bash
pip install -r requirements_dev.txt
python setup.py sdist bdist_wheel
python -m twine upload dist/*
```

## Contributing:

Please [open issues](https://github.com/filwaitman/pysmartcache/issues) if you see one, or [create a pull request](https://github.com/filwaitman/pysmartcache/pulls) when possible.
In case of a pull request, please consider the following:
- Respect the line length (132 characters)
- Write automated tests
- Run `tox` locally so you can see if everything is green (including linter and other python versions)
ActionTree 0.13.2
Executes (long) actions in parallel, respecting dependencies between those actions
License: MIT

*ActionTree* is a Python (3.5+) library to execute (long) actions in parallel, respecting dependencies between those actions.
You create a dependency graph of actions to be executed and then call the ``execute`` function on its root.


It's licensed under the `MIT license <http://choosealicense.com/licenses/mit/>`_.
It's available on the `Python package index <http://pypi.python.org/pypi/ActionTree>`_.
Its `documentation <http://jacquev6.github.io/ActionTree>`_
and its `source code <https://github.com/jacquev6/ActionTree>`_ are on GitHub.

Questions? Remarks? Bugs? Want to contribute? `Open an issue <https://github.com/jacquev6/ActionTree/issues>`_!

.. image:: https://img.shields.io/github/workflow/status/jacquev6/ActionTree/Continuous%20Integration?label=CI&logo=github
    :target: https://github.com/jacquev6/ActionTree/actions?query=workflow%3A%22Continuous+Integration%22

.. image:: https://img.shields.io/pypi/v/ActionTree?logo=pypi
    :alt: PyPI
    :target: https://pypi.org/project/ActionTree/

.. image:: https://img.shields.io/pypi/pyversions/ActionTree?logo=pypi
    :alt: PyPI
    :target: https://pypi.org/project/ActionTree/

Quick start
===========

Install from PyPI::

    $ pip install ActionTree

With dependencies to create Gantt charts and dependency graphs::

    $ pip install 'ActionTree[dependency_graphs,gantt]'

Import:

>>> from ActionTree import execute
>>> from ActionTree.stock import CallSubprocess

Execute some action:

>>> link = CallSubprocess(["g++", "a.o", "b.o", "-o", "test"])
>>> link.add_dependency(CallSubprocess(["g++", "-c", "a.cpp", "-o", "a.o"]))
>>> link.add_dependency(CallSubprocess(["g++", "-c", "b.cpp", "-o", "b.o"]))
>>> report = execute(link)

And verify everything went well:

>>> report.is_success
True
>>> os.path.isfile("test")
True