예제 #1
0
        def onSink(self):
            import journal
            journal.debug("elc.exchange").activate()

            self.coupler.exchangeBoundary()

            return
예제 #2
0
def load(filename, format=None, mechanism=None):

    import journal
    journal.debug("fuego").log("loading file '%s', format='%s')" %
                               (filename, format))

    if not mechanism:
        from mechanisms.Mechanism import Mechanism
        mechanism = Mechanism(filename)
    # patrickh
    else:
        mechanism._name = filename

    if not format:
        format = guessMechanismType(filename)

    factory = registrar().find(format)
    if not factory:
        journal.error("fuego").log("unknown mechanism file format '%s'" %
                                   format)
        return None

    parser = factory.parser()

    file = locate(filename)
    parser.parse(mechanism, file)

    return mechanism
예제 #3
0
class Mesh(object):


    def read(self, simplices, file):

        count = 0
        self._info.log("scanning for simplices")
        while count < simplices:
            self._dump.log("processing simplex %d" % count)

            simplex = [ (int(node) - 1) for node in file.readline().split() ]
            self.simplices.append(simplex)
            count += 1

        self._info.log("read %d simplices" % count)

        return


    def __init__(self):
        self.simplices = []
        return


    import journal
    _info = journal.debug("tecplot")
    _dump = journal.debug("tecplot.scanning")
def findRetriever(Computation, depositories):

    candidates = []
    for depository in depositories:
        package = ['vnf', 'components']
        if depository: package.append(depository)
        package += ['computation_result_retrievers']
        package = '.'.join(package)

        module = Computation.__name__

        code = 'from %s.%s import Retriever' % (package, module)
        try:
            print code
            exec code in locals()
        except:
            import journal
            import traceback
            journal.debug('main').log(traceback.format_exc())
            continue
        candidates.append(Retriever)
        continue

    l = filter(lambda Retriever: Retriever.Computation == Computation,
               candidates)
    if len(l) != 1:
        if not len(l):
            raise RuntimeError, 'No result retriever found for computation %s' % Computation
        if len(l) > 1:
            raise RuntimeError, 'More than one result retrievers for computation %s exist' % Computation
    return l[0]
예제 #5
0
def main():

    from opal.applications.CGI import CGI

    class CmdlineApp(CGI):
        def main(self):
            import os
            import sys

            print '<pre>'
            print sys.argv
            print '</pre>'

            print '<pre>'
            for key, value in os.environ.iteritems():
                print '    %s = {%s}' % (key, value)
            print '</pre>'

            print '<pre>'
            print self.registry.render()
            print '</pre>'

            return

        def __init__(self):
            CGI.__init__(self, 'cmdline')
            return

    import journal
    journal.info('opal.cmdline').activate()
    journal.debug('opal.commandline').activate()

    app = CmdlineApp()
    return app.run()
def findRetriever(Computation, depositories):
    
    candidates = []
    for depository in depositories:
        package = ['vnf', 'components']
        if depository: package.append(depository)
        package += ['computation_result_retrievers']
        package = '.'.join(package)

        module = Computation.__name__

        code = 'from %s.%s import Retriever' % (package, module)
        try:
            print code
            exec code in locals()
        except:
            import journal
            import traceback
            journal.debug('main').log(traceback.format_exc())
            continue
        candidates.append(Retriever)
        continue

    l = filter(lambda Retriever: Retriever.Computation==Computation, candidates)
    if len(l) != 1:
        if not len(l):
            raise RuntimeError, 'No result retriever found for computation %s' % Computation
        if len(l) > 1:
            raise RuntimeError, 'More than one result retrievers for computation %s exist' % Computation
    return l[0]
예제 #7
0
class Nodal(object):
    def read(self, points, fields, input):

        for zone in fields:
            self.fields[zone] = []

        count = 0
        self._info.log("scanning for %d points" % points)
        while 1:
            line = input.readline()
            self._dump.log("processing point %d" % count)
            tokens = line.split()

            for zone, value in map(None, fields, tokens):
                self.fields[zone].append(float(value))

            count += 1
            if count == points:
                break

        self._info.log("read %d nodes" % count)

        return

    def __init__(self):
        self.fields = {}
        return

    import journal
    _info = journal.debug("tecplot")
    _dump = journal.debug("tecplot.scanning")
