udise_school_report_reader 0.1.0

data/lib/udise_school_report_reader/pdf_rectangle_extractor.rb

@@ -0,0 +1,53 @@
+class PDFRectangleExtractor
+  def self.extract_rectangles(reader)
+    raise ArgumentError, "PDF reader cannot be nil" if reader.nil?
+    
+    rectangles = []
+    current_color = '0 G'  # Default stroke color (black)
+    current_fill_color = '1 1 1 rg'  # Default fill color (white)
+    current_line_width = 1.0  # Default line width
+
+    reader.pages.each_with_index do |page, index|
+      page_number = index + 1
+
+      page.raw_content.each_line do |line|
+        # Track stroke color changes
+        if line.match?(/[\d.]+ [\d.]+ [\d.]+ RG/) || line.match?(/[\d.]+ G/)
+          current_color = line.strip
+        end
+
+        # Track fill color changes
+        if line.match?(/[\d.]+ [\d.]+ [\d.]+ rg/) || line.match?(/[\d.]+ g/)
+          current_fill_color = line.strip
+        end
+
+        # Track line width changes
+        if line.match?(/[\d.]+\s+w/)
+          if match = line.match(/(\d+\.?\d*)\s+w/)
+            current_line_width = match[1].to_f
+          end
+        end
+
+        # Look for rectangles (table cells)
+        if line.match?(/(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+re/)
+          matches = line.match(/(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+re/)
+          x, y, width, height = matches[1..4].map(&:to_f)
+
+          # Store the rectangle with its properties
+          rectangles << {
+            page: page_number,
+            x: x,
+            y: y,
+            width: width,
+            height: height,
+            stroke_color: current_color,
+            fill_color: current_fill_color,
+            line_width: current_line_width
+          }
+        end
+      end
+    end
+
+    rectangles
+  end
+end 

data/lib/udise_school_report_reader/rooms_data_reader.rb

@@ -0,0 +1,36 @@
+require_relative 'data_reader_base'
+
+class RoomsDataReader
+  include DataReaderBase
+
+  FIELD_MAPPINGS = {
+    'In Good Condition' => {
+      key_path: ['rooms', 'classrooms', 'good_condition'],
+      value_type: :integer,
+      end_pattern: /Needs Minor/
+    },
+    'Needs Minor Repair' => {
+      key_path: ['rooms', 'classrooms', 'needs_minor_repair'],
+      value_type: :integer,
+      end_pattern: /Needs Major/
+    },
+    'Needs Major Repair' => {
+      key_path: ['rooms', 'classrooms', 'needs_major_repair'],
+      value_type: :integer,
+      end_pattern: /Other Rooms/
+    },
+    'Other Rooms' => {
+      key_path: ['rooms', 'other'],
+      value_type: :integer,
+      end_pattern: /Library/
+    },
+    'Library Availability' => {
+      key_path: ['rooms', 'library'],
+      end_pattern: /Solar/
+    },
+    'Separate Room for HM' => {
+      key_path: ['rooms', 'hm'],
+      end_pattern: /Drinking/
+    }
+  }
+end 

data/lib/udise_school_report_reader/rte_data_reader.rb

@@ -0,0 +1,118 @@
+class RteDataReader
+  GRADES = [
+    'Pre-Pri.', 'Class I', 'Class II', 'Class III', 'Class IV', 'Class V',
+    'Class VI', 'Class VII', 'Class VIII'
+  ]
+
+  def self.read(csv_path) = new(csv_path).read
+
+  def initialize(csv_path)
+    @csv_path = csv_path
+    @rows = Hash.new { |h, k| h[k] = [] }
+    
+    # Group cells by rect_y and rect_x
+    CSV.foreach(@csv_path, headers: true) do |cell|
+      next unless cell['page'] == '1'
+
+      rect_y = cell['rect_y'].to_f
+      @rows[rect_y] << cell
+    end
+
+    # Find the title row
+    @title_row = @rows.find { |_, cells| cells.any? { |cell| cell&.dig('text')&.include?('Total no. of Students Enrolled Under Section 12 of the RTE Act In Private Unaided and Specified Category Schools') } }
+    
+    title_y = @title_row&.first
+    return unless title_y
+
+    # Get all rows below title in descending order
+    rows_after_title = @rows.select { |y, _| y < title_y.to_f }
+                           .sort_by(&:first)
+                           .reverse
+
+    # Get the next 3 rows after title
+    return unless rows_after_title.size >= 3
+    
+    @grades_row = rows_after_title[0].last
+    @bg_row = rows_after_title[1].last
+    @values_row = rows_after_title[2].last
+
+    # Sort cells within each row by x coordinate
+    [@grades_row, @bg_row].each do |row|
+      next unless row
+      row.sort_by! { |cell| cell['text_x'].to_f }
+    end
+
+    # For values row, ensure we have a value for each B/G pair
+    if @values_row && @bg_row
+      sorted_values = []
+      @bg_row.each_slice(2) do |b, g|
+        b_x = b['text_x'].to_f
+        g_x = g['text_x'].to_f
+        
+        # Find or create value for boys
+        b_val = @values_row.find { |cell| (cell['text_x'].to_f - b_x).abs < 10.0 }
+        b_val ||= { 'text' => '-', 'text_x' => b_x }
+        sorted_values << b_val
+        
+        # Find or create value for girls
+        g_val = @values_row.find { |cell| (cell['text_x'].to_f - g_x).abs < 10.0 }
+        g_val ||= { 'text' => '-', 'text_x' => g_x }
+        sorted_values << g_val
+      end
+      @values_row = sorted_values
+    end
+
+    # Normalize empty values to "-"
+    @values_row&.each { |cell| cell['text'] = '-' if cell['text'].strip.empty? }
+
+    # Ensure we have all grades
+    found_grades = @grades_row.map { |cell| cell['text'] }
+    missing_grades = GRADES - found_grades
+    if missing_grades.any?
+      # Removed puts statement
+    end
+  end
+
+  def read
+    return nil unless @grades_row && @bg_row && @values_row
+
+    # Group B,G pairs, ensuring we have complete pairs
+    bg_pairs = {}
+    @bg_row.each_slice(2) do |pair|
+      next unless pair.size == 2 && pair[0] && pair[1]  # Skip incomplete pairs
+      b, g = pair
+      x_mid = (b['text_x'].to_f + g['text_x'].to_f) / 2
+      bg_pairs[x_mid] = [b, g]
+    end
+
+    # Match numbers to pairs
+    {
+      grade_rows: @grades_row,
+      bg_pairs: bg_pairs,
+      rte_numbers: match_numbers_to_pairs(@values_row, bg_pairs),
+    }
+  end
+
+  private
+    def match_numbers_to_pairs(remaining_numbers, bg_pairs, threshold = 10.0)
+      numbers = {}
+      remaining = remaining_numbers.dup
+
+      bg_pairs.each do |x_mid, bg_pair|
+        next unless bg_pair && bg_pair.size == 2  # Skip invalid pairs
+        b_x = bg_pair[0]['text_x'].to_f
+        g_x = bg_pair[1]['text_x'].to_f
+        
+        # Find numbers closest to B and G positions
+        b_num = remaining.find { |cell| (cell['text_x'].to_f - b_x).abs < threshold }
+        remaining.delete(b_num) if b_num
+
+        g_num = remaining.find { |cell| (cell['text_x'].to_f - g_x).abs < threshold }
+        remaining.delete(g_num) if g_num
+        
+        numbers[x_mid] = [b_num, g_num]
+      end
+
+      numbers
+    end
+end 

data/lib/udise_school_report_reader/rte_html_writer.rb

@@ -0,0 +1,63 @@
+class RteHtmlWriter
+  def self.generate_html(data, html_path)
+    return unless data
+
+    grade_rows = data[:grade_rows]
+    bg_pairs = data[:bg_pairs]
+
+    categories = [
+      ['EWS', data[:ews_numbers] || {}],
+    ]
+
+    # Generate table rows for all categories
+    table_rows = categories.map do |category, numbers|
+      cells = bg_pairs.map do |x_mid, _|
+        nums = numbers[x_mid.to_s] || numbers[x_mid] || []
+        b_num = nums&.first
+        g_num = nums&.last
+        "<td>#{b_num ? b_num['text'] : ''}</td><td>#{g_num ? g_num['text'] : ''}</td>"
+      end.join
+
+      "    <tr>\n" \
+      "      <td class=\"category\">#{category}</td>\n" \
+      "      #{cells}\n" \
+      "    </tr>"
+    end.join("\n")
+
+    # Generate grade headers
+    grade_headers = grade_rows.map { |row| "<th colspan='2'>#{row['text']}</th>" }.join
+    bg_headers = grade_rows.map { |_| "<td>B</td><td>G</td>" }.join
+
+    html_content = <<~HTML
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>Enrollment Table</title>
+        <style>
+          table { border-collapse: collapse; margin-top: 20px; width: 100%; }
+          th, td { border: 1px solid black; padding: 8px; text-align: center; }
+          .header { font-weight: bold; background-color: #f0f0f0; }
+          .grade { font-weight: bold; background-color: #e0e0e0; }
+          .bg-pair { background-color: #f8f8f8; }
+          .category { font-weight: bold; text-align: left; }
+        </style>
+      </head>
+      <body>
+        <h2>Enrolment (By Social Category)</h2>
+        <table>
+          <tr class="grade">
+            <th rowspan="2">Category</th>
+            #{grade_headers}
+          </tr>
+          <tr class="bg-pair">
+            #{bg_headers}
+          </tr>
+      #{table_rows}
+        </table>
+      </body>
+      </html>
+    HTML
+
+    File.write(html_path, html_content)
+  end
+end 

data/lib/udise_school_report_reader/rte_yaml_writer.rb

@@ -0,0 +1,61 @@
+class RteYamlWriter
+  GRADE_MAPPING = {
+    'Pre-Pri.' => 'pre-pri.',
+    'Class I' => 'class_i',
+    'Class II' => 'class_ii', 
+    'Class III' => 'class_iii',
+    'Class IV' => 'class_iv',
+    'Class V' => 'class_v',
+    'Class VI' => 'class_vi',
+    'Class VII' => 'class_vii',
+    'Class VIII' => 'class_viii',
+    'Class IX' => 'class_ix',
+    'Class X' => 'class_x',
+    'Class XI' => 'class_xi',
+    'Class XII' => 'class_xii'
+  }
+
+  def self.format_yaml(data)
+    return unless data
+
+    rte_data = { 'rte' => {} }
+    
+    # Get grade names and their indices
+    grades = data[:grade_rows].map { |row| row['text'] }
+    grade_indices = {}
+    grades.each_with_index do |grade, idx|
+      grade_indices[idx] = GRADE_MAPPING[grade] || grade.downcase.gsub(/\s+/, '_')
+    end
+
+    # Initialize structure for each grade
+    grade_indices.values.each do |grade_key|
+      rte_data['rte'][grade_key] = {
+        'boys' => 0,
+        'girls' => 0
+      }
+    end
+
+    # Fill in values
+    data[:rte_numbers].each do |x_mid, pair|
+      next unless pair && pair.size == 2
+      
+      # Find corresponding grade index based on x position
+      grade_idx = grade_indices.keys.find do |idx|
+        x_start = data[:grade_rows][idx]['rect_x'].to_f
+        x_end = x_start + data[:grade_rows][idx]['rect_width'].to_f
+        x_mid >= x_start && x_mid <= x_end
+      end
+      
+      next unless grade_idx && grade_indices[grade_idx]
+      
+      grade_key = grade_indices[grade_idx]
+      boys_val = pair[0]&.dig('text')
+      girls_val = pair[1]&.dig('text')
+      
+      rte_data['rte'][grade_key]['boys'] = boys_val == '-' ? 0 : boys_val.to_i
+      rte_data['rte'][grade_key]['girls'] = girls_val == '-' ? 0 : girls_val.to_i
+    end
+
+    rte_data
+  end
+end

data/lib/udise_school_report_reader/sanitation_data_reader.rb

@@ -0,0 +1,56 @@
+require_relative 'data_reader_base'
+
+class SanitationDataReader
+  include DataReaderBase
+
+  FIELD_MAPPINGS = {
+    'Handwash Near Toilet' => {
+      key_path: ['sanitation', 'handwash', 'near_toilet'],
+      end_pattern: /Handwash Facility/
+    },
+    'Handwash Facility for Meal' => {
+      key_path: ['sanitation', 'handwash', 'for_meal'],
+      end_pattern: /Total Class/
+    },
+    'Toilets' => {
+      key_path: ['sanitation', 'toilets'],
+      is_table: true,
+      table_config: {
+        sections: [
+          {
+            trigger: /Total.*CWSN/,
+            offset: 1,
+            fields: [
+              { key: ['boys', 'total'], value_type: :integer },
+              { key: ['girls', 'total'], value_type: :integer }
+            ]
+          },
+          {
+            trigger: "Functional",
+            offset: 1,
+            fields: [
+              { key: ['boys', 'functional'], value_type: :integer },
+              { key: ['girls', 'functional'], value_type: :integer }
+            ]
+          },
+          {
+            trigger: /CWSN Friendly/,
+            offset: 1,
+            fields: [
+              { key: ['boys', 'cwsn'], value_type: :integer },
+              { key: ['girls', 'cwsn'], value_type: :integer }
+            ]
+          },
+          {
+            trigger: "Urinal",
+            offset: 1,
+            fields: [
+              { key: ['boys', 'urinals'], value_type: :integer },
+              { key: ['girls', 'urinals'], value_type: :integer }
+            ]
+          }
+        ]
+      }
+    }
+  }
+end 

data/lib/udise_school_report_reader/school_report_parser.rb

@@ -0,0 +1,295 @@
+require 'pdf-reader'
+require 'yaml'
+require 'csv'
+require 'fileutils'
+require 'tempfile'
+
+module UdiseSchoolReportReader
+  class SchoolReportParser
+    def self.extract_to_text(pdf_path, output_dir = nil, write_files = false)
+      raise ArgumentError, "PDF file not found" unless File.exist?(pdf_path)
+
+      # Extract all data first
+      extracted_data = extract_data(pdf_path)
+      
+      # Write files if requested
+      write_output_files(pdf_path, extracted_data, output_dir) if write_files
+      
+      # Return the YAML data
+      extracted_data[:yaml_data]
+    end
+
+    private
+
+    def self.extract_data(pdf_path)
+      reader = PDF::Reader.new(pdf_path)
+      
+      # Extract raw content
+      content = reader.pages.map(&:raw_content).join("\n")
+      compressed_content = PDFContentCompressor.compress(content)
+      
+      # Extract blocks and rectangles
+      blocks = PDFBlockExtractor.extract_blocks(reader)
+      rectangles = PDFRectangleExtractor.extract_rectangles(reader)
+      combined_data = BlockRectangleCombiner.combine(blocks, rectangles)
+      
+      # Extract YAML data
+      yaml_data = extract_data_points(compressed_content)
+      
+      # Create temporary file for combined data
+      temp_file = Tempfile.new(['combined', '.csv'])
+      begin
+        CSVWriter.write_combined(combined_data, temp_file.path)
+        
+        # Extract table data using the temp file
+        enrollment_data = EnrollmentDataReader.read(temp_file.path)
+        ews_data = EwsDataReader.read(temp_file.path)
+        rte_data = RteDataReader.read(temp_file.path)
+        
+        # Format table data for YAML
+        yaml_data['enrollment_data'] = EnrollmentYamlWriter.format_yaml(enrollment_data) if enrollment_data
+        yaml_data['ews_data'] = EwsYamlWriter.format_yaml(ews_data)
+        yaml_data['rte_data'] = RteYamlWriter.format_yaml(rte_data)
+        
+        {
+          content: content,
+          compressed_content: compressed_content,
+          blocks: blocks,
+          rectangles: rectangles,
+          combined_data: combined_data,
+          enrollment_data: enrollment_data,
+          ews_data: ews_data,
+          rte_data: rte_data,
+          yaml_data: yaml_data
+        }
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    def self.write_output_files(pdf_path, data, output_dir)
+      paths = OutputPaths.new(pdf_path, output_dir)
+      
+      # Write text files
+      File.write(paths.txt, data[:content])
+      File.write(paths.compressed_txt, data[:compressed_content])
+      
+      # Write CSV files
+      CSVWriter.write_blocks(data[:blocks], paths.blocks_csv)
+      CSVWriter.write_rectangles(data[:rectangles], paths.rects_csv)
+      CSVWriter.write_combined(data[:combined_data], paths.combined_csv)
+      
+      # Write HTML files
+      RteHtmlWriter.generate_html(data[:rte_data], paths.rte_html)
+      EnrollmentHtmlWriter.generate_html(data[:enrollment_data], paths.enrollment_html)
+      EwsHtmlWriter.generate_html(data[:ews_data], paths.ews_html)
+      
+      # Write YAML file
+      File.write(paths.yaml, data[:yaml_data].to_yaml)
+    end
+
+    class OutputPaths
+      EXTENSIONS = {
+        txt: '.txt',
+        compressed_txt: '_compressed.txt',
+        blocks_csv: '_blocks.csv',
+        rects_csv: '_rects.csv',
+        combined_csv: '_combined.csv',
+        rte_html: '_rte.html',
+        enrollment_html: '_enrollment.html',
+        ews_html: '_ews.html',
+        yaml: '.yml'
+      }
+
+      def initialize(pdf_path, output_dir)
+        @pdf_path = pdf_path
+        @output_dir = output_dir
+        @base_name = File.basename(pdf_path, '.pdf')
+      end
+
+      EXTENSIONS.each do |name, ext|
+        define_method(name) do
+          if @output_dir
+            File.join(@output_dir, "#{@base_name}#{ext}")
+          elsif name == :yaml
+            File.join(File.dirname(@pdf_path), "#{@base_name}#{ext}")
+          else
+            tmp_dir = File.join(File.expand_path('.'), 'tmp')
+            FileUtils.mkdir_p(tmp_dir)
+            File.join(tmp_dir, "#{@base_name}#{ext}")
+          end
+        end
+      end
+    end
+
+    def self.extract_data_points(compressed_content)
+      lines = compressed_content.split("\n").map { |line| line.strip.gsub(/\\/, '') }  # Remove escape characters
+
+      # Load template as base structure
+      data = YAML.load_file('template.yml')
+
+      # Extract data using readers
+      basic_info_data = BasicInfoDataReader.read(lines)
+      location_data = LocationDataReader.read(lines)
+      official_data = OfficialDataReader.read(lines)
+      characteristics_data = CharacteristicsReader.read(lines)
+      digital_facilities_data = DigitalFacilitiesDataReader.read(lines)
+      anganwadi_data = AnganwadiDataReader.read(lines)
+      building_data = BuildingDataReader.read(lines)
+      rooms_data = RoomsDataReader.read(lines)
+      teacher_data = TeacherDataReader.read(lines)
+      sanitation_data = SanitationDataReader.read(lines)
+      activities_data = ActivitiesDataReader.read(lines)
+
+      # Merge data from readers
+      data.merge!(basic_info_data) if basic_info_data
+      data.merge!(location_data) if location_data
+      data.merge!(official_data) if official_data
+      data.merge!(characteristics_data) if characteristics_data
+      data.merge!(digital_facilities_data) if digital_facilities_data
+      data.merge!(anganwadi_data) if anganwadi_data
+      data.merge!(building_data) if building_data
+      data.merge!(rooms_data) if rooms_data
+      data.merge!(teacher_data) if teacher_data
+      data.merge!(activities_data) if activities_data
+      data.merge!(sanitation_data) if sanitation_data
+
+      lines.each_with_index do |line, i|
+        next_line = lines[i + 1]&.strip
+
+        case line
+        # Basic Facilities
+        when "Drinking Water Available"
+          data['facilities']['basic']['water']['available'] = next_line if next_line && !next_line.match?(/Drinking Water Fun/)
+        when "Drinking Water Functional"
+          data['facilities']['basic']['water']['functional'] = next_line if next_line && !next_line.match?(/Rain/)
+        when "Rain Water Harvesting"
+          data['facilities']['basic']['water']['rain_water_harvesting'] = next_line if next_line && !next_line.match?(/Playground/)
+        when "Playground Available"
+          data['facilities']['basic']['safety']['playground'] = next_line if next_line && !next_line.match?(/Furniture/)
+        when "Electricity Availability"
+          data['facilities']['basic']['electricity']['available'] = next_line if next_line && !next_line.match?(/Solar/)
+        when "Solar Panel"
+          data['facilities']['basic']['electricity']['solar_panel'] = next_line if next_line && !next_line.match?(/Medical/)
+        when "Furniture Availability"
+          if next_line =~ /^\d+$/
+            data['infrastructure']['furniture']['count'] = next_line.to_i
+          end
+
+        # Academic
+        when /^Medium (\d)$/
+          medium_num = $1
+          if next_line && next_line =~ /^(\d+)-(.+)$/
+            code = $1
+            name = $2.strip
+            data['academic']['medium_of_instruction']["medium_#{medium_num}"] = {
+              'code' => code,
+              'name' => name
+            }
+          end
+
+        when "CCE"
+          if next_line
+            data['academic']['assessments']['cce']['implemented']['primary'] = next_line
+            data['academic']['assessments']['cce']['implemented']['upper_primary'] = lines[i + 2] if lines[i + 2]
+            data['academic']['assessments']['cce']['implemented']['secondary'] = lines[i + 3] if lines[i + 3]
+            data['academic']['assessments']['cce']['implemented']['higher_secondary'] = lines[i + 4] if lines[i + 4]
+          end
+
+        # Residential Info
+        when "Residential School"
+          if next_line && next_line =~ /^(\d+)\s*-\s*(.+)$/
+            code = $1
+            type = $2.strip
+            data['facilities']['residential']['details']['type'] = "#{code} - #{type}"
+          end
+        when "Residential Type"
+          data['facilities']['residential']['details']['category'] = next_line if next_line && !next_line.match?(/Minority/)
+        when "Minority School"
+          data['facilities']['residential']['details']['minority_school'] = next_line if next_line && !next_line.match?(/Approachable/)
+        when "Approachable By All Weather Road"
+          data['facilities']['basic']['safety']['all_weather_road'] = next_line if next_line && !next_line.match?(/Toilets/)
+
+        # Student Facilities
+        when /No\.of Students Received/
+          # Skip the header lines
+          i += 2 # Skip "Primary" and "Up.Primary" lines
+        when /Free text books/
+          if lines[i + 1] =~ /^\d+$/ && lines[i + 2] =~ /^\d+$/
+            data['students']['facilities']['incentives']['free_textbooks']['primary'] = lines[i + 1].to_i
+            data['students']['facilities']['incentives']['free_textbooks']['upper_primary'] = lines[i + 2].to_i
+          end
+        when /Transport/
+          if lines[i + 1] =~ /^\d+$/ && lines[i + 2] =~ /^\d+$/
+            data['students']['facilities']['general']['transport']['primary'] = lines[i + 1].to_i
+            data['students']['facilities']['general']['transport']['upper_primary'] = lines[i + 2].to_i
+          end
+        when /Free uniform/
+          if lines[i + 1] =~ /^\d+$/ && lines[i + 2] =~ /^\d+$/
+            data['students']['facilities']['incentives']['free_uniform']['primary'] = lines[i + 1].to_i
+            data['students']['facilities']['incentives']['free_uniform']['upper_primary'] = lines[i + 2].to_i
+          end
+
+        # Committees
+        when "SMC Exists"
+          data['committees']['smc']['details']['exists'] = next_line if next_line && !next_line.match?(/SMC & SMDC/)
+        when "SMC & SMDC Same"
+          data['committees']['smc']['details']['same_as_smdc'] = next_line if next_line && !next_line.match?(/SMDC Con/)
+        when "SMDC Constituted"
+          data['committees']['smdc']['details']['constituted'] = next_line if next_line && !next_line.match?(/Text Books/)
+
+        # Grants
+        when "Grants Receipt"
+          if next_line =~ /^\d+\.?\d*$/
+            data['grants']['received']['amount'] = next_line.to_f
+          end
+        when "Grants Expenditure"
+          if next_line =~ /^\d+\.?\d*$/
+            data['grants']['expenditure']['amount'] = next_line.to_f
+          end
+
+        # Medical facilities
+        when "Medical checkups"
+          data['facilities']['medical']['checkups']['available'] = next_line if next_line
+
+        # Sports facilities
+        when "Sports Equipment"
+          data['academic']['sports']['equipment']['available'] = next_line if next_line
+        when "Physical Education Teacher"
+          data['academic']['sports']['instructors']['available'] = next_line if next_line
+
+        # Safety measures
+        when "Fire Extinguisher"
+          data['facilities']['safety']['fire']['equipment']['extinguisher'] = next_line if next_line
+        when "Emergency Exit"
+          data['facilities']['safety']['emergency']['exits']['available'] = next_line if next_line
+        when "Security Guard"
+          data['facilities']['safety']['security']['personnel']['guard'] = next_line if next_line
+
+        # Committee meetings
+        when "SMC Meetings Conducted"
+          data['committees']['smc']['details']['meetings']['count'] = next_line.to_i if next_line =~ /^\d+$/
+        when "SMDC Meetings Conducted"
+          data['committees']['smdc']['details']['meetings']['count'] = next_line.to_i if next_line =~ /^\d+$/
+
+        # Vocational courses
+        when "Vocational Courses"
+          data['academic']['vocational']['courses']['available'] = next_line if next_line
+        when "Vocational Trainer"
+          data['academic']['vocational']['trainers']['available'] = next_line if next_line
+        end
+      end
+
+      # Clean up empty sections
+      data.each do |_, section|
+        if section.is_a?(Hash)
+          section.reject! { |_, v| v.nil? || (v.is_a?(Hash) && v.empty?) }
+        end
+      end
+      data.reject! { |_, v| v.nil? || (v.is_a?(Hash) && v.empty?) }
+
+      data
+    end
+  end
+end