semvec/pypi-packages huggingface dataset:
helloworld-serhii73 0.0.1
Say hello!

# Hello World

This is an example project demonstrating how to publish a python module to PyPI.

## Installation

Run the following to install:

```python
pip install helloworld-serhii73
```

## Usage

```python
from helloworld import say_hello

# Generate "Hello, World!"
say_hello()

# Generate "Hello, Everybody!"
say_hello("Everybody")
```
django-redactor-2.0 0.3
This reusable Django app using WYSIWYG editor redactorjs.com

# django-wysiwyg-redactor

Updated to work with django 2.0.x

(Version modified of django-redactorjs)

Some changes:

* version of plugin redactorjs 7.6.3 (changes the [license](#license) too)
* new API method `$('#redactor').getSelection()` get the selected content in editor
* new API method `$('#redactor').getSettings()` you can get and set settings anytime you want
* removing some ajax calls, (modal windows), to avoid the crossdomain issue on production env
* with the *extra_script* option/setting you can load some script to do something more after load the redactor
* now the redactor toolbar is more responsive
* fixing some bugs, adapting things...

## Screenshot

<img src="https://raw.github.com/douglasmiranda/django-wysiwyg-redactor/master/static/img/screenshot.png">

What's that
-----------

*django-wysiwyg-redactor is a reusable application for Django, using WYSIWYG editor http://redactorjs.com/*

Dependence
-----------

- `Django >= 1.3` # for static files
- `PIL` # for image upload

Getting started
---------------

* Install django-wysiwyg-redactor:

```
pip install django-wysiwyg-redactor
```

* Add `'redactor'` to INSTALLED_APPS.

* Add `url(r'^redactor/', include('redactor.urls'))`, to urls.py

* Add default config in settings.py (more settings see: <https://github.com/douglasmiranda/django-wysiwyg-redactor/wiki/Settings>):

```python
REDACTOR_OPTIONS = {'lang': 'en'}
REDACTOR_UPLOAD = 'uploads/'
```

Using in model
--------------

```python
from django.db import models
from redactor.fields import RedactorField

class Entry(models.Model):
    title = models.CharField(max_length=250, verbose_name=u'Title')
    short_text = RedactorField(verbose_name=u'Text')
```
or use custom parametrs:
```python
    short_text = RedactorField(
        verbose_name=u'Text',
        redactor_options={'lang': 'en', 'focus': 'true'},
        upload_to='tmp/'
    )
```
Using for only admin interface
-----------------------------
```python
from django import forms
from redactor.widgets import RedactorEditor
from blog.models import Entry

class EntryAdminForm(forms.ModelForm):
    class Meta:
        model = Entry
        widgets = {
           'short_text': RedactorEditor(),
        }

class EntryAdmin(admin.ModelAdmin):
    form = EntryAdminForm
```

`RedactorEditor` takes the same parameters as `RedactorField`

## License 
Starting with version 7.6.3 redactor-js is licensed under [Creative Commons Attribution-NonCommercial 3.0 license](http://creativecommons.org/licenses/by-nc/3.0/)

For commercial use please buy license here: http://redactorjs.com/download/ or use earlier version.
pychatbotlib 1.0.1
Library for creating chatbots

<h1>PyChatbotLib</h1>
<hr/>
<b>Exclusive library for creating chatbots.<br>
It uses a very simple neural network which helps to recognize possible answers to messages.<br>
You just need to train it in chats with 2 types of messages: reply and original.<br>
</b>
<h3>Installation</h3>

```pip install pychatbotlib```
<h3>Example of usage</h3>

```python
import telebot # pip3 install PyTelegramBotAPI==2.2.3
from time import sleep
from chatbot import Chatbot
bot = telebot.TeleBot('APIKEY')
chatbot = Chatbot("chatbot_data")

@bot.message_handler(content_types=["text"])
def handle_message(message):
    try:
        chatbot.add_data(message.text, message.reply_to_message.text)
        answer = chatbot.get_reply(message.text)
        if answer is not None:
            bot.reply_to(message, answer)
    except Exception as e:
        answer = chatbot.get_reply(message.text)
        if answer is not None:
            bot.reply_to(message, answer)
        print("Not a reply")

while True:
    try:
        bot.polling(none_stop=True)
    except Exception as e:
        bot.polling(none_stop=True)

  ```
webhooks-git-automata 0.0.3
Webhook receiver for Git deployments


Webhook receiver for Git deployments
====================================

This project started as a dirty & quick hack to perform some deployment actions 
triggered by a Git webhook.

I looked a little bit at other projects and didn't found any one that suited my 
needs, so I started this project... and then it grew a little bit and become
something more versatile than the quick hack originally intended.

This project is aimed at DevOps or sysadmin that have git repositories, typically
with a VIP-branch, and automatic deployment. You may want to have different branches
for stage and production or set up push permissions differently to the different 
branches. This utility, when a webhook is received, will update the local Git repository
and perform the commands in the settings.

Quickstart
----------

 - Create and activate a Virtual Environment: 
```
virtualenv --python=/usr/bin/python3 /path/to/venv
source /path/to/venv/bin/activate
```
 - Install the package: `pip install webhooks_git_automata`
 - Create a `settings.yaml` 
 - Set up a service (e.g. a systemd _service_ file) that does something along: 
```
/path/to/venv/bin/wh-gitd /path/to/settings.yaml
```

Settings
--------

Extra CLI features
------------------

To force both the pull and the execution of commands without a deployment, you can use 
the built-in `wh-git-trigger` command. Example usage:

    wh-git-trigger /path/to/setings.yaml myrepoentry

This will force the git pull and execute the commands. Future versions of this tool will 
include more fine-grain control --e.g. avoid fetch, dry-run, display status information...

Implementation details
----------------------

This project contains a minimal Flask server that answers the POST webhooks sent 
by a Git server like GitLab, GitHub or Gogs. The server is started through the 
Flask's `app.run` method.

Not a lot of traffic is expected, but you may want to set up a reverse proxy in front
of the Flask server, or add some fancier method like a WSGI or uWSGI or similar layer.

Typical git servers expect the webhook to send a quick reply (in general, HTTP 
connections are intended to be short lived) so there is a worker/tasks approach. There
is a very simple implementation base on `Threading` and a shared `Queue`. More complex
implementations may be added in the future (pull requests welcome).