예제 #8
0
파일: debug_cascade.py 프로젝트: pyre/pyre
def test():
    """
    Verify that channels lower in the hierarchy inherit their parent default state
    """
    # get the journal
    import journal

    # make a channel
    parent = journal.debug(name="test.index.parent")
    # verify that the state is off
    assert parent.active is False
    # and that is not fatal
    assert parent.fatal is False
    # and the device is at the default value
    assert parent.device is parent.chronicler.device

    # activate it
    parent.active = True
    # and make it fatal
    parent.fatal = True
    # and set the device to a trash can
    parent.device = journal.trash()

    # lookup a name that is lower in the hierarchy
    child = journal.debug(name="test.index.parent.blah.blah.child")
    # that it's active is the same as the parent
    assert child.active == parent.active
    assert child.fatal == parent.fatal
    # and that it inherited the device correctly
    assert child.device is parent.device

    # all done
    return
예제 #9
0
def main():
    #debug.activate()
    journal.debug('periodicdispersion_3d').activate()
    pytests = pysuite()
    alltests = unittest.TestSuite( (pytests, ) )
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys; sys.exit(not res.wasSuccessful())
예제 #10
0
        def onServer(self):
            name = 'journal'

            # turn on my channels so we can watch what happens
            import journal
            journal.info(name).activate()
            journal.debug(name).activate()

            # build the registry settings
            registry = self.createRegistry()
            registry.name = 'root'
            node = registry.getNode(name)

            node.setProperty('port', self.port, self.inventory.getTraitDescriptor('port').locator)

            marshaller = node.getNode('marshaller')
            marshaller.setProperty('key', self.key, None)

            # instantiate the services
            service = journal.service(name)

            # configure it
            self.configureComponent(service, registry)

            # initialize it
            service.init()

            # enter the indefinite loop waiting for requests
            service.serve()

            return
예제 #11
0
def main():

    from opal.applications.CGI import CGI

    class HelloApp(CGI):
        class Inventory(CGI.Inventory):

            import pyre.inventory

            name = pyre.inventory.str("name", default="world")
            name.meta['tip'] = "the target of the greeting"

        def main(self):
            import os
            pid = os.getpid()
            euid = os.geteuid()
            uid = os.getuid()

            print '<pre>'
            print 'content: {%s}' % self.content
            print "(%d, %s): Hello %s!" % (pid, uid, self.inventory.name)
            print '</pre>'
            return

        def __init__(self):
            CGI.__init__(self, 'hello')
            return

    import journal
    journal.info('opal.cmdline').activate()
    journal.debug('opal.commandline').activate()

    app = HelloApp()
    return app.run()
예제 #12
0
def _import():
    try:
        import BoostPythonBinding
    except:
        import warnings, journal, traceback
        warnings.warn('binding not imported')
        journal.debug('BoostPythonBinding').log(traceback.format_exc())
    return
예제 #13
0
def main():
    import journal
    journal.debug("instrument.visitors.Instrument2VisualElements")
    
    from instrument.applications.InstrumentEditor.MainWinApp import MainWinApp
    mainWin = MainWinApp()
    mainWin.MainLoop()
    return
예제 #14
0
def _import():
    try:
        import BoostPythonBinding
    except:
        import warnings, journal, traceback
        warnings.warn('binding not imported')
        journal.debug('BoostPythonBinding').log(traceback.format_exc())
    return
