I wrote a script which invokes ffmpeg and convert commands to create the gif file.
usage: output.gif input.mp4 [--fps fps]

#!/usr/bin/env python

import sys
import os
import commands

def make_gif(input_f, output_f, fps):
  tmp = os.path.join('.', 'tmp');
  if not os.path.exists(tmp):
    os.mkdir(tmp)
  to_jpg(tmp, input_f, fps)  
  to_gif(tmp, output_f, fps)  
  clean(tmp)  

def to_jpg(tmp, input_f, fps):
  cmd = 'ffmpeg -i ' + input_f + ' -r ' + str(fps) + ' ' + os.path.join(tmp, 'f%04d.jpg')  
  print 'dumping:', cmd
  (status, output) = commands.getstatusoutput(cmd)
  if status:
    sys.stderr.write(output)
    sys.exit(status)
  print output

def to_gif(tmp, output_f, fps):
  cmd = 'convert -delay ' + str(100/fps) + ' -loop 0 '  + os.path.join(tmp, '*.jpg') + ' ' + output_f
  print 'creating gif:', cmd
  (status, output) = commands.getstatusoutput(cmd)
  if status:
    sys.stderr.write(output)
    sys.exit(status)
  print output

def clean(tmp):
  cmd = 'rm -rf '+ tmp
  print 'cleaning:', cmd
  (status, output) = commands.getstatusoutput(cmd)
  if status:
    sys.stderr.write(output)
    sys.exit(status)
  print output

def num(s):
  try:
    return int(s)
  except ValueError:
    return 0

def main():
  args = sys.argv[1:]
  if not args:
    print "usage: output.gif input.mp4 [--fps fps]";
    sys.exit(1)
  
  if len(args)  1 and args[0] == '--fps':
    fps = num(args[1])
    if fps == 0:
      fps = 5
    del args[0:2]

  print 'Converting',input_f,'to',output_f,'with',fps,'fps'
  make_gif(input_f, output_f, fps)

if __name__ == "__main__":
  main()

The script can be found on github.

I wrote a python script to connect to my pi radio and invoke stop or start command to play radio stream.
usage: {start|stop} [--url url] [--ip ip] [--port port]

#!/usr/bin/env python

import sys
from mpd import MPDClient

def connect(ip, port):
  client = MPDClient()
  client.timeout = 60     # network timeout in seconds (floats allowed), default: None
  client.idletimeout = None
  client.connect(ip, port)
  return client

def stop(ip, port):
  client = connect(ip, port)
  client.clear()
  return client

def play(ip, port, url):
  client = stop(ip, port)  
  client.add(url)
  client.play()

def num(s):
  try:
    return int(s)
  except ValueError:
    return 0

def main():
  args = sys.argv[1:]
  if not args:
    print "usage: {start|stop} [--url url] [--ip ip] [--port port]";
    sys.exit(1)

  start = False
  if args[0] == 'start':
    start = True
  elif args[0] == 'stop':
    start = False
  else: 
    print 'command {start|stop} not specified'
    sys.exit(1)
  del args[0]
  
  url = 'http://stream4.nadaje.com:8002/muzo'
  if args and args[0] == '--url':
    url = args[1]
    del args[0:2]
  
  ip = '192.168.0.3'
  if args and args[0] == '--ip':
    ip = args[1]
    del args[0:2]
  
  port = 6600
  if args and args[0] == '--port':
    port = num(args[1])
    del args[0:2]

  print 'Connecting to mpd server:',ip,':',port
  if start:
    print 'Playing: ', url
    play(ip, port, url)
  else:  
    print 'Stopping'
    stop(ip, port)

if __name__ == "__main__":
  main()

The script can be found on github.

I wrote a Python script to check the channels of the surrounding wifi networks. Recently I was facing some issues with the quality of signal so I decided to check what’s going on with the help of the powerful linux tool. In scanning mode iwlist provides huge amount of information but in fact I just needed to know which networks occupied which channels. So I wrote an analyser which reads in standard input (e.g. using pipe) the output of iwlist.
usage: iwlist wlp3s0 scan |./analyser.py

The analyser lists the channels with frequency and below the names, link qualities and signal power of the networks using this channel:

		name:               	quality:  	power:    
Channel: 1 (2.412 GHz)
		Name18272346        	36/70     	-74 dBm   
		Name20053835        	27/70     	-83 dBm   
		Name3742A1          	26/70     	-84 dBm   
		Name4123456         	25/70     	-85 dBm   
		Name57005901        	23/70     	-87 dBm   
		Name6D2A47          	22/70     	-88 dBm   
