semvec/pypi-packages huggingface dataset:
mwconv 1.6.2
Wiki text convertions based on MediaWiki
License: MIT

# mwconv 

## Wiki text conversions based on MediaWiki 

This program parses a dialect of MediaWiki syntax and converts it
to various formats (html, plain text and markdown).

This is intended for documentation written using the MediaWiki syntax
instead of the Markdown syntax as is more popularly used these days;
there are no wiki features such as internal links implemented.

Tables and definition lists are supported.

The markdown and text versions of this file are converted using
this utility.

## Options 

Summary

    Options:
     -h, --help show this help message and exit
     -o FILE write to this file (default stdout)
     -t TYPE, --type=TYPE select output type
     -l NUMBER, --first-level=NUMBER

The output TYPE can be one of:
<dl>
<dt> text
<dd>plain text output
<dt> html
<dd>- html output
<dt> md 
<dd>markdown output
<dt> md_safe 
<dd>markdown output with html restricted to a 'safe' subset.
<dt> mw 
<dd>mediawiki output, the output will be a normalized form of the
input. It will also be affected by the _first-level_ option if
given.
</dl>

The first-level option sets the first heading level in
the output. So if it is set to 1, the the first heading will
be **H1** in html regardless of what level it is in the input
and all the other headings adjusted appropriately.

## Compatibility 

The syntax is intended to be almost identical to MediaWiki text.
Lots of people try (or used to try, markdown is commonly used now)
to use MediaWiki for documentation since it is/was
well known.

However if your documentation contains lots of lists and code sections
the syntax is not altogether convenient.

1. A list item has to be all on one line.
2. There can not be any blank lines between list items.
3. A code example can't (easily) be part of a list item.

So typically you use unordered lists and it all kind of looks ok in
the browser, even though the code examples are not really in the list
and break the list up into multiple lists.

This implementation has the following improvements.

1. A list item can be split onto more than one line.
2. If an indented block follows the list item, then it will be
actually inside the list item.
3. There are some alternative notations.
django-chunkator 2.0.0
Chunk large QuerySets into small chunks, and iterate over them without killing your RAM.
License: MIT

================
django-chunkator
================


Chunk large QuerySets into small chunks, and iterate over them without killing
your RAM.

.. image:: https://travis-ci.org/peopledoc/django-chunkator.svg

Tested with all the combinations of:

* Python: 3.5, 3.6, 3.7, 3.8
* Django: 2, 2.1, 2.2, 3.0, master


.. note::

    Django 3.0 is incompatible with Python 3.5, see <https://docs.djangoproject.com/en/3.0/releases/3.0/#python-compatibility>

Usage
=====

.. code:: python

    from chunkator import chunkator
    for item in chunkator(LargeModel.objects.all(), 200):
        do_something(item)

This tool is intended to work on Django querysets.

Your model **must** define a ``pk`` field (this is done by default, but
sometimes it can be overridden) and this pk has to be unique. ``django-
chunkator`` has been tested with PostgreSQL and SQLite, using regular PKs and
UUIDs as primary keys.

You can also use ``values()``:

.. code:: python

    from chunkator import chunkator
    for item in chunkator(LargeModel.objects.values('pk', 'name'), 200):
        do_something(item)

.. important::

    If you're using ``values()`` you **have** to add at least your "pk" field
    to the values, otherwise, the chunkator will throw a
    ``MissingPkFieldException``.

.. warning::

    This will not **accelerate** your process. Instead of having one BIG query,
    you'll have several small queries. This will save your RAM instead, because
    you'll not load a huge queryset result before looping on it.

If you want to manipulate the pages directly, you can use `chunkator_page`:

.. code:: python

    from chunkator import chunkator_page
    queryset = LargeModel.objects.all().values('pk')
    for page in chunkator_page(queryset, 200):
        launch_some_task([item['pk'] for item in page])

License
=======

MIT License.
dockontext 0.1.3
context manager that runs and closes docker containers
License: MIT
Requires Python: >=3.7,<4.0
Keywords: docker

