| Name | coex JSON |
| Version |
0.1.19
JSON |
| download |
| home_page | https://github.com/torchtorchkimtorch/coex |
| Summary | Execute code snippets in isolated Docker environments with multi-language support and security protection |
| upload_time | 2025-09-03 07:33:35 |
| maintainer | None |
| docs_url | None |
| author | torchtorchkimtorch |
| requires_python | >=3.8 |
| license | MIT License
Copyright (c) 2024 coex
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
|
| keywords |
docker
code-execution
sandbox
security
multi-language
testing
validation
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# coex - Code Execution Library
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](tests/)
**coex** is a Python library that executes code snippets using subprocess calls on the host system. It provides secure, multi-language code execution with comprehensive validation and testing capabilities.
## Features
- **Host System Execution**: Uses subprocess to run language tools directly on the host
- **Security First**: Protection against destructive file operations and malicious code
- **Multi-Language Support**: Python, JavaScript, Java, C++, C, Go, Rust, and more
- **Multiple Execution Modes**: Input/output validation, function comparison, simple execution
- **High Performance**: Direct subprocess execution without container overhead
- **Robust Error Handling**: Comprehensive error handling and timeout management
- **Comprehensive Testing**: Extensive test suite with security and integration tests
## Quick Start
### Installation
```bash
pip install coex
```
### Prerequisites
- Python 3.8 or higher
- Language tools installed on host system:
- **Java**: `javac` and `java` (OpenJDK 8+ or Oracle JDK)
- **JavaScript**: `node` (Node.js 14+)
- **C/C++**: `gcc` and `g++` (GCC 7+)
- **Go**: `go` (Go 1.16+)
- **Rust**: `rustc` (Rust 1.50+)
- Docker (optional, for sandboxed execution)
### Basic Usage
```python
import coex
# Method 1: Input/Output validation (explicit mode)
result = coex.execute(
mode="answer",
inputs=[0, 1, 2, 3],
outputs=[1, 2, 3, 4],
code="def add_one(x): return x + 1",
language="python"
)
# Returns: [1, 1, 1, 1] (boolean array indicating pass/fail for each test case)
# Method 2: Function comparison (explicit mode)
result = coex.execute(
mode="function",
answer_fn="def say_hello(): return 'hello world'",
code="def hello(): return 'hello world'",
language="python"
)
# Returns: [1] (boolean indicating if functions return same value)
# Method 3: Backward compatibility (auto-detection)
result = coex.execute(
inputs=[1, 2, 3],
outputs=[2, 4, 6],
code="def double(x): return x * 2",
language="python"
)
# Returns: [1, 1, 1] (auto-detects "answer" mode)
# Method 4: Simple execution
result = coex.execute(code="print('Hello, World!')", language="python")
# Returns: [1] (boolean indicating successful execution)
# Docker cleanup
coex.rm_docker() # Remove cached Docker containers
```
## Supported Languages
| Language | File Extension | Docker Image | Aliases |
|------------|----------------|---------------------|-------------------|
| Python | `.py` | `python:3.11-slim` | `py` |
| JavaScript | `.js` | `node:18-slim` | `js` |
| Java | `.java` | `openjdk:11-slim` | |
| C++ | `.cpp` | `gcc:latest` | `c++`, `cxx` |
| C | `.c` | `gcc:latest` | |
| Go | `.go` | `golang:1.19-slim` | |
| Rust | `.rs` | `rust:slim` | `rs` |
## API Reference
### `coex.execute()`
Execute code snippets in isolated Docker environments.
**Parameters:**
- `inputs` (List[Any], optional): List of input values for testing
- `outputs` (List[Any], optional): List of expected output values
- `code` (str, optional): Code to execute
- `answer_fn` (str, optional): Reference function code for comparison
- `language` (str, default="python"): Programming language
- `timeout` (int, optional): Execution timeout in seconds
- `mode` (str, optional): Execution mode ("answer" for input/output validation, "function" for function comparison, None for auto-detection)
**Returns:**
- `List[int]`: List of integers (0 or 1) indicating pass/fail for each test case
**Raises:**
- `SecurityError`: If dangerous code is detected
- `ValidationError`: If input validation fails
- `ExecutionError`: If code execution fails
- `DockerError`: If Docker operations fail
**New in v0.1.0:**
- **Explicit Mode Parameter**: Use `mode="answer"` or `mode="function"` for explicit execution modes
- **3-Second Timeout**: Each test case has a 3-second timeout limit
- **Unique File Naming**: Automatic unique file naming for batch processing support
### `coex.rm_docker()`
Remove all cached Docker containers.
**Parameters:** None
**Returns:** None
## Execution Modes
### 1. Input/Output Validation Mode
Test code against specific input/output pairs:
```python
inputs = [1, 2, 3, 4, 5]
outputs = [1, 4, 9, 16, 25]
code = """
def square(x):
return x * x
"""
result = coex.execute(inputs=inputs, outputs=outputs, code=code)
# Tests: square(1)==1, square(2)==4, square(3)==9, etc.
```
### 2. Function Comparison Mode
Compare two functions to see if they produce the same output:
```python
answer_fn = """
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
"""
code = """
def fibonacci(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a
"""
result = coex.execute(answer_fn=answer_fn, code=code)
# Compares if both functions return the same value
```
### 3. Simple Execution Mode
Execute code and check if it runs without errors:
```python
code = """
import math
print(f"Pi is approximately {math.pi:.2f}")
"""
result = coex.execute(code=code, language="python")
# Returns [1] if execution succeeds, [0] if it fails
```
## Security Features
coex includes comprehensive security protection:
### Blocked Operations
- File system operations (`rm`, `mkdir`, `chmod`, etc.)
- Network operations (`wget`, `curl`, `ssh`, etc.)
- System operations (`sudo`, `su`, etc.)
- Dangerous imports (`os`, `subprocess`, `sys`, etc.)
- Code evaluation (`eval`, `exec`, `__import__`, etc.)
### Example Security Protection
```python
dangerous_code = """
import os
os.system("rm -rf /") # This will be blocked!
"""
result = coex.execute(code=dangerous_code)
# Returns [0] - execution blocked for security
```
## Multi-Language Examples
### Python
```python
code = """
def greet(name):
return f"Hello, {name}!"
"""
result = coex.execute(code=code, language="python")
```
### JavaScript
```python
code = """
function greet(name) {
return `Hello, ${name}!`;
}
"""
result = coex.execute(code=code, language="javascript")
```
### Java
```python
code = """
public class Greeter {
public String greet(String name) {
return "Hello, " + name + "!";
}
}
"""
result = coex.execute(code=code, language="java")
```
### C++
```python
code = """
#include <iostream>
#include <string>
std::string greet(std::string name) {
return "Hello, " + name + "!";
}
"""
result = coex.execute(code=code, language="cpp")
```
## Configuration
### Environment Variables
- `COEX_DOCKER_TIMEOUT`: Docker operation timeout (default: 300 seconds)
- `COEX_DOCKER_MEMORY_LIMIT`: Container memory limit (default: "512m")
- `COEX_EXECUTION_TIMEOUT`: Code execution timeout (default: 30 seconds)
- `COEX_TEMP_DIR`: Temporary directory for files (default: "/tmp/coex")
- `COEX_DISABLE_SECURITY`: Disable security checks (default: False)
### Custom Configuration
```python
from coex.config.settings import settings
# Modify settings
settings.set("execution.timeout", 60)
settings.set("docker.memory_limit", "1g")
settings.set("security.enable_security_checks", False)
```
## Error Handling
coex provides comprehensive error handling:
```python
try:
result = coex.execute(code="invalid syntax", language="python")
except coex.SecurityError as e:
print(f"Security violation: {e}")
except coex.ValidationError as e:
print(f"Validation error: {e}")
except coex.ExecutionError as e:
print(f"Execution failed: {e}")
except coex.DockerError as e:
print(f"Docker error: {e}")
```
## Performance Tips
1. **Container Reuse**: Containers are cached automatically for better performance
2. **Batch Operations**: Process multiple test cases in single calls when possible
3. **Timeout Management**: Set appropriate timeouts for your use case
4. **Memory Limits**: Adjust memory limits based on your code requirements
5. **Cleanup**: Use `coex.rm_docker()` to clean up containers when done
## Development
### Running Tests
```bash
# Install development dependencies
pip install -e ".[dev]"
# Run all tests
pytest
# Run specific test categories
pytest tests/test_security.py -v
pytest tests/test_integration.py -v -m integration
# Run with coverage
pytest --cov=coex --cov-report=html
```
### Code Quality
```bash
# Format code
black coex/ tests/
# Lint code
flake8 coex/ tests/
# Type checking
mypy coex/
```
## Contributing
1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Make your changes
4. Add tests for your changes
5. Ensure all tests pass (`pytest`)
6. Commit your changes (`git commit -m 'Add amazing feature'`)
7. Push to the branch (`git push origin feature/amazing-feature`)
8. Open a Pull Request
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Changelog
### v0.1.0 (Initial Release)
- Docker-based code execution
- Multi-language support (Python, JavaScript, Java, C++, C, Go, Rust)
- Security protection against dangerous operations
- Input/output validation mode
- Function comparison mode
- Simple execution mode
- Comprehensive test suite
- Container caching for performance
- Robust error handling
## Support
- 📖 [Documentation](docs/)
- 🐛 [Issue Tracker](https://github.com/torchtorchkimtorch/coex/issues)
- 💬 [Discussions](https://github.com/torchtorchkimtorch/coex/discussions)
## Acknowledgments
- Docker for containerization technology
- The Python community for excellent tooling and libraries
- Contributors and testers who helped make this project possible
Raw data
{
"_id": null,
"home_page": "https://github.com/torchtorchkimtorch/coex",
"name": "coex",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "torchtorchkimtorch <mhkim092929@gmail.com>",
"keywords": "docker, code-execution, sandbox, security, multi-language, testing, validation",
"author": "torchtorchkimtorch",
"author_email": "torchtorchkimtorch <mhkim092929@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/c9/da/c0ca55b94bc9e0715294a1bb5b07e0733f2a2f2294e866553d120031f812/coex-0.1.19.tar.gz",
"platform": "any",
"description": "# coex - Code Execution Library\n\n[](https://www.python.org/downloads/)\n[](https://opensource.org/licenses/MIT)\n[](tests/)\n\n**coex** is a Python library that executes code snippets using subprocess calls on the host system. It provides secure, multi-language code execution with comprehensive validation and testing capabilities.\n\n## Features\n\n- **Host System Execution**: Uses subprocess to run language tools directly on the host\n- **Security First**: Protection against destructive file operations and malicious code\n- **Multi-Language Support**: Python, JavaScript, Java, C++, C, Go, Rust, and more\n- **Multiple Execution Modes**: Input/output validation, function comparison, simple execution\n- **High Performance**: Direct subprocess execution without container overhead\n- **Robust Error Handling**: Comprehensive error handling and timeout management\n- **Comprehensive Testing**: Extensive test suite with security and integration tests\n\n## Quick Start\n\n### Installation\n\n```bash\npip install coex\n```\n\n### Prerequisites\n\n- Python 3.8 or higher\n- Language tools installed on host system:\n - **Java**: `javac` and `java` (OpenJDK 8+ or Oracle JDK)\n - **JavaScript**: `node` (Node.js 14+)\n - **C/C++**: `gcc` and `g++` (GCC 7+)\n - **Go**: `go` (Go 1.16+)\n - **Rust**: `rustc` (Rust 1.50+)\n- Docker (optional, for sandboxed execution)\n\n### Basic Usage\n\n```python\nimport coex\n\n# Method 1: Input/Output validation (explicit mode)\nresult = coex.execute(\n mode=\"answer\",\n inputs=[0, 1, 2, 3],\n outputs=[1, 2, 3, 4],\n code=\"def add_one(x): return x + 1\",\n language=\"python\"\n)\n# Returns: [1, 1, 1, 1] (boolean array indicating pass/fail for each test case)\n\n# Method 2: Function comparison (explicit mode)\nresult = coex.execute(\n mode=\"function\",\n answer_fn=\"def say_hello(): return 'hello world'\",\n code=\"def hello(): return 'hello world'\",\n language=\"python\"\n)\n# Returns: [1] (boolean indicating if functions return same value)\n\n# Method 3: Backward compatibility (auto-detection)\nresult = coex.execute(\n inputs=[1, 2, 3],\n outputs=[2, 4, 6],\n code=\"def double(x): return x * 2\",\n language=\"python\"\n)\n# Returns: [1, 1, 1] (auto-detects \"answer\" mode)\n\n# Method 4: Simple execution\nresult = coex.execute(code=\"print('Hello, World!')\", language=\"python\")\n# Returns: [1] (boolean indicating successful execution)\n\n# Docker cleanup\ncoex.rm_docker() # Remove cached Docker containers\n```\n\n## Supported Languages\n\n| Language | File Extension | Docker Image | Aliases |\n|------------|----------------|---------------------|-------------------|\n| Python | `.py` | `python:3.11-slim` | `py` |\n| JavaScript | `.js` | `node:18-slim` | `js` |\n| Java | `.java` | `openjdk:11-slim` | |\n| C++ | `.cpp` | `gcc:latest` | `c++`, `cxx` |\n| C | `.c` | `gcc:latest` | |\n| Go | `.go` | `golang:1.19-slim` | |\n| Rust | `.rs` | `rust:slim` | `rs` |\n\n## API Reference\n\n### `coex.execute()`\n\nExecute code snippets in isolated Docker environments.\n\n**Parameters:**\n- `inputs` (List[Any], optional): List of input values for testing\n- `outputs` (List[Any], optional): List of expected output values\n- `code` (str, optional): Code to execute\n- `answer_fn` (str, optional): Reference function code for comparison\n- `language` (str, default=\"python\"): Programming language\n- `timeout` (int, optional): Execution timeout in seconds\n- `mode` (str, optional): Execution mode (\"answer\" for input/output validation, \"function\" for function comparison, None for auto-detection)\n\n**Returns:**\n- `List[int]`: List of integers (0 or 1) indicating pass/fail for each test case\n\n**Raises:**\n- `SecurityError`: If dangerous code is detected\n- `ValidationError`: If input validation fails\n- `ExecutionError`: If code execution fails\n- `DockerError`: If Docker operations fail\n\n**New in v0.1.0:**\n- **Explicit Mode Parameter**: Use `mode=\"answer\"` or `mode=\"function\"` for explicit execution modes\n- **3-Second Timeout**: Each test case has a 3-second timeout limit\n- **Unique File Naming**: Automatic unique file naming for batch processing support\n\n### `coex.rm_docker()`\n\nRemove all cached Docker containers.\n\n**Parameters:** None\n\n**Returns:** None\n\n## Execution Modes\n\n### 1. Input/Output Validation Mode\n\nTest code against specific input/output pairs:\n\n```python\ninputs = [1, 2, 3, 4, 5]\noutputs = [1, 4, 9, 16, 25]\ncode = \"\"\"\ndef square(x):\n return x * x\n\"\"\"\n\nresult = coex.execute(inputs=inputs, outputs=outputs, code=code)\n# Tests: square(1)==1, square(2)==4, square(3)==9, etc.\n```\n\n### 2. Function Comparison Mode\n\nCompare two functions to see if they produce the same output:\n\n```python\nanswer_fn = \"\"\"\ndef fibonacci(n):\n if n <= 1:\n return n\n return fibonacci(n-1) + fibonacci(n-2)\n\"\"\"\n\ncode = \"\"\"\ndef fibonacci(n):\n a, b = 0, 1\n for _ in range(n):\n a, b = b, a + b\n return a\n\"\"\"\n\nresult = coex.execute(answer_fn=answer_fn, code=code)\n# Compares if both functions return the same value\n```\n\n### 3. Simple Execution Mode\n\nExecute code and check if it runs without errors:\n\n```python\ncode = \"\"\"\nimport math\nprint(f\"Pi is approximately {math.pi:.2f}\")\n\"\"\"\n\nresult = coex.execute(code=code, language=\"python\")\n# Returns [1] if execution succeeds, [0] if it fails\n```\n\n## Security Features\n\ncoex includes comprehensive security protection:\n\n### Blocked Operations\n- File system operations (`rm`, `mkdir`, `chmod`, etc.)\n- Network operations (`wget`, `curl`, `ssh`, etc.)\n- System operations (`sudo`, `su`, etc.)\n- Dangerous imports (`os`, `subprocess`, `sys`, etc.)\n- Code evaluation (`eval`, `exec`, `__import__`, etc.)\n\n### Example Security Protection\n\n```python\ndangerous_code = \"\"\"\nimport os\nos.system(\"rm -rf /\") # This will be blocked!\n\"\"\"\n\nresult = coex.execute(code=dangerous_code)\n# Returns [0] - execution blocked for security\n```\n\n## Multi-Language Examples\n\n### Python\n```python\ncode = \"\"\"\ndef greet(name):\n return f\"Hello, {name}!\"\n\"\"\"\nresult = coex.execute(code=code, language=\"python\")\n```\n\n### JavaScript\n```python\ncode = \"\"\"\nfunction greet(name) {\n return `Hello, ${name}!`;\n}\n\"\"\"\nresult = coex.execute(code=code, language=\"javascript\")\n```\n\n### Java\n```python\ncode = \"\"\"\npublic class Greeter {\n public String greet(String name) {\n return \"Hello, \" + name + \"!\";\n }\n}\n\"\"\"\nresult = coex.execute(code=code, language=\"java\")\n```\n\n### C++\n```python\ncode = \"\"\"\n#include <iostream>\n#include <string>\n\nstd::string greet(std::string name) {\n return \"Hello, \" + name + \"!\";\n}\n\"\"\"\nresult = coex.execute(code=code, language=\"cpp\")\n```\n\n## Configuration\n\n### Environment Variables\n\n- `COEX_DOCKER_TIMEOUT`: Docker operation timeout (default: 300 seconds)\n- `COEX_DOCKER_MEMORY_LIMIT`: Container memory limit (default: \"512m\")\n- `COEX_EXECUTION_TIMEOUT`: Code execution timeout (default: 30 seconds)\n- `COEX_TEMP_DIR`: Temporary directory for files (default: \"/tmp/coex\")\n- `COEX_DISABLE_SECURITY`: Disable security checks (default: False)\n\n### Custom Configuration\n\n```python\nfrom coex.config.settings import settings\n\n# Modify settings\nsettings.set(\"execution.timeout\", 60)\nsettings.set(\"docker.memory_limit\", \"1g\")\nsettings.set(\"security.enable_security_checks\", False)\n```\n\n## Error Handling\n\ncoex provides comprehensive error handling:\n\n```python\ntry:\n result = coex.execute(code=\"invalid syntax\", language=\"python\")\nexcept coex.SecurityError as e:\n print(f\"Security violation: {e}\")\nexcept coex.ValidationError as e:\n print(f\"Validation error: {e}\")\nexcept coex.ExecutionError as e:\n print(f\"Execution failed: {e}\")\nexcept coex.DockerError as e:\n print(f\"Docker error: {e}\")\n```\n\n## Performance Tips\n\n1. **Container Reuse**: Containers are cached automatically for better performance\n2. **Batch Operations**: Process multiple test cases in single calls when possible\n3. **Timeout Management**: Set appropriate timeouts for your use case\n4. **Memory Limits**: Adjust memory limits based on your code requirements\n5. **Cleanup**: Use `coex.rm_docker()` to clean up containers when done\n\n## Development\n\n### Running Tests\n\n```bash\n# Install development dependencies\npip install -e \".[dev]\"\n\n# Run all tests\npytest\n\n# Run specific test categories\npytest tests/test_security.py -v\npytest tests/test_integration.py -v -m integration\n\n# Run with coverage\npytest --cov=coex --cov-report=html\n```\n\n### Code Quality\n\n```bash\n# Format code\nblack coex/ tests/\n\n# Lint code\nflake8 coex/ tests/\n\n# Type checking\nmypy coex/\n```\n\n## Contributing\n\n1. Fork the repository\n2. Create a feature branch (`git checkout -b feature/amazing-feature`)\n3. Make your changes\n4. Add tests for your changes\n5. Ensure all tests pass (`pytest`)\n6. Commit your changes (`git commit -m 'Add amazing feature'`)\n7. Push to the branch (`git push origin feature/amazing-feature`)\n8. Open a Pull Request\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n\n## Changelog\n\n### v0.1.0 (Initial Release)\n- Docker-based code execution\n- Multi-language support (Python, JavaScript, Java, C++, C, Go, Rust)\n- Security protection against dangerous operations\n- Input/output validation mode\n- Function comparison mode\n- Simple execution mode\n- Comprehensive test suite\n- Container caching for performance\n- Robust error handling\n\n## Support\n\n- \ud83d\udcd6 [Documentation](docs/)\n- \ud83d\udc1b [Issue Tracker](https://github.com/torchtorchkimtorch/coex/issues)\n- \ud83d\udcac [Discussions](https://github.com/torchtorchkimtorch/coex/discussions)\n\n## Acknowledgments\n\n- Docker for containerization technology\n- The Python community for excellent tooling and libraries\n- Contributors and testers who helped make this project possible\n",
"bugtrack_url": null,
"license": "MIT License\n \n Copyright (c) 2024 coex\n \n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n \n The above copyright notice and this permission notice shall be included in all\n copies or substantial portions of the Software.\n \n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n SOFTWARE.\n ",
"summary": "Execute code snippets in isolated Docker environments with multi-language support and security protection",
"version": "0.1.19",
"project_urls": {
"Bug Reports": "https://github.com/torchtorchkimtorch/coex/issues",
"Changelog": "https://github.com/torchtorchkimtorch/coex/blob/main/CHANGELOG.md",
"Documentation": "https://github.com/torchtorchkimtorch/coex#readme",
"Homepage": "https://github.com/torchtorchkimtorch/coex",
"Repository": "https://github.com/torchtorchkimtorch/coex"
},
"split_keywords": [
"docker",
" code-execution",
" sandbox",
" security",
" multi-language",
" testing",
" validation"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "dee7dc05adb3c6f965347f54fa6b7d151df44d489690bc9b6407716478ce9db3",
"md5": "c0b1402e08c3f4ba96fb7c8b085099ac",
"sha256": "bd61c4401bfa8fecc04507b5aea53416307f4c2f6a5302daa5428ab4dbf95cf0"
},
"downloads": -1,
"filename": "coex-0.1.19-py3-none-any.whl",
"has_sig": false,
"md5_digest": "c0b1402e08c3f4ba96fb7c8b085099ac",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 40323,
"upload_time": "2025-09-03T07:33:32",
"upload_time_iso_8601": "2025-09-03T07:33:32.963734Z",
"url": "https://files.pythonhosted.org/packages/de/e7/dc05adb3c6f965347f54fa6b7d151df44d489690bc9b6407716478ce9db3/coex-0.1.19-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "c9dac0ca55b94bc9e0715294a1bb5b07e0733f2a2f2294e866553d120031f812",
"md5": "bbff8080f25f186d8f5c99e4dc32061f",
"sha256": "af6b70c2b6c77f45d98e9bb33353a213c2c4d81d5a99bc024c3003246b66b7ce"
},
"downloads": -1,
"filename": "coex-0.1.19.tar.gz",
"has_sig": false,
"md5_digest": "bbff8080f25f186d8f5c99e4dc32061f",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 60569,
"upload_time": "2025-09-03T07:33:35",
"upload_time_iso_8601": "2025-09-03T07:33:35.604551Z",
"url": "https://files.pythonhosted.org/packages/c9/da/c0ca55b94bc9e0715294a1bb5b07e0733f2a2f2294e866553d120031f812/coex-0.1.19.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-09-03 07:33:35",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "torchtorchkimtorch",
"github_project": "coex",
"github_not_found": true,
"lcname": "coex"
}
