semvec/pypi-packages huggingface dataset:
btcpay-python-sdk 0.1.0
BTCPay Python SDK using the Greenfield API
Keywords: btcpay,bitcoin,payments,crypto

# BTCPay Python SDK
BTCPay had a Python SDK, but it was using the old legacy API, meaning the way to connect was outdated as well as the
API responses it was giving. This library uses the Greenfield API and will follow the
[documentation](https://docs.btcpayserver.org/API/Greenfield/v1/) provided by the BTCPay Server team.

> As of right now, this is a work in progress and will be updated to add more API calls

## Installation
You don't need this source code unless you want to modify the package. If you just want to use the package, run the 
command:

```sh
pip install btcpay-python-sdk
```

Install from source with:

```sh
python setup.py install
```

### Dependencies
 - Python 2.7+
 - Requests
 - Setuptools

## Usage
The library needs to be configured with your stores api key, store id, and host url.

> To generate an API key, you need to log in to your BTCPay instance, click "Account" in the lower left corner, click 
> "Manage Account", click the "API Keys" tab, and then generate your key.

```python
import btcpay

btcpay.api_key = 'API_KEY_HERE'  # should use an env variable
btcpay.host_url = 'HOST_URL'
btcpay.store_id = 'STORE_ID'

# get all invoices
invoices = btcpay.Invoices.get_invoices()
print(invoices)
```
ropro-ex 1.0.0
An add on function to consolidate Prokka output
Requires Python: >=3.7

# ROP
Report on Prokka
This script reports important information about a bacterial genome assembly using Prokka annotation data

## Table of Contents

Table of Contents
0. Run Prokka
1. Record the basic assembly and annotation stats
2. Calculate % hypothetical proteins.
3. BLAST species identifying genes
4. Plasmid detection

## Usage
As input, this script takes a directory of Prokka output or a FASTA sequence file. If only a FASTA is provided, Prokka will be run.


## Report Basic Stats
Currently, this functionality is set up to display the statistics presented in the Prokka tsv file

## Calculate the percentage of CDS that are hypothetical proteins
The percent hypothetical is an important statistic for determining assembly quality. Due to limitations in current knowlege, there are many bacterial CDS that have not been annotated. Thus, an assembly where 40-60% of CDS are hypothetical proteins may still be a high quality assembly. However, if the percent hypothetical exceeds 90%, the quality/usability should be questioned.

## Species identification
beencrypted 0.0.3
Encrypt strings to the Bee Movie script and back
Keywords: python,bee,movie,bee movie,encryption,decryption,meme

If you want to encrypt your strings and want to have the Bee Movie script in your code than this is the Python package for you! With this package you can encrypt strings to the first part of the Bee Movie scipt and decrypt it back. Go to https://github.com/Agent-Kwabbel/Beecrypted for more information.
realsense-helpers 0.0.0
Helpers for working with Intel RealSense cameras.
Requires Python: >=3.8
Keywords: cameras,computer vision,realsense,robotics

# realsense_helpers

[![PyPI - Version](https://img.shields.io/pypi/v/realsense-helpers.svg)](https://pypi.org/project/realsense-helpers)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/realsense-helpers.svg)](https://pypi.org/project/realsense-helpers)
[![PyPI - License](https://img.shields.io/pypi/l/realsense-helpers.svg)](https://pypi.org/project/realsense-helpers)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/realsense-helpers.svg)](https://pypistats.org/packages/realsense-helpers)

Helpers for using Intel RealSense Cameras in Python. Wraps around `pyrealsense2`.

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation
```console
pip install realsense-helpers
```

## License

`realsense-helpers` is distributed under the terms of the [MIT license](LICENSE).
tigitaalconnect 0.0.6
Tigitaal's Official Python Package to connect with TigitaalAPI
Keywords: python,first package


# **TigitaalConnect**
The official Python Library to connect with the TigitaalAPI! This library helps easily send requests
to the API, so you dont have to do the hard work of manually setting up requests.
Use a range of easy-to-use functions and explore the endless posibilities of the TigitaalAPI with 
TigitalConnect!


## INSTALLATION:

`pip install tigitaalconnect`


## SETUP:

### UserConnect: 
```python
from  tigitaalconnect import login
user = login(username, password)
# Enter your username and password in the parantheses
```

# REQUESTS:

## Reload Request:
```python
user.reload()
```
## ReloadAdvanced Request: 
```python
user.reloadadvanced()
```
## PFP Request:
```python
user.pfp(fileid)
```
## Nickname Request:
```python
user.nickname(new_nickname)
```
## Mail Request:
```python
user.mail(new_email)
```

# FORUM:

## Setup
```python
from  tigitaalconnect import forum
```
## Messages Request
```python
forum.messages(forumid)
```
## Threads Request
```python
forum.threads(forumid)
```
## Post Request
```python
forum.post(user, text, forumid)
# user is the variable you created earlier to login
```
## Edit Request
```python
forum.edit(user, text, forumid, messageid)
```
## All Request
```python
forum.all()
```

Change Log
==========

0.0.1 (09/29/2022)
------------------
- First Release
- 5 easy to use Requests to manipulate the TigitaalAPI

0.0.2 (09/30/2022)
------------------
- Second Release
- Commands now return info as JSON
- README.txt Updated

0.0.3 (09/30/2022)
------------------
- Third Release (Mini release)
- Bug Fixes

0.0.4 (09/30/2022)
------------------
- Fourth Release (Mini release)
- More Bug Fixes
- Fixed Formatting Errors

0.0.5 (10/05/2022)
------------------
- Fifth Release
- Added Login Class
- Easier setup
- Bug Fixes
- README now a Markdown File

0.0.6 (10/08/2022)
------------------
- Sixth Release
- Added Forum Class
- Bug Fixes
- README updated
sphinx-automagicdoc 0.0.2
A plugin to automagically create autodoc-based API documentation files on the fly

# sphinx-automagicdoc

## Description

This plugin can create API documentation stubs (akin to [sphinx-autogen](https://www.sphinx-doc.org/en/master/man/sphinx-autogen.html)), with the significant difference that the creation is done dynamically and on the fly, and the files remain _virtual_ and are monkey-patched into Sphinx IO routines.

Creating a whole set of files matching the structure of a module violates DRY (don't repeat yourself) and enhances the risk of documentation becoming out of sync during e.g. refactorings. Therefore, `sphinx-automagicdoc` can be used to dynamically source the rST structure from the Python source as the single source of truth.

Based upon the monkey patched virtual filesystem, additionally, other files or strings can be injected into the Sphinx tree.

## Usage

```python
# e.g. added to conf.py

# name the modules automagicdoc should process
automagic_modules = ["nameOfYourPackage"]
automagic_ignore = ["*test*"]

# README.rst and LICENSE from the root directory (outside of doc directory)
# will appear available as README.rst and LICENSE.rst inside doc/
automagic_copy_files = {
    "README.rst", "README.rst",
    "LICENSE.rst": "LICENSE",
}

# index.rst's content is based upon a string
automagic_files = {
    "index.rst": """
Welcome to the documentation!
=============================

.. toctree::
   :maxdepth: 1
   :caption: Contents:

   README
   LICENSE
   nameOfYourPackage
"""
}
```

## Example

This repo builds its documentation using [sphinx-autopyproject](https://github.com/csachs/sphinx-autopyproject) as described in [`.github/workflows/doc.yml`](.github/workflows/doc.yml) using Github Actions and deploys to [Github pages](https://csachs.github.io/sphinx-automagicdoc).


## See also
[sphinx-autopyproject](https://github.com/csachs/sphinx-autopyproject) to use `pyproject.toml` instead of `conf.py`.


## License

MIT
sphinx-autopyproject 0.0.2
Inject Sphinx Configuration from pyproject.toml

# sphinx-autopyproject

Move as much Sphinx configuration as possible from `conf.py` to `pyproject.toml`! *Might even be ... everything*

(If you are interested in more automatically generated API documentation, check out [`sphinx-automagicdoc`](https://github.com/csachs/sphinx-automagicdoc) as well.)

## Usage
Either run `spinx-autopyproject-build` to run `sphinx-build` without the need for a `conf.py` to exist, 
or if you want to use a `conf.py`, add the line:
```python
from sphinx_autopyproject.auto import *
```
To configure, set the `[tool.sphinx-autopyproject]` section:

```toml
[tool.sphinx-autopyproject]
extensions = [
    "sphinx.ext.autodoc",
    "sphinx.ext.doctest",
    "sphinx_rtd_theme",
]

language = "en"
source_suffix = ['.rst']
exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
html_theme = "sphinx_rtd_theme"
```
The `[tool.sphinx-autopyproject.autopyproject]` section is to configure `sphinx-autopyproject` if desired.
Supported is the `dynamic` subsection, which allows to automatically fetch configuration values from other sources,
such as the package metadata. Multiple dynamic fetchers are supported: for `type="package"`, the local package will be built (using `build`), for `type="token"`, a variable assignment will be searched via plain file reading (e.g. to extract `__version__`), or for `type="python"`, the given package/variable will be imported via Python.

```toml
[tool.sphinx-autopyproject.autopyproject.dynamic]
project = { type="package", value="name"}
copyright = { type="package", value="author"}
author = { type="package", value="author"}
version = { type="package", value="version"}
```

The `sys_path` list can be used to add directories to `sys.path`.

## License

MIT
aws-snappy 2.1.0
Snappy is a Python library that facilitates taking root volume snapshots from EC2 as well as other EBS volumes.
Requires Python: >=3.7

# Snappy

Snappy is a Python library that facilitates taking snapshots on EBS.

There are two ways to take snapshots, you can either provide a `volume id` or an ec2 `instance id/instance ipv4/instance name`. If you provide an ec2 detail, it will take a snapshot of the root volume of the instance.

## Getting Started

Assuming that you have Python and virtualenv installed, set up your environment and install the required dependencies using pip:

```
pip install aws-snappy
```

## Using Snappy

After installing snappy, you need to import the main Snappy object and instantiate it to create a connection to AWS:

```
from snappy.snappy import Snappy

snappy = Snappy(values)
```

Here,

`instances` is your list of instances to take snapshots of. i.e. ['10.10.10.10', 'my_instance_name']
Instance can be indentified both by their private IP address or the instance name in the same list.
Snappy will break them apart and search them respectively.

### Available function for Snappy Object

*take_snapshots(tags_specifications)*

This function will take a snapshot of the root volume of the specified instances and return the output in a list in the following format:

#### Parameters

*tags_specifications `<optional>`*: A list of dictionaries containing the tags to be applied to the snapshots in the following format:

```
[{
    "Key": "",
    "Value": ""
}]
```

#### Output

```
[
    {
        "SnapshotID": "",
        "InstanceName": "",
        "VolumeID": "",
    },
    .
    .
    .
]
```

## Running Tests

You can run the tests by following the steps below:

1. Clone or download the project to a folder on your computer.
2. Connect to AWS using AWS CLI
3. Run the tests using the command `./run_test.sh`

## License

```
Copyright Mervin Hemaraju
```