Source.Python/addons/source-python/Python3/xml/sax/xmlreader.py at master · srpg/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

"""An XML Reader is the SAX 2 name for an XML parser. XML Parsers

should be based on this code. """

from . import handler

from ._exceptions import SAXNotSupportedException, SAXNotRecognizedException

# ===== XMLREADER =====

class XMLReader:

"""Interface for reading an XML document using callbacks.

XMLReader is the interface that an XML parser's SAX2 driver must

implement. This interface allows an application to set and query

features and properties in the parser, to register event handlers

for document processing, and to initiate a document parse.

All SAX interfaces are assumed to be synchronous: the parse

methods must not return until parsing is complete, and readers

must wait for an event-handler callback to return before reporting

the next event."""

def __init__(self):

self._cont_handler = handler.ContentHandler()

self._dtd_handler = handler.DTDHandler()

self._ent_handler = handler.EntityResolver()

self._err_handler = handler.ErrorHandler()

def parse(self, source):

"Parse an XML document from a system identifier or an InputSource."

raise NotImplementedError("This method must be implemented!")

def getContentHandler(self):

"Returns the current ContentHandler."

return self._cont_handler

def setContentHandler(self, handler):

"Registers a new object to receive document content events."

self._cont_handler = handler

def getDTDHandler(self):

"Returns the current DTD handler."

return self._dtd_handler

def setDTDHandler(self, handler):

"Register an object to receive basic DTD-related events."

self._dtd_handler = handler

def getEntityResolver(self):

"Returns the current EntityResolver."

return self._ent_handler

def setEntityResolver(self, resolver):

"Register an object to resolve external entities."

self._ent_handler = resolver

def getErrorHandler(self):

"Returns the current ErrorHandler."

return self._err_handler

def setErrorHandler(self, handler):

"Register an object to receive error-message events."

self._err_handler = handler

def setLocale(self, locale):

"""Allow an application to set the locale for errors and warnings.

SAX parsers are not required to provide localization for errors

and warnings; if they cannot support the requested locale,

however, they must raise a SAX exception. Applications may

request a locale change in the middle of a parse."""

raise SAXNotSupportedException("Locale support not implemented")

def getFeature(self, name):

"Looks up and returns the state of a SAX2 feature."

raise SAXNotRecognizedException("Feature '%s' not recognized" % name)

def setFeature(self, name, state):

"Sets the state of a SAX2 feature."

raise SAXNotRecognizedException("Feature '%s' not recognized" % name)

def getProperty(self, name):

"Looks up and returns the value of a SAX2 property."

raise SAXNotRecognizedException("Property '%s' not recognized" % name)

def setProperty(self, name, value):

"Sets the value of a SAX2 property."

raise SAXNotRecognizedException("Property '%s' not recognized" % name)

class IncrementalParser(XMLReader):

"""This interface adds three extra methods to the XMLReader

interface that allow XML parsers to support incremental

parsing. Support for this interface is optional, since not all

underlying XML parsers support this functionality.

When the parser is instantiated it is ready to begin accepting

data from the feed method immediately. After parsing has been

finished with a call to close the reset method must be called to

make the parser ready to accept new data, either from feed or

using the parse method.

Note that these methods must _not_ be called during parsing, that

is, after parse has been called and before it returns.

By default, the class also implements the parse method of the XMLReader

interface using the feed, close and reset methods of the

IncrementalParser interface as a convenience to SAX 2.0 driver

writers."""

def __init__(self, bufsize=2**16):

self._bufsize = bufsize

XMLReader.__init__(self)

def parse(self, source):

from . import saxutils

source = saxutils.prepare_input_source(source)

self.prepareParser(source)

file = source.getCharacterStream()

if file is None:

file = source.getByteStream()

buffer = file.read(self._bufsize)

while buffer:

self.feed(buffer)

buffer = file.read(self._bufsize)

self.close()

def feed(self, data):

"""This method gives the raw XML data in the data parameter to

the parser and makes it parse the data, emitting the

corresponding events. It is allowed for XML constructs to be

split across several calls to feed.

feed may raise SAXException."""

raise NotImplementedError("This method must be implemented!")

def prepareParser(self, source):

"""This method is called by the parse implementation to allow

the SAX 2.0 driver to prepare itself for parsing."""

raise NotImplementedError("prepareParser must be overridden!")

def close(self):

"""This method is called when the entire XML document has been

passed to the parser through the feed method, to notify the

parser that there are no more data. This allows the parser to

do the final checks on the document and empty the internal

data buffer.

The parser will not be ready to parse another document until

the reset method has been called.

close may raise SAXException."""

raise NotImplementedError("This method must be implemented!")

def reset(self):

"""This method is called after close has been called to reset

the parser so that it is ready to parse new documents. The

results of calling parse or feed after close without calling

reset are undefined."""

raise NotImplementedError("This method must be implemented!")

# ===== LOCATOR =====

class Locator:

"""Interface for associating a SAX event with a document

location. A locator object will return valid results only during

calls to DocumentHandler methods; at any other time, the

results are unpredictable."""

