v4.0.5

HISTORY.rst

@@ -3,6 +3,86 @@ History
 -------
 
 
+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)
 +++++++++++++++++++
 

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.
 

WakaTime.py

@@ -6,7 +6,9 @@ License:     BSD, see LICENSE for more details.
 Website:     https://wakatime.com/
 ==========================================================="""
 
-__version__ = '3.0.13'
+
+__version__ = '4.0.5'
+
 
 import sublime
 import sublime_plugin
@@ -19,41 +21,31 @@ import time
 import threading
 import webbrowser
 from datetime import datetime
-from os.path import expanduser, dirname, basename, realpath, join
+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/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'))
-
-# check if we have SSL support
+sys.path.insert(0, os.path.join(PLUGIN_DIR, 'packages'))
 try:
-    import ssl
-    import socket
-    assert ssl
-    assert socket.ssl
-    assert ssl.OPENSSL_VERSION
-    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():
@@ -81,7 +73,6 @@ def prompt_api_key():
 
     default_key = ''
     try:
-        from wakatime.base import parseConfigFile
         configs = parseConfigFile()
         if configs is not None:
             if configs.has_option('settings', 'api_key'):
@@ -123,7 +114,7 @@ def python_binary():
         except:
             pass
     for path in glob.iglob('/python*'):
-        path = realpath(join(path, 'pythonw'))
+        path = os.path.realpath(os.path.join(path, 'pythonw'))
         try:
             Popen([path, '--version'])
             PYTHON_LOCATION = path
@@ -133,31 +124,76 @@ def python_binary():
     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):
-    target_file = view.file_name()
-    project = view.window().project_file_name() if hasattr(view.window(), 'project_file_name') else None
-    thread = SendActionThread(target_file, view, is_write=is_write, project=project, folders=view.window().folders())
-    thread.start()
+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
 
 
-class SendActionThread(threading.Thread):
+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()
+        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 SendHeartbeatThread(threading.Thread):
 
     def __init__(self, target_file, view, is_write=False, project=None, folders=None, force=False):
         threading.Thread.__init__(self)
@@ -170,14 +206,15 @@ 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.copy()
+        self.last_heartbeat = LAST_HEARTBEAT.copy()
+        self.cursorpos = view.sel()[0].begin() if view.sel() else None
         self.view = view
 
     def run(self):
         with self.lock:
             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']):
+                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_heartbeat(self):
@@ -194,52 +231,42 @@ class SendActionThread(threading.Thread):
         ]
         if self.is_write:
             cmd.append('--write')
-        if self.project:
-            self.project = basename(self.project).replace('.sublime-project', '', 1)
-        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)
+                print('[WakaTime] %s' % ' '.join(obfuscate_apikey(cmd)))
+            if platform.system() == 'Windows':
+                Popen(cmd, shell=False)
             else:
-                self.sent()
+                with open(os.path.join(os.path.expanduser('~'), '.wakatime.log'), 'a') as stderr:
+                    Popen(cmd, stderr=stderr)
+            self.sent()
         else:
-            python = python_binary()
-            if python:
-                cmd.insert(0, python)
-                if self.debug:
-                    print('[WakaTime] %s %s' % (python, ' '.join(cmd)))
-                if platform.system() == 'Windows':
-                    Popen(cmd, shell=False)
-                else:
-                    with open(join(expanduser('~'), '.wakatime.log'), 'a') as stderr:
-                        Popen(cmd, stderr=stderr)
-                self.sent()
-            else:
-                print('[WakaTime] Error: Unable to find python binary.')
+            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_action, 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', 'WakaTime active {0}'.format(datetime.now().strftime('%I:%M %p')))
 
-    def set_last_action(self):
-        global LAST_ACTION
-        LAST_ACTION = {
+    def set_last_heartbeat(self):
+        global LAST_HEARTBEAT
+        LAST_HEARTBEAT = {
             'file': self.target_file,
             'time': self.timestamp,
             'is_write': self.is_write,
@@ -250,11 +277,9 @@ def plugin_loaded():
     global SETTINGS
     print('[WakaTime] Initializing WakaTime plugin v%s' % __version__)
 
-    if not HAS_SSL:
-        python = python_binary()
-        if not python:
-            sublime.error_message("Unable to find Python binary!\nWakaTime needs Python to work correctly.\n\nGo to https://www.python.org/downloads")
-            return
+    if not python_binary():
+        sublime.error_message("Unable to find Python binary!\nWakaTime needs Python to work correctly.\n\nGo to https://www.python.org/downloads")
+        return
 
     SETTINGS = sublime.load_settings(SETTINGS_FILE)
     after_loaded()
@@ -273,13 +298,15 @@ 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):

WakaTime.sublime-settings

@@ -9,7 +9,7 @@
     
     // 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,

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__ = ('4', '0', '4')
+__version_info__ = ('4', '0', '12')
 __version__ = '.'.join(__version_info__)
 __author__ = 'Alan Hamlett'
 __author_email__ = 'alan@wakatime.com'

packages/wakatime/base.py

@@ -24,19 +24,19 @@ try:
 except ImportError:
     import configparser
 
-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 .logger import setup_logging
 from .offlinequeue import Queue
-from .log import setup_logging
-from .project import find_project
-from .stats import get_file_stats
 from .packages import argparse
 from .packages import simplejson as json
-from .packages import requests
 from .packages.requests.exceptions import RequestException
+from .project import find_project
+from .session_cache import SessionCache
+from .stats import get_file_stats
 try:
     from .packages import tzlocal
 except:
@@ -147,14 +147,20 @@ def parseArguments(argv):
             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_name',
-            help='optional project name; will auto-discover by default')
+    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('--disableoffline', dest='offline',
             action='store_false',
             help='disables offline time logging instead of queuing logged time')
@@ -172,6 +178,8 @@ def parseArguments(argv):
             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',
@@ -238,6 +246,8 @@ def parseArguments(argv):
         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
 
@@ -294,10 +304,14 @@ def get_user_agent(plugin):
 
 
 def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=None,
-        timestamp=None, isWrite=None, plugin=None, offline=None,
-        hidefilenames=None, notfile=False, proxy=None, **kwargs):
-    url = 'https://wakatime.com/api/v1/heartbeats'
-    log.debug('Sending heartbeat to api at %s' % url)
+        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,
@@ -314,6 +328,10 @@ def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=Non
         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:
@@ -344,10 +362,13 @@ def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=Non
     if tz:
         headers['TimeZone'] = u(tz.zone)
 
+    session_cache = SessionCache()
+    session = session_cache.get()
+
     # log time to api
     response = None
     try:
-        response = requests.post(url, data=request_body, headers=headers,
+        response = session.post(api_url, data=request_body, headers=headers,
                                  proxies=proxies)
     except RequestException:
         exception_data = {
@@ -369,6 +390,7 @@ def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=Non
             log.debug({
                 'response_code': response_code,
             })
+            session_cache.save(session)
             return True
         if offline:
             if response_code != 400:
@@ -394,6 +416,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
 
 
@@ -416,16 +439,20 @@ def main(argv=None):
 
     if os.path.isfile(args.targetFile) or args.notfile:
 
-        stats = get_file_stats(args.targetFile, notfile=args.notfile)
+        stats = get_file_stats(args.targetFile, notfile=args.notfile,
+                               lineno=args.lineno, cursorpos=args.cursorpos)
 
         project = None
         if not args.notfile:
             project = find_project(args.targetFile, configs=configs)
         branch = None
-        project_name = args.project_name
+        project_name = args.project
         if project:
             branch = project.branch()
-            project_name = project.name()
+            if not project_name:
+                project_name = project.name()
+        if not project_name:
+            project_name = args.alternate_project
 
         if send_heartbeat(
                 project=project_name,
@@ -438,18 +465,21 @@ def main(argv=None):
                 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,
-                                   notfile=args.notfile,
-                                   proxy=args.proxy)
+                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,
+                    notfile=args.notfile,
+                    proxy=args.proxy,
+                    api_url=args.api_url,
+                )
                 if not sent:
                     break
             return 0 # success

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.
 
@@ -24,6 +24,9 @@ except ImportError:
 class CustomEncoder(json.JSONEncoder):
 
     def default(self, obj):
+        if isinstance(obj, bytes):
+            obj = bytes.decode(obj)
+            return json.dumps(obj)
         try:
             encoded = super(CustomEncoder, self).default(obj)
         except UnicodeDecodeError:
@@ -34,28 +37,32 @@ 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):
         self.timestamp = timestamp
         self.isWrite = isWrite
         self.targetFile = targetFile
         self.version = version
         self.plugin = plugin
+        self.verbose = verbose
 
     def format(self, record):
         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.msg
         if not self.plugin:
             del data['plugin']
-        if not self.isWrite:
-            del data['isWrite']
         return CustomEncoder().encode(data)
 
     def formatException(self, exc_info):
@@ -70,6 +77,7 @@ def set_log_level(logger, args):
 
 
 def setup_logging(args, version):
+    logging.captureWarnings(True)
     logger = logging.getLogger('WakaTime')
     set_log_level(logger, args)
     if len(logger.handlers) > 0:
@@ -80,6 +88,7 @@ def setup_logging(args, version):
             targetFile=args.targetFile,
             version=version,
             plugin=args.plugin,
+            verbose=args.verbose,
         )
         logger.handlers[0].setFormatter(formatter)
         return logger
@@ -94,7 +103,9 @@ def setup_logging(args, version):
         targetFile=args.targetFile,
         version=version,
         plugin=args.plugin,
+        verbose=args.verbose,
     )
     handler.setFormatter(formatter)
     logger.addHandler(handler)
+    logging.getLogger('py.warnings').addHandler(handler)
     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.

packages/wakatime/packages/requests/__init__.py

@@ -42,7 +42,7 @@ is at <http://python-requests.org>.
 """
 
 __title__ = 'requests'
