v8.7.0

HISTORY.rst

@@ -3,6 +3,55 @@ History
 -------
 
 
+8.7.0 (2019-05-29)
+++++++++++++++++++
+
+- Prevent creating user sublime-settings file when api key already exists in
+  common wakatime.cfg file.
+  `sublime-wakatime#98 <https://github.com/wakatime/sublime-wakatime/issues/98>`_
+
+
+8.6.1 (2019-05-28)
+++++++++++++++++++
+
+- Fix parsing common wakatime.cfg file.
+  `sublime-wakatime#98 <https://github.com/wakatime/sublime-wakatime/issues/98>`_
+
+
+8.6.0 (2019-05-27)
+++++++++++++++++++
+
+- Prevent prompting for api key when found from config file.
+  `sublime-wakatime#98 <https://github.com/wakatime/sublime-wakatime/issues/98>`_
+
+
+8.5.0 (2019-05-10)
+++++++++++++++++++
+
+- Remove clock icon from status bar.
+- Use wakatime-cli to fetch status bar coding time.
+
+
+8.4.2 (2019-05-07)
+++++++++++++++++++
+
+- Upgrade wakatime-cli to v11.0.0.
+- Rename argument --show-time-today to --today.
+- New argument --show-time-today for printing Today's coding time.
+
+
+8.4.1 (2019-05-01)
+++++++++++++++++++
+
+- Use api subdomain for fetching today's coding activity.
+
+
+8.4.0 (2019-05-01)
+++++++++++++++++++
+
+- Show today's coding time in status bar.
+
+
 8.3.6 (2019-04-30)
 ++++++++++++++++++
 

WakaTime.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """ ==========================================================
 File:        WakaTime.py
 Description: Automatic time tracking for Sublime Text 2 and 3.
@@ -7,7 +8,7 @@ Website:     https://wakatime.com/
 ==========================================================="""
 
 
-__version__ = '8.3.6'
+__version__ = '8.7.0'
 
 
 import sublime
@@ -25,7 +26,6 @@ import threading
 import traceback
 import urllib
 import webbrowser
-from datetime import datetime
 from subprocess import STDOUT, PIPE
 from zipfile import ZipFile
 try:
@@ -121,6 +121,9 @@ LAST_HEARTBEAT = {
     'is_write': False,
 }
 LAST_HEARTBEAT_SENT_AT = 0
+LAST_FETCH_TODAY_CODING_TIME = 0
+FETCH_TODAY_DEBOUNCE_COUNTER = 0
+FETCH_TODAY_DEBOUNCE_SECONDS = 60
 PYTHON_LOCATION = None
 HEARTBEATS = queue.Queue()
 HEARTBEAT_FREQUENCY = 2  # minutes between logging heartbeat when editing same file
@@ -137,9 +140,45 @@ ERROR = 'ERROR'
 # add wakatime package to path
 sys.path.insert(0, os.path.join(PLUGIN_DIR, 'packages'))
 try:
-    from wakatime.main import parseConfigFile
+    from wakatime.configs import parseConfigFile
 except ImportError:
-    pass
+    def parseConfigFile():
+        return None
+
+
+class ApiKey(object):
+    _key = None
+
+    def read(self):
+        if self._key:
+            return self._key
+
+        key = SETTINGS.get('api_key')
+        if key:
+            self._key = key
+            return self._key
+
+        try:
+            configs = parseConfigFile()
+            if configs:
+                if configs.has_option('settings', 'api_key'):
+                    key = configs.get('settings', 'api_key')
+                    if key:
+                        self._key = key
+                        return self._key
+        except:
+            pass
+
+        return self._key
+
+    def write(self, key):
+        global SETTINGS
+        self._key = key
+        SETTINGS.set('api_key', str(key))
+        sublime.save_settings(SETTINGS_FILE)
+
+
+APIKEY = ApiKey()
 
 
 def set_timeout(callback, seconds):
@@ -180,45 +219,101 @@ def resources_folder():
         return os.path.join(os.path.expanduser('~'), '.wakatime')
 
 
-def update_status_bar(status):
+def update_status_bar(status=None, debounced=False, msg=None):
     """Updates the status bar."""
