Saravanan666/pypi-org huggingface dataset:
Package: irbt
Library for irbt cloud apiThis library implements some parts of the irbt cloud api (to control the different
robots of the company).Supported devices:It has only been tested with a roomba i7.Featureslogin using gigya/irbt apiassociated robot listhistorymaps api (as json)missions apimqtt start, pause, stop, dock, findcliusage:cli.py[-h][-m][-M][-e][-t][-d][-c[CMD]][-l][-r[ROOM_IDS]][-p][-R][-i[ROBOT_ID]][-I][-j][-w]optionalarguments:-h,--helpshowthishelpmessageandexit-m,--mapoutputcurrentmap-M,--missionsMissionshistory-e,--evachistoryEvachistory-t,--timelineTimeline-d,--debug-mqttdebug-mqtt-c[CMD],--cmd[CMD]cmdfortherobot(start,stop,dock,pause)-l,--list-roomsListrooms-r[ROOM_IDS],--room-ids[ROOM_IDS]roomidstoclean-p,--robot-passwordShowrobotpassword-R,--robotsListrobots-i[ROBOT_ID],--robot-id[ROBOT_ID]Specifyrobotid-I,--robot-infosShowrobotinfos-j,--output-jsonOutputasJsonifpossible-w,--rawOutputRawJson(fromserverapi)ifpossibleInstall the dependenciespip3install-rrequirementsRunset your irobot credentials in the following var :exportIRBT_LOGIN="your.email@provider.com"exportIRBT_PASSWORD="yourpassword"Then launch the cli (-h for the options)./cli.py-hYou can also build the container using:dockerbuild.-tirbt_cliThen run it with the credentials environment variable setsdockerrun-eIRBT_LOGIN-eIRBT_PASSWORD-tiirbt_cli:latestpython3./cli.py-hfor wireshark debuggingimportsslkeylog
sslkeylog.set_keylog("sslkeylog.txt")
Package: irc3
A pluggable irc client library based on python’sasyncio.Requires python 3.5+Python 2 is no longer supported, but if you don’t have a choice you can use
an older version:$ pip install "irc3<0.9"Source:https://github.com/gawel/irc3/Docs:https://irc3.readthedocs.io/Irc:irc://irc.freenode.net/irc3(www)I’ve spent hours writing this software, with love.
Please consider tipping if you like it:BTC: 1PruQAwByDndFZ7vTeJhyWefAghaZx9RZgETH: 0xb6418036d8E06c60C4D91c17d72Df6e1e5b15CE6LTC: LY6CdZcDbxnBX9GFBJ45TqVj8NykBBqsmT
Package: irc-api
IRC APIDescriptionIRC API is a small API to make Python IRC bots. This API is based on decorators to make commands like thecogmodule indiscord.py.If you encounter any issue feel free toopen one.
A full documentation is available onreadthedocs.InstallationTo install IRC API, you should usepip install irc-api, check out thePypi project pagefor more informations.LicenceThis project is under GNU General Public Licence v3.0 or later (GPLv3+).
Please seeLICENCEfor more informations
Package: ircb
# ircbA versatile IRC bouncer.## Requirements- Python3.5- Pip3.5## Setup- Install dependencies:``[sudo] pip3.5 install -r requirements.txt``- Copy and extend``ircb/config/default_settings.py``, as needed,     to a custom location. say, ``/etc/ircb/settings.py``.- [OPTIONAL] ``export IRCB_SETTINGS=<path to your custom settings file>``- Install the project as a development dep``python3.5 setup.py develop``## Setup for development- Install system dependencies:`` sudo dnf install python3-devel openssl-devel redis```` sudo pip install virtualenvwrapper``- Make `python3` virtualenv:``mkvirtualenv --python=/usr/bin/python3 python3``- Activate virtualenv:``workon python3``- Install dependencies:``pip3 install -r requirements.txt``- Install the project as development dep:``python3.5 setup.py develop``- Make sure `REDIS` is running:``sudo systemctl start redis.service``- Now, you need to run ``ircb stores``:``ircb run stores``Continue with `` Setting up data``## Setting up data- Creating a user:```ircb users create USERNAME EMAIL [PASSWORD]```- Creating a network for a user:```ircb networks create USER NETWORK_NAME HOST PORT NICK```You'll get an access token as an output of the above. Use this as**server password** when configuring your IRC client to connect to ``ircb``.## Running the app### Quickstart```sudo ircb run allinone```Note: If you are using virtualenv `sudo` will not work this way, you need torun:```sudo ~/.virtualenvs/python3/bin/ircb run allinone```### AdvancedYou can run the various components of ``ircb``: ``stores``, ``bouncers`` asdifferent processes.- Run stores as a different process: ``ircb run stores``- Run bouncer: ``ircb run bouncer``- Run web server: ``ircb run web``- Run identd server: ``sudo ircb run identd``## Connecting for IRC clientNow, you should be able to connect to ``ircb`` from your IRC client at:- host/port: ``localhost/9000``- server password: ``<your network access token>``- IRC client should have the following settings enabled:* Use SSL for all server on this network* Accept invalid SSL certificate### Configure HexChat- Go to HexChat -> Network List- Change the nick to the nick you have given while configuring network- Under ``Network`` Click `Add` and name the server ``ircb``- Click on `Edit` then `Add` and type `localhost/9000`- Under ``Server`` tab check the ``SSL`` option mentioned above- Enter the ``Server Password`` in `Password` field- Close the dialog box and then connect to the networkNote: In case the problem persist try to ``restart`` ircb server
Package: ircbgp
ircbgpSmall script to simulate bgp with students using IRC.What is neededYou need to design a topology and for each link between two ASes create an irc channel on a irc server.
You can now assign AS numbers to students and let them either interact with this bot and/or each other.Kudos to Tobias Fiebig, who used this concept in a lecture and gave the inspiration to write a bot for
this.Why?Just a proof of concept, however, the bot could already be useful to replace participants leaving the
lecture early.UsageUse screen to start multiple bots in parallel or use separate terminals:$ screen ircbgpbot Florian 1 '#as1-as2'
   $ screen ircbgpbot Claudia 2 '#as1-as2,#as2-as3'
   $ screen ircbgpbot Tobias  3 '#as2-as3'This would start three bots connecting to a irc server running on localhost, names Florian, Claudia and Tobias.
