semvec/pypi-packages huggingface dataset:
rtcpy 1.6.3
fix http error for python 3.11+ 

# rtcpy

**rtcpy** is a simple and powerful Python module for building real-time communication applications. Inspired by the rtcpy standard, it allows you to handle audio, video, and P2P data with low latency and minimal syntax.

---

## Features

* **P2P Communication**: Direct data exchange between clients without a central server.
* **Audio & Video**: Real-time transmission with low latency.
* **Data Channels**: Send and receive text or JSON messages instantly.
* **Event Handling**: Simple callbacks for `on_connect`, `on_message`, `on_disconnect`.
* **Secure**: Built-in DTLS/SRTP encryption.
* **Interoperable**: Compatible with browsers and other rtcpy clients.

---

## Installation

```bash
pip install rtcpy
```



---

## Basic Usage

### Create a client and connect

```python
from rtcpy import rtcpyClient

# Initialize the client
client = rtcpyClient(username="Alice")

# Event triggered when a message is received
@client.on("message")
def handle_message(sender, content):
    print(f"{sender} says: {content}")

# Connect to a peer
client.connect("bob_peer_id")

# Send a message
client.send("bob_peer_id", "Hi Bob!")

# Listen for events
client.listen()
```

### Audio/Video example

```python
client.connect_audio()
client.connect_video()
```

---

## Use Cases

* Real-time audio and video chats
* P2P multiplayer games
* Streaming and data sharing
* Collaborative tools (drawing, shared documents)

---
wkmigrate 0.0.2.post1
wkmigrate is a Python library for converting orchestration definitions between various systems
Requires Python: <4.0,>=3.10

# Databricks Workflows Migrator (`wkmigrate`)

[![PyPi package](https://img.shields.io/pypi/v/wkmigrate?color=green)](https://pypi.org/project/wkmigrate)
[![PyPi downloads](https://img.shields.io/pypi/dm/wkmigrate?label=PyPi%20Downloads)](https://pypistats.org/packages/wkmigrate)

## Project Description
`wkmigrate` is a Python library for migrating data pipelines to Databricks workflows from various
frameworks. Users can programmatically create or migrate workflows with a simple set of commands.

Pipeline definitions are read from a user-specified source system, translated for compatibility
with Databricks workflows, and either directly created or stored in `json` or `yml` files.

## Installation

Use `pip install wkmigrate` to install the PyPi package.

## Compatibility 
`wkmigrate` is a standalone project. Using some features (e.g. serverless jobs compute options) may
require a premium-tier Databricks workspace.

## Using the Workflow Migrator
To use the `wkmigrate`, install the library using the `%pip install wkmigrate` method or install the 
Python wheel directly in your environment.

Once the library has been installed, create source and target **definition stores** for the migration.

```buildoutcfg
from wkmigrate.definition_store_builder import build_definition_store

# Create the source definition store (an ADF instance):
factory_options = {
    "tenant_id": "<TENANT_ID>",
    "client_id": "<CLIENT_ID>",
    "client_secret": "<CLIENT_SECRET>",
    "subscription_id": "<SUBSCRIPTION_ID>",
    "resource_group_name": "<RESOURCE_GROUP_NAME>",
    "factory_name": "<FACTORY_NAME>"
}
factory_store = build_definition_store(
    "factory_definition_store", 
    factory_options
)

# Create the target definition store (a Databricks workspace):
workspace_options = {
    "authentication_type": "pat",
    "host_name": "<DATABRICKS_HOST_URL>",
    "pat": "<DATABRICKS_PERSONAL_ACCESS_TOKEN>",
}
workspace_store = build_definition_store(
    "workspace_definition_store", 
    workspace_options
)                        
```

Use the `load` method to **get definitions** from a source.

```buildoutcfg
pipeline = factory_store.load(pipeline_name="<PIPELINE_NAME>")                      
```

Use `pipeline_translator.translate()` to **translate definitions** for compatibility
with Databricks workflows.

```buildoutcfg
from wkmigrate import pipeline_translator
translated_pipeline = pipeline_translator.translate(pipeline)
```

Use the ``dump`` method to **sync workflows** into a target.

```buildoutcfg
workspace_store.dump(translated_pipeline)
```
zodbc 0.9.2
DBAPI2-like ODBC client with Apache Arrow support
Requires Python: >=3.10
Keywords: odbc, arrow, mssql, sql server

# zodbc

This odbc client tries to be compatible with the DB API 2 Specification, while also treating pyarrow compatibility as a first class citizen. At the moment it is tested with the msodbc driver. Compilation and installation is made easy by ziglang being a simple build dependency. The only system dependencies for compilation should be development headers for unixodbc (if on linux) and python.


# Installation

```bash
pip install zodbc
```


# Features


## DB API 2

```py
import zodbc
import os

con = zodbc.connect(os.environ["ODBC_CONSTR"])  # Connect with odbc connection string or DSN
cur = con.cursor()  # Cursor, which translates to an odbc statement handle

# python parameters & return values, data types like str, int, bool, UUID, decimal, date, time, datetime
cur.execute("select ? a", [42])
assert cur.fetchone()[0] == 42

# Short hand alternative for getting column names from cur.description
assert [c[0] for c in cur.description] == cur.column_names == ["a"]

con.commit()  # Transactions, autocommit is disabled by default
```


## Additional fetch methods

The DB API 2 fetch methods `fetchone`, `fetchmany` and `fetchall` return (lists of) tuples. Additionally, there is `fetch_named` which returns a list of named tuples, which allows accessing fields by attribute name like `row.a` as well as `fetch_dict` which returns a list of dicts. `fetch_dict` requires unique column names in the query. These methods are implemented directly in Zig and should therefore be more efficient than fetching tuples and converting them in python.


## Apache Arrow

A query can be executed for every row in an Arrow RecordBatch.

```py
import pyarrow as pa

cur.execute("drop table if exists t1")
cur.execute("create table t1(a int)")
cur.executemany_arrow(
    "insert into t1(a) values(?)",
    pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], ["a"])
)
cur.execute("select * from t1").fetchall()  # [(1,), (2,), (3,)]
```

Arrow RecordBatches can be fetched from a query result.

```py
cur.execute("select 1 a").fetch_arrow()
```

Arrow RecordBatches can be used as a table valued parameter for MS SQL.

```py
cur.execute("drop type if exists test_tabletype")
cur.execute("create type test_tabletype as table(a int)")
con.commit()

assert cur.execute(
    "select sum(a) from ? where a <= ?",
    [
        zodbc.ArrowTVP(
            zodbc.ArrowTVPType.from_name("test_tabletype"),
            pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], ["a"]),
        ),
        2,
    ]
).fetchone()[0] == 3
```


# Differences with pyodbc

- UUID is always returned as a python UUID object (no pyodbc.native_uuid global variable)
- No output conversion (add_output_converter connection method)
- More explicit:
    - No `execute(query, param1, param2)` => params must be passed as sequence
    - No Cursor.commit, instead use Cursor.connection.commit
- Connection.getinfo takes a string instead of the odbc enum value