(**************************************************************************)

unit PythonEngine;

{$IFNDEF DELPHI2010_OR_HIGHER}

//Error! Delphi 2010 or higher is required!

{$ENDIF}

{$define _so_files}

Types,

Windows,

Dl,

DynLibs,

Posix.DLfcn,

Posix.Pthread,

Classes,

SysUtils,

SyncObjs,

Variants,

MethodCallBack;

{$IF CompilerVersion >= 33}

pidSupportedPlatforms = pidWin32 or pidWin64 or pidOSX32 or pidOSX64 or pidLinux64;

{$ELSE}

pidSupportedPlatforms = pidWin32 or pidWin64 or pidOSX32;

{$IFEND}

TPythonVersionProp = record

DllName : string;

RegVersion : string;

APIVersion : Integer;

end;

PYTHON_KNOWN_VERSIONS: array[1..8] of TPythonVersionProp =

(

(DllName: 'python33.dll'; RegVersion: '3.3'; APIVersion: 1013),

(DllName: 'python34.dll'; RegVersion: '3.4'; APIVersion: 1013),

(DllName: 'python35.dll'; RegVersion: '3.5'; APIVersion: 1013),

(DllName: 'python36.dll'; RegVersion: '3.6'; APIVersion: 1013),

(DllName: 'python37.dll'; RegVersion: '3.7'; APIVersion: 1013),

(DllName: 'python38.dll'; RegVersion: '3.8'; APIVersion: 1013),

(DllName: 'python39.dll'; RegVersion: '3.9'; APIVersion: 1013),

(DllName: 'python310.dll'; RegVersion: '3.10'; APIVersion: 1013)

);

PYTHON_KNOWN_VERSIONS: array[1..8] of TPythonVersionProp =

(

(DllName: 'libpython3.3m.so'; RegVersion: '3.3'; APIVersion: 1013),

(DllName: 'libpython3.4m.so'; RegVersion: '3.4'; APIVersion: 1013),

(DllName: 'libpython3.5m.so'; RegVersion: '3.5'; APIVersion: 1013),

(DllName: 'libpython3.6m.so'; RegVersion: '3.6'; APIVersion: 1013),

(DllName: 'libpython3.7m.so'; RegVersion: '3.7'; APIVersion: 1013),

(DllName: 'libpython3.8.so'; RegVersion: '3.8'; APIVersion: 1013),

(DllName: 'libpython3.9.so'; RegVersion: '3.9'; APIVersion: 1013),

(DllName: 'libpython3.10.so'; RegVersion: '3.10'; APIVersion: 1013)

);

PYTHON_KNOWN_VERSIONS: array[1..8] of TPythonVersionProp =

(

(DllName: 'libpython3.3.dylib'; RegVersion: '3.3'; APIVersion: 1013),

(DllName: 'libpython3.4.dylib'; RegVersion: '3.4'; APIVersion: 1013),

(DllName: 'libpython3.5.dylib'; RegVersion: '3.5'; APIVersion: 1013),

(DllName: 'libpython3.6.dylib'; RegVersion: '3.6'; APIVersion: 1013),

(DllName: 'libpython3.7.dylib'; RegVersion: '3.7'; APIVersion: 1013),

(DllName: 'libpython3.8.dylib'; RegVersion: '3.8'; APIVersion: 1013),

(DllName: 'libpython3.9.dylib'; RegVersion: '3.9'; APIVersion: 1013),

(DllName: 'libpython3.10.dylib'; RegVersion: '3.10'; APIVersion: 1013)

);

COMPILED_FOR_PYTHON_VERSION_INDEX = High(PYTHON_KNOWN_VERSIONS);

PYT_METHOD_BUFFER_INCREASE = 10;

PYT_MEMBER_BUFFER_INCREASE = 10;

PYT_GETSET_BUFFER_INCREASE = 10;

METH_VARARGS = $0001;

METH_KEYWORDS = $0002;

// Masks for the co_flags field of PyCodeObject

CO_OPTIMIZED = $0001;

CO_NEWLOCALS = $0002;

CO_VARARGS = $0004;

CO_VARKEYWORDS = $0008;

// Rich comparison opcodes introduced in version 2.1