+    global LAST_FETCH_TODAY_CODING_TIME, FETCH_TODAY_DEBOUNCE_COUNTER
 
     try:
-        if SETTINGS.get('status_bar_message'):
-            msg = datetime.now().strftime(SETTINGS.get('status_bar_message_fmt'))
-            if '{status}' in msg:
-                msg = msg.format(status=status)
+        if not msg and SETTINGS.get('status_bar_message') is not False and SETTINGS.get('status_bar_enabled'):
+            if SETTINGS.get('status_bar_coding_activity') and status == 'OK':
+                if debounced:
+                    FETCH_TODAY_DEBOUNCE_COUNTER -= 1
+                if debounced or not LAST_FETCH_TODAY_CODING_TIME:
+                    now = int(time.time())
+                    if LAST_FETCH_TODAY_CODING_TIME and (FETCH_TODAY_DEBOUNCE_COUNTER > 0 or LAST_FETCH_TODAY_CODING_TIME > now - FETCH_TODAY_DEBOUNCE_SECONDS):
+                        return
+                    LAST_FETCH_TODAY_CODING_TIME = now
+                    FetchStatusBarCodingTime().start()
+                    return
+                else:
+                    FETCH_TODAY_DEBOUNCE_COUNTER += 1
+                    set_timeout(lambda: update_status_bar(status, debounced=True), FETCH_TODAY_DEBOUNCE_SECONDS)
+                    return
+            else:
+                msg = 'WakaTime: {status}'.format(status=status)
 
+        if msg:
             active_window = sublime.active_window()
             if active_window:
                 for view in active_window.views():
                     view.set_status('wakatime', msg)
+
     except RuntimeError:
-        set_timeout(lambda: update_status_bar(status), 0)
+        set_timeout(lambda: update_status_bar(status=status, debounced=debounced, msg=msg), 0)
+
+
+class FetchStatusBarCodingTime(threading.Thread):
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+
+        self.debug = SETTINGS.get('debug')
+        self.api_key = APIKEY.read() or ''
+        self.proxy = SETTINGS.get('proxy')
+        self.python_binary = SETTINGS.get('python_binary')
+
+    def run(self):
+        if not self.api_key:
+            log(DEBUG, 'Missing WakaTime API key.')
+            return
+
+        python = self.python_binary
+        if not python or not python.strip():
+            python = python_binary()
+        if not python:
+            log(DEBUG, 'Missing Python.')
+            return
+
+        ua = 'sublime/%d sublime-wakatime/%s' % (ST_VERSION, __version__)
+        cmd = [
+            python,
+            API_CLIENT,
+            '--today',
+            '--key', str(bytes.decode(self.api_key.encode('utf8'))),
+            '--plugin', ua,
+        ]
+        if self.debug:
+            cmd.append('--verbose')
+        if self.proxy:
+            cmd.extend(['--proxy', self.proxy])
+
+        log(DEBUG, ' '.join(obfuscate_apikey(cmd)))
+        try:
+            process = Popen(cmd, stdout=PIPE, stderr=STDOUT)
+            output, err = process.communicate()
+            output = u(output)
+            retcode = process.poll()
+            if not retcode and output:
+                msg = 'Today: {output}'.format(output=output)
+                update_status_bar(msg=msg)
+            else:
+                log(DEBUG, 'wakatime-core today exited with status: {0}'.format(retcode))
+                if output:
+                    log(DEBUG, u('wakatime-core today output: {0}').format(output))
+        except:
+            pass
 
 
 def prompt_api_key():
-    global SETTINGS
-
-    if SETTINGS.get('api_key'):
+    if APIKEY.read():
         return True
 
-    default_key = ''
-    try:
-        configs = parseConfigFile()
-        if configs is not None:
-            if configs.has_option('settings', 'api_key'):
-                default_key = configs.get('settings', 'api_key')
-    except:
-        pass
-
     window = sublime.active_window()
     if window:
         def got_key(text):
             if text:
-                SETTINGS.set('api_key', str(text))
-                sublime.save_settings(SETTINGS_FILE)
-        window.show_input_panel('[WakaTime] Enter your wakatime.com api key:', default_key, got_key, None, None)
+                APIKEY.write(text)
+        window.show_input_panel('[WakaTime] Enter your wakatime.com api key:', '', got_key, None, None)
         return True
     else:
         log(ERROR, 'Could not prompt for api key because no window found.')
