Coverage for /var/srv/projects/api.amasfac.comuna18.com/tmp/venv/lib/python3.9/site-packages/yaml/emitter.py: 6%

1 

2# Emitter expects events obeying the following grammar: 

3# stream ::= STREAM-START document* STREAM-END 

4# document ::= DOCUMENT-START node DOCUMENT-END 

5# node ::= SCALAR | sequence | mapping 

6# sequence ::= SEQUENCE-START node* SEQUENCE-END 

7# mapping ::= MAPPING-START (node node)* MAPPING-END 

8 

9__all__ = ['Emitter', 'EmitterError'] 

10 

11from .error import YAMLError 

12from .events import * 

13 

14class EmitterError(YAMLError): 

15 pass 

16 

17class ScalarAnalysis: 

18 def __init__(self, scalar, empty, multiline, 

19 allow_flow_plain, allow_block_plain, 

20 allow_single_quoted, allow_double_quoted, 

21 allow_block): 

22 self.scalar = scalar 

23 self.empty = empty 

24 self.multiline = multiline 

25 self.allow_flow_plain = allow_flow_plain 

26 self.allow_block_plain = allow_block_plain 

27 self.allow_single_quoted = allow_single_quoted 

28 self.allow_double_quoted = allow_double_quoted 

29 self.allow_block = allow_block 

30 

31class Emitter: 

32 

33 DEFAULT_TAG_PREFIXES = { 

34 '!' : '!', 

35 'tag:yaml.org,2002:' : '!!', 

36 } 

37 

38 def __init__(self, stream, canonical=None, indent=None, width=None, 

39 allow_unicode=None, line_break=None): 

40 

41 # The stream should have the methods `write` and possibly `flush`. 

42 self.stream = stream 

43 

44 # Encoding can be overridden by STREAM-START. 

45 self.encoding = None 

46 

47 # Emitter is a state machine with a stack of states to handle nested 

48 # structures. 

49 self.states = [] 

50 self.state = self.expect_stream_start 

51 

52 # Current event and the event queue. 

53 self.events = [] 

54 self.event = None 

55 

56 # The current indentation level and the stack of previous indents. 

57 self.indents = [] 

58 self.indent = None 

59 

60 # Flow level. 

61 self.flow_level = 0 

62 

63 # Contexts. 

64 self.root_context = False 

65 self.sequence_context = False 

66 self.mapping_context = False 

67 self.simple_key_context = False 

68 

69 # Characteristics of the last emitted character: 

70 # - current position. 

71 # - is it a whitespace? 

72 # - is it an indention character 

73 # (indentation space, '-', '?', or ':')? 

74 self.line = 0 

75 self.column = 0 

76 self.whitespace = True 

77 self.indention = True 

78 

79 # Whether the document requires an explicit document indicator 

80 self.open_ended = False 

81 

82 # Formatting details. 

83 self.canonical = canonical 

84 self.allow_unicode = allow_unicode 

85 self.best_indent = 2 

86 if indent and 1 < indent < 10: 

87 self.best_indent = indent 

88 self.best_width = 80 

89 if width and width > self.best_indent*2: 

90 self.best_width = width 

91 self.best_line_break = '\n' 

92 if line_break in ['\r', '\n', '\r\n']: 

93 self.best_line_break = line_break 

94 

95 # Tag prefixes. 

96 self.tag_prefixes = None 

97 

98 # Prepared anchor and tag. 

99 self.prepared_anchor = None 

100 self.prepared_tag = None 

101 

102 # Scalar analysis and style. 

103 self.analysis = None 

104 self.style = None 

105 

106 def dispose(self): 

107 # Reset the state attributes (to clear self-references) 

108 self.states = [] 

109 self.state = None 

110 

111 def emit(self, event): 

112 self.events.append(event) 

113 while not self.need_more_events(): 

114 self.event = self.events.pop(0) 

115 self.state() 

116 self.event = None 

