OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #962 from joakim-hove/empty__init

Browse Source 
Emptied the opm/__init__.py file and create opm.parser package
This commit is contained in:
Joakim Hove 2019-08-20 16:19:59 +02:00 committed by GitHub
commit 441b065b3d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 75 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
python/python/opm/__init__.py
View File

@ -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'

6
python/python/opm/_common.py Normal file
View File

@ -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

3
python/python/opm/parser/__init__.py Normal file
View File

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

0
python/python/opm/config.py → python/python/opm/parser/config.py
View File

0
python/python/opm/deck/__init__.py → python/python/opm/parser/deck/__init__.py
View File

0
python/python/opm/parser.py → python/python/opm/parser/parser.py
View File

0
python/python/opm/properties.py → python/python/opm/parser/properties.py
View File

0
python/python/opm/schedule.py → python/python/opm/parser/schedule.py
View File

0
python/python/opm/sunbeam.py → python/python/opm/parser/sunbeam.py
View File

10
python/python/opm/tools/time_vector.py
View File

@ -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)

4
python/setup.py
View File

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

8
python/tests/test_connection.py
View File

@ -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()
closed = opm.Connection.closed()
flowing = opm.parser.schedule.Connection.flowing()
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)

6
python/tests/test_deck.py
View File

@ -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()
)

6
python/tests/test_group_tree.py
View File

@ -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__':

4
python/tests/test_grupnet.py
View File

@ -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)

22
python/tests/test_parse.py
View File

@ -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)]
spe3 = opm.parse(self.spe3fn, recovery=recovery)
recovery = [("PARSE_RANDOM_SLASH", opm.parser.action.ignore)]
spe3 = opm.parser.parse(self.spe3fn, recovery=recovery)
def test_parse_with_multiple_recoveries(self):
recoveries = [ ("PARSE_RANDOM_SLASH", opm.action.ignore),
("FOO", opm.action.warn),
("PARSE_RANDOM_TEXT", opm.action.throw) ]
recoveries = [ ("PARSE_RANDOM_SLASH", opm.parser.action.ignore),
("FOO", opm.parser.action.warn),
("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())

22
python/tests/test_parse_deck.py
View File

@ -1,6 +1,6 @@
import unittest
import opm
import opm.deck
import opm.parser
import os.path
class TestParse(unittest.TestCase):
@ -55,24 +55,20 @@ FIPNUM
def test_IOError(self):
with self.assertRaises(IOError):
opm.parse("file/not/found")
with self.assertRaises(IOError):
opm.deck.parse("/file/not/found")
opm.parser.load_deck("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,
recovery=error_recovery )
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)]
deck = opm.deck.parse_string(self.DECK_ADDITIONAL_KEYWORDS,
keywords=self.KEYWORDS,
recovery=error_recovery )
error_recovery = [("PARSE_RANDOM_SLASH", opm.parser.action.ignore)]
deck = opm.parser.load_deck_string(self.DECK_ADDITIONAL_KEYWORDS,
keywords=self.KEYWORDS,
recovery=error_recovery )
self.assertIn( 'TESTKEY0', deck )
self.assertIn( 'TESTKEY1', deck )
self.assertIn( 'TESTKEY2', deck )

4
python/tests/test_props.py
View File

@ -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):

9
python/tests/test_schedule.py
View File

@ -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))
prod = head(filter(opm.Well.producer(), g1))
inje = head(filter(opm.parser.schedule.Well.injector(), 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())

12
python/tests/test_state.py
View File

@ -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')
cpa = opm.parse('tests/data/CORNERPOINT_ACTNUM.DATA')
cls.spe3 = opm.parser.parse('tests/spe3/SPE3CASE1.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')

5
python/tests/test_time_vector.py
View File

@ -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")

23
python/tests/test_wells.py
View File

@ -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) ))
defined1 = list(filter(opm.Well.defined(1), self.sch.get_wells(1) ))
defined0 = list(filter(opm.parser.schedule.Well.defined(0), self.sch.get_wells(0) ))
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) ))
prod = list(filter(opm.Well.producer(), self.sch.get_wells(0) ))
inje = list(filter(opm.parser.schedule.Well.injector(), 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)
@ -79,17 +80,17 @@ class TestWells(unittest.TestCase):
self.assertEqual(prod[0].name, "PROD")
def testOpenFilter(self):
wells = self.sch.get_wells(1)
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)
closed1 = filter(opm.Well.closed(), wells)
flowing1 = filter(lambda x: not opm.parser.schedule.Well.closed()(x), wells)
closed1 = filter(opm.parser.schedule.Well.closed(), wells)
self.assertListEqual(list(closed), list(closed1))
def testCompletions(self):