rana-cli/wakatime/__init__.py

467 lines
16 KiB
Python
Raw Normal View History

2013-07-06 07:51:09 +00:00
# -*- coding: utf-8 -*-
"""
wakatime
~~~~~~~~
2013-12-20 15:36:32 +00:00
Common interface to the WakaTime api.
http://wakatime.com
2013-07-06 07:51:09 +00:00
:copyright: (c) 2013 Alan Hamlett.
:license: BSD, see LICENSE for more details.
"""
from __future__ import print_function
__title__ = 'wakatime'
2015-02-13 02:37:01 +00:00
__version__ = '4.0.0'
2013-07-06 07:51:09 +00:00
__author__ = 'Alan Hamlett'
__license__ = 'BSD'
2014-05-26 00:22:30 +00:00
__copyright__ = 'Copyright 2014 Alan Hamlett'
2013-07-06 07:51:09 +00:00
import base64
import logging
import os
import platform
import re
import sys
import time
import traceback
try:
import ConfigParser as configparser
except ImportError:
import configparser
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'packages'))
from .compat import u, open, is_py3
from .offlinequeue import Queue
2013-07-06 07:51:09 +00:00
from .log import setup_logging
from .project import find_project
from .stats import get_file_stats
2013-09-07 05:46:52 +00:00
from .packages import argparse
from .packages import simplejson as json
from .packages import requests
from .packages.requests.exceptions import RequestException
try:
from .packages import tzlocal
except:
2015-02-05 09:47:09 +00:00
from .packages import tzlocal3 as tzlocal
2013-07-06 07:51:09 +00:00
log = logging.getLogger('WakaTime')
2013-07-06 07:51:09 +00:00
class FileAction(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
values = os.path.realpath(values)
setattr(namespace, self.dest, values)
def upgradeConfigFile(configFile):
"""For backwards-compatibility, upgrade the existing config file
to work with configparser and rename from .wakatime.conf to .wakatime.cfg.
"""
2013-07-06 07:51:09 +00:00
if os.path.isfile(configFile):
# if upgraded cfg file already exists, don't overwrite it
return
oldConfig = os.path.join(os.path.expanduser('~'), '.wakatime.conf')
try:
configs = {
'ignore': [],
}
with open(oldConfig, 'r', encoding='utf-8') as fh:
for line in fh.readlines():
line = line.split('=', 1)
if len(line) == 2 and line[0].strip() and line[1].strip():
if line[0].strip() == 'ignore':
configs['ignore'].append(line[1].strip())
else:
configs[line[0].strip()] = line[1].strip()
with open(configFile, 'w', encoding='utf-8') as fh:
fh.write("[settings]\n")
for name, value in configs.items():
if isinstance(value, list):
fh.write("%s=\n" % name)
for item in value:
fh.write(" %s\n" % item)
else:
fh.write("%s = %s\n" % (name, value))
os.remove(oldConfig)
except IOError:
pass
2014-12-24 17:49:46 +00:00
def parseConfigFile(configFile=None):
"""Returns a configparser.SafeConfigParser instance with configs
read from the config file. Default location of the config file is
at ~/.wakatime.cfg.
"""
if not configFile:
configFile = os.path.join(os.path.expanduser('~'), '.wakatime.cfg')
upgradeConfigFile(configFile)
configs = configparser.SafeConfigParser()
try:
with open(configFile, 'r', encoding='utf-8') as fh:
try:
configs.readfp(fh)
except configparser.Error:
print(traceback.format_exc())
return None
except IOError:
print(u('Error: Could not read from config file {0}').format(u(configFile)))
return configs
def parseArguments(argv):
"""Parse command line arguments and configs from ~/.wakatime.cfg.
Command line arguments take precedence over config file settings.
Returns instances of ArgumentParser and SafeConfigParser.
"""
try:
sys.argv
except AttributeError:
sys.argv = argv
# define supported command line arguments
2013-07-06 07:51:09 +00:00
parser = argparse.ArgumentParser(
2013-12-20 15:36:32 +00:00
description='Common interface for the WakaTime api.')
2013-07-06 07:51:09 +00:00
parser.add_argument('--file', dest='targetFile', metavar='file',
action=FileAction, required=True,
help='absolute path to file for current heartbeat')
parser.add_argument('--key', dest='key',
help='your wakatime api key; uses api_key from '+
'~/.wakatime.conf by default')
2013-07-06 07:51:09 +00:00
parser.add_argument('--write', dest='isWrite',
action='store_true',
help='when set, tells api this heartbeat was triggered from '+
'writing to a file')
2013-07-06 07:51:09 +00:00
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('--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')
2014-05-26 00:14:38 +00:00
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')
2013-07-06 07:51:09 +00:00
parser.add_argument('--logfile', dest='logfile',
help='defaults to ~/.wakatime.log')
parser.add_argument('--config', dest='config',
help='defaults to ~/.wakatime.conf')
parser.add_argument('--verbose', dest='verbose', action='store_true',
help='turns on debug messages in log file')
parser.add_argument('--version', action='version', version=__version__)
# parse command line arguments
args = parser.parse_args(args=argv[1:])
# use current unix epoch timestamp by default
2013-07-06 07:51:09 +00:00
if not args.timestamp:
args.timestamp = time.time()
# parse ~/.wakatime.cfg file
configs = parseConfigFile(args.config)
if configs is None:
return args, configs
# update args from configs
2013-07-06 07:51:09 +00:00
if not args.key:
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')
2013-07-06 07:51:09 +00:00
if default_key:
args.key = default_key
else:
parser.error('Missing api key')
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.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
2014-05-26 00:14:38 +00:00
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')
return args, configs
2013-07-06 07:51:09 +00:00
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
2013-07-06 07:51:09 +00:00
def get_user_agent(plugin):
2013-07-24 03:31:36 +00:00
ver = sys.version_info
python_version = '%d.%d.%d.%s.%d' % (ver[0], ver[1], ver[2], ver[3], ver[4])
user_agent = u('wakatime/{ver} ({platform}) Python{py_ver}').format(
ver=u(__version__),
platform=u(platform.platform()),
py_ver=python_version,
)
2013-07-06 07:51:09 +00:00
if plugin:
user_agent = u('{user_agent} {plugin}').format(
user_agent=user_agent,
plugin=u(plugin),
)
else:
user_agent = u('{user_agent} Unknown/0').format(
user_agent=user_agent,
)
2013-07-06 07:51:09 +00:00
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, notfile=False, proxy=None, **kwargs):
url = 'https://wakatime.com/api/v1/heartbeats'
log.debug('Sending heartbeat to api at %s' % url)
2013-07-06 07:51:09 +00:00
data = {
'time': timestamp,
2013-07-06 07:51:09 +00:00
'file': targetFile,
}
if hidefilenames and targetFile is not None and not notfile:
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]))
else:
data['file'] = 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']
2013-07-06 07:51:09 +00:00
if isWrite:
data['is_write'] = isWrite
if project:
data['project'] = project
2013-08-15 07:09:27 +00:00
if branch:
data['branch'] = branch
2013-07-06 07:51:09 +00:00
log.debug(data)
# setup api request
request_body = json.dumps(data)
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,
}
proxies = {}
if proxy:
proxies['https'] = proxy
2013-10-01 04:55:19 +00:00
# add Olson timezone to request
try:
tz = tzlocal.get_localzone()
except:
tz = None
2013-10-01 04:55:19 +00:00
if tz:
headers['TimeZone'] = u(tz.zone)
2013-10-01 04:55:19 +00:00
# log time to api
response = None
2013-07-06 07:51:09 +00:00
try:
response = requests.post(url, data=request_body, headers=headers,
proxies=proxies)
except RequestException:
exception_data = {
sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
}
if log.isEnabledFor(logging.DEBUG):
exception_data['traceback'] = traceback.format_exc()
2014-05-26 00:14:38 +00:00
if offline:
queue = Queue()
queue.push(data, json.dumps(stats), plugin)
2014-05-26 00:14:38 +00:00
if log.isEnabledFor(logging.DEBUG):
log.warn(exception_data)
else:
log.error(exception_data)
2013-07-06 07:51:09 +00:00
else:
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_code,
})
return True
2014-05-26 00:14:38 +00:00
if offline:
if response_code != 400:
queue = Queue()
queue.push(data, json.dumps(stats), plugin)
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({
2014-12-04 08:51:18 +00:00
'response_code': response_code,
'response_content': response_content,
})
2014-05-26 00:14:38 +00:00
else:
log.error({
2014-12-04 08:51:18 +00:00
'response_code': response_code,
'response_content': response_content,
2014-05-26 00:14:38 +00:00
})
2013-07-06 07:51:09 +00:00
return False
def main(argv=None):
if not argv:
argv = sys.argv
args, configs = parseArguments(argv)
if configs is None:
return 103 # config file parsing error
2013-07-06 07:51:09 +00:00
setup_logging(args, __version__)
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) or args.notfile:
stats = get_file_stats(args.targetFile, notfile=args.notfile)
project = None
if not args.notfile:
project = find_project(args.targetFile, configs=configs)
2013-08-15 07:09:27 +00:00
branch = None
project_name = args.project_name
if project:
2013-08-15 07:09:27 +00:00
branch = project.branch()
project_name = project.name()
if send_heartbeat(
project=project_name,
branch=branch,
stats=stats,
**vars(args)
):
2014-05-26 00:14:38 +00:00
queue = Queue()
while True:
heartbeat = queue.pop()
if heartbeat is None:
2014-05-26 00:14:38 +00:00
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)
if not sent:
2014-05-26 00:14:38 +00:00
break
return 0 # success
return 102 # api error
2013-07-06 07:51:09 +00:00
else:
log.debug('File does not exist; ignoring this heartbeat.')
return 0