semvec/pypi-packages huggingface dataset:
my-socket-library 0.1.0
Библиотека для клиент-серверного взаимодействия через сокеты
Requires Python: >=3.6

# My Socket Library

Это библиотека для клиент-серверного взаимодействия через сокеты.

## Установка

Установите библиотеку с помощью pip:

```bash
pip install my_socket_library
trackmania-nations-forever-client 0.1.1
An XML RPC client for Trackmania Nations Forever dedicated servers.

# TrackMania Nations Forever Client

This Python client is intended to be used with the TM Nations Forever remote procedure endpoint.

The available methods are documented at [ListMethods](/ListMethods.html).

It has been built for the dedicated server version of `2011-02-21`.

The hardcoded TrackMania RPC method calls have been AI generated and mostly not tested!

## Usage Example

```python
from trackmania_client import TrackManiaClient as TMClient
import asyncio

async def main():
  HOST = 'localhost'
  PORT = 5000

  async with TMClient(HOST, PORT) as client:
    print('Connected!')
    await client.authenticate('SuperAdmin', 'SuperAdmin')
    print('Authenticated!')

    version = await client.get_version()
    print(f'Version: {version}')
    status = await client.get_status()
    print(f'Status: {status}')
    player_list = await client.get_player_list(100, 0)
    print(f'Players: {player_list}')


if __name__ == '__main__':
  asyncio.run(main())
```

If no response is received after the default timeout of 10 seconds a `TimeoutError` is raised.

## Callback Usage
```python
from trackmania_client import TrackManiaClient as TMClient
import asyncio

def callback_handler(callback: str, data: tuple):
  print(f'Callback: {callback}, {data}')

async def main():
  HOST = 'localhost'
  PORT = 5000

  async with TMClient(HOST, PORT) as client:
    print('Connected!')
    await client.authenticate('SuperAdmin', 'SuperAdmin')
    print('Authenticated!')

    client.register_general_callback_handler(callback_handler)

    result = await client.enable_callbacks()
    print(f'Callbacks enabled: {result}')

    echo = await client.echo()
    print(f'Echo: {echo}')

    client.unregister_general_callback_handler(callback_handler)

    result = await client.disable_callbacks()
    print(f'Callbacks disabled: {result}')

    echo = await client.echo()


if __name__ == '__main__':
  asyncio.run(main())
```

Output:
```
Connected!
Authenticated!
Callbacks enabled: True
Callback: TrackMania.Echo, echo param 2
Echo: True
Callbacks disabled: True
```

Handlers can also be registered to specific callbacks:
```python
from trackmania_client import TrackManiaCallback as TMCallback

client.register_callback_handler(TMCallback.ECHO, echo_callback_handler)
client.unregister_callback_handler(TMCallback.ECHO, echo_callback_handler)
```
fastapi-cloudflare-access-jwt 0.1.1
FastAPI middleware for Cloudflare Access JWT authentication
Requires Python: >=3.12
Keywords: authentication, cloudflare, fastapi, jwt, middleware

# FastAPI bearer class for Cloudflare Access (Argo Tunnel)

A FastAPI middleware for authenticating requests from Cloudflare Access (formerly Argo Tunnel) using JWT tokens.

## Why?

When using Cloudflare Access to protect your FastAPI application, you need to validate the JWT tokens that Cloudflare Access sends with each request. This package provides a simple way to validate these tokens and protect your FastAPI routes.

## Installation

```sh
pip install fastapi-cloudflare-access-jwt
```

## Usage

1. Set up your environment variables:

```sh
export CF_ACCESS_CERTS_URL="https://your-team-name.cloudflareaccess.com/cdn-cgi/access/certs"
export CF_ACCESS_POLICY_AUD="your-application-audience-tag"
```

2. Use in your FastAPI application:

```python
from fastapi import FastAPI, Depends
from cloudflare_access_jwt import enforce_cf_access

app = FastAPI(dependencies=[Depends(enforce_cf_access)])

@app.get("/protected")
async def protected_route():
    return {"message": "This route is protected by Cloudflare Access"}

# Or protect specific routes:
@app.get("/also-protected")
async def another_protected_route(cf_claims=Depends(enforce_cf_access)):
    return {"message": "This route is also protected", "user": cf_claims}
```

You can also initialize the middleware with parameters instead of environment variables:

```python
from cloudflare_access_jwt import CloudflareAccessJWT

custom_enforcer = CloudflareAccessJWT(
    certs_url="https://your-team-name.cloudflareaccess.com/cdn-cgi/access/certs",
    policy_aud="your-application-audience-tag"
)

app = FastAPI(dependencies=[Depends(custom_enforcer)])
```

## Development

1. Clone the repository and install dependencies:

```sh
git clone https://github.com/aluxian/fastapi-cloudflare-access-jwt.git
cd fastapi-cloudflare-access-jwt
uv venv
source .venv/bin/activate
uv sync
```

2. Run linting checks:

```sh
uv run ruff check .
```

3. Run tests:

```sh
uv run pytest
```

4. Start Aider:

```sh
uvx --python 3.12 --from 'aider-chat[playwright]' --with 'aider-chat[help]' aider
```
jaraco.path 3.7.2
miscellaneous path functions
Requires Python: >=3.8

.. image:: https://img.shields.io/pypi/v/jaraco.path.svg
   :target: https://pypi.org/project/jaraco.path

.. image:: https://img.shields.io/pypi/pyversions/jaraco.path.svg

.. image:: https://github.com/jaraco/jaraco.path/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/jaraco.path/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. .. image:: https://readthedocs.org/projects/PROJECT_RTD/badge/?version=latest
..    :target: https://PROJECT_RTD.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2024-informational
   :target: https://blog.jaraco.com/skeleton

Hidden File Detection
---------------------

``jaraco.path`` provides cross platform hidden file detection::

    from jaraco import path
    if path.is_hidden('/'):
        print("Your root is hidden")

    hidden_dirs = filter(is_hidden, os.listdir('.'))


Directory Builder
-----------------

When testing (and perhaps in other cases), it's often necessary to construct
a tree of directories/files. This project provides a ``build`` function to
simply create such a directory from a dictionary definition::

    from jaraco.path import build
    build(
        {
            'foo': 'Content of foo',
            'subdir': {
                'foo': 'Content of subdir/foo',
            },
        },
    )
easylatex 0.1.0
Simplify writing LaTeX documents with Python.
Requires Python: >=3.6

# EasyLaTex

EasyLaTex is a Python library that simplifies the process of writing LaTeX documents.

## Features
- Create LaTeX documents using Python.
- Add sections, paragraphs, and more.
- Export to `.tex` files.

## Installation
```bash
pip install easylatex