576 lines
23 KiB
Python
Executable File
576 lines
23 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
|
|
|
|
from __future__ import unicode_literals, division, absolute_import, print_function
|
|
|
|
from .compatibility_utils import PY2, bstr, utf8_str
|
|
from loguru import logger
|
|
|
|
if PY2:
|
|
range = xrange
|
|
|
|
import os
|
|
|
|
import struct
|
|
|
|
# note: struct pack, unpack, unpack_from all require bytestring format
|
|
# data all the way up to at least python 2.7.5, python 3 okay with bytestring
|
|
|
|
import re
|
|
|
|
# note: re requites the pattern to be the exact same type as the data to be searched in python3
|
|
# but u"" is not allowed for the pattern itself only b""
|
|
|
|
from .mobi_index import MobiIndex
|
|
from .mobi_utils import fromBase32
|
|
from .unipath import pathof
|
|
|
|
_guide_types = [
|
|
b"cover",
|
|
b"title-page",
|
|
b"toc",
|
|
b"index",
|
|
b"glossary",
|
|
b"acknowledgements",
|
|
b"bibliography",
|
|
b"colophon",
|
|
b"copyright-page",
|
|
b"dedication",
|
|
b"epigraph",
|
|
b"foreward",
|
|
b"loi",
|
|
b"lot",
|
|
b"notes",
|
|
b"preface",
|
|
b"text",
|
|
]
|
|
|
|
# locate beginning and ending positions of tag with specific aid attribute
|
|
def locate_beg_end_of_tag(ml, aid):
|
|
pattern = utf8_str(r"""<[^>]*\said\s*=\s*['"]%s['"][^>]*>""" % aid)
|
|
aid_pattern = re.compile(pattern, re.IGNORECASE)
|
|
for m in re.finditer(aid_pattern, ml):
|
|
plt = m.start()
|
|
pgt = ml.find(b">", plt + 1)
|
|
return plt, pgt
|
|
return 0, 0
|
|
|
|
|
|
# iterate over all tags in block in reverse order, i.e. last ta to first tag
|
|
def reverse_tag_iter(block):
|
|
end = len(block)
|
|
while True:
|
|
pgt = block.rfind(b">", 0, end)
|
|
if pgt == -1:
|
|
break
|
|
plt = block.rfind(b"<", 0, pgt)
|
|
if plt == -1:
|
|
break
|
|
yield block[plt : pgt + 1]
|
|
end = plt
|
|
|
|
|
|
class K8Processor:
|
|
def __init__(self, mh, sect, files, debug=False):
|
|
self.sect = sect
|
|
self.files = files
|
|
self.mi = MobiIndex(sect)
|
|
self.mh = mh
|
|
self.skelidx = mh.skelidx
|
|
self.fragidx = mh.fragidx
|
|
self.guideidx = mh.guideidx
|
|
self.fdst = mh.fdst
|
|
self.flowmap = {}
|
|
self.flows = None
|
|
self.flowinfo = []
|
|
self.parts = None
|
|
self.partinfo = []
|
|
self.linked_aids = set()
|
|
self.fdsttbl = [0, 0xFFFFFFFF]
|
|
self.DEBUG = debug
|
|
|
|
# read in and parse the FDST info which is very similar in format to the Palm DB section
|
|
# parsing except it provides offsets into rawML file and not the Palm DB file
|
|
# this is needed to split up the final css, svg, etc flow section
|
|
# that can exist at the end of the rawML file
|
|
if self.fdst != 0xFFFFFFFF:
|
|
header = self.sect.loadSection(self.fdst)
|
|
if header[0:4] == b"FDST":
|
|
(num_sections,) = struct.unpack_from(b">L", header, 0x08)
|
|
self.fdsttbl = struct.unpack_from(
|
|
bstr(">%dL" % (num_sections * 2)), header, 12
|
|
)[::2] + (mh.rawSize,)
|
|
sect.setsectiondescription(self.fdst, "KF8 FDST INDX")
|
|
if self.DEBUG:
|
|
logger.debug("\nFDST Section Map: %d sections" % num_sections)
|
|
for j in range(num_sections):
|
|
logger.debug(
|
|
"Section %d: 0x%08X - 0x%08X"
|
|
% (j, self.fdsttbl[j], self.fdsttbl[j + 1])
|
|
)
|
|
else:
|
|
logger.debug("\nError: K8 Mobi with Missing FDST info")
|
|
|
|
# read/process skeleton index info to create the skeleton table
|
|
skeltbl = []
|
|
if self.skelidx != 0xFFFFFFFF:
|
|
# for i in range(2):
|
|
# fname = 'skel%04d.dat' % i
|
|
# data = self.sect.loadSection(self.skelidx + i)
|
|
# with open(pathof(fname), 'wb') as f:
|
|
# f.write(data)
|
|
outtbl, ctoc_text = self.mi.getIndexData(self.skelidx, "KF8 Skeleton")
|
|
fileptr = 0
|
|
for [text, tagMap] in outtbl:
|
|
# file number, skeleton name, fragtbl record count, start position, length
|
|
skeltbl.append(
|
|
[fileptr, text, tagMap[1][0], tagMap[6][0], tagMap[6][1]]
|
|
)
|
|
fileptr += 1
|
|
self.skeltbl = skeltbl
|
|
if self.DEBUG:
|
|
logger.debug("\nSkel Table: %d entries" % len(self.skeltbl))
|
|
logger.debug(
|
|
"table: filenum, skeleton name, frag tbl record count, start position, length"
|
|
)
|
|
for j in range(len(self.skeltbl)):
|
|
logger.debug(self.skeltbl[j])
|
|
|
|
# read/process the fragment index to create the fragment table
|
|
fragtbl = []
|
|
if self.fragidx != 0xFFFFFFFF:
|
|
# for i in range(3):
|
|
# fname = 'frag%04d.dat' % i
|
|
# data = self.sect.loadSection(self.fragidx + i)
|
|
# with open(pathof(fname), 'wb') as f:
|
|
# f.write(data)
|
|
outtbl, ctoc_text = self.mi.getIndexData(self.fragidx, "KF8 Fragment")
|
|
for [text, tagMap] in outtbl:
|
|
# insert position, ctoc offset (aidtext), file number, sequence number, start position, length
|
|
ctocoffset = tagMap[2][0]
|
|
ctocdata = ctoc_text[ctocoffset]
|
|
fragtbl.append(
|
|
[
|
|
int(text),
|
|
ctocdata,
|
|
tagMap[3][0],
|
|
tagMap[4][0],
|
|
tagMap[6][0],
|
|
tagMap[6][1],
|
|
]
|
|
)
|
|
self.fragtbl = fragtbl
|
|
if self.DEBUG:
|
|
logger.debug("\nFragment Table: %d entries" % len(self.fragtbl))
|
|
logger.debug(
|
|
"table: file position, link id text, file num, sequence number, start position, length"
|
|
)
|
|
for j in range(len(self.fragtbl)):
|
|
logger.debug(self.fragtbl[j])
|
|
|
|
# read / process guide index for guide elements of opf
|
|
guidetbl = []
|
|
if self.guideidx != 0xFFFFFFFF:
|
|
# for i in range(3):
|
|
# fname = 'guide%04d.dat' % i
|
|
# data = self.sect.loadSection(self.guideidx + i)
|
|
# with open(pathof(fname), 'wb') as f:
|
|
# f.write(data)
|
|
outtbl, ctoc_text = self.mi.getIndexData(
|
|
self.guideidx, "KF8 Guide elements)"
|
|
)
|
|
for [text, tagMap] in outtbl:
|
|
# ref_type, ref_title, frag number
|
|
ctocoffset = tagMap[1][0]
|
|
ref_title = ctoc_text[ctocoffset]
|
|
ref_type = text
|
|
fileno = None
|
|
if 3 in tagMap:
|
|
fileno = tagMap[3][0]
|
|
if 6 in tagMap:
|
|
fileno = tagMap[6][0]
|
|
guidetbl.append([ref_type, ref_title, fileno])
|
|
self.guidetbl = guidetbl
|
|
if self.DEBUG:
|
|
logger.debug("\nGuide Table: %d entries" % len(self.guidetbl))
|
|
logger.debug("table: ref_type, ref_title, fragtbl entry number")
|
|
for j in range(len(self.guidetbl)):
|
|
logger.debug(self.guidetbl[j])
|
|
|
|
def buildParts(self, rawML):
|
|
# now split the rawML into its flow pieces
|
|
self.flows = []
|
|
for j in range(0, len(self.fdsttbl) - 1):
|
|
start = self.fdsttbl[j]
|
|
end = self.fdsttbl[j + 1]
|
|
self.flows.append(rawML[start:end])
|
|
|
|
# the first piece represents the xhtml text
|
|
text = self.flows[0]
|
|
self.flows[0] = b""
|
|
|
|
# walk the <skeleton> and fragment tables to build original source xhtml files
|
|
# *without* destroying any file position information needed for later href processing
|
|
# and create final list of file separation start: stop points and etc in partinfo
|
|
if self.DEBUG:
|
|
logger.debug("\nRebuilding flow piece 0: the main body of the ebook")
|
|
self.parts = []
|
|
self.partinfo = []
|
|
fragptr = 0
|
|
baseptr = 0
|
|
cnt = 0
|
|
filename = "part%04d.xhtml" % cnt
|
|
for [skelnum, skelname, fragcnt, skelpos, skellen] in self.skeltbl:
|
|
baseptr = skelpos + skellen
|
|
skeleton = text[skelpos:baseptr]
|
|
aidtext = "0"
|
|
for i in range(fragcnt):
|
|
[insertpos, idtext, filenum, seqnum, startpos, length] = self.fragtbl[
|
|
fragptr
|
|
]
|
|
aidtext = idtext[12:-2]
|
|
if i == 0:
|
|
filename = "part%04d.xhtml" % filenum
|
|
slice = text[baseptr : baseptr + length]
|
|
insertpos = insertpos - skelpos
|
|
head = skeleton[:insertpos]
|
|
tail = skeleton[insertpos:]
|
|
actual_inspos = insertpos
|
|
if tail.find(b">") < tail.find(b"<") or head.rfind(b">") < head.rfind(
|
|
b"<"
|
|
):
|
|
# There is an incomplete tag in either the head or tail.
|
|
# This can happen for some badly formed KF8 files
|
|
logger.debug(
|
|
"The fragment table for %s has incorrect insert position. Calculating manually."
|
|
% skelname
|
|
)
|
|
bp, ep = locate_beg_end_of_tag(skeleton, aidtext)
|
|
if bp != ep:
|
|
actual_inspos = ep + 1 + startpos
|
|
if insertpos != actual_inspos:
|
|
print(
|
|
"fixed corrupt fragment table insert position",
|
|
insertpos + skelpos,
|
|
actual_inspos + skelpos,
|
|
)
|
|
insertpos = actual_inspos
|
|
self.fragtbl[fragptr][0] = actual_inspos + skelpos
|
|
skeleton = skeleton[0:insertpos] + slice + skeleton[insertpos:]
|
|
baseptr = baseptr + length
|
|
fragptr += 1
|
|
cnt += 1
|
|
self.parts.append(skeleton)
|
|
self.partinfo.append([skelnum, "Text", filename, skelpos, baseptr, aidtext])
|
|
|
|
assembled_text = b"".join(self.parts)
|
|
if self.DEBUG:
|
|
outassembled = os.path.join(self.files.k8dir, "assembled_text.dat")
|
|
with open(pathof(outassembled), "wb") as f:
|
|
f.write(assembled_text)
|
|
|
|
# The primary css style sheet is typically stored next followed by any
|
|
# snippets of code that were previously inlined in the
|
|
# original xhtml but have been stripped out and placed here.
|
|
# This can include local CDATA snippets and and svg sections.
|
|
|
|
# The problem is that for most browsers and ereaders, you can not
|
|
# use <img src="imageXXXX.svg" /> to import any svg image that itself
|
|
# properly uses an <image/> tag to import some raster image - it
|
|
# should work according to the spec but does not for almost all browsers
|
|
# and ereaders and causes epub validation issues because those raster
|
|
# images are in manifest but not in xhtml text - since they only
|
|
# referenced from an svg image
|
|
|
|
# So we need to check the remaining flow pieces to see if they are css
|
|
# or svg images. if svg images, we must check if they have an <image />
|
|
# and if so inline them into the xhtml text pieces.
|
|
|
|
# there may be other sorts of pieces stored here but until we see one
|
|
# in the wild to reverse engineer we won't be able to tell
|
|
self.flowinfo.append([None, None, None, None])
|
|
svg_tag_pattern = re.compile(br"""(<svg[^>]*>)""", re.IGNORECASE)
|
|
image_tag_pattern = re.compile(br"""(<image[^>]*>)""", re.IGNORECASE)
|
|
for j in range(1, len(self.flows)):
|
|
flowpart = self.flows[j]
|
|
nstr = "%04d" % j
|
|
m = re.search(svg_tag_pattern, flowpart)
|
|
if m is not None:
|
|
# svg
|
|
ptype = b"svg"
|
|
start = m.start()
|
|
m2 = re.search(image_tag_pattern, flowpart)
|
|
if m2 is not None:
|
|
pformat = b"inline"
|
|
pdir = None
|
|
fname = None
|
|
# strip off anything before <svg if inlining
|
|
flowpart = flowpart[start:]
|
|
else:
|
|
pformat = b"file"
|
|
pdir = "Images"
|
|
fname = "svgimg" + nstr + ".svg"
|
|
else:
|
|
# search for CDATA and if exists inline it
|
|
if flowpart.find(b"[CDATA[") >= 0:
|
|
ptype = b"css"
|
|
flowpart = b'<style type="text/css">\n' + flowpart + b"\n</style>\n"
|
|
pformat = b"inline"
|
|
pdir = None
|
|
fname = None
|
|
else:
|
|
# css - assume as standalone css file
|
|
ptype = b"css"
|
|
pformat = b"file"
|
|
pdir = "Styles"
|
|
fname = "style" + nstr + ".css"
|
|
|
|
self.flows[j] = flowpart
|
|
self.flowinfo.append([ptype, pformat, pdir, fname])
|
|
|
|
if self.DEBUG:
|
|
logger.debug("\nFlow Map: %d entries" % len(self.flowinfo))
|
|
for fi in self.flowinfo:
|
|
logger.debug(fi)
|
|
logger.debug("\n")
|
|
|
|
logger.debug(
|
|
"\nXHTML File Part Position Information: %d entries"
|
|
% len(self.partinfo)
|
|
)
|
|
for pi in self.partinfo:
|
|
logger.debug(pi)
|
|
|
|
if False: # self.Debug:
|
|
# dump all of the locations of the aid tags used in TEXT
|
|
# find id links only inside of tags
|
|
# inside any < > pair find all "aid=' and return whatever is inside the quotes
|
|
# [^>]* means match any amount of chars except for '>' char
|
|
# [^'"] match any amount of chars except for the quote character
|
|
# \s* means match any amount of whitespace
|
|
logger.debug("\npositions of all aid= pieces")
|
|
id_pattern = re.compile(
|
|
br"""<[^>]*\said\s*=\s*['"]([^'"]*)['"][^>]*>""", re.IGNORECASE
|
|
)
|
|
for m in re.finditer(id_pattern, rawML):
|
|
[filename, partnum, start, end] = self.getFileInfo(m.start())
|
|
[seqnum, idtext] = self.getFragTblInfo(m.start())
|
|
value = fromBase32(m.group(1))
|
|
logger.debug(
|
|
" aid: %s value: %d at: %d -> part: %d, start: %d, end: %d"
|
|
% (m.group(1), value, m.start(), partnum, start, end)
|
|
)
|
|
logger.debug(" %s fragtbl entry %d" % (idtext, seqnum))
|
|
|
|
return
|
|
|
|
# get information fragment table entry by pos
|
|
def getFragTblInfo(self, pos):
|
|
for j in range(len(self.fragtbl)):
|
|
[insertpos, idtext, filenum, seqnum, startpos, length] = self.fragtbl[j]
|
|
if pos >= insertpos and pos < (insertpos + length):
|
|
# why are these "in: and before: added here
|
|
return seqnum, b"in: " + idtext
|
|
if pos < insertpos:
|
|
return seqnum, b"before: " + idtext
|
|
return None, None
|
|
|
|
# get information about the part (file) that exists at pos in original rawML
|
|
def getFileInfo(self, pos):
|
|
for [partnum, pdir, filename, start, end, aidtext] in self.partinfo:
|
|
if pos >= start and pos < end:
|
|
return filename, partnum, start, end
|
|
return None, None, None, None
|
|
|
|
# accessor functions to properly protect the internal structure
|
|
def getNumberOfParts(self):
|
|
return len(self.parts)
|
|
|
|
def getPart(self, i):
|
|
if i >= 0 and i < len(self.parts):
|
|
return self.parts[i]
|
|
return None
|
|
|
|
def getPartInfo(self, i):
|
|
if i >= 0 and i < len(self.partinfo):
|
|
return self.partinfo[i]
|
|
return None
|
|
|
|
def getNumberOfFlows(self):
|
|
return len(self.flows)
|
|
|
|
def getFlow(self, i):
|
|
# note flows[0] is empty - it was all of the original text
|
|
if i > 0 and i < len(self.flows):
|
|
return self.flows[i]
|
|
return None
|
|
|
|
def getFlowInfo(self, i):
|
|
# note flowinfo[0] is empty - it was all of the original text
|
|
if i > 0 and i < len(self.flowinfo):
|
|
return self.flowinfo[i]
|
|
return None
|
|
|
|
def getIDTagByPosFid(self, posfid, offset):
|
|
# first convert kindle:pos:fid and offset info to position in file
|
|
# (fromBase32 can handle both string types on input)
|
|
row = fromBase32(posfid)
|
|
off = fromBase32(offset)
|
|
[insertpos, idtext, filenum, seqnm, startpos, length] = self.fragtbl[row]
|
|
pos = insertpos + off
|
|
fname, pn, skelpos, skelend = self.getFileInfo(pos)
|
|
if fname is None:
|
|
# pos does not exist
|
|
# default to skeleton pos instead
|
|
print(
|
|
"Link To Position", pos, "does not exist, retargeting to top of target"
|
|
)
|
|
pos = self.skeltbl[filenum][3]
|
|
fname, pn, skelpos, skelend = self.getFileInfo(pos)
|
|
# an existing "id=" or "name=" attribute must exist in original xhtml otherwise it would not have worked for linking.
|
|
# Amazon seems to have added its own additional "aid=" inside tags whose contents seem to represent
|
|
# some position information encoded into Base32 name.
|
|
# so find the closest "id=" before position the file by actually searching in that file
|
|
idtext = self.getIDTag(pos)
|
|
return fname, idtext
|
|
|
|
def getIDTag(self, pos):
|
|
# find the first tag with a named anchor (name or id attribute) before pos
|
|
fname, pn, skelpos, skelend = self.getFileInfo(pos)
|
|
if pn is None and skelpos is None:
|
|
logger.debug("Error: getIDTag - no file contains %s" % pos)
|
|
textblock = self.parts[pn]
|
|
npos = pos - skelpos
|
|
# if npos inside a tag then search all text before the its end of tag marker
|
|
pgt = textblock.find(b">", npos)
|
|
plt = textblock.find(b"<", npos)
|
|
if plt == npos or pgt < plt:
|
|
npos = pgt + 1
|
|
# find id and name attributes only inside of tags
|
|
# use a reverse tag search since that is faster
|
|
# inside any < > pair find "id=" and "name=" attributes return it
|
|
# [^>]* means match any amount of chars except for '>' char
|
|
# [^'"] match any amount of chars except for the quote character
|
|
# \s* means match any amount of whitespace
|
|
textblock = textblock[0:npos]
|
|
id_pattern = re.compile(
|
|
br"""<[^>]*\sid\s*=\s*['"]([^'"]*)['"]""", re.IGNORECASE
|
|
)
|
|
name_pattern = re.compile(
|
|
br"""<[^>]*\sname\s*=\s*['"]([^'"]*)['"]""", re.IGNORECASE
|
|
)
|
|
aid_pattern = re.compile(br"""<[^>]+\s(?:aid|AID)\s*=\s*['"]([^'"]+)['"]""")
|
|
for tag in reverse_tag_iter(textblock):
|
|
# any ids in the body should default to top of file
|
|
if tag[0:6] == b"<body ":
|
|
return b""
|
|
if tag[0:6] != b"<meta ":
|
|
m = id_pattern.match(tag) or name_pattern.match(tag)
|
|
if m is not None:
|
|
return m.group(1)
|
|
m = aid_pattern.match(tag)
|
|
if m is not None:
|
|
self.linked_aids.add(m.group(1))
|
|
return b"aid-" + m.group(1)
|
|
return b""
|
|
|
|
# do we need to do deep copying
|
|
def setParts(self, parts):
|
|
assert len(parts) == len(self.parts)
|
|
for i in range(len(parts)):
|
|
self.parts[i] = parts[i]
|
|
|
|
# do we need to do deep copying
|
|
def setFlows(self, flows):
|
|
assert len(flows) == len(self.flows)
|
|
for i in range(len(flows)):
|
|
self.flows[i] = flows[i]
|
|
|
|
# get information about the part (file) that exists at pos in original rawML
|
|
def getSkelInfo(self, pos):
|
|
for [partnum, pdir, filename, start, end, aidtext] in self.partinfo:
|
|
if pos >= start and pos < end:
|
|
return [partnum, pdir, filename, start, end, aidtext]
|
|
return [None, None, None, None, None, None]
|
|
|
|
# fileno is actually a reference into fragtbl (a fragment)
|
|
def getGuideText(self):
|
|
guidetext = b""
|
|
for [ref_type, ref_title, fileno] in self.guidetbl:
|
|
if ref_type == b"thumbimagestandard":
|
|
continue
|
|
if ref_type not in _guide_types and not ref_type.startswith(b"other."):
|
|
if ref_type == b"start":
|
|
ref_type = b"text"
|
|
else:
|
|
ref_type = b"other." + ref_type
|
|
[pos, idtext, filenum, seqnm, startpos, length] = self.fragtbl[fileno]
|
|
[pn, pdir, filename, skelpos, skelend, aidtext] = self.getSkelInfo(pos)
|
|
idtext = self.getIDTag(pos)
|
|
linktgt = filename.encode("utf-8")
|
|
if idtext != b"":
|
|
linktgt += b"#" + idtext
|
|
guidetext += (
|
|
b'<reference type="'
|
|
+ ref_type
|
|
+ b'" title="'
|
|
+ ref_title
|
|
+ b'" href="'
|
|
+ utf8_str(pdir)
|
|
+ b"/"
|
|
+ linktgt
|
|
+ b'" />\n'
|
|
)
|
|
# opf is encoded utf-8 so must convert any titles properly
|
|
guidetext = (guidetext.decode(self.mh.codec)).encode("utf-8")
|
|
return guidetext
|
|
|
|
def getPageIDTag(self, pos):
|
|
# find the first tag with a named anchor (name or id attribute) before pos
|
|
# but page map offsets need to little more leeway so if the offset points
|
|
# into a tag look for the next ending tag "/>" or "</" and start your search from there.
|
|
fname, pn, skelpos, skelend = self.getFileInfo(pos)
|
|
if pn is None and skelpos is None:
|
|
logger.debug("Error: getIDTag - no file contains %s" % pos)
|
|
textblock = self.parts[pn]
|
|
npos = pos - skelpos
|
|
# if npos inside a tag then search all text before next ending tag
|
|
pgt = textblock.find(b">", npos)
|
|
plt = textblock.find(b"<", npos)
|
|
if plt == npos or pgt < plt:
|
|
# we are in a tag
|
|
# so find first ending tag
|
|
pend1 = textblock.find(b"/>", npos)
|
|
pend2 = textblock.find(b"</", npos)
|
|
if pend1 != -1 and pend2 != -1:
|
|
pend = min(pend1, pend2)
|
|
else:
|
|
pend = max(pend1, pend2)
|
|
if pend != -1:
|
|
npos = pend
|
|
else:
|
|
npos = pgt + 1
|
|
# find id and name attributes only inside of tags
|
|
# use a reverse tag search since that is faster
|
|
# inside any < > pair find "id=" and "name=" attributes return it
|
|
# [^>]* means match any amount of chars except for '>' char
|
|
# [^'"] match any amount of chars except for the quote character
|
|
# \s* means match any amount of whitespace
|
|
textblock = textblock[0:npos]
|
|
id_pattern = re.compile(
|
|
br"""<[^>]*\sid\s*=\s*['"]([^'"]*)['"]""", re.IGNORECASE
|
|
)
|
|
name_pattern = re.compile(
|
|
br"""<[^>]*\sname\s*=\s*['"]([^'"]*)['"]""", re.IGNORECASE
|
|
)
|
|
for tag in reverse_tag_iter(textblock):
|
|
# any ids in the body should default to top of file
|
|
if tag[0:6] == b"<body ":
|
|
return b""
|
|
if tag[0:6] != b"<meta ":
|
|
m = id_pattern.match(tag) or name_pattern.match(tag)
|
|
if m is not None:
|
|
return m.group(1)
|
|
return b""
|