Update utils/functions.py

utils/functions.py

@@ -1,3 +1,5 @@
+# utils/functions.py
+
 import phonenumbers
 from phonenumbers import geocoder, carrier, NumberParseException
 import re
@@ -6,30 +8,30 @@ import os
 from datetime import datetime
 import logging
 import json
-import whois  # Ensure 'python-whois' is installed: pip install python-whois
+import whois  # Upewnij się, że moduł 'python-whois' jest zainstalowany: pip install python-whois
 from PIL import Image
-import pytesseract  # Ensure 'pytesseract' is installed: pip install pytesseract
+import pytesseract  # Upewnij się, że moduł 'pytesseract' jest zainstalowany: pip install pytesseract
 
-# Configure logging
+# Konfiguracja logowania
 logging.basicConfig(
     filename='app.log',
     level=logging.INFO,
     format='%(asctime)s %(levelname)s:%(message)s'
 )
 
-# Define paths to JSON files
+# Definiowanie ścieżek do plików JSON
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 DATA_DIR = os.path.join(BASE_DIR, '..', 'data')
 FAKE_NUMBERS_FILE = os.path.join(DATA_DIR, 'fake_numbers.json')
 HISTORY_FILE = os.path.join(DATA_DIR, 'history.json')
 STATS_FILE = os.path.join(DATA_DIR, 'stats.json')
 
-# Ensure the 'data' directory exists
+# Upewnij się, że katalog 'data' istnieje
 os.makedirs(DATA_DIR, exist_ok=True)
 
-# Helper functions
+# Funkcje pomocnicze
 def load_json(file_path):
-    """Loads data from a JSON file. Returns an empty list or default object if the file does not exist."""
+    """Ładuje dane z pliku JSON. Jeśli plik nie istnieje, zwraca pustą listę lub domyślny obiekt."""
     if not os.path.exists(file_path):
         if file_path.endswith('stats.json'):
             return {"total_analyses": 0, "total_frauds_detected": 0}
@@ -40,46 +42,47 @@ def load_json(file_path):
             data = json.load(file)
             return data
         except json.JSONDecodeError:
-            logging.error(f"Unable to load data from {file_path}. The file is corrupted.")
+            logging.error(f"Nie można załadować danych z {file_path}. Plik jest uszkodzony.")
             if file_path.endswith('stats.json'):
                 return {"total_analyses": 0, "total_frauds_detected": 0}
             return []
 
 def save_json(file_path, data):
-    """Saves data to a JSON file."""
+    """Zapisuje dane do pliku JSON."""
     with open(file_path, 'w', encoding='utf-8') as file:
         json.dump(data, file, ensure_ascii=False, indent=4)
-        logging.info(f"Data has been saved to {file_path}.")
+        logging.info(f"Dane zostały zapisane do {file_path}.")
 
-# Fake number functions
+# Funkcje związane z fałszywymi numerami telefonów
 def add_fake_number(phone_number):
-    """Adds a phone number to fake_numbers.json as a fake if it does not exist yet."""
+    """Dodaje numer telefonu do pliku fake_numbers.json jako fałszywy, jeśli jeszcze go tam nie ma."""
     fake_numbers = load_json(FAKE_NUMBERS_FILE)
     if phone_number not in fake_numbers:
         fake_numbers.append(phone_number)
         save_json(FAKE_NUMBERS_FILE, fake_numbers)
-        logging.info(f"Number {phone_number} successfully added to fake_numbers.json.")
+        logging.info(f"Numer {phone_number} został pomyślnie dodany do fake_numbers.json.")
         return True
     else:
-        logging.info(f"Number {phone_number} already exists in fake_numbers.json.")
+        logging.info(f"Numer {phone_number} już istnieje w fake_numbers.json.")
         return False
 
 def is_fake_number(phone_number):
-    """Checks if a given phone number is marked as fake in fake_numbers.json."""
+    """Sprawdza, czy dany numer telefonu jest oznaczony jako fałszywy w pliku fake_numbers.json."""
     fake_numbers = load_json(FAKE_NUMBERS_FILE)
     exists = phone_number in fake_numbers
