Source.Python/addons/source-python/Python3/formatter.py at master · durof/Source.Python · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

"""Generic output formatting.

Formatter objects transform an abstract flow of formatting events into

specific output events on writer objects. Formatters manage several stack

structures to allow various properties of a writer object to be changed and

restored; writers need not be able to handle relative changes nor any sort

of ``change back'' operation. Specific writer properties which may be

controlled via formatter objects are horizontal alignment, font, and left

margin indentations. A mechanism is provided which supports providing

arbitrary, non-exclusive style settings to a writer as well. Additional

interfaces facilitate formatting events which are not reversible, such as

paragraph separation.

Writer objects encapsulate device interfaces. Abstract devices, such as

file formats, are supported as well as physical devices. The provided

implementations all work with abstract devices. The interface makes

available mechanisms for setting the properties which formatter objects

manage and inserting data into the output.

"""

import sys

import warnings

warnings.warn('the formatter module is deprecated', DeprecationWarning,

stacklevel=2)

AS_IS = None

class NullFormatter:

"""A formatter which does nothing.

If the writer parameter is omitted, a NullWriter instance is created.

No methods of the writer are called by NullFormatter instances.

Implementations should inherit from this class if implementing a writer

interface but don't need to inherit any implementation.

"""

def __init__(self, writer=None):

if writer is None:

writer = NullWriter()

self.writer = writer

def end_paragraph(self, blankline): pass

def add_line_break(self): pass

def add_hor_rule(self, *args, **kw): pass

def add_label_data(self, format, counter, blankline=None): pass

def add_flowing_data(self, data): pass

def add_literal_data(self, data): pass

def flush_softspace(self): pass

def push_alignment(self, align): pass

def pop_alignment(self): pass

def push_font(self, x): pass

def pop_font(self): pass

def push_margin(self, margin): pass

def pop_margin(self): pass

def set_spacing(self, spacing): pass

def push_style(self, *styles): pass

def pop_style(self, n=1): pass

def assert_line_data(self, flag=1): pass

class AbstractFormatter:

"""The standard formatter.

This implementation has demonstrated wide applicability to many writers,

and may be used directly in most circumstances. It has been used to

implement a full-featured World Wide Web browser.

"""

# Space handling policy: blank spaces at the boundary between elements

# are handled by the outermost context. "Literal" data is not checked

# to determine context, so spaces in literal data are handled directly

# in all circumstances.

def __init__(self, writer):

self.writer = writer # Output device

self.align = None # Current alignment

self.align_stack = [] # Alignment stack

self.font_stack = [] # Font state

self.margin_stack = [] # Margin state

self.spacing = None # Vertical spacing state

self.style_stack = [] # Other state, e.g. color

self.nospace = 1 # Should leading space be suppressed

self.softspace = 0 # Should a space be inserted

self.para_end = 1 # Just ended a paragraph

self.parskip = 0 # Skipped space between paragraphs?

self.hard_break = 1 # Have a hard break

self.have_label = 0

def end_paragraph(self, blankline):

if not self.hard_break:

self.writer.send_line_break()

self.have_label = 0

if self.parskip < blankline and not self.have_label:

self.writer.send_paragraph(blankline - self.parskip)

self.parskip = blankline

self.have_label = 0

self.hard_break = self.nospace = self.para_end = 1

self.softspace = 0

def add_line_break(self):

if not (self.hard_break or self.para_end):

self.writer.send_line_break()

self.have_label = self.parskip = 0

self.hard_break = self.nospace = 1

self.softspace = 0

def add_hor_rule(self, *args, **kw):

if not self.hard_break:

self.writer.send_line_break()

self.writer.send_hor_rule(*args, **kw)

self.hard_break = self.nospace = 1

self.have_label = self.para_end = self.softspace = self.parskip = 0

def add_label_data(self, format, counter, blankline = None):

if self.have_label or not self.hard_break:

self.writer.send_line_break()

if not self.para_end:

self.writer.send_paragraph((blankline and 1) or 0)

if isinstance(format, str):

self.writer.send_label_data(self.format_counter(format, counter))

else:

self.writer.send_label_data(format)

self.nospace = self.have_label = self.hard_break = self.para_end = 1