-__version__ = '2.5.3'
+__version__ = '2.6.0'
 __build__ = 0x020503
 __author__ = 'Kenneth Reitz'
 __license__ = 'Apache 2.0'

packages/wakatime/packages/requests/adapters.py

@@ -11,10 +11,10 @@ and maintain connections.
 import socket
 
 from .models import Response
-from .packages.urllib3 import Retry
 from .packages.urllib3.poolmanager import PoolManager, proxy_from_url
 from .packages.urllib3.response import HTTPResponse
 from .packages.urllib3.util import Timeout as TimeoutSauce
+from .packages.urllib3.util.retry import Retry
 from .compat import urlparse, basestring
 from .utils import (DEFAULT_CA_BUNDLE_PATH, get_encoding_from_headers,
                     prepend_scheme_if_needed, get_auth_from_url, urldefragauth)

packages/wakatime/packages/requests/api.py

@@ -16,7 +16,6 @@ from . import sessions
 
 def request(method, url, **kwargs):
     """Constructs and sends a :class:`Request <Request>`.
-    Returns :class:`Response <Response>` object.
 
     :param method: method for the new :class:`Request` object.
     :param url: URL for the new :class:`Request` object.
@@ -37,6 +36,8 @@ def request(method, url, **kwargs):
     :param verify: (optional) if ``True``, the SSL cert will be verified. A CA_BUNDLE path can also be provided.
     :param stream: (optional) if ``False``, the response content will be immediately downloaded.
     :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
 
     Usage::
 
@@ -55,10 +56,12 @@ def request(method, url, **kwargs):
 
 
 def get(url, **kwargs):
-    """Sends a GET request. Returns :class:`Response` object.
+    """Sends a GET request.
 
     :param url: URL for the new :class:`Request` object.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
     """
 
     kwargs.setdefault('allow_redirects', True)
