Önce ftplib kütüphanesine sahip olup olmadığımızı anlamak için aşağıdaki kodu yazalım.

import ftplib

eğer hata vermediyse sorun yok devam edebiliriz.

from ftplib import FTP
host= 'ftp.ftoptas.com'
kullanici_adi = 'kullanici'
parola = 'bir-iki-uc'
ftp = FTP(host)
ftp.set_pasv('true')
ftp.login(kullanici_adi,parola)

Belirttiğimiz parametreler sonucunda FTP sunucusuna bağlandık. Şimdi bulunduğumuz dizindeki dosya ve dizinleri listeleyelim

ftp.retrlines('LIST')

Şimdi de bulunduğumuz dizini değiştirelim

ftp.cwd('app')

Bulunduğumuz dizinden herhangi bir dosya indirelim

dosya = 'test.txt'
ftp.retrbinary('RETR '+dosya,open(dosya,'wb').write)

veya bir dosya upload edelim

dosya_adi = 'tes2t.txt'
dosya = open(dosya_adi,'r')
ftp.storbinary('STOR '+dosya_adi,dosya,1024)
dosya.close()

Son olarak açtığımız FTP bağlantısını kapatalım

ftp.quit()

Bu yazıyı okumaya devam etmeden önce şuradaki yazımı okumanızı öneriyorum.

Önce alexa isminde bir çalışma dizini oluşturuyoruz. Bu dizinin içine app.yaml isminde bir dosya oluşturuyoruz. Dosyanın içeriğini şöyle yapıyoruz:

application: alexa-rank-ogren
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
script: main.py

İlk satırdaki alexa-rank-ogren degeri appengine.google.com adresine girip Create an Application dedikten sonra girdiğimiz Application Identifier değeri olmalıdır.

Şimdi de burada belirttiğmiz main.py dosyasını da app.yaml dosyasının yanına oluşturuyoruz. main.py dosyası da şöyle olsun:

from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.api import urlfetch
import re,urllib

class MainPage(webapp.RequestHandler):
    def get(self,url):
        self.response.headers['Content-Type'] = 'text/plain'
        url = 'http://www.alexa.com/siteinfo/'+ url
        try:
            content = urlfetch.fetch(url).content
            up = re.search('<img src="/images/icons/globe-sm.jpg" alt="Global" style="margin-bottom:-2px;"/> [0-9,]{1,10}</a>',content)
            up = re.search('[0-9,]{1,10}</a>',up.group()).group()
            sonuc = up[0:-4]
        except:
            sonuc = 'hata'
        self.response.out.write(sonuc)

application = webapp.WSGIApplication([(r'/(.*)',MainPage)],debug=True)

def main():
    run_wsgi_app(application)

if __name__ == "__main__":
    main()

Burada önce MainPage isminde bir sınıf oluşturduk ardından sınıfın içinde oluşturduğumuz get fonksiyonu ile sayfaya gelen istek sonucunda sayfanın gösterdiği değeri belirleyeceğiz. Bu fonksiyonun bir parametresi olan url şu şekilde okunuyor:

http://alexa-rank-ogren.appspot.com/ftoptas.com

Bu adresteki ftoptas.com kısmı urlyi oluşturmaktadır. Çünkü sadece bir parametremiz var o da ilk ‘/’ karakterinden sonra gelen kısımdır.

alexa rank değerini okuyacağımız siteyi öğrendik şimdi de alexaya bağlanıyoruz. Sitenin alexa rank değeri de

http://www.alexa.com/siteinfo/ftoptas.com adresindedir.

urlfetch() fonksiyonuyla bu siteyi çekiyoruz. Yaklaşık olarak 26KB’lik bir dosya. Şimdi bir düzenli ifade yazarak bu 26KB’lik dosyanın içinden sadece alexa rank değerini alacağız.

Eğer FireBug ile bu sayfayı incelersek alexa rank değerinin olduğu yerdeki kodlar şöyledir:

<img src="/images/icons/globe-sm.jpg" alt="Global" style="margin-bottom:-2px;"/> 4,274,049</a>

Bu ifadeyi 12. satırda buluyoruz ve 13.satırda ikinci defa düzenli ifade (regex) kullanarak buradaki sayıyı çekiyoruz.