-    logging.info(f"Checking number {phone_number}: {'found' if exists else 'not found'}.")
+    logging.info(f"Sprawdzanie numeru {phone_number}: {'znaleziony' if exists else 'nie znaleziony'}.")
     return exists
 
 def get_fake_numbers():
-    """Retrieves a list of fake numbers from fake_numbers.json."""
+    """Pobiera listę fałszywych numerów z pliku fake_numbers.json."""
     fake_numbers = load_json(FAKE_NUMBERS_FILE)
     return fake_numbers
 
-# SMS analysis functions
+# Funkcje analizy SMS
 def simple_checks(message, language):
-    """Performs simple heuristic checks on the message."""
+    """Przeprowadza proste sprawdzenia heurystyczne wiadomości SMS."""
     warnings = []
+    # Baza słów kluczowych (polski, niemiecki, angielski)
     scam_keywords = {
         'Polish': ['pieniądze', 'przelew', 'hasło', 'kod', 'nagroda', 'wygrana', 'pilne', 'pomoc', 'opłata', 'bank', 'karta', 'konto', 'logowanie', 'transakcja', 'weryfikacja', 'dane osobowe', 'szybka płatność', 'blokada konta', 'powiadomienie'],
         'German': ['Geld', 'Überweisung', 'Passwort', 'Code', 'Preis', 'Gewinn', 'dringend', 'Hilfe', 'Gebühr', 'Bank', 'Karte', 'Konto', 'Anmeldung', 'Transaktion', 'Verifizierung', 'persönliche Daten', 'schnelle Zahlung', 'Kontosperrung', 'Benachrichtigung'],
@@ -87,24 +90,23 @@ def simple_checks(message, language):
     }
 
     selected_keywords = scam_keywords.get(language, scam_keywords['English'])
-
     message_lower = message.lower()
 
     if any(keyword.lower() in message_lower for keyword in selected_keywords):
-        warnings.append("The message contains keywords associated with potential fraud.")
+        warnings.append("Wiadomość zawiera słowa kluczowe związane z potencjalnym oszustwem.")
     if re.search(r'http[s]?://', message):
-        warnings.append("The message contains a link.")
+        warnings.append("Wiadomość zawiera link.")
     if re.search(r'\b(podaj|prześlij|udostępnij|sende|übermittle|teile|send|provide|share)\b.*\b(hasło|kod|dane osobowe|numer konta|Passwort|Code|persönliche Daten|Kontonummer|password|code|personal information|account number)\b', message_lower):
-        warnings.append("The message contains a request for sensitive information.")
+        warnings.append("Wiadomość zawiera prośbę o poufne informacje.")
     return warnings
 
 def analyze_message(content, sender_info, additional_info, api_key, language):
-    """Analyzes the SMS message content using an AI model, utilizing system prompts."""
+    """Analizuje treść wiadomości SMS za pomocą modelu AI, wykorzystując system prompts."""
     if not api_key:
-        logging.error("API key is missing.")
-        return "API key is missing.", "API key is missing.", "API key is missing."
+        logging.error("Brak klucza API.")
+        return "Brak klucza API.", "Brak klucza API.", "Brak klucza API."
 