def main():
    #debug.activate()
    import journal
    journal.debug("Event2QE").activate()
    pytests = pysuite()
    alltests = unittest.TestSuite( (pytests, ) )
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys; sys.exit(not res.wasSuccessful())
def main():
    #debug.activate()
    journal.debug('phonon_incoherent_inelastic_kernel').activate()
    #journal.debug('random').activate()
    pytests = pysuite()
    alltests = unittest.TestSuite( (pytests, ) )
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys; sys.exit(not res.wasSuccessful())
예제 #17
0
def main():
    #debug.activate()
    journal.debug('phonon_incoherent_inelastic_kernel').activate()
    #journal.debug('random').activate()
    pytests = pysuite()
    alltests = unittest.TestSuite((pytests, ))
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys
    sys.exit(not res.wasSuccessful())
def main():
    #debug.activate()
    import journal
    journal.debug("Event2QE").activate()
    pytests = pysuite()
    alltests = unittest.TestSuite((pytests, ))
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys
    sys.exit(not res.wasSuccessful())
예제 #19
0
def main():
    import journal
    journal.info('ssher').activate()
    journal.debug('dds').activate()

    pytests = pysuite()
    alltests = unittest.TestSuite((pytests, ))
    unittest.TextTestRunner(verbosity=2).run(alltests)
    return
def main():
    # debug.activate()
    journal.debug("periodicdispersion_3d").activate()
    pytests = pysuite()
    alltests = unittest.TestSuite((pytests,))
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys

    sys.exit(not res.wasSuccessful())
예제 #21
0
    def main(self, *args, **kwds):
        debugOn = journal.debug("debug_on")
        debugOn.activate()
        debugOn.log("This journal should be on.")
        debugOn.deactivate()
        debugOn.log("This journal should be off.")

        debugOff = journal.debug("debug_off")
        debugOff.log("This journal should be off.")
예제 #22
0
파일: mesh.py 프로젝트: bmi-forum/bmi-pyre
def test():

    import journal
    journal.debug("pyre.geometry").activate()

    import pyre.geometry

    mesh = pyre.geometry.mesh(dim=3, order=3)

    return
예제 #23
0
def test():

    import journal
    journal.debug("pyre.geometry").activate()

    import pyre.geometry

    mesh = pyre.geometry.mesh(dim=3, order=3)

    return
예제 #24
0
def main():
    import os
    curdir = os.path.abspath( '.' )
    import sys
    sys.path = [curdir] + sys.path
    
    import journal
    journal.debug( 'gml-wx-renderer' ).activate()
    run( 'wx',  ['main.gml', 'hello.gml' ] )
    return
예제 #25
0
 def onChild(pid, fromparent, toparent):
     try:
         response = self._server._marshaled_dispatch(data)
         self._sendResponse(response)
         line = fromparent.readline()
         toparent.write('done\n')
         toparent.flush()
     except:
         journal.debug('pathos').log(print_exc_info())
     os._exit(0)
def main():
    #debug.activate()
    #journal.debug("CompositeNeutronScatterer_Impl").activate()
    journal.warning('mcstas2.parsers.ComponentInfo').deactivate()
    # comment out this line to hide the error msg in searching for component
    journal.debug("mcstas2.pyre_support").activate() 
    import mcstas2.mcstas2bp
    pytests = pysuite()
    alltests = unittest.TestSuite( (pytests, ) )
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys; sys.exit(not res.wasSuccessful())
예제 #27
0
def main():

    name = 'harness'

    import journal
    journal.info(name).activate()
    journal.debug(name).activate()

    from pyre.applications.ServiceHarness import ServiceHarness
    app = ServiceHarness(name)
    return app.run()
예제 #28
0
def main():

    name = 'harness'

    import journal
    journal.info(name).activate()
    journal.debug(name).activate()

    from pyre.applications.ServiceHarness import ServiceHarness
    app = ServiceHarness(name)
    return app.run()
예제 #29
0
def main():
    #debug.activate()
    #journal.debug("CompositeNeutronScatterer_Impl").activate()
    journal.warning('mcstas2.parsers.ComponentInfo').deactivate()
    # comment out this line to hide the error msg in searching for component
    journal.debug("mcstas2.pyre_support").activate()
    import mcstas2.mcstas2bp
    pytests = pysuite()
    alltests = unittest.TestSuite((pytests, ))
    res = unittest.TextTestRunner(verbosity=2).run(alltests)
    import sys
    sys.exit(not res.wasSuccessful())
