Merge pull request #962 from joakim-hove/empty__init

Emptied the opm/__init__.py file and create opm.parser package

python/python/opm/__init__.py

@@ -1,10 +0,0 @@
-from __future__ import absolute_import
-
-from .schedule            import Well, Connection, Schedule
-from .libopmcommon_python import action
-from .config     import EclipseConfig
-from .parser     import parse, parse_string
-
-
-__version__     = '0.1.2'
-__license__     = 'GNU General Public License version 3'

python/python/opm/_common.py

@@ -0,0 +1,6 @@
+from __future__ import absolute_import
+from .libopmcommon_python import action
+
+#from .schedule            import Well, Connection, Schedule
+#from .config     import EclipseConfig
+#from .parser     import parse, parse_string

python/python/opm/parser/__init__.py

@@ -0,0 +1,3 @@
+from opm._common import action
+
+from .parser import parse, load_deck, load_deck_string, parse_string

python/python/opm/tools/time_vector.py

@@ -6,7 +6,7 @@ except ImportError:
     from io import StringIO
 
 
-import opm.deck
+from opm.parser import load_deck, load_deck_string
 
 # This is from the TimeMap.cpp implementation in opm
 ecl_month = {"JAN" : 1,
@@ -213,11 +213,11 @@ class TimeVector(object):
         self._add_dates_block(ts)
         start_dt = datetime.datetime(start_date.year, start_date.month, start_date.day)
         if base_file:
-            deck = opm.deck.parse(base_file)
+            deck = load_deck(base_file)
             self._add_deck(deck, start_dt)
 
         if base_string:
-            deck = opm.deck.parse_string(base_string)
+            deck = load_deck_string(base_string)
             self._add_deck(deck, start_dt)
 
 
@@ -328,7 +328,7 @@ class TimeVector(object):
             tv.load("well.sch", date = datetime.datetime(2017, 4, 1))
 
         """
-        deck = opm.deck.parse(filename)
+        deck = load_deck(filename)
         self._add_deck(deck, date)
 
 
@@ -336,7 +336,7 @@ class TimeVector(object):
         """
         Like load() - but load from a string literal instead of file.
         """
-        deck = opm.deck.parse_string(deck_string)
+        deck = load_deck_string(deck_string)
         self._add_deck(deck, date)
 
 

python/setup.py

@@ -75,8 +75,8 @@ setup(
     package_dir = {'': 'python'},
     packages=[
                 'opm',
-                'opm.tools',
+                'opm.parser',
-                'opm.deck',
+                'opm.tools'
             ],
     ext_modules=ext_modules,
     package_data={

python/tests/test_connection.py

@@ -1,11 +1,11 @@
 import unittest
-import opm
+import opm.parser
 
 class TestWells(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.sch = opm.parse('tests/spe3/SPE3CASE1.DATA').schedule 
+        cls.sch = opm.parser.parse('tests/spe3/SPE3CASE1.DATA').schedule 
         cls.timesteps = cls.sch.timesteps
 
     def test_connection_pos(self):
@@ -26,8 +26,8 @@ class TestWells(unittest.TestCase):
                     self.assertEqual("OPEN", connection.state)
 
     def test_filters(self):
-        flowing = opm.Connection.flowing()
+        flowing = opm.parser.schedule.Connection.flowing()
-        closed = opm.Connection.closed()
+        closed = opm.parser.schedule.Connection.closed()
         connections = self.sch.get_wells(0)[0].connections()
         self.assertEqual(len(list(filter(flowing, connections))), 2)
         self.assertEqual(len(list(filter(closed, connections))), 0)

python/tests/test_deck.py

@@ -1,5 +1,5 @@
 import unittest
-import opm.deck
+from opm.parser import load_deck_string
 
 class TestParse(unittest.TestCase):
 
@@ -27,7 +27,7 @@ FIPNUM
 """
 
     def setUp(self):
-        self.deck = opm.deck.parse_string(self.DECK_STRING)
+        self.deck = load_deck_string(self.DECK_STRING)
 
     def test_deck_in(self):
         map(lambda kw: self.assertIn(kw, self.deck), [
@@ -49,7 +49,7 @@ FIPNUM
             str(self.deck['DX']).split()
         )
         self.assertEqual(
-            str(opm.deck.parse_string('RUNSPEC\n\nDX\n4*0.5 /')).split(),
+            str(load_deck_string('RUNSPEC\n\nDX\n4*0.5 /')).split(),
             'RUNSPEC DX 0.5 0.5 0.5 0.5 /'.split()
         )
 

python/tests/test_group_tree.py

@@ -1,12 +1,12 @@
 import sys
 import unittest
 
-import opm
+import opm.parser
 
 class TestGroupTree(unittest.TestCase):
     def setUp(self):
         norne = 'examples/data/norne/NORNE_ATW2013.DATA'
-        self.sch = opm.parse(norne, [('PARSE_RANDOM_SLASH', opm.action.ignore)]).schedule
+        self.sch = opm.parser.parse(norne, [('PARSE_RANDOM_SLASH', opm.parser.action.ignore)]).schedule
 
     def test_group(self):
         gr = self.sch.group(timestep=2)['PROD']
@@ -35,7 +35,7 @@ class TestGroupTree(unittest.TestCase):
         group = self.sch.group(timestep=3)['PROD']
         children = ['MANI-B1', 'MANI-B2', 'MANI-D1', 'MANI-D2', 'MANI-E1', 'MANI-E2']
         names = [child.name for child in group.children]
-        self.assertEqual(opm.schedule.Group, type(child))
+        self.assertEqual(opm.parser.schedule.Group, type(child))
         self.assertEqual(set(children), set(names))
 
 if __name__ == '__main__':

python/tests/test_grupnet.py

@@ -1,13 +1,13 @@
 import sys
 import unittest
 
-import opm
+import opm.parser
 
 class TestGrupnet(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         norne = 'examples/data/norne/NORNE_ATW2013.DATA'
-        cls.sch = opm.parse(norne, [('PARSE_RANDOM_SLASH', opm.action.ignore)]).schedule
+        cls.sch = opm.parser.parse(norne, [('PARSE_RANDOM_SLASH', opm.parser.action.ignore)]).schedule
 
     def test_vfp_table(self):
         self.assertEqual(0, self.sch.group(timestep=0)['PROD'].vfp_table_nr)

python/tests/test_parse.py

@@ -1,5 +1,5 @@
 import unittest
-import opm
+import opm.parser
 import os.path
 import sys
 
@@ -33,28 +33,28 @@ FIPNUM
         self.norne_fname = os.path.abspath('examples/data/norne/NORNE_ATW2013.DATA')
 
     def test_parse(self):
-        spe3 = opm.parse(self.spe3fn)
+        spe3 = opm.parser.parse(self.spe3fn)
         self.assertEqual('SPE 3 - CASE 1', spe3.state.title)
 
     def test_parse_with_recovery(self):
-        recovery = [("PARSE_RANDOM_SLASH", opm.action.ignore)]
+        recovery = [("PARSE_RANDOM_SLASH", opm.parser.action.ignore)]
-        spe3 = opm.parse(self.spe3fn, recovery=recovery)
+        spe3 = opm.parser.parse(self.spe3fn, recovery=recovery)
 
     def test_parse_with_multiple_recoveries(self):
-        recoveries = [ ("PARSE_RANDOM_SLASH", opm.action.ignore),
+        recoveries = [ ("PARSE_RANDOM_SLASH", opm.parser.action.ignore),
-                       ("FOO", opm.action.warn),
+                       ("FOO", opm.parser.action.warn),
-                       ("PARSE_RANDOM_TEXT", opm.action.throw) ]
+                       ("PARSE_RANDOM_TEXT", opm.parser.action.throw) ]
 
-        spe3 = opm.parse(self.spe3fn, recovery=recoveries)
+        spe3 = opm.parser.parse(self.spe3fn, recovery=recoveries)
 
     def test_throw_on_invalid_recovery(self):
         recoveries = [ ("PARSE_RANDOM_SLASH", 3.14 ) ]
 
         with self.assertRaises(TypeError):
-            opm.parse(self.spe3fn, recovery=recoveries)
+            opm.parser.parse(self.spe3fn, recovery=recoveries)
 
         with self.assertRaises(TypeError):
-            opm.parse(self.spe3fn, recovery="PARSE_RANDOM_SLASH")
+            opm.parser.parse(self.spe3fn, recovery="PARSE_RANDOM_SLASH")
 
     def test_data(self):
         pass
@@ -62,7 +62,7 @@ FIPNUM
         #self.assertEqual([3,3,1,2], regtest.props()['OPERNUM'])
 
     def test_parse_norne(self):
-         state = opm.parse(self.norne_fname, recovery=[('PARSE_RANDOM_SLASH', opm.action.ignore)])
+         state = opm.parser.parse(self.norne_fname, recovery=[('PARSE_RANDOM_SLASH', opm.parser.action.ignore)])
          es = state.state
          self.assertEqual(46, es.grid().getNX())
          self.assertEqual(112, es.grid().getNY())

python/tests/test_parse_deck.py

@@ -1,6 +1,6 @@
 import unittest
 import opm
-import opm.deck
+import opm.parser
 import os.path
 
 class TestParse(unittest.TestCase):
@@ -55,22 +55,18 @@ FIPNUM
 
     def test_IOError(self):
         with self.assertRaises(IOError):
-            opm.parse("file/not/found")
+            opm.parser.load_deck("file/not/found")
-
-        with self.assertRaises(IOError):
-            opm.deck.parse("/file/not/found")
-
 
 
     def test_parser_fail_without_extension(self):
-        error_recovery = [("PARSE_RANDOM_SLASH", opm.action.ignore)]
+        error_recovery = [("PARSE_RANDOM_SLASH", opm.parser.action.ignore)]
         with self.assertRaises(ValueError):
-            opm.deck.parse_string(self.DECK_ADDITIONAL_KEYWORDS,
+            opm.parser.load_deck_string(self.DECK_ADDITIONAL_KEYWORDS,
                                         recovery=error_recovery )
 
     def test_parser_extension(self):
-        error_recovery = [("PARSE_RANDOM_SLASH", opm.action.ignore)]
+        error_recovery = [("PARSE_RANDOM_SLASH", opm.parser.action.ignore)]
-        deck = opm.deck.parse_string(self.DECK_ADDITIONAL_KEYWORDS,
+        deck = opm.parser.load_deck_string(self.DECK_ADDITIONAL_KEYWORDS,
                                            keywords=self.KEYWORDS,
                                            recovery=error_recovery )
         self.assertIn( 'TESTKEY0', deck )

python/tests/test_props.py

@@ -1,5 +1,5 @@
 import unittest
-import opm
+import opm.parser
 
 class TestProps(unittest.TestCase):
 
@@ -9,7 +9,7 @@ class TestProps(unittest.TestCase):
         self.assertTrue(diff <= epsilon, msg=err_msg)
 
     def setUp(self):
-        self.spe3 = opm.parse('tests/spe3/SPE3CASE1.DATA').state
+        self.spe3 = opm.parser.parse('tests/spe3/SPE3CASE1.DATA').state
         self.props = self.spe3.props()
 
     def test_repr(self):

python/tests/test_schedule.py

@@ -1,13 +1,14 @@
 import unittest
 import datetime as dt
-import opm
 
+import opm.parser.schedule
+from opm.parser import parse
 
 class TestSchedule(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.sch = opm.parse('tests/spe3/SPE3CASE1.DATA').schedule
+        cls.sch = parse('tests/spe3/SPE3CASE1.DATA').schedule
 
     def testWells(self):
         self.assertEqual(2, len(self.sch.get_wells(0)))
@@ -36,8 +37,8 @@ class TestSchedule(unittest.TestCase):
 
         def head(xs): return next(iter(xs))
 
-        inje = head(filter(opm.Well.injector(), g1))
+        inje = head(filter(opm.parser.schedule.Well.injector(), g1))
-        prod = head(filter(opm.Well.producer(), g1))
+        prod = head(filter(opm.parser.schedule.Well.producer(), g1))
 
         self.assertEqual(self.sch.get_well('INJ', 0).isinjector(),  inje.isinjector())
         self.assertEqual(self.sch.get_well('PROD', 0).isproducer(), prod.isproducer())

python/tests/test_state.py

@@ -1,5 +1,5 @@
 import unittest
-import opm
+import opm.parser
 
 class TestState(unittest.TestCase):
     FAULTS_DECK = """
@@ -49,8 +49,8 @@ SATNUM
 
     @classmethod
     def setUpClass(cls):
-        cls.spe3 = opm.parse('tests/spe3/SPE3CASE1.DATA')
+        cls.spe3 = opm.parser.parse('tests/spe3/SPE3CASE1.DATA')
-        cpa = opm.parse('tests/data/CORNERPOINT_ACTNUM.DATA')
+        cpa = opm.parser.parse('tests/data/CORNERPOINT_ACTNUM.DATA')
         cls.state = cls.spe3.state
         cls.cp_state = cpa.state
 
@@ -124,7 +124,7 @@ SATNUM
     def test_faults(self):
         self.assertEquals([], self.state.faultNames())
         self.assertEquals({}, self.state.faults())
-        faultdeck = opm.parse_string(self.FAULTS_DECK).state
+        faultdeck = opm.parser.parse_string(self.FAULTS_DECK).state
         self.assertEqual(['F1', 'F2'], faultdeck.faultNames())
         # 'F2'  5  5  1  4   1  4  'X-' / \n"
         f2 = faultdeck.faultFaces('F2')
@@ -139,7 +139,7 @@ SATNUM
         # jf["OIL_WATER"]    = 21.0   # set in deck
         # jf["GAS_OIL"]      = -1.0   # N/A
 
-        js = opm.parse('tests/data/JFUNC.DATA').state
+        js = opm.parser.parse('tests/data/JFUNC.DATA').state
         self.assertEqual('JFUNC TEST', js.title)
         jf = js.jfunc()
         print(jf)
@@ -167,7 +167,7 @@ JFUNC
   GAS * 13.0 0.6 0.7 Z /
 PROPS\nREGIONS
 """
-        js_gas = opm.parse_string(jfunc_gas).state
+        js_gas = opm.parser.parse_string(jfunc_gas).state
         jf = js_gas.jfunc()
         self.assertEqual(jf['FLAG'], 'GAS')
         self.assertEqual(jf['DIRECTION'], 'Z')

python/tests/test_time_vector.py

@@ -1,8 +1,7 @@
 import unittest
 import datetime
 from opm.tools import *
-import opm.deck
+from opm.parser import load_deck_string, load_deck
-
 from utils import tmp
 class TestTimeVector(unittest.TestCase):
 
@@ -120,7 +119,7 @@ class TestTimeVector(unittest.TestCase):
     def test_no_leading_DATES(self):
         tv = TimeVector(datetime.date(1997, 11, 6), base_file="tests/data/schedule/part1.sch")
         s = str(tv)
-        d = opm.deck.parse_string(s)
+        d = load_deck_string(s)
         kw0 = d[0]
         self.assertEqual(kw0.name, "WELSPECS")
 

python/tests/test_wells.py

@@ -1,19 +1,20 @@
 import unittest
 import opm
+from opm.parser import parse
 
 class TestWells(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.sch = opm.parse('tests/spe3/SPE3CASE1.DATA').schedule
+        cls.sch = parse('tests/spe3/SPE3CASE1.DATA').schedule
         cls.timesteps = cls.sch.timesteps
 #        cls.wells = cls.sch.wells
 
     def inje(self, wells):
-        return next(iter(filter(opm.Well.injector(), wells)))
+        return next(iter(filter(opm.parser.schedule.Well.injector(), wells)))
 
     def prod(self, wells):
-        return next(iter(filter(opm.Well.producer(), wells)))
+        return next(iter(filter(opm.parser.schedule.Well.producer(), wells)))
 
     def testWellPos0(self):
         wells = self.sch.get_wells(0)
@@ -63,14 +64,14 @@ class TestWells(unittest.TestCase):
         self.assertTrue(prod.available_gctrl())
 
     def testWellDefinedFilter(self):
-        defined0 = list(filter(opm.Well.defined(0), self.sch.get_wells(0) ))
+        defined0 = list(filter(opm.parser.schedule.Well.defined(0), self.sch.get_wells(0) ))
-        defined1 = list(filter(opm.Well.defined(1), self.sch.get_wells(1) ))
+        defined1 = list(filter(opm.parser.schedule.Well.defined(1), self.sch.get_wells(1) ))
         self.assertEqual(len(list(defined0)), 2)
         self.assertEqual(len(list(defined1)), 2)
 
     def testWellProdInjeFilter(self):
-        inje = list(filter(opm.Well.injector(), self.sch.get_wells(0) ))
+        inje = list(filter(opm.parser.schedule.Well.injector(), self.sch.get_wells(0) ))
-        prod = list(filter(opm.Well.producer(), self.sch.get_wells(0) ))
+        prod = list(filter(opm.parser.schedule.Well.producer(), self.sch.get_wells(0) ))
 
         self.assertEqual(len(inje), 1)
         self.assertEqual(len(prod), 1)
@@ -81,15 +82,15 @@ class TestWells(unittest.TestCase):
     def testOpenFilter(self):
         wells = self.sch.get_wells(1)
 
-        open_at_1 = opm.Well.flowing()
+        open_at_1 = opm.parser.schedule.Well.flowing()
         flowing = list(filter(open_at_1, wells))
         closed  = list(filter(lambda well: not open_at_1(well), wells))
 
         self.assertEqual(2, len(flowing))
         self.assertEqual(0, len(closed))
 
-        flowing1 = filter(lambda x: not opm.Well.closed()(x), wells)
+        flowing1 = filter(lambda x: not opm.parser.schedule.Well.closed()(x), wells)
-        closed1  = filter(opm.Well.closed(), wells)
+        closed1  = filter(opm.parser.schedule.Well.closed(), wells)
         self.assertListEqual(list(closed), list(closed1))
 
     def testCompletions(self):