Environ Global State Management

1.0 · abandoned · verified Fri Apr 17

`environ` is a small Python library providing a stack-based mechanism for managing global application state. It allows setting and retrieving values globally, with the ability to temporarily override values within a context manager. The library's latest version is 1.0, released in 2012, and it is no longer actively maintained or supported.

Common errors

```
ModuleNotFoundError: No module named 'environ'
```
cause The 'environ' package has not been installed.

fix Run `pip install environ` to install the package.
```
TypeError: 'Environ' object is not callable
```
cause The `environ` object is a singleton instance for managing state, not a constructor to be called like `environ()`.

fix Access methods directly on the `environ` object, e.g., `environ.set('key', value)` or `environ.get('key')`.
```
TypeError: 'Environ' object does not support item assignment
```
cause The `environ` object is not a dictionary and does not support direct item assignment or access (e.g., `environ['key'] = value` or `value = environ['key']`).

fix Use the dedicated `set` and `get` methods: `environ.set('key', value)` and `value = environ.get('key')`.

Warnings

breaking This library is **abandoned** and has not been updated since its 1.0 release in 2012. It is not officially supported on modern Python versions (e.g., Python 3.8+). While it might still function for simple cases, compatibility issues or unexpected behavior are likely to arise. Consider alternative solutions for global state management or environment variables.
Fix: Do not use for new projects. For existing projects, migrate to `os.environ` for environment variables, or a dependency injection system for application state.
gotcha The library's name `environ` is highly misleading. It is **not** designed for managing operating system environment variables (like `PATH` or `HOME`). Instead, it manages application-specific global state. For OS environment variables, use Python's built-in `os.environ`.
Fix: Use `os.environ` for OS environment variables. Use `environ.set()` and `environ.get()` for `environ` library's intended application state.
gotcha `environ` uses a global singleton object, which can make testing and managing application state challenging. Modifying global state can lead to side effects, make tests difficult to isolate, and introduce hard-to-debug issues in complex applications.
Fix: Be extremely cautious when using global state. For testing, ensure proper setup and teardown to reset state. Consider dependency injection or passing state explicitly for better control.

Install

pip install environ Install latest version

Imports

environ
```
from environ import environ
```

Quickstart

This example demonstrates how to set and retrieve global application state using `environ`, and how to use its context manager for temporary overrides.

from environ import environ

environ.set('app_config_key', 'initial_value')
assert environ.get('app_config_key') == 'initial_value'

# Temporarily override values within a context
with environ(temporary_key='context_value'):
    assert environ.get('app_config_key') == 'initial_value'
    assert environ.get('temporary_key') == 'context_value'
    environ.set('another_context_key', 'inside_context')
    assert environ.get('another_context_key') == 'inside_context'

# Outside the context, temporary values are reverted
assert environ.get('app_config_key') == 'initial_value'
assert environ.get('temporary_key') is None
assert environ.get('another_context_key') is None

view raw JSON →