# DeepPavlov Dream

**DeepPavlov Dream** is a platform for creating multi-skill generative AI assistants.

To learn more about the platform and how to build AI assistants with it, please visit [Dream](https://dream.deeppavlov.ai/). If you want to learn more about DeepPavlov Agent that powers Dream visit [DeepPavlov Agent documentation](https://deeppavlov-agent.readthedocs.io).

# Star History
[![Star History Chart](https://api.star-history.com/svg?repos=deeppavlov/dream&type=Date)](https://star-history.com/#deeppavlov/dream&Date)

# Distributions

We've already included six distributions: four of them are based on lightweight Deepy socialbot,
one is a full-sized Dream chatbot (based on Alexa Prize Challenge version) in English and a Dream chatbot in Russian.

### Deepy Base

Base version of Lunar assistant.
Deepy Base contains Spelling Preprocessing annotator,
template-based Harvesters Maintenance Skill,
and AIML-based open-domain Program-y Skill based on Dialog Flow Framework.

### Deepy Advanced

Advanced version of Lunar assistant.
Deepy Advanced contains Spelling Preprocessing, Sentence Segmentation,
Entity Linking and Intent Catcher annotators, Harvesters Maintenance GoBot Skill for goal-oriented responses,
and AIML-based open-domain Program-y Skill based on Dialog Flow Framework.

### Deepy FAQ

FAQ version of Lunar assistant.
Deepy FAQ contains Spelling Preprocessing annotator,
template-based Frequently Asked Questions Skill,
and AIML-based open-domain Program-y Skill based on Dialog Flow Framework.

### Deepy GoBot

Goal-oriented version of Lunar assistant.
Deepy GoBot Base contains Spelling Preprocessing annotator,
Harvesters Maintenance GoBot Skill for goal-oriented responses,
and AIML-based open-domain Program-y Skill based on Dialog Flow Framework.

### Dream

Full version of DeepPavlov Dream Socialbot.
This is almost the same version of the DREAM socialbot as at
[the end of Alexa Prize Challenge 4](https://d7qzviu3xw2xc.cloudfront.net/alexa/alexaprize/docs/sgc4/MIPT-DREAM.pdf).
Some API services are replaced with trainable models.
Some services (e.g., News Annotator, Game Skill, Weather Skill) require private keys for underlying APIs,
most of them can be obtained for free.
If you want to use these services in local deployments, add your keys to the environmental variables (e.g., `./.env`, `./.env_ru`).
This version of Dream Socialbot consumes a lot of resources
because of its modular architecture and original goals (participation in Alexa Prize Challenge).
We provide a demo of Dream Socialbot on [our website](https://demo.deeppavlov.ai).

### Dream Mini

Mini version of DeepPavlov Dream Socialbot.
This is a generative-based socialbot that uses [English DialoGPT model](https://huggingface.co/microsoft/DialoGPT-medium) to generate most of the responses. It also contains intent catcher and responder components to cover special user requests.
[Link to the distribution.](https://github.com/deeppavlov/dream/tree/main/assistant_dists/dream_mini)

### Dream Russian

Russian version of DeepPavlov Dream Socialbot. This is a generative-based socialbot that uses [Russian DialoGPT by DeepPavlov](https://huggingface.co/DeepPavlov/rudialogpt3_medium_based_on_gpt2_v2) to generate most of the responses. It also contains intent catcher and responder components to cover special user requests.
[Link to the distribution.](https://github.com/deeppavlov/dream/tree/main/assistant_dists/dream_russian)

### Prompted Dream Distributions

Mini version of DeepPavlov Dream Socialbot with the use of prompt-based generative models.
This is a generative-based socialbot that uses large language models to generate most of the responses.
You can upload your own prompts (json files) to [common/prompts](https://github.com/deeppavlov/dream/common/prompts),
add prompt names to `PROMPTS_TO_CONSIDER` (comma-separated),
and the provided information will be used in LLM-powered reply generation as a prompt.
[Link to the distribution.](https://github.com/deeppavlov/dream/tree/main/assistant_dists/dream_persona_prompted)

# Quick Start

### System Requirements

- Operating System: Ubuntu 18.04+, Windows 10+ (через WSL \& WSL2), MacOS Big Sur;
- Version of `docker` from 20 and above;
- Version of `docker-compose` v1.29.2;
- Operative Memory from 2 Gb (using proxy), from 4 Gb (LLM-based prompted distributions) and from  20 Gb (old scripted distributions).

### Clone the repo

```
git clone https://github.com/deeppavlov/dream.git
```

### Install [docker](https://docs.docker.com/engine/install/) and [docker-compose](https://docs.docker.com/compose/install/)

If you get a "Permission denied" error running docker-compose, make sure to [configure your docker user](https://docs.docker.com/engine/install/linux-postinstall/) correctly.

### Run one of the Dream distributions

#### **Deepy Base**

```
docker-compose -f docker-compose.yml -f assistant_dists/deepy_base/docker-compose.override.yml up --build
```

#### **Deepy Advanced**

```
docker-compose -f docker-compose.yml -f assistant_dists/deepy_adv/docker-compose.override.yml up --build
```

#### **Deepy FAQ**

```
docker-compose -f docker-compose.yml -f assistant_dists/deepy_faq/docker-compose.override.yml up --build
```

#### **Deepy GoBot**

```
docker-compose -f docker-compose.yml -f assistant_dists/deepy_gobot_base/docker-compose.override.yml up --build
```

#### **Dream (via proxy)**

The easiest way to try out Dream is to deploy it via proxy.
All the requests will be redirected to DeepPavlov API, so you don't have to use any local resources.
See [proxy usage](#proxy-usage) for details.

```
docker-compose -f docker-compose.yml -f assistant_dists/dream/docker-compose.override.yml -f assistant_dists/dream/dev.yml -f assistant_dists/dream/proxy.yml up --build
```

#### **Dream (locally)**

**Please note, that DeepPavlov Dream components require a lot of resources.**
Refer to the [components](#components) section to see estimated requirements.

```
docker-compose -f docker-compose.yml -f assistant_dists/dream/docker-compose.override.yml -f assistant_dists/dream/dev.yml up --build
```

We've also included a config with GPU allocations for multi-GPU environments:
```
AGENT_PORT=4242 docker-compose -f docker-compose.yml -f assistant_dists/dream/docker-compose.override.yml -f assistant_dists/dream/dev.yml -f assistant_dists/dream/test.yml up
```

When you need to restart particular docker container without re-building (make sure mapping in `assistant_dists/dream/dev.yml` is correct):

```
AGENT_PORT=4242 docker-compose -f docker-compose.yml -f assistant_dists/dream/docker-compose.override.yml -f assistant_dists/dream/dev.yml restart container-name
```

#### **Prompted Dream**

```
docker-compose -f docker-compose.yml -f assistant_dists/dream_persona_prompted/docker-compose.override.yml -f assistant_dists/dream_persona_prompted/dev.yml -f assistant_dists/dream_persona_prompted/proxy.yml up --build
```

We've also included a config with GPU allocations for multi-GPU environments.

### Let's chat

DeepPavlov Agent provides several options for interaction: a command line interface, an HTTP API, and a Telegram bot

#### CLI

In a separate terminal tab run:

```
docker-compose exec agent python -m deeppavlov_agent.run agent.channel=cmd agent.pipeline_config=assistant_dists/dream/pipeline_conf.json
```

Enter your username and have a chat with Dream!

#### HTTP API

Once you've started the bot, DeepPavlov's Agent API will run on `http://localhost:4242`.
You can learn about the API from the [DeepPavlov Agent Docs](https://deeppavlov-agent.readthedocs.io/en/latest/intro/overview.html#http-api-server).

A basic chat interface will be available at `http://localhost:4242/chat`.

#### Telegram Bot
Currently, Telegram bot is deployed **instead** of HTTP API.
Edit `agent` `command` definition inside `docker-compose.override.yml` config:
```
agent:
  command: sh -c 'bin/wait && python -m deeppavlov_agent.run agent.channel=telegram agent.telegram_token=<TELEGRAM_BOT_TOKEN> agent.pipeline_config=assistant_dists/dream/pipeline_conf.json'
```
**NOTE:** treat your Telegram token as a secret and do not commit it to public repositories!

# Configuration and proxy usage

Dream uses several docker-compose configuration files:

`./docker-compose.yml` is the core config which includes containers for DeepPavlov Agent and mongo database;

`./assistant_dists/*/docker-compose.override.yml` lists all components for the distribution;

`./assistant_dists/dream/dev.yml` includes volume bindings for easier Dream debugging;

`./assistant_dists/dream/proxy.yml` is a list of proxied containers.

If your deployment resources are limited, you can replace containers with their proxied copies hosted by DeepPavlov.
To do this, override those container definitions inside `proxy.yml`, e.g.:

```
convers-evaluator-annotator:
  command: ["nginx", "-g", "daemon off;"]
  build:
    context: dp/proxy/
    dockerfile: Dockerfile
  environment:
    - PROXY_PASS=proxy.deeppavlov.ai:8004
    - SERVICE_PORT=8004
```

and include this config in your deployment command:

```
docker-compose -f docker-compose.yml -f assistant_dists/dream/docker-compose.override.yml -f assistant_dists/dream/dev.yml -f assistant_dists/dream/proxy.yml up --build
```

By default, `proxy.yml` contains all available proxy definitions.

# Components English Version

Dream Architecture is presented in the following image:
![DREAM](DREAM.png)

| Name                | Requirements | Description                                                                                |
|---------------------|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Rule Based Selector |              | Algorithm that selects list of skills to generate candidate responses to the current context based on topics, entities, emotions, toxicity, dialogue acts and dialogue history |
| Response Selector   | 50 MB RAM    | Algorithm that selects a final responses among the given list of candidate responses                                                                                |

## Annotators

| Name                                | Requirements           | Description                                                                                |
|-------------------------------------|------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| ASR                                 | 40 MB RAM              | calculates overall ASR confidence for a given utterance and grades it as either _very low_, _low_, _medium_, or _high_ (for Amazon markup)                                                                                |
| Badlisted Words                     | 150 MB RAM             | detects words and phrases from the badlist                                                                                |
| Combined Classification             | 1.5 GB RAM, 3.5 GB GPU | BERT-based model including topic classification, dialog acts classification, sentiment, toxicity, emotion, factoid classification                                                                                |
| Combined Classification lightweight | 1.6 GB RAM             | The same model as Combined Classification, but takes 42% less time thanks to the lighter backbone                                                                                |
| COMeT Atomic                        | 2 GB RAM, 1.1 GB GPU   | Commonsense prediction models COMeT Atomic                                                                                |
| COMeT ConceptNet                    | 2 GB RAM, 1.1 GB GPU   | Commonsense prediction models COMeT  ConceptNet                                                                                |
| Convers Evaluator Annotator         | 1 GB RAM, 4.5 GB GPU   | is trained on the Alexa Prize data from the previous competitions and predicts whether the candidate response is interesting, comprehensible, on-topic, engaging, or erroneous                                                 |
| Emotion Classification              | 2.5 GB RAM             | emotion classification annotator                                                                                |
| Entity Detection                    | 1.5 GB RAM, 3.2 GB GPU | extracts entities and their types from utterances                                                                                |
| Entity Linking                      | 2.5 GB RAM, 1.3 GB GPU | finds Wikidata entity ids for the entities detected with Entity Detection                                                                                |
| Entity Storer                       | 220 MB RAM             | a rule-based component, which stores entities from the user's and socialbot's utterances if opinion expression is detected with patterns or MIDAS Classifier and saves them along with the detected attitude to dialogue state |
| Fact Random                         | 50 MB RAM              | returns random facts for the given entity (for entities from user utterance)                                                                                |
| Fact Retrieval                      | 7.4 GB RAM, 1.2 GB GPU | extracts facts from Wikipedia and wikiHow                                                                                |
| Intent Catcher                      | 1.7 GB RAM, 2.4 GB GPU | classifies user utterances into a number of predefined intents which are trained on a set of phrases and regexps                                                                                |
| KBQA                                | 2 GB RAM, 1.4 GB GPU   | answers user's factoid questions based on Wikidata KB                                                                                |
| MIDAS Classification                | 1.1 GB RAM, 4.5 GB GPU | BERT-based model trained on a semantic classes subset of MIDAS dataset                                                                                |
| MIDAS Predictor                     | 30 MB RAM              | BERT-based model trained on a semantic classes subset of MIDAS dataset                                                                                |
| NER                                 | 2.2 GB RAM, 5 GB GPU   | extracts person names, names of locations, organizations from uncased text                                                                                |
| News API Annotator                  | 80 MB RAM              | extracts the latest news about entities or topics using the GNews API. DeepPavlov Dream deployments utilize our own API key.                                                                                |
| Personality Catcher                 | 30 MB RAM              | the skill is to change the system's personality description via chatting interface, it works as a system command, the response is system-like message                                                                          |
| Prompt Selector                     | 50 MB RAM              | Annotator utilizing Sentence Ranker to rank prompts and selecting `N_SENTENCES_TO_RETURN` most relevant prompts (based on questions provided in prompts)                                                                       |
| Property Extraction                 | 6.3 GiB RAM            | extracts user attributes from utterances                                                                                |
| Rake Keywords                       | 40 MB RAM              | extracts keywords from utterances with the help of RAKE algorithm                                                                                |
| Relative Persona Extractor          | 50 MB RAM              | Annotator utilizing Sentence Ranker to rank persona sentences and selecting `N_SENTENCES_TO_RETURN` the most relevant sentences                                                                                |
| Sentrewrite                         | 200 MB RAM             | rewrites user's utterances by replacing pronouns with specific names that provide more useful information to downstream components                                                                                |
| Sentseg                             | 1 GB RAM               | allows us to handle long and complex user's utterances by splitting them into sentences and recovering punctuation                                                                                |
| Spacy Nounphrases                   | 180 MB RAM             | extracts nounphrases using Spacy and filters out generic ones                                                                                |
| Speech Function Classifier          | 1.1 GB RAM, 4.5 GB GPU | a hierarchical algorithm based on several linear models and a rule-based approach for the prediction of speech functions described by Eggins and Slade                                                                         |
| Speech Function Predictor           | 1.1 GB RAM, 4.5 GB GPU | yields probabilities of speech functions that can follow a speech function predicted by Speech Function Classifier                                                                                |
| Spelling Preprocessing              | 50 MB RAM              | pattern-based component to rewrite different colloquial expressions to a more formal style of conversation                                                                                |
| Topic Recommendation                | 40 MB RAM              | offers a topic for further conversation using the information about the discussed topics and user's preferences. Current version is based on Reddit personalities (see Dream Report for Alexa Prize 4).                        |
| Toxic Classification                | 3.5 GB RAM, 3 GB GPU   | Toxic classification model from Transformers specified as PRETRAINED_MODEL_NAME_OR_PATH                                                                                |
| User Persona Extractor              | 40 MB RAM              | determines which age category the user belongs to based on some key words                                                                                |
| Wiki Parser                         | 100 MB RAM             | extracts Wikidata triplets for the entities detected with Entity Linking                                                                                |
| Wiki Facts                          | 1.7 GB RAM             | model that extracts related facts from Wikipedia and WikiHow pages                                                                                |

## Services
| Name                   | Requirements            | Description                                                                                |
|------------------------|-------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| DialoGPT               | 1.2 GB RAM, 2.1 GB GPU  | generative service based on Transformers generative model, the model is set in docker compose argument `PRETRAINED_MODEL_NAME_OR_PATH` (for example, `microsoft/DialoGPT-small` with 0.2-0.5 sec on GPU)                                              |
| DialoGPT Persona-based | 1.2 GB RAM, 2.1 GB GPU  | generative service based on Transformers generative model, the model was pre-trained on the PersonaChat dataset to generate a response conditioned on a several sentences of the socialbot's persona                                                  |
| Image Captioning       | 4 GB RAM, 5.4 GB GPU    | creates text representation of a received image                                                                                |
| Infilling              | 1  GB RAM, 1.2 GB GPU   | (turned off but the code is available) generative service based on Infilling model, for the given utterance returns utterance where `_` from original text is replaced with generated tokens                                                          |
| Knowledge Grounding    | 2 GB RAM, 2.1 GB GPU    | generative service based on BlenderBot architecture providing a response to the context taking into account an additional text paragraph                                                                                |
| Masked LM              | 1.1 GB RAM, 1 GB GPU    | (turned off but the code is available)                                                                                |
| Seq2seq Persona-based  | 1.5 GB RAM, 1.5 GB GPU  | generative service based on Transformers seq2seq model, the model was pre-trained on the PersonaChat dataset to generate a response conditioned on a several sentences of the socialbot's persona                                                     |
| Sentence Ranker        | 1.2 GB RAM, 2.1 GB GPU  | ranking model given as `PRETRAINED_MODEL_NAME_OR_PATH` which for a pair os sentences returns a float score of correspondence                                                                                |
| StoryGPT               | 2.6 GB RAM, 2.15 GB GPU | generative service based on fine-tuned GPT-2, for the given set of keywords returns a short story using the keywords                                                                                |
| GPT-3.5                | 100 MB RAM              | generative service based on OpenAI API service, the model is set in docker compose argument `PRETRAINED_MODEL_NAME_OR_PATH` (in particular, in this service, `text-davinci-003` is used.                                                              |
| ChatGPT                | 100 MB RAM              | generative service based on OpenAI API service, the model is set in docker compose argument `PRETRAINED_MODEL_NAME_OR_PATH` (in particular, in this service, `gpt-3.5-turbo` is used.                                                                 |
| Prompt StoryGPT        | 3 GB RAM, 4 GB GPU      | generative service based on fine-tuned GPT-2, for the given topic represented by one noun returns short story on a given topic                                                                                |
| GPT-J 6B               | 1.5 GB RAM, 24.2 GB GPU | generative service based on Transformers generative model, the model is set in docker compose argument `PRETRAINED_MODEL_NAME_OR_PATH` (in particular, in this service, [GPT-J model](https://huggingface.co/EleutherAI/gpt-j-6B) is used.            |
| BLOOMZ 7B              | 2.5 GB RAM, 29 GB GPU   | generative service based on Transformers generative model, the model is set in docker compose argument `PRETRAINED_MODEL_NAME_OR_PATH` (in particular, in this service, [BLOOMZ-7b1 model](https://huggingface.co/bigscience/bloomz-7b1) is used.     |
| GPT-JT 6B              | 2.5 GB RAM, 25.1 GB GPU | generative service based on Transformers generative model, the model is set in docker compose argument `PRETRAINED_MODEL_NAME_OR_PATH` (in particular, in this service, [GPT-JT model](https://huggingface.co/togethercomputer/GPT-JT-6B-v1) is used. |

## Skills
| Name                               | Requirements              | Description                                                                                |
|------------------------------------|---------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Alexa Handler                      | 30 MB RAM                 | handler for several specific Alexa commands                                                                                |
| Christmas Skill                    | 30 MB RAM                 | supports FAQ, facts, and scripts for Christmas                                                                                |
| Comet Dialog skill                 | 300 MB RAM                | uses COMeT ConceptNet model to express an opinion, to ask a question or give a comment about user's actions mentioned in the dialogue                                                                                |
| Convert Reddit                     | 1.2 GB RAM                | uses a ConveRT encoder to build efficient representations for sentences                                                                                |
| Dummy Skill                        | a part of agent container | a fallback skill with multiple non-toxic candidate responses                                                                                |
| Dummy Skill Dialog                 | 600 MB RAM                | returns the next turn from the Topical Chat dataset if the response of the user to the Dummy Skill is similar to the corresponding response in the source data                                                                                |
| Eliza                              | 30 MB RAM                 | Chatbot (https://github.com/wadetb/eliza)                                                                                |
| Emotion Skill                      | 40 MB RAM                 | returns template responses to emotions detected by Emotion Classification from Combined Classification annotator                                                                                |
| Factoid QA                         | 170 MB RAM                | answers factoid questions                                                                                |
| Game Cooperative Skill             | 100 MB RAM                | provides user with a conversation about computer games: the charts of the best games for the past year, past month, and last week                                                                                |
| Harvesters Maintenance Skill       | 30 MB RAM                 | Harvesters maintenance skill                                                                                |
| Harvesters Maintenance Gobot Skill | 30 MB RAM                 | Harvesters maintenance Goal-oriented skill                                                                                |
| Knowledge Grounding Skill          | 100 MB RAM                | generates a response based on the dialogue history and provided knowledge related to the current conversation topic                                                                                |
| Meta Script Skill                  | 150 MB RAM                | provides a multi-turn dialogue around human activities. The skill uses COMeT Atomic model to generate commonsensical descriptions and questions on several aspects                                                                                |
| Misheard ASR                       | 40 MB RAM                 | uses the ASR Processor annotations to give feedback to the user when ASR confidence is too low                                                                                |
| News API Skill                     | 60 MB RAM                 | presents the top-rated latest news about entities or topics using the GNews API                                                                                |
| Oscar Skill                        | 30 MB RAM                 | supports FAQ, facts, and scripts for Oscar                                                                                |
| Personal Info Skill                | 40 MB RAM                 | queries and stores user's name, birthplace, and location                                                                                |
| DFF Program Y Skill                | 800 MB RAM                | **[New DFF version]** Chatbot Program Y (https://github.com/keiffster/program-y) adapted for Dream socialbot                                                                                |
| DFF Program Y Dangerous Skill      | 100 MB RAM                | **[New DFF version]** Chatbot Program Y (https://github.com/keiffster/program-y) adapted for Dream socialbot, containing responses to dangerous situations in a dialog                                                                                |
| DFF Program Y Wide Skill           | 110 MB RAM                | **[New DFF version]** Chatbot Program Y (https://github.com/keiffster/program-y) adapted for Dream socialbot, which includes only very general templates (with lower confidence)                                                                              |
| Small Talk Skill                   | 35 MB RAM                 | asks questions using the hand-written scripts for 25 topics, including but not limited to love, sports, work, pets, etc.                                                                                |
| SuperBowl Skill                    | 30 MB RAM                 | supports FAQ, facts, and scripts for SuperBowl                                                                                |
| Text QA                            | 1.8 GB RAM, 2.8 GB GPU    | The service finds the answer of a factoid question in text.                                                                                |
| Valentine's Day Skill              | 30 MB RAM                 | supports FAQ, facts, and scripts for Valentine's Day                                                                                |
| Wikidata Dial Skill                | 100 MB RAM                | generates an utterance using Wikidata triplets. Not turned on, needs improvement                                                                                |
| DFF Animals Skill                  | 200 MB RAM                | is created using DFF and has three branches of conversation about animals: user's pets, pets of the socialbot, and wild animals                                                                                |
| DFF Art Skill                      | 100 MB RAM                | DFF-based skill to discuss art                                                                                |
| DFF Book Skill                     | 400 MB RAM                | **[New DFF version]** detects book titles and authors mentioned in the user's utterance with the help of Wiki parser and Entity linking and recommends books by leveraging information from the GoodReads database                                            |
| DFF Bot Persona Skill              | 150 MB RAM                | aims to discuss user favorites and 20 most popular things with short stories expressing the socialbot's opinion towards them                                                                                |
| DFF Coronavirus Skill              | 110 MB RAM                | **[New DFF version]** retrieves data about the number of coronavirus cases and deaths in different locations sourced from the John Hopkins University Center for System Science and Engineering                                                               |
| DFF Food Skill                     | 150 MB RAM                | constructed with DFF to encourage food-related conversation                                                                                |
| DFF Friendship Skill               | 100 MB RAM                | **[New DFF version]** DFF-based skill to greet the user in the beginning of the dialog, and forward the user to some scripted skill                                                                                |
| DFF Funfact Skill                  | 100 MB RAM                | **[New DFF version]** Tells user fun facts                                                                                |
| DFF Gaming Skill                   | 80 MB RAM                 | provides a video games discussion. Gaming Skill is for more general talk about video games                                                                                |
| DFF Gossip Skill                   | 95 MB RAM                 | DFF-based skill to discuss other people with news about them                                                                                |
| DFF Image Skill                    | 100 MB RAM                | **[New DFF version]** Scripted skill that based on the sent image captioning (from annotations) responses with specified responses in case of food, animals or people detected, and default responses otherwise                                               |
| DFF Template Skill                 | 50 MB RAM                 | **[New DFF version]** DFF-based skill that provides an example of DFF usage                                                                                |
| DFF Template Prompted Skill        | 50 MB RAM                 | **[New DFF version]** DFF-based skill that provides answers generated by language model based on specified prompts and the dialog context. The model to be used is specified in GENERATIVE_SERVICE_URL. For example, you may use Transformer LM GPTJ service. |
| DFF Grounding Skill                | 90 MB RAM                 | **[New DFF version]** DFF-based skill to answer what is the topic of the conversation, to generate acknowledgement, to generate universal responses on some dialog acts by MIDAS                                                                              |
| DFF Intent Responder               | 100 MB RAM                | **[New DFF version]**  provides template-based replies for some of the intents detected by Intent Catcher annotator                                                                                |
| DFF Movie Skill                    | 1.1 GB RAM                | is implemented using DFF and takes care of the conversations related to movies                                                                                |
| DFF Music Skill                    | 70 MB RAM                 | DFF-based skill to discuss music                                                                                |
| DFF Science Skill                  | 90 MB RAM                 | DFF-based skill to discuss science                                                                                |
| DFF Short Story Skill              | 90 MB RAM                 | **[New DFF version]** tells user short stories from 3 categories: (1) bedtime stories, such as fables and moral stories, (2) horror stories, and (3) funny ones                                                                                |
| DFF Sport Skill                    | 70 MB RAM                 | DFF-based skill to discuss sports                                                                                |
| DFF Travel Skill                   | 70 MB RAM                 | DFF-based skill to discuss travel                                                                                |
| DFF Weather Skill                  | 1.4 GB RAM                | **[New DFF version]** uses the OpenWeatherMap service to get the forecast for the user's location                                                                                |
| DFF Wiki Skill                     | 150 MB RAM                | used for making scenarios with the extraction of entities, slot filling, facts insertion, and acknowledgements                                                                                |

## Prompted Skills
| Name                       | Requirements              | Description                                                                                |
|----------------------------|---------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| AI FAQ Skill               | 150 MB RAM                | **[New DFF version]** Everything you wanted to know about modern AI but was afraid to ask! This FAQ Assistant chats with you while explaining the simplest topics from today's technology world.             |
| Fashion Stylist Skill      | 150 MB RAM                | **[New DFF version]** Stay protected in every season with da Costa Industries Clothes Assistant! Experience the ultimate comfort and protection, no matter the weather. Stay warm in winter a...             |
| Dream Persona Skill        | 150 MB RAM                | **[New DFF version]** Prompt-based skill that utilizes given generative service to generate responses based on the given prompt                                                                              |
| Marketing Skill            | 150 MB RAM                | **[New DFF version]** Connect with your audience like never before with Marketing AI Assistant! Reach new heights of success by tapping into the power of empathy. Say goodbye..                             |
| Fairytale Skill            | 150 MB RAM                | **[New DFF version]** This assistant will tell you or your children a short but engaging fairytale. Choose the characters and the topic and leave the rest to AI imagination.                                |
| Nutrition Skill            | 150 MB RAM                | **[New DFF version]** Discover the secret to healthy eating with our AI assistant! Find nutritious food options for you and your loved ones with ease. Say goodbye to mealtime stress and hello to delici... |
| Life Coaching Skill        | 150 MB RAM                | **[New DFF version]** Unlock your full potential with Rhodes & Co's patented AI assistant! Reach peak performance at work and at home. Get into top form effortlessly and inspire others with.               |

# Papers

### Alexa Prize 3

[Kuratov Y. et al. DREAM technical report for the Alexa Prize 2019 //Alexa Prize Proceedings. – 2020.](https://m.media-amazon.com/images/G/01/mobile-apps/dex/alexa/alexaprize/assets/challenge3/proceedings/Moscow-DREAM.pdf)

### Alexa Prize 4

[Baymurzina D. et al. DREAM Technical Report for the Alexa Prize 4 //Alexa Prize Proceedings. – 2021.](https://d7qzviu3xw2xc.cloudfront.net/alexa/alexaprize/docs/sgc4/MIPT-DREAM.pdf)

# License

DeepPavlov Dream is licensed under Apache 2.0.

Program-y (see `dream/skills/dff_program_y_skill`, `dream/skills/dff_program_y_wide_skill`, `dream/skills/dff_program_y_dangerous_skill`)
is licensed under Apache 2.0.
Eliza (see `dream/skills/eliza`) is licensed under MIT License.

## Report creating

For making certification `xlsx` - file with bot responses, you can use `xlsx_responder.py` script by executing

```shell
docker-compose -f docker-compose.yml -f dev.yml exec -T -u $(id -u) agent python3 \
        utils/xlsx_responder.py --url http://0.0.0.0:4242 \
        --input 'tests/dream/test_questions.xlsx' \
        --output 'tests/dream/output/test_questions_output.xlsx'\
      --cache tests/dream/output/test_questions_output_$(date --iso-8601=seconds).json
```

Make sure all services are deployed. `--input` - `xlsx` file with certification questions, `--output` - `xlsx` file with bot responses, `--cache` - `json`, that contains a detailed markup and is used for a cache.


# eMach
An open source framework for electric machine optimization and evaluation. A detailed
documentation of this code base attributes and capabilities is available
[here](https://emach.readthedocs.io/en/latest/index.html). A broad overview of the repository
is provided below.

## Optimization Workflow

The `eMach` optimization workflow has been developed to make electric machine design
and optimization flexible, modular, and easily extensible. A flowchart showing a
broad view of the workflow is provided below. More information of each block illustrated
in this workflow is available [here](https://emach.readthedocs.io/en/latest/index.html).

   Structure of Optimization

At the Severson research group, we are particularly interested in the design and optimization
of bearingless electric machines. An expanded view of the `Machine Evaluator` for
the optimization of these machines is shown below. The evaluator will be modified for
each optimization based on

   Optimization Flow Chart


# 💭 **Why these awesome projects ??**
💠 _This repository offers a variety of fascinating mini-projects written in Python._

💠 _Working on Python projects will undoubtedly improve your skills and raise your profile in preparation for the globalised marketplace outside._

💠 _Projects are a potential method to begin your career in this area._

💠 _This language deserves a lot of attention in today's world, and why not since it can address so many real-world problems?_

 📈 Tweet this repository

## 📁 All Projects are under [projects](https://github.com/Mrinank-Bhowmick/python-beginner-projects/tree/main/projects) folder.

 🖥 Projects So Far ...

            Audiobook

            Desktop-Notification

            Dice-Roll-Simulator

            Madlibs-Generator

            Make-API

            Medium Article Reader

            Quiz Game

            Rock-Paper-Scissors

            Send-Email

            Tesla

            MorseCode Translator

            Weather

            ProjectEuler

            AudioRecorder

            Hangman

            VoiceToText

            TextTranslate

            Own_browser

            HandCricket

            English Thesaurus

            BMI_calculator

            Higher-Lower

            IPv4_Calculator

            KbdXylo

            NASA-APOD

            Neurons

            Qt5_YouTube

            Tic-Tac-Toe

            TurtlePattern

            Duplicate-search

            Snake-Water-Gun

            AES256

            API Based Weather Report

            Audio Converter

            BFS visualizer

            BMI WebApp

            Bigram_Autocomplete

            Bitcoin Mining

            BlackJack

            Calculator

            Calendar

            Captcha_Genrator

            Card Game

            Connect Four

            Countdown

            Dice Simulator

            DnD Dice

            Drowsiness Detector

            Eye Blink Detection

            Fidget Spinner Game

            Find_imbd_rating

            Flappybird_game

            Full_Calendar

            Guess Number

            HandCricket

            HandTrack

            Hangman

            Higher-Lower

            Image compressor

            Image-to-art

            Internet-speed-test

            Inverse Matrix Calculator

            JARVIS.PY

            Jokenpo

            Jokey

            Language-Translate

            Location Search App (GUI)

            Madlibs Generator

            Mastermind

            Minecraft-in-Python-main

            Mobile Document Scanner

            Mongo CRUD

            Movie recommendation

            Number Guessing App

            OTP-Verfication-System

            OpenCV_color_detect_in_live_feed

            Movie recommendation

            Otp_Generator

            PDF_Reader

            PONG

            Password Projects

            Port_Scaner

            Print_Colored_Text

            ProjectEuler

            Python story generator

            QRCode Scanner

            QRCode-Generator

            QuickWordCloud

            RestrauntAPI

            Roll_A_dice

            Scientific-Calculator

            ScreenRecorder

            Seek_with_hand_track

            Slice-Audio

            Snake Game

            Space Shooter

            Split_Tip

            Stock-Market-Dashboard

            Space Shooter

            Subtitle_synchronizer.py

            Sudoku-Solver

            Sudoku_solver

            Subtitle_synchronizer.py

            Text Editor

            Text to Speech

            TextDetection

            Timer

            Tkinter

            Turtle Pattern

            Turtle_Graphics

            Twitter-Bot

            Watermarker

            Web Scraping Jujustu Kaisen Manga

            Website Blocker

            YouTube Video Downloader

            caesar_cipher

            currency converter

            facebook_video_downloader

            facerecoginition

            game-snake_water_gun

            healthmanagementsystem

            maths

            minesweeper

            pdf_to_text

            ping_pong

            proxy-scrapper

            reciept generator

            scheduledShutdown

            scrap-ycombinator

            takeImage

            web-crawler(movie extract)

            what-for-dinner

            Calculate Age

## Run these projects online :

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/Mrinank-Bhowmick/python-beginner-projects.git)

## Stargazers over time

[![Stargazers over time](https://starchart.cc/Mrinank-Bhowmick/python-beginner-projects.svg)](https://starchart.cc/Mrinank-Bhowmick/python-beginner-projects)

 Contributors

            Mrinank Bhowmick

            Lint Action

            Ibra-kdbra

            Yashvardhan Singh

            Cedric Anover

            Kanchan Rai

            Vikrant Singh Bhadouriya

            Chloe

            Rik Chatterjee

            Yanliutafewa

            Fafa Modey

            Omkar Patel

            Tark-pea

            Shashank Shekhar

            Gabriela20103967

            Justin Johnson

            Tyler-Pear

            Sudip Ghosh

            Masum Reza

            Anish Vantagodi

            Bim22614

            Ng-lis

            Jefferson Bublitz

            Shriyans Naik

            Payallenka

            Yash Upadhyay

            Vagarth Pandey

            Nayan Chandak

            Oluwatomilola

            Peter White

            Kartik Nandagaon

            SirRomey

            Zackery .R. Smith

            Sneha Farkya

            Syed Shagufta Noval

            Bibaswan Roy

            Monit Sharma

            Suhas Kowligi

            Odhy

            Subramanya K S

            Guiszk

            Asingh4451

            Zack Didcott

            Yash Parwal

            Harry830

            Mr.B

            Mrinank Bhowmick

            Sameer Choudhary

            Xia

            Vishal S Murali

            Albert

            Ayan Joshi

            Sowham Bhuin

            VRUSHANG PARIKH

            Vidit Khazanchi

            Cryptoracing

            Ibukun Alesinloye

            Mmakrin

            Parth Verma

            Ayush Lakra

            Ratnadeep Bhowmik

            Srujan-landeri

            Ayush Singh

            ChefYeshpal

            Chirag Aggarwal

            Rahul Kumar

            Kom Senapati

            Subha Sadhu

            U749929

            Adrija

            Advik Sharma

            Ahaan

            Alexander Monterrosa

            Anand Munjuluri

            Anmol Shah

            Soonam Kalyan Panda

            Logadheep

            Saurabh Mahapatra

            Santhosh S

            SHIVA NC

            Rajdeep Das

            Preeray

            Nikita0509

            N11rm44L 7w44711

            Matt Blodgett

            Monish-Kumar-D

            Rishav Raj

            Robert Lent

            Saanvibk

            Samuel Peters

            Sayakb03

            Rudy3

            Shreeram

            Kkchx

            Syeda Nowshin Ibnat

            Siddharth

            Toheed

            Utkarsh Raj

            KhwajaYousuf

            Dapo Adedire

            Dimonalik

            Hritik Bhattacharya

            Maglionaire

            Rathish R

            Rakin Shahriar Plaban

            Smw-1211

            Limyangtyin

            Ishan Joshi

            Sarthak Singhal

            Yest3a

            Anukiran Ghosh

            Ashani Sansala Kodithuwakku

            Akrati Verma

            Amogha Kancharla

            Akarsh Bajpai

            Ankit_Anmol

            CJ Praveen

            Chloe23077

            Destiny

            Devendra Parihar

            Dikshant Jha

            GigabyteZ

            Flourish

            Govind S Nair

            Harsh Mahadev Duche

            Hriday Agrawal

            Jaydeep

            Khushhal Garg

            Konran

            MINHAJ

            Manav Sanghvi

            Haseeb / 하시브

            QubitMatrix

            Raj Saha

            Mr._CG_04

            Meep_

            Rust Master

            Ambush

            Allisonfintz

            Ahmedalhamad7

            Yogeshwar Kumar

            Ylavish64

            Yash Tariyal

            Amitesh Kumar

            Prajwal Benedict A

            Emmanuel  Ogu

            D-coder111

            Nishant Pacharne

            Vivek Kumar Gupta

            Vishvam S

            Vikash

            Uday Srivastava

            Swapnadeep Mohapatra

            Sumit Baroniya

            Suliman Sagindykov

            Sudhanshu Tripathi

            Shubham Kumar

            Shreejan Dolai

            Shivam Rai

            Sergey18273

            Sdthinlay

            Jenil Gajjar

            Leon Heinrich

            Tanawat Jirawttanakul

            Shreya Rathore

            Shayaanyar

            Samual Martin

            Saipranavrguduru

            PRATYUSHA CHATURVEDI

            Prathamesh Phalke

            Prabin Shrestha

            Abhishek Ghimire

            Parthiban Marimuthu

            Ocryptocode

            ThanasisNovatsidis

            Anish Neupane

            Muchamad Yuda Tri Ananda

            Tharindu De Silva

            Zainab Ibraheem

            Marcell

            Mangnez

            Kodingkin

            Kish

            Jonas Carvalho

            Dhruv Jagdish

            Faiz Aslam

            Darsh Baxi

            Harshit Sharma

            Himanshu Singh  Negi

            HarsH

            Gargi

            Eman

            Ebrahim G

            Dishant Nagpal

            Dhruvil-Lakhtaria

            Dhandeep

            David Ioffe

            Crack-er-jack

            Carl283583

            Bhanushri Chinta

            Ayushi Rastogi

            AtharvaDeshmukh0909

            Sudharsan Vanamali

            Arijit

            Arif Shariar Rahman

            Anju Chhetri

            Anisha Nayaju

            Amer Sbahi

            Aleena

            Aditya Sahai

            Aditya Kumar

            Abhinandan Singla

            Abhay-Gupta008

            ARYAN GULATI

            Samayita Kali

            Sai Uttej R

            Surya Narayan

            RishiPastor05

            Ved Sadh

            Ramii Ahmed

            Raashika0201

            Faris Faikar

            Praveen SV

            Pratham-H-S

            Pranav Dasan

            Prajwol Shrestha

            Kushal Pareek

            Nilay Banerjee

            Nischay Goyal

            Nikhil Kumar Jha

            Nesh

            Mohammed El Amine Benkorreche

            Mohamed Khaled Yousef

            Manisha Kundnani

            MANISH KUMAR CHINTHA

            Aman Sharma

            Kunal Pitale

            Krishna13515

            Jyothika Dileepkumar

            Josephtobi

            Jishnudeep Borah


<img class="hide-on-website" height="100px" src="https://ts.gluon.ai/dev/_static/gluonts.svg">

# GluonTS - Probabilistic Time Series Modeling in Python

[![PyPI](https://img.shields.io/pypi/v/gluonts.svg?style=flat-square&color=b75347)](https://pypi.org/project/gluonts/)
[![GitHub](https://img.shields.io/github/license/awslabs/gluonts.svg?style=flat-square&color=df7e66)](./LICENSE)
[![Static](https://img.shields.io/static/v1?label=docs&message=stable&color=edc775&style=flat-square)](https://ts.gluon.ai/)
[![Static](https://img.shields.io/static/v1?label=docs&message=dev&color=edc775&style=flat-square)](https://ts.gluon.ai/dev/)
[![PyPI Downloads](https://img.shields.io/pypi/dm/gluonts?style=flat-square&color=94b594)](https://pepy.tech/project/gluonts)

**📢 BREAKING NEWS**: We released **Chronos**, a suite of pretrained models for zero-shot time series forecasting. Chronos can generate accurate probabilistic predictions for new time series not seen during training. Check it out [here](https://github.com/amazon-science/chronos-forecasting)!

GluonTS is a Python package for probabilistic time series modeling, focusing on deep learning based models,
based on [PyTorch](https://pytorch.org) and [MXNet](https://mxnet.apache.org).

## Installation

GluonTS requires Python 3.7 or newer, and the easiest way to install it is via
`pip`:

```bash
# install with support for torch models
pip install "gluonts[torch]"

# install with support for mxnet models
pip install "gluonts[mxnet]"
```

See the [documentation](https://ts.gluon.ai/stable/getting_started/install.html)
for more info on how GluonTS can be installed.

## Simple Example

To illustrate how to use GluonTS, we train a DeepAR-model and make predictions
using the airpassengers dataset. The dataset consists of a single time
series of monthly passenger numbers between 1949 and 1960. We train the model
on the first nine years and make predictions for the remaining three years.

```py
import pandas as pd
import matplotlib.pyplot as plt

from gluonts.dataset.pandas import PandasDataset
from gluonts.dataset.split import split
from gluonts.torch import DeepAREstimator

# Load data from a CSV file into a PandasDataset
df = pd.read_csv(
    "https://raw.githubusercontent.com/AileenNielsen/"
    "TimeSeriesAnalysisWithPython/master/data/AirPassengers.csv",
    index_col=0,
    parse_dates=True,
)
dataset = PandasDataset(df, target="#Passengers")

# Split the data for training and testing
training_data, test_gen = split(dataset, offset=-36)
test_data = test_gen.generate_instances(prediction_length=12, windows=3)

# Train the model and make predictions
model = DeepAREstimator(
    prediction_length=12, freq="M", trainer_kwargs={"max_epochs": 5}
).train(training_data)

forecasts = list(model.predict(test_data.input))

# Plot predictions
plt.plot(df["1954":], color="black")
for forecast in forecasts:
  forecast.plot()
plt.legend(["True values"], loc="upper left", fontsize="xx-large")
plt.show()
```

![[train-test]](https://ts.gluon.ai/static/README/forecasts.png)

Note, the forecasts are displayed in terms of a probability distribution and
the shaded areas represent the 50% and 90% prediction intervals.

## Contributing

If you wish to contribute to the project, please refer to our
[contribution guidelines](https://github.com/awslabs/gluonts/tree/dev/CONTRIBUTING.md).

## Citing

If you use GluonTS in a scientific publication, we encourage you to add the following references to the related papers,
in addition to any model-specific references that are relevant for your work:

```bibtex
@article{gluonts_jmlr,
  author  = {Alexander Alexandrov and Konstantinos Benidis and Michael Bohlke-Schneider
    and Valentin Flunkert and Jan Gasthaus and Tim Januschowski and Danielle C. Maddix
    and Syama Rangapuram and David Salinas and Jasper Schulz and Lorenzo Stella and
    Ali Caner Türkmen and Yuyang Wang},
  title   = {{GluonTS: Probabilistic and Neural Time Series Modeling in Python}},
  journal = {Journal of Machine Learning Research},
  year    = {2020},
  volume  = {21},
  number  = {116},
  pages   = {1-6},
  url     = {http://jmlr.org/papers/v21/19-820.html}
}
```

```bibtex
@article{gluonts_arxiv,
  author  = {Alexandrov, A. and Benidis, K. and Bohlke-Schneider, M. and
    Flunkert, V. and Gasthaus, J. and Januschowski, T. and Maddix, D. C.
    and Rangapuram, S. and Salinas, D. and Schulz, J. and Stella, L. and
    Türkmen, A. C. and Wang, Y.},
  title   = {{GluonTS: Probabilistic Time Series Modeling in Python}},
  journal = {arXiv preprint arXiv:1906.05264},
  year    = {2019}
}
```

## Links

### Documentation

* [Documentation (stable)](https://ts.gluon.ai/stable/)
* [Documentation (development)](https://ts.gluon.ai/dev/)

### References

* [JMLR MLOSS Paper](http://www.jmlr.org/papers/v21/19-820.html)
* [ArXiv Paper](https://arxiv.org/abs/1906.05264)
* [Collected Papers from the group behind GluonTS](https://github.com/awslabs/gluonts/tree/dev/REFERENCES.md): a bibliography.

### Tutorials and Workshops

* [Tutorial at IJCAI 2021 (with videos)](https://lovvge.github.io/Forecasting-Tutorial-IJCAI-2021/) with [YouTube link](https://youtu.be/AB3I9pdT46c).
* [Tutorial at WWW 2020 (with videos)](https://lovvge.github.io/Forecasting-Tutorial-WWW-2020/)
* [Tutorial at SIGMOD 2019](https://lovvge.github.io/Forecasting-Tutorials/SIGMOD-2019/)
* [Tutorial at KDD 2019](https://lovvge.github.io/Forecasting-Tutorial-KDD-2019/)
* [Tutorial at VLDB 2018](https://lovvge.github.io/Forecasting-Tutorial-VLDB-2018/)
* [Neural Time Series with GluonTS](https://youtu.be/beEJMIt9xJ8)
* [International Symposium of Forecasting: Deep Learning for Forecasting workshop](https://lostella.github.io/ISF-2020-Deep-Learning-Workshop/)


# EMMOntoPy

*Library for representing and working with ontologies in Python.*

![CI tests](https://github.com/emmo-repo/EMMOntoPy/workflows/CI%20Tests/badge.svg)
[![PyPI version](https://badge.fury.io/py/EMMOntoPy.svg)](https://badge.fury.io/py/EMMOntoPy)
[![DOI](https://zenodo.org/badge/190286064.svg)](https://zenodo.org/badge/latestdoi/190286064)

EMMOntoPy is a Python package based on the excellent [Owlready2], which provides a natural and intuitive representation of ontologies in Python.
EMMOntoPy extends Owlready2 and adds additional functionality, like accessing entities by label, reasoning with FaCT++ and parsing logical expressions in Manchester syntax.
It also includes a set of tools, like creating an ontology from an Excel sheet, generation of reference documentation of ontologies and visualisation of ontologies graphically.
EMMOntoPy is freely available for on GitHub and on PyPI under the permissive open source [BSD 3-Clause license](LICENSE.txt).

EMMOntoPy was originally developed to work effectively with the Elemental Multiperspective Material Ontology ([EMMO]) and EMMO-based domain ontologies.
It has now two sub-packages, `ontopy` and `emmopy`, where `ontopy` is a general package to work with any OWL ontology, while `emmopy` provides extra features that are specific to [EMMO].

Owlready2, and thereby also EMMOntoPy, represents OWL classes and individuals in Python as classes and instances.
OWL properties are represented as Python attributes.
Hence, it provides a new *dot* notation for representing ontologies as valid Python code.
The notation is simple and easy to understand and write for people with some knowledge of OWL and Python.
Since Python is a versatile programming language, Owlready2 does not only allow for representation of OWL ontologies, but also to work with them programmatically, including interpretation, modification and generation.
Some of the additional features provided by EMMOntoPy are are listed below:

## Access by label
In Owlready2 ontological entities, like classes, properties and individuals are accessed by the name-part of their IRI (i.e. everything that follows after the final slash or hash in the IRI).
This is very inconvenient for ontologies like EMMO or Wikidata, that identify ontological entities by long numerical names.
For instance, the name-part of the IRI of the Atom class in EMMO is ‘EMMO_eb77076b_a104_42ac_a065_798b2d2809ad’, which is neither human readable nor easy to write.
EMMOntoPy allows to access the entity via its label (or rather skos:prefLabel) ‘Atom’, which is much more user friendly.

## Turtle serialisation/deserialisation
The Terse RDF Triple Language (Turtle) is a common syntax and file format for representing ontologies.
EMMOntoPy adds support for reading and writing ontologies in turtle format.

## FaCT++ reasoning
Owlready2 has only support for reasoning with HermiT and Pellet.
EMMOntoPy adds additional support for the fast tableaux-based [FaCT++ reasoner] for description logics.

## Manchester syntax
Even though the Owlready2 dot notation is clear and easy to read and understand for people who know Python, it is a new syntax that may look foreign for people that are used to working with Protégé.
EMMOntoPy provides support to parse and serialise logical expressions in [Manchester syntax], making it possible to create tools that will be much more familiar to work with for people used to working with Protégé.

## Visualisation
EMMOntoPy provides a Python module for graphical visualisation of ontologies.
This module allows to graphically represent not only the taxonomy, but also restrictions and logical constructs.
The classes to include in the graph, can either be specified manually or inferred from the taxonomy (like all subclasses of a give class that are not a subclass of any class in a set of other classes).

## Tools
EMMOntoPy includes a small set of command-line tools implemented as Python scripts:
  - [`ontoconvert`](docs/tools-instructions.md#ontoconvert):
    Converts ontologies between different file formats.
    It also supports some additional transformation during conversion, like running a reasoner, merging several ontological modules together (squashing), rename IRIs, generate catalogue file and automatic annotation of entities with their source IRI.
  - [`ontograph`](docs/tools-instructions.md#ontograph):
    Vertasile tool for visualising (parts of) an ontology, utilising the visualisation features mention above.
  - [`ontodoc`](docs/tools-instructions.md#ontodoc):
    Documents an ontology.
  - [`excel2onto`](docs/tools-instructions.md#excel2onto):
    Generate an EMMO-based ontology from an excel file.
    It is useful for domain experts with limited knowledge of ontologies and that are not used to tools like Protégé.
  - [`ontoversion`](docs/tools-instructions.md#ontoversion):
    Prints ontology version number.
  - [`emmocheck`](docs/tools-instructions.md#emmocheck):
    A small test framework for checking the consistency of EMMO and EMMO-based domain ontologies and whether they confirm to the EMMO conventions.

## Some examples of what you can do with EMMOntoPy includes:

- Access and query RDF-based ontologies from your application.
  This includes several different flavors of RDF (OWL, **Turtle (`ttl`)**, and more).
- Access and query EMMO-based ontologies from your application.
- Extend EMMO with new domain or application ontologies.
  This can be done both statically with easy readable Python code or dynamically within your application.
- Generate graphs and documentation of your ontologies.
  EMMOntoPy includes `ontodoc`: A dedicated command line tool for this.
  You find it in the [tools/](tools) sub directory.
- Check that an EMMO-based domain or application ontology adhere to the conventions of EMMO.
- Interactively explore an ontology in any Python interpreter, e.g., [IPython].
  Tab-completion makes exploration easy and fast.
  Below is an example of an IPython session where we check the relations of `Matter` in EMMO utilizing the `emmopy.get_emmo` function:

  ```ipython
  In [1]: from emmopy import get_emmo

  In [2]: emmo = get_emmo()

  In [3]: emmo.Matter
  Out[3]: physicalistic.Matter

  In [4]: emmo.Matter.is_a
  Out[4]:
  [physicalistic.Physicalistic,
    physical.Physical,
    mereotopology.hasPart.some(physicalistic.Massive),
    physical.hasTemporalPart.only(physicalistic.Matter)]
  ```

## Documentation and examples

The [Owlready2 documentation][Owlready2-doc] is a good starting point.
The EMMOntoPy package also has its own [dedicated documentation](https://emmo-repo.github.io/EMMOntoPy).

This includes a few examples and demos:

- [demo/vertical](demo/vertical/README.md) shows an example of how EMMO may be used to achieve vertical interoperability.
  The file [define-ontology.py](demo/vertical/define_ontology.py) provides a good example for how an EMMO-based application ontology can be defined in Python.

- [demo/horizontal](demo/horizontal/README.md) shows an example of how EMMO may be used to achieve horizontal interoperability.
  This demo also shows how you can use EMMOntoPy to represent your ontology with the low-level metadata framework [DLite].
  In addition to achieve interoperability, as shown in the demo, DLite also allow you to automatically generate C or Fortran code base on your ontology.

- [examples/emmodoc](examples/emmodoc/README.md) shows how the documentation of EMMO is generated using the `ontodoc` tool.

## Installation

Install with:

```console
pip install EMMOntoPy
```

### Required Dependencies

- [Python] 3.7 or later.
- [Owlready2] v0.23 or later.

### Optional Dependencies

- [Graphviz][graphviz_website]: Needed for graph generation.
  With support for generation pdf, png and svg figures for tests and generation of documentation automatically (`ontodoc`).
- [pandoc]: Only used for generated documentation from markdown to nicely formatted html or pdf.
  Tested with v2.1.2.
- [pdfLaTeX] or [XeLaTeX] and the `upgreek` LaTeX package (included in `texlive-was` on RetHat-based distributions and `texlive-latex-extra` on Ubuntu) for generation of pdf documentation.
  If your ontology contains exotic unicode characters, we recommend XeLaTeX.

- Java.
  Needed for reasoning.

- Optional Python packages:
  - [graphviz][graphviz_python]: Generation of documentation and graphs.
  - [PyYAML]: Required for generating documentation with pandoc.
  - [blessings]: Clean output for `emmocheck`.
  - [Pygments]: Coloured output for `emmocheck`.
  - [rdflib]: Required for `ontoversion`-tool.
  - [semver]: Required for `ontoversion`-tool.
  - [pydot]: Used for generating graphs.
    Will be deprecated.
  - [pyparsing](https://github.com/pyparsing/pyparsing): Used for parsing Manchester syntax

See [docs/docker-instructions.md](docs/docker-instructions.md) for how to build a docker image.

### Known issues

- **Invalid serialising to turtle:** Due to rdflib issue [#1043](https://github.com/RDFLib/rdflib/issues/1043) `ontoconvert` may produce invalid turtle output (if your ontology contains real literals using scientific notation without a dot in the mantissa).
  This issue was fixed after the release of rdflib 5.0.0.
  Hence, install the latest rdflib from PyPI (`pip install --upgrade rdflib`) or directly from the source code repository: [GitHub](https://github.com/RDFLib/rdflib) if you need to serialise to turtle.

### Attributions and credits

EMMOntoPy is maintained by [EMMC-ASBL](https://emmc.eu/).
It has mainly been developed by [SINTEF](https://www.sintef.no/), specifically:

- Jesper Friis ([jesper-friis](https://github.com/jesper-friis))
- Francesca L. Bleken ([francescalb](https://github.com/francescalb))
- Casper W. Andersen ([CasperWA](https://github.com/CasperWA))
- Bjørn Tore Løvfall ([lovfall](https://github.com/lovfall))

### Contributing projects

- EMMC-CSA;
  Grant Agreement No: 723867

  The [EMMC-ASBL organization](https://emmc.eu/emmc-members/mission/) takes on the efforts of continuing and expanding on the efforts of the CSA.
- [MarketPlace](https://www.the-marketplace-project.eu/);
  Grant Agreement No: 760173

- [OntoTrans](https://ontotrans.eu/project/);
  Grant Agreement No: 862136

- [BIG-MAP](https://www.big-map.eu/);
  Grant Agreement No: 957189

- [OpenModel](https://www.open-model.eu/);
  Grant Agreement No: 953167

[EMMOntoPy]: https://github.com/emmo-repo/EMMOntoPy/
[Owlready2]: https://pypi.org/project/Owlready2/
[Owlready2-doc]: https://owlready2.readthedocs.io/
[EMMO]: https://emmo-repo.github.io
[PyPI:EMMOntoPy]: https://pypi.org/project/EMMOntoPy/
[Python]: https://www.python.org/
[IPython]: https://ipython.org/
[DLite]: https://github.com/SINTEF/dlite/
[pydot]: https://pypi.org/project/pydot/
[graphviz_website]: https://www.graphviz.org/
[pandoc]: http://pandoc.org/
[XeLaTeX]: https://www.overleaf.com/learn/latex/XeLaTeX/
[pdfLaTeX]: https://www.latex-project.org/
[graphviz_python]: https://pypi.org/project/graphviz
[PyYAML]: https://pypi.org/project/PyYAML/
[blessings]: https://pypi.org/project/blessings/
[Pygments]: https://pypi.org/project/Pygments/
[semver]: https://pypi.org/project/semver/
[rdflib]: https://pypi.org/project/rdflib/
[FaCT++]: http://owl.cs.manchester.ac.uk/tools/fact/
[Manchester syntax]: https://www.w3.org/TR/owl2-manchester-syntax/


[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/controlplaneio/simulator/blob/master/LICENSE)
[![Platforms](https://img.shields.io/badge/Platform-Linux|MacOS-blue.svg)](https://github.com/controlplaneio/simulator/blob/master/README.md)
[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-blue.svg)](https://conventionalcommits.org)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/controlplaneio/simulator/graphs/commit-activity)

# Simulator

_🔊 Join [the hosted Simulator waitlist](https://kubesim.io) for private scenarios and training content 🚨_

A distributed systems and infrastructure simulator for attacking and debugging Kubernetes: simulator
creates a Kubernetes cluster for you in your AWS account; runs scenarios which misconfigure it and/or leave it
vulnerable to compromise and trains you in mitigating against these vulnerabilities.

## Prerequisites

- [Docker](https://docs.docker.com/get-docker/)
- [AWS Account](https://aws.amazon.com/free)

## Download

Please download the latest release from the [releases page](https://github.com/controlplaneio/simulator/releases)

## AWS Credentials

Simulator supports the following methods of authentication to provision the AWS infrastructure. Refer to
[AWS IAM Permissions](docs/aws-iam-permissions.md) for details of the required permissions.

- [Environment Variables](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html)
- [Shared Credentials file](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)

## Getting Started

- Read the [Player Guide](docs/player-guide.md) to learn how to launch environments, deploy, and play scenarios
- Refer to the [Walkthough Guides](docs/2023-cncf-ctf-walkthroughs) for advice

## Core Components

- [Simulator CLI](docs/cli.md)
- [Simulator Container Images](docs/container-images.md)
- [Simulator AMIs](docs/amis.md)
- [Simulator Infrastructure](docs/infrastructure.md)
- [Simulator Scenarios](docs/scenarios.md)

## More Info

For details on why we created this project, take a look at the [vision statement](./docs/vision-statement.md) and [V2 redesign](/docs/vision-statement-v2.md).

---

Built with ❤ by [https://control-plane.io/](https://control-plane.io/)


![NeuroM Logo](https://raw.githubusercontent.com/BlueBrain/NeuroM/master/doc/source/logo/NeuroM.jpg)

# NeuroM

NeuroM is a Python toolkit for the analysis and processing of neuron morphologies.

[![Run all tox python3](https://github.com/BlueBrain/NeuroM/actions/workflows/run-tox.yml/badge.svg)](https://github.com/BlueBrain/NeuroM/actions/workflows/run-tox.yml)
[![license](https://img.shields.io/pypi/l/neurom.svg)](https://github.com/BlueBrain/NeuroM/blob/master/LICENSE.txt)
[![codecov.io](https://codecov.io/github/BlueBrain/NeuroM/coverage.svg?branch=master)](https://codecov.io/github/BlueBrain/NeuroM?branch=master)
[![Documentation Status](https://readthedocs.org/projects/neurom/badge/?version=latest)](http://neurom.readthedocs.io/en/latest/?badge=latest)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.597333.svg)](https://doi.org/10.5281/zenodo.597333)

## Documentation

NeuroM documentation is built and hosted on [readthedocs](https://readthedocs.org/).

* [latest snapshot](http://neurom.readthedocs.org/en/latest/)
* [latest release](http://neurom.readthedocs.org/en/stable/)

## Migration to v2 or v3 versions

Refer to [the doc page](https://neurom.readthedocs.io/en/latest/migration.html) on this topic.

## Reporting issues

Issues should be reported to the
[NeuroM github repository issue tracker](https://github.com/BlueBrain/NeuroM/issues).
The ability and speed with which issues can be resolved depends on how complete and
succinct the report is. For this reason, it is recommended that reports be accompanied
with
* A minimal but self-contained code sample that reproduces the issue. Minimal means no
  code that is irrelevant to the issue should be included. Self-contained means it should
  be possible to run the code without modifications and reproduce the problem.
* The observed and expected output and/or behaviour. If the issue is an error, the python
  error stack trace is extremely useful.
* The commit ID of the version used. This is particularly important if reporting an error
  from an older version of NeuroM.
* If reporting a regression, the commit ID of the change that introduced the problem
* If the issue depends on data, a data sample which reproduces the problem should be
  up-loaded. But check first whether the error can be reproduced with any of the data
  samples available in the `tests/data` directory.

## Citation

When you use the NeuroM software, we ask you to cite the following (**this includes poster presentations**):
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.597333.svg)](https://doi.org/10.5281/zenodo.597333)

## Funding & Acknowledgements
This work has been partially funded by the European Union’s Horizon 2020 Framework Programme for Research and Innovation under the Specific Grant Agreement No. 720270, 785907 (Human Brain Project SGA1/SGA2) and by the EBRAINS research infrastructure, funded from the European Union’s Horizon 2020 Framework Programme for Research and Innovation under the Specific Grant Agreement No. 945539 (Human Brain Project SGA3).

The development of this software was supported by funding to the Blue Brain Project, a research center of the École polytechnique fédérale de Lausanne (EPFL), from the Swiss government’s ETH Board of the Swiss Federal Institutes of Technology.

For license and authors, see `LICENSE.txt` and `AUTHORS.md` respectively.

Copyright (c) 2015-2022 Blue Brain Project/EPFL


# Datasets server

> Integrate into your apps over 10,000 datasets via simple HTTP requests, with pre-processed responses and scalability built-in.

Documentation: https://huggingface.co/docs/datasets-server

## Ask for a new feature 🎁

The datasets server pre-processes the [Hugging Face Hub datasets](https://huggingface.co/datasets) to make them ready to use in your apps using the API: list of the splits, first rows.

We plan to [add more features](https://github.com/huggingface/datasets-server/issues?q=is%3Aissue+is%3Aopen+label%3A%22feature+request%22) to the server. Please comment there and upvote your favorite requests.

If you think about a new feature, please [open a new issue](https://github.com/huggingface/datasets-server/issues/new).

## Contribute 🤝

You can help by giving ideas, answering questions, reporting bugs, proposing enhancements, improving the documentation, and fixing bugs. See [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.

To install the server and start contributing to the code, see [DEVELOPER_GUIDE.md](./DEVELOPER_GUIDE.md)

## Community 🤗

You can star and watch this [GitHub repository](https://github.com/huggingface/datasets-server) to follow the updates.

You can ask for help or answer questions on the [Forum](https://discuss.huggingface.co/c/datasets/10) and [Discord](https://discord.com/channels/879548962464493619/1019883044724822016).

You can also report bugs and propose enhancements on the code, or the documentation, in the [GitHub issues](https://github.com/huggingface/datasets-server/issues).


<img src="https://media.githubusercontent.com/media/lumicks/pylake/main/docs/logo_light.png" alt="logo" width="489px"/>

[![DOI](https://zenodo.org/badge/133832492.svg)](https://zenodo.org/badge/latestdoi/133832492)
[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](license.md)
[![Build Status](https://github.com/lumicks/pylake/workflows/pytest/badge.svg?branch=main)](https://github.com/lumicks/pylake/actions/workflows/pylake_test.yml?query=branch%3Amain)
[![Documentation Status](https://readthedocs.org/projects/lumicks-pylake/badge/?version=latest)](https://lumicks-pylake.readthedocs.io/)

Pylake is a Python package for analyzing single-molecule optical tweezer data.

Its main features include:

- **Analyzing HDF5 and TIFF data obtained with Bluelake**: Pylake provides a convenient interface to read, analyze and plot data obtained with Bluelake.
- **Correlating data**: Provides functionality to correlate optical tweezer and imaging data.
- **Fitting force-extension curves**: Pylake provides tools to (globally) fit polymer models to force-extension data.
- **Force calibration routines**: The package contains algorithms to calibrate optical tweezer data using power spectral density estimation.
- **Kymotracker**: Tracks single molecules in a kymograph and computes binding rates and diffusion constants.

Please see the [documentation](https://lumicks-pylake.readthedocs.io/) for more information.

## Citing

Pylake is free to use under the conditions of the [Apache-2.0 open source license](license.md).

If you wish to publish results produced with this package, please mention the package name and cite the Zenodo DOI for this project:

[![DOI](https://zenodo.org/badge/133832492.svg)](https://zenodo.org/badge/latestdoi/133832492)

You'll find a *"Cite as"* section at the bottom right of the Zenodo page. You can select a citation
style from the dropdown menu or export the data in BibTeX and similar formats.


=====================
ScyllaDB Sphinx Theme
=====================

.. image:: https://github.com/scylladb/sphinx-scylladb-theme/actions/workflows/docs-pages.yaml/badge.svg
   :target: https://github.com/scylladb/sphinx-scylladb-theme/actions/workflows/docs-pages.yaml

The documentation toolchain for ScyllaDB projects.

.. image:: https://github.com/scylladb/sphinx-scylladb-theme/blob/master/docs/source/deployment/images/preview.png

Features
--------

**Shared Design**

All ScyllaDB documentation sites share a common look and feel.

**Multiversion Support**

Build docs for different versions of your project.

**GitHub Pages Support**

Automatically publish documentation to GitHub Pages.

For more information about the stack, see `Toolchain <https://sphinx-theme.scylladb.com/stable/getting-started/toolchain.html>`_.

Installation
------------

To add the toolchain to a ScyllaDB project, see the `Getting Started <https://sphinx-theme.scylladb.com/stable/getting-started/index.html>`_ section of our docs.

Usage
-----

For more documentation, see `sphinx-theme.scylladb.com <https://sphinx-theme.scylladb.com>`_.

License
-------

Copyright (c) 2020-present ScyllaDB Licensed under the `Apache License 2.0 <LICENSE>`_.


# Sciebo RDS
[![pipeline status](https://zivgitlab.uni-muenster.de/sciebo-rds/sciebo-rds/badges/develop/pipeline.svg)](https://zivgitlab.uni-muenster.de/sciebo-rds/sciebo-rds/-/pipelines)
![MIT License](https://img.shields.io/github/license/Sciebo-RDS/Sciebo-RDS)
[![Version](https://img.shields.io/github/v/release/Sciebo-RDS/Sciebo-RDS)](https://github.com/Sciebo-RDS/Sciebo-RDS/releases/latest)
![Release](https://img.shields.io/github/release-date/Sciebo-RDS/Sciebo-RDS)
[![gitter](https://img.shields.io/gitter/room/Sciebo-RDS/community?color=orange)](https://gitter.im/Sciebo-RDS/community)

Sciebo RDS (**Sciebo** **R**esearch **D**ata **S**ervices) allows researchers to enrich their research data with metadata and to export it directly from Enterprise Sync and Share (EFSS) Systems like Owncloud to Data Repositories like Zenodo and OSF.
It acts as a interoperability layer, allowing them to assign a directory on a Sync and Share System to a research project, annotating the contained data to match the format required by the desired Data Repository and publishing the Research Data directly from the Cloud.

No need to download all the data to a desktop computer to cumbersomely upload it to the repository interface again.

Find more information on the official website at [www.research-data-services.org](https://www.research-data-services.org/).

## Screenshots
|||
|-|-|
| Configuring a project| Adding metadata|
| Adding metadata| Adding metadata|
| Publishing| Connecting repositories|

## Deployment

#### Requirements

To deploy Sciebo RDS you will need:

1. A Kubernetes cluster
2. An OwnCloud instance
3. Two different domains

#### Getting Started

Please refer to our [Getting Started](https://www.research-data-services.org/gettingstarted/) Guide to learn how to deploy Sciebo RDS.

#### Development environment

To deploy a local environment on top of [Minikube](https://minikube.sigs.k8s.io/docs/), including RDS and NextCloud and / or OwnCloud,
please refer to [this guide](/getting-started/minikube-embedded/README.md).

## Monorepo Structure

We use a monorepo to make it easier to track related changes. This means that you will find all relevant files in this Github repository.

The following table will give an impression of the individual parts.

| Folder                                                       | Description                                     |
| ------------------------------------------------ | ----------------------------------------------- |
| /charts                                          | Helm charts                                     |
| /docs                                            | Website with documentation                      |
| /getting-started                                 | Files for easy deployment                       |
| /RDS                                             | The RDS code                                    |
| /RDS/layer0_ingress/web/server                   | The Python Backend                              |
| /RDS/layer0_ingress/web/client/packages/codebase | The Vue.js Frontend                             |
| /RDS/layer3_central_services                     | Microservices `ResearchManager`, `TokenStorage` |
| /                                                | Metafiles and configuration                     |

The monorepo only includes those parts of Sciebo RDS that are officially maintained by the University of Münster.

### Additional Repositories
There is also an [additional repository](https://github.com/Sciebo-RDS/RDS-Connectors) that functions as a community hub for development of 3rd party connectors, such as Dataverse. These connectors are community managed – if you are planning on developing a connector and sharing it as Open Source, feel free to use this repository.
A third repository is used for the ongoing development of the [Nextcloud Plugin](https://github.com/Sciebo-RDS/plugin-nextcloud).

## Contributing and Documentation

Contributions are always welcome! You can find technical documentation and guides on how to extend Sciebo RDS to your needs and connect additional repositories on our [website](https://www.research-data-services.org/documentation/development/).

We follow the [Gitlab-flow](https://docs.gitlab.com/ee/topics/gitlab_flow.html). Our default branch is called `develop` and can be changed exclusively through pull requests via Github.
When a certain amount of features are done, they are merged into `release`. From there we will set a tag and publish the changes in helm and docker repositories.

Please adhere to our `code of conduct`.

## Feedback and Support

Please use the Github Issues and Github Discussions for feedback and technical questions. We also have a [Gitter chat](https://gitter.im/Sciebo-RDS/community). :)

If you are using Sciebo RDS as a researcher and need user level support, please refer to the administrators of your Sciebo RDS instance. You can find their email adresse in the `Help` tab of your Sciebo RDS instance.
## Acknowledgements

Sciebo RDS relies on [describo-online](https://github.com/Arkisto-Platform/describo-online) for metadata management.
## Authors

Sciebo RDS is a project developed by the [University of Münster](https://uni-muenster.de/) and funded by the [DFG](https://www.dfg.de/en/index.jsp).

You can reach the development team at `sciebo.rds <at> uni-muenster.de` or on [Gitter](https://gitter.im/Sciebo-RDS/community).


#  OVOS - Buildroot OS
A minimalistic Linux OS bringing the open source voice assistant [ovos-core](https://github.com/OpenVoiceOS/ovos-core) to embedded, low-spec headless and/or small (touch)screen devices.

## System.
### OpenVoiceOS - Full 64 Bit distribution
- Linux kernel 6.1.x (LTS)
- Buildroot 2023.02.x (LTS) (With some modification here and there)
- OVOS framework / software package utilizing ovos-docker containers (Currently latest alpha/development version)
- Raspberry Pi 3|3b|3b+ (UEFI based)
- Raspberry Pi 4 (UEFI based)
- x86_64 Intel based computers (UEFI based) (Work In Progress)
- Open Virtual Appliance (UEFI based)

## Stats:

| [![Build Status](https://travis-ci.org/OpenVoiceOS/OpenVoiceOS.svg?branch=master)](https://travis-ci.org/OpenVoiceOS/OpenVoiceOS) | [![GitHub last commit](https://img.shields.io/github/last-commit/google/skia.svg)](https://github.com/OpenVoiceOS/OpenVoiceOS/commits/develop) |
|:---:|:---:|
| This shows if the code is valid and can be build. | This shows when this repo was updated for the last time |
| [![GitHub stars](https://img.shields.io/github/stars/OpenVoiceOS/OpenVoiceOS.svg)](https://github.com/OpenVoiceOS/OpenVoiceOS/stargazers) | [![GitHub issues](https://img.shields.io/github/issues/OpenVoiceOS/OpenVoiceOS.svg)](https://github.com/OpenVoiceOS/OpenVoiceOS/issues) |
| Please :star: this repo if you find it useful | Issues are like my personal TODO list and information archive |
|[![License: Apache License 2.0](https://img.shields.io/crates/l/rustc-serialize.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)| [![contributions welcome](https://img.shields.io/badge/contributions-welcome-blue.svg?style=flat)](https://github.com/OpenVoiceOS/OpenVoiceOS/pulls) |
| I'm using the Apache License 2.0 similar as Mycroft A.I. which means commercial use is allowed | If you have any ideas, they're always welcome.  Either submit an issue or a PR! |
| [![Uptime Robot status](https://img.shields.io/website-up-down-green-red/https/shields.io.svg?label=j1nx.nl)](https://stats.uptimerobot.com/Y5L6rSB07) | [![Buy me a](https://img.shields.io/badge/BuyMeABeer-Paypal-blue.svg)](https://www.paypal.me/j1nxnl) |
| I use uptime robot to monitor for things i can't monitor when the connection drops. | If you feel the need, now it's as easy as clicking this button! |

## Documentation.
More information and instructions can be found within the "documentation" folder.

## Credits
Mycroft AI (@MycroftAI)

Buildroot (@buildroot)

HassOS (@home-assistant)

### Inspired by;
HassOS (@home-assistant)

SkiffOS (@skiffos)


PyLabRobot

[**Docs**](https://docs.pylabrobot.org) | [**Forum**](https://forums.pylabrobot.org) | [**Installation**](https://docs.pylabrobot.org/installation.html) | [**Getting started**](https://docs.pylabrobot.org/basic.html)

## What is PyLabRobot?

PyLabRobot is a hardware agnostic, pure Python library for liquid handling robots, plate readers, pumps, scales, heater shakers, and other lab automation equipment. Read [the paper](<https://www.cell.com/device/fulltext/S2666-9986(23)00170-9>) in Device.

Advantages over proprietary software:

- **Cross-platform**: PyLabRobot works on Windows, macOS, and Linux. Many other interfaces are Windows-only.
- **Universal**: PyLabRobot works with any supported liquid handling robot, plate reader, pump, scale, heater shaker, etc. through a single interface.
- **Fast iteration**: PyLabRobot enables rapid development of protocols using atomic commands run interactively in Jupyter notebooks or the Python REPL. This decreases iteration time from minutes to seconds.
- **Open-source**: PyLabRobot is open-source and free to use.
- **Control**: With Python, you have ultimate flexibility to control your lab automation equipment. You can write Turing-complete protocols that include feedback loops.
- **Modern**: PyLabRobot is built on modern Python 3.8+ features and async/await syntax.
- **Fast support**: PyLabRobot has [an active community forum](https://labautomation.io/c/pylabrobot-user-discussion/26) for support and discussion, and most pull requests are merged within a day.

### Liquid handling robots ([docs](https://docs.pylabrobot.org/basic.html))

PyLabRobot enables the use of any liquid handling robot through a single universal interface, that works on any modern operating system (Windows, macOS, Linux). We currently support Hamilton STAR, Hamilton Vantage, Tecan Freedom EVO, and Opentrons OT-2 robots, but we will soon support many more.

Here's a quick example showing how to move 100uL of liquid from well A1 to A2 using firmware on **Hamilton STAR** (this will work on any operating system!):

```python
from pylabrobot.liquid_handling import LiquidHandler
from pylabrobot.liquid_handling.backends import STAR
from pylabrobot.resources import Deck

deck = Deck.load_from_json_file("hamilton-layout.json")
lh = LiquidHandler(backend=STAR(), deck=deck)
await lh.setup()

await lh.pick_up_tips(lh.deck.get_resource("tip_rack")["A1"])
await lh.aspirate(lh.deck.get_resource("plate")["A1"], vols=100)
await lh.dispense(lh.deck.get_resource("plate")["A2"], vols=100)
await lh.return_tips()
```

To run the same protocol on an **Opentrons**, use the following:

```python
from pylabrobot.liquid_handling.backends import OpentronsBackend
deck = Deck.load_from_json_file("opentrons-layout.json")
lh = LiquidHandler(backend=OpentronsBackend(host="x.x.x.x"), deck=deck)
```

Or **Tecan** (also works on any operating system!):

```python
from pylabrobot.liquid_handling.backends import EVO
deck = Deck.load_from_json_file("tecan-layout.json")
lh = LiquidHandler(backend=EVO(), deck=deck)
```

We also provide a browser-based Visualizer which can visualize the state of the deck during a run, and can be used to develop and test protocols without a physical robot.

![Visualizer](.github/img/visualizer.png)

### Plate readers ([docs](https://docs.pylabrobot.org/plate_reading.html))

PyLabRobot also provides a layer of general-purpose abstractions for plate readers, currently with just a driver for the ClarioStar. This driver works on Windows, macOS and Linux. Here's a quick example showing how to read a plate using the ClarioStar:

```python
from pylabrobot.plate_reading import PlateReader, ClarioStar

pr = PlateReader(name="plate reader", backend=ClarioStar(), size_x=1, size_y=1, size_z=1)
await pr.setup()

# Use in combination with a liquid handler
lh.assign_child_resource(pr, location=Coordinate(x, y, z))
lh.move_plate(lh.deck.get_resource("plate"), pr)

data = await pr.read_luminescence()
```

### Pumps ([docs](https://docs.pylabrobot.org/pumps.html))

Pumping at 100 rpm for 30 seconds using a Masterflex pump:

```python
from pylabrobot.pumps import Pump
from pylabrobot.pumps.cole_parmer.masterflex import Masterflex

p = Pump(backend=Masterflex())
await p.setup()
await p.run_for_duration(speed=100, duration=30)
```

### Scales ([docs](https://docs.pylabrobot.org/scales.html))

Taking a measurement from a Mettler Toledo scale:

```python
from pylabrobot.scales import Scale
from pylabrobot.scales.mettler_toledo import MettlerToledoWXS205SDU

backend = MettlerToledoWXS205SDU(port="/dev/cu.usbserial-110")
scale = Scale(backend=backend, size_x=0, size_y=0, size_z=0)
await scale.setup()

weight = await scale.get_weight()
```

### Heater shakers ([docs](https://docs.pylabrobot.org/heater_shakers.html))

Setting the temperature of a heater shaker to 37°C:

```python
from pylabrobot.heating_shaking import HeaterShaker
from pylabrobot.heating_shaking import InhecoThermoShake

backend = InhecoThermoShake()
hs = HeaterShaker(backend=backend, name="HeaterShaker", size_x=0, size_y=0, size_z=0)
await hs.setup()
await hs.set_temperature(37)
```

### Fans ([docs](https://docs.pylabrobot.org/fans.html))

Running a fan at 100% intensity for one minute:

```python
from pylabrobot.only_fans import Fan
from pylabrobot.only_fans import HamiltonHepaFan

fan = Fan(backend=HamiltonHepaFan(), name="my fan")
await fan.setup()
await fan.turn_on(intensity=100, duration=60)
```

## Resources

### Documentation

[docs.pylabrobot.org](https://docs.pylabrobot.org)

- [Installation](https://docs.pylabrobot.org/installation.html)
- [Getting Started](https://docs.pylabrobot.org/basic.html)
- [Contributing](CONTRIBUTING.md)
- [API Reference](https://docs.pylabrobot.org/pylabrobot.html)

### Support

- [forums.pylabrobot.org](https://forums.pylabrobot.org) for questions and discussions.
- [GitHub Issues](https://github.com/pylabrobot/pylabrobot/issues) for bug reports and feature requests.

## Citing

If you use PyLabRobot in your research, please cite the following:

```bibtex
@article{WIERENGA2023100111,
  title = {PyLabRobot: An open-source, hardware-agnostic interface for liquid-handling robots and accessories},
  journal = {Device},
  volume = {1},
  number = {4},
  pages = {100111},
  year = {2023},
  issn = {2666-9986},
  doi = {https://doi.org/10.1016/j.device.2023.100111},
  url = {https://www.sciencedirect.com/science/article/pii/S2666998623001709},
  author = {Rick P. Wierenga and Stefan M. Golas and Wilson Ho and Connor W. Coley and Kevin M. Esvelt},
  keywords = {laboratory automation, open source, standardization, liquid-handling robots},
}
```

---

**Disclaimer:** PyLabRobot is not officially endorsed or supported by any robot manufacturer. If you use a firmware driver such as the STAR driver provided here, you do so at your own risk. Usage of a firmware driver such as STAR may invalidate your warranty. Please contact us with any questions.

_Developed for the Sculpting Evolution Group at the MIT Media Lab_


Python Semantic Release
***********************

|Ruff| |Test Status| |PyPI Version| |conda-forge version| |Read the Docs Status| |Pre-Commit Enabled|

Automatic Semantic Versioning for Python projects. This is a Python
implementation of `semantic-release`_ for JS by Stephan Bönnemann. If
you find this topic interesting you should check out his `talk from
JSConf Budapest`_.

The general idea is to be able to detect what the next version of the
project should be based on the commits. This tool will use that to
automate the whole release, upload to an artifact repository and post changelogs to
GitHub. You can run the tool on a CI service, or just run it locally.

Installation
============

::

  python3 -m pip install python-semantic-release
  semantic-release --help

Python Semantic Release is also available from `conda-forge`_ or as a `GitHub Action`_.
Read more about the setup and configuration in our `getting started guide`_.

.. _semantic-release: https://github.com/semantic-release/semantic-release
.. _talk from JSConf Budapest: https://www.youtube.com/watch?v=tc2UgG5L7WM
.. _getting started guide: https://python-semantic-release.readthedocs.io/en/latest/#getting-started
.. _GitHub Action: https://python-semantic-release.readthedocs.io/en/latest/automatic-releases/github-actions.html
.. _conda-forge: https://anaconda.org/conda-forge/python-semantic-release

.. |Test Status| image:: https://img.shields.io/github/actions/workflow/status/python-semantic-release/python-semantic-release/main.yml?branch=master&label=Test%20Status&logo=github
   :target: https://github.com/python-semantic-release/python-semantic-release/actions/workflows/main.yml
   :alt: test-status
.. |PyPI Version| image:: https://img.shields.io/pypi/v/python-semantic-release?label=PyPI&logo=pypi
   :target: https://pypi.org/project/python-semantic-release/
   :alt: pypi
.. |conda-forge Version| image:: https://img.shields.io/conda/vn/conda-forge/python-semantic-release?logo=anaconda
   :target: https://anaconda.org/conda-forge/python-semantic-release
   :alt: conda-forge
.. |Read the Docs Status| image:: https://img.shields.io/readthedocs/python-semantic-release?label=Read%20the%20Docs&logo=Read%20the%20Docs
   :target: https://python-semantic-release.readthedocs.io/en/latest/
   :alt: docs
.. |Pre-Commit Enabled| image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit
   :target: https://github.com/pre-commit/pre-commit
   :alt: pre-commit
.. |Ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff