Python 3 ve Tweepy Kütüphanesi ile Bir Twitterbot Nasıl Oluşturulur?

Sosyal medya platformları, günümüz dijital dünyasının vazgeçilmez bir parçası haline gelmiştir. Bu platformlardaki otomasyon ve etkileşim imkanları, hem bireysel kullanıcılar hem de işletmeler için büyük potansiyeller sunar. Twitter, bu platformlardan biri olarak, zengin API’si (Uygulama Programlama Arayüzü) sayesinde geliştiricilere çeşitli otomasyon ve entegrasyon fırsatları tanır. Bu makalede, Python 3 programlama dili ve Tweepy kütüphanesi kullanarak kendi Twitterbot’unuzu nasıl oluşturacağınızı adım adım öğreneceksiniz. Bir Twitterbot, belirli görevleri otomatik olarak yerine getiren bir yazılım botudur; örneğin, tweet atmak, belirli anahtar kelimeleri izlemek, yanıt vermek veya takipçi yönetimi yapmak gibi.

Bu kılavuz, temel kavramlardan başlayarak, Twitter Geliştirici Hesabı oluşturmaktan, API anahtarlarını almaya, Tweepy kütüphanesini kurmaya ve nihayetinde çalışan bir bot inşa etmeye kadar geniş bir yelpazeyi kapsayacaktır. Ayrıca, botunuzu geliştirirken karşılaşabileceğiniz potansiyel sorunlara ve en iyi uygulamalara da değineceğiz. Amacımız, size hem teorik bilgiyi hem de pratik uygulama becerisini kazandırarak, kendi yaratıcı Twitterbot projelerinizi hayata geçirmeniz için sağlam bir temel oluşturmaktır.

Twitterbot Nedir ve Neden Oluşturmalıyız?

Bir Twitterbot, Twitter platformunda insan müdahalesi olmadan belirli eylemleri gerçekleştirmek üzere tasarlanmış bir otomasyon programıdır. Bu eylemler, önceden tanımlanmış kurallara veya programlanmış mantığa göre otomatik olarak tweet gönderme, belirli hashtag’leri veya kullanıcıları izleme, tweet’leri beğenme, retweet etme, yanıtlama ve hatta direkt mesaj gönderme gibi çok çeşitli görevleri içerebilir.

Twitterbot’lar oluşturmanın pek çok nedeni vardır. İşletmeler için müşteri hizmetlerini otomatikleştirmek, pazarlama kampanyalarını yürütmek veya belirli bir konudaki trendleri izlemek gibi ticari faydalar sağlayabilirler. Bireysel kullanıcılar için ise, ilgi alanlarına yönelik içerik paylaşımı yapmak, belirli bir konuda bilgi toplamak, hava durumu güncellemeleri veya haber başlıkları gibi düzenli bilgileri otomatikleştirmek veya eğlence amaçlı etkileşimler yaratmak gibi kişisel projelerde kullanılabilirler. Örneğin, her gün rastgele bir alıntı paylaşan bir bot, belirli bir saatte günlük hava durumu bilgisini tweetleyen bir bot veya belirli bir anahtar kelime geçtiğinde otomatik olarak yanıt veren bir bot oluşturabilirsiniz. Ancak, botları geliştirirken Twitter’ın otomasyon politikalarına ve etik kurallara uymak büyük önem taşır.

Ön Koşullar

Twitterbot’unuzu oluşturmaya başlamadan önce, bazı temel gereksinimleri karşılamanız gerekmektedir. Bu ön koşullar, sorunsuz bir geliştirme süreci için kritik öneme sahiptir.

Python 3 Kurulumu

Twitterbot’umuzu Python 3 ile geliştireceğimiz için, sisteminizde Python 3’ün kurulu olması şarttır. Python’ın en güncel sürümünü (genellikle 3.8 veya üzeri) kullanmanız önerilir. Kurulumu kontrol etmek için komut istemcinizi veya terminalinizi açın ve aşağıdaki komutu çalıştırın:

python3 --version

Eğer Python kurulu değilse, python.org adresinden işletim sisteminize uygun kurulum dosyasını indirip yönergeleri takip ederek kurabilirsiniz.

Twitter Geliştirici Hesabı

Twitter API’sine erişmek ve botunuzun Twitter ile etkileşim kurmasını sağlamak için bir Twitter Geliştirici Hesabına ihtiyacınız vardır. Bu hesap, botunuz için gerekli API anahtarlarını ve erişim belirteçlerini (token) almanızı sağlar. Twitter’ın politikaları gereği, geliştirici hesabı başvuruları incelenir ve onaylanır. Bu süreçte botunuzun amacını ve nasıl çalışacağını net bir şekilde açıklamanız önemlidir.

Tweepy Kütüphanesi

Tweepy, Twitter API’si ile etkileşim kurmayı kolaylaştıran popüler bir Python kütüphanesidir. Bu kütüphane, API çağrılarını basitleştirir ve botunuzun kodunu daha okunabilir ve yönetilebilir hale getirir. Tweepy’yi kurmak için Python paket yöneticisi pip’i kullanacağız.

