semvec/pypi-packages huggingface dataset:
openpixels 0.3.1
OpenPixels Python SDK
Requires Python: >=3.8

# OpenPixels Python SDK

A Python SDK for accessing the OpenPixels API.

## Installation

```bash
pip install openpixels
# or with uv
uv pip install openpixels
```

## Usage

```python
from openpixels import OpenPixels

client = OpenPixels(
    api_key="sk-op-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
)

# Generate an image
def generate_image():
    result = client.run(
        model="flux-dev",
        prompt="a cat"
    )
    
    print(result)

generate_image()
```

The SDK provides both synchronous and asynchronous clients. The asynchronous client is preferable for most applications, especially those handling multiple requests or running in async environments like FastAPI.

### Async Client Usage

```python
from openpixels import AsyncOpenPixels
import asyncio

client = AsyncOpenPixels(
	api_key="sk-op-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
)

async def generate_image_async():
    result = await client.run(
        model="flux-dev",
        prompt="a cat"
    )
    
    print(result)

# Run the async function
asyncio.run(generate_image_async())
```

## API Reference

### `OpenPixels`

The synchronous client for making calls to the OpenPixels API.

```python
client = OpenPixels(
    api_key="YOUR_API_KEY",
    base_url="https://worker.openpixels.ai"  # Optional, defaults to production API
)
```

### `AsyncOpenPixels`

The asynchronous client for making calls to the OpenPixels API. This is generally preferred for better performance and responsiveness.

```python
client = AsyncOpenPixels(
    api_key="YOUR_API_KEY",
    base_url="https://worker.openpixels.ai"  # Optional, defaults to production API
)
```

#### Methods

Both clients provide the following methods:

- `run(payload)`: Submits a job and waits for the result.

<!-- - `submit(payload)`: Submits a job and returns the job ID.
- `subscribe(job_id)`: Subscribes to updates for a job. -->

## Development

### Building the Package

