diff --git a/.idea/encodings.xml b/.idea/encodings.xml
index e206d70..f758959 100644
--- a/.idea/encodings.xml
+++ b/.idea/encodings.xml
@@ -1,5 +1,6 @@
-
-
-
+
+
+
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index f738178..209d2d4 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -2,8 +2,16 @@
-
+
+
+
+
+
+
+
+
+
@@ -32,212 +40,211 @@
-
-
+
+
-
-
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
-
+
-
-
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -253,42 +260,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -328,13 +299,13 @@
-
+
+
-
@@ -343,10 +314,8 @@
-
-
@@ -354,23 +323,49 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -393,16 +388,6 @@
-
-
-
@@ -477,9 +469,12 @@
+
+
+
@@ -532,12 +527,10 @@
-
-
-
+
@@ -715,12 +708,6 @@
1420801533300
-
- 1436738253915
-
-
- 1436738253916
-
1436976862583
@@ -1009,33 +996,39 @@
1443285679310
-
+
+ 1445105837799
+
+
+ 1445105837800
+
+
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -1050,7 +1043,6 @@
-
@@ -1075,202 +1067,16 @@
-
+
+
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1278,13 +1084,6 @@
-
-
-
-
-
-
-
@@ -1313,20 +1112,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1369,233 +1154,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1603,14 +1161,136 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -1644,36 +1324,284 @@
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/addon.xml b/addon.xml
index e30f66a..4f05006 100644
--- a/addon.xml
+++ b/addon.xml
@@ -1,5 +1,5 @@

