semvec/pypi-packages huggingface dataset:
llm-adapters 8.14.1
Adapters as API gateways to Different LLM Models
Requires Python: <4.0,>=3.11

# LLM Adapters

LLM Adapters provides a unified interface for interacting with various language model APIs, supporting both synchronous and asynchronous operations. Whether you're using OpenAI, Claude, or other providers, this library simplifies integration and offers flexibility in usage.

## Installation

To install llm-adapters for use in your projects, simply run:

```bash
pip install llm-adapters
```

## Usage

Package is using OpenAI SDK format, so you can use it as a drop in replacement for the OpenAI SDK, just need to change the import. It works both for synchronous and asynchronous clients.

```python
from llm_adapters import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
  model="claude-3-5-sonnet-20241022",
  messages=[
    {"role": "developer", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello!"}
  ]
)

print(completion.choices[0].message)

```

Note: If you plan to contribute to this project, you'll need Poetry to set up the development environment. After cloning the repository, run:

```bash
poetry install
poetry run pre-commit install
```

## Getting Started

### Prerequisites

- Python 3.11+
- [Poetry](https://python-poetry.org/docs/#installation) (if using Poetry)

### Setup

1. Copy `.env-example` to `.env` and fill in the necessary environment variables.

## Supported Models

Adapter paths follow the format `provider/vendor/model_name`. Use `AdapterFactory.get_supported_models()` to retrieve all supported models. For any model, calling `.get_path()` will return its adapter path.

## Configuration and Environment

LLM Adapters can be customized via environment variables. For example, configure the HTTP client settings with:

```env
ADAPTERS_MAX_KEEPALIVE_CONNECTIONS_PER_PROCESS = 100
ADAPTERS_MAX_CONNECTIONS_PER_PROCESS = 1000
ADAPTERS_HTTP_CONNECT_TIMEOUT = 5
ADAPTERS_HTTP_TIMEOUT = 600
```

To override base URLs for testing or specific setups:

```env
_ADAPTERS_OVERRIDE_ALL_BASE_URLS_ = "https://new-base-url.com/api"
```

## Testing and Pre-commit

- Run tests with:

```bash
poetry run pytest
```

- Validate code using pre-commit hooks:

```bash
poetry run pre-commit run --all-files
```

## Contributing

We welcome contributions! To contribute:

1. Fork the repository.
2. Create a branch for your feature or bug fix.
3. Update tests and documentation as necessary.
4. Run existing tests and pre-commit checks.
5. Submit a pull request.

## Versioning

This project adheres to [Semantic Versioning](https://semver.org).

## Additional Resources

For complete documentation and a list of supported models, please visit our [Documentation Site](https://withmartian.github.io/llm-adapters/).

Happy coding!
atc24-py 0.1.3
A Python wrapper for the ATC24 24data API.
Requires Python: >=3.8

# atc24-py

<p align="center">
  <a href="https://pypi.org/project/atc24-py/"><img alt="PyPI" src="https://img.shields.io/pypi/v/atc24-py?color=blue&label=pypi%20package"></a>
  <a href="https://github.com/niranjanskumaar/atc24-py/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/pypi/l/atc24-py?color=green"></a>
  <a href="https://discord.gg/jRGCzyRj5T"><img alt="Discord" src="https://img.shields.io/discord/1103012748994023536?logo=Discord&label=Discord"></a>

</p>

An asynchronous Python wrapper for the ATC24 `24data` API.

## Features

* Asynchronous client built on `asyncio`, `httpx`, and `websockets`.
* Event-driven architecture using decorators (`@client.event`) for WebSocket data streams.
* Dual-mode operation for connecting to either the main or event server (`Client(event_mode=True)`).
* All API responses are parsed into Pydantic models for type safety.
* Provides methods for all REST and WebSocket endpoints.

## Installation

The package is available on PyPI:

```bash
pip install atc24-py
```
## Usage

### Main Server (Default)
The client connects to the main server by default.

```python
import asyncio
from atc24 import Client, FlightPlan, ControllerPosition

client = Client()

@client.event
async def on_ready():
    print("Client connected.")

@client.event
async def on_flight_plan(plan: FlightPlan):
    print(f"New Flight Plan: {plan.callsign} from {plan.departing} to {plan.arriving}")

@client.event
async def on_controllers(controllers: list[ControllerPosition]):
    active_count = sum(1 for c in controllers if c.is_active)
    print(f"Active Controllers: {active_count}")

async def main():
    await client.start()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("Client stopped.")
```

### Event Server
To connect to the event server, initialize the client with `event_mode = True`.

```python
import asyncio
from atc24 import Client, FlightPlan

# Initialize in event mode
client = Client(event_mode=True)

@client.event
async def on_event_flight_plan(plan: FlightPlan):
    """
    This listener only works in event_mode.
    Registering it in normal mode will raise a ConfigurationError.
    """
    print(f"[EVENT] New Plan: {plan.callsign}")

# ...
```

## License
This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for details.
codeless-django 1.0.2
A Django app to create django apps, models, urls, views , api-views, documentation in a single click
Requires Python: >=3.7

# CodeLess-Django

**CodeLess-Django** is a powerful Django tool that lets you build Django apps, models, fields, and APIs using a graphical interface—without writing repetitive boilerplate code. It's ideal for rapid prototyping, educational projects, and accelerating development.

---

## ✨ Features

* Create Django apps via UI
* Add models and fields dynamically
* Supports API Views and Template Views
* Auto-handles `INSTALLED_APPS`, serializers, views, and URLs
* Modern, responsive interface

---

## 📦 Installation

Install CodeLess-Django with pip:

```bash
pip install codeless-django
```

---

## ⚙️ Quick Start

1. **Add to your ****************************************`INSTALLED_APPS`****************************************:**

```python
# settings.py
INSTALLED_APPS = [
    ...
    'codeless_django',
]
```

2. **Include URLs in your project:**

```python
# urls.py
from django.urls import path, include

urlpatterns = [
    ...
    path('codeless-django/', include('codeless_django.urls')),
]
```

3. **Run the development server:**

```bash
python manage.py runserver
```

4. **Visit:** [http://127.0.0.1:8000/codeless-django/](http://127.0.0.1:8000/codeless-django/)

---

## 🖼️ Screenshots

![image.png](https://github.com/omariut/codeless-django/blob/main/image.png)

### 🔹 App Creation Interface

* **Type your app name** in the input field.

---
![image2.png](https://github.com/omariut/codeless-django/blob/main/image2.png)
### 🔸 Model and Field Builder
After creating the app:
* You’ll see your app in the right panel (e.g., `user`).
* Under "Add Model", type your model name and click **`Add Model`**.
* Click the model name (e.g., `User`) to expand it.
* Now:

  * Click **`Add Field`** to define model fields like `CharField`, `IntegerField`, etc.
  * Set the field name and options (e.g., `max_length`, `default`, `null`).
* Optionally, click **`Add Meta`** to add class-level options like `ordering` or `verbose_name`.

Repeat this process for as many models and fields as you need.

---

## ✅ Final Step: Create Apps

After adding all your models and fields:

* Hit the **`Create Apps`** button to generate files.
* Select:

  * ✅ `API View` – if you want REST API views generated.
  * ✅ `Template Views` – if you want generic HTML views generated.
* Your Django app will now include:

  * `models.py`
  * `serializers.py` (if API View checked)
  * `views.py`
  * `urls.py`
  * `admin.py`
*

---

## 🤝 Contribution

We welcome contributions! Feel free to open issues, suggest improvements, or submit PRs.

---

## 🛠️ License

MIT License