semvec/pypi-packages huggingface dataset:
blackout 1.0.4
A python package making it easy to drop a multi-module package from sys.modules

## Installation
You can either download or clone this repo, or alternatively you can
install this module using pip:

```commandline
pip install blackout
```


## Overview
Blackout is a small micro-module which makes it easier to completely
forget packages. This is particularly useful when working with packages
made up of multiple sub-modules.

And example might be:

    /site-packages/foo/__init__.py
    /site-packages/foo/bar.py

If bar.py has a function called foo() within it, and we change that
function then it is not enough to reload foo, we must specifically
reload foo as well as foo.bar. 

When working with packages with any modules this can be time consuming
and problematic - particularly when developing within a host which is
persistent.

Blackout helps, because we can unload the package in its entirety in 
a single line using:

    ```blackout.drop('foo')```

This will remove any hold to foo as well as any submodules of foo. In this 
case we can simply call ```import foo``` again, knowing that everything
within that package is being loaded fresh.


## Compatability

This has been tested under Python 2.7.13 and Python 3.6.6 under both Windows and Ubuntu.
scribble 1.0.0
Allows for persistent storage of dictionary data
Keywords: scribble dictionary appdata persistent

# Overview
Scibble is a mechanism to store dictionary information to a persistent
state. This allows the data to be easily retrieved and edited, making it
a good option when trying to store settings data. 

Note: Data saved within the ScribbleDictionary must be json serialisable.

An example of creating a persisten data block would be:
```python
    import os
    import scribble
    
    
    # -- Instance a scribble dictionary. We can treat this exactly
    # -- as we treat a dictionary
    data = scribble.get('foobar')
    
    # -- Set some key/value pairs in the ScribbleDictionary
    data['option_a'] = True
    data['option_b'] = 123
    
    # -- Calling .save() will trigger the dictionary
    # -- to store its current state to a persistent state
    data.save()
    
    # -- We can see the location the data is saved to, and we can
    # -- see that it does indeed exist
    print(data.location())
    print(os.path.exists(data.location()))    
```

    
Equally, we can re-retrieve that data in a completely new instance of python
using the following code:
```python
    # -- Instance a scribble dictionary with the same identifier
    data = scribble.get('foobar')
    
    # -- Print the fact that we have retrieved the same 
    # -- infromation
    print(data)
    # {'option_a': True, 'option_b': 123}
    
    # -- We can then further edit the data
    data['option_a'] = False
    
    # -- Calling .save() will trigger the dictionary
    # -- to store its current state to a persistent state
    data.save()
```
By default scribble will store its data in the follow platform specific
locations:

* Windows: %APPDATA%/pyscribble

* Linux: %XDG_CONFIG_HOME%/pyscribble if the environment variable exists, otherwise %HOME%/.config/pyscribble

* OSX: ËœHOME/Documents/pyscribble

However, you can override these paths by setting an environment variable
PYSCRIBBLE_STORAGE_DIR, if this is set then the path defined by that variable
will always be used over the default behaviour.

## Compatability

This has been tested under Python 2.7.13 and Python 3.6.6 on both Ubuntu and Windows.

## Contribute

If you would like to contribute thoughts, ideas, fixes or features please get in touch! mike@twisted.space