semvec/pypi-packages huggingface dataset:
pychatbot2 0.1.6
Python client for chatbot platform
Requires Python: >=3.8
Keywords: chatbot, python, sdk

# pychatbot2

A Python SDK for the chatbot platform, providing a clean and type-safe interface for interacting with messaging platforms.

## Features

- Type-safe interfaces using Python's type hints
- Async/await support for all operations
- Event-driven architecture using Server-Sent Events (SSE)
- Support for various message content types (text, image, audio, card)
- Comprehensive error handling and logging
- Easy integration with messaging platforms

## Installation

```bash
pip install pychatbot2
```

## Quick Start

```python
from pychatbot2 import ChatbotClient, ChatbotClientOptions, CommandRunner, Contact, ContactType, ChatMessagePayload, ChatMessagePlainContent

class MyCommandRunner(CommandRunner):
    async def on_start(self, payload):
        return {
            "self": Contact(
                contact_type=ContactType.PRIVATE,
                contact_id="user123",
                name="My Bot"
            ),
            "contacts": []
        }
    
    async def get_self(self, payload):
        return Contact(
            contact_type=ContactType.PRIVATE,
            contact_id="user123",
            name="My Bot"
        )
    
    async def get_contacts(self, payload):
        return []
    
    async def get_contact_info(self, payload):
        return {
            "name": "Test Contact",
            "members": []
        }
    
    async def send_chat_message(self, payload):
        # Implement message sending logic
        pass

# Create client options
options = ChatbotClientOptions(
    base_url="https://api.example.com",
    api_key="your-api-key",
    message_platform_type="custom",
    message_platform_account_id="account123",
    command_runner=MyCommandRunner()
)

# Create and start the client
client = ChatbotClient(options)
await client.start()

# Handle incoming messages
async def handle_message(message):
    payload = ChatMessagePayload(
        contact_type=ContactType.PRIVATE,
        contact_id="user123",
        message_id="msg123",
        sender_id="sender123",
        content=ChatMessagePlainContent(text="Hello!"),
        mentioned=False
    )
    await client.on_receive_chat_message(payload)
```

## Development

### Setup

1. Clone the repository
2. Install development dependencies:
   ```bash
   pip install -e ".[dev]"
   ```

### Running Tests

```bash
pytest
```

### Code Style

This project uses:
- Black for code formatting
- isort for import sorting
- mypy for type checking

Run the formatters:
```bash
black .
isort .
```

## License

MIT License
async-apple-checker 0.0.1
A package to check apple related certificates (p12 & mobileprovision) asyncronously.
Requires Python: >=3.10

# Async Apple Checker

[![PyPI version](https://badge.fury.io/py/async-apple-checker.svg)](https://pypi.org/project/async-apple-checker/)

An asynchronous Python library to check Apple `.p12` certificates and `.mobileprovision` profiles. It verifies OCSP status, extracts certificate metadata, and analyzes entitlements.

## 🔧 Installation

```bash
pip install async-apple-checker
```

## ✨ Features

- ✅ Extract certificate metadata from `.p12` and `.mobileprovision`
- 🔐 Check OCSP status using Apple CA certificates
- 📱 Analyze provisioning profile entitlements
- ⚡ Caching with `@alru_cache` for performance

## 🚀 Quick Usage

```python
from async_apple_checker import check_p12, check_mobileprovision

# Check a .p12 certificate
with open("certificate.p12", "rb") as f:
    result = await check_p12(f.read(), password="your_password")
    print(result)

# Check a .mobileprovision file
with open("profile.mobileprovision", "rb") as f:
    result = await check_mobileprovision(f.read())
    print(result)
```
pylawson 0.3
Infor Lawson IOS API Wrapper
Keywords: infor, lawson, erp

# pylawson

This package exposes a Python API to connect to Infor Lawson IOS services.

The `pylawson.client` package contains Session objects for authenticating on the lawson server:
`sec_api.SecApiSession` for Windows utilizes the `sec-api.dll` library which is installed with
the Lawson Excel Add-Ins; and `ms_samlpr.SamlSession` which uses `requests` to robotically
authenticate through the SAML login session.

Simple use:

First create a json file with connection details (each value is optional and can alternatively
be passed directly to the session instantiation):

```json
{
  "lawson": {
    "lawson_server": "https://target.resource/sso/SSOServlet",
    "ident_server": "http://identity.provider/adfs",
    "ident_host": "identity.provider",
    "username": "username",
    "password": "password"
  }
}
```

Then write a couple of lines of code:

```python
from pylawson.client import SamlSession as Ios

lawson = Ios(json_file='./pylawson.json')
response = lawson.tokens({'systemCode': 'GL'})
```

This authenticates on the server and returns Lawson's XML response in a string with the result
of a ListTokens action for the GL system.

**NOTE:** The IOS URLs and parameters are documented in Infor's *'Doc for Developers: IOS Application
Program Interfaces--Windows'* available on the Infor Xtreme support site.