self.softspace = self.parskip = 0

def format_counter(self, format, counter):

label = ''

for c in format:

if c == '1':

label = label + ('%d' % counter)

elif c in 'aA':

if counter > 0:

label = label + self.format_letter(c, counter)

elif c in 'iI':

if counter > 0:

label = label + self.format_roman(c, counter)

else:

label = label + c

return label

def format_letter(self, case, counter):

label = ''

while counter > 0:

counter, x = divmod(counter-1, 26)

# This makes a strong assumption that lowercase letters

# and uppercase letters form two contiguous blocks, with

# letters in order!

s = chr(ord(case) + x)

label = s + label

return label

def format_roman(self, case, counter):

ones = ['i', 'x', 'c', 'm']

fives = ['v', 'l', 'd']

label, index = '', 0

# This will die of IndexError when counter is too big

while counter > 0:

counter, x = divmod(counter, 10)

if x == 9:

label = ones[index] + ones[index+1] + label

elif x == 4:

label = ones[index] + fives[index] + label

else:

if x >= 5:

s = fives[index]

x = x-5

else:

s = ''

s = s + ones[index]*x

label = s + label

index = index + 1

if case == 'I':

return label.upper()

return label

def add_flowing_data(self, data):

if not data: return

prespace = data[:1].isspace()

postspace = data[-1:].isspace()

data = " ".join(data.split())

if self.nospace and not data:

return

elif prespace or self.softspace:

if not data:

if not self.nospace:

self.softspace = 1

self.parskip = 0

return

if not self.nospace:

data = ' ' + data

self.hard_break = self.nospace = self.para_end = \

self.parskip = self.have_label = 0

self.softspace = postspace

self.writer.send_flowing_data(data)

def add_literal_data(self, data):

if not data: return

if self.softspace:

self.writer.send_flowing_data(" ")

self.hard_break = data[-1:] == '\n'

self.nospace = self.para_end = self.softspace = \

self.parskip = self.have_label = 0

self.writer.send_literal_data(data)

def flush_softspace(self):

if self.softspace:

self.hard_break = self.para_end = self.parskip = \

self.have_label = self.softspace = 0

self.nospace = 1

self.writer.send_flowing_data(' ')

def push_alignment(self, align):

if align and align != self.align:

self.writer.new_alignment(align)

self.align = align

self.align_stack.append(align)

else:

self.align_stack.append(self.align)

def pop_alignment(self):

if self.align_stack:

del self.align_stack[-1]

if self.align_stack:

self.align = align = self.align_stack[-1]

self.writer.new_alignment(align)

else:

self.align = None

self.writer.new_alignment(None)

def push_font(self, font):

size, i, b, tt = font

if self.softspace:

self.hard_break = self.para_end = self.softspace = 0

self.nospace = 1

self.writer.send_flowing_data(' ')

if self.font_stack:

csize, ci, cb, ctt = self.font_stack[-1]

if size is AS_IS: size = csize

if i is AS_IS: i = ci

if b is AS_IS: b = cb

if tt is AS_IS: tt = ctt

font = (size, i, b, tt)

self.font_stack.append(font)

self.writer.new_font(font)

def pop_font(self):

if self.font_stack:

del self.font_stack[-1]

if self.font_stack:

font = self.font_stack[-1]

else:

font = None

self.writer.new_font(font)

def push_margin(self, margin):

self.margin_stack.append(margin)

fstack = [m for m in self.margin_stack if m]

if not margin and fstack:

margin = fstack[-1]

self.writer.new_margin(margin, len(fstack))

def pop_margin(self):

if self.margin_stack:

del self.margin_stack[-1]

fstack = [m for m in self.margin_stack if m]

if fstack:

margin = fstack[-1]

else:

margin = None

self.writer.new_margin(margin, len(fstack))

def set_spacing(self, spacing):

self.spacing = spacing

self.writer.new_spacing(spacing)

def push_style(self, *styles):

if self.softspace:

self.hard_break = self.para_end = self.softspace = 0

self.nospace = 1

self.writer.send_flowing_data(' ')

for style in styles:

self.style_stack.append(style)

self.writer.new_styles(tuple(self.style_stack))

def pop_style(self, n=1):

