semvec/pypi-packages huggingface dataset:
netora 0.24.0
Quickly uncover details and geolocation for any IP address
Requires Python: >=3.6
Keywords: geolocation, IP, OSINT

<p align=center>
  <br>
  <a href="https://github.com/nativevoid/netora" target="_blank"><img src="https://raw.githubusercontent.com/nativevoid/netora/refs/heads/main/docs/images/netora-banner.png" style="margin: 20px 0;"></img></a>
  <br>
  <span>Quickly uncover details and geolocation for <strong>any</strong> IP address</span>
  <br><br>
  <span>Additional documentation can be found at our <a href="https://github.com/nativevoid/netora">GitHub repository</a></span>
  <br>
</p>

## Usage

```console
$ netora --help
usage: netora [-h] [--version] [--folderoutput FOLDEROUTPUT]
                [--output OUTPUT] [--no-color]
                IP_ADDRESSES [IP_ADDRESS ...] 
```

To search for only one IP address:
```bash
$ netora 123.123.123.123
```

To search for more than one IP address:
```bash
$ netora 111.111.111.111 222.222.222.222 112.112.112.112
```
<br>

___

<br>
<p align="center">
</a>
</p>
audioeqinfer 0.1.0
Probabilistic Equalization Discovery for Audio Signals
Requires Python: >=3.8
Keywords: Audio Equalizer, Equalizer Inference

# Audio EQ Infer

**audioeqinfer** is a Python package for discovering audio equalization (EQ) curves of an altered signal through probabilistic inference about the signal source.  
It supports both **importance sampling** and **Metropolis-Hastings (MH)** to infer flexible, data-driven EQ transformations from audio signals.

See examples notebook for usage examples.

Currently in beta.


## Features

- Flexible spline-based parameterization of EQ curves
- Probabilistic inference using:
  - Importance sampling
  - Metropolis-Hastings
- Handles large audio files with online chunked processing
- Modular design with current set up for flow models (`f_X`)
- Clean API for inference and training
- Easily adjustable number of EQ parameters


## Installation
This package is available on pypi

## Requirements

- Python
- PyTorch
- torch
- nflows
- numpy
- scipy
- matplotlib
- statsmodels
- pedalboard
MagisterPy 0.1.50
A Python package for retrieving information from magister
Requires Python: >=3.9

# MagisterPY

This library will help you interact with your magister account using python!

## Disclaimer: 
Please note: Using unauthorized APIs to access Magister is against Magister’s Terms of Service. 
By using this library, you assume all responsibility and accept any risks associated with breaching these terms. 
For more details, please refer to Magister's Terms of Service. (https://magister.nl/over-ons/juridische-zaken/)

## Installation
```
pip install git+https://github.com/H3LL0U/MagisterPy.git
```
or 
```
pip install MagisterPy
```

## Contributing
Feel free to create an issue if something doesn't work. It's only been tested on a singular school so far so it is to be expected. If you want to help add a feature it would be great as well! :D

## Basic usage
The following code snippet demonstrates how to create a session, log in, and retrieve your schedule and recent grades:
```
from magisterpy import MagisterSession

# Create a new session and log in
session = MagisterSession()
session.login(school_name="School_name", username="your_username", password="your_password")

# Get schedule for a specific date range
my_schedule = session.get_schedule("2024-11-03", "2024-11-10")

# Get the most recent grade
my_most_recent_grade = session.get_grades(top=1)[0]["waarde"]

print("Schedule:", my_schedule)
print("Most Recent Grade:", my_most_recent_grade)
```
With MagisterPy, you can access and manage your Magister account directly from Python, automating repetitive tasks and integrating your school data into your projects. We hope you find it helpful!
More functionality to come!
cosipy 0.3.4
High-level analysis for the COSI telescope data

# cosipy

