Py4A – Python w Androidzie to wpis z FLLOGa

pierwsza_zmienna_od_długiej_nazwie                = 1
druga                                             = 2
trzecia_zmienna                                   = 3
czwarta_zmienna_o_długiej_nazwie_i_jeszcze_trochę = 4

Piękne, prawda? Ostatnią dodałem specjalnie najdłuższą aby pokazać bzdurność takiej konstrukcji. Po jej dodaniu musiałem przesunąć inne znaki przypisania w zmiennych wpisanych wcześniej!! Cóż za prostota rozwiązania.

dict = {
'pierwsza'                                          : 1,
'druga'                                             : 2,
'trzecia_zmienna'                                   : 3,
'czwarta_zmienna_o_długiej_nazwie_i_jeszcze_trochę' : 4
}

Kolejny cudowny przykład.
Uważam to za błąd w każdym języku ponieważ to zaciemnia tylko kod i wymusza liczenie spacji a potem przerabianie całej konstrukcji w wypadku gdy dodaje się zmienną o dłuższej nazwie. Taka metoda musi być popularna wśród szachistów gdzie ruchy należy planować odpowiednio przed.
Proszę nie piszcie tak. Szachiści również.

Przedszkole w edytorze to wpis z FLLOGa

pip install pep8 pyflakes

Natomiast flymake-cursor już trzeba ręcznie skopiować i zapisać jako flymake-cursor.el na ścieżce z plikami el. Ja zapisałem w /usr/share/emacs/site-lisp. Kolejny krok to modyfikacja pliku konfiguracyjnego .emacs. Należy dokleić do niego poniższy kod.

