"""
2012.1.25 CKS
Incremental calculation of both the mean and variance.
http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
"""
import unittest
 
## Dumb slow mean/variance formulas.
 
def mean(seq):
    return sum(seq)/float(len(seq))
 
def variance(seq):
    m = mean(seq)
    return sum((v-m)**2 for v in seq)/float(len(seq))
 
## Incremental mean/variance formulas.
 
class Stat(object):
 
    def __init__(self):
        self.mean_sum = 0
        self.mean_count = 0
        self.last_variance = 0
 
    def __iadd__(self, value):
        last_mean = self.mean
        self.mean_sum += value
        self.mean_count += 1
        if last_mean is not None:
            self.last_variance = self.last_variance + (value  - last_mean)*(value - self.mean)
        return self
 
    @property
    def mean(self):
        if self.mean_count:
            return self.mean_sum/float(self.mean_count)
 
    @property
    def variance(self):
        return self.last_variance/float(self.mean_count)
 
class Test(unittest.TestCase):
 
    def test(self):
        nums = range(1,7)
        s = Stat()
        for n in nums:
            s += n
            print 'mean:',s.mean
            print 'variance:',s.variance
        self.assertAlmostEqual(s.mean, mean(nums), 1)
        self.assertAlmostEqual(s.variance, variance(nums), 2)
 
if __name__ == '__main__':
    unittest.main()

from django.conf import settings
from django.test import TestCase
 
if settings.PERSIST_TEST_DATABASE:
    # Disable destruction of the test database.
    from django.db import transaction, connection, connections, DEFAULT_DB_ALIAS
    from django.test.testcases import restore_transaction_methods, connections_support_transactions
    connection.creation.destroy_test_db = lambda *args, **kwargs: None
 
class Test(TestCase):
 
    def _fixture_teardown(self):
        if not settings.PERSIST_TEST_DATABASE or not connections_support_transactions():
            return super(TestCase, self)._fixture_teardown()
 
        # If the test case has a multi_db=True flag, teardown all databases.
        # Otherwise, just teardown default.
        if getattr(self, 'multi_db', False):
            databases = connections
        else:
            databases = [DEFAULT_DB_ALIAS]
 
        restore_transaction_methods()
        for db in databases:
            transaction.commit(using=db)
            transaction.leave_transaction_management(using=db)

from django.contrib import admin
from django.contrib.admin.util import flatten_fieldsets
from django.contrib.auth.admin import UserAdmin as _UserAdmin
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404
 
class UserAdmin(_UserAdmin):
    _readonly_fields = [] # Default fields that are readonly for everyone.
 
    def get_readonly_fields(self, request, obj):
        readonly = list(self._readonly_fields)
        if request.user.is_staff and not request.user.is_superuser:
            if obj.is_superuser:
                # Prevent a staff user from editing anything of a superuser.
                readonly.extend(flatten_fieldsets(self.declared_fieldsets))
            else:
                # Prevent a non-superuser from editing sensitive security-related fields.
                readonly.extend(['is_staff', 'is_superuser', 'user_permissions', 'groups'])
        return readonly
 
    def user_change_password(self, request, id):
        # Disallow a non-superuser from changing the password of a superuser.
        user = get_object_or_404(self.model, pk=id)
        if not request.user.is_superuser and user.is_superuser:
            raise PermissionDenied
        return super(UserAdmin, self).user_change_password(request, id)
 
admin.site.unregister(User)
admin.site.register(User, UserAdmin)

#!/bin/bash
set -e
 
VOICE=en1
VLANG=english
 
# Install all required packages.
sudo apt-get install festival mbrola mbrola-${VOICE} esound-clients festlex-oald
 
# Download wrappers for mbrola voices.
cd ~/Desktop
wget http://www.cstr.ed.ac.uk/downloads/festival/1.95/festvox_${VOICE}.tar.gz
tar xvf festvox_${VOICE}.tar.gz
rm -f festvox_${VOICE}.tar.gz
 
