Replace import * with explicit imports

lib/yaml/__init__.py

@@ -1,16 +1,51 @@
-
-from .error import *
-
-from .tokens import *
-from .events import *
-from .nodes import *
-
-from .loader import *
-from .dumper import *
+from .error import (Mark, MarkedYAMLError, YAMLError,)
+from .tokens import (AliasToken, AnchorToken, BlockEndToken, BlockEntryToken,
+                     BlockMappingStartToken, BlockSequenceStartToken,
+                     DirectiveToken, DocumentEndToken, DocumentStartToken,
+                     FlowEntryToken, FlowMappingEndToken,
+                     FlowMappingStartToken, FlowSequenceEndToken,
+                     FlowSequenceStartToken, KeyToken, ScalarToken,
+                     StreamEndToken, StreamStartToken, TagToken, Token,
+                     ValueToken,)
+from .events import (AliasEvent, CollectionEndEvent, CollectionStartEvent,
+                     DocumentEndEvent, DocumentStartEvent, Event,
+                     MappingEndEvent, MappingStartEvent, NodeEvent,
+                     ScalarEvent, SequenceEndEvent, SequenceStartEvent,
+                     StreamEndEvent, StreamStartEvent,)
+from .nodes import (CollectionNode, MappingNode, Node, ScalarNode,
+                    SequenceNode,)
+from .loader import (BaseLoader, FullLoader, Loader, SafeLoader, UnsafeLoader,)
+from .dumper import (BaseDumper, Dumper, SafeDumper,)
+
+
+__all__ = ['AliasEvent', 'AliasToken', 'AnchorToken', 'BaseDumper',
+           'BaseLoader', 'BlockEndToken', 'BlockEntryToken',
+           'BlockMappingStartToken', 'BlockSequenceStartToken',
+           'CollectionEndEvent', 'CollectionNode', 'CollectionStartEvent',
+           'DirectiveToken', 'DocumentEndEvent', 'DocumentEndToken',
+           'DocumentStartEvent', 'DocumentStartToken', 'Dumper', 'Event',
+           'FlowEntryToken', 'FlowMappingEndToken', 'FlowMappingStartToken',
+           'FlowSequenceEndToken', 'FlowSequenceStartToken', 'FullLoader',
+           'KeyToken', 'Loader', 'MappingEndEvent', 'MappingNode',
+           'MappingStartEvent', 'Mark', 'MarkedYAMLError', 'Node', 'NodeEvent',
+           'SafeDumper', 'SafeLoader', 'ScalarEvent', 'ScalarNode',
+           'ScalarToken', 'SequenceEndEvent', 'SequenceNode',
+           'SequenceStartEvent', 'StreamEndEvent', 'StreamEndToken',
+           'StreamStartEvent', 'StreamStartToken', 'TagToken', 'Token',
+           'UnsafeLoader', 'ValueToken', 'YAMLError', 'YAMLObject',
+           'YAMLObjectMetaclass', 'add_constructor', 'add_implicit_resolver',
+           'add_multi_constructor', 'add_multi_representer',
+           'add_path_resolver', 'add_representer', 'compose', 'compose_all',
+           'dump', 'dump_all', 'emit', 'full_load', 'full_load_all', 'load',
+           'load_all', 'parse', 'safe_dump', 'safe_dump_all', 'safe_load',
+           'safe_load_all', 'scan', 'serialize', 'serialize_all',
+           'unsafe_load', 'unsafe_load_all', 'warnings']
 
 __version__ = '6.0'
+
 try:
-    from .cyaml import *
+    from yaml.cyaml import (CBaseDumper, CBaseLoader, CDumper, CFullLoader,
+                            CLoader, CSafeDumper, CSafeLoader, CUnsafeLoader,)
     __with_libyaml__ = True
 except ImportError:
     __with_libyaml__ = False