Twitter Geliştirici Hesabı Oluşturma ve API Anahtarlarını Alma

Twitterbot’unuzun Twitter ile iletişim kurabilmesi için bir Twitter Geliştirici Hesabına sahip olmanız ve bu hesap üzerinden bir uygulama oluşturarak API anahtarlarını almanız gerekmektedir. Bu bölüm, bu süreci adım adım açıklamaktadır.

Geliştirici Hesabı Başvurusu

İlk adım, bir Twitter Geliştirici Hesabı için başvurmaktır. Bunun için Twitter Geliştirici Portalı‘na gidin ve “Apply for access” veya “Sign up for Free Account” butonuna tıklayın. Twitter sizden hesabınızın amacını, botunuzun ne yapacağını ve nasıl çalışacağını detaylı bir şekilde açıklamanızı isteyecektir. Bu açıklamayı yaparken dürüst, şeffaf ve Twitter’ın otomasyon politikalarına uygun olduğunuzu belirtmeniz önemlidir. Başvurunuz genellikle birkaç gün içinde incelenir ve onaylanır.

Proje ve Uygulama Oluşturma

Geliştirici hesabınız onaylandıktan sonra, geliştirici portalına giriş yapın. Burada “Projects & Apps” bölümüne giderek yeni bir proje oluşturmanız gerekecektir. Projenize anlamlı bir isim verin. Projeyi oluşturduktan sonra, bu proje altında yeni bir uygulama (App) oluşturmanız istenir. Uygulamanıza da botunuzu tanımlayan bir isim verin. Uygulama oluşturma aşamasında, botunuzun ihtiyaç duyduğu izinleri (örneğin, sadece tweet okuma, tweet atma ve yanıtlama veya direkt mesaj gönderme) belirlemeniz gerekecektir. Çoğu bot için “Read and Write” izinleri yeterli olacaktır.

API Anahtarları ve Erişim Belirteçleri

Uygulamanızı oluşturduktan sonra, “Keys and tokens” sekmesine gidin. Burada botunuzun Twitter API’sine erişmek için kullanacağı kimlik bilgilerini bulacaksınız. Bu kimlik bilgileri şunlardır:

API Key (Consumer Key)
API Secret Key (Consumer Secret)
Access Token
Access Token Secret

Bu anahtarlar ve belirteçler, botunuzun Twitter hesabınız adına işlem yapmasını sağlayan hassas bilgilerdir. Bu nedenle, bunları kesinlikle kimseyle paylaşmamalı ve kodunuzda doğrudan açık metin olarak bulundurmamalısınız. Güvenli bir şekilde saklamak için ortam değişkenlerini veya bir yapılandırma dosyasını kullanmak en iyi uygulamadır. “Generate” veya “Regenerate” butonlarına tıklayarak bu anahtarları oluşturabilir ve kopyalayabilirsiniz. Özellikle Access Token ve Access Token Secret, yalnızca bir kez gösterildiği için hemen kopyalayıp güvenli bir yere kaydetmeniz önemlidir.

Python Ortamını Hazırlama

API anahtarlarınızı aldıktan sonra, Python geliştirme ortamınızı botunuz için hazırlamanız gerekmektedir. Bu, projeniz için izole bir ortam oluşturmayı ve gerekli kütüphaneleri yüklemeyi içerir.

Sanal Ortam Oluşturma

Python projeleri için sanal ortamlar (virtual environments) kullanmak, en iyi uygulamalardan biridir. Sanal ortamlar, her projenin kendi bağımlılık setine sahip olmasını sağlar ve farklı projeler arasındaki kütüphane çakışmalarını önler. Projeniz için bir klasör oluşturun ve içine girin:

mkdir twitter_bot
cd twitter_bot

Şimdi sanal ortamı oluşturun ve etkinleştirin:

python3 -m venv venv

Sanal ortamı etkinleştirin:

Windows:

.\venv\Scripts\activate

macOS/Linux:

source venv/bin/activate

Ortam etkinleştirildiğinde, terminal komut satırınızın başında (venv) ifadesini görmelisiniz. Bu, artık projenize özel bir Python ortamında çalıştığınız anlamına gelir.

Tweepy Kütüphanesini Kurma

Sanal ortamınız etkinleştirildikten sonra, Tweepy kütüphanesini kurabilirsiniz:

pip install tweepy python-dotenv

Burada python-dotenv kütüphanesini de kurduk. Bu kütüphane, API anahtarlarınızı .env dosyasında güvenli bir şekilde saklamanıza ve Python kodunuzdan kolayca erişmenize olanak tanır.

API Anahtarlarını Güvenli Bir Şekilde Saklama

