Merge remote-tracking branch 'origin/v2' into v2

Author: adorton-adobe

setup.py

@@ -51,13 +51,12 @@
           'pycryptodome==3.9.7',
           'ldap3',
           'PyYAML',
-          'six',
           'umapi-client==2.19',
           'click',
           'click-default-group',
           'configparser==3.7.4',
           'schema==0.7.2',
-          'sign-client'
+          'sign-client~=0.2.1',
       ],
       extras_require={
           ':sys_platform=="linux" or sys_platform=="linux2"': [

sign_client/poetry.lock

@@ -0,0 +1,45 @@
+# Copyright (c) 2016-2017 Adobe Inc.  All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from setuptools import setup, find_packages
+
+version_namespace = {}
+with open('sign_client/version.py') as f:
+    exec(f.read(), version_namespace)
+
+setup(name='sign-client',
+      version=version_namespace['__version__'],
+      description='Client for the Adobe Sign API',
+      classifiers=[
+          'Programming Language :: Python :: 3.7',
+          'Programming Language :: Python :: 3.8',
+          'Programming Language :: Python :: 3.9',
+          'Programming Language :: Python :: 3.10',
+          'License :: OSI Approved :: MIT License',
+      ],
+      maintainer='Andrew Dorton',
+      maintainer_email='[email protected]',
+      license='MIT',
+      packages=find_packages(),
+      install_requires=[
+        "requests~=2.26.0",
+        "aiohttp~=3.8.1",
+      ],
+      zip_safe=False)

sign_client/pyproject.toml

@@ -6,6 +6,8 @@
 import aiohttp
 import requests
 
+from aiohttp.client_exceptions import ServerTimeoutError
+
 from .error import AssertionException, TimeoutException
 
 from .model import GroupInfo, UsersInfo, DetailedUserInfo, GroupsInfo, UserGroupsInfo, JSONEncoder, DetailedGroupInfo, UserStateInfo
@@ -343,7 +345,7 @@ async def call_with_retry_async(self, method, url, header, data=None, session=No
                     else:
                         # PUT calls respond with an empty body
                         return body, r.status
-            except TimeoutException as err:
+            except (TimeoutException, ServerTimeoutError) as err:
                 retry_nb += 1
                 self.logger.warning('Call failed: Type: {} - Message: {}'.format(type(err), err))
                 if retry_nb == (self.max_sign_retries + 1):

sign_client/setup.py

@@ -0,0 +1 @@
+__version__ = '0.2.1'

sign_client/sign_client/client.py

@@ -355,12 +355,12 @@ def begin_work_umapi(config_loader: UMAPIConfigLoader):
     # make sure that all the adobe groups are from known umapi connector names
     primary_umapi_config, secondary_umapi_configs = config_loader.get_target_options()
     referenced_umapi_names = set()
-    for groups in six.itervalues(directory_groups):
+    for groups in directory_groups.values():
         for group in groups:
             umapi_name = group.umapi_name
             if umapi_name != PRIMARY_TARGET_NAME:
                 referenced_umapi_names.add(umapi_name)
-    referenced_umapi_names.difference_update(six.iterkeys(secondary_umapi_configs))
+    referenced_umapi_names.difference_update(secondary_umapi_configs.keys())
     if len(referenced_umapi_names) > 0:
         raise AssertionException('Adobe groups reference unknown umapi connectors: %s' % referenced_umapi_names)
 
@@ -380,7 +380,7 @@ def begin_work_umapi(config_loader: UMAPIConfigLoader):
     primary_name = '.primary' if secondary_umapi_configs else ''
     umapi_primary_connector = UmapiConnector(primary_name, primary_umapi_config, True)
     umapi_other_connectors = {}
-    for secondary_umapi_name, secondary_config in six.iteritems(secondary_umapi_configs):
+    for secondary_umapi_name, secondary_config in secondary_umapi_configs.items():
         umapi_secondary_conector = UmapiConnector(".secondary.%s" % secondary_umapi_name,
                                                   secondary_config)
         umapi_other_connectors[secondary_umapi_name] = umapi_secondary_conector
@@ -646,7 +646,7 @@ def log_parameters(argv, config_loader):
     logger.info('------- Command line arguments -------')
     logger.info(' '.join(argv))
     logger.debug('-------- Resulting invocation options --------')
-    for parameter_name, parameter_value in six.iteritems(config_loader.get_invocation_options()):
+    for parameter_name, parameter_value in config_loader.get_invocation_options().items():
         logger.debug('  %s: %s', parameter_name, parameter_value)
     logger.info('-------------------------------------')
 

sign_client/sign_client/version.py

@@ -56,13 +56,13 @@ def create_key():
 def create_cert(subject_fields, key):
     try:
         subject = issuer = x509.Name([
-            x509.NameAttribute(NameOID.COUNTRY_NAME, six.text_type(subject_fields['countryName'])),
+            x509.NameAttribute(NameOID.COUNTRY_NAME, str(subject_fields['countryName'])),
             x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME,
-                               six.text_type(subject_fields['stateOrProvinceName'])),
-            x509.NameAttribute(NameOID.LOCALITY_NAME, six.text_type(subject_fields['localityName'])),
-            x509.NameAttribute(NameOID.ORGANIZATION_NAME, six.text_type(subject_fields['organizationName'])),
-            x509.NameAttribute(NameOID.COMMON_NAME, six.text_type(subject_fields['commonName'])),
-            x509.NameAttribute(NameOID.EMAIL_ADDRESS, six.text_type(subject_fields['emailAddress']))
+                               str(subject_fields['stateOrProvinceName'])),
+            x509.NameAttribute(NameOID.LOCALITY_NAME, str(subject_fields['localityName'])),
+            x509.NameAttribute(NameOID.ORGANIZATION_NAME, str(subject_fields['organizationName'])),
+            x509.NameAttribute(NameOID.COMMON_NAME, str(subject_fields['commonName'])),
+            x509.NameAttribute(NameOID.EMAIL_ADDRESS, str(subject_fields['emailAddress']))
         ])
 
         return x509.CertificateBuilder().subject_name(

user_sync/app.py

@@ -2,7 +2,7 @@
 import os
 
 import re
-import six
+# import six
 import yaml
 from abc import ABC, abstractmethod
 
@@ -72,7 +72,7 @@ def iter_configs(self):
         :rtype iterable(ObjectConfig)
         """
         yield self
-        for child_config in six.itervalues(self.child_configs):
+        for child_config in self.child_configs.values():
             for subtree_config in child_config.iter_configs():
                 yield subtree_config
 
@@ -88,7 +88,7 @@ def create_assertion_error(self, message):
         return AssertionException("%s in: %s" % (message, self.get_full_scope()))
 
     def describe_types(self, types_to_describe):
-        if types_to_describe == six.string_types:
+        if types_to_describe == str:
             result = self.describe_types(str)
         elif isinstance(types_to_describe, tuple):
             result = []
@@ -166,7 +166,7 @@ def __contains__(self, item):
         return item in self.value
 
     def iter_keys(self):
-        return six.iterkeys(self.value)
+        return self.value.keys()
 
     def iter_unused_keys(self):
         for key in self.iter_keys():
@@ -196,7 +196,7 @@ def get_string(self, key, none_allowed=False) -> str:
         """
         :rtype: basestring
         """
-        return self.get_value(key, six.string_types, none_allowed)
+        return self.get_value(key, str, none_allowed)
 
     def get_int(self, key, none_allowed=False):
         """
@@ -393,7 +393,7 @@ def load_from_yaml(self, filepath, path_keys):
         if not isinstance(yml, dict):
             # malformed YML files produce a non-dictionary
             raise AssertionException("Configuration file or command '{}' does not contain settings".format(filepath))
-        for path_key, options in six.iteritems(path_keys):
+        for path_key, options in path_keys.items():
             key_path = path_key
             keys = path_key.split('/')
             self.process_path_key(dirpath, filename, key_path, yml, keys, 1, *options)
@@ -419,7 +419,7 @@ def process_path_key(self, dirpath, filename, key_path, dictionary, keys, level,
             # if a wildcard is specified at this level, that means we
             # should process all keys as path values
             if key == "*":
-                for key, val in six.iteritems(dictionary):
+                for key, val in dictionary.items():
                     dictionary[key] = self.process_path_value(dirpath, filename, key_path, val, must_exist, can_have_subdict)
             elif key in dictionary:
                 dictionary[key] = self.process_path_value(dirpath, filename, key_path, dictionary[key], must_exist, can_have_subdict)
@@ -451,13 +451,13 @@ def process_path_value(self, dirpath, filename, key_path, val, must_exist, can_h
         :param must_exist: whether there must be a value
         :param can_have_subdict: whether the value can be a tagged string
         """
-        if isinstance(val, six.string_types):
+        if isinstance(val, str):
             return self.relative_path(dirpath, filename, key_path, val, must_exist)
         elif isinstance(val, list):
             vals = []
             for entry in val:
                 if can_have_subdict and isinstance(entry, dict):
-                    for subkey, subval in six.iteritems(entry):
+                    for subkey, subval in entry.items():
                         vals.append({subkey: self.relative_path(dirpath, filename, key_path, subval, must_exist)})
                 else:
                     vals.append(self.relative_path(dirpath, filename, key_path, entry, must_exist))
@@ -468,7 +468,7 @@ def relative_path(dirpath, filename, key_path, val, must_exist):
         """
         returns an absolute path that is resolved relative to the file being loaded
         """
-        if not isinstance(val, six.string_types):
+        if not isinstance(val, str):
             raise AssertionException("Expected pathname for setting {} in config file {}".format(key_path, filename))
         if val.startswith('$(') and val.endswith(')'):
             raise AssertionException("Shell execution is no longer supported: {}".format(val))
@@ -509,7 +509,7 @@ def set_string_value(self, key, default_value):
         :type key: str
         :type default_value: Optional(str)
         """
-        self.set_value(key, six.string_types, default_value)
+        self.set_value(key, str, default_value)
 
     def set_dict_value(self, key, default_value):
         """
@@ -526,7 +526,7 @@ def set_value(self, key, allowed_types, default_value):
         self.options[key] = value
 
     def require_string_value(self, key):
-        return self.require_value(key, six.string_types)
+        return self.require_value(key, str)
 
     def require_value(self, key, allowed_types):
         config = self.default_config
@@ -539,7 +539,7 @@ def require_value(self, key, allowed_types):
 def resolve_invocation_options(options: dict, invocation_config: DictConfig, invocation_defaults: dict, args: dict) -> dict:
     # get overrides from the main config
     if invocation_config:
-        for k, v in six.iteritems(invocation_defaults):
+        for k, v in invocation_defaults.items():
             if isinstance(v, bool):
                 val = invocation_config.get_bool(k, True)
                 if val is not None:

user_sync/certgen.py

@@ -233,7 +233,7 @@ def get_engine_options(self) -> dict:
         sign_only_user_action = user_sync.get_value('sign_only_user_action', (str, int))
         options['user_sync']['sign_only_user_action'] = sign_only_user_action
         if options.get('directory_group_mapped'):
-            options['directory_group_filter'] = set(six.iterkeys(self.directory_groups))
+            options['directory_group_filter'] = set(self.directory_groups.keys())
         options['cache'] = self.main_config.get_dict('cache')
         return options