예제 #30
0
파일: login.py 프로젝트: bmi-forum/bmi-pyre
def main():


    from opal.applications.CGI import CGI


    class LoginApp(CGI):


        class Inventory(CGI.Inventory):

            import pyre.inventory

            username = pyre.inventory.str("username")
            password = pyre.inventory.str("password")


        def main(self):
            import os
            import sys

            print '<pre>'
            print sys.argv
            print '</pre>'

            print '<pre>'
            for key, value in os.environ.iteritems():
                print '    %s = {%s}' % (key, value)
            print '</pre>'

            print '<pre>'
            print self.registry.render()
            print "username:"******"password:"******"This is an info message")
            self._debug.log("This is a debug message")

            return


        def __init__(self):
            CGI.__init__(self, 'login')
            return


    import journal
    journal.debug('opal.commandline').activate()

    app = LoginApp()
    return app.run()
예제 #31
0
class Scanner(object):
    def match(self, text, column):
        match = self._scanner.match(text, column)
        if not match:
            return None

        return self._decode(match)

    def __init__(self):
        self._tokens = self._tokenClasses()
        self._scanner = self._constructTokenRecognizer()
        return

    def _tokenClasses(self):
        raise NotImplementedError("class '%s' must override '_tokenClasses'" %
                                  self.__class__.__name__)

    def _constructTokenRecognizer(self):
        import re
        patterns = [
            "(?P<%s>%s)" % (token.__name__, token.pattern)
            for token in self._tokens
        ]

        scanner = '|'.join(patterns)
        self._debugPattern.log("pattern: {%s}" % scanner)
        return re.compile(scanner)

    def _decode(self, match):
        groups = match.groupdict()
        for token in self._tokens:
            if groups[token.__name__]:
                self._info.log("matched token class '%s'" % token.__name__)
                return token(match, groups)

        str = "The text '%s' matched the scanner pattern " % match.group()
        str += "but there is no corresponding token class"
        import journal
        journal.firewall("pyre.parsing").log(str)

        return

    def _pattern(self):
        return self._scanner.pattern

    import journal
    _info = journal.debug("pyre.parsing.scanner")
    _debugPattern = journal.debug("pyre.parsing.scanner.pattern")

    from TokenizationException import TokenizationException
예제 #32
0
def journald(name=None):

    if name is None:
        name = "journald"
        
    import journal
    journal.info("journal").activate()
    journal.debug("journal").activate()
    
    journal.info("journald").activate()
    journal.debug("journald").activate()

    app = journal.daemon(name)
    app.run()
예제 #33
0
def save(mechanism, format="chemkin"):

    import journal
    journal.debug("fuego").log("pickling mechanism, format='%s')" % format)

    factory = registrar().retrieve(format)
    if not factory:
        journal.error("fuego").log("unknown mechanism file format '%s'" % format)
        return []
        
    pickler = factory.pickler()
    pickler.initialize()

    return pickler.pickle(mechanism)
예제 #34
0
def journald(name=None):

    if name is None:
        name = "journald"

    import journal
    journal.info("journal").activate()
    journal.debug("journal").activate()

    journal.info("journald").activate()
    journal.debug("journald").activate()

    app = journal.daemon(name)
    app.run()
예제 #35
0
def save(weaver, mechanism, stream, format="chemkin"):

    # mga 20070913: FIXME: impossible to use with an driver:
    # who can configure a weaver manually?

    import journal
    journal.debug("fuego").log("pickling mechanism, format='%s')" % format)

    mill = pickler(format)
    if not pickler:
        journal.error("fuego").log("unknown mechanism file format '%s'" % format)
        return []
        
    weaver.renderer = mill
    return weaver.weave(mechanism, stream)