Daha önce de belirtildiği gibi, API anahtarlarınızı doğrudan kodunuza yazmak güvenlik açısından risklidir. Bunun yerine, .env adında bir dosya oluşturarak anahtarlarınızı burada saklayabiliriz. Proje klasörünüzde twitter_bot dizini içinde .env adında bir dosya oluşturun ve içine API anahtarlarınızı aşağıdaki formatta ekleyin:

CONSUMER_KEY="API_KEY_BURAYA"
CONSUMER_SECRET="API_SECRET_KEY_BURAYA"
ACCESS_TOKEN="ACCESS_TOKEN_BURAYA"
ACCESS_TOKEN_SECRET="ACCESS_TOKEN_SECRET_BURAYA"
BEARER_TOKEN="BEARER_TOKEN_BURAYA" # Tweepy v2 için gerekli olabilir

Twitter Geliştirici Portalı’nda genellikle bir “Bearer Token” da bulunur. Tweepy’nin Twitter API v2 ile çalışabilen tweepy.Client sınıfını kullanıyorsanız, bu token’a da ihtiyacınız olacaktır. Bu token’ı da .env dosyanıza eklemeyi unutmayın.

Daha sonra, bu değerleri Python kodunuzda python-dotenv kütüphanesi ile yükleyebilirsiniz. Projenizin ana Python dosyası (örneğin, bot.py) içinde aşağıdaki gibi kullanabilirsiniz:

import os
from dotenv import load_dotenv

load_dotenv() # .env dosyasını yükle

consumer_key = os.getenv("CONSUMER_KEY")
consumer_secret = os.getenv("CONSUMER_SECRET")
access_token = os.getenv("ACCESS_TOKEN")
access_token_secret = os.getenv("ACCESS_TOKEN_SECRET")
bearer_token = os.getenv("BEARER_TOKEN") # Eğer kullanıyorsanız

if not all([consumer_key, consumer_secret, access_token, access_token_secret, bearer_token]):
    print("Hata: API anahtarları veya belirteçler eksik. .env dosyasını kontrol edin.")
    exit()

Artık bu değişkenleri Tweepy kimlik doğrulaması için kullanabilirsiniz.

Bu yöntem, hassas bilgilerinizi kodunuzdan ayırarak hem güvenliği artırır hem de kodunuzu daha taşınabilir hale getirir. Ayrıca, bu .env dosyasını Git gibi sürüm kontrol sistemlerine göndermemeye özen gösterin. Bunun için .gitignore dosyanıza .env ekleyebilirsiniz.

Temel Tweepy Kullanımı ve Twitter API v2

Tweepy kütüphanesi, Twitter API’si ile etkileşimi oldukça basitleştirir. Twitter API’sinin iki ana sürümü bulunmaktadır: v1.1 ve v2. Tweepy, her iki sürümü de destekler ancak yeni projeler için Twitter API v2’yi kullanmak daha güncel ve önerilen bir yaklaşımdır. Tweepy’nin tweepy.Client sınıfı, API v2 ile etkileşim kurmak için tasarlanmıştır.

Tweepy ile Kimlik Doğrulama

Botunuzun Twitter API’sine erişebilmesi için kimlik doğrulaması yapması gerekir. Tweepy v2 için bu işlem tweepy.Client sınıfı kullanılarak yapılır. Bu sınıf, hem kullanıcı bağlamı (Access Token ve Secret ile) hem de uygulama bağlamı (Bearer Token ile) işlemlerini destekler.

import tweepy
import os
from dotenv import load_dotenv

load_dotenv()

consumer_key = os.getenv("CONSUMER_KEY")
consumer_secret = os.getenv("CONSUMER_SECRET")
access_token = os.getenv("ACCESS_TOKEN")
access_token_secret = os.getenv("ACCESS_TOKEN_SECRET")
bearer_token = os.getenv("BEARER_TOKEN")

API v2 için Client nesnesi oluşturma
Hem kullanıcı bağlamı hem de uygulama bağlamı (bearer_token) için kullanılır.
Sadece tweet okuma gibi işlemler için bearer_token yeterli olabilir.
Tweet atma, beğenme gibi işlemler için access_token ve access_token_secret gereklidir.
client = tweepy.Client(
    bearer_token,
    consumer_key,
    consumer_secret,
    access_token,
    access_token_secret
)

Kimlik doğrulamanın başarılı olup olmadığını test etmek için
Kendi kullanıcı bilgilerinizi çekebilirsiniz.
try:
    me = client.get_me()
    print(f"Kimlik doğrulama başarılı! Botun kullanıcı adı: @{me.data.username}")
except tweepy.TweepyException as e:
    print(f"Kimlik doğrulama hatası: {e}")
    exit()

Bu kod parçası, .env dosyasından API anahtarlarını yükler ve tweepy.Client nesnesini oluşturur. client.get_me() çağrısı, kimlik doğrulamasının doğru yapılıp yapılmadığını test etmek için kullanılır.

Temel API Çağrıları

tweepy.Client nesnesini kullanarak çeşitli Twitter eylemlerini gerçekleştirebilirsiniz:

Tweet Atma