Channel: 11 (2.462 GHz)
		Name119496          	50/70     	-60 dBm   
		Name20682504        	39/70     	-71 dBm   
Channel: 13 (2.472 GHz)
		Name10682504          	38/70     	-72 dBm   
Channel: 52 (5.26 GHz)
		Name10682504        	32/70     	-78 dBm

#!/usr/bin/python

import sys
import re

def num(s):
  try:
    return int(s)
  except ValueError:
    return 0
  
def first(x):
  match = re.search(r'Channel: (\d+)', x)
  if match:
    return num(match.group(1))
  return x

def last(x):
  power = x[2]  
  match = re.search(r'-(\d+) dBm', power)
  if match:
    return match.group(1)  
  return power
  
def print_cells(cells):
  sorted_cells = sorted(cells, key=last)  
  for cell in sorted_cells:
    print '\t\t','\t'.join(cell)

def process_channels(channels):
  print_cells([(crop('name:', 20), crop('quality:', 10), crop('power:', 10))])
  sorted_keys = sorted(channels, key=first)
  for channel in sorted_keys:
      print channel
      print_cells(channels[channel])

def crop(name, chars):
  if len(name) > chars:  
    return name[:chars]
  else:
    return name.ljust(chars)

def main():
  channels = {}
  channel = ''
  name = ''
  quality = ''
  level = ''
  for line in sys.stdin:
    to_add = False
    match = re.search(r'Frequency:(.+) GHz \(Channel (\d+)\)', line)
    if match:
      channel = 'Channel: '+ match.group(2) + ' ('+ match.group(1)+' GHz)'
      name = ''
      quality = ''
      level = ''
    match = re.search(r'Quality=(\S+)\s+Signal level=(.+) dBm', line)
    if match:
      quality = crop(match.group(1), 10)
      level = crop(match.group(2) + ' dBm', 10)
    match = re.search(r'ESSID:"(.+)"', line)
    if match:
      name = crop(match.group(1), 20)
      to_add = True

    if to_add:
      if channel in channels:
        channels[channel].append((name, quality, level))
      else:
        channels[channel] = [(name, quality, level)]  

  process_channels(channels)
    
if __name__ == "__main__":
  main()

The script can be found on github.

I wrote a simple script to fast check open ports in my local network. This script skips the VPN connections.

Usage:
usage: [--max ip] port [port ...]
where:
ip is the maximum ip to scan

#!/usr/bin/python

import socket
from netifaces import interfaces, ifaddresses, AF_INET
import re
import sys

def get_my_ip():
  result = []
  print 'retrieving ip addresses ...'
  for ifaceName in interfaces():
    addresses = [i['addr'] for i in ifaddresses(ifaceName).setdefault(AF_INET, [{'addr':'No IP addr'}] )]
    if not addresses:
      continue;
    address = addresses[0]
    if address == 'No IP addr':
      continue
    if ifaceName == 'lo':
      print 'Skip local: ', address
      continue
    match = re.search(r'tap', ifaceName)
    if match:
      print 'Skip vpn: ', address
      continue
    result.append(address)
  print 'found:',', '.join(result)
  return result

def check_ips(ip, maxip, ports):
  match = re.search(r'(\d+.\d+.+\d+).\d+', ip)
  if match:
    ip_base = match.group(1)
    ip_base = ip_base+'.'
    ports_str = ', '.join(str(x) for x in ports)
    print 'checking network: ',ip_base+'1-'+str(maxip)+':'+ports_str
    for i in range(1,maxip):
      ip_to_check = ip_base+str(i)
      check_ip_ports(ip_to_check, ports)

def check_ip_ports(ip, ports):
  for port in ports:
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    result = sock.connect_ex((ip,port))
    if result:
      continue
    print 'Ip:', ip, 'has open port', port

def num(s):
  try:
    return int(s)
  except ValueError:
    return 0

def main():
  args = sys.argv[1:]
  if not args:
    print "usage: [--max ip] port [port ...]";
    sys.exit(1)

  maxip = 0
  if args[0] == '--max':
    maxip = num(args[1])
    del args[0:2]

  if not maxip:
    maxip = 255

  if len(args) == 0:
    print "error: must specify one or more ports"
    sys.exit(1)

  ports = []
  for arg in args:
    port = num(arg)
    if port:
      ports.append(port)

  if len(ports) == 0:
    print "error: must specify one or more ports"
    sys.exit(1)

  ips = get_my_ip();
  for ip in ips:
    check_ips(ip, maxip, ports)  

if __name__ == "__main__":
  main()

The script can be found on github.