[![unit_tests](https://github.com/cositools/cosipy/actions/workflows/unit_tests.yml/badge.svg?branch=develop)](https://github.com/cositools/cosipy/actions/workflows/unit_tests.yml)
[![codecov](https://codecov.io/gh/cositools/cosipy/branch/develop/graph/badge.svg?token=FQGI2VG4OY)](https://codecov.io/gh/cositools/cosipy)

The cosipy library is [COSI](https://cosi.ssl.berkeley.edu)'s high-level analysis software.

The main repository is hosted in https://github.com/cositools/cosipy

For the cosipy installation and usage instructions please refer to the main [cosipy documentation](https://cositools.github.io/cosipy/).
gv-linalg 0.1.7
Some tools for accessing numpy using Sage-like syntax
Requires Python: <4.0,>=3.10

This package is meant for students taking linear algebra classes at [Grand Valley State University](https://gvsu.edu/math) though others are certainly welcome to use it.  Students become comfortable using Sage to do some linear algebraic computations but eventually start working in Colab notebooks.  To help facilitate working in a Colab notebook, this package provides access to `numpy` commands using a Sage-like syntax.  There are a few other features for visualizing the results of some computations.

Within a Colab notebook or other pure Python environment, begin with

```
!pip install gv_linalg
from gv_linalg import *
```
Then Sage-like commands, such as,

```
A = matrix([[1,2],[2,1]])
A.eigenvalues()
```
work as expected.
py-cryptomus 0.1.1
Python wrapper for Cryptomus API based on the requests library.

Cryptomus API library developed by a python addict who did not find any documentations on how to use the API using python and decided to craft one for the better!.

This project is not an official one from Cryptomus. Rather, it was created by Ted Hackwell to make it easier for developers to integrate with the Cryptomus API using python.

Top contributers:
-Ted Hackwell (Main)
-Tarius Blake
ypy-sqlite 0.1.0
SQLite persistence provider for YPY (Python bindings for YJS)
Requires Python: >=3.7
Keywords: yjs, crdt, sqlite, persistence, collaboration, y-py

# YPY SQLite Persistence Provider

A SQLite persistence provider for [YPY](https://github.com/y-crdt/ypy), the Python bindings for [Yjs](https://github.com/yjs/yjs).

## Installation

```bash
pip install ypy-sqlite
```

## Usage

Here's a basic example of how to use the YPY SQLite persistence provider:

```python
import asyncio
import y_py as Y
from ypy_sqlite import SQLitePersistence

async def example():
    # Initialize the persistence layer
    persistence = await SQLitePersistence.build("data.db", {
        "flush_size": 100,
        "table_name": "my_documents",
        "use_index": True
    })

    # Create and load a document
    doc_name = "example-doc"
    ydoc = await persistence.get_ydoc(doc_name)

    # Make changes
    with ydoc.begin_transaction() as txn:
        ytext = txn.get_text("content")
        ytext.insert(0, "Hello, world!")

    # Get updates for sync
    state_vector = await persistence.get_state_vector(doc_name)

    # Store updates
    update = Y.encode_state_as_update(ydoc)
    await persistence.store_update(doc_name, update)

    # Clean up
    await persistence.destroy()

if __name__ == "__main__":
    asyncio.run(example())
```

## API

### SQLitePersistence

#### `async SQLitePersistence.build(db_path, options=None)`

Initialize the persistence layer with options.

- `db_path`: Path to the SQLite database file
- `options`: Configuration options
  - `flush_size`: Number of updates before flushing (default: 200)
  - `table_name`: Name of the table to store documents (default: "ypy_documents")
  - `use_index`: Whether to use an index on the table (default: True)

#### `async get_ydoc(doc_name)`

Create a Y.Doc instance with the data persisted in SQLite.

#### `async store_update(doc_name, update)`

Store a single document update to the database.

#### `async get_state_vector(doc_name)`

Get the state vector for a document.

#### `async get_diff(doc_name, state_vector)`

Get differences between the current document state and the provided state vector.

#### `async clear_document(doc_name)`

Delete a document and all associated data from the database.

#### `async destroy()`

Clean up resources and close the database connection.

## License

MIT
factoryfloor-helpers 0.1.0
Helper tools for FactoryFloor projects
Requires Python: >=3.7

# FactoryFloor Helpers

A collection of helper tools for FactoryFloor projects.

## Installation

```bash
pip install factoryfloor-helpers
```

## Features

### Context Services

The `context_services` module provides classes for working with Five9 context services:

- `Holiday`: A Pydantic model representing a holiday with a name and date
- `HolidayBuilder`: A builder class for retrieving and formatting holiday information
- `TableBuilder`: A builder class for creating and managing Five9 context service tables

### Environment Utilities

The `environment` module provides utilities for environment-specific configurations:

- `get_base_url`: A function to get the base URL for the Five9 API based on the region

## Usage Examples

### Working with Holidays

```python
from factoryfloor_helpers.context_services import HolidayBuilder

# Create a holiday builder for the UK
holiday_builder = HolidayBuilder("GB")

# Get the next public holidays
holidays = holiday_builder.get_next_public_holidays()

# Print the holidays
for holiday in holidays:
    print(f"{holiday.name}: {holiday_builder.get_date(holiday)}")
```

### Creating Context Service Tables

```python
from factoryfloor_helpers.context_services import TableBuilder
from factoryfloor_helpers.environment import get_base_url
from five9 import RestAdminAPIClient

# Create a Five9 client
f9client = RestAdminAPIClient(
    base_url=get_base_url("US"),
    username="your_username",
    password="your_password",
    domain_id="your_domain_id"
)

# Create a table builder
table_builder = TableBuilder(f9client, dev_mode=True)

# Create a datatable
table = table_builder.create_datatable("MY_TABLE", "My test table")

# Define attributes
attributes = [
    {
        'name': 'ID',
        'type': 'STRING',
        'unique': True,
        'required': True,
    },
    {
        'name': 'NAME',
        'type': 'STRING',
        'unique': False,
        'required': True,
    }
]

# Create attributes
table_builder.create_attributes(table, attributes)

# Create a query
table_builder.create_query(table.id, "MY_QUERY", "My test query", "AND", ["ID"])
```

## License

MIT
image-processing-samuell-shoiti 0.0.1
Image Processing package using skimage
Requires Python: >=3.8

# image_processing

Description
The package image-processing-samuellshoiti is used to:
	Processing:
		- Histogram matching
		- Structural similarity
		- Resize Image
	Utils:
		- Read image
		- Save image
		- Plot image
		- Plot result
		- Plot histogram

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install image-processing-samuellshoiti

```bash
pip install image-processing-samuellshoiti
```

## Author
Samuell Shoiti Pinto Assanuma

## License
[MIT](https://choosealicense.com/licenses/mit/)
tableascii 0.1.0
A lightweight, simple Python library to create clean ASCII Table.
Requires Python: >=3.6

# Tableascii

A simple, lightweight, no-dependency Python library to create clean ASCII Table.

## Installation
Install from pypi
```bash
pip install tableascii
```
Or directly from Github
```bash
pip install git+https://github.com/Tari-dev/tableascii.git
```

## Usage Example
```python
from tableascii import Table

data = [
    ["Name", "Age"],
    ["Alice", 30],
    ["Bob", 25]
]

tb = Table(data)
print(tb.create())
```

```bash
+-------------+
| Name  | Age |
|-------------|
| Alice | 30  |
| Bob   | 25  |
+-------------+
```
## Features
- Pure ASCII output
- Simple and Lightweight
- No dependencies
- Automatically adjusts column width

## License
[MIT](https://github.com/Tari-dev/tableascii/blob/main/LICENSE)