{ "info": { "author": "Stephen McDonald", "author_email": "stephen.mc@gmail.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 4 - Beta", "Environment :: Web Environment", "Framework :: Django", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python", "Topic :: Internet :: WWW/HTTP", "Topic :: Software Development :: Libraries :: Python Modules" ], "description": "======\nGnotty\n======\n\nCreated by `Stephen McDonald `_\n\nGnotty ties the knot between the web and IRC. It is designed to assist\nopen source projects that host an IRC channel for collaboration on\ntheir project.\nGnotty is `BSD licensed `_.\n\nGnotty is comprised of several parts. Primarily Gnotty provides a\nmodern web client and server for communicating with an IRC channel via\na web browser. The web server uses `gevent `_\nand `WebSockets `_, which\nprovides the communication layer between the IRC channel and the web\nbrowser. Twitter's `Bootstrap `_\nis used to style the web interface, providing a fully responsive\nlayout, suitable for use with mobile devices. Customisable templates\nare also provided for skinning the web interface.\n\nCheck out the `Gnotty live demo `_ to see the\nweb interface in action.\n\nSecondly, Gnotty provides the ability to run a highly customisable\nIRC bot. Different classes of bots can be configured on startup, and\nbots can perform different services such as message logging and\ninteracting with users in the IRC channel. Bots also contain webhooks,\nwhich allows bots to receive and act on input over HTTP from external\nservices.\n\nGnotty also provides an optional Django application that archives IRC\nmessages, for browsing and searching via a web interface. By default\nthe IRC bot uses Python's logging module to provide configurable\nlogging handlers for IRC messages. When the Django application is\nused, a logging handler is added that logs all IRC messages to the\nDjango project's database. The Django application then provides all\nthe necessary views and templates for messages to be searched by\nkeyword, or browsed by date using a calendar interface.\n\nNote that the Django application is entirely optional. Gnotty can\nbe run without using Django at all, as a stand-alone gevent web\nserver that provides the web interface to an IRC channel, with\nconfigurable IRC bots.\n\n\nInstallation\n============\n\nThe easiest way to install Gnotty is directly from PyPi using\n`pip `_ by running the command below::\n\n $ pip install -U gnotty\n\nOtherwise you can obtain Gnotty from the\n`GitHub `_ or\n`Bitbucket `_ repositories,\nand install it directly from source::\n\n $ python setup.py install\n\n\nConfiguration\n=============\n\nGnotty is configured via a handful of settings. When integrated\nwith Django, these settings can be defined in your Django project's\n``settings.py`` module. When Gnotty is run as a stand-alone\nclient, these same settings can be defined via the command-line, or\nin a separate Python configuration module. See the \"Stand-Alone Web\nClient\" section below for details.\n\n * ``GNOTTY_HTTP_HOST`` - HTTP host address to serve from.\n *string, default: 127.0.0.1*\n * ``GNOTTY_HTTP_PORT`` - HTTP port to serve from.\n *integer, default: 8080*\n * ``GNOTTY_IRC_HOST`` - IRC host address to connect to.\n *string, default: irc.freenode.net*\n * ``GNOTTY_IRC_PORT`` - IRC port to connect to.\n *integer, default: 6667*\n * ``GNOTTY_IRC_CHANNEL`` - IRC channel to join.\n *string, default: #gnotty*\n * ``GNOTTY_IRC_CHANNEL_KEY`` - Optional key required to access\n the IRC channel.\n *string, default: None*\n * ``GNOTTY_BOT_CLASS`` - Dotted Python path to the IRC client bot\n class to run.\n *string, default: gnotty.bots.BaseBot*\n * ``GNOTTY_BOT_NICKNAME`` - IRC nickname the logging client will\n use.\n *string, default: gnotty*\n * ``GNOTTY_BOT_PASSWORD`` - Optional IRC password for the bot.\n *string, default: None*\n * ``GNOTTY_LOGIN_REQUIRED`` - Django login required for all URLs\n (Django only)\n *boolean, default: False*\n * ``GNOTTY_DAEMON`` - run in daemon mode.\n *boolean, default: False*\n * ``GNOTTY_PID_FILE`` - path to write PID file to when in daemon\n mode.\n *string, default: [tmp]/gnotty-[http-host]-[http-port].pid*\n * ``GNOTTY_LOG_LEVEL`` - Log level to use. ``DEBUG`` will spew out\n all IRC data.\n *string, default: INFO*\n\nTo be clear: the IRC host and port are for specifying the IRC server\nto connect to. The HTTP host and port are what will be used to host\nthe gevent/WebSocket server.\n\n\nDjango Integration\n==================\n\nWith the above settings defined in your Django project's\n``settings.py`` module, a few more steps are required. As with most\nDjango apps, add ``gnotty`` to your ``INSTALLED_APPS`` setting, and\n``gnotty.urls`` to your project's ``urls.py`` module::\n\n # settings.py\n INSTALLED_APPS = (\n # other apps here\n 'gnotty',\n )\n\n # urls.py\n from django.conf.urls.defaults import patterns, include, url\n urlpatterns = patterns('',\n # other patterns here\n ('^irc/', include('gnotty.urls')),\n )\n\nAs you can see we've mounted all of the urls Gnotty provides under\nthe prefix ``/irc/`` - feel free to use whatever suits you here. With\nthis prefix, the URL on our Django development server\n`http://127.0.0.1:8000/irc/ `_ will load\nthe chat interface to the IRC channel, along with a search form for\nsearching the message archive, and links to browsing the archive by\ndate.\n\nThe final step when integrated with Django is to run the Gnotty\nserver itself. The Gnotty server is backed by gevent, and will host\nthe WebSocket bridge to the IRC channel. It will also start up the\nIRC bot that will connect to the channel, and log all of the messages\nin the channel to the database archive.\n\nRunning the Gnotty server when integrated with Django is simply a\nmatter of running the ``gnottify`` Django management command::\n\n $ python manage.py gnottify [options]\n\nNote that each of the configuration options can also be specified as\narguments to the ``gnottify`` management command. The names and\nformats used in this context are the same as those described next for\nthe stand-alone web client. Any options provided as command-line\narguments take precendence over those defined in your Django project's\n``settings.py`` module.\n\nThe ``gnottify_runserver`` command is also included, which will run\nboth the Gnotty server and Django's ``runserver`` command at once,\nwhich is useful during development.\n\nStand-Alone Web Client\n======================\n\nAs mentioned, Gnotty can also be run as a stand-alone web client\nwithout using Django at all. In this mode, only the web interface to\nthe IRC channel is provided, along with whichever IRC bot class is\nconfigured. Message logging can be configured using standard handlers\nfor the ``logging`` module in Python's standard library.\n\nOnce installed, the command ``gnottify`` should be available on your\nsystem, and all of the options described earlier can be provided as\narguments to it::\n\n $ gnottify --help\n Usage: gnottify [options]\n\n Options:\n --version show program's version number and exit\n -h, --help show this help message and exit\n -a HOST, --http-host=HOST\n HTTP host address to serve from\n [default: 127.0.0.1]\n -p PORT, --http-port=PORT\n HTTP port to serve from\n [default: 8080]\n -A HOST, --irc-host=HOST\n IRC host address to connect to\n [default: irc.freenode.net]\n -P PORT, --irc-port=PORT\n IRC port to connect to\n [default: 6667]\n -C CHANNEL, --irc-channel=CHANNEL\n IRC channel to join\n [default: #gnotty]\n -K CHANNEL_KEY, --irc-channel-key=CHANNEL_KEY\n Optional key required to access the IRC channel\n -c DOTTED_PYTHON_PATH, --bot-class=DOTTED_PYTHON_PATH\n Dotted Python path to the IRC client bot class to run\n [default: gnotty.bots.LoggingBot]\n -n NICKNAME, --bot-nickname=NICKNAME\n IRC nickname the bot will use\n [default: gnotty]\n -x PASSWORD, --bot-password=PASSWORD\n Optional IRC password for the bot\n [default: None]\n -D, --daemon run in daemon mode\n -k, --kill Shuts down a previously started daemon\n -F FILE_PATH, --pid-file=FILE_PATH\n path to write PID file to when in daemon mode\n -l INFO|DEBUG, --log-level=INFO|DEBUG\n Log level to use. DEBUG will spew out all IRC\n data.\n [default: INFO]\n -f FILE_PATH, --conf-file=FILE_PATH\n path to a Python config file to load options from\n\nNote the final argument in the list, ``--conf-file``. This can be used\nto provide the path to a Python config module, that contains each of\nthe settings described earlier. Any options provided via command-line\narguments will take precedence over any options defined in the Python\nconfiguration module.\n\n\nDaemon Mode\n===========\n\nGnotty can be configured to run as a background process when the\n``GNOTTY_DAEMON`` setting is set to ``True`` (the ``--daemon`` arg\nwhen running stand-alone). When in daemon mode, Gnotty will write its\nprocess ID to the absolute file path specfified by the\n``GNOTTY_PID_FILE`` setting (the ``--pid-file`` arg when running\nstand-alone). If the PID file path is not configured, Gnotty will use\na file name based on the HTTP host and port, in your operating\nsystem's location for temporary files.\n\nWhen run in daemon mode, Gnotty will check for an existing PID file\nand if found, will attempt to shut down a previously started server\nwith the same PID file.\n\n\nIRC Bots\n========\n\nWhen running, Gnotty hosts an IRC bot that will connect to the\nconfigured IRC channel. The ``gnotty.bots.BaseBot`` bot is run by\ndefault, which implements message logging and support for commands\nissued within the IRC channel, and webhooks, which allow the IRC\nbot to receive data over HTTP.\n\nYou can implement your own IRC bot simply by subclassing\n``gnotty.bots.BaseBot`` and defining the Python dotted path to it on\nstartup, via the ``GNOTTY_BOT_CLASS`` setting (the ``--bot-class`` arg\nwhen running stand-alone).\n\nThe ``gnotty.bots.BaseBot`` class is derived from the third-party\n``irclib`` package's ``irc.client.SimpleIRCClient`` class (and\ntranslated into a Python new-style class for sanity). The IRC\nbot will have all of the same methods and events available as the\n``SimpleIRCClient`` class.\n\nThese are the built-in IRC bot classes provided by the\n``gnotty.bots`` package:\n\n * ``gnotty.bots.BaseBot`` - The default bot class that implements\n logging and handling for commands and webhooks. Your custom bot\n should subclass this.\n * ``gnotty.bots.ChatBot`` - A bot that demonstrates interacting with\n the IRC channel by greeting and responding to other users.\n Requires the ``nltk`` package to be installed.\n * ``gnotty.bots.commits.CommitMixin`` - A base bot mixin for\n receiving commit information for version control systems via bot\n webhooks, and relaying the commits to the IRC channel. Used as the\n base for the ``GitHubBot`` and ``BitBucketBot`` bots.\n * ``gnotty.bots.GitHubBot`` - ``CommitMixin`` subclass for\n `GitHub `_\n * ``gnotty.bots.BitBucketBot`` - ``CommitMixin`` subclass for\n `Bitbucket `_\n * ``gnotty.bots.CommandBot`` - A bot that implements a handful\n of basic commands that can be issued by users in the channel.\n * ``gnotty.bots.RSSBot`` - A bot that watches RSS feeds and posts\n new items from them to the IRC channel.\n * ``gnotty.bots.Voltron`` - All of the available bots, merged into\n one `super bot `_.\n\nTake a look at the source code for the ``gnotty.bots`` package. You'll\nsee that the different features from all of the available bots are\nimplemented as mixins, which you can mix and match together when\nbuilding your own bot classes.\n\n\nBot Events\n==========\n\nGnotty's IRC bots make use of an event handling system. Event handlers\nare implemented as methods on any of the classes used to build a bot.\nEach event handler gets wrapped with the decorator\n``gnotty.bots.events.on``, which takes a single positional argument for\nthe event name and marks the method as being a handler for that event.\nThe decorator may also accept optional keyword arguments depending on\nthe type of event. Several types of events are available:\n\n * IRC channel events, as implemented by the ``irclib`` package's\n ``irc.client.SimpleIRCClient`` class.\n * IRC commands, which are custom commands that can be triggered by\n users in the IRC channel. Each of these take a ``command`` keyword\n argument, which defines the command name.\n * Timer events, which are handlers that are periodically run at a\n defined time interval. Each of these take a ``seconds`` keyword\n argument, which defines the time interval.\n * Webhooks, which are handlers that accept data over HTTP. Each of\n take a ``urlpattern`` keyword argument which defines a regular\n expression to match against the webhook's URL, similar to Django's\n ``urlpatterns``.\n\nHere's an example IRC bot that implements all the above event types::\n\n from gnotty.bots import BaseBot, events\n\n class MyBot(BaseBot):\n\n @events.on(\"join\")\n def my_join_handler(self, connection, event):\n \"\"\"IRC channel event - someone joined the channel.\"\"\"\n nickname = self.get_nickname(event)\n self.message_channel(\"Hello %s\" nickname)\n\n @events.on(\"timer\", seconds=10)\n def my_timer(self):\n \"\"\"Do something every 10 seconds.\"\"\"\n msg = \"Another 10 seconds has passed, are you annoyed yet?\"\n self.message_channel(msg)\n\n @events.on(\"command\", command=\"!time\")\n def my_time_command(self, connection, event):\n \"\"\"Write the time to the channel when someone types !time\"\"\"\n from datetime import datetime\n return \"The date and time is %s\" % datetime.now()\n\n @events.on(\"webhook\", urlpattern=\"^/webhook/do/something/$\")\n def my_webhook_handler(self, environ, url, params):\n \"\"\"Tell the channel that someone hit the webhook URL.\"\"\"\n ip = environ[\"REMOTE_ADDR\"]\n self.message_channel(\"The IP %s hit the URL %s\" (ip, url))\n\nGiven the above class in an importable Python module named ``my_bot.py``,\nGnotty can be started with the bot using the following arguments::\n\n $ gnottify --http-host=127.0.0.1 --http-port=8000 --bot-class=my_bot.MyBot\n\n\nChannel Events\n==============\n\nAs described above, each of the IRC channel events implemented by the\n``irclib`` package's ``irc.client.SimpleIRCClient`` class are available\nas event handlers for an IRC bot. Consult the ``irclib`` docs or source\ncode for details about each of the IRC channel events that are\nimplemented, as documenting all of these is beyond the scope of this\ndocument. Here are some of the common events to get you started:\n\n - ``events.on(\"welcome\")``: Bot has connected to the server but not\n yet joined the channel.\n - ``events.on(\"namreply\")``: Bot receives the initial list of\n nicknames in the channel once joined.\n - ``events.on(\"join\")``: Someone new joined the channel.\n - ``events.on(\"quit\")``: Someone left the channel.\n - ``events.on(\"pubmsg\")``: A message was sent to the channel.\n\nEach of the channel events receive a ``connection`` and ``event``\nargument, which are objects for the connection to the IRC server, and\ninformation about the event that occurred.\n\n\nCommand Events\n==============\n\nEvent handlers for simple commands can be implemented using the\n``command`` event name for the ``gnotty.bots.events.on`` decorator.\nThe decorator then takes a ``command`` keyword argument, which is the\ncommand name itself. Command events are then triggered by any public\nmessages in the channel that contain the command name as the first word\nin the message. Each subsequent word in the message after the command\nis then passed as a separate argument to the event handler method for\nthe command. In each command event handler method, the bot can then\nperform some task, and return a message back to the channel.\n\n\nTimer Events\n============\n\nThese event handlers are defined using the ``timer`` event name for the\n``gnotty.bots.events.on`` decorator, and simply run repeatedly at a\ngiven interval. A ``seconds`` keyword argument to the decorator defines\nthe interval in seconds as an integer. Note that the ``seconds``\nkeyword argument is used to ``sleep`` after each time the event handler\nis run, in order to implement the interval, so an interval of 30\nseconds won't necessarily run precisely twice per minute, since the\nevent handler itself will take time to execute, particularly if it\naccesses external resources over a network.\n\n\nWebhook Events\n==============\n\nIRC bots run by Gnotty contain the ability to receive data over HTTP\nvia webhooks. Webhooks are methods defined on the bot class with the\n``webhook`` event handler name specified for the\n``gnotty.bots.events.on`` decorator. The decorator also requires a\n``urlpattern`` keyword argument, which is a regular expression for\nmatching the webhook URL.\n\nThe gevent web server will intercept any URLs prefixed\nwith the path ``/webhook/``, and pass the request onto the bot which\nwill match the URL to any of the URL patterns defined by webhook event\nhandlers on the running bot class. A webhook event handler receives\nthe following arguments:\n\n * ``environ`` - The raw environment dict supplied by the gevent web\n server that contains all information about the HTTP request.\n * ``url`` - The actual URL accessed.\n * ``params`` - A dictionary containing all of the POST and GET data.\n\nNote that the ``url`` and ``params`` arguments are simply provided for\nextra convenience, as their values (and all other environment\ninformation) are already available via the ``environ`` argument.\n\n\nMessage Logging\n===============\n\nBy default, each IRC message in the channel is logged by the IRC bot\nrun by Gnotty. Logging occurs using `Python's logging module\n`_, to the logger named\n``irc.message``.\n\nEach log record contains the following attributes, where ``record`` is\nthe log record instance:\n\n * ``record.server`` - The IRC server the message occurred on.\n * ``record.channel`` - The IRC channel the message occurred on.\n * ``record.nickname`` - The nickname of the user who sent the\n message.\n * ``record.msg`` - The actual message string itself.\n * ``record.join_or_leave`` - ``True`` if the record was for a user\n joining or leaving the channel, otherwise ``False``.\n\nHere's an example of adding an extra logging handler for IRC messages::\n\n from logging import getLogger, StreamHandler\n\n class MyLogHandler(StreamHandler):\n def emit(self, record):\n # Do something cool with the log record.\n print record.msg\n\n getLogger(\"irc.message\").addHandler(MyLogHandler())\n\n\nJavaScript Client\n=================\n\nThe web client that Gnotty provides includes all the necessary\nJavaScript files for communicating with the WebSocket server, such as\nDouglas Crockford's ``json2.js``, and the ``socket.io.js`` library\nitself. Also provided is the file ``gnotty.js`` which implements a\ncouple of public functions used by the web interface. The first is the\n``gnotty`` JavaScript function, which deals directly with the HTML\nstructure of the chat template::\n\n // Start up the default UI. This function isn't very\n // interesting, since it's bound to the HTML provided\n // by Gnotty's chat template.\n gnotty({\n httpHost: '127.0.0.1',\n httpPort: '8080',\n ircHost: 'irc.freenode.net',\n ircPort: '6667',\n ircChannel: '#gnotty'\n });\n\nThe second interface is the ``IRCClient`` function. This is of\nparticular interest if you'd like to create your own chat interface,\nas it deals exclusively with communication between the web browser and\nthe WebSocket server. Here's an example client that simply writes\nevents out to the console::\n\n // Prompt the user for a nickname and password,\n // and create an IRC client.\n var client = new IRCClient({\n httpHost: '127.0.0.1',\n httpPort: '8080',\n ircHost: 'irc.freenode.net',\n ircPort: '6667',\n ircChannel: '#gnotty',\n ircNickname: prompt('Enter a nickname:')\n ircPassword: prompt('Enter a password (optional):')\n });\n\n // When the client first joins the IRC channel,\n // send a message to the channel to say hello.\n client.onJoin = function() {\n console.log('joined the channel');\n client.message('Hello, is it me you\\'re looking for?');\n };\n\n // When someone joins or leaves the channel, we're given the\n // entire user list. It'a an array of objects, each with a\n // nickname and color property.\n client.onNicknames = function(nicknames) {\n nicknames = $.map(nicknames, function(obj) {\n return obj.nickname;\n }).join(', ');\n console.log('The user list changed, here it is: ' + nicknames);\n });\n\n // Whenever a message is received from the channel, it's an\n // object with nickname, message and color properties.\n client.onMessage = function(data) {\n console.log(data.nickname + ' wrote: ' + data.message);\n });\n\n // When we leave, reload the page.\n client.onLeave = function() {\n location.reload();\n };\n\n // The IRC server rejected the nickname.\n client.onInvalid = function() {\n console.log('Invalid nickname, please try again.');\n };\n\nAs you may have guessed, the server-side settings configured for\nGnotty are passed directly into the ``gnotty`` JavaScript function,\nwhich then creates its own ``IRCClient`` instance.\n\nYou'll also see the data sent to the ``onMessage`` and ``onNickname``\nevents contain color values that the interface can use for colorizing\nnicknames. These are calculated on the server, so that both the chat\ninterface and message archive produce consistent colors every time\na particular nickname is displayed.\n\n\nHosting Private Chat Rooms\n==========================\n\nCreating a private login-protected chat room for your team members\nto collaborate on is a breeze using Gnotty. By setting the\n``GNOTTY_LOGIN_REQUIRED`` setting to ``True``, Gnotty will require\neach user to have a Django user account which they can authenticate\nwith. The following steps should get you started:\n\n * Create a Django project with Gnotty installed, using the steps\n described above under `Django Integration`. Take a look at the\n ``example_project`` directory within Gnotty, which contains a\n working Django project with Gnotty configured.\n * Install an IRC server such as `ngIRCd `_.\n ngIRCd can be installed on both Linux or OSX with a single command\n (this works great for local development on OSX). Be sure to\n configure ngIRCd to only allow local connections, so that only\n Gnotty can connect to it.\n\nWith the above setup, all that is then needed are the following\nGnotty settings configured in your Django project's ``settings.py``\nmodule::\n\n GNOTTY_IRC_HOST = \"127.0.0.1\"\n GNOTTY_LOGIN_REQUIRED = True\n GNOTTY_IRC_CHANNEL = \"#mychannel\" # This can be anything really.", "description_content_type": null, "docs_url": null, "download_url": "UNKNOWN", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "http://github.com/stephenmcd/gnotty", "keywords": null, "license": "BSD", "maintainer": null, "maintainer_email": null, "name": "Gnotty", "package_url": "https://pypi.org/project/Gnotty/", "platform": "UNKNOWN", "project_url": "https://pypi.org/project/Gnotty/", "project_urls": { "Download": "UNKNOWN", "Homepage": "http://github.com/stephenmcd/gnotty" }, "release_url": "https://pypi.org/project/Gnotty/0.2.7/", "requires_dist": null, "requires_python": null, "summary": "Gnotty ties the knot between the web and IRC. It is a web client and message archive for IRC.", "version": "0.2.7" }, "last_serial": 1727450, "releases": { "0.1.0": [ { "comment_text": "", "digests": { "md5": "b14aaee021720695be145607ec86eda5", "sha256": "c1a39c5f2b3b23f0beb5160a8e08ec69cce0570ac2ac067c89180de3e7400764" }, "downloads": -1, "filename": "Gnotty-0.1.0.tar.gz", "has_sig": false, "md5_digest": "b14aaee021720695be145607ec86eda5", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 301083, "upload_time": "2012-11-18T05:49:56", "url": "https://files.pythonhosted.org/packages/69/ad/712a1c15026c531d4b899baa8aad247fe451820c81c540c46a9e03a61c4b/Gnotty-0.1.0.tar.gz" } ], "0.2.0": [ { "comment_text": "", "digests": { "md5": "e6fbc2a418867cf3ad09e65b2ec99b7c", "sha256": "6db64a3bb38c447baee992be5608eac4edc6820faa06405f703c91e73ebe38ff" }, "downloads": -1, "filename": "Gnotty-0.2.0.tar.gz", "has_sig": false, "md5_digest": "e6fbc2a418867cf3ad09e65b2ec99b7c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 508142, "upload_time": "2012-12-25T05:43:16", "url": "https://files.pythonhosted.org/packages/80/83/7e22ef34e702bc2f098d4a9ffeb5d926fe62799e821d98ba6f2cdd53c4e5/Gnotty-0.2.0.tar.gz" } ], "0.2.1": [ { "comment_text": "", "digests": { "md5": "e4d5c47f75ff95c2d6a833ba207a97c7", "sha256": "5548351cb33b398e43e0556647ed7dad057ba96c2f92329bc727eac35e0b0c4f" }, "downloads": -1, "filename": "Gnotty-0.2.1.tar.gz", "has_sig": false, "md5_digest": "e4d5c47f75ff95c2d6a833ba207a97c7", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 508497, "upload_time": "2013-01-27T13:27:05", "url": "https://files.pythonhosted.org/packages/da/d3/a6c7efd1ff7e1c870f3f8d6821d36b8fe4ba3c2d21044d31952448614ccc/Gnotty-0.2.1.tar.gz" } ], "0.2.2": [ { "comment_text": "", "digests": { "md5": "22266e85dba6ec99dd506cff075d7196", "sha256": "25e8959efea0514203ca4ef370129a9386c2b00a52f16e4168a8eeefcca05807" }, "downloads": -1, "filename": "Gnotty-0.2.2.tar.gz", "has_sig": false, "md5_digest": "22266e85dba6ec99dd506cff075d7196", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 508952, "upload_time": "2013-02-17T09:03:36", "url": "https://files.pythonhosted.org/packages/07/1d/250ba8885d7a4509be0395ef37834bce053dbc337b61b1891ade98960017/Gnotty-0.2.2.tar.gz" } ], "0.2.3": [ { "comment_text": "", "digests": { "md5": "b239cc7eccf305594d0efca696dc0edd", "sha256": "60694e8f8a08bff72a8feeee16cf9cf734fd81f88ecee56a29f8098335dd0e99" }, "downloads": -1, "filename": "Gnotty-0.2.3.tar.gz", "has_sig": false, "md5_digest": "b239cc7eccf305594d0efca696dc0edd", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 509191, "upload_time": "2013-02-23T09:25:16", "url": "https://files.pythonhosted.org/packages/56/23/af36773281c2341dec16c9e3a91f2d07ab190077e9520915a4bcced2b60a/Gnotty-0.2.3.tar.gz" } ], "0.2.4": [ { "comment_text": "", "digests": { "md5": "06106846abf1c0e5dafed80cedf199e9", "sha256": "2b570eee051061b75334210fac4f9efd12ae20709a2924b0f17b4dbc94bc7e0e" }, "downloads": -1, "filename": "Gnotty-0.2.4.tar.gz", "has_sig": false, "md5_digest": "06106846abf1c0e5dafed80cedf199e9", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 293465, "upload_time": "2013-03-06T23:29:17", "url": "https://files.pythonhosted.org/packages/80/54/f29679d2ba2261f5c48d28f898336efd1af15bfd3e91d809e7a5fd99ecdd/Gnotty-0.2.4.tar.gz" } ], "0.2.5": [ { "comment_text": "", "digests": { "md5": "571867075b33523f513706e91d5f36cc", "sha256": "a186500dc5cee40b07ebccfbd525537b5abc850982b50801343d17e220534c01" }, "downloads": -1, "filename": "Gnotty-0.2.5.tar.gz", "has_sig": false, "md5_digest": "571867075b33523f513706e91d5f36cc", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 565120, "upload_time": "2013-03-30T01:55:38", "url": "https://files.pythonhosted.org/packages/34/9b/3cd8219be396033601aed7df3e1ddc27de5bd8bab07afd26649dc47c622d/Gnotty-0.2.5.tar.gz" } ], "0.2.6": [ { "comment_text": "", "digests": { "md5": "c60685f2ab0a8e1c47b3cefa20ec19fb", "sha256": "41c08866f1650dc523d025d84da56d4521ffd36d821dded1f1741ce7f8859e52" }, "downloads": -1, "filename": "Gnotty-0.2.6.tar.gz", "has_sig": false, "md5_digest": "c60685f2ab0a8e1c47b3cefa20ec19fb", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 299106, "upload_time": "2014-02-20T09:38:45", "url": "https://files.pythonhosted.org/packages/f5/7c/54d2cdf3f859ab4142c8577342df30615167cd5e499b2f349c475648954f/Gnotty-0.2.6.tar.gz" } ], "0.2.7": [ { "comment_text": "", "digests": { "md5": "cfbd433c854529ea554017a63b9c07ed", "sha256": "f1e76390fa5007b14d9fdf25c2e244af25c850ec936bff7e11fe01a0816be2ee" }, "downloads": -1, "filename": "Gnotty-0.2.7.tar.gz", "has_sig": false, "md5_digest": "cfbd433c854529ea554017a63b9c07ed", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 293444, "upload_time": "2015-09-17T23:42:11", "url": "https://files.pythonhosted.org/packages/ea/f8/efd496dae831d71ab701b337957a4c0494a03d0961c919ad3ca8fa08dee8/Gnotty-0.2.7.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "cfbd433c854529ea554017a63b9c07ed", "sha256": "f1e76390fa5007b14d9fdf25c2e244af25c850ec936bff7e11fe01a0816be2ee" }, "downloads": -1, "filename": "Gnotty-0.2.7.tar.gz", "has_sig": false, "md5_digest": "cfbd433c854529ea554017a63b9c07ed", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 293444, "upload_time": "2015-09-17T23:42:11", "url": "https://files.pythonhosted.org/packages/ea/f8/efd496dae831d71ab701b337957a4c0494a03d0961c919ad3ca8fa08dee8/Gnotty-0.2.7.tar.gz" } ] }