# Copy MBROLA voices into Festival's voice directory.
sudo mkdir -p /usr/share/festival/voices/${VLANG}/${VOICE}_mbrola/${VOICE}
sudo mv festival/lib/voices/${VLANG}/${VOICE}_mbrola/* /usr/share/festival/voices/${VLANG}/${VOICE}_mbrola/
sudo cp /usr/share/mbrola/voices/${VOICE} /usr/share/festival/voices/${VLANG}/${VOICE}_mbrola/${VOICE}
 
# Cleanup.
rm -rf ~/Desktop/festival
 
# Test.
echo '(voice_'${VOICE}'_mbrola)(SayText "Installation complete!")' | esddsp festival --pipe

#!/bin/bash
set -e
 
echo "Drive Encrypter"
 
# Determine the device name.
mount # Display all mounted devices to help the user find the device name.
read -p "What is device name (e.g. /dev/<devicename>, from the mount list above)? " -e DEVICE
 
# Verify all required packages are installed.
echo "Checking packages..."
sudo apt-get install cryptsetup
sudo modprobe dm-crypt
 
# Overwrite with random data in order to slow down an attack on the encryption.
echo "Erasing device..."
umount /dev/$DEVICE
sudo badblocks -c 10240 -s -w -t random -v /dev/$DEVICE
 
echo "Creating encrypted partition..."
sudo cryptsetup --verbose --verify-passphrase luksFormat /dev/$DEVICE
sudo cryptsetup luksOpen /dev/$DEVICE $DEVICE
sudo mkfs.ext3 /dev/mapper/$DEVICE
sudo cryptsetup luksClose $DEVICE
 
echo "Done."
echo "Remove the drive and then plug it back in, and you should be prompted for a password to access the device."
#Note, you may have to run this to access the device from a normal account:
#sudo chown -R user:user /media/mountpoint

ssh-copy-id tunneluser@12.345.678.90

sudo /usr/sbin/useradd tunneluser
sudo /usr/sbin/usermod -a -G apache tunneluser
sudo passwd tunneluser
sudo mysql -e "GRANT USAGEG ON *.* TO tunneluser@localhost IDENTIFIED BY 'mysqlpassword';GRANT ALL PRIVILEGES ON *.* TO tunneluser@localhost;"

#!/bin/bash
# Simple script for remotely backing up all data on a webserver.
# Adapted from http://www.cyberciti.biz/faq/how-to-back-up-a-web-server/
 
# Define remote login.
SSHUSER="tunneluser"
SSHHOST="12.345.678.90"
 
# Define remote and local backup destinations.
LOCAL_BACKUP_ROOT="/var/backups"
NOW=$(date +"%F")
BACKUP_ROOT="/tmp/backup/$NOW"
BACKUP_FILENAME="backup-$SSHHOST-$NOW.tar.gz"
BACKUP_PATH="$BACKUP_ROOT/$BACKUP_FILENAME"
 
# Run a script on the remote host.
ssh -T $SSHUSER@$SSHHOST <<EOI
 
TERM=dumb
export TERM
 
# File directories to backup.
DIRS="/var/www/html/ /etc"
 
# Paths for binary files
TAR="/bin/tar"
PGDUMP="/usr/bin/pg_dump"
MYSQLDUMP="/usr/bin/mysqldump"
GZIP="/bin/gzip"
LOGGER="/usr/bin/logger"
 
# Set Pgsql username
PGSQLUSER="tunneluser"
 
# Set MySQL username and password
MYSQLUSER="tunneluser"
MYSQLPASSWORD="mysqlpassword"
 
# Backup file name hostname.time.tar.gz
BFILE="web.tar.gz"
PFILE="pg.sql.gz"
MFILE="mysql.sq.gz"
PKGFILE="installed-software.log"
 
# Store todays date.
NOW=\$(date +"%F")
echo \$NOW
 
# Store backup path.
BACKUP_ROOT="$BACKUP_ROOT"
[ ! -d \$BACKUP_ROOT ] && mkdir -p \${BACKUP_ROOT}
BACKUP_FILENAME="$BACKUP_FILENAME"
 
# Log backup start time in /var/log/messages
\$LOGGER "*** Backup started @ \$(date) ***"
 
# Backup package list.
echo "Backing up package list..."
rpm -qa > \${BACKUP}/\${PKGFILE} # Redhat
#dpkg --get-selections > \${BACKUP}/\${PKGFILE} # Debian
 
# Backup webserver directories.
echo "Backing up directories..."
\$TAR -zcf \${BACKUP_ROOT}/\${BFILE} \${DIRS}
 
# Backup PgSQL.
echo "Backing up PgSQL..."
\$PGDUMP -x -D -U\${PGSQLUSER} | \$GZIP -c > \${BACKUP_ROOT}/\${PFILE}
 
# Backup MySQL.
echo "Backing up MySQL..."
\$MYSQLDUMP -u \${MYSQLUSER} -h localhost -p\${MYSQLPASSWORD} --all-databases --lock-all-tables | \$GZIP -9 > \${BACKUP_ROOT}/\${MFILE}
 
# Create final file and cleanup.
echo "Cleaning up..."
\$TAR -zcf \${BACKUP_FILENAME} \${BACKUP_ROOT}/\${BFILE} \${BACKUP_ROOT}/\${MFILE} \${BACKUP_ROOT}/\${PKGFILE} \${BACKUP_ROOT}/\${PFILE}
rm -Rf \${BACKUP_ROOT}
 
# Log backup end time in /var/log/messages
\$LOGGER "*** Backup Ended @ \$(date) ***"
 
exit
EOI
 
echo "Downloading archive..."
[ ! -d $LOCAL_BACKUP_ROOT ] && mkdir -p ${LOCAL_BACKUP_ROOT}
scp -rp $SSHUSER@$SSHHOST:$BACKUP_PATH ${LOCAL_BACKUP_ROOT}/${BACKUP_FILENAME}
 
echo "Backup complete."

from django.db import IntegrityError
import models
try:
    myNewRecord = models.MyTable(data=blah)
    myNewRecord.save()
except IntegrityError:
    pass
 
myOtherRecord = models.MyOtherTable(data=blah)
# Throws an error if an IntegrityError was previously thrown.
myOtherRecord.save()

from django.db import IntegrityError, connection
import models
try:
    myNewRecord = models.MyTable(data=blah)
    myNewRecord.save()
except IntegrityError:
    # Required to clear PostgreSQL's failed transaction.
    connection.close()
 
myOtherRecord = models.MyOtherTable(data=blah)
# Now works correctly.
myOtherRecord.save()