semvec/pypi-packages huggingface dataset:
tmcp 1.0.0
Helper classes for the Team Match Communication Protocol.
License: MIT
Keywords: RLBot,protocol

# tmcp

## Helper classes for the Team Match Communication Protocol

Learn more about [TMCP](https://github.com/RLBot/RLBot/wiki/Team-Match-Communication-Protocol).

---

## How to use

Start by creating an instance of the TMCPHandler.
You should pass in your agent.

```py
from tmcp import TMCPHandler

class MyBot(BaseAgent):
    def initialize_agent(self):
        self.tmcp_handler = TMCPHandler(self)
```

Usage is also very straightforward:

```py
from tmcp import TMCPMessage, ActionType

...
    def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
        # Receive and parse all new matchcomms messages into TMCPMessage objects.
        new_messages: List[TMCPMessage] = self.tmcp_handler.recv()
        # Handle TMCPMessages.
        for message in new_messages:
            if message.action_type == ActionType.BALL:
                print(message.time)
        
        ...

        # You can send messages like this.
        self.tmcp_handler.send_boost_action(pad_index)

        # Or you can create them and send them more directly:
        my_message = TMCPMessage.ball_action(self.team, self.index, estimated_time_of_arrival)
        self.tmcp_handler.send(my_message)
```

The handler will throttle your messages if you send them too quickly.
If you want to make sure all of your messages are sent, you can create a backlog like this:

```py
# During initialization, create a backlog list.
self.backlog = []

...
# Sending returns false if a message was not sent.
if not self.tmcp_handler.send(message):
    self.backlog.append(message)

...
# In your main loop, check whether you have any messages in the backlog.
if self.backlog:
    backlog_message = self.backlog.pop(0)
    # Try sending the message again. If it doesn't work, return it to the backlog.
    if not self.tmcp_handler.send(backlog_message):
        self.backlog.insert(0, backlog_message)
```

## Avoiding major breaking changes

This package is regularly updated according to the latest TMCP specification.
To avoid your bot breaking during tournaments due to major version updates, you can use a virtual_environment and pin a specific version of this package.

In your requirements.txt:

```txt
tmcp==1.*
```

In your bot.cfg:

```toml
[Locations]
use_virtual_environment = true
requirements_file = ./requirements.txt
```

If you don't want to do this, you can also disable the handler if a different version of the package is used.
This will not send or receive any messages, but will pretend as if it was sending all and receiving none.

```py
from tmcp import TMCP_VERSION

if TMCP_VERSION[0] != 1:
    my_handler.disable()
```
folderpreview 0.4.3
Generates folder preview thumb
License: MIT
Requires Python: >=3.6.12
Keywords: folder,thumb

# FOLDERPREVIEW

Generates folder thumbs using child files thumbs

![demo](https://gitlab.com/hxss-linux/folderpreview/-/raw/master/demo.png)

## Installation

### aur: `folderpreview`

### pip:

systems requirements:

* [dbus thumbnail service](https://wiki.gnome.org/DraftSpecs/ThumbnailerSpec#Request_the_creation_of_thumbnails)
* gtk3 >= 3.24.3
* libvips >= 8.9.2

```
$ pip install folderpreview
$ sudo -E folderpreview --install-thumbnailer
```

## Usage

The thumbnailer will be automatically calling by thumnail service when file manager asks for folder thumbnail. For general usage all you need is installed thumnail service.

`folderpreview --help` for manual usage.

### Tested with:

* `tumbler`
* `thunar`
* `nemo`
* `pcmanfm` (`libfm-directory_thumbnails` required)

### Debugging:

```sh
$ journalctl -f -p debug -t folderpreview
```

## Configuration

`XDG_CONFIG_HOME/folderpreview/config.yaml:`
```yaml
size: 256                  # default thumb size, px
use_hidden: false          # generate thumbs for and use hidden files in preview
request_child_thumbs: true # request thumbs of supported child files
                           # in background scheduler and wait for their readiness
request_timeout: 5         # request timeout, s
priority:                  # priority of child's files for using on preview
- media                    # video/image files with thumbs/thumbnailer
- thumbs                   # other files with thumbs/thumbnailer
- icons                    # files without thumbs/thumbnailer
- subdirs                  # recursion in subdirs with the order
- files                    # all child files
locations:                 # enabled folders locations(including subdirs)
- /
- $HOME/videos
renderer: custom_renderer.CustomRenderer # renderer class name
```

## Customization

For better integration with icon theme renderer can be customized using `config.renderer` option. It should be instance of `folderpreview.renderer.ThumbRenderer` class. Custom renderer can be stored in config folder.

## Links

* [Thumbnail Managing Standard](https://specifications.freedesktop.org/thumbnail-spec/thumbnail-spec-latest.html#CREATION)
* [Thumbnail management DBus specification](https://wiki.gnome.org/DraftSpecs/ThumbnailerSpec#Request_the_creation_of_thumbnails)
dailycovid 1.3.0
U.S.A daily covid information.
License: MIT
Requires Python: >=3.5,<4.0
Keywords: COVID,Coronavirus

# dailycovid - Easily get covid updates

# Pypi installation
`pip3 install dailycovid`

# Usage


## Simplest

`dailycovid --plot -s statecode`

## Specific Counties in a State or Whole States

You can now use an arbitrary number of arguments with `-s` or `-sc`.

`dailycovid -sc ny-albany ca-orange "California-Los Angeles"`

`dailycovid -s DELAWARE MA`


Here are three ways to do the same thing.

`dailycovid -sc "California-Los Angeles"`

`dailycovid -s CA -c "Los Angeles"`

`dailycovid --state CA --county "Los Angeles"`

## Making Plots

Use `--plot` or `-p` to make the plots.

## Updating Data

On the first run it will download a csv file containing the most recent data.

Use `dailycovid -g` to update the cache.


# Examples of plots

'![image](https://raw.githubusercontent.com/Fitzy1293/daily-covid/master/examples/plots_LOS-ANGELES_CA.png)'

![image](https://raw.githubusercontent.com/Fitzy1293/daily-covid/master/examples/plots_SUFFOLK_MA.png)   

![image](https://raw.githubusercontent.com/Fitzy1293/daily-covid/master/examples/plots_NEW-YORK-CITY_NY.png)
grinmw 0.1.1
Python wrappers around the Grin wallet V3 and Grin node V2 APIs
License: MIT

# grinmw.py

Grin is a privacy-preserving digital currency built openly by developers distributed all over the world. Check [grin.mw](https://grin.mw/) to know more!

This module provides Python wrappers for

* [Grin Wallet API V3](https://docs.grin.mw/wiki/api/wallet-api/)
* [Grin Node API V2](https://docs.grin.mw/wiki/api/node-api/)

Install with

```
pip install grinmw
```

If you need help please check how to reach our [community](https://grin.mw/community).

## Examples

Using the Node V2 API to access the locally running Grin node.

```python
from grinmw.node_v2 import NodeV2

import pprint
from pathlib import Path
home = str(Path.home())

pp = pprint.PrettyPrinter(indent=4)
owner_api_url = 'http://localhost:3413/v2/owner'

# change to your grin owner_api secret file
owner_api_sercet_file = os.path.join(home, '.grin/main/.api_secret')
owner_api_user = 'grin'
owner_api_password = open(owner_api_sercet_file).read().strip()

foreign_api_url = 'http://localhost:3413/v2/foreign'

# change to your grin owner_api sercret file
foreign_api_sercet_file = os.path.join(home, '.grin/main/.foreign_api_secret')
foreign_api_user = 'grin'
foreign_api_password = open(foreign_api_sercet_file).read().strip()

node = NodeV2( foreign_api_url, foreign_api_user, foreign_api_password, owner_api_url, owner_api_user, owner_api_password)
pp.pprint(node.get_status())
pp.pprint(node.get_header(1036985))
pp.pprint(node.get_kernel('096a7303ab9e3a68cf0b3d70d6ec61311efaf0f33f2ac251bff2a4da45908d3f15'))
pp.pprint(node.get_kernel('08f0a2b7e3ddd0ccc60ac147e93f3e8b01ede591d0da08ba93333e3c73fd45c1cf'))
```

Using the Wallet V3 API to access the locally running Grin wallet listener.

```python
from grinmw.wallet_v3 import WalletV3

import pprint, os

pp = pprint.PrettyPrinter(indent=4)
api_url = 'http://localhost:3420/v3/owner'

# change to your grin owner_api sercret file
api_sercet_file = '/home/ubuntu/.grin/main/.owner_api_secret'
api_user = 'grin'
api_password = open(api_sercet_file).read().strip()
wallet = WalletV3(api_url, api_user, api_password)
wallet.init_secure_api()

# change to you wallet password
wallet_password = '123'

wallet.open_wallet(None, wallet_password)
pp.pprint(wallet.node_height())
pp.pprint(wallet.get_slatepack_address())

# send to gate.io
send_args = {
    'src_acct_name': None,
    'amount': int(2.67020546 * 1000000000),
    'minimum_confirmations': 10,
    'max_outputs': 500,
    'num_change_outputs': 1,
    'selection_strategy_is_use_all': False,
    'target_slate_version': None,
    'payment_proof_recipient_address': 'grin1n26np6apy07576qx6yz4qayuwxcpjvl87a2mjv3jpk6mnyz8y4vq65ahjm',
    'ttl_blocks': None,
    'send_args': {
        "dest": 'grin1n26np6apy07576qx6yz4qayuwxcpjvl87a2mjv3jpk6mnyz8y4vq65ahjm',
        "post_tx": True,
        "fluff": True,
        "skip_tor": False
    }
}
print(wallet.init_send_tx(send_args))
```
semitan 0.0.1
Library that interacts with Tan API
License: MIT
Requires Python: >=3.6
Keywords: tan transport transports metropolitain semitan nantes tram chronobus bus

# Semitan
## Python Library interacting with Tan RealTime API.

A library which interact with semitan RealTime API.

## Usage

```python
stats=stations(47.21677620581732, -1.5567190467771277)
print(stats.getLocationForecast())
```