semvec/pypi-packages huggingface dataset:
callmemaybe 1.0.4
A CLI tool to talk to you
License: MIT

# Call Me Maybe

_Call Me Maybe_ (cmm) is a command line tool to send the results of a command line (shell) script to _you_, whatever
_you_ might be.

```shell script
 ./compute_some_big_stuff.sh | awk "{some magic}" | cmm -t >> result.txt
```

And you will get, having configured the `twilio` settings, a text message with the results of your big compute.

Otherwise, `cmm` behaves as `tee`: it spits out exactly what it gets in.


## Getting started

`> pip3 install callmemaybe`

You will need to create a configuration file, so `cmm` knows who it has to send the information too. You can generate
a sample config file by simply doing:

`> cmm -c >> ~.callmemaybe`

After filling the fields you want to use, you're good to go!

## Supported "Communicators"

Right now, `cmm` supports the following:

- [X] Twilio Text Messages

- [X] Log Files 

- [X] Pushover

- [ ] Telegram Bots (WIP)

You can open up an issue with the label "NCommunicator" to suggest a new way of talking to you.
langauge 0.0.3
LanGauge: 'gauge' the usefulness of open-source medical datasets
License: MIT
Requires Python: >=3.6
Keywords: AI,NLP,Flapmax

# LanGauge
LanGauage: NLP experiment platform. To be open-sourced publicly (Apache 2.0 or similar).

## Architecture
![architecture](images/arc.png)

## What is it?
Natural Language Processing (NLP) is one of the most important fields of research in today’s world. It has many applications such as chatbots, sentiment analysis, and document classification. 

LanGauge is a web application leveraging Natural Language Processing (NLP) to reduce the time spent analyzing medical research papers in an easy-to-use fashion. This free, open-source platform helps researchers in fields such as drug discovery curate their data to secure and scale the development of health solution. An example application would be enhancing COVID-19 research using multiple NLP models on medical datasets.  

We want to use the language processing models to “gauge” the usefulness of open-source medical datasets for the researchers.  

## How to run the project using pip ?
 1. Create (or navigate to) a folder you would like to use with LanGauge and create a virtual environment
 
    On Linux use
    ```bash
    python3 -m venv env
    ```
    and activate it using
    ```bash
    source env/bin/activate
    ```
 2. Install using
    ```bash
    pip install langauge
    ```
 3. Now, Run the following command line instruction 
     for starting the front end
     ```
     langauge ui [OPTIONS]
     
     Options:
     -h, --host TEXT          The network address to listen on (default:
                              127.0.0.1). Use 0.0.0.0 to bind to all addresses if
                              you want to access the tracking server from other
                              machines.

     -p, --port INTEGER       The UI port to configure on (default:8080)

     -b --backend TEXT        The backend address & port to listen on
                              requests (default: 127.0.0.1:5000).
                              
     --help                   Show this message and exit.
     ```

     and for the backend use

     ```
     langauge backend [OPTIONS]
     
     Options:
     -bp, --backendport INTEGER  The backend port to configure on (default:5000)
     ```

## or using docker-compose?
 1. Clone the repository.
 ```bash
 git clone https://github.com/flapmx/LanGauge-INTERNAL.git
 ```
 2. Ensure you have docker and docker-compose installed.
    
 3. Move to langauge directory
 ```bash
 cd langauge
 ```
 
 4. Build and Launch the project
 ```bash
 docker-compose up --build -d
 ```
 
## How to access the application?
 1. http://localhost:8080 for the React front end
 2. http://localhost:5000 for the Flask back end
 3. http://localhost:5555 for the monitoring Celery

## How to shut down?
```bash
 docker-compose down
 ```
sito-io 0.0.2
Standard Interfaces for Object Transformation - File I/O Structures
License: MIT
Keywords: setup,distutils

# sito-io
Standard Interfaces for Transforming Objects - File I/O

The goal of this library is to provide data structures and interfaces which are 
at least as ergonomic as existing file I/O and path primitives (`open`, `Path`, etc),
while providing strongly typed functionality to facilitate transformations of collections of
files. 

### Core concepts

#### Resource

A Resource is the core unit of abstraction. It is kind of like a sum type of a `os.Path` and `urllib.parse.ParseResult`. 
Its essence is to act as a handle to a more sophisticated resource, such as a file, directory, 
URL, endpoint, transaction, FIFO, special file, etc. 

#### Context

A Context is a Resource that can be used to "anchor" another Resource. For example, a context might be 
`http://example.com`, `/home/user`, or even `.`. A context can be: 
- Fully qualified - `file:///home/user/foo/bar`, `http://example.com/foo/bar`, `ftp://example.com/foo/bar`
- Absolute - `/home/user/foo/bar`, `/home/user/arch.tar::/foo/bar`
- Relative - `./bar` - Relative contexts must be rooted before they can be fully 
resolved
- Naive - `bar` - Naive contexts must be rooted before they can be fully resolved

#### Manifest

A Manifest is a collection of Resources. This might be files on disk (or a description thereof, it need not exist),
or files in a TAR file, or endpoints. The primary purpose is to facilitate moving collections of files atomically, 
capturing I/O of a process, and "slurping up" the data, thus allowing stateful processes to be modeled as a transaction. 
This makes a process behave less like a mutation and more like a lambda, improving referential transparency 
in pipelines. 

A Manifest can be used to generate a ManifestFile, a serialized index of the manifest. This can be packed 
with the files and give an easy handle to verify the contents of a transaction.