f-strings for EasyDNSProvider

octodns/provider/easydns.py

@@ -50,22 +50,22 @@ class EasyDNSClient(object):
 
     def __init__(self, token, api_key, currency, portfolio, sandbox,
                  domain_create_sleep):
-        self.log = logging.getLogger('EasyDNSProvider[{}]'.format(id))
+        self.log = logging.getLogger(f'EasyDNSProvider[{id}]')
         self.default_currency = currency
         self.domain_portfolio = portfolio
         self.domain_create_sleep = domain_create_sleep
 
-        auth_key = '{}:{}'.format(token, api_key)
+        auth_key = f'{token}:{api_key}'
         auth_key = base64.b64encode(auth_key.encode("utf-8"))
+        auth_key = auth_key.decode('utf-8')
         self.base_path = self.SANDBOX if sandbox else self.LIVE
         sess = Session()
-        sess.headers.update({'Authorization': 'Basic {}'
-                             .format(auth_key.decode('utf-8'))})
+        sess.headers.update({'Authorization': f'Basic {auth_key}'})
         sess.headers.update({'accept': 'application/json'})
         self._sess = sess
 
     def _request(self, method, path, params=None, data=None):
-        url = '{}{}'.format(self.base_path, path)
+        url = f'{self.base_path}{path}'
         resp = self._sess.request(method, url, params=params, json=data)
         if resp.status_code == 400:
             self.log.debug('Response code 400, path=%s', path)
@@ -80,14 +80,14 @@ class EasyDNSClient(object):
         return resp
 
     def domain(self, name):
-        path = '/domain/{}'.format(name)
+        path = f'/domain/{name}'
         return self._request('GET', path).json()
 
     def domain_create(self, name):
         # EasyDNS allows for new domains to be created for the purpose of DNS
         # only, or with domain registration. This function creates a DNS only
         # record expectig the domain to be registered already
-        path = '/domains/add/{}'.format(name)
+        path = f'/domains/add/{name}'
         domain_data = {'service': 'dns',
                        'term': 1,
                        'dns_only': 1,
@@ -108,9 +108,9 @@ class EasyDNSClient(object):
 
     def records(self, zone_name, raw=False):
         if raw:
-            path = '/zones/records/all/{}'.format(zone_name)
+            path = f'/zones/records/all/{zone_name}'
         else:
-            path = '/zones/records/parsed/{}'.format(zone_name)
+            path = f'/zones/records/parsed/{zone_name}'
 
         ret = []
         resp = self._request('GET', path).json()
@@ -123,12 +123,12 @@ class EasyDNSClient(object):
 
             # change any apex value to zone name
             if record['rdata'] == '@':
-                record['rdata'] = '{}.'.format(zone_name)
+                record['rdata'] = f'{zone_name}.'
 
         return ret
 
     def record_create(self, zone_name, params):
-        path = '/zones/records/add/{}/{}'.format(zone_name, params['type'])
+        path = f'/zones/records/add/{zone_name}/{params["type"]}'
         # change empty name string to @, EasyDNS uses @ for apex record names
         params['host'] = params['name']
         if params['host'] == '':
@@ -136,7 +136,7 @@ class EasyDNSClient(object):
         self._request('PUT', path, data=params)
 
     def record_delete(self, zone_name, record_id):
-        path = '/zones/records/{}/{}'.format(zone_name, record_id)
+        path = f'/zones/records/{zone_name}/{record_id}'
         self._request('DELETE', path)
 
 
@@ -164,7 +164,7 @@ class EasyDNSProvider(BaseProvider):
 
     def __init__(self, id, token, api_key, currency='CAD', portfolio='myport',
                  sandbox=False, domain_create_sleep=1, *args, **kwargs):
-        self.log = logging.getLogger('EasyDNSProvider[{}]'.format(id))
+        self.log = logging.getLogger(f'EasyDNSProvider[{id}]')
         self.log.debug('__init__: id=%s, token=***', id)
         super(EasyDNSProvider, self).__init__(id, *args, **kwargs)
         self._client = EasyDNSClient(token, api_key, currency, portfolio,
@@ -226,7 +226,7 @@ class EasyDNSProvider(BaseProvider):
         return {
             'ttl': record['ttl'],
             'type': _type,
-            'value': '{}'.format(record['rdata'])
+            'value': str(record['rdata'])
         }
 
     def _data_for_MX(self, _type, records):
@@ -234,7 +234,7 @@ class EasyDNSProvider(BaseProvider):
         for record in records:
             values.append({
                 'preference': record['prio'],
-                'exchange': '{}'.format(record['rdata'])
+                'exchange': str(record['rdata'])
             })
         return {
             'ttl': records[0]['ttl'],
@@ -245,7 +245,7 @@ class EasyDNSProvider(BaseProvider):
     def _data_for_NS(self, _type, records):
         values = []
         for record in records:
-            data = '{}'.format(record['rdata'])
+            data = str(record['rdata'])
             values.append(data)
         return {
             'ttl': records[0]['ttl'],
@@ -318,7 +318,7 @@ class EasyDNSProvider(BaseProvider):
         before = len(zone.records)
         for name, types in values.items():
             for _type, records in types.items():
-                data_for = getattr(self, '_data_for_{}'.format(_type))
+                data_for = getattr(self, f'_data_for_{_type}')
                 record = Record.new(zone, name, data_for(_type, records),
                                     source=self, lenient=lenient)
                 zone.add_record(record, lenient=lenient)
@@ -344,8 +344,7 @@ class EasyDNSProvider(BaseProvider):
     def _params_for_CAA(self, record):
         for value in record.values:
             yield {
-                'rdata': "{} {} {}".format(value.flags, value.tag,
-                                           value.value),
+                'rdata': f"{value.flags} {value.tag} {value.value}",
                 'name': record.name,
                 'ttl': record.ttl,
                 'type': record._type
@@ -353,12 +352,8 @@ class EasyDNSProvider(BaseProvider):
 
     def _params_for_NAPTR(self, record):
         for value in record.values:
-            content = '{} {} "{}" "{}" "{}" {}'.format(value.order,
-                                                       value.preference,
-                                                       value.flags,
-                                                       value.service,
-                                                       value.regexp,
-                                                       value.replacement)
+            content = f'{value.order} {value.preference} "{value.flags}" ' \
+                f'"{value.service}" "{value.regexp}" {value.replacement}'
             yield {
                 'rdata': content,
                 'name': record.name,
@@ -389,8 +384,8 @@ class EasyDNSProvider(BaseProvider):
     def _params_for_SRV(self, record):
         for value in record.values:
             yield {
-                'rdata': "{} {} {} {}".format(value.priority, value.port,
-                                              value.weight, value.target),
+                'rdata': f"{value.priority} {value.port} {value.weight} "
+                f"{value.target}",
                 'name': record.name,
                 'ttl': record.ttl,
                 'type': record._type,
@@ -407,7 +402,7 @@ class EasyDNSProvider(BaseProvider):
 
     def _apply_Create(self, change):
         new = change.new
-        params_for = getattr(self, '_params_for_{}'.format(new._type))
+        params_for = getattr(self, f'_params_for_{new._type}')
         for params in params_for(new):
             self._client.record_create(new.zone.name[:-1], params)
 
@@ -440,7 +435,7 @@ class EasyDNSProvider(BaseProvider):
 
         for change in changes:
             class_name = change.__class__.__name__
-            getattr(self, '_apply_{}'.format(class_name))(change)
+            getattr(self, f'_apply_{class_name}')(change)
 
         # Clear out the cache if any
         self._zone_records.pop(desired.name, None)