Python DefineType示例

示例#1

文件： about_tag.py 项目： srplab/pchain

    def __init__(self, name='Charlie', age=8):
        self.name = name
        self.age = age

    def say(self, content):
        print(content)

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.__dict__ == other.__dict__
        else:
            return False


pydata.DefineType('PersonClass', Person)


# Define procedure types
@pyproc.DefineProc('TestProcClass', None, PersonClass)
def Execute(self):
    Context = self.Context  #  first must save Context in local variable
    if Context['SelfObj'].Status < 0:
        return None
    return (0, 1, None)


@pyproc.DefineProc('TestProcClass1', None, PersonClass)
def Execute(self):
    Context = self.Context  #  first must save Context in local variable
    if Context['SelfObj'].Status < 0:

示例#2

    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase()

# Define data types
pydata.DefineType('NumberClass', int)


# Define procedure types
@pyproc.DefineProc('AddProc', (NumberClass, NumberClass), NumberClass)
def Execute(self, num1, num2):
    Context = self.Context  #  first must save Context in local variable
    return (0, 1, NumberClass(num1.value() + num2.value()))


cell = Service.PCCellBase()
cell.AddProc(AddProc)
cell.AddEnvData(realm, NumberClass(1), NumberClass(2))
realm.AddCell(cell)
result = realm.ExecuteForResult()
print(result[0])

示例#3

文件： pyclass.py 项目： srplab/pchain

from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase()


#define a python class
class pyclass:
    def pyfunc(self, a, b, c):
        return a + b + c


#define data management type
pydata.DefineType('PythonObjectClass', pyclass)
pydata.DefineType('PythonNumberClass')


#define proc management type
@pyproc.DefineRawProc('PyFuncProc', (PythonObjectClass, PythonNumberClass,
                                     PythonNumberClass, PythonNumberClass),
                      PythonNumberClass)
def PyFun(obj, a, b, c):
    print('input :', obj, a, b, c)
    return obj.pyfunc(a, b, c)


