semvec/pypi-packages huggingface dataset:
super-rpa 0.1.4
二次封装 Selenium，并且后期会维护搭载各种文本、csv、xlsx、本地文件等操作。

# SuperRPA

## 介绍
二次封装 Selenium，并且搭载各种文本、csv、xlsx、本地文件等操作。后期会不断更新新功能。谢谢使用 ~

## 安装教程

1.  pip install super-rpa

## 使用说明

1.  from super_rpa.super_pypackage import *
2.  看源码。

## 与作者互动

* **作者**：叶狼
* **Email**：yelang97@qq.com
* **pypi地址**：https://pypi.org/project/SuperRPA/
* **了解作者更多，请查看csdn博客**：https://blog.csdn.net/weixin_42038955
* **gitee地址**：https://gitee.com/xiaoye_01/super-rpa
* **您的使用，是我最大的动力，支持开源。**


## 更新日志

* **v0.0.6** (2021.05.23)：对 xlsx 表格的显示和追加修改。
* **v0.0.7** (2021.05.27)：新增了一些 selenium 二次封装的新功能。
stark-utilities 0.0.5
Stark utilities
Requires Python: >=3.6
Keywords: stark,utilities,stark-utilities,stark_utilities

# stark_utilities
StarStandard way to get the REST api response.

## Install
  ```
  pip install stark_utilities
  ```

## Usage
1. Import stark_utilities
  ```
  from stark_utilities.utilities import *
  ```
  
2. To get the response
  ```
  - generate_otp_number
  - MultipleFieldPKModelMixin
  - CreateRetrieveUpdateViewSet
  - is_valid_email
  - get_serielizer_error
  - get_pagination_resp
  - string_to_date
  - convert_timestamp_to_date
  - encrypt
  - decrypt
  - generate_token
  - revoke_oauth_token
  - get_otp_expirity
  - transform_list
  - utc_to_time
  - check_email
  - get_notification_time
  - find_day
  - min_to_hr_conversion
  - get_slug
  - int_to_time
  - random_string_generator
  ```
flask-datadog-monitor 0.0.7
Tool for auto generating DataDog Monitors from flask endpoints
Requires Python: <4,>=3.6

# Overview

Utility for auto generating DataDog terraform monitor specifications from flask
endpoints.

1. Setup DataDog Terraform integration
1. Decorate flask endpoints you want to monitor
1. Run the `flask-datadog` cmd line util to generate terraform files for the monitors
1. Apply Terraform changes

# Usage Examples

## Decorate Flask endpoints you want to monitor

```
# Decorating with `datadog_monitors` will generate default monitors for each
# method on the route
@datadog_monitors()
@flask_app.route('/foo', methods=['GET', 'POST'])
def handle_foo():
    return ''

# Specifying a particular monitor will allow you to tweak thresholds (and
# other parameters) but will only generate that particular monitor for
# that route
@datadog_monitors(
    monitors={
        MonitorType.APM_ERROR_RATE_THRESHOLD: {
            MonitorSpec.CRITICAL_THRESHOLD: 0.8,
            MonitorSpec.ALERT_PERIOD: '10m',
        },
    },
)
@flask_app.route('/foo', methods=['GET', 'POST'])
def handle_foo():
    return ''
```


## Generate Terraform for monitors with cmd line utility

```
flask-datadog gen-terraform --env prod --service my_service path/to/flask_app:app output_dir
```

# Running This Project Locally

Info on running the test service locally against a DataDog test account.

Assumptions
- You have a DataDog test account created

Steps to standup local test env
1. Set DATADOG_API_KEY in env vars
1. Set DATADOG_APP_KEY in env vars
1. `make sync-datadog`: this applies monitoring configs to datadog acnt
1. `make local-up`: this builds app and runs them locally with the dd-agent
containers

Once the local env is up, an automatic script in the `fake-client` service
should ping the `test-app` service periodically to generate fake traffic.

The `test-app` service and `fake-client` service both have mount points so
you can edit the code and have changes reflected directly without rebuilding
containers.


# Unit / Integration Testing

1. Ensure venv is created. From root dir: `python -m venv venv`
1. Install testing dependencies: `./venv/bin/pip install .[testing]` (setup.cfg has `testing` extras_require)
1. `make test`


# Reference

Flask API interface
- Flask App Object API: https://tedboy.github.io/flask/interface_api.application_object.html


# TODO

- Allow specification of just the monitors you want to default to
- "trigger when metric is <above/below> the threshold <in total | on average | etc.> ...
- test with different versions of Flask
- make terraform file generator into a cmd line executable
searchsort 0.1.6
Almost all Searching and Sorting Algorithms for Python 3.x
Requires Python: >=3
Keywords: python3,sort,search,sorting,searching,sorting-algorithms,searching-algorithms,search-sort,searchsort