117 

118 # In some cases, we wait for a few next events before emitting. 

119 

120 def need_more_events(self): 

121 if not self.events: 

122 return True 

123 event = self.events[0] 

124 if isinstance(event, DocumentStartEvent): 

125 return self.need_events(1) 

126 elif isinstance(event, SequenceStartEvent): 

127 return self.need_events(2) 

128 elif isinstance(event, MappingStartEvent): 

129 return self.need_events(3) 

130 else: 

131 return False 

132 

133 def need_events(self, count): 

134 level = 0 

135 for event in self.events[1:]: 

136 if isinstance(event, (DocumentStartEvent, CollectionStartEvent)): 

137 level += 1 

138 elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)): 

139 level -= 1 

140 elif isinstance(event, StreamEndEvent): 

141 level = -1 

142 if level < 0: 

143 return False 

144 return (len(self.events) < count+1) 

145 

146 def increase_indent(self, flow=False, indentless=False): 

147 self.indents.append(self.indent) 

148 if self.indent is None: 

149 if flow: 

150 self.indent = self.best_indent 

151 else: 

152 self.indent = 0 

153 elif not indentless: 

154 self.indent += self.best_indent 

155 

156 # States. 

157 

158 # Stream handlers. 

159 

160 def expect_stream_start(self): 

161 if isinstance(self.event, StreamStartEvent): 

162 if self.event.encoding and not hasattr(self.stream, 'encoding'): 

163 self.encoding = self.event.encoding 

164 self.write_stream_start() 

165 self.state = self.expect_first_document_start 

166 else: 

167 raise EmitterError("expected StreamStartEvent, but got %s" 

168 % self.event) 

169 

170 def expect_nothing(self): 

171 raise EmitterError("expected nothing, but got %s" % self.event) 

172 

173 # Document handlers. 

174 

175 def expect_first_document_start(self): 

176 return self.expect_document_start(first=True) 

177 

178 def expect_document_start(self, first=False): 

179 if isinstance(self.event, DocumentStartEvent): 

180 if (self.event.version or self.event.tags) and self.open_ended: 

181 self.write_indicator('...', True) 

182 self.write_indent() 

183 if self.event.version: 

184 version_text = self.prepare_version(self.event.version) 

185 self.write_version_directive(version_text) 

186 self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy() 

187 if self.event.tags: 

188 handles = sorted(self.event.tags.keys()) 

189 for handle in handles: 

190 prefix = self.event.tags[handle] 

191 self.tag_prefixes[prefix] = handle 

192 handle_text = self.prepare_tag_handle(handle) 

193 prefix_text = self.prepare_tag_prefix(prefix) 

194 self.write_tag_directive(handle_text, prefix_text) 

195 implicit = (first and not self.event.explicit and not self.canonical 

196 and not self.event.version and not self.event.tags 

197 and not self.check_empty_document()) 

198 if not implicit: 

199 self.write_indent() 

200 self.write_indicator('---', True) 

201 if self.canonical: 

202 self.write_indent() 

203 self.state = self.expect_document_root 

204 elif isinstance(self.event, StreamEndEvent): 

205 if self.open_ended: 

206 self.write_indicator('...', True) 

207 self.write_indent() 

208 self.write_stream_end() 

209 self.state = self.expect_nothing 

210 else: 

211 raise EmitterError("expected DocumentStartEvent, but got %s" 

212 % self.event) 

213 

214 def expect_document_end(self): 

215 if isinstance(self.event, DocumentEndEvent): 

216 self.write_indent() 

217 if self.event.explicit: 

218 self.write_indicator('...', True) 

219 self.write_indent() 

220 self.flush_stream() 

221 self.state = self.expect_document_start 

222 else: 

223 raise EmitterError("expected DocumentEndEvent, but got %s" 

224 % self.event) 

225 

226 def expect_document_root(self): 

227 self.states.append(self.expect_document_end) 

