Montando um ambiente de desenvolvimento Python / Django no Mac OSX

Depois de muito não encontrar nada para postar aqui, e ter meus problemas todos sanados por artigos já escritos na internet. Encontrei algo útil quando fui instalar meu velho amigo framework Django com a biblioteca PIL assim como uma atualização da linguagem de programação Python, da versão 2.6.1 para versão 2.6.4.

Antes de mais nada o Ambiente:

Mac OS X 10.6.2 (Snow Leopard)
Python 2.6.4
IPython 0.10
PIL 1.1.7
Django 1.1.1

Vamos então aos procedimentos realizados:

Para chegar a este resultado, primeiramente instale o Mac Ports, você pode encontrar ele aqui e se
ainda tiver alguma dúvida para a instalção do mesmo, é só ir até a página do projeto

Já com o Mac Ports instalado, vamos instalar a Python 2.6.4, para tal basta chamar o comando de um terminal:

$ sudo port install py26-ipython

Obs: Porque eu pedi para instalar direto o IPython? Simples, eu acredito que a maioria das pessoas que programem em Python gostam de aproveitar dos recursos do IPython, sendo assim e, chamando o comando de instalação do mesmo pelo MacPorts, o MacPorts já resolve todas as dependências (dentre elas a linguagem de programacao
Python) e instala tudo perfeitamente.

Até aqui você já tem metade dos ítens do seu ambiente instalados, agora ficou faltando só falar para o Mac OSX qual versão da Python você deseja utilizar quando chamar o comando ” $ python ” do terminal. Sendo assim, para que o Mac OSX chame a versão que o Mac Ports terminou de instalar, você vai precisar baixar um software que lhe auxiliará nesta tarefa também através do Mac Ports:

$ sudo port install python_select

Já com o python_select instalado, chame o comando:

$ sudo python_select python26

Com isso, você acabou de dizer para o Mac OS X que quando você chamar o comando ” $ python” de um terminal, é para ele chamar a shell da versão mais nova, ou seja, da versão 2.6.4.

Ficou faltando só instalar o Django e a PIL correto? Vamos lá então.

Antes de mais nada, você vai notar que ao chamar o comando ” $ ipython ” de um terminal ele vai abrir a shell da Python 2.6.1, que veio com o sistema operacional. O comando correto é ipython-2.6. E o comando ” $ easy_install ” segue esta mesma lógica que vai precisar ser chamado pelo ” $ easy_install-2.6 ” então para instalar o Django chame do terminal:

$ sudo easy_install-2.6 django

E pronto, já temos o framework Django 1.1.1 instalado corretamente. Para melhorar o ambiente de desenvolvimento, também seria interessante adicionar o comando ” $ django-admin.py ” na sua pasta ~/bin/ para que você possa chamar o mesmo de qualquer local do sistema, para isso, chame os seguintes comandos:

$ cd ~/bin/
$ ln -s /opt/local/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages/Django-1.1.1-py2.6.egg/django/bin/django-admin.py django-admin.py

Ainda falta a PIL, vamos lá então. Para instalar a PIL (Python Image Library). Você precisa ter instalada a biblioteca libjpeg no seu sistema operacional, caso não tenha ainda, instale através do Mac Ports:

$ sudo port install jpeg

Depois vá até o site da PIL e baixe o Source Kit da versão (no nosso caso 1.1.7) que pode ser encontrado aqui

Vá até a pasta onde você realizou o download do arquivo e abra o mesmo. Depois de um terminal vá até a pasta gerada e chame o comando:

$ sudo python setup.py install

Pronto, tudo funcionando perfeitamente e sem dor de cabeça.
Até a próxima.

Hospedando repositórios git com gitosis em um servidor Arch Linux

Ontem resolvi me propor novos desafios e criar um repositório git dentro do meu servidor para projetos pessoais. Antes, eu somente era um usuário da ferramenta, e para montar tal repositório, fui buscar informações com quem havia me dado algumas dicas no início: visitem a wiki do nofxx. Além de algumas explicações e configurações rápidas para o aprendizado da linguagem, também há um screencast muito interessante.

