Initial refactor for v4 of sdk.

Author: tedchamb

vsts/LICENSE.txt azure-devops/LICENSE.txtvsts/LICENSE.txt renamed to azure-devops/LICENSE.txt

@@ -0,0 +1,6 @@
+# --------------------------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# --------------------------------------------------------------------------------------------
+import pkg_resources
+pkg_resources.declare_namespace(__name__)

vsts/MANIFEST.in azure-devops/MANIFEST.invsts/MANIFEST.in renamed to azure-devops/MANIFEST.in

@@ -0,0 +1,176 @@
+# --------------------------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# --------------------------------------------------------------------------------------------
+
+import base64
+import json
+import logging
+import os
+import time
+try:
+    import collections.abc as collections
+except ImportError:
+    import collections
+
+
+logger = logging.getLogger(__name__)
+
+
+class FileCache(collections.MutableMapping):
+    """A simple dict-like class that is backed by a JSON file.
+
+    All direct modifications will save the file. Indirect modifications should
+    be followed by a call to `save_with_retry` or `save`.
+    """
+
+    def __init__(self, file_name, max_age=0):
+        super(FileCache, self).__init__()
+        self.file_name = file_name
+        self.max_age = max_age
+        self.data = {}
+        self.initial_load_occurred = False
+
+    def load(self):
+        self.data = {}
+        try:
+            if os.path.isfile(self.file_name):
+                if self.max_age > 0 and os.stat(self.file_name).st_mtime + self.max_age < time.time():
+                    logger.debug('Cache file expired: %s', file=self.file_name)
+                    os.remove(self.file_name)
+                else:
+                    logger.debug('Loading cache file: %s', self.file_name)
+                    self.data = get_file_json(self.file_name, throw_on_empty=False) or {}
+            else:
+                logger.debug('Cache file does not exist: %s', self.file_name)
+        except Exception as ex:
+            logger.debug(ex, exc_info=True)
+            # file is missing or corrupt so attempt to delete it
+            try:
+                os.remove(self.file_name)
+            except Exception as ex2:
+                logger.debug(ex2, exc_info=True)
+        self.initial_load_occurred = True
+
+    def save(self):
+        self._check_for_initial_load()
+        self._save()
+
+    def _save(self):
+        if self.file_name:
+            with os.fdopen(os.open(self.file_name, os.O_RDWR | os.O_CREAT | os.O_TRUNC, 0o600), 'w+') as cred_file:
+                cred_file.write(json.dumps(self.data))
+
+    def save_with_retry(self, retries=5):
+        self._check_for_initial_load()
+        for _ in range(retries - 1):
+            try:
+                self.save()
+                break
+            except OSError:
+                time.sleep(0.1)
+        else:
+            self.save()
+
+    def clear(self):
+        if os.path.isfile(self.file_name):
+            logger.info("Deleting file: " + self.file_name)
+            os.remove(self.file_name)
+        else:
+            logger.info("File does not exist: " + self.file_name)
+
+    def get(self, key, default=None):
+        self._check_for_initial_load()
+        return self.data.get(key, default)
+
+    def __getitem__(self, key):
+        self._check_for_initial_load()
+        return self.data.setdefault(key, {})
+
+    def __setitem__(self, key, value):
+        self._check_for_initial_load()
+        self.data[key] = value
+        self.save_with_retry()
+
+    def __delitem__(self, key):
+        self._check_for_initial_load()
+        del self.data[key]
+        self.save_with_retry()
+
+    def __iter__(self):
+        self._check_for_initial_load()
+        return iter(self.data)
+
+    def __len__(self):
+        self._check_for_initial_load()
+        return len(self.data)
+
+    def _check_for_initial_load(self):
+        if not self.initial_load_occurred:
+            self.load()
+
+
+def get_cache_dir():
+    azure_devops_cache_dir = os.getenv('AZURE_DEVOPS_CACHE_DIR', None)\
+                             or os.path.expanduser(os.path.join('~', '.azure-devops', 'python-sdk', 'cache'))
+    if not os.path.exists(azure_devops_cache_dir):
+        os.makedirs(azure_devops_cache_dir)
+    return azure_devops_cache_dir
+
+
+DEFAULT_MAX_AGE = 3600 * 12  # 12 hours
+DEFAULT_CACHE_DIR = get_cache_dir()
+
+
+def get_cache(name, max_age=DEFAULT_MAX_AGE, cache_dir=DEFAULT_CACHE_DIR):
+    file_name = os.path.join(cache_dir, name + '.json')
+    return FileCache(file_name, max_age)
+
+
+OPTIONS_CACHE = get_cache('options')
+RESOURCE_CACHE = get_cache('resources')
+
+
+# Code below this point from azure-cli-core
+# https://github.com/Azure/azure-cli/blob/master/src/azure-cli-core/azure/cli/core/util.py
+
+def get_file_json(file_path, throw_on_empty=True, preserve_order=False):
+    content = read_file_content(file_path)
+    if not content and not throw_on_empty:
+        return None
+    return shell_safe_json_parse(content, preserve_order)
+
+
+def read_file_content(file_path, allow_binary=False):
+    from codecs import open as codecs_open
+    # Note, always put 'utf-8-sig' first, so that BOM in WinOS won't cause trouble.
+    for encoding in ['utf-8-sig', 'utf-8', 'utf-16', 'utf-16le', 'utf-16be']:
+        try:
+            with codecs_open(file_path, encoding=encoding) as f:
+                logger.debug("attempting to read file %s as %s", file_path, encoding)
+                return f.read()
+        except UnicodeDecodeError:
+            if allow_binary:
+                with open(file_path, 'rb') as input_file:
+                    logger.debug("attempting to read file %s as binary", file_path)
+                    return base64.b64encode(input_file.read()).decode("utf-8")
+            else:
+                raise
+        except UnicodeError:
+            pass
+
+    raise ValueError('Failed to decode file {} - unknown decoding'.format(file_path))
+
+
+def shell_safe_json_parse(json_or_dict_string, preserve_order=False):
+    """ Allows the passing of JSON or Python dictionary strings. This is needed because certain
+    JSON strings in CMD shell are not received in main's argv. This allows the user to specify
+    the alternative notation, which does not have this problem (but is technically not JSON). """
+    try:
+        if not preserve_order:
+            return json.loads(json_or_dict_string)
+        from collections import OrderedDict
+        return json.loads(json_or_dict_string, object_pairs_hook=OrderedDict)
+    except ValueError:
+        import ast
+        return ast.literal_eval(json_or_dict_string)

