From adf08a178adb0759a44c18cb5deb3fd1ce1d90fc Mon Sep 17 00:00:00 2001 From: Ross McFarland Date: Sat, 4 Sep 2021 19:08:29 -0700 Subject: [PATCH] f-strings for Manager, Zone and yaml --- octodns/manager.py | 116 +++++++++++++++++++++------------------------ octodns/yaml.py | 4 +- octodns/zone.py | 29 +++++------- 3 files changed, 70 insertions(+), 79 deletions(-) diff --git a/octodns/manager.py b/octodns/manager.py index 104e445..7df65d9 100644 --- a/octodns/manager.py +++ b/octodns/manager.py @@ -111,16 +111,16 @@ class Manager(object): _class = provider_config.pop('class') except KeyError: self.log.exception('Invalid provider class') - raise ManagerException('Provider {} is missing class' - .format(provider_name)) + raise ManagerException(f'Provider {provider_name} is missing ' + 'class') _class = self._get_named_class('provider', _class) kwargs = self._build_kwargs(provider_config) try: self.providers[provider_name] = _class(provider_name, **kwargs) except TypeError: self.log.exception('Invalid provider config') - raise ManagerException('Incorrect provider config for {}' - .format(provider_name)) + raise ManagerException('Incorrect provider config for ' + + provider_name) self.processors = {} for processor_name, processor_config in \ @@ -129,8 +129,8 @@ class Manager(object): _class = processor_config.pop('class') except KeyError: self.log.exception('Invalid processor class') - raise ManagerException('Processor {} is missing class' - .format(processor_name)) + raise ManagerException(f'Processor {processor_name} is ' + 'missing class') _class = self._get_named_class('processor', _class) kwargs = self._build_kwargs(processor_config) try: @@ -138,8 +138,8 @@ class Manager(object): **kwargs) except TypeError: self.log.exception('Invalid processor config') - raise ManagerException('Incorrect processor config for {}' - .format(processor_name)) + raise ManagerException('Incorrect processor config for ' + + processor_name) zone_tree = {} # sort by reversed strings so that parent zones always come first @@ -173,8 +173,8 @@ class Manager(object): _class = plan_output_config.pop('class') except KeyError: self.log.exception('Invalid plan_output class') - raise ManagerException('plan_output {} is missing class' - .format(plan_output_name)) + raise ManagerException(f'plan_output {plan_output_name} is ' + 'missing class') _class = self._get_named_class('plan_output', _class) kwargs = self._build_kwargs(plan_output_config) try: @@ -182,8 +182,8 @@ class Manager(object): _class(plan_output_name, **kwargs) except TypeError: self.log.exception('Invalid plan_output config') - raise ManagerException('Incorrect plan_output config for {}' - .format(plan_output_name)) + raise ManagerException('Incorrect plan_output config for ' + + plan_output_name) def _get_named_class(self, _type, _class): try: @@ -192,15 +192,13 @@ class Manager(object): except (ImportError, ValueError): self.log.exception('_get_{}_class: Unable to import ' 'module %s', _class) - raise ManagerException('Unknown {} class: {}' - .format(_type, _class)) + raise ManagerException(f'Unknown {_type} class: {_class}') try: return getattr(module, class_name) except AttributeError: self.log.exception('_get_{}_class: Unable to get class %s ' 'from module %s', class_name, module) - raise ManagerException('Unknown {} class: {}' - .format(_type, _class)) + raise ManagerException(f'Unknown {_type} class: {_class}') def _build_kwargs(self, source): # Build up the arguments we need to pass to the provider @@ -214,8 +212,7 @@ class Manager(object): except KeyError: self.log.exception('Invalid provider config') raise ManagerException('Incorrect provider config, ' - 'missing env var {}' - .format(env_var)) + 'missing env var ' + env_var) except AttributeError: pass kwargs[k] = v @@ -279,7 +276,7 @@ class Manager(object): meta = Record.new(zone, 'octodns-meta', { 'type': 'TXT', 'ttl': 60, - 'value': 'provider={}'.format(target.id) + 'value': f'provider={target.id}', }) zone.add_record(meta, replace=True) try: @@ -322,19 +319,19 @@ class Manager(object): # Check that the source zone is defined. if source_zone not in self.config['zones']: - self.log.error('Invalid alias zone {}, target {} does ' - 'not exist'.format(zone_name, source_zone)) - raise ManagerException('Invalid alias zone {}: ' - 'source zone {} does not exist' - .format(zone_name, source_zone)) + self.log.error(f'Invalid alias zone {zone_name}, ' + f'target {source_zone} does not exist') + raise ManagerException(f'Invalid alias zone {zone_name}: ' + f'source zone {source_zone} does ' + 'not exist') # Check that the source zone is not an alias zone itself. if 'alias' in self.config['zones'][source_zone]: - self.log.error('Invalid alias zone {}, target {} is an ' - 'alias zone'.format(zone_name, source_zone)) - raise ManagerException('Invalid alias zone {}: source ' - 'zone {} is an alias zone' - .format(zone_name, source_zone)) + self.log.error(f'Invalid alias zone {zone_name}, ' + f'target {source_zone} is an alias zone') + raise ManagerException(f'Invalid alias zone {zone_name}: ' + f'source zone {source_zone} is an ' + 'alias zone') aliased_zones[zone_name] = source_zone continue @@ -343,14 +340,12 @@ class Manager(object): try: sources = config['sources'] except KeyError: - raise ManagerException('Zone {} is missing sources' - .format(zone_name)) + raise ManagerException(f'Zone {zone_name} is missing sources') try: targets = config['targets'] except KeyError: - raise ManagerException('Zone {} is missing targets' - .format(zone_name)) + raise ManagerException(f'Zone {zone_name} is missing targets') processors = config.get('processors', []) @@ -377,8 +372,8 @@ class Manager(object): collected.append(self.processors[processor]) processors = collected except KeyError: - raise ManagerException('Zone {}, unknown processor: {}' - .format(zone_name, processor)) + raise ManagerException(f'Zone {zone_name}, unknown ' + f'processor: {processor}') try: # rather than using a list comprehension, we break this loop @@ -389,21 +384,21 @@ class Manager(object): collected.append(self.providers[source]) sources = collected except KeyError: - raise ManagerException('Zone {}, unknown source: {}' - .format(zone_name, source)) + raise ManagerException(f'Zone {zone_name}, unknown ' + f'source: {source}') try: trgs = [] for target in targets: trg = self.providers[target] if not isinstance(trg, BaseProvider): - raise ManagerException('{} - "{}" does not support ' - 'targeting'.format(trg, target)) + raise ManagerException(f'{trg} - "{target}" does not ' + 'support targeting') trgs.append(trg) targets = trgs except KeyError: - raise ManagerException('Zone {}, unknown target: {}' - .format(zone_name, target)) + raise ManagerException(f'Zone {zone_name}, unknown ' + f'target: {target}') futures.append(self._executor.submit(self._populate_and_plan, zone_name, processors, @@ -427,9 +422,9 @@ class Manager(object): try: desired_config = desired[zone_source] except KeyError: - raise ManagerException('Zone {} cannot be sync without zone ' - '{} sinced it is aliased' - .format(zone_name, zone_source)) + raise ManagerException(f'Zone {zone_name} cannot be sync ' + f'without zone {zone_source} sinced ' + 'it is aliased') futures.append(self._executor.submit( self._populate_and_plan, zone_name, @@ -488,7 +483,7 @@ class Manager(object): a = [self.providers[source] for source in a] b = [self.providers[source] for source in b] except KeyError as e: - raise ManagerException('Unknown source: {}'.format(e.args[0])) + raise ManagerException(f'Unknown source: {e.args[0]}') za = self.get_zone(zone) for source in a: @@ -513,7 +508,7 @@ class Manager(object): try: sources = [self.providers[s] for s in sources] except KeyError as e: - raise ManagerException('Unknown source: {}'.format(e.args[0])) + raise ManagerException(f'Unknown source: {e.args[0]}') clz = YamlProvider if split: @@ -537,15 +532,15 @@ class Manager(object): if source_zone: if source_zone not in self.config['zones']: self.log.exception('Invalid alias zone') - raise ManagerException('Invalid alias zone {}: ' - 'source zone {} does not exist' - .format(zone_name, source_zone)) + raise ManagerException(f'Invalid alias zone {zone_name}: ' + f'source zone {source_zone} does ' + 'not exist') if 'alias' in self.config['zones'][source_zone]: self.log.exception('Invalid alias zone') - raise ManagerException('Invalid alias zone {}: ' - 'source zone {} is an alias zone' - .format(zone_name, source_zone)) + raise ManagerException(f'Invalid alias zone {zone_name}: ' + 'source zone {source_zone} is an ' + 'alias zone') # this is just here to satisfy coverage, see # https://github.com/nedbat/coveragepy/issues/198 @@ -555,8 +550,7 @@ class Manager(object): try: sources = config['sources'] except KeyError: - raise ManagerException('Zone {} is missing sources' - .format(zone_name)) + raise ManagerException(f'Zone {zone_name} is missing sources') try: # rather than using a list comprehension, we break this @@ -567,8 +561,8 @@ class Manager(object): collected.append(self.providers[source]) sources = collected except KeyError: - raise ManagerException('Zone {}, unknown source: {}' - .format(zone_name, source)) + raise ManagerException(f'Zone {zone_name}, unknown source: ' + + source) for source in sources: if isinstance(source, YamlProvider): @@ -581,16 +575,16 @@ class Manager(object): for processor in processors: collected.append(self.processors[processor]) except KeyError: - raise ManagerException('Zone {}, unknown processor: {}' - .format(zone_name, processor)) + raise ManagerException(f'Zone {zone_name}, unknown ' + f'processor: {processor}') def get_zone(self, zone_name): if not zone_name[-1] == '.': - raise ManagerException('Invalid zone name {}, missing ending dot' - .format(zone_name)) + raise ManagerException(f'Invalid zone name {zone_name}, missing ' + 'ending dot') for name, config in self.config['zones'].items(): if name == zone_name: return Zone(name, self.configured_sub_zones(name)) - raise ManagerException('Unknown zone name {}'.format(zone_name)) + raise ManagerException(f'Unknown zone name {zone_name}') diff --git a/octodns/yaml.py b/octodns/yaml.py index 4187199..7e0101c 100644 --- a/octodns/yaml.py +++ b/octodns/yaml.py @@ -26,8 +26,8 @@ class SortEnforcingLoader(SafeLoader): expected = keys_sorted.pop(0) if key != expected: raise ConstructorError(None, None, 'keys out of order: ' - 'expected {} got {} at {}' - .format(expected, key, node.start_mark)) + f'expected {expected} got {key} at ' + + str(node.start_mark)) return dict(ret) diff --git a/octodns/zone.py b/octodns/zone.py index dcc07c3..84a56c7 100644 --- a/octodns/zone.py +++ b/octodns/zone.py @@ -37,8 +37,7 @@ class Zone(object): def __init__(self, name, sub_zones): if not name[-1] == '.': - raise Exception('Invalid zone name {}, missing ending dot' - .format(name)) + raise Exception(f'Invalid zone name {name}, missing ending dot') # Force everything to lowercase just to be safe self.name = text_type(name).lower() if name else name self.sub_zones = sub_zones @@ -47,7 +46,7 @@ class Zone(object): self._records = defaultdict(set) # optional leading . to match empty hostname # optional trailing . b/c some sources don't have it on their fqdn - self._name_re = re.compile(r'\.?{}?$'.format(name)) + self._name_re = re.compile(fr'\.?{name}?$') # Copy-on-write semantics support, when `not None` this property will # point to a location with records for this `Zone`. Once `hydrated` @@ -75,14 +74,13 @@ class Zone(object): if not lenient and last in self.sub_zones: if name != last: # it's a record for something under a sub-zone - raise SubzoneRecordException('Record {} is under a ' - 'managed subzone' - .format(record.fqdn)) + raise SubzoneRecordException(f'Record {record.fqdn} is under ' + 'a managed subzone') elif record._type != 'NS': # It's a non NS record for exactly a sub-zone - raise SubzoneRecordException('Record {} a managed sub-zone ' - 'and not of type NS' - .format(record.fqdn)) + raise SubzoneRecordException(f'Record {record.fqdn} a ' + 'managed sub-zone and not of ' + 'type NS') if replace: # will remove it if it exists @@ -91,16 +89,15 @@ class Zone(object): node = self._records[name] if record in node: # We already have a record at this node of this type - raise DuplicateRecordException('Duplicate record {}, type {}' - .format(record.fqdn, - record._type)) + raise DuplicateRecordException(f'Duplicate record {record.fqdn}, ' + f'type {record._type}') elif not lenient and ((record._type == 'CNAME' and len(node) > 0) or ('CNAME' in [r._type for r in node])): # We're adding a CNAME to existing records or adding to an existing # CNAME - raise InvalidNodeException('Invalid state, CNAME at {} cannot ' - 'coexist with other records' - .format(record.fqdn)) + raise InvalidNodeException('Invalid state, CNAME at ' + f'{record.fqdn} cannot coexist with ' + 'other records') node.add(record) @@ -236,4 +233,4 @@ class Zone(object): return copy def __repr__(self): - return 'Zone<{}>'.format(self.name) + return f'Zone<{self.name}>'