try kullanmamızın nedeni ise olmayan bir url girdiğimizde bize ‘hata’ değerini döndürmesi içindir.

Oluşturduğumuz WSGIApplication parametrelerinde ise urllerin nasıl olacağını belirttik. Yani hangi fonksiyonun hangi url ile bağlantılı olacağını yazdık.

Burada ‘/’ yerine r’/(.*)’ kullanmamızın nedeni ise http://alexa-rank-ogren.appspot.com/ adresinden sonra bir parametre geleceğini belirtmek.

Eğer http://alexa-rank-ogren.appspot.com/alexa/ftoptas.com urlsini kullandığımızda MainPage fonksiyonunu çağırmak isteseydik şu ifadeyi kullanırdık:

r’/alexa/(.*)’

veya MainPage fonksiyonunda iki parametre kullanmak isteseydik şöyle yapardık:

r’/(.*)/(.*)’

Yani regex kullanarak çok esnek urller oluşturabiliriz.

Gördüğünüz gibi 26KB’lik bir veriyi kendi sunucunuzda çekip işlemek hem trafiği hem de işlemci yükünü arttırır. Google app engine kullanarak bu yükü google sunucuların yükledik.  Sistemin çalışan halini şu adreslerden test edebilirsiniz.

http://f-toptas.appspot.com/alexa/google.com

http://f-toptas.appspot.com/alexa/ftoptas.com

import MySQLdb

Eğer problem yoksa devam edebiliriz. Önce veritabanına bağlanmak için sunucu, kullanıcı adı, parola ve veritabanı ismini girelim.

import MySQLdb
db = MySQLdb.connect(host="localhost",user="root",passwd="par01a",db="python")
cursor = db.cursor()

şimdi istediğimiz sorguları yazabiliriz.

cursor.execute("select * from users")
result = cursor.fetchall()

Eğer tablodan birkaç eleman çekmek istiyorsak fetchall() yerine fetchmany() kullanabiliriz.

result = cursor.fetchmany(3)

Tablodaki satır sayısını öğrenmek için

cursor.rowcount

Veritabanına bilgi girmek için

s = """insert into users (username, password) values ("yeni-kullanici","yeni-sifre")"""
cursor.execute(s)

en son eklenen girdinin id numarasını öğrenmek için

cursor.lastrowid

Eğer veritabanına tek seferde birden fazla veri eklemek istiyorsak şu yöntemi kullanabiliriz:

s = "insert into users (username, password) values (%s,%s)"
cursor.executemany(s,[("ali","alininparolali"),("veli","velininparolası"),("ayşe","ayşeninparolası")])

Son olarak da işimiz bittikten sonra bağlantıyı kapatıyoruz.

cursor.close()
db.close()

Kolay gelsin…

Hemen inbox kütüphanesini kullanarak 1 KB’den daha az bir betik yazarak tüm smslerinizi text dosyası olarak yedekleyip gönül rahatlığıyla silebilirsiniz. Hemen kodlara geçelim:

from time import  ctime
from inbox import Inbox
from os import listdir,mkdir

kutum = Inbox()
id = kutum.sms_messages()
yol = "e:\\mesajlar\\"
if not 'mesajlar' in listdir('e:\\'):
    mkdir(yol)
sayi = 10 #yedeklenmesini istediğiniz sms adedi
for i in range(0,sayi):
    msj = kutum.address(id[i])+'\n'+ctime(kutum.time(id[0]))+'\n'+kutum.content(id[i])
    h,ay,gun,saat,yil = ctime(kutum.time(id[i])).split(" ")
    sa,dk,sn=saat.split(':')
    d = gun+ay+yil+'-'+sa+'.'+dk+'.'+sn+'-'+kutum.address(id[i])+".txt"
    dosya = open(yol+d,'w')
    dosya.write(msj.encode('utf-8'))
    dosya.close()
print str(sayi)+" adet mesaj '"+yol+"' dizinine kaydedildi."

Kodları kısaca açıklayalım.

Önce inbox modülünü import ediyoruz. Ardından gelen kutusuna bağlanıyoruz. Her smsnin kendine özgü başka smsde ıolmayan bir id numarası vardır. “id” isimli değişkene bu id numaralarını atıyoruz (kutum.sms_messages()) Sms okumayı bu id numaralarına göre yapacağız. Hafıza kartında mesajlar isminde bir dizin yoksa oluşturuyoruz. Sonra kaç adet sms yedeklemek istiyorsak “sayi” değişkenine o sayıyı yazıyoruz. “msj” isimli değişkene mesajın gönderenini, gönderme zamanını ve mesaj içeriğini atıyoruz. Mesajın gönderme tarihinin formatını ayarlıyoruz ve gönderme zamanı+gönderen+’.txt’ isimli bir dosya oluşturup mesajlar dizinine yazdırıyoruz. Yazarken utf-8 şeklinde kodlanmış olarak yazarsak karakter problemi yaşamayız. Kolay gelsin…

import contacts
rehber=contacts.open()
liste=''
s=len(rehber)
for id in rehber:
    try:
        isim=rehber[id][0].value
    except:
        isim='isim yok'
    try:
        no=rehber[id][1].value
    except:
        no='numara yok'
    liste = liste+isim+'-'+no+'\n'
dosya_adi = 'e:\\rehber-yedek.txt'
dosya = open(dosya_adi,'w')
dosya.write(liste.encode('utf-8'))
dosya.close()
print s,' kisi "'+dosya_adi+'" adresine yedeklendi.'

utf-8 karakter kodlamasıyla okuyup yazdığımız için herhangi bir karakter problemi de oluşmuyor.

Burada önce contacts modülünü import ediyoruz.

contacts.open() fonksiyonuyla rehberi açıyoruz.

len(rehber) rehberdeki kişi sayısını veriyor.

for döngüsüyle rehberdeki her elemanı sırasıyla çekiyoruz.

rehber[id][0].value değeri bize rehberdeki ismi verir

rehber[id][1].value değeri bize ilk numarayı veriri

rehber[id][2].value değeri bize ikinci numarayı verir. Değiştirdiğimiz sayı her bir alanı ifade etmektedir.

try kullanmamızın nedeni ise bazen isim olup numara olmuyor veya tam tersi oluyor böyle bir durumda hata verip döngüyü bitirmemesidir.

Okuduğumuz isim ve numaraları aralarına bir ‘-‘ karakteri koyarak ve ‘\n’ ile bir alt satıra geçmesini sağlayarak liste stringine ekliyoruz.

for döngüsü bittikten sonra bir dosya açıp ‘utf-8’ karakter kodlamasıyla kaydediyoruz.

Hepsi bu kadar…

import PIL

Herhangi bir hata vermediyse kütüphane yüklenmiştir. Şimdi işlem yapmaya başlayabiliriz.

from PIL import Image
resim = Image.open("test.jpg")
print resim.size

(241,172)

Burada önce PIL içerisinden Image nesnesini çağırdık ve open fonksiyonuyla test.jpg resmini açtık. Resmin boyutlarını öğrenmek için size özelliğine bakarız. Image nesnesiyle kullanacağımız diğer metotlar için şunu yazabiliriz:

dir(resim)

Resim üzerine bir yazı yazmak için de ImageDraw nesnesini kullanacağız. Bu yazının fontunu belirlemek için ImageFont nesnesini kullanacağız.

from PIL import Image,ImageFont,ImageDraw
resim = Image.open("test.jpg")
f = ImageFont.truetype("arial.ttf", 35)
ciz = ImageDraw.Draw(resim)
ciz.text((10,10), "ftoptas.com", font=f, fill="#0C3446")
resim.save("test2.jpg")

Önce yazacağımız yazının fontunu arial ve font büyüklüğünü de 20 olarak belirledik. Ardından 4. satırda açtığımız resmi kullanarak bir Draw nesnesi oluşturduk. Bu nesnenin text metodunu kullanarak (10,10) koordinatına “#0C3446″ renginde ve ayarladığımız fontta yazı yazmış olduk. text metodunun parametreleri şu şekildedir:

text((x,y), “yazılacak metin”, font, renk)