228 self.expect_node(root=True) 

229 

230 # Node handlers. 

231 

232 def expect_node(self, root=False, sequence=False, mapping=False, 

233 simple_key=False): 

234 self.root_context = root 

235 self.sequence_context = sequence 

236 self.mapping_context = mapping 

237 self.simple_key_context = simple_key 

238 if isinstance(self.event, AliasEvent): 

239 self.expect_alias() 

240 elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): 

241 self.process_anchor('&') 

242 self.process_tag() 

243 if isinstance(self.event, ScalarEvent): 

244 self.expect_scalar() 

245 elif isinstance(self.event, SequenceStartEvent): 

246 if self.flow_level or self.canonical or self.event.flow_style \ 

247 or self.check_empty_sequence(): 

248 self.expect_flow_sequence() 

249 else: 

250 self.expect_block_sequence() 

251 elif isinstance(self.event, MappingStartEvent): 

252 if self.flow_level or self.canonical or self.event.flow_style \ 

253 or self.check_empty_mapping(): 

254 self.expect_flow_mapping() 

255 else: 

256 self.expect_block_mapping() 

257 else: 

258 raise EmitterError("expected NodeEvent, but got %s" % self.event) 

259 

260 def expect_alias(self): 

261 if self.event.anchor is None: 

262 raise EmitterError("anchor is not specified for alias") 

263 self.process_anchor('*') 

264 self.state = self.states.pop() 

265 

266 def expect_scalar(self): 

267 self.increase_indent(flow=True) 

268 self.process_scalar() 

269 self.indent = self.indents.pop() 

270 self.state = self.states.pop() 

271 

272 # Flow sequence handlers. 

273 

274 def expect_flow_sequence(self): 

275 self.write_indicator('[', True, whitespace=True) 

276 self.flow_level += 1 

277 self.increase_indent(flow=True) 

278 self.state = self.expect_first_flow_sequence_item 

279 

280 def expect_first_flow_sequence_item(self): 

281 if isinstance(self.event, SequenceEndEvent): 

282 self.indent = self.indents.pop() 

283 self.flow_level -= 1 

284 self.write_indicator(']', False) 

285 self.state = self.states.pop() 

286 else: 

287 if self.canonical or self.column > self.best_width: 

288 self.write_indent() 

289 self.states.append(self.expect_flow_sequence_item) 

290 self.expect_node(sequence=True) 

291 

292 def expect_flow_sequence_item(self): 

293 if isinstance(self.event, SequenceEndEvent): 

294 self.indent = self.indents.pop() 

295 self.flow_level -= 1 

296 if self.canonical: 

297 self.write_indicator(',', False) 

298 self.write_indent() 

299 self.write_indicator(']', False) 

300 self.state = self.states.pop() 

301 else: 

302 self.write_indicator(',', False) 

303 if self.canonical or self.column > self.best_width: 

304 self.write_indent() 

305 self.states.append(self.expect_flow_sequence_item) 

306 self.expect_node(sequence=True) 

307 

308 # Flow mapping handlers. 

309 

310 def expect_flow_mapping(self): 

311 self.write_indicator('{', True, whitespace=True) 

312 self.flow_level += 1 

313 self.increase_indent(flow=True) 

314 self.state = self.expect_first_flow_mapping_key 

315 

316 def expect_first_flow_mapping_key(self): 

317 if isinstance(self.event, MappingEndEvent): 

318 self.indent = self.indents.pop() 

319 self.flow_level -= 1 

320 self.write_indicator('}', False) 

321 self.state = self.states.pop() 

322 else: 

323 if self.canonical or self.column > self.best_width: 

324 self.write_indent() 

325 if not self.canonical and self.check_simple_key(): 

326 self.states.append(self.expect_flow_mapping_simple_value) 

327 self.expect_node(mapping=True, simple_key=True) 

328 else: 

329 self.write_indicator('?', True) 

330 self.states.append(self.expect_flow_mapping_value) 

