yuno-proofreader 0.1.0

data/lib/yuno/proofreader/analysis/links.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Yuno
+  module Proofreader
+    module Analysis
+      # Addresses as the analysis compares them: absolute, without a fragment, and keyed so that
+      # https://www.example.com/a/ and https://example.com/a count as the same page.
+      module Links
+        SKIPPED = ["#", "mailto:", "tel:", "javascript:"].freeze
+
+        module_function
+
+        def absolute(base, href)
+          text = href.to_s.strip
+          return if text.empty? || text.start_with?(*SKIPPED)
+
+          uri = URI.join(base.to_s, text)
+          return unless %w[http https].include?(uri.scheme) && !uri.host.to_s.empty?
+
+          uri.fragment = nil
+          uri.to_s
+        rescue URI::Error
+          nil
+        end
+
+        def host(url)
+          URI.parse(url.to_s).host.to_s.downcase.delete_prefix("www.")
+        rescue URI::Error
+          ""
+        end
+
+        def same_site?(url, other) = !host(url).empty? && host(url) == host(other)
+
+        # The page an address stands for: host without www., path without a trailing slash, and the query.
+        def key(url)
+          uri = URI.parse(url.to_s)
+          path = uri.path.to_s.chomp("/")
+          query = uri.query ? "?#{uri.query}" : ""
+          "#{uri.host.to_s.downcase.delete_prefix('www.')}#{path.empty? ? '/' : path}#{query}"
+        rescue URI::Error
+          url.to_s
+        end
+
+        def segments(url)
+          URI.parse(url.to_s).path.to_s.split("/").reject(&:empty?)
+        rescue URI::Error
+          []
+        end
+      end
+    end
+  end
+end

data/lib/yuno/proofreader/analysis/list_order.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Yuno
+  module Proofreader
+    module Analysis
+      # Whether the order of a list says which entries matter most.
+      module ListOrder
+        MIN_ENTRIES = 3
+
+        module_function
+
+        # mode: "editorial" (always), "neutral" (never) or "auto" (unless the list is in alphabetical order, which
+        # is how a list sorted by a machine rather than by a person usually looks).
+        def editorial?(list, mode)
+          case mode
+          when "editorial" then true
+          when "neutral" then false
+          else !alphabetical?(list)
+          end
+        end
+
+        def alphabetical?(list)
+          names = list.list_members.map { |entry| sortable(entry.name) }
+          names.size >= MIN_ENTRIES && names.none?(&:empty?) && names.each_cons(2).all? do |first, second|
+            first <= second
+          end
+        end
+
+        def sortable(name) = name.to_s.unicode_normalize(:nfd).gsub(/\p{Mn}/, "").downcase.strip
+      end
+    end
+  end
+end

data/lib/yuno/proofreader/analysis/reasons.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Yuno
+  module Proofreader
+    module Analysis
+      # Says in a few words why a page ranks where it does.
+      module Reasons
+        TEMPLATES = {
+          home: "the homepage", navigation: "in the homepage's navigation", footer: "in the homepage's footer",
+          list: "%<rank>d. of %<size>d on %<from>s", cards: "card %<rank>d of %<size>d on %<from>s",
+          text: "linked in the text of %<from>s", address: "under %<from>s"
+        }.freeze
+        ON_HOMEPAGE = %i[home navigation].freeze
+        MIN_MENTIONS = 3
+        MAX = 3
+
+        module_function
+
+        # home: the key of the homepage, so a route that starts there is not described twice.
+        def of(item, home: nil) = [reached(item.path), *standing_out(item, home)].first(MAX)
+
+        def reached(path)
+          return "not reached from the homepage" unless path
+
+          format(TEMPLATES.fetch(path.kind), rank: path.rank.to_i, size: path.size.to_i, from: shown(path.from))
+        end
+
+        def standing_out(item, home)
+          notes = []
+          notes << "shown on the homepage" if shown_on_homepage?(item, home)
+          notes << "listed or linked on #{item.mentioned_by} pages" if item.mentioned_by >= MIN_MENTIONS
+          notes << "changed #{item.changed.iso8601}" if item.changed
+          notes
+        end
+
+        # Said only when the way the page is reached does not say it already.
+        def shown_on_homepage?(item, home)
+          return false unless item.values[:presence].to_f >= 1
+
+          path = item.path
+          !(path && (ON_HOMEPAGE.include?(path.kind) || (home && path.from == home)))
+        end
+
+        # A key such as "example.com/trips" as the path a person reads: "/trips".
+        def shown(key) = key.to_s.sub(%r{\A[^/]*}, "").then { |path| path.empty? ? "/" : path }
+      end
+    end
+  end
+end