Depois de procurar sobre informações na internet, ele me indicou a gitosis. Uma ferramenta para hospedar repositórios git. Sendo assim, achei alguns artigos que me fizeram ter uma ou outra dor de cabeça, e eis que resolvi escrever o meu.

Instalando a gitosis

Antes de mais nada, faz-se necessária a instalação do git (obviamente) e da python (para instalar a gitosis). Para os dois há pacotes prontos no repositório oficial extra. Utilizando o pacman:

# pacman -S git python

Já com os programas instalados, é preciso criar um novo usuário onde vão residir os arquivos hospedados em disco. Para tal criei um usuário denominado git:

# adduser

Obs: Atenção na hora de criar o usuário, o mesmo pode ter qualquer nome, porém não será possível realizar acesso ao mesmo através do ssh mais tarde, somente acesso físico. Ou seja, uma vez os repositórios criados, o gitosis bloqueia o ssh do usuário para somente acesso via git.

Com o novo usuário já logado, baixe a gitosis através do repositório:

$ cd
$ git clone git://eagain.net/gitosis.git

Para instalá-la, execute o seguinte procedimento:

$ cd gitosis
# python setup.py install

A instalação da gitosis irá criar um repositório inicial na pasta ~/repositories/gitosis-admin.git.

Volte ao seu computador. Caso não haja uma chave de ssh pública ainda, crie uma através do comando:

$ ssh-keygen -t rsa

A chave pública criada geralmente fica em ~/.ssh/id_rsa.pub, utilize o scp para copiar o arquivo para o servidor:

$ scp ~/.ssh/id_rsa.pub git@ENDERECO_DO_SEU_SERVIDOR:/tmp

Obs: Note que git é o nome do usuário criado no servidor anteriormente.

Voltando para o servidor, inicie o servidor da gitosis com a chave copiada e altere a permissão do arquivo post-update:

$ gitosis-init < /tmp/id_rsa.pub
$ chmod 755 ~/repositories/gitosis-admin.git/hooks/post-update

Agora, no seu computador, clone o repositório da gitosis para manipulação do servidor criado:

$ mkdir ~/projects
$ cd ~/projects
$ git clone git@ENDERECO_DO_SEU_SERVIDOR:gitosis-admin.git

Adicionando um novo repositório

Toda manipulação dos repositórios controlados pela gitosis se faz através do arquivo gitosis.conf, encontrado dentro do repositório clonado. Para criar um novo repositório, adicione o seguinte conteúdo ao arquivo gitosis.conf:

$ emacs ~/projects/gitosis-admin/gitosis.conf


[group nome_do_projeto]
writable = nome_do_projeto
members = usuario_do_seu_computador

Obs: não esqueça de apertar <ENTER> ao terminar a linha members.

Obs2: para encontrar encontrar qual conteúdo correto para utilizar na variável usuario_do_seu_computador procure no final da chave pública gerada anteriormente. Por exemplo, usuario@archlinux.

Com o arquivo editado, crie um commit para o mesmo:

$ git commit -a -m "Adicionando permissão ao usuário usuoario_do_seu_computador para o projeto nome_do_projeto."

E logo após de um push para o repositório no seu servidor:

$ git push

Logo em seguida, crie um repositório local para o novo projeto:

$ mkdir ~/projects/new_project
$ cd ~/projects/new_project
$ git init
$ git remote add origin git@ENDERECO_DO_SEU_COMPUTADOR:new_project.git

Então crie algum conteúdo, um commit e faça o push inicial.

$ touch README.txt
$ git add README.txt
$ git commit -m "Criando o repositório"
$ git push origin master:refs/heads/master

Obs: caso ocorra algum erro, preste atenção nas chaves públicas utilizadas e nos dados no arquvio gitosis.conf.

Adicionando novos usuários

O processo pra adicionar novos usuários aos repositórios controlados pela gitosis é bem fácil. Basta copiar os arquivos de chaves públicas dos mesmos para a pasta keydir do repositório renomeando para o nome de usuário e host aos quais os arquivos pertencerem. Segue um exemplo:

Usuário lhe manda o arquivo id_rsa.pub como usuario_pog@computer_do_pog, para achar esses detalhes basta ler o final do arquivo com o cat:

$ cat id_rsa.pub

Sendo assim, faz-se necessário copiar o arquivo para a pasta com o nome alterado:

$ cp id_rsa.pub ~/projects/gitosis/keys/usuario_pog@computer_do_pog

Depois é só adicionar o arquivo a um novo commit e realizar o push do mesmo:

$ cd ~/projects/gitosis/
$ git add keys/usuario_pog@computer_do_pog
$ git push

Pronto, o novo usuário já poderá acessar o repositório permitido no arquivo gitosis.conf.

DICA

Caso você tenha trocado sua porta do ssh, edite o arquivo ~/.ssh/config:

$ emacs ~/.ssh/config


host nome_do_computador
HostName 127.0.0.1
port numero_da_porta

Com essas modificações basta acessar usuario_do_computador@nome_do_computador, não precisando digitar o endereço IP do mesmo.

DICA 2

Adicione o branch master ao arquivo .git/config do repositório do novo projeto:

$ emacs ~/projects/new_project/.git/config


[branch "master"]
        remote = origin
        merge = refs/heads/master

Realizando esta operação para os branchs não é necessário indicar qual você gostaria de atualizar ao executar o comando git pull.

Configurando o Emacs 23 / Emacs cvs no Arch Linux – Parte 1

O Emacs é tratado, principalmente pelos “vim users”, como um ótimo sistema operacional porém um péssimo editor de textos. Na realidade, aprender a configurá-lo não é uma tarefa fácil, sua curva de aprendizado exige bastante dedicação e é complicado de sair da chamada, estaca zero.

Nesta série vou demonstrar como configurar o Emacs 23, atual cvs, para trabalhar com algumas linguagens de programação que eu utilizo, além de demonstrar algumas configurações pessoais. Para tal, serão usados alguns pacotes encontrados nos repositórios oficiais, alguns pacotes do AUR e outros de downloads diretos, sendo os links destes, disponibilizados durante a série.

Neste primeiro artigo, será demonstrado apenas configurações pessoais.

Para iniciar, instale o pacote emacs-cvs do repositório community:

# pacman -S emacs-cvs

Logo após vá até o arquivo ~/.Xresources e adicione:

$ emacs ~/.Xresources


! Emacs
Emacs.FontBackend: xft
Emacs.Font:Monaco-8

Para que o conteúdo acima funcione é necessário carregar o arquivo .Xresoucres na inicialização de sua interface gráfica, aqui eu utilizo a pekwm, sendo assim, basta editar o arquivo ~/.pekwm/start:

$ emacs ~/.pekwm/start


xrdb -merge ~/.Xresources &

Obs: Você pode escolher a fonte e o tamanho da mesma de acordo com sua preferência. Há algum tempo atrás, publiquei um artigo explicando como instalar a fonte Monaco no Archlinux.

Realizei algumas outras configurações pelo próprio menu gráfico do Emacs. Porém, para facilitar, basta editar o arquivo ~/.emacs e adicionar as seguintes linhas na sessão custom-set-variables.

$ emacs ~/.emacs


 '(blink-cursor-mode nil)
 '(column-number-mode t)
 '(cua-mode t nil (cua-base))
 '(current-language-environment "UTF-8")
 '(indent-tabs-mode t)
 '(indicate-buffer-boundaries (quote left))
 '(js2-indent-on-enter-key t)
 '(make-backup-files nil)
 '(py-python-command "ipython")
 '(python-python-command "ipython")
 '(python-use-skeletons t)
 '(show-paren-mode t)
 '(standard-indent 4)
 '(tab-always-ident t)
 '(tab-width 4)
 '(tooltip-mode nil))

Obs: tais cofigurações são extritamente pessoais. Caso você não deseje utilizá-las, pode cofigurar o Emacs a vontade acessando o menu Options > Customize Emacs > Top-level Customization Group.

A seguir, estão mais algumas configurações pessoais, caso não queira utilizar alguma(s) dela(s), basta pular a sessão.

Desligando o Alarm Bell
Para desligar o alarm bell, adicione ao final arquivo ~.emacs:

$ emacs ~/.emacs