Son olarak  yeni resmi test2.jpg olarak kaydediyoruz.

Yazıya biraz gölge efekti vermek için yazıyı iki defa farklı renkte ve x-y koordinatlarının 2 piksel arttırılmış olarak kaydedelim.

from PIL import Image,ImageFont,ImageDraw
resim = Image.open("test.jpg")
f = ImageFont.truetype("arial.ttf", 35)
ciz = ImageDraw.Draw(resim)
ciz.text((8,8), "ftoptas.com", font=f, fill="#3EA3D1")
ciz.text((10,10), "ftoptas.com", font=f, fill="#0C3446")
resim.save("test3.jpg")

Yazının arkasına açık renkli bir diktörtgen çizip yazının okunabilirliğini arttırabiliriz.

from PIL import Image,ImageFont,ImageDraw
resim = Image.open("test.jpg")
f = ImageFont.truetype("arial.ttf", 35)
ciz = ImageDraw.Draw(resim)
ciz.rectangle(((8,8),(190,48)),fill="#ffffff")
ciz.text((8,8), "ftoptas.com", font=f, fill="#3EA3D1")
ciz.text((10,10), "ftoptas.com", font=f, fill="#0C3446")
resim.save("test4.jpg")

Draw nesnesinin rectangle metodunu kullanarak belirtiğimiz koordinatlara bir diktörtgen oluşturduk. Yazıya bir açı vermek için şu yöntemi kullanabiliriz:

from PIL import Image,ImageFont,ImageDraw
resim = Image.open("test.jpg")
f = ImageFont.truetype("arial.ttf", 20)
yazi = Image.new('RGB',(120,50))
ciz = ImageDraw.Draw(yazi)
ciz.text((8,8), "ftoptas.com", font=f, fill="#ffffff")
yazi = yazi.rotate(15)
resim.paste(yazi,(20,20))
resim.save("test5.jpg")

RGB formatında 120×50 piksel boyutunda yeni bir Image oluşturup yazıyı onun içine yazdık. Ardından içinde yazı olan resme 15 derece açı verip eski resmin üzerinde yapıştırdık.

1. Adım: Uygulamayı indirelim:

şuradan google_appengine_1.2.3.zip dosyasını indiriyoruz.

2. Adım: indirdiğimiz zip dosyasını açıp /home/faruk/gae (burada ‘faruk’ yerine sizin kullanıcı adınız gelecek) dizinine kopyalıyoruz. Bu kısmı isterseniz sağ tıklayıp buraya çıkar diyerek veya komutlarla şöyle yapabilirsiniz:

unzip google_apengine_1.2.3.zip
cp -R googgle_appengine /home/faruk/gae

Sıkıştırılmış dosyayı açıp /home/faruk/gae dizinine kopyaladık. Uygulamamız bu dizine kurulmuş oldu.

3.Adım: Şimdi de çalışacağımız dizinin içine buradan bir symlink oluşturalım. Çalışacağımız dizin /home/faruk/Desktop/projelerim/ olsun. Şu kodları yazarak symlink oluşturuyoruz:

sudo ln -s /home/faruk/gae /home/faruk/Desktop/projelerim/gae

4.Adım: Şimdi tekrar projelerim dizinine dönerek burada herhangi bir GAE uygulaması yapabilirz. Hemen küçük bir uygulama yapalım. Önce deneme isminde bir dizin açalım:

mkdir deneme

Bu dizinin içine app.yaml ve main.py dosyalarımızı oluşturalım:

app.yaml:

application: deneme
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
  script: main.py

main.py:

from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app

class MainPage(webapp.RequestHandler):
    def get(self):
        self.response.headers['Content-Type'] = 'text/plain'
        self.response.out.write('Merhaba Pardus')

application = webapp.WSGIApplication([('/',MainPage)],debug=True)

def main():
    run_wsgi_app(application)

if __name__ == "__main__":
    main()

Şimdi tekrar projelerim dizinine gelerek şu komutları yazalım:

sudo python gae/dev_appserver.py deneme

Firefoxu açıp localhost:8080/ adresine girdiğimizde Merhaba Pardus yazısını görüyoruz. Hayırlı olsun…

import urllib, httplib

