v4.0.12

add "Wakatime: Open Dashboard" into command palette

Default.sublime-commands

@@ -0,0 +1,6 @@
+[
+	{
+		"caption": "WakaTime: Open Dashboard",
+		"command": "wakatime_dashboard"
+	}
+]

HISTORY.rst

@@ -3,6 +3,177 @@ History
 -------
 
 
+4.0.12 (2015-07-31)
+++++++++++++++++++
+
+- correctly use urllib in Python3
+
+
+4.0.11 (2015-07-31)
+++++++++++++++++++
+
+- install python if missing on Windows OS
+
+
+4.0.10 (2015-07-31)
+++++++++++++++++++
+
+- downgrade requests library to v2.6.0
+
+
+4.0.9 (2015-07-29)
+++++++++++++++++++
+
+- catch exceptions from pygments.modeline.get_filetype_from_buffer
+
+
+4.0.8 (2015-06-23)
+++++++++++++++++++
+
+- fix offline logging
+- limit language detection to known file extensions, unless file contents has a vim modeline
+- upgrade wakatime cli to v4.0.16
+
+
+4.0.7 (2015-06-21)
+++++++++++++++++++
+
+- allow customizing status bar message in sublime-settings file
+- guess language using multiple methods, then use most accurate guess
+- use entity and type for new heartbeats api resource schema
+- correctly log message from py.warnings module
+- upgrade wakatime cli to v4.0.15
+
+
+4.0.6 (2015-05-16)
+++++++++++++++++++
+
+- fix bug with auto detecting project name
+- upgrade wakatime cli to v4.0.13
+
+
+4.0.5 (2015-05-15)
+++++++++++++++++++
+
+- correctly display caller and lineno in log file when debug is true
+- project passed with --project argument will always be used
+- new --alternate-project argument
+- upgrade wakatime cli to v4.0.12
+
+
+4.0.4 (2015-05-12)
+++++++++++++++++++
+
+- reuse SSL connection over multiple processes for improved performance
+- upgrade wakatime cli to v4.0.11
+
+
+4.0.3 (2015-05-06)
+++++++++++++++++++
+
+- send cursorpos to wakatime cli
+- upgrade wakatime cli to v4.0.10
+
+
+4.0.2 (2015-05-06)
+++++++++++++++++++
+
+- only send heartbeats for the currently active buffer
+
+
+4.0.1 (2015-05-06)
+++++++++++++++++++
+
+- ignore git temporary files
+- don't send two write heartbeats within 2 seconds of eachother
+
+
+4.0.0 (2015-04-12)
+++++++++++++++++++
+
+- listen for selection modified instead of buffer activated for better performance
+
+
+3.0.19 (2015-04-07)
++++++++++++++++++++
+
+- fix bug in project detection when folder not found
+
+
+3.0.18 (2015-04-04)
++++++++++++++++++++
+
+- upgrade wakatime cli to v4.0.8
+- added api_url config option to .wakatime.cfg file
+
+
+3.0.17 (2015-04-02)
++++++++++++++++++++
+
+- use open folder as current project when not using revision control
+
+
+3.0.16 (2015-04-02)
++++++++++++++++++++
+
+- copy list when obfuscating api key so original command is not modified
+
+
+3.0.15 (2015-04-01)
++++++++++++++++++++
+
+- obfuscate api key when logging to Sublime Text Console in debug mode
+
+
+3.0.14 (2015-03-31)
++++++++++++++++++++
+
+- always use external python binary because ST builtin python does not support checking SSL certs
+- upgrade wakatime cli to v4.0.6
+
+
+3.0.13 (2015-03-23)
++++++++++++++++++++
+
+- correctly check for SSL support in ST built-in python
+- fix status bar message
+
+
+3.0.12 (2015-03-23)
++++++++++++++++++++
+
+- always use unicode function from compat module when encoding log messages
+
+
+3.0.11 (2015-03-23)
++++++++++++++++++++
+
+- upgrade simplejson package to v3.6.5
+
+
+3.0.10 (2015-03-22)
++++++++++++++++++++
+
+- ability to disable status bar message from WakaTime.sublime-settings file
+
+
+3.0.9 (2015-03-20)
+++++++++++++++++++
+
+- status bar message showing when WakaTime plugin is enabled
+- moved some logic into thread to help prevent slow plugin warning message
+
+
+3.0.8 (2015-03-09)
+++++++++++++++++++
+
+- upgrade wakatime cli to v4.0.4
+- use requests library instead of urllib2, so api SSL cert is verified
+- new --notfile argument to support logging time without a real file
+- new --proxy argument for https proxy support
+- new options for excluding and including directories
+
+
 3.0.7 (2015-02-05)
 ++++++++++++++++++
 

README.md

@@ -18,7 +18,7 @@ Heads Up! For Sublime Text 2 on Windows & Linux, WakaTime depends on [Python](ht
 
   c) Type `wakatime`, then press `enter` with the `WakaTime` plugin selected.
 
