Saravanan666/pypi-org huggingface dataset:
Package: chasing-targets-gym
IntroductionThis is a simple gym environment that sets up a set of robots and targets for them to chase.
These targets are dumb, they simply move at a constant speed and bounce off the “limits” of
the simulation environment. The intention is that the robots will chase after these targets,
and switch to a new target after catching their current one. The targets are “transparent” and
robots are free to ignore “avoiding them”, the intention is that they avoid each other. An
example of a simulation with robot controller is shown below.InstallationEither you can clone and pip install the source, or you can install via pypi.gitclonehttps://github.com/5had3z/chasing-targets-gym&&cdchasing-targets-gym&&pip3install-e.Otherwise install pypi packagepip3installchasing-targets-gymSome CreditI was pointed to a basic environmentherebut it didn’t
really match what I wanted, so I made my own based off this.
Package: chasm
chasmimproved chemi-compiler-compiler for goonstationFree software: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 United States LicenseDocumentation:https://chasm.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-03-16)First release on PyPI.
Package: chassisml
Docs·Discord(#chassisml)·Slack(#chassis-model-builder)haWhat is Chassis?Chassis turns ML models written in Python into containerized prediction APIs in just minutes. We built it to be an easier way to put our models into containers and ship them to production.Chassis picks up right where your training code leaves off and builds containers for a variety of target architectures. This means that after completing a single Chassis job, you can run your models in the cloud, on-prem, or on a fleet of edge devices (Raspberry Pi, NVIDIA Jetson Nano, Intel NUC, etc.).BenefitsTurns models into containers, automaticallyCreates easy-to-use prediction APIsBuilds containers locally on Docker or as a K8s serviceChassis containers run on Docker, containerd, Modzy, and moreCompiles for both x86 and ARM processorsSupports GPU batch processingNo missing dependencies, perfect for edge AIInstallationInstall Chassis on your machine or in a virtual environment viaPyPi:Stable - v1.5.*pipinstall"chassisml[quickstart]"Try it outQuickstart Guide(<5 minutes)Full Workflow(~10 minutes)Docs📗Getting Started📘Full DocsFramework-specific examples:🤗DiffusersTorch🤗TransformersComing soon...SupportJoin the#chassismlchannel onModzy's Discord Serverwhere our maintainers meet to plan changes and improvements.We also have a#chassis-model-builderSlack channel on theMLOps.community Slack!ContributorsBradley Munday💻🤔🚧💬Seth Clark🖋📖📆Clayton Davis💻📖🤔📆Nathan Mellis🤔🚇💻saumil-d💻📖✅🤔lukemarsden📖📆🤔📢📹Carlos Millán Soler💻Douglas Holman💻Phil Winder🤔Sonja Hall🎨
Package: chasta
TODO ideasspecify the type of charts: area, line, etc...if data columns have different scale/range, use multiple Y-axis or left/rightuse timeseries for x-axisuse "steps" in chartsstore both data/html into a file that that can be "served"allow to upload the chartable data to "the cloud" or at known file/data repostore the data compresseduse a bit.ly type of short/random URL to access to saved data
Package: chaste-codegen
Code generation for cardiac ChasteThechaste_codegenmodule takesCellMLmodels as input, viacellmlmanipto read and manipulate them, then uses templating to generate C++ code.Thejinja2templating engine is used.InstallingWe recommend installing chaste_codegen in a virtual environment (using virtualenv or conda)Users installchaste_codegenusing pip.pip install chaste_codegenUsingchaste_codegenAfter installation, chaste_codegen can be called using thechaste_codegencommand:usage: chaste_codegen [-h] [--version] [--normal] [--cvode]
                      [--cvode-data-clamp] [--backward-euler] [--rush-larsen]
                      [--grl1] [--grl2] [--rush-larsen-labview]
                      [--rush-larsen-c] [-j] [-o OUTFILE]
                      [--output-dir OUTPUT_DIR] [--show-outputs] [-c CLS_NAME]
                      [-q] [--skip-ingularity-fixes] [-y] [--opt] [-m]
                      [--lookup-table <metadata tag> min max step]
                      [--use-model-factory]
                      cellml_file
chaste_codegen: error: the following arguments are required: cellml_fileFor more information about the available options callchaste_codegen -hor see theCodeGenerationFromCellML guideRelease notesFor release notes seeRELEASE.mdDocumentationAPI documentation explaining how to use cellmlmanip can be found onreadthedocsContributingFor guidelines on contributing tochaste_codegen, please seeCONTRIBUTING.md.
Package: chaster-sdk
Chaster Python SDKpip install --upgrade chaster-sdkfromchasterimportapiimportoschaster_api=api.ChasterAPI(os.environ.get('CHASTER_BEARER_TOKEN'),user_agent='your_username/1.0')See the Demos folder for examples of utilizing the SDK.pypi projectContributingYou want to? Nice! Hmu on Discord, username PupHimboCreditsRepository started by copyingthis python boilerplate
Package: chata
ChataVisualize WhatsApp chats and groups with ease 🏄InstallationpipinstallchataHow to useExport chat to text formatEnter the chat thread that you want to exportTap theMore optionsbutton, represented as three vertical dots, in the top right of your screenThen hitMoreThen tapExport ChatWhen asked, chooseWITHOUT MEDIAAfter a moment, you'll be prompted to share the exported files.Get the .txt file to the device that will run chata (you can discard any other files)Run ChataTo show all visualizations, runchata show <path_to_exported.txt>To save visualizations to a directory, runchata save <path_to_exported.txt> <output_dir>Example outputs
Package: chatai
ChatAI (beta)ChatAI is a Python package for creating chatbot apps with easy integration of NLP and ML capabilities, allowing it to understand and respond to user input in an intelligent and natural way.chatai.x()Costum helloYou need to provide "hello" to show to api the wordshello = ["hi","hello"] 

 costumhello(hello)Casual HelloDont worry about the words! We wrote you for youcasualhello()Formal HelloDont worry about the words! We wrote you for youformalhello()Costum How Are YouYou need to provide "hru" to show to api the wordshru = ["How are you?","How’s it   going?"]

costumhru(hru)Casual How Are YouDont worry about the words! We wrote you for youcasualhru()Formal How Are YouDont worry about the words! We wrote you for youformalhru()Friends How Are YouDont worry about the words! We wrote you for youfriendhru()What is ChatAI?ChatAI is a Python package for creating chatbot applications. It allows developers to easily integrate natural language processing and machine learning capabilities into their chatbot, enabling it to understand and respond to user input in a more intelligent and natural way. With ChatBot, creating a custom chatbot for your business or website has never been easier. Give it a try!
Package: chataimaker
ChatAIMaker - Python Module that can help you make the simple chat bot!CHANGELOGv1.0:
- chataimaker.chat(query) function (gives answer to any query)v1.1:
- Bug fix with pickle module.v1.2:
- chataimaker.pchat(query) function (prints answer to the query)v1.3:
- Fixed Bug With Modulev1.3.1:
- Fixed Bug With Modulev1.3.2:
- Fixed Bug With Module
Package: chatairunner
Chat AI: Run LLMs with your own hardwareChat AI is an interface that sits on top of a custom engine which is responsible for processing requests and responses
to and from an active Google T5-Flan model.Bundled InstallationOfficial Build can be acquired herefor those who want to use a compiled version of Chat AI without having to install any additional requirementsDevelopmentPrerequisitesUbuntu 20.04+ or Windows 10+Python 3.10.6pip-23.0.1Pypi installationUse this installation method if you intend to use Chat AI from the command line or with
other python libraries or scripts.Windowspip install torch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1 --index-url https://download.pytorch.org/whl/cu117
pip install aihandlerwindows
pip install https://github.com/w4ffl35/diffusers/archive/refs/tags/v0.14.0.ckpt_fix.tar.gz
pip install https://github.com/w4ffl35/transformers/archive/refs/tags/tensor_fix-v1.0.2.tar.gz
pip install https://github.com/acpopescu/bitsandbytes/releases/download/v0.37.2-win.0/bitsandbytes-0.37.2-py3-none-any.whl
pip install chatai --no-depsLinuxpip install https://github.com/w4ffl35/diffusers/archive/refs/tags/v0.14.0.ckpt_fix.tar.gz
pip install https://github.com/w4ffl35/transformers/archive/refs/tags/tensor_fix-v1.0.2.tar.gz
pip install chatairunnerDevelopment installationUse this installation method if you intend to modify the source code of Chat AI.Ubuntu 20.04+ or Windows 10+Python 3.10.6pip-23.0.1Fork this repo on githubgit clone https://github.com/Capsize-Games/chataipython -m venv env- skip if you don't want to use venvcd chatai && pip install -e .cd chatai && python main.pyHere are the special tokens used by the model:: Used to pad sequences to a fixed length.: Beginning of sequence token, used to indicate the start of a sequence.: End of sequence token, used to indicate the end of a sequence.: Unknown token, used to represent out-of-vocabulary words.: Mask token, used for masked language modeling tasks.<extra_id_X>: Special token used to represent additional task-specific labels, where X is a number from 0 to 99.: End of turn token, used in conversation models to indicate the end of a speaker's turn.
Package: chatango-lib
chatango-libChatango bot library using Python 3.8 and asyncioAcknowledgementsCredit to the original authors:neokuzeandTheClonerxOther important projects:ch.py,megach,Cherry-BlossomInstallationRequirementspython3.8+pipPackagepip install chatango-libFrom Sourcegit clone https://github.com/LmaoLover/chatango-lib
cd chatango-lib
pip install .UsageThe main classes you will use from thechatangomodule areClient,Room,PM,Message, andUser.Please Note: the interfaces for these classes and their events are not finalized.  Please be aware of any changes when upgrading.UsingasyncioThe major difference from older libraries likech.pyis the use ofasyncio.asyncfunctions must either beawaited which cause the awaiting function to pause until the operation completes, or made into a task which runs in parallel to the current control flow.ClientandRoomprovide some light task handlers for convenience.  Within your custom subclasses you can useself.add_task(...)instead ofasyncio.create_task(...).  This provides some basic exception reporting, plus custom error handling viaself.on_task_exception(task).EventsAll generated events are async coroutines ran as tasks on theRoomorClientwhich defined them.Limitations ofasyncioRegular blocking I/O cannot be used in async programs as it will block the execution of all routines.  Also, any slow CPU heavy code will block other routines from running.You can still use regular synchronous I/O by running it in a separate thread.  The easiest way to do this is usingasyncio.to_thread:# This code will block the entire application
res = requests.get("example.com")

# Run instead in an async friendly thread
res = await asyncio.to_thread(requests.get, "example.com")This should be used only with single I/O calls, as you cannot call or access any async code from within the new thread.You can run slow CPU heavy calculations in a separate pythonProcessif necessary.Basic ExampleA common pattern similar to older libraries likech.pyis to create a customClientclass to connect and handle events from multiple rooms.Seeexample.py.Custom RoomYou may create a customRoomsubclass to handle events.  This also allows your application to add custom attributes toRoom.If you are only connecting to one room, or want to manage rooms yourself without aClient, you may do so using a customRoomsubclass.
Package: chatapi-toolkit
中文文档移步这里。Chatapi ToolkitA Python wrapper for ChatAPI Toolkit, supporting multi-turn dialogue, proxy, and asynchronous data processing.Installationpipinstallchatapi-toolkit--upgradeUsageSet API Key and Base URLMethod 1, write in Python code:importchatapi_toolkitchatapi_toolkit.api_key="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"chatapi_toolkit.base_url="https://api.example.com"Method 2, set environment variables in~/.bashrcor~/.zshrc:exportOPENAI_API_KEY="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"exportOPENAI_BASE_URL="https://api.example.com"ExamplesExample 1, simulate multi-turn dialogue:# first chatchat=Chat("Hello, GPT-3.5!")resp=chat.getresponse()# continue the chatchat.user("How are you?")next_resp=chat.getresponse()# add response manuallychat.user("What's your name?")chat.assistant("My name is GPT-3.5.")# save the chat historychat.save("chat.json",mode="w")# default to "a"# print the chat historychat.print_log()Example 2, process data in batch, and use a checkpoint filecheckpoint:# write a function to process the datadefmsg2chat(msg):chat=Chat(api_key=api_key)chat.system("You are a helpful translator for numbers.")chat.user(f"Please translate the digit to Roman numerals:{msg}")chat.getresponse()checkpoint="chat.jsonl"msgs=["%d"%iforiinrange(1,10)]# process the datachats=process_chats(msgs[:5],msg2chat,checkpoint,clearfile=True)# process the rest data, and read the cache from the last timecontinue_chats=process_chats(msgs,msg2chat,checkpoint)Example 3, process data in batch (asynchronous), print hello using different languages, and use two coroutines:fromchatapi_toolkitimportasync_chat_completion,load_chatslangs=["python","java","Julia","C++"]chatlogs=["print hello using%s"%langforlanginlangs]async_chat_completion(chatlogs,chkpoint="async_chat.jsonl",ncoroutines=2)chats=load_chats("async_chat.jsonl")LicenseThis package is licensed under the MIT license. See the LICENSE file for more details.update logCurrent version1.0.0is a stable version, with the redundant featurefunction callremoved, and the asynchronous processing tool added.Beta versionSince version0.2.0,Chattype is used to handle dataSince version0.3.0, you can use different API Key to send requests.Since version0.4.0, this package is mantained bycubenlp.Since version0.5.0, one can useprocess_chatsto process the data, with a customizedmsg2chatfunction and a checkpoint file.Since version0.6.0, the featurefunction callis added.
Package: chatapi-translate
chatapi-translate功能ChatGPT 通常英文对话效果比较好, 但是英文水平不行的话来回翻译比较麻烦, 这个项目通过包裹 OpenAI API 接口实现自动调用翻译器来翻译你的提问和助理的回答.英文靠谱例子：https://shareg.pt/jVBkjbD中文不靠谱例子(最后一次回答不对)：https://shareg.pt/YfhCTDn支持流式传输, 多轮对话自动提取英文上下文用于 ChatGPT.支持 百度翻译 / 腾讯翻译 / DeepL / 阿里翻译 / 彩云小译 / 火山翻译 / Google翻译 的API作为中转翻译器 (申请后都有免费额度)支持直接使用 ChatGPT 翻译, 不过它经常回答问题而不是翻译问题很难控制, 大家要能找到好的prompt可以分享一下 (见配置示例)如果肯用 gpt-4 做翻译器, 翻译效果应该还是挺好的不想使用翻译的时候可以输入 "--不翻译\n" (见配置文件)支持 MacOS / Windows / Linux 全平台因为会先输出英文回答, 还可以顺便学学英语～搭建方法1. 本地运行安装python 3安装包pip3 install --upgrade chatapi-translate下载配置文件config_example.jsonc并重命名为config.jsonc将config.jsonc中的翻译器密钥更换为你的(申请方法), 其他参数可以看注释修改配置文件同目录下运行:chatapi-translate --port 7100现在你可以用http://127.0.0.1:7100替换https://api.openai.com的API域名在本地进行使用了, 例如你可以使用客户端chatbox2. 命令行测试exportCHATGLM_API_KEY=token1# 你的 API keycurlhttp://127.0.0.1:7100/v1/chat/completions\-H"Content-Type: application/json"\-H"Authorization: Bearer$CHATGLM_API_KEY"\-d'{"model": "gpt-3.5-turbo","messages": [{"role": "user", "content": "你是谁?"}]}'3. 反向代理# vi /usr/local/nginx/conf/nginx.confhttp{server{listen443ssl;server_name你的域名;ssl_certificate你的证书路径.pem;ssl_certificate_key你的密钥路径.key;location/{proxy_passhttp://127.0.0.1:7100/;proxy_bufferingoff;}}}# /usr/local/nginx/sbin/nginx -s reload配置好就可以在其他第三方客户端上修改 自定义API域名 为自己的域名进行使用了～免搭建体验借助ChatGPT Next Web项目自建了一个自动翻译对话的演示站点有需要的话可直接进行体验:https://chatapi-translate.vercel.app可以自动统计每次对话的token数量和官方API价格, 因为用了英文也更节省token～(使用免费的翻译接口, 可能并发数量和额度有限制, 不建议大量使用)
Package: chat-app
chat-appAllows people to chat through terminalInstallationInstall Using Git:gitclonehttps://github.com/lol-cubes/chat-app.git
pipinstallcryptography
python3chat-app/chat-app# setupInstall Using Pip:pipinstallchat-app
python3-mchat-app# setupUsageCreate a Serverchat-appserverPort is any 4-digit number that isn't already in use
(you'll know when it's in use)Join a Serverchat-appclientThe server is the IP address of the server machine.
Find your IP address (on unix) using the command:ipconfiggetifaddren0System Requirements and DependenciesPython 3.x installedUnix-based OS
Package: chat-app-package
Chat is a Django app to conduct Web-based Chat. For each question,
visitors can choose between a fixed number of answers.Detailed documentation is in the “docs” directory.Quick startAdd “chat” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'chat',
]