@@ -387,4 +422,3 @@ def to_yaml(cls, dumper, data):
         """
         return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
                 flow_style=cls.yaml_flow_style)
-

lib/yaml/composer.py

@@ -2,8 +2,13 @@
 __all__ = ['Composer', 'ComposerError']
 
 from .error import MarkedYAMLError
-from .events import *
-from .nodes import *
+from .events import (AliasEvent, CollectionEndEvent, CollectionStartEvent,
+                     DocumentEndEvent, DocumentStartEvent, Event,
+                     MappingEndEvent, MappingStartEvent, NodeEvent,
+                     ScalarEvent, SequenceEndEvent, SequenceStartEvent,
+                     StreamEndEvent, StreamStartEvent,)
+from .nodes import (CollectionNode, MappingNode, Node, ScalarNode,
+                    SequenceNode,)
 
 class ComposerError(MarkedYAMLError):
     pass

lib/yaml/constructor.py

@@ -8,8 +8,8 @@
     'ConstructorError'
 ]
 
-from .error import *
-from .nodes import *
+from .error import (Mark, MarkedYAMLError, YAMLError,)
+from .nodes import (Node, ScalarNode, CollectionNode, SequenceNode, MappingNode)
 
 import collections.abc, datetime, base64, binascii, re, sys, types
 

lib/yaml/cyaml.py

@@ -6,12 +6,15 @@
 
 from yaml._yaml import CParser, CEmitter
 
-from .constructor import *
+from yaml.constructor import (BaseConstructor, Constructor, ConstructorError,
+                              FullConstructor, SafeConstructor,
+                              UnsafeConstructor,)
 
-from .serializer import *
-from .representer import *
+from .serializer import (Serializer, SerializerError,)
+from .representer import (BaseRepresenter, Representer, RepresenterError,
+                          SafeRepresenter,)
 
-from .resolver import *
+from .resolver import (BaseResolver, Resolver,)
 
 class CBaseLoader(CParser, BaseConstructor, BaseResolver):
 

lib/yaml/dumper.py

@@ -1,10 +1,11 @@
 
 __all__ = ['BaseDumper', 'SafeDumper', 'Dumper']
 
-from .emitter import *
-from .serializer import *
-from .representer import *
-from .resolver import *
+from .emitter import (Emitter, EmitterError,)
+from .serializer import (Serializer, SerializerError,)
+from .representer import (BaseRepresenter, Representer, RepresenterError,
+                          SafeRepresenter,)
+from .resolver import (BaseResolver, Resolver,)
 
 class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
 

lib/yaml/emitter.py

@@ -9,7 +9,12 @@
 __all__ = ['Emitter', 'EmitterError']
 
 from .error import YAMLError
-from .events import *
+from .events import (AliasEvent, CollectionEndEvent, CollectionStartEvent,
+                     DocumentEndEvent, DocumentStartEvent, Event,
+                     MappingEndEvent, MappingStartEvent, NodeEvent,
+                     ScalarEvent, SequenceEndEvent, SequenceStartEvent,
+                     StreamEndEvent, StreamStartEvent,)
+
 
 class EmitterError(YAMLError):
     pass

lib/yaml/loader.py

@@ -1,12 +1,13 @@
 
 __all__ = ['BaseLoader', 'FullLoader', 'SafeLoader', 'Loader', 'UnsafeLoader']
 
-from .reader import *
-from .scanner import *
-from .parser import *
-from .composer import *
-from .constructor import *
-from .resolver import *
+from .reader import (Reader, ReaderError,)
+from .scanner import (Scanner, ScannerError,)
+from .parser import (Parser, ParserError,)
+from .composer import (Composer, ComposerError,)
+from .constructor import (BaseConstructor, Constructor, ConstructorError,
+                          FullConstructor, SafeConstructor, UnsafeConstructor,)
+from .resolver import (BaseResolver, Resolver,)
 
 class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
 

lib/yaml/parser.py

@@ -62,9 +62,20 @@
 __all__ = ['Parser', 'ParserError']
 
 from .error import MarkedYAMLError
-from .tokens import *
-from .events import *
-from .scanner import *
+from .tokens import (AliasToken, AnchorToken, BlockEndToken, BlockEntryToken,
+                     BlockMappingStartToken, BlockSequenceStartToken,
+                     DirectiveToken, DocumentEndToken, DocumentStartToken,
+                     FlowEntryToken, FlowMappingEndToken,
+                     FlowMappingStartToken, FlowSequenceEndToken,
+                     FlowSequenceStartToken, KeyToken, ScalarToken,
+                     StreamEndToken, StreamStartToken, TagToken, Token,
+                     ValueToken,)
+from .events import (AliasEvent, CollectionEndEvent, CollectionStartEvent,
+                     DocumentEndEvent, DocumentStartEvent, Event,
+                     MappingEndEvent, MappingStartEvent, NodeEvent,
+                     ScalarEvent, SequenceEndEvent, SequenceStartEvent,
+                     StreamEndEvent, StreamStartEvent,)
+from .scanner import (Scanner, ScannerError,)
 
 class ParserError(MarkedYAMLError):
     pass
@@ -482,7 +493,7 @@ def parse_flow_sequence_entry(self, first=False):
                     token = self.peek_token()
                     raise ParserError("while parsing a flow sequence", self.marks[-1],
                             "expected ',' or ']', but got %r" % token.id, token.start_mark)
-            
+
             if self.check_token(KeyToken):
                 token = self.peek_token()
                 event = MappingStartEvent(None, None, True,

lib/yaml/representer.py

@@ -2,8 +2,9 @@
 __all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer',
     'RepresenterError']
 
-from .error import *
-from .nodes import *
+from .error import (Mark, MarkedYAMLError, YAMLError,)
+from .nodes import (CollectionNode, MappingNode, Node, ScalarNode,
+                    SequenceNode,)
 
 import datetime, copyreg, types, base64, collections
 

lib/yaml/resolver.py

@@ -1,8 +1,9 @@
 
 __all__ = ['BaseResolver', 'Resolver']
 
-from .error import *
-from .nodes import *
+from .error import (Mark, MarkedYAMLError, YAMLError,)
+from .nodes import (CollectionNode, MappingNode, Node, ScalarNode,
+                    SequenceNode,)
 
 import re
 

lib/yaml/scanner.py

@@ -27,7 +27,14 @@
 __all__ = ['Scanner', 'ScannerError']
 
 from .error import MarkedYAMLError
-from .tokens import *
+from .tokens import (AliasToken, AnchorToken, BlockEndToken, BlockEntryToken,
+                     BlockMappingStartToken, BlockSequenceStartToken,
+                     DirectiveToken, DocumentEndToken, DocumentStartToken,
+                     FlowEntryToken, FlowMappingEndToken,
+                     FlowMappingStartToken, FlowSequenceEndToken,
+                     FlowSequenceStartToken, KeyToken, ScalarToken,
+                     StreamEndToken, StreamStartToken, TagToken, Token,
+                     ValueToken,)
 
 class ScannerError(MarkedYAMLError):
     pass
@@ -313,7 +320,7 @@ def remove_possible_simple_key(self):
         # Remove the saved possible key position at the current flow level.
         if self.flow_level in self.possible_simple_keys:
             key = self.possible_simple_keys[self.flow_level]
-            
+
             if key.required:
                 raise ScannerError("while scanning a simple key", key.mark,
                         "could not find expected ':'", self.get_mark())
@@ -362,11 +369,11 @@ def fetch_stream_start(self):
 
         # Read the token.
         mark = self.get_mark()
-        
+
         # Add STREAM-START.
         self.tokens.append(StreamStartToken(mark, mark,
             encoding=self.encoding))
-        
+
 
     def fetch_stream_end(self):
 
@@ -380,15 +387,15 @@ def fetch_stream_end(self):
 
         # Read the token.
         mark = self.get_mark()
-        
+
         # Add STREAM-END.
         self.tokens.append(StreamEndToken(mark, mark))
 
         # The steam is finished.
         self.done = True
 
     def fetch_directive(self):
-        
+
         # Set the current indentation to -1.
         self.unwind_indent(-1)
 
@@ -515,7 +522,7 @@ def fetch_block_entry(self):
         self.tokens.append(BlockEntryToken(start_mark, end_mark))
 
     def fetch_key(self):
-        
+
         # Block context needs additional checks.
         if not self.flow_level:
 
@@ -565,7 +572,7 @@ def fetch_value(self):
 
         # It must be a part of a complex key.
         else:
-            
+
             # Block context needs additional checks.
             # (Do we really need them? They will be caught by the parser
             # anyway.)
@@ -1017,14 +1024,14 @@ def scan_block_scalar(self, style):
                 # Unfortunately, folding rules are ambiguous.
                 #
                 # This is the folding according to the specification:
-                
+
                 if folded and line_break == '\n'    \
                         and leading_non_space and self.peek() not in ' \t':
                     if not breaks:
                         chunks.append(' ')
                 else:
                     chunks.append(line_break)
-                
+
                 # This is Clark Evans's interpretation (also in the spec
                 # examples):
                 #

lib/yaml/serializer.py

@@ -2,8 +2,14 @@
 __all__ = ['Serializer', 'SerializerError']
 
 from .error import YAMLError
-from .events import *
-from .nodes import *
+from .events import (AliasEvent, CollectionEndEvent, CollectionStartEvent,
+                     DocumentEndEvent, DocumentStartEvent, Event,
+                     MappingEndEvent, MappingStartEvent, NodeEvent,
+                     ScalarEvent, SequenceEndEvent, SequenceStartEvent,
+                     StreamEndEvent, StreamStartEvent,)
+from .nodes import (CollectionNode, MappingNode, Node, ScalarNode,
+                    SequenceNode,)
+
 
 class SerializerError(YAMLError):
     pass