This project uses [uv](https://github.com/astral-sh/uv) for package management and building:

```bash
# Install development dependencies
uv pip install -e ".[dev]"

# Run tests
pytest

# Build the package
uv build
```

### Deploying a New Version

1. Update the version in `pyproject.toml`
2. Remove the dists folder: `rm -rf dist`
3. Build the distribution packages:
   ```bash
   uv build
   ```
4. Upload to PyPI using twine:
   ```bash
   python3 -m twine upload dist/*
   ```
5. `git tag vX.Y.Z`
6. `git push origin vX.Y.Z`

## License

MIT
clihttp 1.1.0
A simple Python module to make HTTP requests using command line.
Requires Python: >=3.6

# **clihttp**  
*A simple and efficient CLI tool for making HTTP/S requests.*  

`clihttp` is a command-line interface for interacting with HTTP/S APIs using Python. It provides an easy way to send requests, handle responses, and debug API calls—all from the terminal.  

## **✨ Features**
- Lightweight and easy to use  
- Supports `GET`, `POST`, `PUT`, `DELETE`, and more  
- Custom headers, JSON data, and query parameters  
- Easily installable via `pip`  
- Open-source and customizable  

---

## **📦 Installation**  

### **Install via PyPI**  
You can install `clihttp` directly from [PyPI](https://pypi.org/project/clihttp/):  
```bash
pip install clihttp
```

### **Build from Source**  
If you prefer to install from source, clone the repository and install manually:  
```bash
git clone https://github.com/kshvsec/clihttp.git
cd clihttp
pip install .
```

---

## **🚀 Usage**  

Once installed, you can use `clihttp` from your terminal. Here are some basic examples:  

### **Make a GET request**  
```bash
clihttp get https://api.example.com/data
```

### **Send a POST request with JSON data**  
```bash
clihttp post https://api.example.com/create -d '{"name": "Keshav", "role": "admin"}'
```

### **Pass custom headers**  
```bash
clihttp get https://api.example.com/auth -H "Authorization: Bearer YOUR_TOKEN"
```

### **Send query parameters**  
```bash
clihttp get https://api.example.com/search?q=python
```

### **View full response details**  
```bash
clihttp get https://api.example.com/status -v
```

---

## **🛠 Development & Contribution**  
Want to contribute? Fork the repository, make your changes, and submit a pull request!  

```bash
git clone https://github.com/kshvsec/clihttp.git
cd clihttp
```

---

## **📝 License**  
This project is licensed under a **custom restrictive license**—usage is allowed, but modification and redistribution are prohibited.  

---

## **📞 Support**  
For any issues or feature requests, open an issue on [GitHub](https://github.com/kshvsec/clihttp/issues).
mlogitviz 0.1.5
A library to compute and visualize marginal effects for multinomial logistic regression models
Requires Python: >=3.6

# mlogitviz

`mlogitviz` is a Python package designed to visualize changes in predicted probabilities from multinomial logistic regression models. It simplifies interpreting complex models, especially those involving Likert-scale predictors or other categorical data.

## Installation

To install `mlogitviz`, run:

```bash
pip install mlogitviz
```

## Usage

```python
import pandas as pd
from mlogitviz import visualize_mlogit

# Load your dataset
df = pd.read_csv("your_data.csv")

# Define key parameters
dependent_var = "outcome"  # Your categorical dependent variable
independent_vars = ["predictor1", "predictor2", "predictor3"]  # Independent variables
baseline_category = "Baseline_Outcome"

# Visualize with custom parameters
visualize_mlogit(df, dependent_var, independent_vars,
                  baseline=baseline_category,
                  significance=0.05,
                  margeff_at='overall',
                  margeff_count=False,
                  output_file="heatmap.png")
```

## Parameters
- **`df`** *(pd.DataFrame)*: Data containing the dependent and independent variables.
- **`dependent`** *(str)*: The name of the dependent variable (categorical).
- **`independent`** *(list of str)*: List of predictor variables (continuous or categorical).
- **`baseline`** *(str)*: Reference category for interpreting marginal effects.
- **`significance`** *(float, default=0.05)*: Threshold for displaying statistically significant effects.
- **`margeff_at`** *(str, default='overall')*: Controls how marginal effects are computed.
  - `'overall'`: Recommended for Likert scales or diverse data types.
  - `'mean'`: Uses the mean values of predictors for marginal effects.
- **`margeff_count`** *(bool, default=False)*: Treats count variables as continuous (`False`) or calculates changes when increased by one unit (`True`).
- **`output_file`** *(str or None)*: Path to save the visualization as an image file. If `None`, it will be displayed directly.

## Example Output
- The heatmap visualizes changes in probabilities, showing:
  - **Positive values** (red) = increased likelihood.
  - **Negative values** (blue) = decreased likelihood.
  - Baseline effects appear as a separate column with no significance indicators.

## Credits
This package was co-authored by Payam Saeedi and Eric Williams.


## License
This project is licensed under the MIT License.

## Citing this Package
If you use `mlogitviz` in your research, please cite:

**Payam Saeedi** and **Eric Williams**. *mlogitviz: Visualizing Marginal Effects in Multinomial Logistic Regression*. Version 0.1.4. URL: [https://pypi.org/project/mlogitviz/](https://pypi.org/project/mlogitviz/)

### BibTeX
```bibtex
@software{mlogitviz,
  author = {Payam Saeedi and Eric Williams},
  title = {mlogitviz: Visualizing Marginal Effects in Multinomial Logistic Regression},
  year = {2024},
  version = {0.1.4},
  url = {https://pypi.org/project/mlogitviz/}
}
```
cowpoke 0.0.2
Code in support of the 'Cooking with Python and KBpedia' (CWPK) series
Requires Python: >=3.6
Keywords: KBpedia, knowledge graph, build, extract

# *cowpoke*
<div style="float: right; width: 305px; margin-left: 10px;">
<img src="files/cowpoke-450.png" title="cowpoke" width="305" />
</div>

*cowpoke* is a package of Python build, extract, mapping, statistics, and analysis routines applicable to knowledge graphs, specifically [KBpedia](https://kbpedia.org/). The *cowpoke* package was developed as part of a 75-part series of electronic notebooks entitled [*Cooking with Python
and KBpedia*](https://www.mkbergman.com/cooking-with-python-and-kbpedia/). 

The electronic notebooks, which begin with installment #14, may be obtained from the [Jupyter Notebook repository](https://github.com/Cognonto/CWPK). There is much explanatory material in those notebooks regarding how the *cowpoke* code was constructed and what it does.

### Installation
Besides downloading and building the package locally, you may install the *cowpoke* package directly:

<code>pip install cowpoke</code>
emagpy 1.4.2
API for FDEM inversion and data manipulation

# EMagPy

Python API for inversion/modelling of frequency domain electromagnetic data (FDEM).

EMagPy is divided into a python API and a standalone graphical user interface (GUI).
It aims to be a powerfull but simple tool for inverting EMI data obtain from conductimeter.

# Getting started
Clone the repository:
```sh
git clone https://gitlab.com/hkex/emagpy
```
Change to the `src` directory and run `ui.py` to start the GUI.
```sh
cd emgapy/src
python ui.py # this will start the GUI
```
The python API is available by simply importing the `emagpy` module from the python shell:
```python
import emagpy
k = Problem()
k.createSurvey('./test/coverCrop.csv')
k.invert(forwardModel='CS') # specify the forward model (here the Cumulative Sensitivty of McNeil1980)
k.showResults() # display the section
k.showMisfit() # display predicted and observed apparent EC
k.showOne2one() # 1:1 line of misfit of apparent EC
```

Check out the jupyter notebook examples in `emagpy/examples/`.