@@ -66,10 +69,12 @@ def get(url, **kwargs):
 
 
 def options(url, **kwargs):
-    """Sends a OPTIONS request. Returns :class:`Response` object.
+    """Sends a OPTIONS request.
 
     :param url: URL for the new :class:`Request` object.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
     """
 
     kwargs.setdefault('allow_redirects', True)
@@ -77,10 +82,12 @@ def options(url, **kwargs):
 
 
 def head(url, **kwargs):
-    """Sends a HEAD request. Returns :class:`Response` object.
+    """Sends a HEAD request.
 
     :param url: URL for the new :class:`Request` object.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
     """
 
     kwargs.setdefault('allow_redirects', False)
@@ -88,44 +95,52 @@ def head(url, **kwargs):
 
 
 def post(url, data=None, json=None, **kwargs):
-    """Sends a POST request. Returns :class:`Response` object.
+    """Sends a POST request.
 
     :param url: URL for the new :class:`Request` object.
     :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
     :param json: (optional) json data to send in the body of the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
     """
 
     return request('post', url, data=data, json=json, **kwargs)
 
 
 def put(url, data=None, **kwargs):
-    """Sends a PUT request. Returns :class:`Response` object.
+    """Sends a PUT request.
 
     :param url: URL for the new :class:`Request` object.
     :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
     """
 
     return request('put', url, data=data, **kwargs)
 
 
 def patch(url, data=None, **kwargs):
-    """Sends a PATCH request. Returns :class:`Response` object.
+    """Sends a PATCH request.
 
     :param url: URL for the new :class:`Request` object.
     :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
     """
 
     return request('patch', url,  data=data, **kwargs)
 
 
 def delete(url, **kwargs):
-    """Sends a DELETE request. Returns :class:`Response` object.
+    """Sends a DELETE request.
 
     :param url: URL for the new :class:`Request` object.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
     """
 
     return request('delete', url, **kwargs)

packages/wakatime/packages/requests/models.py

