semvec/pypi-packages huggingface dataset:
baleapi 2.2.0
Python library for Bale Bot API
Requires Python: >=3.8

# BaleAPI 

**BaleAPI** یک لایبرری سبک و سریع برای ساخت بات‌های **پیام‌رسان بله** است.  

---

## 💡 قابلیت‌های کلیدی

- مدیریت پیام‌ها (ارسال، ویرایش، حذف)  
- مدیریت گروه و کانال (بن/آن‌بن، پین/آن‌پین، تنظیم عنوان و توضیحات)  
- کیبوردهای **Reply** و **Inline**  
- چند هندلر همزمان: پیام متنی، عکس، کامند  
- قابلیت ساخت بات‌های **چند منظوره** و **ترکیبی**  
- گرفتن تاریخچه چت و Logging (برای توسعه و دیباگ)

> ⚠️ متد **unpin** فعلا مشکل داره و در نسخه فعلی بدرستی کار نمی‌کند.

---

## ⚡ نصب

```bash
pip install baleapi
```
## ⚡ بروزرسانی

```bash
pip install --upgrade baleapi
```

---

## 💻 نویسنده

- ایمیل: thealiapi@gmail.com  
- آیدی: [ble.ir/ali_api](https://ble.ir/ali_api)
put-back-iterator 0.1.0a1
A drop-in replacement for `iter(iterable)` that allows **putting items back** after consuming them. Ideal for parsing, lexing, and other scenarios requiring lookahead or backtracking.
Requires Python: >=2

# `put-back-iterator`

A drop-in replacement for `iter(iterable)` that allows **putting items back** after consuming them. Ideal for parsing, lexing, and other scenarios requiring lookahead or backtracking.

## Why Use This?

Python's built-in iterators don't support pushing items back, forcing workarounds like:

- Rebuilding iterators with `itertools.chain`
- Using lists/deques as buffers
- Complex state tracking

This package solves it with:

- ✅ **Simple API**: `.put_back(item)` and `.has_next()`
- ✅ **Compatibility with `iter(iterable)`**: Works with any iterable (`str`, `list`, generators, etc.)
- ✅ **Python 2/3 compatible**

## Quick Start

```python
# coding=utf-8
from __future__ import print_function
from put_back_iterator import PutBackIterator

# Wrap any iterable
it = PutBackIterator([1, 2, 3])

# Consume an item
print(next(it))  # 1

# Put it back for later
it.put_back(1)

# Check if more items exist (without consuming)
print(it.has_next())  # True

# Iterate as usual
print(list(it))  # [1, 2, 3]
```

## Use Cases

### 1. **Parsing/Tokenizing**

```
tokens = PutBackIterator(tokenize(source_code))
while tokens.has_next():
    token = next(tokens)
    if token == 'IF':
        # Peek ahead without consuming
        if tokens.has_next() and next(tokens) == 'EOF':
            tokens.put_back('EOF')
            handle_incomplete_if()
```

### 2. **Backtracking Algorithms**

```
def backtrack(it):
    item = next(it)
    if not is_valid(item):
        it.put_back(item)  # Try alternative path
        return fallback()
```

### 3. **Stream Processing**

```
for chunk in PutBackIterator(stream):
    if needs_retry(chunk):
        chunk = modify(chunk)
        it.put_back(chunk)  # Reprocess
```

## API Reference

### **`PutBackIterator(iterable)`** Wraps an iterable.,Compatible with `iter(iterable)`.

### Methods

- **`.put_back(item: T) -> None`** Pushes an item back into the iterator (LIFO order).
- **`.has_next() -> bool`** Returns `True` if more items exist (peeks without consuming).
- **`.__iter__()` and `.__next__()` / `.next()`** Compatible with Python 2/3 iterator protocol.

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).
primitives 0.1.0
Shared PLC-style primitives in Python
Requires Python: >=3.9

timers-latches

Lightweight, production-ready implementations of PLC-style primitives in Python:

TON — On-delay timer

SR — Set/Reset latch (reset dominant)

These primitives are useful for industrial automation logic, simulations, or anywhere you want PLC-like control behavior in Python.

Installation
pip install timers-latches


Or, for development:

git clone https://github.com/yourorg/timers-latches.git
cd timers-latches
pip install -e .

Usage
from timers_latches import TON, SR

# --- TON example ---
ton = TON(preset_s=2.0)   # 2-second delay
for step in range(5):
    q = ton.update(enable=True, dt_s=0.5)
    print(f"t={step*0.5:.1f}s, Q={q}")
# Q will turn True after 2.0 seconds of accumulated enable time

