Changeset 144

Timestamp:

08/31/2009 06:38:30 PM (13 years ago)

Author:

marcus

Message:

• access to user defined symbols
• trace counting starts from zero (fallback function for natural counting starting from one)
• test enhanced

Location:

SHX/trunk/src/SeismicHandler

Files:

• core/error.py (modified) (1 diff)
• core/modules/Trace.py (modified) (3 diffs)
• core/modules/Variables.py (modified) (2 diffs)
• startup.py (modified) (1 diff)
• tests/test_commands.py (modified) (2 diffs)
• tests/test_shlib.py (modified) (2 diffs)
• tests/test_traces.py (modified) (1 diff)
• tests/test_variables.py (added)

SHX/trunk/src/SeismicHandler/core/error.py

@@ -85 +85 @@
     def __str__(self):
         return """internal variables are unchangeable!"""
+
+class VarsSymbolNotFoundError(Error):
+    def __init__(self, name):
+        Error.__init__(self)
+        self.name = name
+
+    def __str__(self):
+        return """symbol '%s' not found!""" % self.name
+
+class VarsSymbolGlobalLocalError(Error):
+    def __init__(self, name):
+        Error.__init__(self)
+        self.name = name
+
+    def __str__(self):
+        return """symbol '%s' already defined in local scope!""" % self.name

SHX/trunk/src/SeismicHandler/core/modules/Trace.py

@@ -61 +61 @@
     def __len__(self):
         """return length of trace in milliseconds"""
-        
+
         return self.delta * self.length * 1000
 
@@ -191 +191 @@
 
     def __getitem__(self, number):
-        return self.tracedata[self.traces[number-1]]
+        if number >= len(self.traces):
+            raise IndexError("trace list end reached")
+
+        return self.tracedata[self.traces[number]]
 
     def update(self, event=None):
@@ -258 +261 @@
         return len(self.traces)
 
+    def get(self, number):
+        """return trace by index using natural count (start from one)
+        """
+        return self.traces[number-1]
+
 if __name__ == "__main__":
     t = Traces()

SHX/trunk/src/SeismicHandler/core/modules/Variables.py

@@ -26 +26 @@
 from SeismicHandler.core.shlib import shlib
 from SeismicHandler.core.log import logging
-from SeismicHandler.core.error import VarsSystemReadOnlyError
+from SeismicHandler.core.error import VarsSystemReadOnlyError, VarsSymbolNotFoundError, VarsSymbolGlobalLocalError
 import ctypes as C
 
 class accessSystem(object):
+    _logger = None
+    _sh = None
+
     def __init__(self):
-        self._logger = logging.getLogger("modules.variables")
-        self._sh = shlib().sh
-    
+        if not self._logger:
+            self._logger = logging.getLogger("modules.variables")
+
+        if not self._sh:
+            self._sh = shlib().sh
+
     def __getattr__(self, name):
         if name in ["_logger", "_sh"]:
             return self.__dict__[name]
-        
+
         res = C.create_string_buffer(1024)
         status = C.c_int()
-        
+
+        self._logger.debug("system variable access: %s" % name.upper())
         self._sh.tr_intern(name.upper(), "", len(res), C.byref(res), C.byref(status))
-        
+
         if not status:
             return res.value
         else:
             return False
-    
+
     def __setattr__(self, name, value):
         if name in ["_logger", "_sh"]:
@@ -55 +62 @@
 
 class accessSymbols(object):
+    _logger = None
+    _sh = None
+    _types = {}
+
     def __init__(self):
-        pass
-    
+        if not self._logger:
+            self._logger = logging.getLogger("modules.variables")
+
+        if not self._sh:
+            self._sh = shlib().sh
+
     def __getattr__(self, name):
-        pass
-    
-    def __setattr__(self, name, value):
-        pass
+        if name in ["_logger", "_sh", "_types"]:
+            return self.__dict__[name]
 
