git-fit 0.11.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6128a0ade228a52d4521a69f4cf036c2edd0507db418bdab7a27439c7675463e
-  data.tar.gz: 889d4c1a82660bd67a5e00344e66bd05ce36071926cde030dda1a88f6272008c
+  metadata.gz: d2f295d660e818e0baf5fcd3a624aabff068288c1cc93cbb4a661b046fd58a3c
+  data.tar.gz: ee63230c3e1ae93aa7ef1bec736b5011ccbfcf013b35e70c39afcc38acbe2c06
 SHA512:
-  metadata.gz: ca1456122456538768205397ff39ac128f1cdec115dcbeacd9c37874fa62bae20011ed4b98560c68d762f1a2fb80ab8ec5e42e8a5539713ed66f73a6f7eec079
-  data.tar.gz: 0edbddf20214183b02caa9dab86d17c20ae7f87a5cdfdf450e939c45a32bd23acc5c5a30209293b53c1def43e85ed090920804123aa21e5cdce9e604e6d54777
+  metadata.gz: 6498333581ad0d68044f77c8de1ffddb1a3a4f6634a92f99081df76e5dda26fc7eb25eeb0eaf8ac0b04637db40257d43ade12c2325a6ebdec63cb95430964113
+  data.tar.gz: edda04a53ebaadd13d4bd15c325251bf4ab0f7b500917fe323c52968ca55303162f5fe95a62f4baaf2734ff8e9dc278c1786e44506b32fedcbb9cad43dbfe5c2

data/lib/git_fit/cli/import_cli.rb

@@ -184,5 +184,36 @@ module GitFit
         0
       end
     end
+
+    desc 'tbulu', 'Import 2bulu (两步路) activities from data/import/2bulu/'
+    option :activity, type: :array, desc: 'Filter by sport type', aliases: '--act'
+    option :checkpoint, type: :boolean, desc: 'Run WAL checkpoint after import'
+    def tbulu
+      config = GitFit::Config.new
+      conn = GitFit::DB::Connection.new(config.db_path)
+      conn.migrate!
+      db = conn.db
+      filter = options[:activity]&.map(&:strip)&.map(&:downcase)
+      time_budget = config.dig('sync', 'time_budget')
+
+      say_status :import, '2bulu', :green
+      adapter = GitFit::Import::Tbulu.new(
+        config: {}, db:, activity_filter: filter,
+        time_budget: time_budget
+      )
+
+      begin
+        count = adapter.call
+        if count == 0
+          say_status :warn, '2bulu: 0 activities (already imported or none found)', :yellow
+        else
+          say_status :done, "2bulu: #{count} activities", :green
+        end
+        checkpoint_db(db) if options[:checkpoint]
+      rescue StandardError => e
+        say_status :error, "2bulu: #{e.message}", :red
+        0
+      end
+    end
   end
 end