data/lib/yuno/proofreader/analysis/report.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Yuno
+  module Proofreader
+    module Analysis
+      # Turns the result of an analysis into the lines the analyze command prints.
+      class Report
+        TOP = 15
+        BOTTOM = 5
+        MISSING = 10
+        DISAGREEMENTS = 5
+
+        def initialize(result)
+          @result = result
+          @ranking = result.ranking
+        end
+
+        def lines
+          [*summary, "", *usage_lines, *model_lines, *note_lines, "", "Most important:", *rows(top), *bottom_lines,
+           *missing_lines, "", footer]
+        end
+
+        private
+
+        def scores = @ranking.scores
+
+        def summary
+          tiers = scores.map(&:tier).tally.sort.map { |tier, count| "tier #{tier}: #{count}" }.join(", ")
+          ["#{'[dry run] ' if @result.dry_run}Analysed #{scores.size} pages, after reading #{@result.pages_read} " \
+           "of them.",
+           "The structure of the site leads to #{percent(@ranking.confidence)} of the pages, and the models' " \
+           "judgement makes up #{percent(@ranking.ai_share)} of each score.",
+           "Pages per tier: #{tiers}."]
+        end
+
+        def usage_lines
+          counted = @ranking.usage.map do |use|
+            note = use.note ? "  (#{use.note})" : ""
+            "  #{use.signal}: weight #{use.weight.round}, measured on #{percent(use.coverage)} of the pages#{note}"
+          end
+          ["How each measurement counted:", *counted]
+        end
+
+        def model_lines
+          judged = @result.judged
+          return [] unless judged
+
+          calls = judged.calls.map do |call|
+            "  #{call.model}, #{call.seconds.round} s, tokens in/out/thinking " \
+              "#{call.input_tokens} / #{call.output_tokens} / #{call.thinking_tokens}"
+          end
+          ["", "The models were asked #{calls.size} time(s):", *calls, *disagreement_lines(judged),
+           *judged.problems.map { |problem| "  - #{problem}" }]
+        end
+
+        def disagreement_lines(judged)
+          return [] if judged.disagreements.empty?
+
+          shown = judged.disagreements.first(DISAGREEMENTS).map do |view|
+            "  #{Reasons.shown(view.key)}  (#{(view.spread * 100).round} points apart)"
+          end
+          ["The two models disagree most about:", *shown]
+        end
+
+        def note_lines
+          return [] if @result.notes.empty?
+
+          ["", "Notes:", *@result.notes.map { |note| "  - #{note}" }]
+        end
+
+        def top = scores.first(TOP).each_with_index.map { |score, index| [score, index + 1] }
+
+        def bottom_lines
+          count = [BOTTOM, scores.size - TOP].min
+          return [] unless count.positive?
+
+          shown = scores.last(count).each_with_index.map { |score, index| [score, scores.size - count + index + 1] }
+          ["", "Least important:", *rows(shown)]
+        end
+
+        def rows(list)
+          list.map do |score, place|
+            format("  %3<place>d. %3<score>d  T%<tier>d  %-45<path>s %<notes>s", place:, score: score.score,
+                                                                                 tier: score.tier,
+                                                                                 path: Reasons.shown(score.key),
+                                                                                 notes: score.notes.join("; "))
+          end
+        end
+
+        def missing_lines
+          missing = @result.not_in_sheet
+          return [] if missing.empty?
+
+          more = missing.size > MISSING ? ", ..." : ""
+          ["", "#{missing.size} page(s) are not in the Pages tab, so nothing was written for them " \
+               "(run pages import): #{missing.first(MISSING).join(', ')}#{more}"]
+        end
+
+        def footer
+          return "Dry run: nothing was written to the sheet." if @result.dry_run
+
+          "Written: importance, tier and notes for #{@result.written} page(s) in the Pages tab, and the " \
+            "measurements of every page in the Analysis tab."
+        end
+
+        def percent(share) = "#{(share * 100).round}%"
+      end
+    end
+  end
+end

