semvec/pypi-packages huggingface dataset:
chatter-py 1.0.1
A lightweight Python framework for building chatbots.
License: MIT
Requires Python: >=3
Keywords: chatbot,framework

# Chatter

[![codecov](https://codecov.io/gh/nickjfenton/chatter/branch/develop/graph/badge.svg?token=4HYFV573S8)](https://codecov.io/gh/nickjfenton/chatter)
[![Documentation Status](https://readthedocs.org/projects/chatter-py/badge/?version=latest)](https://chatter-py.readthedocs.io/en/latest/?badge=latest)

## Welcome to Chatter!

Chatter is a framework with the goal of allowing you to quickly and easily create chatbots. It hides
away the things you want to just work, exposing a simple API, so that you can focus on writing your
custom features and delivering a working chatbot.

Take a look:

```python
from chatter_py import ChatClient, Feature, Bot, Message
from typing import Any


# Define your feature
class Echo(Feature):
    def receive(self, message):
        self.send_to_chat(message)


# Write a handler for your chat client, for example:
class MyChatClient(ChatClient):
    def __init__(self):
        self.chat_client_connection = Any

    def on_chat_message(self, message: dict):
        """Receive your chat messages and convert them to bot friendly messages"""
        bot_message = Message(text=message["text"], room=message["room_id"])
        self.send_to_bot(bot_message)

    def start_listening(self) -> None:
        """connect to your chat client"""
        self.chat_client_connection.register_callback(self.on_chat_message)
        self.chat_client_connection.start_listening()

    def send_to_client(self, message):
        """Format your bot messages and send them off to your chat client"""
        text = "<p>" + " ".join(message.text) + "</p>"
        self.chat_client_connection.send(text)


def main():
    # Let Chatter put it all together
    Bot(MyChatClient(), [Echo]).start()


if __name__ == '__main__':
    # Start your bot!
    main()
```

Chatter encourages you to separate concerns by keeping your chat client specific message
transformations in your `ChatClient` classes and letting all your `Feature` classes handle
standardised
`Messages`. This:

* Makes your code more testable
* Makes your bot super portable - being able to handle a new chat client is as simple as creating a
  new `ChatClient` subclass and writing your custom logic for transforming messages between Bot and
  Presentation format.

You could even use a command-line frontend for testing your bot's logic:

```python
from chatter_py import ChatClient, Message


class CommandLine(ChatClient):
    def send_to_client(self, message: Message):
        print("Chatter-bot: " + " ".join(message.text))

    def start_listening(self) -> None:
        while True:
            input_message = input("You: ")
            message_to_bot = Message(text=input_message.split(" "), room="")
            self.send_to_bot(message_to_bot)
```

Now every time you write a new chat client class, all you have to focus on testing is given a Bot
message, you receive the correct chat message, and vice versa - simple!
wickedhot 0.2.6
Wicked easy one-hot-encoding in pure python with (mostly) no dependencies
License: MIT
Keywords: one-hot encoding,machine learning

# wickedhot
Wicked easy one-hot-encoder in pure python with no dependencies

Properties

* Built for streaming
* Easy configuration of maximum number of levels
* Simple handling of unseen categorical levels
* Unobtrusive handling of numerical values
* Built in serialization and persistence of encoder
* Html form generation capability for use in web apps
* Well tested


May 1, 2020
First pypi version 0.1.0

May 4, 2020
version 0.1.2
Included html form generation and numeric statistics


May 4, 2020
version 0.1.3
Bug fix, include template directory in setup

May 18, 2020
version 0.1.6
HTML form generation

July 16, 2020
version 0.2.0
Added functionality to form generation to omit fields and add extra ones.
Useful when you have dropped base features prior to endcoding and want them back
or just want to upload other user supplied info.

July 16, 2020
version 0.2.1
Added omit_cols so some columns can have encoding info calculated
(useful for forms for example) but will not produce encoded variables.

July 16, 2020
version 0.2.2
Convert categorical with too many levels from drop down to input

July 28, 2020
version 0.2.3
Fixed bug in reservoir sampler

Sept 15, 2020
version 0.2.4
Removed min and max value from stats in forms
made the default value an integer for big numbers
md4mathjax 0.1.3
python-markdown extension for support mathjax
License: MIT
Keywords: markdown,python,mathjax

# md4mathjax
this is a python-markdown extension. basicly learning from the pelican plugin render-math. and i think inside its code, the mathjax extension split would be better.

原插件做了很多额外的工作，但现在mathjax对于数学公式写法上的支持已经很强大了，很多额外的工作都是没有必要的了。

本插件做的两个工作一就是检测markdown文档里面是否有数学公式，如果有则插入下面这段js代码。

本插件还有一个工作就是将检测到的数学公式封装进 `class=math` 的span或者div环境中。这给后续css调配提供了便利。

此外因为markdown的EscapeInlineProcessor机制存在，如果不进行处理 `\(...\)` `\[...\)` 这两个写法都会出错的，本插件经过处理将数学公式统一转为 `$...$` 和 `$$ ... $$` 这样的形式了。

很简单直观的一个插件，同时又完成了必要的工作。tests文件夹下可以有输出html文件参考。

## Usage
This Extension is writing in the Python-Markdown Recommend way, so basically it's usage can reference the Python-Markdown Extension Usage document. 

本插件在写法是Python-Markdown的统一写法，因此使用可以参看Python-Markdown的插件使用文档。

### in pelican

```
MARKDOWN = {
    'extensions': [
        'md4mathjax'
    ],
}
```

## 参数
### auto_insert 
default True 

是否根据文章有否数学公式来添加mathjax

based on the markdown file does have the math equations to decide whether add the mathjax
script

### tag_class  
default math

like 
```
<div class="math">$\pi$</div>
```

### mathjax_src
default https://cdn.jsdelivr.net/npm/mathjax@3.2.0/es5/tex-mml-chtml.js

### mathjax_id
default MathJax-script

### mathjax_settings

default 

```
DEFUALT_MATHJAX_SETTING = r"""
window.MathJax = {
  tex: {
    inlineMath: [['$', '$'], ['\\(', '\\)']],
    displayMath: [["$$", "$$"], ['\\[', '\\]']],
    packages: {
      '[+]': ['mhchem']
    }
  },
  loader: {
    load: ['[tex]/mhchem']
  },
}
"""
```

In python assign this value do not forget the prefix `r` .


## CHANGELOG
### 0.1.3
fix escape issue.

### 0.1.2
README 

### 0.1.1
解决了和toc插件不兼容的问题。

fixed a problem which is conflicted with the toc extension

### 0.1.0
初步编写完成

project started
webgenesis 0.0.2
create basic hello-world apps for the various web frameworks as boiler plates
License: MIT
Requires Python: >=3.8,<4.0
Keywords: webgenesis,webkit,cookiecutter,jcharistech,web microframeworks,flask,hello world app,streamlit

### Webgenesis
A simple command line interface for generating hello-world starter apps for 
quick setup


#### Why Webgenesis?
When building web apps, it can become common to be starting from the same or similar set of code and basic project structure. Hence webgenesis comes in to
reduce this burden of writing the same code when starting up a web project



#### Installation
```bash
pip install webgenesis
```


#### Usage
```bash
webgenesis --help

```


#### Create A Project for a web framework
+ Uses the default 'hello-<webframework>' as project folder
+ Supported frameworks include
	- flask
	- streamlit
	- express
	- koajs
	- bottle
	- tornado
	- fastapi

```bash
webgenesis create flask

```

```bash
webgenesis create streamlit

```

#### Create A Project using Custom/Specified Project
```bash
webgenesis create flask -f myflaskapp
```



#### About
+ Maintainer: Jesse E.Agbe(JCharis)
+ Jesus Saves @JCharisTech


#### Contributions
Contributions are welcome. In case you notice a bug let us know.
Happy Coding
pyplan-core 0.1.36
Pyplan Core is a Python library for using Pyplan models in any Python environment as for example a Jupyter Notebook.
License: MIT

.. image:: https://raw.githubusercontent.com/pyplan/pyplan-ide/master/docs/assets/img/logo.png

**Pyplan** is a Python development environment intended for easily creating and deploying data analytics apps. Different than a Jupyter Notebook, where code is structured as a list of sentences, in Pyplan code is contained in nodes that work as calculation steps, organized in a hierarchical influence diagram. Nodes can be evaluated, and its result inspected through a console output or rendered as a table or graph. 

**Pyplan Core** is a Python library for using Pyplan models in any Python environment as for example a Jupyter Notebook.
It provides methods to open a model, set selectors values and get results of nodes.
This library expands the possibilities of using Pyplan models embedded in your own application.
Models still have to be created using the Pyplan Graphical IDE that you can download and use for free at www.pyplan.org


Installing and running Pyplan Core
----------------------------------

You can install Pyplan Core in your computer following the instructions below::

  pip install pyplan_core

You can use Pyplan Core following the instructions below::

  from pyplan_core.pyplan import Pyplan

  pyplan = Pyplan()

  #model_filename = "path/to/my_model_file.ppl"
  model_filename = pyplan.sample_models.use_of_pyplan_core()  # for sample purposes
  pyplan.openModel(model_filename)
  value = pyplan.getResult("total_of_cases")
  print(value)

  pyplan.closeModel()