vsts/vsts/__init__.py azure-devops/azure/__init__.pyvsts/vsts/__init__.py renamed to azure-devops/azure/__init__.py

@@ -0,0 +1,215 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Generated file, DO NOT EDIT
+# Changes may cause incorrect behavior and will be lost if the code is
+# regenerated.
+# --------------------------------------------------------------------------
+
+from msrest.serialization import Model
+
+
+class ApiResourceLocation(Model):
+    """ApiResourceLocation.
+    """
+
+    _attribute_map = {
+        'id': {'key': 'id', 'type': 'str'},
+        'area': {'key': 'area', 'type': 'str'},
+        'resource_name': {'key': 'resourceName', 'type': 'str'},
+        'route_template': {'key': 'routeTemplate', 'type': 'str'},
+        'resource_version': {'key': 'resourceVersion', 'type': 'int'},
+        'min_version': {'key': 'minVersion', 'type': 'float'},
+        'max_version': {'key': 'maxVersion', 'type': 'float'},
+        'released_version': {'key': 'releasedVersion', 'type': 'str'},
+    }
+
+    def __init__(self, id=None, area=None, resource_name=None,
+                 route_template=None, resource_version=None,
+                 min_version=None, max_version=None,
+                 released_version=None):
+        super(ApiResourceLocation, self).__init__()
+        self.id = id
+        self.area = area
+        self.resource_name = resource_name
+        self.route_template = route_template
+        self.resource_version = resource_version
+        self.min_version = min_version
+        self.max_version = max_version
+        self.released_version = released_version
+
+
+class CustomerIntelligenceEvent(Model):
+    """CustomerIntelligenceEvent.
+
+    :param area:
+    :type area: str
+    :param feature:
+    :type feature: str
+    :param properties:
+    :type properties: dict
+    """
+
+    _attribute_map = {
+        'area': {'key': 'area', 'type': 'str'},
+        'feature': {'key': 'feature', 'type': 'str'},
+        'properties': {'key': 'properties', 'type': '{object}'}
+    }
+
+    def __init__(self, area=None, feature=None, properties=None):
+        super(CustomerIntelligenceEvent, self).__init__()
+        self.area = area
+        self.feature = feature
+        self.properties = properties
+
+
+class ImproperException(Model):
+    """ImproperException.
+    :param message:
+    :type message: str
+    """
+
+    _attribute_map = {
+        'message': {'key': 'Message', 'type': 'str'}
+    }
+
+    def __init__(self, message=None):
+        super(ImproperException, self).__init__()
+        self.message = message
+
+
+class ResourceAreaInfo(Model):
+    """ResourceAreaInfo.
+
+    :param id:
+    :type id: str
+    :param location_url:
+    :type location_url: str
+    :param name:
+    :type name: str
+    """
+
+    _attribute_map = {
+        'id': {'key': 'id', 'type': 'str'},
+        'location_url': {'key': 'locationUrl', 'type': 'str'},
+        'name': {'key': 'name', 'type': 'str'}
+    }
+
+    def __init__(self, id=None, location_url=None, name=None):
+        super(ResourceAreaInfo, self).__init__()
+        self.id = id
+        self.location_url = location_url
+        self.name = name
+
+
+class SystemException(Model):
+    """SystemException.
+    :param class_name:
+    :type class_name: str
+    :param inner_exception:
+    :type inner_exception: :class:`SystemException <vsts.models.SystemException>`
+    :param message:
+    :type message: str
+    """
+
+    _attribute_map = {
+        'class_name': {'key': 'ClassName', 'type': 'str'},
+        'message': {'key': 'Message', 'type': 'str'},
+        'inner_exception': {'key': 'InnerException', 'type': 'SystemException'}
+    }
+
+    def __init__(self, class_name=None, message=None, inner_exception=None):
+        super(SystemException, self).__init__()
+        self.class_name = class_name
+        self.message = message
+        self.inner_exception = inner_exception
+
+
+class VssJsonCollectionWrapperBase(Model):
+    """VssJsonCollectionWrapperBase.
+
+    :param count:
+    :type count: int
+    """
+
+    _attribute_map = {
+        'count': {'key': 'count', 'type': 'int'}
+    }
+
+    def __init__(self, count=None):
+        super(VssJsonCollectionWrapperBase, self).__init__()
+        self.count = count
+
+
+class VssJsonCollectionWrapper(VssJsonCollectionWrapperBase):
+    """VssJsonCollectionWrapper.
+
+    :param count:
+    :type count: int
+    :param value:
+    :type value: object
+    """
+
+    _attribute_map = {
+        'count': {'key': 'count', 'type': 'int'},
+        'value': {'key': 'value', 'type': 'object'}
+    }
+
+    def __init__(self, count=None, value=None):
+        super(VssJsonCollectionWrapper, self).__init__(count=count)
+        self.value = value
+
+
+class WrappedException(Model):
+    """WrappedException.
+    :param exception_id:
+    :type exception_id: str
+    :param inner_exception:
+    :type inner_exception: :class:`WrappedException <vsts.models.WrappedException>`
+    :param message:
+    :type message: str
+    :param type_name:
+    :type type_name: str
+    :param type_key:
+    :type type_key: str
+    :param error_code:
+    :type error_code: int
+    :param event_id:
+    :type event_id: int
+    :param custom_properties:
+    :type custom_properties: dict
+    """
+
+    _attribute_map = {
+        'exception_id': {'key': '$id', 'type': 'str'},
+        'inner_exception': {'key': 'innerException', 'type': 'WrappedException'},
+        'message': {'key': 'message', 'type': 'str'},
+        'type_name': {'key': 'typeName', 'type': 'str'},
+        'type_key': {'key': 'typeKey', 'type': 'str'},
+        'error_code': {'key': 'errorCode', 'type': 'int'},
+        'event_id': {'key': 'eventId', 'type': 'int'},
+        'custom_properties': {'key': 'customProperties', 'type': '{object}'}
+    }
+
+    def __init__(self, exception_id=None, inner_exception=None, message=None,
+                 type_name=None, type_key=None, error_code=None, event_id=None, custom_properties=None):
+        super(WrappedException, self).__init__()
+        self.exception_id = exception_id
+        self.inner_exception = inner_exception
+        self.message = message
+        self.type_name = type_name
+        self.type_key = type_key
+        self.error_code = error_code
+        self.event_id = event_id
+        self.custom_properties = custom_properties
+
+
+__all__ = [
+    'ApiResourceLocation',
+    'CustomerIntelligenceEvent',
+    'ImproperException',
+    'ResourceAreaInfo',
+    'SystemException',
+    'VssJsonCollectionWrapperBase',
+    'VssJsonCollectionWrapper',
+    'WrappedException'
+]