AdvancedHTMLParser.SpecialAttributes
index

Copyright (c) 2015, 2017, 2018, 2019 Tim Savannah under LGPLv3. All Rights Reserved.
 
See LICENSE (https://gnu.org/licenses/lgpl-3.0.txt) for more information.
 
 
These are various helpers for "special" attributes

 
Modules
       
copy
weakref

 
Classes
       
__builtin__.dict(__builtin__.object)
SpecialAttributesDict
__builtin__.list(__builtin__.object)
DOMTokenList
__builtin__.object
AttributeNode
AttributeNodeMap
StyleAttribute

 
class AttributeNode(__builtin__.object)
    AttributeNode - A basic NamedNode implementing Attribute Node, mostly.
 
  Methods defined here:
__eq__(self, other)
__getattribute__(self, name)
__getitem__(self, name)
__hash__(self)
__init__(self, name, value, ownerElement, ownerDocument=None)
__ne__(self, other)
__repr__(self)
__setattr__(self, name, value)
__str__(self)
cloneNode(self)
cloneNode - Make a copy of this node, but not associated with the ownerElement
 
@return AttributeNode

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
localName
namespaceURI
nodeName
nodeType
nodeType - Return this node type (ATTRIBUTE_NODE)
nodeValue
nodeValue - value of this node.
prefix
specified

 
class AttributeNodeMap(__builtin__.object)
    AttributeNodeMap - A map of AttributeNode associated with an element.
 
    Not very useful, I've never actually seen the "Node" interface used in practice,
    but here just incase...
 
    You probably want to just use the normal getAttribute and setAttribute on nodes... that way makes sense.
     This way really doesn't make a whole lot of sense.
 
  Methods defined here:
X__setitem__(self, name, value)
__getattribute__(self, name)
__getitem__(self, name)
__init__(self, attributesDict, ownerElement, ownerDocument=None)
__iter__(self)
__str__(self)
getNamedItem(self, name)
item = getNamedItem(self, name)
setNamedItem(self, *args, **kwargs)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class DOMTokenList(__builtin__.list)
    DOMTokenList - Imitates a DOMTokenList, that is a list in normal form, but joins via " " on stringifying
 
        and can be constructed from a string by stripping to single words and splitting by " ", ignoring empty string case
 
 
Method resolution order:
DOMTokenList
__builtin__.list
__builtin__.object

Methods defined here:
__init__(self, *args, **kwargs)
__init__ - Create a DOMTaskList.
 
    Can take no arguments to create empty list
 
    Can take a list argument to use those elements in this list
 
    Can take a string argument, and will strip whitespace and retain each distinct word as an element
__repr__(self)
__str__(self)
__str__ - String this element. Equivilant to a javascript DOMTokenList.toString(),
 
    and will join by ' '

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from __builtin__.list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__iadd__(...)
x.__iadd__(y) <==> x+=y
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(...)
x.__rmul__(n) <==> n*x
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
__setslice__(...)
x.__setslice__(i, j, y) <==> x[i:j]=y
 
Use  of negative indices is not supported.
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
append(...)
L.append(object) -- append object to end
count(...)
L.count(value) -> integer -- return number of occurrences of value
extend(...)
L.extend(iterable) -- extend list by appending elements from the iterable
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
insert(...)
L.insert(index, object) -- insert object before index
pop(...)
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
remove(...)
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
reverse(...)
L.reverse() -- reverse *IN PLACE*
sort(...)
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Data and other attributes inherited from __builtin__.list:
__hash__ = None
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class SpecialAttributesDict(__builtin__.dict)
    SpecialAttributesDict - A dictionary that supports the various special members, to allow javascript-like syntax
 
 
Method resolution order:
SpecialAttributesDict
__builtin__.dict
__builtin__.object

Methods defined here:
__contains__(self, key)
__delitem__(self, key)
__delitem__ - Called when someone does del tag.attributes['key']
 
    @param key <str> - The attribute key to delete
__getitem__(self, key)
__init__(self, tag)
# A dict that supports returning special members
__iter__(self)
__repr__(self)
__setitem__(self, key, value)
get(self, key, default=None)
get - Gets an attribute by key with the chance to provide a default value
 
    @param key <str> - The key to query
 
    @param default <Anything> Default None - The value to return if key is not found
 
 @return - The value of attribute at #key, or #default if not present.
items(self)
keys(self)
pop(self, key)
setdefault(self, *args, **kwargs)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
tag
tag - Property (dot-access) for the associated tag to this attributes dict
 
      Handles getting the value from a weak association
 
        @return <AdvancedTag/None> - The associated tag, or None if no association

Methods inherited from __builtin__.dict:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__gt__(...)
x.__gt__(y) <==> x>y
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__sizeof__(...)
D.__sizeof__() -> size of D in memory, in bytes
clear(...)
D.clear() -> None.  Remove all items from D.
copy(...)
D.copy() -> a shallow copy of D
fromkeys(...)
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
has_key(...)
D.has_key(k) -> True if D has a key k, else False
iteritems(...)
D.iteritems() -> an iterator over the (key, value) items of D
iterkeys(...)
D.iterkeys() -> an iterator over the keys of D
itervalues(...)
D.itervalues() -> an iterator over the values of D
popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
update(...)
D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
values(...)
D.values() -> list of D's values
viewitems(...)
D.viewitems() -> a set-like object providing a view on D's items
viewkeys(...)
D.viewkeys() -> a set-like object providing a view on D's keys
viewvalues(...)
D.viewvalues() -> an object providing a view on D's values

Data and other attributes inherited from __builtin__.dict:
__hash__ = None
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class StyleAttribute(__builtin__.object)
    StyleAttribute - Represents the "style" field on a tag.
 
  Methods defined here:
__copy__(self)
__deepcopy__(self, memo)
__eq__(self, other)
__eq__ - Test if two "style" tag properties are equal.
 
    NOTE: This differs from javascript. In javascript, no two styles equal eachother, it's
            an identity comparison not a value comparison.
 
          I don't understand how that is useful, but in a future version we may choose to adopt
            that "feature" and export comparison into a different "isSaneAs(otherStyle)" function
 
    @param other<StyleAttribute> - The other style attribute map.
__getattribute__(self, name)
__getattribute__ - used on dot (.) access on a Style element.
 
@param name <str> - The style attribute name
 
  NOTE: This should the camelCase name (like paddingTop)
 
@return <str> - The attribute value or empty string if not set
__init__(self, styleValue, tag=None)
__init__ - Create a StyleAttribute object.
 
@param styleValue <str> - A style string ( like "display: none; padding-top: 5px" )
__ne__(self, other)
__repr__(self)
__setattr__(self, name, val)
__setattr__ - Used to set an attribute using dot (.) access on a Style element
 
@param name <str> - The attribute name
 
  NOTE: This must be the camelCase name (like paddingTop).
 
@param val <str> - The value of the attribute
__str__(self)
isEmpty(self)
isEmpty - Check if this is an "empty" style (no attributes set)
 
    @return <bool> - True if no attributes are set, otherwise False
setProperty(self, name, value)
setProperty - Set a style property to a value.
 
    NOTE: To remove a style, use a value of empty string, or None
 
     @param name <str> - The style name.
 
        NOTE: The dash names are expected here, whereas dot-access expects the camel case names.
 
          Example:  name="font-weight"  versus the dot-access  style.fontWeight
 
     @param value <str> - The style value, or empty string to remove property
setTag(self, tag)
setTag - Set the tag association for this style.
 
  This will handle the underlying weakref to the tag.
 
  Call setTag(None) to clear the association, otherwise setTag(tag) to associate this style to that tag.
 
 
    @param tag <AdvancedTag/None> - The new association. If None, the association is cleared, otherwise the passed tag
        becomes associated with this style.

Static methods defined here:
camelCaseToDashName(camelCase)
camelCaseToDashName - Convert a camel case name to a dash-name (like paddingTop to padding-top)
 
@param camelCase <str> - A camel-case string
 
@return <str> - A dash-name
dashNameToCamelCase(dashName)
dashNameToCamelCase - Converts a "dash name" (like padding-top) to its camel-case name ( like "paddingTop" )
 
@param dashName <str> - A name containing dashes
 
    NOTE: This method is currently unused, but may be used in the future. kept for completeness.
 
@return <str> - The camel-case form
styleToDict(styleStr)
getStyleDict - Gets a dictionary of style attribute/value pairs.
 
  NOTE: dash-names (like padding-top) are used here
 
@return - OrderedDict of "style" attribute.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
tag
tag - Property (dot-access variable) which will return the associated tag, if any.
 
  This method should be used for access to handle the weakref.
 
  @see setTag - Method to set or remove the tag association
 
    @return <AdvancedTag/None> - If a tag is associated with this style, it will be returned.
                                    Otherwise, None will be returned

Data and other attributes defined here:
RESERVED_ATTRIBUTES = ('_styleValue', '_styleDict', '_asStr', '_ensureHtmlAttribute', 'tag', '_tagRef', 'setTag', 'isEmpty', 'setProperty')

 
Data
        __all__ = ('SpecialAttributesDict', 'AttributeNode', 'AttributeNodeMap', 'StyleAttribute', 'DOMTokenList')