| |
- __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')
| |