예제 #36
0
def test():
    """
    Verify the channel initial state
    """
    # access
    import journal

    # make a channel
    channel = journal.debug(name="tests.journal.debug")
    # verify the channel name
    assert channel.name == "tests.journal.debug"
    # the verbosity should be at the default level
    assert channel.verbosity == 1
    # the channel should be inactive
    assert channel.active == False
    # and non fatal
    assert channel.fatal == False

    # the page should be empty
    assert tuple(channel.page) == ()
    # verify the metadata
    assert channel.notes["application"] == "journal"
    assert channel.notes["channel"] == channel.name
    assert channel.notes["severity"] == channel.severity

    # all done
    return
예제 #37
0
  def _configure(self):
    """
    Set members based using inventory.
    """
    PetscComponent._configure(self)
    self.matrixType = self.inventory.matrixType
    self.timeStep = self.inventory.timeStep
    self.solver = self.inventory.solver
    self.output = self.inventory.output
    self.viewJacobian = self.inventory.viewJacobian
    self.jacobianViewer = self.inventory.jacobianViewer
    self.perfLogger = self.inventory.perfLogger

    import journal
    self._debug = journal.debug(self.name)

    if self.inventory.useCustomConstraintPC and \
           not self.inventory.useSplitFields:
      print "WARNING: Request to use custom preconditioner for Lagrange " \
            "constraints without splitting fields. " \
            "Setting split fields flag to 'True'."
      self.inventory.useSplitFields = True

    ModuleFormulation.splitFields(self, self.inventory.useSplitFields)
    ModuleFormulation.useCustomConstraintPC(self, self.inventory.useCustomConstraintPC)

    return
예제 #38
0
    def __init__(self, name=None):
        Traceable.__init__(self)

        if name is None:
            name = self.name # class attribute
        else:
            self.name = name
        self.inventory = self.createInventory()
        
        # provide simple, convenient access to descriptors
        self.metainventory = self.createMetaInventory()

        # other names by which I am known for configuration purposes
        self.aliases = [ name ]

        import journal
        self._debug = journal.debug(name)
        self._info = journal.info(name)
        self._error = journal.error(name)
        self._warning = journal.warning(name)

        # modify the inventory defaults that were hardwired at compile time
        # gives derived components an opportunity to modify their default behavior
        # from what was inherited from their parent's inventory
        self._defaults()
        
        return
예제 #39
0
def createContinuousAxis(name,
                         unit,
                         centers=None,
                         boundaries=None,
                         centersCreationArgs=None,
                         attributes=None):
    """create a continuous axis

    a continuos axis represents a continuous physics quantity like energy, time of flight, etc.
    
    datatype is set to 'double' because of the continuity
    
    a mapper is created and attached to the axis.
    """
    if (centers is not None
            or centersCreationArgs is not None) and boundaries is not None:
        raise ValueError("both centers and boundaries are specified")

    if centers is not None and centersCreationArgs is not None:
        raise ValueError(
            "both centers and center creation arguments are specified")

    if centers is not None:
        boundaries = boundariesFromCenters(centers)
        pass  # end if centers

    if centersCreationArgs is not None:
        min, delta, nBins = centersCreationArgs
        boundaries = calcBinBoundaries(min, delta, nBins)
        pass  # end if centersCreationArgs

    unit = unitFromString(unit)

    from .EvenlyContinuousAxisMapper import \
         EvenlyContinuousAxisMapper as AxisMapper, NotEvenlySpaced
    try:
        axisMapper = AxisMapper(binBoundaries=boundaries)
    except NotEvenlySpaced:
        import traceback
        import journal
        debug = journal.debug('histogram.createContinuousAxis')
        #debug.log( traceback.format_exc() )
        debug.log(
            'createContinuousAxis(name = %r, unit = %r, centers= %r, boundaries = %r'
            % (name, unit, centers, boundaries))
        from .ContinuousAxisMapper import ContinuousAxisMapper as AxisMapper
        axisMapper = AxisMapper(boundaries)

    nBins = len(boundaries) - 1

    storage = ndArray("double", boundaries)

    from .Axis import Axis
    return Axis(name,
                unit,
                length=nBins,
                storage=storage,
                mapper=axisMapper,
                centers=centers,
                attributes=attributes)