USE_DEFAULT_TEMPLATES=FalseInclude the chat URLconf in your project urls.py like this:path('chat/', include('chat.urls')),Runpython manage.py migrateto create the chat models.Add to settings.py this:ASGI_APPLICATION = 'your_project_name.asgi.application'

CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
            "hosts": [('127.0.0.1', 6379)],
        },
    },
}

WEBSOCKETPATH='127.0.0.1:8000'Create routing.py file in project folder:from django.urls import path
from channels.routing import URLRouter
from chat.consumers import ChatConsumer

ws_application = [
    path("ws/chat/",ChatConsumer.as_asgi())
]Write in asgi.py file in project folder:import os
from channels.routing import URLRouter,ProtocolTypeRouter
from channels.security.websocket import AllowedHostsOriginValidator
from channels.auth import AuthMiddlewareStack
from django.core.asgi import get_asgi_application
from .routing import ws_application

application = ProtocolTypeRouter({
    'websocket': AllowedHostsOriginValidator(
        AuthMiddlewareStack(
        URLRouter(
            ws_application
        )
        )
    )
})Start the development server and visithttp://127.0.0.1:8000/admin/to create a chat (you’ll need the Admin app enabled).Visithttp://127.0.0.1:8000/chat/to participate in the chat.If you want to use your template:write views.py