# --- SR example ---
latch = SR(initial=False)
print(latch.update(set_=True, reset=False))   # True
print(latch.update(set_=False, reset=True))   # False (reset dominates)

API
TON(preset_s: float)

preset_s: delay time in seconds (must be ≥ 0).

.update(enable: bool, dt_s: float) -> bool: call once per scan; returns the done bit (Q).

.Q: current output (done bit).

SR(initial: bool = False)

initial: starting state.

.update(set_: bool, reset: bool) -> bool: updates and returns current state. Reset dominates set.

.state: current latched state.

Versioning

Follows Semantic Versioning
.

API is stable from 1.0.0 onward.

License

MIT © Your Name / Your Organization

⚡️ This package is intentionally minimal and focused: no dependencies, only core primitives. You can drop it into simulations, control logic, or larger automation frameworks.
git-lfs-advisor-cli 0.1.0
A script to find large/binary files and generate Git LFS commands.
Requires Python: >=3.6

# Git LFS Advisor

A simple command-line tool to scan a Git repository, find files suitable for Git LFS, and generate the necessary configuration commands.

This tool helps you quickly set up Git LFS for a new or existing project without manually checking every file.

## ✨ Features

- **Repository Scan**: Scans the entire Git repository to find large or binary files.
- **Custom Rules**: Define scanning rules based on file size or file extension.
- **Command Generation**: Automatically generates `git lfs track` and `git lfs migrate` commands for you to copy and execute.
- **Cross-Platform**: Built with Python, it runs on Windows, macOS, and Linux.

## 📋 What It Does

1. **Scans** your repository for large files and binary assets
2. **Analyzes** file patterns, sizes, and repository structure
3. **Recommends** which files should be tracked by Git LFS
4. **Generates** `.gitattributes` configuration automatically
5. **Provides** migration commands and best practices

## 🎯 Use Cases

- Setting up LFS for new repositories
- Optimizing existing repositories with large files
- Migrating from regular Git to Git LFS
- Repository cleanup and size optimization
- CI/CD pipeline integration

## 📊 Example Output

```txt
🔍 Scanning repository...
📁 Found 1,247 files (Total: 2.3 GB)

💡 LFS Recommendations:
  • *.psd files (127 files, 890 MB) → Track with LFS
  • *.mp4 files (23 files, 1.2 GB) → Track with LFS
  • *.zip files (8 files, 156 MB) → Track with LFS

📝 Generated .gitattributes:
  *.psd filter=lfs diff=lfs merge=lfs -text
  *.mp4 filter=lfs diff=lfs merge=lfs -text
  *.zip filter=lfs diff=lfs merge=lfs -text

💾 Potential space savings: ~2.1 GB in Git history
```

## 🛠️ Installation

```bash
pip install git-lfs-advisor-cli
```

## 🤝 Contributing

Contributions are welcome!

## ⭐ Show Your Support

If this tool helps you manage your Git LFS setup, please give it a star! ⭐

---

**Made with ❤️ for better Git workflows**
pyDAmonitor 0.1.1
Safeguard invaluable DA investments by vigilantly monitoring DA performance
Requires Python: >=3.9

[pyDAmonitor Book](https://pyDAmonitor.github.io/docs): showcase plots and results

# pyDAmonitor
Safeguarding invaluable DA investments by vigilantly monitoring DA performance both in real-time and retrospective scenarios.

# Installation
```
git clone https://github.com/pyDAmonitor/pyDAmonitor.git
conda env create -f pyDAmonitor/environment.yaml
conda activate pyDAmonitor
```
Note: The `pyDAmonitor` Python environment is already installed on `Jet/Hera/Ursa/Gaea/Orion/Hercules/Derecho` and can be loaded with `source pyDAmonitor/ush/load_pyDAmonitor.sh`.  
Sample data is also staged on these machines for a quick start. If you need the sample data on other platforms, feel free to reach out.

# Details
Data assimilation (DA) is a critical component of modern weather forecasting and earth system modeling, it enables the integration of atmospheric observations into models to increase forecast accuracy. 

pyDAmonitor automatically reads JEDI (or GSI) diagnostic files and create a comprehensive set of statistics, plots, and maps of key assimilation metrics like OmB (Observation minus Background) and OmA (Observation minus Analysis), innovation distribution, etc. It aims to facilitate and speed up analysis of DA performance in both real-time and retrospective scenarios.

# Links:
[pyDAmonitor Book](https://pyDAmonitor.github.io/docs): showcase plots and results

[work with pyDAmonitor](https://github.com/pyDAmonitor/pyDAmonitor/wiki/work-with-pyDAmonitor)  

Check [wiki](https://github.com/pyDAmonitor/pyDAmonitor/wiki) for more information