semvec/pypi-packages huggingface dataset:
AirfoilEditor-test-jxjo 4.0.0a1
View, Modify, Optimize Airfoils
Requires Python: >=3.12

![AE](https://github.com/jxjo/AirfoilEditor/blob/main/images/AirfoilEditor_logo.png?raw=true)

### Version 4

---

The **AirfoilEditor** serves as a fast airfoil viewer and an advanced geometry editor including Xoptfoil2-based optimization. The App provides three operating modes:

#### View
* Browse and view airfoils in subdirectories
* Analyse curvature of airfoil surface
* Show polars generated using XFOIL

#### Modify
* Repanel and normalize airfoils
* Adjust thickness, camber, high points, and trailing edge gap
* Blend two airfoils
* Set flap
* Generate airfoil replicas using Bezier curves.

#### Optimize
* User Interface of [Xoptfoil2](https://github.com/jxjo/Xoptfoil2)
* Graphical definition of polar based objectives
* View results while optimizing

The app was initially developed to address artefacts found in other tools like Xflr5 when using xfoil geometry routines. The aim has been an intuitive, user-friendly experience that encourages exploration.
The app, developed in Python with the Qt UI framework, runs on Windows, Linux, and MacOS. Linux and MacOS users are required to compile the underlying programs for polar viewing and airfoil optimization - see 'Installation' for details.

Find more info about the AirfoilEditor on [Github](https://github.com/jxjo/AirfoilEditor) ...
luk-sdk 1.0.0
LukSDK Python - 游戏平台接入SDK
Requires Python: >=3.8
Keywords: api, game, luksdk, sdk

# LukSDK for Python

本项目为 Python 版本的 LukSDK，提供游戏平台接入所需的数据结构定义、API 调用接口和控制事件构造工具。

## 安装

```bash
pip install luk-sdk
```

## 示例代码

参考示例文件：[SDK 初始化和 API 调用示例](./example/main.py)
uuid-extension 0.2.0
UUID7 Extension for Python
Requires Python: >=3.8

# UUID Extension for Python

A Python library implementing UUID version 7 as specified in the RFC, providing time-ordered UUIDs for modern applications.

## Features

- Full implementation of UUID version 7
- Time-ordered UUIDs for better database performance
- Compatible with standard Python UUID objects
- Timestamp extraction capabilities
- Optional counter for monotonicity within milliseconds

## Installation

```bash
pip install uuid-extension
```

## Usage

### Basic Usage

```python
from uuid_extension import uuid7

# Generate a new UUID7
uuid = uuid7()
print(uuid)  # e.g., 018c1585-5e7c-7601-b322-5bf9f7478708

# Access the underlying UUID object
uuid_obj = uuid.uuid7
```

### With Timestamp

```python
from datetime import datetime
from uuid_extension import uuid7

# Generate UUID7 with a specific timestamp
custom_time = datetime.now()
uuid = uuid7(timestamp=custom_time)

# Or with Unix timestamp
uuid = uuid7(timestamp=1690000000.123)
```

### With Counter

```python
from uuid_extension import uuid7

# Use a counter for guaranteeing monotonicity within the same millisecond
counter = 1
id1 = uuid7(counter=counter)
counter += 1
id2 = uuid7(counter=counter)
```

### Time Extraction

```python
from uuid_extension import uuid7

uuid = uuid7()

# Extract timestamp as float (Unix timestamp in seconds)
ts = uuid.to_timestamp()

# Extract as datetime object (UTC timezone by default)
dt = uuid.to_datetime()

# Extract as datetime with a specific timezone
import pytz
dt_est = uuid.to_datetime(tz=pytz.timezone('US/Eastern'))
```

### Comparison Operations

UUID7 objects support standard comparison operations:

```python
id1 = uuid7()
id2 = uuid7()

print(id1 == id2)  # False
print(id1 < id2)   # True (usually, as they're time-ordered)
print(id1 <= id2)  # True
```

## Technical Details

UUID version 7 structure:
- 48 bits of Unix timestamp in milliseconds
- 4 bits for version (set to 7)
- 2 bits for variant (set to 0b10)
- 74 bits of random data for uniqueness

## License
MIT License

<!-- ## Contributing

[Contribution guidelines here] -->
craite-sdk 1.0.2
CRAITE Python SDK - AI-powered Web3 code generation
Requires Python: >=3.8

# CRAITE Python SDK

Web3 AI development in Python.

## Installation

```bash
pip install craite-sdk
Quick Start
pythonfrom craite import create_client

# Initialize client
client = create_client("your-api-key")

# Generate smart contract
result = client.generate("Create an ERC-20 token with burn function")
print(result["code"])
Features

🚀 Simple API for Web3 code generation
🔧 Support for multiple LLM providers
🎯 14+ specialized MCP tools
📦 Multi-language output (Solidity, Rust, etc.)
⚡ Async support

Documentation
Full documentation at https://craite.xyz/docs
trim-trim 0.2.0
Trim SDK.
Requires Python: >=3.10

# 🧠 Trim LangChain SDK

**Trim LangChain** is a lightweight, OpenAI-compatible SDK designed for smart routing and efficient interaction with LLMs. It integrates seamlessly with LangChain agents, chat models, and OpenAI-style APIs.

---

## 📦 Installation

Install the SDK via pip:

```bash
pip install trim-sdk
```

---

## 🚀 Quick Start

---

### 🔐 Environment Variables

To use the SDK, you need to set the following environment variables in a `.env` file or your system environment:

```env
TRIM_API_KEY=your_trim_api_key_here
OPENAI_API_KEY=your_openai_api_key_here
```

- **`TRIM_API_KEY`**: Your API key for authenticating with the Trim backend.
- **`OPENAI_API_KEY`**: Your OpenAI API key used internally by Trim to route to OpenAI models.

Make sure to load these using Python's `dotenv`:

```python
from dotenv import load_dotenv
load_dotenv()
```

### 🔗 LangChain ReAct Agent

```python
from dotenv import load_dotenv
from langgraph.prebuilt import create_react_agent

from examples.utils import print_agent_response
from trim import TrimChatModel

load_dotenv()


def calculator(expression: str) -> str:
    """Evaluates a basic math expression."""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"Error: {e}"


llm = TrimChatModel()

agent = create_react_agent(model=llm, tools=[calculator])

response = agent.invoke({"messages": "What is (12 * 3) + 5?"})
print_agent_response(response['messages'])
```

---

### 💬 LangChain `ChatModel`

```python
from trim import TrimChatModel
from dotenv import load_dotenv

load_dotenv()

llm = TrimChatModel()

response = llm.invoke([
    {"role": "user", "content": "Tell me about Elon Musk in 20 words"}
])

print(response.content)
```

---

### 🧩 OpenAI-Compatible API

```python
from trim import TrimClient
from dotenv import load_dotenv

load_dotenv()

client = TrimClient()

# Way 1: Simple completion
completion = client.responses.create(
    model="gpt-4.1",
    input="Write a one-sentence bedtime story about a unicorn."
)
print(completion.output_text)

# Way 2: Chat completion
completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Write a one-sentence bedtime story about bears"}]
)
print(completion.choices[0].message.content)
```

---

### 🧠 LangChain `LLM` Wrapper

```python
from trim import TrimLLM
from dotenv import load_dotenv

load_dotenv()

llm = TrimLLM()

prompt = "Explain quantum computing in less than 20 words."

result = llm.invoke(prompt)
print(result)
```

---

## 📚 Documentation

Coming soon. For now, explore the `examples/` directory for use cases and integration patterns.

---

## 🤝 Contributing

Contributions are welcome! Please open issues or submit pull requests.

---

## 🛡️ License

MIT License
asmx 0.1.2
ASMX - A macro assembler and virtual machine platform running on Scratch
Requires Python: >=3.7

# ASMX
ASMX is a development platform, comprised of a modular assembler, and a VM which runs on [Scratch](https://scratch.mit.edu/).
It allows you to write simple programs in a custom assembly-like language, and then execute them in an educational and visual environment.
ASMX is perfect for people who want to learn how computers work with low-level programming, people looking to contribute to a project for the first time, or people who want to create interesting projects whilst still using Scratch.

---

## Features
- ⚙️ **Macro-based Assembler** - Powerful macro system with modular namespaces and grammar extensions
- 🧱 **Scratch VM** - The virtual machine is implemented in Scratch, making it visual, easy to experiment with, and beginner-friendly
- 📦 **Package System** - Create and load your own macro packages, allowing you to extend the instruction set
- 🕹️ **Demo Projects Included** - Demo projects like Rock Paper Scissors are included to help you learn and experiment
- 💡 **Made For Learning** - Built with simplicity and education in mind, perfect for exploring how computers work

---

## Getting Started

### 🧰 Requirements
- Python 3.8 or above
- A local clone/copy of this repo

### 🚀 Quick Start
To download ASMX, run:

```
pip install asmx
```

Congrats, you just installed ASMX! Open up the guide, by running:

```
asmx --docs
```

Then click on the Guide section.

## Project Structure
```
asmx/
├── asmx_core/           # Core Python package (assembler logic, macro dispatcher, parser, etc.)
│   ├── macros.py
│   ├── parser.py
│   └── packages/        # User-defined + Standard library packages
├── docs/                # Documentation for ASMX
├── asmx.py              # Entry point, run this file
README.md
setup.py
setup.cfg
...
```

## Documentation
Documentation is built with [MkDocs.](https://www.mkdocs.org/) To open the documentation, run:

```
asmx --docs
```

If you are looking to contribute to the documentation, go to the [asmx-docs repo.](https://github.com/cousdev/asmx-docs/)

## Contributing
All contributions are welcome! You could:
- Fix bugs
- Write documentation
- Create new packages
- Submit new demo programs or games
- Help add new features
- Simplify code
- Write tests
- Expand the VM's capabilities

If you're interested, just open an issue or pull request. Make sure your code is clean and commented where necessary.

## License
This project is licensed under the MIT License. See the `LICENSE` file for details.

## ⚠️ Important Note
The ASMX project is still in early development - expect changes and bugs!