예제 #40
0
def debug():
    d = journal.debug("foo")
    d.active = True
    d.log("unknown error")
    # also from C++
    journal.extension.debugTest("foo")
    return
예제 #41
0
def test():
    import journal
    # journal.debug("postgres.init").active = True
    # journal.debug("postgres.execute").active = True
    # journal.debug("postgres.connection").active = True
    journal.debug("postgres.transactions").active = True

    # this is the SQL statement that looks for a table by a given name
    sql = "SELECT tablename FROM pg_tables WHERE tablename='{}'".format(Weather.pyre_name)

    # build a database component and connect to the database specified in the local
    # configuration file
    db = pyre.db.postgres(name="test").attach()

    # in a transaction block
    with db:
        # create the table
        db.createTable(Weather)
        # verify it is there
        assert db.execute(sql) == (('tablename',), ('weather',))
        # drop the table
        db.dropTable(Weather)
        # verify it is not there
        assert db.execute(sql) == (('tablename',),)

    # and return the connection and the table
    return db, Weather
예제 #42
0
    def findPendingTask(self, db, iworker=None):
        import journal
        debug = journal.debug('itask-findPendingTask')
        from ITask import ITask
        tasks = self.getReferences(db, ITask, 'beneficiary')
        if not tasks: return

        found = None
        for task in tasks:
            
            # if not the right task, skip
            if task.worker != iworker: continue

            if task.state == 'finished':
                raise RuntimeError, "Task %s for %s finished but apparently it is not giving the right results or the results of this task has been mistakenly removed." % (task.id, self.id)

            if task.state == 'failed':
                debug.log("Task %s for %s found. Which has failed before." % (task.id, self.id))
                return task

            if task.state == 'cancelled':
                debug.log("Task %s for %s found. Which was cancelled." % (task.id, self.id))
                # reopen the task
                task.state = 'created'
                db.updateRecord(task)
                found = task
                break

            found = task
            break

        return found
예제 #43
0
    def __init__(self, name=None, **kwds):
        # chain up
        super().__init__(name=name, **kwds)

        # attach my renderer to the console
        import journal
        journal.console.renderer = self.pyre_renderer

        # make a name for my channels
        channel  = self.pyre_namespace or name
        # if I have a name
        if channel:
            # build my channels
            self.debug = journal.debug(channel)
            self.firewall = journal.firewall(channel)
            self.info = journal.info(channel).activate()
            self.warning = journal.warning(channel).activate()
            self.error = journal.error(channel).activate()
            # if i am in debugging mode
            if self.DEBUG:
                # activate the debug channel
                self.debug.active = True

        # sniff around for my environment
        self.pyre_home, self.pyre_prefix, self.pyre_defaults = self.pyre_explore()
        # instantiate my layout
        self.layout = self.pyre_loadLayout()
        # mount my folders
        self.pfs = self.pyre_mountPrivateFilespace()
        # go through my requirements and build my dependency map
        # self.dependencies = self.pyre_resolveDependencies()

        # all done
        return
예제 #44
0
파일: Peer.py 프로젝트: PyreFramework/pyre
    def __init__(self, name=None, timer=None, **kwds):
        # chain up
        super().__init__(name=name, **kwds)

        # i am not have a name, but i need one in what follows
        name = name or self.pyre_family() or "pyre.nexus.peers"

        # if i were handed a timer to use
        if timer is not None:
            # save it
            self.timer = timer
        # otherwise
        else:
            # make a new one and start it
            self.timer = self.pyre_executive.newTimer(name=name).start()

        # journal channels
        import journal
        self.info = journal.info(name=name)
        self.debug = journal.debug(name=name)
        self.warning = journal.warning(name=name)
        self.error = journal.error(name=name)

        # all done
        return
예제 #45
0
    def __init__(self):
        self.port = None

        import journal
        self._debug = journal.debug("pyre.ipc.monitor")

        return