@@ -493,7 +588,7 @@ class SendHeartbeatsThread(threading.Thread):
         threading.Thread.__init__(self)
 
         self.debug = SETTINGS.get('debug')
-        self.api_key = SETTINGS.get('api_key', '')
+        self.api_key = APIKEY.read() or ''
         self.ignore = SETTINGS.get('ignore', [])
         self.include = SETTINGS.get('include', [])
         self.hidefilenames = SETTINGS.get('hidefilenames')
@@ -648,7 +743,7 @@ def plugin_loaded():
     SETTINGS = sublime.load_settings(SETTINGS_FILE)
 
     log(INFO, 'Initializing WakaTime plugin v%s' % __version__)
-    update_status_bar('Initializing')
+    update_status_bar('Initializing...')
 
     if not python_binary():
         log(WARNING, 'Python binary not found.')
@@ -664,6 +759,7 @@ def plugin_loaded():
 def after_loaded():
     if not prompt_api_key():
         set_timeout(after_loaded, 0.5)
+    update_status_bar('OK')
 
 
 # need to call plugin_loaded because only ST3 will auto-call it

WakaTime.sublime-settings

@@ -21,12 +21,13 @@
     // POSIX regular expressions will bypass your ignore setting.
     "include": [".*"],
 
-    // Status bar message. Set to false to hide status bar message.
-    // Defaults to true.
-    "status_bar_message": true,
+    // Status bar for surfacing errors and displaying today's coding time. Set
+    // to false to hide. Defaults to true.
+    "status_bar_enabled": true,
 
-    // Status bar message format.
-    "status_bar_message_fmt": "WakaTime {status} %I:%M %p",
+    // Show today's coding activity in WakaTime status bar item.
+    // Defaults to true.
+    "status_bar_coding_activity": true,
 
     // Obfuscate file paths when sending to API. Your dashboard will no longer display coding activity per file.
     "hidefilenames": false,

packages/wakatime/__about__.py

@@ -1,7 +1,7 @@
 __title__ = 'wakatime'
 __description__ = 'Common interface to the WakaTime api.'
 __url__ = 'https://github.com/wakatime/wakatime'
-__version_info__ = ('10', '8', '4')
+__version_info__ = ('11', '0', '0')
 __version__ = '.'.join(__version_info__)
 __author__ = 'Alan Hamlett'
 __author_email__ = 'alan@wakatime.com'

packages/wakatime/api.py

@@ -163,6 +163,119 @@ def send_heartbeats(heartbeats, args, configs, use_ntlm_proxy=False):
     return AUTH_ERROR if code == 401 else API_ERROR
 
 