veriler = urllib.urlencode({'veri':'herhangi bir veri'})
headers = {"Content-type":"application/x-www-form-urlencoded","Accept":"text/plain"}
baglanti = httplib.HttpConnection("ftoptas.com")
baglanti.request("POST","/ornekform/gonder/",veriler,headers)
cevap = baglanti.getresponse()
baglanti.close()

Önce kullanacağımız kütüphaneleri çağırıyoruz. Biz burada urllib ve httplib kütüphanelerini kullandık. Ardından göndereceğimiz verileri belirledik. Gördüğünüz gibi verileri dictionary şeklinde yazıyoruz. İlk değer verinin ismi ikincisi de değeri oluyor. headers parametresiyle de bu bağlantının nereden geldiğini belirtiyoruz. Sunucu bağlantının nereden geldiğini header bilgilerinden anlar. Dolayısıyla buraya yazacağımız değerlerle bağlantının bir web tarayıcısından geliyormuş gibi görünmesini sağlayabiliriz. Bunun nedeni ise google gibi bazı siteler header bilgilerine göre cevap vermektedir. Bir nevi sunucuyu kandırmış gibi oluyoruz. baglanti isminde bir bağlantı yapıyoruz ve yaptığımız bağlantıyla POST metodunu kullanarak ftoptas.com/ornekform/gonder/ adresine bilgileri gönderiyoruz. Eğer bu göndermenin ardında bir cevap dönüyorsa bunu da getresponse() fonksiyonuyla alıyoruz. Bu şekilde gönderdiğimiz bilgileri okumak için sunucumuzu da PHP ile şu şekilde kodlarız:

$dosyaadi = "deneme.txt"
// verileri yazacağımız dosyayı açıyoruz
$dosya = fopen($dosyaadi,'a+')
// POST metoduyla gelen verileri okuyoruz
$veri = $_POST['veri']
// okuduğumuz verileri dosyaya yazdırıyoruz
fwrite($dosya, $veri, strlen($veri))
// dosyayı kapatıyoruz
fclose($dosya)
// cevap olarak istemciye dönecek veri
echo "veri başarıyla iletildi."

Eğer string değil de bir dosya göndermek istiyorsak bunu da şöyle yapabiliriz:

dosya = open(dosyaadi,'r')
veri = dosya.read()
dosya.close()
veri = veri.encode("zlib")
headers = {"Content-type":"application/x-gzip","Accept":"text/plain"}
baglanti = httplib.HttpConnection(sunucu)
baglanti.request("POST",yol,veri,headers)
cevap = baglanti.getresponse()
cevap_dosya = cevap.read()
baglanti.close()

Burada ise okuduğumuz dosyayi read() yöntemiyle stringe dönüştürüyoruz. Bu stringi de zlib ile kodlayarak sıkıştırılmış bir dosya haline getiriyoruz. Dolayısıyla header bilgilerinde bunun sıkıştırılmış dosya biçimi olduğunu belirtiyoruz. Geri kalan kısmı ilk örnekte yaptığımız gibi oluyor. cevap_dosya ise veri gönderme sonucunda sunucun bize verdiği cevabın stringe dönüşmüş halidir. Bu yöntemle gönderilmiş verileri PHP sunucumuzda okumak için aşağıdaki gibi kodlayalım.

// gelen veriyi okuyoruz
$veri = file_get_contents('php://input')
// sıkıştırılmış olarak geldiği için gelen veriyi
// tekrar eski haline getirmek için uncompress yapıyoruz
$dosya = gzuncompress($veri)
// eğer veri yoksa -1 değer döndürüyoruz
if (!$dosya){
echo -1
die()
}
// veriyi kaydedeceğimiz dosyanın ismini belirtiyoruz.
// dosya ismi unique yani seçiliyor yani aynı isimde 2 farklı dosya
// bu kısma herhangi bir dosya ismi de verebilirsiniz.
$uid = uniqid()
$dosyaadi = "$uid.tmp"
// dosyayı oluşturuyoruz
$yaz = fopen($dosyaadi,'wb')
// verileri dosyaya yazıyoruz
fputs($yaz,$dosya,strlen($dosya))
// dosyayı kapatıp cevap dönüyoruz
fclose($yaz)
echo "dosya iletildi."

