semvec/pypi-packages huggingface dataset:
YealinkManager 2.1
Automate Action Uri in yealinkPhone
Requires Python: >3.6.0

# YealinkManager

install using ``` pip install YealinkManager```
after doing this you got two new shell commands:
```YealinkManager``` and the short form ```ym```.
you shuld use it in this way: 

    ym path/to/list.csv

This module read the csv file, that must be composed in this way:

    ip, action, credential, row comment 

Exemplum gratie:

    192.168.9.101,HEADSET,admin:admin,Commento1

One at time the script will read the parameters, build the action Uri and call it.

In the list the character ```#``` at the beginning of line is a comment.

__Remember to enable remote control on your yealink phone and set the remote controller ip correctly!__
wtk 0.2.1.3
A Wasserstein Subsequence Kernel for Time Series
Requires Python: >=3.6

# Wasserstein Time Series Kernel

### Installation
The easiest way is to install WTK from the Python Package Index (PyPI) via

```
$ pip install wtk
```

### Usage
The package provides functions to transform a set of `n` training time series and `o` test time series into an `n x n` distance matrix for training and an `o x n` distance matrix for testing.
Additionally, we provide a way to run a grid search for a krein space SVM. `krein_svm_grid_search` runs a `5`-fold
cross-validation on the training set to determine the best hyperparameters. Then, its classification accuracy is
computed on the test set.

```
from wtk import transform_to_dist_matrix
from wtk.utilities import get_ucr_dataset, krein_svm_grid_search

# Read UCR data
X_train, y_train, X_test, y_test = get_ucr_dataset('../data/UCR/raw_data/', 'DistalPhalanxTW')

# Compute wasserstein distance matrices with subsequent length k=10
D_train, D_test = transform_to_dist_matrix(X_train, X_test, 10)

# Run the grid search
svm_clf = krein_svm_grid_search(D_train, D_test, y_train, y_test)
```

Alternatively, you can get the kernel matrices computed from the distance matrices and train your own classifier.
```
from sklearn.svm import SVC
from wtk import get_kernel_matrix
from sklearn.metrics import accuracy_score

# Get the kernel matrices
K_train = get_kernel_matrix(D_train, psd=True, gamma=0.2)
K_test = get_kernel_matrix(D_test, psd=False, gamma=0.2)

# Train your classifier
clf = SVC(C=5, kernel='precomputed')
clf.fit(K_train, y_train)

y_pred = clf.predict(K_test)
print(accuracy_score(y_test, y_pred))
```

# Help

If you have questions concerning WTK or you encounter problems when
trying to build the tool under your own system, please open an issue in
[the issue tracker](https://github.com/BorgwardtLab/WTK/issues). Try to
describe the issue in sufficient detail in order to make it possible for
us to help you.

# Contributors

WTK is developed and maintained by members of the [Machine Learning and
Computational Biology Lab](https://www.bsse.ethz.ch/mlcb) of [Prof. Dr.
Karsten Borgwardt](https://www.bsse.ethz.ch/mlcb/karsten.html):

- Christian Bock ([GitHub](https://github.com/chrisby))
- Matteo Togninalli ([GitHub](https://github.com/mtog))
- Bastian Rieck ([GitHub](https://github.com/Submanifold))
batch-run-cmd 0.0.2
To run commands line by line, and check each exit status
Requires Python: >=3.5

# batch-run-cmd

## 1 Introduction


See `https://github.com/linzhi2013/batch-run-cmd`.

This is a Python3 package which will read command lines from an input file,
and run each line of command one by one, and check their exit status.

More importantly, if one command fails, you can just jump to next command
(`-e` option). Furthermore, you can check for the existences of result files
(`-E` option).


## 2 Installation

with `pip`

    $ pip install batch-run-cmd

There will be a command `batch_run_cmd` created under the same directory as your `pip` command.

## 3 Usage
run `batch_run_cmd`

    $ batch_run_cmd
	usage: batch_run_cmd [-h] [-f <file>] [-e <int> [<int> ...]] [-E <str>]

	    To run command line by line, and check each exit status.

	    Then optionally check for the existences of result files.

	    Each line format:

	    echo "Hello world" && echo "Where are you?" ;Result-files: /path/to/resultfile1 /path/to/resultfile2

	    Internally, each line will be split by ";Result-files:" delimiter,
	    and the part before ";Result-files:" will be treated as a shell command,
	    the part after ";Result-files:" will be regardeds as result files.

	    Multiple result files are allowed, seperated by blank space(s).

	    See https://github.com/linzhi2013/batch-run-cmd for more details.


	optional arguments:
	  -h, --help            show this help message and exit
	  -f <file>             commands in a file.
	  -e <int> [<int> ...]  continue On Return Code for a shell command. [[0]]
	  -E <str>              continue On: 'a': all files must exist; 'e': at least
	                        one file must exist; 'o': omitted, i.e. do not check
	                        for existences of files [o]


## 4 Citation
Currently I have no plan to publish `batch-run-cmd`.