semvec/pypi-packages huggingface dataset:
ezmsg-neo 0.4.0
Load and stream data from neo files into ezmsg.
Requires Python: >=3.10.15

# ezmsg-neo

Load and stream data from [neo](https://github.com/NeuralEnsemble/python-neo) files into [ezmsg](https://github.com/ezmsg-org/ezmsg).

## Installation

`pip install ezmsg-neo`

Or install the latest development version:

`pip install git+https://github.com/ezmsg-org/ezmsg-neo@dev`

### Dependencies

* [`ezmsg`](https://github.com/ezmsg-org/ezmsg)
* [`neo`](https://neo.readthedocs.io/)
* [`sparse`](https://sparse.pydata.org/)

## Usage

ezmsg-neo modules are available under `import ezmsg.neo`

Add the `NeoIteratorUnit` to your ezmsg graph as a data source. You may be interested in other ezmsg extensions for processing the data, such as [`ezmsg-sigproc`](https://github.com/ezmsg-org/ezmsg-sigproc) and [`ezmsg-event`](https://github.com/ezmsg-org/ezmsg-event).

```python
import ezmsg.core as ez
from ezmsg.neo.source import NeoIteratorUnit
from ezmsg.util.messages.key import FilterOnKey
from ezmsg.util.debuglog import DebugLog
from ezmsg.event.rate import EventRate


comps = {
    "NEO": NeoIteratorUnit(filepath="path/to/file", chunk_dur=0.05),
    "FILTER": FilterOnKey(key="spike"),
    "RATE": EventRate(bin_duration=0.05),
    "LOG": DebugLog()  # Print the output to the console
}
conns = (
    (comps["NEO"].OUTPUT_SIGNAL, comps["FILTER"].INPUT_SIGNAL),
    (comps["FILTER"].OUTPUT_SIGNAL, comps["RATE"].INPUT_SIGNAL),
    (comps["RATE"].OUTPUT_SIGNAL, comps["LOG"].INPUT),
)
ez.run(components=comps, connections=conns)

```

### Standalone

The ``NeoIterator`` class can be used outside ezmsg for offline processing:

```python
from ezmsg.neo.source import NeoIterator, NeoIteratorSettings
from ezmsg.util.messages.axisarray import AxisArray

settings = NeoIteratorSettings(filepath="data.nev", chunk_dur=0.05)
neo_iter = NeoIterator(settings)

# Filter messages by key (e.g., "ns3" for analog signals, "spike" for spikes)
sig_msgs = [msg for msg in neo_iter if msg.key.startswith("ns")]

# Concatenate all chunks into a single AxisArray
full_signal = AxisArray.concatenate(*sig_msgs, dim="time")
```

### NeoIterator Messages

The `NeuoIteratorUnit` and `NeoIterator` objects, when called, return `AxisArray` messages with a `key` attribute identifying the signal type:

* **Analog signals** - Key matches the stream name (e.g., `"ns3"`). Data shape: `(n_samples, n_channels)`
* **Spike trains** - Key is `"spike"`. Data is a sparse array with shape `(n_units, n_samples)`
* **Events** - Key is `"events"`. Data contains event labels and its `time` axis is irregular (`CoordinateAxis`) with timestamps associated with each event.

## Development

1. Clone this repo and `cd` into it
2. `uv sync` to setup your environment
3. `uv run pytest tests` to run the tests
4. (Optional) Install pre-commit hooks: `uv run pre-commit install`
auditize 0.10.0
Empower your functional logs
Requires Python: >=3.12

![Auditize](https://raw.githubusercontent.com/auditize/auditize/refs/heads/master/misc/logo.svg)

# Auditize: Empower your functional logs

Auditize aims to deliver powerful audit log management capabilities to your software without the burden of developing an in-house solution.

It is a backend & frontend solution based on [Python](https://www.python.org/), [FastAPI](https://fastapi.tiangolo.com/), [React](https://react.dev/), [PostgreSQL](https://www.postgresql.org/) and [Elasticsearch](https://www.elastic.co/elasticsearch/).

Please check the [documentation](https://auditize.org) for more information about features, installation, and usage.

Auditize is licensed under the [Apache License](https://github.com/auditize/auditize/blob/master/LICENSE.txt).
TabulAIrity 1.1.0
Chat network based interrogation of unstructured text
Requires Python: >=3.8

# Tabulairity

Slide Deck:
[Slide Deck](https://docs.google.com/presentation/d/1A5SZgjTdp4PyHzKldXnDUMtvnwshi2Yv1uGauso26ZQ)
configparser_rb 1.0.0
Config parser with the ability to obfuscate keys with rotated bits in base64
Requires Python: <4,>=3.9

# configparser_rb
Config parser with the ability to obfuscate keys 

## Write config file

```python
    from configparser_rb import ConfigParserRB

    config=ConfigParserRB("config.ini")
    config.set("Features", "string", "Hi")
    config.set("Features", "boolean", True)
    config.set("Features", "integer", 1)
    config.set("Features", "float", 1.1)
    config.set("Features", "list of strings", ["a", "b"])
    config.set("Features", "list of integers", [1, 2])
    config.set("Features", "decimal", "12.234")
    config.cset("Features", "cstring", "Hi")
    config.save()
    

```


You get

```ini
[Features]
string = Hi
boolean = True
integer = 1
float = 1.1
list of strings = 'a', 'b'
list of integers = 1, 2
decimal = 12.234
cstring = kNI=

```

## Read config file
```python
    config=ConfigParserRB("config.ini")
    assert config.cget("Features", "cstring") == "Hi"
    assert config.get("Features", "string") == "Hi"
    assert config.getBoolean("Features", "boolean") == True
    assert config.getInteger("Features", "integer") == 1
    assert config.getFloat("Features", "float") == 1.1
    assert config.getListOfIntegers("Features", "list of integers") == [1, 2]
    assert config.getList("Features", "list of strings") == ["a", "b"]
    assert config.getDecimal("Features", "decimal") == Decimal("12.234")
```
vaas 0.1.7
VAAS (Vision-Attention Anomaly Scoring) is a dual-module vision framework for image anomaly detection and localisation.
Requires Python: >=3.10

# VAAS — Vision-Attention Anomaly Scoring

VAAS (Vision-Attention Anomaly Scoring) is an inference-focused Python library for image anomaly detection and localisation.

It combines global attention-based reasoning with patch-level consistency analysis to produce a continuous anomaly score alongside dense anomaly maps. The output is designed to be interpretable, spatially grounded, and suitable for research and prototyping workflows.

This package provides the **runtime inference pipeline only**.
Pretrained model weights and research assets are hosted separately.

---

## Installation

Install the VAAS inference library from PyPI:

```bash
pip install vaas
```

### Optional dependency: PyTorch

VAAS uses **lazy loading** for PyTorch.

* Importing `vaas` does **not** require PyTorch
* PyTorch is required **only when running inference**

If PyTorch is not installed, VAAS will raise a clear runtime error when inference is invoked.

To install PyTorch (CPU, CUDA, or ROCm), follow the official guide:
[https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)

---

## Quick Start

```python
from vaas.inference.pipeline import VAASPipeline
from PIL import Image

pipeline = VAASPipeline.from_pretrained(
    "OBA-Research/vaas-v1-df2023",
    device="cpu",
    alpha=0.5,
)

image = Image.open("image.jpg").convert("RGB")
result = pipeline(image)

print(result["S_H"])
```

### Output format

```python
{
    "S_F": float,
    "S_P": float,
    "S_H": float,
    "anomaly_map": numpy.ndarray  # shape (224, 224)
}
```

---

## Visualisation

VAAS can optionally generate qualitative visual explanations combining:

* Patch-level anomaly heatmaps
* Global attention overlays
* A hybrid anomaly score gauge

```python
pipeline.visualize(
    image="image.jpg",
    save_path="vaas_visualization.png",
    mode="all",
    threshold=0.5,
)
```

---

## Model Variants

This release supports pretrained models hosted on Hugging Face.

Example:

* VAAS v1 — trained on 10% of DF2023

Additional variants and future releases may extend training scale and evaluation coverage.

---

## Intended Use

VAAS is intended for:

* Image anomaly detection
* Visual integrity assessment
* Explainable inspection of irregular regions
* Research on attention-based anomaly scoring
* Prototyping anomaly-aware vision systems

The library supports CPU-only inference and GPU acceleration when available.

---

## Limitations

* Trained on a subset of a single dataset
* Does not classify anomaly types
* Performance may degrade on out-of-distribution imagery

VAAS should not be used as a standalone decision-making system in high-stakes applications.

---

## License

MIT License

---

## Maintainers

OBA-Research
- [https://github.com/OBA-Research](https://github.com/OBA-Research)
- [https://huggingface.co/OBA-Research](https://huggingface.co/OBA-Research)
hack4u-kebris-c-tools 0.1.0
A library to list courses from Hack4u web

# Hack4u Academy Courses Library

A library to list courses from Hack4u academy web.

## Courses available:

- Introducción a Linux [15 horas]
- Personalización de Entornos en Linux [3 horas]
- Python Ofensivo [35 horas]
- Introducción al Hacking [53 horas]
- Hacking Web [51 horas]

## Installation

Install with 'pip3':

```python3
pip3 install hack4u-kebris-c-tools
```

## Usage

### List courses:

```python3
from hack4u-kebris-c-tools import list_courses

for course in courses:
    print(course)
```

### Get course by name:

```python3
from hack4u-kebris-c-tools import get_course_by_name

course = get_course_by_name("Introducción al Hacking")
print(course)
```

### Calculate total duration of all the courses on Hack4u academy web

```python3
from hack4u-kebris-c-tools.utils import total_duration

print(f"Total duration: {total_duration()} hours")
```

### To use all utilities

```python3
from hack4u-kebris-c-tools import *
```
neopia 0.4.0
Python library for NEOPIA Neobot
Requires Python: >=3.8
Keywords: neopia, neobot, neosoco

# Python library for Neopia neobot (NEO SoCo)

## Overview
Part of the RoboticsWare project - https://roboticsware.uz
Copyright (C) 2022 RoboticsWare (neopia.uz@google.com)

Currently support NEO SoCo only

## Installation
``pip install -U neopia``

## API documentation
Refer to the [Wiki](https://github.com/roboticsware/pylib_neobot/wiki)