All three will start announcing their nickname and AS number (1-3) to the channels listed as last parameters.Received announcements will then be forwarded to all other channels and the own AS-number appended(!) to the aspath.Note: We are of course NOT implementing the whole BGP protocol and do not support things like withdrawals.Testing convergenceThe command msg:nickname:Text message can be used to send a message to the nickname given, if it was announced
by somebody in the 'network'. Bots will print the message as debugging output.
Package: ircbot
backgroundOn Feb 13th I joined the PyLadies folks (along with a friend,@btanaka) to learn about how to make an IRC bot.There was no formal presentation, but it was a great opportunity to get
together with friends and hack. The notes from the event can be foundhere, with relevant code found atthis GitHub repo.I can understand whyRachelwould have started
with a repository that wouldn’t have required a single sudo or pip command:K.I.S.S. There is overhead
associated with teaching pip/virtualenv/etc. when people don’t know what that
is.After perusing the code in that repo, however, I thought that there had to be
a simpler way. Back in December the question of making an IRC bot came up in
theBayPIGgiesmailing list, and Guido hisself
answeredwith one word: Twisted.I thought I ought to look at what it would take, and turns out that it isn’t
much; I made this repo/package so that people could grab the source, run
setup.py develop, and hack/execute to their heart’s content.I hope someone finds it useful.installationIf you’re going to hack, clone this repo:hgclonehttps://bitbucket.org/smcquay/ircbotcdircbotpythonsetup.pydevelopAnd then continue to add code to ircbot.IRCBot.privmsg.If you’re not going to hack and just want a simple echo server:pipinstallircbotexecutionOnce you’ve installed the bot, you can invoke it as such:ircbot-p6668-nechobotpythonutah-pythonor consult ircbot -h.
Package: ircbuilder
This package provides a python api for sending commands to a Minetest server over IRC.The source for this package is available here.To installpip install ircbuilderRequires Minetest with irc_builder modOn Ubuntu or Debian linux:sudo apt install minetest lua-socket
mkdir -p ~/.minetest/mods
cd ~/.minetest/mods
git clone --recursive git@github.com/minetest-mods/irc.git
git clone git@github.com:ShadowNinja/minetest-irc_commands.git irc_commands
git clone https://github.com/mt-mods/basic_materials.git
git clone https://github.com/mt-mods/signs_lib.git
git clone git@github.com:timcu/irc_builder.git
minetestOn Windows:# Download and extract minetest-5.3.0-win64.zip to Documents folder (https://www.minetest.net/downloads/)
# Run Git-Bash (you will need to install it first. https://git-scm.com/download/)
cd ~/Documents/minetest/mods
git clone --recursive git@github.com/minetest-mods/irc.git
git clone git@github.com:ShadowNinja/minetest-irc_commands.git irc_commands
git clone https://github.com/mt-mods/basic_materials.git
git clone https://github.com/mt-mods/signs_lib.git
git clone git@github.com:timcu/irc_builder.git
exit
# Double click on Documents > minetest > bin > minetest.exeOn Mac OS X:brew install minetest luarocks-5.1
luarocks-5.1 install luasocket
mkdir -p ~/Library/Application\ Support/minetest/mods
cd ~/Library/Application\ Support/minetest/mods
git clone --recursive git@github.com/minetest-mods/irc.git
git clone git@github.com:ShadowNinja/minetest-irc_commands.git irc_commands
git clone https://github.com/mt-mods/basic_materials.git
git clone https://github.com/mt-mods/signs_lib.git
git clone git@github.com:timcu/irc_builder.git
/usr/local/opt/minetest/minetest.app/Contents/MacOS/minetestOn Mac OS X using MacPorts:sudo port install minetest luarocks
sudo -H luarocks install luasocket
cd /opt/local/share/lua/5.1
sudo ln -s ../5.3/socket
# Then continue from third line aboveOnce running, adjust the following settings:# Settings > Advanced > Server/Singleplayer > Security > Trusted mods > irc
# Settings > Advanced > Mods > irc > Basic > Bot nickname > eg mtserver
# Settings > Advanced > Mods > irc > Basic > IRC server > eg irc.undernet.org
# Settings > Advanced > Mods > irc > Basic > IRC server port > eg 6667 or 6697
# Settings > Advanced > Mods > irc > Basic > Channel to join > eg ##myminetest
Package: ircclient
ircclientSimple IRC client interface.Examplefromircclient.clientimportDispatchClientclient=DispatchClient(('localhost',6667),blocking=True)client.connect()m=client.dispatch()# ircclient.struct.Messageassertm.type=='CONNECTED'# connected message which is out of irc protocolclient('nick','testnick')# list args are joined. colons will be automatically added.client('user 8 * :{name}',name='realname')# keyword args are formatted as raw stringwhileTrue:m=client.dispatch()# raw=True option will make it returns raw textprint(m)# ircclient.struct.Message
Package: irccodes
IRC codesUsage:Text format:fromirccodesimport*# Functional method:bold(str)italic(str)strikethrough(str)underline(str)monospace(str)reset(str)# Concatenation method:symbols.BOLD+strsymbols.ITALIC+strsymbols.STRIKETHROUGH+strsymbols.underline+strsymbols.MONOSPACE+strsymbols.RESET+strText colors:colored(str,text_color,background_color)symbols.COLOR+symbols.<COLORNAME>+','+symbols.<BACKGROUNDCOLORNAME>+strExamples:colored(text,'blue')colored(text,'light green','grey')bold(colored('first','white')+' '+colored('second','grey'))symbols.COLOR+symbols.BLUE+','+symbols.LIGHTRED+texttext+symbols.RESETreset(text)Supported colors:IndexColorRGB0White(255,255,255)1Black(0,0,0)2Blue(0,0,127)3Green(0,147,0)4Light Red(255,0,0)5Brown(127,0,0)6Purple(156,0,156)7Orange(252,127,0)8Yellow(255,255,0)9Light Green(0,252,0)10Cyan(0,147,147)11Light Cyan(0,255,255)12Light Blue(0,0,252)13Pink(255,0,255)14Grey(127,127,127)15Light Grey(210,210,210)More detailed:https://www.mirc.com/colors.htmlhttps://stackoverflow.com/questions/1391610/embed-mirc-color-codes-into-a-c-sharp-literal
Package: ircelsos
Downloading air quality data from the SOS of IRCEL - CELINE, the Belgian
Interregional Environment Agency (http://www.irceline.be).This packages provides both a command line interface, as a python module
that downloads the data as pandas DataFrames.Installationircelsosis a Python package. If you have Python installed,ircelsoscan
easily be installed with pip:pip install ircelsosThis will automatically install the dependencyOWSlib.
ircelsos supports python 2.7 and 3.3+. For python 3, OWSlib 9.0 or higher is needed.Command line usageInstalling ircelsos will register aircelsoscommand. This can be used from
the command line to download data and to retrieve info about the stations and
pollutants available in the SOS, using the two subcommandsqueryandinfo.Downloading dataTo download data, you can use theircelsos querycommand. Eg:ircelsos query o3 -s BETN060 -p 2015-03-27T00:00:00 2015-03-27T10:00:00This will save a csv file in the current directory.Specifying no stations or no period, will download the data for that pollutant
for all stations for the full available period.For more details on the arguments, callircelsos query-h.Retrieving infoTheircelsos infocommand can be used to inspect available stations and
pollutants. The following will give a list of all pollutants:$ ircelsos info --pollutant
SOS of IRCEL - CELINE

id                     | short | name                         | stations
-----------------------+-------+------------------------------+---------
16111 - Black Carbon   | bc    | Black Carbon                 | 25
42101 - CO             | co    | Carbon Monoxide              | 24
...To get the detailed information about one pollutant, you can specify this after--pollutant. Eg:$ ircelsos info --pollutant bc
SOS of IRCEL - CELINE

      id = 16111 - Black Carbon
   short = bc
    name = Black Carbon
stations = 25

This pollutant is measured at the following stations:

name   | EU_code | location             | region   | type
-------+---------+----------------------+----------+-----------
40AB01 | BELAB01 | ANTWERPEN            | suburban | Background
40AL01 | BELAL01 | LINKEROEVER          | suburban | Background
...The same can be done to get information about the stations:ircelsos info--stationfor a list of all stations andircelsos info--stationSTATION_CODEfor the detailed information of one
station.Alternatively to the command line, you can also run the same script from
theircelsosdirectory:python -m ircelsos query ...Interactive usage (pandas)To use the packages in an interactive python session, you need an extra
dependency:pandas(to install pandas,
it is recommended to use a scientific python distribution likeAnacondaorCanopythat includes pandas).To download data as a pandas DataFrame, you can use thequeryfunction:>>>importircelsos>>>df=ircelsos.query('no2',station=['42R801','42R802'],utc_start='2015-11-15')>>>df.head()42R80142R802time2015-11-24T01:00:00.000+01:0027.028.52015-11-24T02:00:00.000+01:0017.519.52015-11-24T03:00:00.000+01:0016.016.52015-11-24T04:00:00.000+01:0017.017.52015-11-24T05:00:00.000+01:0024.024.5Author: Joris Van den BosscheLicense: BSD 2-clause
Package: ircevents
irceventsusageexample codeimportircstates,irctokens,ircevents,socket# Connection settingsNICK="nickname"HOST="127.0.0.1"POST=6667server=ircstates.Server("freenode")sock=socket.socket()events=ircevents.Engine(sock)sock.connect((HOST,POST))def_send(text):line=irctokens.tokenise(text)server.send(line)def_sent(source,state):ifnotstate.get("init"):state.set("init",True)_send(f"USER{NICK}0 * :{NICK}")_send(f"NICK{NICK}")whileserver.pending():send_lines=server.sent(source.send(server.pending()))forlineinsend_lines:print(f"<{line.format()}")@events.when(always_run=True)def_display(line,state):print(f">{line.format()}")@events.when(command="PING")def_ping(line,state)_send(f"PONG{line.params[0]}")@events.when(command="001")def_join(line,state):channels=state.get("channels",list())forchannelinchannels:ifchannelnotinserver.channels:_send(f"JOIN{channel}")state.set("joined_channels",True)# Load ircstates as a state mutationevents.use("ircstates",lambdaraw:server.recv(raw))# Events will be received using 1024 bytes from socketevents.recv_with(lambdasource,state:source.recv(1024))# Before processing new data, send queued data to serverevents.pre_process(_sent)# Define what channels to joinevents.ns_set("ircstates","channels",["#bots","#test"])# Run event loopevents.run()
Package: irckaaja
IrckaajaA scriptable IRC bot with a Python interface.Table of ContentsInstallationUsageScriptsScreenshotsContributingLicenseInstallationirckaaja requires Python 3.9 or newer. The package is available onPyPIand can be installed with pippipinstallirckaajaUsagepython-mirckaaja.irckaaja-cconfig.iniScriptsTo build your own scripts, subclassirckaaja.botscript.BotScript. Currently
subscribable events aredefon_channel_message(self,user:User,channel_name:str,message:str)->None:"""Called when a channel message is received."""defon_private_message(self,user:User,message:str)->None:"""Called when a private message is received."""defon_join(self,user:User,channel_name:str)->None:"""Called when a user joins a channel."""defon_part(self,user:User,channel_name:str)->None:"""Called when a user parts a channel."""defon_quit(self,user:User)->None:"""Called when a user quits the network."""defon_connect(self)->None:"""Called when bot has connected to the network."""defon_topic(self,user:User,channel_name:str,topic:str)->None:"""Called when topic has changed on a channel."""A simple greeter bot would look like this.fromirckaaja.botscriptimportBotScript,UserclassHelloWorld(BotScript):"""A simple script class. Only responds to messages starting "hello"in every joined channel."""defon_channel_message(self,user:User,channel_name:str,message:str)->None:ifmessage.startswith("hello"):self.say(channel_name,"hello, "+user.nick)returnThe modules should be present in theirckaaja.scriptspackage and named as the
lowercase of the class name found in the module. E.g. script calledGreetershould be placed toirckaaja.scripts.greeter.Greeter.Loading of modules is controlled by the[modules]section of the configuration
file:[modules][[Greeter]]arbitrary_configuration="passed to script as a dict[str, Any]"ConfigurationExample configuration:[servers][[QuakeNet]] # also alias for the networkhostname=se.quakenet.orgport=6667# if port is no defined, default is 6667channels="#example1", "#example2"#[[IRCNet]]#    hostname = irc.cs.hut.fi[bot]nick=irckaajaaltnick=irckaaja_# if not provided, nick + "_"realname=Irkkaa Nörttien Kanssausername=irckaajaowner="nick!user@example.com"[modules][[HelloWorld]]ScreenshotsContributingDrop a pull request if you have something you'd want to incorporate.LicenseSeeLicence.txt.
Package: irckit
tinkering with a made-from-scratch irc library in pythondocumentationhosted on readthedocs.orginstallinginstall from github (recommended):pip install -e git+git://github.com/coleifer/irc.git#egg=irckitinstall using pypi:pip install irckitinstall dependencies:pip install gevent (for botnet)
pip install boto (for botnet's EC2 launcher)
pip install httplib2 (for some of the bots)
Package: irclm
IRC Log ManagerManage a local cache of irc logs.Capabilities:incremental cache update by defaultconvenience wrapper for greplog cache optionally managed by gitsession reuseIncremental UpdateirclmConveniently Grep Log Cacherun command from log cache directoryirclm-grep<key>
irclm-rg<key>
irclm-gitgrep<key>Development:gitclonegit@github.com:holmanb/irclm.gitcdirclm
poetryinstall
<edit># run testspoetryrunall
<submitpr>Goals:be simple, reliable, slimgood netizinship - defaults to keep the servers happyServer Support:irclogs.ubuntu.comOpen a PR (or a bug with details) for support!Future Work:manifest should store per-channel updated datestests, tests, testsverify timer install and document
Package: irclogger
irclogger is a simple daemon written in thePython Programming Languageutilizing thecircuitsframework for the sole purpose of logging a set of IRC
Channels to disk in the form that something likeirclog2htmlcan understand and parse.InstallationFrom PyPi using pip:$ pip install ircloggerfrom source:$ mkvirtualenv irclogger
$ hg clone https://bitbucket.org/prologic/irclogger
$ cd irclogger
$ pip install -r requirements.txtUsageTo display help:$ irclogger --help

Usage: irclogger [options] <host> [<port>]

Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -d, --daemon          Enable daemon mode
  -c CHANNELS, --channel=CHANNELS
                        Channel to join (multiple allowed)
  -n NICK, --nick=NICK  Nickname to use
  -o OUTPUT, --output=OUTPUT
                        Path to store log files
  -p PIDFILE, --pidfile=PIDFILE
                        Path to store PID file
  -v, --verbose         Enable verbose debugging modeTo log a single channel:$ irclogger -c "#mychannel" irc.freenode.netNoteBy default irclogger stores logs in the current working directory.
Use-o/--outputto change the location to store log files.NoteAlso note that the default nickname used is your current username
on your system. i.e:$USER. To change this use the-n/--nickoption.ChangeLog for irclogger0.0.2 (2014-10-04)Updated to usecircuits 3.00.0.1 (2013-03-10)Initial Release
Package: ircmatch
# ircmatchThis is a python extension which provides string comparison and matching functions from Atheme.They are hand-optimized for high performance when matching IRC hostmasks.## Usage```pythonimport ircmatchprint ircmatch.match(0, 'kaniini!*@*', 'kaniini!~kaniini@localhost')```See also `help(ircmatch)` and `example.py` in this source distribution.
Package: ircmessage
IRC Message is a simple Python module for applying and stripping
formatting from IRC messages. Its primary purpose is for use with Python
based IRC bots.The modules syntax was heavily inspired byClick’s own style and
unstyle methods.InstallationYou can install the IRC Message Formatter module via pip,pip install ircmessageThis module provides two primary methods,styleandunstyleStyleircmessage.style(text,fg=None,bg=None,bold=False,italics=False,underline=False,reset=True):This method is used to style text with IRC attribute and / or color
codes.Examples:ircmessage.style('Hello World!',fg='green')ircmessage.style('ATTENTION!',bold=True,underline=True)ircmessage.style('Some things',bg=ircmessage.colors.teal)Unstyleircmessage.unstyle(text)This method is used to strip all formatting control codes from IRC
messages so that you can safely display and log the contents outside of
IRC in a printable format.LicenseThe MIT License (MIT)

Copyright (c) 2015 Makoto Fujimoto

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Package: ircnotifier
Overviewircnotifier is a simple daemon written in thePython Programming Languageutilizing thecircuitsframework for the sole purpose of forwarding
notifications received through various sources to IRC Channels.RequirementscircuitsSupported PlatformsLinux, FreeBSD, Mac OS X, WindowsPython 2.6, 2.7, 3.2, 3.3PyPy 2.0Changelog for ircnotifier0.0.2 (2013-03-10)Added generic message endpoint and message script.0.0.1 (2013-03-10)Initial Release