IronPython.Runtime Namespace
 
Classes
  ClassDescription
Public classBuiltinPythonModule
Implements a built-in module which is instanced per PythonContext. Implementers can subclass this type and then have a module which has efficient access to internal state (this doesn't need to go through PythonContext.GetModuleState). These modules can also declare module level globals which they'd like to provide efficient access to by overloading GetGlobalVariableNames. When Initialize is called these globals are provided and can be cached in the instance for fast global access. Just like normal static modules these modules are registered with the PythonModuleAttribute.
Public classByteArray
bytearray(string, encoding[, errors]) -> bytearray bytearray(iterable) -> bytearray Construct a mutable bytearray object from: - an iterable yielding values in range(256), including: + a list of integer values + a bytes, bytearray, buffer, or array object - a text string encoded using the specified encoding bytearray([int]) -> bytearray Construct a zero-ititialized bytearray of the specified length. (default=0)
Public classBytes
Public classclassmethod
Public classClassMethodAttribute
Marks a method as being a class method. The PythonType which was used to access the method will then be passed as the first argument.
Public classClassMethodDescriptor
Public classClosureCell
Public classClrModule
this class contains objecs and static methods used for .NET/CLS interop with Python.
Public classClrModuleArgChecker
Decorator for verifying the arguments to a function are of a specified type.
Public classClrModuleReferencesList
Public classClrModuleReturnChecker
Decorator for verifying the return type of functions.
Public classClrModuleRuntimeArgChecker
Returned value when using clr.accepts/ArgChecker. Validates the argument types and then calls the original function.
Public classClrModuleRuntimeReturnChecker
Returned value when using clr.returns/ReturnChecker. Calls the original function and validates the return type is of a specified type.
Public classCodeContext
Captures and flows the state of executing code from the generated Python code into the IronPython runtime.
Public classCompiledLoader
Public classConverter
Public classDefaultContext
Public classDictionaryGenericWrapperK, V
Public classDictionaryItemEnumerator
Note: IEnumerator innerEnum = Dictionary<K,V>.KeysCollections.GetEnumerator(); innerEnum.MoveNext() will throw InvalidOperation even if the values get changed, which is supported in python
Public classDictionaryItemView
Public classDictionaryKeyEnumerator
Note: IEnumerator innerEnum = Dictionary<K,V>.KeysCollections.GetEnumerator(); innerEnum.MoveNext() will throw InvalidOperation even if the values get changed, which is supported in python
Public classDictionaryKeyView
Public classDictionaryOps
Provides both helpers for implementing Python dictionaries as well as providing public methods that should be exposed on all dictionary types. Currently these are published on IDictionary<object, object>
Public classDictionaryValueEnumerator
Note: IEnumerator innerEnum = Dictionary<K,V>.KeysCollections.GetEnumerator(); innerEnum.MoveNext() will throw InvalidOperation even if the values get changed, which is supported in python
Public classDictionaryValueView
Public classEnumerate
Public classFrozenSetCollection
Immutable set class
Public classFunctionCode
Represents a piece of code. This can reference either a CompiledCode object or a Function. The user can explicitly call FunctionCode by passing it into exec or eval.
Public classFutureBuiltins
Public classIEnumerableOfTWrapperT
Public classIEnumeratorOfTWrapperT
Public classImporter
Importer class - used for importing modules. Used by Ops and __builtin__ Singleton living on Python engine.
Public classIndex
Wrapper class used when a user defined type (new-style or old-style) defines __index__. We provide a conversion from all user defined types to the Index type so they can be used for determing and method bind time the most appropriate method to dispatch to.
Public classItemEnumerable
Public classItemEnumerator
Public classKwCallInfo
Public classList
Public classListGenericWrapperT
Public classListIterator
Public classListReverseIterator
Public classLiteralParser
Summary description for ConstantValue.
Public classMemoryView
Public classMethod
Public classMissingParameter
Public classModuleContext
Captures the globals and other state of module code.
Public classModuleGlobalCache
Cached global value. Created and maintained on a per-language basis. Default implementation returns a singleton which indicates caching is not occuring.
Public classModuleLoader
Public classProfiler
Manages the acquisition of profiling data for a single ScriptRuntime
Public classProfilerTreatsAsExternalAttribute
Marks that this built-in method should be treated as external by the profiler. When placed on a call emitted into a Python method, all the time spent in this call will still show up in its parent's inclusive time, but will not be part of its exclusive time.
Public classPythonBuffer
Public classPythonContext
Public classPythonDictionary
Public classPythonEnumerable
Public classPythonEnumerator
Public classPythonFile
Public classPythonFunction
Created for a user-defined function.
Public classPythonGenerator
Public classPythonHiddenBaseClassAttribute
Marks a class as being hidden from the Python hierarchy. This is applied to the base class and then all derived types will not see the base class in their hierarchy and will not be able to access members declaredo on the base class.
Public classPythonModule
Python module. Stores classes, functions, and data. Usually a module is created by importing a file or package from disk. But a module can also be directly created by calling the module type and providing a name or optionally a documentation string.
Public classPythonModuleAttribute
This assembly-level attribute specifies which types in the engine represent built-in Python modules. Members of a built-in module type should all be static as an instance is never created.
Public classPythonProperty
Public classPythonTuple
Public classPythonTypeAttribute
Marks a type as being a PythonType for purposes of member lookup, creating instances, etc... If defined a PythonType will use __new__ / __init__ when creating instances. This allows the object to match the native Python behavior such as returning cached values from __new__ or supporting initialization to run multiple times via __init__. The attribute also allows you to specify an alternate type name. This allows the .NET name to be different from the Python name so they can follow .NET naming conventions. Types defining this attribute also don't show CLR methods such as Equals, GetHashCode, etc... until the user has done an import clr.
Public classReversedEnumerator
Public classSentinelIterator
Public classSequenceTypeInfoAttribute
Provides more specific type information for Python lists which are not strongly typed. This attribute can be applied to fields, parameters, proeprties, and return values. It can be inspected to get type information about the types of the values of the expected list or the returned list.
Public classSetCollection
Mutable set class
Public classSetIterator
Iterator over sets
Public classSiteLocalStorage
Public classSiteLocalStorageT
Provides storage which is flowed into a callers site. The same storage object is flowed for multiple calls enabling the callee to cache data that can be re-used across multiple calls. Data is a public field so that this works properly with DynamicSite's as the reference type (and EnsureInitialize)
Public classSlice
Public classstaticmethod
Public classSuper
Public classSymbols
Public classTupleEnumerator
public class to get optimized
Public classUnboundLocalException
Public classUnboundNameException
Public classWeakRefTracker
single finalizable instance used to track and deliver all the callbacks for a single object that has been weakly referenced by one or more references and proxies. The reference to this object is held in objects that implement IWeakReferenceable.
Public classXRange
Public classXRangeIterator
Structures
  StructureDescription
Public structureOrderedLocker
we need to lock both objects (or copy all of one's data w/ it's lock held, and then compare, which is bad). Therefore we have a strong order for locking on the two objects based upon the hash code or object identity in case of a collision
Public structureProfilerData
Encapsulates profiler data to return to clients
Interfaces
  InterfaceDescription
Public interfaceIBufferProtocol
Public interfaceICodeFormattable
Public interfaceIParameterSequence
Represents a sequence which may have been provided as a set of parameters to an indexer. TODO: This should be removed, and all uses of this should go to [SpecialName]object GetItem(..., params object[] keys) and [SpecialName]void SetItem(..., params object [] keys) or this[params object[]xyz] which is also legal. currently this exists for backwards compatibility w/ IronPython's "expandable tuples".
Public interfaceIProxyObject
Public interfaceIPythonBufferable
Public interfaceIPythonMembersList
Provides a list of all the members of an instance. ie. all the keys in the dictionary of the object. Note that it can contain objects that are not strings. Such keys can be added in IronPython using syntax like: obj.__dict__[100] = someOtherObject This Python specific version also supports filtering based upon the show cls flag by flowing in the code context.
Public interfaceIReversible
Public interfaceIWeakReferenceable
Defines the internal interface used for accessing weak references and adding finalizers to user-defined types.
Delegates
  DelegateDescription
Public delegateHashDelegate
Enumerations