semvec/pypi-packages huggingface dataset:
hmmlogo 0.0.4
Package to plot logos for profile hidden Markov models.
Requires Python: >=3.6

# Table of Contents

1.  [Introduction](#org61820c1)



<a id="org61820c1"></a>

# Introduction

[Pfam](https://pfam.xfam.org/) is a database that collects information about protein families
and domains.  Profile hidden Markov models (HMMs) are used to
classify the protein families and hold information about
conservation and variability within family members.  Sequence logos
are graphical representations of biological sequence alignments or
HMMs, that give information about the conservation.
automatic-behavior-analysis 0.0.21
Program complex for automated behavior analysis
Requires Python: >=3.6,<4.0

# AutomaticBehaviorAnalysis

## Installation
### pip
Client (in cache mode)
To work with the cache, you need to place the video and cache file in the same folder.

Package installation:

`pip install --user automatic-behavior-analysis`

Package update:

`pip install --upgrade --user automatic-behavior-analysis`

Client launch:

`aba-client`

ATTENTION!
For correct operation, the package path should not contain Cyrillic characters.

## Requirements

* Python 3
* TensorFlow
* [Tensorflow Object Detection API](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/installation.md)
* Keras
* numpy
* PIL
* appdirs
* openCV
* websocket
* imageio

### Client2

* pip install PyQt5 opencv-python appdirs requests matplotlib scipy pandas

## Build a container with a server

### Development container

There are no files and models in the development container in order to minify the image and increase the usability.

The container is collected by the following command:

```bash
# For container with GPU support 
docker build -t registry.gitlab.com/digiratory/automatic-behavior-analysis/dev-gpu .
# For container with CPU support only 
docker build  -f Dockerfile.dev.cpu -t registry.gitlab.com/digiratory/automatic-behavior-analysis/dev-cpu .
```

There's no need to rebuild the container for work and you can pick up the assembled from the repository using the following commands:

```bash
docker login registry.gitlab.com
# To run a container with GPU support 
docker run --runtime=nvidia -it -v <workspace>:/home/user/ -p 1217:1217 registry.gitlab.com/digiratory/automatic-behavior-analysis/dev-gpu:latest

# For container with CPU support only 
docker run -it -v <workspace>:/home/user/ -p 1217:1217 registry.gitlab.com/digiratory/automatic-behavior-analysis/dev-cpu:latest
```

For CPU-only:

```bash
docker login registry.gitlab.com
docker run -it -v <workspace>:/home/user/ -p 1217:1217 registry.gitlab.com/digiratory/automatic-behavior-analysis/dev-cpu:latest
```

If the machine does not have gpu, then the key `--runtime=nvidia` no need to specify.

ATTENTION! The development container does not include source code, models, and more.

## Launch applications

Launch order:

1. Server part
2. Client side

Shutdown Procedure:

1. Client side
2. Server part

### Server

To start the server side, you must run ./server.py

```bash
python3 ./server.py
```

Team Arguments:
[ip= ] — Ip wiretap address (Default 172.0.0.1 )
[port= ] — Server Port (Default 1217)

### Client part (GUI)

To start the client side, you must run ./client_gui.py

```bash
python3 ./client_gui.py
```

Team Arguments:
[ip= ] — Ip server address (Default 172.0.0.1 )
[port= ] — Server Port (Default 1217)
pyTRIS 0.2.6
Simple no-dependencies API wrapper for Highways England's WebTRIS Traffic Flow API
Requires Python: >=3.6, <4
Keywords: transport

# pyTRIS
![Pytest](https://github.com/asongtoruin/pyTRIS/workflows/Pytest/badge.svg)
[![codecov](https://codecov.io/gh/asongtoruin/pyTRIS/branch/main/graph/badge.svg)](https://codecov.io/gh/asongtoruin/pyTRIS)
[![PyPI version](https://badge.fury.io/py/pyTRIS.svg)](https://pypi.org/project/pyTRIS/)

A simple API wrapper for Highways England's WebTRIS Traffic Flow API. 
Documentation is available [here](https://asongtoruin.github.io/pyTRIS).
coinstacparsers 0.0.3
fsl, vbm and csv parsers

# coinstacparsers 

This package includes fsl_parser, vbm_parser and csv parser. fsl_parser parses the freesurfer files (specified in inputspec.json) as dependencies and returns 
the covariates (X) and dependent (y) matrices as dataframes. The format of inputspec.json should be as shown in the example inputspec.json here.
Similarly vbm_parser parses NIfTI images as dependencies and returns the covariates (X) and dependent (y) matrices as dataframes. 
csv_parser reads the values specified in inputspec.json file and returns the covariates (X) and dependent (y) matrices as dataframes.
# How to install
pip install coinstacparsers
# How to run
for fsl parser: \
 &nbsp;&nbsp;&nbsp;&nbsp; import coinstacparsers \
 &nbsp;&nbsp;&nbsp;&nbsp; from coinstacparsers import parsers \
 &nbsp;&nbsp;&nbsp;&nbsp; args = json.loads(sys.stdin.read()) \
 &nbsp;&nbsp;&nbsp;&nbsp; (X, y) = parsers.fsl_parser(args) \
for vbm parser: \
 &nbsp;&nbsp;&nbsp;&nbsp; import coinstacparsers \
 &nbsp;&nbsp;&nbsp;&nbsp; from coinstacparsers import parsers \
 &nbsp;&nbsp;&nbsp;&nbsp; args = json.loads(sys.stdin.read()) \
 &nbsp;&nbsp;&nbsp;&nbsp; mask = os.path.join('/computation', mask_directory, mask_file_name) \
 &nbsp;&nbsp;&nbsp;&nbsp; (X, y) = parsers.vbm_parser(args, mask)
for csv parser: \
 &nbsp;&nbsp;&nbsp;&nbsp; import coinstacparsers \
 &nbsp;&nbsp;&nbsp;&nbsp; from coinstacparsers import parsers \
 &nbsp;&nbsp;&nbsp;&nbsp; args = json.loads(sys.stdin.read()) \
 &nbsp;&nbsp;&nbsp;&nbsp; (X, y) = parsers.csv_parser(args)
asexecutor 0.2
A convenient python library to execute ASE (Atomic Simulation Environment) calculators on clusters.

asexecutor
============

|Binder| |PyPI version| |Code style: black| |MIT license|

Asexecutor is a convenient python library to wrap ASE (Atomic Simulation Environment) calculators to be executed on clusters.

.. |Binder| image:: https://mybinder.org/badge_logo.svg
   :target: https://mybinder.org/v2/gh/efiminem/asexecutor/master

.. |PyPI version| image:: https://badge.fury.io/py/asexecutor.svg
   :target: https://pypi.org/pypi/asexecutor

.. |MIT license| image:: https://img.shields.io/badge/License-MIT-blue.svg
   :target: https://lbesson.mit-license.org/

.. |Code style: black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
   :target: https://github.com/psf/black

============
Installing
============

You can install asexecutor via pip:

.. code:: shell

	$ pip install asexecutor

==============
Documentation
==============

Detailed documentation will be available soon.

============
License
============

Asexecutor is distributed under the MIT `license
<https://github.com/efiminem/asexecutor/blob/master/LICENSE>`_.
pg-replica-auditor 0.15
Run a few sanity checks on your logical PostgreSQL replica to make sure its the same as the primary.
Requires Python: >=3

# pg-replica-auditor

A tool to compare a PostgreSQL logical replica to its primary. It can help detect data inconsistencies.

## Features

### Assumptions
These tests assume that `id` and `updated_at` (or column specified in `--lag-column`) columns exist and have indexes for efficient querying and that the table exists on both databases.

#### Row comparison
Runs row comparisons between primary and replica using two methods:

1. select 8128 rows (or number of rows given to `--rows`) at random between `MIN(id)` and `MAX(id)`
2. select the last 1000 rows.

#### Replica lag
Checks for "replica lag" by comparing `MAX(updated_at)` on the given table on both databases.

#### MinMax
Checks that the minimum `id` and the maximum `id` match on both replica and primary. These can drift _a little_ because of replica lag.

#### Bulk 1000 Sum
Take the sum of the `id` column in chunks of 1000 and compare it between databases. This assumes that retrieving rows in bulk is easier than at random and runs faster than the row comparison and can scan more rows.

#### Count all rows
Counts all the rows using `COUNT(lag_column)` to make sure row counts match on both replica and primary. Very slow, since it has to do a full scan (index or table). Adjust `--count-before` to count all columns before a timestamp on `--lag-column`, or `updated_at` by default.

#### Missing Sequential Records
Go throught the table with a step size of `MAX(id)` * `--step-size=0.01`. The assumption is that if records will be missing, they will be missing in bulk, grouped together.

## Requirements

1. Python 3
2. Postgres development files (required by psycopg2). On Mac OS, use `brew install postgresql`. On Ubuntu, install `libpq-dev`.

## Installation

### Development
Using virtualenv, `pip install -r requirements.txt`

### Production
Using Pypi, `pip install pg-replica-auditor`.

## Usage

This script requires three arguments:
1. `--primary`, any acceptable Postgres connection string (incl. DSN),
2. `--replica`, same as `--primary` but for the replica database,

Optional arguments:
1. `--exclude-tables`, excludes the comma-separated tables from the scan,
2. `--table`, only scans this table,
3. `--debug`, will print debugging information,
4. `--rows`, will scan this many rows in the row comparisons check,
5. `--lag-column`, will use this column for the replica lag check,
6. `--show-skipped`, will print the skipped rows in the Last 1000 check,
7. `--count-before`, will count all rows in the table created/updated before this timestamp,
8. `--step-size`, will decrease the step size for missing sequential records search.

Example:

```bash
$ pgreplicaauditor --primary=postgres://primary-db.amazonaws.com:5432/my_db --replica=postgres://replica-db.amazonaws.com:5432/my_db --table=immutable_items --lag-column=created_at --count-before="2020-04-06"
```
reify 0.4
A standalone tool for rendering jinja templates

usage: reify [-h] [--context CONTEXT] [--envfile ENVFILE] [--output OUTPUT]
             [--mode MODE] [--charm-config CHARM_CONFIG]
             template [extra [extra ...]]

render a jinja2 template

positional arguments:
  template              the template file
  extra                 extra key value pairs (foo=bar)

optional arguments:
  -h, --help            show this help message and exit
  --context CONTEXT, -c CONTEXT
                        file to load context data from. Can also be read from
                        stdin.
  --envfile ENVFILE, -e ENVFILE
                        file with environment varibles
  --output OUTPUT, -o OUTPUT
                        output file; defaults to stdout
  --mode MODE, -m MODE  mode of output file, if not stdout; defaults to 0666 -
                        umask
  --charm-config CHARM_CONFIG
                        charm config file, default values will be added to
                        template context
live-client 0.8.2
Client libraries to connect with the Intelie LIVE platform
Requires Python: >=3.6

# Live Client

A toolset to interact with the Intelie LIVE Platform


## Usage examples

```
import sys
import argparse

from live_client.query import on_event
from live_client.events import messenger


def parse_arguments(argv):
    parser = argparse.ArgumentParser(
        description="Connects to a live instance and watches every query which is started",
        epilog="For each query, sends a message to one of the messenger's rooms"
    )
    parser.add_argument("--live_url", dest="live_url", required=True, help="The url Intelie Live")
    parser.add_argument("--username", dest="username", required=True, help="Live username")
    parser.add_argument("--password", dest="password", required=True, help="Live password")
    parser.add_argument(
        "--rest_input", dest="rest_input", required=True, help="Path of the rest input integration"
    )
    parser.add_argument("--user_id", dest="user_id", required=True, help="Live user id")
    parser.add_argument("--room_id", dest="room_id", required=True, help="Target room id")

    return parser.parse_args(argv[1:])


def build_settings(args):
    return {
        "output": {
            "author": {"id": args.user_id, "name": "🤖  Messages bot "},
            "room": {"id": args.room_id},
        },
        "live": {
            "url": args.live_url,
            "rest_input": args.rest_input,
            "username": args.username,
            "password": args.password,
            "user_id": args.user_id,
        },
    }


if __name__ == "__main__":
    """
    Connects to a live instance and watches every query which is started
    For each query, sends a message to one of the messenger's rooms
    """
    args = parse_arguments(sys.argv)
    settings = build_settings(args)

    example_query = "__queries action:start => expression, description"
    span = f"last 60 seconds"

    @on_event(example_query, settings, span=span, timeout=120)
    def handle_events(event):
        event_data = event.get("data", {})
        content = event_data.get("content", {})
        template = "New query: '{}'"
        for item in content:
            message = template.format(item["expression"])
            print(message)
            messenger.send_message(
                message, timestamp=item["timestamp"], process_settings=settings
            )

        return

    handle_events()
```

More examples can be found on the folder `docs/examples`.

## Development

This project uses [black](https://github.com/psf/black) and [pre-commit](https://pre-commit.com/)

### Running the Tests

If you installled `dev-requirements.txt` you already have `pytest` installed.
Then just `cd` to the `tests` directory and run `pytest`.

### Publishing to pypi

```
# Build the packages
$ python setup.py egg_info sdist

# Validate the package
$ twine check dist/*

# Upload the package
$ twine upload dist/*
```