data/lib/yuno/proofreader/analysis/runner.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yuno
+  module Proofreader
+    module Analysis
+      # Runs the whole importance analysis: reads the structure of the site, asks the models, scores every page and
+      # writes the results to the store. Everything it needs is passed in, so it runs with fakes in tests.
+      class Runner
+        # judged: what the models answered (a Judge::Result), or nil when they were not asked. not_in_sheet: the
+        # pages that have a score but no row in the Pages tab. written: how many rows of Pages were written.
+        Result = Data.define(:ranking, :judged, :pages_read, :notes, :not_in_sheet, :written, :dry_run)
+
+        # client: the model client, needed only when the models are asked.
+        def initialize(site:, store:, http:, client: nil, weights: Weights.default, clock: -> { Time.now.utc },
+                       progress: ->(_message) {}, log: Log.null)
+          @site = site
+          @store = store
+          @http = http
+          @client = client
+          @weights = weights
+          @clock = clock
+          @progress = progress
+          @log = log
+          @language = site.default_language
+        end
+
+        # judgement: :fresh (ask the models), :reuse (take their judgement from the last run, kept in the Analysis
+        # tab) or :none (the structure alone).
+        def run(judgement: :fresh, dry_run: false)
+          @notes = []
+          now = @clock.call
+          pairing = load_pairing
+          inventory, signals = measure(pairing, now)
+          views, judged = views_for(judgement, inventory, pairing)
+          records = @store.pages
+          ranking = Scorer.call(signals, @weights, views:, adjustments: adjustments(pairing, records))
+          written = dry_run ? 0 : write(ranking, signals, records, now)
+          result = Result.new(ranking:, judged:, pages_read: inventory.facts.size, notes: @notes,
+                              not_in_sheet: not_in_sheet(ranking, records), written:, dry_run:)
+          log_result(result)
+          result
+        end
+
+        private
+
+        def settings = @site.analysis
+
+        def load_pairing
+          @progress.call("Reading the sitemap...")
+          pairing = Sitemap::Loader.call(@site, @http).pairing
+          return pairing if pairing.resolved?
+
+          raise SitemapError, "The pages could not be paired by language. Run the sitemap command to see why."
+        end
+
+        def measure(pairing, now)
+          inventory = Crawler.new(site: @site, pages: pairing.pages, fetcher: Pages::Fetcher.new(@site, @http),
+                                  extra_hubs: settings.hubs, max_pages: settings.max_pages, progress: @progress).call
+          unless inventory.unread.empty?
+            @notes << "#{inventory.unread.size} index page(s) were not read, because max_pages " \
+                      "(#{settings.max_pages}) was reached."
+          end
+          signals = Signals.call(inventory:, pages: pairing.pages, weights: @weights, language: @language,
+                                 today: now.to_date, order: settings.hub_order)
+          [inventory, signals]
+        end
+
+        # ---- the models ----
+
+        def views_for(mode, inventory, pairing)
+          case mode
+          when :fresh then fresh_views(inventory, pairing)
+          when :reuse then [reused_views, nil]
+          else [{}, nil]
+          end
+        end
+
+        def fresh_views(inventory, pairing)
+          entries = Entries.call(inventory:, pages: pairing.pages, language: @language)
+          judged = Judge.new(site: @site, client: @client, weights: @weights, hint: settings.importance_hint,
+                             progress: @progress).call(entries)
+          [judged.views, judged]
+        rescue LlmError => e
+          @notes << "The models could not be asked (#{e.message}). The scores come from the structure alone."
+          [{}, nil]
+        end
+
+        def reused_views
+          views = @store.analysis_rows.to_h { |row| view_from(row) }
+          return views if views.values.any?(&:value)
+
+          raise Error, "The Analysis tab holds no judgements from the models to reuse. " \
+                       "Run analyze without --reuse-ai first."
+        end
+
+        def view_from(row)
+          key = Links.key(row[:address].to_s)
+          [key, AiView.new(key:, value: share(row[:ai_value]), kind: row[:ai_kind].to_s, place: row[:ai_place].to_s,
+                           certainty: row[:ai_certainty].to_s, reason: row[:ai_reason].to_s,
+                           spread: share(row[:ai_spread]))]
+        end
+
+        def share(value) = (value.nil? || value.to_s.strip.empty? ? nil : value.to_f / 100)
+
+        # ---- the sheet ----
+
+        def keyed(records) = records.to_h { |record| [Links.key(record.key(@language).to_s), record] }
+
+        def adjustments(pairing, records)
+          boosts = records.to_h { |record| [Links.key(record.key(@language).to_s), record.boost] }.compact
+          Adjustments.call(pages: pairing.pages, language: @language, settings:, boosts:)
+        end
+
+        def write(ranking, signals, records, now)
+          by_key = keyed(records)
+          updates = ranking.scores.each_with_object({}) do |score, found|
+            record = by_key[score.key]
+            found[record.row] = importance_of(score, now) if record
+          end
+          @store.record_importance(updates)
+          @store.replace_analysis(analysis_rows(ranking, signals, now))
+          updates.size
+        end
+
+        def importance_of(score, now)
+          { importance: score.score, tier: score.tier, importance_notes: score.notes.join("; "), analyzed_at: now }
+        end
+
+        def not_in_sheet(ranking, records)
+          known = keyed(records)
+          ranking.scores.reject { |score| known.key?(score.key) }.map { |score| Reasons.shown(score.key) }
+        end
+
+        def analysis_rows(ranking, signals, now)
+          measured = signals.to_h { |item| [item.key, item] }
+          ranking.scores.map { |score| analysis_row(score, measured[score.key], now) }
+        end
+
+        def analysis_row(score, item, now)
+          { page_name: score.page.name, address: score.page.urls[@language] || score.page.urls.values.first,
+            importance: score.score, tier: score.tier, changed: item&.changed&.iso8601.to_s,
+            route: Reasons.reached(item&.path), analyzed_at: now, **measurements(score), **judgement(score.ai) }
+        end
+
+        def measurements(score)
+          score.values.slice(:reach, :presence, :mentions, :freshness).transform_values { |value| value&.round(3) }
+        end
+
+        def judgement(view)
+          return {} unless view
+
+          { ai_value: view.value && (view.value * 100).round, ai_kind: view.kind.to_s, ai_place: view.place,
+            ai_certainty: view.certainty, ai_reason: view.reason, ai_spread: view.spread && (view.spread * 100).round }
+        end
+
+        def log_result(result)
+          @notes.each { |note| @log.warn("analysis note", message: note) }
+          ranking = result.ranking
+          @log.info("analysis finished", pages: ranking.scores.size, pages_read: result.pages_read,
+                                         written: result.written, dry_run: result.dry_run,
+                                         not_in_sheet: result.not_in_sheet.size,
+                                         structure_confidence: ranking.confidence.round(2),
+                                         ai_share: ranking.ai_share.round(2),
+                                         **Llm::Usage.of(Array(result.judged&.calls)))
+        end
+      end
+    end
+  end
+end