Py_LT = 0;

Py_LE = 1;

Py_EQ = 2;

Py_NE = 3;

Py_GT = 4;

Py_GE = 5;

// Delphi equivalent used by TPyObject

TRichComparisonOpcode = (pyLT, pyLE, pyEQ, pyNE, pyGT, pyGE);

C_Long = Integer;

C_ULong = Cardinal;

C_Long= NativeInt;

C_ULong = NativeUInt;

const

Py_TPFLAGS_HEAPTYPE = (C_ULong(1) shl 9);

Py_TPFLAGS_BASETYPE = (C_ULong(1) shl 10);

Py_TPFLAGS_READY = (C_ULong(1) shl 12);

Py_TPFLAGS_READYING = (C_ULong(1) shl 13);

Py_TPFLAGS_HAVE_GC = (C_ULong(1) shl 14);

_Py_TPFLAGS_HAVE_VECTORCALL = (C_ULong(1) shl 11);

Py_TPFLAGS_METHOD_DESCRIPTOR = (C_ULong(1) shl 17);

Py_TPFLAGS_HAVE_VERSION_TAG = (C_ULong(1) shl 18);

Py_TPFLAGS_VALID_VERSION_TAG = (C_ULong(1) shl 19);

Py_TPFLAGS_IS_ABSTRACT = (C_ULong(1) shl 20);

Py_TPFLAGS_LONG_SUBCLASS = (C_ULong(1) shl 24);

Py_TPFLAGS_LIST_SUBCLASS = (C_ULong(1) shl 25);

Py_TPFLAGS_TUPLE_SUBCLASS = (C_ULong(1) shl 26);

Py_TPFLAGS_BYTES_SUBCLASS = (C_ULong(1) shl 27);

Py_TPFLAGS_UNICODE_SUBCLASS = (C_ULong(1) shl 28);

Py_TPFLAGS_DICT_SUBCLASS = (C_ULong(1) shl 29);

Py_TPFLAGS_BASE_EXC_SUBCLASS = (C_ULong(1) shl 30);

Py_TPFLAGS_TYPE_SUBCLASS = (C_ULong(1) shl 31);

Py_TPFLAGS_DEFAULT = Py_TPFLAGS_BASETYPE or Py_TPFLAGS_HAVE_VERSION_TAG;

TPFlag = (tpfHeapType, tpfBaseType, tpfReady, tpfReadying, tpfHaveGC,

tpVectorCall, tpMethodDescriptor, tpHaveVersionTag,

tpValidVersionTag, tpIsAbstract, tpLongSubclass,

tpListSubClass, tpTupleSubclass, tpBytesSubclass,

tpBaseExcSubclass, tpTypeSubclass);

TPFlags = set of TPFlag;

TPFLAGS_DEFAULT = [tpfBaseType, tpHaveVersionTag];

single_input = 256;

file_input = 257;

eval_input = 258;

// UnicodeObject.h

// Return values of the PyUnicode_KIND() macro

