semvec/pypi-packages huggingface dataset:
ontolocy 0.9.3
A Python package for modeling cybersecurity data in a Neo4j graph database.
Requires Python: >=3.9

# Ontolocy

An open source cyber security graph ontology.

Use Python and Neo4j to explore cyber security data as a graph.

Currently in alpha/proof-of-concept stage - the ontology is likely to change (there may be breaking changes between minor releases).

> "All models are wrong, but some are useful" - George Box

Read the [docs](https://ontolocy.readthedocs.io/)

## Built with Ontolocy

- [Ontolocy Explore](https://explore.ontolocy.com/)

## Quick Start

### Install Ontolocy

```bash
pip install ontolocy
```

### Setup Neo4j Connection Details

Put info in a local `.env` file.

```txt
# .env
NEO4J_URI=neo4j://localhost:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=Neo4jPassword

NEO4J_AUTH=neo4j/Neo4jPassword      # If running Neo4j with Docker
```

### Import MITRE ATT&CK Data into Neo4j

```bash
ontolocy parse mitre-attack
```
malbolge 0.1.0
Simple Malbolge(https://en.wikipedia.org/wiki/Malbolge) interpreter in python with debugger
Requires Python: >=3.8

# pyMalbolge

This is a fork from https://github.com/Avantgarde95/pyMalbolge

Simple [Malbolge](https://en.wikipedia.org/wiki/Malbolge) interpreter in Python with built-in debugger.

## Installation

```bash
# Basic installation
pip install malbolge

# With TUI debugger support
pip install malbolge[tui]
```

## Usage

### Command Line

![TUI Debugger Screenshot](screenshots/cli.png)

```bash
# Run a Malbolge program
python3 -m malbolge hello.mal

# Run with input (for programs that read stdin, like cat.mal)
python3 -m malbolge cat.mal -i "Hello World"

# Start CLI debugger
python3 -m malbolge.debug_cli hello.mal

# Start CLI debugger with input
python3 -m malbolge.debug_cli cat.mal -i "Hello World"

# Start TUI debugger (requires textual)
python3 -m malbolge.debug_tui hello.mal

# Start TUI debugger with input
python3 -m malbolge.debug_tui cat.mal -i "Hello World"
```

### Python API

```python
from malbolge import eval

# Hello World
eval('''(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc''')
# Output: Hello World!

# Cat program with input
eval('''(=BA#9"=<;:3y7x54-21q/p-,+*)"!h%B0/.~P<<:(8&66#"!~}|{zyxwvugJ%''', "abc123")
# Output: abc123
```

### Debugger API

```python
from malbolge import MalbolgeDebugger

# Create debugger instance
dbg = MalbolgeDebugger(source_code, input_data)

# Set breakpoints
dbg.add_breakpoint(10)

# Step execution
state = dbg.step()      # Execute one instruction
state = dbg.step_back() # Undo last instruction
state = dbg.run()       # Run until breakpoint

# Inspect state
print(dbg.registers)    # {'a': 0, 'c': 5, 'd': 45}
print(dbg.output)       # Program output so far
print(dbg.disassemble(0, 10))  # Disassemble instructions
```

## Debugger

### CLI Debugger

Interactive command-line debugger similar to GDB.

```
(maldbg) break 10       # Set breakpoint at address 10
(maldbg) run            # Run until breakpoint
(maldbg) step 5         # Step 5 instructions
(maldbg) back 2         # Step back 2 instructions
(maldbg) examine 0 20   # Examine memory at address 0
(maldbg) disassemble    # Show disassembly
(maldbg) registers      # Show register values
(maldbg) output         # Show program output
(maldbg) help           # Show all commands
```

### TUI Debugger

Visual terminal-based debugger with split-screen interface.

![TUI Debugger Screenshot](screenshots/tui.png)

**Keybindings:**
- `↓` - Step one instruction
- `↑` - Step back
- `r` - Run until breakpoint
- `b` - Toggle breakpoint at current address
- `←` / `→` - Scroll memory view left/right
- `0` - Reset memory scroll to D pointer
- `h` / `?` - Show help
- `q` - Quit

## Changes from Original

### Fixed
- Integer division syntax (Python 3 compatibility)

### Added
- `eval()` function for inline evaluation
- Full-featured debugger with:
  - Breakpoints and watchpoints
  - Step-by-step execution
  - Step back (execution history)
  - Memory inspection
  - Disassembly view
  - CLI and TUI interfaces

## TODO
- Support Malbolge20 and Malbolge Unshackled
- A simple Malbolge compiler/generator

## License

MIT
tdlib3d 1.0.0
A lightweight 3D rendering library for Python
Requires Python: >=3.8

# 3Dlib (tdlib) 🦆
A lightweight, hardware-accelerated 3D rendering library for Python built on ModernGL and Pygame.

## Features
- **Fast Rendering**: Uses ModernGL for low-level GPU access.
- **Universal Loading**: Support for `.obj`, `.stl`, `.glb`, and more via `trimesh`.
- **Lighting**: Built-in Phong shading (Ambient + Diffuse).
- **Textures**: Easy PNG/JPG texture mapping.
- **Simple API**: Designed to get you rendering in under 50 lines of code.

Code be like:
import tdlib
from pyrr import Matrix44
import pygame

# 1. Initialize the Engine
engine = tdlib.Renderer(width=800, height=600)

# 2. Load a 3D Model
# Supports .obj, .glb, .stl
model = tdlib.load_resource(engine, "assets/duck.obj", texture_path="assets/duck_diffuse.png")

# 3. Main Render Loop
angle = 0
while True:
    engine.clear() # Clears the screen
    angle += 0.01

    # Define Camera and Transformation
    model_matrix = Matrix44.from_y_rotation(angle)
    view_matrix = Matrix44.look_at((3, 3, 3), (0, 0, 0), (0, 1, 0))
    proj_matrix = Matrix44.perspective_projection(45.0, 800/600, 0.1, 100.0)
    mvp = proj_matrix * view_matrix * model_matrix

    # Draw the object
    engine.render_object(model, mvp, model_matrix, light_pos=[5, 5, 5])

    pygame.display.flip()