# dockontext
[![pypi](https://img.shields.io/pypi/v/dockontext.svg)](https://pypi.python.org/pypi/dockontext)
[![Build Status](https://travis-ci.com/ghsang/dockontext.svg?branch=master)](https://travis-ci.com/ghsang/dockontext)
[![codecov](https://codecov.io/gh/ghsang/dockontext/branch/master/graph/badge.svg)](https://codecov.io/gh/ghsang/dockontext)


### context manager that runs and closes docker containers
* When integration or end-to-end test needs temporal docker container to fake remote systems, this package will help to create/close/remove the temporal docker container.

### Features
* Create docker container by giving image name. The container will be named as 'docontext={name}'
* Close and remove the container when exit.

### Example

#### pytest.fixture
```
import pytest
from dockontext import container_generator_from_image, Result, Config

create_container = pytest.fixture(container_generator_from_image)

def test_fixture(create_container):
     config = Config(name, "alpine:latest")
     container = create_container(config)
     result = container.execute("echo hello", timeout: float)
     assert result == Result(returncode=0, stdout="hello\n", stderr="")
```


### TODO
* Dockerfile
* docker-compose.yml
* container group context

### Free software: MIT License


### Credits

* This package was created with [Cookiecutter][1]
* Also was copied and modified from the [audreyr/cookiecutter-pypackage][2] project template.

[1]: https://github.com/cookiecutter/cookiecutter
[2]: https://github.com/audreyr/cookiecutter-pypackage
TChatBot 0.1.0
A ChatBot framework to create customizable all purpose Chatbots using NLP, Tensorflow, Speech Recognition
License: MIT
Keywords: A Customizable ChatBot framework with Tensorflow,NLP,Speech Recognition

[![TChatBot](https://img.shields.io/badge/TChatBot-v0.1.0-blue)](https://pypi.org/project/TChatBot/0.1.0/)  [![license](https://img.shields.io/badge/License-MIT-yellow)](https://github.com/deepraj1729/TChatBot/blob/master/LICENSE) [![dependencies](https://img.shields.io/badge/dependencies-packages-orange)](https://github.com/deepraj1729/TChatBot/blob/master/requirements.txt)
[![pull](https://img.shields.io/badge/pull--requests-requests-green)](https://github.com/deepraj1729/TChatBot/pulls) [![issues](https://img.shields.io/badge/issues-issues-red)](https://github.com/deepraj1729/TChatBot/issues) ![python](https://img.shields.io/badge/python-3.5%20%7C%203.6%20%7C%203.7-blue)


# TChatBot
A ChatBot framework to make customizable all purpose Chatbots using NLP, Tensorflow, Speech Recognition 

# Basic Requirements: 
1. RAM > 4GB (For training the model)
2. Storage Space > 200MB
3. GPU RAM >=4 GB (optional)
4. Python >= 3.5

# Installation

(a). Install using `pip` 
(b). Clone the repository (dev testing)

## (a) Install Using `pip`:

# Pre-Requisites:
1. An Empty folder
2. A virtual environment (using normal python or conda python)


## Setting up the Pre-Requisites:
### Step 1: Create an empty folder say `Demo`.

### Step 2: Open the folder and open terminal from that folder location.

### Step 3: Create Virtual Environment
1. Either Using `virtualenv` (strictly for non-conda users, optional for conda users)
2. Or Using conda (for conda users only)

## Choose any one of the above 2 steps based on conda or non-conda users
### 1. Install virtualenv using `pip` (for both non-conda and conda users)

        pip install virtualenv==20.0.14

### (1.a) Run the command to create virtual environment: 

        virtualenv .

### (1.b) Activate virtual environment by running the command:

        .\Scripts\activate

### (1.c) `(Demo)` in the left of terminal indicates that the environment is activated

### 2. Create virtual environment (for conda users only), skip if step 1 is done: 

        conda create -n TChatBot

### (2.a) Activate virtual environment by running the command:

        conda activate TChatBot

### (2.b) `(TChatBot)` in the left of terminal shows that the environment is activated


## Install the latest `TChatBot` package using `pip`:

        pip install TChatBot

### Congrats, You installed all the required dependencies :) 

# Usage:
### (Must run within the virtual environment):

### Chat with TensorChat Bot:

        tchatbot -chat

### Train the Chatbot:

        tchatbot -train

### Create Custom Dataset commandline

        tchatbot -create

### Check Current classes trained

        tchatbot -classes

### Check Model Pipeline Configurations

        tchatbot --config

### Check Version:

        tchatbot -v

### For any help/guidance regarding commands:

        tchatbot -h