# searchsort
A Python Package that contains almost all the Searching and Sorting Algorithms

It is also available in [GitHub](https://github.com/Programmin-in-Python/searchsort)

## Installation
**If there are 2 or more versions of Python installed in your system (which mostly occurs in UNIX/Linux systems) then please run any one of the commands in the BASH Shell \:-**
```bash
$ pip3 install searchsort
```
```bash
$ python3 -m pip install searchsort
```

**If there is only Python 3.x installed in your system like in Windows systems then please run any one of commands in the Command Prompt \:-**
```console
pip install searchsort
```
```console
python -m pip install searchsort
```
## Quick Guide
***Please Read till the End***
- Import the Package using `import searchsort as ss`.
- `ss.AvailableSearchingAlgorithms()` will show you the available Searching algorithms.
- `ss.AvailableSortingAlgorithms()` will show you the available Sorting algorithms.
- All the Functions have their **Asymptotic Analysis** in their docstrings. If you wish; you may take a note of it.

## A Searching Implementation
```python3
from random import shuffle
import searchsort as ss

L1 = [i for i in range(1, 51)]
element = 20

# Shuffling the List
shuffle(L1)

index = ss.LinearSearch(L1, element)

if index:
  print(f"{element} found at :", index)
else:
  print(f"{element} not found")
```
**Note \:-**
- **Some of the Algorithms require a sorted array. It is mentioned in the docstring of the functions so please read them carefully.**
- **All the Algorithms return the index of the First Occurrence of the element.**
- **If Element is Not Present, False is Returned.**

## A Sorting Implementation
```python3
from random import shuffle
import searchsort as ss

L1 = [i for i in range(1, 51)]

# Shuffling the List
shuffle(L1)
print("List Before Sorting :", L1)

Result = ss.BubbleSort(L1)
print("List After Sorting :", Result)
```
**Note \:-**
- **Some of the Algorithms perform an in-place sorting, which means the structure of the Original List will be changed.**
- **All the Algorithms return the sorted array, so assigning statements are preferred.**

## \'IsSorted\' Function Implementation
**Besides Searching an Element in an Array and Sorting Arrays, the Package also contains an 'IsSorted' Function that Returns True if an Array is _SORTED_ in either direction; False If NOT.**
```python3
from random import shuffle
from searchsort import IsSorted

L1 = [i for i in range(1, 51)]
print("Is the List Sorted Now? ", IsSorted(L1))

# Shuffling the List
shuffle(L1)

print("Is the List Sorted Now? ", IsSorted(L1))
```
oceania-query 0.1.2
A small package to query data from the OceanIA services
Requires Python: >=3.6

# OceanIA query

A small package to query data from the OceanIA services

## Install

Install using `pip`

```bash
> pip install oceania-query
```

## Usage

The library may be used directly as a command line tool or imported as a python package

### Command line

In the command line:

```bash
> oceania query-fasta <key> <query_file> <output_format> <output_file>
```

For more information information:

```bash
> oceania query-fasta -h
Usage: oceania query-fasta [OPTIONS] <key> <query_file> <output_format> <output_file>

  Extract secuences from a fasta file in the OceanIA Storage.

  <key> object key in the OceanIA storage
  <query_file> CSV file containing the values to query.
               Each line represents a sequence to extract in the format "sequence_id,start,end,type"
               "sequence_id" sequence ID
               "start" start index position of the sequence to be extracted
               "end" end index position of the sequence to extract
               "type" type of the sequence to extract
                      options are ["raw", "complement", "reverse_complement"]
                      type value is optional, if not provided default is "raw"
  <output_format> results format
                  options are ["csv", "fasta"]
  <output_file> name of the file to write the results
```

#### Example

```bash
> oceania query-fasta data/raw/tara/OM-RGC_v2/assemblies/TARA_A100000171.scaftig.gz query.csv csv example.output.csv
```

query.csv:
```csv
TARA_A100000171_G_scaffold48_1,10,50,complement
TARA_A100000171_G_scaffold48_1,10,50,raw
TARA_A100000171_G_scaffold48_1,10,50,reverse_complement
TARA_A100000171_G_scaffold181_1,0,50
TARA_A100000171_G_scaffold181_1,100,200
TARA_A100000171_G_scaffold181_1,200,230
```

### As a python package

```python
from oceania import OceaniaClient

# Create a client instance
oceania_client = OceaniaClient()

# Execute a query
oceania_client.get_secuences_from_fasta_to_file(key, positions, output_format, output_file)
```

#### Example
```python
from oceania import OceaniaClient

oceania_client = OceaniaClient()

key = "data/raw/tara/OM-RGC_v2/assemblies/TARA_A100000171.scaftig.gz"
positions = [
    ["TARA_A100000171_G_scaffold48_1", 10, 50, "complement"],
    ["TARA_A100000171_G_scaffold48_1", 10, 50],
    ["TARA_A100000171_G_scaffold48_1", 10, 50, "reverse_complement"],
    ["TARA_A100000171_G_scaffold181_1", 0, 50],
    ["TARA_A100000171_G_scaffold181_1", 100, 200],
    ["TARA_A100000171_G_scaffold181_1", 200, 230],
]

oceania_client.get_secuences_from_fasta_to_file(
    key,
    positions,
    "csv",
    "test_output.csv"
)
```
simplepythonwer 1.0.3
A small basic python implementation of WER (word error rate) and levenshtein

# SimplePythonWER

The purpose of this repo is to provide a well tested basic python implementation of levenshein / WER so it can be shared across projects.
It's based on [this](http://hetland.org/coding/python/levenshtein.py) with a couple of minor changes.


## Getting Started
 1. Install with: `pip install simplepythonwer`
 2. Import with: `from simplepythonwer import wer`
 3. Use with:
```python
>>> wer("the cat sat on the mat", "the mat sat on the cat")
0.3333333333333333
```

## Features
 - Simple, minimal and only in python with 0 external dependencies
 - It is versioned and can be pip installed
 - Provide examples with [tests](test/test_wer.py) to ensure it's working correctly

## Caveats and Gotchas
 - Providing an empty string or filled with whitespace ground-truth will intentionally raise a divide by zero.
 - It's possible to have greater than 100% WER if the ASR result is many times larger than the ground-truth, this is normal. 
   It's sometimes a good idea to cap the results at a 100% with min function e.g.
   ` min(wer(ground_truth, new_asr_string), 1.0)`, otherwise you could be exposed to unlimited error rate that could skew your averages.


## Change Log
 - v1.0.0 - First release - Minor ~15% speed improvements compared to original 
 - v1.0.1 - Fixed pip packaging and added install steps. Exclude tests from pip
 - v1.0.2 - Fixed pip packaging issue
 - v1.0.3 - Fixed divide by zero error when the ground truth is zero length (including evaluates to zero length since it's just whitespace)


## Tests
 Run with: `PYTHONPATH=$(pwd) python3 -m unittest discover .`
 Results:
```shell
rob@rob-T480s:~/projects/SimplePythonWER (master)$ PYTHONPATH=$(pwd) python3 -m unittest discover .
..
----------------------------------------------------------------------
Ran 9 tests in 0.001s

OK

```

##  Speed Improvements
```python
from simplepythonwer.simplepythonwer import *
import timeit
sentence = "the cat sat on the mat"*5
print(timeit.timeit('levenshtein(sentence, sentence[::-1])', number=10000, globals=globals()))
print(timeit.timeit('levenshtein_original(sentence, sentence[::-1])', number=10000, globals=globals()))
38.16882774699479
44.751817572047
```
django-betterforms3 2
App for Django 3 featuring improved form base classes.

django-betterforms
------------------

.. image:: https://travis-ci.org/fusionbox/django-betterforms.png
   :target: http://travis-ci.org/fusionbox/django-betterforms
   :alt: Build Status

.. image:: https://coveralls.io/repos/fusionbox/django-betterforms/badge.png
   :target: http://coveralls.io/r/fusionbox/django-betterforms
   :alt: Build Status

`django-betterforms` builds on the built-in django forms.


Installation
============

1.  Install the package::

    $ pip install django-betterforms

2.  Add ``betterforms`` to your ``INSTALLED_APPS``.
python-termenu 0.1.4
Simple terminal-based menus in Python
Requires Python: >=3.6, <4
Keywords: menu terminal cli console keystroke ascii

# Termenu
## Easy-to-use, python-based menus in Python.
---

Termenu is a project designed to create menus within terminals.

Currently, it only has one type of menu, but many more will be implemented soon.

### Pre-install deps
Before you install Termenu, you require the following:
  - Python 3.6 or above (3.8.2+ recommended, https://python.org)
  - Git (`sudo apt install git`, or https://git-scm.org)
  - Wheel (optional, `python3 -m pip install -U wheel`)

### Installation
Install via **PyPi** (*recommended*):
  - Install: `python3 -m pip install -U termenu`

Install via source:
  - Clone the repository: `git clone https://github.com/ii-Python/Termenu`
  - Move into the directory: `cd Termenu`
  - Run the setup script: `python3 setup.py install`

### Getting started
Please see the `examples` directory.


©2021, iiPython | Last update: Apr. 17, 2021