semvec/pypi-packages huggingface dataset:
transend 0.1.1
Python Client for the Transend Automotive Tech APIs
Requires Python: >=3.8

# transend-python

![Python Tests](https://github.com/TranstarIndustries/transend-python/workflows/Python%20Tests/badge.svg)
![PyPI Version](https://img.shields.io/pypi/v/transend.svg)
![PyPI Downloads](https://img.shields.io/pypi/dm/transend.svg)

Python Client for the Transend APIs

## Installation

### From PyPI (Recommended)

```bash
pip install transend
```

### From Source

```bash
# Clone the repository
git clone https://github.com/TranstarIndustries/transend-python.git
cd transend-python

# Install dependencies
pip install -r requirements.txt

# Install in development mode
pip install -e .
```

## Usage

```python
from src.client import TransendAPIClient

# Initialize with your API credentials
api_key = "your_api_key_here"
api_token = "your_api_token_here"
client = TransendAPIClient(api_key, api_token)

# Example calls
sort_types = client.product.get_all_sort_types()
branches = client.branch.get_all_branches()
dtcs = client.vehicle.get_all_dtcs()
print(sort_types, branches, dtcs)

# Vehicle lookup
vhid = client.vehicle.get_year_make_model_vhid(2010, "Toyota", "Camry")
vehicle = client.vehicle.get_vehicle_by_vhid(vhid["vhid"])
print(vehicle)
```

## Available APIs

- **ProductAPI**: Access product information, sorting options, and tags
- **BranchAPI**: Get branch details and listings
- **VehicleAPI**: Look up vehicles by VIN, year/make/model, and access vehicle details
- **AccountAPI**: Manage customer accounts, bank accounts, and credit cards
- **ContentAPI**: Retrieve articles and resources
- **CoreAPI**: Access core information
- **CustomerAPI**: Get user information

## Running Tests

We use pytest for testing. To run the tests:

```bash
# Run all tests
python -m pytest

# Run with verbose output
python -m pytest -v

# Run a specific test file
python -m pytest tests/test_vehicle_api.py

# Run with coverage report
python -m pytest --cov=src --cov-report=term
```

## Continuous Integration

This project uses GitHub Actions to automatically run tests on every push and pull request.
The workflow runs tests on multiple Python versions (3.8, 3.9, 3.10, 3.11) to ensure compatibility.

You can view the test results in the "Actions" tab of the GitHub repository.

## Release Process

This package uses GitHub Actions to automatically publish to PyPI when a new release is created:

1. Update the version number in `setup.py`
2. Create a new release on GitHub:
   - Go to the repository's "Releases" section
   - Click "Draft a new release"
   - Choose or create a tag in the format `v{version}` (e.g., `v0.1.0`)
   - Add a title and release notes
   - Click "Publish release"
3. The GitHub Actions workflow will automatically:
   - Build the package
   - Verify the package contents
   - Upload the package to PyPI

### Setting up PyPI publishing

For the PyPI publishing to work, a PyPI API token needs to be added to the repository secrets:

1. Create an API token in your PyPI account settings
2. Add the token as a repository secret named `PYPI_API_TOKEN` in your GitHub repository settings
mcp-serverless 0.1.0
Tools for Model Context Protocol in serverless environments
Requires Python: >=3.7
Keywords: ai, model, context, protocol, serverless

# MCP-Serverless

A Python package for implementing the Model Context Protocol in serverless environments.

## About Model Context Protocol

The Model Context Protocol (MCP) is a standardized way for AI models to interact with their context, including:

- Structured communication between models and their runtime environments
- Standardized interfaces for data exchange
- Context management for AI inference in serverless environments
- Tools for efficient model deployment and scaling

## Installation

```bash
pip install mcp-serverless
```

## Quick Start

```python
from mcp_serverless import about
from mcp_serverless.core import create_mcp_context

# Print information about MCP
print(about())

# Create a context for your model
context = create_mcp_context(model_id="my-model")

# Add data to the context
context.add_context("input", "Some user input")
context.add_context("parameters", {"temperature": 0.7, "max_tokens": 100})

# Get context data
print(context.get_context())
```

## Features

- Simple API for managing model context
- Lightweight with minimal dependencies
- Designed for serverless environments

## License

MIT
ReForge 0.1.1
A 2D game engine written in Python using both PyGame, PySDL2 and PySDL3.

# ReForge [Forge IV]
A 2D game engine written in Python using PySDL2, PySDL3 and PyGame.

# Getting Started
## How to install.
```
pip install ReForge
```

# Examples
## Creating a window.
```python
import os

os.environ["REFORGE_API"] = "sdl3"

import reforge, ctypes

def reforgeEntry(argc: int, argv: list[str]) -> int:
    context = reforge.Context()
    context.makeContextCurrent()
    window = reforge.Window(title = "ReForge", width = 1200, height = 600)
    context.registerWindow(window)
    renderer = reforge.Renderer(window)
    scene = reforge.Scene()

    while not context.isTerminated():
        context.pollEvents()
        renderer.clear(reforge.Vector4(0.0, 0.0, 0.0, 255.0))
        renderer.renderScene(scene)
        renderer.present()

    context.terminate()
    return reforge.exitSuccess
```

## Rendering a rect.
```python
import os

os.environ["REFORGE_API"] = "sdl3"

import reforge, ctypes

def reforgeEntry(argc: int, argv: list[str]) -> int:
    context = reforge.Context()
    context.makeContextCurrent()
    window = reforge.Window(title = "ReForge", width = 1200, height = 600)
    context.registerWindow(window)
    renderer = reforge.Renderer(window)
    scene = reforge.Scene()

    entity = scene.createEntity()
    entity.addComponent(reforge.RectComponent(fill = False, color = reforge.Vector4(0.0, 128.0, 128.0, 255.0)))
    entity.getComponent(reforge.TransformComponent).scale = reforge.Vector2(200.0, 200.0)
    entity.getComponent(reforge.TransformComponent).position = \
        window.size / 2.0 - entity.getComponent(reforge.TransformComponent).scale / 2.0

    while not context.isTerminated():
        context.pollEvents()
        renderer.clear(reforge.Vector4(0.0, 0.0, 0.0, 255.0))
        renderer.renderScene(scene)
        renderer.present()

    renderer.terminate()
    context.terminate()
    return reforge.exitSuccess
```

## Using the low-level API.
```python
import os

os.environ["REFORGE_API"] = "sdl3"

import reforge, ctypes

def reforgeEntry(argc: int, argv: list[str]) -> int:
    context = reforge.api.Context()
    window = reforge.api.Window(title = "ReForge", width = 1200, height = 600)
    renderer = reforge.api.Renderer(window)
    inputHandler = reforge.api.Input(window)
    eventHandler = reforge.api.EventHandler()
    event = reforge.api.Event()
    running = True

    while running:
        while eventHandler.pollEvents(event):
            if event.type == reforge.api.EventType.WindowClosed:
                running = False

            inputHandler.eventHandler(event)

        if inputHandler.keyboard.keys[reforge.api.Key.Escape]:
            running = False

        renderer.clear(reforge.Vector4(0.0, 0.0, 0.0, 255.0))
        renderer.present()

    eventHandler.terminate()
    inputHandler.terminate()
    renderer.terminate()
    window.terminate()
    context.terminate()
    return reforge.exitSuccess
```