{

PyUnicode_WCHAR_KIND = 0;

PyUnicode_1BYTE_KIND = 1;

PyUnicode_2BYTE_KIND = 2;

PyUnicode_4BYTE_KIND = 4;

// structmember.h

T_SHORT = 0;

T_INT = 1;

T_LONG = 2;

T_FLOAT = 3;

T_DOUBLE = 4;

T_STRING = 5;

T_OBJECT = 6;

T_CHAR = 7; //* 1-character string */

T_BYTE = 8; //* 8-bit signed int */

T_UBYTE = 9;

T_USHORT = 10;

T_UINT = 11;

T_ULONG = 12;

T_STRING_INPLACE= 13;

T_OBJECT_EX = 16;{* Like T_OBJECT, but raises AttributeError

READONLY = 1;

RO = READONLY; //* Shorthand */

READ_RESTRICTED = 2;

PY_WRITE_RESTRICTED = 4;

RESTRICTED = (READ_RESTRICTED or PY_WRITE_RESTRICTED);

TPyMemberType = (mtShort, mtInt, mtLong, mtFloat, mtDouble, mtString, mtObject,

mtChar, mtByte, mtUByte, mtUShort, mtUInt, mtULong,

mtStringInplace, mtObjectEx);

TPyMemberFlag = (mfDefault, mfReadOnly, mfReadRestricted, mfWriteRestricted, mfRestricted);

CR = #13;

LF = #10;

TAB = #09;

CRLF = CR+LF;

PP_frozen = ^P_frozen;

P_frozen = ^_frozen;

PPyObject = ^PyObject;

PPPyObject = ^PPyObject;

PPPPyObject = ^PPPyObject;

PPyTypeObject = ^PyTypeObject;

PPySliceObject = ^PySliceObject;

AtExitProc = procedure;

PyCFunction = function( self, args:PPyObject): PPyObject; cdecl;

PyCFunctionWithKW = function( self, args, keywords:PPyObject): PPyObject; cdecl;

unaryfunc = function( ob1 : PPyObject): PPyObject; cdecl;

binaryfunc = function( ob1,ob2 : PPyObject): PPyObject; cdecl;

ternaryfunc = function( ob1,ob2,ob3 : PPyObject): PPyObject; cdecl;

inquiry = function( ob1 : PPyObject): integer; cdecl;

lenfunc = function( ob1 : PPyObject): NativeInt; cdecl;

coercion = function( ob1,ob2 : PPPyObject): integer; cdecl;

ssizeargfunc = function( ob1 : PPyObject; i: NativeInt): PPyObject; cdecl;

ssizeobjargproc = function( ob1 : PPyObject; i: NativeInt; ob2 : PPyObject):

integer; cdecl;

objobjargproc = function( ob1,ob2,ob3 : PPyObject): integer; cdecl;

pydestructor = procedure(ob: PPyObject); cdecl;

getattrfunc = function( ob1: PPyObject; name: PAnsiChar): PPyObject; cdecl;

setattrfunc = function( ob1: PPyObject; name: PAnsiChar; ob2: PPyObject): integer; cdecl;

reprfunc = function( ob: PPyObject): PPyObject; cdecl;

hashfunc = function( ob: PPyObject): NativeInt; cdecl; // !! in 2.x it is still a LongInt

getattrofunc = function( ob1,ob2: PPyObject): PPyObject; cdecl;

setattrofunc = function( ob1,ob2,ob3: PPyObject): integer; cdecl;

objobjproc = function ( ob1, ob2: PPyObject): integer; cdecl;

visitproc = function ( ob1: PPyObject; ptr: Pointer): integer; cdecl;

traverseproc = function ( ob1: PPyObject; proc: visitproc; ptr: Pointer): integer; cdecl;

richcmpfunc = function ( ob1, ob2 : PPyObject; i : Integer) : PPyObject; cdecl;

getiterfunc = function ( ob1 : PPyObject) : PPyObject; cdecl;

iternextfunc = function ( ob1 : PPyObject) : PPyObject; cdecl;

descrgetfunc = function ( ob1, ob2, ob3 : PPyObject) : PPyObject; cdecl;

descrsetfunc = function ( ob1, ob2, ob3 : PPyObject) : Integer; cdecl;

initproc = function ( self, args, kwds : PPyObject) : Integer; cdecl;

newfunc = function ( subtype: PPyTypeObject; args, kwds : PPyObject) : PPyObject; cdecl;

allocfunc = function ( self: PPyTypeObject; nitems : NativeInt) : PPyObject; cdecl;

PyNumberMethods = {$IFNDEF CPUX64}packed{$ENDIF} record

nb_add : binaryfunc;

nb_subtract : binaryfunc;

nb_multiply : binaryfunc;

nb_remainder : binaryfunc;

nb_divmod : binaryfunc;

nb_power : ternaryfunc;

nb_negative : unaryfunc;

nb_positive : unaryfunc;

nb_absolute : unaryfunc;

nb_bool : inquiry;

nb_invert : unaryfunc;

nb_lshift : binaryfunc;

nb_rshift : binaryfunc;

nb_and : binaryfunc;

nb_xor : binaryfunc;

nb_or : binaryfunc;

nb_int : unaryfunc;

nb_reserved : Pointer; // not used

nb_float : unaryfunc;

nb_inplace_add : binaryfunc;

nb_inplace_subtract : binaryfunc;

nb_inplace_multiply : binaryfunc;

nb_inplace_remainder : binaryfunc;

nb_inplace_power : ternaryfunc;

nb_inplace_lshift : binaryfunc;

nb_inplace_rshift : binaryfunc;

nb_inplace_and : binaryfunc;

nb_inplace_xor : binaryfunc;

nb_inplace_or : binaryfunc;

nb_floor_divide : binaryfunc;

nb_true_divide : binaryfunc;

nb_inplace_floor_divide : binaryfunc;

nb_inplace_true_divide : binaryfunc;

nb_index : unaryfunc;

nb_matrix_multiply : binaryfunc; // new in python 3.5

nb_inplace_matrix_multiply : binaryfunc; // new in python 3.5

end;

PPyNumberMethods = ^PyNumberMethods;

PySequenceMethods = {$IFNDEF CPUX64}packed{$ENDIF} record

sq_length : lenfunc;

sq_concat : binaryfunc;

sq_repeat : ssizeargfunc;

sq_item : ssizeargfunc;

was_sq_slice : Pointer; // empty slot in python 3.x

sq_ass_item : ssizeobjargproc;

was_sq_ass_slice : Pointer; // empty slot in python 3.x

sq_contains : objobjproc;

sq_inplace_concat : binaryfunc;

sq_inplace_repeat : ssizeargfunc;

end;

PPySequenceMethods = ^PySequenceMethods;

PyMappingMethods = {$IFNDEF CPUX64}packed{$ENDIF} record

mp_length : lenfunc;

mp_subscript : binaryfunc;

mp_ass_subscript : objobjargproc;

end;

PPyMappingMethods = ^PyMappingMethods;

Py_complex = {$IFNDEF CPUX64}packed{$ENDIF} record

real : double;

imag : double;

end;

PyObject = {$IFNDEF CPUX64}packed{$ENDIF} record

ob_refcnt: NativeInt;

ob_type: PPyTypeObject;

end;

_frozen = {$IFNDEF CPUX64}packed{$ENDIF} record

name : PAnsiChar;

code : PByte;

size : Integer;

end;

PySliceObject = {$IFNDEF CPUX64}packed{$ENDIF} record

ob_refcnt: NativeInt;

ob_type: PPyTypeObject;

start, stop, step: PPyObject;

end;

PPyMethodDef = ^PyMethodDef;

PyMethodDef = {$IFNDEF CPUX64}packed{$ENDIF} record

ml_name: PAnsiChar;

ml_meth: PyCFunction;

ml_flags: Integer;

ml_doc: PAnsiChar;

end;

// structmember.h

PPyMemberDef = ^PyMemberDef;

PyMemberDef = {$IFNDEF CPUX64}packed{$ENDIF} record

name : PAnsiChar;

_type : integer;

offset : NativeInt;

flags : integer;

doc : PAnsiChar;

end;

// descrobject.h

// Descriptors

getter = function ( obj : PPyObject; context : Pointer) : PPyObject; cdecl;

setter = function ( obj, value : PPyObject; context : Pointer) : integer; cdecl;

PPyGetSetDef = ^PyGetSetDef;

PyGetSetDef = {$IFNDEF CPUX64}packed{$ENDIF} record

name : PAnsiChar;

get : getter;

_set : setter;

doc : PAnsiChar;

closure : Pointer;

end;

wrapperfunc = function (self, args: PPyObject; wrapped : Pointer) : PPyObject; cdecl;

pwrapperbase = ^wrapperbase;

wrapperbase = {$IFNDEF CPUX64}packed{$ENDIF} record

name : PAnsiChar;

wrapper : wrapperfunc;

doc : PAnsiChar;

end;

// Various kinds of descriptor objects

{#define PyDescr_COMMON \

PPyDescrObject = ^PyDescrObject;

PyDescrObject = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

end;

PPyMethodDescrObject = ^PyMethodDescrObject;

PyMethodDescrObject = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

// End of PyDescr_COMMON

d_method : PPyMethodDef;

end;

PPyMemberDescrObject = ^PyMemberDescrObject;

PyMemberDescrObject = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

// End of PyDescr_COMMON

d_member : PPyMemberDef;

end;

PPyGetSetDescrObject = ^PyGetSetDescrObject;

PyGetSetDescrObject = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

// End of PyDescr_COMMON

d_getset : PPyGetSetDef;

end;

PPyWrapperDescrObject = ^PyWrapperDescrObject;

PyWrapperDescrObject = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of PyDescr_COMMON

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

d_type : PPyTypeObject;

d_name : PPyObject;

// End of PyDescr_COMMON

d_base : pwrapperbase;

d_wrapped : Pointer; // This can be any function pointer

end;

PPyModuleDef_Base = ^PyModuleDef_Base;

PyModuleDef_Base = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

m_init : function( ) : PPyObject; cdecl;

m_index : NativeInt;

m_copy : PPyObject;

end;

PPyModuleDef = ^PyModuleDef;

PyModuleDef = {$IFNDEF CPUX64}packed{$ENDIF} record

m_base : PyModuleDef_Base;

m_name : PAnsiChar;

m_doc : PAnsiChar;

m_size : NativeInt;

m_methods : PPyMethodDef;

m_reload : inquiry;

m_traverse : traverseproc;

m_clear : inquiry;

m_free : inquiry;

end;

// object.h

PyTypeObject = {$IFNDEF CPUX64}packed{$ENDIF} record

ob_refcnt: NativeInt;

ob_type: PPyTypeObject;

ob_size: NativeInt; // Number of items in variable part

tp_name: PAnsiChar; // For printing

tp_basicsize,

tp_itemsize: NativeInt; // For allocation

// Methods to implement standard operations

tp_dealloc: pydestructor;

tp_vectorcall_offset: NativeInt;

tp_getattr: getattrfunc;

tp_setattr: setattrfunc;

tp_as_async: Pointer; // not implemented

tp_repr: reprfunc;

// Method suites for standard classes

tp_as_number: PPyNumberMethods;

tp_as_sequence: PPySequenceMethods;

tp_as_mapping: PPyMappingMethods;

// More standard operations (here for binary compatibility)

tp_hash: hashfunc;

tp_call: ternaryfunc;

tp_str: reprfunc;

tp_getattro: getattrofunc;

tp_setattro: setattrofunc;

// Functions to access object as input/output buffer

tp_as_buffer: Pointer; // PPyBufferProcs - not implemented

// Flags to define presence of optional/expanded features

tp_flags: C_ULong;

tp_doc: PAnsiChar; // Documentation string

// call function for all accessible objects

tp_traverse: traverseproc;

// delete references to contained objects

tp_clear: inquiry;

// rich comparisons

tp_richcompare: richcmpfunc;

// weak reference enabler

tp_weaklistoffset: NativeInt;

// Iterators

tp_iter : getiterfunc;

tp_iternext : iternextfunc;

// Attribute descriptor and subclassing stuff

tp_methods : PPyMethodDef;

tp_members : PPyMemberDef;

tp_getset : PPyGetSetDef;

tp_base : PPyTypeObject;

tp_dict : PPyObject;

tp_descr_get : descrgetfunc;

tp_descr_set : descrsetfunc;

tp_dictoffset : NativeInt;

tp_init : initproc;

tp_alloc : allocfunc;

tp_new : newfunc;

tp_free : pydestructor; // Low-level free-memory routine

tp_is_gc : inquiry; // For PyObject_IS_GC

tp_bases : PPyObject;

tp_mro : PPyObject; // method resolution order

tp_cache : PPyObject;

tp_subclasses : PPyObject;

tp_weaklist : PPyObject;

tp_del : PyDestructor;

tp_version_tag : Cardinal; // Type attribute cache version tag. Added in version 2.6

tp_finalize : PyDestructor;

tp_vectorcall : Pointer; // not implemented

//More spares

tp_xxx1 : NativeInt;

tp_xxx2 : NativeInt;

tp_xxx3 : NativeInt;

tp_xxx4 : NativeInt;

tp_xxx5 : NativeInt;

tp_xxx6 : NativeInt;

tp_xxx7 : NativeInt;

tp_xxx8 : NativeInt;

tp_xxx9 : NativeInt;

tp_xxx10 : NativeInt;

end;

// from pystate.h

// the structure of PyInterpreterState and PyThreadState is considered

// an implementation detail. It has been changing between python versions

// and there is no real use of accessing these structures directly.

PPyInterpreterState = Pointer;

PPyThreadState = Pointer;

// Parse tree node interface

PNode = ^node;

node = {$IFNDEF CPUX64}packed{$ENDIF} record

n_type : smallint;

n_str : PAnsiChar;

n_lineno : integer;

n_col_offset: integer;

n_nchildren : integer;

n_child : PNode;

end;

PPyCompilerFlags = ^PyCompilerFlags;

PyCompilerFlags = {$IFNDEF CPUX64}packed{$ENDIF} record

flags : integer;

cf_feature_version : integer; //added in Python 3.8

end;

// from datetime.h

{ # of bytes for year, month, and day. }

_PyDateTime_DATE_DATASIZE = 4;

{ # of bytes for hour, minute, second, and usecond. }

_PyDateTime_TIME_DATASIZE = 6;

{ # of bytes for year, month, day, hour, minute, second, and usecond. }

_PyDateTime_DATETIME_DATASIZE = 10;

PyDateTime_Delta = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : NativeInt; // -1 when unknown

days : Integer; // -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS

seconds : Integer; // 0 <= seconds < 24*3600 is invariant

microseconds: Integer; // 0 <= microseconds < 1000000 is invariant

end;

PPyDateTime_Delta = ^PyDateTime_Delta;

PyDateTime_TZInfo = {$IFNDEF CPUX64}packed{$ENDIF} record // a pure abstract base clase

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

end;

PPyDateTime_TZInfo = ^PyDateTime_TZInfo;

_PyDateTime_BaseTZInfo = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

end;

_PPyDateTime_BaseTZInfo = ^_PyDateTime_BaseTZInfo;

_PyDateTime_BaseTime = {$IFNDEF CPUX64}packed{$ENDIF} record // hastzinfo false

// Start of _PyDateTime_TIMEHEAD

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_TIME_DATASIZE)] of Byte;

// End of _PyDateTime_TIMEHEAD

end;

_PPyDateTime_BaseTime = ^_PyDateTime_BaseTime;

PyDateTime_Time = {$IFNDEF CPUX64}packed{$ENDIF} record // hastzinfo true

// Start of _PyDateTime_TIMEHEAD

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_TIME_DATASIZE)] of Byte;

// End of _PyDateTime_TIMEHEAD

tzinfo : PPyObject;

end;

PPyDateTime_Time = ^PyDateTime_Time;

PyDateTime_Date = {$IFNDEF CPUX64}packed{$ENDIF} record

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_DATE_DATASIZE)] of Byte;

