semvec/pypi-packages huggingface dataset:
QRankGWAS 0.0.9
Python implementation of the QRank method described in Song et al Bioninformatics 2017.

# QRankGWAS
 Software implementing the QRank method described in Song el al. Bioninformatics 2017. It was adapted for use within the UK Biobank using Python. It was designed to be used as a command-line tool. Note, the R QRank version and the python implementation will not yield identical results. The python version uses Iterative Weighted Least Squares to fit the null regression models, while the R version uses the simplex method. Therefore, the two implementations can produce slightly different p-values, but they are highly consistent.

Installation:

pip install QRankGWAS

Following installation, specific details regarding the software can be found by running the following command:

python -m QRankGWAS -h
pytest_srcpaths 1.0.0
Add paths to sys.path

# pytest-path

Add paths to `sys.path`.  
A pytest plugin to help pytest find the code you want to test.


## Installation

Install with pip:

    pip install pytest-srcpaths


## Usage

Add a line in your pytest.ini file with a key of `srcpaths`.
It should contain a space seperated list of paths.

    [pytest]
    srcpaths = src lib

Paths are relative to the directory that pytest.ini is in. 
You can include the top level directory with a dot.

    [pytest]
    srcpaths = .

## Similar project

This plugin was inspired by [pytest-pythonpath](https://pypi.org/project/pytest-pythonpath/).

Implementation and scope are a bit different.
sdmenu 1.0.0
A simple way to query UC San Diego's HDH dining halls
Requires Python: >=3.7.*

# sdmenu

**sdmenu** is a simple way to query UC San Diego's HDH dining halls.

![Code Style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)

## Installation

```bash
$ pip install sdmenu
Successfully installed sdmenu-1.0.0
```

## Example

This example is based off the menu for [64 Degrees](https://hdh-web.ucsd.edu/dining/apps/diningservices/Restaurants/MenuItem/64), which you can find [here](https://hdh-web.ucsd.edu/dining/apps/diningservices/Restaurants/MenuItem/64).

```py
>>> from sdmenu import menu
>>> my_menu = menu()
<menu {'64 Degrees', 'Cafe Ventanas', 'Canyon Vista', ...}>

>>> items = my_menu.get('64 Degrees')
[<menu_item 'Avocado Toast'>, <menu_item 'Bacon Bobcat Sandwich'>, ...]

>>> items[0].price
3.5

>>> my_menu.has('64 Degrees', 'Hibachi Chicken')
True
```
logistigate 0.1.0
python implementation of logistigate for supply-chain aberration inference
Requires Python: >=3
Keywords: supply chains,statistical inference,pharmaceutical regulation

# logistigate
python implementation of logistigate

Overview of logistigate
----------------
Generally speaking, the logistigate methods infer aberration likelihoods at
entities within a two-echelon supply chain, only using testing data from sample
points taken from entities of the lower echelon. It is assumed that products
originate within the system at one entity of the upper echelon, and are
procured by one entity of the lower echelon. The likelihood of a lower-echelon
entity obtaining product from each of the upper-echelon entities is stored in
what is deemed the "transition matrix" for that system. Testing of products at
the lower echelon yields aberrational (recorded as "1") or acceptable ("0")
results. We then distinguish possible information-availability settings into
two categories, Tracked and Untracked:
 - In the Tracked case, both the upper-echelon and lower-echelon entities
     traversed by the tested product are known upon testing.
 - In the Untracked case, only the lower-echelon entity is entirely known, in
     addition to the system's transition matrix.
It is further assumed that products are aberrational at their origin in the
upper echelon with some entity-specific fixed probability, and that products
acceptable at the upper echelon become aberrational at the destination in the
lower echelon with some other entity-specific fixed probabiltiy. It is these
fixed probabilities that the logistigate methods attempt to infer.

More specifically, the logistigate methods were developed with the intent of
inferring sources of substandard or falsified products within a pharmaceutical
supply chain. Entities of the upper echelon are referred to as importers, and
entities of the lower echelon are referred to as outlets. This terminology is
used interchangeably throughout the logistigate package.
auditee 0.0.1.dev2
auditee
Requires Python: >=3.6

# auditee

**WORK IN PROGRESS -- DO NOT USE -- DO NOT TRUST**

Tool to help with auditing an SGX enclave that has been remotely attested.
The idea is as follows:

Given:
* a signed enclave binary file (e.g. `Enclave.signed.so`),
* the source code used to build the enclave, and
* an attestation report,

an auditor verifies:

* whether the signed enclave build can be reproduced, using the source code, and
a nix & docker based toolchain to rebuild the enclave binary
* Whether the MRENCLAVE and ATTRIBUTES of the provided signed Enclave match that of
  the rebuilt one
* Whether the MRENCLAVE and ATTRIBUTES match the ones from the provided report

Roughly speaking the goal is to establish that the source code was indeed the code
used to build the signed enclave that has been successfully (remotely) attested.

Such an audit can help external users gain trust into a system which depends on
Intel SGX and remote attestation. Without such an audit, remote attestation is not
sufficient because the fact that an MRENCLAVE (enclave hash) matches that of the
attestation verification report does not prove to a user of the system that the
MRENCLAVE corresponds to a version of source code that they are willing to trust.


## MRENCLAVE (enclave hash)
The MRENCLAVE, also known as enclave hash, from three sources must all match. The
enclave hash is obtained via a _measurment_ of the enclave code and data when an
enclave is initialized. This measurement can also be simulated, and thus a verifier
can obtain the MRENCLAVE using a build toolchain, and the SGX signing tool to get
the SIGSTRUCT which contains the MRENCLAVE.

1. Hash extracted from the signed enclave (`Enclave.signed.so`) that is remotely attestated
2. Hash in the attestation report, from IAS
3. Hash extracted from the enclave, which was rebuilt from source code using a
   nix+docker based toolchain

If (1) and (3) match then the auditor can trust that they are auditing the correct
code, and can trust that the report is for the enclave that is under audit, and
consequently the successful attesation can be trusted in sofar that the attestation
is for source code that has been audited.
selenium-tools 0.0.2
Datetime and range slider tools for python selenium
Requires Python: >=3.6

Selenium-Tools provides the following tools for use with [Selenium](https://selenium-python.readthedocs.io/):

1. Send/receive `datetime.datetime` objects from web forms.
2. Drag range sliders to specified values.

## Installation

```
$ pip install selenium-tools
```

## Quickstart

First, clone an example file from the Selenium-Tools repo.

```bash
$ curl https://raw.githubusercontent.com/dsbowen/selenium-tools/master/form.html --output form.html
```

Let's send the current date and time to all input in the form.

```python
from selenium_tools import get_datetime, send_datetime

from selenium.webdriver import Chrome

from datetime import datetime

driver = Chrome()
driver.get('data:text/html,'+open('form.html').read())

datetime_ = datetime.utcnow()

css_selectors = (
    'input[type=date]',
    'input[type=datetime-local]',
    'input[type=month]',
    'input[type=time]',
    'input[type=week]'
)
for selector in css_selectors:
    input_ = driver.find_element_by_css_selector(selector)
    send_datetime(input_, datetime_)
    print(get_datetime(
        input_.get_attribute('type'), 
        input_.get_property('value')
    ))
```

You'll see the form filled in in your selenium browser and receive the following output in your terminal:

```
2020-06-30 00:00:00
2020-06-30 15:47:00
2020-06-01 00:00:00
1900-01-01 15:47:00
2020-01-01 00:00:00
```

We can also drag the range slider as follows:

```python
from selenium_tools import drag_range

range_ = driver.find_element_by_css_selector('input[type=range]')
drag_range(driver, range_, 80)
range_.get_property('value')
```

Out:

```
'80'
```

## Citation

```
@software{bowen2020selenium-tools,
  author = {Dillon Bowen},
  title = {Selenium-Tools},
  url = {https://dsbowen.github.io/selenium-tools/},
  date = {2020-06-29},
}
```

## License

Users must cite this package in any publications which use it.

It is licensed with the MIT [License](https://github.com/dsbowen/selenium-tools/blob/master/LICENSE).
pyrecipepuppy 0.0.1
A simple Python wrapper for the Recipe Puppy API
Requires Python: >=3.6

**pyrecipepuppy**

A simple Python wrapper for the *Recipe Puppy API*

Makes requests to the Recipe Puppy API to retrieve the recipes containing a given list
of ingredients and/or a given search term. It returns the list of all the
recipes returned by the API. For each recipe the following data might
be available:

* title
* link to a web page containing the entire recipe
* the list of ingredients used in the recipe
* link to a thumbnail photo with the result of the recipe

For more information on the API, please visit the `Recipe Puppy API web page <http://www.recipepuppy.com/about/api/>`_

**Installation**

``pip install pyrecipepuppy``

**Usage**::

    import pprint
    from pyrecipepuppy import RecipePuppy

    rp = RecipePuppy()
    recipes = rp.get_recipes(ingredients='salmon,onions', search_query='omelet')
    pprint.pprint(recipes)
fastgenomics_upload 0.8.8
FASTGenomics upload script

# FASTGenomics Upload tool

This tool is used to upload files to [FASTGenomics](https://beta.fastgenomics.org) via the command line.

## Installation

It can be installed via

```bash
pip install fastgenomics_upload
```

## Usage

```bash
fastgenomics_upload [-h] [-v] [-d DATASET] [-u USER] [-p PASSWORD] [-t TITLE] [-m] file [file ...]

positional arguments:
  file                  the files to be uploaded

optional arguments:
  -h, --help            show this help message and exit
  -v, --verbose         more verbose output (default: False)
  -d DATASET, --dataset DATASET
                        add file to existing dataset with this id (default: None)
  -u USER, --user USER  your username (or email address) (default: None)
  -p PASSWORD, --password PASSWORD
                        your password (default: None)
  -t TITLE, --title TITLE
                        the title of the new dataset (default: None)
  -m, --metadata        upload files as metadata instead of expression data (default: False)
```
pyrecipepuppy-crinela 0.0.1
A simple Python wrapper for the Recipe Puppy API
Requires Python: >=3.6

**pyrecipepuppy**

A simple Python wrapper for the *Recipe Puppy API*

Makes requests to the Recipe Puppy API to retrieve the recipes containing a given list
of ingredients and/or a given search term. It returns the list of all the
recipes returned by the API. For each recipe the following data might
be available:

* title
* link to a web page containing the entire recipe
* the list of ingredients used in the recipe
* link to a thumbnail photo with the result of the recipe

For more information on the API, please visit the `Recipe Puppy API web page <http://www.recipepuppy.com/about/api/>`_

**Installation**

``pip install pyrecipepuppy``

**Usage**::

    import pprint
    from pyrecipepuppy import RecipePuppy

    rp = RecipePuppy()
    recipes = rp.get_recipes(ingredients='salmon,onions', search_query='omelet')
    pprint.pprint(recipes)