@@ -143,12 +143,13 @@ class RequestEncodingMixin(object):
             else:
                 fn = guess_filename(v) or k
                 fp = v
-            if isinstance(fp, str):
-                fp = StringIO(fp)
-            if isinstance(fp, (bytes, bytearray)):
-                fp = BytesIO(fp)
 
-            rf = RequestField(name=k, data=fp.read(),
+            if isinstance(fp, (str, bytes, bytearray)):
+                fdata = fp
+            else:
+                fdata = fp.read()
+
+            rf = RequestField(name=k, data=fdata,
                               filename=fn, headers=fh)
             rf.make_multipart(content_type=ft)
             new_fields.append(rf)
@@ -572,7 +573,11 @@ class Response(object):
         self.cookies = cookiejar_from_dict({})
 
         #: The amount of time elapsed between sending the request
-        #: and the arrival of the response (as a timedelta)
+        #: and the arrival of the response (as a timedelta).
+        #: This property specifically measures the time taken between sending
+        #: the first byte of the request and finishing parsing the headers. It
+        #: is therefore unaffected by consuming the response content or the
+        #: value of the ``stream`` keyword argument.
         self.elapsed = datetime.timedelta(0)
 
         #: The :class:`PreparedRequest <PreparedRequest>` object to which this

packages/wakatime/packages/requests/packages/urllib3/__init__.py

@@ -4,7 +4,7 @@ urllib3 - Thread-safe connection pooling and re-using.
 
 __author__ = 'Andrey Petrov (andrey.petrov@shazow.net)'
 __license__ = 'MIT'
-__version__ = 'dev'
+__version__ = '1.10.2'
 
 
 from .connectionpool import (

packages/wakatime/packages/requests/packages/urllib3/_collections.py

@@ -20,8 +20,6 @@ from .packages.six import iterkeys, itervalues, PY3
 __all__ = ['RecentlyUsedContainer', 'HTTPHeaderDict']
 
 
-MULTIPLE_HEADERS_ALLOWED = frozenset(['cookie', 'set-cookie', 'set-cookie2'])
-
 _Null = object()
 
 
@@ -143,7 +141,10 @@ class HTTPHeaderDict(dict):
     def __init__(self, headers=None, **kwargs):
         dict.__init__(self)
         if headers is not None:
-            self.extend(headers)
+            if isinstance(headers, HTTPHeaderDict):
+                self._copy_from(headers)
+            else:
+                self.extend(headers)
         if kwargs:
             self.extend(kwargs)
 
@@ -223,11 +224,8 @@ class HTTPHeaderDict(dict):
                 vals.append(val)
             else:
                 # vals should be a tuple then, i.e. only one item so far
-                if key_lower in MULTIPLE_HEADERS_ALLOWED:
-                    # Need to convert the tuple to list for further extension
-                    _dict_setitem(self, key_lower, [vals[0], vals[1], val])
-                else:
-                    _dict_setitem(self, key_lower, new_vals)
+                # Need to convert the tuple to list for further extension
+                _dict_setitem(self, key_lower, [vals[0], vals[1], val])
 
     def extend(*args, **kwargs):
         """Generic import function for any type of header-like object.
@@ -276,14 +274,17 @@ class HTTPHeaderDict(dict):
     def __repr__(self):
         return "%s(%s)" % (type(self).__name__, dict(self.itermerged()))
 
-    def copy(self):
-        clone = type(self)()
-        for key in self:
-            val = _dict_getitem(self, key)
+    def _copy_from(self, other):
+        for key in other:
+            val = _dict_getitem(other, key)
             if isinstance(val, list):
                 # Don't need to convert tuples
                 val = list(val)
-            _dict_setitem(clone, key, val)
+            _dict_setitem(self, key, val)
+
+    def copy(self):
+        clone = type(self)()
+        clone._copy_from(self)
         return clone
 
     def iteritems(self):

packages/wakatime/packages/requests/packages/urllib3/exceptions.py

@@ -157,3 +157,8 @@ class InsecureRequestWarning(SecurityWarning):
 class SystemTimeWarning(SecurityWarning):
     "Warned when system time is suspected to be wrong"
     pass
+
+
+class InsecurePlatformWarning(SecurityWarning):
+    "Warned when certain SSL configuration is not available on a platform."
+    pass

packages/wakatime/packages/requests/packages/urllib3/util/ssl_.py

@@ -1,7 +1,7 @@
 from binascii import hexlify, unhexlify
 from hashlib import md5, sha1, sha256
 
-from ..exceptions import SSLError
+from ..exceptions import SSLError, InsecurePlatformWarning
 
 
 SSLContext = None
@@ -10,6 +10,7 @@ create_default_context = None
 
 import errno
 import ssl
+import warnings
 
 try:  # Test for SSL features
     from ssl import wrap_socket, CERT_NONE, PROTOCOL_SSLv23
@@ -69,6 +70,14 @@ except ImportError:
             self.ciphers = cipher_suite
 
         def wrap_socket(self, socket, server_hostname=None):
+            warnings.warn(
+                'A true SSLContext object is not available. This prevents '
+                'urllib3 from configuring SSL appropriately and may cause '
+                'certain SSL connections to fail. For more information, see '
+                'https://urllib3.readthedocs.org/en/latest/security.html'
+                '#insecureplatformwarning.',
+                InsecurePlatformWarning
+            )
             kwargs = {
                 'keyfile': self.keyfile,
                 'certfile': self.certfile,

packages/wakatime/packages/requests/sessions.py

@@ -171,7 +171,10 @@ class SessionRedirectMixin(object):
             except KeyError:
                 pass
 
-            extract_cookies_to_jar(prepared_request._cookies, prepared_request, resp.raw)
+            # Extract any cookies sent on the response to the cookiejar
+            # in the new request. Because we've mutated our copied prepared
+            # request, use the old one that we haven't yet touched.
+            extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
             prepared_request._cookies.update(self.cookies)
             prepared_request.prepare_cookies(prepared_request._cookies)
 

packages/wakatime/session_cache.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.session_cache
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Persist requests.Session for multiprocess SSL handshake pooling.
+
+    :copyright: (c) 2015 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+
+import logging
+import os
+import pickle
+import sys
+import traceback
+
+try:
+    import sqlite3
+    HAS_SQL = True
+except ImportError:
+    HAS_SQL = False
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'packages'))
+
+from .packages import requests
+
+
+log = logging.getLogger('WakaTime')
+
+
+class SessionCache(object):
+    DB_FILE = os.path.join(os.path.expanduser('~'), '.wakatime.db')
+
+    def connect(self):
+        conn = sqlite3.connect(self.DB_FILE)
+        c = conn.cursor()
+        c.execute('''CREATE TABLE IF NOT EXISTS session (
+            value BLOB)
+        ''')
+        return (conn, c)
+
+
+    def save(self, session):
+        """Saves a requests.Session object for the next heartbeat process.
+        """
+
+        if not HAS_SQL:
+            return
+        try:
+            conn, c = self.connect()
+            c.execute('DELETE FROM session')
+            values = {
+                'value': pickle.dumps(session),
+            }
+            c.execute('INSERT INTO session VALUES (:value)', values)
+            conn.commit()
+            conn.close()
+        except:
+            log.error(traceback.format_exc())
+
+
+    def get(self):
+        """Returns a requests.Session object.
+
+        Gets Session from sqlite3 cache or creates a new Session.
+        """
+
+        if not HAS_SQL:
+            return requests.session()
+
+        try:
+            conn, c = self.connect()
+        except:
+            log.error(traceback.format_exc())
+            return requests.session()
+
+        session = None
+        try:
+            c.execute('BEGIN IMMEDIATE')
+            c.execute('SELECT value FROM session LIMIT 1')
+            row = c.fetchone()
+            if row is not None:
+                session = pickle.loads(row[0])
+        except:
+            log.error(traceback.format_exc())
+
+        try:
+            conn.close()
+        except:
+            log.error(traceback.format_exc())
+
+        return session if session is not None else requests.session()
+
+
+    def delete(self):
+        """Clears all cached Session objects.
+        """
+
+        if not HAS_SQL:
+            return
+        try:
+            conn, c = self.connect()
+            c.execute('DELETE FROM session')
+            conn.commit()
+            conn.close()
+        except:
+            log.error(traceback.format_exc())

packages/wakatime/stats.py

@@ -86,12 +86,14 @@ def number_lines_in_file(file_name):
     return lines
 
 
-def get_file_stats(file_name, notfile=False):
+def get_file_stats(file_name, notfile=False, lineno=None, cursorpos=None):
     if notfile:
         stats = {
             'language': None,
             'dependencies': [],
             'lines': None,
+            'lineno': lineno,
+            'cursorpos': cursorpos,
         }
     else:
         language, lexer = guess_language(file_name)
@@ -101,5 +103,7 @@ def get_file_stats(file_name, notfile=False):
             'language': language,
             'dependencies': dependencies,
             'lines': number_lines_in_file(file_name),
+            'lineno': lineno,
+            'cursorpos': cursorpos,
         }
     return stats