+def get_time_today(args, use_ntlm_proxy=False):
+    """Get coding time from WakaTime API for given time range.
+
+    Returns total time as string or `None` when unable to fetch summary from
+    the API. When verbose output enabled, returns error message when unable to
+    fetch summary.
+    """
+
+    url = 'https://api.wakatime.com/api/v1/users/current/summaries'
+    timeout = args.timeout
+    if not timeout:
+        timeout = 60
+
+    api_key = u(base64.b64encode(str.encode(args.key) if is_py3 else args.key))
+    auth = u('Basic {api_key}').format(api_key=api_key)
+    headers = {
+        'User-Agent': get_user_agent(args.plugin),
+        'Accept': 'application/json',
+        'Authorization': auth,
+    }
+
+    session_cache = SessionCache()
+    session = session_cache.get()
+
+    should_try_ntlm = False
+    proxies = {}
+    if args.proxy:
+        if use_ntlm_proxy:
+            from .packages.requests_ntlm import HttpNtlmAuth
+            username = args.proxy.rsplit(':', 1)
+            password = ''
+            if len(username) == 2:
+                password = username[1]
+            username = username[0]
+            session.auth = HttpNtlmAuth(username, password, session)
+        else:
+            should_try_ntlm = '\\' in args.proxy
+            proxies['https'] = args.proxy
+
+    ssl_verify = not args.nosslverify
+    if args.ssl_certs_file and ssl_verify:
+        ssl_verify = args.ssl_certs_file
+
+    params = {
+        'start': 'today',
+        'end': 'today',
+    }
+
+    # send request to api
+    response, code = None, None
+    try:
+        response = session.get(url, params=params, headers=headers,
+                               proxies=proxies, timeout=timeout,
+                               verify=ssl_verify)
+    except RequestException:
+        if should_try_ntlm:
+            return get_time_today(args, use_ntlm_proxy=True)
+
+        session_cache.delete()
+        if log.isEnabledFor(logging.DEBUG):
+            exception_data = {
+                sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
+                'traceback': traceback.format_exc(),
+            }
+            log.error(exception_data)
+            return '{0}: {1}'.format(sys.exc_info()[0].__name__, u(sys.exc_info()[1])), API_ERROR
+        return None, API_ERROR
+
+    except:  # delete cached session when requests raises unknown exception
+        if should_try_ntlm:
+            return get_time_today(args, use_ntlm_proxy=True)
+
+        session_cache.delete()
+        if log.isEnabledFor(logging.DEBUG):
+            exception_data = {
+                sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
+                'traceback': traceback.format_exc(),
+            }
+            log.error(exception_data)
+            return '{0}: {1}'.format(sys.exc_info()[0].__name__, u(sys.exc_info()[1])), API_ERROR
+        return None, API_ERROR
+
+    code = response.status_code if response is not None else None
+    content = response.text if response is not None else None
+
+    if code == requests.codes.ok:
+        try:
+            text = response.json()['data'][0]['grand_total']['text']
+            session_cache.save(session)
+            return text, SUCCESS
+        except:
+            if log.isEnabledFor(logging.DEBUG):
+                exception_data = {
+                    sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
+                    'traceback': traceback.format_exc(),
+                }
+                log.error(exception_data)
+                return '{0}: {1}'.format(sys.exc_info()[0].__name__, u(sys.exc_info()[1])), API_ERROR
+            return None, API_ERROR
+    else:
+        if should_try_ntlm:
+            return get_time_today(args, use_ntlm_proxy=True)
+
+        session_cache.delete()
+        log.debug({
+            'response_code': code,
+            'response_text': content,
+        })
+        if log.isEnabledFor(logging.DEBUG):
+            return 'Error: {0}'.format(code), API_ERROR
+        return None, API_ERROR
+
+
 def _process_server_results(heartbeats, code, content, results, args, configs):
     log.debug({
         'response_code': code,

packages/wakatime/arguments.py

@@ -201,6 +201,9 @@ def parse_arguments():
                              'online 5 offline heartbeats are synced. Can ' +
                              'be used without --entity to only sync offline ' +
                              'activity without generating new heartbeats.')
+    parser.add_argument('--today', dest='today',
+                        action='store_true',
+                        help='Prints dashboard time for Today, then exits.')
     parser.add_argument('--config', dest='config', action=StoreWithoutQuotes,
                         help='Defaults to ~/.wakatime.cfg.')
     parser.add_argument('--verbose', dest='verbose', action='store_true',
@@ -245,7 +248,7 @@ def parse_arguments():
     if not args.entity:
         if args.file:
             args.entity = args.file
-        elif not args.sync_offline_activity or args.sync_offline_activity == 'none':
+        elif (not args.sync_offline_activity or args.sync_offline_activity == 'none') and not args.today:
             parser.error('argument --entity is required')
 
     if not args.sync_offline_activity:

packages/wakatime/main.py

@@ -22,7 +22,7 @@ sys.path.insert(0, os.path.dirname(pwd))
 sys.path.insert(0, os.path.join(pwd, 'packages'))
 
 from .__about__ import __version__
-from .api import send_heartbeats
+from .api import send_heartbeats, get_time_today
 from .arguments import parse_arguments
 from .compat import u, json
 from .constants import SUCCESS, UNKNOWN_ERROR, HEARTBEATS_PER_REQUEST
@@ -42,6 +42,12 @@ def execute(argv=None):
 
     setup_logging(args, __version__)
 
+    if args.today:
+        text, retval = get_time_today(args)
+        if text:
+            print(text)
+        return retval
+
     try:
         heartbeats = []