semvec/pypi-packages huggingface dataset:
statscounter 0.0.2
Python's missing statistical Swiss Army knife
License: MIT
Keywords: stats statistics statistic statistical measurements              mean average avg standard deviation std dev stddev              variance Counter StatsCounter collection measurement              measure count sum elements items

StatsCounter: A statistics-enabled Python container
---------------------------------------------------

::

         _        _                             _
     ___| |_ __ _| |_ ___  ___ ___  _   _ _ __ | |_ ___ _ __
    / __| __/ _` | __/ __|/ __/ _ \| | | | '_ \| __/ _ \ '__|
    \__ \ || (_| | |_\__ \ (_| (_) | |_| | | | | ||  __/ |
    |___/\__\__,_|\__|___/\___\___/ \__,_|_| |_|\__\___|_|


StatsCounter is a GNU Licensed, statistics powered version
of Python's standard library ``Counter`` class. It attaches
several helpful methods that can be used to make your
data-driven uses a breeze.

Usage
-----

As a histogram
~~~~~~~~~~~~~~

.. code-block:: python

    >>> import statscounter as stats
    >>> letter_freq = stats.StatsCounter(a=1, b=2, c=3, d=4, e=4, f=6)
    >>> letter_freq.mean()      # average frequency
    3.3333333333333335
    >>> letter_freq.mode()      # most frequent element
    4
    >>> letter_freq.median()    # the median number (avg if even # of items)
    3.5
    >>> letter_freq.variance()  # sample variance
    3.066666666666667
    >>> letter_freq.stdev()     # sample standard deviation
    1.7511900715418263
    >>> letter_freq.pvariance() # population variance
    2.555555555555556
    >>> letter_freq.pstdev()    # population std. dev.
    1.5986105077709065
    >>> letter_freq.max()       # the maximum value
    6
    >>> letter_freq.argmax()    # the argument yielding the maximum value
    "f"

As a utility
~~~~~~~~~~~~

.. code-block:: python

    >>> import statscounter as stats
    >>> stats.mean([1, 2, 3, 4, 4, 6])      # average frequency
    3.3333333333333335
    >>> stats.mode([1, 2, 3, 4, 4, 6])      # most frequent element
    4
    >>> stats.median([1, 2, 3, 4, 4, 6])    # the median number (avg if even # of items)
    3.5
    >>> stats.variance([1, 2, 3, 4, 4, 6])  # sample variance
    3.066666666666667
    >>> stats.stdev([1, 2, 3, 4, 4, 6])     # sample standard deviation
    1.7511900715418263
    >>> stats.pvariance([1, 2, 3, 4, 4, 6]) # population variance
    2.555555555555556
    >>> stats.pstdev([1, 2, 3, 4, 4, 6])    # population std. dev.
    1.5986105077709065
phizz 0.2.3
Tool to query hpo database and some other sources
License: MIT
Keywords: hpo omim hgnc

[![Build Status](https://travis-ci.org/moonso/phizz.svg)](https://travis-ci.org/moonso/phizz)

# phizz #

Tool to query HPO and OMIM

## Installation ##

```pip install phizz```

or 

```
$git clone https://github.com/moonso/phizz.git
$cd phizz
$python setup.py install
```

## Usage ##

Using command line utility:

```
Usage: phizz query [OPTIONS]

  Query the hpo database.

  Print the result in csv format as default.

Options:
  -c, --config PATH
  -h, --hpo_term TEXT     Specify a hpo term
  -m, --mim_term TEXT     Specify a omim id
  -o, --outfile FILENAME  Specify path to outfile
  -j, --to_json           If output should be in json format
  --help                  Show this message and exit.
```

so trying:

```
$ phizz query -m OMIM:615373
#hpo_id	description
HP:0011675	Arrhythmia
HP:0001644	Dilated cardiomyopathy
HP:0001653	Mitral regurgitation
HP:0000006	Autosomal dominant inheritance
HP:0001711	Abnormality of the left ventricle
```
to json:

```
$ phizz query --hpo_term HP:0000002 --to_json
[{"hpo_term": "HP:0000002", "description": "Abnormality of body height"}]
```

Importing in python:

```
In [1]: import phizz

In [2]: phizz.query_disease(['OMIM:615373'])
Out[2]:
[{'description': u'Arrhythmia', 'hpo_term': u'HP:0011675'},
 {'description': u'Dilated cardiomyopathy', 'hpo_term': u'HP:0001644'},
 {'description': u'Mitral regurgitation', 'hpo_term': u'HP:0001653'},
 {'description': u'Autosomal dominant inheritance', 'hpo_term': u'HP:0000006'},
 {'description': u'Abnormality of the left ventricle',
  'hpo_term': u'HP:0001711'}]
```
imporganizer 1.1
A Python import organizer
License: MIT
Keywords: development import organizer organizing

============
Imporganizer
============
Imporganizer organizes any imports of Python files found in the start of the file, putting them in alphabetic order. Comments or docstrings in the first lines are not supported yet. This feature is planned.

Requisites
----------

Your imports need to be formatted in these rules:

* They must be at the start of the file (blank lines before the first import will be removed).
* They must use forward-slash to define multi-line imports.
* They must be separated from the rest of the file (Python code) by 2 empty lines.

**GOOD:**

    from django.models import Model, \
        Manager

**BAD:**

    from django.models import (Model,
        Manager)

Usage
-----

Install using pip:

    pip install imporganizer

Use with the command line (main usage):

    imporganizer organize-this.py --third-party=package1,package2 --homemade=package3,package4

Update the standard packages list with:

    imporganizer --update-builtin

You can't update the builtin list and organize a file with a single command, but this is a feature in our roadmap.

Output
------

They will be categorized by:

* **Standard:** all packages included with the default distribution of Python.
* **Third party:** all packages not standard and not internal to the project.
* **Homemade:** dependencies, packages and modules internal to the project.

To be able to categorize your packages this way, you must inform which ones are third party and which ones are internal to the project. You do this by the command line:

    imporganizer organize-this.py --third-party=package1,package2 --homemade=package3,package4

For an input like this:

    from django.forms import Form, \
        CharField
    from textwrap import dedent

    from django.db.models import Model
    import sys
    import os
    import internal

    import another_internal


    print('hey')

The output will be:

    import os
    import sys
    from textwrap import dedent

    from django.db.models import Model
    from django.forms import CharField, \
        Form

    import another_internal
    import internal


    print('hey')

It will assume a maximum line length of 79 characters.