semvec/pypi-packages huggingface dataset:
pikvm-cli 1.1.0
CLI tool for managing PIKVM device
License: MIT

# pikvm-cli

A command-line interface (CLI) for controlling PIKVM devices.

## Installation

You can install the `pikvm-cli` package from PyPI:

```sh
$ pip install pikvm-cli
```

## Usage

To use the `pikvm-cli` tool, you must first configure it with the URL, username, and password of your PIKVM device:

```sh
$ pikvm-cli configure --url https://example.com --username admin --password password
```

_Note:_ configuration file is located at `~/.pikvm-cli`

Once the tool is configured, you can use it to retrieve information about your device:

```sh
$ pikvm-cli info
```

You can also use it to control the power of your device:

```sh
$ pikvm-cli atx on
$ pikvm-cli atx off
$ pikvm-cli atx off_hard
$ pikvm-cli atx reset
```

_Note:_ for the full list of available commands, run `pikvm-cli --help`

### Multiple Devices

If you have multiple PIKVM devices, you can configure the tool to use a specific device by passing the `--name` flag:

```sh
$ pikvm-cli info --name pikvm-1
```

_Note:_ if `--name` is not passed, "default" configuration will be used
sbmlcore 0.2.8
Constructs core features table for the application to machine learning models
License: MIT
Requires Python: >=3.6

[![Tests](https://github.com/fowler-lab/sbmlcore/actions/workflows/tests.yaml/badge.svg)](https://github.com/fowler-lab/sbmlcore/actions/workflows/tests.yaml)
[![codecov](https://codecov.io/gh/fowler-lab/sbmlcore/branch/main/graph/badge.svg?token=P44BPYQBFS)](https://codecov.io/gh/fowler-lab/sbmlcore)
[![PyPI version](https://badge.fury.io/py/sbmlcore.svg)](https://badge.fury.io/py/sbmlcore)
[![DOI](https://zenodo.org/badge/448929365.svg)](https://zenodo.org/badge/latestdoi/448929365)


# sbmlcore
Collection of core classes to help with building structure- and chemistry-based feature datasets to train machine learning models to predict antimicrobial resistance.

This is under active development and so is subject to change with no notice.

We will be making a series of jupyter-notebooks demonstrating how to use the classes available [here](https://github.com/fowler-lab/sbmlcore-tutorials).

## Included features

### Changes in Amino Acid Properties

- Volume
- Hydropathy scales: Kyte-Doolittle ([paper](https://www.sciencedirect.com/science/article/abs/pii/0022283682905150?via%3Dihub)) and WimleyWhite ([paper](https://www.nature.com/articles/nsb1096-842))
- Molecular weight
- Isoelectric point

### Secondary structure

- STRIDE ([website](http://webclu.bio.wzw.tum.de/stride/) and [paper](https://onlinelibrary.wiley.com/doi/10.1002/prot.340230412))

### Solvent accessible surface areas

- FreeSASA ([paper](https://f1000research.com/articles/5-189/v1))
- STRIDE ([website](http://webclu.bio.wzw.tum.de/stride/) and [paper](https://onlinelibrary.wiley.com/doi/10.1002/prot.340230412))

### Likelihood of changes in protein function

- SNAP2 ([server](https://www.rostlab.org/services/snap/) and [paper](https://bmcgenomics.biomedcentral.com/articles/10.1186/1471-2164-16-S8-S1))

### Effect of mutation on protein stability

- DeepDDG: a more recent neural network that claims to outperform DUET, PopMusic etc. ([paper](https://pubs.acs.org/doi/10.1021/acs.jcim.8b00697) and  [server](http://protein.org.cn/ddg.html)). Can do all possible mutations in one job.

### Structural distances

- Distances between mutated residues and any atom/group of atoms of interest. Uses MDAnalysis ([paper1](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3144279/) and [paper2](https://conference.scipy.org/proceedings/scipy2016/oliver_beckstein.html)).

## To potentially include at a later stage
 - Secondary structure: DSSP (do not anticipate much difference to STRIDE)
 - Protein stability:
    1. StabilityPredict. Online metapredictor, single amino acid at a time. Josh used in the pncA paper but had to contact them directly to run the entirity of PncA. ([paper](https://www.jbc.org/article/S0021-9258(20)34176-4/fulltext))
    2. DynaMUT. Also claims to outperform DUET etc. ([paper](https://academic.oup.com/nar/article/46/W1/W350/4990022)). Can process a list of specified mutations in one job. ([server](http://biosig.unimelb.edu.au/dynamut/))

PWF, 9 May 2023
fieldrouter 1.0.4
Data model validation for nested data routes
License: MIT
Requires Python: >=3.10

# fieldrouter: Data model validation for nested data routes

`fieldrouter` is a Python library that provides helpers for modelling routes in highly nested structured data.

It should be considered for cases when exhaustively modelling the tree structures involved is
surplus to requirements (in other cases you would simply use Pydantic in the regular way),
or perhaps if you want to specify 'routes' on an existing data model.

For example to access the number 30 in

```py
data = {"a": {"aa": {"aaa": [10, 20, 30]}}}
```

You would typically need to write Pydantic models for each level

```py
class A(BaseModel):
    a: AA

class AA(BaseModel):
    aa: AAA

class AAA(BaseModel):
    aaa: list[int]

thirty = A.model_validate(data).a.aa.aaa[2]
```

With `fieldrouter` you would instead specify a 'route' for the subpath on a 'router' model
(which is just a regular Pydantic model with default argument validation):

```py
from fieldrouter import Routing, RoutingModel

class A(RoutingModel):
    thirty: Routing(int, "a.aa.aaa.2")

thirty = A.model_validate(data).thirty
```

## Route syntax

### Relative references

You can reference another field in a route by prefixing its field name by a dot, such as `x` here:

```py
class B(RoutingModel):
    x: Routing(int, "foo.0.etc")
    b1: Routing(int, ".x.0.bar")
    b2: Routing(int, ".x.1.bar")
```

The prefix `.x` is substituted for `foo.0.etc` (the value of the Route for the field x).

This is equivalent to the following routes without references to the `x` field:

```py
class B(RoutingModel):
    x: Routing(int, "foo.0.etc")
    b1: Routing(int, "foo.0.etc.0.bar")
    b2: Routing(int, "foo.0.etc.1.bar")
```

Use this to keep your subpaths readable.


### The identity route

Sometimes when you're exploring nested data you want a reminder (or easy access to) the entire
data at a given route. This is available at the `.` route (the route string made up of a single
dot). This is known as the 'identity' route.

```py
class I(RoutingModel):
    full: Routing(dict, ".")
```

This will just give you the entire input, in this case as a dict field named `full`.

## Generics

> **Note**: deprecated since v1.0

You can also write routing models in a more 'longform' way, using one model for the routes and
another for the types:

```py
from fieldrouter.generic import RouterModel, Route

class Where(RouterModel):
    thirty: Route = "a.aa.aaa.2"
```

Then you can model the value at that route with a corresponding field on a 'routed' model
(which is a generic model which takes the router as a type argument):

```py
from fieldrouter.generic import Routed, R

class What(Routed[R]):
    thirty: int
```

Then you can use the router class as a generic type argument to the instance of the routee:

```py
model = What[Where].model_validate(data)
```