semvec/pypi-packages huggingface dataset:
bounce-desktop 0.3.0
Hardware-accelerated Linux virtual desktops.
Requires Python: >=3.10

# Bounce Desktop

Bounce Desktop is a cpp library and python package for starting and interacting
with lightweight hardware-accelerated virtual desktops. It does this by running
VNC-backed Weston sessions and then connecting to them with a VNC client.

I've written Bounce Desktop to serve as a desktop platform for my RL with Games
framework: [BounceRL](https://github.com/Whenning42/bounce-rl).

# Dependencies

poetry, libvncserver (optional), gmock, gtest, libgvnc (from gtk-vnc)

# Getting started

If you want just want the python package, you'll first need to install the system
dependencies listed above. Then you can run this pip command:

```shell
pip install bounce_desktop
```

# Usage

I don't have docs or clear examples handy, but for starter pointers, see:
[src/desktop/client.h](src/desktop/client.h),
[bounce_desktop/bounce_desk_test.py](bounce_desktop/bounce_desk_test.py), and
[src/bindings/client_exe.h](src/bindings/client_ext.h).

# Limitations

Running multiple desktops from a single process isn't supported yet. I'd like to support
this use case, but there are some threading details to work through in the libgvnc
client and SDL viewer. Until then, if you do want to test the threaded set up,
pass in "true" to the the "allow_unsafe" arg for the client or viewer.

# Roadmap 

This project's being developed to support [BounceRL](https://github.com/Whenning42/bounce-rl),
so I'll be focusing development toward that project's needs. With that said, I
do think there's value in having a lightweight virtual desktop library available, and
I do think one could develop this project toward that goal if they're interested.

I also think this project should be close to feature complete at this point, I may at
some point integrate the prototyped, but unused, subprocess reaper into the desktop
class, so that callers can get guaranteed process clean-up, but we'll see if or when
I need that feature.

# Contributing

I don't plan on accepting pull requests in the near term, but I'll take a look at any
issues or feature requests you open.
ya-tagscript 1.6.1
Yet Another TagScript fork. An easy drop in user-provided Templating system.
Requires Python: >=3.11
Keywords: tagscript

# ya_tagscript - Yet Another TagScript fork

Current stable version: v1.6.1

## Information

This is a fork of PhenoM4n4n's [TagScript](https://github.com/phenom4n4n/TagScript),
which itself is a fork of JonSnowbd's
[TagScript](https://github.com/JonSnowbd/TagScript), a string templating language.

The main purpose of this fork is to align the Discord-specific blocks with the most
recent Discord and discord.py changes (new username system, etc.).

## What?

TagScript is a drop-in, easy-to-use string interpreter that lets you provide users with
ways of customizing their profiles or chat rooms with interactive text.

For example TagScript comes out of the box with a random block that would let users
provide a template that produces a new result each time its ran, or assign math and
variables for later use.

## Changes in v1

The newly released v1 includes a complete rewrite of the entire parsing and
interpretation performed by the TagScriptInterpreter class. This comes with some subtle
behavioural changes but great care was taken to keep v1 behaviourally similar to v0 and
PhenoM4n4n's fork. Most simple uses *should* behave the same but especially deeply
nested scripts or dynamically assembled ones will most likely require adjustments.
Some documentation examples were also outright wrong, so those were also adjusted to
reflect the actual behaviour of the pre-existing interpreter.

### Oh, no! Behaviour changes?!

To remove the need for dynamically assembled blocks (e.g. command blocks that only
happen under some circumstances), v1 only performs interpretation of branches that were
actually hit (to the best of its ability).

Take this (very bad) password check script:

```tagscript
{if({args}==123):{command:echo password accepted!}|something else}
```

If `{args}` is not in fact equal to `123`, the interpreter WILL NOT interpret the
command block AT ALL. It jumps straight to the `else` section after the `|` and only
interprets that. This means that for any incorrect values of `{args}`, the `echo`
command is NOT included in the list of commands in `response.actions.get("commands")`.

Other blocks with some conditional executions (like `all` or `any`) do the same.

## Installation

Download the latest version through pip:

```
pip install ya_tagscript
```

or

<!--VERSIONED TAG SECTION START-->

```
pip install git+https://github.com/MajorTanya/ya_tagscript.git@v1.6.1
```

<!--VERSIONED TAG SECTION END-->

Download from a commit:

```
pip install git+https://github.com/MajorTanya/ya_tagscript.git@<COMMIT_HASH>
```

Install for editing/development:

```
git clone https://github.com/MajorTanya/ya_tagscript.git
pip install -e ./ya_tagscript
```

## Dependencies

- `Python>=3.11`
    - before v1.4.0, this was effectively `>=3.12` due to an oversight in testing
    - after v1.4.0, Python 3.11 is _actually_ supported
- `discord.py>=2.5.0`
- `pyparsing>=3.2.0`
- `python-dateutil>=2.9.0`
muuttaa 0.1.2
Minimalist xarray-based climate impact framework
Requires Python: >=3.8

[![codecov](https://codecov.io/gh/brews/muuttaa/graph/badge.svg?token=BU7RCYZGMP)](https://codecov.io/gh/brews/muuttaa)
[![Python package](https://github.com/brews/muuttaa/actions/workflows/pythonpackage.yml/badge.svg)](https://github.com/brews/muuttaa/actions/workflows/pythonpackage.yml)
# muuttaa

Minimalist xarray-based climate impact framework.

> [!CAUTION]
> This is a toy. Don't use this in production. Expect it to break.
aiotelnet 1.1.0
A generic asyncio Python package to use telnet.
Requires Python: >=3.13.0

# aiotelnet: Async Telnet Client

aiotelnet is a lightweight, asynchronous Telnet client for Python, designed for easy integration into modern async applications.

Notice: AI has been used to generate parts of this project. It has been checked against Python documentation for correctness.

This project was born due to the lack of standard async telnet library, while it has been built primarily for telnet usage, it could also be used for any kind of low-level server/client network communication.

## Features

- **Asynchronous:** Built on `asyncio` for non-blocking network I/O.
- **Automatic Reconnection:** Can automatically reconnect to the server if the connection is lost.
- **Easy to Use:** Simple and intuitive API for connecting, sending commands, and handling messages.
- **Customizable:** Allows customization of encoding, line breaks, and reconnection behavior.

## Installation

```bash
pip install aiotelnet
```

## Usage

Here's a basic example of how to use `TelnetClient` to connect to a Telnet server, send a command, and receive messages:

```python
import asyncio

from aiotelnet.client import TelnetClient


# Define a message handler
async def message_handler(message: bytes):
    """Handle incoming messages from the Telnet server."""
    print(f"Received: {message.decode('utf-8').strip()}")


async def main():
    """Connect to the Telnet server and send a command."""
    # Create a Telnet client
    client = TelnetClient(
        host="telehack.com",
        port=23,
        message_handler=message_handler,
    )

    try:
        # Establish the connection
        await client.connect()

        # Send a command
        await client.send_command("hello")

        # Keep the connection open for a while
        await asyncio.sleep(10)

    except ConnectionError as e:
        print(f"Connection failed: {e}")
    finally:
        # Close the connection
        if client.is_connected():
            await client.close()


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

## API Reference

### `TelnetClient(host, port, message_handler, ...)`

- `host`: The Telnet server host.
- `port`: The Telnet server port (default: 23).
- `message_handler`: An optional callable (sync or async) to handle incoming messages.
- `break_line`: The byte sequence that separates messages (default: `b'\\n'`).
- `encoding`: The encoding to use for commands (default: `'utf-8'`).
- `auto_reconnect`: Whether to automatically reconnect if the connection is lost (default: `True`).
- `reconnect_interval`: The interval in seconds between reconnection attempts (default: `10`).

### `async connect()`

Establishes a connection to the Telnet server.

### `is_connected() -> bool`

Returns `True` if the client is connected, `False` otherwise.

### `async send_command(command: str)`

Sends a command to the Telnet server.

### `async close()`

Closes the connection to the Telnet server.

## Contributing

Contributions are welcome! Please open an issue or submit a pull request on GitHub.

## License

This project is licensed under the Apache 2.0 License.
swifttools 3.0.24
Tools for users of the Swift satellite
Requires Python: >=3.6

# Swifttools python package

This module presents tools to enable access from Python to some of the web-based
tools supporting the Swift satellite.

In the this release there are a two modules available: [ukssdc](swifttools/ukssdc/APIDocs/ukssdc/README.md) and
[swift_too](swifttools/swift_too/README.md).

`ukssdc` provides a Python interface to various services from the  [UK Swift Science Data
Centre](https://www.swift.ac.uk). This includes the [tools to build XRT data products](https://www.swift.ac.uk/user_objects),
interfaces to query catalogues such as [the LSXPS catalogue](https://www.swift.ac.uk/LSXPS) and tools to download
data, including [XRT GRB data products](https://www.swift.ac.uk/xrt_products) or [Swift obs data](https://www.swift.ac.uk/swift_live).

`swift_too` provides a Python interface for submitting Swift Target of Opportunity Requests, calculating visibility of
targets to Swift, querying observations that Swift has performed and will perform, and other Swift related tools.
Documentation for the `swift_too` module can be found here:
[https://www.swift.psu.edu/too_api/index.php](https://www.swift.psu.edu/too_api/index.php).
conjunto 0.0.25
Django application framework/helpers using Tetra, tabler.io, tables2, crispy-forms & more.
Keywords: python, django, tetra, framework, i18n

# Conjunto

## Description
Conjunto is a Django application framework using [Tetra](https://tetraframework.com), [tabler.io](https://tabler.io), [crispy-forms](https://github.com/django-crispy-forms/django-crispy-forms) and more.

## Installation
You can install the package by using pip (best using a virtualenv):

```bash
pip install conjunto
```

## Usage
There is a separate section in the [documentation](https://conjunto.readthedocs.io) available.


## Development setup
For setting up development environment you will need pytest, pre-commit and black. You can install these by running (in the project directory):

```bash
pip install .[dev]
```

## Contributing
Pull requests and general ideas are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License
The Conjunto project is open-source and licensed under the MIT License. Please keep in mind that Conjunto uses many other libraries, which may be under different licenses.