-3. Enter your [api key](https://wakatime.com/settings#apikey) from https://wakatime.com/settings#apikey, then press `enter`.
+3. Enter your [api key](https://wakatime.com/settings#apikey), then press `enter`.
 
 4. Use Sublime and your time will be tracked for you automatically.
 
@@ -29,3 +29,15 @@ Screen Shots
 
 ![Project Overview](https://wakatime.com/static/img/ScreenShots/ScreenShot-2014-10-29.png)
 
+Troubleshooting
+---------------
+
+First, turn on debug mode in your `WakaTime.sublime-settings` file.
+
+![sublime user settings](https://wakatime.com/static/img/ScreenShots/sublime-wakatime-settings-menu.png)
+
+Add the line: `"debug": true`
+
+Then, open your Sublime Console with `View -> Show Console` to see the plugin executing the wakatime cli process when sending a heartbeat. Also, tail your `$HOME/.wakatime.log` file to debug wakatime cli problems.
+
+For more general troubleshooting information, see [wakatime/wakatime#troubleshooting](https://github.com/wakatime/wakatime#troubleshooting).

WakaTime.py

@@ -6,7 +6,9 @@ License:     BSD, see LICENSE for more details.
 Website:     https://wakatime.com/
 ==========================================================="""
 
-__version__ = '3.0.7'
+
+__version__ = '4.0.12'
+
 
 import sublime
 import sublime_plugin
@@ -17,41 +19,34 @@ import platform
 import sys
 import time
 import threading
-import uuid
-from os.path import expanduser, dirname, basename, realpath, isfile, join, exists
+import urllib
+import webbrowser
+from datetime import datetime
+from subprocess import Popen
+
 
 # globals
-ACTION_FREQUENCY = 2
+HEARTBEAT_FREQUENCY = 2
 ST_VERSION = int(sublime.version())
-PLUGIN_DIR = dirname(realpath(__file__))
-API_CLIENT = '%s/packages/wakatime/wakatime-cli.py' % PLUGIN_DIR
+PLUGIN_DIR = os.path.dirname(os.path.realpath(__file__))
+API_CLIENT = os.path.join(PLUGIN_DIR, 'packages', 'wakatime', 'cli.py')
 SETTINGS_FILE = 'WakaTime.sublime-settings'
 SETTINGS = {}
-LAST_ACTION = {
+LAST_HEARTBEAT = {
     'time': 0,
     'file': None,
     'is_write': False,
 }
-HAS_SSL = False
 LOCK = threading.RLock()
+PYTHON_LOCATION = None
+
 
 # add wakatime package to path
-sys.path.insert(0, join(PLUGIN_DIR, 'packages', 'wakatime'))
-
-from wakatime import parseConfigFile
-
-# check if we have SSL support
+sys.path.insert(0, os.path.join(PLUGIN_DIR, 'packages'))
 try:
-    import ssl
-    import socket
-    socket.ssl
-    HAS_SSL = True
-except (ImportError, AttributeError):
-    from subprocess import Popen
-
-if HAS_SSL:
-    # import wakatime package so we can use built-in python
-    import wakatime
+    from wakatime.base import parseConfigFile
+except ImportError:
+    pass
 
 
 def createConfigFile():
@@ -78,10 +73,13 @@ def prompt_api_key():
     createConfigFile()
 
     default_key = ''
-    configs = parseConfigFile()
-    if configs is not None:
-        if configs.has_option('settings', 'api_key'):
-            default_key = configs.get('settings', 'api_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
 
     if SETTINGS.get('api_key'):
         return True
@@ -100,56 +98,107 @@ def prompt_api_key():
 
 
 def python_binary():
-    if platform.system() == 'Windows':
+    global PYTHON_LOCATION
+    if PYTHON_LOCATION is not None:
+        return PYTHON_LOCATION
+    paths = [
+        "pythonw",
+        "python",
+        "/usr/local/bin/python",
+        "/usr/bin/python",
+    ]
+    for path in paths:
         try:
-            Popen(['pythonw', '--version'])
-            return 'pythonw'
+            Popen([path, '--version'])
+            PYTHON_LOCATION = path
+            return path
         except:
-            for path in glob.iglob('/python*'):
-                if exists(realpath(join(path, 'pythonw.exe'))):
-                    return realpath(join(path, 'pythonw'))
-            return None
-    return 'python'
+            pass
+    for path in glob.iglob('/python*'):
+        path = os.path.realpath(os.path.join(path, 'pythonw'))
+        try:
+            Popen([path, '--version'])
+            PYTHON_LOCATION = path
+            return path
+        except:
+            pass
+    return None
 
 
-def enough_time_passed(now, last_time):
-    if now - last_time > ACTION_FREQUENCY * 60:
+def obfuscate_apikey(command_list):
+    cmd = list(command_list)
+    apikey_index = None
+    for num in range(len(cmd)):
+        if cmd[num] == '--key':
+            apikey_index = num + 1
+            break
+    if apikey_index is not None and apikey_index < len(cmd):
+        cmd[apikey_index] = '********-****-****-****-********' + cmd[apikey_index][-4:]
+    return cmd
+
+
+def enough_time_passed(now, last_heartbeat, is_write):
+    if now - last_heartbeat['time'] > HEARTBEAT_FREQUENCY * 60:
+        return True
+    if is_write and now - last_heartbeat['time'] > 2:
         return True
     return False
 
 
-def find_project_name_from_folders(folders):
-    try:
+def find_folder_containing_file(folders, current_file):
+    """Returns absolute path to folder containing the file.
+    """
+
+    parent_folder = None
+
+    current_folder = current_file
+    while True:
         for folder in folders:
-            for file_name in os.listdir(folder):
-                if file_name.endswith('.sublime-project'):
-                    return file_name.replace('.sublime-project', '', 1)
-    except:
-        pass
-    return None
+            if os.path.realpath(os.path.dirname(current_folder)) == os.path.realpath(folder):
+                parent_folder = folder
+                break
+        if parent_folder is not None:
+            break
+        if not current_folder or os.path.dirname(current_folder) == current_folder:
+            break
+        current_folder = os.path.dirname(current_folder)
+
+    return parent_folder
 
 
-def handle_action(view, is_write=False):
-    global LOCK, LAST_ACTION
-    with LOCK:
+def find_project_from_folders(folders, current_file):
+    """Find project name from open folders.
+    """
+
+    folder = find_folder_containing_file(folders, current_file)
+    return os.path.basename(folder) if folder else None
+
+
+def is_view_active(view):
+    if view:
+        active_window = sublime.active_window()
+        if active_window:
+            active_view = active_window.active_view()
+            if active_view:
+                return active_view.buffer_id() == view.buffer_id()
+    return False
+
+
+def handle_heartbeat(view, is_write=False):
+    window = view.window()
+    if window is not None:
         target_file = view.file_name()
-        if target_file:
-            project = view.window().project_file_name() if hasattr(view.window(), 'project_file_name') else None
-            if project:
-                project = basename(project).replace('.sublime-project', '', 1)
-            thread = SendActionThread(target_file, is_write=is_write, project=project, folders=view.window().folders())
-            thread.start()
-            LAST_ACTION = {
-                'file': target_file,
-                'time': time.time(),
-                'is_write': is_write,
-            }
+        project = window.project_data() if hasattr(window, 'project_data') else None
+        folders = window.folders()
+        thread = SendHeartbeatThread(target_file, view, is_write=is_write, project=project, folders=folders)
+        thread.start()
 
 
-class SendActionThread(threading.Thread):
+class SendHeartbeatThread(threading.Thread):
 
-    def __init__(self, target_file, is_write=False, project=None, folders=None, force=False):
+    def __init__(self, target_file, view, is_write=False, project=None, folders=None, force=False):
         threading.Thread.__init__(self)
+        self.lock = LOCK
         self.target_file = target_file
         self.is_write = is_write
         self.project = project
@@ -158,15 +207,18 @@ class SendActionThread(threading.Thread):
         self.debug = SETTINGS.get('debug')
         self.api_key = SETTINGS.get('api_key', '')
         self.ignore = SETTINGS.get('ignore', [])
-        self.last_action = LAST_ACTION
+        self.last_heartbeat = LAST_HEARTBEAT.copy()
+        self.cursorpos = view.sel()[0].begin() if view.sel() else None
+        self.view = view
 
     def run(self):
-        if self.target_file:
-            self.timestamp = time.time()
-            if self.force or (self.is_write and not self.last_action['is_write']) or self.target_file != self.last_action['file'] or enough_time_passed(self.timestamp, self.last_action['time']):
-                self.send()
+        with self.lock:
+            if self.target_file:
+                self.timestamp = time.time()
+                if self.force or self.target_file != self.last_heartbeat['file'] or enough_time_passed(self.timestamp, self.last_heartbeat, self.is_write):
+                    self.send_heartbeat()
 
-    def send(self):
+    def send_heartbeat(self):
         if not self.api_key:
             print('[WakaTime] Error: missing api key.')
             return
@@ -180,44 +232,57 @@ class SendActionThread(threading.Thread):
         ]
         if self.is_write:
             cmd.append('--write')
-        if self.project:
-            cmd.extend(['--project', self.project])
+        if self.project and self.project.get('name'):
+            cmd.extend(['--alternate-project', self.project.get('name')])
         elif self.folders:
-            project_name = find_project_name_from_folders(self.folders)
+            project_name = find_project_from_folders(self.folders, self.target_file)
             if project_name:
-                cmd.extend(['--project', project_name])
+                cmd.extend(['--alternate-project', project_name])
+        if self.cursorpos is not None:
+            cmd.extend(['--cursorpos', '{0}'.format(self.cursorpos)])
         for pattern in self.ignore:
             cmd.extend(['--ignore', pattern])
         if self.debug:
             cmd.append('--verbose')
-        if HAS_SSL:
+        if python_binary():
+            cmd.insert(0, python_binary())
             if self.debug:
-                print('[WakaTime] %s' % ' '.join(cmd))
-            code = wakatime.main(cmd)
-            if code != 0:
-                print('[WakaTime] Error: Response code %d from wakatime package.' % code)
-        else:
-            python = python_binary()
-            if python:
-                cmd.insert(0, python)
-                if self.debug:
-                    print('[WakaTime] %s' % ' '.join(cmd))
-                if platform.system() == 'Windows':
-                    Popen(cmd, shell=False)
-                else:
-                    with open(join(expanduser('~'), '.wakatime.log'), 'a') as stderr:
-                        Popen(cmd, stderr=stderr)
+                print('[WakaTime] %s' % ' '.join(obfuscate_apikey(cmd)))
+            if platform.system() == 'Windows':
+                Popen(cmd, shell=False)
             else:
-                print('[WakaTime] Error: Unable to find python binary.')
+                with open(os.path.join(os.path.expanduser('~'), '.wakatime.log'), 'a') as stderr:
+                    Popen(cmd, stderr=stderr)
+            self.sent()
+        else:
+            print('[WakaTime] Error: Unable to find python binary.')
+
+    def sent(self):
+        sublime.set_timeout(self.set_status_bar, 0)
+        sublime.set_timeout(self.set_last_heartbeat, 0)
+
+    def set_status_bar(self):
+        if SETTINGS.get('status_bar_message'):
+            self.view.set_status('wakatime', datetime.now().strftime(SETTINGS.get('status_bar_message_fmt')))
+
+    def set_last_heartbeat(self):
+        global LAST_HEARTBEAT
+        LAST_HEARTBEAT = {
+            'file': self.target_file,
+            'time': self.timestamp,
+            'is_write': self.is_write,
+        }
 
 
 def plugin_loaded():
     global SETTINGS
     print('[WakaTime] Initializing WakaTime plugin v%s' % __version__)
 
-    if not HAS_SSL:
-        python = python_binary()
-        if not python:
+    if not python_binary():
+        print('[WakaTime] Warning: Python binary not found.')
+        if platform.system() == 'Windows':
+            install_python()
+        else:
             sublime.error_message("Unable to find Python binary!\nWakaTime needs Python to work correctly.\n\nGo to https://www.python.org/downloads")
             return
 
@@ -230,6 +295,26 @@ def after_loaded():
         sublime.set_timeout(after_loaded, 500)
 
 
+def install_python():
+    print('[WakaTime] Downloading and installing python...')
+    url = 'https://www.python.org/ftp/python/3.4.3/python-3.4.3.msi'
+    if platform.architecture()[0] == '64bit':
+        url = 'https://www.python.org/ftp/python/3.4.3/python-3.4.3.amd64.msi'
+    python_msi = os.path.join(os.path.expanduser('~'), 'python.msi')
+    try:
+        urllib.urlretrieve(url, python_msi)
+    except AttributeError:
+        urllib.request.urlretrieve(url, python_msi)
+    args = [
+        'msiexec',
+        '/i',
+        python_msi,
+        '/norestart',
+        '/qb!',
+    ]
+    Popen(args)
+
+
 # need to call plugin_loaded because only ST3 will auto-call it
 if ST_VERSION < 3000:
     plugin_loaded()
@@ -238,10 +323,18 @@ if ST_VERSION < 3000:
 class WakatimeListener(sublime_plugin.EventListener):
 
     def on_post_save(self, view):
-        handle_action(view, is_write=True)
+        handle_heartbeat(view, is_write=True)
 
-    def on_activated(self, view):
-        handle_action(view)
+    def on_selection_modified(self, view):
+        if is_view_active(view):
+            handle_heartbeat(view)
 
     def on_modified(self, view):
-        handle_action(view)
+        if is_view_active(view):
+            handle_heartbeat(view)
+
+
+class WakatimeDashboardCommand(sublime_plugin.ApplicationCommand):
+
+    def run(self):
+        webbrowser.open_new_tab('https://wakatime.com/dashboard')

WakaTime.sublime-settings

@@ -9,8 +9,15 @@
     
     // Ignore files; Files (including absolute paths) that match one of these
     // POSIX regular expressions will not be logged.
-    "ignore": ["^/tmp/", "^/etc/", "^/var/"],
+    "ignore": ["^/tmp/", "^/etc/", "^/var/", "COMMIT_EDITMSG$", "PULLREQ_EDITMSG$", "MERGE_MSG$", "TAG_EDITMSG$"],
     
     // Debug mode. Set to true for verbose logging. Defaults to false.
-    "debug": false
+    "debug": false,
+    
+    // Status bar message. Set to false to hide status bar message.
+    // Defaults to true.
+    "status_bar_message": true,
+    
+    // Status bar message format.
+    "status_bar_message_fmt": "WakaTime active %I:%M %p"
 }

packages/wakatime/.gitignore

@@ -1,39 +0,0 @@
-*.py[cod]
-
-# C extensions
-*.so
-
-# Packages
-*.egg
-*.egg-info
-dist
-build
-eggs
-parts
-bin
-var
-sdist
-develop-eggs
-.installed.cfg
-lib
-lib64
-
-# Installer logs
-pip-log.txt
-
-# Unit test / coverage reports
-.coverage
-.tox
-nosetests.xml
-
-# Translations
-*.mo
-
-# Mr Developer
-.mr.developer.cfg
-.project
-.pydevproject
-
-virtualenv
-venv
-.DS_Store

packages/wakatime/AUTHORS

@@ -1,15 +0,0 @@
-WakaTime is written and maintained by Alan Hamlett and
-various contributors:
-
-
-Development Lead
-----------------
-
-- Alan Hamlett <alan.hamlett@gmail.com>
-
-
-Patches and Suggestions
------------------------
-
-- 3onyc <3onyc@x3tech.com>
-- userid <xixico@ymail.com>

packages/wakatime/HISTORY.rst

@@ -1,304 +0,0 @@
-
-History
--------
-
-
-3.0.5 (2015-01-13)
-++++++++++++++++++
-
-- ignore errors from malformed markup (too many closing tags)
-
-
-3.0.4 (2015-01-06)
-++++++++++++++++++
-
-- remove unused dependency, which is missing in some python environments
-
-
-3.0.3 (2014-12-25)
-++++++++++++++++++
-
-- detect JavaScript frameworks from script tags in Html template files
-
-
-3.0.2 (2014-12-25)
-++++++++++++++++++
-
-- detect frameworks from JavaScript and JSON files
-
-
-3.0.1 (2014-12-23)
-++++++++++++++++++
-
-- handle unknown language when parsing dependencies
-
-
-3.0.0 (2014-12-23)
-++++++++++++++++++
-
-- detect libraries and frameworks for C++, Java, .NET, PHP, and Python files
-
-
-2.1.11 (2014-12-22)
-+++++++++++++++++++
-
-- fix offline logging when response from api is None
-
-
-2.1.10 (2014-12-15)
-+++++++++++++++++++
-
-- prevent queuing offline heartbeats which will never be valid (400 errors)
-
-
-2.1.9 (2014-12-05)
-++++++++++++++++++
-
-- fix bug preventing offline heartbeats from being purged after uploaded
-
-
-2.1.8 (2014-12-04)
-++++++++++++++++++
-
-- fix UnicodeDecodeError when building user agent string
-- handle case where response is None
-
-
-2.1.7 (2014-11-30)
-++++++++++++++++++
-
-- upgrade pygments to v2.0.1
-- always log an error when api key is incorrect
-
-
-2.1.6 (2014-11-18)
-++++++++++++++++++
-
-- fix list index error when detecting subversion project
-
-
-2.1.5 (2014-11-17)
-++++++++++++++++++
-
-- catch exceptions when getting current machine time zone
-
-
-2.1.4 (2014-11-12)
-++++++++++++++++++
-
-- when Python was not compiled with https support, log an error to the log file
-
-
-2.1.3 (2014-11-10)
-++++++++++++++++++
-
-- correctly detect branch name for subversion projects
-
-
-2.1.2 (2014-10-07)
-++++++++++++++++++
-
-- still log heartbeat when something goes wrong while reading num lines in file
-
-
-2.1.1 (2014-09-30)
-++++++++++++++++++
-
-- fix bug where binary file opened as utf-8
-
-
-2.1.0 (2014-09-30)
-++++++++++++++++++
-
-- python3 compatibility changes
-
-
-2.0.8 (2014-08-29)
-++++++++++++++++++
-
-- supress output from svn command
-
-
-2.0.7 (2014-08-27)
-++++++++++++++++++
-
-- find svn binary location from common install directories
-
-
-2.0.6 (2014-08-07)
-++++++++++++++++++
-
-- encode json data as str when passing to urllib
-
-
-2.0.5 (2014-07-25)
-++++++++++++++++++
-
-- option in .wakatime.cfg to obfuscate file names
-
-
-2.0.4 (2014-07-25)
-++++++++++++++++++
-
-- use unique logger namespace to prevent collisions in shared plugin environments
-
-
-2.0.3 (2014-06-18)
-++++++++++++++++++
-
-- use project from command line arg when no revision control project is found
-
-
-2.0.2 (2014-06-09)
-++++++++++++++++++
-
-- include python3.2 compatible versions of simplejson, pytz, and tzlocal
-- disable offline logging when Python was not compiled with sqlite3 module
-
-
-2.0.1 (2014-05-26)
-++++++++++++++++++
-
-- fix bug in queue preventing actions with NULL values from being purged
-
-
-2.0.0 (2014-05-25)
-++++++++++++++++++
-
-- offline time logging using sqlite3 to queue editor events
-
-
-1.0.2 (2014-05-06)
-++++++++++++++++++
-
-- ability to set project from command line argument
-
-
-1.0.1 (2014-03-05)
-++++++++++++++++++
-
-- use new domain name wakatime.com
-
-
-1.0.0 (2014-02-05)
-++++++++++++++++++
-
-- detect project name and branch name from mercurial revision control
-
-
-0.5.3 (2014-01-15)
-++++++++++++++++++
-
-- bug fix for unicode in Python3
-
-
-0.5.2 (2014-01-14)
-++++++++++++++++++
-
-- minor bug fix for Subversion on non-English systems
-
-
-0.5.1 (2013-12-13)
-++++++++++++++++++
-
-- second line in .wakatime-project file now sets branch name
-
-
-0.5.0 (2013-12-13)
-++++++++++++++++++
-
-- Convert ~/.wakatime.conf to ~/.wakatime.cfg and use configparser format
-- new [projectmap] section in cfg file for naming projects based on folders
-
-
-0.4.10 (2013-11-13)
-+++++++++++++++++++
-
-- Placing .wakatime-project file in a folder will read the project's name from that file
-
-
-0.4.9 (2013-10-27)
-++++++++++++++++++
-
-- New config for ignoring files from regular expressions
-- Parse more options from config file (verbose, logfile, ignore)
-
-
-0.4.8 (2013-10-13)
-++++++++++++++++++
-
-- Read git HEAD file to find current branch instead of running git command line
-
-
-0.4.7 (2013-09-30)
-++++++++++++++++++
-
-- Sending local olson timezone string in api request
-
-
-0.4.6 (2013-09-22)
-++++++++++++++++++
-
-- Sending total lines in file and language name to api
-
-
-0.4.5 (2013-09-07)
-++++++++++++++++++
-
-- Fixed relative import error by adding packages directory to sys path
-
-
-0.4.4 (2013-09-06)
-++++++++++++++++++
-
-- Using urllib2 again because of intermittent problems sending json with requests library
-
-
-0.4.3 (2013-09-04)
-++++++++++++++++++
-
-- Encoding json as utf-8 before making request
-
-
-0.4.2 (2013-09-04)
-++++++++++++++++++
-
-- Using requests package v1.2.3 from pypi
-
-
-0.4.1 (2013-08-25)
-++++++++++++++++++
-
-- Fix bug causing requests library to omit POST content
-
-
-0.4.0 (2013-08-15)
-++++++++++++++++++
-
-- Sending single branch instead of multiple tags
-
-
-0.3.1 (2013-08-08)
-++++++++++++++++++
-
-- Using requests module instead of urllib2 to verify SSL certs
-
-
-0.3.0 (2013-08-08)
-++++++++++++++++++
-
-- Allow importing directly from Python plugins
-
-
-0.1.1 (2013-07-07)
-++++++++++++++++++
-
-- Refactored
-- Simplified action events schema
-
-
-0.0.1 (2013-07-05)
-++++++++++++++++++
-
-- Birth
-

packages/wakatime/LICENSE

@@ -1,31 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2014 by the respective authors (see AUTHORS file).
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright
-  notice, this list of conditions and the following disclaimer
-  in the documentation and/or other materials provided
-  with the distribution.
-
-* Neither the names of WakaTime, nor the names of its
-  contributors may be used to endorse or promote products derived
-  from this software without specific prior written permission.
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
-NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

packages/wakatime/MANIFEST.in

@@ -1,2 +0,0 @@
-include README.rst LICENSE HISTORY.rst
-recursive-include wakatime *.py

packages/wakatime/README.rst

@@ -1,20 +0,0 @@
-WakaTime
-========
-
-Fully automatic time tracking for programmers.
-
-This is the common interface for the WakaTime api. You shouldn't need to directly use this package unless you are creating a new plugin or your text editor's plugin asks you to install the wakatime-cli interface.
-
-Go to http://wakatime.com to install the plugin for your text editor.
-
-
-Installation
-------------
-
-    pip install wakatime
-
-
-Usage
------
-
-https://wakatime.com/

packages/wakatime/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'wakatime'
+__description__ = 'Common interface to the WakaTime api.'
+__url__ = 'https://github.com/wakatime/wakatime'
+__version_info__ = ('4', '1', '0')
+__version__ = '.'.join(__version_info__)
+__author__ = 'Alan Hamlett'
+__author_email__ = 'alan@wakatime.com'
+__license__ = 'BSD'
+__copyright__ = 'Copyright 2014 Alan Hamlett'

packages/wakatime/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime
+    ~~~~~~~~
+
+    Common interface to the WakaTime api.
+    http://wakatime.com
+
+    :copyright: (c) 2013 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+
+__all__ = ['main']
+
+
+from .base import main

packages/wakatime/base.py

@@ -1,10 +1,9 @@
 # -*- coding: utf-8 -*-
 """
-    wakatime
-    ~~~~~~~~
+    wakatime.base
+    ~~~~~~~~~~~~~
 
-    Common interface to the WakaTime api.
-    http://wakatime.com
+    wakatime module entry point.
 
     :copyright: (c) 2013 Alan Hamlett.
     :license: BSD, see LICENSE for more details.
@@ -12,13 +11,6 @@
 
 from __future__ import print_function
 
-__title__ = 'wakatime'
-__version__ = '3.0.5'
-__author__ = 'Alan Hamlett'
-__license__ = 'BSD'
-__copyright__ = 'Copyright 2014 Alan Hamlett'
-
-
 import base64
 import logging
 import os
@@ -27,30 +19,29 @@ import re
 import sys
 import time
 import traceback
+import socket
 try:
     import ConfigParser as configparser
 except ImportError:
     import configparser
-try:
-    from urllib2 import HTTPError, Request, urlopen
-except ImportError:
-    from urllib.error import HTTPError
-    from urllib.request import Request, urlopen
 
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'packages'))
 
+from .__about__ import __version__
 from .compat import u, open, is_py3
-from .queue import Queue
-from .log import setup_logging
-from .project import find_project
-from .stats import get_file_stats
+from .logger import setup_logging
+from .offlinequeue import Queue
 from .packages import argparse
 from .packages import simplejson as json
+from .packages.requests.exceptions import RequestException
+from .project import get_project_info
+from .session_cache import SessionCache
+from .stats import get_file_stats
 try:
     from .packages import tzlocal
 except:
-    from .packages import tzlocal3
+    from .packages import tzlocal3 as tzlocal
 
 
 log = logging.getLogger('WakaTime')
@@ -143,31 +134,54 @@ def parseArguments(argv):
     parser.add_argument('--file', dest='targetFile', metavar='file',
             action=FileAction, required=True,
             help='absolute path to file for current heartbeat')
-    parser.add_argument('--time', dest='timestamp', metavar='time',
-            type=float,
-            help='optional floating-point unix epoch timestamp; '+
-                'uses current time by default')
-    parser.add_argument('--write', dest='isWrite',
-            action='store_true',
-            help='note heartbeat was triggered from writing to a file')
-    parser.add_argument('--plugin', dest='plugin',
-            help='optional text editor plugin name and version '+
-                'for User-Agent header')
-    parser.add_argument('--project', dest='project_name',
-            help='optional project name; will auto-discover by default')
     parser.add_argument('--key', dest='key',
             help='your wakatime api key; uses api_key from '+
                 '~/.wakatime.conf by default')
+    parser.add_argument('--write', dest='isWrite',
+            action='store_true',
+            help='when set, tells api this heartbeat was triggered from '+
+                 'writing to a file')
+    parser.add_argument('--plugin', dest='plugin',
+            help='optional text editor plugin name and version '+
+                 'for User-Agent header')
+    parser.add_argument('--time', dest='timestamp', metavar='time',
+            type=float,
+            help='optional floating-point unix epoch timestamp; '+
+                 'uses current time by default')
+    parser.add_argument('--lineno', dest='lineno',
+            help='optional line number; current line being edited')
+    parser.add_argument('--cursorpos', dest='cursorpos',
+            help='optional cursor position in the current file')
+    parser.add_argument('--notfile', dest='notfile', action='store_true',
+            help='when set, will accept any value for the file. for example, '+
+                 'a domain name or other item you want to log time towards.')
+    parser.add_argument('--proxy', dest='proxy',
+                        help='optional https proxy url; for example: '+
+                        'https://user:pass@localhost:8080')
+    parser.add_argument('--project', dest='project',
+            help='optional project name')
+    parser.add_argument('--alternate-project', dest='alternate_project',
+            help='optional alternate project name; auto-discovered project takes priority')
+    parser.add_argument('--hostname', dest='hostname', help='hostname of current machine.')
     parser.add_argument('--disableoffline', dest='offline',
             action='store_false',
             help='disables offline time logging instead of queuing logged time')
     parser.add_argument('--hidefilenames', dest='hidefilenames',
             action='store_true',
             help='obfuscate file names; will not send file names to api')
+    parser.add_argument('--exclude', dest='exclude', action='append',
+            help='filename patterns to exclude from logging; POSIX regex '+
+                 'syntax; can be used more than once')
+    parser.add_argument('--include', dest='include', action='append',
+            help='filename patterns to log; when used in combination with '+
+                 '--exclude, files matching include will still be logged; '+
+                 'POSIX regex syntax; can be used more than once')
     parser.add_argument('--ignore', dest='ignore', action='append',
-            help='filename patterns to ignore; POSIX regex syntax; can be used more than once')
+            help=argparse.SUPPRESS)
     parser.add_argument('--logfile', dest='logfile',
             help='defaults to ~/.wakatime.log')
+    parser.add_argument('--apiurl', dest='api_url',
+            help='heartbeats api url; for debugging with a local server')
     parser.add_argument('--config', dest='config',
             help='defaults to ~/.wakatime.conf')
     parser.add_argument('--verbose', dest='verbose', action='store_true',
@@ -191,47 +205,83 @@ def parseArguments(argv):
         default_key = None
         if configs.has_option('settings', 'api_key'):
             default_key = configs.get('settings', 'api_key')
+        elif configs.has_option('settings', 'apikey'):
+            default_key = configs.get('settings', 'apikey')
         if default_key:
             args.key = default_key
         else:
             parser.error('Missing api key')
-    if not args.ignore:
-        args.ignore = []
+    if not args.exclude:
+        args.exclude = []
     if configs.has_option('settings', 'ignore'):
         try:
             for pattern in configs.get('settings', 'ignore').split("\n"):
                 if pattern.strip() != '':
-                    args.ignore.append(pattern)
+                    args.exclude.append(pattern)
+        except TypeError:
+            pass
+    if configs.has_option('settings', 'exclude'):
+        try:
+            for pattern in configs.get('settings', 'exclude').split("\n"):
+                if pattern.strip() != '':
+                    args.exclude.append(pattern)
+        except TypeError:
+            pass
+    if not args.include:
+        args.include = []
+    if configs.has_option('settings', 'include'):
+        try:
+            for pattern in configs.get('settings', 'include').split("\n"):
+                if pattern.strip() != '':
+                    args.include.append(pattern)
         except TypeError:
             pass
     if args.offline and configs.has_option('settings', 'offline'):
         args.offline = configs.getboolean('settings', 'offline')
     if not args.hidefilenames and configs.has_option('settings', 'hidefilenames'):
         args.hidefilenames = configs.getboolean('settings', 'hidefilenames')
+    if not args.proxy and configs.has_option('settings', 'proxy'):
+        args.proxy = configs.get('settings', 'proxy')
     if not args.verbose and configs.has_option('settings', 'verbose'):
         args.verbose = configs.getboolean('settings', 'verbose')
     if not args.verbose and configs.has_option('settings', 'debug'):
         args.verbose = configs.getboolean('settings', 'debug')
     if not args.logfile and configs.has_option('settings', 'logfile'):
         args.logfile = configs.get('settings', 'logfile')
+    if not args.api_url and configs.has_option('settings', 'api_url'):
+        args.api_url = configs.get('settings', 'api_url')
 
     return args, configs
 
 
-def should_ignore(fileName, patterns):
-    try:
-        for pattern in patterns:
-            try:
-                compiled = re.compile(pattern, re.IGNORECASE)
-                if compiled.search(fileName):
-                    return pattern
-            except re.error as ex:
-                log.warning(u('Regex error ({msg}) for ignore pattern: {pattern}').format(
-                    msg=u(ex),
-                    pattern=u(pattern),
-                ))
-    except TypeError:
-        pass
+def should_exclude(fileName, include, exclude):
+    if fileName is not None and fileName.strip() != '':
+        try:
+            for pattern in include:
+                try:
+                    compiled = re.compile(pattern, re.IGNORECASE)
+                    if compiled.search(fileName):
+                        return False
+                except re.error as ex:
+                    log.warning(u('Regex error ({msg}) for include pattern: {pattern}').format(
+                        msg=u(ex),
+                        pattern=u(pattern),
+                    ))
+        except TypeError:
+            pass
+        try:
+            for pattern in exclude:
+                try:
+                    compiled = re.compile(pattern, re.IGNORECASE)
+                    if compiled.search(fileName):
+                        return pattern
+                except re.error as ex:
+                    log.warning(u('Regex error ({msg}) for exclude pattern: {pattern}').format(
+                        msg=u(ex),
+                        pattern=u(pattern),
+                    ))
+        except TypeError:
+            pass
     return False
 
 
@@ -248,30 +298,43 @@ def get_user_agent(plugin):
             user_agent=user_agent,
             plugin=u(plugin),
         )
+    else:
+        user_agent = u('{user_agent} Unknown/0').format(
+            user_agent=user_agent,
+        )
     return user_agent
 
 
-def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=None,
-        timestamp=None, isWrite=None, plugin=None, offline=None,
-        hidefilenames=None, **kwargs):
-    url = 'https://wakatime.com/api/v1/heartbeats'
-    log.debug('Sending heartbeat to api at %s' % url)
+def send_heartbeat(project=None, branch=None, hostname=None, stats={}, key=None, targetFile=None,
+        timestamp=None, isWrite=None, plugin=None, offline=None, notfile=False,
+        hidefilenames=None, proxy=None, api_url=None, **kwargs):
+    """Sends heartbeat as POST request to WakaTime api server.
+    """
+
+    if not api_url:
+        api_url = 'https://wakatime.com/api/v1/heartbeats'
+    log.debug('Sending heartbeat to api at %s' % api_url)
     data = {
         'time': timestamp,
-        'file': targetFile,
+        'entity': targetFile,
+        'type': 'file',
     }
-    if hidefilenames and targetFile is not None:
-        data['file'] = data['file'].rsplit('/', 1)[-1].rsplit('\\', 1)[-1]
-        if len(data['file'].strip('.').split('.', 1)) > 1:
-            data['file'] = u('HIDDEN.{ext}').format(ext=u(data['file'].strip('.').rsplit('.', 1)[-1]))
+    if hidefilenames and targetFile is not None and not notfile:
+        data['entity'] = data['entity'].rsplit('/', 1)[-1].rsplit('\\', 1)[-1]
+        if len(data['entity'].strip('.').split('.', 1)) > 1:
+            data['entity'] = u('HIDDEN.{ext}').format(ext=u(data['entity'].strip('.').rsplit('.', 1)[-1]))
         else:
-            data['file'] = u('HIDDEN')
+            data['entity'] = u('HIDDEN')
     if stats.get('lines'):
         data['lines'] = stats['lines']
     if stats.get('language'):
         data['language'] = stats['language']
     if stats.get('dependencies'):
         data['dependencies'] = stats['dependencies']
+    if stats.get('lineno'):
+        data['lineno'] = stats['lineno']
+    if stats.get('cursorpos'):
+        data['cursorpos'] = stats['cursorpos']
     if isWrite:
         data['is_write'] = isWrite
     if project:
@@ -282,15 +345,19 @@ def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=Non
 
     # setup api request
     request_body = json.dumps(data)
-    request = Request(url=url, data=str.encode(request_body) if is_py3 else request_body)
-    request.add_header('User-Agent', get_user_agent(plugin))
-    request.add_header('Content-Type', 'application/json')
-    auth = u('Basic {key}').format(key=u(base64.b64encode(str.encode(key) if is_py3 else key)))
-    request.add_header('Authorization', auth)
-
-    ALWAYS_LOG_CODES = [
-        401,
-    ]
+    api_key = u(base64.b64encode(str.encode(key) if is_py3 else key))
+    auth = u('Basic {api_key}').format(api_key=api_key)
+    headers = {
+        'User-Agent': get_user_agent(plugin),
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Authorization': auth,
+    }
+    if hostname:
+        headers['X-Machine-Name'] = hostname
+    proxies = {}
+    if proxy:
+        proxies['https'] = proxy
 
     # add Olson timezone to request
     try:
@@ -298,68 +365,52 @@ def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=Non
     except:
         tz = None
     if tz:
-        request.add_header('TimeZone', u(tz.zone))
+        headers['TimeZone'] = u(tz.zone)
+
+    session_cache = SessionCache()
+    session = session_cache.get()
 
     # log time to api
     response = None
     try:
-        response = urlopen(request)
-    except HTTPError as exc:
+        response = session.post(api_url, data=request_body, headers=headers,
+                                 proxies=proxies)
+    except RequestException:
         exception_data = {
-            'response_code': exc.getcode(),
             sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
         }
         if log.isEnabledFor(logging.DEBUG):
             exception_data['traceback'] = traceback.format_exc()
         if offline:
-            if response is None or response.getcode() != 400:
-                queue = Queue()
-                queue.push(data, json.dumps(stats), plugin)
+            queue = Queue()
+            queue.push(data, json.dumps(stats), plugin)
             if log.isEnabledFor(logging.DEBUG):
                 log.warn(exception_data)
-            if response is not None and response.getcode() in ALWAYS_LOG_CODES:
-                log.error({
-                    'response_code': response.getcode(),
-                })
-        else:
-            log.error(exception_data)
-    except:
-        exception_data = {
-            sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
-        }
-        if log.isEnabledFor(logging.DEBUG):
-            exception_data['traceback'] = traceback.format_exc()
-        if offline:
-            if response is None or response.getcode() != 400:
-                queue = Queue()
-                queue.push(data, json.dumps(stats), plugin)
-            if 'unknown url type: https' in u(sys.exc_info()[1]):
-                log.error(exception_data)
-            elif log.isEnabledFor(logging.DEBUG):
-                log.warn(exception_data)
-            if response is not None and response.getcode() in ALWAYS_LOG_CODES:
-                log.error({
-                    'response_code': response.getcode(),
-                })
         else:
             log.error(exception_data)
     else:
-        if response is not None and response.getcode() == 201:
+        response_code = response.status_code if response is not None else None
+        response_content = response.text if response is not None else None
+        if response_code == 201:
             log.debug({
-                'response_code': response.getcode(),
+                'response_code': response_code,
             })
+            session_cache.save(session)
             return True
-        response_code = response.getcode() if response is not None else None
-        response_content = response.read() if response is not None else None
         if offline:
-            if response is None or response.getcode() != 400:
+            if response_code != 400:
                 queue = Queue()
                 queue.push(data, json.dumps(stats), plugin)
-            if log.isEnabledFor(logging.DEBUG):
-                log.warn({
-                    'response_code': response_code,
-                    'response_content': response_content,
-                })
+                if response_code == 401:
+                    log.error({
+                        'response_code': response_code,
+                        'response_content': response_content,
+                    })
+                elif log.isEnabledFor(logging.DEBUG):
+                    log.warn({
+                        'response_code': response_code,
+                        'response_content': response_content,
+                    })
             else:
                 log.error({
                     'response_code': response_code,
@@ -370,6 +421,7 @@ def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=Non
                 'response_code': response_code,
                 'response_content': response_content,
             })
+    session_cache.delete()
     return False
 
 
@@ -383,45 +435,50 @@ def main(argv=None):
 
     setup_logging(args, __version__)
 
-    ignore = should_ignore(args.targetFile, args.ignore)
-    if ignore is not False:
-        log.debug(u('File ignored because matches pattern: {pattern}').format(
-            pattern=u(ignore),
+    exclude = should_exclude(args.targetFile, args.include, args.exclude)
+    if exclude is not False:
+        log.debug(u('File not logged because matches exclude pattern: {pattern}').format(
+            pattern=u(exclude),
         ))
         return 0
 
-    if os.path.isfile(args.targetFile):
+    if os.path.isfile(args.targetFile) or args.notfile:
 
-        stats = get_file_stats(args.targetFile)
+        stats = get_file_stats(args.targetFile, notfile=args.notfile,
+                               lineno=args.lineno, cursorpos=args.cursorpos)
 
-        project = find_project(args.targetFile, configs=configs)
-        branch = None
-        project_name = args.project_name
-        if project:
-            branch = project.branch()
-            project_name = project.name()
+        project, branch = None, None
+        if not args.notfile:
+            project, branch = get_project_info(configs=configs, args=args)
 
-        if send_heartbeat(
-                project=project_name,
-                branch=branch,
-                stats=stats,
-                **vars(args)
-            ):
+        kwargs = vars(args)
+        kwargs['project'] = project
+        kwargs['branch'] = branch
+        kwargs['stats'] = stats
+        kwargs['hostname'] = args.hostname or socket.gethostname()
+
+        if send_heartbeat(**kwargs):
             queue = Queue()
             while True:
                 heartbeat = queue.pop()
                 if heartbeat is None:
                     break
-                sent = send_heartbeat(project=heartbeat['project'],
-                                   targetFile=heartbeat['file'],
-                                   timestamp=heartbeat['time'],
-                                   branch=heartbeat['branch'],
-                                   stats=json.loads(heartbeat['stats']),
-                                   key=args.key,
-                                   isWrite=heartbeat['is_write'],
-                                   plugin=heartbeat['plugin'],
-                                   offline=args.offline,
-                                   hidefilenames=args.hidefilenames)
+                sent = send_heartbeat(
+                    project=heartbeat['project'],
+                    targetFile=heartbeat['file'],
+                    timestamp=heartbeat['time'],
+                    branch=heartbeat['branch'],
+                    hostname=kwargs['hostname'],
+                    stats=json.loads(heartbeat['stats']),
+                    key=args.key,
+                    isWrite=heartbeat['is_write'],
+                    plugin=heartbeat['plugin'],
+                    offline=args.offline,
+                    hidefilenames=args.hidefilenames,
+                    notfile=args.notfile,
+                    proxy=args.proxy,
+                    api_url=args.api_url,
+                )
                 if not sent:
                     break
             return 0 # success

packages/wakatime/cli.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.cli
+    ~~~~~~~~~~~~
+
+    Command-line entry point.
+
+    :copyright: (c) 2013 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import os
+import sys
+
+
+# get path to local wakatime package
+package_folder = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# add local wakatime package to sys.path
+sys.path.insert(0, package_folder)
+
+# import local wakatime package
+try:
+    import wakatime
+except TypeError:
+    # on Windows, non-ASCII characters in import path can be fixed using
+    # the script path from sys.argv[0].
+    # More info at https://github.com/wakatime/wakatime/issues/32
+    package_folder = os.path.dirname(os.path.dirname(os.path.abspath(sys.argv[0])))
+    sys.path.insert(0, package_folder)
+    import wakatime
+
+
+if __name__ == '__main__':
+    sys.exit(wakatime.main(sys.argv))

packages/wakatime/languages/unknown.py

@@ -12,7 +12,6 @@
 import os
 
 from . import TokenParser
-from ..compat import u
 
 
 FILES = {

packages/wakatime/logger.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """
-    wakatime.log
-    ~~~~~~~~~~~~
+    wakatime.logger
+    ~~~~~~~~~~~~~~~
 
     Provides the configured logger for writing JSON to the log file.
 
@@ -30,7 +30,6 @@ class CustomEncoder(json.JSONEncoder):
         try:
             encoded = super(CustomEncoder, self).default(obj)
         except UnicodeDecodeError:
-            encoding = sys.getfilesystemencoding()
             obj = u(obj)
             encoded = super(CustomEncoder, self).default(obj)
         return encoded
@@ -38,32 +37,38 @@ class CustomEncoder(json.JSONEncoder):
 
 class JsonFormatter(logging.Formatter):
 
-    def setup(self, timestamp, isWrite, targetFile, version, plugin):
+    def setup(self, timestamp, isWrite, targetFile, version, plugin, verbose,
+              warnings=False):
         self.timestamp = timestamp
         self.isWrite = isWrite
         self.targetFile = targetFile
         self.version = version
         self.plugin = plugin
+        self.verbose = verbose
+        self.warnings = warnings
 
-    def format(self, record):
+    def format(self, record, *args):
         data = OrderedDict([
             ('now', self.formatTime(record, self.datefmt)),
-            ('version', self.version),
-            ('plugin', self.plugin),
-            ('time', self.timestamp),
-            ('isWrite', self.isWrite),
-            ('file', self.targetFile),
-            ('level', record.levelname),
-            ('message', record.msg),
         ])
+        data['version'] = self.version
+        data['plugin'] = self.plugin
+        data['time'] = self.timestamp
+        if self.verbose:
+            data['caller'] = record.pathname
+            data['lineno'] = record.lineno
+            data['isWrite'] = self.isWrite
+            data['file'] = self.targetFile
+            if not self.isWrite:
+                del data['isWrite']
+        data['level'] = record.levelname
+        data['message'] = record.getMessage() if self.warnings else record.msg
         if not self.plugin:
             del data['plugin']
-        if not self.isWrite:
-            del data['isWrite']
         return CustomEncoder().encode(data)
 
     def formatException(self, exc_info):
-        return exec_info[2].format_exc()
+        return sys.exec_info[2].format_exc()
 
 
 def set_log_level(logger, args):
@@ -84,6 +89,7 @@ def setup_logging(args, version):
             targetFile=args.targetFile,
             version=version,
             plugin=args.plugin,
+            verbose=args.verbose,
         )
         logger.handlers[0].setFormatter(formatter)
         return logger
@@ -98,7 +104,27 @@ def setup_logging(args, version):
         targetFile=args.targetFile,
         version=version,
         plugin=args.plugin,
+        verbose=args.verbose,
     )
     handler.setFormatter(formatter)
     logger.addHandler(handler)
+
+    warnings_formatter = JsonFormatter(datefmt='%Y/%m/%d %H:%M:%S %z')
+    warnings_formatter.setup(
+        timestamp=args.timestamp,
+        isWrite=args.isWrite,
+        targetFile=args.targetFile,
+        version=version,
+        plugin=args.plugin,
+        verbose=args.verbose,
+        warnings=True,
+    )
+    warnings_handler = logging.FileHandler(os.path.expanduser(logfile))
+    warnings_handler.setFormatter(warnings_formatter)
+    logging.getLogger('py.warnings').addHandler(warnings_handler)
+    try:
+        logging.captureWarnings(True)
+    except AttributeError:
+        pass  # Python >= 2.7 is needed to capture warnings
+
     return logger

packages/wakatime/offlinequeue.py

@@ -1,10 +1,9 @@
 # -*- coding: utf-8 -*-
 """
-    wakatime.queue
-    ~~~~~~~~~~~~~~
+    wakatime.offlinequeue
+    ~~~~~~~~~~~~~~~~~~~~~
 
-    Queue for offline time logging.
-    http://wakatime.com
+    Queue for saving heartbeats while offline.
 
     :copyright: (c) 2014 Alan Hamlett.
     :license: BSD, see LICENSE for more details.
@@ -51,7 +50,7 @@ class Queue(object):
         try:
             conn, c = self.connect()
             heartbeat = {
-                'file': data.get('file'),
+                'file': data.get('entity'),
                 'time': data.get('time'),
                 'project': data.get('project'),
                 'branch': data.get('branch'),