331 self.expect_node(mapping=True) 

332 

333 def expect_flow_mapping_key(self): 

334 if isinstance(self.event, MappingEndEvent): 

335 self.indent = self.indents.pop() 

336 self.flow_level -= 1 

337 if self.canonical: 

338 self.write_indicator(',', False) 

339 self.write_indent() 

340 self.write_indicator('}', False) 

341 self.state = self.states.pop() 

342 else: 

343 self.write_indicator(',', False) 

344 if self.canonical or self.column > self.best_width: 

345 self.write_indent() 

346 if not self.canonical and self.check_simple_key(): 

347 self.states.append(self.expect_flow_mapping_simple_value) 

348 self.expect_node(mapping=True, simple_key=True) 

349 else: 

350 self.write_indicator('?', True) 

351 self.states.append(self.expect_flow_mapping_value) 

352 self.expect_node(mapping=True) 

353 

354 def expect_flow_mapping_simple_value(self): 

355 self.write_indicator(':', False) 

356 self.states.append(self.expect_flow_mapping_key) 

357 self.expect_node(mapping=True) 

358 

359 def expect_flow_mapping_value(self): 

360 if self.canonical or self.column > self.best_width: 

361 self.write_indent() 

362 self.write_indicator(':', True) 

363 self.states.append(self.expect_flow_mapping_key) 

364 self.expect_node(mapping=True) 

365 

366 # Block sequence handlers. 

367 

368 def expect_block_sequence(self): 

369 indentless = (self.mapping_context and not self.indention) 

370 self.increase_indent(flow=False, indentless=indentless) 

371 self.state = self.expect_first_block_sequence_item 

372 

373 def expect_first_block_sequence_item(self): 

374 return self.expect_block_sequence_item(first=True) 

375 

376 def expect_block_sequence_item(self, first=False): 

377 if not first and isinstance(self.event, SequenceEndEvent): 

378 self.indent = self.indents.pop() 

379 self.state = self.states.pop() 

380 else: 

381 self.write_indent() 

382 self.write_indicator('-', True, indention=True) 

383 self.states.append(self.expect_block_sequence_item) 

384 self.expect_node(sequence=True) 

385 

386 # Block mapping handlers. 

387 

388 def expect_block_mapping(self): 

389 self.increase_indent(flow=False) 

390 self.state = self.expect_first_block_mapping_key 

391 

392 def expect_first_block_mapping_key(self): 

393 return self.expect_block_mapping_key(first=True) 

394 

395 def expect_block_mapping_key(self, first=False): 

396 if not first and isinstance(self.event, MappingEndEvent): 

397 self.indent = self.indents.pop() 

398 self.state = self.states.pop() 

399 else: 

400 self.write_indent() 

401 if self.check_simple_key(): 

402 self.states.append(self.expect_block_mapping_simple_value) 

403 self.expect_node(mapping=True, simple_key=True) 

404 else: 

405 self.write_indicator('?', True, indention=True) 

406 self.states.append(self.expect_block_mapping_value) 

407 self.expect_node(mapping=True) 

408 

409 def expect_block_mapping_simple_value(self): 

410 self.write_indicator(':', False) 

411 self.states.append(self.expect_block_mapping_key) 

412 self.expect_node(mapping=True) 

413 

414 def expect_block_mapping_value(self): 

415 self.write_indent() 

416 self.write_indicator(':', True, indention=True) 

417 self.states.append(self.expect_block_mapping_key) 

418 self.expect_node(mapping=True) 

419 

420 # Checkers. 

421 

422 def check_empty_sequence(self): 

423 return (isinstance(self.event, SequenceStartEvent) and self.events 

424 and isinstance(self.events[0], SequenceEndEvent)) 

425 

426 def check_empty_mapping(self): 

427 return (isinstance(self.event, MappingStartEvent) and self.events 

428 and isinstance(self.events[0], MappingEndEvent)) 

