def PCDataBase_OnDefineSubType(CleObj, SubTypeName):
from pchain import pydata
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
rawclass = pydata.UnWrap(CleObj)
#using name space of parent class
StarNameSpace = Service.StarObjectSpace.FindSpace(CleObj)
if rawclass == None:
subclass_cle = CleObj.CreateType(SubTypeName)
if StarNameSpace == None:
pass
else:
StarNameSpace.SetObject(subclass_cle)
return subclass_cle
else:
if StarNameSpace == None:
pass
else:
subclass_cle = StarNameSpace.GetObject(SubTypeName)
if subclass_cle == None:
pass
else:
return subclass_cle
subclass = pydata.DefineSubType_WithSpace(rawclass, SubTypeName,
StarNameSpace)
subclass_cle = subclass.Wrap()
return subclass_cle
def _Wrap(self):
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
if Service == None:
return None
if hasattr(self, 'cleobjid') == True:
retobj = Service._GetObject(self.cleobjid)
if retobj == None:
pass # restore corresponding cle pcproc object
else:
return retobj
cleproc = pyprocypemap.get(self.__class__)
if cleproc == None:
raise Exception('Wrap ' + self.__class__.__name__ +
' failed, it is not registered')
# find the pcproc
cleobj = Service._New()
cleobj._AttachRawObject(self, False)
newproc = cleproc._New()
newproc.SetAttachObject(cleobj)
self.cleobjid = newproc._ID
return newproc
def Register(tp) :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("","")
global PCDataBaseClass
if PCDataBaseClass == None :
PCDataBaseClass = Service.PCDataBase
import inspect
f = inspect.stack()[1][0]
globaltbl = f.f_globals
localtbl = f.f_locals
_m_name = f.f_locals['__name__']
StarNameSpace = None
if _m_name == None :
pass
elif _m_name == '__main__' :
pass
else :
_m_name = _m_name.replace('.','_')
StarNameSpace = Service._GetObject(_m_name)
if StarNameSpace == None :
StarNameSpace = Service.StarObjectSpace._New(_m_name)
else :
if Service.StarObjectSpace._IsInst(StarNameSpace) == True :
pass
else :
raise Exception('Register '+tp.__name__+' failed, there has cle object which is not instance of StarNameSpace named '+_m_name)
_Register(None,tp,StarNameSpace)
newtype = globaltbl[tp.__name__]
newtype.cached_globaltbl = globaltbl
newtype.cached_localtbl = localtbl
return newtype
def PCProcBase_Create(CleObj, StarSpaceObject, ProcName, InputQueue,
OutputQueue):
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
Proc = Service.PCProcBase._New(ProcName)
#--input
if InputQueue == None:
pass
else:
Proc.InputFrom(InputQueue)
#--output
if OutputQueue == None:
pass
else:
Proc.OutputFrom(OutputQueue)
if StarSpaceObject == None:
pass
else:
StarSpaceObject.SetObject(Proc)
def CreateDecorator(func):
Proc._RegScriptProc_P('Execute', func)
return CreateDecorator
def Equals(self,inst) :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
if SrvGroup == None :
return False
Service = SrvGroup._GetService("","")
if Service == None :
return False
l_val = None
if isinstance(inst,PCPyDataClass) == True :
l_val = inst.value()
else :
import libstarpy
if type(inst) == libstarpy.ObjectClass and Service.PCDataBase._IsInst(inst) :
rawinst = UnWrap(inst)
if rawinst == None :
return False
else :
return True
else :
return False
if self.val == inst.val :
return True
else :
return False
def cleterm():
global IsInitCLE
if IsInitCLE == False:
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
SrvGroup._ClearService()
libstarpy._ModuleExit()
def return_internal(Result, PackageName):
if Result == True:
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
return Service._GetObject(PackageName)
else:
return None
def _Wrap(self) :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
if SrvGroup == None :
return None
Service = SrvGroup._GetService("","")
if Service == None :
return None
if hasattr(self,'cleobjid') == True :
retobj = Service._GetObject(self.cleobjid)
if retobj == None :
# need restore
if hasattr(self,'RestoreDataObjectProperity') == True :
if self.RestoreDataObjectProperity == None :
raise Exception('Wrap '+ self.__class__.__name__ + " failed, it's corresponding cle object has been freed.")
else :
pass
else :
raise Exception('Wrap '+ self.__class__.__name__ + " failed, it's corresponding cle object has been freed.")
else :
return retobj
cledata = pydatatypemap.get(self.__class__)
if cledata == None :
raise Exception('Wrap '+ self.__class__.__name__ + ' failed, it is not registered')
if hasattr(self,'classinst') == True :
class_newdata = self.classinst.Wrap()
newdata = class_newdata._New()
self.cleobjid = newdata._ID
return newdata
# find the pcdata
cleobj = Service._New()
cleobj._AttachRawObject(self,False)
newdata = cledata.Create(cleobj)
# need restore
if hasattr(self,'RestoreDataObjectProperity') == True :
if self.RestoreDataObjectProperity == None :
pass
else :
newdata.RestoreCleDataProperty(self.RestoreDataObjectProperity)
newdata.ClearCleDataProperty(self.RestoreDataObjectProperity)
self.RestoreDataObjectProperity = None
#use newdata[0]._GetRawObject() to get the attach python object
self.cleobjid = newdata._ID
newdata.Notify()
return newdata
def IsChangedFrom(self,SourceData) :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("","")
cle_self = self.Wrap()
cle_SourceData = None
if isinstance(SourceData,PCPyDataClass) == True :
cle_SourceData = SourceData.Wrap()
else :
if type(SourceData) == libstarpy.ObjectClass and Service.PCDataBase._IsInst(SourceData) :
cle_SourceData = SourceData
if cle_SourceData == None or cle_self == None :
return False
return cle_self.IsChangedFrom(cle_SourceData)
def __del__ (self):
if hasattr(self,'RestoreDataObjectProperity') == True :
if self.RestoreDataObjectProperity == None :
pass
else :
try :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
if SrvGroup == None :
return
Service = SrvGroup._GetService("","")
if Service == None or Service.PCDataBase == None:
return
Service.PCDataBase.ClearCleDataProperty(self.RestoreDataObjectProperity)
except Exception as exc:
pass
def pydata_Init() :
import inspect
f = inspect.stack()[0][0]
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
StarNameSpace = Service.StarObjectSpace._New('pydata')
_DefineType(f.f_globals,f.f_locals,None,'pint',int,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'pbool',bool,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'pfloat',float,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'pcomplex',complex,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'pstr',str,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'plist',list,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'pset',set,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'pdict',dict,True,StarNameSpace)
_DefineType(f.f_globals,f.f_locals,None,'ptuple',tuple,True,StarNameSpace)
def loadfolder(Folder, PrintFlag=True):
import os
try:
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
import pchain
if os.path.exists(Folder + '/packageinfo.json') == False:
if PrintFlag == True:
print(Folder + '/packageinfo.json is not found')
return None
f = None
if pchain.ispython2 == True:
f = open(Folder + "/packageinfo.json")
else:
f = open(Folder + "/packageinfo.json", encoding='utf-8')
packagetxt = f.read()
f.close()
packageinfo = SrvGroup._NewParaPkg()
if packageinfo._FromJSon(packagetxt) == False:
if PrintFlag == True:
print('invalid format "packageinfo.json"')
return None
Result = loadinternal(packageinfo["PackageName"],
packageinfo["PackageLang"],
packageinfo["PackageEntry"], Folder)
if pchain.SystemPackageInfo == None:
query = SrvGroup._NewQueryRecord()
realmobj = Service.PCRealmBase._FirstInst(query)
Service.PCRealmBase._QueryClose(query)
if realmobj == None:
print('PCRealmBase instance is not created')
return None
else:
pchain.SystemPackageInfo = realmobj.GetSystemPackageInfo()
if Result == True and pchain.SystemPackageInfo != None:
pchain.SystemPackageInfo[
pchain.SystemPackageInfo._Number] = packageinfo
return return_internal(True, packageinfo["PackageName"])
except Exception as exc:
if PrintFlag == True:
print(repr(exc))
return None
def PCProcBase_Create(CleObj, StarSpaceObject, ProcName, InputQueue,
OutputQueue):
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
Proc = Service.PCCellBase.CreateType(ProcName)
#--input
if InputQueue == None:
pass
else:
Proc.InputFrom(InputQueue)
#--output
if OutputQueue == None:
pass
else:
Proc.OutputFrom(OutputQueue)
if StarSpaceObject == None:
pass
else:
StarSpaceObject.SetObject(Proc)
return Proc
def UnWrap(cleobj):
import libstarpy
if type(cleobj) == libstarpy.ObjectClass:
if PCProcBaseClass._IsInst(cleobj):
pass
else: #for some case, cle object attach raw data directly
rawinst = cleobj._GetRawObject()
return rawinst
else:
return None
if cleobj.TypeFlag == True:
localobj = cleobj.GetAttachObject()
if localobj == None:
return None
return localobj._GetRawObject()
else:
#has attach pyproc
localobj = cleobj.GetAttachObject()
if localobj == None:
pass
else:
return localobj._GetRawObject()
#create new pyproc
cleobjtype = cleobj.GetType()
localobj = cleobjtype.GetAttachObject()
if localobj == None:
return None
rawproc = localobj._GetRawObject()
if rawproc == None:
return None
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
newrawproc = rawproc.__class__()
attach_cleobj = Service._New()
attach_cleobj._AttachRawObject(newrawproc, False)
cleobj.SetAttachObject(attach_cleobj)
newrawproc.cleobjid = cleobj._ID
return newrawproc
def Register(tp, InputQueue, OutputQueue):
from pchain import pydata
from pchain.pydata import PCPyDataClass
import libstarpy
import inspect
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
global PCDataBaseClass
if PCDataBaseClass == None:
PCDataBaseClass = Service.PCDataBase
global PCProcBaseClass
if PCProcBaseClass == None:
PCProcBaseClass = Service.PCProcBase
import inspect
f = inspect.stack()[1][0]
_m_name = f.f_locals['__name__']
StarNameSpace = None
if _m_name == None:
pass
elif _m_name == '__main__':
pass
else:
_m_name = _m_name.replace('.', '_')
StarNameSpace = Service._GetObject(_m_name)
if StarNameSpace == None:
StarNameSpace = Service.StarObjectSpace._New(_m_name)
else:
if Service.StarObjectSpace._IsInst(StarNameSpace) == True:
pass
else:
raise Exception(
'Register ' + tp.__name__ +
' failed, there has cle object which is not instance of StarNameSpace named '
+ _m_name)
return _Register(tp, StarNameSpace, InputQueue, OutputQueue)
def cleproc_StarCall(SelfObj, *Args):
import libstarpy
import inspect
from pchain import pydata
from pchain.pydata import PCPyDataClass
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
pythonobj = UnWrap(SelfObj)
returntuple = pythonobj(*Args)
if type(returntuple) == type(()) or type(returntuple) == type([]):
ParaPkg = SrvGroup._NewParaPkg()
for item in returntuple:
if isinstance(item, PCPyDataClass):
ParaPkg[ParaPkg._Number] = item.Wrap()
else:
ParaPkg[ParaPkg._Number] = item
return ParaPkg
else:
if isinstance(returntuple, PCPyDataClass):
return returntuple.Wrap()
else:
return returntuple
return returntuple
def _DefineType(globaltbl,localtbl,datatype,tpname,pyrawtype,StarNameSpaceIsValid,InputStarNameSpace) :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("","")
global PCDataBaseClass
if PCDataBaseClass == None :
PCDataBaseClass = Service.PCDataBase
StarNameSpace = None
if StarNameSpaceIsValid == False :
_m_name = globaltbl.get('__name__')
if _m_name == None :
pass
elif _m_name == '__main__' :
pass
else :
_m_name = _m_name.replace('.','_')
StarNameSpace = Service._GetObject(_m_name)
if StarNameSpace == None :
StarNameSpace = Service.StarObjectSpace._New(_m_name)
else :
if Service.StarObjectSpace._IsInst(StarNameSpace) == True :
pass
else :
raise Exception('Register '+tpname+' failed, there has cle object which is not instance of StarNameSpace named '+_m_name)
else :
StarNameSpace = InputStarNameSpace
data_class_rawtext = '''
from pchain import pydata
from pchain.pydata import PCPyDataClass
from pchain.pydata import PCPySimpleDataClass
class {0}(PCPySimpleDataClass) :
rawtype = pyrawtype
def __init__(self,val) :
if self.rawtype == None :
self.val = val
else :
import inspect
if (inspect.isclass(self.rawtype) == True and isinstance(val,self.rawtype)) or (type(val) == self.rawtype) :
self.val = val
else :
raise Exception('create data instance failed, input ',val,'is not instance of ',self.rawtype)
self.GetTag = self._GetTag
self.GetTagLabel = self._GetTagLabel
self.IsType = self._IsType
self.Wrap = self._Wrap
@staticmethod
def Load(MetaData) :
# MetaData maybe string or parapkg
# raise Exception('Load function is not defined ')
import pickle
import base64
if type(MetaData) == type('') :
return {0}(pickle.loads(base64.b64decode(MetaData)))
else :
raise Exception('Load from ParaPkg is not supported ')
def Save(self) :
#raise Exception('Save function is not defined for '+str(self))
import pickle
import base64
return base64.b64encode(pickle.dumps(self.val))
pydata._Register(datatype,{0},StarNameSpace)
globaltbl['{0}'] = {0}
localtbl['{0}'] = {0}
'''
local_env = {}
local_env['StarNameSpace'] = StarNameSpace
local_env['pyrawtype'] = pyrawtype
local_env['globaltbl'] = globaltbl
local_env['localtbl'] = localtbl
local_env['datatype'] = datatype
exec(str.format(data_class_rawtext,tpname),local_env)
newtype = globaltbl[tpname]
newtype.cached_globaltbl = globaltbl
newtype.cached_localtbl = localtbl
return newtype
def _Register(tp, StarNameSpace, InputQueue, OutputQueue):
from pchain import pydata
from pchain.pydata import PCPyDataClass
import libstarpy
import inspect
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
global PCDataBaseClass
if PCDataBaseClass == None:
PCDataBaseClass = Service.PCDataBase
global PCProcBaseClass
if PCProcBaseClass == None:
PCProcBaseClass = Service.PCProcBase
if StarNameSpace == None:
_allobject = SrvGroup._NewParaPkg()
Service._GetObjectEx3(tp.__name__, _allobject)
starspaceobject = Service.StarObjectSpace
for item in _allobject:
if starspaceobject.FindSpace(item) == None:
if item._Name == tp.__name__:
_allobject._Free()
raise Exception('Register ' + tp.__name__ +
' failed, it had been registered before.')
_allobject._Free()
else:
if type(StarNameSpace
) == libstarpy.ObjectClass and Service.StarObjectSpace._IsInst(
StarNameSpace):
if StarNameSpace.GetObject(tp.__name__) == None:
pass
else:
raise Exception('Register ' + tp.__name__ +
' failed, it had been registered before.')
else:
raise Exception('Register ' + tp.__name__ + ' failed, ' +
str(StarNameSpace) +
' is not instance of StarObjectSpace')
cleproc = pyprocypemap.get(tp)
if cleproc == None:
cleproc = Service.PCProcBase._New(tp.__name__)
cleproc._LockGC() # do not free
#input
if InputQueue == None:
pass
else:
if type(InputQueue) == type(()):
newin = []
for item in InputQueue:
if inspect.isclass(item) and issubclass(
item, PCPyDataClass):
newin.append(pydata.GetCleType(item))
else:
newin.append(item)
if len(newin) == 0:
pass
else:
cleproc.InputFrom(tuple(newin))
else:
if inspect.isclass(InputQueue) and issubclass(
InputQueue, PCPyDataClass):
cleproc.InputFrom(pydata.GetCleType(InputQueue))
else:
cleproc.InputFrom(InputQueue)
#--output
if OutputQueue == None:
pass
else:
if type(OutputQueue) == type(()):
newin = []
for item in OutputQueue:
if inspect.isclass(item) and issubclass(
item, PCPyDataClass):
newin.append(pydata.GetCleType(item))
else:
newin.append(item)
if len(newin) == 0:
pass
else:
cleproc.OutputFrom(tuple(newin))
else:
if inspect.isclass(OutputQueue) and issubclass(
OutputQueue, PCPyDataClass):
cleproc.OutputFrom(pydata.GetCleType(OutputQueue))
else:
cleproc.OutputFrom(OutputQueue)
#register function
@cleproc._RegScriptProc_P('Execute')
def cleproc_Execute(SelfObj, Realm, Cell, Runner):
from pchain import pydata
pythonobj = UnWrap(SelfObj)
in1 = SelfObj.InputToParaPkg()
SrvGroup = libstarpy._GetSrvGroup(0)
pythonobj.Context = {
'SelfObj': SelfObj,
'Realm': Realm,
'Cell': Cell,
'Runner': Runner
}
para = []
for item in in1._Iterator():
if type(item
) == libstarpy.ObjectClass and PCDataBaseClass._IsInst(
item) and item.HasDataTypeClass():
para.append(pydata.UnWrap(item))
else:
if SrvGroup._IsParaPkg(item) == True:
subitem = []
for ii in item._Iterator():
if type(
ii
) == libstarpy.ObjectClass and PCDataBaseClass._IsInst(
ii) and ii.HasDataTypeClass():
subitem.append(pydata.UnWrap(ii))
else:
subitem.append(ii)
para.append(tuple(subitem))
else:
para.append(item)
#call class function
result = pythonobj.Execute(*para)
if isinstance(result, tuple):
if len(result) == 3 and type(result[0]) == int and type(
result[1]) == int:
if result[1] < 0:
SelfObj.RejectInput(None)
else:
if result[1] > 0:
SelfObj.AcceptInput(None)
else:
isresultvalid = True
for item in result:
if isinstance(item, PCPyDataClass):
pass
else:
isresultvalid = False
if isresultvalid == False:
raise Exception(
'result from proc ' +
pythonobj.__class__.__name__ +
' must be tuple (returnvalue,processinput,result)')
else:
SelfObj.AcceptInput(None)
result = (0, 1, result)
else:
if isinstance(result, PCPyDataClass):
SelfObj.AcceptInput(None)
result = (0, 1, result)
else:
if result == None:
SelfObj.AcceptInput(None)
result = (0, 1, result)
else:
raise Exception(
'result from proc ' +
pythonobj.__class__.__name__ +
' must be tuple (returnvalue,processinput,result)')
if result[0] < 0:
return -1
else:
_processresult(SelfObj, tp.__name__, result[2], libstarpy,
PCPyDataClass)
if result[0] == 0 or result[0] == 1 or result[0] == 2 or result[
0] == 3:
return result[0]
else:
return SelfObj.Continue(result[0] - 4)
#register function
@cleproc._RegScriptProc_P('_StarCall')
def cleproc_StarCall(SelfObj, *Args):
import libstarpy
import inspect
from pchain import pydata
from pchain.pydata import PCPyDataClass
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
pythonobj = UnWrap(SelfObj)
returntuple = pythonobj(*Args)
if type(returntuple) == type(()) or type(returntuple) == type([]):
ParaPkg = SrvGroup._NewParaPkg()
for item in returntuple:
if isinstance(item, PCPyDataClass):
ParaPkg[ParaPkg._Number] = item.Wrap()
else:
ParaPkg[ParaPkg._Number] = item
return ParaPkg
else:
if isinstance(returntuple, PCPyDataClass):
return returntuple.Wrap()
else:
return returntuple
return returntuple
# set attach object
attach_cleobj = Service._New()
attach_cleobj._AttachRawObject(tp(), False)
cleproc.SetAttachObject(attach_cleobj)
pyprocypemap[tp] = cleproc
if StarNameSpace == None:
pass
else:
StarNameSpace.SetObject(cleproc)
cleproc.Notify()
return tp
def call(cls, *args):
# call execute? no
import libstarpy
import inspect
from pchain import pydata
from pchain.pydata import PCPyDataClass
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
newin = []
for item in args:
if type(item) == libstarpy.ObjectClass:
if PCDataBaseClass._IsInst(item) == True:
rawitem = pydata.UnWrap(item)
if rawitem == None:
rawitem = item
else:
if item._HasRawContext() == True:
rawitem = item._GetRawObject()
if isinstance(rawitem, PCPyDataClass) == True:
pass
else:
rawitem = item
else:
rawitem = item
else:
rawitem = item
if isinstance(rawitem, PCPyDataClass):
newin.append(rawitem.Wrap())
else:
if type(rawitem
) == libstarpy.ObjectClass and PCDataBaseClass._IsInst(
rawitem) == True:
newin.append(rawitem)
else:
if rawitem == None:
newin.append(rawitem)
else:
raise Exception(
'call ' + cls.__name__ +
' failed, input args must be cle object or instance of PCPyDataClass'
)
#
self_cleobj = cls.GetType()
result = Service.PCRealmBase.RunProc(newin,
self_cleobj.GetOutputType(),
self_cleobj)
if result._Number == 0: #failed
raise Exception('call ' + cls.__name__ +
' failed, RunProc function returns false')
return None
else:
ReturnValue = result
if SrvGroup._IsParaPkg(ReturnValue) == False:
if isinstance(ReturnValue, PCPyDataClass):
return ReturnValue
else:
if type(ReturnValue) == libstarpy.ObjectClass:
if PCDataBaseClass._IsInst(
ReturnValue) and ReturnValue.HasDataTypeClass(
):
return pydata.UnWrap(ReturnValue)
else:
return ReturnValue
else:
if ReturnValue == None:
return ReturnValue
else:
raise Exception(
'call ' + cls.__name__ +
' failed, output must be None, or cle object or instance of PCPyDataClass'
)
else:
if ReturnValue._Number == 0:
return None
else:
returntuple = []
for item in ReturnValue._Iterator():
if isinstance(item, PCPyDataClass):
returntuple.append(item)
else:
if type(item) == libstarpy.ObjectClass:
if PCDataBaseClass._IsInst(
item) and item.HasDataTypeClass():
returntuple.append(pydata.UnWrap(item))
else:
returntuple.append(item)
else:
if item == None:
returntuple.append(item)
else:
raise Exception(
'call ' + cls.__name__ +
' failed, output must be None, or cle object or instance of PCPyDataClass'
)
if len(returntuple) == 1:
return returntuple[0]
else:
return tuple(returntuple)
def cleinit():
global IsInitPChain
if IsInitPChain == True:
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
return SrvGroup._GetService('', '')
import platform
import os
import sys
import pchain
version = platform.python_version().split('.')
modulename = ""
#set current path for starcore
savedcwd = os.getcwd()
os.chdir(pchain.nativepath)
#put it first path
try:
index = sys.path.index(pchain.nativepath)
except Exception as exc:
sys.path.insert(0, pchain.nativepath)
try:
if (version[0] == '2' and version[1] == '7'):
import libstarpy
modulename = 'python'
elif version[0] == '3' and version[1] == '5':
import libstar_python35
modulename = 'python35'
elif version[0] == '3' and version[1] == '6':
import libstar_python36
modulename = 'python36'
elif version[0] == '3' and version[1] == '7':
import libstar_python37
modulename = 'python37'
elif version[0] == '3' and version[1] == '8':
import libstar_python38
modulename = 'python37'
elif version[0] == '3' and version[1] == '9':
import libstar_python39
modulename = 'python37'
else:
print('python ' + version + ' not supported')
os.chdir(savedcwd)
return None
except Exception as exc:
print('cle init failed, may be it not installed, auto install it !')
if cleinstall() == False:
os.chdir(savedcwd)
return None
else:
print('please run app again')
os.chdir(savedcwd)
return None
os.chdir(savedcwd)
global IsInitCLE
IsInitCLE = False
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
if SrvGroup != None and SrvGroup._GetService('', '') != None:
IsInitCLE = True
Service = None
if IsInitCLE == False:
import libstarpy
Service = libstarpy._InitSimple("test", "123", 0, 0)
SrvGroup = Service._ServiceGroup
CleVer = libstarpy._Version()
if CleVer[0] < 3 or (CleVer[0] == 3 and CleVer[1] < 118):
print(
'pchain initialize failed, starcore version must be equal or higher than 3.7.6'
)
SrvGroup._ClearService()
libstarpy._ModuleExit()
return None
Result = Service._DoFile("", nativepath + "/" + nativename, "")
if Result[0] == False:
print(Result[1])
SrvGroup._ClearService()
libstarpy._ModuleExit()
return None
IsInitPChain = True
else:
CleVer = libstarpy._Version()
if CleVer[0] < 3 or (CleVer[0] == 3 and CleVer[1] < 118):
print(
'pchain initialize failed, starcore version must be equal or higher than 3.7.6'
)
return None
Service = SrvGroup._GetService("", "")
Result = Service._DoFile("", nativepath + "/" + nativename, "")
if Result[0] == False:
print(Result[1])
return None
IsInitPChain = True
@Service.PCDataBase._RegScriptProc_P('OnDefineSubType')
def PCDataBase_OnDefineSubType(CleObj, SubTypeName):
from pchain import pydata
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
rawclass = pydata.UnWrap(CleObj)
#using name space of parent class
StarNameSpace = Service.StarObjectSpace.FindSpace(CleObj)
if rawclass == None:
subclass_cle = CleObj.CreateType(SubTypeName)
if StarNameSpace == None:
pass
else:
StarNameSpace.SetObject(subclass_cle)
return subclass_cle
else:
if StarNameSpace == None:
pass
else:
subclass_cle = StarNameSpace.GetObject(SubTypeName)
if subclass_cle == None:
pass
else:
return subclass_cle
subclass = pydata.DefineSubType_WithSpace(rawclass, SubTypeName,
StarNameSpace)
subclass_cle = subclass.Wrap()
return subclass_cle
@Service.PCDataBase._RegScriptProc_P('OnCastFrom')
def PCDataBase_OnCastFrom(CleObj, SourceData):
from pchain import pydata
rawdata = pydata.UnWrap(SourceData)
rawclass = pydata.UnWrap(CleObj)
if rawdata == None or rawclass == None: #not python data or not python class
databuf = SourceData.GetDataBuf()
newdata = CleObj._New()
newdata.SetDataBuf(databuf)
return newdata
else:
#create new class instance with old class's value
newrawdata = rawclass(rawdata.value())
newdata = newrawdata.Wrap()
return newdata
@Service.PCProcBase._RegScriptProc_P('Create')
def PCProcBase_Create(CleObj, StarSpaceObject, ProcName, InputQueue,
OutputQueue):
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
Proc = Service.PCProcBase._New(ProcName)
#--input
if InputQueue == None:
pass
else:
Proc.InputFrom(InputQueue)
#--output
if OutputQueue == None:
pass
else:
Proc.OutputFrom(OutputQueue)
if StarSpaceObject == None:
pass
else:
StarSpaceObject.SetObject(Proc)
def CreateDecorator(func):
Proc._RegScriptProc_P('Execute', func)
return CreateDecorator
@Service.PCCellBase._RegScriptProc_P('Create')
def PCProcBase_Create(CleObj, StarSpaceObject, ProcName, InputQueue,
OutputQueue):
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
Proc = Service.PCCellBase.CreateType(ProcName)
#--input
if InputQueue == None:
pass
else:
Proc.InputFrom(InputQueue)
#--output
if OutputQueue == None:
pass
else:
Proc.OutputFrom(OutputQueue)
if StarSpaceObject == None:
pass
else:
StarSpaceObject.SetObject(Proc)
return Proc
@Service.PCRealmBase._RegScriptProc_P('LoadPackage')
def PCRealmBase_LoadPackage(CleObj, PackageList):
PackageInfo = PackageList['PackageInfo']
if PackageInfo == None or PackageInfo._Number == 0:
return
from pchain import loader
LoadResult = True
for item in PackageInfo._Iterator():
url = item['PackageUrl']
if len(url) == 0:
if loader.load(item['PackageName'],
item['PackageVersion']) == False:
print('package ', item['PackageName'],
' has no url and not installed, can not load')
LoadResult = False
else:
if loader.loadurl(url) == False:
LoadResult = False
return LoadResult
#init pydata
from pchain import pydata
pydata.pydata_Init()
return Service
def _Register(datatype,tp,StarNameSpace=None) :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("","")
global PCDataBaseClass
if PCDataBaseClass == None :
PCDataBaseClass = Service.PCDataBase
if StarNameSpace == None :
_allobject = SrvGroup._NewParaPkg()
Service._GetObjectEx3(tp.__name__,_allobject)
starspaceobject = Service.StarObjectSpace
for item in _allobject :
if starspaceobject.FindSpace(item) == None :
if item._Name == tp.__name__ :
_allobject._Free()
raise Exception('Register '+tp.__name__+' failed, it had been registered before.')
_allobject._Free()
else :
if type(StarNameSpace) == libstarpy.ObjectClass and Service.StarObjectSpace._IsInst(StarNameSpace) :
if StarNameSpace.GetObject(tp.__name__) == None :
pass
else :
raise Exception('Register '+tp.__name__+' failed, it had been registered before.')
else :
raise Exception('Register '+tp.__name__+' failed, '+str(StarNameSpace)+' is not instance of StarObjectSpace')
cledata = pydatatypemap.get(tp)
if cledata == None :
#not exist, create for it
cleobj = Service._New()
cleobj._AttachRawObject(tp,True)
cledata = None
# the parent class
basecls = None
import pchain
if pchain.ispython2 == True :
basecls = tp.__bases__[0]
else :
basecls = tp.__base__
if basecls == PCPyDataClass or basecls == PCPySimpleDataClass :
if datatype == None :
cledata = Service.PCDataBase.CreateType(tp.__name__)
else :
cledata = datatype.CreateType(tp.__name__)
else :
parent_cledata = pydatatypemap.get(basecls)
if parent_cledata == None :
raise Exception('Register '+ basecls.__name__ + ' failed, it parent class is not registered')
cledata = parent_cledata.CreateType(tp.__name__)
cledata.SetDataTypeClass(cleobj)
@cleobj._RegScriptProc_P('ToString')
def cleobj_ToString(cleobj,cledata) :
rawinst = UnWrap(cledata)
if rawinst == None :
return None
return rawinst.ToString()
@cleobj._RegScriptProc_P('IsRawInstance')
def cleobj_IsInstance(cleobj,inst) :
rawinst = inst._GetRawObject()
if rawinst == None :
pass
else :
return isinstance(rawinst,PCPyDataClass)
rawinst = UnWrap(inst)
if rawinst == None :
return False
return isinstance(rawinst,PCPyDataClass)
@cleobj._RegScriptProc_P('Equals')
def cleobj_Equals(cleobj,inst1,inst2) :
rawinst1 = UnWrap(inst1)
rawinst2 = UnWrap(inst2)
if rawinst1 == None or rawinst2 == None :
return False
if rawinst1 == rawinst2 :
return True
if rawinst1.__class__ == rawinst2.__class__ :
return rawinst1.Equals(rawinst2)
else :
return False
@cleobj._RegScriptProc_P('Dup')
def cleobj_Dup(cleobj,inst,newtype_obj) : # Dup function may change data type
rawinst = UnWrap(inst)
if rawinst == None :
return None
if newtype_obj == None :
newinst = rawinst.Dup()
if newinst == None :
return None
return newinst.Wrap()
else :
if newtype_obj._HasRawContext() == True :
newtype = newtype_obj._GetRawObject()
if issubclass(newtype,PCPyDataClass) == True :
newinst = newtype(rawinst.value())
return newinst.Wrap()
else :
return None
return None
@cleobj._RegScriptProc_P('Save')
def cleobj_Save(cleobj,cledata) :
rawinst = UnWrap(cledata)
return rawinst.Save()
@cleobj._RegScriptProc_P('Load')
def cleobj_Load(cleobj,MetaData) : # MetaData is a string
rawinst = tp.Load(MetaData)
if rawinst == None :
return None
return rawinst.Wrap()
@cleobj._RegScriptProc_P('ToParaPkg')
def cleobj_Save(cleobj,inst,parapkg) :
rawinst = UnWrap(inst)
return rawinst.ToParaPkg(parapkg)
# need save for restore
@cleobj._RegScriptProc_P('OnBeforeFree')
def cleobj_OnBeforeFree(cleobj,rawobject,CleObjectProperty) :
rawinst = rawobject._GetRawObject()
if rawinst == None :
return
try:
if isinstance(rawinst,PCPyDataClass) == True :
rawinst.RestoreDataObjectProperity = CleObjectProperty
else :
return
except Exception as exc:
pass
pydatatypemap[tp] = cledata
if StarNameSpace == None :
pass
else :
StarNameSpace.SetObject(cledata)
cledata.Notify()
return tp
def cleproc_Execute(SelfObj, Realm, Cell, Runner):
from pchain import pydata
pythonobj = UnWrap(SelfObj)
in1 = SelfObj.InputToParaPkg()
SrvGroup = libstarpy._GetSrvGroup(0)
pythonobj.Context = {
'SelfObj': SelfObj,
'Realm': Realm,
'Cell': Cell,
'Runner': Runner
}
para = []
for item in in1._Iterator():
if type(item
) == libstarpy.ObjectClass and PCDataBaseClass._IsInst(
item) and item.HasDataTypeClass():
para.append(pydata.UnWrap(item))
else:
if SrvGroup._IsParaPkg(item) == True:
subitem = []
for ii in item._Iterator():
if type(
ii
) == libstarpy.ObjectClass and PCDataBaseClass._IsInst(
ii) and ii.HasDataTypeClass():
subitem.append(pydata.UnWrap(ii))
else:
subitem.append(ii)
para.append(tuple(subitem))
else:
para.append(item)
#call class function
result = pythonobj.Execute(*para)
if isinstance(result, tuple):
if len(result) == 3 and type(result[0]) == int and type(
result[1]) == int:
if result[1] < 0:
SelfObj.RejectInput(None)
else:
if result[1] > 0:
SelfObj.AcceptInput(None)
else:
isresultvalid = True
for item in result:
if isinstance(item, PCPyDataClass):
pass
else:
isresultvalid = False
if isresultvalid == False:
raise Exception(
'result from proc ' +
pythonobj.__class__.__name__ +
' must be tuple (returnvalue,processinput,result)')
else:
SelfObj.AcceptInput(None)
result = (0, 1, result)
else:
if isinstance(result, PCPyDataClass):
SelfObj.AcceptInput(None)
result = (0, 1, result)
else:
if result == None:
SelfObj.AcceptInput(None)
result = (0, 1, result)
else:
raise Exception(
'result from proc ' +
pythonobj.__class__.__name__ +
' must be tuple (returnvalue,processinput,result)')
if result[0] < 0:
return -1
else:
_processresult(SelfObj, tp.__name__, result[2], libstarpy,
PCPyDataClass)
if result[0] == 0 or result[0] == 1 or result[0] == 2 or result[
0] == 3:
return result[0]
else:
return SelfObj.Continue(result[0] - 4)
def loadinternal(PackageName, PackageLang, PackageEntry, Folder):
import os
try:
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
import pchain
if PackageLang != "python" and PackageLang != "python2" and PackageLang != "python3" and PackageLang != "c" and PackageLang != "c#" and PackageLang != "java":
print('PackageLang ' + PackageLang +
' is not defined or not supported')
return False
if PackageEntry == None or len(PackageEntry) == 0:
print('PackageEntry is not defined')
return False
if PackageLang == "python" or PackageLang == "python2" or PackageLang == "python3":
if pchain.ispython2 == True:
if PackageLang == "python" or PackageLang == "python2":
pass
else:
print('PackageLang ' + PackageLang +
' is not supported, must be python or python2 ')
return False
else:
if PackageLang == "python" or PackageLang == "python3":
pass
else:
print(
'PackageLang ' + PackageLang +
' is not defined or not supported, must be python or python3'
)
return False
#--save all object
existedObjects = Service._AllObject()
if PackageLang == "c":
Result = Service._DoFile("", Folder + "/" + PackageEntry, "")
else:
if PackageLang == "python" or PackageLang == "python2" or PackageLang == "python3":
import sys
sys.path.insert(0, Folder)
try:
__import__(PackageName)
Result = [True, '']
except Exception as exc:
import traceback
traceback.print_exc()
return False
else:
Result = Service._DoFile(PackageLang,
Folder + "/" + PackageEntry, "")
if Result[0] == False:
print(Exception(Result[1]))
return False
return True
except Exception as exc:
print(exc)
return False
def load(PackageName, PackageVersion='', PrintFlag=True):
try:
import os
import pchain
if pchain.SystemPackageInfo == None:
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
query = SrvGroup._NewQueryRecord()
realmobj = Service.PCRealmBase._FirstInst(query)
Service.PCRealmBase._QueryClose(query)
if realmobj == None:
if PrintFlag == True:
print('PCRealmBase instance is not created')
return None
else:
pchain.SystemPackageInfo = realmobj.GetSystemPackageInfo()
if pchain.SystemPackageInfo != None:
for loadedpackage in pchain.SystemPackageInfo._Iterator():
if loadedpackage["PackageName"] == PackageName:
if len(PackageVersion) == 0:
return return_internal(True, PackageName)
elif PackageVersion <= loadedpackage["PackageVersion"]:
return return_internal(True, PackageName)
else:
if PrintFlag == True:
print('the request package "' + PackageName + '[' +
PackageVersion +
']" had been loaded with another version [' +
loadedpackage["PackageVersion"] + ']')
return None
PackageName_WithExt = None
if True:
dirList = []
ext_name = None
if pchain.ispython2 == True:
ext_name = '-python2'
else:
ext_name = '-python3'
files = os.listdir(pchain.packagepath)
for f in files:
if os.path.isdir(pchain.packagepath + '/' +
f) == True and f.startswith(
PackageName + '-python.') == True:
dirList.append(f)
elif os.path.isdir(pchain.packagepath + '/' +
f) == True and f.startswith(PackageName +
ext_name +
'.') == True:
dirList.append(f)
if len(dirList) == 0:
if PrintFlag == True:
print(PackageName + ' is not installed')
return None
# find the highest
installed_package_version = ""
for f in dirList:
thisver = f[f.index('.') + 1:]
if len(installed_package_version) == 0:
if len(PackageVersion) == 0:
installed_package_version = thisver
PackageName_WithExt = f
elif installed_package_version >= PackageVersion:
installed_package_version = thisver
PackageName_WithExt = f
else:
if installed_package_version < thisver:
installed_package_version = thisver
PackageName_WithExt = f
if len(installed_package_version) == 0:
if PrintFlag == True:
print(PackageName + ' version ' + PackageVersion +
' is not installed')
return None
PackageVersion = installed_package_version
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
f = None
if pchain.ispython2 == True:
f = open(pchain.packagepath + '/' + PackageName_WithExt +
"/packageinfo.json")
else:
f = open(pchain.packagepath + '/' + PackageName_WithExt +
"/packageinfo.json",
encoding='utf-8')
packagetxt = f.read()
f.close()
packageinfo = SrvGroup._NewParaPkg()
if packageinfo._FromJSon(packagetxt) == False:
if PrintFlag == True:
print('invalid format "packageinfo.json" for package ' +
PackageName)
return None
Result = loadinternal(packageinfo["PackageName"],
packageinfo["PackageLang"],
packageinfo["PackageEntry"],
pchain.packagepath + '/' + PackageName_WithExt)
if Result == True and pchain.SystemPackageInfo != None:
pchain.SystemPackageInfo[
pchain.SystemPackageInfo._Number] = packageinfo
return return_internal(Result, packageinfo["PackageName"])
except Exception as exc:
if PrintFlag == True:
print(repr(exc))
return None
def loadzip_internal(zipfilename, url, installIgnoreVersion):
import zipfile
import os
import pchain
try:
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
destfolder = pchain.packagepath
if installIgnoreVersion == False:
tempname = zipfilename.replace("\\", "/")
fname = tempname.split('/')[-1]
flist = fname.split('.')
if len(flist) == 5:
pass
else:
print('invalid package name, must be xxxx.x.x.x.zip')
return None
PackageName = flist[0][:flist[0].rindex('-')]
if load(PackageName, flist[1] + '.' + flist[2] + '.' + flist[3],
False) == None:
pass
else:
return return_internal(True, PackageName)
myzip = zipfile.ZipFile(zipfilename)
f = None
if pchain.ispython2 == True:
f = myzip.open("packageinfo.json")
else:
f = myzip.open("packageinfo.json")
packagetxt = f.read()
f.close()
if pchain.ispython2 == False:
packagetxt = packagetxt.decode(encoding='utf-8')
packageinfo = SrvGroup._NewParaPkg()
if packageinfo._FromJSon(packagetxt) == False:
print('"packageinfo.json" invalid format')
return None
fpath = os.path.join(
destfolder, packageinfo["PackageName"] + "-" +
packageinfo["PackageLang"].lower() + "." +
packageinfo["PackageVersion"])
if os.path.exists(fpath) == False:
os.makedirs(fpath)
# print('begin uncompress...')
for file in myzip.namelist():
myzip.extract(file, fpath)
myzip.close()
# check signature
currentpath = os.getcwd()
os.chdir(fpath)
package_signature = getmd5()
os.chdir(currentpath)
if package_signature == packageinfo["signature"]:
pass
else:
print(packageinfo["PackageName"] + 'singature check failed.')
return None
PackageLang = packageinfo["PackageLang"]
if PackageLang != "python" and PackageLang != "python2" and PackageLang != "python3" and PackageLang != "c" and PackageLang != "c#" and PackageLang != "java":
print('PackageLang ' + PackageLang +
' is not defined or not supported')
return None
if PackageLang == "python" or PackageLang == "python2" or PackageLang == "python3":
if os.path.exists(fpath+"/requirements.txt") == True and os.path.getsize(fpath+"/requirements.txt") > 3 \
and (pchain.platform == 'windows' or pchain.platform == 'linux' or pchain.platform == 'darwin' ):
print("find requirements.txt, processing it")
import sys
import subprocess
Result = subprocess.call([
sys.executable, "-m", "pip", "install", "-r",
fpath + "/requirements.txt"
])
if Result != 0:
print("install requirements.txt failed")
else:
print("install requirements.txt finish")
PackageEntry = packageinfo["PackageEntry"]
if PackageEntry == None or len(PackageEntry) == 0:
print('PackageEntry is not defined')
return None
Result = loadinternal(packageinfo["PackageName"], PackageLang,
PackageEntry, fpath)
#update url
if len(url) == 0:
if pchain.SystemPackageInfo == None:
query = SrvGroup._NewQueryRecord()
realmobj = Service.PCRealmBase._FirstInst(query)
Service.PCRealmBase._QueryClose(query)
if realmobj == None:
print('PCRealmBase instance is not created')
return None
else:
pchain.SystemPackageInfo = realmobj.GetSystemPackageInfo()
if Result == True and pchain.SystemPackageInfo != None:
pchain.SystemPackageInfo[
pchain.SystemPackageInfo._Number] = packageinfo
else:
if Result == True:
f = None
if pchain.ispython2 == True:
f = open(os.path.join(fpath + '/packageinfo.json'))
else:
f = open(os.path.join(fpath + '/packageinfo.json'),
mode='r',
encoding='utf-8')
packagetxt = f.read()
f.close()
packageinfo = SrvGroup._NewParaPkg()
if packageinfo._FromJSon(packagetxt) == True:
packageinfo['PackageUrl'] = url
if pchain.ispython2 == True:
f = open(os.path.join(fpath + '/packageinfo.json'),
'w')
else:
f = open(os.path.join(fpath + '/packageinfo.json'),
mode='w',
encoding='utf-8')
packagetxt = f.write(packageinfo._ToJSon())
f.close()
if Result == True and pchain.SystemPackageInfo != None:
pchain.SystemPackageInfo[
pchain.SystemPackageInfo._Number] = packageinfo
return return_internal(Result, packageinfo["PackageName"])
except Exception as exc:
print(exc)
return None
def _DefineSubType(globaltbl,localtbl,parenttype,tpname,pyrawtype,StarNameSpaceIsValid,InputStarNameSpace) :
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("","")
global PCDataBaseClass
if PCDataBaseClass == None :
PCDataBaseClass = Service.PCDataBase
StarNameSpace = None
if StarNameSpaceIsValid == False :
_m_name = globaltbl.get('__name__')
if _m_name == None :
pass
elif _m_name == '__main__' :
pass
else :
_m_name = _m_name.replace('.','_')
StarNameSpace = Service._GetObject(_m_name)
if StarNameSpace == None :
StarNameSpace = Service.StarObjectSpace._New(_m_name)
else :
if Service.StarObjectSpace._IsInst(StarNameSpace) == True :
pass
else :
raise Exception('Register '+tpname+' failed, there has cle object which is not instance of StarNameSpace named '+_m_name)
else :
StarNameSpace = InputStarNameSpace
if pyrawtype == None :
pass
else :
if parenttype == None :
raise Exception('Register '+tpname+' failed, its parent type '+parenttype.__name__+' is not found.')
if parenttype.rawtype == None :
raise Exception('Register '+tpname+' failed, rawtype must be None')
else :
if issubclass(pyrawtype,parenttype.rawtype) == False:
raise Exception('Register '+tpname+' failed, rawtype is not subclass of its parent class')
data_class_rawtext = '''
from pchain import pydata
from pchain.pydata import PCPyDataClass
from pchain.pydata import PCPySimpleDataClass
class {0}(parenttype) :
if pyrawtype == None :
pass
else :
rawtype = pyrawtype
pydata._Register(None,{0},StarNameSpace)
globaltbl['{0}'] = {0}
localtbl['{0}'] = {0}
'''
local_env = {}
local_env['StarNameSpace'] = StarNameSpace
local_env['pyrawtype'] = pyrawtype
local_env['globaltbl'] = globaltbl
local_env['localtbl'] = localtbl
local_env['parenttype'] = parenttype
exec(str.format(data_class_rawtext,tpname),local_env)
newtype = globaltbl[tpname]
newtype.cached_globaltbl = globaltbl
newtype.cached_localtbl = localtbl
return newtype
# -*- coding: utf-8 -*-
"""
main.py
:package : {name}
:date : {date}
"""
import sys
import os
import pchain
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
# define pcdata management type
NumberClass = Service.PCDataBase.CreateType("NumberClass")
# define pcproc management type
@Service.PCProcBase.Create(None, "NumberProc", (NumberClass),
(NumberClass, NumberStepClass))
def NumberProc_Execute(SelfObj, Realm, Cell, Runner):
#get input
in1 = SelfObj.InputToParaPkg()
if in1[0] == None:
return 2
SelfObj.AcceptInput()
# create output
def _DefineType(globaltbl,
localtbl,
tpname,
InputDataType,
OutputDataType,
RawInputOutput,
IsAsync,
PyFunc=None):
if PyFunc == None:
def CreateDecorator(func):
DefineType(tpname, StarNameSpace, InputDataType, OutputDataType,
RawInputOutput, IsAsync, func)
return CreateDecorator
import libstarpy
SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")
global PCDataBaseClass
if PCDataBaseClass == None:
PCDataBaseClass = Service.PCDataBase
global PCProcBaseClass
if PCProcBaseClass == None:
PCProcBaseClass = Service.PCProcBase
StarNameSpace = None
_m_name = globaltbl.get('__name__')
if _m_name == None:
pass
elif _m_name == '__main__':
pass
else:
_m_name = _m_name.replace('.', '_')
StarNameSpace = Service._GetObject(_m_name)
if StarNameSpace == None:
StarNameSpace = Service.StarObjectSpace._New(_m_name)
else:
if Service.StarObjectSpace._IsInst(StarNameSpace) == True:
pass
else:
raise Exception(
'Register ' + tpname +
' failed, there has cle object which is not instance of StarNameSpace named '
+ _m_name)
proc_class_rawtext = '''
from pchain import pydata
from pchain.pydata import PCPyDataClass
from pchain.pydata import PCPySimpleDataClass
from pchain import pyproc
from pchain.pyproc import PCPyProcClass
class {0}(PCPyProcClass) :
def Execute(self,*args) :
Context = self.Context # first must save Context in local variable
from pchain import pydata
from pchain.pydata import PCPyDataClass
from pchain.pydata import PCPySimpleDataClass
WrapCallResult = None
if RawInputOutput == True :
if type(args) == type(()) :
callargs = []
for item in args :
if item == None :
callargs.append(None)
else :
callargs.append(item.value())
if len(callargs) == 0 :
WrapCallResult = WrapPyFunc()
else :
WrapCallResult = WrapPyFunc(*callargs)
else :
callargs = args.value()
WrapCallResult = WrapPyFunc(callargs)
if WrapCallResult == None :
return (0,0,None)
if RetPyType == None :
return (0,0,None)
else :
return (0,0,RetPyType(WrapCallResult))
else :
WrapCallResult = WrapPyFunc(self,*args)
return WrapCallResult
pyproc._Register({0},StarNameSpace,InputPyType,RetPyType)
{0}.GetType().IsAsync = IsAsync
globaltbl['{0}'] = {0}
localtbl['{0}'] = {0}
'''
local_env = {}
local_env['StarNameSpace'] = StarNameSpace
local_env['InputPyType'] = InputDataType
local_env['RetPyType'] = OutputDataType
local_env['WrapPyFunc'] = PyFunc
local_env['RawInputOutput'] = RawInputOutput
local_env['globaltbl'] = globaltbl
local_env['localtbl'] = localtbl
local_env['IsAsync'] = IsAsync
exec(str.format(proc_class_rawtext, tpname), local_env)
return globaltbl[tpname]