Bir tweet göndermek oldukça basittir:

def send_tweet(text):
    try:
        response = client.create_tweet(text=text)
        print(f"Tweet başarıyla gönderildi! ID: {response.data['id']}")
        return response.data['id']
    except tweepy.TweepyException as e:
        print(f"Tweet gönderilirken hata oluştu: {e}")
        return None

Örnek kullanım:
tweet_id = send_tweet("Merhaba Dünya! Bu benim ilk Python Twitterbot tweet'im. #PythonBot")
if tweet_id:
print(f"Gönderilen tweet'in URL'si: https://twitter.com/user/status/{tweet_id}")

Tweetleri Beğenme

Belirli bir tweet’i beğenmek için tweet ID’sine ihtiyacınız vardır:

def like_tweet(tweet_id):
    try:
        # Kendi kullanıcı ID'nizi almanız gerekir. Bunu client.get_me() ile alabilirsiniz.
        user_id = client.get_me().data.id
        response = client.like(tweet_id, user_id)
        if response.data['liked']:
            print(f"Tweet ID {tweet_id} başarıyla beğenildi.")
        else:
            print(f"Tweet ID {tweet_id} beğenilemedi.")
    except tweepy.TweepyException as e:
        print(f"Tweet beğenilirken hata oluştu: {e}")

Örnek kullanım:
like_tweet("1460323737035677698") # Örnek bir tweet ID

Tweetleri Retweet Etme

Bir tweet’i retweet etmek (Twitter API v2’de “retweet” yerine “retweet” eylemi ile doğrudan bir endpoint yoktur, bunun yerine create_tweet ile alıntı tweet veya retweet endpoint’i kullanılabilir, ancak client.retweet Tweepy tarafından v1.1 uyumluluğu veya v2’nin bazı özel endpointleri için sağlanabilir. En güncel v2 yaklaşımı için client.retweet() metodunu kullanabiliriz.):

def retweet_tweet(tweet_id):
    try:
        user_id = client.get_me().data.id
        response = client.retweet(tweet_id, user_id)
        if response.data['retweeted']:
            print(f"Tweet ID {tweet_id} başarıyla retweet edildi.")
        else:
            print(f"Tweet ID {tweet_id} retweet edilemedi.")
    except tweepy.TweepyException as e:
        print(f"Tweet retweet edilirken hata oluştu: {e}")

Örnek kullanım:
retweet_tweet("1460323737035677698")

Tweetlere Yanıt Verme

Bir tweete yanıt vermek için create_tweet metodunu in_reply_to_tweet_id parametresiyle kullanırız:

def reply_to_tweet(original_tweet_id, reply_text):
    try:
        response = client.create_tweet(
            text=reply_text,
            in_reply_to_tweet_id=original_tweet_id
        )
        print(f"Tweet ID {original_tweet_id} yanıtlandı. Yanıt ID: {response.data['id']}")
        return response.data['id']
    except tweepy.TweepyException as e:
        print(f"Yanıt gönderilirken hata oluştu: {e}")
        return None

Örnek kullanım:
reply_to_tweet("1460323737035677698", "Harika bir tweet! Teşekkürler. #Python")

Kullanıcı Bilgisi Çekme

Bir kullanıcının bilgilerini kullanıcı adıyla veya ID’siyle çekebilirsiniz:

def get_user_info(username):
    try:
        response = client.get_user(username=username)
        user = response.data
        if user:
            print(f"Kullanıcı Adı: @{user.username}")
            print(f"Adı: {user.name}")
            print(f"Açıklama: {user.description}")
            print(f"Takipçi Sayısı: {user.public_metrics['followers_count']}")
            print(f"Takip Edilen Sayısı: {user.public_metrics['following_count']}")
            return user
        else:
            print(f"Kullanıcı @{username} bulunamadı.")
            return None
    except tweepy.TweepyException as e:
        print(f"Kullanıcı bilgileri çekilirken hata oluştu: {e}")
        return None

Örnek kullanım:
user_info = get_user_info("TwitterDev")

Twitterbot’unuzu Tasarlama

Botunuzu kodlamaya başlamadan önce, ne tür bir bot oluşturmak istediğinizi ve hangi görevleri yerine getireceğini net bir şekilde tanımlamanız önemlidir. Bu aşama, botunuzun amacını, hedef kitlesini ve temel işlevselliğini belirlemenizi sağlar.

Botun Amacını ve Özelliklerini Tanımlama

Bir Twitterbot’un potansiyel kullanım alanları oldukça geniştir. İşte bazı örnekler:

Otomatik Tweet Atan Bot: Belirli aralıklarla önceden tanımlanmış metinleri, görselleri veya harici bir kaynaktan (API, RSS beslemesi vb.) alınan bilgileri tweetler.
Yanıt Botu: Belirli anahtar kelimeleri içeren tweetlere veya kendisine yapılan mention’lara otomatik olarak yanıt verir.
Takip Botu: Belirli kriterlere uyan kullanıcıları takip eder veya takipten çıkarır.
Veri Toplama Botu: Belirli hashtag’ler veya kullanıcılar hakkında tweetleri toplar ve analiz eder.
Eğlence Botu: Rastgele şakalar, alıntılar veya ilginç bilgiler paylaşır.

