semvec/pypi-packages huggingface dataset:
virtual-camera 1.1.0
Virtual Camera

# Virtual Camera

## Install
```bash
pip install virtual_camera
```

## Instructions
### Coordinate systems
| STYLE     | X-Y-Z              |
| :-------: | :-----------------:|
| MOTOVIS   | right-forward-up   |
| openGL    | right-up-backward  |
| camera    | right-down-forward |
| pytorch3d | left-up-forward    |

### Create virtual cameras
Following are default virtual camera setups.
```python
VCAMERA_PERSPECTIVE_FRONT = create_virtual_perspective_camera((1280, 960), (-90, 0, 0), (0, 1.5, 1.5))
VCAMERA_PERSPECTIVE_FRONT_LEFT = create_virtual_perspective_camera((1280, 960), (-90, 0, 45), (-1, 2, 1))
VCAMERA_PERSPECTIVE_FRONT_RIGHT = create_virtual_perspective_camera((1280, 960), (-90, 0, -45), (1, 2, 1))
VCAMERA_PERSPECTIVE_BACK = create_virtual_perspective_camera((1280, 960), (-90, 0, 180), (0, -1, 1))
VCAMERA_PERSPECTIVE_BACK_LEFT = create_virtual_perspective_camera((1280, 960), (-90, 0, 135), (-1, 2, 1))
VCAMERA_PERSPECTIVE_BACK_RIGHT = create_virtual_perspective_camera((1280, 960), (-90, 0, -135), (1, 2, 1))

VCAMERA_FISHEYE_FRONT = create_virtual_fisheye_camera((1024, 640), (-120, 0, 0), (0, 3.5, 0.5))
VCAMERA_FISHEYE_LEFT = create_virtual_fisheye_camera((1024, 640), (-135, 0, 90), (-1, 2, 1))
VCAMERA_FISHEYE_RIGHT = create_virtual_fisheye_camera((1024, 640), (-135, 0, -90), (1, 2, 1))
VCAMERA_FISHEYE_BACK = create_virtual_fisheye_camera((1024, 640), (-120, 0, 180), (0, -1, 0.5))
```

### Convert from a real image
```python
import yaml
import virtual_camera as vc
```
1. Initialize the a camera from a real image and its calibration file.
```python
yaml_file = 'data/calibration.yml'
cfg = yaml.safe_load(open(yaml_file, 'r'))
camera_real = vc.FisheyeCamera.init_from_motovis_cfg(cfg)
```
2. Read the real image.
```python
src_image = plt.imread('data/src_image.jpg')
```
3. Convert the image to a virtual image. Alongside with mask.
```python
dst_image, mask = vc.render_image(src_image, camera_real, vc.VCAMERA_PERSPECTIVE_FRONT)
```
stream-zip 0.0.84
Python function to construct a ZIP archive with stream processing - without having to store the entire ZIP in memory or disk
Requires Python: >=3.6.7

<!-- --8<-- [start:intro] -->
# stream-zip