429 

430 def check_empty_document(self): 

431 if not isinstance(self.event, DocumentStartEvent) or not self.events: 

432 return False 

433 event = self.events[0] 

434 return (isinstance(event, ScalarEvent) and event.anchor is None 

435 and event.tag is None and event.implicit and event.value == '') 

436 

437 def check_simple_key(self): 

438 length = 0 

439 if isinstance(self.event, NodeEvent) and self.event.anchor is not None: 

440 if self.prepared_anchor is None: 

441 self.prepared_anchor = self.prepare_anchor(self.event.anchor) 

442 length += len(self.prepared_anchor) 

443 if isinstance(self.event, (ScalarEvent, CollectionStartEvent)) \ 

444 and self.event.tag is not None: 

445 if self.prepared_tag is None: 

446 self.prepared_tag = self.prepare_tag(self.event.tag) 

447 length += len(self.prepared_tag) 

448 if isinstance(self.event, ScalarEvent): 

449 if self.analysis is None: 

450 self.analysis = self.analyze_scalar(self.event.value) 

451 length += len(self.analysis.scalar) 

452 return (length < 128 and (isinstance(self.event, AliasEvent) 

453 or (isinstance(self.event, ScalarEvent) 

454 and not self.analysis.empty and not self.analysis.multiline) 

455 or self.check_empty_sequence() or self.check_empty_mapping())) 

456 

457 # Anchor, Tag, and Scalar processors. 

458 

459 def process_anchor(self, indicator): 

460 if self.event.anchor is None: 

461 self.prepared_anchor = None 

462 return 

463 if self.prepared_anchor is None: 

464 self.prepared_anchor = self.prepare_anchor(self.event.anchor) 

465 if self.prepared_anchor: 

466 self.write_indicator(indicator+self.prepared_anchor, True) 

467 self.prepared_anchor = None 

468 

469 def process_tag(self): 

470 tag = self.event.tag 

471 if isinstance(self.event, ScalarEvent): 

472 if self.style is None: 

473 self.style = self.choose_scalar_style() 

474 if ((not self.canonical or tag is None) and 

475 ((self.style == '' and self.event.implicit[0]) 

476 or (self.style != '' and self.event.implicit[1]))): 

477 self.prepared_tag = None 

478 return 

479 if self.event.implicit[0] and tag is None: 

480 tag = '!' 

481 self.prepared_tag = None 

482 else: 

483 if (not self.canonical or tag is None) and self.event.implicit: 

484 self.prepared_tag = None 

485 return 

486 if tag is None: 

487 raise EmitterError("tag is not specified") 

488 if self.prepared_tag is None: 

489 self.prepared_tag = self.prepare_tag(tag) 

490 if self.prepared_tag: 

491 self.write_indicator(self.prepared_tag, True) 

492 self.prepared_tag = None 

493 

494 def choose_scalar_style(self): 

495 if self.analysis is None: 

496 self.analysis = self.analyze_scalar(self.event.value) 

497 if self.event.style == '"' or self.canonical: 

498 return '"' 

499 if not self.event.style and self.event.implicit[0]: 

500 if (not (self.simple_key_context and 

501 (self.analysis.empty or self.analysis.multiline)) 

502 and (self.flow_level and self.analysis.allow_flow_plain 

503 or (not self.flow_level and self.analysis.allow_block_plain))): 

504 return '' 

505 if self.event.style and self.event.style in '|>': 

506 if (not self.flow_level and not self.simple_key_context 

507 and self.analysis.allow_block): 

508 return self.event.style 

509 if not self.event.style or self.event.style == '\'': 

510 if (self.analysis.allow_single_quoted and 

511 not (self.simple_key_context and self.analysis.multiline)): 

512 return '\'' 

513 return '"' 

514 

515 def process_scalar(self): 

516 if self.analysis is None: 

517 self.analysis = self.analyze_scalar(self.event.value) 

