semvec/pypi-packages huggingface dataset:
ndi-python 5.1.1.5
Wrapper package for NDI SDK python bindings.
License: MIT
Requires Python: >=3.7
Keywords: NDI,NewTek,Video Production

# ndi-python
NewTek NDI Python wrapper

## Installation
ndi-python is support pypi package now. https://pypi.org/project/ndi-python/  
So you can install it using pip if it is a supported environment.  
```
pip install ndi-python
```
The supported environment is as follows.  
- Windows x64 Python(3.7-3.10)
- macOS x64 >=10.12 Python(3.7-3.10)
- Linux x64,aarch64 Python(3.7-3.10)

## Setup Avahi
Linux requires Avahi to search for NDI sources.  
Please install according to your environment.  

### Ubuntu
```
sudo apt install avahi-daemon
sudo systemctl enable --now avahi-daemon
```

### Arch Linux
```
sudo pacman -S avahi
sudo systemctl enable --now avahi-daemon
```

## Run examples
I've ported some examples to python.  
You can try it by running the ndi-python examples.  
```
git clone --recursive https://github.com/buresu/ndi-python.git
cd ndi-python/example
pip install -r requirements.txt
python find.py
```

## Development

### Install NDI SDK
NDI SDK is required for development.  
You should install according to your environment.  

### Windows, Mac, Ubuntu
Donwload and install NDI SDK.  
https://ndi.tv/sdk/

### Arch Linux
```
yay -S ndi-sdk
```

## Build
### Build with setup.py
```
git clone --recursive https://github.com/buresu/ndi-python.git
cd ndi-python
python setup.py build
```
For ubuntu you need to set the SDK directory in NDI_SDK_DIR as cmake options.  
```
env CMAKE_ARGS="-DNDI_SDK_DIR=/path/to/ndisdk" python setup.py build
```
You can also specify the python version.  
```
env CMAKE_ARGS="-DNDI_SDK_DIR=/path/to/ndisdk -DPYTHON_EXECUTABLE=/path/to/python3.8 -DPYBIND11_PYTHON_VERSION=3.8" /path/to/python3.8 setup.py build
```

### Build for Python package
```
python setup.py bdist_wheel
```

### Build only CMake
```
git clone --recursive https://github.com/buresu/ndi-python.git
cd /path/to/build
cmake /path/to/project
cmake --build /path/to/build --config Release
```

For ubuntu you need to set the SDK directory in NDI_SDK_DIR.  
And build as follows.  
```
cmake /path/to/project -DNDI_SDK_DIR=/path/to/ndisdk
cmake --build /path/to/build --config Release
```
After build copy ndi-python binary and NDI binary to execute directory.  

## License
ndi-python is MIT License  
NDI follows NDI's license
modelify 0.0.2.8
New Version of MLOps Platforms.
License: MIT
Keywords: mlops,machine learning,model deployment,deploy model,data science,computer vision

# Modelify

Modelify takes over all devops jobs from data scientists and machine learning practitioners and brings their models to production.

## Install 

```
pip install modelify
```

## Usage

Deploying LightGBM Model

```python
import pandas as pd
from sklearn.datasets import load_iris
from lightgbm import LGBMClassifier, Dataset, train as train_lgbm
import modelify
from modelify import ModelInference
from modelify.helpers import create_schema

# import data
iris = load_iris()
df= pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                     columns= iris['feature_names'] + ['target'])

# train test split
train, test = train_test_split(df, test_size=0.2 )
y_train = df["target"]
X_train = df.drop(columns=["target"])

# build your model
clr = LGBMClassifier()
clr.fit(X_train, y_train)

# deployment
inference = ModelInference(model=model, framework="LIGHTGBM", inputs=create_schema(X_train))

modelify.connect("YOUR_API_KEY")

modelify.deploy(inference, app_uid="YOUR_APP_UID")

```
viz-image-deobfuscate 0.1.4
Deobfuscate Viz-style manga images.
License: MIT
Requires Python: >=3.10,<4.0
Keywords: viz,manga,deobfuscate,image

# Viz Manga Deobfuscator

Viz manga pages are delivered to the browser as obfuscated images and the client JS is responsible for deobfuscation of those images for the viewer to read. This program reproduces the deobfuscate logic to produce a readable image.