del self.style_stack[-n:]

self.writer.new_styles(tuple(self.style_stack))

def assert_line_data(self, flag=1):

self.nospace = self.hard_break = not flag

self.para_end = self.parskip = self.have_label = 0

class NullWriter:

"""Minimal writer interface to use in testing & inheritance.

A writer which only provides the interface definition; no actions are

taken on any methods. This should be the base class for all writers

which do not need to inherit any implementation methods.

"""

def __init__(self): pass

def flush(self): pass

def new_alignment(self, align): pass

def new_font(self, font): pass

def new_margin(self, margin, level): pass

def new_spacing(self, spacing): pass

def new_styles(self, styles): pass

def send_paragraph(self, blankline): pass

def send_line_break(self): pass

def send_hor_rule(self, *args, **kw): pass

def send_label_data(self, data): pass

def send_flowing_data(self, data): pass

def send_literal_data(self, data): pass

class AbstractWriter(NullWriter):

"""A writer which can be used in debugging formatters, but not much else.

Each method simply announces itself by printing its name and

arguments on standard output.

"""

def new_alignment(self, align):

print("new_alignment(%r)" % (align,))

def new_font(self, font):

print("new_font(%r)" % (font,))

def new_margin(self, margin, level):

print("new_margin(%r, %d)" % (margin, level))

def new_spacing(self, spacing):

print("new_spacing(%r)" % (spacing,))

def new_styles(self, styles):

print("new_styles(%r)" % (styles,))

def send_paragraph(self, blankline):

print("send_paragraph(%r)" % (blankline,))

def send_line_break(self):

print("send_line_break()")

def send_hor_rule(self, *args, **kw):

print("send_hor_rule()")

def send_label_data(self, data):

print("send_label_data(%r)" % (data,))

def send_flowing_data(self, data):

print("send_flowing_data(%r)" % (data,))

def send_literal_data(self, data):

print("send_literal_data(%r)" % (data,))

class DumbWriter(NullWriter):

"""Simple writer class which writes output on the file object passed in

as the file parameter or, if file is omitted, on standard output. The

output is simply word-wrapped to the number of columns specified by

the maxcol parameter. This class is suitable for reflowing a sequence

of paragraphs.

"""

def __init__(self, file=None, maxcol=72):

self.file = file or sys.stdout

self.maxcol = maxcol

NullWriter.__init__(self)

self.reset()

def reset(self):

self.col = 0

self.atbreak = 0

def send_paragraph(self, blankline):

self.file.write('\n'*blankline)

self.col = 0

self.atbreak = 0

def send_line_break(self):

self.file.write('\n')

self.col = 0

self.atbreak = 0

def send_hor_rule(self, *args, **kw):

self.file.write('\n')

self.file.write('-'*self.maxcol)

self.file.write('\n')

self.col = 0

self.atbreak = 0

def send_literal_data(self, data):

self.file.write(data)

i = data.rfind('\n')

if i >= 0:

self.col = 0

data = data[i+1:]

data = data.expandtabs()

self.col = self.col + len(data)

self.atbreak = 0

def send_flowing_data(self, data):

if not data: return

atbreak = self.atbreak or data[0].isspace()

col = self.col

maxcol = self.maxcol

write = self.file.write

for word in data.split():

if atbreak:

if col + len(word) >= maxcol:

write('\n')

col = 0

else:

write(' ')

col = col + 1

write(word)

col = col + len(word)

atbreak = 1

self.col = col

self.atbreak = data[-1].isspace()

def test(file = None):

w = DumbWriter()

f = AbstractFormatter(w)

if file is not None:

fp = open(file)

elif sys.argv[1:]:

fp = open(sys.argv[1])

else:

fp = sys.stdin

try:

for line in fp:

if line == '\n':

f.end_paragraph(1)

else:

f.add_flowing_data(line)

finally:

if fp is not sys.stdin:

fp.close()

f.end_paragraph(0)

if __name__ == '__main__':

test()

Source.Python/addons/source-python/Python3/formatter.py at master · durof/Source.Python · GitHub

Repository navigation

Expand file tree

Breadcrumbs

formatter.py

Latest commit

History

Breadcrumbs

formatter.py

File metadata and controls