data/lib/yuno/proofreader/analysis/scorer.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Yuno
+  module Proofreader
+    module Analysis
+      # The importance of one page: a score from 0 to 100, its tier (1 is the most important), the reasons, and the
+      # model's view of it when there is one.
+      Score = Data.define(:key, :page, :score, :tier, :values, :notes, :ai)
+
+      # How much a signal counted: its weight in weights.yml, the share of pages it was measured on, and the weight
+      # it ended with. note says why a signal counted nothing.
+      Usage = Data.define(:signal, :weight, :coverage, :effective, :note)
+
+      # The pages from the most to the least important. confidence is the share of pages that the navigation or the
+      # lists of the site lead to, and ai_share the part of each score the model's judgement made up.
+      Ranking = Data.define(:scores, :usage, :confidence, :ai_share)
+
+      # Combines the measurements of every page, and the model's judgement when there is one, into a score and a
+      # tier. A signal counts by the share of pages it was measured on, a page without a value gets the middle value
+      # of the others, and a signal that is the same on every page counts nothing. The model's share grows as the
+      # structure of the site leads to fewer pages.
+      class Scorer
+        STRUCTURE = { home: 1.0, navigation: 1.0, footer: 1.0, list: 1.0, cards: 0.5 }.freeze
+        UNMEASURED = "could not be measured on any page"
+        NO_SPREAD = "the same on every page, so it says nothing"
+
+        # views: the model's views of the pages, keyed like the signals. Without them the score comes from the
+        # structure alone. adjustments: points a person added to pages, keyed the same way.
+        def self.call(signals, weights, views: {}, adjustments: {}) = new(signals, weights, views, adjustments).call
+
+        def initialize(signals, weights, views = {}, adjustments = {})
+          @signals = signals
+          @weights = weights
+          @ai = views
+          @adjustments = adjustments
+        end
+
+        def call
+          usage = @weights.signals.map { |signal, weight| usage_for(signal, weight) }
+          medians = usage.to_h { |use| [use.signal, median(known(use.signal))] }
+          valued = @signals.map { |item| [item, value_of(item, usage, medians)] }
+          Ranking.new(scores: ranked(valued), usage:, confidence:, ai_share:)
+        end
+
+        private
+
+        def known(signal) = @signals.filter_map { |item| item.values[signal] }
+
+        def usage_for(signal, weight)
+          values = known(signal)
+          coverage = @signals.empty? ? 0.0 : values.size.fdiv(@signals.size)
+          note = UNMEASURED if values.empty?
+          note ||= NO_SPREAD if values.any? && values.max - values.min < @weights.min_spread
+          Usage.new(signal:, weight:, coverage:, effective: note ? 0.0 : weight * coverage, note:)
+        end
+
+        def median(values)
+          sorted = values.sort
+          return 0.0 if sorted.empty?
+
+          middle = sorted.size / 2
+          sorted.size.odd? ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2.0
+        end
+
+        def home_key = @home_key ||= @signals.find { |item| item.path&.kind == :home }&.key
+
+        # The homepage leads to every other page, so it always comes first and is never adjusted.
+        def value_of(item, usage, medians)
+          return 1.0 if item.key == home_key
+
+          points = @adjustments[item.key]&.points.to_f
+          (blended(item, usage, medians) + (points / 100.0)).clamp(0.0, 1.0)
+        end
+
+        def blended(item, usage, medians)
+          structural = combined(item, usage, medians)
+          return structural if ai_share.zero?
+
+          ((1 - ai_share) * structural) + (ai_share * (@ai[item.key]&.value || ai_median))
+        end
+
+        def combined(item, usage, medians)
+          total = usage.sum(&:effective)
+          return 0.0 if total.zero?
+
+          usage.sum { |use| use.effective * (item.values[use.signal] || medians[use.signal]) } / total
+        end
+
+        def ai_values = @ai_values ||= @ai.values.filter_map(&:value)
+
+        def ai_median = @ai_median ||= median(ai_values)
+
+        # ai_share_min when the structure leads to every page, growing to ai_share_max as it leads to fewer.
+        # Nothing when the model judged no page.
+        def ai_share
+          @ai_share ||= begin
+            low = @weights.ai_share_min
+            ai_values.empty? ? 0.0 : low + ((1 - confidence) * (@weights.ai_share_max - low))
+          end
+        end
+
+        # Highest value first. The values are not rounded here, so only pages that really are equal share a place
+        # and the better tier. The score shown is rounded.
+        def ranked(valued)
+          order = valued.each_with_index.sort_by { |(_item, value), index| [-value, index] }.map(&:first)
+          first_place = {}
+          order.each_with_index.map do |(item, value), index|
+            first_place[value] ||= index
+            score_for(item, value, tier_at(first_place[value], order.size))
+          end
+        end
+
+        def score_for(item, value, tier)
+          Score.new(key: item.key, page: item.page, score: (100 * value).round, tier:, values: item.values,
+                    notes: Reasons.of(item, home: home_key) + Array(@adjustments[item.key]&.notes), ai: @ai[item.key])
+        end
+
+        def tier_at(index, count) = @weights.tiers.count { |share| index.fdiv(count) >= share } + 1
+
+        def confidence
+          return 0.0 if @signals.empty?
+
+          @confidence ||= @signals.sum { |item| STRUCTURE.fetch(item.path&.kind, 0.0) }.fdiv(@signals.size)
+        end
+      end
+    end
+  end
+end