518 if self.style is None: 

519 self.style = self.choose_scalar_style() 

520 split = (not self.simple_key_context) 

521 #if self.analysis.multiline and split \ 

522 # and (not self.style or self.style in '\'\"'): 

523 # self.write_indent() 

524 if self.style == '"': 

525 self.write_double_quoted(self.analysis.scalar, split) 

526 elif self.style == '\'': 

527 self.write_single_quoted(self.analysis.scalar, split) 

528 elif self.style == '>': 

529 self.write_folded(self.analysis.scalar) 

530 elif self.style == '|': 

531 self.write_literal(self.analysis.scalar) 

532 else: 

533 self.write_plain(self.analysis.scalar, split) 

534 self.analysis = None 

535 self.style = None 

536 

537 # Analyzers. 

538 

539 def prepare_version(self, version): 

540 major, minor = version 

541 if major != 1: 

542 raise EmitterError("unsupported YAML version: %d.%d" % (major, minor)) 

543 return '%d.%d' % (major, minor) 

544 

545 def prepare_tag_handle(self, handle): 

546 if not handle: 

547 raise EmitterError("tag handle must not be empty") 

548 if handle[0] != '!' or handle[-1] != '!': 

549 raise EmitterError("tag handle must start and end with '!': %r" % handle) 

550 for ch in handle[1:-1]: 

551 if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ 

552 or ch in '-_'): 

553 raise EmitterError("invalid character %r in the tag handle: %r" 

554 % (ch, handle)) 

555 return handle 

556 

557 def prepare_tag_prefix(self, prefix): 

558 if not prefix: 

559 raise EmitterError("tag prefix must not be empty") 

560 chunks = [] 

561 start = end = 0 

562 if prefix[0] == '!': 

563 end = 1 

564 while end < len(prefix): 

565 ch = prefix[end] 

566 if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ 

567 or ch in '-;/?!:@&=+$,_.~*\'()[]': 

568 end += 1 

569 else: 

570 if start < end: 

571 chunks.append(prefix[start:end]) 

572 start = end = end+1 

573 data = ch.encode('utf-8') 

574 for ch in data: 

575 chunks.append('%%%02X' % ord(ch)) 

576 if start < end: 

577 chunks.append(prefix[start:end]) 

578 return ''.join(chunks) 

579 

580 def prepare_tag(self, tag): 

581 if not tag: 

582 raise EmitterError("tag must not be empty") 

583 if tag == '!': 

584 return tag 

585 handle = None 

586 suffix = tag 

587 prefixes = sorted(self.tag_prefixes.keys()) 

588 for prefix in prefixes: 

589 if tag.startswith(prefix) \ 

590 and (prefix == '!' or len(prefix) < len(tag)): 

591 handle = self.tag_prefixes[prefix] 

592 suffix = tag[len(prefix):] 

593 chunks = [] 

594 start = end = 0 

595 while end < len(suffix): 

596 ch = suffix[end] 

597 if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ 

598 or ch in '-;/?:@&=+$,_.~*\'()[]' \ 

599 or (ch == '!' and handle != '!'): 

600 end += 1 

601 else: 

602 if start < end: 

603 chunks.append(suffix[start:end]) 

604 start = end = end+1 

605 data = ch.encode('utf-8') 

606 for ch in data: 

607 chunks.append('%%%02X' % ch) 

608 if start < end: 

609 chunks.append(suffix[start:end]) 

610 suffix_text = ''.join(chunks) 

611 if handle: 

612 return '%s%s' % (handle, suffix_text) 

613 else: 

614 return '!<%s>' % suffix_text 

615 

616 def prepare_anchor(self, anchor): 

617 if not anchor: 

618 raise EmitterError("anchor must not be empty") 

619 for ch in anchor: 

620 if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ 

621 or ch in '-_'): 

622 raise EmitterError("invalid character %r in the anchor: %r" 

623 % (ch, anchor)) 