-SystemVars = accessSystem()
-SymbolVars = accessSymbols()
+        name = name.upper()
+
+        inlocal = self._sh.ss_exist(0, name)
+        inglobal =  self._sh.ss_exist(1, name)
+
+        # not found at all
+        if not inlocal | inglobal:
+            raise VarsSymbolNotFoundError(name)
+
+        symbolset = inglobal and 1 or 0
+
+        status = C.c_int(0)
+        value = C.create_string_buffer(512)
+
+        self._sh.ss_getval(symbolset, name, len(value), C.byref(value), C.byref(status))
+
+        if not status:
+            try:
+                return self._types[name](value.value)
+            except KeyError:
+                self._types[name] = str
+                return value.value
+        else:
+            self._logger.warning("error accessing symbol: %s" % name.upper())
+
+    def __setattr__(self, name, value, globalscope = 0):
+        if name in ["_logger", "_sh", "_types"]:
+            self.__dict__[name] = value
+            return
+
+        name = name.upper()
+        status = C.c_int(0)
+        
+        inlocal = self._sh.ss_exist(0, name)
+        inglobal =  self._sh.ss_exist(1, name)
+        
+        if not inlocal | inglobal:
+            # symbol does not exist at all
+            if value != None:
+                # setting value to None will delete symbol
+                # since is does not exist, we just have to handle the opposite
+
+                # save type for later reconversion (SH saves everything as string)
+                self._types[name] = type(value)
+
+                self._logger.debug("creating %s symbol: %s, value '%s', %s" % (globalscope and "global" or "local", name, str(value), type(value)))
+                self._sh.ss_define(globalscope, name, str(value), C.byref(status))
+
+        else:
+            # symbol exists already
+            # use detected scope
+            globalscope = inglobal and 1 or 0
+            
+            if value == None:
+                # setting value to None deletes symbol by definition
+                self._logger.debug("deleting %s symbol: %s" % (globalscope and "global" or "local", name))
+                self._sh.ss_delete(globalscope, name, C.byref(status))
+                del self._types[name]
+            else:
+                self._logger.debug("changing %s symbol value: %s to '%s', %s" % (globalscope and "global" or "local", name, str(value), type(value)))
+                self._sh.ss_change(globalscope, name, str(value), C.byref(status))
+                self._types[name]= type(value)
+
+        if status:
+            self._logger.warning("error accessing symbol: %s" % name)
+
+    def createGlobal(self, name, value = ""):
+        # check if symbol was defined in other scope
+        name = name.upper()
+
+        if name in self._types:
+            raise VarsSymbolGlobalLocalError(name)
+
+        self.__setattr__(name, value, 1)
+
+System = accessSystem()
+Symbol = accessSymbols()
 
 if __name__ == "__main__":
-    print SystemVars.pi
+#    print System.pi
+    Symbol.lala = 10
+    Symbol.createGlobal("lala", 1)
+#    print Symbol.lala
+#    Symbol.lala = None
+#    Symbol.lala = 1
+#    print Symbol.lala
+#    Symbol.createGlobal("a", 2.1)
+#    print Symbol.a
+#    Symbol.lulu = "test"
+#    Symbol.i = 1j
+    
+#    print Symbol._types
+    
+#    print type(Symbol.i)

SHX/trunk/src/SeismicHandler/startup.py

@@ -35 +35 @@
 # finally import modules and commands for instant usage
 from SeismicHandler.core.log import logging
-from SeismicHandler.core.commands import Run, Quit
+from SeismicHandler.core.commands import *
+from SeismicHandler.core.modules.Variables import System, Symbol
 
 # just init adopted cmd line interface

SHX/trunk/src/SeismicHandler/tests/test_commands.py

@@ -3 +3 @@
 from SeismicHandler.core.modules.Events import Event, EventManager
 from SeismicHandler.core.modules.Trace import Traces
+from SeismicHandler.core.modules.Variables import Symbol, System
 from SeismicHandler.core.commands import Run
 
@@ -15 +16 @@
         
     def testAm(self):
-        # create synth 100 seconds length
-        # maximum amplitude 113 at position 15 
+        # Create synthetic trace of 100 seconds length.
+        # Maximum amplitude 113 at position 15. 
         Run("create sharp 0.05 100 113. 15. .1 .5")
+        
+        # create symbols (we want to set the result type from python
+        Symbol.min = 0.
+        Symbol.minpos = 0.
+        Symbol.max = 0.
+        Symbol.maxpos = 0.
+        Run("am 1 0. 100. &min &max &minpos &maxpos")
+        
+        # test values taken from SH command line version
+        self.assertAlmostEqual(Symbol.min, -60.2811)
+        self.assertAlmostEqual(Symbol.minpos, 24.05)
+        self.assertAlmostEqual(Symbol.max, 113.00)
+        # please note that the maximum position differs from input (15)
+        self.assertAlmostEqual(Symbol.maxpos, 17.75)
+        
+    def testAppend(self):
+        pass
         
     def testSum(self):

SHX/trunk/src/SeismicHandler/tests/test_shlib.py

@@ -4 +4 @@
 from SeismicHandler.config.options import config
 from SeismicHandler.core.commands import Run
+from SeismicHandler.core.modules.Variables import System
 
 import unittest
@@ -23 +24 @@
 
         Run("cresharp")
-        # xxx should check number of traces
-#        Run("echo $tottrcs")
+        self.assertEqual(int(System.dsptrcs), 1)
 
 def suite():

SHX/trunk/src/SeismicHandler/tests/test_traces.py

@@ -13 +13 @@
         self.traces = Traces()
         # count starts from one!
-        self.trace = self.traces[1]
+        self.trace = self.traces[0]
 
     def tearDown(self):