| Project | Description | Links |
|---|---|---|
| BEXY | Sandbox for executing generated code | GitHub · Docs |
| GetLLM | LLM model management and code generation | GitHub · PyPI · Docs |
| DevLama | Python code generation with Ollama | GitHub · Docs |
| LogLama | Centralized logging and environment management | GitHub · PyPI · Docs |
| APILama | API service for code generation | GitHub · Docs |
| JSLama | JavaScript code generation | GitHub · NPM · Docs |
| JSBox | JavaScript sandbox for executing code | GitHub · NPM · Docs |
| SheLLama | Shell command generation | GitHub · PyPI · Docs |
| WebLama | Web application generation | GitHub · Docs |
Tom Sapletta — DevOps Engineer & Systems Architect
- 💻 15+ years in DevOps, Software Development, and Systems Architecture
- 🏢 Founder & CEO at Telemonit (Portigen - edge computing power solutions)
- 🌍 Based in Germany | Open to remote collaboration
- 📚 Passionate about edge computing, hypermodularization, and automated SDLC
If you find this project useful, please consider supporting it:
A sandbox for safely running Python code in isolated environments. Bexy is part of the PyLama ecosystem and integrates with LogLama as the primary service for centralized logging and environment management.
- Code analysis for detecting dependencies
- Dependency management for automatic installation
- Python sandbox for running code in the current environment
- Docker sandbox for running code in isolated containers
- Interactive terminal menu for running examples (arrow keys + Enter)
- Utility functions for system information and execution results
- Integration with LogLama for centralized logging and environment management
- Structured logging with component context for better debugging and monitoring
# Install from PyPI
pip install bexy
# Or install locally in development mode
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
pip install -e . # This is important! Always install in development mode before starting
# Alternatively, use the Makefile
make setupIMPORTANT: Always run
pip install -e .before starting the project to ensure all dependencies are properly installed and the package is available in development mode.
from bexy import PythonSandbox, DockerSandbox
# Run code in the current Python environment
python_sandbox = PythonSandbox()
result = python_sandbox.run_code("""
import math
print(f'The square root of 16 is {math.sqrt(16)}')
""")
print(result)
# Run code in an isolated Docker container
docker_sandbox = DockerSandbox()
result = docker_sandbox.run_code("""
import platform
print(f'Running on {platform.system()}')
""")
print(result)Bexy includes a Makefile to simplify common development tasks:
# Set up the project (creates a virtual environment and installs dependencies)
make setup
# Run the API server (default port 8000)
make run
# Run the API server on a custom port
make run PORT=8080
# The run-port command is also available for backward compatibility
make run-port PORT=8080
# Run tests
make test
# Format code with black
make format
# Lint code with flake8
make lint
# Docker Testing
# Build Docker test images
make docker-build
# Run tests in Docker
make docker-test
# Start interactive Docker test environment
make docker-interactive
# Start Bexy mock service in Docker
make docker-mock
# Clean up Docker test resources
make docker-clean
# Clean up project (remove __pycache__, etc.)
make clean
# Show all available commands
make helpBexy includes a Docker-based testing infrastructure that allows you to run tests in isolated containers. This ensures consistent test environments 8000 and makes it easier to test integration with other components.
# Build the Docker test images
make docker-build
# Run all tests in Docker
make docker-test
# Start an interactive Docker test environment
make docker-interactive
# Start a Bexy mock service for integration testing
make docker-mock
# Clean up Docker test resources
make docker-cleanBexy is part of the PyLama ecosystem and can be tested together with other components using the main Makefile in the PyLama project root:
# From the PyLama project root
make docker-test-bexy # Run Bexy tests only
make docker-integration-test # Run integration tests across all componentsYou can use Bexy to safely run code from Python scripts (.py) or extract and run all Python code blocks from Markdown files (.md). This functionality is available both as a command-line tool and in the interactive menu.
python -m bexy.bexy_run script.py
python -m bexy.bexy_run README.md
python -m bexy.bexy_run README.md --docker- For
.pyfiles: the whole script is executed in a sandbox. - For
.mdfiles: all code blocks marked as ```python are extracted and executed one by one in isolation. - Add
--dockerto run code in an isolated Docker container.
Launch the menu:
bexyChoose "Uruchom kod z pliku .py lub .md" and follow the prompts to run any script or markdown code blocks, locally or in Docker.
Bexy is a sandbox system for safely running Python code from scripts or markdown, with support for dependency management and Docker isolation.
flowchart TD
A[User Input: .py/.md file] --> B{File Type?}
B -- .py --> C[Read Python file]
B -- .md --> D[Extract python code blocks]
C --> E[Choose Sandbox Type]
D --> E
E -- PythonSandbox --> F[Run code locally]
E -- DockerSandbox --> G[Run code in Docker]
F --> H[Collect Results]
G --> H
H --> I[Display Output]
+-------------------+
| User/CLI/Menu |
+--------+----------+
|
v
+--------+----------+
| bexy_run / menu |
+--------+----------+
|
v
+-------------------+
| File Handler |
| (.py/.md parser) |
+--------+----------+
|
v
+-------------------+
| Sandbox Layer |
| PythonSandbox |
| DockerSandbox |
+--------+----------+
|
v
+-------------------+
| Output/Reporter |
+-------------------+
- User selects file via CLI or menu.
- File Handler detects file type:
.py: reads the script..md: extracts all ```python code blocks.
- Sandbox Layer runs code using
PythonSandbox(local) orDockerSandbox(container). - Output/Reporter collects and displays results for each code block/script.
sequenceDiagram
participant U as User
participant P as bexy_run
participant F as FileHandler
participant S as Sandbox
participant O as Output
U->>P: Provide README.md
P->>F: Parse .md, extract python blocks
F->>S: Send code block to sandbox
S->>O: Return execution result
O->>U: Show output
loop for each block
F->>S: Next block
S->>O: Result
O->>U: Output
end
---
## Key Components
- **bexy_run**: CLI/utility for running code from files
- **examples.py**: Interactive menu, now integrates file execution
- **PythonSandbox/DockerSandbox**: Safe code execution layers
- **DependencyManager**: Handles required packages
- **Markdown Parser**: Extracts code blocks from `.md`
---
## Extending
- Add support for more file types (e.g., Jupyter).
- Enhance reporting (HTML, JSON output).
- Add block selection for markdown.
### Example
Suppose you have a Markdown file with:
```markdown
```python
print("Hello from markdown!")
Running `python -m bexy.bexy_run README.md` or using the interactive menu will execute the code above in a sandbox and print the results.
## Interactive Examples Menu
BEXY provides an interactive terminal menu for running usage examples. The menu allows you to navigate using arrow keys and select examples with Enter. Powered by the [`questionary`](https://github.com/tmbo/questionary) library.
### Running the interactive menu
You can start the interactive menu via the console script or directly:
```bash
# Using the installed entry point
bexy
# Or directly
python -m bexy.examples
Follow the on-screen menu to choose an example (e.g. CodeAnalyzer, DependencyManager, PythonSandbox, DockerSandbox, etc.).
The interactive menu requires questionary (installed automatically with BEXY 0.1.1+):
pip install questionaryApache License 2.0