Bu kodların tamamı PyS60′da da çalışmaktadır. Yani telefondan da bunları yapabiliriz. Şimdi yaptığımız iki örnekte sunucumuzu PHP ile programladık. Bir sonraki yazımda Python sunucuları kullanacağız. Bunun için de Google App Engine üzerinde Django kurup çalıştıracağız. Yani hem sunucu hem istemci tamamiyle Python ile yazılmış olacak.

Python betiğinin en başına şu satırı yazarak betiğin utf-8 olarak kodlanmasını sağlarız:

# -*- coding: utf-8 -*-

Dosyadan veri okuyacağımız zaman open yerine şunu kullanırız:

import codecs
codecs.open('dosya.txt','r','utf-8')

Ya da herhangi bir stringi utf-8 şeklinde kodlamak için şunu kullanırız:

s = 'normal string'
u = unicode(s,'utf-8')

Unicode şeklinde kodladığımız u değişkenini tekrar normal string haline getirmek için şunu kullanırız:

normal = u.encode()

Bu kısma geçmeden önce App Engine kurulumu ile alakalı ön bilgi almak için şuradaki yazıyı okumanızı öneririm.

Klasik bir blog uygulaması yapalım.

django-blog isminde bir dizin oluşturup içine app.yaml dosyamızı oluşturalım. İçeriği şöyle olsun

application: django-blog
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
script: main.py

Ardından app.yaml dosyasının yanına main.py dosyasını oluşturuyoruz. İçeriği şöle olsun

import os, sys

from django.conf import settings
settings._target = None

os.environ["DJANGO_SETTINGS_MODULE"] = "blog.settings"
sys.path.append("E:\\app_engine\\django-blog")

from google.appengine.ext.webapp import util
from django.conf import settings

settings._target = None

import django.core.handlers.wsgi
import django.core.signals
import django.db
import django.dispatch.dispatcher

django.dispatch.dispatcher.disconnect(django.db._rollback_on_exception,django.core.signals.got_request_exception)

def main():
    application = django.core.handlers.wsgi.WSGIHandler()
    util.run_wsgi_app(application)

if __name__ == "__main__":
    main()

Burada 7. satırı biraz önce oluşturduğumuz django-blog dizininin yolunu yazıyoruz. 6. satır ise birazdan oluşturacağımız projenin adı. Yani django-admin.py startproject komutuyla oluşturacağımız proje.

Komut penceresini açıp django-blog dizinine geldikten sonra blog isminde bir django projesi başlatıyoruz.

django-admin.py startproject blog

Şimdi çalışıp çalışmadığını görmek için sunucumuzu çalıştırıyoruz.

dev_appserver.py django-blog/

Şimdi http://localhost:8080/ adresinden Congrulations sayfasını görüyoruz. Artık django çalışıyor. Eğer göremiyorsanız başa dönüp tekrar gözden geçirin.

Komut penceresinden django-blog/blog dizinine gelip blogum isminde bir uygulama başlatıyoruz.

python manage.py startapp blogum

Bu komutla birlikte blogum isminde bir dizin oluşacak. Bu dizinin içindeki models.py dosyasına modelimizi tanımlayalım.

from google.appengine.ext import db

class Yazi(db.Model):
yazan = db.UserProperty()
metin = db.StringProperty(multiline=True)

Modelde yazan ve metin olmak üzere iki elaman tanımladık.

Djangonun en sevdiğin kısmı olan urls.py dosyasını da şöyle yapıyoruz:

from django.conf.urls.defaults import *
from blog.blogum.views import index,ekle

urlpatterns = patterns('',
(r'^blog/$',index),
(r'^blog/ekle/$',ekle),
)

Burada /blog adresinde index fonksiyonunu ve /blog/ekle adresinde de ekle fonksiyonunu çağıracağını bilidiriyoruz. Buradaki urlpatterns değeri düzenli ifadeler(regular expressions ) kullanılarak oluşturuluyor. Düzenli ifadeler hakkında bilgi edinmek için şuraya ve şuraya bakabilirsiniz.

