From 43b53abba72c906ac4730cb0ef90bdeba8df3bab Mon Sep 17 00:00:00 2001 From: DiMartinoXBMC Date: Mon, 14 Dec 2015 23:08:38 +0300 Subject: [PATCH] fix nothing --- .idea/encodings.xml | 7 +- .idea/workspace.xml | 1402 ++++++++-------- addon.xml | 2 +- resources/btclient/__init__.py | 0 resources/btclient/argparse.py | 2378 ---------------------------- resources/btclient/btclient.py | 828 ---------- resources/btclient/cachebt.py | 100 -- resources/btclient/common.py | 505 ------ resources/btclient/opensubtitle.py | 262 --- resources/contenters/CXZ.py | 40 +- 10 files changed, 672 insertions(+), 4852 deletions(-) delete mode 100644 resources/btclient/__init__.py delete mode 100644 resources/btclient/argparse.py delete mode 100644 resources/btclient/btclient.py delete mode 100644 resources/btclient/cachebt.py delete mode 100644 resources/btclient/common.py delete mode 100644 resources/btclient/opensubtitle.py 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 @@ - - - - - + @@ -715,12 +708,6 @@ - + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + @@ -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