semvec/pypi-packages huggingface dataset:
libnova 0.1.14
Personal python batteries libary -- mostly binary analysis, exploitation.
Requires Python: ==3.8.10

# libnova
The novafacing standard library but this time it's on PyPi

## What is this for?

Mostly pwntools and angr wrapper stuff so I can avoid retyping things constantly.
I also now only write strongly typed Python and I don't use strings for paths,
which doesn't sound like a huge change but things don't play nice! So here's my
compatibility.

## Example?

```python
from logging import getLogger
from pathlib import Path
from libnova import PW, PWMode

l = getLogger(__name__).info


b = Path("../src/target/debug/src")

x = PW(binary=b, mode=PWMode.DEBUG)

l(f"Loaded with {len(x.elf.symbols)} symbols")

x.sendline(b":q")
x.precvall()
```

The nice part is we get some really nice output from *everything* (you can't see the colors but they are there!):

```
...
INFO     | /home/novafa...a/pwn/pwn.py:0237 | Checksec info for library: ld-2.31.so
INFO     | /home/novafa...a/pwn/pwn.py:0239 | RELRO:    Partial RELRO
INFO     | /home/novafa...a/pwn/pwn.py:0239 | Stack:    No canary found
INFO     | /home/novafa...a/pwn/pwn.py:0239 | NX:       NX enabled
INFO     | /home/novafa...a/pwn/pwn.py:0239 | PIE:      PIE enabled
INFO     | /home/novafa...a/pwn/pwn.py:0241 | Checksec info for main object: src
INFO     | /home/novafa...a/pwn/pwn.py:0243 | RELRO:    Full RELRO
INFO     | /home/novafa...a/pwn/pwn.py:0243 | Stack:    No canary found
INFO     | /home/novafa...a/pwn/pwn.py:0243 | NX:       NX enabled
INFO     | /home/novafa...a/pwn/pwn.py:0243 | PIE:      PIE enabled
INFO     |                    __main__:0012 | Loaded with 1260 symbols
INFO     | pwnlib.tubes...365646789552:0298 | Receiving all data
INFO     | pwnlib.tubes...365646789552:0298 | Receiving all data: 0B
INFO     | pwnlib.tubes...365646789552:0298 | Receiving all data: 108B
INFO     | pwnlib.tubes...365646789552:0298 | Receiving all data: 136B
INFO     | pwnlib.tubes...365646789552:0298 | Process '/usr/local/bin/gdbserver' stopped with exit code 0 (pid 419479)
INFO     | pwnlib.tubes...365646789552:0298 | Receiving all data: Done (136B)
b'Welcome to the embedded programming simulator!\nOf course, you can only code using vim if you are 133...\nex: \nChild exited with status 0\n'
```
soloman 3.1.1
For the love of Artificial Intelligence, Python and QML
Keywords: audio,pyaudio,ffmpeg,qml,pyffmpeg

# soloman    [![Downloads](https://pepy.tech/badge/soloman/month)](https://pepy.tech/project/soloman)
For the love of Artificial Intelligence, Python and QML


[refer to milestone](https://github.com/deuteronomy-works/soloman/milestone/12)



## Installation
    pip install soloman



## Python Usage



### Play audio
```python
from soloman import Audio


aud = Audio()
aud.play('/path/to/music.mp3')
```

## Qml Usage
example.py
```python
import soloman
...
engine = QQmlApplicationEngine()
...
engine.load('example.qml')

```

### Play audio
*example.qml*


**Qt6**
```qml
import QtQuick
...
import soloman

SAudio {
    id: aud
}

Button {
    text: "Play"
    onClicked: aud.play('path/to/music.mp3')
}

```


**Qt5**
```qml
import QtQuick 2.15
...
import soloman 3.0

SAudio {
    id: aud
}

Button {
    text: "Play"
    onClicked: aud.play('path/to/music.mp3')
}

```

### Play videos
*example.qml*

#### Play a video file

**Qt6**

```qml
import QtQuick
...
import soloman

SVideo {
    id: vid
}

Button {
    text: "Play video"
    onClicked: vid.play('path/to/video.mp4')
}
```

**Qt5**

```qml
import QtQuick 2.15
...
import soloman 3.0

SVideo {
    id: vid
}

Button {
    text: "Play video"
    onClicked: vid.play('path/to/video.mp4')
}
```

### Play stills

##### Option one

```qml
...
    onClicked: vid.play('path/to/video_stills_01.jpg') # possibly the first image
...
```

##### Option two

```qml
...
    onClicked: vid.play('path/to/') # make sure folder contains only stills
...
```




### Show cv2 frame

example.py

```python
import sys
import cv2
import threading
from time import sleep

from PyQt5.QtGui import QGuiApplication
from PyQt5.QtQml QQmlApplicationEngine
import soloman

app = QGuiApplication(sys.argv)

# Create a QML engine.
engine = QQmlApplicationEngine()
engine.quit.connect(app.quit)
engine.load(QUrl('example.qml'))

# Get SVideo
vid = soloman.Video(engine)
vid.get_SVideo('screen_01')  # objectName goes here

# Capture
capture = cv2.VideoCapture(0)  # capture camera

def start_capt():
    # start thread
    o_thread = threading.Thread(target=_start_capt)
    o_thread.daemon = True
    o_thread.start()

def _start_capt():

    while True:

        ret, frame = capture.read()

        if not ret:
            break

        vid.show_frame(frame)
        sleep(1/24)

# Call to start capturing
start_capt()

# Run the app
ret_value = app.exec_()
capture.release()
sys.exit(0)
```

example.qml

**Qt6**

```qml
import QtQuick
import QtQuick.Controls.Basic
import solomon

ApplicationWindow {
	visible: true
	width: 800
	height: 500

    SVideo {
        objectName: "screen_01"  // declare objectName to be used in python
    }
    
}
```

**Qt5**

```qml
import QtQuick 2.15
import QtQuick.Controls 2.15
import solomon 3.0

ApplicationWindow {
	visible: true
	width: 800
	height: 500

    SVideo {
        objectName: "screen_01"  // declare objectName to be used in python
    }
    
}
```





## Wiki

The wiki can be located [here](https://github.com/deuteronomy-works/soloman/wiki)
simmeth 0.1.0
Simulation Methods Package
Requires Python: >=3.6

# Simulation Methods - Wiki

![version](https://img.shields.io/badge/version-0.0.9-blue)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)
[![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)
[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)

Simple python package to test simulation methods.

# Getting Started

## Installation :hammer:

```commandline
pip install simmeth
```

## Basic Usage

To set up a simulation simply create an instance of `Simulation` class. In order to run the simulation call `run()` on
simulation object.

```python
from simmeth.simulation import Simulation

env_scenarios = [
    {
        'turb': 0,
        'max_confidence': 1,
        'unlearn': True
    }
]
sim = Simulation(scenarios=env_scenarios, n_strategies=3, t=100, n=100)
sim.run()
```

## Plot Simulation Results

In order to plot simulation results you can call `sim.plot_scenarios()`.

![](./docs/assets/sim_plot.png)
pynterpol 1.1.0
Fast image interpolation
Requires Python: >=3.6

# pynterpol

Fast image interpolation in Python.

## Installation

```shell
python -m pip install pynterpol
```

## Usage (example)

```python
from pynterpol import interp_bilinear_u8
import cv2

img = cv2.imread('image.jpg')  # or any other way of reading an image as a numpy ndarray

interpolated_values = interp_bilinear_u8(img, [100.1, 100.8], [50.5, 51.2])
```

## Performances

High performance is achieved:

- by considering that the image to interpolate is defined on an orthogonal equally-spaced regular grid, and
- by using [Numba](http://numba.pydata.org/) for the loop-intensive parts of the computation, and
- by optimizing the algorithm implementation (avoid code cache misses for special cases, etc.)

### Comparative Timings

Timings realized on an Apple MacBook Pro (Intel Core i9 8 cores, 2.3 GHz)
with an gray (i.e. single channel) image of size 1904x1081x1 interpolated on a regular equally-spaced grid of size
3807x2161 that covers the entire domain of the image
(that corresponds to a x2 upsampling of the input image).

| method | timings |
|--------|---------|
| SciPy `RegularGridInterpolator` | 1614 ms |
| `interp_bilinear_u8` (without Numba) | 82980 ms (LOL) |
| `interp_bilinear_u8` (with Numba) | **65 ms** (almost x25 speedup)|

## Reference

As of 2022-03-06, only images represented as a NumPy ndarray with uint8 as dtype are supported. Interpolated values are
stored as float64. All of this is implemented with a single function: `interp_bilinear_u8`.

Other cases may be considered in the future:

- bicubic interpolation or other interpolation schemes
- image represented with different types (float, bigger uints, ...)
- integer (or smaller floats) interpolated values

## Tests

```shell
cd $PROJECT_ROOT
PYTHONPATH=./src python -m unittest tests.test_pynterpol.TestPynterpol
```

Note: There may be a better way than providing the `PYTHONPATH` variable in the command...

## Distribution

```shell
python -m pip install --upgrade build twine
python -m pip build
python -m twine upload --repository testpypi dist/*
```