624 return anchor 

625 

626 def analyze_scalar(self, scalar): 

627 

628 # Empty scalar is a special case. 

629 if not scalar: 

630 return ScalarAnalysis(scalar=scalar, empty=True, multiline=False, 

631 allow_flow_plain=False, allow_block_plain=True, 

632 allow_single_quoted=True, allow_double_quoted=True, 

633 allow_block=False) 

634 

635 # Indicators and special characters. 

636 block_indicators = False 

637 flow_indicators = False 

638 line_breaks = False 

639 special_characters = False 

640 

641 # Important whitespace combinations. 

642 leading_space = False 

643 leading_break = False 

644 trailing_space = False 

645 trailing_break = False 

646 break_space = False 

647 space_break = False 

648 

649 # Check document indicators. 

650 if scalar.startswith('---') or scalar.startswith('...'): 

651 block_indicators = True 

652 flow_indicators = True 

653 

654 # First character or preceded by a whitespace. 

655 preceded_by_whitespace = True 

656 

657 # Last character or followed by a whitespace. 

658 followed_by_whitespace = (len(scalar) == 1 or 

659 scalar[1] in '\0 \t\r\n\x85\u2028\u2029') 

660 

661 # The previous character is a space. 

662 previous_space = False 

663 

664 # The previous character is a break. 

665 previous_break = False 

666 

667 index = 0 

668 while index < len(scalar): 

669 ch = scalar[index] 

670 

671 # Check for indicators. 

672 if index == 0: 

673 # Leading indicators are special characters. 

674 if ch in '#,[]{}&*!|>\'\"%@`': 

675 flow_indicators = True 

676 block_indicators = True 

677 if ch in '?:': 

678 flow_indicators = True 

679 if followed_by_whitespace: 

680 block_indicators = True 

681 if ch == '-' and followed_by_whitespace: 

682 flow_indicators = True 

683 block_indicators = True 

684 else: 

685 # Some indicators cannot appear within a scalar as well. 

686 if ch in ',?[]{}': 

687 flow_indicators = True 

688 if ch == ':': 

689 flow_indicators = True 

690 if followed_by_whitespace: 

691 block_indicators = True 

692 if ch == '#' and preceded_by_whitespace: 

693 flow_indicators = True 

694 block_indicators = True 

695 

696 # Check for line breaks, special, and unicode characters. 

697 if ch in '\n\x85\u2028\u2029': 

698 line_breaks = True 

699 if not (ch == '\n' or '\x20' <= ch <= '\x7E'): 

700 if (ch == '\x85' or '\xA0' <= ch <= '\uD7FF' 

701 or '\uE000' <= ch <= '\uFFFD' 

702 or '\U00010000' <= ch < '\U0010ffff') and ch != '\uFEFF': 

703 unicode_characters = True 

704 if not self.allow_unicode: 

705 special_characters = True 

706 else: 

707 special_characters = True 

708 

709 # Detect important whitespace combinations. 

710 if ch == ' ': 

711 if index == 0: 

712 leading_space = True 

713 if index == len(scalar)-1: 

714 trailing_space = True 

715 if previous_break: 

716 break_space = True 

717 previous_space = True 

718 previous_break = False 

719 elif ch in '\n\x85\u2028\u2029': 

720 if index == 0: 

721 leading_break = True 

722 if index == len(scalar)-1: 

723 trailing_break = True 

724 if previous_space: 

725 space_break = True 

726 previous_space = False 

727 previous_break = True 

728 else: 

729 previous_space = False 

730 previous_break = False 

731 

732 # Prepare for the next character. 

733 index += 1 

734 preceded_by_whitespace = (ch in '\0 \t\r\n\x85\u2028\u2029') 

735 followed_by_whitespace = (index+1 >= len(scalar) or 

736 scalar[index+1] in '\0 \t\r\n\x85\u2028\u2029') 

737 

738 # Let's decide what styles are allowed.