git-fit 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 726e06c730a1309c59072df3f52e3261f5bf0e9d3b931e7a7016a8756c3190fa
-  data.tar.gz: 314a50f4b64054fe984e022421e464f22ae0a5469c9e7d369c5ef775ccdc0f14
+  metadata.gz: a5d6722be96ccba39d45fd0484e446158b826fe858eb33223ab31c15a8020db8
+  data.tar.gz: d0947ed101afc498ef96d1826c5560b93288b36719d88cab324c52205197405c
 SHA512:
-  metadata.gz: 2e36dcd8e78e57bbec0a451f1ce8d98fe4a3ab83dbbce334c0b528f08b5a2cc3d050a3b5da1092dbbc808d3afb6fb48b4d8052030f7d3301ac557027c97072d4
-  data.tar.gz: '00767969c5771dac29763dad5a65f4d1fd0c348ea127cfa36165dc46497000eb0db93ccff83aa13f5fc2c051d35ea618163ba1046e0abbb4c7cac315aac9f386'
+  metadata.gz: aaf3ba7f83299545ec1958713baa75a4af80a4945a30d4d13480b47a09a670b137519e6cb275f2a423407e0f849483092d3b6aec04bf4f7af52783e202e1be28
+  data.tar.gz: 6591ac01cfc11b881c9b2d9c8168564c511a3da8a32e52523da6ab8c0d050482172d85b2435e89a3ed010db09f443a27e3b1cf69a3d94b272cde10e11de51e85

data/lib/git-fit.rb

@@ -79,4 +79,5 @@ require_relative "git_fit/cli/install_cli"
 require_relative "git_fit/cli/gh_cli"
 require_relative "git_fit/cli/export"
 require_relative "git_fit/cli/import_cli"
+require_relative "git_fit/cli/geo_cli"
 require_relative "git_fit/cli"

data/lib/git_fit/cli/geo_cli.rb

@@ -0,0 +1,29 @@
+require "thor"
+
+module GitFit
+  class GeoCLI < Thor
+    desc "detect", "Detect administrative divisions for activities with GPS data"
+    option :limit,    type: :numeric, aliases: "-l", desc: "Max activities to process"
+    option :batch,    type: :numeric, aliases: "-b", desc: "Batch size", default: 20
+    option :strategy, type: :string,  aliases: "-s", desc: "Strategy: proportional|start_end", default: "proportional"
+    option :time,     type: :numeric, aliases: "-t", desc: "Time budget in seconds"
+    option :"dry-run", type: :boolean, desc: "Don't write to DB"
+    def detect
+      config = GitFit::Config.new
+      db = GitFit::DB::Connection.new(config.db_path).db
+      amap_key = ENV["AMAP_API_KEY"] || config.sync_config("amap")["api_key"]
+      detector = GitFit::Geo::DivisionDetector.new(
+        db: db,
+        amap_key: amap_key,
+        batch: options[:batch],
+        limit: options[:limit],
+        strategy: options[:strategy],
+        time_budget: options[:time],
+        dry_run: options[:"dry-run"],
+      )
+      detector.run
+    rescue => e
+      say_status :error, "Geo detection failed: #{e.message}", :red
+    end
+  end
+end

data/lib/git_fit/cli.rb

@@ -72,6 +72,9 @@ module GitFit
     desc "gh SUBCOMMAND", "Manage GitHub secrets and variables"
     subcommand "gh", GhCLI
 
+    desc "geo SUBCOMMAND", "Detect geographical administrative regions"
+    subcommand "geo", GeoCLI
+
     desc "install SUBCOMMAND", "Install project assets (actions)"
     subcommand "install", InstallCLI
 

data/lib/git_fit/geo/amap_client.rb

@@ -0,0 +1,55 @@
+require "net/http"
+require "json"
+require "uri"
+
+module GitFit
+  module Geo
+    class AMapClient
+      BASE_URL = "https://restapi.amap.com/v3/geocode/regeo".freeze
+
+      def initialize(api_key:)
+        @api_key = api_key
+        @mutex = Mutex.new
+        @last_request = 0.0
+        @min_interval = 0.2
+      end
+
+      def reverse_geocode(lat, lng)
+        rate_limit
+        uri = URI(BASE_URL)
+        uri.query = URI.encode_www_form(
+          key: @api_key,
+          location: "#{lng},#{lat}",
+          output: "JSON",
+          radius: 1000,
+          extensions: "all",
+        )
+        resp = Net::HTTP.get_response(uri)
+        body = JSON.parse(resp.body)
+        if body["status"] != "1"
+          raise "AMap API error: #{body["info"]}"
+        end
+        parse_response(body)
+      end
+
+      private
+
+      def parse_response(body)
+        comp = body.dig("regeocode", "addressComponent") || {}
+        province = comp["province"].to_s.empty? ? nil : comp["province"]
+        city = comp["city"].to_s.empty? || comp["city"] == comp["province"] ? nil : comp["city"]
+        district = comp["district"].to_s.empty? ? nil : comp["district"]
+        township = comp["township"].to_s.empty? ? nil : comp["township"]
+        { province: province, city: city, district: district, township: township, source: "amap" }
+      end
+
+      def rate_limit
+        @mutex.synchronize do
+          elapsed = Time.now.to_f - @last_request
+          sleep(@min_interval - elapsed) if elapsed < @min_interval
+          @last_request = Time.now.to_f
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/geo/division_detector.rb

