ImportError: No module named 'click.repository'

It's most likely because you also have the ubuntu-sdk PPA installed, and a new version of python3-click has been pushed up that doesn't include the repository submodule that Snappy uses. I found unravelling the two project's dependencies to be non-trivial at the moment, so here's an alternative quick fix:

1. Run:

   sudo apt purge -y python3-click

2. Create a new file at /etc/apt/preferences.d/snappy-ppa-1500, with these contents (telling apt that we prefer duplicate packages from the snappy-dev PPA).

3. Run:

   sudo apt update

4. Run:

   sudo apt install -y --force-yes snappy-tools

For the time being this should select the packages we need from the snappy-dev PPA, and giving us the right python3-click, complete with repository submodule.

The other alternative is to confine your Snappy experiments to an LXC or VM; or completely purge both PPAs and all the packages from them and reinstall just Snappy if you don't care about Ubuntu Touch or regular click package dev right now.
I'm sure the conflict will be fixed soon though. :-)

Deployments of a service have a number of different network dependencies that require verification:

• Connections between services (e.g. app <-> postgresql, are ports unblocked at the firewall(s)? If talking to a data centre instance do we have a route?)
• External services (e.g. webservices such as S3)
• Verification that the services on the other end are real (you're actually talking to MongoDB or rabbitmq via AMQP, not just another TCP service running on those ports)
• Verification of authentication

Although many of these can be solved with smoke tests, it's not always immediately obvious that there is a problem, or what the problem is.

Our solution

conn-check is a tool that started life inside Ubuntu One to verify connections between services and to S3 etc. post-deploy.
During a mini-sprint in Uruguay a few months ago we separated conn-check into it's own own package and open sourced it.
Since then we've been improving it and using it to verify deploys on our services (such as login.ubuntu.com).

conn-check takes a simple YAML config defining a list of checks to perform (udp, tcp, tls, http, amqp, postgres, mongodb, redis, memcache), and performs those checks asynchronously using Twisted's thread pool, and outputs the results in a Nagios check standard output, so conn-check can be run regulary as a Nagios check to continually verify network status between services (and alert on change, e.g. out of band firewall changes).

Automatically generating configs

We have also released a separate package called conn-check-configs which provides tools for automatically generating conn-check YAML configs from a source such as a Django settings module or Juju environment status (we're currently using the Django settings export, with Juju env export being tested in a branch).

Getting conn-check

You can get conn-check by:

• Installing from PyPI:

pip install conn-check

(You can sudo this to get it system installed, but personally I'd put it in a virtualenv or use pipsi.)

• Installing with apt-get from my PPA:

sudo add-apt-repository ppa:wesmason/conn-check
sudo apt-get update
sudo apt-get install conn-check

• If you use Juju to manage your infrastructure/deployments, then you can use our charm to deploy conn-check for your service (and even add Nagios checks automatically via the nrpe relation).

Expect to hear soon about some of the things I've been working on.

• West Yorkshire Python User Group Meeting - Thurs 9th
• Atmosphere 2013 - Mon 13th / Tues 14th
• DevOpsDays Berlin - Tues 28th

If you fancy following along head on over and subscribe, or follow me on twitter where I will also post links to freshly archived mailshots.

Normally this would have been the end of my quick perusal, until the next time I had reason to the use the service, but I noticed they had not only an API, but also Jabber/XMPP exposure for creating bots. Now my interest was piqued.**Looking at the existing third-party bots out there I found you had your choice of languages…as long as that choice was Ruby or Javascript. ;-)

Now I'm not averse to developing in either, but they're not my preferred languages by far (okay Javascript has a soft spot in my heart but I still haven't made the jump to server-side JS dev).

So with that I present hippybot
(Hip**chat Python Bot, geddit?)
Not to be confused with Hippy, a PHP library for the Hipchat API.

I wrote hippybot using the excellent python-jabberbot, a library that utilises the equally brilliant xmpppy to allow the creation of bots in an easy to understand and pythonic way (e.g. inherit from base class, set some connection strings, override event methods if need be, use decorators to extend commands the bot responds to).

How is this different from a regular Jabber bot? I've written some Hipchat-specific customisations into the bot:

• The connection config assumes Hipchat's XMPP server, and various details such as the username and channel names have Hipchat specific [pre/suf]fixes added to them automatically.
• The bot "understands" at-sign mentions (e.g. those popularised by Twitter and supported by Hipchat for directing messages to specific people within rooms, as well as triggering notifications), and commands added by plugins can leverage this.

I've added a simple plugin API to the bot, which consists of either creating a function in a module with a decorator, or a class in a module with as many decorated methods (each a different command to trigger the bot) as you like, and the ability to create aliases for commands and define whether a command is triggered by an at-sign mention or not (e.g. @hippybot do something!).

In the next release I plan to add a simple wrapper to Hipchat's API (already in master), better at-sign mention handling, and some more core plugins.

Feel free to check it out and for an example of the sorts of things you can do with a bot like this just check out some of the things Github's hubot does.

A quick recap for the uninitiated: dfs is a set of utilities for generating the mark up and Django template code to display all the fields in a Django Form, e.g. the task of displaying each input element, label text and error message is still given to Django, but we display the markup around those elements in the template itself.

The library offers a few variants on the Form.as_* methods, which will output mark up similar to those methods.

New in v1.1.0:

• A README typo fix, spotted by Chris Matthews.
• A management command (formscaffold), based on a script submitted by Chris Matthews.
• Some fixes to the way form errors are generated for ModelForms.

To use the new management command just add 'dfs' to your settings.INSTALLED_APPS tuple and the command will become available.
It's used like so:

./manage formscaffold my_app.forms MyCustomForm as_p
# or if using buildout
bin/django formscaffold my_app.forms MyCustomForm as_p

The above would generate the form using

tags, for the class MyCustomForm located in the module/package my_app.forms.

Please note, if your form requires any setup (e.g. values passing to the constructor or the instance) the above won't work, as it just creates a base instance from the class and passes that to the helper, you can still use dfs to do this from a Django app shell though (using ./manage.py shell).

I'm wondering if switching to a static file generator system like Blogofile might help me be more productive with the place, reducing my workflow on 1stvamp.org down to a vim → git problem.

• Getting the name of the current view in a Django template
• Querying Webtrends analytics via ODBC with SQLAlchemy
• Writing interactive command line DB query tools with pyDBCLI
• Querying Webtrends ODBC from the command line with WebtrendsQT

It makes threads of tweets, so you can send a full conversation to someone else (or include it in another tweet) to people rather than copying and pasting half a dozen different URLs for each one.

As for how my speech is going, I’ve written over half of it, but I’m now considering re-writing what I’ve got as I’m just not sure if it’s the way I want to go.
Jonty has suggested I write a bunch, plus a markov chaining tool, and generate a speech. Of course he also suggested I include lyrics from The Fresh Prince Of Bel-Air.

Whatever I come up with in the end, I’m sure it’ll be fine, as long as I thank the right people and hit the right sentiments.

"Now, this is a story all about how
My life got flipped-turned upside down
And I’d like to take a minute
Just sit right there…"

• Who I am
• The “social web”, what’s thattabout den?
• Data mining, identity theft, social engineering, and digital forensics
• The case of the missing tweet
• Tools of the trade
• APIs, apps, loopholes & exploits
• Stalking Miss Daisy
• Outro

This is made possible by using the new late static binding and __callStatic magic method features. By using late static binding we can call a static method in the base ancestor class which assigns the lamba function passed in to a static hash of methods, indexed by the descendant class you called it via, using the new get_calling_class() function to get it’s class name and use that as the index.
We can use a separate hash of static methods to add static methods (which are just lambdas again) to the class by defining an extra __callStatic() magic method, that works just like the __call() method, but obviously for static calls.

test();// Should output:// default testecho ’2: ‘;$object->test(‘monkeys’);// Should output: monkeys testecho ’3: ‘;$object->test(‘chimps’);// Should output: chimps testecho ’4: ‘;$object2 = new MyOtherClass();// Should output: Instantiating “MyOtherClass”echo ’5: ‘;$object2->test();// Should output: default test2echo ’6: ‘;$object2->test(‘chimps’);// Should output: chimps test2echo ’7: ‘;$object2->test(‘conan’);// Should output: conan test2echo ’8: ‘;$object->test(‘conan’);// Should output: conan test?>

I’ve released OneVersion\DyanmicClass 1.0 out into the wild under the LGPL v2.1, so download and play at your own peril. ;-)

Effectively this is similar to traits/grafts, except you don’t have to define anything in a new class, you just extend the object itself when you come to use it.
You could also use a singleton within the Extensible class that keeps track of any added methods and propagates them to any other existing or new instances.

_methods, $name)) {                        call_user_func_array(array($this, $name), $args);                } else {                        throw new Exception(‘Unknown dynamic method ‘ . $name . ‘ called in class ‘ . get_class($this));                }        }        function __set($name, $value) {                if (is_callable($value)) {                        $this->_methods[$name] = $value;                }        }}class MyClass extends Extensible {        function test() {                echo ‘Non-dynamic method’;        }}$object = new MyClass();$object->test2 = function () {        echo ‘Dynamic method’;};// test() is defined within the static class definition$object->test();// test2() was created dynamically at runtime, but you call it just as// if it had been in the class definition$object->test2();?>

EDIT:
Incidentally this my first proper post sent via email. w00t.

Anyhoo, my latest project was finally released this weekend, memorised, a Python decorator for caching function/method results in memcached with very little faffing about (using the "memoize" pattern).
For a write up on memorised, take a gander at my post on the Isotoma blog.