Botunuzun amacını belirlerken, hangi özelliklerin bu amaca hizmet edeceğini düşünün. Örneğin, bir haber botu her saat başı belirli bir haber sitesinin RSS beslemesinden başlıkları çekip tweetleyebilir. Bir destek botu, belirli bir anahtar kelimeyle (örneğin, “yardım”) kendisine mention atıldığında otomatik bir yanıt gönderebilir.

Etik Kurallar ve Twitter Politikaları

Twitterbot geliştirirken, Twitter’ın otomasyon politikalarına ve etik kurallara uymak hayati öneme sahiptir. Bu politikalara uymamak, botunuzun askıya alınmasına veya hesabınızın kapatılmasına neden olabilir. Dikkat etmeniz gereken bazı temel noktalar:

Spam Yapmaktan Kaçının: Aşırı tweet atmak, aynı içeriği tekrar tekrar paylaşmak veya alakasız mention’lar göndermek spam olarak algılanabilir.
Şeffaf Olun: Botunuzun bir otomasyon olduğunu açıkça belirtin (örneğin, profil açıklamasında veya tweetlerde).
Kullanıcı Deneyimine Odaklanın: Botunuzun kullanıcılar için değer yaratmasına veya en azından rahatsız edici olmamasına dikkat edin.
API Limitlerine Uyun: Twitter API’sinin belirli istek limitleri vardır. Bu limitleri aşmamak için botunuzun çağrılarını düzenleyin.
Yanlış Bilgi Yaymayın: Botunuzun yanlış veya yanıltıcı bilgi yaymadığından emin olun.

Bu kurallara uyarak hem başarılı hem de sorumlu bir Twitterbot geliştirebilirsiniz.

Basit Bir Bot Oluşturma – Örnek 1: Otomatik Tweet Atan Bot

Şimdiye kadar öğrendiklerimizi kullanarak basit bir otomatik tweet atan bot oluşturalım. Bu bot, önceden tanımlanmış bir liste içerisinden rastgele bir tweet seçecek ve belirli aralıklarla bunu paylaşacaktır.

Kod Yapısı

Botumuzun ana yapısı aşağıdaki gibi olacaktır:

API anahtarlarını yükle ve Tweepy client’ı başlat.
Tweetlenecek mesajların bir listesini tanımla.
Rastgele bir mesaj seçen bir fonksiyon oluştur.
Seçilen mesajı tweetleyen bir fonksiyon oluştur.
Belirli aralıklarla tweet gönderme işlemini tekrarlayan bir döngü oluştur.

Örnek Kod

import tweepy
import os
import random
import time
from dotenv import load_dotenv

.env dosyasını yükle
load_dotenv()

API anahtarlarını al
bearer_token = os.getenv("BEARER_TOKEN")
consumer_key = os.getenv("CONSUMER_KEY")
consumer_secret = os.getenv("CONSUMER_SECRET")
access_token = os.getenv("ACCESS_TOKEN")
access_token_secret = os.getenv("ACCESS_TOKEN_SECRET")

Tweepy Client nesnesini başlat
try:
    client = tweepy.Client(
        bearer_token,
        consumer_key,
        consumer_secret,
        access_token,
        access_token_secret
    )
    # Kimlik doğrulama testi
    me = client.get_me()
    print(f"Bot olarak giriş yapıldı: @{me.data.username}")
except tweepy.TweepyException as e:
    print(f"Hata: Tweepy Client başlatılamadı veya kimlik doğrulama başarısız: {e}")
    exit()

Tweetlenecek mesajların listesi
tweet_messages = [
    "Bugün Python ile harika bir gün! #Python",
    "Kod yazmak bir sanattır. Yaratıcılığınızı kullanın! #Coding",
    "Otomasyon hayatı kolaylaştırır. Bir Twitterbot denediniz mi? #Twitterbot",
    "Her gün yeni bir şeyler öğrenmek için harika bir fırsat! #Learning",
    "Merhaba Twitter! Umarım güzel bir gün geçiriyorsunuzdur.  ",
    "Unutmayın, en iyi kodlar okunabilir olanlardır. #CleanCode"
]

def send_random_tweet():
    """Rastgele bir mesaj seçer ve tweet olarak gönderir."""
    tweet_text = random.choice(tweet_messages)
    try:
        response = client.create_tweet(text=tweet_text)
        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Tweet başarıyla gönderildi: '{tweet_text}' (ID: {response.data['id']})")
    except tweepy.TweepyException as e:
        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Tweet gönderilirken hata oluştu: {e}")