예제 #46
0
파일: debug_notes.py 프로젝트: pyre/pyre
def test():
    """
    Verify access to the channel metadata
    """
    # access
    import journal

    # make a channel
    channel = journal.debug("test.channel")
    # get its metadata
    notes = channel.notes
    # adjust the application name
    notes["application"] = "debug_notes"
    # add something
    notes["author"] = "michael"

    # make sure the adjustments stick by asking for the notes once again; this step is
    # non-trivial: if support is provided by the C++ library, it ensures that the notes are
    # mutable
    notes = channel.notes
    # and comparing against expectations
    assert notes["application"] == "debug_notes"
    assert notes["author"] == "michael"
    assert notes["channel"] == "test.channel"
    assert notes["severity"] == "debug"

    # all done
    return
예제 #47
0
    def __init__(self, name=None, timer=None, **kwds):
        # chain up
        super().__init__(name=name, **kwds)

        # i may not have a name, but i need one in what follows
        name = name or self.pyre_family() or "pyre.nexus.peers"

        # if i didn't get handed a timer to use
        if timer is None:
            # make a new one
            timer = self.pyre_executive.newTimer(name=name)
            # start it
            timer.start()
        # save it
        self.timer = timer

        # journal channels
        import journal
        self.info = journal.info(name=name)
        self.debug = journal.debug(name=name)
        self.warning = journal.warning(name=name)
        self.error = journal.error(name=name)

        # all done
        return
예제 #48
0
    def __init__(self, name):
        self._name = name
        self._options = None

        import journal
        self._debug = journal.debug(name)

        return
    def test2(self):
        "bpext: double array"
        import journal
        journal.debug('wrap_native_ptr').activate()
        journal.debug('extract_native_ptr').activate()
        
        import bpext._bpext as binding
        arr = binding.newdblarr(10)
        print arr

        wrapped_ptr_bpobj = binding.wrap_native_ptr( arr )

        print wrapped_ptr_bpobj

        extracted = binding.extract_native_ptr( wrapped_ptr_bpobj )
        print extracted
        return
예제 #50
0
    def __init__(self, name="CitcomS"):
        """Constructor. Inventory object is not initialized yet.
        """
        Application.__init__(self, name)

        # channel for debugging output
        self._info = journal.debug("application")
        return
예제 #51
0
	def __init__( self, name = "snaccitcom" ):
		SnacApplication.__init__( self, name )

		self.solverCommunicator = None
		self.myPlus = []
		self.remotePlus = []

		self._info = journal.debug( "application" )
		return
예제 #52
0
  def _configure(self):
    """
    Set members based using inventory.
    """
    Formulation._configure(self)

    import journal
    self._debug = journal.debug(self.name)
    return
예제 #53
0
파일: Solver.py 프로젝트: Alex-Song/vmaf
    def __init__(self, name, facility=None):
        if facility is None:
            facility = "solver"
            
        Component.__init__(self, name, facility)
        
        self._elc = None
                
        import journal
        self._loopInfo = journal.debug("%s.timeloop" % name)
        self._monitorInfo = journal.debug("%s.monitoring" % name)

        from pyre.units.time import second
        self.t = 0.0 * second

        self.step = 0

        return
예제 #54
0
    def __init__(self, name):
        self.codecs = {}

        tag = name + '.curator'

        import journal
        self._info = journal.info(tag)
        self._debug = journal.debug(tag)

        return
예제 #55
0
def test():

    import journal
    journal.debug("pyre.ipc.selector").activate()

    import pyre.ipc
    selector = pyre.ipc.selector()

    selector.notifyWhenIdle(onTimeout)
    
    try:
        selector.watch()
    except:
        import sys
        type, value, tb = sys.exc_info()
        print "got %s: {%s}" % (type, value)
        raise type, value

    return
예제 #56
0
        def onClient(self):
            # initialize the journal device
            import journal
            journal.remote(self.key, self.port, self.host)

            for idx in range(5):
                info = journal.debug("test-%02d" % idx).activate()
                info.log("test %02d: this a sample message" % idx)

            return