-
+
diff --git a/resources/btclient/__init__.py b/resources/btclient/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/resources/btclient/argparse.py b/resources/btclient/argparse.py
deleted file mode 100644
index 5a68b70..0000000
--- a/resources/btclient/argparse.py
+++ /dev/null
@@ -1,2378 +0,0 @@
-# Author: Steven J. Bethard .
-
-"""Command-line parsing library
-
-This module is an optparse-inspired command-line parsing library that:
-
- - handles both optional and positional arguments
- - produces highly informative usage messages
- - supports parsers that dispatch to sub-parsers
-
-The following is a simple usage example that sums integers from the
-command-line and writes the result to a file::
-
- parser = argparse.ArgumentParser(
- description='sum the integers at the command line')
- parser.add_argument(
- 'integers', metavar='int', nargs='+', type=int,
- help='an integer to be summed')
- parser.add_argument(
- '--log', default=sys.stdout, type=argparse.FileType('w'),
- help='the file where the sum should be written')
- args = parser.parse_args()
- args.log.write('%s' % sum(args.integers))
- args.log.close()
-
-The module contains the following public classes:
-
- - ArgumentParser -- The main entry point for command-line parsing. As the
- example above shows, the add_argument() method is used to populate
- the parser with actions for optional and positional arguments. Then
- the parse_args() method is invoked to convert the args at the
- command-line into an object with attributes.
-
- - ArgumentError -- The exception raised by ArgumentParser objects when
- there are errors with the parser's actions. Errors raised while
- parsing the command-line are caught by ArgumentParser and emitted
- as command-line messages.
-
- - FileType -- A factory for defining types of files to be created. As the
- example above shows, instances of FileType are typically passed as
- the type= argument of add_argument() calls.
-
- - Action -- The base class for parser actions. Typically actions are
- selected by passing strings like 'store_true' or 'append_const' to
- the action= argument of add_argument(). However, for greater
- customization of ArgumentParser actions, subclasses of Action may
- be defined and passed as the action= argument.
-
- - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
- ArgumentDefaultsHelpFormatter -- Formatter classes which
- may be passed as the formatter_class= argument to the
- ArgumentParser constructor. HelpFormatter is the default,
- RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
- not to change the formatting for help text, and
- ArgumentDefaultsHelpFormatter adds information about argument defaults
- to the help.
-
-All other classes in this module are considered implementation details.
-(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
-considered public as object names -- the API of the formatter objects is
-still considered an implementation detail.)
-"""
-
-__version__ = '1.3.0' # we use our own version number independant of the
- # one in stdlib and we release this on pypi.
-
-__external_lib__ = True # to make sure the tests really test THIS lib,
- # not the builtin one in Python stdlib
-
-__all__ = [
- 'ArgumentParser',
- 'ArgumentError',
- 'ArgumentTypeError',
- 'FileType',
- 'HelpFormatter',
- 'ArgumentDefaultsHelpFormatter',
- 'RawDescriptionHelpFormatter',
- 'RawTextHelpFormatter',
- 'Namespace',
- 'Action',
- 'ONE_OR_MORE',
- 'OPTIONAL',
- 'PARSER',
- 'REMAINDER',
- 'SUPPRESS',
- 'ZERO_OR_MORE',
-]
-
-
-import copy as _copy
-import os as _os
-import re as _re
-import sys as _sys
-import textwrap as _textwrap
-
-from gettext import gettext as _
-
-try:
- set
-except NameError:
- # for python < 2.4 compatibility (sets module is there since 2.3):
- from sets import Set as set
-
-try:
- basestring
-except NameError:
- basestring = str
-
-try:
- sorted
-except NameError:
- # for python < 2.4 compatibility:
- def sorted(iterable, reverse=False):
- result = list(iterable)
- result.sort()
- if reverse:
- result.reverse()
- return result
-
-
-def _callable(obj):
- return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
-
-
-SUPPRESS = '==SUPPRESS=='
-
-OPTIONAL = '?'
-ZERO_OR_MORE = '*'
-ONE_OR_MORE = '+'
-PARSER = 'A...'
-REMAINDER = '...'
-_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
-
-# =============================
-# Utility functions and classes
-# =============================
-
-class _AttributeHolder(object):
- """Abstract base class that provides __repr__.
-
- The __repr__ method returns a string in the format::
- ClassName(attr=name, attr=name, ...)
- The attributes are determined either by a class-level attribute,
- '_kwarg_names', or by inspecting the instance __dict__.
- """
-
- def __repr__(self):
- type_name = type(self).__name__
- arg_strings = []
- for arg in self._get_args():
- arg_strings.append(repr(arg))
- for name, value in self._get_kwargs():
- arg_strings.append('%s=%r' % (name, value))
- return '%s(%s)' % (type_name, ', '.join(arg_strings))
-
- def _get_kwargs(self):
- return sorted(self.__dict__.items())
-
- def _get_args(self):
- return []
-
-
-def _ensure_value(namespace, name, value):
- if getattr(namespace, name, None) is None:
- setattr(namespace, name, value)
- return getattr(namespace, name)
-
-
-# ===============
-# Formatting Help
-# ===============
-
-class HelpFormatter(object):
- """Formatter for generating usage messages and argument help strings.
-
- Only the name of this class is considered a public API. All the methods
- provided by the class are considered an implementation detail.
- """
-
- def __init__(self,
- prog,
- indent_increment=2,
- max_help_position=24,
- width=None):
-
- # default setting for width
- if width is None:
- try:
- width = int(_os.environ['COLUMNS'])
- except (KeyError, ValueError):
- width = 80
- width -= 2
-
- self._prog = prog
- self._indent_increment = indent_increment
- self._max_help_position = max_help_position
- self._width = width
-
- self._current_indent = 0
- self._level = 0
- self._action_max_length = 0
-
- self._root_section = self._Section(self, None)
- self._current_section = self._root_section
-
- self._whitespace_matcher = _re.compile(r'\s+')
- self._long_break_matcher = _re.compile(r'\n\n\n+')
-
- # ===============================
- # Section and indentation methods
- # ===============================
- def _indent(self):
- self._current_indent += self._indent_increment
- self._level += 1
-
- def _dedent(self):
- self._current_indent -= self._indent_increment
- assert self._current_indent >= 0, 'Indent decreased below 0.'
- self._level -= 1
-
- class _Section(object):
-
- def __init__(self, formatter, parent, heading=None):
- self.formatter = formatter
- self.parent = parent
- self.heading = heading
- self.items = []
-
- def format_help(self):
- # format the indented section
- if self.parent is not None:
- self.formatter._indent()
- join = self.formatter._join_parts
- for func, args in self.items:
- func(*args)
- item_help = join([func(*args) for func, args in self.items])
- if self.parent is not None:
- self.formatter._dedent()
-
- # return nothing if the section was empty
- if not item_help:
- return ''
-
- # add the heading if the section was non-empty
- if self.heading is not SUPPRESS and self.heading is not None:
- current_indent = self.formatter._current_indent
- heading = '%*s%s:\n' % (current_indent, '', self.heading)
- else:
- heading = ''
-
- # join the section-initial newline, the heading and the help
- return join(['\n', heading, item_help, '\n'])
-
- def _add_item(self, func, args):
- self._current_section.items.append((func, args))
-
- # ========================
- # Message building methods
- # ========================
- def start_section(self, heading):
- self._indent()
- section = self._Section(self, self._current_section, heading)
- self._add_item(section.format_help, [])
- self._current_section = section
-
- def end_section(self):
- self._current_section = self._current_section.parent
- self._dedent()
-
- def add_text(self, text):
- if text is not SUPPRESS and text is not None:
- self._add_item(self._format_text, [text])
-
- def add_usage(self, usage, actions, groups, prefix=None):
- if usage is not SUPPRESS:
- args = usage, actions, groups, prefix
- self._add_item(self._format_usage, args)
-
- def add_argument(self, action):
- if action.help is not SUPPRESS:
-
- # find all invocations
- get_invocation = self._format_action_invocation
- invocations = [get_invocation(action)]
- for subaction in self._iter_indented_subactions(action):
- invocations.append(get_invocation(subaction))
-
- # update the maximum item length
- invocation_length = max([len(s) for s in invocations])
- action_length = invocation_length + self._current_indent
- self._action_max_length = max(self._action_max_length,
- action_length)
-
- # add the item to the list
- self._add_item(self._format_action, [action])
-
- def add_arguments(self, actions):
- for action in actions:
- self.add_argument(action)
-
- # =======================
- # Help-formatting methods
- # =======================
- def format_help(self):
- help = self._root_section.format_help()
- if help:
- help = self._long_break_matcher.sub('\n\n', help)
- help = help.strip('\n') + '\n'
- return help
-
- def _join_parts(self, part_strings):
- return ''.join([part
- for part in part_strings
- if part and part is not SUPPRESS])
-
- def _format_usage(self, usage, actions, groups, prefix):
- if prefix is None:
- prefix = _('usage: ')
-
- # if usage is specified, use that
- if usage is not None:
- usage = usage % dict(prog=self._prog)
-
- # if no optionals or positionals are available, usage is just prog
- elif usage is None and not actions:
- usage = '%(prog)s' % dict(prog=self._prog)
-
- # if optionals and positionals are available, calculate usage
- elif usage is None:
- prog = '%(prog)s' % dict(prog=self._prog)
-
- # split optionals from positionals
- optionals = []
- positionals = []
- for action in actions:
- if action.option_strings:
- optionals.append(action)
- else:
- positionals.append(action)
-
- # build full usage string
- format = self._format_actions_usage
- action_usage = format(optionals + positionals, groups)
- usage = ' '.join([s for s in [prog, action_usage] if s])
-
- # wrap the usage parts if it's too long
- text_width = self._width - self._current_indent
- if len(prefix) + len(usage) > text_width:
-
- # break usage into wrappable parts
- part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
- opt_usage = format(optionals, groups)
- pos_usage = format(positionals, groups)
- opt_parts = _re.findall(part_regexp, opt_usage)
- pos_parts = _re.findall(part_regexp, pos_usage)
- assert ' '.join(opt_parts) == opt_usage
- assert ' '.join(pos_parts) == pos_usage
-
- # helper for wrapping lines
- def get_lines(parts, indent, prefix=None):
- lines = []
- line = []
- if prefix is not None:
- line_len = len(prefix) - 1
- else:
- line_len = len(indent) - 1
- for part in parts:
- if line_len + 1 + len(part) > text_width:
- lines.append(indent + ' '.join(line))
- line = []
- line_len = len(indent) - 1
- line.append(part)
- line_len += len(part) + 1
- if line:
- lines.append(indent + ' '.join(line))
- if prefix is not None:
- lines[0] = lines[0][len(indent):]
- return lines
-
- # if prog is short, follow it with optionals or positionals
- if len(prefix) + len(prog) <= 0.75 * text_width:
- indent = ' ' * (len(prefix) + len(prog) + 1)
- if opt_parts:
- lines = get_lines([prog] + opt_parts, indent, prefix)
- lines.extend(get_lines(pos_parts, indent))
- elif pos_parts:
- lines = get_lines([prog] + pos_parts, indent, prefix)
- else:
- lines = [prog]
-
- # if prog is long, put it on its own line
- else:
- indent = ' ' * len(prefix)
- parts = opt_parts + pos_parts
- lines = get_lines(parts, indent)
- if len(lines) > 1:
- lines = []
- lines.extend(get_lines(opt_parts, indent))
- lines.extend(get_lines(pos_parts, indent))
- lines = [prog] + lines
-
- # join lines into usage
- usage = '\n'.join(lines)
-
- # prefix with 'usage:'
- return '%s%s\n\n' % (prefix, usage)
-
- def _format_actions_usage(self, actions, groups):
- # find group indices and identify actions in groups
- group_actions = set()
- inserts = {}
- for group in groups:
- try:
- start = actions.index(group._group_actions[0])
- except ValueError:
- continue
- else:
- end = start + len(group._group_actions)
- if actions[start:end] == group._group_actions:
- for action in group._group_actions:
- group_actions.add(action)
- if not group.required:
- if start in inserts:
- inserts[start] += ' ['
- else:
- inserts[start] = '['
- inserts[end] = ']'
- else:
- if start in inserts:
- inserts[start] += ' ('
- else:
- inserts[start] = '('
- inserts[end] = ')'
- for i in range(start + 1, end):
- inserts[i] = '|'
-
- # collect all actions format strings
- parts = []
- for i, action in enumerate(actions):
-
- # suppressed arguments are marked with None
- # remove | separators for suppressed arguments
- if action.help is SUPPRESS:
- parts.append(None)
- if inserts.get(i) == '|':
- inserts.pop(i)
- elif inserts.get(i + 1) == '|':
- inserts.pop(i + 1)
-
- # produce all arg strings
- elif not action.option_strings:
- part = self._format_args(action, action.dest)
-
- # if it's in a group, strip the outer []
- if action in group_actions:
- if part[0] == '[' and part[-1] == ']':
- part = part[1:-1]
-
- # add the action string to the list
- parts.append(part)
-
- # produce the first way to invoke the option in brackets
- else:
- option_string = action.option_strings[0]
-
- # if the Optional doesn't take a value, format is:
- # -s or --long
- if action.nargs == 0:
- part = '%s' % option_string
-
- # if the Optional takes a value, format is:
- # -s ARGS or --long ARGS
- else:
- default = action.dest.upper()
- args_string = self._format_args(action, default)
- part = '%s %s' % (option_string, args_string)
-
- # make it look optional if it's not required or in a group
- if not action.required and action not in group_actions:
- part = '[%s]' % part
-
- # add the action string to the list
- parts.append(part)
-
- # insert things at the necessary indices
- for i in sorted(inserts, reverse=True):
- parts[i:i] = [inserts[i]]
-
- # join all the action items with spaces
- text = ' '.join([item for item in parts if item is not None])
-
- # clean up separators for mutually exclusive groups
- open = r'[\[(]'
- close = r'[\])]'
- text = _re.sub(r'(%s) ' % open, r'\1', text)
- text = _re.sub(r' (%s)' % close, r'\1', text)
- text = _re.sub(r'%s *%s' % (open, close), r'', text)
- text = _re.sub(r'\(([^|]*)\)', r'\1', text)
- text = text.strip()
-
- # return the text
- return text
-
- def _format_text(self, text):
- if '%(prog)' in text:
- text = text % dict(prog=self._prog)
- text_width = self._width - self._current_indent
- indent = ' ' * self._current_indent
- return self._fill_text(text, text_width, indent) + '\n\n'
-
- def _format_action(self, action):
- # determine the required width and the entry label
- help_position = min(self._action_max_length + 2,
- self._max_help_position)
- help_width = self._width - help_position
- action_width = help_position - self._current_indent - 2
- action_header = self._format_action_invocation(action)
-
- # ho nelp; start on same line and add a final newline
- if not action.help:
- tup = self._current_indent, '', action_header
- action_header = '%*s%s\n' % tup
-
- # short action name; start on the same line and pad two spaces
- elif len(action_header) <= action_width:
- tup = self._current_indent, '', action_width, action_header
- action_header = '%*s%-*s ' % tup
- indent_first = 0
-
- # long action name; start on the next line
- else:
- tup = self._current_indent, '', action_header
- action_header = '%*s%s\n' % tup
- indent_first = help_position
-
- # collect the pieces of the action help
- parts = [action_header]
-
- # if there was help for the action, add lines of help text
- if action.help:
- help_text = self._expand_help(action)
- help_lines = self._split_lines(help_text, help_width)
- parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
- for line in help_lines[1:]:
- parts.append('%*s%s\n' % (help_position, '', line))
-
- # or add a newline if the description doesn't end with one
- elif not action_header.endswith('\n'):
- parts.append('\n')
-
- # if there are any sub-actions, add their help as well
- for subaction in self._iter_indented_subactions(action):
- parts.append(self._format_action(subaction))
-
- # return a single string
- return self._join_parts(parts)
-
- def _format_action_invocation(self, action):
- if not action.option_strings:
- metavar, = self._metavar_formatter(action, action.dest)(1)
- return metavar
-
- else:
- parts = []
-
- # if the Optional doesn't take a value, format is:
- # -s, --long
- if action.nargs == 0:
- parts.extend(action.option_strings)
-
- # if the Optional takes a value, format is:
- # -s ARGS, --long ARGS
- else:
- default = action.dest.upper()
- args_string = self._format_args(action, default)
- for option_string in action.option_strings:
- parts.append('%s %s' % (option_string, args_string))
-
- return ', '.join(parts)
-
- def _metavar_formatter(self, action, default_metavar):
- if action.metavar is not None:
- result = action.metavar
- elif action.choices is not None:
- choice_strs = [str(choice) for choice in action.choices]
- result = '{%s}' % ','.join(choice_strs)
- else:
- result = default_metavar
-
- def format(tuple_size):
- if isinstance(result, tuple):
- return result
- else:
- return (result, ) * tuple_size
- return format
-
- def _format_args(self, action, default_metavar):
- get_metavar = self._metavar_formatter(action, default_metavar)
- if action.nargs is None:
- result = '%s' % get_metavar(1)
- elif action.nargs == OPTIONAL:
- result = '[%s]' % get_metavar(1)
- elif action.nargs == ZERO_OR_MORE:
- result = '[%s [%s ...]]' % get_metavar(2)
- elif action.nargs == ONE_OR_MORE:
- result = '%s [%s ...]' % get_metavar(2)
- elif action.nargs == REMAINDER:
- result = '...'
- elif action.nargs == PARSER:
- result = '%s ...' % get_metavar(1)
- else:
- formats = ['%s' for _ in range(action.nargs)]
- result = ' '.join(formats) % get_metavar(action.nargs)
- return result
-
- def _expand_help(self, action):
- params = dict(vars(action), prog=self._prog)
- for name in list(params):
- if params[name] is SUPPRESS:
- del params[name]
- for name in list(params):
- if hasattr(params[name], '__name__'):
- params[name] = params[name].__name__
- if params.get('choices') is not None:
- choices_str = ', '.join([str(c) for c in params['choices']])
- params['choices'] = choices_str
- return self._get_help_string(action) % params
-
- def _iter_indented_subactions(self, action):
- try:
- get_subactions = action._get_subactions
- except AttributeError:
- pass
- else:
- self._indent()
- for subaction in get_subactions():
- yield subaction
- self._dedent()
-
- def _split_lines(self, text, width):
- text = self._whitespace_matcher.sub(' ', text).strip()
- return _textwrap.wrap(text, width)
-
- def _fill_text(self, text, width, indent):
- text = self._whitespace_matcher.sub(' ', text).strip()
- return _textwrap.fill(text, width, initial_indent=indent,
- subsequent_indent=indent)
-
- def _get_help_string(self, action):
- return action.help
-
-
-class RawDescriptionHelpFormatter(HelpFormatter):
- """Help message formatter which retains any formatting in descriptions.
-
- Only the name of this class is considered a public API. All the methods
- provided by the class are considered an implementation detail.
- """
-
- def _fill_text(self, text, width, indent):
- return ''.join([indent + line for line in text.splitlines(True)])
-
-
-class RawTextHelpFormatter(RawDescriptionHelpFormatter):
- """Help message formatter which retains formatting of all help text.
-
- Only the name of this class is considered a public API. All the methods
- provided by the class are considered an implementation detail.
- """
-
- def _split_lines(self, text, width):
- return text.splitlines()
-
-
-class ArgumentDefaultsHelpFormatter(HelpFormatter):
- """Help message formatter which adds default values to argument help.
-
- Only the name of this class is considered a public API. All the methods
- provided by the class are considered an implementation detail.
- """
-
- def _get_help_string(self, action):
- help = action.help
- if '%(default)' not in action.help:
- if action.default is not SUPPRESS:
- defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
- if action.option_strings or action.nargs in defaulting_nargs:
- help += ' (default: %(default)s)'
- return help
-
-
-# =====================
-# Options and Arguments
-# =====================
-
-def _get_action_name(argument):
- if argument is None:
- return None
- elif argument.option_strings:
- return '/'.join(argument.option_strings)
- elif argument.metavar not in (None, SUPPRESS):
- return argument.metavar
- elif argument.dest not in (None, SUPPRESS):
- return argument.dest
- else:
- return None
-
-
-class ArgumentError(Exception):
- """An error from creating or using an argument (optional or positional).
-
- The string value of this exception is the message, augmented with
- information about the argument that caused it.
- """
-
- def __init__(self, argument, message):
- self.argument_name = _get_action_name(argument)
- self.message = message
-
- def __str__(self):
- if self.argument_name is None:
- format = '%(message)s'
- else:
- format = 'argument %(argument_name)s: %(message)s'
- return format % dict(message=self.message,
- argument_name=self.argument_name)
-
-
-class ArgumentTypeError(Exception):
- """An error from trying to convert a command line string to a type."""
- pass
-
-
-# ==============
-# Action classes
-# ==============
-
-class Action(_AttributeHolder):
- """Information about how to convert command line strings to Python objects.
-
- Action objects are used by an ArgumentParser to represent the information
- needed to parse a single argument from one or more strings from the
- command line. The keyword arguments to the Action constructor are also
- all attributes of Action instances.
-
- Keyword Arguments:
-
- - option_strings -- A list of command-line option strings which
- should be associated with this action.
-
- - dest -- The name of the attribute to hold the created object(s)
-
- - nargs -- The number of command-line arguments that should be
- consumed. By default, one argument will be consumed and a single
- value will be produced. Other values include:
- - N (an integer) consumes N arguments (and produces a list)
- - '?' consumes zero or one arguments
- - '*' consumes zero or more arguments (and produces a list)
- - '+' consumes one or more arguments (and produces a list)
- Note that the difference between the default and nargs=1 is that
- with the default, a single value will be produced, while with
- nargs=1, a list containing a single value will be produced.
-
- - const -- The value to be produced if the option is specified and the
- option uses an action that takes no values.
-
- - default -- The value to be produced if the option is not specified.
-
- - type -- The type which the command-line arguments should be converted
- to, should be one of 'string', 'int', 'float', 'complex' or a
- callable object that accepts a single string argument. If None,
- 'string' is assumed.
-
- - choices -- A container of values that should be allowed. If not None,
- after a command-line argument has been converted to the appropriate
- type, an exception will be raised if it is not a member of this
- collection.
-
- - required -- True if the action must always be specified at the
- command line. This is only meaningful for optional command-line
- arguments.
-
- - help -- The help string describing the argument.
-
- - metavar -- The name to be used for the option's argument with the
- help string. If None, the 'dest' value will be used as the name.
- """
-
- def __init__(self,
- option_strings,
- dest,
- nargs=None,
- const=None,
- default=None,
- type=None,
- choices=None,
- required=False,
- help=None,
- metavar=None):
- self.option_strings = option_strings
- self.dest = dest
- self.nargs = nargs
- self.const = const
- self.default = default
- self.type = type
- self.choices = choices
- self.required = required
- self.help = help
- self.metavar = metavar
-
- def _get_kwargs(self):
- names = [
- 'option_strings',
- 'dest',
- 'nargs',
- 'const',
- 'default',
- 'type',
- 'choices',
- 'help',
- 'metavar',
- ]
- return [(name, getattr(self, name)) for name in names]
-
- def __call__(self, parser, namespace, values, option_string=None):
- raise NotImplementedError(_('.__call__() not defined'))
-
-
-class _StoreAction(Action):
-
- def __init__(self,
- option_strings,
- dest,
- nargs=None,
- const=None,
- default=None,
- type=None,
- choices=None,
- required=False,
- help=None,
- metavar=None):
- if nargs == 0:
- raise ValueError('nargs for store actions must be > 0; if you '
- 'have nothing to store, actions such as store '
- 'true or store const may be more appropriate')
- if const is not None and nargs != OPTIONAL:
- raise ValueError('nargs must be %r to supply const' % OPTIONAL)
- super(_StoreAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- nargs=nargs,
- const=const,
- default=default,
- type=type,
- choices=choices,
- required=required,
- help=help,
- metavar=metavar)
-
- def __call__(self, parser, namespace, values, option_string=None):
- setattr(namespace, self.dest, values)
-
-
-class _StoreConstAction(Action):
-
- def __init__(self,
- option_strings,
- dest,
- const,
- default=None,
- required=False,
- help=None,
- metavar=None):
- super(_StoreConstAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- nargs=0,
- const=const,
- default=default,
- required=required,
- help=help)
-
- def __call__(self, parser, namespace, values, option_string=None):
- setattr(namespace, self.dest, self.const)
-
-
-class _StoreTrueAction(_StoreConstAction):
-
- def __init__(self,
- option_strings,
- dest,
- default=False,
- required=False,
- help=None):
- super(_StoreTrueAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- const=True,
- default=default,
- required=required,
- help=help)
-
-
-class _StoreFalseAction(_StoreConstAction):
-
- def __init__(self,
- option_strings,
- dest,
- default=True,
- required=False,
- help=None):
- super(_StoreFalseAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- const=False,
- default=default,
- required=required,
- help=help)
-
-
-class _AppendAction(Action):
-
- def __init__(self,
- option_strings,
- dest,
- nargs=None,
- const=None,
- default=None,
- type=None,
- choices=None,
- required=False,
- help=None,
- metavar=None):
- if nargs == 0:
- raise ValueError('nargs for append actions must be > 0; if arg '
- 'strings are not supplying the value to append, '
- 'the append const action may be more appropriate')
- if const is not None and nargs != OPTIONAL:
- raise ValueError('nargs must be %r to supply const' % OPTIONAL)
- super(_AppendAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- nargs=nargs,
- const=const,
- default=default,
- type=type,
- choices=choices,
- required=required,
- help=help,
- metavar=metavar)
-
- def __call__(self, parser, namespace, values, option_string=None):
- items = _copy.copy(_ensure_value(namespace, self.dest, []))
- items.append(values)
- setattr(namespace, self.dest, items)
-
-
-class _AppendConstAction(Action):
-
- def __init__(self,
- option_strings,
- dest,
- const,
- default=None,
- required=False,
- help=None,
- metavar=None):
- super(_AppendConstAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- nargs=0,
- const=const,
- default=default,
- required=required,
- help=help,
- metavar=metavar)
-
- def __call__(self, parser, namespace, values, option_string=None):
- items = _copy.copy(_ensure_value(namespace, self.dest, []))
- items.append(self.const)
- setattr(namespace, self.dest, items)
-
-
-class _CountAction(Action):
-
- def __init__(self,
- option_strings,
- dest,
- default=None,
- required=False,
- help=None):
- super(_CountAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- nargs=0,
- default=default,
- required=required,
- help=help)
-
- def __call__(self, parser, namespace, values, option_string=None):
- new_count = _ensure_value(namespace, self.dest, 0) + 1
- setattr(namespace, self.dest, new_count)
-
-
-class _HelpAction(Action):
-
- def __init__(self,
- option_strings,
- dest=SUPPRESS,
- default=SUPPRESS,
- help=None):
- super(_HelpAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- default=default,
- nargs=0,
- help=help)
-
- def __call__(self, parser, namespace, values, option_string=None):
- parser.print_help()
- parser.exit()
-
-
-class _VersionAction(Action):
-
- def __init__(self,
- option_strings,
- version=None,
- dest=SUPPRESS,
- default=SUPPRESS,
- help="show program's version number and exit"):
- super(_VersionAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- default=default,
- nargs=0,
- help=help)
- self.version = version
-
- def __call__(self, parser, namespace, values, option_string=None):
- version = self.version
- if version is None:
- version = parser.version
- formatter = parser._get_formatter()
- formatter.add_text(version)
- parser.exit(message=formatter.format_help())
-
-
-class _SubParsersAction(Action):
-
- class _ChoicesPseudoAction(Action):
-
- def __init__(self, name, aliases, help):
- metavar = dest = name
- if aliases:
- metavar += ' (%s)' % ', '.join(aliases)
- sup = super(_SubParsersAction._ChoicesPseudoAction, self)
- sup.__init__(option_strings=[], dest=dest, help=help,
- metavar=metavar)
-
- def __init__(self,
- option_strings,
- prog,
- parser_class,
- dest=SUPPRESS,
- help=None,
- metavar=None):
-
- self._prog_prefix = prog
- self._parser_class = parser_class
- self._name_parser_map = {}
- self._choices_actions = []
-
- super(_SubParsersAction, self).__init__(
- option_strings=option_strings,
- dest=dest,
- nargs=PARSER,
- choices=self._name_parser_map,
- help=help,
- metavar=metavar)
-
- def add_parser(self, name, **kwargs):
- # set prog from the existing prefix
- if kwargs.get('prog') is None:
- kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
-
- aliases = kwargs.pop('aliases', ())
-
- # create a pseudo-action to hold the choice help
- if 'help' in kwargs:
- help = kwargs.pop('help')
- choice_action = self._ChoicesPseudoAction(name, aliases, help)
- self._choices_actions.append(choice_action)
-
- # create the parser and add it to the map
- parser = self._parser_class(**kwargs)
- self._name_parser_map[name] = parser
-
- # make parser available under aliases also
- for alias in aliases:
- self._name_parser_map[alias] = parser
-
- return parser
-
- def _get_subactions(self):
- return self._choices_actions
-
- def __call__(self, parser, namespace, values, option_string=None):
- parser_name = values[0]
- arg_strings = values[1:]
-
- # set the parser name if requested
- if self.dest is not SUPPRESS:
- setattr(namespace, self.dest, parser_name)
-
- # select the parser
- try:
- parser = self._name_parser_map[parser_name]
- except KeyError:
- tup = parser_name, ', '.join(self._name_parser_map)
- msg = _('unknown parser %r (choices: %s)' % tup)
- raise ArgumentError(self, msg)
-
- # parse all the remaining options into the namespace
- # store any unrecognized options on the object, so that the top
- # level parser can decide what to do with them
- namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
- if arg_strings:
- vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
- getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
-
-
-# ==============
-# Type classes
-# ==============
-
-class FileType(object):
- """Factory for creating file object types
-
- Instances of FileType are typically passed as type= arguments to the
- ArgumentParser add_argument() method.
-
- Keyword Arguments:
- - mode -- A string indicating how the file is to be opened. Accepts the
- same values as the builtin open() function.
- - bufsize -- The file's desired buffer size. Accepts the same values as
- the builtin open() function.
- """
-
- def __init__(self, mode='r', bufsize=None):
- self._mode = mode
- self._bufsize = bufsize
-
- def __call__(self, string):
- # the special argument "-" means sys.std{in,out}
- if string == '-':
- if 'r' in self._mode:
- return _sys.stdin
- elif 'w' in self._mode:
- return _sys.stdout
- else:
- msg = _('argument "-" with mode %r' % self._mode)
- raise ValueError(msg)
-
- # all other arguments are used as file names
- if self._bufsize:
- return open(string, self._mode, self._bufsize)
- else:
- return open(string, self._mode)
-
- def __repr__(self):
- args = [self._mode, self._bufsize]
- args_str = ', '.join([repr(arg) for arg in args if arg is not None])
- return '%s(%s)' % (type(self).__name__, args_str)
-
-# ===========================
-# Optional and Positional Parsing
-# ===========================
-
-class Namespace(_AttributeHolder):
- """Simple object for storing attributes.
-
- Implements equality by attribute names and values, and provides a simple
- string representation.
- """
-
- def __init__(self, **kwargs):
- for name in kwargs:
- setattr(self, name, kwargs[name])
-
- __hash__ = None
-
- def __eq__(self, other):
- return vars(self) == vars(other)
-
- def __ne__(self, other):
- return not (self == other)
-
- def __contains__(self, key):
- return key in self.__dict__
-
-
-class _ActionsContainer(object):
-
- def __init__(self,
- description,
- prefix_chars,
- argument_default,
- conflict_handler):
- super(_ActionsContainer, self).__init__()
-
- self.description = description
- self.argument_default = argument_default
- self.prefix_chars = prefix_chars
- self.conflict_handler = conflict_handler
-
- # set up registries
- self._registries = {}
-
- # register actions
- self.register('action', None, _StoreAction)
- self.register('action', 'store', _StoreAction)
- self.register('action', 'store_const', _StoreConstAction)
- self.register('action', 'store_true', _StoreTrueAction)
- self.register('action', 'store_false', _StoreFalseAction)
- self.register('action', 'append', _AppendAction)
- self.register('action', 'append_const', _AppendConstAction)
- self.register('action', 'count', _CountAction)
- self.register('action', 'help', _HelpAction)
- self.register('action', 'version', _VersionAction)
- self.register('action', 'parsers', _SubParsersAction)
-
- # raise an exception if the conflict handler is invalid
- self._get_handler()
-
- # action storage
- self._actions = []
- self._option_string_actions = {}
-
- # groups
- self._action_groups = []
- self._mutually_exclusive_groups = []
-
- # defaults storage
- self._defaults = {}
-
- # determines whether an "option" looks like a negative number
- self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
-
- # whether or not there are any optionals that look like negative
- # numbers -- uses a list so it can be shared and edited
- self._has_negative_number_optionals = []
-
- # ====================
- # Registration methods
- # ====================
- def register(self, registry_name, value, object):
- registry = self._registries.setdefault(registry_name, {})
- registry[value] = object
-
- def _registry_get(self, registry_name, value, default=None):
- return self._registries[registry_name].get(value, default)
-
- # ==================================
- # Namespace default accessor methods
- # ==================================
- def set_defaults(self, **kwargs):
- self._defaults.update(kwargs)
-
- # if these defaults match any existing arguments, replace
- # the previous default on the object with the new one
- for action in self._actions:
- if action.dest in kwargs:
- action.default = kwargs[action.dest]
-
- def get_default(self, dest):
- for action in self._actions:
- if action.dest == dest and action.default is not None:
- return action.default
- return self._defaults.get(dest, None)
-
-
- # =======================
- # Adding argument actions
- # =======================
- def add_argument(self, *args, **kwargs):
- """
- add_argument(dest, ..., name=value, ...)
- add_argument(option_string, option_string, ..., name=value, ...)
- """
-
- # if no positional args are supplied or only one is supplied and
- # it doesn't look like an option string, parse a positional
- # argument
- chars = self.prefix_chars
- if not args or len(args) == 1 and args[0][0] not in chars:
- if args and 'dest' in kwargs:
- raise ValueError('dest supplied twice for positional argument')
- kwargs = self._get_positional_kwargs(*args, **kwargs)
-
- # otherwise, we're adding an optional argument
- else:
- kwargs = self._get_optional_kwargs(*args, **kwargs)
-
- # if no default was supplied, use the parser-level default
- if 'default' not in kwargs:
- dest = kwargs['dest']
- if dest in self._defaults:
- kwargs['default'] = self._defaults[dest]
- elif self.argument_default is not None:
- kwargs['default'] = self.argument_default
-
- # create the action object, and add it to the parser
- action_class = self._pop_action_class(kwargs)
- if not _callable(action_class):
- raise ValueError('unknown action "%s"' % action_class)
- action = action_class(**kwargs)
-
- # raise an error if the action type is not callable
- type_func = self._registry_get('type', action.type, action.type)
- if not _callable(type_func):
- raise ValueError('%r is not callable' % type_func)
-
- return self._add_action(action)
-
- def add_argument_group(self, *args, **kwargs):
- group = _ArgumentGroup(self, *args, **kwargs)
- self._action_groups.append(group)
- return group
-
- def add_mutually_exclusive_group(self, **kwargs):
- group = _MutuallyExclusiveGroup(self, **kwargs)
- self._mutually_exclusive_groups.append(group)
- return group
-
- def _add_action(self, action):
- # resolve any conflicts
- self._check_conflict(action)
-
- # add to actions list
- self._actions.append(action)
- action.container = self
-
- # index the action by any option strings it has
- for option_string in action.option_strings:
- self._option_string_actions[option_string] = action
-
- # set the flag if any option strings look like negative numbers
- for option_string in action.option_strings:
- if self._negative_number_matcher.match(option_string):
- if not self._has_negative_number_optionals:
- self._has_negative_number_optionals.append(True)
-
- # return the created action
- return action
-
- def _remove_action(self, action):
- self._actions.remove(action)
-
- def _add_container_actions(self, container):
- # collect groups by titles
- title_group_map = {}
- for group in self._action_groups:
- if group.title in title_group_map:
- msg = _('cannot merge actions - two groups are named %r')
- raise ValueError(msg % (group.title))
- title_group_map[group.title] = group
-
- # map each action to its group
- group_map = {}
- for group in container._action_groups:
-
- # if a group with the title exists, use that, otherwise
- # create a new group matching the container's group
- if group.title not in title_group_map:
- title_group_map[group.title] = self.add_argument_group(
- title=group.title,
- description=group.description,
- conflict_handler=group.conflict_handler)
-
- # map the actions to their new group
- for action in group._group_actions:
- group_map[action] = title_group_map[group.title]
-
- # add container's mutually exclusive groups
- # NOTE: if add_mutually_exclusive_group ever gains title= and
- # description= then this code will need to be expanded as above
- for group in container._mutually_exclusive_groups:
- mutex_group = self.add_mutually_exclusive_group(
- required=group.required)
-
- # map the actions to their new mutex group
- for action in group._group_actions:
- group_map[action] = mutex_group
-
- # add all actions to this container or their group
- for action in container._actions:
- group_map.get(action, self)._add_action(action)
-
- def _get_positional_kwargs(self, dest, **kwargs):
- # make sure required is not specified
- if 'required' in kwargs:
- msg = _("'required' is an invalid argument for positionals")
- raise TypeError(msg)
-
- # mark positional arguments as required if at least one is
- # always required
- if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
- kwargs['required'] = True
- if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
- kwargs['required'] = True
-
- # return the keyword arguments with no option strings
- return dict(kwargs, dest=dest, option_strings=[])
-
- def _get_optional_kwargs(self, *args, **kwargs):
- # determine short and long option strings
- option_strings = []
- long_option_strings = []
- for option_string in args:
- # error on strings that don't start with an appropriate prefix
- if not option_string[0] in self.prefix_chars:
- msg = _('invalid option string %r: '
- 'must start with a character %r')
- tup = option_string, self.prefix_chars
- raise ValueError(msg % tup)
-
- # strings starting with two prefix characters are long options
- option_strings.append(option_string)
- if option_string[0] in self.prefix_chars:
- if len(option_string) > 1:
- if option_string[1] in self.prefix_chars:
- long_option_strings.append(option_string)
-
- # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
- dest = kwargs.pop('dest', None)
- if dest is None:
- if long_option_strings:
- dest_option_string = long_option_strings[0]
- else:
- dest_option_string = option_strings[0]
- dest = dest_option_string.lstrip(self.prefix_chars)
- if not dest:
- msg = _('dest= is required for options like %r')
- raise ValueError(msg % option_string)
- dest = dest.replace('-', '_')
-
- # return the updated keyword arguments
- return dict(kwargs, dest=dest, option_strings=option_strings)
-
- def _pop_action_class(self, kwargs, default=None):
- action = kwargs.pop('action', default)
- return self._registry_get('action', action, action)
-
- def _get_handler(self):
- # determine function from conflict handler string
- handler_func_name = '_handle_conflict_%s' % self.conflict_handler
- try:
- return getattr(self, handler_func_name)
- except AttributeError:
- msg = _('invalid conflict_resolution value: %r')
- raise ValueError(msg % self.conflict_handler)
-
- def _check_conflict(self, action):
-
- # find all options that conflict with this option
- confl_optionals = []
- for option_string in action.option_strings:
- if option_string in self._option_string_actions:
- confl_optional = self._option_string_actions[option_string]
- confl_optionals.append((option_string, confl_optional))
-
- # resolve any conflicts
- if confl_optionals:
- conflict_handler = self._get_handler()
- conflict_handler(action, confl_optionals)
-
- def _handle_conflict_error(self, action, conflicting_actions):
- message = _('conflicting option string(s): %s')
- conflict_string = ', '.join([option_string
- for option_string, action
- in conflicting_actions])
- raise ArgumentError(action, message % conflict_string)
-
- def _handle_conflict_resolve(self, action, conflicting_actions):
-
- # remove all conflicting options
- for option_string, action in conflicting_actions:
-
- # remove the conflicting option
- action.option_strings.remove(option_string)
- self._option_string_actions.pop(option_string, None)
-
- # if the option now has no option string, remove it from the
- # container holding it
- if not action.option_strings:
- action.container._remove_action(action)
-
-
-class _ArgumentGroup(_ActionsContainer):
-
- def __init__(self, container, title=None, description=None, **kwargs):
- # add any missing keyword arguments by checking the container
- update = kwargs.setdefault
- update('conflict_handler', container.conflict_handler)
- update('prefix_chars', container.prefix_chars)
- update('argument_default', container.argument_default)
- super_init = super(_ArgumentGroup, self).__init__
- super_init(description=description, **kwargs)
-
- # group attributes
- self.title = title
- self._group_actions = []
-
- # share most attributes with the container
- self._registries = container._registries
- self._actions = container._actions
- self._option_string_actions = container._option_string_actions
- self._defaults = container._defaults
- self._has_negative_number_optionals = \
- container._has_negative_number_optionals
-
- def _add_action(self, action):
- action = super(_ArgumentGroup, self)._add_action(action)
- self._group_actions.append(action)
- return action
-
- def _remove_action(self, action):
- super(_ArgumentGroup, self)._remove_action(action)
- self._group_actions.remove(action)
-
-
-class _MutuallyExclusiveGroup(_ArgumentGroup):
-
- def __init__(self, container, required=False):
- super(_MutuallyExclusiveGroup, self).__init__(container)
- self.required = required
- self._container = container
-
- def _add_action(self, action):
- if action.required:
- msg = _('mutually exclusive arguments must be optional')
- raise ValueError(msg)
- action = self._container._add_action(action)
- self._group_actions.append(action)
- return action
-
- def _remove_action(self, action):
- self._container._remove_action(action)
- self._group_actions.remove(action)
-
-
-class ArgumentParser(_AttributeHolder, _ActionsContainer):
- """Object for parsing command line strings into Python objects.
-
- Keyword Arguments:
- - prog -- The name of the program (default: sys.argv[0])
- - usage -- A usage message (default: auto-generated from arguments)
- - description -- A description of what the program does
- - epilog -- Text following the argument descriptions
- - parents -- Parsers whose arguments should be copied into this one
- - formatter_class -- HelpFormatter class for printing help messages
- - prefix_chars -- Characters that prefix optional arguments
- - fromfile_prefix_chars -- Characters that prefix files containing
- additional arguments
- - argument_default -- The default value for all arguments
- - conflict_handler -- String indicating how to handle conflicts
- - add_help -- Add a -h/-help option
- """
-
- def __init__(self,
- prog=None,
- usage=None,
- description=None,
- epilog=None,
- version=None,
- parents=[],
- formatter_class=HelpFormatter,
- prefix_chars='-',
- fromfile_prefix_chars=None,
- argument_default=None,
- conflict_handler='error',
- add_help=True):
-
- if version is not None:
- import warnings
- warnings.warn(
- """The "version" argument to ArgumentParser is deprecated. """
- """Please use """
- """"add_argument(..., action='version', version="N", ...)" """
- """instead""", DeprecationWarning)
-
- superinit = super(ArgumentParser, self).__init__
- superinit(description=description,
- prefix_chars=prefix_chars,
- argument_default=argument_default,
- conflict_handler=conflict_handler)
-
- # default setting for prog
- if prog is None:
- prog = _os.path.basename(_sys.argv[0])
-
- self.prog = prog
- self.usage = usage
- self.epilog = epilog
- self.version = version
- self.formatter_class = formatter_class
- self.fromfile_prefix_chars = fromfile_prefix_chars
- self.add_help = add_help
-
- add_group = self.add_argument_group
- self._positionals = add_group(_('positional arguments'))
- self._optionals = add_group(_('optional arguments'))
- self._subparsers = None
-
- # register types
- def identity(string):
- return string
- self.register('type', None, identity)
-
- # add help and version arguments if necessary
- # (using explicit default to override global argument_default)
- if '-' in prefix_chars:
- default_prefix = '-'
- else:
- default_prefix = prefix_chars[0]
- if self.add_help:
- self.add_argument(
- default_prefix+'h', default_prefix*2+'help',
- action='help', default=SUPPRESS,
- help=_('show this help message and exit'))
- if self.version:
- self.add_argument(
- default_prefix+'v', default_prefix*2+'version',
- action='version', default=SUPPRESS,
- version=self.version,
- help=_("show program's version number and exit"))
-
- # add parent arguments and defaults
- for parent in parents:
- self._add_container_actions(parent)
- try:
- defaults = parent._defaults
- except AttributeError:
- pass
- else:
- self._defaults.update(defaults)
-
- # =======================
- # Pretty __repr__ methods
- # =======================
- def _get_kwargs(self):
- names = [
- 'prog',
- 'usage',
- 'description',
- 'version',
- 'formatter_class',
- 'conflict_handler',
- 'add_help',
- ]
- return [(name, getattr(self, name)) for name in names]
-
- # ==================================
- # Optional/Positional adding methods
- # ==================================
- def add_subparsers(self, **kwargs):
- if self._subparsers is not None:
- self.error(_('cannot have multiple subparser arguments'))
-
- # add the parser class to the arguments if it's not present
- kwargs.setdefault('parser_class', type(self))
-
- if 'title' in kwargs or 'description' in kwargs:
- title = _(kwargs.pop('title', 'subcommands'))
- description = _(kwargs.pop('description', None))
- self._subparsers = self.add_argument_group(title, description)
- else:
- self._subparsers = self._positionals
-
- # prog defaults to the usage message of this parser, skipping
- # optional arguments and with no "usage:" prefix
- if kwargs.get('prog') is None:
- formatter = self._get_formatter()
- positionals = self._get_positional_actions()
- groups = self._mutually_exclusive_groups
- formatter.add_usage(self.usage, positionals, groups, '')
- kwargs['prog'] = formatter.format_help().strip()
-
- # create the parsers action and add it to the positionals list
- parsers_class = self._pop_action_class(kwargs, 'parsers')
- action = parsers_class(option_strings=[], **kwargs)
- self._subparsers._add_action(action)
-
- # return the created parsers action
- return action
-
- def _add_action(self, action):
- if action.option_strings:
- self._optionals._add_action(action)
- else:
- self._positionals._add_action(action)
- return action
-
- def _get_optional_actions(self):
- return [action
- for action in self._actions
- if action.option_strings]
-
- def _get_positional_actions(self):
- return [action
- for action in self._actions
- if not action.option_strings]
-
- # =====================================
- # Command line argument parsing methods
- # =====================================
- def parse_args(self, args=None, namespace=None):
- args, argv = self.parse_known_args(args, namespace)
- if argv:
- msg = _('unrecognized arguments: %s')
- self.error(msg % ' '.join(argv))
- return args
-
- def parse_known_args(self, args=None, namespace=None):
- # args default to the system args
- if args is None:
- args = _sys.argv[1:]
-
- # default Namespace built from parser defaults
- if namespace is None:
- namespace = Namespace()
-
- # add any action defaults that aren't present
- for action in self._actions:
- if action.dest is not SUPPRESS:
- if not hasattr(namespace, action.dest):
- if action.default is not SUPPRESS:
- default = action.default
- if isinstance(action.default, basestring):
- default = self._get_value(action, default)
- setattr(namespace, action.dest, default)
-
- # add any parser defaults that aren't present
- for dest in self._defaults:
- if not hasattr(namespace, dest):
- setattr(namespace, dest, self._defaults[dest])
-
- # parse the arguments and exit if there are any errors
- try:
- namespace, args = self._parse_known_args(args, namespace)
- if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
- args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
- delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
- return namespace, args
- except ArgumentError:
- err = _sys.exc_info()[1]
- self.error(str(err))
-
- def _parse_known_args(self, arg_strings, namespace):
- # replace arg strings that are file references
- if self.fromfile_prefix_chars is not None:
- arg_strings = self._read_args_from_files(arg_strings)
-
- # map all mutually exclusive arguments to the other arguments
- # they can't occur with
- action_conflicts = {}
- for mutex_group in self._mutually_exclusive_groups:
- group_actions = mutex_group._group_actions
- for i, mutex_action in enumerate(mutex_group._group_actions):
- conflicts = action_conflicts.setdefault(mutex_action, [])
- conflicts.extend(group_actions[:i])
- conflicts.extend(group_actions[i + 1:])
-
- # find all option indices, and determine the arg_string_pattern
- # which has an 'O' if there is an option at an index,
- # an 'A' if there is an argument, or a '-' if there is a '--'
- option_string_indices = {}
- arg_string_pattern_parts = []
- arg_strings_iter = iter(arg_strings)
- for i, arg_string in enumerate(arg_strings_iter):
-
- # all args after -- are non-options
- if arg_string == '--':
- arg_string_pattern_parts.append('-')
- for arg_string in arg_strings_iter:
- arg_string_pattern_parts.append('A')
-
- # otherwise, add the arg to the arg strings
- # and note the index if it was an option
- else:
- option_tuple = self._parse_optional(arg_string)
- if option_tuple is None:
- pattern = 'A'
- else:
- option_string_indices[i] = option_tuple
- pattern = 'O'
- arg_string_pattern_parts.append(pattern)
-
- # join the pieces together to form the pattern
- arg_strings_pattern = ''.join(arg_string_pattern_parts)
-
- # converts arg strings to the appropriate and then takes the action
- seen_actions = set()
- seen_non_default_actions = set()
-
- def take_action(action, argument_strings, option_string=None):
- seen_actions.add(action)
- argument_values = self._get_values(action, argument_strings)
-
- # error if this argument is not allowed with other previously
- # seen arguments, assuming that actions that use the default
- # value don't really count as "present"
- if argument_values is not action.default:
- seen_non_default_actions.add(action)
- for conflict_action in action_conflicts.get(action, []):
- if conflict_action in seen_non_default_actions:
- msg = _('not allowed with argument %s')
- action_name = _get_action_name(conflict_action)
- raise ArgumentError(action, msg % action_name)
-
- # take the action if we didn't receive a SUPPRESS value
- # (e.g. from a default)
- if argument_values is not SUPPRESS:
- action(self, namespace, argument_values, option_string)
-
- # function to convert arg_strings into an optional action
- def consume_optional(start_index):
-
- # get the optional identified at this index
- option_tuple = option_string_indices[start_index]
- action, option_string, explicit_arg = option_tuple
-
- # identify additional optionals in the same arg string
- # (e.g. -xyz is the same as -x -y -z if no args are required)
- match_argument = self._match_argument
- action_tuples = []
- while True:
-
- # if we found no optional action, skip it
- if action is None:
- extras.append(arg_strings[start_index])
- return start_index + 1
-
- # if there is an explicit argument, try to match the
- # optional's string arguments to only this
- if explicit_arg is not None:
- arg_count = match_argument(action, 'A')
-
- # if the action is a single-dash option and takes no
- # arguments, try to parse more single-dash options out
- # of the tail of the option string
- chars = self.prefix_chars
- if arg_count == 0 and option_string[1] not in chars:
- action_tuples.append((action, [], option_string))
- char = option_string[0]
- option_string = char + explicit_arg[0]
- new_explicit_arg = explicit_arg[1:] or None
- optionals_map = self._option_string_actions
- if option_string in optionals_map:
- action = optionals_map[option_string]
- explicit_arg = new_explicit_arg
- else:
- msg = _('ignored explicit argument %r')
- raise ArgumentError(action, msg % explicit_arg)
-
- # if the action expect exactly one argument, we've
- # successfully matched the option; exit the loop
- elif arg_count == 1:
- stop = start_index + 1
- args = [explicit_arg]
- action_tuples.append((action, args, option_string))
- break
-
- # error if a double-dash option did not use the
- # explicit argument
- else:
- msg = _('ignored explicit argument %r')
- raise ArgumentError(action, msg % explicit_arg)
-
- # if there is no explicit argument, try to match the
- # optional's string arguments with the following strings
- # if successful, exit the loop
- else:
- start = start_index + 1
- selected_patterns = arg_strings_pattern[start:]
- arg_count = match_argument(action, selected_patterns)
- stop = start + arg_count
- args = arg_strings[start:stop]
- action_tuples.append((action, args, option_string))
- break
-
- # add the Optional to the list and return the index at which
- # the Optional's string args stopped
- assert action_tuples
- for action, args, option_string in action_tuples:
- take_action(action, args, option_string)
- return stop
-
- # the list of Positionals left to be parsed; this is modified
- # by consume_positionals()
- positionals = self._get_positional_actions()
-
- # function to convert arg_strings into positional actions
- def consume_positionals(start_index):
- # match as many Positionals as possible
- match_partial = self._match_arguments_partial
- selected_pattern = arg_strings_pattern[start_index:]
- arg_counts = match_partial(positionals, selected_pattern)
-
- # slice off the appropriate arg strings for each Positional
- # and add the Positional and its args to the list
- for action, arg_count in zip(positionals, arg_counts):
- args = arg_strings[start_index: start_index + arg_count]
- start_index += arg_count
- take_action(action, args)
-
- # slice off the Positionals that we just parsed and return the
- # index at which the Positionals' string args stopped
- positionals[:] = positionals[len(arg_counts):]
- return start_index
-
- # consume Positionals and Optionals alternately, until we have
- # passed the last option string
- extras = []
- start_index = 0
- if option_string_indices:
- max_option_string_index = max(option_string_indices)
- else:
- max_option_string_index = -1
- while start_index <= max_option_string_index:
-
- # consume any Positionals preceding the next option
- next_option_string_index = min([
- index
- for index in option_string_indices
- if index >= start_index])
- if start_index != next_option_string_index:
- positionals_end_index = consume_positionals(start_index)
-
- # only try to parse the next optional if we didn't consume
- # the option string during the positionals parsing
- if positionals_end_index > start_index:
- start_index = positionals_end_index
- continue
- else:
- start_index = positionals_end_index
-
- # if we consumed all the positionals we could and we're not
- # at the index of an option string, there were extra arguments
- if start_index not in option_string_indices:
- strings = arg_strings[start_index:next_option_string_index]
- extras.extend(strings)
- start_index = next_option_string_index
-
- # consume the next optional and any arguments for it
- start_index = consume_optional(start_index)
-
- # consume any positionals following the last Optional
- stop_index = consume_positionals(start_index)
-
- # if we didn't consume all the argument strings, there were extras
- extras.extend(arg_strings[stop_index:])
-
- # if we didn't use all the Positional objects, there were too few
- # arg strings supplied.
- if positionals:
- self.error(_('too few arguments'))
-
- # make sure all required actions were present
- for action in self._actions:
- if action.required:
- if action not in seen_actions:
- name = _get_action_name(action)
- self.error(_('argument %s is required') % name)
-
- # make sure all required groups had one option present
- for group in self._mutually_exclusive_groups:
- if group.required:
- for action in group._group_actions:
- if action in seen_non_default_actions:
- break
-
- # if no actions were used, report the error
- else:
- names = [_get_action_name(action)
- for action in group._group_actions
- if action.help is not SUPPRESS]
- msg = _('one of the arguments %s is required')
- self.error(msg % ' '.join(names))
-
- # return the updated namespace and the extra arguments
- return namespace, extras
-
- def _read_args_from_files(self, arg_strings):
- # expand arguments referencing files
- new_arg_strings = []
- for arg_string in arg_strings:
-
- # for regular arguments, just add them back into the list
- if arg_string[0] not in self.fromfile_prefix_chars:
- new_arg_strings.append(arg_string)
-
- # replace arguments referencing files with the file content
- else:
- try:
- args_file = open(arg_string[1:])
- try:
- arg_strings = []
- for arg_line in args_file.read().splitlines():
- for arg in self.convert_arg_line_to_args(arg_line):
- arg_strings.append(arg)
- arg_strings = self._read_args_from_files(arg_strings)
- new_arg_strings.extend(arg_strings)
- finally:
- args_file.close()
- except IOError:
- err = _sys.exc_info()[1]
- self.error(str(err))
-
- # return the modified argument list
- return new_arg_strings
-
- def convert_arg_line_to_args(self, arg_line):
- return [arg_line]
-
- def _match_argument(self, action, arg_strings_pattern):
- # match the pattern for this action to the arg strings
- nargs_pattern = self._get_nargs_pattern(action)
- match = _re.match(nargs_pattern, arg_strings_pattern)
-
- # raise an exception if we weren't able to find a match
- if match is None:
- nargs_errors = {
- None: _('expected one argument'),
- OPTIONAL: _('expected at most one argument'),
- ONE_OR_MORE: _('expected at least one argument'),
- }
- default = _('expected %s argument(s)') % action.nargs
- msg = nargs_errors.get(action.nargs, default)
- raise ArgumentError(action, msg)
-
- # return the number of arguments matched
- return len(match.group(1))
-
- def _match_arguments_partial(self, actions, arg_strings_pattern):
- # progressively shorten the actions list by slicing off the
- # final actions until we find a match
- result = []
- for i in range(len(actions), 0, -1):
- actions_slice = actions[:i]
- pattern = ''.join([self._get_nargs_pattern(action)
- for action in actions_slice])
- match = _re.match(pattern, arg_strings_pattern)
- if match is not None:
- result.extend([len(string) for string in match.groups()])
- break
-
- # return the list of arg string counts
- return result
-
- def _parse_optional(self, arg_string):
- # if it's an empty string, it was meant to be a positional
- if not arg_string:
- return None
-
- # if it doesn't start with a prefix, it was meant to be positional
- if not arg_string[0] in self.prefix_chars:
- return None
-
- # if the option string is present in the parser, return the action
- if arg_string in self._option_string_actions:
- action = self._option_string_actions[arg_string]
- return action, arg_string, None
-
- # if it's just a single character, it was meant to be positional
- if len(arg_string) == 1:
- return None
-
- # if the option string before the "=" is present, return the action
- if '=' in arg_string:
- option_string, explicit_arg = arg_string.split('=', 1)
- if option_string in self._option_string_actions:
- action = self._option_string_actions[option_string]
- return action, option_string, explicit_arg
-
- # search through all possible prefixes of the option string
- # and all actions in the parser for possible interpretations
- option_tuples = self._get_option_tuples(arg_string)
-
- # if multiple actions match, the option string was ambiguous
- if len(option_tuples) > 1:
- options = ', '.join([option_string
- for action, option_string, explicit_arg in option_tuples])
- tup = arg_string, options
- self.error(_('ambiguous option: %s could match %s') % tup)
-
- # if exactly one action matched, this segmentation is good,
- # so return the parsed action
- elif len(option_tuples) == 1:
- option_tuple, = option_tuples
- return option_tuple
-
- # if it was not found as an option, but it looks like a negative
- # number, it was meant to be positional
- # unless there are negative-number-like options
- if self._negative_number_matcher.match(arg_string):
- if not self._has_negative_number_optionals:
- return None
-
- # if it contains a space, it was meant to be a positional
- if ' ' in arg_string:
- return None
-
- # it was meant to be an optional but there is no such option
- # in this parser (though it might be a valid option in a subparser)
- return None, arg_string, None
-
- def _get_option_tuples(self, option_string):
- result = []
-
- # option strings starting with two prefix characters are only
- # split at the '='
- chars = self.prefix_chars
- if option_string[0] in chars and option_string[1] in chars:
- if '=' in option_string:
- option_prefix, explicit_arg = option_string.split('=', 1)
- else:
- option_prefix = option_string
- explicit_arg = None
- for option_string in self._option_string_actions:
- if option_string.startswith(option_prefix):
- action = self._option_string_actions[option_string]
- tup = action, option_string, explicit_arg
- result.append(tup)
-
- # single character options can be concatenated with their arguments
- # but multiple character options always have to have their argument
- # separate
- elif option_string[0] in chars and option_string[1] not in chars:
- option_prefix = option_string
- explicit_arg = None
- short_option_prefix = option_string[:2]
- short_explicit_arg = option_string[2:]
-
- for option_string in self._option_string_actions:
- if option_string == short_option_prefix:
- action = self._option_string_actions[option_string]
- tup = action, option_string, short_explicit_arg
- result.append(tup)
- elif option_string.startswith(option_prefix):
- action = self._option_string_actions[option_string]
- tup = action, option_string, explicit_arg
- result.append(tup)
-
- # shouldn't ever get here
- else:
- self.error(_('unexpected option string: %s') % option_string)
-
- # return the collected option tuples
- return result
-
- def _get_nargs_pattern(self, action):
- # in all examples below, we have to allow for '--' args
- # which are represented as '-' in the pattern
- nargs = action.nargs
-
- # the default (None) is assumed to be a single argument
- if nargs is None:
- nargs_pattern = '(-*A-*)'
-
- # allow zero or one arguments
- elif nargs == OPTIONAL:
- nargs_pattern = '(-*A?-*)'
-
- # allow zero or more arguments
- elif nargs == ZERO_OR_MORE:
- nargs_pattern = '(-*[A-]*)'
-
- # allow one or more arguments
- elif nargs == ONE_OR_MORE:
- nargs_pattern = '(-*A[A-]*)'
-
- # allow any number of options or arguments
- elif nargs == REMAINDER:
- nargs_pattern = '([-AO]*)'
-
- # allow one argument followed by any number of options or arguments
- elif nargs == PARSER:
- nargs_pattern = '(-*A[-AO]*)'
-
- # all others should be integers
- else:
- nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
-
- # if this is an optional action, -- is not allowed
- if action.option_strings:
- nargs_pattern = nargs_pattern.replace('-*', '')
- nargs_pattern = nargs_pattern.replace('-', '')
-
- # return the pattern
- return nargs_pattern
-
- # ========================
- # Value conversion methods
- # ========================
- def _get_values(self, action, arg_strings):
- # for everything but PARSER args, strip out '--'
- if action.nargs not in [PARSER, REMAINDER]:
- arg_strings = [s for s in arg_strings if s != '--']
-
- # optional argument produces a default when not present
- if not arg_strings and action.nargs == OPTIONAL:
- if action.option_strings:
- value = action.const
- else:
- value = action.default
- if isinstance(value, basestring):
- value = self._get_value(action, value)
- self._check_value(action, value)
-
- # when nargs='*' on a positional, if there were no command-line
- # args, use the default if it is anything other than None
- elif (not arg_strings and action.nargs == ZERO_OR_MORE and
- not action.option_strings):
- if action.default is not None:
- value = action.default
- else:
- value = arg_strings
- self._check_value(action, value)
-
- # single argument or optional argument produces a single value
- elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
- arg_string, = arg_strings
- value = self._get_value(action, arg_string)
- self._check_value(action, value)
-
- # REMAINDER arguments convert all values, checking none
- elif action.nargs == REMAINDER:
- value = [self._get_value(action, v) for v in arg_strings]
-
- # PARSER arguments convert all values, but check only the first
- elif action.nargs == PARSER:
- value = [self._get_value(action, v) for v in arg_strings]
- self._check_value(action, value[0])
-
- # all other types of nargs produce a list
- else:
- value = [self._get_value(action, v) for v in arg_strings]
- for v in value:
- self._check_value(action, v)
-
- # return the converted value
- return value
-
- def _get_value(self, action, arg_string):
- type_func = self._registry_get('type', action.type, action.type)
- if not _callable(type_func):
- msg = _('%r is not callable')
- raise ArgumentError(action, msg % type_func)
-
- # convert the value to the appropriate type
- try:
- result = type_func(arg_string)
-
- # ArgumentTypeErrors indicate errors
- except ArgumentTypeError:
- name = getattr(action.type, '__name__', repr(action.type))
- msg = str(_sys.exc_info()[1])
- raise ArgumentError(action, msg)
-
- # TypeErrors or ValueErrors also indicate errors
- except (TypeError, ValueError):
- name = getattr(action.type, '__name__', repr(action.type))
- msg = _('invalid %s value: %r')
- raise ArgumentError(action, msg % (name, arg_string))
-
- # return the converted value
- return result
-
- def _check_value(self, action, value):
- # converted value must be one of the choices (if specified)
- if action.choices is not None and value not in action.choices:
- tup = value, ', '.join(map(repr, action.choices))
- msg = _('invalid choice: %r (choose from %s)') % tup
- raise ArgumentError(action, msg)
-
- # =======================
- # Help-formatting methods
- # =======================
- def format_usage(self):
- formatter = self._get_formatter()
- formatter.add_usage(self.usage, self._actions,
- self._mutually_exclusive_groups)
- return formatter.format_help()
-
- def format_help(self):
- formatter = self._get_formatter()
-
- # usage
- formatter.add_usage(self.usage, self._actions,
- self._mutually_exclusive_groups)
-
- # description
- formatter.add_text(self.description)
-
- # positionals, optionals and user-defined groups
- for action_group in self._action_groups:
- formatter.start_section(action_group.title)
- formatter.add_text(action_group.description)
- formatter.add_arguments(action_group._group_actions)
- formatter.end_section()
-
- # epilog
- formatter.add_text(self.epilog)
-
- # determine help from format above
- return formatter.format_help()
-
- def format_version(self):
- import warnings
- warnings.warn(
- 'The format_version method is deprecated -- the "version" '
- 'argument to ArgumentParser is no longer supported.',
- DeprecationWarning)
- formatter = self._get_formatter()
- formatter.add_text(self.version)
- return formatter.format_help()
-
- def _get_formatter(self):
- return self.formatter_class(prog=self.prog)
-
- # =====================
- # Help-printing methods
- # =====================
- def print_usage(self, file=None):
- if file is None:
- file = _sys.stdout
- self._print_message(self.format_usage(), file)
-
- def print_help(self, file=None):
- if file is None:
- file = _sys.stdout
- self._print_message(self.format_help(), file)
-
- def print_version(self, file=None):
- import warnings
- warnings.warn(
- 'The print_version method is deprecated -- the "version" '
- 'argument to ArgumentParser is no longer supported.',
- DeprecationWarning)
- self._print_message(self.format_version(), file)
-
- def _print_message(self, message, file=None):
- if message:
- if file is None:
- file = _sys.stderr
- file.write(message)
-
- # ===============
- # Exiting methods
- # ===============
- def exit(self, status=0, message=None):
- if message:
- self._print_message(message, _sys.stderr)
- _sys.exit(status)
-
- def error(self, message):
- """error(message: string)
-
- Prints a usage message incorporating the message to stderr and
- exits.
-
- If you override this in a subclass, it should not return -- it
- should either exit or raise an exception.
- """
- self.print_usage(_sys.stderr)
- self.exit(2, _('%s: error: %s\n') % (self.prog, message))
diff --git a/resources/btclient/btclient.py b/resources/btclient/btclient.py
deleted file mode 100644
index 1f0b839..0000000
--- a/resources/btclient/btclient.py
+++ /dev/null
@@ -1,828 +0,0 @@
-#!/usr/bin/env python
-import time
-import sys
-import argparse
-import os.path
-from threading import Thread
-import re
-import urlparse
-import BaseHTTPServer as htserver
-import types
-import logging
-import logging.handlers
-import traceback
-import urllib
-import SocketServer
-import socket
-import pickle
-import json
-import shutil
-
-from cachebt import CacheBT
-
-from common import AbstractFile, Hasher, BaseMonitor, BaseClient, Resolver
-
-logging.basicConfig()
-logger = logging.getLogger()
-
-
-INITIAL_TRACKERS = ['udp://tracker.openbittorrent.com:80',
- 'udp://tracker.istole.it:80',
- 'udp://open.demonii.com:80',
- 'udp://tracker.coppersurfer.tk:80',
- 'udp://tracker.leechers-paradise.org:6969',
- 'udp://exodus.desync.com:6969',
- 'udp://tracker.publicbt.com:80']
-
-VIDEO_EXTS = {'.avi': 'video/x-msvideo', '.mp4': 'video/mp4', '.mkv': 'video/x-matroska',
- '.m4v': 'video/mp4', '.mov': 'video/quicktime', '.mpg': 'video/mpeg', '.ogv': 'video/ogg',
- '.ogg': 'video/ogg', '.webm': 'video/webm', '.ts': 'video/mp2t', '.3gp': 'video/3gpp'}
-
-RANGE_RE = re.compile(r'bytes=(\d+)-')
-
-# offset from end to download first
-FILE_TAIL = 10000
-
-class x:
- lol=''
-
-def parse_range(range): # @ReservedAssignment
- if range:
- m = RANGE_RE.match(range)
- if m:
- try:
- return int(m.group(1))
- except:
- pass
- return 0
-
-
-class StreamServer(SocketServer.ThreadingMixIn, htserver.HTTPServer):
- daemon_threads = True
-
- def __init__(self, address, handler_class, tfile=None, allow_range=True, status_fn=None):
- htserver.HTTPServer.__init__(self, address, handler_class)
- self.file = tfile
- self._running = True
- self.allow_range = allow_range
- self.status_fn = status_fn
-
- def stop(self):
- self._running = False
-
- def set_file(self, f):
- self.file = f
-
- def serve(self, w):
- while self._running:
- try:
- self.handle_request()
- time.sleep(w)
- except Exception, e:
- print >> sys.stderr, str(e)
-
- def run(self):
- self.timeout = 0.5
- t = Thread(target=self.serve, args=[self.timeout], name='HTTP Server')
- t.daemon = True
- t.start()
-
- def handle_error(self, request, client_address):
- """Handle an error gracefully. May be overridden.
-
- The default is to print a traceback and continue.
-
- """
- _, e, _ = sys.exc_info()
- if isinstance(e, socket.error) and e.errno == 32:
- logger.debug("Socket disconnect for client %s", client_address)
- # pprint.pprint(e)
- else:
- logger.exception("HTTP Server Error")
- traceback.print_exc()
-
-
-class BTFileHandler(htserver.BaseHTTPRequestHandler):
- protocol_version = 'HTTP/1.1'
-
- def do_GET(self):
- if self.do_HEAD(only_header=False):
- with self.server.file.create_cursor(self._offset) as f:
- send_something = False
- while True:
- buf = f.read(1024)
- if not send_something and logger.level <= logging.DEBUG:
- logger.debug('Start sending data')
- send_something = True
- if buf:
- self.wfile.write(buf)
- else:
- if logger.level <= logging.DEBUG:
- logger.debug('Finished sending data')
- break
-
- def _file_info(self):
- size = self.server.file.size
- ext = os.path.splitext(self.server.file.path)[1]
- mime = (self.server.file.mime if hasattr(self.server.file, 'mime') else None) or VIDEO_EXTS.get(ext)
- if not mime:
- mime = 'application/octet-stream'
- return size, mime
-
- def do_HEAD(self, only_header=True):
- parsed_url = urlparse.urlparse(self.path)
- if parsed_url.path == "/status" and self.server.status_fn:
- s = self.server.status_fn()
- status = json.dumps(s)
- self.send_response(200, 'OK')
- self.send_header('Content-Type', 'application/json')
- self.send_header('Content-Length', len(status))
- self._finish_header(only_header)
- if not only_header:
- self.wfile.write(status)
- return False
-
- elif self.server.file and urllib.unquote(parsed_url.path) == '/' + self.server.file.path:
- self._offset = 0
- size, mime = self._file_info()
- range = None # @ReservedAssignment
- if self.server.allow_range:
- range = parse_range(self.headers.get('Range', None)) # @ReservedAssignment
- if range not in [None, False]:
- self._offset = range
- range = (range, size - 1, size) # @ReservedAssignment
- logger.debug('Request range %s - (header is %s', range, self.headers.get('Range', None))
- self.send_resp_header(mime, size, range, only_header)
- return True
-
- else:
- logger.error('Requesting wrong path %s, but file is %s', parsed_url.path, '/' + self.server.file.path)
- self.send_error(404, 'Not Found')
-
- def send_resp_header(self, cont_type, cont_length, range=False, only_header=False): # @ReservedAssignment
- logger.debug('range is %s'% str(range))
- if self.server.allow_range and range not in [None, False]:
- self.send_response(206, 'Partial Content')
- else:
- self.send_response(200, 'OK')
- self.send_header('Content-Type', cont_type)
- self.send_header('transferMode.dlna.org', 'Streaming')
- self.send_header('contentFeatures.dlna.org',
- 'DLNA.ORG_OP=01;DLNA.ORG_CI=0;DLNA.ORG_FLAGS=01700000000000000000000000000000')
- if self.server.allow_range:
- self.send_header('Accept-Ranges', 'bytes')
- else:
- self.send_header('Accept-Ranges', 'none')
- if self.server.allow_range and range not in [None, False]:
- if isinstance(range, (types.TupleType, types.ListType)) and len(range) == 3:
- self.send_header('Content-Range', 'bytes %d-%d/%d' % range)
- self.send_header('Content-Length', range[1] - range[0] + 1)
- else:
- raise ValueError('Invalid range value')
- else:
- self.send_header('Content-Range', 'bytes %d-%d/%d' % (range, cont_length-1, cont_length))
- self.send_header('Content-Length', cont_length)
- self._finish_header(only_header)
-
- def _finish_header(self, only_header):
- self.send_header('Connection', 'close')
- if not only_header: self.end_headers()
-
- def log_message(self, format, *args): # @ReservedAssignment
- logger.debug(format, *args)
-
-
-class BTClient(BaseClient):
- def __init__(self, path_to_store,
- args=None,
- state_file="",
- lt=None,
- **kwargs):
- super(BTClient, self).__init__(path_to_store, args=args)
- self.lt=lt
- self._cache = CacheBT(path_to_store, self.lt)
- self._torrent_params = {'save_path': path_to_store,
- 'storage_mode': self.lt.storage_mode_t.storage_mode_sparse
- }
- if not state_file:
- state_file=os.path.join(path_to_store,'.btclient_state')
- self._state_file = os.path.expanduser(state_file)
- self._ses = self.lt.session()
- if os.path.exists(self._state_file):
- with open(self._state_file) as f:
- state = pickle.load(f)
- self._ses.load_state(state)
- # self._ses.set_alert_mask(self.lt.alert.category_t.progress_notification)
- if args:
- s = self._ses.get_settings()
- s['download_rate_limit'] = int(round(args.bt_download_limit * 1024))
- s['upload_rate_limit'] = int(round(args.bt_upload_limit * 1024))
- self._ses.set_settings(s)
- self._ses.listen_on(args.listen_port_min, args.listen_port_max)
- self.content_id=args.content_id
- else:
- self._ses.listen_on(6881, 6891)
- self._start_services()
- self._th = None
-
- self._monitor.add_listener(self._check_ready)
- self._dispatcher = BTClient.Dispatcher(self, lt=self.lt)
- self._dispatcher.add_listener(self._update_ready_pieces)
- self._hash = None
- self._url = None
-
- if args and args.debug_log and args.trace:
- self.add_monitor_listener(self.debug_download_queue)
- self.add_dispatcher_listener(self.debug_alerts)
-
- @property
- def is_file_complete(self):
- pcs = self._th.status().pieces[self._file.first_piece:self._file.last_piece + 1]
- return all(pcs)
-
- def _update_ready_pieces(self, alert_type, alert):
- if alert_type == 'read_piece_alert' and self._file:
- self._file.update_piece(alert.piece, alert.buffer)
-
- def _check_ready(self, s, **kwargs):
- if s.state in [3, 4, 5] and not self._file and s.progress > 0:
- try:
- self._meta_ready(self._th.torrent_file())
- except:
- self._meta_ready(self._th.get_torrent_info())
- logger.debug('Got torrent metadata and start download')
- self.hash = True
- self.hash = Hasher(self._file, self._on_file_ready)
-
- def _choose_file(self, files, i):
- if not i and i!=0:
- videos = filter(lambda f: VIDEO_EXTS.has_key(os.path.splitext(f.path)[1]), files)
- if not videos:
- raise Exception('No video files in torrent')
- f = sorted(videos, key=lambda f: f.size)[-1]
- i = files.index(f)
- f.index = i
- f=files[i]
- f.index = i
- return f
-
- def _meta_ready(self, meta):
- fs = meta.files()
- files = fs if isinstance(fs, list) else [fs.at(i) for i in xrange(fs.num_files())]
- f = self._choose_file(files, self.content_id)
- fmap = meta.map_file(f.index, 0, 1)
- self._file = BTFile(f.path, self._base_path, f.index, f.size, fmap, meta.piece_length(),
- self.prioritize_piece)
-
- self.prioritize_file()
- print ('File %s pieces (pc=%d, ofs=%d, sz=%d), total_pieces=%d, pc_length=%d' %
- (f.path, fmap.piece, fmap.start, fmap.length,
- meta.num_pieces(), meta.piece_length()))
-
- try:
- meta = self._th.torrent_file()
- except:
- meta=self._th.get_torrent_info()
- self._cache.file_complete(meta,
- self._url if self._url and self._url.startswith('http') else None)
-
- def prioritize_piece(self, pc, idx):
- piece_duration = 1000
- min_deadline = 2000
- dl = idx * piece_duration + min_deadline
- self._th.set_piece_deadline(pc, dl, self.lt.deadline_flags.alert_when_available)
- logger.debug("Set deadline %d for piece %d", dl, pc)
-
- # we do not need to download pieces that are lower then current index, but last two pieces are special because players sometime look at end of file
- if idx == 0 and (self._file.last_piece - pc) > 2:
- for i in xrange(pc - 1):
- self._th.piece_priority(i, 0)
- self._th.reset_piece_deadline(i)
-
- def prioritize_file(self):
- try:
- meta = self._th.torrent_file()
- except:
- meta=self._th.get_torrent_info()
- priorities = [1 if i >= self._file.first_piece and i <= self.file.last_piece else 0 \
- for i in xrange(meta.num_pieces())]
- self._th.prioritize_pieces(priorities)
-
- def encrypt(self):
- # Encryption settings
- print 'Encryption enabling...'
- try:
- encryption_settings = self.lt.pe_settings()
- encryption_settings.out_enc_policy = self.lt.enc_policy(self.lt.enc_policy.forced)
- encryption_settings.in_enc_policy = self.lt.enc_policy(self.lt.enc_policy.forced)
- encryption_settings.allowed_enc_level = self.lt.enc_level.both
- encryption_settings.prefer_rc4 = True
- self._ses.set_pe_settings(encryption_settings)
- print 'Encryption on!'
- except Exception, e:
- print 'Encryption failed! Exception: ' + str(e)
- pass
-
- @property
- def unique_file_id(self):
- try:
- meta = self._th.torrent_file()
- except:
- meta=self._th.get_torrent_info()
- return str(meta.info_hash())
-
- @property
- def pieces(self):
- return self._th.status().pieces
-
- def add_dispatcher_listener(self, cb):
- self._dispatcher.add_listener(cb)
-
- def remove_dispacher_listener(self, cb):
- self._dispatcher.remove_listener(cb)
-
- def remove_all_dispatcher_listeners(self):
- self._dispatcher.remove_all_listeners()
-
- def info_from_file(self, uri):
- if os.access(uri, os.R_OK):
- e = self.lt.bdecode(open(uri, 'rb').read())
- info = self.lt.torrent_info(e)
- tp = {'ti': info}
- resume_data = self._cache.get_resume(info_hash=str(info.info_hash()))
- if resume_data:
- tp['resume_data'] = resume_data
- return tp
- raise ValueError('Invalid torrent path %s' % uri)
-
- def start_url(self, uri):
- if self._th:
- raise Exception('Torrent is already started')
-
- if uri.startswith('http://') or uri.startswith('https://'):
- self._url = uri
- stored = self._cache.get_torrent(url=uri)
- if stored:
- tp = self.info_from_file(stored)
- else:
- tp = {'url': uri}
- resume_data = self._cache.get_resume(url=uri)
- if resume_data:
- tp['resume_data'] = resume_data
- elif uri.startswith('magnet:'):
- self._url = uri
- stored = self._cache.get_torrent(info_hash=CacheBT.hash_from_magnet(uri))
- if stored:
- tp = self.info_from_file(stored)
- else:
- tp = {'url': uri}
- resume_data = self._cache.get_resume(info_hash=CacheBT.hash_from_magnet(uri))
- if resume_data:
- tp['resume_data'] = resume_data
- elif os.path.isfile(uri):
- tp = self.info_from_file(uri)
- else:
- raise ValueError("Invalid torrent %s" % uri)
-
- tp.update(self._torrent_params)
- self._th = self._ses.add_torrent(tp)
- for tr in INITIAL_TRACKERS:
- self._th.add_tracker({'url': tr})
- self._th.set_sequential_download(True)
- time.sleep(1)
- self._th.force_dht_announce()
-
- self._monitor.start()
- self._dispatcher.do_start(self._th, self._ses)
-
- def stop(self):
- BaseClient.stop(self)(self)
- self._dispatcher.stop()
- self._dispatcher.join()
-
- def _start_services(self):
- self._ses.add_dht_router('router.bittorrent.com', 6881)
- self._ses.add_dht_router('router.utorrent.com', 6881)
- self._ses.add_dht_router('router.bitcomet.com', 6881)
- self._ses.start_dht()
- self._ses.start_lsd()
- self._ses.start_upnp()
- self._ses.start_natpmp()
-
- def _stop_services(self):
- self._ses.stop_natpmp()
- self._ses.stop_upnp()
- self._ses.stop_lsd()
- self._ses.stop_dht()
-
- def save_state(self):
- state = self._ses.save_state()
- with open(self._state_file, 'wb') as f:
- pickle.dump(state, f)
-
- def save_resume(self):
- if self._th.need_save_resume_data() and self._th.is_valid() and self._th.status().has_metadata:
- r = BTClient.ResumeData(self)
- start = time.time()
- while (time.time() - start) <= 5:
- if r.data or r.failed:
- break
- time.sleep(0.1)
- if r.data:
- logger.debug('Savig fast resume data')
- self._cache.save_resume(self.unique_file_id, self.lt.bencode(r.data))
- else:
- logger.warn('Fast resume data not available')
-
- def close(self):
- self.remove_all_dispatcher_listeners()
- self._monitor.stop()
- self._cache.close()
- if self._ses:
- self._ses.pause()
- if self._th:
- self.save_resume()
- self.save_state()
- self._stop_services()
- try:
- self._ses.remove_torrent(self._th)
- except:
- print 'RuntimeError: invalid torrent handle used'
- BaseClient.close(self)
-
- @property
- def status(self):
- if self._th:
- s = self._th.status()
- if self._file:
- pieces = s.pieces[self._file.first_piece:self._file.last_piece]
- if len(pieces)>0:
- progress = float(sum(pieces)) / len(pieces)
- else:
- progress = 0
- else:
- progress = 0
- size = self._file.size if self._file else 0
- s.desired_rate = self._file.byte_rate if self._file and progress > 0.003 else 0
- s.progress_file = progress
- s.file_size = size
- return s
-
- class ResumeData(object):
- def __init__(self, client):
- self.data = None
- self.failed = False
- client.add_dispatcher_listener(self._process_alert)
- client._th.save_resume_data()
-
- def _process_alert(self, t, alert):
- if t == 'save_resume_data_failed_alert':
- logger.debug('Fast resume data generation failed')
- self.failed = True
- elif t == 'save_resume_data_alert':
- self.data = alert.resume_data
-
- class Dispatcher(BaseMonitor):
- def __init__(self, client, lt=None):
- super(BTClient.Dispatcher, self).__init__(client, name='Torrent Events Dispatcher')
- self.lt=lt
-
- def do_start(self, th, ses):
- self._th = th
- self._ses = ses
- self.start()
-
- def run(self):
- if not self._ses:
- raise Exception('Invalid state, session is not initialized')
-
- while (self._running):
- a = self._ses.wait_for_alert(1000)
- if a:
- alerts = self._ses.pop_alerts()
- for alert in alerts:
- with self._lock:
- for cb in self._listeners:
- if "udp_error_alert" not in self.lt.alert.what(alert):
- cb(self.lt.alert.what(alert), alert)
-
- STATE_STR = ['queued', 'checking', 'downloading metadata',
- 'downloading', 'finished', 'seeding', 'allocating', 'checking fastresume']
-
- def print_status(self, s, client):
- if self._th:
-
- state_str = ['queued', 'checking', 'downloading metadata',
- 'downloading', 'finished', 'seeding', 'allocating', 'checking fastresume']
- print('[%s] %.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s' %
- (self.lt.version, s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000,
- s.num_peers, state_str[s.state]))
-
- def get_normalized_status(self):
- s = self.status
- if self._file:
- pieces = s.pieces[self._file.first_piece: self._file.last_piece + 1]
- downloaded = reduce(lambda s, x: s + (x and 1 or 0) * self._file.piece_size, pieces[:-1], 0)
- if pieces[-1]:
- rem = self._file.size % self._file.piece_size
- downloaded += rem if rem else self._file.piece_size
- else:
- downloaded = 0
- return {'source_type': 'bittorrent',
- 'state': BTClient.STATE_STR[s.state],
- 'downloaded': downloaded,
- 'total_size': s.file_size,
- 'download_rate': s.download_rate,
- 'upload_rate': s.upload_rate,
- 'desired_rate': s.desired_rate,
- 'piece_size': self._file.piece_size if self._file else 0,
- 'progress': s.progress_file,
- # BT specific
- 'seeds_connected': s.num_seeds,
- 'seeds_total': s.num_complete,
- 'peers_connected': s.num_peers,
- 'peers_total': s.num_incomplete,
- 'num_pieces': s.num_pieces,
-
- }
-
- def debug_download_queue(self, s, client):
- if s.state != 3:
- return
- download_queue = self._th.get_download_queue()
- if self.file:
- first = self.file.first_piece
- else:
- first = 0
- q = map(lambda x: x['piece_index'] + first, download_queue)
- logger.debug('Download queue: %s', q)
-
- def debug_alerts(self, type, alert):
- logger.debug("Alert %s - %s", type, alert)
-
-
-class BTFile(AbstractFile):
- def __init__(self, path, base, index, size, fmap, piece_size, prioritize_fn):
- AbstractFile.__init__(self, path, base, size, piece_size)
- self.index = index
- self.first_piece = fmap.piece
- self.last_piece = self.first_piece + max((size - 1 + fmap.start), 0) // piece_size
- self.offset = fmap.start
- self._prioritize_fn = prioritize_fn
-
- def prioritize_piece(self, n, idx):
- self._prioritize_fn(n, idx)
-
-
-class LangAction(argparse.Action):
- def __init__(self, option_strings, dest, nargs=None, **kwargs):
- if nargs is not None:
- raise ValueError("nargs not allowed")
- super(LangAction, self).__init__(option_strings, dest, **kwargs)
-
- def __call__(self, parser, namespace, values, option_string=None):
- if len(values) != 3:
- raise ValueError('subtitles language should be 3 letters code')
- setattr(namespace, self.dest, values)
-
-
-def main(args=None):
- #from argparse import Namespace
- #args=Namespace(bt_download_limit=0,
- # bt_upload_limit=0,
- # choose_subtitles=False,
- # clear_older=0,
- # debug_log='D:\\log.txt',
- # delete_on_finish=True,#Flase,
- # directory='D:\\',
- # listen_port_max=6891,
- # listen_port_min=6881,
- # no_resume=False,
- # player='vlc',#kodi
- # port=5001,
- # print_pieces=False,
- # quiet=False,
- # stdin=False,
- # stream=False,
- # subtitles=None,
- # trace=True,
- # url='D:\\ntest.torrent')
- if not args:
- p = argparse.ArgumentParser()
- p.add_argument("url", help="Torrent file, link to file or magnet link")
- p.add_argument("-d", "--directory", default="./", help="directory to save download files")
- p.add_argument("-p", "--player", default="mplayer", choices=["mplayer", "vlc"], help="Video player")
- p.add_argument("--port", type=int, default=5001, help="Port for http server")
- p.add_argument("--debug-log", default='', help="File for debug logging")
- p.add_argument("--stdin", action='store_true', help='sends video to player via stdin (no seek then)')
- p.add_argument("--print-pieces", action="store_true",
- help="Prints map of downloaded pieces and ends (X is downloaded piece, O is not downloaded)")
- p.add_argument("-s", "--subtitles", action=LangAction,
- help="language for subtitle 3 letter code eng,cze ... (will try to get subtitles from opensubtitles.org)")
- p.add_argument("--stream", action="store_true", help="just file streaming, but will not start player")
- p.add_argument("--no-resume", action="store_true", help="Do not resume from last known position")
- p.add_argument("-q", "--quiet", action="store_true", help="Quiet - did not print progress to stdout")
- p.add_argument('--delete-on-finish', action="store_true", help="Delete downloaded file when program finishes")
- p.add_argument('--clear-older', type=int, default=0,
- help="Deletes files older then x days from download directory, if set will slowdown start of client")
- p.add_argument('--bt-download-limit', type=int, default=0, help='Download limit for torrents kB/s')
- p.add_argument('--bt-upload-limit', type=int, default=0, help='Upload limit for torrents kB/s')
- p.add_argument('--listen-port-min', type=int, default=6881, help='Bitorrent input port range - minimum port')
- p.add_argument('--listen-port-max', type=int, default=6891, help='Bitorrent input port range - maximum port')
- p.add_argument('--choose-subtitles', action="store_true",
- help="Always manually choose subtitles (otherwise will try to use best match in many cases)")
- p.add_argument('--trace', action='store_true', help='More detailed debug logging')
- args = p.parse_args(args)
- # str(args)
- if args.debug_log:
- logger.setLevel(logging.DEBUG)
- h = logging.handlers.RotatingFileHandler(args.debug_log)
- logger.addHandler(h)
- else:
- logger.setLevel(logging.CRITICAL)
- logger.addHandler(logging.StreamHandler())
-
- if args.clear_older:
- days = args.clear_older
- items = os.listdir(args.directory)
- now = time.time()
- for item in items:
- if item != CacheBT.CACHE_DIR:
- full_path = os.path.join(args.directory, item)
- if now - os.path.getctime(full_path) > days * 24 * 3600:
- logger.debug('Deleting path %s', full_path)
- if os.path.isdir(full_path):
- shutil.rmtree(full_path, ignore_errors=True)
- else:
- os.unlink(full_path)
-
- if args.print_pieces:
- print_pieces(args)
- elif re.match('https?://localhost', args.url):
- class TestResolver(Resolver):
- SPEED_LIMIT = 300
- THREADS = 2
-
- #stream(args, HTClient, TestResolver)
- else:
- #rclass = plugins.find_matching_plugin(args.url)
- #if rclass:
- # stream(args, HTClient, rclass)
- #else:
- #stream(args, BTClient)
- return args
-
-#def stream(args, client_class, resolver_class=None):
-# c = client_class(args.directory, args=args, resolver_class=resolver_class)
-# player = None
-#
-# def on_exit(sig=None, frame=None):
-# c.close()
-# if player:
-# player.terminate()
-# if sig:
-# logger.info('Exiting by signal %d', sig)
-# sys.exit(0)
-#
-# try:
-#
-# if not args.stream:
-# player = Player.create(args.player, c.update_play_time)
-#
-# server = None
-# # test if port if free, otherwise find free
-# free_port = args.port
-# while True:
-#
-# try:
-# s = socket.socket()
-# res = s.connect_ex(('127.0.0.1', free_port))
-# if res:
-# break
-# finally:
-# s.close()
-# free_port += 1
-# if not args.stdin:
-# server = StreamServer(('127.0.0.1', free_port), BTFileHandler, allow_range=True,
-# status_fn=c.get_normalized_status)
-# logger.debug('Started http server on port %d', free_port)
-# server.run()
-# #thread.start_new_thread(server.run, ())
-# if player:
-# def start_play(f, finished):
-# base = None
-# if not args.stdin:
-# server.set_file(f)
-# base = 'http://127.0.0.1:' + str(free_port) + '/'
-# sin = args.stdin
-# if finished:
-# base = args.directory
-# sin = False
-# logger.debug('File is already downloaded, will play it directly')
-# args.play_file = True
-#
-# if args.no_resume:
-# start_time = 0
-# else:
-# start_time = c.last_play_time or 0
-# player.start(f, base, stdin=sin, sub_lang=args.subtitles, start_time=start_time,
-# always_choose_subtitles=args.choose_subtitles)
-# logger.debug('Started media player for %s', f)
-#
-# c.set_on_file_ready(start_play)
-# else:
-# def print_url(f, done):
-# server.set_file(f)
-# base = 'http://127.0.0.1:' + str(free_port) + '/'
-# url = urlparse.urljoin(base, urllib.quote(f.path))
-# print "\nServing file on %s" % url
-# sys.stdout.flush()
-#
-# c.set_on_file_ready(print_url)
-#
-# logger.debug('Starting btclient - libtorrent version %s', self.lt.version)
-# c.start_url(args.url)
-# while not c.is_file_ready:
-# time.sleep(1)
-# if not args.stdin or hasattr(args, 'play_file') and args.play_file:
-# f = None
-# else:
-# f = c.file.create_cursor()
-#
-# while True:
-# if player and not player.is_playing():
-# break
-# if not f:
-# time.sleep(1)
-# else:
-# buf = f.read(1024)
-# if buf:
-# try:
-# player.write(buf)
-# logger.debug("written to stdin")
-# except IOError:
-# pass
-# else:
-# player.close()
-# if f:
-# f.close()
-# logger.debug('Play ended')
-# if server:
-# server.stop()
-# if player:
-# if player.rcode != 0:
-# msg = 'Player ended with error %d\n' % (player.rcode or 0)
-# sys.stderr.write(msg)
-# logger.error(msg)
-#
-# logger.debug("Player output:\n %s", player.log)
-# finally:
-# on_exit()
-# # logger.debug("Remaining threads %s", list(threading.enumerate()))
-
-
-def pieces_map(pieces, w):
- idx = 0
- sz = len(pieces)
- w(" " * 4)
- for i in xrange(10):
- w("%d " % i)
- w('\n')
- while idx < sz:
- w("%3d " % (idx / 10))
- for _c in xrange(min(10, sz - idx)):
- if pieces[idx]:
- w('X ')
- else:
- w('O ')
- idx += 1
- w('\n')
-
-
-def print_pieces(args):
- def w(x):
- sys.stdout.write(x)
-
- c = BTClient(args.directory)
- c.start_url(args.url)
- # c.add_listener(print_status)
- start = time.time()
- while time.time() - start < 60:
- if c.file:
- print "Pieces (each %.0f k) for file: %s" % (c.file.piece_size / 1024.0, c.file.path)
- pieces = c.pieces
- pieces_map(pieces, w)
- return
- time.sleep(1)
- print >> sys.stderr, "Cannot get metadata"
-
-
-if __name__ == '__main__':
- try:
- main()
- except KeyboardInterrupt:
- print >> sys.stderr, '\nProgram interrupted, exiting'
- logger.info('Exiting by SIGINT')
- except Exception:
- traceback.print_exc()
- logger.exception('General error')
diff --git a/resources/btclient/cachebt.py b/resources/btclient/cachebt.py
deleted file mode 100644
index be1a9d4..0000000
--- a/resources/btclient/cachebt.py
+++ /dev/null
@@ -1,100 +0,0 @@
-'''
-Created on Apr 28, 2015
-
-@author: ivan
-'''
-import os.path
-import shelve
-import re
-import logging
-import base64
-
-logger = logging.getLogger('cache')
-
-
-class CacheBT(object):
- CACHE_DIR = '.cache'
-
- def __init__(self, path, lt):
- if not os.path.isdir(path):
- raise ValueError('Invalid base directory')
- self.path = os.path.join(path, CacheBT.CACHE_DIR)
- if not os.path.isdir(self.path):
- os.mkdir(self.path)
- self._index_path = os.path.join(self.path, 'index')
- self._index = shelve.open(self._index_path)
- self._last_pos_path = os.path.join(self.path, 'last_position')
- self._last_pos = shelve.open(self._last_pos_path)
- self.lt=lt
-
- def save(self, url, info_hash):
- self._index[url] = info_hash
- self._index.sync()
-
- def close(self):
- self._index.close()
- self._last_pos.close()
-
- def _tname(self, info_hash):
- return os.path.join(self.path, info_hash.upper() + '.torrent')
-
- def _rname(self, info_hash):
- return os.path.join(self.path, info_hash.upper() + '.resume')
-
- def save_resume(self, info_hash, data):
- with open(self._rname(info_hash), 'wb') as f:
- f.write(data)
-
- def get_resume(self, url=None, info_hash=None):
- if url:
- info_hash = self._index.get(url)
- if not info_hash:
- return
- rname = self._rname(info_hash)
- if os.access(rname, os.R_OK):
- with open(rname, 'rb') as f:
- return f.read()
-
- def file_complete(self, torrent, url=None):
- info_hash = str(torrent.info_hash())
- nt = self.lt.create_torrent(torrent)
- tname = self._tname(info_hash)
- with open(tname, 'wb') as f:
- f.write(self.lt.bencode(nt.generate()))
- if url:
- self.save(url, info_hash)
-
- def get_torrent(self, url=None, info_hash=None):
- if url:
- info_hash = self._index.get(url)
- if not info_hash:
- return
- tname = self._tname(info_hash)
- if os.access(tname, os.R_OK):
- logger.debug('Torrent is cached')
- return tname
-
- magnet_re = re.compile('xt=urn:btih:([0-9A-Za-z]+)')
- hexa_chars = re.compile('^[0-9A-F]+$')
-
- @staticmethod
- def hash_from_magnet(m):
- res = CacheBT.magnet_re.search(m)
- if res:
- ih = res.group(1).upper()
- if len(ih) == 40 and CacheBT.hexa_chars.match(ih):
- return res.group(1).upper()
- elif len(ih) == 32:
- s = base64.b32decode(ih)
- return "".join("{:02X}".format(ord(c)) for c in s)
- else:
- raise ValueError('Not BT magnet link')
-
- else:
- raise ValueError('Not BT magnet link')
-
- def play_position(self, info_hash, secs):
- self._last_pos[info_hash] = secs
-
- def get_last_position(self, info_hash):
- return self._last_pos.get(info_hash) or 0
diff --git a/resources/btclient/common.py b/resources/btclient/common.py
deleted file mode 100644
index 6cb10e0..0000000
--- a/resources/btclient/common.py
+++ /dev/null
@@ -1,505 +0,0 @@
-'''
-Created on May 3, 2015
-
-@author: ivan
-'''
-import os
-from collections import deque
-import logging
-import copy
-import threading
-import traceback
-import shutil
-import urlparse
-from StringIO import StringIO
-
-from hachoir_metadata import extractMetadata
-from hachoir_parser import guessParser
-import hachoir_core.config as hachoir_config
-from hachoir_core.stream.input import InputIOStream
-
-logger = logging.getLogger('common')
-hachoir_config.quiet = True
-
-
-def enum(**enums):
- return type('Enum', (), enums)
-
-
-TerminalColor = enum(default='\033[39m', green='\033[32m', red='\033[31m', yellow='\033[33m')
-
-
-def get_duration(fn):
- # We need to provide just begining of file otherwise hachoir might try to read all file
- with open(fn, 'rb') as f:
- s = StringIO(f.read(1024 * 64))
- p = guessParser(InputIOStream(s, filename=unicode(fn), tags=[]))
- m = extractMetadata(p)
- if m:
- return m.getItem('duration', 0) and m.getItem('duration', 0).value
-
-
-def debug_fn(fn):
- def _fn(*args, **kwargs):
- print "Entering %s, thread %s" % (fn.__name__, threading.current_thread().name)
- traceback.print_stack()
- ret = fn(*args, **kwargs)
- print "Leaving %s, thread %s" % (fn.__name__, threading.current_thread().name)
- return ret
-
- return _fn
-
-
-class Hasher(threading.Thread):
- def __init__(self, btfile, hash_cb):
- threading.Thread.__init__(self, name="Hasher")
- if btfile is None:
- raise ValueError('BTFile is None!')
- self._btfile = btfile
- self._hash_cb = hash_cb
- self.hash = None
- self.daemon = True
- self.start()
-
- def run(self):
- with self._btfile.create_cursor() as c:
- filehash = OpenSubtitles.hash_file(c, self._btfile.size)
- self.hash = filehash
- self._hash_cb(filehash)
-
-
-class OpenSubtitles(object):
- USER_AGENT = 'BTClient'
-
- def __init__(self, lang, user='', pwd=''):
- self._lang = lang
- self._token = None
- self._user = user
- self._pwd = pwd
-
- @staticmethod
- def hash_file(f, filesize):
- import struct
-
- longlongformat = ' 0:
- for i in xrange(self.size):
- if i + diff < self.size:
- self._cache[i] = self._cache[i + diff]
- else:
- self._cache[i] = None
-
- elif diff < 0:
- for i in xrange(self.size - 1, -1, -1):
- if i + diff >= 0:
- self._cache[i] = self._cache[i + diff]
- else:
- self._cache[i] = None
-
- self._cache_first = first
- self._event.clear()
- for i in xrange(self.size):
- if self._cache[i] is None and (self._cache_first + i) <= self._last_piece:
- to_request.append((self._cache_first + i, i))
- for args in to_request:
- self._request_piece(*args)
-
- def add_piece(self, n, data):
- with self._lock:
- i = n - self._cache_first
- if i >= 0 and i < self.size:
- self._cache[i] = data
- if i == 0:
- self._event.set()
-
- def has_piece(self, n):
- with self._lock:
- i = n - self._cache_first
- if i >= 0 and i < self.size:
- return not (self._cache[i] is None)
-
- def _wait_piece(self, pc_no):
- while not self.has_piece(pc_no):
- self.fill_cache(pc_no)
- # self._event.clear()
- logger.debug('Waiting for piece %d' % pc_no)
- self._event.wait(self.TIMEOUT)
-
- def _get_piece(self, n):
- with self._lock:
- i = n - self._cache_first
- if i < 0 or i > self.size:
- raise ValueError('index of of scope of current cache')
- return self._cache[i]
-
- def get_piece(self, n):
- self._wait_piece(n)
- return self._get_piece(n)
-
- def read(self, offset, size):
- size = min(size, self._file_size - offset)
- if not size:
- return
-
- pc_no, ofs = self._map_offset(offset)
- data = self.get_piece(pc_no)
- pc_size = self._piece_size - ofs
- if pc_size > size:
- return data[ofs: ofs + size]
- else:
- pieces = [data[ofs:self._piece_size]]
- remains = size - pc_size
- new_head = pc_no + 1
- while remains and self.has_piece(new_head):
- sz = min(remains, self._piece_size)
- data = self.get_piece(new_head)
- pieces.append(data[:sz])
- remains -= sz
- if remains:
- new_head += 1
- self.fill_cache(new_head)
- return ''.join(pieces)
-
-
-class BTCursor(object):
- def __init__(self, btfile):
- self._btfile = btfile
- self._pos = 0
- self._cache = PieceCache(btfile)
-
- def clone(self):
- c = BTCursor(self._btfile)
- c._cache = self._cache.clone()
- return c
-
- def close(self):
- self._btfile.remove_cursor(self)
-
- def read(self, n=None):
- sz = self._btfile.size - self._pos
- if not n:
- n = sz
- else:
- n = min(n, sz)
- res = self._cache.read(self._pos, n)
- if res:
- self._pos += len(res)
- return res
-
- def seek(self, n):
- if n > self._btfile.size:
- n = self._btfile.size
- # raise ValueError('Seeking beyond file size')
- elif n < 0:
- raise ValueError('Seeking negative')
- self._pos = n
-
- def tell(self):
- return self._pos
-
- def update_piece(self, n, data):
- self._cache.add_piece(n, data)
-
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_val, exc_tb):
- self.close()
-
-
-class AbstractFile(object):
- def __init__(self, path, base, size, piece_size):
- self._base = base
- self.size = size
- self.path = path
- self.piece_size = piece_size
- self.offset = 0
- self._full_path = os.path.join(base, path)
- self._cursors = []
- self._cursors_history = deque(maxlen=3)
- self._lock = threading.Lock()
- self.first_piece = 0
- self.last_piece = self.first_piece + (max(size - 1, 0)) // piece_size
-
- self._rate = None
- self._piece_duration = None
-
- def add_cursor(self, c):
- with self._lock:
- self._cursors.append(c)
-
- def remove_cursor(self, c):
- with self._lock:
- self._cursors.remove(c)
- self._cursors_history.appendleft(c)
-
- def create_cursor(self, offset=None):
- c = None
- if offset is not None:
- with self._lock:
- for e in reversed(self._cursors):
- if abs(e.tell() - offset) < self.piece_size:
- c = e.clone()
- logger.debug('Cloning existing cursor')
- break
- if not c:
- with self._lock:
- for e in reversed(self._cursors_history):
- if abs(e.tell() - offset) < self.piece_size:
- c = e
- logger.debug('Reusing previous cursor')
- if not c:
- c = BTCursor(self)
- self.add_cursor(c)
- if offset:
- c.seek(offset)
- return c
-
- def map_piece(self, ofs):
- return self.first_piece + (ofs + self.offset) // self.piece_size, \
- (ofs + self.offset) % self.piece_size
-
- def prioritize_piece(self, piece, idx):
- raise NotImplementedError()
-
- @property
- def full_path(self):
- return self._full_path
-
- def close(self):
- pass
-
- def remove(self):
- dirs = self.path.split(os.sep)
- if len(dirs) > 1:
- shutil.rmtree(os.path.join(self._base, dirs[0]), ignore_errors=True)
- else:
- os.unlink(self._full_path)
-
- def update_piece(self, n, data):
- for c in self._cursors:
- c.update_piece(n, data)
-
- @property
- def duration(self):
- if not hasattr(self, '_duration'):
- self._duration = get_duration(self._full_path) if os.path.exists(self._full_path) else 0
- return self._duration or 0
-
- @property
- def piece_duration_ms(self):
- if not self._piece_duration:
- if self.byte_rate:
- self._piece_duration = self.piece_size / self.byte_rate / 1000
-
- return self._piece_duration
-
- @property
- def byte_rate(self):
- if not self._rate:
- d = self.duration
- if d:
- if hasattr(d, 'total_seconds'):
- total_seconds=d.total_seconds()
- else:
- total_seconds=(d.microseconds + (d.seconds + d.days * 24 * 3600) * 10**6) / 10**6
- self._rate = self.size / total_seconds
- return self._rate
-
- def __str__(self):
- return self.path
-
-
-class Resolver(object):
- URL_PATTERN = None
- SPEED_LIMIT = None # kB/s
- THREADS = 4
-
- def __init__(self, loader):
- self._client = loader
-
- def resolve(self, url):
- return url
-
- @staticmethod
- def url_to_file(uri):
- path = urlparse.urlsplit(uri)[2]
- if path.startswith('/'):
- path = path[1:]
- return path
diff --git a/resources/btclient/opensubtitle.py b/resources/btclient/opensubtitle.py
deleted file mode 100644
index 4d772b4..0000000
--- a/resources/btclient/opensubtitle.py
+++ /dev/null
@@ -1,262 +0,0 @@
-'''
-Created on Apr 2, 2015
-
-@author: ivan
-
-import xmlrpclib
-import urllib2
-import os.path
-import gzip
-from StringIO import StringIO
-import logging
-import subprocess
-import struct
-import time
-
-logger = logging.getLogger('opensubtitles')
-
-
-class Urllib2Transport(xmlrpclib.Transport):
- def __init__(self, opener=None, https=False, use_datetime=0):
- xmlrpclib.Transport.__init__(self, use_datetime)
- self.opener = opener or urllib2.build_opener()
- self.https = https
-
- def request(self, host, handler, request_body, verbose=0):
- proto = ('http', 'https')[bool(self.https)]
- req = urllib2.Request('%s://%s%s' % (proto, host, handler), request_body)
- req.add_header('User-agent', self.user_agent)
- self.verbose = verbose
- return self.parse_response(self.opener.open(req))
-
-
-class OpenSubtitles(object):
- USER_AGENT = 'BTClient'
-
- def __init__(self, lang, user='', pwd=''):
- self._lang = lang
- self._proxy = xmlrpclib.ServerProxy('http://api.opensubtitles.org/xml-rpc',
- Urllib2Transport(use_datetime=True),
- allow_none=True, use_datetime=True)
- self._token = None
- self._user = user
- self._pwd = pwd
-
- def login(self):
- res = self._proxy.LogIn(self._user, self._pwd, 'en', self.USER_AGENT)
- self._parse_status(res)
- token = res.get('token')
- if token:
- self._token = token
- else:
- raise xmlrpclib.Fault('NO_TOKEN', 'No token!')
-
- def _parse_status(self, res):
- if res.has_key('status'):
- code = res['status'].split()[0]
- if code != '200':
- raise xmlrpclib.Fault('ERROR_CODE_RETURENED', 'Returned error status: %s (%s)' % (code, res))
- return True
- else:
- raise xmlrpclib.Fault('NO_STATUS', 'No status!')
-
- def search(self, filename, filesize=None, filehash=None, limit=20):
- filename = os.path.split(filename)[1]
- name = os.path.splitext(filename)[0]
- query = []
- if filehash and filesize:
- query.append({'sublanguageid': self._lang, 'moviehash': filehash, 'moviebytesize': str(filesize)})
- query.append({'sublanguageid': self._lang, 'tag': filename})
- query.append({'sublanguageid': self._lang, 'query': name})
- res = self._proxy.SearchSubtitles(self._token, query, {'limit': limit})
- self._parse_status(res)
- data = res.get('data')
-
- return data if data else []
-
- @staticmethod
- def _sub_file(filename, lang, ext):
- lang = lang.lower()
- path, fname = os.path.split(filename)
- fname = os.path.splitext(fname)[0]
- return os.path.join(path, fname + '.' + lang + '.' + ext)
-
- @staticmethod
- def _base_name(filename):
- fname = os.path.split(filename)[1]
- return os.path.splitext(fname)[0]
-
- @staticmethod
- def hash_file(f, filesize):
-
- longlongformat = ' 0 and not overwrite:
- logger.debug('subs %s are already downloaded', sfile)
- return sfile
- else:
- while True:
- try:
- with OpenSubtitles(lang) as opensub:
- res = opensub.download(filename, filesize, filehash, can_choose)
- if res:
- logger.debug('Subtitles %s downloaded', res)
- return res
- else:
- logger.debug('No subtitles found for file %s in language %s', filename, lang)
- return
- except urllib2.HTTPError, e:
- retries -= 1
- if retries <= 0:
- raise e
- logger.debug('Retrying to load subtitles due to HTTP error %d, remains %d attempts', e.code,
- retries)
- time.sleep(1)
-
- def download(self, filename, filesize=None, filehash=None, can_choose=True):
- data = self.search(filename, filesize, filehash)
- if not data:
- return None
- media_file = OpenSubtitles._base_name(filename).lower()
-
- def same_name(b):
- return media_file == OpenSubtitles._base_name(b['SubFileName']).lower()
-
- if filehash and filesize:
- match = filter(lambda x: x.get('QueryNumber', 0) == 0, data)
- logger.debug('Got results by filehash')
- else:
- match = filter(same_name, data)
- if match and can_choose != 'always':
- sub = match[0]
- link = sub['SubDownloadLink']
- ext = sub['SubFormat']
- logger.debug('Find exact match for media file, subtitle is %s', sub['SubFileName'])
- elif can_choose:
- link = self.choose(data)
- ext = 'srt'
- else:
- sub = data[0]
- link = sub['SubDownloadLink']
- ext = sub['SubFormat']
- if link:
- return self.download_link(filename, link, ext)
-
- def download_link(self, filename, link, ext):
- out_file = OpenSubtitles._sub_file(filename, self._lang, ext)
- res = urllib2.urlopen(link, timeout=10)
- data = StringIO(res.read())
- data.seek(0)
- res.close()
- z = gzip.GzipFile(fileobj=data)
- with open(out_file, 'wb') as f:
- while True:
- d = z.read(1024)
- if not d:
- break
- f.write(d)
- z.close()
- return out_file
-
- def logout(self):
- try:
- res = self._proxy.LogOut(self._token)
- self._parse_status(res)
- except urllib2.HTTPError:
- logger.warn('Failed to logout')
-
- def __enter__(self):
- self.login()
- return self
-
- def __exit__(self, exc_type, exc_val, exc_tb):
- self.logout()
-
-
-def down(f, lang, overwrite=False):
- filesize, filehash = calc_hash(f)
- OpenSubtitles.download_if_not_exists(f, lang, filesize=filesize,
- filehash=filehash, can_choose=True, overwrite=overwrite)
-
-
-def calc_hash(f):
- if not os.access(f, os.R_OK):
- raise ValueError('Cannot read from file %s' % f)
- filesize = os.stat(f).st_size
- with open(f, 'rb') as fs:
- filehash = OpenSubtitles.hash_file(fs, filesize)
- return filesize, filehash
-
-
-def list_subs(f, lang):
- import pprint
-
- filesize, filehash = calc_hash(f)
- with OpenSubtitles(lang) as opensub:
- res = opensub.search(f, filesize, filehash)
- res = map(lambda x: {'SubFileName': x['SubFileName'],
- 'SubDownloadsCnt': x['SubDownloadsCnt'],
- 'QueryNumber': x.get('QueryNumber', 0),
- },
- res)
- pprint.pprint(res)
-
-
-if __name__ == '__main__':
-
- from argparse import ArgumentParser
-
- p = ArgumentParser()
- p.add_argument("video_file", help="video file")
- p.add_argument("-d", "--download", action="store_true", help="Download subtitles for video files")
- p.add_argument("-l", "--list", action="store_true", help="List available subtitles")
- p.add_argument("--lang", default='eng', help="Language")
- p.add_argument("--debug", action="store_true", help="Print debug messages")
- p.add_argument("--overwrite", action="store_true", help="Overwrite existing subtitles ")
- args = p.parse_args()
- if args.debug:
- logging.basicConfig(level=logging.DEBUG)
- if args.download:
- down(args.video_file, args.lang, args.overwrite)
- else:
- list_subs(args.video_file, args.lang)
-'''
\ No newline at end of file
diff --git a/resources/contenters/CXZ.py b/resources/contenters/CXZ.py
index a06d9cb..b9b4c5f 100644
--- a/resources/contenters/CXZ.py
+++ b/resources/contenters/CXZ.py
@@ -132,7 +132,7 @@ class CXZ(Content.Content):
def mode(self, response):
contentList = []
Soup = BeautifulSoup(response)
- result = Soup.findAll('div', {'class': 'b-poster-tile '})
+ result = Soup.findAll('div', {'class': 'b-poster-tile '})
num = 0
for tr in result:
#main
@@ -158,40 +158,4 @@ class CXZ(Content.Content):
originaltitle, title, int(year), img, info,
))
#print result
- return contentList
-
-
-'''
- - Video Values:
- - genre : string (Comedy)
- - year : integer (2009)
- - episode : integer (4)
- - season : integer (1)
- - top250 : integer (192)
- - rating : float (6.4) - range is 0..10
- - cast : list (Michal C. Hall)
- - castandrole : list (Michael C. Hall|Dexter)
- - director : string (Dagur Kari)
- - mpaa : string (PG-13)
- - plot : string (Long Description)
- - plotoutline : string (Short Description)
- - title : string (Big Fan)
- - originaltitle : string (Big Fan)
- - sorttitle : string (Big Fan)
- - duration : string (3:18)
- - studio : string (Warner Bros.)
- - tagline : string (An awesome movie) - short description of movie
- - writer : string (Robert D. Siegel)
- - tvshowtitle : string (Heroes)
- - premiered : string (2005-03-04)
- - status : string (Continuing) - status of a TVshow
- - code : string (tt0110293) - IMDb code
- - aired : string (2008-12-07)
- - credits : string (Andy Kaufman) - writing credits
- - lastplayed : string (Y-m-d h:m:s = 2009-04-05 23:16:04)
- - album : string (The Joshua Tree)
- - artist : list (['U2'])
- - votes : string (12345 votes)
- - trailer : string (/home/user/trailer.avi)
- - dateadded : string (Y-m-d h:m:s = 2009-04-05 23:16:04)
- '''
\ No newline at end of file
+ return contentList
\ No newline at end of file