data/lib/git_fit/import/tbulu.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'time'
+require 'tzinfo'
+
+module GitFit
+  module Import
+    class Tbulu < Source::Base
+      DEFAULT_IMPORT_DIR = 'data/import/2bulu'
+
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
+        super
+        @import_dir = config['import_dir'] || DEFAULT_IMPORT_DIR
+        @timezone_resolver = GitFit::Timezone::Resolver.new(config)
+      end
+
+      def before_call
+        return false unless File.directory?(@import_dir)
+        super
+      end
+
+      def authenticate
+        true
+      end
+
+      def call
+        return 0 unless before_call
+
+        files = scan_files
+        total = 0
+        files.each do |file_path|
+          break if time_expired? && total.positive?
+          r = process_one(file_path)
+          total += 1 if r
+          report_progress(total, files.size, File.basename(file_path)) if r
+        end
+
+        total
+      end
+
+      def pending_ids
+        []
+      end
+
+      def source_label
+        '2bulu'
+      end
+
+      def raw_dir
+        File.join('data', 'raw', '2bulu')
+      end
+
+      def std_dir
+        File.join('data', 'std', '2bulu')
+      end
+
+      private
+
+      def scan_files
+        Dir.glob(File.join(@import_dir, '*'), File::FNM_CASEFOLD).select do |f|
+          File.file?(f) && GitFit::Parser::Tbulu.sniff_format(File.binread(f))
+        end
+      end
+
+      def process_one(file_path)
+        content = File.binread(file_path)
+        format = GitFit::Parser::Tbulu.sniff_format(content)
+        return nil unless format
+
+        parser = GitFit::Parser::Tbulu.new
+        activities, points = parser.call_with_points(content)
+        return nil if activities.empty?
+
+        activity = activities.first
+        return nil if skip_type?(activity[:sport_category])
+
+        run_id = build_run_id(activity, points)
+        return nil if existing_run_id?(run_id)
+
+        ext = format == :tk ? '.2tk' : '.kml'
+        write_raw(content, run_id, ext)
+        write_std(activity, run_id, points)
+
+        activity[:source] = '2bulu'
+        activity[:run_id] = run_id
+        upsert_activity(activity)
+        activity
+      end
+
+      def build_run_id(activity, points)
+        date = extract_date_prefix(activity[:start_date])
+        "2bulu_#{date}_#{content_hash(points, activity)[0, 12]}"
+      end
+
+      def content_hash(points, activity)
+        point_part = points.map do |p|
+          t = p[3].respond_to?(:to_i) ? p[3].to_i : p[3]
+          [p[0].round(9), p[1].round(9), p[2].round(3), t].join('|')
+        end.join("\n")
+        sensor_part = [
+          activity[:steps].to_i,
+          activity[:calories].to_f.round(1),
+          activity[:total_up].to_f.round(1),
+          activity[:total_down].to_f.round(1),
+        ].join('|')
+        Digest::SHA256.hexdigest("#{point_part}\n#{sensor_part}")
+      end
+
+      def upsert_activity(activity)
+        # steps/total_up/total_down are hash-only signals, not DB columns
+        persistable = activity.reject { |k, _| %i[steps total_up total_down].include?(k) }
+        super(persistable)
+      end
+
+      def extract_date_prefix(start_date)
+        t = parse_start_time(start_date)
+        return '00000000' unless t
+        t.getutc.strftime('%Y%m%d')
+      end
+
+      def parse_start_time(start_date)
+        return nil unless start_date
+        start_date.respond_to?(:getutc) ? start_date : Time.parse(start_date.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def write_raw(content, run_id, ext)
+        FileUtils.mkdir_p(raw_dir)
+        tmp = File.join(raw_dir, ".#{run_id}#{ext}.tmp")
+        final = File.join(raw_dir, "#{run_id}#{ext}")
+        File.binwrite(tmp, content)
+        File.rename(tmp, final)
+      end
+
+      def write_std(activity, run_id, points)
+        return unless points&.any?
+
+        std_data = points.map do |pt|
+          h = { latitude: pt[0], longitude: pt[1] }
+          h[:altitude] = pt[2] if pt[2]
+          h[:timestamp] = pt[3]&.iso8601 if pt[3]
+          h
+        end
+
+        natural_id = run_id.sub('2bulu_', '')
+        FileUtils.mkdir_p(std_dir)
+        tmp = File.join(std_dir, ".#{natural_id}.json.tmp")
+        final = File.join(std_dir, "#{natural_id}.json")
+        File.write(tmp, JSON.generate(std_data))
+        File.rename(tmp, final)
+
+        coords = points.map { |p| [p[0], p[1]] }
+        activity[:summary_polyline] = GitFit::Geo::Polyline.encode(coords)
+
+        first_pt = points.first
+        tz = @timezone_resolver.resolve(first_pt[0], first_pt[1])
+        return unless tz && activity[:start_date]
+        activity[:start_date_local] = utc_to_local(activity[:start_date], tz)
+      end
+
+      def existing_run_id?(run_id)
+        !@db[:activities].where(run_id: run_id).empty?
+      end
+
+      def utc_to_local(utc_iso8601, tz_name)
+        return utc_iso8601 unless utc_iso8601 && tz_name
+        t = Time.parse(utc_iso8601)
+        return utc_iso8601 unless t.utc?
+        tz = TZInfo::Timezone.get(tz_name)
+        local = tz.utc_to_local(t)
+        local.iso8601
+      rescue TZInfo::InvalidTimezoneIdentifier, ArgumentError
+        utc_iso8601
+      end
+    end
+  end
+end

data/lib/git_fit/import.rb

@@ -2,3 +2,4 @@
 
 require_relative 'import/local_file'
 require_relative 'import/apple_health'
+require_relative 'import/tbulu'

data/lib/git_fit/parser/tbulu.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module GitFit
+  module Parser
+    class Tbulu < Base
+      MAGIC = '##tk'.b
+      MOD32 = 2**32
+      HOUR8 = 8 * 3600 * 1000
+
+      SPORT_TYPE_MAP = {
+        3 => 'hike',
+        18 => 'hike',
+        24 => 'run',
+      }.freeze
+
+      def self.sniff_format(content)
+        return :tk if content.start_with?(MAGIC)
+        return :kml if content.lstrip.start_with?('<kml', '<?xml')
+
+        nil
+      end
+
+      def call(input)
+        activities, = call_with_points(input)
+        activities
+      end
+
+      def call_with_points(input)
+        content = input.is_a?(String) ? input.b : input
+        return [[], []] if content.nil? || content.empty?
+
+        format = sniff_format(content)
+        case format
+        when :tk then parse_2tk_full(content)
+        when :kml then parse_kml_full(content)
+        else
+          [[], []]
+        end
+      end
+
+      def extract_points(input)
+        _, points = call_with_points(input)
+        points
+      end
+
+      private
+
+      def sniff_format(content)
+        self.class.sniff_format(content)
+      end
+
+      # ── 2tk ──────────────────────────────────────────────────
+
+      def parse_2tk_full(content)
+        header = extract_2tk_header(content)
+        ti = header['trackinfo']
+        return [[], []] if ti.nil?
+
+        start_ms = ti['starttime']
+        return [[], []] unless start_ms
+
+        points = extract_2tk_points(content, header, start_ms)
+        return [[], points] if points.empty?
+
+        times = points.map { |p| p[3] }.compact
+        return [[], points] if times.empty?
+
+        sport = classify_sport(ti['tracktype'], header)
+        attrs = build_activity_attrs({
+          run_id: build_run_id('2bulu', SecureRandom.hex(8)),
+          name: ti['title'],
+          distance: total_distance(points),
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: sport,
+          sport_type: ti['tracktype'],
+          start_date: times.min,
+          start_date_local: times.min,
+          location_country: nil,
+          summary_polyline: nil,
+          average_heartrate: nil,
+          elevation_gain: elevation_gain(points),
+          source: '2bulu',
+        })
+        attach_sensor_stats(attrs, ti)
+        [[attrs], points]
+      end
+
+      def parse_2tk(content)
+        attrs, = parse_2tk_full(content)
+        attrs
+      end
+
+      def attach_sensor_stats(attrs, track_info)
+        attrs[:steps] = track_info['steps']
+        attrs[:calories] = track_info['calorie']
+        attrs[:total_up] = track_info['totalup']
+        attrs[:total_down] = track_info['totaldown']
+      end
+
+      def extract_2tk_header(content)
+        pos = content.index('{')
+        return {} unless pos
+
+        depth = 0
+        json_end = nil
+        (pos...content.bytesize).each do |i|
+          case content.getbyte(i)
+          when 0x7b then depth += 1
+          when 0x7d then depth -= 1
+          end
+          json_end = i if depth.zero?
+          break if depth.zero?
+        end
+        return {} unless json_end
+
+        JSON.parse(content[pos..json_end])
+      rescue JSON::ParserError
+        {}
+      end
+
+      def extract_2tk_points(content, _header, start_ms)
+        pos = content.index('{')
+        return [] unless pos
+
+        depth = 0
+        json_end = nil
+        (pos...content.bytesize).each do |i|
+          case content.getbyte(i)
+          when 0x7b then depth += 1
+          when 0x7d then depth -= 1
+          end
+          json_end = i if depth.zero?
+          break if depth.zero?
+        end
+        return [] unless json_end
+
+        bin_start = json_end + 1
+        pcount = content[bin_start + 10, 4].unpack1('L<')
+        pts_raw = content[bin_start + 14, pcount * 36]
+        return [] unless pts_raw && pts_raw.bytesize == pcount * 36
+
+        times = []
+        coords = []
+        (0...pcount).each do |i|
+          off = i * 36
+          lat, lng = pts_raw[off, 16].unpack('E2')
+          alt = pts_raw[off + 16, 4].unpack1('l<')
+          t = pts_raw[off + 24, 4].unpack1('L<')
+          q = ((start_ms - t).to_f / MOD32).round
+          times << t + q * MOD32
+          coords << [lat, lng, alt]
+        end
+
+        delta = timezone_fix(times, start_ms)
+        times.map! { |t| t + delta }
+
+        times.each_with_index.map do |t, i|
+          c = coords[i]
+          [c[0], c[1], c[2], Time.at(t / 1000.0).utc, nil]
+        end
+      end
+
+      def timezone_fix(times, start_ms)
+        return 0 if times.empty?
+        (-2..2).each do |k|
+          cand = times[0] + k * HOUR8
+          return k * HOUR8 if cand >= start_ms - 30 * 60_000 && cand <= start_ms + HOUR8
+        end
+        0
+      end
+
+      # ── KML ─────────────────────────────────────────────────
+
+      def parse_kml_full(content)
+        doc = parse_xml(content)
+        return [[], []] unless doc
+
+        ext = extract_extended_data(doc)
+        points = extract_kml_points(doc)
+        return [[], points] if points.empty?
+
+        times = points.map { |p| p[3] }.compact
+        return [[], points] if times.empty?
+        start_date = times.min
+
+        sport = classify_sport(nil, ext)
+        distance = ext['Mileage'].to_f
+        distance = ext['Distance'].to_f if distance.zero?
+
+        attrs = build_activity_attrs({
+          run_id: build_run_id('2bulu', SecureRandom.hex(8)),
+          name: doc_text(doc, '//Document/name'),
+          distance: distance,
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: sport,
+          sport_type: sport_type_name(ext['SportTypeId']),
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: nil,
+          average_heartrate: nil,
+          elevation_gain: elevation_gain(points),
+          source: '2bulu',
+        })
+        attach_kml_stats(attrs, ext)
+        [[attrs], points]
+      end
+
+      def parse_kml(content)
+        attrs, = parse_kml_full(content)
+        attrs
+      end
+
+      def attach_kml_stats(attrs, ext)
+        attrs[:steps] = ext['Step'].to_i
+        attrs[:calories] = ext['Calorie'].to_f
+        attrs[:total_up] = ext['ElevationGain'].to_f
+        attrs[:total_down] = ext['ElevationLoss'].to_f
+      end
+
+      def extract_kml_points(doc)
+        whens = doc.xpath('//when').map(&:text)
+        coords = doc.xpath('//coord').map { |c| c.text.strip.split.map(&:to_f) }
+
+        if whens.empty? || coords.empty?
+          whens = []
+          coords = []
+          doc.xpath('//coordinates').each do |cs|
+            cs.text.strip.split.each do |triplet|
+              c = triplet.split(',').map(&:to_f)
+              coords << c
+              whens << nil
+            end
+          end
+        end
+
+        whens.each_with_index.map do |w, i|
+          c = coords[i] || [0, 0, 0]
+          [c[1], c[0], c[2], w ? parse_time(w) : nil, nil]
+        end
+      end
+
+      def extract_extended_data(doc)
+        ext = {}
+        doc.xpath('//Data').each do |d|
+          name = d['name']
+          value = d.at_xpath('value')&.text
+          ext[name] = value if name && value
+        end
+        ext
+      end
+
+      def parse_xml(content)
+        require 'nokogiri'
+        doc = Nokogiri::XML(content)
+        doc.remove_namespaces!
+        doc
+      rescue Nokogiri::XML::SyntaxError
+        nil
+      end
+
+      def doc_text(doc, xpath)
+        doc.at_xpath(xpath)&.text&.strip
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str)
+      rescue ArgumentError
+        nil
+      end
+
+      # ── sport classification ────────────────────────────────
+
+      TRACKTYPE_MAP = {
+        '爬山' => 'hike',
+        '徒步' => 'hike',
+        '跑步' => 'run',
+        '骑行' => 'ride',
+      }.freeze
+
+      def classify_sport(tracktype, data)
+        sport_type_id = data['SportTypeId'] if data.is_a?(Hash)
+        mapped = SPORT_TYPE_MAP[sport_type_id.to_i] if sport_type_id
+        return mapped if mapped
+
+        track_type_id = data['TrackTypeId'] if data.is_a?(Hash)
+        return 'hike' if track_type_id.to_i == 8
+
+        TRACKTYPE_MAP[tracktype.to_s] || normalize_sport_type(tracktype.to_s)
+      end
+
+      def sport_type_name(id)
+        return nil if id.nil? || id.to_i.zero?
+        SPORT_TYPE_MAP[id.to_i]
+      end
+    end
+  end
+end

