# Sqeezz
A lightweight dependency injection and service configuration library for Python that makes it easy to manage dependencies, configure services, and switch between different environments.
## Features
- 🚀 **Simple API** - Easy to use builder pattern for configuring dependencies
- 🔧 **Flexible Configuration** - Support for functions, classes, modules, and custom objects
- 🏷️ **Named Groups** - Organize dependencies into logical groups and switch between them
- 🔄 **Context Switching** - Dynamic group switching with context managers
- ⚡ **Async Support** - Full support for async functions and coroutines
- 🧪 **Testing Friendly** - Perfect for mocking dependencies in tests
- 🌍 **Environment Management** - Easy switching between development, testing, and production configurations
- 📦 **Using Class** - Advanced dependency access with the Using class
## Installation
```bash
pip install sqeezz
```
## Quick Start
```python
import sqeezz
# Configure dependencies
sqeezz.builder()\
.add_ref(my_service)\
.add_named_ref('config', {'debug': True})\
.lazy_add_ref('os')
# Use dependencies
def my_function():
service = sqeezz.using('my_service')
config = sqeezz.using('config')
os = sqeezz.using('os')
print(f"Debug mode: {config['debug']}")
print(f"Current directory: {os.getcwd()}")
```
## Core Concepts
### Builder Pattern
Sqeezz uses a fluent builder pattern to configure dependencies:
```python
import sqeezz
# Basic builder
sqeezz.builder()\
.add_ref(Calculator)\
.add_named_ref('db_url', 'postgresql://localhost:5432/mydb')\
.lazy_add_ref('json')
```
### Three Ways to Add Dependencies
#### 1. `add_ref()` - Add by Reference
Adds functions, classes, or objects using their `__name__` attribute:
```python
def logger(message):
print(f"LOG: {message}")
class UserService:
def get_user(self, id):
return {"id": id, "name": "John"}
sqeezz.builder()\
.add_ref(logger)\
.add_ref(UserService)
# Usage
log_func = sqeezz.using('logger')
UserService = sqeezz.using('UserService')
user_service = UserService()
```
#### 2. `add_named_ref()` - Add with Custom Name
Adds any object with a custom name:
```python
sqeezz.builder()\
.add_named_ref('db_config', {'host': 'localhost', 'port': 5432})\
.add_named_ref('api_key', 'your-secret-key')\
.add_named_ref('multiplier', lambda x: x * 2)
# Usage
config = sqeezz.using('db_config')
api_key = sqeezz.using('api_key')
multiply = sqeezz.using('multiplier')
```
#### 3. `lazy_add_ref()` - Lazy Module Loading
Loads modules only when needed:
```python
sqeezz.builder()\
.lazy_add_ref('os')\
.lazy_add_ref('json')\
.lazy_add_ref('datetime')
# Usage
os = sqeezz.using('os')
json = sqeezz.using('json')
```
### Named Groups
Organize dependencies into logical groups for different environments:
```python
# Production configuration
sqeezz.builder('production')\
.add_named_ref('db_host', 'prod-db.example.com')\
.add_named_ref('debug', False)\
.add_named_ref('cache_ttl', 3600)
# Development configuration
sqeezz.builder('development')\
.add_named_ref('db_host', 'localhost')\
.add_named_ref('debug', True)\
.add_named_ref('cache_ttl', 60)
# Function that uses configuration
def get_database_info():
host = sqeezz.using('db_host')
debug = sqeezz.using('debug')
return f"Connecting to {host} (debug: {debug})"
# Create environment-specific versions
prod_db_info = sqeezz.group('production', get_database_info)
dev_db_info = sqeezz.group('development', get_database_info)
print(prod_db_info()) # "Connecting to prod-db.example.com (debug: False)"
print(dev_db_info()) # "Connecting to localhost (debug: True)"
```
### Group Switcher Context Manager
Use the `group_switcher` context manager for dynamic group switching within your code:
```python
# Configure different API environments
sqeezz.builder('api_v1')\
.add_named_ref('api_version', 'v1')\
.add_named_ref('rate_limit', 100)\
.add_named_ref('timeout', 30)
sqeezz.builder('api_v2')\
.add_named_ref('api_version', 'v2')\
.add_named_ref('rate_limit', 1000)\
.add_named_ref('timeout', 60)
def api_handler(endpoint):
api_version = sqeezz.using('api_version')
rate_limit = sqeezz.using('rate_limit')
timeout = sqeezz.using('timeout')
return f"Handled {endpoint} with {api_version} (limit: {rate_limit}, timeout: {timeout}s)"
# Switch contexts dynamically
with sqeezz.group_switcher('api_v1'):
v1_result = api_handler('/users')
with sqeezz.group_switcher('api_v2'):
v2_result = api_handler('/users')
print(v1_result) # "Handled /users with v1 (limit: 100, timeout: 30s)"
print(v2_result) # "Handled /users with v2 (limit: 1000, timeout: 60s)"
```
### Using Class for Advanced Dependency Management
The `Using` class provides advanced dependency access with lazy evaluation:
```python
class ServiceManager:
def __init__(self):
# Initialize Using objects for dependencies
self.logger_using = sqeezz.Using('logger_func')
self.config_using = sqeezz.Using('config')
self.db_using = sqeezz.Using('db')
def get_logger(self):
"""Get logger using Using.get"""
return self.logger_using.get
def get_config_value(self, key):
"""Get configuration value using Using.get"""
config = self.config_using.get
return config.get(key)
def log_system_status(self):
"""Log system status using dependencies through Using.get"""
logger = self.logger_using.get
config = self.config_using.get
debug_mode = config.get('debug', False)
port = config.get('port', 'unknown')
return logger(f"System status: debug={debug_mode}, port={port}")
# Use with different groups
service_manager = ServiceManager()
app_logger = sqeezz.group('app', service_manager.get_logger)
enterprise_logger = sqeezz.group('enterprise', service_manager.get_logger)
```
### Async Support
Sqeezz fully supports async functions:
```python
import asyncio
import sqeezz
# Configure async dependencies
sqeezz.builder('async_env')\
.add_named_ref('delay', 0.1)\
.add_named_ref('api_url', 'https://api.example.com')
async def fetch_data():
delay = sqeezz.using('delay')
api_url = sqeezz.using('api_url')
print(f"Fetching from {api_url}")
await asyncio.sleep(delay)
return {"data": "response"}
# Create grouped async function
async_fetch = sqeezz.group('async_env', fetch_data)
# Usage
result = asyncio.run(async_fetch())
```
## Advanced Examples
### Dynamic Database Configuration Switching
```python
class DatabaseManager:
def __init__(self):
self.connection_count = 0
def execute_query(self, query):
db_type = sqeezz.using('db_type')
host = sqeezz.using('host')
connection_pool = sqeezz.using('connection_pool')
self.connection_count += 1
return {
'query': query,
'database_type': db_type,
'executed_on': host,
'pool_size': connection_pool,
'connection_id': self.connection_count,
'result': f"Query '{query}' executed on {db_type} at {host}"
}
# Configure different databases
sqeezz.builder('mysql_db')\
.add_named_ref('db_type', 'MySQL')\
.add_named_ref('connection_pool', 20)\
.add_named_ref('host', 'mysql.example.com')
sqeezz.builder('postgres_db')\
.add_named_ref('db_type', 'PostgreSQL')\
.add_named_ref('connection_pool', 50)\
.add_named_ref('host', 'postgres.example.com')
# Use with context manager
db_manager = DatabaseManager()
with sqeezz.group_switcher('mysql_db'):
mysql_result = db_manager.execute_query('SELECT * FROM users')
with sqeezz.group_switcher('postgres_db'):
postgres_result = db_manager.execute_query('SELECT * FROM orders')
```
### Complex Dependency Chains
```python
import sqeezz
from unittest.mock import Mock
# Setup complex dependencies
mock_database = Mock()
mock_database.find_user.return_value = {
"id": 1, "name": "Alice", "email": "alice@example.com"
}
def custom_logger(message):
return f"[{datetime.now()}] {message}"
class UserService:
def __init__(self, db, logger):
self.db = db
self.logger = logger
def get_user(self, user_id):
self.logger(f"Fetching user {user_id}")
return self.db.find_user(user_id)
class EmailService:
def __init__(self, config):
self.smtp_host = config['smtp_host']
self.port = config['port']
def send_email(self, to, subject):
return f"Email sent to {to} via {self.smtp_host}:{self.port}"
# Configure all dependencies
sqeezz.builder('app')\
.add_named_ref('user_db', mock_database)\
.add_named_ref('app_logger', custom_logger)\
.add_named_ref('email_config', {'smtp_host': 'smtp.example.com', 'port': 587})\
.add_ref(UserService)\
.add_ref(EmailService)
# Use in application
def user_workflow(user_id):
# Get dependencies
UserService = sqeezz.using('UserService')
EmailService = sqeezz.using('EmailService')
user_db = sqeezz.using('user_db')
logger = sqeezz.using('app_logger')
email_config = sqeezz.using('email_config')
# Create service instances
user_service = UserService(user_db, logger)
email_service = EmailService(email_config)
# Execute workflow
user = user_service.get_user(user_id)
email_result = email_service.send_email(user['email'], "Welcome!")
return {"user": user, "email": email_result}
# Create grouped workflow
app_workflow = sqeezz.group('app', user_workflow)
result = app_workflow(123)
```
### Testing with Mocks
```python
import sqeezz
from unittest.mock import Mock
# Test configuration with mocks
mock_api = Mock()
mock_api.get.return_value = {"status": "ok", "data": "test"}
sqeezz.builder('test')\
.add_named_ref('api_client', mock_api)\
.add_named_ref('base_url', 'https://test-api.example.com')\
.add_named_ref('timeout', 0.001)
def api_service():
api = sqeezz.using('api_client')
base_url = sqeezz.using('base_url')
response = api.get(f"{base_url}/users")
return response
# Test with mocked dependencies
test_service = sqeezz.group('test', api_service)
result = test_service()
assert result["status"] == "ok"
```
## API Reference
### `sqeezz.builder(name: str = 'default') -> Builder`
Creates a new builder for the specified group.
### `Builder.add_ref(ref: Callable | type) -> Builder`
Adds a function or class using its `__name__` attribute as the key.
### `Builder.add_named_ref(name: str, ref: Any) -> Builder`
Adds any object with a custom name.
### `Builder.lazy_add_ref(module_name: str) -> Builder`
Adds a module that will be imported only when first accessed.
### `sqeezz.using(name: str) -> Any`
Retrieves a dependency from the current group.
### `sqeezz.group(group_name: str, func: Callable) -> Callable`
Wraps a function to use dependencies from a specific group.
### `sqeezz.group_switcher(group_name: str)`
Context manager for temporarily switching to a different group.
```python
with sqeezz.group_switcher('production'):
# Code here uses 'production' group dependencies
result = some_function()
```
### `sqeezz.Using(name: str)`
Class for advanced dependency management with lazy evaluation.
```python
# Create Using instance
config_using = sqeezz.Using('config')
# Get dependency value
config = config_using.get
```
## Requirements
- Python 3.8+
- No external dependencies
## License
MIT License - see LICENSE file for details.
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
## Changelog
### 0.1.0
- Initial release
- Basic dependency injection functionality
- Named groups support
- Async function support
- Group switcher context manager
- Using class for advanced dependency management
- Comprehensive test suite
Raw data
{
"_id": null,
"home_page": null,
"name": "sqeezz",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "Jeffrey Tackett <sqeezz@jeffreytackett.us>",
"keywords": "dependency injection, service locator, configuration, async, testing",
"author": null,
"author_email": "Jeffrey Tackett <sqeezz@jeffreytackett.us>",
"download_url": "https://files.pythonhosted.org/packages/ca/88/50f60deb6553e56e47e651596db5ec86e249d55e149d37ab23a672d70eda/sqeezz-0.1.0.tar.gz",
"platform": null,
"description": "\n# Sqeezz\n\nA lightweight dependency injection and service configuration library for Python that makes it easy to manage dependencies, configure services, and switch between different environments.\n\n## Features\n\n- \ud83d\ude80 **Simple API** - Easy to use builder pattern for configuring dependencies\n- \ud83d\udd27 **Flexible Configuration** - Support for functions, classes, modules, and custom objects\n- \ud83c\udff7\ufe0f **Named Groups** - Organize dependencies into logical groups and switch between them\n- \ud83d\udd04 **Context Switching** - Dynamic group switching with context managers\n- \u26a1 **Async Support** - Full support for async functions and coroutines\n- \ud83e\uddea **Testing Friendly** - Perfect for mocking dependencies in tests\n- \ud83c\udf0d **Environment Management** - Easy switching between development, testing, and production configurations\n- \ud83d\udce6 **Using Class** - Advanced dependency access with the Using class\n\n## Installation\n\n```bash\npip install sqeezz\n```\n\n## Quick Start\n\n```python\nimport sqeezz\n\n# Configure dependencies\nsqeezz.builder()\\\n .add_ref(my_service)\\\n .add_named_ref('config', {'debug': True})\\\n .lazy_add_ref('os')\n\n# Use dependencies\ndef my_function():\n service = sqeezz.using('my_service')\n config = sqeezz.using('config')\n os = sqeezz.using('os')\n \n print(f\"Debug mode: {config['debug']}\")\n print(f\"Current directory: {os.getcwd()}\")\n```\n\n## Core Concepts\n\n### Builder Pattern\n\nSqeezz uses a fluent builder pattern to configure dependencies:\n\n```python\nimport sqeezz\n\n# Basic builder\nsqeezz.builder()\\\n .add_ref(Calculator)\\\n .add_named_ref('db_url', 'postgresql://localhost:5432/mydb')\\\n .lazy_add_ref('json')\n```\n\n### Three Ways to Add Dependencies\n\n#### 1. `add_ref()` - Add by Reference\nAdds functions, classes, or objects using their `__name__` attribute:\n\n```python\ndef logger(message):\n print(f\"LOG: {message}\")\n\nclass UserService:\n def get_user(self, id):\n return {\"id\": id, \"name\": \"John\"}\n\nsqeezz.builder()\\\n .add_ref(logger)\\\n .add_ref(UserService)\n\n# Usage\nlog_func = sqeezz.using('logger')\nUserService = sqeezz.using('UserService')\nuser_service = UserService()\n```\n\n#### 2. `add_named_ref()` - Add with Custom Name\nAdds any object with a custom name:\n\n```python\nsqeezz.builder()\\\n .add_named_ref('db_config', {'host': 'localhost', 'port': 5432})\\\n .add_named_ref('api_key', 'your-secret-key')\\\n .add_named_ref('multiplier', lambda x: x * 2)\n\n# Usage\nconfig = sqeezz.using('db_config')\napi_key = sqeezz.using('api_key')\nmultiply = sqeezz.using('multiplier')\n```\n\n#### 3. `lazy_add_ref()` - Lazy Module Loading\nLoads modules only when needed:\n\n```python\nsqeezz.builder()\\\n .lazy_add_ref('os')\\\n .lazy_add_ref('json')\\\n .lazy_add_ref('datetime')\n\n# Usage\nos = sqeezz.using('os')\njson = sqeezz.using('json')\n```\n\n### Named Groups\n\nOrganize dependencies into logical groups for different environments:\n\n```python\n# Production configuration\nsqeezz.builder('production')\\\n .add_named_ref('db_host', 'prod-db.example.com')\\\n .add_named_ref('debug', False)\\\n .add_named_ref('cache_ttl', 3600)\n\n# Development configuration\nsqeezz.builder('development')\\\n .add_named_ref('db_host', 'localhost')\\\n .add_named_ref('debug', True)\\\n .add_named_ref('cache_ttl', 60)\n\n# Function that uses configuration\ndef get_database_info():\n host = sqeezz.using('db_host')\n debug = sqeezz.using('debug')\n return f\"Connecting to {host} (debug: {debug})\"\n\n# Create environment-specific versions\nprod_db_info = sqeezz.group('production', get_database_info)\ndev_db_info = sqeezz.group('development', get_database_info)\n\nprint(prod_db_info()) # \"Connecting to prod-db.example.com (debug: False)\"\nprint(dev_db_info()) # \"Connecting to localhost (debug: True)\"\n```\n\n### Group Switcher Context Manager\n\nUse the `group_switcher` context manager for dynamic group switching within your code:\n\n```python\n# Configure different API environments\nsqeezz.builder('api_v1')\\\n .add_named_ref('api_version', 'v1')\\\n .add_named_ref('rate_limit', 100)\\\n .add_named_ref('timeout', 30)\n\nsqeezz.builder('api_v2')\\\n .add_named_ref('api_version', 'v2')\\\n .add_named_ref('rate_limit', 1000)\\\n .add_named_ref('timeout', 60)\n\ndef api_handler(endpoint):\n api_version = sqeezz.using('api_version')\n rate_limit = sqeezz.using('rate_limit')\n timeout = sqeezz.using('timeout')\n \n return f\"Handled {endpoint} with {api_version} (limit: {rate_limit}, timeout: {timeout}s)\"\n\n# Switch contexts dynamically\nwith sqeezz.group_switcher('api_v1'):\n v1_result = api_handler('/users')\n \nwith sqeezz.group_switcher('api_v2'):\n v2_result = api_handler('/users')\n\nprint(v1_result) # \"Handled /users with v1 (limit: 100, timeout: 30s)\"\nprint(v2_result) # \"Handled /users with v2 (limit: 1000, timeout: 60s)\"\n```\n\n### Using Class for Advanced Dependency Management\n\nThe `Using` class provides advanced dependency access with lazy evaluation:\n\n```python\nclass ServiceManager:\n def __init__(self):\n # Initialize Using objects for dependencies\n self.logger_using = sqeezz.Using('logger_func')\n self.config_using = sqeezz.Using('config')\n self.db_using = sqeezz.Using('db')\n \n def get_logger(self):\n \"\"\"Get logger using Using.get\"\"\"\n return self.logger_using.get\n \n def get_config_value(self, key):\n \"\"\"Get configuration value using Using.get\"\"\"\n config = self.config_using.get\n return config.get(key)\n \n def log_system_status(self):\n \"\"\"Log system status using dependencies through Using.get\"\"\"\n logger = self.logger_using.get\n config = self.config_using.get\n \n debug_mode = config.get('debug', False)\n port = config.get('port', 'unknown')\n \n return logger(f\"System status: debug={debug_mode}, port={port}\")\n\n# Use with different groups\nservice_manager = ServiceManager()\napp_logger = sqeezz.group('app', service_manager.get_logger)\nenterprise_logger = sqeezz.group('enterprise', service_manager.get_logger)\n```\n\n### Async Support\n\nSqeezz fully supports async functions:\n\n```python\nimport asyncio\nimport sqeezz\n\n# Configure async dependencies\nsqeezz.builder('async_env')\\\n .add_named_ref('delay', 0.1)\\\n .add_named_ref('api_url', 'https://api.example.com')\n\nasync def fetch_data():\n delay = sqeezz.using('delay')\n api_url = sqeezz.using('api_url')\n \n print(f\"Fetching from {api_url}\")\n await asyncio.sleep(delay)\n return {\"data\": \"response\"}\n\n# Create grouped async function\nasync_fetch = sqeezz.group('async_env', fetch_data)\n\n# Usage\nresult = asyncio.run(async_fetch())\n```\n\n## Advanced Examples\n\n### Dynamic Database Configuration Switching\n\n```python\nclass DatabaseManager:\n def __init__(self):\n self.connection_count = 0\n \n def execute_query(self, query):\n db_type = sqeezz.using('db_type')\n host = sqeezz.using('host')\n connection_pool = sqeezz.using('connection_pool')\n \n self.connection_count += 1\n return {\n 'query': query,\n 'database_type': db_type,\n 'executed_on': host,\n 'pool_size': connection_pool,\n 'connection_id': self.connection_count,\n 'result': f\"Query '{query}' executed on {db_type} at {host}\"\n }\n\n# Configure different databases\nsqeezz.builder('mysql_db')\\\n .add_named_ref('db_type', 'MySQL')\\\n .add_named_ref('connection_pool', 20)\\\n .add_named_ref('host', 'mysql.example.com')\n\nsqeezz.builder('postgres_db')\\\n .add_named_ref('db_type', 'PostgreSQL')\\\n .add_named_ref('connection_pool', 50)\\\n .add_named_ref('host', 'postgres.example.com')\n\n# Use with context manager\ndb_manager = DatabaseManager()\n\nwith sqeezz.group_switcher('mysql_db'):\n mysql_result = db_manager.execute_query('SELECT * FROM users')\n\nwith sqeezz.group_switcher('postgres_db'):\n postgres_result = db_manager.execute_query('SELECT * FROM orders')\n```\n\n### Complex Dependency Chains\n\n```python\nimport sqeezz\nfrom unittest.mock import Mock\n\n# Setup complex dependencies\nmock_database = Mock()\nmock_database.find_user.return_value = {\n \"id\": 1, \"name\": \"Alice\", \"email\": \"alice@example.com\"\n}\n\ndef custom_logger(message):\n return f\"[{datetime.now()}] {message}\"\n\nclass UserService:\n def __init__(self, db, logger):\n self.db = db\n self.logger = logger\n \n def get_user(self, user_id):\n self.logger(f\"Fetching user {user_id}\")\n return self.db.find_user(user_id)\n\nclass EmailService:\n def __init__(self, config):\n self.smtp_host = config['smtp_host']\n self.port = config['port']\n \n def send_email(self, to, subject):\n return f\"Email sent to {to} via {self.smtp_host}:{self.port}\"\n\n# Configure all dependencies\nsqeezz.builder('app')\\\n .add_named_ref('user_db', mock_database)\\\n .add_named_ref('app_logger', custom_logger)\\\n .add_named_ref('email_config', {'smtp_host': 'smtp.example.com', 'port': 587})\\\n .add_ref(UserService)\\\n .add_ref(EmailService)\n\n# Use in application\ndef user_workflow(user_id):\n # Get dependencies\n UserService = sqeezz.using('UserService')\n EmailService = sqeezz.using('EmailService')\n user_db = sqeezz.using('user_db')\n logger = sqeezz.using('app_logger')\n email_config = sqeezz.using('email_config')\n \n # Create service instances\n user_service = UserService(user_db, logger)\n email_service = EmailService(email_config)\n \n # Execute workflow\n user = user_service.get_user(user_id)\n email_result = email_service.send_email(user['email'], \"Welcome!\")\n \n return {\"user\": user, \"email\": email_result}\n\n# Create grouped workflow\napp_workflow = sqeezz.group('app', user_workflow)\nresult = app_workflow(123)\n```\n\n### Testing with Mocks\n\n```python\nimport sqeezz\nfrom unittest.mock import Mock\n\n# Test configuration with mocks\nmock_api = Mock()\nmock_api.get.return_value = {\"status\": \"ok\", \"data\": \"test\"}\n\nsqeezz.builder('test')\\\n .add_named_ref('api_client', mock_api)\\\n .add_named_ref('base_url', 'https://test-api.example.com')\\\n .add_named_ref('timeout', 0.001)\n\ndef api_service():\n api = sqeezz.using('api_client')\n base_url = sqeezz.using('base_url')\n \n response = api.get(f\"{base_url}/users\")\n return response\n\n# Test with mocked dependencies\ntest_service = sqeezz.group('test', api_service)\nresult = test_service()\nassert result[\"status\"] == \"ok\"\n```\n\n## API Reference\n\n### `sqeezz.builder(name: str = 'default') -> Builder`\n\nCreates a new builder for the specified group.\n\n### `Builder.add_ref(ref: Callable | type) -> Builder`\n\nAdds a function or class using its `__name__` attribute as the key.\n\n### `Builder.add_named_ref(name: str, ref: Any) -> Builder`\n\nAdds any object with a custom name.\n\n### `Builder.lazy_add_ref(module_name: str) -> Builder`\n\nAdds a module that will be imported only when first accessed.\n\n### `sqeezz.using(name: str) -> Any`\n\nRetrieves a dependency from the current group.\n\n### `sqeezz.group(group_name: str, func: Callable) -> Callable`\n\nWraps a function to use dependencies from a specific group.\n\n### `sqeezz.group_switcher(group_name: str)`\n\nContext manager for temporarily switching to a different group.\n\n```python\nwith sqeezz.group_switcher('production'):\n # Code here uses 'production' group dependencies\n result = some_function()\n```\n\n### `sqeezz.Using(name: str)`\n\nClass for advanced dependency management with lazy evaluation.\n\n```python\n# Create Using instance\nconfig_using = sqeezz.Using('config')\n\n# Get dependency value\nconfig = config_using.get\n```\n\n## Requirements\n\n- Python 3.8+\n- No external dependencies\n\n## License\n\nMIT License - see LICENSE file for details.\n\n## Contributing\n\nContributions are welcome! Please feel free to submit a Pull Request.\n\n## Changelog\n\n### 0.1.0\n- Initial release\n- Basic dependency injection functionality\n- Named groups support\n- Async function support\n- Group switcher context manager\n- Using class for advanced dependency management\n- Comprehensive test suite\n\n",
"bugtrack_url": null,
"license": null,
"summary": "A lightweight dependency injection and service configuration library for Python",
"version": "0.1.0",
"project_urls": {
"Bug Tracker": "https://github.com/jfftck/sqeezz/issues",
"Changelog": "https://github.com/jfftck/sqeezz/blob/main/CHANGELOG.md",
"Documentation": "https://github.com/jfftck/sqeezz#readme",
"Homepage": "https://github.com/jfftck/sqeezz",
"Repository": "https://github.com/jfftck/sqeezz"
},
"split_keywords": [
"dependency injection",
" service locator",
" configuration",
" async",
" testing"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "451eec2b22985f3301e9312843a6956da0c8805e535752cbd5b3344608fe8268",
"md5": "3bf7d59a6c76cd17eb2138c7f8c2ec77",
"sha256": "f6d7c1cdce67f0a3f8de7f9c188711bba8daf32c2132e27e94484e82355a8c3b"
},
"downloads": -1,
"filename": "sqeezz-0.1.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "3bf7d59a6c76cd17eb2138c7f8c2ec77",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 6581,
"upload_time": "2025-09-02T18:42:19",
"upload_time_iso_8601": "2025-09-02T18:42:19.919056Z",
"url": "https://files.pythonhosted.org/packages/45/1e/ec2b22985f3301e9312843a6956da0c8805e535752cbd5b3344608fe8268/sqeezz-0.1.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "ca8850f60deb6553e56e47e651596db5ec86e249d55e149d37ab23a672d70eda",
"md5": "e1c37015282451a78e70760e8970f3bd",
"sha256": "2b2d479f1153009fe7a88360328a3578f1fcfdd75de0e111c665c6b15e1949fe"
},
"downloads": -1,
"filename": "sqeezz-0.1.0.tar.gz",
"has_sig": false,
"md5_digest": "e1c37015282451a78e70760e8970f3bd",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 6434,
"upload_time": "2025-09-02T18:42:21",
"upload_time_iso_8601": "2025-09-02T18:42:21.145509Z",
"url": "https://files.pythonhosted.org/packages/ca/88/50f60deb6553e56e47e651596db5ec86e249d55e149d37ab23a672d70eda/sqeezz-0.1.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-09-02 18:42:21",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "jfftck",
"github_project": "sqeezz",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "sqeezz"
}
JSON