(add-hook 'find-file-hook 'flymake-find-file-hook)
(when (load "flymake" t)
  (defun flymake-pyflakes-init ()
    (let* ((temp-file (flymake-init-create-temp-buffer-copy
               'flymake-create-temp-inplace))
       (local-file (file-relative-name
            temp-file
            (file-name-directory buffer-file-name))))
      (list "pycheckers"  (list local-file))))
   (add-to-list 'flymake-allowed-file-name-masks
             '("\\.py\\'" flymake-pyflakes-init)))
(load-library "flymake-cursor")
(global-set-key [f10] 'flymake-goto-prev-error)
(global-set-key [f11] 'flymake-goto-next-error)

Ostatni krok to stworzyć plik o nazwie pycheckers gdzieś w PATH oraz ustawić go jako wykonywalny. W tym miejscu można skonfigurować sobie pep8, przydatne gdy wcięcia kodu nie są wielokrotnością 4.

#!/bin/bash

pyflakes "$1"
pep8 --ignore=E221,E701,E202 --repeat "$1"
true

Tyle wystarczy, pozostaje restart Emacsa lub M-x eval-buffer w otwartym buforze z plikiem .emacs i już można korzystać.
Całość to właściwie opis ze strony http://www.saltycrane.com/blog/2010/05/my-emacs-python-environment/ i polecam zajrzeć do źródła gdzie można znaleźć parę innych smaczków do emacsa.

devs y u no pep8 in Emacs to wpis z FLLOGa

from django.db import models

class Kostka(models.Model):
    wynik = models.IntegerField()
    osoba = models.CharField(max_length = 10, default = 'Anonim')

    def _sprawdz_liczbe(self):
        if (wynik % 2):
            return 'Parzysta'
        else:
            return 'Nieparzysta'

    test_wyniku = property(_sprawdz_liczbe)

Na tym modelu chcemy wykonać następujące testy:

• Tworzenie obiektu (pole ‘wynik’ nie posiada wartości domyślnych)
• Tworzenie obiektu z wartością domyślną
• Test parzystości wyniku

Wszystkie testy dobrze trzymać w osobnym pliku, który nota bene jest tworzony wraz z projektem, plik tests.py znajduje się w katalogu aplikacji. Jest to wygodne i pozwala w łatwy sposób odnaleźć wszystkie testy w danej aplikacji. Zaczynamy od importów oraz stworzenia klasy testu.

import unittest
from aplikacja.app.models import Kostka

class KostkaTestCase(unittest.TestCase):

Następnym krokiem jest przeładowanie metody setUp() w celu stworzenia zmiennych lub obiektów odpowiadających naszym wymaganiom. Jak w pythonie i tutaj możliwe jest przeładowanie metod tearDown(), runTest() i suite() ale nie jest to konieczne. W opisywanym przypadku tworzone są trzy właściwości które posłużą później do tworzenia obiektów; rzutu parzystego, nieparzystego, zwykłego rzutu oraz anonimowego rzutu testującego wartość domyślną.

class KostkaTestCase(unittest.TestCase):
    def setUp(self):
        self.osoba = 'Michal'
        self.liczba_parzysta = 4
        self.liczba_nieparzysta = 5

Teraz czas na przygotowanie testów. Na pierwszy ogień idzie test tworzenia obiektu z podanymi obiema wartościami: osoba i wynik. Test powinien przejść bez żadnych problemów.

class KostkaTestCase(unittest.TestCase):
...
    def test_tworzenie_obiektu(self):
        rzut = Kostka.objects.create(self.liczba_parzysta, self.osoba)
        self.assertTrue(rzut)
        self.assertEqual(rzut.wynik, 4)
        self.assertEqual(rzut.osoba, 'Michal')

Następny test to sprawdzenie czy pole osoba przyjmuje wartość domyślną.

class KostkaTestCase(unittest.TestCase):
...
    def test_wartosci_domyslnej(self):
        rzut_anonim = Kostka.objects.create(self.liczba_parzysta)
        self.assertTrue(rzut_anonim)
        self.assertEqual(rzut_anonim.osoba, 'Anonim')

Kolejny test i ostatni, którego kod zaprezentuję to test parzystości. Drugi test jest analogiczny i nie widzę potrzeby umieszczania kodu. W tym przypadku nie testujemy czy obiekt został stworzony ponieważ jest to w poprzednich testach.

class KostkaTestCase(unittest.TestCase):
...
    def test_parzystosci(self):
        rzut_parzysty = Kostka.objects.create(self.liczba_parzysta)
        self.assertEqual(rzut_parzysty.test_wyniku, 'Parzysty')

To wszystkie potrzebne testy, w tym momencie można je uruchomić i sprawdzić czy nasze testy lub model są poprawne. Do wykonania tego służy znany wszystkim manage.py.

./manage.py test app

Jeśli wszystko pójdzie dobrze to powinien ukazać się następujący listing, jeśli nie to opis błędu jest na tyle jasny (czasem stworzony przez nas), że szybko można poprawić test lub model.

----------------------------------------------------------------------
Ran 4 tests in 0.009s

OK
Destroying test database 'default'...

Jak widać jest to łatwe i przyjemne oraz w pełni zgodne z Pythonem. Koniec, wszystkim życzę 100% skuteczności wykonywanych testów.

django: unittest to wpis z FLLOGa

import os
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
....
TEMPLATE_DIRS = (
    BASE_DIR + '/templates/'
)

Dzięki temu niezależnie od wersji aplikacji ścieżka do templates będzie poprawna. Teraz czas na ładowanie haseł oraz innych ścieżek. To wygląda mniej przyjemnie z punktu widzenia urody kodu. Chociaż ostatni przykład do najpiękniejszych również nie należy.
Ja użyłem następującego rozwiązania. Do pliku settings.py dodałem zmienną, której wartość określa jaki plik ma zostać zaimportowany.

MODE = 'DEVEL'

A następnie kod, który załaduje odpowiedni plik.

if MODE == 'PROD':
    try:
        from settings_prod import *
    except:
        pass
else:
    try:
        from settings_devel import *
    except:
        pass

Użycie komendy else spowoduje załadowanie ustawień deweloperskich w wypadku braku MODE lub literówki, przydatne gdy masz dostęp z jednej maszyny do obu baz danych i jesteś zapominalski. Teraz pliki settings ładujesz do aplikacji i zmieniasz MODE w zależności od trybu pracy.
Wracając do pliku urls.py, a dokładnie chodzi mi o wpis

(r'^templates/static/(?P<path>.*)$',
'django.views.static.serve',
{'document_root': os.path.join(os.path.dirname(__file__), '/home/michal/Projects/django/gdzie_byl_kaziu/templates/static')}),

W wersji produkcyjnej za serwowanie plików statycznych jest odpowiedzialny serwer www ale to też można zmodyfikować jeśli będzie taka potrzeba. Urlpatterns można rozszerzać, na przykład

if settings.MODE == 'LOCAL':
    urlpatterns += patterns('',
                            (r'^templates/static/(?P<path>.*)$',
                             'django.views.static.serve',
                             {'document_root': os.path.join(os.path.dirname(__file__), '/home/user/projects/templates/static')}))

Zaprezentowane rozwiązanie nie jest idealne ponieważ nadal trzeba pilnować jaki tryb jest włączony ale dużo bardziej wygodne niż komentowanie całych linijek w settings.py. Z miłą chęcią przeczytam o innych sposobach rozdzielania ustawień.

django: settings.py aplikacji w trybie devel i production to wpis z FLLOGa

• ssh

To naprawdę proste, wymieniamy się po prostu kluczami z serwerem gdzie leży nasz cenny kod. Pierwsze czego potrzeba to para kluczy publiczny/prywatny. Można je wygenerować poleceniem

ssh-keygen -t rsa

Następnie kod publiczny należy dołączyć do pliku authorized_keys na serwerze. Napisałem „dołączyć” bo mogą tam być już inne klucze.

cat ~/.ssh/id_rsa.pub | ssh login@serwer 'cat - >> ~/.ssh/authorized_keys'

Po tej operacji wystarczy sprawdzić czy operacja się udała i zalogować się

ssh login@serwer

• sshfs

Kolejny sposób to zamontowanie zdalnego folderu u siebie, można to osiągnąć poprzez sshfs. Nie wygląda jakby ten pakiet był instalowany domyślnie, a dokładniej to ja go nie miałem. Znajduje się on w paczce o nazwie fuse-sshfs. Po instalacji wystarczy zamontować zdalny zasób poleceniem.

sshfs -oworkaround=rename,follow_symlinks login@serwer:/zdalna/sciezka/ /lokalna/sciezka

Użyłem follow_symlinks na wpadek gdyby w zamontowanym folderze były jakieś linki, nie powinno się to zdarzyć jeśli linkujesz do kodu, ale na wszelki wypadek. Ta metoda pyta o hasło tylko raz. Następnie można już używać bzr na tym zamontowanym zasobie.

bzr pull /lokalna/sciezka
bzr push /lokalna/sciezka

Odmontowanie zasobu nastąpi po wykonaniu

fusermount -u /sciezka/lokalna

lub

umount /sciezka/lokalna

Mam nadzieję, że ułatwi to życie tym, którzy mają po dziurki w nosie wpisywania swojego hasła.
P.S.
Tak, trafił mnie szlag więc napisałem żeby innym oszczędzić nerwów.

Z warsztatu kodera: po co te hasła? to wpis z FLLOGa

bzr branch lp:bzr-push-and-update ~/.bazaar/plugins/push_and_update

Po commicie wystarczy bzr push. Uciążliwe może się stać wklepywanie haseł, ale jest to lepsze niż przeglądanie historii poleceń konsoli lub wpisywanie litanii ssh looser@serwer… od nowa.

Z warsztatu kodera: bzr push-and-update to wpis z FLLOGa

su -c 'cd /etc/yum.repos.d/ && wget baseroot.info/devilish.repo'

A potem już tradycyjnie

sudo yum install django-extensions

.
Następnie dodajemy django-extensions do pliku settings i jazda. Podpowiem jedną komendę

./manage.py shell_plus

Resztę można odnaleźć w dokumentacji, do której odsyłam.
Pokój.

django-extensions w repo devilish to wpis z FLLOGa

1. Instalacja Dajaxice

Pobieramy kod ze strony http://github.com/jorgebastida/django-dajaxice/downloads i rozpakowujemy do katalogu z aplikacją. Następnie edytujemy plik settings.py naszego projektu i dodajemy dajaxice do listy aplikacji.

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

Następnie upewniamy się, że TEMPLATE_LOADERS w tym samym pliku wygląda tak

TEMPLATE_LOADERS = (
	'django.template.loaders.filesystem.load_template_source',
	'django.template.loaders.app_directories.load_template_source',
	'django.template.loaders.eggs.load_template_source',
)

Ostatni wpis w pliku settings.py wygląda tak

DAJAXICE_MEDIA_PREFIX="dajaxice"

Co stworzy nam adres o postaci http://www.domena.pl/dajaxice. Zostawiamy ten plik i przechodzimy do urls.py. Ten wpis nie jest do końca potrzebny, ja go nie posiadam i u mnie działa to bezbłędnie.

from dajaxice.core import dajaxice_autodiscover
dajaxice_autodiscover()

Dodajemy linijkę do listy urli aby to mogło zadziałać

(r'^%s/' % settings.DAJAXICE_MEDIA_PREFIX, include('dajaxice.urls')),

oraz import

from django.conf import settings

Koniec instalacji dajaxice. Kolejny element do dajax.

2. Instalacja Dajax

Kod jest do pobrania ze strony http://github.com/jorgebastida/django-dajax/downloads. Rozpakowujemy i dorzucamy wpis do settings.py.

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'dajaxice',
    'dajax',
    ...
)

Koniec instalacji, teraz przechodzimy do mięsa czyli jak to wszystko zakodować.

3. KOD

Zakładam, że posiadasz jakąś aplikację w której chcesz dołożyć dajax. W swoim pliku bazowym, tym którego używasz w tagu {%extends%} dołóż dwa dodatkowe tagi (oczywiście, jeśli chcesz korzystać z dobrodziejstw Dajax na wszystkich swoich podstronach)

{% load dajaxice_templatetags %}

oraz w head

{% dajaxice_js_import %}

a także import wybranego przez Ciebie pliku, w zależności od używanego frameworka js. Może to być jQuery, Prototype, MooTools lub Dojo.
Import oczywiście należy wsadzić do head. Ja wybrałem jQuery.

<script src="{{ MEDIA_URL }}/js/jquery.dajax.core.js" type="text/javascript" charset="utf-8"></script>

Powyższy plik znajduje się w katalogu z instalacją dajax i należy go skopiować do swojego katalogu site_media.
Już prawie koniec, jedyna rzecz jaka pozostała to napisać trochę kodu pythona odpowiedzialnego za ajax. Autorzy i ja się dołączam do nich radzą cały kod umieszczać w pliku ajax.py. Podam przykład funkcji dodającej dwie liczby, oczywiście możliwości są nieskończone.

def dodawanie(request, a, b):
    dajax = Dajax()
    result = int(a) + int(b)
    dajax.assign('#koniec','value',str(result))
    return dajax.json()

dajax.assign przypisze do obiektu DOM o id równym wynik wartość zmiennej result która jest wynikiem funkcji dodawanie. Zachęcam do obejrzenia pliku dajax.core.js, odpowiedniego dla wybranego frameworka aby dowiedzieć się jakie jeszcze funkcje są dostępne.
Funkcję wywołujemy z poziomu javascript wpisując po prostu

Dajaxice.aplikacja.funkcja('Dajax.process', {'a': wartosc1, 'b': wartosc2})

Każda funkcja stworzona przez nas w ajax.py musi znaleźć się w pliku settings.py. W tym wypadku będzie to wyglądać tak:

DAJAXICE_FUNCTIONS = (
    'aplikacja.ajax.nazwa_funkcji'
)

Koniec. W tym momencie powinieneś wiedzieć jak zaimplementować Dajax i cieszyć się odpicowanym Django. Jeśli nie rozumiesz to ja się nie zdziwię bo kiepski ze mnie nauczyciel. Wszelkie pytania proszę zamieszczać w komentarzach, postaram się na nie odpowiedzieć w miarę moich skromnych możliwości.
Pokój

Dajax odpicuje Django! to wpis z FLLOGa

case 'addcc':
case 'remcc':

I do wywołań funkcji addClass() oraz removeClass() dodajemy toString()

case 'addcc':
jQuery.each(elem.val,function(){
$(elem.id).addClass(this.toString());
});
break;

case 'remcc':
jQuery.each(elem.val,function(){
$(elem.id).removeClass(this.toString());
});
break;

Prawda, że banalne. Następnie opiszę w jaki sposób używać dajax, jest to równie proste jak ten fix.

Dajax i jquery 1.4.2 to wpis z FLLOGa