semvec/pypi-packages huggingface dataset:
asyncgram 0.0.4
A lightweight, asynchronous telegram logging client
Requires Python: >=3,<4

# Telegram requirements

To be able to use this tool, you will require a Telegram bot token and a group chat ID. 

[Telegram bot token reference](https://core.telegram.org/bots#6-botfather)

[Telegram group chat ID reference](https://stackoverflow.com/questions/32423837/telegram-bot-how-to-get-a-group-chat-id)

# Installation

```
pip install asyncgram
```

# Usage

Once you have your telegram bot token and group chat ID, and you've install asyncgram, you are ready to get started. 

## Creating a client

```
from asyncgram import Asyncgram

# replace XXX with your keys
TG_BOT_TOKEN = "XXX"
TG_GROUP_ID = "XXX"

client = Asyncgram(
    tg_token = TG_BOT_TOKEN, 
    tg_group = TG_GROUP_ID
)
```

## Logging messages

```
client.start()

messages = [
    'Hello world',
    'My name is codeman',
    'My birthday was yesterday.'
]

for msg in messages: client.put(msg)

client.stop()
```

This is a toy example to get you started. Recommended usage would be to put relevant messages from some form of a websocket connection such that it's logged in an asynchronous way.

# Donations

If you liked this tool and would like to support me, kindly send your donations in ETH to 0xB08f9B316ddBCA4Dc5736153Cd63B8d9Bec46Bab
gpxrecords 0.0.18
GPX log packet processing tool

### About program

Easy way to process a bunch of .gpx logs to get best times on selected distances.

### Installation

Python3 is required. Download latest version for your OS from https://www.python.org/downloads/ and install it.

After that, open console (for Windows users, it can be found in Accessories folder of the Start Menu) or terminal (for Linux users).

Execute following commands:

    pip3 install setuptools
	pip3 install gpxrecords

### Usage

Open console (or terminal) and execute:

    gpx-records

Several windows will be appeared in the following order:
- folders selections: specify directories where your .gpx logs are stored;
- logs selection: select logs you want to analyze;
- distances selection: specify distances and number of attempts for each distance;

After processing, table will be shown with following columns:
- Distance. Two types of distance is shown here: distances with best times in the current log (simple number, i.e. 100), and distances with zero start speed (100zs, for example).
- Time;
- Average speed;
- Time from start: location of the distance in the log;
- Distance from start: location of the distance in the log;
- Actual distance. Due to large GPS sampling time actually logged distance fits required size in very rare cases, so recalculating method is used for required distance time calculation. See more in Accuracy chapter of this manual.

In the end of the table absolute records for processed logs is given.

All records and settings are stored in .gpx_records directory of your home directory or user folder for Windows.

### Accuracy

GPS is not very accurate method for distance measurement, so some best practices are recommended:
- Use special GPS trackers. Smartphone log quality is often very poor;
- Use high sampling rate: 1 sample in second, for example is good enough for accurate results;
- Do not hide GPS tracker deep inside your bag.

If you use smartphone applications, such as Strava and Runtastic, be very careful, when use this program for short distances analysis. These applications can turn on autopause feature for log compression purposes (even if user didn't selected it), so first several seconds of the log can be missed. Be critical to given results and don't be too proud if you occasionaly "beat" world record on your moring jogging.

Quality of the log can be indirectly estimated by "Actual distance" field of the table. Difference between actual and required distances don't have to be too large since large difference usually is the sign of GPS failure and leads to large inaccuracy in time calculaton.

Time is recalculated by following formula:

    time = actual_distance_time * distance / actual_distance
instaresizer 0.0.6
Returns a PIL Image object of instagram compatible aspect ratio when supplied with an image URL or an image object.
Requires Python: >=3.6

### Instaresizer

#### Description

Instagram only allows images between aspect ratios 16:9 (landscape) and 4:5 (portrait) to be uploaded. Images that are wider than 16:9 or taller than 4:5 are not supported by Instagram for uploads. Instaresizer is an image resizer that can be used to convert images of any aspect ratio to instagram supported aspect ratios. This resizer converts the image to optimal dimensions depending on the original image's orientation. If the image is too wide, it fills transparent pixels on top and bottom to bring the image to the supported aspect ratio of 16:9. Similarly if the image is too tall, it fills in the left and right of the image with transparent pixels to bring the aspect ratio to 4:5. 

Instaresizer supports two methods. `instasize.resize_remote()` can be used to supply an image URL whereas `instasize.resize_image()` can be used to supply a PIL image object. Both methods return resized PIL Image object which then can be saved to file system or perform other operations as necessary.

#### Usage

##### Installation

```
pip install instaresizer
```

##### Example

###### Importing the library
```
#!/usr/bin/env python3
from instaresizer import instasize
```
###### Usage - resizing remote image file supplied via a URL. 

This is useful if the image is publicly accessible with no additional authentication requirements. 
```
image_url = 'https://s3.amazonaws.com/images.seroundtable.com/30th-anniversary-of-the-world-wide-web-google-1552390014.gif'
img = instasize.resize_remote(image_url)
img.save('resized_file.png', 'PNG')
```
###### Usage - resizing local image file. 
```
image = Image.open("test_image.jpeg")
img = instasize.resize_image(image)
img.save('resized_file.png', 'PNG')
```
github-email-scraper 1.0.0
Scrape GitHub to get user emails
Requires Python: >=3.6
Keywords: scraper,github,email,crawler

# GitHub Email Scraper

Scrape GitHub for email addresses associated with a username. Search through public events and commits in the user's repositories.

## Requirements

-   Python 3
-   Requests (`pip3 install requests`)

## Installation

### PIP

```
pip install github-email-scraper
```

### Manual install

1. `pip install -r requirements.txt`
2. `python setup.py install` or `pip install .`

### Standalone

Just run the `github_email_scraper.py` script in the github_email_scraper directory.

## Usage

Specify a username with `-u` or a file containing usernames (one per line) with `-U`. Choose to either search commits (`--commits`), events (`--events`), or both (`--all`).

Installed

```
github-email-scraper -u USERNAME --all
```

Standalone

```
python github_email_scraper.py -u USERNAME --all
```

### Full usage

```
usage: github_email_scraper.py [-h] (-u USER | -U USER_LIST) [-c] [-e] [-a] [-o] [-n] [-r] [-l AUTH_USER] [-t TOKEN]

Scrape GitHub for email addresses associated with a username. Choose to search through public events (--events), commits in the user's repositories
(--commits), or both (--all). Specify users on the command line (-u) or load a file with one user per line (-U).

optional arguments:
  -h, --help            show this help message and exit
  -u USER, --user USER  Target GitHub username
  -U USER_LIST, --user-list USER_LIST
                        File containing list of target GitHub usernames, or - for stdin
  -c, --commits         Look through user's commits in their repos
  -e, --events          Look through user's public events
  -a, --all             Commits and events
  -o, --other-users     Include emails from commits not associated with the GitHub user. This may find other email addresses beloning to the user that they haven't manually associated with their GitHub account, but may also contain a lot of emails from other accounts if the repo is a fork or has multiple contributors.
  -n, --name            Show commit/event author name
  -r, --repo            Show repo the email was (first) found in
  -l AUTH_USER, --auth-user AUTH_USER
                        Your GitHub username to use for authentication; use with --token
  -t TOKEN, --token TOKEN
                        Your GitHub personal access token; use with --auth-user
```

## Increasing your rate limit

GitHub limits the number of unauthenticated API requests per IP address. To get around this, create a personal access token on GitHub under your user's Settings -> Developer settings -> Personal access tokens. It does not need any scopes. Then use it in this program by setting `--auth-user YOUR_GH_USERNAME --token YOUR_TOKEN`.
calcs 0.0.0.9999
call CS tag to SAM file
Requires Python: >=3.7

## Description

Append the [minimap2's CS tag](https://github.com/lh3/minimap2#cs) to SAM file.  
If the CS tag is already present, this command will overwrite the existing tag.


> :warning: This tool will be maintained until [the samtools team implements official CS caller](https://github.com/samtools/samtools/issues/1264).

## Installation

You can install `calcs` using pip:

```bash
pip install calcs
```

<!-- Alternatively, you can get `calcs` from bioconda:

```
conda install -c bioconda calcs
``` -->

## Usage

```bash
calcs [options] <in.sam> -r/--reference <in.fasta>
```

## Getting Started

```bash
# CS tag (short form)
calcs aln.sam -r ref.fasta > aln_cs.sam
# CS tag (long form)
calcs aln.sam -r ref.fasta -l > aln_cslong.sam
# PAF format with CS tag (short form)
calcs aln.sam -r ref.fasta -p > aln_cs.paf
# PAF format with CS tag (long form)
calcs aln.sam -r ref.fasta -p -l > aln_cslong.paf
# Multithreading
calcs aln.sam -r ref.fasta -t 4 > aln_cs.sam
```


## Options

```bash
-l, --long: output the cs tag in  the long form
-t, --threads INT: number of threads to use (default: 1)
```

## Examples

```bash
calcs examples/example.sam -r examples/ref.fa > example_cs.sam
```

If the input file is a BAM/CRAN format, you can use `samtools view`.

```bash
samtools view examples/example.bam |
  calcs -l -r examples/ref.fa |
  samtools sort > example_cslong.bam
```

## `paftools.js sam2paf` vs `calcs`

|                     | sam2paf                    | calcs      |
| ------------------- | -------------------------- | ---------- |
| Speed               | +                          | -          |
| Report substitution | + (if SAM includes MD tag) | +          |
| Report CS tag       | + (if SAM includes MD tag) | +          |
| Output format       | PAF                        | SAM or PAF |
hub-shm 1.0.1
Hub Shared Memory

Hub Shared Memory
---

This package provides a backport of the Python 3.8's shared\_memory module that works for 3.6 and 3.7. 
This is based off dillonlaird's Shared Numpy array but is leaner.


Install
---
To install run `pip install hub_shm`.

Installation will only work on Python 3.6.x and 3.7.x.


Usage
---

```python
import hub_shm as shm
```


You can then access `shm.SharedMemory` and `shm.ShareableList` which are the same as the
ones in Python 3.8's [shared\_memory](https://docs.python.org/3/library/multiprocessing.shared_memory.html)
module.
ceta 0.0.2
Corporate Entity Tracking Automation (CETA)
Requires Python: >=3.6

# Documentation
This search tool assists in the identification of corporate entities and the relationships between them.


## Getting started

1. Install python tooling:

        sudo apt install -y python3 python3-pip python3-venv # python package manager and virtual environments

2. Clone the repo:

        git clone git@github.com:appleseedlab/ceta.git
        cd ceta/

3. Setup a virtual environment and install dependencies:

        python3 -m venv ceta_env # create the virtual environment
        source ceta_env/bin/activate # enter the virtual environment
        pip3 install -r requirements.txt # install dependencies

4. Setup your API keys:

    If you have a data package containing keys, just untar it in the ceta/ source directory, replacing `YYYYMMDD-HHMMSS_TAG` with that from the downloaded data package name:
    
        tar -xvf data_package_YYYYMMDD-HHMMSS_TAG.tar.bz2

    Otherwise, only if you do not have the data package, create a `keys.conf` file in the ceta/ source directory with the contents below, replacing each `YOUR_KEY` with the corresponding API key.

        [KEYS]
        OC_TOKEN=YOUR_KEY
        FINTEL_TOKEN=YOUR_KEY
        FINNHUB_TOKEN=YOUR_KEY

5. Run the SBA PPP loan experiment

        python3 sba_ppp.py 2>/dev/null  # run without showing verbose output

### Expected output

- If using the `data_package_YYYYMMDD_HHMMSS.tar.bz2`, the experiment will use cached data.  To hit the opencorporate servers, delete the `cache/` folder.

- To show debugging output, just use `python3 sba_ppp.py`

- The resulting tables are quite wide, so you may need to enlarge your terminal or redirect them to a file.

- The resulting tables should match those in `ground_truth/sba_ppp_results.txt`.