semvec/pypi-packages huggingface dataset:
markit-tcpbroker 1.8.4
IMU message broker
Requires Python: >=3.7

# IMU Interface

This repo contains code to interact with [rfimu-esp-node](https://github.com/mvig-robotflow/rfimu-esp-node).

## Get Started

```shell
git clone https://github.com/mvig-robotflow/rfimu-interface.git
python setup.py install
```

Or from PYPI:

```shell
python -m pip install markit-tcpbroker
```

## Documentation

For documentation, please refer to [rfimu-interface/docs](https://github.com/mvig-robotflow/rfimu-interface/docs).
Trial2Vec 0.1.0
Pretrained BERT models for encoding clinical trial documents to compact embeddings.
Keywords: clinical trial,machine learning,data mining,information retrieval

# Trial2Vec
[![PyPI version](https://badge.fury.io/py/transtab.svg)](https://badge.fury.io/py/trial2vec)
[![Downloads](https://pepy.tech/badge/trial2vec)](https://pepy.tech/project/trial2vec)
![GitHub Repo stars](https://img.shields.io/github/stars/ryanwangzf/trial2vec)
![GitHub Repo forks](https://img.shields.io/github/forks/ryanwangzf/trial2vec)

Wang, Zifeng and Sun, Jimeng. (2022). Trial2Vec: Zero-Shot Clinical Trial Document Similarity Search using Self-Supervision. Findings of EMNLP'22.

# News
- 12/8/2022: Support `download_embedding` that obtains the pretrained embedding only. It saves a lot of GPU/CPU memory! Please refer this [example](example/demo_download_embedding.ipynb) for detailed use cases.

```python
from trial2vec import download_embedding
t2v_emb = download_embedding()
```

- 10/27/2022: Support `word_vector` and `sentence_vector`!
```python
# sentence vectors
inputs = ['I am a sentence', 'I am another sentence']
outputs = model.sentence_vector(inputs)
# torch.tensor w/ shape [2, 128]
```

```python
# word vectors
inputs = ['I am a sentence', 'I am another sentence abcdefg xyz']
outputs = model.word_vector(inputs)
# {'word_embs': torch.tensor w/ shape [2, max_token, 128], 'mask': torch.tensor w/ shape [2, max_token]}
```


# Usage
Get pretrained Trial2Vec model in three lines:

```python
from trial2vec import Trial2Vec

model = Trial2Vec()

model.from_pretrained()
```

A jupyter example is shown at https://github.com/RyanWangZf/Trial2Vec/blob/main/example/demo_trial2vec.ipynb.

# How to install
Install the correct `PyTorch` version by referring to https://pytorch.org/get-started/locally/.

Then install `Trial2Vec` by

```bash
# Recommended because it is update to date, small bugs will be kept fixed
pip install git+https://github.com/RyanWangZf/Trial2Vec.git

```

or
```bash

pip install trial2vec

```

# Search similar trials
Use `Trial2Vec` to search similar clinical trials:

```python

# load demo data
from trial2vec import load_demo_data
data = load_demo_data()

# contains trial documents
test_data = {'x': data['x']} 

# make prediction
pred = model.predict(test_data)
```

# Encode trials

Use `Trial2Vec` to encode clinical trial documents:

```python

test_data = {'x': df} # contains trial documents

emb = model.encode(test_data) # make inference

# or just find the pre-encoded trial documents
emb = [model[nct_id] for test_data['x']['nct_id']]
```

# Continue training

One can continue to train the pretrained models on new trials as

```python

# just formulate trial documents as the format of `data`
data = load_demo_data()

model.fit(
    {
    'x':data['x'], # document dataframe
    'fields':data['fields'], # attribute field columns
    'ctx_fields':data['ctx_fields'], # context field columns
    'tag': data['tag'], # nct_id is the unique tag for each trial
    },
    valid_data={
            'x':data['x_val'],
            'y':data['y_val']
        },
)

# save
model.save_model('./finetuned-trial2vec')

```
metarclone 0.0.1.dev2
Metadata-preserving backup with small file merging using Rclone
Requires Python: >=3.6

# metarclone

**metarclone** is a command-line utility to sync files with file attributes to rclone remotes. It aggregates files smaller than a certain threshold into larger tarballs, thus useful for remotes where creating lots of small files are not feasible, e.g. Google Drive, S3 Glacier.

***Note: Still under development; partial download sync is not implemented currently**

## Features

- Small-file aggregation while preserving directory structure whenever possible
- File attributes preservation (ctime, mtime, sparse files; permission, owner, ACLs on Linux) using tar
- Partial sync based on whole-file content and/or timestamps
- Configurable compression methods
pyobjconfig 0.1.4
An argparse+pydantic-based configuration system for Python.

# pyobjconfig

`pyobjconfig` is a module suite designed with Machine Learning (ML) experiments in mind, but should work for a broad range of hierarchical configurations.

## Example usage

Pyobjconfig supports configuring nested objects, such that each object has control over its own configuration:

```python

import argparse
import pyobjconfig as poc

# Any class which plugs into pyobjconfig should derive from `ConfigurableObject`
class Child(poc.ConfigurableObject):
    # To register configuration options for this class, add a `config` member
    # which derives from a pydantic model.
    class config(poc.PydanticBaseModel):
        # Pydantic handles basic type validation and allows default values to be
        # set
        inner: str = 'hello'

class Base(poc.ConfigurableObject):
    class config(poc.PydanticBaseModel):
        hello: str = 'hi'

    # Assigning a class deriving from `ConfigurableObject` as a member of a
    # class definition results in a nested object, which will be instantiated
    # using parameters from the command line.
    child = Child

ap = argparse.ArgumentParser()
Base.argparse_setup(ap)

args = ap.parse_args(['--child-inner', 'beep']).__dict__
obj = Base.argparse_create(args)
print(obj.config.hello)  # Prints 'hi'
print(obj.child.config.inner)  # Prints 'beep'

ap.print_help()
# usage: ipython [-h] [--hello HELLO] [--child-inner CHILD-INNER]
#
# optional arguments:
#   -h, --help            show this help message and exit
#   --hello HELLO         Default: hi
#   --child-inner CHILD-INNER
#                         Default: hello

```

Switches are also supported, such that the class (or value) of a child member may be changed at initialization time. Additionally, the `--help` for the `argparse` parser will change to reflect the choice of child:

```python
import pyobjconfig as poc
class A(poc.ConfigurableObject):
    pass
class B(poc.ConfigurableObject):
    pass
class Base(poc.ConfigurableObject):
    child = poc.ConfigurableSwitch({
        'a': A,
        'b': B,
        'none': None,
    }, default='none')
```

Experimentally, environment variables are supported. Not yet well tested, but calling `argparse_create(args, env='PREFIX')` will allow e.g. `PREFIX_CHILD=a` to be specified in the environment. Arguments on the command line take precedence.

```python
import argparse
import pyobjconfig as poc
```

## Usage with pytorch

Pytorch overrides `__setattr__` in a way that is incompatible with the `ConfigurableObject` class provided by `pyobjconfig`. To work around this, use the `pyobjconfig.torch.ConfigurableModule` as a drop-in replacement for `torch.nn.Module`.


# Changelog
* 2023-04-21 - v0.1.4. `argparse.ArgumentParser` has `type` specified for each argument now, so local equality comparisons against previous `argparse_hparams()` before object instantiation will work.
* 2023-04-18 - v0.1.3. Disallow `None` as parameter values because it serializes poorly, and disallow abbreviated parameter matches to avoid confusion.
* 2021-01-14 - v0.1.2. Support lists on the command line.
sshlab 0.2.0
A tool for launching Jupyter Notebooks on remote servers using SSH

# sshlab

Jupyter notebook / lab and tensorboard through ssh with a single command and config file

This script is inspired by https://github.com/nicolaschotard/stackyter but reimplemented to allow starting Jupyter in a container (singularity or docker) in the remote server

# Documentation

Visit https://vuillaut.github.io/sshlab/

# Usage

Copy the example settings file `.sshlab_config.yml` to your HOME and edit it to your needs.

## Install


```
pip install sshlab
```

or from source code:

```
pip install .
```

## Run 

```
sshlab -c singularity_config
```