Всё чудесатее и чудесатее

И снова о разрезании lossless-аудио (ape, flac, wv, wav) по файлу cue

2010-06-14T17:30:00.005+03:00

Ранее я выкладывал перевод одной заметки о том, как разрезать lossless-аудио на отдельные треки. Однако, в комментариях мне подсказали более простой способ.

Для этого понадибится утилита shntool (в Debian и Ubuntu живёт в одноимённом пакете). Вообще, это настоящий швейцарский армейский нож в области работы со звуковыми файлами (в том числе и сжатыми), в чём можно убедиться, открыв соответствующий man:

man shntool

Вот перечень некоторых команд, которые эта утилита поддерживает:

len — отображает продолжительность, размер и свойства звуковых данных
join — объединяет несколько файлов в один
split — разбивает звуковой файл на несколько отдельных файлов
cue — генерирует файл CUE или список точек разбиения по набору файлов
conv — преобразует из одного формата в другой
trim — удаляет тишину по краям записи

Список поддерживаемых форматов тоже немал: wav (RIFF WAVE), aiff (Audio Interchange File Format), shn (Shorten low complexity waveform coder), flac (Free Lossless Audio Codec), ape (Monkey's Audio Compressor), ofr (OptimFROG Lossless WAVE), lpac (Lossless Predictive Audio Compression), wv (WavPack Hybrid Lossless Audio Compression), alac (Apple Lossless Audio Codec) и другие, менее распространённые.

Естественно, для поддержки форматов нужно доустанавливать соответствующие утилиты. Для flac, ape и wv:

sudo apt-get install flac wavpack monkeys-audio

Собственно команда для разрезания будет иметь вид:
Эта команда не только разобьёт исходный flac-файл, но и переименует каждый трек в соответствии с форматом:

Исполнитель (Альбом) - Номер - Название

Естественно, можно указать и другой формат, задав свою строку и используя постановочные символы %p, %a, %n, %t.

Если файлы Music.flac и Music.cue расположены в одной папке, имеют одинаковое имя, как в данном случае и других подобных файлов нет, то можно использовать следующий скрипт:

#!/bin/bash
f=`ls *.cue`
f=${f%.cue}
shntool split -f "$f.cue" -o flac "$f.flac" -t "%p (%a) - %n - %t"

Я его назвал split_flac и поместил в ~/bin. Чтобы им воспользоваться достаточно зайти в директорию с разрезаемыми файлами и выполнить всего одну команду:

split_flac

Аналогичный скрипт можно написать и для формата APE. А можно сделать один большой интеллектуальный скрипт, если не лень.

Чтобы не было закорючек в именах, нужно следить, чтобы файл cue был в той же кодировке, что и текущая локаль (обычно, UTF-8).

Единственный минус — теги будут пустыми, но их можно заполнить командой cuetag или какой-то специализированной утилитой наподобие EasyTAG.

Решето Эратосфена / Sieve of Eratosthenes

2010-06-08T21:05:00.005+03:00

Programming Praxis, 19.02.2009

Более двух тысяч лет назад Эратосфен, который вычислил окружность Земли, расстояние до Солнца и наклон земной оси, изобрёл широту и долготу, а также придумал високосный день, создал систематический метод перечисления всех простых числе, который используется и по сей день.
Эратосфен родился в Кирене (на территории современной Ливии) и жил с 276 г. до н. э. по 194 до н. э. Он провёл большую часть своей жизни в Александрии (Египет), где был вторым главой Великой библиотеки перед Аполлонием Родосским.

Решето Эратосфена начинается с создания списка натуральных чисел до желаемого предела; проиллюстрируем метод, вычислив простые числа до тридцати:

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Теперь возьмём первое число в списке — 2 — и вычеркнем каждое второе число:

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Затем берём следующее невычеркнутое число в списке — 3 — и вычёркиваем каждое третье число; некоторые из них окажутся уже вычеркнутыми:

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

повторяем последний шаг для следующего невычеркнутого числа — 5:

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

И так далее, каждый раз вычёркивая все числа, кратные следующему невычеркнутому числу в списке. Все невычеркнутые числа к концу процедуры будут простыми:

2 3 5 7 11 13 17 19 23 29

Этот метод называется решетом, потому что он просеивает весь исходный диапазон чисел в поисках простых чисел.

Решето допускает некоторые оптимизации.

Во-первых, нужно рассматривать только нечётные числа, так как первый проход вычеркнет все чётные за исключением 2, которое можно рассматривать отдельно.

Во-вторых, вычёркивание нужно начинать с квадрата числа, которое рассматривается в данный момент, так как все меньшие составные числа уже были вычеркнуты на предыдущих шагах; например, рассматривая 3, вычёркивание нужно начинать с 9, так как 6 было вычеркнуто, когда рассматривали 2.

В третьих, процедура останавливается на квадратном корне из максимального числа, так как все простые числа, большие него уже будут вычеркнуты к этому моменту. Так, в рассмотренном выше примере не было необходимости проверять числа, большие либо равные 7, так как квадрат 7 больше 30 — наибольшего числа в списке.

Напишите функцию, которая принимает один аргумент n и возвращает список простых чисел, меньших либо равных n используя оптимизированный алгоритм, описанный выше. Примените эту функцию к 15485863 и посчитайте количество полученных простых чисел.

Решение.
Jos Koot написал следующую версию решета Эратосфена:


(define (primes n)
  (let* ((max-index (quotient (- n 3) 2))
         (v (make-vector (+ 1 max-index) #t)))
    (let loop ((i 0) (ps '(2)))
      (let ((p (+ i i 3)) (startj (+ (* 2 i i) (* 6 i) 3)))
        (cond ((>= (* p p) n)
               (let loop ((j i) (ps ps))
                  (cond ((> j max-index) (reverse ps))
                        ((vector-ref v j)
                          (loop (+ j 1) (cons (+ j j 3) ps)))
                        (else (loop (+ j 1) ps)))))
              ((vector-ref v i)
                (let loop ((j startj))
                  (if (<= j max-index)
                      (begin (vector-set! v j #f)
                             (loop (+ j p)))))
                      (loop (+ 1 i) (cons p ps)))
              (else (loop (+ 1 i) ps)))))))

Существует миллион простых числе, меньших, либо равных 15485863:


> (length (primes 15485863))
1000000

Моё решение.


from math import sqrt

def sieve(n):
    l = range(3,n+1,2)
    i = 0
    while 2*i+3 <= sqrt(n):
        k = l[i]
        l[(k**2-3)/2:(n-1)/2:k] = [0] * ((n-k**2+1)/(2*k)+1)
        i += 1
        while l[i] == 0:
            i += 1
    return [2] + filter(lambda x: x != 0, l)

print len(sieve(15485863))

Казалось бы, использование сечений — не самый оптимальный способ присвоить значение сразу многим элементам списка, но при замене страшной строчки «l[(k**2-3)/2:(n-1)/2:k] = [0] * ((n-k**2+1)/(2*k)+1)» на цикл программ стала завершать работу не за 3.172 с, а за 5,056 с.

Всего же для просеивания 15485863 числе программе потребовалось 545 итераций. Из упомянутых трёх секунд только полторы уходило на собственно просеивание. Остальное время программа отфильтровывала вычеркнутые элементы.

Обратный польский калькулятор / RPN Calculator

2010-06-07T00:45:00.011+03:00

Дисклеймер. Хотелось бы поделиться с людьми, которые не особо знают английский, задачками с довольно интересного сайта Programming Praxis. Готовых переводов задач я не нашёл, а потому буду потихоньку сам их тут выкладывать. Задачки простые, но для того, чтобы не терять навыки программирования — самое то.

Programming Praxis, 19.02.2009

Реализовать обратный польский калькулятор, принимающий выражения вида «19 2.14 + 4.5 2 4.3 / - *», которое обычно вычисляется как «(19 + 2.14) * (4.5 - 2 / 4.3)» и соответствует 85.2974. Программа должна читать выражение со стандартного входа и выводить вершину стека с символом конца строки в стандартный вывод. Программа должна сохранять состояние стека операндов между выражениями.

Решение.
Единственная сложность заключается в обработке новой строки, которая в Scheme трактуется как пробел. Функция (op token) преобразует знак, из символа, полученного со входа, в оператор, который может быть использован для вычислений. Формат первой строки программы специфичен для Chez Scheme, но большинство реализаций Scheme предоставляют что-то подобное.


#! /usr/bin/scheme –script
(define (next)
  (cond ((eof-object? (peek-char)) (exit))
        ((char=? (peek-char) #\space) (read-char) (next))
        ((char=? (peek-char) #\newline) (read-char) ‘nl)
        (else (read))))

(define (op token) (case token ((+) +) ((-) -) ((*) *) ((/) /)))

(let rpn ((token (next)) (stack ‘()))
  (cond ((eq? ‘nl token) (display (car stack)) (newline) (rpn (next) (cdr stack)))
        ((number? token) (rpn (next) (cons token stack)))
        (else (rpn (next) (cons ((op token) (cadr stack) (car stack)) (cddr stack))))))

Моё решение.


#!/usr/bin/env python
#-*- coding:utf-8 -*-

from sys import stdin, stdout

def calc():
    stack = []
    result = None
    while True:
        line = yield result
        for token in line.split():
            try:
                number = float(token)
                stack[:0] = [number]
                result = number
            except ValueError:
                try:
                    result = {
                        '+': lambda x, y: x + y,
                        '-': lambda x, y: x - y,
                        '*': lambda x, y: x * y,
                        '/': lambda x, y: x / y
                    }[token](stack[1], stack[0])
                    stack[0:2] = [result]
                except IndexError:
                    raise ValueError, 'Stack is empty'
                except KeyError:
                    raise ValueError, 'Unknown operation'
c = calc()
c.next()

for line in stdin.xreadlines():
    print >> stdout, c.send(line)

Тут есть несколько необычных для новичка моментов.

line = yield result

— это «вывернутый наизнанку» вызов функции, который позволяет разбить цикл обработки на две части: работу со стеком и получение строк со стандартного ввода. Команда yield возвращает значение подобно return, но функция при этом не завершается и будет продолжена при вызове метода send снаружи. причём, аргумент send будет передан через yield внутрь функции. Звучит запутанно, но генераторы — это действительно очень мощная и гибкая штука.

Другая необычность — использование индексирования словаря. Это позволяет ввести конструкцию, аналогичную, например, switch в C, без использования if—elif. Так код выглядит чище, хотя, конечно, тратятся ресурсы на создание анонимного словаря и поиск ключа в нём.

Странные индексы списка stack с двоеточиями — это сечения (slices). Тоже довольно удобная штука. Они есть также в MatLab и Fortran, где без них программирование заметно усложнилось бы.

Как сделать deb-пакет со своими скриптами

2009-11-05T19:29:00.012+02:00

Рано или поздно у продвинутого пользователя линукса накапливается набор собственных скриптов, хранящихся где-то в «~/bin». Но каталог с программами не так красиво смотрится в домашнем каталоге, да и потом если делиться с друзьями, то приходится отправлять в архиве, говорить куда что копировать, убеждать их, что загромождение домашнего каталога — неизбежное зло. Можно, конечно и куда-то в «/usr/local/bin» их поместить, но можно потратить десять минут и собрать пакет, который потом легко устанавливается (и удаляется) штатными средствами. Причём туда, куда надо.

Посмотрим, как это делается.

В качестве примера скриптов возьмем, например следующие два.

Первый загружает цитаты с lorquotes.ru.

#!/bin/sh
[ -x ~/.lor ] || mkdir ~/.lor
wget http://lorquotes.ru/fortraw.php -O -| iconv -f koi8-r -o ~/.lor/lor
strfile ~/.lor/lor ~/.lor/lor.dat

А второй — выводит и при помощи утилиты fortune.

#!/bin/sh
fortune ~/.lor

Назовем их соответственно «lor-update» и «lor».

Сохраним их в отдельный каталог, который при сборке пакета должен иметь имя вида «пакет-версия». В нашем случае это будет «lorquotes-0.1».

Теперь создадим заготовку пакета при помощи команды dh_make (есть в репозитории под именем — сюрприз! — «dh-make»). Для этого в нашем каталоге выполним следующую команду:

dh_make --createorig -c gpl3 -e user@example.com -i -p lorquotes_0.1

Довольно длинно, не так ли? Разберём по порядку:
--createorig — создать отдельную папку с исходниками, это будет нужно при создании пакета;
-c gpl3 — указать в качестве лицензии GPL3 (какие ещё есть лицензии ,можно посмотреть в man-страничке утилиты dh_make);
-e user@example.com — электронная почта собравшего пакет (то есть ваш);
-i — говорим, что пакет не зависит от платформы (bash-скрипты везде одинаковы ведь);
-p lorquotes_0.1 — указываем имя пакета (вообще, необязательно).

Утилита спросит, всё ли она правильно поняла, на что мы честно соглашаемся и заходим в папку.

Как видим, старое содержимое скопировалось в каталог «lorquotes-0.1.orig» (спасибо опции --createorig), а в «lorquotes-0.1» появился каталог «debian» с кучей файликов непонятного назначения. Собственно, содержимое этого каталога и определяет как будет вести себя пакет при установке и что он будет содержать.

Но сперва нужно создать мейкфайл. Это специальный файл, имеющий имя Makefile и говорящий сборщику пакета, как скомпилировать исходнуе тексты и куда устанавливать его содержимое. Структура нашего мейкфайла очень проста:

DESTDIR =
BIN = $(DESTDIR)/usr/bin

build:
 true

install:
 install -d $(BIN)
 install -m755 lor $(BIN)
 install -m755 lor-update $(BIN)

Заметьте, что некоторые строки набраны с отступом при помощи табуляции. Именно так и нужно набирать. Это важно!

Мейкфайл — это просто предписание команде «make» выполнить определенный набор действий.

В строке 1 определены специальные переменные: DESTDIR — каталог, в который будет устанавливаться наш пакет. Эта переменная обязательно должна быть в мейкфайле, так как черех неё потом сборщик пакета указывает каталог назначения.

В строке 2 указан каталог, куда будут установлены наши скрипты. Без этой переменной уже можно было обойтись, так как она пользовательская и введена для удобства.

Строка с «build» — это одна из целей, которых должен достичь make. После двоеточия можно было указать список целей, от которых цель «build» зависит, но у нас и компилировать-то нечего, потому ничего и не указано. После цели идут команды (внимание, с отступом!), которые необходимо выполнить для достижения этой цели. Так как ничего выполнять не надо, то там стоит команда true, которая ничего не делает (такая у неё работа).

Аналогично описана цель «install». Но тут уже нужны действия: а именно создание каталога назначения и копирование в него с соответствующими правами наших скриптов. Вместо обычных команд создания и копирования используется утилита install, которая более интеллектуальна и специально для этих целей предназначена.

Итак, создаем в папке со скриптами (не в debian) мейкфайл под именем Makefile. Теперь мы можем при помощи команд «make» (ничего не делает, т.к выполнится первая цель в файле, т.е. «build») и «sudo make install» (копирует скрипты куда надо) собрать и установить вручную наши скрипты. Но вручную нам не нужно, мы ведь пакет хотим собрать. Поэтому переходим к следующему этапу.

Настроим свойства нашего пакета. Перейдём в каталог «debian» и откроем файл «control». Он содержит информацию о пакете, его зависимостях и так далее. Заполним его как анкету.

Source — название того, что мы сейчас собираем,
Section — в какую секцию дерева репозитория поместить наш пакет,
Priority — важность пакета,
Maintainer — сборщик,
Build-Depends — какие программы нужны для сборки пакета,
Standards-Version — версия стандарта, описывающего сборку пакетов,
Homepage — домашняя страничка (если есть),
Package — имя собственно deb-пакета,
Architecture — архитектура, под которую он собирается (i386, amd64 и иже с ними),
Depends — от каких пакетом наш зависит,
Description — описание, короткое в той же строке и длинное ниже (обратите внимание на пробел в начале строки с длинным описанием).

Я для примера сделал такой файл:

Source: lorquotes
Section: misc
Priority: optional
Maintainer: Vasiliy Pupkin 
Build-Depends: debhelper (>= 7)
Standards-Version: 3.8.3
Homepage: http://pupkin.example.com/lorquotes/

Package: lorquotes
Architecture: all
Depends: wget,fortunes
Description: Small LOR quotes utility
 Shows you random quote from lorquotes.ru.

Думаю, указывать в зависимостях шелл и libc6 смысла нет. Они точно есть в любой системе (или нет?).

Теперь подправим файл «changelog». Он содержит историю версия нашего пакета. Во время правки не забывайте, что он тоже имеет строгий формат и не добавляйте лишние отступы и строки.

Вот мой вариант:

lorquotes (0.1-1) unstable; urgency=low

  * Initial release

 -- Vasiliy Pupkin   Thu, 05 Nov 2009 19:53:58 +0200

unstable — это имя ветки дистрибутива, для которой готовится пакет, а urgency — это приоритет.

В том же каталоге есть файл «rules». Это обычный мекфайл, который и отвечает за конфигурирование и сборку пакета. Но так как мы ничего экстраординарного не делали, оставим всё как есть.

В файле «copyright» находится лицензия. Мы лицензию сразу указали, так что и этот файл трогать не будем.

Итак, остались ещё следующие важные для нас файлы.

«cron.d.ex». Переименовываем его в «cron.d». Он содержит информацию о регулярных действиях, которые будет выполнять установленная программа. В нашем случае — ежедневное обновление базы цитат в полдень:

#
# Regular cron jobs for the lorquotes package
#
0 12 * * * root [ -x /usr/bin/lor-update ] && /usr/bin/lor-update

«postrm.ez». Переименовываем в «postrm». Это скрипт, запускаемый после удаления пакета. Заставим его очищать нашу базу цитат, хранящуюся в «~/.lor». Хотя хранить базу в домашнем каталоге не совсем верно идеологически. Но, думаю, после этого поста читатель и сам исправит эту неточность. Итак, мой «postrm»:

#!/bin/sh
# postrm script for lorquotes
#
# see: dh_installdeb(1)

set -e

case "$1" in
    purge|remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
    rm -rf ~/.lor
    ;;

    *)
        echo "postrm called with unknown argument \`$1'" >&2
        exit 1
    ;;
esac

# dh_installdeb will replace this with shell code automatically
# generated by other debhelper scripts.

#DEBHELPER#

exit 0

Остальные файлы нам не нужны и смело их удаляем. Это разные заготовки. Например, для man-страниц.

Переходим теперь в каталог со скриптами (т.е. на уровень выше) и даём команду на сбору пакета:

debuild

Она собирает пакет, проверяет на ошибки, а потом пробует его подписать вашим GPG-ключом. Но даже если ей подписать не удастся, пакет будет собран. Найти его можно будет в каталоге уровнем выше. Там же будет архив с исходниками и вспомогательные файлы, нужные, если вы хотите создать свой репозиторий или загрузить пакет в уже существующий.

Конечно, при сборке пакета будут предупреждения. Но мы ведь не закачивать его в дебиановский репозиторий будем, а для себя собираем. Так что устранение причин предупреждений остаётся в качестве домашнего задания читателю. (Кстати, это несложно.)

Вот и всё! Осталось только установить пакет. :)

Как видите, ничего сложного. Если интересуют подробности или захотелось собрать пакет позаковыристее, милости просим на соответствующую страничку дебиановской документации.

А вот архив с исходниками и пакетом.

Отправка email из командной строки

2009-11-02T12:05:00.006+02:00

О том как отправлять сообщения через jabber, я уже написал. А вот сегодня мне захотелось написать утилитку, которая бы делала то же самое и с теми же (примерно) параметрами командной строки, но для электронной почты. Конечно, в линуксе полно консольных почтовых программ (я в курсе, что есть команда mail), но мне не нужны все их возможности, а кроме того, хотелось бы ещё и кроссплатформенности (я в курсе, что в Windows есть утилита blat) и возможности быстро самому что-то дописать. Вот, что получилось.

Не буду тянуть, сразу приведу код скрипта.

#!/usr/bin/env python
import smtplib, ConfigParser, email.mime.text, getopt, os, sys, locale

name = os.path.basename(sys.argv[0])

optlist, args = getopt.getopt(sys.argv[1:], 's:f:')
if len(args) < 2:
    print "Send a message via email"
    print
    print "Syntax:", name, "[-f from] [-s subject] email text"
    print "email\trecipient's e-mail address"
    print "from\tsender's email"
    print "subject\tmessage subject"
    print "text\tmessage, use '-' for stdin"
    sys.exit(0)

configFile = os.path.join(os.environ['HOME'], '.' + name)
config = ConfigParser.RawConfigParser()
try:
    config.read(configFile)
    fromEmail = config.get('From', 'E-mail')
    smtpServer = config.get('SMTP', 'Server')
    smtpLogin = config.get('SMTP', 'Login')
    smtpPassword = config.get('SMTP', 'Password')
except:
    print "Default configuration was written to", configFile
    config.add_section('From')
    config.set('From', 'E-mail', 'user@example.com')
    config.add_section('SMTP')
    config.set('SMTP', 'Server', 'smtp.example.com')
    config.set('SMTP', 'Login', 'user')
    config.set('SMTP', 'Password', '********')
    f = file(configFile, 'w')
    config.write(f)
    f.close()
    sys.exit(0)

toEmail = args[0]
subject = ''
for option, value in optlist:
    if option == '-s':
        subject = value
    elif option == '-f':
        fromEmail = value

encoding = locale.getpreferredencoding()
if args[1] == '-':
    message = email.mime.text.MIMEText(sys.stdin.read(), 'plain', encoding)
else:
    message = email.mime.text.MIMEText(' '.join(args[1:]), 'plain', encoding)

message['Subject'] = subject
message['From'] = fromEmail
message['To'] = toEmail

server = smtplib.SMTP(smtpServer)
server.login(smtpLogin, smtpPassword)
server.sendmail(message['From'], message['To'], message.as_string())
server.quit()

Всё это сохраняем в файл с именем, например, «mailto» и даём права на выполнение:

chmod +x mailto

После первого создаётся файл с настройками подключения. По умолчанию это файл «.mailto» (если скрипт называется «mailto», конечно) в домашнем каталоге. В нём нужно указать адрес отправителя и настройки smtp-сервера.

Параметров у скрипта минимум, только то, что нужно. Есть два опциональных для указания темы сообщения и адреса отправителя (по умолчанию берётся из файла с настройками). Для них используются ключи «-s» и «-f» соответственно (от слов «From» и «Subject»).

Обязательных параметров всего два и они без ключей. Это адрес получателя собственно текст сообщения. Если вместо текста поставить «-», то текст будет браться из стандартного входа, что удобно для отправки результатов вывода какой-то программы.

Использовать программу можно для чего угодно. Например, чтобы отправить список пользователей себе на ящик можно воспользоваться командой:

who | mailto user@example.com -

Я, например, использую этот скрипт, чтобы автоматически в определённое время слать себе СМС с напоминанием о чём-либо через гейт «email—SMS» моего мобильного оператора. Получилось удобно.

Отправка jabber-сообщений из командной строки

2009-11-01T00:44:00.016+02:00

О том, как отправить jabber-сообщение из консоли при помощи клиента Gajim, я уже писал ранее. Тем не менее, использование gajim-remote имеет ряд недостатков: нужно установить сам Gajim и запустить его. Это может вызвать некоторые затруднения, например, на сервере, где вовсе может не быть графического интерфейса. Однако, проблема имеет и более простое решение.

Сделаем скрипт, которому бы в качестве параметров передавались данные учётной записи jabber, JID отправителя и текст сообщения. В качестве основы возьмём питоновскую библиотеку xmpppy. В частности, рассмотрим повнимательнее один из примеров, входящих в её комплект, который (сюрприз!) как раз и предназначен для отправки сообщений из консоли. Остаётся только его чуть-чуть «допилить» по вкусу.

Итак, нам потребуется библиотека. Они есть в репозиториях Debian (да и других популярных дистрибутивов), поэтому устанавливаем как обычно:

sudo aptitude install python-xmpp python-dnspython

Без python-dnspython работать тоже будет, кстати. Но лучше поставить, так как в этом случае придётся вводить точное имя узла, на котором располагается сервер.

А вот и сам скрипт:

#!/usr/bin/env python
import sys,os,xmpp,time,ConfigParser

name = os.path.basename(sys.argv[0])

if len(sys.argv) < 2:
    print "Send a message via Jabber (XMPP)"
    print "Syntax:", name, "JID text"
    print "JID\trecipient's Jabber ID"
    print "text\tmessage, use '-' for stdin"
    sys.exit(0)

toJID = sys.argv[1]
if sys.argv[2] == '-':
    text = sys.stdin.read()
else:
    text = ' '.join(sys.argv[2:])

configFile = os.path.join(os.environ['HOME'], '.' + name)
config = ConfigParser.RawConfigParser()

try:
    config.read(configFile)
    fromJID = config.get('Connection', 'JID')
    password = config.get('Connection', 'Password')
except:
    print "Default configuration was written to", configFile
    config.add_section('Connection')
    config.set('Connection', 'JID', 'user@example.com/home')
    config.set('Connection', 'Password', '********')
    f = file(configFile, 'w')
    config.write(f)
    f.close()
    sys.exit(0)

fromJID = xmpp.protocol.JID(fromJID)
client = xmpp.Client(fromJID.getDomain(),debug=[])

conn = client.connect()
if not conn:
    print 'Could not connect!'
    sys.exit(1)
print 'Connected with', conn

auth = client.auth(fromJID.getNode(), password, resource=fromJID.getResource())
if not auth:
    print 'Could not authenticate!'
    sys.exit(1)
print 'Authenticated using', auth

messageID = client.send(xmpp.protocol.Message(toJID, text))
print 'Message was sent'

time.sleep(1)
client.disconnect()

Скрипт довольно простой, так что разбирать его работу не буду.

Всё это сохраняем в каталог «~/bin» под именем, например, «jsend». Имя и каталог значения не имеют, просто «~/bin» удобен для хранения пользовательских скриптов, так как он входит в переменную PATH и для запуска скритов из него достаточно указать их имена. В любом случае нужно разрешить выполнение нашей программки:

chmod +x jsend

Рассмотрим её работу. После первого запуска утилита создаёт в домашнем каталоге файл с JID и паролем отправителя. Это удобнее, чем вводить пароль в качестве параметра командной строки, так как в этом случае никто не сможет его подсмотреть. Да и доступ к файлу можно будет закрыть. Файл поличит имя, совпадающее с именем скрипта, но с точкой впереди, чтобы не отображаться лишний раз в списке файлов. В моём случае имя будет «~/.jsend». Естественно, файл после первого запуска нужно будет открыть и впесать свои JID и пароль.

Формат запуска скрипта:

jsend JID text

JID — это идентификатор получателя сообщения, а text — это собственно текст, который нужно отправить.

Если текста много или нужно отправить вывод какой-либо команды, то вместо text можно поставить «-». Например, команда

df | jsend user@example.com -

отправит информацию о заполненности разделов на дисках пользователю user@example.com.

Также можно настроить отправку сообщений в определённое время при помощи команды at, что тоже иногда оказывается удобным.

Разрезаем lossless-аудио (ape, flac, wv, wav) по файлу cue

2009-10-27T21:16:00.013+02:00

Понимаю, что теме этого поста наверняка написано огромное количество статей, мануалов и прочих ЧаВо. Но каждый раз искать лень, проще один раз сделать узелок на память в блоге.

(Это перевод англоязычной заметки. См. также описание более простого способа.)

Итак, задача такова: дана пара файлов, предположим sample.cue и sample.flac, с каким-либо альбомом. Требуется получить треки альбома в отдельных flac-файлах.Если у вас linux, то делается это в два счёта. Ниже следует перевод одной довольно неплохой статьи с решением проблемы.

Файлы с lossless-аудио могут быть разрезаны по cue-файлу при помощи утилиты «shnsplit» (входит в пакет «shntool»). Также потребуется утилита «cuebreakpoints» (из пакета «cuetools»). Чтобы установить их, откройте терминал и введите следующее (эти пакеты есть в Ubuntu и Debian):

sudo apt-get install cuetools shntool

Кроме этого потребуются приложения для работы с выбранным форматом. Для Monkey’s Audio нужна будет утилита «mac» (в Debian есть пакет «monkeys-audio»). Для FLAC и WavePack потребуется установить соответственно «flac» и «wavpack»:

sudo apt-get install flac wavpack

Утилите shnsplit требуется для работы список точек, в которых нужно делить звуковой файл. Очень кстати тут оказывается утилита cuebreakpoints, которая печатает список таких точек по cue- или toc-файлу в формате, используемом в shnsplit. Можно создать конвейер между cuebreakpoints и shnsplit следующим образом:

cuebreakpoints sample.cue | shnsplit -o flac sample.flac

В этом примере flac-файл с именем «sample.flac» разрезается по точкам, содержащимся в «sample.cue» и результат выводится в формате FLAC.

Выходной формат задаётся параметром «-o». Если не указать формат, то файлы будут сохрняться в формате по умолчанию, то есть в виде wav-файлов.

Чтобы разрезать файл в формате Monkey’s Audio и сохраниеть результаты в формате FLAC, нужно выполнить следующую команду:

cuebreakpoints sample.cue | shnsplit -o flac sample.ape

По умолчанию для выходных файлов используется префикс «split-track» (то есть по умолчанию файлы будут иметь имена: split-track01, split-track02, split-track03,…). Можно задать собственный префикс при помощи опции «-a».

Чтобы посмотреть список всех параметров наберите «shntool split -h» или «shnsplit -h».

В звуковые файлах, полученных с помощью shnsplit не будут записаны данные об исполнителе, альбоме и так далее. Однако, можно воспользоваться скриптом cuetag (также входящим в пакет cuetools) для того, чтобы перенести данные из cue-файла в отдельные дорожки. Можно указать отдельные файлы, соответствующие дорожкам, содержащимся в cue-файле:

cuetag sample.cue split-track01.flac split-track02.flac split-track03.flac split-track04.flac

Эта команда перенесёт теги, содержащиеся в файле «sample.cue» в файлы с дорожками: «split-track01.flac», «split-track02.flac», «split-track03.flac» and «split-track04.flac».
Можно записать теги сразу во все полученные файлы:

cuetag sample.cue split-track*.flac

Утилита cuetag работает с форматами FLAC, Ogg и mp3.

Источник

Управляем Gajim из командной строки

2009-07-27T20:45:00.005+03:00

Gajim — это популярный и активно развивающийся Jabber-клиент, написанный на Python. К слову, он обладает очень неплохой поддержкой всевозможных вкусностей и полезностей Jabber по сравнению со многими другими клиентами. Одной из таких полезностей является возможность управления им из командной строки при помощи D-Bus — системы межпроцессного взаимодействия.

Управление из командной строки не означает, что Gajim имеет консольный интерфейс. Он по-прежнему будет располагаться на рабочем столе в виде окошка. Просто из консоли можно будет отправлять ему какие-либо команды. Собственно, команд поддерживается немного, но для каких-то простейших действий должно хватить.

В состав пакета с Gajim входит консольная утилитка gajim-remote, которая как раз и предназначена для отправки команд основной программе. Если вызвать её без параметров, она покажет список поддерживаемых действий. Вот наиболее интересные:

check_gajim_running — проверить, запущен ли Gajim (результат — True или False),
list_accounts — список учётных записей,
list_contacts [учётные записи] — список контактов в учётных записях,
contact_info <jid> — информация о пользователе с указанным JID,
account_info <учётная запись> — показать информацию об одной из учётных записей Gajim,
add_contact <jid> [учётные записи] — добавить контакт в ростер,
remove_contact <jid> [учётные записи] — удалить учётную запись из ростера,
change_status <статус> [сообщение] [учётные записи] — изменить статус с возможностью указания сообщения и учётной записи (если не указать — будет изменен статус всех учётных записей),
get_status [учётные записи] — получить статус указанных учётных записей,
get_status_message [учётные записи] — получить сообщение статуса указанных учётных записей,
get_unread_msgs_number — количество непрочитанных сообщений,
handle_uri <uri> [учётные записи] — обработать ссылку вида «xmpp://»,
join_room <комната> [ник] [пароль:] [учётные записи] — присоединиться к конференции,
send_chat_message <jid> <сообщение> [PGP-ключ] [учётные записи] — отправить сообщение в чат,
send_file <файл> <jid> [учётные записи] — отправить файл,
send_groupchat_message <jid> <сообщение> [учётные записи] — отправить сообщение в конференцию,
send_single_message <jid> <тема> <сообщение> [PGP-ключ] [учётные записи] — отправить одиночное сообщение,
open_chat <jid> [учётные записи] — открыть чат с указанным контактом,
start_chat <учётные записи> — открыть чат для заданной учётной записи (появится окно ввода JID),
toggle_roster_appearance — показать/скрыть окошко ростера.

Попробуем теперь применить это на практике. Напишем скрипт, меняющий сообщение статуса на случайную цитату из fortunes. (Для тех, кто ещё не знает, fortunes — это консольная программа, выдающая случайную цитату из довольно объемной базы.)

Для этого в бесконечном цикле будем вызывать gajim-remote, передавая ему при помощи обратных кавычек результат выполнения команды fortunes. Между вызовами поставим паузу 5 минут (5×60=300 с).

while true; do gajim-remote change_status "online" "`fortune`"; sleep 300; done

У этой команды есть небольшой недостаток — нужно всё время держать терминал открытым. Для того, чтобы решить эту проблему, можно просто записать команду в текстовый файл, а потом запустить следующим образом:

bash changestatus.sh &

Амперсанд в конце запустит выполнение скрипта в фоне. Можно также создать правило для cron — тогда вообще не придется что-либо запускать.

Другое возможное применение — отправка кому-то сообщения по расписанию. Например, при помощи такой команды:

echo "gajim-remote send_chat_message user@example.com 'Hello'" | at 10:00

Ровно в 10:00 пользователю будет отправлено сообщение «Hello» (если, конечно, Gajim будет в этот момент запущен).

Итак, даже этот небольшой набор команд в сочетании с инструментами командной строки позволяет сделать что-то полезное.

Если работа gajim-remote покажется слишком медленной, можно воспользоваться, например, командой dbus-send или qdbus для отправки сообщения напрямую через D-Bus.

Список предоставляемых функций можно посмотреть при помощи команды

qdbus org.gajim.dbus /org/gajim/dbus/RemoteObject

Вызвать же функцию можно так:

qdbus org.gajim.dbus /org/gajim/dbus/RemoteObject toggle_roster_appearance

Работает намного быстрее gajim-remote, но приходится явно указывать, кому мы шлём команды.

Построение графиков с помощью PyXPlot

2009-07-20T18:49:00.019+03:00

Утилит, позволяющих построить на компьютере график какой-то функции, превеликое множество. Но не каждая способна создать график в достойном качестве, и с соответствующим оформлением. Многие из них интерактивны, но часто это мешает, когда нужно менять много параметров графика. Поэтому при активной работе с графиками часто применяются командные «графопостроители» — фактически маленькие языки программирования.

Среди программ таких можно отметить, например, asymptote, популярный gnuplot, metapost и другие. Достойное место в этом ряду занимает PyXPlot (её команды, кстати, во многом совпадают с командами gnuplot, так что изучив одну из этих программ, легко разобраться в другой). Отличительными особенностями программы являются простота и высокое качество результата. Ей и посвящен этот обзор.

Запуск программы
PyXPlot есть в дистрибутиве Ubuntu и Debian, так что установка должна пройти без проблем. В крайнем случае, всегда можно скачать программу с родного сайта.

Сразу нужно отметить, что PyXPlot — программа чисто консольная. Работать с ней можно как интерактивно, вводя команду за командой, так и в скриптовом режиме. В последнем случае команды записываются в отдельный файл, который затем «скармливается» PyXPlot.

Запускается PyXPlot как обычно:

pyxplot СКРИПТЫ

Если вместо списка файлов поставить дефис, то программа будет читать команды со стандартного ввода, что очень удобно при автоматизации. Например, так можно нарисовать синусоиду:

echo 'plot sin(x)' | pyxplot -

Простейшие операции
Главная команда для рисования графиков — plot. Она позволяет не только рисовать графики функции, но и строить «по точкам» графики данных, записанных в файл.

Чтобы построить данные из файла, нужно просто указать его имя в апострофах или двойных кавычках после команды plot. Данные в файле должны быть обычным текстом с одним или несколькими столбцами чисел, разделенных пробелами или запятыми. Если имя заканчивается на «.gz», он будет автоматически распакован перед построением.

plot 'data.gz'

Так как в файле указаны отдельные значения, то и отображаются они по отдельности, маркерами.

По умолчанию результаты сохраняются в файл «pyxplot.eps».

Построения графика функции полностью аналогична. Нужно просто записать её после команды plot. В качестве аргумента нужно использовать x.

plot sin(x)/x

Можно построить сразу несколько графиков в одной системе координат, просто перечислив функции (или имена файлов) через запятую.

plot sin(x)/x, sin(x)

Переменные и функции
В теле файла с командами можно объявить переменные и пользовательские функции при помощи операции «=». Всё достаточно интуитивно:

a = 2
b = 3
plot sqrt(a*pow(x,2) + b)

В PyXPlot встроены самые распространенные математические функции, такие как: sin, cos, tan, exp, min, log, acos, asin, atan, sqrt, pow и т. д.

f(x) = sqrt(x)*sin(x)
plot f(x)

Настройки графика
При помощи команды set можно задать дополнительные параметры графика, такие как подписи осей (x label и ylabel) и заголовок графика (title). В подписях можно использовать формат формулы в формате TeX (их нужно обязательно заключить в знаки «$»). Использование TeX делает график намного симпатичнее и презентабельнее.

Пример:

set xlabel '$x$'
set ylabel '$y$'
set title 'Plot of $\sin(x)\over x$'
plot sin(x)/x

Можно также задать имя выходного файла (set output) и формат выходных данных (set terminal). Поддерживаются распространённые форматы: postscript, pdf, png, jpeg.

Пример:

set terminal png
set output 'plot.png'
plot cos(x)*exp(x)

Работа с файлами данных
Данные в файле можно использовать как независимые координаты при построении. Для этого нужно добавить парметр using к команде plot.

Например, команда

plot 'data.gz' using 1:2

строит график, используя первый столбец как координату x точек, а второй — как координату y.

Стили графика
Стиль построения графика настраивается при помощи параметра with.

Команда

plot 'data.gz' with points

строит точечный график, а команда

plot 'data.gz' with lines

соединяет точки отрезками.

Можно также откладывать ошибку на графике (with yerrorbars), но для этого потребуется третий столбец.

Тип маркеров и линий также настраивается при помощи модификаторов pointtype и linetype. Подробности — в документации.

plot sin(x) with lines linetype 3

Диапазоны по осям
При построении можно указать размеры осей. Для этого нужно указать минимально и максимальное значения по каждой из осей в квадратных скобках через двоеточие. Если нужно указать параметры только для одной оси, то для другой просто записсывается «[:]» без чисел. Пример:

plot [-1:1][-1:1] sin(x)

Заключение
Разумеется, возможности программы не исчерпываются только перечисленными командами. Утилита имеет ещё очень много разных возможностей: от аппроксимации данных из файла до построения графиков векторных полей.

Массовое переименование файлов

2009-07-20T11:53:00.014+03:00

Наверное, каждый сталкивался с ситуацией, когда нужно переименовать по какому-то шаблону огромное количество файлов. Например, поменять в названиях песен имя исполнителя и заголовок. Или вставить определенную дату в название группы фотографий.

В этих случаях на помощь приходят регулярные выражения и специальные утилиты для массового переименования.

Для меня наиболее удобна консольная утилита prename (или rename), входящая в состав пакета perl. Но кому-то больше по душе, наверное, придутся программы с графическим интерфейсом. Могу посоветовать программы krename или gprename. Однако, в большинстве случаев вполне хватит и prename.

Введение
Синтаксис команды выглядит очень просто:

prename ШАБЛОН ФАЙЛЫ

Но за этой простотой скрывается огромная мощь. Дело в том, что в качестве шаблона используются регулярные выражения.

Параметр ФАЙЛЫ может быть как списком файлов, так и шаблоном в стиле bash, использующим «*» для любой последовательности символов и «?» для одиночного символа. Например, «*.txt» — это все файлы с раширением «txt».

Регулярные выражения
Остановимся поподробнее на регулярных выражениях. Это настолько обширная тема, что о них пишутся целые книги. И настолько сложная, что большую популярность получила известная шутка: «Некоторые люди, когда сталкиваются с какой-то проблемой, думают: “Думаю, я применю регулярные выражения.” Теперь у них две проблемы.» (Jamie Zawinski) Однако, в простых случаях регулярные выражения просты и удобны. Разве что выглядят непривычно. (Честно говоря, иногда они выглядят так, будто по клавиатуре пробежала кошка.)

В утилите prename регулярные выражения обычно имеют следующий вид:

s/ИСХОДНЫЙ/КОНЕЧНЫЙ/

ИСХОДНЫЙ и КОНЕЧНЫЙ — это шаблоны. Первый задает подстроку, которую нужно найти в имени, а второй — на что эту подстроку заменить.

В простейшем случае это могут быть обычные слова. Команда

prename 's/Алиса/Боб/' *.txt

заменит во всех файлах с расширением «txt» слово «Алиса» на слово «Боб».

Нужно заметить, что шаблон применяется к каждому имени файла только один раз. То есть файл с именем «Эх, Алиса, Алиса.txt» будет заменен на «Эх, Боб, Алиса.txt». Чтобы шаблон примянялся столько, сколько нужно, необходимо добавить параметр g к регулярному выражению:

prename 's/Алиса/Боб/g' *.txt

Подстановки
Кроме собственно слов можно использовать специальные подстановочные символы:
«.» — любой одиночный символ,
«\d» — цифра,
«\D» — любой символ кроме цифры,
«\w» — буква, цифра или знак подчёркивания,
«\W» — всё, кроме букв, цифр и знака подчёркивания,
«\s» — любой пробельный символ,
«\S» — любой непробельный символ.

Например, команда

prename 's/\s/_/g' *.txt

заменит пробелы на знаки подчёркивания. Несколько идущих подряд пробелов будут заменены на несколько подчёркиваний.

Начало и конец
Есть также специальные псевдосиволы:
«^» — обозначает начало слова,
«$» — обозначает конец слова.

Например, команда

prename 's/a$/b/' *.txt

заменит «a» на «b» только если «a» — последний символ имени файла.

Экранирование
Если же какой-то из специальных символов нужно использовать в шаблоне как символ обычный, его нужно экранировать обратным слэшем. Например, «.» — одиночный символ, «\.» — просто точка.

Повторы
После любой части регулярного выражения можно поставить количество его повторов:
«?» — ноль или один,
«*» — ноль и более,
«+» — один и более,
«{n}» — ровно n
«{m,n}» — от m до n,
«{m,}» — от m и более,
«{,n}» — от нуля до n.

Символы «?», «+» и «*» по умолчанию являются «жадными», то есть пытаются отхватить как можно большую часть выражения, попадающую под шаблон.

Команда

prename 's/\s+/_/g' *.txt

заменит пробелы на знаки подчёркивания. Несколько идущих подряд пробелов будут заменены на одно подчёркивание.

Группировка и ссылки
Части выражения можно группировать при помощи круглых скобок. Также можно ссылаться на скобки при помощи выражения вида «$номер». Здесь — номер — это номер пары скобок в порядке их вхождения в выражение.

Например, команда

prename 's/(\d)+/$1/g' *.txt

заменит несколько подряд идущих одинаковых цифр в имени на одну (эту же!) цифру. То есть файл с именем «11122233333.txt» будет переименован в «123.txt».

А команда

prename 's/(.*) - (.*)\.mp3/$2 - $1\.mp3/' *.mp3

переименует файл «Ария Филиппа - Шаляпин.mp3» в «Шаляпин - Ария Филиппа.mp3».

Что за там, за горизонтом?
Есть также полезная возможность заглянуть вперед или назад, но не включая определенную часть шаблона в найденное:
«(?=ШАБЛОН)» — просмотр вперёд,
«(?!ШАБЛОН)» — просмотр вперёд (с отрицанием),
«(?<=ШАБЛОН)» — просмотр назад,
«(?<!ШАБЛОН)» — просмотр назад (с отрицанием).

Например, команда

prename 's/(?<!x)a/b/g' *.txt

заменит «a» на «b» в файлах с раширением «txt» только если «a» не идёт после x.

А команда

prename 's/a(?!x)/b/g' *.txt

заменит «a» на «b» в файлах с раширением «txt» только если «a» не идёт перед x.

Заключение
Регулярные выражения имеют огромную область применения. Естественно, в этом посте перечислены далеко не все их возможности. Например, не сказано про транслитерацию или диапазоны символов.

В качестве неплохого руководства по ним могу порекомендовать книгу Дж. Фридла «Регулярные выражения».

У утилиты, конечно, есть и недостатки. Главный очевиден — нужно знать регулярные выражения. Есть и другие. Например, с помощью prename нельзя пронумеровать файлы.

Идеи для GNOME Shell

2009-07-17T13:20:00.008+03:00

Как известно, сейчас полным ходом идет работа над GNOME 3, в котором привычный интерфейс будет заменен на GNOME Shell. И хотя последний будет включен в GNOME 2.28, работа сейчас находится на достаточно ранней стадии. В связи с этим разработчики предлагают каждому предложить свою идею, каким должен быть интерфейс нового GNOME. Сбор идей производится на сайте проекта.

Вот, некоторые из предложений, представленных на сайте, которые мне показались достаточно любопытными (подробности — на сайте GNOME).

Расширенный вид меню
Máirín Duffy предлагает сделать возможность отображения в меню Activities не только приложений, но и связаной с ними информации. Например, недавно открытых файлов.

Мини-терминал
Предлагается также сделать небольшое поле для ввода команд. Может быть полезным, если приложению требуются какие-то параметры для запуска.

Полка для окон
Довольно интересной представляется возможность складывать неиспользуемые окна на «полку». Особенно удобно это будет с устройствами, оборудованными тачскринами. Тогда окна можно будет просто выделить при помощи «лассо» и свернуть, чтобы не занимали место.

«Связывание» окон
Если эта возможность будет реализована, то пользователь сможет «связывать» два окна, после чего они будут отображаться как единое целое. Шаг в сторону тайловых оконных менеджеров.

Отображение приложений справа
Некоторые пользователи считают, что список приложений лучше выводить справа от миниатюр рабочих столов. Выглядит достаточно непривычно.

Цепочка последних действий
Очень удобным мне показалось отображение последних открытых документов и приложений рядом с меню Activities.

Заголовки окон вместо панели
Не знаю, насколько это удобно, но есть предложение отказаться от панели, где отображались бы запущенные приложения. Вместо этого можно было бы использовать заголовки окон.

Умные окна
Предлагается позволить окнам самим мледить за тем, кто из них на переднем плане. Возможно,что это позволит переключаться между ними, затрачивая меньше времени. Хотя выглядит тоже очень очень непривычно. По-моему, окнам лучше быть просто окнами.

Категории в меню
Некоторые идеи выглядят очень инновационо. Например, отображение всех приложений и документов в одном меню. Поэтому появилось предложение сделать возможность выбора между новым и старым стилем представления.

Выпадающий список приложений
В то время как одни хотят избавиться от панели задач, другие предлагают менее радикальное решение — представить запущенные приложения в виде списка.

Отказ от списка приложений
Есть также идея вообще отказаться от списка приложений в пользу списка контактов и документов (организованного, например, при помощи Zeitgeist). В целом, довольно здравая мысль, так как всё равно люди часто используют приложения только для обработки документов или для свзяи с кем-то.

Контакты в Activities
Также кроме простого отображения списка контактов можно выводить и дополнительную информацию, получая более тесную интеграцию окружения рабочего стола с мессенджерами.

Вот, вкратце, наиболее инновационные предложения. Есть какая-то идея? Присоединяйтесь и вы!

Информация о медиафайлах

2009-07-16T20:58:00.008+03:00

В недавнем посте об отображении тегов mp3-файлов рассказывалось об утилите mp3info. К сожалению, она обладает существенными недостатками: не понимает ID3v2 и работает, как следует из названия, только с mp3-файлам.

Однако, сама по себе утилитка довольно удобна. Поэтому я решил написать небольшой скрипт, предоставляющий похожий интерфейс, но понимающий большее количество медиаформатов.

Естественно, писал я его не на пустом месте. Для работы скрипта потребуется библиотека Kaa.Metadata:

sudo aptitude install python-kaa-metadata

Параметров у скрипта всего два (для простоты): форматная строка и файл (или несколько файлов через пробел):

mediainfo.py ФОРМАТ файл(ы)

При указании файла можно использовать стандартные шаблоны. Так что вполне допустимо имя вида «*.mp3». Можно использовать и более сложные шаблоны: «~/Музыка/*/*.mp3».

Скрипт не умеет рекурсивно обходить каталоги, но это ему и не нужно. Обход можно реализовать, например, средствами bash.

Подробнее о форматной строке. В ней можно использовать следующие шаблоны:
%t — название,
%a — исполнитель,
%r — частота дискретизации,
%l — продолжительность,
%m — продолжительность (только минуты),
%s — продолжительность (только секунды)
%c — кодек,
%b — битрейт,
%n — номер трека,
%A — альбом,
%g — жанр,
%% — символ %.

В ней также можно использовать обычные питоновские экранированные последовательности: \n, \t и т. д.

Вставлять \n в конце форматной строки не нужно, это делается автоматически. Кроме того, вывод скрипта автоматически переконвертируется в кодировку текущей локали.

Если теги файла записаны в однобайтовой кодировке и формат тегов не предусматривает указания кодировки, то скорее всего вместо ожидаемой cp1251 будет latin-1. Впрочем, ответственность за это лежит на библиотеке. Может, это можно настроить, я глубоко не вникал. Во всяком случае, это еще один повод перевести все теги в utf-8.

Утилиту можно использовать как саму по себе, так и в конвейере:

mediainfo.py '%l' ~/Музыка/*/* | awk '{s += $1} END {print "≈",int(s/3600),"hour(s)"}'

А вот, собственно, исходный текст скрипта:

#!/usr/bin/env python
#-*- coding:utf-8 -*-

# Disable all warnings
import warnings
warnings.filterwarnings('ignore')

# Disable log messages
#import logging
#logger = logging.getLogger('metadata')
#logger.setLevel(logging.CRITICAL)

# Get locale encoding
import locale
encoding = locale.getdefaultlocale()[1]

import os
import sys
import glob
import string
import kaa.metadata

class MyTemplate(string.Template): delimiter = '%'

def addItem(infolist, info):
    item = {}
    item['t'] = info.title                      # Title
    item['a'] = info.artist                     # Artist
    item['r'] = info.samplerate                 # Samplerate
    item['l'] = int(info.length)                # Length (seconds)
    item['m'] = int(item['l'] / 60) % 60        # Length (minutes only)
    item['s'] = format(item['l'] % 60, '02d')   # Length (seconds only)
    item['c'] = info.codec                      # Codec
    item['b'] = info.bitrate                    # Bitrate
    item['n'] = info.trackno                    # Track number
    item['A'] = info.album                      # Album title
    item['g'] = info.genre                      # Genre
    infolist.append(item)

def process(path):
    infolist = []
    path = os.path.normpath(path)
    for f in glob.glob(os.path.expanduser(path)):
        if os.path.isdir(f):
            continue
        try:
            info = kaa.metadata.parse(f)
        except:
            info = None
        if info != None:
            addItem(infolist, info)
    return infolist

if len(sys.argv) < 3:
    print 'Usage:'
    print os.path.split(sys.argv[0])[1], 'FORMAT file(s)'
    exit(0)    
for f in sys.argv[2:]:
    infolist = process(f)        
    for item in infolist:
        sys.stdout.write(MyTemplate(sys.argv[1]).safe_substitute(item).encode(encoding) + '\n')

Не забываем разрешить его выполнение:

chmod +x mediainfo.py

Информация об mp3-файлах

2009-07-15T15:47:00.010+03:00

Иногда, когда залезаешь в свою коллекцию музыки, возникает необходимость составить список песен с продолжительностью. Например, для того, чтобы распечатать и приложить к диску.

Для того, чтобы получить названия песен можно использовать ls, но не всегда название файла соответствует содержимому. И ещё реже в названии указана продолжительность.

В этом случае на помощь приходит пакет mp3info.

В Ubuntu устанавливается как обычно:


sudo aptitude install mp3info

У него довольно много возможностей по редактированию и отображению тегов. Подробности можно узнать в man. Для того, чтобы получить список песен в альбоме можно воспользоваться следующей командой:


mp3info -p 'ФОРМАТ' *.mp3

Она выведет данные об mp3-файлах в текущем каталоге в соответствии со строкой ФОРМАТ.

В форматной строке можно использовать как обычные символы (они выведутся как есть), так и специальные шаблоны. Вот список некоторых из них:
%f — имя файла без пути,
%F — имя файла с путём,
%k — размер файла в килобайтах,
%a — исполнитель,
%g — жанр,
%l — альбом,
%n — номер трека,
%t — название трека,
%y — год,
%q — частота сэмплирования (в кГц),
%r — битрейт,
%m — продолжительность (только минуты),
%s — продолжительность (только секунды),
%% — знак процента,
\n — перевод строки,
\t — горизонтальная табуляция,
\\ — обратный слэш.

Например, команда

mp3info -p '%n. %a - %t (%m:%s)\n' *.mp3

выведет на экран что-то вроде:

01. Allison Crowe - It Came Upon the Midnight Clea (0:42)
02. Allison Crowe - Silent Night (4:2)
03. Allison Crowe - In the Bleak Midwinter (4:3)
04. Allison Crowe - What Child Is This (4:4)
05. Allison Crowe - The First Noel (5:34)
06. Allison Crowe - O Holy Night (4:16)

При работе с файлами, содержащими теги на русском языке могут возникнуть проблемы. Дело в том, что в них данные очень часто записываются в виндососвской кодировке cp1251. Решить проблему можно перекодировав вывод команды при помощи утилиты iconv:

Просто по старой виндузячьей традиции теги хранятся в кодировке cp1251. Я все перекодирую при помощи easytag, но если файлик с такими тегами попался, то можно использовать iconv. Например, так:

mp3info -p '%a - %t \n'  *.mp3 |iconv -f cp1251

Следует помнить, что mp3info работает только с тегами ID3v1.1.

Пишем пищалку для будильника

2009-07-13T09:10:00.034+03:00

Часто мне не хватает удобного и простого будильника под Linux. Органайзеры со всплывающими окошками и проигрыванием заданной мелодии явно избыточны для того, чтобы просто не забыть про чайник. А старый добрый beep я использовать не могу по причине отсутствия PC-Speaker. Можно бы, конечно, поискать подходящую программу, но проще написать её самому. Тем более, программирование звука — это просто!

Итак, что должна уметь делать программа? Во-первых, издавать какой-то звук. Причем используя для этого звуковую карту. А во-вторых, должна быть консольной с возможностью указания времени звучания в командной строке.

Чтобы проигать какой-то звук я решил использовать библиотеку libao — очень простую в использовании и удобную. При этом ещё и кроссплатформенную. К слову, она поддерживает ALSA, ESD, OSS, Pulse, чего должно хватить с головой.

На родном сайте есть ссылки для скачивания и подробная документация. Пользователи Debian/Ubuntu могут установить библиотеку обычным способом


sudo aptitude install libao2
sudo aptitude install libao-dev

Пакет libao2 — это сама библиотека, он нужен будет для работы программы, а libao-dev — это заголовочные файлы.

Библиотека написана на чистом C, поэтому для удобства можно обернуть все необходимые функции в класс¸ а потом, если потребуется, выделить в отдельную библиотеку. Удобство может показаться сомнительным, но лично мне в основной программе не хочется вводить посторонние переменные и писать функции для открытия/закрытия устройства. Да и забыть могу. А так всё, что нужно, прописано в конструкторе и деструкторе, а значит вызывается само собой.

Работу с библиотекой можно разбить на три этапа:

инициализация, настройка формата вывода, открытие устройства;

воспроизведение звука;

закрытие устройства и завершение работы с библиотекой.

Класс можно написать, например, такой:


class Beeper {
  private:
  ao_device *device;
  int driver;
  ao_sample_format format;

  public:
  Beeper();
  void operator() (double freq, double time, double volume = 0.75);
  ~Beeper();
};

С конструктором и деструктором всё понятно, а вот перегруженная операция вызова функции — это и есть метод класса, который издает звуки. Ему передается всего три параметра: freq — частота звучания в герцах, time — время звучания в секундах, volume — громкость (от 0.0 до 1.0).

Про инициализацию и завершение работы с библиотекой можно почитать в документации. Скажу лишь про то, как, собственно, издавать звуки. Тут потребуется вспомнить школьный курс физики, в котором говориться, что звук — это просто колебания воздуха.

Можно взять синусоиду, тогда мы получим чистый тон. Частота колебаний определяет высоту звука, а амплитуда — громкость. Тут всё просто. На практике же мы сталкиваемся со следующей проблемой: компьютер-то работает не с математическими формулами, а с числами.

Но и тут проблема легко решается. Звуковая карта получает на вход последовательность чисел, задающих амплитуду через некоторые малые промежутки времени. Количество таких отсчетов амплитуды в секунду называется частотой дискретизации. Типичное значение — это 44100 Гц. Почему именно такое число? Дело в том, что человек может слышать звуки с частотой не выше ≈20000 Гц. А по теореме Котельникова, чтобы точно передать сигнал с какой-то частотой, нужна минимум в два раза большая частота дискретизации. Хотя, для низких звуков такая высокая частота — излишество.

Другие важные параметры — это разрядность и количество каналов (моно, стерео).

Разрядность говорит, сколько бит тратится на один отсчет амплитуды. Чем больше разрядность, тем точнее передается звук. Но для обычных нужд хватит и 16 бит, то бишь двух байт. Тут возникает такой вопрос: а как хранить эти два байта? Сначала старший или младший? Это старая компьютерная проблема. Я же решил не заморачиваться и сначала помещаю младший байт, а потом старший (так называемый little-endian порядок байтов). Для указания, что используется именно такой параметр, соответствующему полю структуры, отвечающей за формат сигнала присваивается значение AO_FMT_LITTLE.

Разбить двубайтовой целое на два однобайтовых легко. Для этого можно использовать побитовое И с числом 0xFF. Это даст младщий байт, так как старшие биты будут умножены на 0. А потом можно сдвинуть все старшие биты в исходном числе на 8 бит влево и повторить процедуру.

Для 16 битного звука значения амплитуды должны быть в диапазоне от -32768 до 32767. Эти крайние величины соответствуют максимальной громкости. Если нужен звук потише, то амплитуду можно уменьшить. Амплитуда, равная 0 — это тишина.

Если мы хотим выводить звук в несколько каналов, то значения амплитуды для каждого из них чередуются.

Итак, как издать звук. Для этого в памяти создается буфер, чтоб не отправлять каждый байт поодиночке. Буфер должен иметь размер t×F×b, где t — это время звучания, F — частота дискретизации, а b — разрядность в байтах. Потом мы в цикле записываем значения синусоиды с нужной частотой и амплитудой. А затем всё это дело выводится на устройство. Подробности можно посмотреть в коде программы.

Когда класс готов, можно заняться самой пищалкой. В ней просто несколько раз повторяется звук с частотой 880 Гц (это ля второй октавы) и длительностью 0,3 с. Пауза между звукам — 0,2 с. По умолчанию сигнал повторяется 20 раз (то есть 20/(0,3+0,2)=10 с), но можно передать нужную дительность как параметр командной строки.

Как видно, работа с классом очень проста и функция main выглядит ясной и чистой.

После того, как программа скомпилирована, её можно поместить, например, в /usr/local/bin или создать deb-пакет, чтоб потом можно было поделиться с друзьями.

Использовать её просто. Например, нужно подать сигнал в 12:30, а исполняемый файл называется beep. Тогда пишем следующее:


echo "beep" | at 12:30

Если beep лежит в домашней папке, то не забываем указать путь:


echo "~/beep" | at 12:30

У at очень гибкий формат указания времени исполнения, так что рекомендую заглянуть в man.

Можно также всё это оформить в виде скрипта:


#!/bin/sh
echo "~/beep" | at $@

$@ — это специальная переменная, хранящая параметры, переданные скрипту. Так что можно будет просто написать, например:


alarm.sh 12:30

А вот вся программа в одном файле.


#include <ao/ao.h>
#include <cmath>
#include <cstdlib>

#define BITS       16
#define CHANNELS   1
#define RATE       22050

class Beeper {
private:
ao_device *device;
int driver;
ao_sample_format format;

public:
Beeper() {
 ao_initialize();
 this->driver = ao_default_driver_id();

 this->format.bits = BITS;
 this->format.channels = CHANNELS;
 this->format.rate = RATE;
 this->format.byte_format = AO_FMT_LITTLE;

 this->device = ao_open_live(driver, &format, NULL);
 if (this->device == NULL)
     exit(1);
}

void operator() (double freq, double time, double volume = 0.75) {
 int buf_size = static_cast<int>(this->format.bits/8 * this->format.channels * this->format.rate * time);
 char *buffer = new char[buf_size];
 int sample;

 for (int i = 0; i < this->format.rate * time; i++) {
     for (int c = 0; c < this->format.channels; c++) {
         sample = static_cast<int>(volume * (1<<(this->format.bits - 1)) * sin(2 * M_PI * freq * ((float) i/format.rate)));
         for (int j = 0; j < this->format.bits/8; j++) {
             buffer[this->format.bits/8*i*this->format.channels + this->format.channels*c + j] = sample & 0xff;
             sample >>= 8;
         }
     }
 }
 ao_play(device, buffer, buf_size);
 delete[] buffer;
}

~Beeper() {
 ao_close(device);
 ao_shutdown();
}
};

int main(int argc, char **argv)
{
Beeper b;

int count = (argc == 1) ? 20 : atoi(argv[1]);

for (int i=0; i < count*2; i++){
 b(880.0, 0.3);
 b(0.0, 0.2);
}

return 0;
}

Компилируется командой


g++ -lao -o beep beep.cpp

Вот, вкратце всё. Не забываем покритиковать! ;)

Ввод специальных символов или «типографские раскладки»

2009-05-06T00:07:00.007+03:00

Наверняка многие пользователи хотели бы вводить различные специальные символы вроде кавычек-ёлочек («») или длинного тире (—) простыми сочетаниями клавиш, но не знают как. И остается им облизываться на раскладку Бирмана, для которой в Windows есть удобный установочный пакет. Либо копаться по форумам и выполнять загадочные действия: что-то скачивать, что-то где-то править в здоровенном xml-файле. А то и вовсе использовать старую добрую таблицу символов.

Однако, всё что нужно, уже может быть в вашем дистрибутиве!

Дело в том, что существуют специальные клавиатурные раскладки, позволяющие вводить спецсимволы при помощи нажатия особой клавиши одновременно с какой-то из обычных клавиш клавиатуры. Например, после нажатия правого Alt и > получается знак ». Всё просто и легко запоминается (» похожа на >). Такие раскладки и называются типографскими.

К сожалению, я сейчас использую только Ubuntu 9.04 и не могу сказать, верно ли сказанное в других дистрибутивах.

В старых версиях для того, чтобы использовать все возможности и удобства расширенной раскладки, мне пришлось (по совету с какого-то сайта) править несколько файлов со списками раскладок, что неудобно, да и неправильно, так как эти файлы принадлежали пакету xkb-data.

После установки Ubuntu 9.04, я хотел было уже опять искать в сети способ включить типографскую раскладку, но тут случайно обнаружил, что всё уже есть в самой системе. Достаточно лишь зайти в настройки клавиатуры («Система» → «Параметры» → «Клавиатура» → вкладка «Раскладки» → «Параметры раскладки») и включить соответствующую галочку.

Теперь пару слов о том, как же теперь эти символы вводить. В качестве «волшебной клавиши» для ввода по умолчанию используется правый Alt, но это можно изменить в том же окне в разделе «Key to choose 3rd level».

Раскладка, конечно не такая богатая, как некоторые другие, но всё, что нужно позволяет легко вводить. Вот несколько полезных сочетаний:

Alt-> »
Alt-< «
Alt-- —
Alt-. …

Остальные можно посмотреть, распечатав раскладку в том же окне настроек клавиатуры.

Несколько слов для тех, кто не хочет или не может пользоваться гномовским клавиатурным настройщиком. Активировать расширенные раскладки можно командой setxbmap. Пример того, как это сделать, я подсмотрел на сайте Сергея Столярова.

setxkbmap -option grp:caps_toggle -option grp_led:caps -layout us+typo,ru:2+typo

Эта команда задаёт способ переключения (grp:capstoggle, т.е. клавишей Caps Lock), индикатор, используемый для отображения раскладки (grpled:caps, т.е. индикатор Caps Lock), а также непосредственно раскладки (us+typo и ru:2+typo). Как можно заметить, слой с дополнительными символами добавляется к обеим раскладкам (us и ru).

Если вы используете другой способ настройки XKB, то вы должны там заменить us на us+typo и ru на ru:2+typo.

Upd. Я забыл упомянуть (спасибо пользователю konkere за подсказку) о другом, даже более мощном штатном способе ввода спецсимволов — клавише Compose. О нём довольно много написано в интернете, поэтому отсылаю читателя к википедии и гуглу. Скажу лишь о некоторых недостатках этого способа.

Чтобы ввести сочетание Compose + > + > нужно переключаться в английскую раскладку, так как в русской нет символа >. (Имеется в виду обычная русская раскладка, которую можно видеть на клавиатуре. Расширенная русская позволяет вводить как < и > — Alt-Shift-б и Alt-Shift-б — так и квадратные и круглые скобки без дополнительных переключений.) Можно, конечно, использовать ~/.XCompose, что было бы очень удобно, так как позволяет создавать свои раскладки, но в гномовских приложениях используется другой метод ввода и файл с настройками просто проигнорируется.

Upd. 2 Ещё рекомендую включить опцию «Unicode additions».

Тогда можно будет указанным выше способом вводить при помощи цифровой клавиатуры стрелки (←→⇐⇒) и некоторые математические операторы (⋅×÷).

Upd. 3 Пользователь pluton натолкнул меня на мысль об еще одном способе ввода символов — по их коду в Unicode. Для этого нужно нажать Ctrl-Shift-U. Появится маленькая подчеркнутая буква u, после которой нужно ввести 16-ричный код символа и нажать пробел. К сожалению, использовать этот способ для ввода текстов в Firefox не получится, так как там это сочетание клавиш, по-видимому, уже используется для отображения исходного кода посещённой страницы. Но в текстовых редакторах (например в gedit) этот способ может пригодиться (если, конечно, вы помните все коды Unicode ;)).