@@ -0,0 +1,245 @@
+require "json"
+require "fileutils"
+require_relative "reverse_geocode"
+
+module GitFit
+  module Geo
+    class DivisionDetector
+      KEEP_PLACEHOLDER = "gqqrFurkeU??".freeze
+      SAMPLE_INTERVAL_DEG = 0.01
+      CACHE_DIR = "data/cache"
+      POINT_CACHE_FILE = File.join(CACHE_DIR, "geo-point.jsonl")
+
+      def initialize(db:, amap_key: nil, batch: 20, limit: nil, strategy: "proportional", time_budget: nil, dry_run: false)
+        @db = db
+        @geocoder = ReverseGeocode.new(amap_key: amap_key)
+        @amap_key = amap_key
+        @batch = batch
+        @limit = limit
+        @strategy = strategy
+        @time_budget = time_budget
+        @start_time = Time.now
+        @dry_run = dry_run
+        @processed = 0
+        @skipped = 0
+        @errors = 0
+        @attempted = 0
+        @total = 0
+        FileUtils.mkdir_p(CACHE_DIR)
+        load_caches
+      end
+
+      def run
+        $stdout.sync = true
+        activities = pending_activities
+        @total = activities.size
+
+        if @total > 0 && @amap_key.nil?
+          $stdout.puts "ERROR: AMAP_API_KEY not configured."
+          $stdout.puts "Set via: ENV[\"AMAP_API_KEY\"] or config.yml sync.amap.api_key"
+          $stdout.puts "Run again after configuring the key to process #{@total} pending activities."
+          return
+        end
+
+        $stdout.puts "Geo detection: #{@total} activities to process"
+        activities.each_slice(@batch) do |batch|
+          break if budget_exhausted?
+          process_batch(batch)
+          break if @limit && @processed >= @limit
+        end
+        print_summary
+      end
+
+      private
+
+      def pending_activities
+        dataset = @db[:activities]
+          .where(Sequel.lit("summary_polyline IS NOT NULL"))
+          .where(Sequel.lit("summary_polyline != ''"))
+          .where(Sequel.lit("divisions IS NULL"))
+          .order(Sequel.desc(:start_date))
+        dataset = dataset.limit(@limit) if @limit
+        dataset.all
+      end
+
+      def process_batch(batch)
+        @db.transaction do
+          batch.each do |activity|
+            break if budget_exhausted? || (@limit && @processed >= @limit)
+            process_one(activity)
+          end
+        end
+      end
+
+      def process_one(activity)
+        run_id = activity[:run_id]
+        polyline = activity[:summary_polyline]
+
+        if polyline.nil? || polyline.empty? || polyline == KEEP_PLACEHOLDER
+          mark_empty_divisions(run_id) unless @dry_run
+          @skipped += 1
+          return
+        end
+
+        points = decode_points(polyline)
+        unless points && points.size >= 2
+          mark_empty_divisions(run_id) unless @dry_run
+          @skipped += 1
+          return
+        end
+
+        samples = sample_points(points)
+        if samples.empty?
+          mark_empty_divisions(run_id) unless @dry_run
+          @skipped += 1
+          return
+        end
+
+        @attempted += 1
+        prefix = "[#{@attempted}/#{@total}]"
+
+        divisions = resolve_divisions(samples)
+        if divisions.empty?
+          $stdout.puts "  #{prefix} #{run_id} → skipped (no divisions resolved)"
+          @skipped += 1
+          return
+        end
+
+        summary = build_summary(divisions, samples.size)
+        update_db(run_id, summary) unless @dry_run
+        $stdout.puts "  #{prefix} #{run_id} → #{format_divisions(divisions)} (#{samples.size} samples)"
+        @processed += 1
+      rescue => e
+        $stdout.puts "  #{prefix} #{run_id} → error: #{e.message}"
+        @errors += 1
+      end
+
+      def format_divisions(divisions)
+        divisions.map { |d| [d[:province], d[:city], d[:district], d[:township]].compact.reject(&:empty?).join(" ") }.join(" / ")
+      end
+
+      def decode_points(polyline)
+        GitFit::Geo::Polyline.decode(polyline)
+      end
+
+      def sample_points(points)
+        samples = []
+        last_lat = nil
+        last_lng = nil
+        points.each do |lat, lng|
+          if last_lat.nil? ||
+             (lat - last_lat).abs >= SAMPLE_INTERVAL_DEG ||
+             (lng - last_lng).abs >= SAMPLE_INTERVAL_DEG
+            samples << [lat.round(4), lng.round(4)]
+            last_lat = lat
+            last_lng = lng
+          end
+        end
+        samples
+      end
+
+      def resolve_divisions(samples)
+        key_counts = Hash.new(0)
+        samples.each do |lat, lng|
+          coord_key = "#{lat},#{lng}"
+          raw = lookup_point_cache(coord_key)
+          unless raw
+            raw = @geocoder.lookup(lat, lng)
+            save_point_cache(coord_key, raw) if raw[:province]
+          end
+          result = normalize_entry(raw)
+          next unless result
+          key = division_key(result)
+          key_counts[key] += 1
+        end
+        key_counts.map do |key, count|
+          province, city, district, township = key.split("|")
+          { province: province, city: city, district: district, township: township, count: count }
+        end.sort_by { |r| -r[:count] }
+      end
+
+      def normalize_entry(raw)
+        return nil unless raw
+        province = raw[:province] || raw["p"] || raw["province"]
+        province = nil if province.is_a?(Array) || province.to_s.empty? || province == "中华人民共和国"
+        return nil unless province
+        {
+          province: province,
+          city: pick_field(raw, :city, "city", "c", "city") { |v| valid_name?(v) },
+          district: pick_field(raw, :district, "dist", "d"),
+          township: pick_field(raw, :township, "town", "t"),
+        }
+      end
+
+      def pick_field(raw, *keys)
+        keys.each do |k|
+          v = raw[k] || raw[k.to_s]
+          return v if block_given? ? yield(v) : v.is_a?(String) && !v.empty?
+        end
+        nil
+      end
+
+      def valid_name?(v)
+        v.is_a?(String) && !v.empty? && !v.match?(/^-?\d+\.\d+,-?\d+\.\d+$/)
+      end
+
+      def division_key(result)
+        [result[:province], result[:city], result[:district], result[:township]].join("|")
+      end
+
+      def build_summary(divisions, total_points)
+        total = total_points.to_f
+        division_list = divisions.map do |r|
+          h = { p: r[:province] }
+          h[:c] = r[:city] if r[:city]
+          h[:d] = r[:district] if r[:district]
+          h[:t] = r[:township] if r[:township]
+          h[:w] = (r[:count] / total).round(4)
+          h[:n] = r[:count]
+          h
+        end
+        { divisions: division_list, total_sampled: total_points, source: "amap", processed_at: Time.now.utc.iso8601 }
+      end
+
+      def lookup_point_cache(coord_key)
+        return nil unless File.exist?(POINT_CACHE_FILE)
+        File.open(POINT_CACHE_FILE, "r") do |f|
+          f.each_line do |line|
+            entry = JSON.parse(line) rescue next
+            return entry if entry["ck"] == coord_key
+          end
+        end
+        nil
+      end
+
+      def save_point_cache(coord_key, result)
+        entry = { ck: coord_key, p: result[:province], source: result[:source] }
+        entry[:city] = result[:city] if result[:city]
+        entry[:dist] = result[:district] if result[:district]
+        entry[:town] = result[:township] if result[:township]
+        File.open(POINT_CACHE_FILE, "a") { |f| f.puts(JSON.generate(entry)) }
+      end
+
+      def update_db(run_id, summary)
+        @db[:activities].where(run_id: run_id).update(divisions: JSON.generate(summary[:divisions]))
+      end
+
+      def mark_empty_divisions(run_id)
+        @db[:activities].where(run_id: run_id).update(divisions: "[]")
+      end
+
+      def load_caches
+        # Preload: nothing needed, read on-demand
+      end
+
+      def budget_exhausted?
+        return false unless @time_budget
+        Time.now - @start_time > @time_budget
+      end
+
+      def print_summary
+        $stdout.puts "Geo detection complete: #{@processed} processed, #{@skipped} skipped, #{@errors} errors"
+      end
+    end
+  end
+end