if __name__ == "__main__":
    print("Otomatik tweet botu başlatılıyor...")
    while True:
        send_random_tweet()
        # Her 4 saatte bir tweet gönder (4  60 dakika  60 saniye = 14400 saniye)
        # Bu süreyi Twitter'ın API limitlerini ve spam politikalarını göz önünde bulundurarak ayarlayın.
        sleep_duration = 14400 
        print(f"Sonraki tweet için {sleep_duration / 3600} saat bekleniyor...")
        time.sleep(sleep_duration)

Bu bot, tweet_messages listesinden rastgele bir mesaj seçer ve send_random_tweet fonksiyonu aracılığıyla tweetler. while True döngüsü, botun sürekli çalışmasını sağlar ve time.sleep(sleep_duration) ile belirlenen süre boyunca bekler. Bu bekleme süresi, Twitter’ın API limitlerini aşmamak ve spam olarak algılanmamak için önemlidir. Gerçek bir botta bu süre daha uzun tutulabilir veya daha karmaşık bir zamanlama mekanizması (örneğin, cron job) kullanılabilir.

Daha Karmaşık Bir Bot Oluşturma – Örnek 2: Yanıt/Etkileşim Botu

Daha karmaşık bir bot örneği olarak, belirli anahtar kelimeleri içeren tweet’leri izleyen ve bunlara otomatik olarak yanıt veren bir etkileşim botu oluşturalım. Bu bot, daha önce işlenmiş tweet’leri tekrar yanıtlamamak için bir mekanizma da içerecektir.

Kod Yapısı

API anahtarlarını yükle ve Tweepy client’ı başlat.
İzlenecek anahtar kelimeleri ve verilecek yanıtları tanımla.
Daha önce işlenmiş tweet ID’lerini saklamak için bir mekanizma (örneğin, bir dosya) oluştur.
Belirli anahtar kelimeleri içeren tweet’leri arayan bir fonksiyon oluştur.
Bulunan tweet’lere yanıt veren ve işlenen ID’yi kaydeden bir fonksiyon oluştur.
Botun sürekli çalışmasını sağlayan bir döngü oluştur.

Örnek Kod

import tweepy
import os
import time
import json
from dotenv import load_dotenv

.env dosyasını yükle
load_dotenv()

API anahtarlarını al
bearer_token = os.getenv("BEARER_TOKEN")
consumer_key = os.getenv("CONSUMER_KEY")
consumer_secret = os.getenv("CONSUMER_SECRET")
access_token = os.getenv("ACCESS_TOKEN")
access_token_secret = os.getenv("ACCESS_TOKEN_SECRET")

Tweepy Client nesnesini başlat
try:
    client = tweepy.Client(
        bearer_token,
        consumer_key,
        consumer_secret,
        access_token,
        access_token_secret
    )
    me = client.get_me()
    my_user_id = me.data.id
    print(f"Bot olarak giriş yapıldı: @{me.data.username} (ID: {my_user_id})")
except tweepy.TweepyException as e:
    print(f"Hata: Tweepy Client başlatılamadı veya kimlik doğrulama başarısız: {e}")
    exit()

İzlenecek anahtar kelimeler ve bunlara verilecek yanıtlar
keywords_and_replies = {
    "python": ["Python harika bir dil! Öğrenmeye devam edin.", "Python ile neler yapmayı planlıyorsunuz?", "Python dünyasına hoş geldiniz!"],
    "bot": ["Bir bot mu arıyorsunuz? İşte buradayım!", "Botlar hayatı kolaylaştırır, değil mi?", "Ben de bir botum! Merhaba :)"],
    "yardım": ["Yardıma mı ihtiyacınız var? Belki size yardımcı olabilirim.", "Nasıl bir yardım arıyorsunuz? Detayları paylaşır mısınız?"],
    "tweepy": ["Tweepy ile Twitter botu yapmak çok kolay!", "Tweepy kütüphanesi harika bir seçim.", "Tweepy hakkında sorunuz mu var?"]
}

İşlenmiş tweet ID'lerini saklamak için dosya
PROCESSED_TWEETS_FILE = "processed_tweets.json"

def load_processed_tweets():
    """İşlenmiş tweet ID'lerini dosyadan yükler."""
    if os.path.exists(PROCESSED_TWEETS_FILE):
        with open(PROCESSED_TWEETS_FILE, 'r') as f:
            return set(json.load(f))
    return set()

def save_processed_tweets(processed_tweets):
    """İşlenmiş tweet ID'lerini dosyaya kaydeder."""
    with open(PROCESSED_TWEETS_FILE, 'w') as f:
        json.dump(list(processed_tweets), f)

