Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/ismael-sarmiento/kimera_python/llms.txt

Use this file to discover all available pages before exploring further.

Kimera Core is distributed as the kimera-core package on PyPI and can be added to any project with a single pip command. The library targets Python 3.6 or later and its core feature set — local caching, serialization, hashing, logging, and import utilities — relies exclusively on the Python standard library, so no heavy dependency tree is introduced into your project.

​
Requirements

Before installing, confirm that your environment meets the following minimum requirements.

Python Version

Python 3.6 or later is required. The constraint is declared in setup.py as python_requires='>=3.6'.

Dependencies

The core library has no mandatory third-party dependencies. Only the Python standard library modules abc, threading, hashlib, json, and importlib are used.

​
Install from PyPI

Install the latest stable release directly from the Python Package Index: 
pip install kimera-core
To pin a specific version — recommended for reproducible deployments — append the version number: 
pip install kimera-core==0.0.4

​
Optional Dependencies for Remote Cache Backends

The remote cache engines (RedisEngine and MemcachedEngine) are backed by optional third-party packages. These packages are not installed automatically with kimera-core; they are imported lazily at runtime only when you instantiate the corresponding engine. Kimera Core uses ImportUtils.raise_exception_if_module_not_exists to perform this lazy check. If the required package is absent when the engine is instantiated, a ModuleNotFoundError is raised with a descriptive message prompting you to install the missing dependency.
Install the redis client to enable RedisEngine:
pip install redis
The engine connects to localhost:6379 by default. A running Redis server is required at instantiation time.
Remote cache engines (RedisEngine and MemcachedEngine) establish a network connection to their respective servers at the time the engine object is created. If the server is not running or is unreachable, instantiation will raise a connection error. Always ensure Redis or Memcached is running and accessible before using the remote backends.

​
Install for Development

To contribute to Kimera Core or run its test suite locally, clone the repository and use tox to execute tests with coverage reporting.
1

Clone the repository

git clone https://github.com/ismael-sarmiento/kimera-core.git
cd kimera-core
2

Install tox

tox orchestrates the test environment and installs the coverage dependency declared in requirements.txt automatically.
pip install tox
3

Run the test suite

Invoking tox with no arguments executes the coverage environment defined in tox.ini. It uses unittest discover to find all unit tests starting from the project root, runs them against the components source tree, and prints a line-by-line coverage report.
tox
The tox.ini configuration runs three commands in sequence:
[tox]
envlist = coverage

[testenv]
commands = coverage run --source=components -m unittest discover
           coverage report -m
           coverage html

deps = -rrequirements.txt
After the run, an HTML coverage report is written to htmlcov/index.html for detailed inspection.

​
Verify Installation

After installing, confirm that the package is importable and that the core engine initialises correctly: 
from components.storage.dynamic.cache.local.engines import InMemoryCacheEngine
print(InMemoryCacheEngine())  # <__main__.InMemoryCacheEngine object ...>
A successful run prints the object representation of a freshly created InMemoryCacheEngine instance. If you see a ModuleNotFoundError, double-check that you are running the command from within the kimera-core directory or that the package’s components namespace is on your PYTHONPATH.
The import path components.storage.dynamic.cache.local.engines reflects the package’s internal directory layout. When running from the project root — the folder that contains the components/ directory — Python resolves this path without any additional configuration.

Build docs developers (and LLMs) love

Get started for freeTalk to us