data/lib/git_fit/geo/nominatim_client.rb

@@ -0,0 +1,57 @@
+require "net/http"
+require "json"
+require "uri"
+
+module GitFit
+  module Geo
+    class NominatimClient
+      BASE_URL = "https://nominatim.openstreetmap.org/reverse".freeze
+      USER_AGENT = "git-fit/1.0 (geo-detector)"
+
+      def initialize
+        @mutex = Mutex.new
+        @last_request = 0.0
+        @min_interval = 1.0
+      end
+
+      def reverse_geocode(lat, lng)
+        rate_limit
+        uri = URI(BASE_URL)
+        uri.query = URI.encode_www_form(
+          lat: lat,
+          lon: lng,
+          format: "jsonv2",
+          addressdetails: 1,
+          zoom: 10,
+        )
+        resp = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          req = Net::HTTP::Get.new(uri)
+          req["User-Agent"] = USER_AGENT
+          http.request(req)
+        end
+        body = JSON.parse(resp.body)
+        if body["error"]
+          raise "Nominatim error: #{body["error"]}"
+        end
+        parse_response(body)
+      end
+
+      private
+
+      def parse_response(body)
+        addr = body["address"] || {}
+        country = addr["country"]
+        state = addr["state"]
+        { province: country, city: state, district: nil, township: nil, source: "nominatim" }
+      end
+
+      def rate_limit
+        @mutex.synchronize do
+          elapsed = Time.now.to_f - @last_request
+          sleep(@min_interval - elapsed) if elapsed < @min_interval
+          @last_request = Time.now.to_f
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/geo/reverse_geocode.rb