def search_and_reply():
    """Belirli anahtar kelimeleri içeren tweetleri arar ve yanıtlar."""
    processed_tweets = load_processed_tweets()
    query = " OR ".join(keywords_and_replies.keys()) + " -is:retweet -is:reply lang:tr" # Retweetleri ve kendi yanıtlarımızı hariç tut, Türkçe tweet ara

    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Tweetler aranıyor: '{query}'")
    
    try:
        # Son 100 tweeti arıyoruz, daha fazla tweet için Paginator kullanılabilir.
        response = client.search_recent_tweets(query=query, tweet_fields=["author_id"], max_results=100)
        
        if response.data:
            for tweet in response.data:
                tweet_id = tweet.id
                tweet_text = tweet.text
                author_id = tweet.author_id

                # Kendi tweetlerimize yanıt vermemek için
                if author_id == my_user_id:
                    continue

                if str(tweet_id) not in processed_tweets:
                    print(f"Yeni tweet bulundu (ID: {tweet_id}, Yazar ID: {author_id}): {tweet_text}")
                    
                    # Tweet içeriğindeki anahtar kelimeleri kontrol et
                    found_keyword = None
                    for keyword in keywords_and_replies.keys():
                        if keyword.lower() in tweet_text.lower():
                            found_keyword = keyword
                            break
                    
                    if found_keyword:
                        reply_options = keywords_and_replies[found_keyword]
                        reply_text = random.choice(reply_options)
                        
                        # Yanıtı tweet'in yazarını etiketleyerek gönder
                        try:
                            # Orijinal tweet'in yazarının username'ini al
                            author_response = client.get_user(id=author_id)
                            author_username = author_response.data.username
                            
                            full_reply_text = f"@{author_username} {reply_text}"
                            
                            reply_response = client.create_tweet(
                                text=full_reply_text,
                                in_reply_to_tweet_id=tweet_id
                            )
                            print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Tweet ID {tweet_id} yanıtlandı. Yanıt ID: {reply_response.data['id']}")
                            processed_tweets.add(str(tweet_id))
                            save_processed_tweets(processed_tweets)
                        except tweepy.TweepyException as e:
                            print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Yanıt gönderilirken hata oluştu: {e}")
                    else:
                        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Anahtar kelime bulunamadı veya işlenmiş tweet: {tweet_id}")
                else:
                    # print(f"Tweet ID {tweet_id} zaten işlenmiş, atlanıyor.")
                    pass
        else:
            print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Yeni tweet bulunamadı.")
            
    except tweepy.TweepyException as e:
        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Tweet aranırken hata oluştu: {e}")

if __name__ == "__main__":
    print("Yanıt/Etkileşim botu başlatılıyor...")
    while True:
        search_and_reply()
        # Her 5 dakikada bir kontrol et (Twitter API limitlerini göz önünde bulundurun)
        sleep_duration = 300 
        print(f"Sonraki kontrol için {sleep_duration / 60} dakika bekleniyor...")
        time.sleep(sleep_duration)

Bu bot, keywords_and_replies sözlüğünde tanımlanan anahtar kelimeleri içeren tweet’leri arar. search_recent_tweets metodu ile son tweet’leri çeker. Her yeni tweet için, içeriğinde bir anahtar kelime olup olmadığını kontrol eder. Eğer bir anahtar kelime bulunursa, ilgili anahtar kelimeye atanmış yanıt listesinden rastgele bir yanıt seçer ve orijinal tweet’i yazarını etiketleyerek yanıtlar. processed_tweets.json dosyası, botun daha önce yanıtladığı tweet’lerin ID’lerini saklayarak aynı tweet’e birden fazla yanıt vermesini engeller. time.sleep fonksiyonu, API limitlerini aşmamak ve Twitter’ın otomasyon politikalarına uymak için botun belirli aralıklarla çalışmasını sağlar.

Gelişmiş Konular ve En İyi Uygulamalar

Bir Twitterbot geliştirirken ve onu çalışır durumda tutarken dikkate almanız gereken bazı gelişmiş konular ve en iyi uygulamalar bulunmaktadır.

Hata Yönetimi (Error Handling)

API çağrıları sırasında ağ sorunları, API limitlerine takılma veya geçersiz parametreler gibi çeşitli hatalar oluşabilir. Botunuzun kararlı bir şekilde çalışması için bu hataları uygun şekilde yönetmeniz önemlidir. Python’daki try-except blokları bu amaçla kullanılır.

try:
    response = client.create_tweet(text="Deneme tweeti")
    print("Tweet gönderildi.")
except tweepy.TooManyRequests as e:
    print(f"API limitine takıldı: {e}. Bir süre bekleniyor...")
    time.sleep(60 * 15) # 15 dakika bekle
except tweepy.TweepyException as e:
    print(f"Bir hata oluştu: {e}")
except Exception as e:
    print(f"Beklenmedik bir hata oluştu: {e}")

Tweepy, farklı hata türleri için özel istisnalar (örneğin tweepy.TooManyRequests API limitleri için) sağlar. Bu istisnaları yakalayarak botunuzun davranışını buna göre ayarlayabilirsiniz.

API Limitleri