;; alarmbell off
(setq visible-bell 1)
(setq ring-bell-function 'ignore)

Ativando o Syntax Hilighting
Para ativar o syntax hilighting e ter seu texto colorido de acordo com a linguagem de programação, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; turning on syntax hilighting
(global-font-lock-mode 1)

Adicionando uma nova linha no final do arquivo ao salvá-lo
Para adicionar uma nova linha ao final do arquivo quando for salvá-lo, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; autoadd new eof line
(setq require-final-newline t)

Ativando identação com tabs
Para ativar a identação com tabs em seu Emacs, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; tab ident
(setq-default indent-tabs-mode t)
(setq tabify t)
(setq c-basic-offset 4)

Ativando identação com espaços
Para ativar identação com espaços em seu Emacs, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; space ident
(setq-default ident-tabs-mode nil)
(setq tabify nil)

Obs: O Emacs realizará identação somente através de um dos dois métodos. Caso adicione os dois, ele irá utilizar o adicionado por último, para comentar uma linha utilize o caracter ponto e vírgula “;”.

Desligando a Toolbar
Para desabilitar a Toolbar (barra com ícones no topo do Emacs), adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; turn off toolbar
(tool-bar-mode -1)

Desligando a Menubar
Para desabilitar a Menubar (barra de menus), adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; turn off menubar
(menu-bar-mode -1)

Obs: meu Emacs apresentou alguns problemas de renderização ao utilizar tal configuração. Ele escondia visualmente a barra porém não removia o espaço ocupado por ela.

Limpando o lixo criado automaticamente pelo Emacs
Para apagar os arquivos salvos automaticamente e fazer com que o Emacs não salve arquivos de backup, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; clear the trash
(setq delete-auto-save-files t)
(setq make-backup-files nil)

Exibindo o número da linha em que o cursor se encontra
Para exibir o número da linha que o cursor se encontra na status bar do Emacs, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; showing line numbers
(setq line-number-mode t)

Limpando espaços em branco nos finais das linhas
Para limpar os espaços em branco nos finais das linhas, adicione no final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; clear trailing spaces
(global-set-key "C-cw" 'delete-trailing-whitespace)
(add-hook 'before-save-hook 'delete-trailing-whitespace)

Obs: Para apagar os espaços nos finais das linhas sem salvar o arquivo, utilize a combinação de teclas Ctrl+c w.

Extendendo linhas compridas
Por padrão, o Emacs quebra visualmente uma linha com mais de 80 caracteres, para desligar esta função, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; truncation of long lines
(setq truncate-lines nil)
(global-set-key "C-ct" 'toogle-truncate-lines)

Obs: Esta configuração não funcionou automaticamente no meu Emacs, porém eu utilizo a combinação de teclas Ctrl+c t para realizar tal função.

Ativando o color-theme
Para ativar os temas de cores em seu Emacs, é preciso instalar o pacote emacs-color-theme do repositório community:

# pacman -S emacs-color-theme

Logo após, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


(require 'color-theme)
(color-theme-initialize)

Agora, basta escolher qualquer tema de sua preferência. Para tal, execute dada função através da combinação de teclas Alt+x, digite color-theme- e tecle tab, será exibida uma lista com temas disponíveis. O que eu mais prefiro dentro dos padrões é o charcoal-black, porém resolvi fazer meu próprio tema extendendo o tema deep-blue.

Instalando o emacs-redpill-theme.el
Na realidade, como citado anteriormente, este tema nada mais é do que o color-theme-deep-blue extendido, porém caso queiram utilizar, criem o arquivo ~/.emacs-files/emacs-redpill-theme.el com o seguinte conteúdo:

$ emacs ~/.emacs-files/emacs-redpill-theme.el


(eval-when-compile
  (require 'color-theme))

(defun color-theme-redpill ()
  "Deep Blue theme with #242424 background."
  (interactive)
  (color-theme-deep-blue)
  (let ((color-theme-is-cumulative t))
  (color-theme-install
   '(color-theme-redpill
     ;; General
      ((background-color . "#242424"))
    ))
  )
)

;;-- Test
(color-theme-redpill)

E então para ativar o tema, adicione ao final do arquivo ~/.emacs:

$ emacs ~/.emacs


;; redpill-color-theme activation
(load-library "~/.emacs-files/emacs-redpill-theme.el")

Obs: caso não queira editar o arquvio na mão, por qualquer motivo que seje, faça o download através deste link

Nos próximos artigos, ensinarei como configurar as linguagens de programação que utilizo no meu dia-a-dia.

Corrigindo bug do hal 0.5.11 no Arch Linux

Algum tempo depois de atualizar o pacote hal do Archlinux para a versão 0.5.11 notei que os meus pendrives não estavam mais montando automaticamente, sem nem pestanejar eu comecei a utilizar o autofs novamente enquanto precisava acessar os drivers. Porém, ontem anoite, um amigo meu que utiliza o XFCE veio me perguntando se eu já havia me deparado com tal problema, e, em seguida, já me deu a solução, eu a apliquei aqui e então estou postando para não esquecer.

Na realidade você precisará editar o arquivo:

# emacs /etc/PolicyKit/PolicyKit.conf

E adicione o seguinte conteúdo:

<config version="0.1">
  <match action="org.freedesktop.hal.storage.mount-removable">
	<return result="yes"/>
  </match>
  <match action="org.freedesktop.hal.power-management.shutdown">
	<return result="yes"/>
  </match>
  <match action="org.freedesktop.hal.power-management.reboot">
	<return result="yes"/>
  </match>
</config>

Note que as tags </config> já existirão no seu arquivo PolicyKit.conf.

Logo após, faz-se necessário reiniciar as daemons:

# /etc/rc.d/fam stop
# /etc/rc.d/hal stop
# /etc/rc.d/dbus restart
# /etc/rc.d/hal start
# /etc/rc.d/fam start

E agora tudo estará funcionando perfeitamente.

Configurando o RTorrent com Screen no Arch Linux

Já faz algum tempo, quando o Azureus virou Vuze, que ando evitando o mesmo por gastar muita memória ram. Desde então venho testando vários e vários clientes de torrent no meu Archlinux.

Por causa de alguns problemas, em sua maior parte, sem tempo para configurações textuais minimalistas, terminei utilizando Kde durante o kde 4.1, e esqueci dos programas de baixo consumo de recursos.

Até então utilizando o Deluge como cliente oficial de torrents, pois não consumia tanta memória quanto o Azureus, na realidade metade, e ainda assim tinha boas configurações.

Porém, ocorreu uma queda de energia em casa e o deluge perdeu seus arquivos de status, e simplesmente bugou, perdendo todas as informações sobre os meus torrents ativos.

Sendo assim, resolvi procurar outra solução para o meu problema, e então testei o rtorrent. Eu já havia ouvido sobre o mesmo a não muito tempo atrás, porém, com a ideologia do Kde todo pronto, nunca havia parado para testá-lo.

Vamos configurar o RTorrent para trabalhar em background através do Screen.

Instalando:

Como sempre, utilize o pacman:

# pacman -Sy screen rtorrent

Configurando:

As configuração são realizadas através dos arquivos ~/.screenrc e ~/.rtorrent.rc, Screen e RTorrent respectivamente. Os arquivos de configuração são auto explicativos. Eu não alterei absolutamente nenhuma configuração do Screen e somente algumas no RTorrent, segue o meu ~/.rtorrent.rc

~/.rtorrent.rc


# This is an example resource file for rTorrent. Copy to
# ~/.rtorrent.rc and enable/modify the options as needed. Remember to
# uncomment the options you wish to enable.

# Maximum and minimum number of peers to connect to per torrent.
#min_peers = 40
#max_peers = 100

# Same as above but for seeding completed torrents (-1 = same as downloading)
#min_peers_seed = 10
#max_peers_seed = 50

# Maximum number of simultanious uploads per torrent.
max_uploads = 4

# Global upload and download rate in KiB. "0" for unlimited.
download_rate = 0
upload_rate = 22

# Default directory to save the downloaded torrents.
directory = ~/torrents/

# Default session directory. Make sure you don't run multiple instance
# of rtorrent using the same session directory. Perhaps using a
# relative path?
session = ~/torrents/.session/

# Watch a directory for new torrents, and stop those that have been
# deleted.
schedule = watch_directory,5,5,load_start=~/torrents/watch/*.torrent
schedule = untied_directory,5,5,stop_untied=

# Close torrents when diskspace is low.
schedule = low_diskspace,5,60,close_low_diskspace=1200M

# Stop torrents when reaching upload ratio in percent,
# when also reaching total upload in bytes, or when
# reaching final upload ratio in percent.
# example: stop at ratio 2.0 with at least 200 MB uploaded, or else ratio 20.0
#schedule = ratio,60,60,"stop_on_ratio=200,200M,2000"

# The ip address reported to the tracker.
#ip = 127.0.0.1
#ip = rakshasa.no

# The ip address the listening socket and outgoing connections is
# bound to.
#bind = 127.0.0.1
#bind = rakshasa.no

# Port range to use for listening.
port_range = 6890-6999

# Start opening ports at a random position within the port range.
port_random = no

# Check hash for finished torrents. Might be usefull until the bug is
# fixed that causes lack of diskspace not to be properly reported.
check_hash = yes

# Set whetever the client should try to connect to UDP trackers.
use_udp_trackers = yes

# Alternative calls to bind and ip that should handle dynamic ip's.
#schedule = ip_tick,0,1800,ip=rakshasa
#schedule = bind_tick,0,1800,bind=rakshasa

# Encryption options, set to none (default) or any combination of the following:
# allow_incoming, try_outgoing, require, require_RC4, enable_retry, prefer_plaintext
#
# The example value allows incoming encrypted connections, starts unencrypted
# outgoing connections but retries with encryption if they fail, preferring
# plaintext to RC4 encryption after the encrypted handshake
#
# encryption = allow_incoming,enable_retry,prefer_plaintext
encryption = allow_incoming,try_outgoing,enable_retry

# Enable DHT support for trackerless torrents or when all trackers are down.
# May be set to "disable" (completely disable DHT), "off" (do not start DHT),
# "auto" (start and stop DHT as needed), or "on" (start DHT immediately).
# The default is "off". For DHT to work, a session directory must be defined.
#
# dht = no

# UDP port to use for DHT.
#
# dht_port = 6881

# Enable peer exchange (for torrents not marked private)
#
peer_exchange = yes

#
# Do not modify the following parameters unless you know what you're doing.
#

# Hash read-ahead controls how many MB to request the kernel to read
# ahead. If the value is too low the disk may not be fully utilized,
# while if too high the kernel might not be able to keep the read
# pages in memory thus end up trashing.
#hash_read_ahead = 10

# Interval between attempts to check the hash, in milliseconds.
#hash_interval = 100

# Number of attempts to check the hash while using the mincore status,
# before forcing. Overworked systems might need lower values to get a
# decent hash checking rate.
#hash_max_tries = 10

Depois precisaremos criar as pastas indicadas no arquivo:

$ mkdir ~/torrents
$ mkdir ~/torrents/watch
$ mkdir ~/torrents/.session/

Utilizando:

Para utilizar o RTorrent através do Screen é muito fácil. Abra seu terminal e digite:

$ screen

Isso fara com que uma sessão do screen seja aberta, agora chame o RTorrent dentro da sessão aberta:

$ rtorrent

E o RTorrent já estará carregado dentro do screen.

Para sair do screen e manter o RTorrent aberto faça a combinação de teclas:

Ctrl + A, solte as duas e em seguida tecle D.

O Screen será “detached” e continuará rodando o RTorrent em background. Para retornar a sessão do Screen basta digitar o comando:

$ screen -r

Para fechar o RTorrent digite a combinação de teclas:

Ctrl + q

Para fechar o Screen primeiramente feche o RTorrent e logo em seguida digite:

$ exit

Para adicionar torrents há várias maneiras, porém eu me utilizo simplesmente da pasta watch que criamos. Para tal basta mover o arquivo.torrent para dentro dela:

$ mv arquivo.torrent ~/torrents/watch/

Para remover os torrents, adivinhem, basta remover ou mover o arquivo.torrent da pasta watch:

$ rm ~/torrents/watch/arquivo.torrent

ou

$ mv ~/torrents/watch/arquivo.torrent ~/

Para maiores informações de como utilizar os comandos internos do RTorrent acesse o manual do usuário do mesmo.

Como nota final, o RTorrent e o Screen mais todas as bibliotecas necessárias para o seu funcionamento ocupam singelos 15 Megabyes de memória ram.

Até a próxima.