# AIM Framework: Adaptive Intelligence Mesh
[](https://python.org)
[](LICENSE)
[](https://aim-framework.readthedocs.io/)
A distributed coordination system for AI deployment and interaction that revolutionizes how AI systems collaborate and scale.
## Overview
The AIM Framework creates a mesh network of AI agents that can:
- **Dynamic Capability Routing**: Route queries to specialized micro-agents based on context, urgency, and required expertise
- **Persistent Context Weaving**: Create "context threads" that persist across sessions and can be selectively shared between agents
- **Adaptive Resource Scaling**: Automatically spawn or hibernate agents based on demand patterns
- **Cross-Agent Learning Propagation**: Share knowledge gained by one agent across the mesh without centralized retraining
- **Confidence-Based Collaboration**: Enable agents to detect their uncertainty and automatically collaborate with other agents
The core innovation of AIM is the **Intent Graph** - a real-time graph of user intentions, project contexts, and capability needs that allows the system to anticipate requirements and pre-position resources.
## Key Features
### 🔀 Dynamic Capability Routing
Instead of having one large model handle everything, AIM routes queries to specialized micro-agents based on context, urgency, and required expertise. A coding question might route through a code-specialist agent, then to a security-review agent, then to a documentation agent.
### 🧵 Persistent Context Weaving
Each interaction creates "context threads" that persist across sessions and can be selectively shared between agents. Your conversation about a project continues seamlessly whether you're asking about code, design, or deployment.
### 📈 Adaptive Resource Scaling
The mesh automatically spawns or hibernates agents based on demand patterns. During high coding activity, more programming agents activate. During research phases, more analysis agents come online.
### 🧠 Cross-Agent Learning Propagation
When one agent learns something valuable (like a common error pattern), it propagates this knowledge through the mesh without centralized retraining.
### 🤝 Confidence-Based Collaboration
Agents can detect their uncertainty and automatically collaborate with other agents, creating dynamic expert panels for complex problems.
### 🎯 Intent Graph
Builds a real-time graph of user intentions, project contexts, and capability needs to anticipate requirements and pre-position resources.
## Installation
### From PyPI (Recommended)
```bash
pip install aim-framework
```
### From Source
```bash
git clone https://github.com/jasonviipers/aim-framework.git
cd aim-framework
pip install -e .
```
### Development Installation
```bash
git clone https://github.com/jasonviipers/aim-framework.git
cd aim-framework
pip install -e ".[dev,docs,api,visualization]"
```
## Quick Start
### 1. Basic Usage
```python
import asyncio
from aim import AIMFramework, Config
async def main():
# Create and initialize framework
framework = AIMFramework()
await framework.initialize()
# Create a request
from aim import Request
request = Request(
user_id="user_123",
content="Create a Python function to calculate prime numbers",
task_type="code_generation"
)
# Process the request
response = await framework.process_request(request)
print(f"Response: {response.content}")
# Shutdown
await framework.shutdown()
if __name__ == "__main__":
asyncio.run(main())
```
### 2. Using the CLI
Start the AIM server:
```bash
aim-server --host 0.0.0.0 --port 5000
```
Initialize a new project:
```bash
aim-init my-aim-project
cd my-aim-project
pip install -r requirements.txt
python main.py
```
Run benchmarks:
```bash
aim-benchmark --benchmark-type latency --num-requests 100
```
### 3. Creating Custom Agents
```python
from aim import Agent, AgentCapability, Request, Response
class CustomCodeAgent(Agent):
def __init__(self):
super().__init__(
capabilities={AgentCapability.CODE_GENERATION},
description="Custom code generation agent",
version="1.0.0"
)
async def process_request(self, request: Request) -> Response:
# Your custom logic here
result = f"Generated code for: {request.content}"
return Response(
request_id=request.request_id,
agent_id=self.agent_id,
content=result,
confidence=0.9,
success=True
)
# Register with framework
framework.register_agent(CustomCodeAgent())
```
### 4. Configuration
```python
from aim import Config
# Load from file
config = Config("config.json")
# Or create programmatically
config = Config({
"framework": {
"name": "My AIM Framework",
"log_level": "INFO"
},
"api": {
"host": "0.0.0.0",
"port": 5000
},
"agents": {
"max_agents_per_type": 5
}
})
framework = AIMFramework(config)
```
## Architecture
The AIM Framework consists of five main layers:
1. **Interface Layer**: APIs and user interfaces
2. **Coordination Layer**: Dynamic routing, context weaving, and collaboration
3. **Agent Layer**: Specialized micro-agents for different capabilities
4. **Resource Management Layer**: Adaptive scaling and load balancing
5. **Knowledge Layer**: Learning propagation and Intent Graph
## API Reference
### Core Classes
- `AIMFramework`: Main orchestrator class
- `Agent`: Base class for creating custom agents
- `Request`/`Response`: Communication primitives
- `ContextThread`: Persistent context management
- `Config`: Configuration management
### Agent Capabilities
The framework supports various built-in capabilities:
- `CODE_GENERATION`: Generate code in various languages
- `SECURITY_REVIEW`: Security analysis and vulnerability detection
- `DOCUMENTATION`: Generate and maintain documentation
- `DATA_ANALYSIS`: Analyze and visualize data
- `DESIGN`: UI/UX design and prototyping
- `RESEARCH`: Information gathering and analysis
- `TESTING`: Test generation and execution
- `DEPLOYMENT`: Application deployment and DevOps
## Examples
### Multi-Agent Collaboration
```python
# Request that requires multiple agents
request = Request(
user_id="user_123",
content="Create a secure web API with documentation",
task_type="code_generation"
)
# Framework automatically routes through:
# 1. Code generation agent
# 2. Security review agent
# 3. Documentation agent
response = await framework.process_request(request)
```
### Context Persistence
```python
# Create a context thread
thread_id = await framework.create_context_thread(
user_id="user_123",
initial_context={"project": "web_api", "language": "python"}
)
# First request
request1 = Request(
user_id="user_123",
content="Create a Flask API",
task_type="code_generation",
context_thread_id=thread_id
)
# Second request (context is maintained)
request2 = Request(
user_id="user_123",
content="Add authentication to the API",
task_type="code_generation",
context_thread_id=thread_id # Same thread
)
```
### Performance Monitoring
```python
# Get performance metrics
metrics = await framework.get_performance_metrics()
print(f"Average latency: {metrics['avg_latency']}")
print(f"Throughput: {metrics['avg_throughput']}")
# Get framework status
status = framework.get_framework_status()
print(f"Active agents: {status['active_agents']}")
```
## Configuration
The framework supports extensive configuration through JSON files or environment variables:
```json
{
"framework": {
"name": "AIM Framework",
"version": "1.0.0",
"log_level": "INFO"
},
"agents": {
"min_agents_per_type": 1,
"max_agents_per_type": 5,
"default_timeout": 30.0
},
"context": {
"max_threads_per_user": 10,
"default_ttl": 86400.0
},
"api": {
"host": "0.0.0.0",
"port": 5000,
"cors_enabled": true
},
"performance": {
"cache_size": 10000,
"load_balancing_strategy": "predictive"
}
}
```
Environment variables:
- `AIM_LOG_LEVEL`: Set logging level
- `AIM_API_HOST`: Set API host
- `AIM_API_PORT`: Set API port
- `AIM_CACHE_SIZE`: Set cache size
## Testing
Run the test suite:
```bash
pytest tests/
```
Run with coverage:
```bash
pytest --cov=aim tests/
```
## Contributing
We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
### Development Setup
1. Clone the repository
2. Install development dependencies: `pip install -e ".[dev]"`
3. Install pre-commit hooks: `pre-commit install`
4. Run tests: `pytest`
## Documentation
Full documentation is available at [https://aim-framework.readthedocs.io/](https://aim-framework.readthedocs.io/)
### Building Documentation Locally
```bash
cd docs/
make html
```
## Performance
The AIM Framework is designed for high performance and scalability:
- **Latency**: Sub-second response times for most requests
- **Throughput**: Handles thousands of concurrent requests
- **Scalability**: Horizontal scaling through agent mesh architecture
- **Memory**: Efficient memory usage with intelligent caching
- **CPU**: Optimized for multi-core systems
## Roadmap
- [ ] Support for more agent types and capabilities
- [ ] Enhanced Intent Graph with machine learning
- [ ] Distributed deployment across multiple nodes
- [ ] Integration with popular AI/ML frameworks
- [ ] Advanced security and authentication features
- [ ] Real-time collaboration features
- [ ] Plugin system for third-party extensions
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Support
- **Documentation**: [https://aim-framework.readthedocs.io/](https://aim-framework.readthedocs.io/)
- **Issues**: [GitHub Issues](https://github.com/jasonviipers/aim-framework/issues)
- **Discussions**: [GitHub Discussions](https://github.com/jasonviipers/aim-framework/discussions)
- **Email**: support@jasonviipers.com
## Citation
If you use the AIM Framework in your research, please cite:
```bibtex
@software{aim_framework,
title={AIM Framework: Adaptive Intelligence Mesh},
author={jasonviipers},
year={2025},
url={https://github.com/jasonviipers/aim-framework}
}
```
## Acknowledgments
- Thanks to all contributors and the open-source community
- Inspired by distributed systems and multi-agent architectures
- Built with modern Python async/await patterns
Raw data
{
"_id": null,
"home_page": "https://github.com/jasonviipers/aim-framework",
"name": "aim-framework",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "ai artificial-intelligence distributed-systems mesh-network coordination agents",
"author": "jasonviipers",
"author_email": "support@jasonviipers.com",
"download_url": "https://files.pythonhosted.org/packages/b4/56/a624069c569b41d4a7da4762b02653e47776b67022254fc43e9dd1296ca2/aim-framework-1.0.0.tar.gz",
"platform": null,
"description": "# AIM Framework: Adaptive Intelligence Mesh\r\n\r\n[](https://python.org)\r\n[](LICENSE)\r\n[](https://aim-framework.readthedocs.io/)\r\n\r\nA distributed coordination system for AI deployment and interaction that revolutionizes how AI systems collaborate and scale.\r\n\r\n## Overview\r\n\r\nThe AIM Framework creates a mesh network of AI agents that can:\r\n\r\n- **Dynamic Capability Routing**: Route queries to specialized micro-agents based on context, urgency, and required expertise\r\n- **Persistent Context Weaving**: Create \"context threads\" that persist across sessions and can be selectively shared between agents\r\n- **Adaptive Resource Scaling**: Automatically spawn or hibernate agents based on demand patterns\r\n- **Cross-Agent Learning Propagation**: Share knowledge gained by one agent across the mesh without centralized retraining\r\n- **Confidence-Based Collaboration**: Enable agents to detect their uncertainty and automatically collaborate with other agents\r\n\r\nThe core innovation of AIM is the **Intent Graph** - a real-time graph of user intentions, project contexts, and capability needs that allows the system to anticipate requirements and pre-position resources.\r\n\r\n## Key Features\r\n\r\n### \ud83d\udd00 Dynamic Capability Routing\r\nInstead of having one large model handle everything, AIM routes queries to specialized micro-agents based on context, urgency, and required expertise. A coding question might route through a code-specialist agent, then to a security-review agent, then to a documentation agent.\r\n\r\n### \ud83e\uddf5 Persistent Context Weaving\r\nEach interaction creates \"context threads\" that persist across sessions and can be selectively shared between agents. Your conversation about a project continues seamlessly whether you're asking about code, design, or deployment.\r\n\r\n### \ud83d\udcc8 Adaptive Resource Scaling\r\nThe mesh automatically spawns or hibernates agents based on demand patterns. During high coding activity, more programming agents activate. During research phases, more analysis agents come online.\r\n\r\n### \ud83e\udde0 Cross-Agent Learning Propagation\r\nWhen one agent learns something valuable (like a common error pattern), it propagates this knowledge through the mesh without centralized retraining.\r\n\r\n### \ud83e\udd1d Confidence-Based Collaboration\r\nAgents can detect their uncertainty and automatically collaborate with other agents, creating dynamic expert panels for complex problems.\r\n\r\n### \ud83c\udfaf Intent Graph\r\nBuilds a real-time graph of user intentions, project contexts, and capability needs to anticipate requirements and pre-position resources.\r\n\r\n## Installation\r\n\r\n### From PyPI (Recommended)\r\n\r\n```bash\r\npip install aim-framework\r\n```\r\n\r\n### From Source\r\n\r\n```bash\r\ngit clone https://github.com/jasonviipers/aim-framework.git\r\ncd aim-framework\r\npip install -e .\r\n```\r\n\r\n### Development Installation\r\n\r\n```bash\r\ngit clone https://github.com/jasonviipers/aim-framework.git\r\ncd aim-framework\r\npip install -e \".[dev,docs,api,visualization]\"\r\n```\r\n\r\n## Quick Start\r\n\r\n### 1. Basic Usage\r\n\r\n```python\r\nimport asyncio\r\nfrom aim import AIMFramework, Config\r\n\r\nasync def main():\r\n # Create and initialize framework\r\n framework = AIMFramework()\r\n await framework.initialize()\r\n \r\n # Create a request\r\n from aim import Request\r\n request = Request(\r\n user_id=\"user_123\",\r\n content=\"Create a Python function to calculate prime numbers\",\r\n task_type=\"code_generation\"\r\n )\r\n \r\n # Process the request\r\n response = await framework.process_request(request)\r\n print(f\"Response: {response.content}\")\r\n \r\n # Shutdown\r\n await framework.shutdown()\r\n\r\nif __name__ == \"__main__\":\r\n asyncio.run(main())\r\n```\r\n\r\n### 2. Using the CLI\r\n\r\nStart the AIM server:\r\n\r\n```bash\r\naim-server --host 0.0.0.0 --port 5000\r\n```\r\n\r\nInitialize a new project:\r\n\r\n```bash\r\naim-init my-aim-project\r\ncd my-aim-project\r\npip install -r requirements.txt\r\npython main.py\r\n```\r\n\r\nRun benchmarks:\r\n\r\n```bash\r\naim-benchmark --benchmark-type latency --num-requests 100\r\n```\r\n\r\n### 3. Creating Custom Agents\r\n\r\n```python\r\nfrom aim import Agent, AgentCapability, Request, Response\r\n\r\nclass CustomCodeAgent(Agent):\r\n def __init__(self):\r\n super().__init__(\r\n capabilities={AgentCapability.CODE_GENERATION},\r\n description=\"Custom code generation agent\",\r\n version=\"1.0.0\"\r\n )\r\n \r\n async def process_request(self, request: Request) -> Response:\r\n # Your custom logic here\r\n result = f\"Generated code for: {request.content}\"\r\n \r\n return Response(\r\n request_id=request.request_id,\r\n agent_id=self.agent_id,\r\n content=result,\r\n confidence=0.9,\r\n success=True\r\n )\r\n\r\n# Register with framework\r\nframework.register_agent(CustomCodeAgent())\r\n```\r\n\r\n### 4. Configuration\r\n\r\n```python\r\nfrom aim import Config\r\n\r\n# Load from file\r\nconfig = Config(\"config.json\")\r\n\r\n# Or create programmatically\r\nconfig = Config({\r\n \"framework\": {\r\n \"name\": \"My AIM Framework\",\r\n \"log_level\": \"INFO\"\r\n },\r\n \"api\": {\r\n \"host\": \"0.0.0.0\",\r\n \"port\": 5000\r\n },\r\n \"agents\": {\r\n \"max_agents_per_type\": 5\r\n }\r\n})\r\n\r\nframework = AIMFramework(config)\r\n```\r\n\r\n## Architecture\r\n\r\nThe AIM Framework consists of five main layers:\r\n\r\n1. **Interface Layer**: APIs and user interfaces\r\n2. **Coordination Layer**: Dynamic routing, context weaving, and collaboration\r\n3. **Agent Layer**: Specialized micro-agents for different capabilities\r\n4. **Resource Management Layer**: Adaptive scaling and load balancing\r\n5. **Knowledge Layer**: Learning propagation and Intent Graph\r\n\r\n## API Reference\r\n\r\n### Core Classes\r\n\r\n- `AIMFramework`: Main orchestrator class\r\n- `Agent`: Base class for creating custom agents\r\n- `Request`/`Response`: Communication primitives\r\n- `ContextThread`: Persistent context management\r\n- `Config`: Configuration management\r\n\r\n### Agent Capabilities\r\n\r\nThe framework supports various built-in capabilities:\r\n\r\n- `CODE_GENERATION`: Generate code in various languages\r\n- `SECURITY_REVIEW`: Security analysis and vulnerability detection\r\n- `DOCUMENTATION`: Generate and maintain documentation\r\n- `DATA_ANALYSIS`: Analyze and visualize data\r\n- `DESIGN`: UI/UX design and prototyping\r\n- `RESEARCH`: Information gathering and analysis\r\n- `TESTING`: Test generation and execution\r\n- `DEPLOYMENT`: Application deployment and DevOps\r\n\r\n## Examples\r\n\r\n### Multi-Agent Collaboration\r\n\r\n```python\r\n# Request that requires multiple agents\r\nrequest = Request(\r\n user_id=\"user_123\",\r\n content=\"Create a secure web API with documentation\",\r\n task_type=\"code_generation\"\r\n)\r\n\r\n# Framework automatically routes through:\r\n# 1. Code generation agent\r\n# 2. Security review agent \r\n# 3. Documentation agent\r\n\r\nresponse = await framework.process_request(request)\r\n```\r\n\r\n### Context Persistence\r\n\r\n```python\r\n# Create a context thread\r\nthread_id = await framework.create_context_thread(\r\n user_id=\"user_123\",\r\n initial_context={\"project\": \"web_api\", \"language\": \"python\"}\r\n)\r\n\r\n# First request\r\nrequest1 = Request(\r\n user_id=\"user_123\",\r\n content=\"Create a Flask API\",\r\n task_type=\"code_generation\",\r\n context_thread_id=thread_id\r\n)\r\n\r\n# Second request (context is maintained)\r\nrequest2 = Request(\r\n user_id=\"user_123\", \r\n content=\"Add authentication to the API\",\r\n task_type=\"code_generation\",\r\n context_thread_id=thread_id # Same thread\r\n)\r\n```\r\n\r\n### Performance Monitoring\r\n\r\n```python\r\n# Get performance metrics\r\nmetrics = await framework.get_performance_metrics()\r\nprint(f\"Average latency: {metrics['avg_latency']}\")\r\nprint(f\"Throughput: {metrics['avg_throughput']}\")\r\n\r\n# Get framework status\r\nstatus = framework.get_framework_status()\r\nprint(f\"Active agents: {status['active_agents']}\")\r\n```\r\n\r\n## Configuration\r\n\r\nThe framework supports extensive configuration through JSON files or environment variables:\r\n\r\n```json\r\n{\r\n \"framework\": {\r\n \"name\": \"AIM Framework\",\r\n \"version\": \"1.0.0\",\r\n \"log_level\": \"INFO\"\r\n },\r\n \"agents\": {\r\n \"min_agents_per_type\": 1,\r\n \"max_agents_per_type\": 5,\r\n \"default_timeout\": 30.0\r\n },\r\n \"context\": {\r\n \"max_threads_per_user\": 10,\r\n \"default_ttl\": 86400.0\r\n },\r\n \"api\": {\r\n \"host\": \"0.0.0.0\",\r\n \"port\": 5000,\r\n \"cors_enabled\": true\r\n },\r\n \"performance\": {\r\n \"cache_size\": 10000,\r\n \"load_balancing_strategy\": \"predictive\"\r\n }\r\n}\r\n```\r\n\r\nEnvironment variables:\r\n- `AIM_LOG_LEVEL`: Set logging level\r\n- `AIM_API_HOST`: Set API host\r\n- `AIM_API_PORT`: Set API port\r\n- `AIM_CACHE_SIZE`: Set cache size\r\n\r\n## Testing\r\n\r\nRun the test suite:\r\n\r\n```bash\r\npytest tests/\r\n```\r\n\r\nRun with coverage:\r\n\r\n```bash\r\npytest --cov=aim tests/\r\n```\r\n\r\n## Contributing\r\n\r\nWe welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.\r\n\r\n### Development Setup\r\n\r\n1. Clone the repository\r\n2. Install development dependencies: `pip install -e \".[dev]\"`\r\n3. Install pre-commit hooks: `pre-commit install`\r\n4. Run tests: `pytest`\r\n\r\n## Documentation\r\n\r\nFull documentation is available at [https://aim-framework.readthedocs.io/](https://aim-framework.readthedocs.io/)\r\n\r\n### Building Documentation Locally\r\n\r\n```bash\r\ncd docs/\r\nmake html\r\n```\r\n\r\n## Performance\r\n\r\nThe AIM Framework is designed for high performance and scalability:\r\n\r\n- **Latency**: Sub-second response times for most requests\r\n- **Throughput**: Handles thousands of concurrent requests\r\n- **Scalability**: Horizontal scaling through agent mesh architecture\r\n- **Memory**: Efficient memory usage with intelligent caching\r\n- **CPU**: Optimized for multi-core systems\r\n\r\n## Roadmap\r\n\r\n- [ ] Support for more agent types and capabilities\r\n- [ ] Enhanced Intent Graph with machine learning\r\n- [ ] Distributed deployment across multiple nodes\r\n- [ ] Integration with popular AI/ML frameworks\r\n- [ ] Advanced security and authentication features\r\n- [ ] Real-time collaboration features\r\n- [ ] Plugin system for third-party extensions\r\n\r\n## License\r\n\r\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\r\n\r\n## Support\r\n\r\n- **Documentation**: [https://aim-framework.readthedocs.io/](https://aim-framework.readthedocs.io/)\r\n- **Issues**: [GitHub Issues](https://github.com/jasonviipers/aim-framework/issues)\r\n- **Discussions**: [GitHub Discussions](https://github.com/jasonviipers/aim-framework/discussions)\r\n- **Email**: support@jasonviipers.com\r\n\r\n## Citation\r\n\r\nIf you use the AIM Framework in your research, please cite:\r\n\r\n```bibtex\r\n@software{aim_framework,\r\n title={AIM Framework: Adaptive Intelligence Mesh},\r\n author={jasonviipers},\r\n year={2025},\r\n url={https://github.com/jasonviipers/aim-framework}\r\n}\r\n```\r\n\r\n## Acknowledgments\r\n\r\n- Thanks to all contributors and the open-source community\r\n- Inspired by distributed systems and multi-agent architectures\r\n- Built with modern Python async/await patterns\r\n\r\n",
"bugtrack_url": null,
"license": null,
"summary": "Adaptive Intelligence Mesh - A distributed coordination system for AI deployment and interaction",
"version": "1.0.0",
"project_urls": {
"Bug Reports": "https://github.com/jasonviipers/aim-framework/issues",
"Documentation": "https://aim-framework.readthedocs.io/",
"Homepage": "https://github.com/jasonviipers/aim-framework",
"Source": "https://github.com/jasonviipers/aim-framework"
},
"split_keywords": [
"ai",
"artificial-intelligence",
"distributed-systems",
"mesh-network",
"coordination",
"agents"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "d6c824d44c39654853caf0f6fa2dedf7fbb8c0d4a0270e288edc81ef7d861252",
"md5": "3885c6438ae6a27d3a964d6e7c69439a",
"sha256": "c406132636fdf638d840d1ac62aaee92040f2099227a6ff5eb98a9f5df481299"
},
"downloads": -1,
"filename": "aim_framework-1.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "3885c6438ae6a27d3a964d6e7c69439a",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 56116,
"upload_time": "2025-07-30T00:34:36",
"upload_time_iso_8601": "2025-07-30T00:34:36.856899Z",
"url": "https://files.pythonhosted.org/packages/d6/c8/24d44c39654853caf0f6fa2dedf7fbb8c0d4a0270e288edc81ef7d861252/aim_framework-1.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "b456a624069c569b41d4a7da4762b02653e47776b67022254fc43e9dd1296ca2",
"md5": "6171fea66962cf2ea7aa789d40fd4bb4",
"sha256": "d9033083dcccd4528a154953996be9cd54568a1a116effac414e2dbf86fbb125"
},
"downloads": -1,
"filename": "aim-framework-1.0.0.tar.gz",
"has_sig": false,
"md5_digest": "6171fea66962cf2ea7aa789d40fd4bb4",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 50342,
"upload_time": "2025-07-30T00:34:38",
"upload_time_iso_8601": "2025-07-30T00:34:38.328963Z",
"url": "https://files.pythonhosted.org/packages/b4/56/a624069c569b41d4a7da4762b02653e47776b67022254fc43e9dd1296ca2/aim-framework-1.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-30 00:34:38",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "jasonviipers",
"github_project": "aim-framework",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "asyncio-mqtt",
"specs": [
[
">=",
"0.11.0"
]
]
},
{
"name": "numpy",
"specs": [
[
">=",
"1.21.0"
]
]
},
{
"name": "pandas",
"specs": [
[
">=",
"1.3.0"
]
]
},
{
"name": "requests",
"specs": [
[
">=",
"2.28.0"
]
]
},
{
"name": "aiohttp",
"specs": [
[
">=",
"3.8.0"
]
]
},
{
"name": "websockets",
"specs": [
[
">=",
"10.0"
]
]
},
{
"name": "flask",
"specs": [
[
">=",
"2.2.0"
]
]
},
{
"name": "flask-cors",
"specs": [
[
">=",
"4.0.0"
]
]
},
{
"name": "gunicorn",
"specs": [
[
">=",
"20.1.0"
]
]
},
{
"name": "matplotlib",
"specs": [
[
">=",
"3.5.0"
]
]
},
{
"name": "plotly",
"specs": [
[
">=",
"5.10.0"
]
]
},
{
"name": "networkx",
"specs": [
[
">=",
"2.8.0"
]
]
},
{
"name": "scikit-learn",
"specs": [
[
">=",
"1.1.0"
]
]
},
{
"name": "pyyaml",
"specs": [
[
">=",
"6.0"
]
]
},
{
"name": "python-dotenv",
"specs": [
[
">=",
"0.19.0"
]
]
},
{
"name": "click",
"specs": [
[
">=",
"8.0.0"
]
]
},
{
"name": "pytest",
"specs": [
[
">=",
"7.0.0"
]
]
},
{
"name": "pytest-cov",
"specs": [
[
">=",
"4.0.0"
]
]
},
{
"name": "pytest-asyncio",
"specs": [
[
">=",
"0.20.0"
]
]
},
{
"name": "black",
"specs": [
[
">=",
"22.0.0"
]
]
},
{
"name": "flake8",
"specs": [
[
">=",
"5.0.0"
]
]
},
{
"name": "mypy",
"specs": [
[
">=",
"0.991"
]
]
},
{
"name": "pre-commit",
"specs": [
[
">=",
"2.20.0"
]
]
},
{
"name": "sphinx",
"specs": [
[
">=",
"5.0.0"
]
]
},
{
"name": "sphinx-rtd-theme",
"specs": [
[
">=",
"1.0.0"
]
]
},
{
"name": "myst-parser",
"specs": [
[
">=",
"0.18.0"
]
]
},
{
"name": "psutil",
"specs": [
[
">=",
"5.9.0"
]
]
},
{
"name": "memory-profiler",
"specs": [
[
">=",
"0.60.0"
]
]
}
],
"lcname": "aim-framework"
}
JSON