-    url = "https://api.sambanova.ai/v1/chat/completions"  # Ensure this is the correct API URL
+    url = "https://api.sambanova.ai/v1/chat/completions"
     headers = {
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json"
@@ -112,29 +114,29 @@ def analyze_message(content, sender_info, additional_info, api_key, language):
 
     system_prompts = {
         'Polish': """
-You are an advanced AI assistant specializing in identifying fake SMS messages. Your task is to conduct a detailed analysis of the message, utilizing a deep thinking process and providing a comprehensive assessment. Your response should be divided into three sections:
+Jesteś zaawansowanym asystentem AI specjalizującym się w identyfikacji fałszywych wiadomości SMS. Twoim zadaniem jest przeprowadzenie szczegółowej analizy wiadomości, wykorzystując głęboki proces myślenia i dostarczając kompleksową ocenę. Twoja odpowiedź powinna być podzielona na trzy sekcje:
 
 <analysis>
-**Message Content Analysis:**
-- Conduct a detailed analysis of the message content, identifying potential red flags such as language errors, requests for personal information, urgent contact requests, etc.
-- Describe the linguistic and cultural context of the message.
-- Identify any elements that may suggest the message is an attempt to solicit information or money.
+**Analiza Treści Wiadomości:**
+- Przeprowadź szczegółową analizę treści wiadomości, identyfikując potencjalne czerwone flagi, takie jak błędy językowe, prośby o dane osobowe, pilne prośby o kontakt itp.
+- Opisz kontekst językowy i kulturowy wiadomości.
+- Zidentyfikuj wszelkie elementy, które mogą sugerować, że wiadomość jest próbą wyłudzenia informacji lub pieniędzy.
 </analysis>
 
 <risk_assessment>
-**Fraud Risk Assessment:**
-- Based on the content analysis and available information, assess the likelihood that the message is fraudulent. Use a scale from 1 to 10, where 1 indicates very low risk and 10 indicates very high risk.
-- Explain the factors that influence this assessment.
+**Ocena Ryzyka Oszustwa:**
+- Na podstawie analizy treści i dostępnych informacji oceń prawdopodobieństwo, że wiadomość jest oszustwem. Użyj skali od 1 do 10, gdzie 1 oznacza bardzo niskie ryzyko, a 10 bardzo wysokie ryzyko.
+- Wyjaśnij, jakie czynniki wpływają na tę ocenę.
 </risk_assessment>
 
 <recommendations>
-**User Recommendations:**
-- Provide clear and concrete recommendations regarding the next steps the user should take.
-- Include security suggestions such as blocking the sender, reporting the message to appropriate authorities, or ignoring the message.
-- If possible, suggest additional precautionary measures the user can take to protect their personal and financial information.
+**Zalecenia dla Użytkownika:**
+- Podaj jasne i konkretne zalecenia dotyczące dalszych kroków, które użytkownik powinien podjąć.
+- Uwzględnij sugestie dotyczące bezpieczeństwa, takie jak blokowanie nadawcy, zgłaszanie wiadomości do odpowiednich instytucji, czy też ignorowanie wiadomości.
+- Jeśli to możliwe, zasugeruj dodatkowe środki ostrożności, które użytkownik może podjąć, aby chronić swoje dane osobowe i finansowe.
 </recommendations>
 
-Your response should be formatted exactly as specified above, using the <analysis>, <risk_assessment>, and <recommendations> tags. Ensure that each section is thoroughly and comprehensively filled out.
+Twoja odpowiedź powinna być sformatowana dokładnie w powyższy sposób, używając znaczników <analysis>, <risk_assessment> i <recommendations>. Upewnij się, że każda sekcja jest wypełniona kompletnie i szczegółowo.
         """,
         'German': """
 Du bist ein fortgeschrittener KI-Assistent, spezialisiert auf die Identifizierung gefälschter SMS-Nachrichten. Deine Aufgabe ist es, eine detaillierte Analyse der Nachricht durchzuführen, indem du einen tiefgreifenden Denkprozess nutzt und eine umfassende Bewertung lieferst. Deine Antwort sollte in drei Abschnitte unterteilt sein:
@@ -201,7 +203,7 @@ Additional Information:
 Provide your analysis and conclusions following the guidelines above."""
 
     payload = {
-        "model": "Meta-Llama-3.1-8B-Instruct",  # Ensure this is the correct API model
+        "model": "Meta-Llama-3.1-8B-Instruct",
         "messages": [
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": user_prompt}
@@ -217,7 +219,7 @@ Provide your analysis and conclusions following the guidelines above."""
         if response.status_code == 200:
             data = response.json()
             ai_response = data['choices'][0]['message']['content']
-            # Parse the response
+            # Parsowanie odpowiedzi
             analysis = re.search(r'<analysis>(.*?)</analysis>', ai_response, re.DOTALL)
             risk_assessment = re.search(r'<risk_assessment>(.*?)</risk_assessment>', ai_response, re.DOTALL)
             recommendations = re.search(r'<recommendations>(.*?)</recommendations>', ai_response, re.DOTALL)
@@ -234,14 +236,14 @@ Provide your analysis and conclusions following the guidelines above."""
         logging.error(f"Błąd połączenia z API: {e}")
         return f"Błąd połączenia z API: {e}", "Błąd analizy.", "Błąd analizy."
 
-# Email analysis functions
+# Funkcje analizy email
 def analyze_email_message(content, sender_info, additional_info, api_key, language):
-    """Analyzes the content of the email message using an AI model, utilizing system prompts."""
+    """Analizuje treść wiadomości email za pomocą modelu AI, wykorzystując system prompts."""
     if not api_key:
-        logging.error("API key is missing.")
-        return "API key is missing.", "API key is missing.", "API key is missing."
+        logging.error("Brak klucza API.")
+        return "Brak klucza API.", "Brak klucza API.", "Brak klucza API."
 
-    url = "https://api.sambanova.ai/v1/chat/completions"  # Ensure this is the correct API URL
+    url = "https://api.sambanova.ai/v1/chat/completions"
     headers = {
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json"
@@ -341,7 +343,7 @@ Additional Information:
 Provide your analysis and conclusions following the guidelines above."""
 
     payload = {
-        "model": "Meta-Llama-3.1-8B-Instruct",  # Ensure this is the correct API model
+        "model": "Meta-Llama-3.1-8B-Instruct",
         "messages": [
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": user_prompt}
@@ -357,7 +359,7 @@ Provide your analysis and conclusions following the guidelines above."""
         if response.status_code == 200:
             data = response.json()
             ai_response = data['choices'][0]['message']['content']
-            # Parse the response
+            # Parsowanie odpowiedzi
             analysis = re.search(r'<analysis>(.*?)</analysis>', ai_response, re.DOTALL)
             risk_assessment = re.search(r'<risk_assessment>(.*?)</risk_assessment>', ai_response, re.DOTALL)
             recommendations = re.search(r'<recommendations>(.*?)</recommendations>', ai_response, re.DOTALL)
@@ -374,118 +376,42 @@ Provide your analysis and conclusions following the guidelines above."""
         logging.error(f"Błąd połączenia z API: {e}")
         return f"Błąd połączenia z API: {e}", "Błąd analizy.", "Błąd analizy."
 
-# Website analysis functions
+# Funkcja analizy stron internetowych
 def analyze_website(url, api_key, language):
-    """Analyzes the website URL for potential threats."""
+    """Analizuje zawartość strony internetowej."""
     if not api_key:
-        logging.error("API key is missing.")
-        return "API key is missing.", "API key is missing.", "API key is missing."
-
-    phishing_urls = check_urls_with_phishtank([url])
-    unsafe_urls = check_urls_with_safe_browsing([url])
-
-    # Prepare the analysis results
-    if phishing_urls:
-        analysis_result = "The following URLs are flagged as phishing:"
-        for phishing_url in phishing_urls:
-            analysis_result += f"\n- {phishing_url}"
-    else:
-        analysis_result = "No phishing threats found."
+        logging.error("Brak klucza API.")
+        return "Brak klucza API.", "Brak klucza API."
 
-    if unsafe_urls:
-        analysis_result += "\nThe following URLs are flagged as unsafe:"
-        for unsafe_url in unsafe_urls:
-            analysis_result += f"\n- {unsafe_url}"
-    else:
-        analysis_result += "\nNo unsafe threats found."
-
-    return analysis_result
-
-def check_urls_with_phishtank(urls):
-    """Checks URLs with PhishTank for phishing threats."""
-    phishing_urls = []
-    for url in urls:
-        params = {
-            'format': 'json',
-            'url': url
-        }
-        try:
-            response = requests.post('https://checkurl.phishtank.com/checkurl/', data=params)
-            if response.status_code == 200:
-                data = response.json()
-                in_database = data.get('results', {}).get('in_database', False)
-                valid = data.get('results', {}).get('valid', False)
-                if in_database and valid:
-                    phishing_urls.append(url)
-            else:
-                logging.warning(f"Error checking URL in PhishTank: {response.status_code}")
-        except Exception as e:
-            logging.error(f"Error checking URL in PhishTank: {e}")
-    return phishing_urls
-
-def check_urls_with_safe_browsing(urls):
-    """Checks URLs with Google Safe Browsing for unsafe threats."""
-    api_key = os.getenv('GOOGLE_SAFE_BROWSING_API_KEY')
-    if not api_key:
-        return None
-    unsafe_urls = []
-    headers = {'Content-Type': 'application/json'}
-    client_body = {
-        'client': {
-            'clientId': 'yourcompanyname',
-            'clientVersion': '1.0'
-        },
-        'threatInfo': {
-            'threatTypes': ["MALWARE", "SOCIAL_ENGINEERING", "UNWANTED_SOFTWARE", "POTENTIALLY_HARMFUL_APPLICATION"],
-            'platformTypes': ["ANY_PLATFORM"],
-            'threatEntryTypes': ["URL"],
-            'threatEntries': [{'url': url} for url in urls]
-        }
-    }
     try:
-        response = requests.post(
-            f'https://safebrowsing.googleapis.com/v4/threatMatches:find?key={api_key}',
-            headers=headers,
-            json=client_body
-        )
+        response = requests.get(url)
         if response.status_code == 200:
-            data = response.json()
-            matches = data.get('matches', [])
-            unsafe_urls = [match['threat']['url'] for match in matches]
+            content = response.text
+            logging.info(f"Zawartość strony {url} została pobrana pomyślnie.")
+            return content
         else:
-            logging.error(f"Error communicating with Google Safe Browsing API: {response.status_code}")
+            logging.error(f"Błąd podczas pobierania zawartości strony {url}: {response.status_code}")
+            return f"Błąd: {response.status_code}", "Błąd analizy strony.", "Błąd analizy strony."
     except Exception as e:
-        logging.error(f"Error checking URL in Google Safe Browsing: {e}")
-    return unsafe_urls
-
-# Add history and statistics functions as needed
-def add_to_history(message, phone_number, analysis, risk, recommendations):
-    """Adds an entry to the analysis history in history.json."""
-    history = load_json(HISTORY_FILE)
-    history.append({
-        "timestamp": datetime.now().isoformat(),
-        "message": message,
-        "phone_number": phone_number,
-        "analysis": analysis,
-        "risk_assessment": risk,
-        "recommendations": recommendations
-    })
-    save_json(HISTORY_FILE, history)
-    logging.info(f"Entry added to history.json for number {phone_number}.")
-
-def update_stats(fraud_detected=False):
-    """Updates analysis statistics in stats.json."""
-    stats = load_json(STATS_FILE)
-    stats["total_analyses"] += 1
-    if fraud_detected:
-        stats["total_frauds_detected"] += 1
-    save_json(STATS_FILE, stats)
-    logging.info(f"Statistics updated: Analyses {stats['total_analyses']}, Frauds {stats['total_frauds_detected']}.")
-
-def get_stats():
-    """Retrieves analysis statistics from stats.json."""
-    stats = load_json(STATS_FILE)
-    logging.info("Statistics retrieved successfully.")
-    return stats
-
-# Additional functions can be added as required
+        logging.error(f"Błąd połączenia z {url}: {e}")
+        return f"Błąd połączenia z {url}: {e}", "Błąd analizy strony.", "Błąd analizy strony."
+
+def get_phone_info(phone_number):
+    """Weryfikuje numer telefonu i zwraca informacje o kraju i operatorze."""
+    try:
+        parsed_number = phonenumbers.parse(phone_number, None)
+        country = geocoder.description_for_number(parsed_number, 'pl')
+        operator = carrier.name_for_number(parsed_number, 'pl')
+        if not country:
+            country = "Nieznany"
+        if not operator:
+            operator = "Nieznany"
+        logging.info(f"Numer {phone_number} - Kraj: {country}, Operator: {operator}.")
+        return country, operator
+    except NumberParseException as e:
+        logging.error(f"Nie udało się przetworzyć numeru telefonu {phone_number}: {e}")
+        return "Nieznany", "Nieznany"
+
+# Jeśli inne funkcje są używane, dodaj je tutaj
+# ...
+