from chat.use_customs import CustomTemplate

CustomTemplate.chat_template_name='mychat.html'
CustomTemplate.login_template_name='mylogin.html'
CustomTemplate.signup_template_name='mysignup.html'
Package: chatbook
chatbookPython-based summary and keyword extractor and question answering system   about a document's content##INSTALL
See therequirements.txtfile if installing directly. To make an editable package locally, usepip3 install -e .To embed in a system as is, frompypi.orgusepip3 install -U chatbook##USAGE:This lightweight version of thedoctalkpackage assumes that files have been pre-processesed bydoctalkfrom .txt or .pdf files into .json files. With minimal dependencies (networkx and nltk) and memory requeirements this package is planned to be exposed as a Web App or as an Alexa skill.python3 -i

>>> from chatbook.talk import run_with
>>> run_with(fname)This activates dialog about document in<fname>.txtwith questions in<fname>_quests.txtSee some examples at :https://github.com/ptarau/chatbook, where, after installing the system, you can runpython3 -i tests.py
>>> go()To play with various parameter settings, edit thechatbook/params.pyfile.Web AppTo use the included ``docbotWeb app, after installingFlask``` and ```waitress```, run the ```app.py``` file in directory ```docbot``` with ```python3 app.py```.The docbot uses a JSON-based API, documented inchatbook/api.py. In fact, this is the simplest way to integrate the summarizer and the dialog agent into a production system.
Package: chatbot-builder
Chatbot Builder: a discord chatbotA discord bot that is programmed through commands sent in discord messages by
discord users. You can invite this bot to a server and teach it to say whatever you like!The bot will see all messages in all channels within the server you invite it to.
Any message starting with ‘%’ is assumed to be a command. If a message does not
start with ‘%’, the bot will assume it is conversational text and will respond,
if has any appropriate responses programmed.Run the ‘%help’ command to get started with available commands to program the bot.InstallInstall with pip:python3 -m pip install chatbot_builderUsageSet the environment variableDISCORD_BOTBUILDER_TOKENto the API token for your
discord bot application.Run the discord client:python3 -m chatbot_builder.clients.discord_clientThe bot should now be online in any servers that you have invited it to
Package: chatbotentities
version number: 0.0.1
author: Karel Antonio Verdecia OrtizOverviewChatbot Entities Extractor.Installation / UsageTo install use pip:$ pip install chatbotentitiesOr clone the repo:$ git clonehttps://github.com/kverdecia/chatbotentities.git$ python setup.py installContributingTBDExampleTBD
Package: chatbot-help
一、Chatbot_Help介绍Chatbot_Help是一个接入机器人的第三方扩展工具，提供一系列相关api来将自己开发的机器人（Chatbot）接入到相关外部平台，实现与用户的交互目前，Chatbot_Help支持的第三方平台有：1、钉钉群：2、微信公众号；3、QQ群；4、外部平台：如电商平台、网页端等二、安装使用pip install Chatbot_Help三、各消息类型使用示例1、dingtalkfrom四、Update News2020.1.7  接入钉钉群，支持主动推送消息、outgoing交互五、参考1、
Package: chatbot-nlu
一、Chatbot_NLUChatbot_NLU是一个基于RASA的自定义中文语言理解组件，他可以替换掉RASA中本身的nlu模块，可以使nlu的准确率有较大提升，目前
引入了bert，后续将引入xlnet。同时，RASA的自定义组件可以参考Custom NLU Components目前Chatbot_NLU支持的功能有：1、bert vector2、bert intent3、bert slot二、安装使用1、安装pipinstallchatbot_nlu2、使用Chatbot_NLU的使用是在config.yml文件中修改配置，常见的使用方法请参考：language:"zh"pipeline:-name:"JiebaTokenizer"-name:"chatbot_nlu.extractors.crf_entity_extractor.CRFEntityExtractor"# ner-name:"chatbot_nlu.extractors.jieba_pseg_extractor.JiebaPsegExtractor"part_of_speech:["nr"]-name:"chatbot_nlu.extractors.bilstm_crf_entity_extractor.BilstmCRFEntityExtractor"# Word Embedding-name:"chatbot_nlu.featurizers.bert_vectors_featurizer.BertVectorsFeaturizer"ip:"172.18.103.43"port:5555port_out:5556show_server_config:Truetimeout:10000check_version:False三、Update News2020.1.7  接入钉钉群，支持主动推送消息、outgoing交互2020.1.9  接入微信四、Resources
Package: chatbot_script
This is the README file for the project.The file should use UTF-8 encoding and be written using ReStructured Text. It will be used to generate the project webpage on PyPI and will be displayed as the project homepage on common code-hosting services, and should be written for that purpose.Typical contents for this file would include an overview of the project, basic usage examples, etc. Generally, including the project changelog in here is not a good idea, although a simple “What’s New” section for the most recent version may be appropriate.
Package: chatcell
chatcellA python framework to create your personal AI assistant 🤖.Getting Started•License•Changelogchatcell is a Python framework that allows you to create a chatbot, which can respond to your commands and perform various tasks according to your requirements.⚡ Highlights💬 Create your personal AI assistant.📈 Customize responses and functions to enhance versatility.🧩 Extentable framework for variety of chat-based tasks.🔗 Integrated with cutting-edge AI stack.🤗 One-click deployment to Hugging Face and Replit.🔧 Installationchatcell can be installed using pip with the following command:pip install chatcell💡 ExamplesExample implementationsEcho Bot, an example bot which return exactly what you send to him.Cat Bot, this example is intended to cover most of the options that the chatcell provides.OpenAI Bot, an example bot built on top of OpenAI Chat Completion API, powered byopenai-python.LangChain Bot, an example bot built on top of ChatGPT usingLangChain.LlamaIndex Bot, a knowledge-augmented bot powered byLlamaIndex.🌱 ContributingContributions to the chatcell framework are welcome! Please submit any bug reports, feature requests, or pull requests through theGitHub repository.LicenseThis project is licensed under the Apache-2.0 License.