semvec/pypi-packages huggingface dataset:
sceneprogrenderer 0.1.2
A Renderer built for the SceneProg project
Requires Python: >=3.9

# SceneProgRenderer

**SceneProgRenderer** is a Python-based **Blender automation tool** for rendering scenes programmatically. It allows users to generate high-quality renders, including 360-degree animations, custom camera angles, and transparent background images using Blender’s Python API.

## 🚀 Features
- **Scene Loading & Setup**
  - Clears the scene and loads a new `.blend` file.
  - Applies smooth shading and fixes materials.
  - Adds an environment texture for realistic lighting.

- **Rendering Options**
  - **Single Render**: Capture an image from a specified camera position.
  - **Front/Top Views**: Render images from standard viewpoints.
  - **Corner Views**: Automatically position the camera at four scene corners.
  - **Edge Midpoints**: Position the camera at four upper midpoints of the scene.
  - **360-Degree Animation**: Generate a rotating video render.

- **Supports Transparent Backgrounds**
  - Renders images with **RGBA** and **film transparency** for compositing.

## 📦 Installation
```bash
pip install sceneprogrenderer
```

## 📜 Usage

Importing the package:
```python
from sceneprogrenderer import SceneProgRenderer
```
### Initializing the Renderer
```python
renderer = SceneProgRenderer(
    resolution_x=1920,
    resolution_y=1080,
    samples=128,
    frame_rate=30,
    num_frames=360,
    cuda=False,
    verbose=False,
)
```
### Generic Render
```python
renderer.render(
  path="scene.blend",
  output_path="output.png",
  location=(2, 2, 2),       ## Camera location
  target=(0, 0, 0),         ## Target location
)
```

### Render from corners or edge midpoints
```python
renderer.render_from_corners(
  path="scene.blend",
  output_paths=["corner1.png", "corner2.png", "corner3.png", "corner4.png"],
)

renderer.render_from_edge_midpoints(
  path="scene.blend",
  output_paths=["edge1.png", "edge2.png", "edge3.png", "edge4.png"],
)
```

### Render from front or top views
```python
renderer.render_from_front_view(
  path="scene.blend",
  output_path="front_view.png",
)

renderer.render_from_top_view(
  path="scene.blend",
  output_path="top_view.png",
)
```

### Render 360-degree animation
```python
renderer.render_360_animation(
  path="scene.blend",
  output_path="360_animation.mp4",
)
```
ansi-stdio 0.0.2
ANSI text animation library
Requires Python: >=3.10

# 🖼️ ansi stdio

Terminal text composition and animation library.

```sh
$ uvx ansi_stdio
```

## Tools

* `ansi-quantize` - terminal filter to help you strip out log dump noise from
  asciinema recordings. Currently doesn't do a very good job of it, due to
  not having char-level diffs.
* `ansi-fonts` - lists available monospace fonts on the system.

## Design

The thing is a scene graph made of Actor nodes. Each node has a clock and when
rendered, can redirect calls. Haven't decided how child relationships and
recursion will work yet, so keeping this open. Probably won't call them actors
either.

Clocks are chained timers that can be paused and implement time however they
like. `clock.wall` gives you the system time. `Clock.time` gives the current
time etc.

Buffers are sparse grids of `rich` characters. They track their own size and
can be merged (`+=` and `+`), queried/set (slice notation) and copied.

### Object design

So far we have:

* 🔢 Versioned - objects that are versioned have a version number that gets
  updated when they are changed.
* 📦 Box - a 2d box, used for bounding things.
* ⏲️ Clock - the workhorse of animation.

Still not figured out:

* 💾 Saved - a serializable class.
* 🎞️ The main actor class - is it a View?
* How buffers, views and time work together with caching.
* Should "Animation" be a buffer?

## Overall plan

* Build a custom video format with keyframes and delta frames/buffers. This can
  act as a cache and a rendering format. The encoder can then be used to
  capture terminal graphics from various sources, including text files,
  programs or other loaders.
* Build serialization into the core objects via a generic mixin. The
  construction parameters will be attribute names by convention, so they can
  always be (de)serialized.
* Once the foundations are laid, build in structure for working with a vast
  library of effects, sources and so on, and filtering it effectively. So we
  don't end up constrained, with everything dumped in a directory, and can
  compose the different things in various ways.
* Make a plugin system for all these things.
* Build a basic UI that works with this, somewhere between Kdenlive and OBS
  Studio.
* Go to town building components that are useful. Idea being to use code
  generation within the confines of a decent structure, so using AI to add
  to it doesn't end up like a Glastonbury Festival toilet.

## Next Steps

* Finish the Saved class, figure out how it relates to Versioned.
* Figure out animation buffers, how they map to buffers, accumulate and can
  be rendered.
* Implement a recorder using the above.
* Figure out how to convert ANSI text into animations when it has no timing
  info (callbacks that look for cursor movements and/or screen resets).
* Start work on the UI

## Links

* [🏠 home](https://bitplane.net/dev/python/ansi-stdio)
* [🐈 github](https://github.com/bitplane/ansi-stdio)
* [🐍 pypi](https://pypi.org/project/ansi-stdio)
* [📖 pydoc]((https://bitplane.net/dev/python/ansi-stdio/pydoc)