'''
func = PyFuncProc()
result = func(PythonObjectClass(pyclass()),PythonNumberClass(1.0),PythonNumberClass(2.0),PythonNumberClass(3.0))

示例#4

文件： simple_pyqt_stub.py 项目： srplab/pchain

import libstarpy

realm = Service.PCRealmBase._New()
realm_stub = Service.PCRealmStubBase._New()


@realm_stub._RegScriptProc_P('OnException')
def realm_stub_OnException(SelfObj, AlarmLevel, Info):
    if AlarmLevel == 1:
        print(Info)


realm.SetRealmStub(realm_stub)

# Define data types
pydata.DefineType('PC_ButtonNameClass', str)  #--save button name
pydata.DefineType('PC_EventClass', str)  #save event


# Define procedure types
@pyproc.DefineProc('ButtonClickHandlerProc', PC_EventClass, None)
def Execute(self, event):
    Context = self.Context  #  first must save Context in local variable
    btn_name = event.GetSource()[0]
    Context['Realm'].GetLocalBuf()[0].numLabel.setText(btn_name.value() +
                                                       ' is clicked')
    return (0, 1, None)


#define stub function to handle all ream's callback
@realm_stub._RegScriptProc_P('OnBeforeExecute')

示例#5

    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase._New()

# Define data types
pydata.DefineType('NumberClass', float)

realm.AddEnvData(NumberClass(1.2), NumberClass(3.4), NumberClass(4.5))
datas = realm.GetEnvData()
print(datas)

realm.RemoveEnvData(datas)
newdatas = realm.GetEnvData()
print(newdatas._Number)

realm.AddEnvData(datas)
datas = realm.GetEnvData()

realm.RemoveEnvData(datas[0])
print(realm.GetEnvData())

示例#6

# Define data types
class Person :
  hair = 'black'
  def __init__(self, name = 'Charlie', age=8):
    self.name = name
    self.age = age
  def say(self, content):
    print(content)
  def __eq__(self, other):
    if isinstance(other, self.__class__):
      return self.__dict__ == other.__dict__
    else:
      return False   

pydata.DefineType('PersonClass',Person)

@pyproc.DefineProc('HelloWorldProc',None,None)
def Execute(self) :  
  Context = self.Context  #  first must save Context in local variable
  print('Hello world !')
  return (0,1,None)

#--
myobjdataclass = Service.PCObjectDataBase.CreateType("myobjdataclass")

obj_data = myobjdataclass.Create(Service.PersonClass.GetType())
print(obj_data.GetObject())

obj_proc = myobjdataclass.Create(Service.HelloWorldProc.GetType())
print(obj_proc.GetObject())

示例#7

文件： save_load_index.py 项目： srplab/pchain

    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase._New()

# Define data types
pydata.DefineType('NumberClass', float)


# Define procedure types
@pyproc.DefineProc('InputProc', None, NumberClass)
def Execute(self):
    Context = self.Context  #  first must save Context in local variable
    if Context['SelfObj'].Status < 0:
        return None
    val = input('input a number : ')
    return (4, 1, NumberClass(val))


# Define procedure types
@pyproc.DefineProc('OutputProc', (NumberClass, NumberClass), None)
def Execute(self, num1, num2):

示例#8

    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase._New()

# Define data types
pydata.DefineType('StringClass', str)
pydata.DefineType('NumberClass', int)
pydata.DefineType('UpperStringClass', str)


# Define procedure types
@pyproc.DefineProc('LengthProc', StringClass, NumberClass)
def Execute(self, instr):
    Context = self.Context  #  first must save Context in local variable
    return (0, 1, NumberClass(len(instr.value())))


@pyproc.DefineProc('ToUpperProc', StringClass, UpperStringClass)
def Execute(self, instr):
    Context = self.Context  #  first must save Context in local variable
    return (0, 1, UpperStringClass(instr.value().upper()))

示例#9

文件： simple_java_process.py 项目： srplab/pchain

    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase._New()

# Define data types
pydata.DefineType('NumberBaseClass')


class NumberClass(NumberBaseClass):
    @staticmethod
    def Load(MetaData):
        # MetaData maybe string or parapkg
        # raise Exception('Load function is not defined ')
        if type(MetaData) == type(''):
            return NumberClass(float(MetaData))
        else:
            return NumberClass(MetaData[0])

    def ToParaPkg(self, parapkg):
        parapkg[0] = self.value()
        return True

示例#10

except Exception as exc:
    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase._New()

pydata.DefineType("UrlClass")
pydata.DefineType("WebPageClass")


# this proc will be blocked
@pyproc.DefineAsyncProc('DownLoadUrlProc', UrlClass, WebPageClass)
def Execute(self, url):
    Context = self.Context  #  first must save Context in local variable
    SelfObj = Context["SelfObj"]

    try:
        libstarpy._SRPUnLock()  # release cle lock, before enter wait
        result = None
        if pchain.ispython2 == True:
            import urllib2
            req = urllib2.Request(url.value())

示例#11

文件： list_dir.py 项目： srplab/pchain

import libstarpy

realm = Service.PCRealmBase._New()

realmStub = Service.PCRealmStubBase._New()


@realmStub._RegScriptProc_P('OnMoreUnAllocatedData')
def OnMoreUnAllocatedData(cleobj, realm, proc):
    return 1


realm.SetRealmStub(realmStub)

# Define data types
pydata.DefineType('DiskPathClass')
pydata.DefineType('FileNameClass')


@pyproc.DefineAsyncProc('ListFileClass', DiskPathClass, FileNameClass)
def Execute(self, DiskPath):
    Context = self.Context

    localbuf = Context['SelfObj'].GetLocalBuf()
    if Context['SelfObj'].Status == 0:
        import os
        listfile = os.listdir(DiskPath.value())
        localbuf[0] = listfile
        localbuf[1] = 0

        Context['SelfObj'].Status = 1

示例#12

################################################################ define datatype EnvInMsg
class RawEnvInMsg:
    def __init__(self, MsgId, MsgInfo):
        self.MsgId = MsgId
        self.MsgInfo = MsgInfo

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.__dict__ == other.__dict__
        else:
            return False


pydata.DefineType('EnvInMsg', RawEnvInMsg)


################################################################ define datatype InnerMsg2
class RawInnerMsg2:
    def __init__(self, MsgId, MsgInfo):
        self.MsgId = MsgId
        self.MsgInfo = MsgInfo

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.__dict__ == other.__dict__
        else:
            return False

示例#13

文件： grab_url_img_package.py 项目： srplab/pchain

"""

import sys
import os
import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass
import libstarpy

SrvGroup = libstarpy._GetSrvGroup(0)
Service = SrvGroup._GetService("", "")

# Define data types
pydata.DefineType('UrlClass')
pydata.DefineType('HtmlClass')
pydata.DefineSubType(UrlClass, 'ImageUrlClass')
pydata.DefineType('ImageClass')


# Define procedure types
@pyproc.DefineAsyncProc('DownloadHtmlProc', UrlClass, HtmlClass)
def Execute(self, url):
    Context = self.Context  #  first must save Context in local variable
    SelfObj = Context["SelfObj"]

    try:
        libstarpy._SRPUnLock()  # release cle lock, before enter wait
        fd = None
        if pchain.ispython2 == True:

示例#14

文件： wrap_class.py 项目： srplab/pchain

#==
class Study:
    def __init__(self, name=None):
        self.name = name

    def say(self):
        print(self.name)


'''    
study = Study("xxxxxx")
study.say()
'''

# Define data types
pydata.DefineType('StringClass', type(''))
pydata.DefineType('StudyClass', Study)


@pyproc.DefineProc('Create_Study_Proc', StringClass, StudyClass)
def Execute(self, val):
    Context = self.Context  #  first must save Context in local variable
    return (0, 1, StudyClass(Study(val.value())))


@pyproc.DefineProc('Study_Say_Proc', StudyClass, None)
def Execute(self, item):
    Context = self.Context  #  first must save Context in local variable
    item.value().say()
    return (0, 1, None)

示例#15

                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

from PIL import Image

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase._New()

pydata.DefineType('SizeClass', type(()))
pydata.DefineType('IntClass', type(int))
pydata.DefineType('ImageFileClass', type(''))
pydata.DefineType('ImageClass')
pydata.DefineType('ImageFormatClass', type(''))
pydata.DefineType('ImageHistogramClass', type([]))


@pyproc.DefineProc('ImageOpenProc', ImageFileClass, ImageClass)
def Execute(self, ImageFile):
    Context = self.Context  #  first must save Context in local variable
    im = Image.open(ImageFile.value())
    return (0, 1, ImageClass(im))


@pyproc.DefineProc('ImageResizeProc', (ImageClass, SizeClass), ImageClass)

示例#16

文件： data_runproc.py 项目： srplab/pchain

    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase._New()

# Define data types
pydata.DefineType('StringClass', str)
pydata.DefineType('IntegerClass', int)


# Define procedure types
@pyproc.DefineProc('StringLengthProc', StringClass, IntegerClass)
def Execute(self, input_str):
    Context = self.Context  #  first must save Context in local variable
    return (0, 1, IntegerClass(len(input_str.value())))


d2 = StringClass("aaaa")
print(d2.RunProc(StringLengthProc))

d3 = StringClass("sssssssssssss")
set1 = Service.PCDataSetBase.Create(d2, d3)

示例#17

文件： pyfunction.py 项目： srplab/pchain

except:
    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

realm = Service.PCRealmBase()

pydata.DefineType('PythonNumberClass')


@pyproc.DefineRawProc(
    'PyFuncProc', (PythonNumberClass, PythonNumberClass, PythonNumberClass),
    PythonNumberClass)
def PyFun(a, b, c):
    print('input :', a, b, c)
    val = a + b + c
    return val


'''
func = PyFuncProc()
result = func(PythonNumberClass(1.0),PythonNumberClass(2.0),PythonNumberClass(3.0))
'''

示例#18

    import pchain
except Exception as exc:
    pchain_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               '../')
    sys.path.insert(0, pchain_path)
    import pchain
from pchain import pydata
from pchain import pyproc
from pchain.pydata import PCPyDataClass
from pchain.pyproc import PCPyProcClass

Service = pchain.cleinit()
import libstarpy

# Define data types
pydata.DefineType('StringClass')
pydata.DefineType('NumberClass')


@pyproc.DefineProc('LengthProc', StringClass, NumberClass)
def Execute(self, strobj):
    Context = self.Context
    val = len(strobj.value())
    return (0, 1, NumberClass(val))


@pyproc.DefineProc('ToIntProc', StringClass, NumberClass)
def Execute(self, strobj):
    Context = self.Context
    val = 0
    try: