semvec/pypi-packages huggingface dataset:
yala-events-mcp 0.2.1
YALA Events MCP Server with stdio transport
Requires Python: >=3.11

# Yala Events MCP Server

A Model Context Protocol (MCP) server for Yala Events that provides access to events, organizations, roles, and other Yala Events API features.

## Installation

```bash
pip install yala-events-mcp
```

## Usage

### Command Line

1. Set up your environment variables in a `.env` file:

```env
YALA_EVENTS_API_TOKEN=your_api_token
BASE_URL=https://api.yala.events
```

2. Run the server in stdio mode:

```bash
yala-events-mcp
```

### Claude Desktop Configuration

Add this to your Claude Desktop configuration (`claude_desktop_config.json`):

```json
"yala-events-mcp": {
  "command": "python3",
  "args": ["-m", "yala_events_mcp.server"],
  "env": {
    "YALA_EVENTS_API_TOKEN": "your_api_token",
    "BASE_URL": "https://api.yala.events"
  }
}
```

## Available Tools

- List Events
- Create Event
- Get Event Details
- Get Organizations
- List Histories
- List/Create/Update/Delete Modules
- List/Create/Update/Delete Permissions
- List/Create/Update/Delete Roles
- Manage Favorite Events
- Manage Personal Access Tokens
- List Public Organizations
- Get App Version
- Health Check

## License

MIT License
iracing-mcp 0.1.2.dev3
A model context protocol server to chat with iRacing data.
Requires Python: >=3.11.8

# iRacing MCP

iRacing MCP is a Python-based project that integrates iRacing with the Model Context Protocol (MCP). It provides tools and resources to interact with iRacing data and build custom applications.

## Features

- Retrieve iRacing profile statistics.
- Get iRating chart (for any category)
- More coming soon

## Getting Started

### Prerequisites

- uv - [Install here](https://docs.astral.sh/uv/getting-started/installation/)
- iRacing account with legacy authentication (required) - Enable it here: <https://oauth.iracing.com/accountmanagement/security>

## Usage

### Running the Server Standalone

To start the MCP server, run:

```bash
IRACING_USERNAME="your username" IRACING_PASSWORD="your-password" uvx iracing-mcp
```

### Running the Server on VSCode

Add this to your settings.json (in `mcp.servers`):

```json
"iracing": {
    "command": "uvx",
    "args": [
        "iracing-mcp@latest"
    ],
    "env": {
        "IRACING_USERNAME": "your@email.com",
        "IRACING_PASSWORD": "your password"
    }
}
```

### Running the MCP Server on Claude Desktop

Add this to your settings.json:

```json
[
    "mcpServers": {
        "iracing": {
            "command": "uvx",
            "args": [
                "iracing-mcp@latest"
            ],
            "env": {
                "IRACING_USERNAME": "your@email.com",
                "IRACING_PASSWORD": "your-password"
            }
        }
    }
}
```

### Running the Server on other MCP Clients

Currently I am only using VS Code as MCP Client so I don't know how to configure to other MCP Clients.
I am happy to receive PRs on how to configure in the different MCP Servers (e.g. Cursor, Claude Desktop, etc.)

### Development

1. Clone the repository:

   ```bash
   git clone https://github.com/musantro/iracing-mcp.git
   cd iracing-mcp
   ```

2. Create environment with dependencies:

   ```bash
   uv sync
   ```

3. Set up environment variables for iRacing credentials:

   ```bash
   export IRACING_USERNAME="your_username"
   export IRACING_PASSWORD="your_password"
   ```

#### Linting and Formatting

Use the following commands to lint and format the code:

```bash
make
```

## Contributing

We welcome contributions! Follow these steps to contribute:

1. Fork the repository.
2. Create a new branch for your feature or bugfix.
3. Push your branch.
4. Open a pull request.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
django-mjml-email 0.1.0
Use mjml in your Django project
Requires Python: >=3.10

# Django MJML Email

Django MJML Email is a package that allows Django developers to write email 
templates using the MJML language. This tool simplifies the creation of
responsive and well-structured emails.

## What is MJML?
From the [documentation](https://documentation.mjml.io/) of the project:
> MJML is a markup language designed to reduce the pain of coding a responsive 
> email. Its semantic syntax makes it easy and straightforward and its rich 
> standard components library speeds up your development time and lightens your 
> email codebase. MJML’s open-source engine generates high quality responsive 
> HTML compliant with best practices.

## Then what?

While the original compiler is written in Javascript and runs on Node.js, this
package leverages [mrml](https://github.com/jdrouet/mrml), a rust implementation
of `mjml` through [mjml-python](https://github.com/mgd020/mjml-python).

The rust port is almost complete, it lacks a single feature:
https://github.com/jdrouet/mrml?tab=readme-ov-file#missing-implementations

## Requirements

- Python >= 3.12
- Django >= 4.2
- mjml-python == 1.3.5

## Installation

To install the package, run the following command:

```bash
pip install django-mjml-email
```

## Configuration

To start using `django-mjml-email`, you must configure a mail backend in your 
settings. If you're using SMTP to send your emails:

```python
EMAIL_BACKEND = "django_mjml_email.backend.SMTPMJMLEmailBackend"
```

If you're using any other email backend, you should define your custom backend 
and then refer to it in `settings.py`.

```python
# yourproject/my_email_backend.py
from django.core.mail.backends.console import EmailBackend

from django_mjml_email.mjml_email import MJMLEmailMixin


class MyEmailBackend(MJMLEmailMixin, EmailBackend):
    pass

```
```python
# settings.py
# ...
EMAIL_BACKEND = "my_email_backend.MyEmailBackend"

```

**Only Django builtin backends are tested**, so if you're using AnyMail or any
other email backend, please report any problem in the issues.



## Usage

You can create email templates using MJML. For example, create a file named `email_template.mjml`:

```mjml
<mjml>
  <mj-body>
    <mj-section>
      <mj-column>
        <mj-text>
          Welcome to our application!
        </mj-text>
      </mj-column>
    </mj-section>
  </mj-body>
</mjml>
```

In your Django code, you don't need anything special to send it:

```python
from django.core.mail import send_mail
from django.template.loader import get_template

template = get_template("email_template.mjml")
send_mail(
    "It works!",
    template.render(),
    "MJML Sender <from@example.com>",
    ["to@example.com"],
)

```

## Contributions

Contributions, bug reports, and suggestions are welcome! Feel free to open an 
issue or submit a pull request.

## License

This project is distributed under the BSD 3-Clause Clear License. See the 
`LICENSE` file for more details.
hatch-conda-build 0.1.2
A Hatch plugin to enable building a conda package from your pyproject.toml without having to write a separate conda build recipe meta.yaml file
Requires Python: >=3.9

# hatch-conda-build

Conda package builder for [Hatch](https://hatch.pypa.io/latest/). Hatch is modern, extensible Python project manager.

## Usage

Add `hatch-conda-build` within the build-system.requires field in your pyproject.toml file.

```toml
[build-system]
requires = ["hatchling", "hatch-conda-build"]
build-backend = "hatchling.build"
```

Additionally `conda-build` must be in your current path when running a
hatch build.

`hatch-conda-build` uses [grayskull](https://github.com/conda/grayskull) to translate the requirements section of your `pyproject.toml`, which
specifies dependencies on PyPi, to appropriate conda package names.

### Building Conda Package

The [builder plugin](https://hatch.pypa.io/latest/plugins/builder/reference/) defines the `conda` target.

To start build process, run `hatch build -t conda`:

```shell
$ hatch build -t conda
[conda]
...
```

### Installing the local package

The ouptut package is written to the `dist/conda` directory. This directory is a fully-indexed
conda channel and can be used to install the package.

```shell
$ conda install -c ./dist/conda <package-name>
```

## Conda-build Options

Additional builder configuration can be set in the following TOML
header.

```toml
[tool.hatch.build.targets.conda]
...
```

Following table contains available customization of builder behavior.

| Option                | Type      | Default         | Description                                      |
|:----------------------|:----------|:----------------|:-------------------------------------------------|
| channels              | list[str] | ['conda-forge'] | Channels used for package build and testing      |
| default_numpy_version | str       | None            | numpy version, otherwise use conda-build default |

### Modifying the generated recipe

You can specify [recipe metadata](https://docs.conda.io/projects/conda-build/en/latest/resources/define-metadata.html) keys in following TOML header

```tml
[tool.hatch.build.targets.conda.recipe]
...
```

Recipe metadata is defined in TOML syntax. The metadata is merged using [deepmerge](https://deepmerge.readthedocs.io/en/latest/index.html) with the following strategies

```python
recipe_merger = Merger(
    type_strategies=[
        (dict, ["merge"]),
        (list, ["append"])
    ],
    fallback_strategies=["override"],
    type_conflict_strategies=["override"]
)
```

Most importantly, this will append list values if the key already exists. For example you can use nested key TOML
syntax:

```toml
[tool.hatch.build.targets.conda.recipe]
requirements.run = ["anaconda-anon-usage"]
test.imports = ["my_package"]
```

will *append* the package name `anaconda-anon-usage` to the autogenerated run requirements and inject the `test`
section into the recipe before it is built.


## License

Plugin hatch-conda-build is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
OKAppleAPI 1.5.2
OK App Store Connect API
Requires Python: ~=3.7
Keywords: ios ok apple appstore app store connect api appstoreconnectapi

# OK App Store Connect API

仅支持 >=Python3.7

Apple官方API文档：<https://developer.apple.com/documentation/appstoreconnectapi>

同时，也借鉴了 [appstoreconnect库](https://pypi.org/project/appstoreconnect/) 的设计；

## 安装

```shell
pip3 install OKAppleAPI
```

## 功能

profile，即mobileprovision文件；  
device，即设备（iPhone、iPad等），包括设备的name、UDID信息；

* 获取profile列表；
* 删除一个profile；
* 创建一个profile；
* 获取bundleId列表；
* 获取Certificate证书信息列表；
* 获取device列表；
* 注册一个新device

## 使用

```python

from okappleapi.apple_api_agent import APIAgent, TokenManager
from okappleapi.models import *
from pathlib import Path

# key参数 支持key文件内容，或者key文件路径（即*.p8文件路径）
token_manager = TokenManager(issuer_id='xxx', key_id='xxx', key='xxx')
# TokenManager.from_json(key_path)  # 读取配置文件来创建对象

agent = APIAgent(token_manager)

# 获取certificates列表
cer_list = agent.list_certificates()
for tmp_cer in cer_list:
    print(f'{tmp_cer.id}, {tmp_cer.attributes.__dict__}')

# 获取bundle_id列表
bundle_id_list = agent.list_bundle_id()
for tmp_id in bundle_id_list:
    print(f'{tmp_id.id}, {tmp_id.attributes}')

# 获取device设备列表
device_list = agent.list_devices()
for tmp_device in device_list:
    print(tmp_device.__dict__)

# 获取profile列表
profile_list = agent.list_profiles()
for index, tmp_profile in enumerate(profile_list, start=1):
    print(f"profile: {index}. {tmp_profile.id}, {tmp_profile.attributes.name}")

# 创建profile
attrs = ProfileCreateReqAttrs('test_hello')
result = agent.create_a_profile(attrs, bundle_id=bundle_id_list[0], devices=device_list, certificates=cer_list)
print(f'create profile: {result.id}, {result.attributes.name}')

# 删除刚创建的profile
agent.delete_a_profile(result.id)

# 添加一个iOS新设备
device_name = 'xxx'
device_udid = 'xxx'
result = agent.register_a_device(DeviceCreateReqAttrs(device_name, device_udid))
print(result)


# 更新一个profile
from okappleapi.ok_agent import OKProfileManager

profile_name = 'test_hello'
bundle_id_str = 'com.oksw.hellotest'
ok_agent = OKProfileManager.from_token_manager(token_manager)
ok_agent.update_profile(profile_name, bundle_id_str=bundle_id_str)


```

## 待完成

1. 处理所有时间的时区问题；
pybinary 0.9.6
Better binary serialization for python
Requires Python: >=3.10

# pybinary
A simple binary serializer/deserializer in pure python.

## Limitations
Variable-sized fields are not supported. No size check on assignment for the most of the types.

## Installation 
Install from pypi:
```
pip install pybinary
```

Or download the repository and build from the sources:
```
python3 ./setup.py build
python3 ./setup.py install
```

## Examples
### ELF64 header
Spec taken from https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html

```
class Elf64_Ehdr(BinarySerializable):
    e_ident = ArrayTypes.bytearray(16)
    e_type = Types.u16
    e_machine = Types.u16
    e_version = Types.u32
    e_entry = Types.u64
    e_phoff = Types.u64
    e_shoff = Types.u64
    e_flags = Types.u32
    e_ehsize = Types.u16
    e_phentsize = Types.u16
    e_phnum = Types.u16
    e_shentsize = Types.u16
    e_shnum = Types.u16
    e_shstrndx  = Types.u16


header = Elf64_Ehdr.deserialize(input_stream_or_bytes) # deserialize header
header.e_phnum += 1 # update any field
header.serialize() # serialize and get updated bytes
...

```

### CPIO Newc ACII Format Archive 

Spec taken from https://manpages.ubuntu.com/manpages/bionic/man5/cpio.5.html

[Code here](https://github.com/lim8en1/pybinary/blob/main/examples/cpio.py)