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.

Anúncios

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.

Começando no Erlang

Olá, sou o mais novo membro do Pognation (vulgo blog do Stallone xD) e vou começar a postar sobre minhas experiências malucas com linguagens, começando com ERLANG.

Segundo o sagrado Wikipedia, Erlang é uma linguagem de programação concorrente e funcional, dinâmicamente tipada. Originalmente desenvolvida pela Ericsson, liberada como opensource em 1998.

O paradigma funcional (Haskell, OCaml, F#, só para citar alguns outros exemplos) é difícil de “digerir” para o desenvolvedor acostumado somente com Orientação a Objetos (no meu caso, Delphi, Ruby, C#, Java, Python). Mas como acredito que aprender uma linguagem nova me torna melhor em outras (know your enemy! Brincadeirinha ^^), vamos matar esse leão!

Ah, estou no Archlinux, então se virem para instalar o Erlang em suas distros favoritas :P

01 – Instaladno o Erlang

# pacman -S erlang

Assim teremos o ambiente Erlang instalado e sua shell, o erl.

Abra a shell do Erlang:

$ erl
<em>Erlang (BEAM) emulator version 5.6.3  [smp:2] [async-threads:0] [hipe] [kernel-poll:false]
Eshell V5.6.3  (abort with ^G)
1>

Vamos brincar com a calculadora:

1> 4*4.
<em>16
2>

OBS.: Nunca se esqueça do ponto(.) no final da expressão!

Ficar mofando no shell é maçante, então vamos criar um programa de exemplo (feche o erl com CTRL + C, depois A):

Abra seu editor favorito e crie o arquivo exemplo.erl com este conteúdo:

-module(exemplo).
-export([double/1]).
double(X) -> 2*X.

Programação funcional é meio estranha, mas não é difícil entender que este programa dobra o valor de um número.

Agora abra o erl novamente, na mesma pasta do programa de teste e compile-o:

1> c(exemplo).
<em>{ok,exemplo}

E agora veja o resultado chamando o nosso “programa”:

2> exemplo:double(10).
<em>20
3>

Agora vamos explicar algumas coisas neste programa:

-module(exemplo).

Programas Erlang são criados em arquivos de texto com a extensão .erl, e o nome do arquivo deve ser igual ao nome do módulo(uma convenção semelhante ao Java). Quando usamos uma função em outro módulo, a sintaxe padrão é nome_do_módulo:nome_da_função(argumentos). Por isso temos:

2> exemplo:double(10).

A segunda linha do programa nos informa que o módulo exemplo contém uma função chamada double que recebe um argumento(X em nosso exemplo) e que esta função pode ser chamada fora do módulo exemplo(algo como encapsulamento público):

-export([double/1]).

Tudo bem até aqui, certo? Respirem fundo para o exemplo clássico de programa que calcula o fatorial de um número:

fatorial.erl
<em>-module(fatorial).
-export([fac/1]).
fac(1) -> 1;
fac(N) -> N * fac(N - 1).

Compile o programa no erl:

1> c(fatorial).
<em>{ok,fatorial}

E faça um teste calculando o fatorial de 4:

2> fatorial:fac(4).
<em>24

Agora vamos às explicações:

A primeira linha de código da função:

fac(1) -> 1;

Nos diz que o fatorial de 1 é 1, e o “;” indica que há mais “exemplos” desta função.

Na segunda e última linha:

fac(N) -> N * fac(N-1).

Utilizamos a recursividade para calcular o fatorial do argumento que será passado à função, aliás, acostumem-se com isso, pois loops são todos feitos assim no Erlang! *head explodes*

Esse foi o primeiro de uma série de posts sobre minhas aventuras no paradigma funcional, estou aprendendo ainda, mas espero poder dividir isto com a galera esperta que frequenta o blog :)

Django Pagination – Paginação fácil no Django

Estava eu, rodando pela internet no site da comunidade oficial do django quando me deparei com dois novos screencasts nesse site, e como sou bem curioso fui olhar.

O primeiro nem me chamou muito a atenção, a não ser pelo nível de organização do cara que é bastante interessante, porém no segundo ele apresentou uma aplicação chamada django-pagination, que torna muito fácil fazer paginação utilizando o framework django.

