Removed unused pieces

Author: Clark Perkins

stackdio/client/__init__.py

@@ -32,7 +32,6 @@
 from .region import RegionMixin
 from .settings import SettingsMixin
 from .stack import StackMixin
-from .version import _parse_version_string
 
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
@@ -60,13 +59,16 @@ def __init__(self, url=None, username=None, password=None, verify=True, cfg_file
 
         if self.usable():
             try:
-                _, self.version = _parse_version_string(self.get_version(raise_for_status=False))
+                raw_version = self.get_version(raise_for_status=False)
+                self.version = raw_version.split('.')
             except MissingUrlException:
-                self.version = None
+                raw_version = None
 
-            if self.version and (self.version[0] != 0 or self.version[1] != 7):
-                raise IncompatibleVersionException('Server version {0}.{1}.{2} not '
-                                                   'supported.'.format(*self.version))
+            if raw_version and (self.version[0] != 0 or self.version[1] != 7):
+                raise IncompatibleVersionException(
+                    'Server version {0} not supported.  Please upgrade '
+                    'stackdio-cli to {1}.{2}.0 or higher.'.format(raw_version, *self.version)
+                )
 
     @property
     def url(self):

stackdio/client/stack.py

@@ -17,7 +17,6 @@
 
 from .exceptions import StackException
 from .http import HttpMixin, get, post, put, delete
-from .version import deprecated
 
 
 class StackMixin(HttpMixin):

stackdio/client/version.py

@@ -97,78 +97,6 @@ def get_git_changeset():
 __version__ = get_version(VERSION)
 
 
-def _unsupported_function(func, current_version, accepted_versions):
-    raise IncompatibleVersionException("%s: %s is not one of %s" %
-                                       (func.__name__,
-                                        ".".join([str(v) for v in current_version]),
-                                        list(accepted_versions)))
-
-
-def _parse_version_string(version_string):
-    original_version_string = version_string
-    comparisons = {
-        "=": operator.eq,
-        "!=": operator.ne,
-        "<": operator.lt,
-        ">": operator.gt,
-        "<=": operator.le,
-        ">=": operator.ge
-    }
-
-    # Determine the comparison function
-    comp_string = "="
-    if version_string[0] in ["<", ">", "=", "!"]:
-        offset = 1
-        if version_string[1] == "=":
-            offset += 1
-
-        comp_string = version_string[:offset]
-        version_string = version_string[offset:]
-
-    # Check if the version appears compatible
-    try:
-        int(version_string[0])
-    except ValueError:
-        raise InvalidVersionStringException(original_version_string)
-
-    # String trailing info
-    version_string = re.split("[a-zA-Z]", version_string)[0]
-    if version_string[-1] == '.':
-        version_string = version_string[:-1]
-    version = version_string.split(".")
-
-    # Pad length to 3
-    version += [0] * (3 - len(version))
-
-    # Convert to ints
-    version = [int(num) for num in version]
-
-    try:
-        return comparisons[comp_string], tuple(version)
-    except KeyError:
-        raise InvalidVersionStringException(original_version_string)
-
-
-def accepted_versions(*versions):
-    def decorator(func):
-        if not versions:
-            return func
-
-        parsed_versions = [_parse_version_string(version_string)
-                           for version_string in versions]
-
-        @wraps(func)
-        def wrapper(obj, *args, **kwargs):
-            for parsed_version in parsed_versions:
-                comparison, version = parsed_version
-                if comparison(obj.version, version):
-                    return func(obj, *args, **kwargs)
-
-            return _unsupported_function(func, obj.version, versions)
-        return wrapper
-    return decorator
-
-
 def deprecated(func):
     """
     This is a decorator which can be used to mark functions