data/lib/yuno/proofreader/analysis/settings.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Yuno
+  module Proofreader
+    module Analysis
+      # The analysis part of the settings file. Everything in it is optional.
+      #   importance_hint  what the model should know about the business, such as which offers matter most
+      #   priority_paths   points added to the score of the pages at or below a path, from -50 to 50
+      #   hubs             index pages to read even if nothing else leads to them
+      #   hub_order        auto, editorial or neutral: whether the order of the lists says what matters
+      #   max_pages        how many pages the crawl reads at most
+      class Settings < Data.define(:importance_hint, :priority_paths, :hubs, :hub_order, :max_pages)
+        KEYS = %w[importance_hint priority_paths hubs hub_order max_pages].freeze
+        ORDERS = %w[auto editorial neutral].freeze
+        MAX_POINTS = 50
+        PAGES = (1..500)
+        DEFAULT_PAGES = 80
+
+        def self.default
+          new(importance_hint: "", priority_paths: {}, hubs: [], hub_order: "auto", max_pages: DEFAULT_PAGES)
+        end
+
+        def self.from_hash(value)
+          return default if value.nil?
+          raise ConfigError, "Site: analysis must be a list of key: value pairs" unless value.is_a?(Hash)
+
+          raw = value.transform_keys(&:to_s)
+          unknown = raw.keys - KEYS
+          unless unknown.empty?
+            raise ConfigError, "Site: analysis: unknown setting(s): #{unknown.join(', ')}. Allowed: #{KEYS.join(', ')}"
+          end
+
+          new(importance_hint: Context.text(raw["importance_hint"], "analysis: importance_hint", Context::MAX_TEXT),
+              priority_paths: priority_paths(raw["priority_paths"]), hubs: hubs(raw["hubs"]),
+              hub_order: hub_order(raw["hub_order"]), max_pages: max_pages(raw["max_pages"]))
+        end
+
+        def self.priority_paths(value)
+          return {} if value.nil?
+          unless value.is_a?(Hash)
+            raise ConfigError, "Site: analysis: priority_paths must list paths with points, for example /trips: 10"
+          end
+
+          value.to_h { |path, points| [path_of(path), points_for(points, path)] }
+        end
+
+        def self.points_for(value, path)
+          number = Integer(value.to_s.strip, 10, exception: false)
+          return number if number&.between?(-MAX_POINTS, MAX_POINTS)
+
+          raise ConfigError, "Site: analysis: priority_paths #{path} needs whole points from -#{MAX_POINTS} to " \
+                             "#{MAX_POINTS} (got #{value.inspect})"
+        end
+
+        def self.hubs(value)
+          items = Array(value)
+          raise ConfigError, "Site: analysis: hubs must be a list of paths, written as text" unless items.all?(String)
+
+          items.map { |item| path_of(item) }.reject { |path| path == "/" }.uniq
+        end
+
+        # A path as it appears in the address: with a leading slash and without a trailing one. "/" stays "/".
+        def self.path_of(value)
+          path = value.to_s.strip
+          path = "/#{path}" unless path.start_with?("/")
+          path.length > 1 ? path.chomp("/") : path
+        end
+
+        def self.hub_order(value)
+          return "auto" if value.nil?
+
+          order = value.to_s.strip.downcase
+          return order if ORDERS.include?(order)
+
+          raise ConfigError, "Site: analysis: hub_order must be one of #{ORDERS.join(', ')} (got #{value.inspect})"
+        end
+
+        def self.max_pages(value)
+          return DEFAULT_PAGES if value.nil?
+
+          number = Integer(value.to_s.strip, 10, exception: false)
+          return number if number && PAGES.cover?(number)
+
+          raise ConfigError, "Site: analysis: max_pages must be a whole number from 1 to #{PAGES.last}"
+        end
+        private_class_method :priority_paths, :points_for, :hubs, :path_of, :hub_order, :max_pages
+      end
+    end
+  end
+end