`obfuscated image:`
![obfuscated image](https://raw.githubusercontent.com/minormending/viz-image-deobfuscate/main/images/raw1.jpg)

`deobfuscated image:`
![deobfuscated image](https://raw.githubusercontent.com/minormending/viz-image-deobfuscate/main/images/page1.jpg)

The image Exif metadata stores a hex digest to deobfuscate the image. Using the each byte value of the digest with it's position in the digest, we can select the appropriate tile in the obfuscated image and put it in the proper place in the deobfuscated image.  

DISCLAIMER: I am not licensed or affiliated with Viz Media and this repository is meant for informational purposes only.

# Installation 
```
pip install viz-image-deobfuscate 
```

# Usage
This package exposes `deobfuscate_image` that accepts a path to an image and returns an PIL `Image` of the deobfuscated image.

```
from viz_image_deobfuscate import deobfuscate_image

deobfuscated = deobfuscate_image("raw.jpg")
deobfuscated.save("page.jpg")
```

# CLI Usage
Bundled with this package is a CLI tool for scripting/testing purposes.

```
usage: image-deobfuscate-cli [-h] obfuscated_image deobfuscated_image

Deobfuscate manage page image.

positional arguments:
  obfuscated_image    Path to the obfuscated image.
  deobfuscated_image  Output path to the obfuscated image.

options:
  -h, --help          show this help message and exit
```

## Example
```
>>> image-deobfuscate-cli raw1.jpg page1.jpg

Successfully deobfuscated image at: page1.jpg
```

# Docker
Alternatively, you can build your own docker container to run the CLI or download an already built container from [Docker Hub](https://hub.docker.com/r/minormending/viz-image-deobfuscate)

```
>>> docker build -t viz .
>>> docker run -v /home/user/images/:/app/images viz images/raw1.jpg images/page1.jpg

Successfully deobfuscated image at: images/page1.jpg
```
PyScep 0.0.14
A Python SCEP client and server
License: MIT
Requires Python: >=2.7

# PyScep

A Python SCEP Client library to enrol for certificate from a SCEP CA.

**Note: It is intended to be used for testing the environments**

## Getting Started

### Prerequisite
Either Generate a Self Signed Certificate or use an existing Certificate issued by CA

#### Generate a Self Signed Certificate
````
identity, identity_private_key = Client.SigningRequest.generate_self_signed(
    cn=u'PyScep-test',
    key_usage={u'digital_signature', u'key_encipherment'}
)
````
Note: this will generate a new RSA Key pair automatically, you can optionally supply a `private_key`.

#### Load an Existing Certificate
````
identity, identity_private_key = Client.Certificate.from_p12_file(
    p12_file='/path/to/cert.p12', 
    password='password'
)
````

### Signing Request
````
csr, private_key = Client.SigningRequest.generate_csr(
    cn=u'PyScep-test', 
    key_usage={u'digital_signature', u'key_encipherment'}, 
    password='password' 
)
````
Note: this will generate a new RSA Key pair automatically, you can optionally supply a `private_key`.

### Creating a Client
````
client = Client.Client(
    'http://<hostname>:<port>/ejbca/publicweb/apply/scep/pkiclient.exe'
)
````
Above example creates a sample client for [EJBCA](https://www.ejbca.org/). Please update the path according to the CA server in use.

### Enrollment
````
res = client.enrol(
    csr=csr,
    identity=identity, 
    identity_private_key=identity_private_key, 
    identifier=identifier ## An optional identifier how CA Server identifies the CA
)

if res.status == PKIStatus.FAILURE:
    print res.fail_info
elif res.status == PKIStatus.PENDING:
    print res.transaction_id
else:
    print res.certificate
````

### Poll
````
res = client.poll(
    identity=identity,
    identity_private_key=identity_private_key,
    subject=subject,
    transaction_id=transaction_id 
)
````
Response is same as Enrollment.

### Get Certificate
````
res = client.get_cert(
    identity=identity,
    identity_private_key=identity_private_key,
    serial_number=1234567890
)
````
Response is same as Enrollment.

### CRL
````
res = client.get_crl(
    identity=identity,
    identity_private_key=identity_private_key, 
    serial_number=1234567890
)

if res.status == PKIStatus.FAILURE:
    print res.fail_info
elif res.status == PKIStatus.PENDING:
    print res.transaction_id
else:
    print res.crl
````

### Get Rollover Certificate
````
ca_certificate = client.rollover_certificate()
````

## Credits
[SCEPy](https://github.com/mosen/SCEPy) for providing base implementation for this project

[jscep](https://github.com/jscep/jscep) for interface