basictypes.basic_types
index
p:\properties\basictypes\basic_types.py

Stand-alone type-definition objects for basic data types
 
Rather than add class-methods to the built-in data types
module designs stand in datatypes which can be used to
define basicproperty property classes.

 
Modules
       
basictypes.booleanfix
basictypes.datatypedefinition
basictypes.latebind
basictypes.registry
traceback
types

 
Classes
       
BaseType_DT(DataTypeDefinition)
Boolean_DT
ClassName_DT
Class_DT
List_DT
Numeric_DT
Float_DT
Int_DT
Long_DT
Object_DT
StringLocale_DT
String_DT

 
class Boolean_DT(BaseType_DT)
    Boolean-integer data-type specifier
 
 
Method resolution order:
Boolean_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
check(cls, value) from type
Determine whether value conforms to definition
coerce(cls, value) from type
Coerce value to Boolean value
 
Accepted Values:
        (any value in self.falseValues) -- False
        __nonzero__ False -- False
        otherwise True

Data and other attributes defined here:
baseType = <type 'bool'>
bool(x) -> bool
 
Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.
dataType = 'bool'
falseValues = (0, None, '0', 'zero', 'null', 'none', 'false', 'f', 'no', '')

Class methods inherited from BaseType_DT:
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30610>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class ClassName_DT(BaseType_DT)
    Class-name data-type specifier
 
 
Method resolution order:
ClassName_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
coerce(cls, value) from type
Coerce to a string
 
Acceptable Values:
        class name (string or Unicode, Unicode will be encoded)
        class object (with __module__ and __name__)

Data and other attributes defined here:
baseType = <type 'str'>
str(object) -> string
 
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
dataType = 'str.classname'

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30930>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class Class_DT(BaseType_DT)
    Class-object data-type specifier
 
 
Method resolution order:
Class_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
coerce(cls, value) from type
Coerce to a class
 
Acceptable Values:
        Unicode/string class name
        a class

Data and other attributes defined here:
baseType = (<type 'type'>, <type 'classobj'>, <type 'function'>, <type 'instancemethod'>, <type 'builtin_function_or_method'>, <type 'builtin_function_or_method'>, <type 'instance'>, <type 'function'>, <type 'instancemethod'>)
dataType = 'class'

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30550>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class Float_DT(Numeric_DT)
    Integer data-type specifier
 
 
Method resolution order:
Float_DT
Numeric_DT
BaseType_DT
DataTypeDefinition
object

Data and other attributes defined here:
baseType = <type 'float'>
float(x) -> floating point number
 
Convert a string or number to a floating point number, if possible.
dataType = 'float'

Class methods inherited from Numeric_DT:
coerce(cls, value) from type
Coerce value to Numeric value (using baseType)
 
Accepted values:
        "", "0" -- 0
        numeric values
        ascii strings -- base type attempts to interpret

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30930>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class Int_DT(Numeric_DT)
    Integer data-type specifier
 
 
Method resolution order:
Int_DT
Numeric_DT
BaseType_DT
DataTypeDefinition
object

Data and other attributes defined here:
baseType = <type 'int'>
int(x[, base]) -> integer
 
Convert a string or number to an integer, if possible.  A floating point
argument will be truncated towards zero (this does not include a string
representation of a floating point number!)  When converting a string, use
the optional base.  It is an error to supply a base when converting a
non-string. If the argument is outside the integer range a long object
will be returned instead.
dataType = 'int'

Class methods inherited from Numeric_DT:
coerce(cls, value) from type
Coerce value to Numeric value (using baseType)
 
Accepted values:
        "", "0" -- 0
        numeric values
        ascii strings -- base type attempts to interpret

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30930>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class List_DT(BaseType_DT)
    List-of-objects data-type (no coercion of items)
 
Conceptually this is a listof_objects, but that would
make an inefficient type for such a common datatype.
 
 
Method resolution order:
List_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
coerce(cls, value) from type
Attempt to coerce the value to a list
 
Strings and unicode values are converted to
[ value ].  Anything else which can be processed with
list( value ) is, everything else raises errors
when list(value) is called.

Data and other attributes defined here:
baseType = <type 'list'>
list() -> new list
list(sequence) -> new list initialized from sequence's items

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A308B0>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class Long_DT(Numeric_DT)
    Long-integer data-type specifier
 
 
Method resolution order:
Long_DT
Numeric_DT
BaseType_DT
DataTypeDefinition
object

Data and other attributes defined here:
baseType = <type 'long'>
long(x[, base]) -> integer
 
Convert a string or number to a long integer, if possible.  A floating
point argument will be truncated towards zero (this does not include a
string representation of a floating point number!)  When converting a
string, use the optional base.  It is an error to supply a base when
converting a non-string.
dataType = 'long'

Class methods inherited from Numeric_DT:
coerce(cls, value) from type
Coerce value to Numeric value (using baseType)
 
Accepted values:
        "", "0" -- 0
        numeric values
        ascii strings -- base type attempts to interpret

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30830>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class Numeric_DT(BaseType_DT)
    
Method resolution order:
Numeric_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
coerce(cls, value) from type
Coerce value to Numeric value (using baseType)
 
Accepted values:
        "", "0" -- 0
        numeric values
        ascii strings -- base type attempts to interpret

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from BaseType_DT:
baseType = None

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30670>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class Object_DT(BaseType_DT)
    Generic "object" data-type
 
 
Method resolution order:
Object_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
coerce(cls, value) from type
Coerce value to the appropriate data type

Data and other attributes defined here:
baseType = <type 'object'>
The most base type
dataType = 'object'

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30A90>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class StringLocale_DT(BaseType_DT)
    String data-type specifier
 
 
Method resolution order:
StringLocale_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
coerce(cls, value) from type
Coerce the value to string (true string) value
 
Acceptable Values:
        Unicode -- value.encode()
        None --  ""
        integer, float, long, complex -- str(value)

Data and other attributes defined here:
baseType = <type 'str'>
str(object) -> string
 
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
dataType = 'str.locale'

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A30EB0>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)

 
class String_DT(BaseType_DT)
    String (Unicode) data-type specifier
 
 
Method resolution order:
String_DT
BaseType_DT
DataTypeDefinition
object

Class methods defined here:
coerce(cls, value) from type
Coerce value to Unicode value
 
Accepted values:
        None -- u""
        str instance -- value.decode()
        int,float,long,complex -- unicode(value)

Data and other attributes defined here:
baseType = <type 'unicode'>
unicode(string [, encoding[, errors]]) -> object
 
Create a new Unicode object from the given encoded string.
encoding defaults to the current default string encoding.
errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.
dataType = 'str'

Class methods inherited from BaseType_DT:
check(cls, value) from type
Determine whether value conforms to definition
factories(cls) from type
Determine a sequence of factory objects

Static methods inherited from BaseType_DT:
__new__(cls, *args, **named)
Create a new instance of our base-type

Data and other attributes inherited from DataTypeDefinition:
__dict__ = <dictproxy object at 0x01A303D0>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'DataTypeDefinition' objects>
list of weak references to the object (if defined)