semvec/pypi-packages huggingface dataset:
onc-toolbox 0.0.6
A toolbox for exploring Ocean Networks Canada data for the adventuring scientist.
Requires Python: >=3.10
Keywords: ONC

# onc-toolbox

onc-toolbox is a community-supported collection of Python code and notebooks for exploring data from Ocean Networks Canada. 


## Installation

You can install `onc-toolbox` using pip:

```
pip install onc-toolbox
```

## Examples
You can find example notebooks in the [examples](https://github.com/IanTBlack/onc-toolbox/tree/main/examples) directory of onc-toolbox.
torch-code-tracing 0.1.1
Code tracing for PyTorch models
Requires Python: >=3.10

# torch-code-tracing

[![PyPI - Version](https://img.shields.io/pypi/v/torch-code-tracing)](https://pypi.org/project/torch-code-tracing)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/torch-code-tracing)](https://pypistats.org/packages/torch-code-tracing)

Code trace your PyTorch model to understand its exexution and intermediate tensor shapes.

## Install

```sh
pip install git+https://github.com/justinchuby/torch-code-tracing.git
```

## Usage

```py
from torch_code_tracing import TracingMode

with TracingMode(succinct=True, color=True):
    out = model(*args, **kwargs)
```

```py
out = model(**example_kwargs)  # test.py:41 in <module>:
│ ⬇️
│ output = func(self, *args, **kwargs)  # site-packages/transformers/utils/generic.py:969 in wrapper:
│ │ ⬇️
│ │ inputs_embeds = self.get_input_embeddings()(llm_input_ids)  # site-packages/transformers/models/gemma3/modeling_gemma3.py:1175 in forward:
│ │ │ ⬇️
│ │ │ return super().forward(input_ids) * self.embed_scale.to(self.weight.dtype)  # site-packages/transformers/models/gemma3/modeling_gemma3.py:144 in forward:
│ │ │ │ # embedding(bf16[262208, 2560], i64[2, 3], 0) -> bf16[2, 3, 2560];
│ │ │ return super().forward(input_ids) * self.embed_scale.to(self.weight.dtype)  # site-packages/transformers/models/gemma3/modeling_gemma3.py:144 in forward:
│ │ │ │ # mul.Tensor(bf16[2, 3, 2560], bf16[]) -> bf16[2, 3, 2560];
│ │ cache_position = torch.arange(  # site-packages/transformers/models/gemma3/modeling_gemma3.py:1179 in forward:
│ │ │ # arange.start(30, 33, device=meta, pin_memory=False) -> i64[3];
│ │ causal_mask = self._update_causal_mask(  # site-packages/transformers/models/gemma3/modeling_gemma3.py:1205 in forward:
│ │ │ ⬇️
│ │ │ causal_mask = torch.full(  # site-packages/transformers/models/gemma3/modeling_gemma3.py:1050 in _update_causal_mask:
│ │ │ │ # full([3, 33], -3.3895313892515355e+38, dtype=torch.bfloat16, device=meta, pin_memory=False) -> bf16[3, 33];
│ │ │ causal_mask = torch.triu(causal_mask, diagonal=1)  # site-packages/transformers/models/gemma3/modeling_gemma3.py:1056 in _update_causal_mask:
│ │ │ │ # triu(bf16[3, 33], 1) -> bf16[3, 33];
...
```
jinja-layout 0.5.0
Extended layout system for Jinja
Requires Python: >=3.10

# Jinja Layout

Easier layouts for Jinja templates.

## Installation

    pip install jinja-layout

## Usage

The `jinja_layout.LayoutExtension` needs to be added to your environment:

    from jinja2 import Environment, PackageLoader

    env = Environment(loader=PackageLoader(__name__, 'templates'))
    env.add_extension('jinja_layout.LayoutExtension')

Jinja-layout introduces the `use_layout` directive. There are two
optional arguments:

 - a template name to extend from (default: "layout.html")
 - the name of the default block to override (default: "content")

You can change the default layout template using the `defaut_layout`
attribute on your environment and the default block name using
the `default_layout_block` attribute.

This directive is similar to Jinja's `extends` directive but does
not require the use of blocks. The content which is not used in
blocks, will be automatically wrapped in a block. The name of this
block is defined by the second argument of the directive.

## Example

Let's consider the following layout saved as *layout.html*:

    <html>
      <head>{% block head %}{% endblock %}</head>
      <body>{% block content %}{% endblock %}</body>
    </html>

Basic layout example:

    {% use_layout %}
    hello world

Overriding the header block:

    {% use_layout %}
    {% block head %}<title>example</title>{% endblock %}
    hello world

Using blocks all the way:

    {% use_layout %}
    {% block head %}<title>example</title>{% endblock %}
    {% block content %}hello world{% endblock %}
python4mini 0.1.1
Python4 MINI - Python with the addition of new functions to make life easier for programmers
Requires Python: >=3.7

# Python 4 MINI

Python 4 MINI is a version with added functions to make your life easier, including:

- Color prints (`say`, `csay`)
- Repetitions (`times`)
- Mathematical operations (`sum`, `sub`, `mul`, `div`, `perc`, `sqrt`)
- Text manipulation (`upper`, `lower`, `reverse`, `length`)
- Logic (`isEven`, `isOdd`, `greater`, `smaller`)
- HUDs (`border`, `banner`, `mirror`)
- Debug (`debug`, `typeOf`)

Usage example:

```python
from python4mini import say, csay, sum, sqrt

say("Hello World")
csay("Colored message", "red")
print(sum(1,2,3))
print(sqrt(16))
pufferlib-core 3.0.10
PufferLib core functionality with vectorized environments and reinforcement learning
Requires Python: >=3.8
Keywords: reinforcement-learning, machine-learning, multi-agent, vectorized-environments

# PufferLib Core

Minimal PufferLib core functionality with vectorized environments.

This package contains only the essential components:
- `spaces`: Observation/action space handling
- `emulation`: Environment compatibility layer for Gym/Gymnasium/PettingZoo
- `vector`: Vectorized environment implementations

For the full PufferLib with training capabilities and environments, see the main `pufferlib` package.

## Installation

### Basic Installation (Python-only)
```bash
pip install pufferlib-core
```

### Installation with C++/CUDA Extensions
To enable the `pufferlib._C` extensions (required for advanced features like CUDA advantage computation):

```bash
# First install torch
pip install torch

# Then install with extensions
PUFFERLIB_BUILD_EXT=1 pip install pufferlib-core[ext]
```

Or you can install the dependencies and build in separate steps:
```bash
# Install with extra dependencies
pip install pufferlib-core[ext]

# Then rebuild with extensions
PUFFERLIB_BUILD_EXT=1 pip install --upgrade --force-reinstall --no-deps pufferlib-core
```

## Usage

After installation with extensions, you should be able to import the C extensions:

```python
import pufferlib
from pufferlib import _C  # This will only work if extensions were built
```

## Development

To build extensions in development mode:
```bash
PUFFERLIB_BUILD_EXT=1 python setup.py build_ext --inplace
```