end;

PPyDateTime_Date = ^PyDateTime_Date;

{

_PyDateTime_BaseDateTime = {$IFNDEF CPUX64}packed{$ENDIF} record // hastzinfo false

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_DATETIME_DATASIZE)] of Byte;

end;

_PPyDateTime_BaseDateTime = ^_PyDateTime_BaseDateTime;

PyDateTime_DateTime = {$IFNDEF CPUX64}packed{$ENDIF} record // hastzinfo true

// Start of _PyDateTime_DATETIMEHEAD

// Start of _PyTZINFO_HEAD

// Start of the Head of an object

ob_refcnt : NativeInt;

ob_type : PPyTypeObject;

// End of the Head of an object

hashcode : Integer;

hastzinfo : Char; // boolean flag

// End of _PyTZINFO_HEAD

data : array[0..Pred(_PyDateTime_DATETIME_DATASIZE)] of Byte;

// End of _PyDateTime_DATETIMEHEAD

tzinfo : PPyObject;

end;

PPyDateTime_DateTime = ^PyDateTime_DateTime;

PyGILState_STATE = (PyGILState_LOCKED, PyGILState_UNLOCKED);

// Components' exceptions

EDLLLoadError = class(Exception);

EDLLImportError = class(Exception)

public

WrongFunc : AnsiString;

ErrorCode : Integer;

end;

// Python's exceptions

EPythonError = class(Exception)

public

EName : string;

EValue : string;

end;

EPyExecError = class(EPythonError);

// Standard exception classes of Python and maXbox