def getColumnNumber(self):

"Return the column number where the current event ends."

return -1

def getLineNumber(self):

"Return the line number where the current event ends."

return -1

def getPublicId(self):

"Return the public identifier for the current event."

return None

def getSystemId(self):

"Return the system identifier for the current event."

return None

# ===== INPUTSOURCE =====

class InputSource:

"""Encapsulation of the information needed by the XMLReader to

read entities.

This class may include information about the public identifier,

system identifier, byte stream (possibly with character encoding

information) and/or the character stream of an entity.

Applications will create objects of this class for use in the

XMLReader.parse method and for returning from

EntityResolver.resolveEntity.

An InputSource belongs to the application, the XMLReader is not

allowed to modify InputSource objects passed to it from the

application, although it may make copies and modify those."""

def __init__(self, system_id = None):

self.__system_id = system_id

self.__public_id = None

self.__encoding = None

self.__bytefile = None

self.__charfile = None

def setPublicId(self, public_id):

"Sets the public identifier of this InputSource."

self.__public_id = public_id

def getPublicId(self):

"Returns the public identifier of this InputSource."

return self.__public_id

def setSystemId(self, system_id):

"Sets the system identifier of this InputSource."

self.__system_id = system_id

def getSystemId(self):

"Returns the system identifier of this InputSource."

return self.__system_id

def setEncoding(self, encoding):

"""Sets the character encoding of this InputSource.

The encoding must be a string acceptable for an XML encoding

declaration (see section 4.3.3 of the XML recommendation).

The encoding attribute of the InputSource is ignored if the

InputSource also contains a character stream."""

self.__encoding = encoding

def getEncoding(self):

"Get the character encoding of this InputSource."

return self.__encoding

def setByteStream(self, bytefile):

"""Set the byte stream (a Python file-like object which does

not perform byte-to-character conversion) for this input

source.

The SAX parser will ignore this if there is also a character

stream specified, but it will use a byte stream in preference

to opening a URI connection itself.

If the application knows the character encoding of the byte

stream, it should set it with the setEncoding method."""

self.__bytefile = bytefile

def getByteStream(self):

"""Get the byte stream for this input source.

The getEncoding method will return the character encoding for

this byte stream, or None if unknown."""

return self.__bytefile

def setCharacterStream(self, charfile):

"""Set the character stream for this input source. (The stream

must be a Python 2.0 Unicode-wrapped file-like that performs

conversion to Unicode strings.)

If there is a character stream specified, the SAX parser will

ignore any byte stream and will not attempt to open a URI

connection to the system identifier."""

self.__charfile = charfile

def getCharacterStream(self):

"Get the character stream for this input source."

return self.__charfile

# ===== ATTRIBUTESIMPL =====

class AttributesImpl:

def __init__(self, attrs):

"""Non-NS-aware implementation.

attrs should be of the form {name : value}."""

self._attrs = attrs

def getLength(self):

return len(self._attrs)

def getType(self, name):

return "CDATA"

def getValue(self, name):

return self._attrs[name]

def getValueByQName(self, name):

return self._attrs[name]

def getNameByQName(self, name):

if name not in self._attrs:

raise KeyError(name)

return name

def getQNameByName(self, name):

if name not in self._attrs:

raise KeyError(name)

return name

def getNames(self):

return list(self._attrs.keys())

def getQNames(self):

return list(self._attrs.keys())

def __len__(self):

return len(self._attrs)

def __getitem__(self, name):

return self._attrs[name]

def keys(self):

return list(self._attrs.keys())

def __contains__(self, name):

return name in self._attrs

def get(self, name, alternative=None):

return self._attrs.get(name, alternative)

def copy(self):

return self.__class__(self._attrs)

def items(self):

return list(self._attrs.items())

def values(self):

return list(self._attrs.values())

# ===== ATTRIBUTESNSIMPL =====

class AttributesNSImpl(AttributesImpl):

def __init__(self, attrs, qnames):

"""NS-aware implementation.

attrs should be of the form {(ns_uri, lname): value, ...}.

qnames of the form {(ns_uri, lname): qname, ...}."""

self._attrs = attrs

self._qnames = qnames

def getValueByQName(self, name):

for (nsname, qname) in self._qnames.items():

if qname == name:

return self._attrs[nsname]

raise KeyError(name)

def getNameByQName(self, name):

for (nsname, qname) in self._qnames.items():

if qname == name:

return nsname

raise KeyError(name)

def getQNameByName(self, name):

return self._qnames[name]

def getQNames(self):

return list(self._qnames.values())

def copy(self):

return self.__class__(self._attrs, self._qnames)

def _test():

XMLReader()

IncrementalParser()

Locator()

if __name__ == "__main__":

_test()

Source.Python/addons/source-python/Python3/xml/sax/xmlreader.py at master · srpg/Source.Python · GitHub

Repository navigation

Expand file tree

Breadcrumbs

xmlreader.py

Latest commit

History

Breadcrumbs

xmlreader.py

File metadata and controls