[![Debian (unstable) package](https://img.shields.io/debian/v/python3-stream-zip/sid?label=Debian%20%28unstable%29)](https://packages.debian.org/sid/python3-stream-zip) [![conda-forge package](https://img.shields.io/conda/v/conda-forge/stream-zip?label=conda-forge&color=%234c1)](https://anaconda.org/conda-forge/stream-zip) [![PyPI package](https://img.shields.io/pypi/v/stream-zip?label=PyPI%20package&color=%234c1)](https://pypi.org/project/stream-zip/) [![Test suite](https://img.shields.io/github/actions/workflow/status/uktrade/stream-zip/test.yml?label=Test%20suite)](https://github.com/uktrade/stream-zip/actions/workflows/test.yml) [![Code coverage](https://img.shields.io/codecov/c/github/uktrade/stream-zip?label=Code%20coverage)](https://app.codecov.io/gh/uktrade/stream-zip)

Python function to construct a ZIP archive on the fly - without having to store the entire ZIP in memory or disk. This is useful in memory-constrained environments, or when you would like to start returning compressed data before you've even retrieved all the uncompressed data. Generating ZIPs on-demand in a web server is a typical use case for stream-zip.

Offers similar functionality to [zipfly](https://github.com/BuzonIO/zipfly), but with a different API, and does not use Python's zipfile module under the hood. Creates both Zip32/2.0/Legacy and Zip64 files.
<!-- --8<-- [end:intro] -->

To unZIP files on the fly try [stream-unzip](https://github.com/uktrade/stream-unzip).

<!-- --8<-- [start:features] -->
## Features

In addition to being memory efficient (with some [limitations](https://stream-zip.docs.trade.gov.uk/get-started/limitations/)) stream-zip:

- Constructs ZIP files that can be stream unzipped, for example by [stream-unzip](https://stream-unzip.docs.trade.gov.uk/)

- Can construct Zip64 ZIP files. Zip64 ZIP files allow sizes far beyond the approximate 4GiB limit of the original ZIP format

- Can construct ZIP files that contain symbolic links

- Can construct ZIP files that contain directories, including empty directories

- Can construct password protected / AES-256 encrypted ZIP files adhering to the [WinZip AE-2 specification](https://www.winzip.com/en/support/aes-encryption/).

- Allows the specification of permissions on the member files and directories (although not all clients respect them)

- By default stores modification time as an extended timestamp. An extended timestamp is a more accurate timestamp than the original ZIP format allows

- Provides an async interface (that uses threads under the hood)

<!-- --8<-- [end:features] -->

---

Visit the [stream-zip documentation](https://stream-zip.docs.trade.gov.uk/) for usage instructions.
dishka-flet 0.0.4
Integration package for Dishka DI and Flet framework
Requires Python: >=3.10

# Flet integration for Dishka

[![Downloads](https://static.pepy.tech/personalized-badge/dishka-flet?period=month&units=international_system&left_color=grey&right_color=green&left_text=downloads/month)](https://www.pepy.tech/projects/dishka-flet)
[![Package version](https://img.shields.io/pypi/v/dishka-flet?label=PyPI)](https://pypi.org/project/dishka-flet)
[![Supported Python versions](https://img.shields.io/pypi/pyversions/dishka-flet.svg)](https://pypi.org/project/dishka-flet)

Though it is not required, you can use *dishka-flet* integration. It features:

* *REQUEST* scope management using sessions
* *APP* scope management using sessions
* *FletProvider* for working with `Page` in container

You need to specify `@inject` manually.

## Installation

Install using `pip`

```sh
pip install dishka-flet
```

Or with `uv`

```sh
uv add dishka-flet
```

## How to use

1. Import

```python
from dishka_flet import (
    FromDishka,
    inject,
    setup_dishka
)
from dishka import make_async_container, Provider, provide, Scope
```

2. Create provider like here below

```python
class MyProvider(Provider):
    @provide(scope=Scope.REQUEST)
    def get_greeting_service(self) -> GreetingService:
        return GreetingService(name="Dishka User")

    @provide(scope=Scope.APP)
    def get_counter_service(self) -> CounterService:
        return CounterService()
```

3. Mark those of your handlers parameters which are to be injected with `FromDishka[]`

```python
@inject
async def button_clicked(
        event: ft.ControlEvent,
        greeting: FromDishka[GreetingService],
        counter: FromDishka[CounterService],
) -> None:
    ...
```

4. Setup `dishka` integration.

```python
setup_dishka(container=container, page=page)
```
cirm-odm 0.1.9
ODM models for CVE, CWE, and CPE management
Requires Python: >=3.8

[![Python CI](https://github.com/cybersecurity-srl/cirm-odm/actions/workflows/CI.yml/badge.svg)](https://github.com/cybersecurity-srl/cirm-odm/actions/workflows/CI.yml)


**CIRM ODMs**

**CIRM ODMs** is a Python package developed by **CyberSecurity S.r.l.** to centralize and validate data models used in the **CIRM** project — a framework for managing cyber risk, with a specific focus on software vulnerability management.

This package contains all the **Object Document Mappers (ODMs)** built with [Pydantic](https://docs.pydantic.dev/) and Beanie, designed to work with [MongoDB](https://www.mongodb.com/) and ensure reliable, strongly-typed data validation.

The goal is to support internal use within the CIRM ecosystem, while also making the models publicly available for reuse in other CyberSecurity-related projects.

---

## Project Context

The **CIRM** (Continuous Improvement Risk Management) platform automates the handling of software vulnerabilities by integrating:

- **Official data sources** such as the [National Vulnerability Database (NVD)](https://nvd.nist.gov/), which provides CVE records, CWE categorizations, and CPE identifiers.
- **AI models** for automatically predicting important parameters, such as:
  - CVSS scores (vulnerability severity),
  - CWE classes (weakness types),
  - Affected CPEs (platforms or software).

The extracted and predicted data is stored in a **MongoDB** database and validated through the Pydantic/Beanie models provided in this package.

---

## Package Features

- ODMs for CVE, CWE, and CPE entities
- MongoDB-compatible schemas
- Automatic data validation
- Modern packaging with `pyproject.toml` and [Flit](https://flit.pypa.io/)

---

## Technology Stack

- **Python**
- **Pydantic** / **Beanie**
- **Flit** for packaging and publishing
- Central configuration via **pyproject.toml**

---

## Project Structure

```txt
.
├── .github/workflows/         # GitHub Actions for build & publish
├── .devcontainer/             # VSCode DevContainer setup
│   ├── Dockerfile
│   └── devcontainer.json
├── .vscode/settings.json      # Project-specific VSCode settings
├── src/                       # Source code of the package
├── tests/                     # Unit tests for ODMs
├── pyproject.toml             # Project metadata and config
└── README.md                  # Project documentation
```

## Installation

Once published to PyPI:

```bash
pip install cirm-odm
```
pybgpkitstream 0.4.0
Drop-in replacement for PyBGPStream using BGPKIT
Requires Python: >=3.10

# PyBGPKITStream

A drop-in replacement for PyBGPStream using BGPKIT

## Features

- Generates time-ordered BGP messages on the fly from RIBs and updates MRT files of multiple collectors
- Stream the same BGP messages as PyBGPStream, enabling seamless, drop-in replacement
- Lazy loading consumes minimal memory, making it suitable for large datasets
- Multiple BGP parsers supported: `pybgpkit` (default but slow), `bgpkit-parser`, `bgpdump` and `pybgpstream` single file backend (the latter three are system dependencies)
- Caching with concurrent downloading fully compatible with the BGPKIT parser's caching functionality.
- Performance: for updates, typically 3–10× faster than PyBGPStream; for RIB-only processing, currently about 3–4× slower (see [perf.md](perf.md) for test details).
- A CLI tool

## Quick start

Installation:

```sh
pip install pybgpkitstream
```

Usage:

```python
import datetime
from pybgpkitstream import BGPStreamConfig, BGPKITStream

config = BGPStreamConfig(
    start_time=datetime.datetime(2010, 9, 1, 0, 0),
    end_time=datetime.datetime(2010, 9, 1, 1, 59),
    collectors=["route-views.sydney", "route-views.wide"],
    data_types=["ribs", "updates"],
)

stream = BGPKITStream.from_config(config)

n_elems = 0
for elem in stream:
  n_elems += 1
    
print(f"Processed {n_elems} BGP elements")
```

or in the terminal:

```sh
pybgpkitstream --start-time 2010-09-01T00:00:00 --end-time 2010-09-01T01:59:00 --collectors route-views.sydney route-views.wide --data-types updates > updates.txt
```

## Motivation

PyBGPStream is great but the implementation is complex and stops working when UC San Diego experiences a power outage.  
BGPKIT broker and parser are great, but cannot be used to create an ordered stream of BGP messages from multiple collectors and multiple data types.

## Missing features

- Live mode for RouteViews collectors
- Some PyBGPStream data interface options like csv or sqlite
jayzz 0.1.0
Unified access to NumPy, Pandas, Seaborn, and Matplotlib via a single import
Requires Python: >=3.8

# jayzz

jayzz is a lightweight Python umbrella package that provides unified access to popular data science libraries — NumPy, Pandas, Seaborn, and Matplotlib — using a single import.

## Why jayzz?
Instead of importing multiple libraries separately, jayzz allows you to write cleaner and more readable code by accessing all core data science tools through one namespace.

## Installation
```bash
pip install jayzz