semvec/pypi-packages huggingface dataset:
py-ios 0.1.3
A brief description of your project
Requires Python: >=3.6

# py-ios: A Wrapper for iOS Device Interaction Tools Based on the go - ios Project

-   [English](#Installation)
-   [中文版](#安装)

# py-ios

`py-ios` is a simple wrapper based on the [https://github.com/danielpaulus/go-ios](https://github.com/danielpaulus/go-ios) project. In a Windows environment, there's no need to download `wintun.dll` additionally, and you don't have to start `tunnel start` with administrative privileges.

## Installation
The specific steps to install `py-ios` depend on your environment. Generally, you can install it via a package manager like `pip`:

```bash
pip install py-ios
```

## Usage
`py-ios` maintains consistency with `go-ios` in terms of usage. You can refer to the official documentation of `go-ios` for detailed operations and commands, and use them in a similar way in `py-ios`. 


`py-ios` 基于 [https://github.com/danielpaulus/go-ios](https://github.com/danielpaulus/go-ios) 项目进行简单封装, window环境不需要额外下载wintun.dll，也无需在管理员权限下启动 tunnel start

## 安装
安装 `py-ios` 的具体步骤取决于你的环境。通常，你可以通过包管理器（如 `pip`）进行安装：
```bash
pip install py-ios
```

## 用法
`py-ios` 与go-ios保持一致
json_partial_python 0.1.3
getting structured outputs from LLMs
Requires Python: >=3.8
Keywords: structured outputs, agents, llm

`json_partial_py` is a resilient JSON parsing library written in Rust that goes beyond the strict JSON specification. It’s designed to parse not only valid JSON but also "JSON‐like" input that may include common syntax errors, multiple JSON objects, or JSON embedded in markdown code blocks.

This is python bindings for `json_partial` library (Rust).

Usage: 

```python
pip install json_partial_python
```

## Simple Example

<pre> 
from pydantic import BaseModel
from json_partial_py import to_json_string

# Define a simple Pydantic model that matches the expected JSON structure.
class Person(BaseModel):
    name: str
    age: int

# Example input: A malformed JSON wrapped in Markdown fences.
MALFORMED_JSON = r"""
```json
{"name": "Bob", "age": 25}
```
"""

json_str = to_json_string(MALFORMED_JSON)
person = Person.model_validate_json(json_str)
print(person)
</pre> 

## Advanced Example

<pre> 
from typing import List
from pydantic import BaseModel
from json_partial_py import to_json_string

# Define nested models for the JSON structure.
class Coordinates(BaseModel):
    lat: float
    lng: float

class Address(BaseModel):
    street: str
    city: str
    country: str
    coordinates: Coordinates

class Hobby(BaseModel):
    name: str
    years_active: int
    proficiency: str

class Person(BaseModel):
    name: str
    age: int
    address: Address
    hobbies: List[Hobby]

# Example input: A complex nested JSON wrapped in Markdown fences.
MALFORMED_NESTED_JSON = r"""
```json
{
    "name": "Bob",
    "age": 42,
    "address": {
        "street": "789 Pine Rd",
        "city": "Metropolis",
        "country": "USA",
        "coordinates": {"lat": 40.7128, "lng": -74.0060}
    },
    "hobbies": [
        {"name": "Cooking", "years_active": 5, "proficiency": "intermediate"},
        {"name": "Cycling", "years_active": 10, "proficiency": "expert"}
    ]
}
```
"""

json_str = to_json_string(MALFORMED_NESTED_JSON)
person = Person.model_validate_json(json_str)
print(person)

</pre> 

One more corner case handled
<pre>
MALFORMED_JSON=r"""
{ rec_one: "and then i said \"hi\", and also \"bye\"", rec_two: "and then i said "hi", and also "bye"", "also_rec_one": ok }
"""

json_str = to_json_string(MALFORMED_NESTED_JSON)
print(json.loads(json_str))

</pre>

## Publishing

To compile to the desired target using Zig, execute the following command:
`maturin build --release --target aarch64-unknown-linux-gnu --zig`
`maturin build --release --target x86_64-unknown-linux-gnu --zig`

After building, move the files from the `target/wheels` directory to the `dist/` folder using the following command:
```bash
cp target/wheels/* dist/
```

Finally, use the command `uv publish` to publish the package.
wiseAI 1.1.0
Private library using Web3
Requires Python: >=3.7

## wiseAI

### wiseAI: Simplify Your Machine Learning Workflow 

**Introduction:**
Welcome to **wiseAI**, the ultimate machine learning library designed specifically! Whether you are a seasoned data scientist or a business analyst venturing into the world of machine learning, wiseAI offers an intuitive and powerful platform to streamline your model development process.

**Key Features:**
- **User-Friendly Interface:** wiseAI provides a simple, yet powerful interface that allows users to build and deploy machine learning models with minimal coding.
- **Comprehensive Preprocessing Tools:** From data cleaning to feature engineering, our library includes a wide array of preprocessing tools to prepare your data efficiently.
- **Model Selection and Evaluation:** Easily compare multiple algorithms and choose the best-performing model with our built-in evaluation metrics and visualizations.
- **Automation and Hyperparameter Tuning:** Automate repetitive tasks and optimize model performance with advanced hyperparameter tuning techniques.
- **Scalability:** Designed to handle large datasets and integrate seamlessly with big data platforms, ensuring models are ready for enterprise-level deployment.
- **Support:** Dedicated support developer to assist you in every step of your machine learning journey.

**Why Choose wiseAI?**
1. **Efficiency:** Save time and resources with automated workflows and optimized processes.
2. **Accessibility:** Make machine learning accessible to a broader audience within your organization.
3. **Flexibility:** Adaptable to various business needs and industry-specific applications.
4. **Integration:** Compatible with popular data science tools and frameworks, allowing for smooth integration into existing workflows.

**Getting Started:**
1. Install wiseAI using pip:
    ```bash
    pip install wiseAI
    ```
2. Training Model
    ```
    test_model = AutoBinaryML(
        model_name= 'test_model'
        , model_version = 'v1'
        , train_data = data
        , label = 'target'
        , time_limit = 60*5 
    )
    test_model.fit()
    ```
3. Predict 
    ```
    predicts = test_model.batch_prediction(data, 'predict')
    ```

Transform data into actionable insights with wiseAI. Start your machine learning journey today and see the difference!

---

Elevate machine learning capabilities with wiseAI, where simplicity meets power.
yt-dlp-helper 0.1.2
A wrapper for yt-dlp that downloads best quality, and ensures it's in H.264
Requires Python: >=3.6

# yt-dlp-helper

A beautiful command-line wrapper for yt-dlp with a rich interface.

## Installation

```bash
pip install yt-dlp-helper
```

To upgrade to the latest version:
```bash
pip install --upgrade yt-dlp-helper
```

## Usage

Download a video with best quality (h.264/mp4, up to 1080p):
```bash
download "https://www.youtube.com/watch?v=..."
```

Interactive format selection with automatic conversion option:
```bash
download "https://www.youtube.com/watch?v=..." --ask-format
# or
download "https://www.youtube.com/watch?v=..." -a
```

Manual format selection:
```bash
download "https://www.youtube.com/watch?v=..." --format "bestvideo[height<=1080]+bestaudio/best"
# or
download "https://www.youtube.com/watch?v=..." -f "bestvideo[height<=1080]+bestaudio/best"
```

## Features

- Beautiful progress bars and status indicators
- Smart format selection prioritizing h.264/mp4 formats
- Interactive format selection with detailed information
- Automatic format conversion to h.264/mp4 when needed
- Rich CLI interface with helpful error messages

## Format Selection

The tool prioritizes formats in the following order:
1. Best h.264/mp4 format up to 1080p
2. Best separate h.264 video + audio combination
3. Other formats with optional conversion to h.264/mp4

When using `--ask-format` or `-a`, you'll see a detailed table of available formats with:
- Resolution and FPS
- File size
- Video and audio codecs
- Bitrate information
- Format-specific notes

Formats are organized into three categories:
1. Combined formats (video + audio)
2. Video-only formats
3. Audio-only formats

You can select:
- A single format ID for combined formats
- Two format IDs (e.g., "137+251") to combine video and audio
- Non-h.264/mp4 formats with automatic conversion option

## License

MIT

## Author

Isaac Gutekunst
mrlee 0.1.0
A collection of simple and useful utilities for file and string operations.
Requires Python: >=3.7

# Introduction

Hi everyone. This is Mr. Lee and this is my first python project!

It is a collection of simple and useful utilities for file and string operations. It provides easy-to-use functions for common tasks like reading/writing files, grouping data, and regex-based string manipulation.

---

## Features

- **File Utilities**:
  - Read and write files in various formats (JSON, YAML, TOML, raw text).
  - Extract file extensions.
  - Automatically create directories for file paths.

- **String Utilities**:
  - Group items by keys.
  - Extract regex matches from strings.
  - Modify strings by removing matched patterns.

---

## Installation

You can install mrlee using `pip`:

```bash
pip install mrlee
```

Or clone from `github`:

```bash
git clone https://github.com/kevinlulee/mrlee.git
cd mrlee
pip install
```

Have fun! I can't wait to see your own python packages.
posto-sdk 3.0.5
Posto SDK for social media management
Requires Python: >=3.6

The Posto SDK makes it easy to schedule and post your content on social media networks through a simple Python or Javascript API. You can post messages immediately or schedule them for later, attach media files (images, videos), and much more.

This can be used by brands and agencies to schedule posts for multiple social media networks from a single place.

Or allow the age of agentic social media management, where AI agents can schedule and post content on social media networks autonomously.