cpython: 135aa1c4349d (original) (raw)

--- a/Lib/logging/config.py +++ b/Lib/logging/config.py @@ -277,6 +277,30 @@ def valid_ident(s): return True +class ConvertingMixin(object):

"""For ConvertingXXX's, this mixin class provides common functions"""

def convert_with_key(self, key, value, replace=True):

   result = self.configurator.convert(value)[](#l1.11)

   #If the converted value is different, save for next time[](#l1.12)

```
   if value is not result:[](#l1.13)
```
```
       if replace:[](#l1.14)
```
```
           self[key] = result[](#l1.15)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.16)

                          ConvertingTuple):[](#l1.17)

           result.parent = self[](#l1.18)

```
           result.key = key[](#l1.19)
```
```
   return result[](#l1.20)
```

def convert(self, value):

   result = self.configurator.convert(value)[](#l1.23)

```
   if value is not result:[](#l1.24)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.25)

                          ConvertingTuple):[](#l1.26)

           result.parent = self[](#l1.27)

```
   return result[](#l1.28)
```

+ +

The ConvertingXXX classes are wrappers around standard Python containers,

and they serve to convert any suitable values in the container. The

conversion converts base dicts, lists and tuples to their wrapped

@@ -286,77 +310,37 @@ def valid_ident(s):

Each wrapper should have a configurator attribute holding the actual

configurator to use for conversion.

-class ConvertingDict(dict): +class ConvertingDict(dict, ConvertingMixin): """A converting dictionary wrapper.""" def getitem(self, key): value = dict.getitem(self, key)

   result = self.configurator.convert(value)[](#l1.44)

   #If the converted value is different, save for next time[](#l1.45)

```
   if value is not result:[](#l1.46)
```
```
       self[key] = result[](#l1.47)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.48)

                           ConvertingTuple):[](#l1.49)

           result.parent = self[](#l1.50)

```
           result.key = key[](#l1.51)
```
```
   return result[](#l1.52)
```

   return self.convert_with_key(key, value)[](#l1.53)

def get(self, key, default=None): value = dict.get(self, key, default)

   result = self.configurator.convert(value)[](#l1.57)

   #If the converted value is different, save for next time[](#l1.58)

```
   if value is not result:[](#l1.59)
```
```
       self[key] = result[](#l1.60)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.61)

                           ConvertingTuple):[](#l1.62)

           result.parent = self[](#l1.63)

```
           result.key = key[](#l1.64)
```
```
   return result[](#l1.65)
```

   return self.convert_with_key(key, value)[](#l1.66)

def pop(self, key, default=None): value = dict.pop(self, key, default)

   result = self.configurator.convert(value)[](#l1.70)

```
   if value is not result:[](#l1.71)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.72)

                           ConvertingTuple):[](#l1.73)

           result.parent = self[](#l1.74)

```
           result.key = key[](#l1.75)
```
```
   return result[](#l1.76)
```

   return self.convert_with_key(key, value, replace=False)[](#l1.77)

-class ConvertingList(list): +class ConvertingList(list, ConvertingMixin): """A converting list wrapper.""" def getitem(self, key): value = list.getitem(self, key)

   result = self.configurator.convert(value)[](#l1.84)

   #If the converted value is different, save for next time[](#l1.85)

```
   if value is not result:[](#l1.86)
```
```
       self[key] = result[](#l1.87)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.88)

                           ConvertingTuple):[](#l1.89)

           result.parent = self[](#l1.90)

```
           result.key = key[](#l1.91)
```
```
   return result[](#l1.92)
```

   return self.convert_with_key(key, value)[](#l1.93)

def pop(self, idx=-1): value = list.pop(self, idx)

   result = self.configurator.convert(value)[](#l1.97)

```
   if value is not result:[](#l1.98)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.99)

                           ConvertingTuple):[](#l1.100)

           result.parent = self[](#l1.101)

```
   return result[](#l1.102)
```

   return self.convert(value)[](#l1.103)

-class ConvertingTuple(tuple): +class ConvertingTuple(tuple, ConvertingMixin): """A converting tuple wrapper.""" def getitem(self, key): value = tuple.getitem(self, key)

   result = self.configurator.convert(value)[](#l1.110)

```
   if value is not result:[](#l1.111)
```

       if type(result) in (ConvertingDict, ConvertingList,[](#l1.112)

                           ConvertingTuple):[](#l1.113)

           result.parent = self[](#l1.114)

```
           result.key = key[](#l1.115)
```
```
   return result[](#l1.116)
```

   # Can't replace a tuple entry.[](#l1.117)

   return self.convert_with_key(key, value, replace=False)[](#l1.118)

class BaseConfigurator(object): """