semvec/pypi-packages huggingface dataset:
MyCatApi 0.1
API для работы с фактами о котах
Requires Python: >=3.6

# MyCatApi 🐱

Библиотека для работы с API котов (https://catfact.ninja).

# Описание

Эта простенькая библиотека скорей для развлечения,но
можно использовать в больших проектах.Создана библиотека для
больше для каких нибудь телеграм ботов для развлечений.
ЖДИ ОБНОВЛЕНИЙ УДАЧИ!

# весь функционал
```python
from MyCatApi import CatAPI # основной класс
a = CatAPI.RandomFact() # рандомный факт про котов 
b = CatAPI.GetBreeds() # самые популярыне породы кошек в мире
```

## Установка
```bash
pip install MyCatApi
```
simba-chem 1.0.2
Astrophysical Chemical Network Solver
Requires Python: >=3.8

# SIMBA: Solver for Inferring Molecular aBundances in Astrophysical environments

SIMBA is a comprehensive solver for chemical reaction networks in astrophysical environments. It is designed to model and simulate complex chemical processes in various cosmic settings such as the interstellar medium (ISM), molecular clouds, and protoplanetary disks.

## Features

- Initialization of chemical species, reactions, and environmental parameters
- Efficient solving of stiff ODEs representing chemical reactions
- Support for various reaction types including:
  - Gas-phase reactions
  - Grain-surface chemistry
  - Photochemistry
- Integration of self-shielding factors for specific molecules (H2, CO, N2, C)
- Optimization using Numba JIT compilation for performance-critical functions
- Comprehensive logging and progress tracking

## Installation

You can install SIMBA using pip:

```bash
pip install simba_chem
```

## Quick Start

1. First, create an input file for your simulation:
```python
import simba_chem as simba

# Create default input file
simba.create_input('my_input.dat')
```

&nbsp;&nbsp;&nbsp;&nbsp; You will also need to have a correctly formatted chemical network file available. A template can be generated using:
```python
simba.create_network("directory/to/save/network/") 
```

&nbsp;&nbsp;&nbsp;&nbsp; Don't forget to specify the path to the chemical network file in your input file!


2. Modify the input parameters in `my_input.py` according to your needs

3. Run your simulation:
```python
# Initialize the network
network = simba.Simba()
network.init_simba('my_input.dat')

# Solve the network
result = network.solve_network()
```





## Dependencies

- numpy
- scipy
- matplotlib
- numba
- tqdm
- pandas

## Model Components

SIMBA consists of several key components:
- Elements: Handling of chemical elements
- Species: Management of atomic and molecular species
- Gas: Gas phase parameters and properties
- Dust: Dust grain properties and interactions
- Environment: Environmental conditions (UV field, cosmic rays, etc.)
- Reactions: Chemical reaction network and rates
- Parameters: System parameters and constants

## Example Usage

```python
import simba_chem as simba
import matplotlib.pyplot as plt

# Initialize and run
network = simba.Simba()
network.init_simba('my_input.dat')
result = network.solve_network()

# Plot results
time = result['time']
abundances = result['abundances']
plt.loglog(time, abundances[0,:])  # Plot first species abundance
plt.xlabel('Time (s)')
plt.ylabel('Number Density (cm^-3)')
plt.show()
```


## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Luke Keyte

## Contributing

Contributions are welcome! Please feel free to get in touch: l.keyte@qmul.ac.uk
resumable-sse 0.1.0
Asynchronous recoverable SSE (Server-Sent Events) push toolkit, supporting Redis and in-memory backend.
Requires Python: >=3.10

# resumable-sse

> Asynchronous recoverable SSE (Server-Sent Events) push toolkit, supporting Redis and in-memory backend.

## ✨ Features

* ✅ Seamless integration with async generators (`async for`)
* 🔁 Resumable message stream support with `Last-Event-ID`
* 💾 Backend-agnostic: in-memory or Redis support
* ⚙️ Clean abstraction, minimal API surface
* 🧪 Easy to test, extendable for custom storage backends

## 📦 Installation

```bash
pip install resumable-sse
```

Or from source:

```bash
git clone https://github.com/vvanglro/resumable-sse.git
cd resumable-sse
pip install -e .
```

## 🚀 Quick Start

Using with FastAPI:

```python
import asyncio
from fastapi import FastAPI, Request
from sse_starlette.sse import EventSourceResponse
from resumable_sse.factory import get_streamer

app = FastAPI()
streamer = get_streamer(backend="memory")

async def fake_generator():
    for word in ["Hello,", "I'm an AI.", "Nice to meet you."]:
        yield word
        await asyncio.sleep(1)

@app.get("/stream")
async def stream(request: Request, session_id: str):
    return EventSourceResponse(
        streamer.stream(session_id=session_id, generator=fake_generator())
    )
```

Supports resume with:

```http
GET /stream?session_id=abc
```

## 🔌 Redis Backend Example

```python
import redis.asyncio as redis
from resumable_sse.factory import get_streamer

redis_client = redis.Redis()
streamer = get_streamer(backend="redis", redis_client=redis_client)
```

## 📘 API Reference

```python
async def stream(
    self,
    session_id: str,
    generator: ContentStream,
    last_id: str = "0",
) -> AsyncGenerator[dict, None]:
```

* `session_id`: Unique ID per conversation or stream session
* `last_id`: Resume position (used with `Last-Event-ID`)
* `generator`: Async generator function that yields message chunks

## 🧪 Run Tests

```bash
pytest tests/
```

## 📁 Project Structure

```
resumable_sse/
├── base.py           # Abstract base class
├── memory.py         # In-memory implementation
├── redis.py          # Redis implementation
├── factory.py        # Factory for backend selection
├── __init__.py
README.md
pyproject.toml
```

## 📄 License

MIT License

---
suse-translate 11.0.2
test
Keywords: test


# anupamas01
 <img src="[https://s3.amazonaws.com/nrjio/interactive.gif](https://compote.slate.com/images/697b023b-64a5-49a0-8059-27b963453fb1.gif?crop=780%2C520%2Cx0%2Cy0&width=1280)https://compote.slate.com/images/697b023b-64a5-49a0-8059-27b963453fb1.gif?crop=780%2C520%2Cx0%2Cy0&width=1280" alt="Interactive notifications example" width=350/>
pluxtools 0.1.0
Convert .plux files to image formats and compute surface heterogeneity metrics.
Requires Python: >=3.7
Keywords: plux, image, surface, metrics, heterogeneity

# PLUXTools
**PLUXTools** – A utility for converting `.plux` surface metrology archives and calculating quantitative heterogeneity metrics  
***

A Python-based module for automated conversion of Sensofar `.plux` topography data into usable image formats (PNG and TIFF), followed by optional surface texture analysis using image-derived metrics.

- [Basic usage](#basic-usage)  
- [Heterogeneity metrics](#heterogeneity-metrics)  
- [Installation instructions](#installation-instructions)
- [Dependencies](#dependencies)
- [Output and structure](#output-and-structure)  
- [Notes](#notes)  
- [License](#license)  

---

## Basic usage

PLUXTools supports `.plux` files containing metrology information and structured surface maps. It extracts the core data using `index.xml` and `.raw` layers, and converts it into common image formats for downstream analysis or publication.

### Conversion only

```bash
python -m pluxtools.convert [input_file.plux]
```
This will:
 1) Extract the .plux archive
 2) Parse image dimensions from `index.xml`
 3) Convert the raw topography (`LAYER_0_stack.raw`) to `.png` and `.tiff` formats

## Heterogeneity metrics

PLUXTools can calculate basic surface texture metrics from extracted images. These metrics provide a summary of spatial heterogeneity and surface roughness.
Metrics calculated

* Laplacian Variance – measure of surface sharpness and detail
* Shannon Entropy – texture randomness and complexity
* Sobel Mean Gradient – average spatial edge strength

### Metric calculation usage

```
python -m pluxtools.metrics [directory_of_images]
```

All supported image formats in the specified directory will be processed, including: `.png`, `.jpg`, `.jpeg`, `.tif`, and `.tiff`

### Example output 
| filename       | laplacian\_variance | entropy | sobel\_mean |
| -------------- | ------------------- | ------- | ----------- |
| sample\_1.png  | 54.23               | 6.22    | 0.0452      |
| sample\_2.tiff | 48.14               | 6.12    | 0.0385      |

## Installation instructions

We recommend using a virtual environment.

### Install via PyPI

```
pip3 install pluxtools

```

### Install from source

```
git clone https://github.com/yourgroup/pluxtools.git
cd pluxtools
pip install -e .

```

## Dependencies

PLUXTools requires the following packages:
* `numpy`
* `pillow`
* `opencv-python`
* `scikit-image`
* `pandas`
* `tqdm`

## Output and structure

All converted image files are saved to the same directory as the input `.plux` archive. Metric outputs are saved as a single `.csv` file summarising calculated features per image.

## Notes
* `.plux` files are ZIP-compressed archives with metadata and binary topography data
* Image dimensions are parsed from `index.xml`
* Bit depth and format are inferred from the size of the `.raw` file
* Only `LAYER_0_stack.raw` is processed
* No manual configuration of dimensions is required

## License

MIT License © DrATedder 2025