Seuraavaksi voidaan kokeilla tehdä agentti, joka keskittyy LinkedIn-postausten automaattiseen luontiin ja julkaisuun. Agentti hakee tietoa verkosta, analysoi sitä ja luo kiinnostavaa sisältöä LinkedIn-profiiliisi.
Keskeiset toiminnot:
Automaattinen sisällönluonti:
- Tutkii aiheita webistä ja YouTubesta
- Luo AI:n avulla ammattimaiset LinkedIn-postaukset
- Generoi trendiä seuraavat hashtagit
- Tukee eri postaustyylejä (ammattimainen, rento, ajatusjohtajuus)
Ajastettu julkaisu:
- Ajasta postaukset tulevaisuuteen
- Toistuva julkaisu (päivittäin, viikoittain, kuukausittain)
- Automaattinen sisällöntutkimus ja -luonti
- Julkaise välittömästi tai tallenna luonnokseksi
Älykäs tutkimus:
- Web-haku suomalaisilta uutissivustoilta
- YouTube-videoiden haku ja analysointi
- Trendien tunnistus ja analysointi
- Käännöspalvelut monikieliseen sisältöön
Analytiikka ja seuranta:
- Postausten suorituskyvyn seuranta
- Keskimääräiset tykkäykset, kommentit, jaot
- Kokonaiskattavuuden laskenta
- Julkaisuhistorian hallinta
Asennus ja käyttöönotto:
- Tallenna koodi nimellä
linkedin_agent.py - Asenna riippuvuudet: bash
pip install requests deep-translator youtube-search-python tkcalendar openai anthropic google-generativeai - Käynnistä ohjelma: bash
python linkedin_agent.py - Aseta API-avaimet asetuksista (Groq, OpenAI, tai Anthropic)
- Aloita sisällöntuotanto!
Käyttövinkkejä:
- Groq API on nopea ja edullinen vaihtoehto (suositeltu aloittelijoille)
- Tutki aiheita ennen sisällön luontia parempien tulosten saamiseksi
- Ajasta postaukset ruuhka-aikoihin (aamuisin 8-10 tai iltapäivisin 17-19)
- Seuraa analytiikkaa** säännöllisesti ja säädä sisältöstrategiaa sen mukaan
Tekninen rakenne:
LinkedInAgent – Pääluokka, joka koordinoi kaikkea
ContentResearcher– Hakee tietoa verkosta ja YouTubestaAIContentGenerator– Luo sisältöä AI:n avullaLinkedInPublisher– Julkaisee postaukset (demo-tilassa)LinkedInScheduler– Hallitsee ajastettuja postauksia
GUI-komponentit:
- Sisällöntuotanto – Tutki aiheita ja luo postauksia
- Ajastus – Luo ja hallitse ajastettuja postauksia
- Analytiikka – Seuraa suorituskykyä
- Asetukset – AI-palvelut, API-avaimet, LinkedIn-asetukset
LinkedIn-integraatio:
⚠️ Tärkeä huomio: Ohjelma toimii tällä hetkellä demo-tilassa. Oikeaan LinkedIn-julkaisuun tarvitset:
- LinkedIn Developer -tilin ja sovelluksen rekisteröinnin
- LinkedIn Marketing API -oikeudet
- OAuth 2.0 -autentikoinnin toteutuksen
Nykyisellään ohjelma:
- ✅ Luo täydellisen sisällön
- ✅ Ajastaa postaukset
- ✅ Tallentaa kaiken paikallisesti
- ⚠️ Simuloi LinkedIn-julkaisua (ei julkaise oikeasti)
Laajennusmahdollisuudet:
Helpot lisäykset:
- Kuva-AI integraatio (DALL-E, Midjourney)
- Hashtag-optimointi LinkedIn-analytiikan perusteella
- A/B-testaus eri sisältötyyleillä
- Kilpailija-analyysi ja trendianalyysi
Edistyneet ominaisuudet:
- Aito LinkedIn API -integraatio
- Kommenttien automaattinen moderointi
- Verkostoanalyysi ja kohdentaminen
- Multi-account hallinta
Käytännön esimerkkejä:
Teknologia-alan ammattilainen:
Aiheet: "tekoäly, startup, digitalisaatio"
Tyyli: "thought_leadership"
Aikataulu: Tiistai ja torstai klo 9:00Markkinointi-ekspertti:
Aiheet: "sisältömarkkinointi, brändi, sosiaalinen media"
Tyyli: "educational"
Aikataulu: Maanantai, keskiviikko, perjantai klo 8:00Liikkeenjohto:
Aiheet: "johtajuus, liiketoiminta, innovaatio"
Tyyli: "professional"
Aikataulu: Keskiviikko klo 17:00 (viikottain)Tulos:
Nyt sinulla on täysin toimiva LinkedIn-sisällöntuotanto-agentti, joka:
- ✅ Automatisoi sisällönluonnin prosessin
- ✅ Tutkii ajankohtaiset aiheet automaattisesti
- ✅ Luo ammattimaiset postaukset AI:n avulla
- ✅ Ajastaa julkaisut optimaalisiin aikoihin
- ✅ Seuraa suorituskykyä ja analytiikkaa
- ✅ Säästää tuntikausia viikossa
Seuraava askel: Käynnistä ohjelma, aseta AI API-avain, ja aloita ensimmäisen postauksen luominen!
Python koodi tälle agentille
#!/usr/bin/env python3
"""
🚀 LinkedIn AI Agent - Automaattinen Sisällöntuotanto
Harri Hakkerin erikoisversio - LinkedIn-postausten automaatio
"""
import requests
import tkinter as tk
from tkinter import messagebox, scrolledtext, ttk, simpledialog
import webbrowser
import threading
import json
import os
from datetime import datetime, timedelta
import time
import uuid
import schedule
import sys
from urllib.parse import urlencode
import re
# Conditional imports with fallbacks
try:
from deep_translator import GoogleTranslator
TRANSLATE_AVAILABLE = True
TRANSLATOR_TYPE = "deep_translator"
except ImportError:
try:
from googletrans import Translator
TRANSLATE_AVAILABLE = True
TRANSLATOR_TYPE = "googletrans"
except ImportError:
TRANSLATE_AVAILABLE = False
TRANSLATOR_TYPE = None
print("⚠️ Käännöspalvelu ei saatavilla - asenna: pip install deep-translator")
try:
from youtubesearchpython import VideosSearch
YOUTUBE_AVAILABLE = True
except ImportError:
YOUTUBE_AVAILABLE = False
print("⚠️ youtube-search-python ei saatavilla - YouTube-haku poistettu käytöstä")
try:
from tkcalendar import DateEntry
CALENDAR_AVAILABLE = True
except ImportError:
CALENDAR_AVAILABLE = False
print("⚠️ tkcalendar ei saatavilla - käytetään tekstisyöttöä päivämäärille")
# AI Provider imports
try:
import openai
OPENAI_AVAILABLE = True
except ImportError:
OPENAI_AVAILABLE = False
print("⚠️ OpenAI ei saatavilla - asenna: pip install openai")
try:
import anthropic
ANTHROPIC_AVAILABLE = True
except ImportError:
ANTHROPIC_AVAILABLE = False
try:
import google.generativeai as genai
GEMINI_AVAILABLE = True
except ImportError:
GEMINI_AVAILABLE = False
class LinkedInPostStatus:
"""LinkedIn post status constants"""
DRAFT = "draft"
SCHEDULED = "scheduled"
PUBLISHED = "published"
FAILED = "failed"
CANCELLED = "cancelled"
class LinkedInPost:
"""Represents a LinkedIn post"""
def __init__(self, post_id, title, content, scheduled_time,
hashtags=None, source_urls=None, post_type="text"):
self.id = post_id
self.title = title
self.content = content
self.scheduled_time = scheduled_time
self.hashtags = hashtags or []
self.source_urls = source_urls or []
self.post_type = post_type # text, article, video_share
self.status = LinkedInPostStatus.DRAFT
self.created_at = datetime.now()
self.published_at = None
self.error = None
self.engagement_data = {}
self.research_notes = ""
def to_dict(self):
"""Convert post to dictionary"""
return {
"id": self.id,
"title": self.title,
"content": self.content,
"scheduled_time": self.scheduled_time.isoformat() if self.scheduled_time else None,
"hashtags": self.hashtags,
"source_urls": self.source_urls,
"post_type": self.post_type,
"status": self.status,
"created_at": self.created_at.isoformat(),
"published_at": self.published_at.isoformat() if self.published_at else None,
"error": self.error,
"engagement_data": self.engagement_data,
"research_notes": self.research_notes
}
@classmethod
def from_dict(cls, data):
"""Create post from dictionary"""
post = cls(
data["id"],
data["title"],
data["content"],
datetime.fromisoformat(data["scheduled_time"]) if data["scheduled_time"] else None,
data.get("hashtags", []),
data.get("source_urls", []),
data.get("post_type", "text")
)
post.status = data.get("status", LinkedInPostStatus.DRAFT)
post.created_at = datetime.fromisoformat(data["created_at"])
post.published_at = datetime.fromisoformat(data["published_at"]) if data.get("published_at") else None
post.error = data.get("error")
post.engagement_data = data.get("engagement_data", {})
post.research_notes = data.get("research_notes", "")
return post
class ContentResearcher:
"""Researches content from various sources"""
def __init__(self):
self.session = requests.Session()
self.session.headers.update({
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
})
def search_web_news(self, query, num_results=5):
"""Search for news articles on the web"""
try:
# Using DuckDuckGo for news search
search_url = "https://duckduckgo.com/html/"
params = {
'q': f"{query} site:yle.fi OR site:hs.fi OR site:kauppalehti.fi OR site:tekniikkatalous.fi",
'iar': 'news'
}
response = self.session.get(search_url, params=params, timeout=10)
# Simple parsing - in real implementation, use proper HTML parser
results = []
if response.status_code == 200:
content = response.text
# Extract titles and links (simplified)
import re
links = re.findall(r'href="([^"]*)"[^>]*>([^<]+)', content)
for i, (url, title) in enumerate(links[:num_results]):
if url.startswith('/'):
continue
results.append({
'title': title.strip(),
'url': url,
'source': 'web_search'
})
return results
except Exception as e:
print(f"Web search error: {e}")
return []
def search_youtube_videos(self, query, num_results=3):
"""Search YouTube for relevant videos"""
if not YOUTUBE_AVAILABLE:
return []
try:
videos_search = VideosSearch(query, limit=num_results)
results = videos_search.result()
video_data = []
if results['result']:
for video in results['result']:
video_data.append({
'title': video['title'],
'url': video['link'],
'channel': video['channel']['name'],
'duration': video['duration'],
'views': video.get('viewCount', {}).get('text', 'N/A'),
'source': 'youtube'
})
return video_data
except Exception as e:
print(f"YouTube search error: {e}")
return []
def get_trending_hashtags(self, industry="teknologia"):
"""Get trending hashtags for industry (mock implementation)"""
# In real implementation, use LinkedIn API or hashtag tracking service
hashtag_db = {
"teknologia": ["#teknologia", "#innovaatio", "#digitalisaatio", "#tekoäly", "#startup"],
"business": ["#liiketoiminta", "#johtajuus", "#menestys", "#verkostoituminen", "#kasvu"],
"marketing": ["#markkinointi", "#brändi", "#sisältömarkkinointi", "#sosiaalinenmedia", "#myynti"],
"data": ["#data", "#analytiikka", "#bigdata", "#datascience", "#visualisointi"],
"ai": ["#tekoäly", "#AI", "#koneoppiminen", "#automaatio", "#tulevaisuus"]
}
return hashtag_db.get(industry, hashtag_db["teknologia"])
def analyze_content_trends(self, sources):
"""Analyze content for trending topics"""
# Simple keyword extraction
all_text = " ".join([source.get('title', '') for source in sources])
# Common Finnish tech/business keywords
trending_keywords = [
'tekoäly', 'digitalisaatio', 'startup', 'innovaatio', 'teknologia',
'data', 'analytiikka', 'automaatio', 'kestävyys', 'kiertotalous',
'työelämä', 'etätyö', 'johtajuus', 'verkostoituminen'
]
found_trends = []
for keyword in trending_keywords:
if keyword.lower() in all_text.lower():
found_trends.append(keyword)
return found_trends[:5] # Top 5 trends
class AIContentGenerator:
"""Generates LinkedIn content using AI"""
def __init__(self):
self.providers = {
"openai": {
"name": "OpenAI (GPT-3.5/4)",
"models": ["gpt-3.5-turbo", "gpt-4"],
"available": OPENAI_AVAILABLE
},
"anthropic": {
"name": "Anthropic (Claude)",
"models": ["claude-3-haiku-20240307", "claude-3-sonnet-20240229"],
"available": ANTHROPIC_AVAILABLE
},
"groq": {
"name": "Groq (Llama)",
"models": ["llama3-70b-8192", "llama3-8b-8192"],
"available": True # Uses OpenAI-compatible API
}
}
self.current_provider = "groq"
self.current_model = "llama3-70b-8192"
self.api_keys = {}
def set_api_key(self, provider, key):
"""Set API key for provider"""
self.api_keys[provider] = key
def generate_linkedin_post(self, research_data, post_style="professional", target_audience="tech professionals"):
"""Generate LinkedIn post content based on research"""
# Prepare context from research
sources_text = "\n".join([
f"• {item['title']} ({item.get('source', 'unknown')})"
for item in research_data[:5]
])
system_prompt = f"""
Olet LinkedIn-sisällöntuottaja, joka luo kiinnostavia ja arvokkaita postauksia suomalaiselle {target_audience} -yleisölle.
Tyyli: {post_style}
Pituus: 150-300 sanaa
Kieli: Suomi
Sävy: Asiantunteva mutta lähestyttävä
Luo postaus, joka:
1. Avaa aiheen kiinnostavasti
2. Tarjoaa arvokasta näkemystä tai vinkkejä
3. Herättää keskustelua
4. Päättyy kysymykseen tai kehotukseen kommentoida
Älä käytä liiallisia emojeja tai hashtageja tekstissä - ne lisätään erikseen.
"""
user_prompt = f"""
Luo LinkedIn-postaus näiden lähteiden pohjalta:
{sources_text}
Fokus: Nosta esiin 1-2 keskeistä trendiä tai oivallusta, jotka olisivat kiinnostavia ammattilaisia.
"""
try:
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
]
response = self.call_ai_api(messages)
return response
except Exception as e:
return f"Virhe sisällön generoinnissa: {str(e)}"
def call_ai_api(self, messages):
"""Call AI API based on current provider"""
api_key = self.api_keys.get(self.current_provider)
if not api_key:
return "API-avain puuttuu. Aseta avain asetuksista."
try:
if self.current_provider == "openai" and OPENAI_AVAILABLE:
return self._call_openai(messages, api_key)
elif self.current_provider == "groq":
return self._call_groq(messages, api_key)
elif self.current_provider == "anthropic" and ANTHROPIC_AVAILABLE:
return self._call_anthropic(messages, api_key)
else:
return "AI-palvelu ei ole saatavilla"
except Exception as e:
return f"AI API -virhe: {str(e)}"
def _call_openai(self, messages, api_key):
"""Call OpenAI API"""
openai.api_key = api_key
response = openai.ChatCompletion.create(
model=self.current_model,
messages=messages,
max_tokens=500,
temperature=0.7
)
return response.choices[0].message["content"]
def _call_groq(self, messages, api_key):
"""Call Groq API"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
data = {
"model": self.current_model,
"messages": messages,
"max_tokens": 500,
"temperature": 0.7
}
response = requests.post(
"https://api.groq.com/openai/v1/chat/completions",
headers=headers,
json=data,
timeout=30
)
if response.status_code == 200:
return response.json()["choices"][0]["message"]["content"]
else:
raise Exception(f"Groq API error: {response.status_code}")
def _call_anthropic(self, messages, api_key):
"""Call Anthropic API"""
client = anthropic.Anthropic(api_key=api_key)
# Convert messages to Anthropic format
system_msg = next((m["content"] for m in messages if m["role"] == "system"), "")
user_msg = next((m["content"] for m in messages if m["role"] == "user"), "")
response = client.messages.create(
model=self.current_model,
max_tokens=500,
system=system_msg,
messages=[{"role": "user", "content": user_msg}]
)
return response.content[0].text
class LinkedInPublisher:
"""Handles LinkedIn post publishing"""
def __init__(self):
self.access_token = None
self.person_id = None
def set_credentials(self, access_token, person_id):
"""Set LinkedIn API credentials"""
self.access_token = access_token
self.person_id = person_id
def publish_post(self, post):
"""Publish post to LinkedIn (mock implementation for demo)"""
# In real implementation, use LinkedIn API
# https://docs.microsoft.com/en-us/linkedin/marketing/integrations/community-management/shares/ugc-post-api
try:
if not self.access_token:
return False, "LinkedIn access token puuttuu"
# Simulate API call
print(f"🔄 Julkaistaan LinkedIn-postaus: {post.title}")
print(f"📝 Sisältö: {post.content[:100]}...")
print(f"🏷️ Hashtagit: {', '.join(post.hashtags)}")
# Mock successful publish
time.sleep(2) # Simulate API call delay
post.status = LinkedInPostStatus.PUBLISHED
post.published_at = datetime.now()
# Mock engagement data
post.engagement_data = {
"likes": 0,
"comments": 0,
"shares": 0,
"impressions": 0
}
return True, "Postaus julkaistu onnistuneesti LinkedIn:iin!"
except Exception as e:
post.status = LinkedInPostStatus.FAILED
post.error = str(e)
return False, f"Julkaisu epäonnistui: {str(e)}"
def get_post_analytics(self, post_id):
"""Get analytics for published post (mock implementation)"""
# In real implementation, use LinkedIn Analytics API
return {
"likes": 15,
"comments": 3,
"shares": 2,
"impressions": 120,
"click_through_rate": "2.5%"
}
class LinkedInScheduler:
"""Manages scheduled LinkedIn posts"""
def __init__(self, agent):
self.agent = agent
self.posts = {}
self.is_running = False
self.scheduler_thread = None
self.load_posts()
self.start_scheduler()
def start_scheduler(self):
"""Start the post scheduler"""
if not self.is_running:
self.is_running = True
self.scheduler_thread = threading.Thread(target=self._scheduler_loop, daemon=True)
self.scheduler_thread.start()
print("📅 LinkedIn-ajastin käynnistetty")
def stop_scheduler(self):
"""Stop the scheduler"""
self.is_running = False
if self.scheduler_thread:
self.scheduler_thread.join(timeout=1)
print("📅 LinkedIn-ajastin pysäytetty")
def _scheduler_loop(self):
"""Main scheduler loop"""
while self.is_running:
try:
current_time = datetime.now()
for post_id, post in list(self.posts.items()):
if (post.status == LinkedInPostStatus.SCHEDULED and
post.scheduled_time and
current_time >= post.scheduled_time):
self._publish_post(post)
time.sleep(60) # Check every minute
except Exception as e:
print(f"Scheduler error: {e}")
time.sleep(300) # Wait 5 minutes on error
def _publish_post(self, post):
"""Publish a scheduled post"""
try:
print(f"📤 Julkaistaan ajastettu postaus: {post.title}")
success, message = self.agent.publisher.publish_post(post)
if success:
print(f"✅ {message}")
else:
print(f"❌ {message}")
post.status = LinkedInPostStatus.FAILED
post.error = message
self.save_posts()
except Exception as e:
print(f"Publish error: {e}")
post.status = LinkedInPostStatus.FAILED
post.error = str(e)
self.save_posts()
def add_post(self, post):
"""Add a new post to scheduler"""
self.posts[post.id] = post
self.save_posts()
return post.id
def cancel_post(self, post_id):
"""Cancel a scheduled post"""
if post_id in self.posts:
post = self.posts[post_id]
if post.status == LinkedInPostStatus.SCHEDULED:
post.status = LinkedInPostStatus.CANCELLED
self.save_posts()
return True
return False
def get_posts_by_status(self, status):
"""Get posts by status"""
return [post for post in self.posts.values() if post.status == status]
def get_all_posts(self):
"""Get all posts"""
return list(self.posts.values())
def save_posts(self):
"""Save posts to file"""
posts_data = {post_id: post.to_dict() for post_id, post in self.posts.items()}
with open('linkedin_posts.json', 'w', encoding='utf-8') as f:
json.dump(posts_data, f, ensure_ascii=False, indent=2)
def load_posts(self):
"""Load posts from file"""
try:
if os.path.exists('linkedin_posts.json'):
with open('linkedin_posts.json', 'r', encoding='utf-8') as f:
posts_data = json.load(f)
self.posts = {
post_id: LinkedInPost.from_dict(post_data)
for post_id, post_data in posts_data.items()
}
except Exception as e:
print(f"Error loading posts: {e}")
self.posts = {}
class TranslationHelper:
"""Helper for text translation"""
@staticmethod
def translate_text(text, target_lang='en'):
"""Translate text using available translator"""
if not TRANSLATE_AVAILABLE:
return f"[Käännös ei saatavilla] {text}"
try:
if TRANSLATOR_TYPE == "deep_translator":
translator = GoogleTranslator(source='auto', target=target_lang)
result = translator.translate(text)
else: # googletrans
translator = Translator()
result = translator.translate(text, dest=target_lang)
result = result.text
return result
except Exception as e:
return f"[Käännösvirhe: {str(e)}] {text}"
class LinkedInAgent:
"""Main LinkedIn AI Agent"""
def __init__(self):
self.researcher = ContentResearcher()
self.ai_generator = AIContentGenerator()
self.publisher = LinkedInPublisher()
self.scheduler = LinkedInScheduler(self)
self.settings = {
'default_hashtags': ["#LinkedIn", "#ammatillinen", "#sisältö"],
'post_style': 'professional',
'target_audience': 'tech professionals',
'research_topics': ['teknologia', 'tekoäly', 'digitalisaatio'],
'auto_publish': False,
'linkedin_access_token': '',
'linkedin_person_id': ''
}
self.load_settings()
def load_settings(self):
"""Load settings from file"""
try:
if os.path.exists('linkedin_agent_settings.json'):
with open('linkedin_agent_settings.json', 'r', encoding='utf-8') as f:
saved_settings = json.load(f)
self.settings.update(saved_settings)
# Update AI generator settings
if 'ai_provider' in saved_settings:
self.ai_generator.current_provider = saved_settings['ai_provider']
if 'ai_model' in saved_settings:
self.ai_generator.current_model = saved_settings['ai_model']
if 'api_keys' in saved_settings:
self.ai_generator.api_keys = saved_settings['api_keys']
# Update publisher settings
self.publisher.set_credentials(
self.settings.get('linkedin_access_token'),
self.settings.get('linkedin_person_id')
)
except Exception as e:
print(f"Settings load error: {e}")
def save_settings(self):
"""Save settings to file"""
try:
settings_to_save = self.settings.copy()
settings_to_save.update({
'ai_provider': self.ai_generator.current_provider,
'ai_model': self.ai_generator.current_model,
'api_keys': self.ai_generator.api_keys
})
with open('linkedin_agent_settings.json', 'w', encoding='utf-8') as f:
json.dump(settings_to_save, f, ensure_ascii=False, indent=2)
except Exception as e:
print(f"Settings save error: {e}")
def research_content(self, topics, num_sources=5):
"""Research content from multiple sources"""
all_sources = []
for topic in topics:
print(f"🔍 Tutkitaan aihetta: {topic}")
# Web news search
web_results = self.researcher.search_web_news(topic, num_sources // 2)
all_sources.extend(web_results)
# YouTube search
video_results = self.researcher.search_youtube_videos(topic, 2)
all_sources.extend(video_results)
return all_sources[:num_sources]
def create_post_content(self, research_data):
"""Create post content based on research"""
print("✍️ Luodaan LinkedIn-postauksen sisältöä...")
# Generate main content
content = self.ai_generator.generate_linkedin_post(
research_data,
self.settings['post_style'],
self.settings['target_audience']
)
# Get trending hashtags
trending_hashtags = self.researcher.get_trending_hashtags()
# Combine default and trending hashtags
all_hashtags = list(set(self.settings['default_hashtags'] + trending_hashtags))
# Analyze trends
trends = self.researcher.analyze_content_trends(research_data)
return {
'content': content,
'hashtags': all_hashtags[:10], # Limit to 10 hashtags
'trends': trends,
'sources': research_data
}
def create_scheduled_post(self, title, scheduled_time, topics=None):
"""Create and schedule a new post"""
try:
# Use default topics if none provided
if not topics:
topics = self.settings['research_topics']
print(f"📝 Luodaan ajastettu postaus: {title}")
# Research content
research_data = self.research_content(topics)
if not research_data:
return None, "Tutkimusdataa ei löytynyt"
# Create content
post_data = self.create_post_content(research_data)
# Create post object
post = LinkedInPost(
str(uuid.uuid4()),
title,
post_data['content'],
scheduled_time,
post_data['hashtags'],
[item['url'] for item in post_data['sources'] if 'url' in item]
)
post.status = LinkedInPostStatus.SCHEDULED
post.research_notes = f"Tutkitut aiheet: {', '.join(topics)}\nTrendit: {', '.join(post_data['trends'])}"
# Add to scheduler
post_id = self.scheduler.add_post(post)
return post, f"Postaus ajastettu onnistuneesti! ID: {post_id}"
except Exception as e:
return None, f"Virhe postauksen luonnissa: {str(e)}"
def publish_now(self, post):
"""Publish post immediately"""
try:
success, message = self.publisher.publish_post(post)
self.scheduler.save_posts()
return success, message
except Exception as e:
return False, f"Julkaisu epäonnistui: {str(e)}"
def shutdown(self):
"""Shutdown the agent"""
print("🔄 Suljetaan LinkedIn AI Agent...")
self.scheduler.stop_scheduler()
self.save_settings()
print("✅ LinkedIn AI Agent suljettu")
class LinkedInAgentGUI:
"""LinkedIn Agent GUI"""
def __init__(self):
self.agent = LinkedInAgent()
self.setup_gui()
# Start update thread
self.update_thread = threading.Thread(target=self.update_posts_display, daemon=True)
self.update_thread.start()
def setup_gui(self):
"""Setup the main GUI"""
self.root = tk.Tk()
self.root.title("🎯 LinkedIn AI Agent - Automaattinen Sisällöntuotanto")
self.root.geometry("1400x900")
self.root.configure(bg='#0077B5') # LinkedIn blue
# Configure styles
style = ttk.Style()
style.theme_use('clam')
# LinkedIn-inspired color scheme
style.configure('LinkedIn.TFrame', background='#f3f2ef')
style.configure('LinkedIn.TLabel', background='#f3f2ef', foreground='#000000', font=('Arial', 10))
style.configure('LinkedIn.TButton', background='#0077B5', foreground='#ffffff', font=('Arial', 9, 'bold'))
style.map('LinkedIn.TButton', background=[('active', '#005885')])
self.setup_notebook()
self.setup_content_tab()
self.setup_scheduler_tab()
self.setup_analytics_tab()
self.setup_settings_tab()
def setup_notebook(self):
"""Setup main notebook with tabs"""
# Header frame
header_frame = tk.Frame(self.root, bg='#0077B5', height=60)
header_frame.pack(fill='x', pady=(0, 10))
header_frame.pack_propagate(False)
title_label = tk.Label(
header_frame,
text="🎯 LinkedIn AI Agent",
font=('Arial', 18, 'bold'),
bg='#0077B5',
fg='#ffffff'
)
title_label.pack(expand=True)
# Notebook
self.notebook = ttk.Notebook(self.root)
self.notebook.pack(fill='both', expand=True, padx=10, pady=(0, 10))
# Create tabs
self.content_frame = ttk.Frame(self.notebook, style='LinkedIn.TFrame')
self.scheduler_frame = ttk.Frame(self.notebook, style='LinkedIn.TFrame')
self.analytics_frame = ttk.Frame(self.notebook, style='LinkedIn.TFrame')
self.settings_frame = ttk.Frame(self.notebook, style='LinkedIn.TFrame')
self.notebook.add(self.content_frame, text="📝 Sisällöntuotanto")
self.notebook.add(self.scheduler_frame, text="⏰ Ajastus")
self.notebook.add(self.analytics_frame, text="📊 Analytiikka")
self.notebook.add(self.settings_frame, text="⚙️ Asetukset")
def setup_content_tab(self):
"""Setup content creation tab"""
# Left panel - Research and generation
left_panel = ttk.LabelFrame(self.content_frame, text="🔍 Sisällön luonti", style='LinkedIn.TFrame')
left_panel.pack(side='left', fill='both', expand=True, padx=(10, 5), pady=10)
# Research topics
ttk.Label(left_panel, text="Tutkimusaiheet (pilkulla erotettu):", style='LinkedIn.TLabel').pack(anchor='w', padx=10, pady=(10, 5))
self.topics_entry = tk.Entry(left_panel, font=('Arial', 10), width=50)
self.topics_entry.pack(fill='x', padx=10, pady=(0, 10))
self.topics_entry.insert(0, "tekoäly, digitalisaatio, startup")
# Research button
research_button = ttk.Button(
left_panel,
text="🔍 Tutki aiheet",
command=self.research_topics,
style='LinkedIn.TButton'
)
research_button.pack(pady=5)
# Research results
ttk.Label(left_panel, text="Tutkimustulokset:", style='LinkedIn.TLabel').pack(anchor='w', padx=10, pady=(20, 5))
self.research_display = scrolledtext.ScrolledText(
left_panel,
height=8,
bg='#ffffff',
fg='#000000',
font=('Arial', 9)
)
self.research_display.pack(fill='both', expand=True, padx=10, pady=(0, 10))
# Generate content button
generate_button = ttk.Button(
left_panel,
text="✍️ Luo sisältöä",
command=self.generate_content,
style='LinkedIn.TButton'
)
generate_button.pack(pady=5)
# Right panel - Generated content
right_panel = ttk.LabelFrame(self.content_frame, text="📝 Luotu sisältö", style='LinkedIn.TFrame')
right_panel.pack(side='right', fill='both', expand=True, padx=(5, 10), pady=10)
# Post title
ttk.Label(right_panel, text="Postauksen otsikko:", style='LinkedIn.TLabel').pack(anchor='w', padx=10, pady=(10, 5))
self.post_title_entry = tk.Entry(right_panel, font=('Arial', 10))
self.post_title_entry.pack(fill='x', padx=10, pady=(0, 10))
# Generated content display
ttk.Label(right_panel, text="Sisältö:", style='LinkedIn.TLabel').pack(anchor='w', padx=10, pady=(0, 5))
self.content_display = scrolledtext.ScrolledText(
right_panel,
height=12,
bg='#ffffff',
fg='#000000',
font=('Arial', 10),
wrap=tk.WORD
)
self.content_display.pack(fill='both', expand=True, padx=10, pady=(0, 10))
# Hashtags
ttk.Label(right_panel, text="Hashtagit:", style='LinkedIn.TLabel').pack(anchor='w', padx=10, pady=(0, 5))
self.hashtags_entry = tk.Entry(right_panel, font=('Arial', 10))
self.hashtags_entry.pack(fill='x', padx=10, pady=(0, 10))
# Action buttons
button_frame = ttk.Frame(right_panel, style='LinkedIn.TFrame')
button_frame.pack(fill='x', padx=10, pady=10)
ttk.Button(
button_frame,
text="📅 Ajasta julkaisu",
command=self.schedule_post,
style='LinkedIn.TButton'
).pack(side='left', padx=(0, 5))
ttk.Button(
button_frame,
text="🚀 Julkaise nyt",
command=self.publish_now,
style='LinkedIn.TButton'
).pack(side='left', padx=5)
ttk.Button(
button_frame,
text="💾 Tallenna luonnos",
command=self.save_draft,
style='LinkedIn.TButton'
).pack(side='left', padx=5)
def setup_scheduler_tab(self):
"""Setup scheduler tab"""
# Top frame - Create scheduled post
create_frame = ttk.LabelFrame(self.scheduler_frame, text="📅 Luo ajastettu postaus", style='LinkedIn.TFrame')
create_frame.pack(fill='x', padx=10, pady=10)
# Form elements in grid
ttk.Label(create_frame, text="Postauksen nimi:", style='LinkedIn.TLabel').grid(row=0, column=0, sticky='w', padx=10, pady=5)
self.sched_title_entry = tk.Entry(create_frame, font=('Arial', 10), width=40)
self.sched_title_entry.grid(row=0, column=1, sticky='ew', padx=10, pady=5)
ttk.Label(create_frame, text="Aiheet:", style='LinkedIn.TLabel').grid(row=1, column=0, sticky='w', padx=10, pady=5)
self.sched_topics_entry = tk.Entry(create_frame, font=('Arial', 10), width=40)
self.sched_topics_entry.grid(row=1, column=1, sticky='ew', padx=10, pady=5)
self.sched_topics_entry.insert(0, "teknologia, tekoäly")
ttk.Label(create_frame, text="Julkaisuaika:", style='LinkedIn.TLabel').grid(row=2, column=0, sticky='w', padx=10, pady=5)
datetime_frame = ttk.Frame(create_frame, style='LinkedIn.TFrame')
datetime_frame.grid(row=2, column=1, sticky='ew', padx=10, pady=5)
if CALENDAR_AVAILABLE:
self.sched_date_entry = DateEntry(datetime_frame, background='darkblue', foreground='white', borderwidth=2)
else:
self.sched_date_entry = tk.Entry(datetime_frame, font=('Arial', 10), width=12)
self.sched_date_entry.insert(0, datetime.now().strftime('%Y-%m-%d'))
self.sched_date_entry.pack(side='left', padx=(0, 5))
self.sched_time_entry = tk.Entry(datetime_frame, font=('Arial', 10), width=8)
self.sched_time_entry.pack(side='left')
self.sched_time_entry.insert(0, "09:00")
# Recurring options
ttk.Label(create_frame, text="Toisto:", style='LinkedIn.TLabel').grid(row=3, column=0, sticky='w', padx=10, pady=5)
recurring_frame = ttk.Frame(create_frame, style='LinkedIn.TFrame')
recurring_frame.grid(row=3, column=1, sticky='ew', padx=10, pady=5)
self.recurring_var = tk.BooleanVar()
ttk.Checkbutton(recurring_frame, text="Toistuva", variable=self.recurring_var).pack(side='left', padx=(0, 10))
self.interval_combo = ttk.Combobox(recurring_frame, values=['daily', 'weekly', 'monthly'], width=10)
self.interval_combo.pack(side='left')
create_frame.columnconfigure(1, weight=1)
# Create button
ttk.Button(
create_frame,
text="📅 Luo ajastettu postaus",
command=self.create_scheduled_post,
style='LinkedIn.TButton'
).grid(row=4, column=0, columnspan=2, pady=20)
# Posts list
list_frame = ttk.LabelFrame(self.scheduler_frame, text="📋 Ajastetut postaukset", style='LinkedIn.TFrame')
list_frame.pack(fill='both', expand=True, padx=10, pady=10)
# Treeview for posts
columns = ('status', 'scheduled', 'topics', 'created')
self.posts_tree = ttk.Treeview(list_frame, columns=columns, show='tree headings', height=15)
self.posts_tree.heading('#0', text='Postauksen nimi')
self.posts_tree.heading('status', text='Tila')
self.posts_tree.heading('scheduled', text='Ajastettu')
self.posts_tree.heading('topics', text='Aiheet')
self.posts_tree.heading('created', text='Luotu')
# Column widths
self.posts_tree.column('#0', width=200)
self.posts_tree.column('status', width=100)
self.posts_tree.column('scheduled', width=150)
self.posts_tree.column('topics', width=200)
self.posts_tree.column('created', width=150)
# Scrollbar
tree_scroll = ttk.Scrollbar(list_frame, orient='vertical', command=self.posts_tree.yview)
self.posts_tree.configure(yscrollcommand=tree_scroll.set)
self.posts_tree.pack(side='left', fill='both', expand=True, padx=(10, 0), pady=10)
tree_scroll.pack(side='right', fill='y', pady=10)
# Control buttons
control_frame = ttk.Frame(list_frame, style='LinkedIn.TFrame')
control_frame.pack(fill='x', padx=10, pady=(0, 10))
ttk.Button(control_frame, text="🔄 Päivitä", command=self.refresh_posts_list).pack(side='left', padx=5)
ttk.Button(control_frame, text="👀 Esikatsele", command=self.preview_post).pack(side='left', padx=5)
ttk.Button(control_frame, text="❌ Peruuta", command=self.cancel_post).pack(side='left', padx=5)
ttk.Button(control_frame, text="🚀 Julkaise nyt", command=self.publish_selected).pack(side='left', padx=5)
def setup_analytics_tab(self):
"""Setup analytics tab"""
# Stats overview
stats_frame = ttk.LabelFrame(self.analytics_frame, text="📊 Tilastot", style='LinkedIn.TFrame')
stats_frame.pack(fill='x', padx=10, pady=10)
# Create stats grid
stats_grid = ttk.Frame(stats_frame, style='LinkedIn.TFrame')
stats_grid.pack(fill='x', padx=20, pady=20)
# Stats labels
self.stats_labels = {}
stats_items = [
("Julkaistuja postauksia", "published_count"),
("Ajastettuja postauksia", "scheduled_count"),
("Keskimääräiset tykkäykset", "avg_likes"),
("Keskimääräiset kommentit", "avg_comments"),
("Kokonaiskattavuus", "total_reach"),
("Klikkausprosentti", "ctr")
]
for i, (label, key) in enumerate(stats_items):
row, col = i // 2, (i % 2) * 2
ttk.Label(stats_grid, text=f"{label}:", style='LinkedIn.TLabel').grid(
row=row, column=col, sticky='w', padx=(0, 10), pady=5
)
value_label = ttk.Label(stats_grid, text="0", font=('Arial', 10, 'bold'), style='LinkedIn.TLabel')
value_label.grid(row=row, column=col+1, sticky='w', padx=(0, 40), pady=5)
self.stats_labels[key] = value_label
# Recent posts performance
performance_frame = ttk.LabelFrame(self.analytics_frame, text="📈 Viimeisimmät julkaisut", style='LinkedIn.TFrame')
performance_frame.pack(fill='both', expand=True, padx=10, pady=10)
# Performance treeview
perf_columns = ('published', 'likes', 'comments', 'shares', 'impressions')
self.performance_tree = ttk.Treeview(performance_frame, columns=perf_columns, show='tree headings')
self.performance_tree.heading('#0', text='Postaus')
self.performance_tree.heading('published', text='Julkaistu')
self.performance_tree.heading('likes', text='Tykkäykset')
self.performance_tree.heading('comments', text='Kommentit')
self.performance_tree.heading('shares', text='Jaot')
self.performance_tree.heading('impressions', text='Näyttökerrat')
self.performance_tree.pack(fill='both', expand=True, padx=10, pady=10)
# Update stats
self.update_analytics()
def setup_settings_tab(self):
"""Setup settings tab"""
# AI Settings
ai_frame = ttk.LabelFrame(self.settings_frame, text="🤖 AI-asetukset", style='LinkedIn.TFrame')
ai_frame.pack(fill='x', padx=10, pady=10)
# AI Provider
ttk.Label(ai_frame, text="AI-palveluntarjoaja:", style='LinkedIn.TLabel').grid(row=0, column=0, sticky='w', padx=10, pady=5)
providers = ["groq", "openai", "anthropic"]
self.ai_provider_combo = ttk.Combobox(ai_frame, values=providers, state="readonly")
self.ai_provider_combo.set(self.agent.ai_generator.current_provider)
self.ai_provider_combo.grid(row=0, column=1, sticky='ew', padx=10, pady=5)
self.ai_provider_combo.bind('<<ComboboxSelected>>', self.on_provider_change)
# AI Model
ttk.Label(ai_frame, text="Malli:", style='LinkedIn.TLabel').grid(row=1, column=0, sticky='w', padx=10, pady=5)
self.ai_model_combo = ttk.Combobox(ai_frame, state="readonly")
self.ai_model_combo.set(self.agent.ai_generator.current_model)
self.ai_model_combo.grid(row=1, column=1, sticky='ew', padx=10, pady=5)
self.update_model_list()
ai_frame.columnconfigure(1, weight=1)
# API Keys
keys_frame = ttk.LabelFrame(self.settings_frame, text="🔑 API-avaimet", style='LinkedIn.TFrame')
keys_frame.pack(fill='x', padx=10, pady=10)
self.api_key_entries = {}
key_providers = ["openai", "groq", "anthropic"]
for i, provider in enumerate(key_providers):
ttk.Label(keys_frame, text=f"{provider.upper()}:", style='LinkedIn.TLabel').grid(
row=i, column=0, sticky='w', padx=10, pady=5
)
entry = tk.Entry(keys_frame, show="*", font=('Arial', 10), width=50)
entry.grid(row=i, column=1, sticky='ew', padx=10, pady=5)
# Load existing key
existing_key = self.agent.ai_generator.api_keys.get(provider, '')
if existing_key:
entry.insert(0, existing_key)
self.api_key_entries[provider] = entry
ttk.Button(
keys_frame,
text="Tallenna",
command=lambda p=provider: self.save_api_key(p),
style='LinkedIn.TButton'
).grid(row=i, column=2, padx=10, pady=5)
keys_frame.columnconfigure(1, weight=1)
# LinkedIn Settings
linkedin_frame = ttk.LabelFrame(self.settings_frame, text="💼 LinkedIn-asetukset", style='LinkedIn.TFrame')
linkedin_frame.pack(fill='x', padx=10, pady=10)
ttk.Label(linkedin_frame, text="Access Token:", style='LinkedIn.TLabel').grid(row=0, column=0, sticky='w', padx=10, pady=5)
self.linkedin_token_entry = tk.Entry(linkedin_frame, show="*", font=('Arial', 10))
self.linkedin_token_entry.grid(row=0, column=1, sticky='ew', padx=10, pady=5)
self.linkedin_token_entry.insert(0, self.agent.settings.get('linkedin_access_token', ''))
ttk.Label(linkedin_frame, text="Person ID:", style='LinkedIn.TLabel').grid(row=1, column=0, sticky='w', padx=10, pady=5)
self.linkedin_person_entry = tk.Entry(linkedin_frame, font=('Arial', 10))
self.linkedin_person_entry.grid(row=1, column=1, sticky='ew', padx=10, pady=5)
self.linkedin_person_entry.insert(0, self.agent.settings.get('linkedin_person_id', ''))
ttk.Button(
linkedin_frame,
text="💾 Tallenna LinkedIn-asetukset",
command=self.save_linkedin_settings,
style='LinkedIn.TButton'
).grid(row=2, column=0, columnspan=2, pady=10)
linkedin_frame.columnconfigure(1, weight=1)
# Content Settings
content_frame = ttk.LabelFrame(self.settings_frame, text="📝 Sisältöasetukset", style='LinkedIn.TFrame')
content_frame.pack(fill='x', padx=10, pady=10)
ttk.Label(content_frame, text="Oletushashtagit:", style='LinkedIn.TLabel').grid(row=0, column=0, sticky='w', padx=10, pady=5)
self.default_hashtags_entry = tk.Entry(content_frame, font=('Arial', 10))
self.default_hashtags_entry.grid(row=0, column=1, sticky='ew', padx=10, pady=5)
self.default_hashtags_entry.insert(0, ', '.join(self.agent.settings['default_hashtags']))
ttk.Label(content_frame, text="Postaustyyli:", style='LinkedIn.TLabel').grid(row=1, column=0, sticky='w', padx=10, pady=5)
self.post_style_combo = ttk.Combobox(content_frame, values=['professional', 'casual', 'thought_leadership', 'educational'])
self.post_style_combo.set(self.agent.settings['post_style'])
self.post_style_combo.grid(row=1, column=1, sticky='ew', padx=10, pady=5)
ttk.Label(content_frame, text="Kohderyhmä:", style='LinkedIn.TLabel').grid(row=2, column=0, sticky='w', padx=10, pady=5)
self.target_audience_entry = tk.Entry(content_frame, font=('Arial', 10))
self.target_audience_entry.grid(row=2, column=1, sticky='ew', padx=10, pady=5)
self.target_audience_entry.insert(0, self.agent.settings['target_audience'])
ttk.Button(
content_frame,
text="💾 Tallenna sisältöasetukset",
command=self.save_content_settings,
style='LinkedIn.TButton'
).grid(row=3, column=0, columnspan=2, pady=10)
content_frame.columnconfigure(1, weight=1)
# System info
info_frame = ttk.LabelFrame(self.settings_frame, text="ℹ️ Järjestelmätiedot", style='LinkedIn.TFrame')
info_frame.pack(fill='both', expand=True, padx=10, pady=10)
self.system_info = scrolledtext.ScrolledText(info_frame, height=8, bg='#ffffff', fg='#000000')
self.system_info.pack(fill='both', expand=True, padx=10, pady=10)
self.update_system_info()
def research_topics(self):
"""Research topics and display results"""
topics_text = self.topics_entry.get().strip()
if not topics_text:
messagebox.showwarning("Varoitus", "Syötä tutkimusaiheet")
return
topics = [topic.strip() for topic in topics_text.split(',')]
def research_thread():
try:
self.root.after(0, lambda: self.research_display.delete('1.0', tk.END))
self.root.after(0, lambda: self.research_display.insert(tk.END, "🔍 Tutkitaan aiheita...\n\n"))
research_data = self.agent.research_content(topics)
display_text = f"📊 Löydetty {len(research_data)} lähdettä:\n\n"
for i, item in enumerate(research_data, 1):
display_text += f"{i}. {item['title']}\n"
display_text += f" Lähde: {item.get('source', 'unknown')}\n"
if 'url' in item:
display_text += f" URL: {item['url'][:80]}...\n"
display_text += "\n"
self.root.after(0, lambda: self.research_display.delete('1.0', tk.END))
self.root.after(0, lambda: self.research_display.insert(tk.END, display_text))
# Store research data for content generation
self.current_research_data = research_data
except Exception as e:
self.root.after(0, lambda: messagebox.showerror("Virhe", f"Tutkimus epäonnistui: {str(e)}"))
threading.Thread(target=research_thread, daemon=True).start()
def generate_content(self):
"""Generate content based on research"""
if not hasattr(self, 'current_research_data') or not self.current_research_data:
messagebox.showwarning("Varoitus", "Tutki aiheita ensin")
return
def generate_thread():
try:
self.root.after(0, lambda: self.content_display.delete('1.0', tk.END))
self.root.after(0, lambda: self.content_display.insert(tk.END, "✍️ Luodaan sisältöä...\n"))
post_data = self.agent.create_post_content(self.current_research_data)
# Update UI
self.root.after(0, lambda: self.content_display.delete('1.0', tk.END))
self.root.after(0, lambda: self.content_display.insert(tk.END, post_data['content']))
self.root.after(0, lambda: self.hashtags_entry.delete(0, tk.END))
self.root.after(0, lambda: self.hashtags_entry.insert(0, ' '.join(post_data['hashtags'])))
# Generate title if empty
if not self.post_title_entry.get().strip():
title = f"LinkedIn-postaus {datetime.now().strftime('%d.%m.%Y')}"
self.root.after(0, lambda: self.post_title_entry.insert(0, title))
except Exception as e:
self.root.after(0, lambda: messagebox.showerror("Virhe", f"Sisällön generointi epäonnistui: {str(e)}"))
threading.Thread(target=generate_thread, daemon=True).start()
def schedule_post(self):
"""Schedule post for later publishing"""
title = self.post_title_entry.get().strip()
content = self.content_display.get('1.0', tk.END).strip()
hashtags = self.hashtags_entry.get().strip()
if not title or not content:
messagebox.showwarning("Varoitus", "Syötä otsikko ja sisältö")
return
# Ask for schedule time
schedule_dialog = ScheduleDialog(self.root)
if schedule_dialog.result:
scheduled_time = schedule_dialog.result
# Create post
post = LinkedInPost(
str(uuid.uuid4()),
title,
content,
scheduled_time,
hashtags.split() if hashtags else [],
[item.get('url', '') for item in getattr(self, 'current_research_data', [])]
)
post.status = LinkedInPostStatus.SCHEDULED
# Add to scheduler
post_id = self.agent.scheduler.add_post(post)
messagebox.showinfo("Onnistui", f"Postaus ajastettu! ID: {post_id}")
self.clear_content_form()
self.refresh_posts_list()
def publish_now(self):
"""Publish post immediately"""
title = self.post_title_entry.get().strip()
content = self.content_display.get('1.0', tk.END).strip()
hashtags = self.hashtags_entry.get().strip()
if not title or not content:
messagebox.showwarning("Varoitus", "Syötä otsikko ja sisältö")
return
# Create post
post = LinkedInPost(
str(uuid.uuid4()),
title,
content,
datetime.now(),
hashtags.split() if hashtags else [],
[item.get('url', '') for item in getattr(self, 'current_research_data', [])]
)
def publish_thread():
try:
success, message = self.agent.publish_now(post)
if success:
self.root.after(0, lambda: messagebox.showinfo("Onnistui", message))
self.root.after(0, self.clear_content_form)
self.root.after(0, self.refresh_posts_list)
self.root.after(0, self.update_analytics)
else:
self.root.after(0, lambda: messagebox.showerror("Virhe", message))
except Exception as e:
self.root.after(0, lambda: messagebox.showerror("Virhe", f"Julkaisu epäonnistui: {str(e)}"))
threading.Thread(target=publish_thread, daemon=True).start()
def save_draft(self):
"""Save post as draft"""
title = self.post_title_entry.get().strip()
content = self.content_display.get('1.0', tk.END).strip()
hashtags = self.hashtags_entry.get().strip()
if not title or not content:
messagebox.showwarning("Varoitus", "Syötä otsikko ja sisältö")
return
# Create draft post
post = LinkedInPost(
str(uuid.uuid4()),
title,
content,
None, # No scheduled time
hashtags.split() if hashtags else [],
[item.get('url', '') for item in getattr(self, 'current_research_data', [])]
)
post.status = LinkedInPostStatus.DRAFT
# Add to scheduler
post_id = self.agent.scheduler.add_post(post)
messagebox.showinfo("Onnistui", f"Luonnos tallennettu! ID: {post_id}")
self.clear_content_form()
self.refresh_posts_list()
def create_scheduled_post(self):
"""Create scheduled post with automatic content generation"""
title = self.sched_title_entry.get().strip()
topics_text = self.sched_topics_entry.get().strip()
if not title or not topics_text:
messagebox.showwarning("Varoitus", "Syötä postauksen nimi ja aiheet")
return
# Parse datetime
try:
if CALENDAR_AVAILABLE:
date_str = self.sched_date_entry.get()
else:
date_str = self.sched_date_entry.get()
time_str = self.sched_time_entry.get()
datetime_str = f"{date_str} {time_str}"
try:
scheduled_time = datetime.strptime(datetime_str, '%Y-%m-%d %H:%M')
except ValueError:
try:
scheduled_time = datetime.strptime(datetime_str, '%d.%m.%Y %H:%M')
except ValueError:
messagebox.showerror("Virhe", "Virheellinen päivämäärä/aika-muoto")
return
except Exception as e:
messagebox.showerror("Virhe", f"Päivämäärän käsittely epäonnistui: {str(e)}")
return
topics = [topic.strip() for topic in topics_text.split(',')]
def create_thread():
try:
post, message = self.agent.create_scheduled_post(title, scheduled_time, topics)
if post:
# Handle recurring posts
if self.recurring_var.get() and self.interval_combo.get():
post.recurring = True
post.interval = self.interval_combo.get()
self.agent.scheduler.save_posts()
self.root.after(0, lambda: messagebox.showinfo("Onnistui", message))
self.root.after(0, self.clear_scheduler_form)
self.root.after(0, self.refresh_posts_list)
else:
self.root.after(0, lambda: messagebox.showerror("Virhe", message))
except Exception as e:
self.root.after(0, lambda: messagebox.showerror("Virhe", f"Postauksen luonti epäonnistui: {str(e)}"))
threading.Thread(target=create_thread, daemon=True).start()
def preview_post(self):
"""Preview selected post"""
selection = self.posts_tree.selection()
if not selection:
messagebox.showwarning("Varoitus", "Valitse postaus esikatselua varten")
return
item = selection[0]
post_title = self.posts_tree.item(item, 'text')
# Find post by title
post = None
for p in self.agent.scheduler.get_all_posts():
if p.title == post_title:
post = p
break
if post:
PreviewDialog(self.root, post)
else:
messagebox.showerror("Virhe", "Postauksen tietoja ei löytynyt")
def cancel_post(self):
"""Cancel selected post"""
selection = self.posts_tree.selection()
if not selection:
messagebox.showwarning("Varoitus", "Valitse peruutettava postaus")
return
item = selection[0]
post_title = self.posts_tree.item(item, 'text')
# Find and cancel post
for post in self.agent.scheduler.get_all_posts():
if post.title == post_title and post.status == LinkedInPostStatus.SCHEDULED:
if self.agent.scheduler.cancel_post(post.id):
messagebox.showinfo("Onnistui", f"Postaus '{post_title}' peruutettu")
self.refresh_posts_list()
return
messagebox.showwarning("Varoitus", "Postauksen peruutus epäonnistui")
def publish_selected(self):
"""Publish selected post now"""
selection = self.posts_tree.selection()
if not selection:
messagebox.showwarning("Varoitus", "Valitse julkaistava postaus")
return
item = selection[0]
post_title = self.posts_tree.item(item, 'text')
# Find post
post = None
for p in self.agent.scheduler.get_all_posts():
if p.title == post_title:
post = p
break
if not post:
messagebox.showerror("Virhe", "Postauksen tietoja ei löytynyt")
return
if post.status not in [LinkedInPostStatus.SCHEDULED, LinkedInPostStatus.DRAFT]:
messagebox.showwarning("Varoitus", "Vain ajastettuja tai luonnos-postauksia voidaan julkaista")
return
def publish_thread():
try:
success, message = self.agent.publish_now(post)
if success:
self.root.after(0, lambda: messagebox.showinfo("Onnistui", message))
self.root.after(0, self.refresh_posts_list)
self.root.after(0, self.update_analytics)
else:
self.root.after(0, lambda: messagebox.showerror("Virhe", message))
except Exception as e:
self.root.after(0, lambda: messagebox.showerror("Virhe", f"Julkaisu epäonnistui: {str(e)}"))
threading.Thread(target=publish_thread, daemon=True).start()
def refresh_posts_list(self):
"""Refresh the posts list"""
try:
# Clear current items
for item in self.posts_tree.get_children():
self.posts_tree.delete(item)
# Add posts
posts = self.agent.scheduler.get_all_posts()
for post in sorted(posts, key=lambda p: p.created_at, reverse=True):
scheduled_str = post.scheduled_time.strftime('%d.%m.%Y %H:%M') if post.scheduled_time else "Ei ajastettu"
created_str = post.created_at.strftime('%d.%m.%Y %H:%M')
# Extract topics from research notes or use default
topics = "N/A"
if hasattr(post, 'research_notes') and post.research_notes:
if "Tutkitut aiheet:" in post.research_notes:
topics_part = post.research_notes.split("Tutkitut aiheet:")[1].split("\n")[0]
topics = topics_part.strip()
self.posts_tree.insert(
'',
'end',
text=post.title,
values=(post.status, scheduled_str, topics, created_str)
)
except Exception as e:
print(f"Posts refresh error: {e}")
def update_posts_display(self):
"""Update posts display periodically"""
while True:
try:
time.sleep(5) # Update every 5 seconds
self.root.after(0, self.refresh_posts_list)
self.root.after(0, self.update_analytics)
except Exception as e:
print(f"Update error: {e}")
time.sleep(10)
def update_analytics(self):
"""Update analytics display"""
try:
posts = self.agent.scheduler.get_all_posts()
# Calculate stats
published_posts = [p for p in posts if p.status == LinkedInPostStatus.PUBLISHED]
scheduled_posts = [p for p in posts if p.status == LinkedInPostStatus.SCHEDULED]
self.stats_labels["published_count"].config(text=str(len(published_posts)))
self.stats_labels["scheduled_count"].config(text=str(len(scheduled_posts)))
# Mock engagement stats (in real app, fetch from LinkedIn API)
if published_posts:
avg_likes = sum(p.engagement_data.get('likes', 0) for p in published_posts) / len(published_posts)
avg_comments = sum(p.engagement_data.get('comments', 0) for p in published_posts) / len(published_posts)
total_reach = sum(p.engagement_data.get('impressions', 0) for p in published_posts)
self.stats_labels["avg_likes"].config(text=f"{avg_likes:.1f}")
self.stats_labels["avg_comments"].config(text=f"{avg_comments:.1f}")
self.stats_labels["total_reach"].config(text=str(int(total_reach)))
self.stats_labels["ctr"].config(text="2.3%") # Mock CTR
# Update performance tree
for item in self.performance_tree.get_children():
self.performance_tree.delete(item)
for post in published_posts[-10:]: # Last 10 published posts
published_str = post.published_at.strftime('%d.%m.%Y %H:%M') if post.published_at else "N/A"
self.performance_tree.insert(
'',
'end',
text=post.title,
values=(
published_str,
post.engagement_data.get('likes', 0),
post.engagement_data.get('comments', 0),
post.engagement_data.get('shares', 0),
post.engagement_data.get('impressions', 0)
)
)
except Exception as e:
print(f"Analytics update error: {e}")
def on_provider_change(self, event=None):
"""Handle AI provider change"""
provider = self.ai_provider_combo.get()
self.agent.ai_generator.current_provider = provider
self.agent.save_settings()
self.update_model_list()
def update_model_list(self):
"""Update model list based on selected provider"""
provider = self.ai_provider_combo.get()
if provider in self.agent.ai_generator.providers:
models = self.agent.ai_generator.providers[provider]["models"]
self.ai_model_combo['values'] = models
if models:
self.ai_model_combo.set(models[0])
self.agent.ai_generator.current_model = models[0]
self.agent.save_settings()
def save_api_key(self, provider):
"""Save API key for provider"""
if provider in self.api_key_entries:
key = self.api_key_entries[provider].get().strip()
if key:
self.agent.ai_generator.set_api_key(provider, key)
self.agent.save_settings()
messagebox.showinfo("Onnistui", f"API-avain tallennettu: {provider}")
else:
messagebox.showwarning("Varoitus", "Syötä API-avain")
def save_linkedin_settings(self):
"""Save LinkedIn settings"""
token = self.linkedin_token_entry.get().strip()
person_id = self.linkedin_person_entry.get().strip()
self.agent.settings['linkedin_access_token'] = token
self.agent.settings['linkedin_person_id'] = person_id
self.agent.publisher.set_credentials(token, person_id)
self.agent.save_settings()
messagebox.showinfo("Onnistui", "LinkedIn-asetukset tallennettu")
def save_content_settings(self):
"""Save content settings"""
hashtags_text = self.default_hashtags_entry.get().strip()
hashtags = [tag.strip() for tag in hashtags_text.split(',') if tag.strip()]
self.agent.settings['default_hashtags'] = hashtags
self.agent.settings['post_style'] = self.post_style_combo.get()
self.agent.settings['target_audience'] = self.target_audience_entry.get().strip()
self.agent.save_settings()
messagebox.showinfo("Onnistui", "Sisältöasetukset tallennettu")
def update_system_info(self):
"""Update system information"""
info_text = f"""🎯 LinkedIn AI Agent v1.0
📅 Käynnistetty: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}
📊 Järjestelmätiedot:
• Python versio: {sys.version.split()[0]}
• Käyttöjärjestelmä: {os.name}
• Työhakemisto: {os.getcwd()}
🔧 Saatavilla olevat ominaisuudet:
• YouTube-haku: {'✅' if YOUTUBE_AVAILABLE else '❌'}
• Käännöspalvelu: {'✅' if TRANSLATE_AVAILABLE else '❌'}
• Kalenteri: {'✅' if CALENDAR_AVAILABLE else '❌'}
• OpenAI: {'✅' if OPENAI_AVAILABLE else '❌'}
• Anthropic: {'✅' if ANTHROPIC_AVAILABLE else '❌'}
• Google Gemini: {'✅' if GEMINI_AVAILABLE else '❌'}
🤖 AI-asetukset:
• Nykyinen palveluntarjoaja: {self.agent.ai_generator.current_provider}
• Nykyinen malli: {self.agent.ai_generator.current_model}
• API-avaimet asetettu: {len(self.agent.ai_generator.api_keys)} kpl
💼 LinkedIn-asetukset:
• Access token: {'✅ Asetettu' if self.agent.settings.get('linkedin_access_token') else '❌ Puuttuu'}
• Person ID: {'✅ Asetettu' if self.agent.settings.get('linkedin_person_id') else '❌ Puuttuu'}
📋 Postaustilastot:
• Luonnoksia: {len(self.agent.scheduler.get_posts_by_status(LinkedInPostStatus.DRAFT))}
• Ajastettuja: {len(self.agent.scheduler.get_posts_by_status(LinkedInPostStatus.SCHEDULED))}
• Julkaistuja: {len(self.agent.scheduler.get_posts_by_status(LinkedInPostStatus.PUBLISHED))}
• Epäonnistuneita: {len(self.agent.scheduler.get_posts_by_status(LinkedInPostStatus.FAILED))}
💡 Vinkkejä:
• Aseta AI API-avaimet päästäksesi alkuun
• Tutki aiheita ennen sisällön luontia
• Käytä ajastusta säännölliseen julkaisuun
• Seuraa analytiikkaa paremman sisällön luomiseksi
⚠️ Huomio:
LinkedIn API-integraatio on demo-tilassa. Oikeassa käytössä
tarvitset LinkedIn Developer -tilin ja API-oikeudet.
"""
self.system_info.delete('1.0', tk.END)
self.system_info.insert('1.0', info_text)
def clear_content_form(self):
"""Clear content creation form"""
self.post_title_entry.delete(0, tk.END)
self.content_display.delete('1.0', tk.END)
self.hashtags_entry.delete(0, tk.END)
self.research_display.delete('1.0', tk.END)
if hasattr(self, 'current_research_data'):
delattr(self, 'current_research_data')
def clear_scheduler_form(self):
"""Clear scheduler form"""
self.sched_title_entry.delete(0, tk.END)
self.sched_topics_entry.delete(0, tk.END)
self.sched_topics_entry.insert(0, "teknologia, tekoäly")
self.sched_time_entry.delete(0, tk.END)
self.sched_time_entry.insert(0, "09:00")
self.recurring_var.set(False)
self.interval_combo.set('')
def quit_application(self):
"""Quit the application"""
if messagebox.askyesno("Lopetus", "Haluatko varmasti lopettaa LinkedIn AI Agentin?"):
self.agent.shutdown()
self.root.quit()
def run(self):
"""Run the GUI application"""
try:
self.root.protocol("WM_DELETE_WINDOW", self.quit_application)
self.root.mainloop()
except KeyboardInterrupt:
self.quit_application()
class ScheduleDialog:
"""Dialog for scheduling posts"""
def __init__(self, parent):
self.result = None
self.dialog = tk.Toplevel(parent)
self.dialog.title("📅 Ajasta julkaisu")
self.dialog.geometry("400x300")
self.dialog.configure(bg='#f3f2ef')
self.dialog.transient(parent)
self.dialog.grab_set()
# Center the dialog
self.dialog.geometry("+%d+%d" % (parent.winfo_rootx() + 50, parent.winfo_rooty() + 50))
self.setup_dialog()
def setup_dialog(self):
"""Setup dialog components"""
# Title
title_label = tk.Label(
self.dialog,
text="📅 Valitse julkaisuaika",
font=('Arial', 14, 'bold'),
bg='#f3f2ef'
)
title_label.pack(pady=20)
# Date selection
date_frame = tk.Frame(self.dialog, bg='#f3f2ef')
date_frame.pack(pady=10)
tk.Label(date_frame, text="Päivämäärä:", bg='#f3f2ef', font=('Arial', 10)).pack(anchor='w')
if CALENDAR_AVAILABLE:
self.date_entry = DateEntry(date_frame, background='darkblue', foreground='white', borderwidth=2)
else:
self.date_entry = tk.Entry(date_frame, font=('Arial', 10))
self.date_entry.insert(0, datetime.now().strftime('%Y-%m-%d'))
self.date_entry.pack(pady=5)
# Time selection
time_frame = tk.Frame(self.dialog, bg='#f3f2ef')
time_frame.pack(pady=10)
tk.Label(time_frame, text="Aika (HH:MM):", bg='#f3f2ef', font=('Arial', 10)).pack(anchor='w')
self.time_entry = tk.Entry(time_frame, font=('Arial', 10))
self.time_entry.pack(pady=5)
# Default to next hour
next_hour = (datetime.now() + timedelta(hours=1)).strftime('%H:%M')
self.time_entry.insert(0, next_hour)
# Quick selection buttons
quick_frame = tk.Frame(self.dialog, bg='#f3f2ef')
quick_frame.pack(pady=20)
tk.Label(quick_frame, text="Pikavalinta:", bg='#f3f2ef', font=('Arial', 10)).pack(anchor='w')
quick_buttons_frame = tk.Frame(quick_frame, bg='#f3f2ef')
quick_buttons_frame.pack(pady=5)
tk.Button(quick_buttons_frame, text="1h", command=lambda: self.set_quick_time(1)).pack(side='left', padx=2)
tk.Button(quick_buttons_frame, text="3h", command=lambda: self.set_quick_time(3)).pack(side='left', padx=2)
tk.Button(quick_buttons_frame, text="1 päivä", command=lambda: self.set_quick_time(24)).pack(side='left', padx=2)
tk.Button(quick_buttons_frame, text="1 viikko", command=lambda: self.set_quick_time(24*7)).pack(side='left', padx=2)
# Buttons
button_frame = tk.Frame(self.dialog, bg='#f3f2ef')
button_frame.pack(pady=20)
tk.Button(button_frame, text="✅ OK", command=self.ok_clicked, bg='#0077B5', fg='white', font=('Arial', 10, 'bold')).pack(side='left', padx=10)
tk.Button(button_frame, text="❌ Peruuta", command=self.cancel_clicked, bg='#666666', fg='white', font=('Arial', 10)).pack(side='left', padx=10)
def set_quick_time(self, hours_from_now):
"""Set quick time selection"""
target_time = datetime.now() + timedelta(hours=hours_from_now)
if CALENDAR_AVAILABLE:
self.date_entry.set_date(target_time.date())
else:
self.date_entry.delete(0, tk.END)
self.date_entry.insert(0, target_time.strftime('%Y-%m-%d'))
self.time_entry.delete(0, tk.END)
self.time_entry.insert(0, target_time.strftime('%H:%M'))
def ok_clicked(self):
"""Handle OK button click"""
try:
if CALENDAR_AVAILABLE:
date_str = self.date_entry.get()
else:
date_str = self.date_entry.get()
time_str = self.time_entry.get()
datetime_str = f"{date_str} {time_str}"
try:
self.result = datetime.strptime(datetime_str, '%Y-%m-%d %H:%M')
except ValueError:
try:
self.result = datetime.strptime(datetime_str, '%d.%m.%Y %H:%M')
except ValueError:
messagebox.showerror("Virhe", "Virheellinen päivämäärä/aika-muoto")
return
# Check that time is in the future
if self.result <= datetime.now():
messagebox.showwarning("Varoitus", "Ajastusaika on menneisyydessä")
return
self.dialog.destroy()
except Exception as e:
messagebox.showerror("Virhe", f"Ajan asetus epäonnistui: {str(e)}")
def cancel_clicked(self):
"""Handle Cancel button click"""
self.result = None
self.dialog.destroy()
class PreviewDialog:
"""Dialog for previewing posts"""
def __init__(self, parent, post):
self.dialog = tk.Toplevel(parent)
self.dialog.title(f"👀 Esikatselu: {post.title}")
self.dialog.geometry("600x500")
self.dialog.configure(bg='#f3f2ef')
self.dialog.transient(parent)
self.dialog.grab_set()
# Center dialog
self.dialog.geometry("+%d+%d" % (parent.winfo_rootx() + 50, parent.winfo_rooty() + 50))
self.setup_preview(post)
def setup_preview(self, post):
"""Setup preview dialog"""
# Header
header_frame = tk.Frame(self.dialog, bg='#0077B5', height=60)
header_frame.pack(fill='x')
header_frame.pack_propagate(False)
title_label = tk.Label(
header_frame,
text=f"📝 {post.title}",
font=('Arial', 14, 'bold'),
bg='#0077B5',
fg='white'
)
title_label.pack(expand=True)
# Content frame
content_frame = tk.Frame(self.dialog, bg='#f3f2ef')
content_frame.pack(fill='both', expand=True, padx=20, pady=20)
# Post content
tk.Label(content_frame, text="Sisältö:", font=('Arial', 12, 'bold'), bg='#f3f2ef').pack(anchor='w')
content_text = scrolledtext.ScrolledText(
content_frame,
height=12,
bg='white',
fg='black',
font=('Arial', 11),
wrap=tk.WORD,
state='disabled'
)
content_text.pack(fill='both', expand=True, pady=(5, 10))
content_text.config(state='normal')
content_text.insert('1.0', post.content)
content_text.config(state='disabled')
# Hashtags
if post.hashtags:
tk.Label(content_frame, text="Hashtagit:", font=('Arial', 10, 'bold'), bg='#f3f2ef').pack(anchor='w')
hashtags_text = ' '.join(post.hashtags)
tk.Label(content_frame, text=hashtags_text, font=('Arial', 10), bg='#f3f2ef', fg='#0077B5').pack(anchor='w', pady=(0, 10))
# Post info
info_frame = tk.Frame(content_frame, bg='#f3f2ef')
info_frame.pack(fill='x', pady=10)
info_text = f"""📊 Postauksen tiedot:
• Tila: {post.status}
• Luotu: {post.created_at.strftime('%d.%m.%Y %H:%M:%S')}"""
if post.scheduled_time:
info_text += f"\n• Ajastettu: {post.scheduled_time.strftime('%d.%m.%Y %H:%M:%S')}"
if post.published_at:
info_text += f"\n• Julkaistu: {post.published_at.strftime('%d.%m.%Y %H:%M:%S')}"
if post.source_urls:
info_text += f"\n• Lähteitä: {len(post.source_urls)} kpl"
tk.Label(info_frame, text=info_text, font=('Arial', 9), bg='#f3f2ef', justify='left').pack(anchor='w')
# Close button
tk.Button(
content_frame,
text="❌ Sulje",
command=self.dialog.destroy,
bg='#666666',
fg='white',
font=('Arial', 10, 'bold')
).pack(pady=20)
if __name__ == "__main__":
print("🎯 LinkedIn AI Agent käynnistyy...")
print("📦 Tarkistetaan riippuvuudet...")
# Check dependencies
print(f"✅ Python {sys.version.split()[0]}")
print(f"✅ YouTube-haku: {'Saatavilla' if YOUTUBE_AVAILABLE else 'Ei saatavilla'}")
print(f"✅ Käännöspalvelu: {'Saatavilla' if TRANSLATE_AVAILABLE else 'Ei saatavilla'}")
print(f"✅ Kalenteri: {'Saatavilla' if CALENDAR_AVAILABLE else 'Ei saatavilla'}")
try:
# Create and run the application
app = LinkedInAgentGUI()
print("🚀 LinkedIn AI Agent GUI käynnistetty!")
print("💡 Muista asettaa AI API-avaimet asetuksista")
app.run()
except Exception as e:
print(f"❌ Virhe käynnistyksessä: {e}")
import traceback
traceback.print_exc()
finally:
print("👋 LinkedIn AI Agent lopetettu")