Aynı dizindeki views.py dosyasına da olayları yazıyoruz:

from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render_to_response
from google.appengine.ext import db
from google.appengine.api import users
from blog.blogum.models import Yazi

def index(request):
    yazilar = Yazi.all()
    yazilar = yazilar.fetch(1000)
    if users.get_current_user():
        url = users.create_logout_url(request.path)
        url_text = "Cikis"
    else:
        url = users.create_login_url(request.path)
        url_text = "Giris"
    sablon_param = {"yazilar":yazilar,"url":url,"url_text":url_text}
    return render_to_response("index.html",sablon_param)

def ekle(request):
    metin = request.POST["metin"]
    yazi = Yazi()
    yazi.metin = metin
    if users.get_current_user():
        yazi.yazan = users.get_current_user()
    yazi.put()
    return HttpResponseRedirect("/blog")

Burada iki fonksiyonumuz var biri index biri de ekle, index fonksiyonunda yazilari veritabanından okuyoruz. İlk 1000 yazıyı çekiyoruz.  1000 yazmamızın nedeni ise veritabanından veri okurken en fazla 1000 adet okuyabiliyoruz. Bu sınırlama App Engine tarafından yapılıyor.

users.get_current_user() fonksiyonu ile kullanıcının giriş yapıp yapmadığına bakıyoruz. Buradaki kullanıcı girişinden kasdımız Gmail hesabıyla giriştir. Lokalden çalıştırırken buraya giriş yapıp herhangi bir mail adresi yazabiliyorsunuz. Ama uygulamayı App Engine sunucularına yükledikten sonra Gooogle hesabıyla giriş yapılıyor.

Django’nun vazgeçilmezlerinden biri olan sablonları kullanıyoruz. Sablona parametrelerini girdikten sonra render_to_response komutuyla sablonu render ediyoruz.

ekle fonksiyonunda ise POST metoduyla gelen veriyi okuyoruz. Eğer kullanıcı giriş yaptıysa yazinin yazarı oluyor. Eğer yapmadıysa yazi.yazan değeri boş oluyor. Bunu da şablonumuzda sorgulatarak “anonim” olarak belirtiyoruz. Yani kullanıcı giriş yapmadan yazı yazarsa yazan kısmı anonim olarak görünüyor. put() fonksiyonuyla veritabanına yazdığımız veriyi ekliyoruz. Son olarak “/blog” sayfasına yönlendiriyoruz.

Şablon kullanmak için şablon dizinlerini djangoya belirtmemiz gerekiyor. Bunun için django-blog/blog/settings.py dosyasına bir ekleme yapacağız. Bu dosyada TEMPLATE_DIRS değişkenine şablon dosyamızın yolunu ekliyoruz. Ben djang0-blog/blog/blogum dizinin içine sablon isminde bir oluşturup index.html dosyasını oraya koydum. O zaman değişikliği şöyle yapıyoruz:

TEMPLATE_DIRS = (
"e:\\app_engine\\django-blog\\blog\\blogum\\sablon"
)

sablon dizinin içine index.html dosyasını oluşturuyoruz.

<a href ="{{ url }}">{{ url_text }}</a>
<h1>Blog</h1>
{% for yazi in yazilar %}
{% if yazi.yazan %}
{{ yazi.yazan.nickname }}
{% else %}
anonim
{% endif %}
<blockquote>{{ yazi.metin|escape }}</blockquote>
{% endfor %}

<form action="/blog/ekle/" method="post">
<textarea name="metin" rows="3" cols="40"></textarea>
<input type="submit" value="Gönder">
</form>

Burada kullanıcının giriş yapıp yapmadığına bakarak giriş veya çıkış linklerini koyuyoruz. Ardında sablonda belirttiğimiz yazilar değerini bir for döngüsüyle okuyup ekrana yazdırıyoruz. Oluşturduğumuz form ile “/blog/ekle/” adresine post metoduyla yazdığımız yazının gönderilmesini sağlıyoruz.

Veritabanındaki verilerin tamamını silmek için sunucuyu şu komutla başlatıyoruz:

dev_appserver.py –clear_datastore django-blog/

Hepsi bu kadar, kolay gelsin…