@@ -0,0 +1,48 @@
+require_relative "coord_transform"
+require_relative "amap_client"
+require_relative "nominatim_client"
+
+module GitFit
+  module Geo
+    class ReverseGeocode
+      CHINA_BBOX = {
+        min_lng: 73, max_lng: 135,
+        min_lat: 18, max_lat: 54,
+      }.freeze
+
+      def initialize(amap_key: nil)
+        @amap = amap_key ? AMapClient.new(api_key: amap_key) : nil
+        @nominatim = NominatimClient.new
+      end
+
+      def amap_available?
+        !@amap.nil?
+      end
+
+      def lookup(lat, lng)
+        in_china?(lat, lng) ? lookup_china(lat, lng) : lookup_intl(lat, lng)
+      end
+
+      private
+
+      def in_china?(lat, lng)
+        lat >= CHINA_BBOX[:min_lat] && lat <= CHINA_BBOX[:max_lat] &&
+          lng >= CHINA_BBOX[:min_lng] && lng <= CHINA_BBOX[:max_lng]
+      end
+
+      def lookup_china(lat, lng)
+        raise "AMap API key not configured" unless @amap
+        gcj_lat, gcj_lng = CoordTransform.wgs84_to_gcj02(lat, lng)
+        @amap.reverse_geocode(gcj_lat, gcj_lng)
+      rescue => e
+        { province: nil, city: nil, district: nil, township: nil, source: "error", error: e.message }
+      end
+
+      def lookup_intl(lat, lng)
+        @nominatim.reverse_geocode(lat, lng)
+      rescue => e
+        { province: nil, city: nil, district: nil, township: nil, source: "error", error: e.message }
+      end
+    end
+  end
+end

data/lib/git_fit/geo.rb

@@ -5,3 +5,7 @@ end
 
 require_relative "geo/polyline"
 require_relative "geo/coord_transform"
+require_relative "geo/amap_client"
+require_relative "geo/nominatim_client"
+require_relative "geo/reverse_geocode"
+require_relative "geo/division_detector"

data/lib/git_fit/version.rb

@@ -1,3 +1,3 @@
 module GitFit
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Lax
@@ -190,6 +190,7 @@ files:
 - lib/git-fit.rb
 - lib/git_fit/cli.rb
 - lib/git_fit/cli/export.rb
+- lib/git_fit/cli/geo_cli.rb
 - lib/git_fit/cli/gh_cli.rb
 - lib/git_fit/cli/import_cli.rb
 - lib/git_fit/cli/install_cli.rb
@@ -206,8 +207,12 @@ files:
 - lib/git_fit/fit.rb
 - lib/git_fit/fit/decoder.rb
 - lib/git_fit/geo.rb
+- lib/git_fit/geo/amap_client.rb
 - lib/git_fit/geo/coord_transform.rb
+- lib/git_fit/geo/division_detector.rb
+- lib/git_fit/geo/nominatim_client.rb
 - lib/git_fit/geo/polyline.rb
+- lib/git_fit/geo/reverse_geocode.rb
 - lib/git_fit/import.rb
 - lib/git_fit/import/apple_health.rb
 - lib/git_fit/import/local_file.rb