Twitter API’sinin, belirli zaman dilimlerinde yapabileceğiniz istek sayısını sınırlayan katı limitleri vardır. Bu limitler, her API endpoint’i için farklılık gösterebilir (örneğin, tweet arama, tweet gönderme, kullanıcı bilgisi çekme). Limitleri aşmak, botunuzun geçici olarak engellenmesine neden olabilir. Botunuzu tasarlarken ve çalıştırırken bu limitleri göz önünde bulundurmalısınız. Tweepy, API limit bilgilerine erişmenizi sağlayan mekanizmalar sunar. Genellikle, her API çağrısından sonra bir miktar beklemek (time.sleep) veya API limitlerini kontrol ederek çağrıları ertelemek iyi bir stratejidir.

Veri Saklama (State Management)

Botunuzun durumunu (örneğin, son işlenen tweet ID’si, takip edilen kullanıcılar listesi) saklaması gerekebilir. Bu, botunuzun her yeniden başlatıldığında kaldığı yerden devam etmesini sağlar ve tekrar eden işlemlerden kaçınır. Basit botlar için JSON veya metin dosyaları kullanılabilirken, daha karmaşık botlar için SQLite gibi hafif bir veritabanı veya bulut tabanlı bir veritabanı çözümü tercih edilebilir.

# processed_tweets.json örneği, veri saklama için basit bir yöntemdir.
Daha gelişmiş botlar için SQLite veya PostgreSQL gibi veritabanları kullanılabilir.

Dağıtım (Deployment)

Botunuzun 24/7 çalışmasını istiyorsanız, onu yerel bilgisayarınızdan başka bir ortama dağıtmanız gerekir. Popüler dağıtım seçenekleri şunlardır:

Bulut Platformları: Heroku, AWS EC2, Google Cloud Platform veya Azure gibi bulut servisleri, botunuzu barındırmak için güçlü ve ölçeklenebilir çözümler sunar.
VPS (Sanal Özel Sunucu): DijitalOcean, Linode gibi sağlayıcılardan bir VPS kiralayarak kendi sunucunuzu kurabilir ve botunuzu burada çalıştırabilirsiniz.
PythonAnywhere: Python projeleri için özel olarak tasarlanmış, kullanımı kolay bir web hosting platformudur.
Cron Jobs (Linux/macOS): Eğer bir Linux veya macOS sunucunuz varsa, cron kullanarak botunuzun belirli aralıklarla otomatik olarak çalışmasını sağlayabilirsiniz.

Güvenlik

API anahtarlarınızı ve belirteçlerinizi güvende tutmak en önemli güvenlik önceliğidir. Daha önce bahsettiğimiz .env dosyası ve ortam değişkenleri kullanmak, bu bilgileri kodunuzdan ayırmanın ve versiyon kontrol sistemlerine (Git gibi) yanlışlıkla yüklemeyi önlemenin en iyi yoludur.

Twitter Politikalarına Uyum

Botunuzun Twitter tarafından askıya alınmasını önlemek için, Twitter’ın otomasyon politikalarını dikkatlice okuyun ve bunlara uyun. Botunuzun amacını ve nasıl çalıştığını açıkça belirtin, spam yapmaktan kaçının ve kullanıcı deneyimini olumsuz etkileyecek davranışlardan uzak durun. Her zaman botunuzun bir insan tarafından denetlenebilir olduğundan ve etik kurallara uyduğundan emin olun.

Sonuç

Bu makalede, Python 3 ve Tweepy kütüphanesini kullanarak kendi Twitterbot’unuzu nasıl oluşturacağınızı kapsamlı bir şekilde inceledik. Twitter Geliştirici Hesabı oluşturmaktan, API anahtarlarını almaya, Python ortamınızı hazırlamaya ve temel Tweepy komutlarını kullanmaya kadar adım adım ilerledik. Ayrıca, otomatik tweet atan ve belirli tweet’lere yanıt veren iki örnek bot oluşturarak öğrendiklerimizi pekiştirdik.

Bir Twitterbot oluşturmak, sadece teknik bir beceri değil, aynı zamanda yaratıcılığınızı ve otomasyon anlayışınızı geliştiren bir süreçtir. Botunuzu tasarlarken amacını, hedef kitlesini ve Twitter’ın etik kurallarını her zaman göz önünde bulundurmanız, başarılı ve sürdürülebilir bir proje için kritik öneme sahiptir. API limitlerini aşmamaya, hata yönetimini doğru yapmaya ve hassas bilgilerinizi güvende tutmaya özen gösterin.

Artık temel bilgilere sahip olduğunuza göre, kendi yaratıcı bot fikirlerinizi hayata geçirmek için iyi bir başlangıç noktasındasınız. Botunuzu daha da geliştirmek için Tweepy’nin diğer özelliklerini keşfedebilir, daha karmaşık algoritmalar uygulayabilir veya botunuzu harici veri kaynaklarıyla entegre edebilirsiniz. Unutmayın, pratik yapmak ve denemek, öğrenme sürecinin en önemli parçasıdır. Sorumlu ve yenilikçi botlar geliştirerek Twitter platformuna değer katmaya devam edin!

Python 3 ve Tweepy Kütüphanesi ile Bir Twitterbot Nasıl Oluşturulur?