def __init__()

in transcoder/Transcoder.py [0:0]

• 52 lines of code
• 4 McCabe index (conditional complexity)

    def __init__(self,  # pylint: disable=too-many-arguments),too-many-locals
                 factory: str, schema_file_path: str, source_file_path: str, source_file_encoding: str,
                 source_file_format_type: str, source_file_endian: str, prefix_length: int, skip_lines: int,
                 skip_bytes: int, message_skip_bytes: int, quiet: bool, output_type: str, output_encoding: str,
                 output_path: str, error_output_path: str, destination_project_id: str, destination_dataset_id: str,
                 message_handlers: str, lazy_create_resources: bool, frame_only: bool, stats_only: bool,
                 create_schemas_only: bool, continue_on_error: bool, create_schema_enforcing_topics: bool,
                 sampling_count: int, message_type_inclusions: str, message_type_exclusions: str, fix_header_tags: str,
                 fix_separator: int, base64: bool, base64_urlsafe: bool):

        signal.signal(signal.SIGINT, self.trap)

        self.message_handler_spec = message_handlers
        self.message_handlers = {}
        self.all_message_type_handlers = []
        self.all_handlers = []
        self.handlers_enabled = False
        self.continue_on_error = continue_on_error
        self.error_output_path = error_output_path
        self.output_encoding = output_encoding
        self.frame_only = frame_only
        self.create_schemas_only = create_schemas_only
        self.lazy_create_resources = lazy_create_resources
        self.prefix_length = prefix_length
        self.quiet = quiet
        self.start_time = None
        self.stats_only = stats_only
        self.sampling_count = sampling_count
        self.transcoded_count = 0

        self.output_prefix = os.path.basename(
            os.path.splitext(source_file_path)[0]) if source_file_path else 'stdin'

        self.error_writer = ErrorWriter(prefix=self.output_prefix,
                                        output_path=self.error_output_path)

        self.output_manager = get_output_manager(output_type, self.output_prefix, output_path,
                                                 output_encoding, self.prefix_length, destination_project_id,
                                                 destination_dataset_id, lazy_create_resources,
                                                 create_schema_enforcing_topics)

        # TODO: think about this abstraction some more
        if self.output_manager.supports_data_writing() is False:
            self.create_schemas_only = True
        else:
            self.source = get_message_source(source_file_path, source_file_encoding,
                                             source_file_format_type, source_file_endian,
                                             skip_bytes, skip_lines, message_skip_bytes,
                                             prefix_length, base64, base64_urlsafe)

        self.message_parser: DatacastParser = NoParser() if self.frame_only else get_message_parser(
            factory,
            schema_file_path,
            stats_only,
            message_type_inclusions,
            message_type_exclusions,
            fix_header_tags,
            fix_separator
        )

        self.setup_handlers()