Smart Article Summarizer

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.probability import FreqDist
import string
import heapq

# --- Initial Setup: Download required NLTK datasets ---
# NLTK requires downloading specific dictionaries the first time it runs
def download_nltk_data():
  try:
      nltk.data.find('tokenizers/punkt')
  except LookupError:
      print("📥 Downloading NLTK tokenizer data...")
      nltk.download('punkt', quiet=True)
      
  try:
      nltk.data.find('corpora/stopwords')
  except LookupError:
      print("📥 Downloading NLTK stopwords data...")
      nltk.download('stopwords', quiet=True)

def summarize_text(text, num_sentences=3):
  """
  Summarizes a block of text by extracting the most statistically significant sentences.
  """
  print("
⚙️ Processing text with NLTK...")

  # 1. Tokenize the text into sentences and words
  sentences = sent_tokenize(text)
  words = word_tokenize(text.lower()) # Convert to lowercase for accurate counting

  # 2. Get the list of English "stopwords" and punctuation
  stop_words = set(stopwords.words("english"))
  punctuation = set(string.punctuation)

  # 3. Clean the words (Remove stopwords and punctuation)
  cleaned_words = []
  for word in words:
      if word not in stop_words and word not in punctuation:
          cleaned_words.append(word)

  # 4. Calculate the frequency of each remaining word
  word_frequencies = FreqDist(cleaned_words)
  
  # Find the maximum frequency to normalize the scores (scale them between 0 and 1)
  maximum_frequency = max(word_frequencies.values())
  for word in word_frequencies.keys():
      word_frequencies[word] = (word_frequencies[word] / maximum_frequency)

  # 5. Score the sentences based on the words they contain
  sentence_scores = {}
  for sentence in sentences:
      sentence_words = word_tokenize(sentence.lower())
      for word in sentence_words:
          if word in word_frequencies.keys():
              # If the sentence is too long, skip it so we don't just pick the longest sentences
              if len(sentence_words) < 30: 
                  if sentence not in sentence_scores:
                      sentence_scores[sentence] = word_frequencies[word]
                  else:
                      sentence_scores[sentence] += word_frequencies[word]

  # 6. Extract the top N highest-scoring sentences
  print(f"📊 Extracting the top {num_sentences} most important sentences...")
  summary_sentences = heapq.nlargest(num_sentences, sentence_scores, key=sentence_scores.get)
  
  # Join them back into a single paragraph
  summary = " ".join(summary_sentences)
  return summary

if __name__ == "__main__":
  # Ensure NLTK data is ready
  download_nltk_data()

  # A sample long article to summarize
  SAMPLE_ARTICLE = """
  Artificial intelligence (AI) is intelligence demonstrated by machines, as opposed to the natural intelligence displayed by animals including humans. 
  Leading AI textbooks define the field as the study of "intelligent agents": any system that perceives its environment and takes actions that maximize its chance of achieving its goals. 
  Some popular accounts use the term "artificial intelligence" to describe machines that mimic "cognitive" functions that humans associate with the human mind, such as "learning" and "problem solving", however this definition is rejected by major AI researchers.
  AI applications include advanced web search engines, recommendation systems, understanding human speech, self-driving cars, automated decision-making and competing at the highest level in strategic game systems. 
  As machines become increasingly capable, tasks considered to require "intelligence" are often removed from the definition of AI, a phenomenon known as the AI effect. 
  For instance, optical character recognition is frequently excluded from things considered to be AI, having become a routine technology.
  The field was founded on the assumption that human intelligence can be so precisely described that a machine can be made to simulate it.
  """

  print("=== NLTK Article Summarizer ===")
  print("
📜 ORIGINAL TEXT LENGTH:", len(SAMPLE_ARTICLE), "characters")
  
  # Run the summarizer
  final_summary = summarize_text(SAMPLE_ARTICLE, num_sentences=3)
  
  print("-" * 50)
  print("✨ GENERATED SUMMARY:")
  print("-" * 50)
  print(final_summary)
  print("-" * 50)
  print(f"📉 NEW TEXT LENGTH: {len(final_summary)} characters")
  print("
✅ Summary successfully generated!")