data/lib/git_fit/parser.rb

@@ -9,3 +9,4 @@ require_relative 'parser/base'
 require_relative 'parser/gpx'
 require_relative 'parser/tcx'
 require_relative 'parser/fit'
+require_relative 'parser/tbulu'

data/lib/git_fit/sync/garmin_base_di.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'garmin_base'
-require 'open3'
 
 module GitFit
   module Sync
@@ -157,44 +156,6 @@ module GitFit
         save_tokens
         true
       end
-
-      # @deprecated Kept for local script reference only.
-      # email+password SSO strategies are not called by `authenticate`
-      # because garmin.com DI auth requires MFA, handled by
-      # git fit auth garmin outside Ruby.
-      #
-      # Note: method naming (strategy_a = curl_cffi, strategy_b = Playwright) is
-      # historical. In git fit auth garmin, Playwright runs first (cookies
-      # persist 365d → no repeat MFA), curl_cffi is the fallback.
-      def strategy_a_login
-        script = File.expand_path('../../../scripts/garmin_auth.py', __dir__)
-        return nil unless File.exist?(script)
-
-        stdout, stderr, status = Open3.capture3(
-          {'SYNC__GARMIN__EMAIL' => @email, 'SYNC__GARMIN__PASSWORD' => @password, 'SYNC__GARMIN__DOMAIN' => @domain},
-          'python3', script
-        )
-        warn stderr unless stderr.empty?
-        JSON.parse(stdout) if status.success?
-      rescue StandardError => e
-        puts "Strategy A (curl_cffi) failed: #{e.message}"
-        nil
-      end
-
-      def strategy_b_login
-        script = File.expand_path('../../../scripts/garmin_auth_playwright.py', __dir__)
-        return nil unless File.exist?(script)
-
-        stdout, stderr, status = Open3.capture3(
-          {'SYNC__GARMIN__EMAIL' => @email, 'SYNC__GARMIN__PASSWORD' => @password, 'SYNC__GARMIN__DOMAIN' => @domain},
-          'python3', script
-        )
-        warn stderr unless stderr.empty?
-        JSON.parse(stdout) if status.success?
-      rescue StandardError => e
-        puts "Strategy B (Playwright) failed: #{e.message}"
-        nil
-      end
     end
   end
 end

data/lib/git_fit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GitFit
-  VERSION = '0.11.2'
+  VERSION = '0.12.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.0
 platform: ruby
 authors:
 - Lax
@@ -294,6 +294,7 @@ files:
 - lib/git_fit/import.rb
 - lib/git_fit/import/apple_health.rb
 - lib/git_fit/import/local_file.rb
+- lib/git_fit/import/tbulu.rb
 - lib/git_fit/install/actions.rb
 - lib/git_fit/install/actions/db-store/restore.yml.erb
 - lib/git_fit/install/actions/db-store/save.yml.erb
@@ -301,6 +302,7 @@ files:
 - lib/git_fit/parser/base.rb
 - lib/git_fit/parser/fit.rb
 - lib/git_fit/parser/gpx.rb
+- lib/git_fit/parser/tbulu.rb
 - lib/git_fit/parser/tcx.rb
 - lib/git_fit/privacy/polyline_filter.rb
 - lib/git_fit/source.rb