A utilização da mesma se dá de maneira bem fácil e é sobre isso que vou discorrer neste artigo, de acordo com as alterações que o autor do artigo original citou no screencast.

01 – Instalando a django-pagination para ser usada em todos os projetos;

Como feito no primeiro screencast (que citei o site acima) eu instalei a django-pagination junto com o meu django e em seguida linkei para o site-packages para poder ser usada em qualquer projeto, vamos então aos passos:

a) Baixe o source do google-source pelo SVN:

# cd /var/www/apps/python/
svn checkout http://django-pagination.googlecode.com/svn/trunk/ django-pagination

Logo após terminar, registre no site-packages do seu sistema, como eu uso o Archlinux, e sendo ele um *nix que suporta bash… resolvi usar o script pylink citado pelo autor para fazê-lo de maneira mais prática:

b) Crie o script em um arquivo chamado pylink:

pylink

#!/bin/bash ln -s `pwd`/$1 `python -c "from distutils.sysconfig import get_python_lib; print get_python_lib()"`/$1

c) Dê permissão para que os usuários possam utilizá-lo:

# chmod 755 pylink

Aqui no Archlinux eu também linkei ele para uma pasta de binários locais que eu utilizo:

# ln -s `pwd`/pylink /usr/local/bin/pylink

d) Agora é só utilizá-lo para adicionar o pagination no site-packages do seu sistema:

 # cd django-pagination/
# pylink pagination

Com o django-pagination instalado podemos então modifcar o projeto:

02 – Alterando o arquivo settings.py do projeto;

Primeiramente é preciso adicionar os TEMPLATES_CONTEXT_PROCESSORS logo embaixo das MIDDLEWARE_CLASSES no arquivo settings.py do projeto no qual estaremos instalando a aplicação django-pagination:

settings.py

TEMPLATE_CONTEXT_PROCESSORS = ( "django.core.context_processors.auth", "django.core.context_processors.debug", "django.core.context_processors.i18n", "django.core.context_processors.media", "django.core.context_processors.request", )

Logo após também é necessário adicionar a aplicação pagination no seu settings.py:

settings.py

INSTALLED_APPS = ( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.admin', 'twitter', 'pagination', )

E, em seguida adicionar o middleware da aplicação também no arquivo settings.py do projeto:

settings.py

MIDDLEWARE_CLASSES = ( 'django.middleware.common.CommonMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.middleware.doc.XViewMiddleware', 'pagination.middleware.PaginationMiddleware', )

Por incrível que pareça não é necessário alterar nada nos models nem nas views do projeto e simplesmente alterando o templete conseguimos implementar a paginação utilizando a django-pagination.

03 – Alterando o template:

As alterações no template consistem em:

a) Adicionar a tag {% load pagination_tags %} no topo do template:

public.html

{% load pagination_tags %} <html>

b) Adicionar a tag {% autopaginate v n %} antes do loop que vai preencher a página. Onde v é a variável que contém os registros que vamos carregar no loop e n é o número de registros que queremos exibir por página, sendo o n padrão igual a 20. Segue um exemplo:

public.html

{% autopaginate tweets 10 %} {% for tweet in tweets %} <p><b>{{ tweet.user.username }}</b> said: {{ tweet.message }}</p> {% endfor %}

c) Adicionar a tag {% paginate %} logo após o loop, para aparecer o rodapé de navegação na página:

public.html

{% autopaginate tweets 10 %} {% for tweet in tweets %} <p><b>{{ tweet.user.username }}</b> said: {{ tweet.message }}</p> {% endfor %} {% paginate %}

E vualá, você terá 10 registros sendo exibidos por página…

Você pode se perguntar: Eu estou carregando todos os registros para somente apresentar 10 por vez, e vou recarregar toda vez que eu mudar de página? Isso vai ficar muito lento!

Exatamente, se você adicionar a tag {% autopaginate v n %} antes do seu loop só serão carregados os registros dá página em que você estará navegando. Então segundo as palavras do próprio autor: Você não precisa nem hesitar em não usar a django-pagination em seus projetos.

Obrigado pela atenção e até a próxima.