def _simulation_from_element(element):
"""Return a simulation.Simulation from a <Simul> element."""
if element is not None:
# entite can be a Sitehydro or a Stationhydro
entite = None
if element.find('CdSiteHydro') is not None:
entite = _sitehydro.Sitehydro(
code=_value(element, 'CdSiteHydro')
)
elif element.find('CdStationHydro') is not None:
entite = _sitehydro.Stationhydro(
code=_value(element, 'CdStationHydro')
)
# make the Simulation
return _simulation.Simulation(
entite=entite,
modeleprevision=_modeleprevision.Modeleprevision(
code=_value(element, 'CdModelePrevision')
),
grandeur=_value(element, 'GrdSimul'),
statut=_value(element, 'StatutSimul', int),
qualite=int(_value(element, 'IndiceQualiteSimul', float)), # int(float())
public=_value(element, 'PubliSimul', bool),
commentaire=_value(element, 'ComSimul'),
dtprod=_value(element, 'DtProdSimul', _UTC),
previsions=_previsions_from_element(element.find('Prevs'))
)
def test_error_03(self):
"""Stations error."""
code = 'B4401122'
stations = (sitehydro.Stationhydro(code='%s01' % code),
sitehydro.Stationhydro(code='%s02' % code))
sitehydro.Sitehydro(**{'code': code, 'stations': stations})
self.assertRaises(TypeError, sitehydro.Sitehydro, **{
'code': code,
'stations': ['station']
})
self.assertRaises(
ValueError, sitehydro.Sitehydro, **{
'code': code,
'typesite': 'PONCTUEL',
'stations': stations
})
self.assertRaises(
ValueError, sitehydro.Sitehydro, **{
'code': code,
'typesite': 'FICTIF',
'stations': stations
})
self.assertRaises(
ValueError, sitehydro.Sitehydro, **{
'code': code,
'typesite': 'VIRTUEL',
'stations': stations
})
def _serie_from_element(element):
"""Return a obshydro.Serie from a <Serie> element."""
if element is not None:
# entite can be a Sitehydro, a Stationhydro or a Capteur
entite = None
if element.find('CdSiteHydro') is not None:
entite = _sitehydro.Sitehydro(
code=_value(element, 'CdSiteHydro')
)
elif element.find('CdStationHydro') is not None:
entite = _sitehydro.Stationhydro(
code=_value(element, 'CdStationHydro')
)
elif element.find('CdCapteur') is not None:
entite = _sitehydro.Capteur(
code=_value(element, 'CdCapteur')
)
# make the Serie
return _obshydro.Serie(
entite=entite,
grandeur=_value(element, 'GrdSerie'),
statut=_value(element, 'StatutSerie'),
observations=_observations_from_element(element.find('ObssHydro'))
)
def test_error_01(self):
"""Typesite error."""
code = 'H0001010'
s = sitehydro.Sitehydro(**{'code': code, 'typesite': 'REEL'})
self.assertRaises(TypeError, s.__setattr__, *('typesite', None))
self.assertRaises(ValueError, sitehydro.Sitehydro, **{
'code': code,
'typesite': 'REEEL'
})
def test_error_02(self):
"""Code error."""
code = 'B4401122'
sitehydro.Sitehydro(**{'code': code})
self.assertRaises(TypeError, sitehydro.Sitehydro, **{'code': None})
self.assertRaises(ValueError, sitehydro.Sitehydro,
**{'code': '%s01' % code})
self.assertRaises(ValueError, sitehydro.Sitehydro,
**{'code': code[:-1]})
def test_fuzzy_mode_02(self):
"""Fuzzy mode test."""
code = '3'
typesite = '6'
stations = [1, 2, 3]
s = sitehydro.Sitehydro(typesite=typesite,
code=code,
stations=stations,
strict=False)
self.assertEqual((s.typesite, s.code, s.stations),
(typesite, code, stations))
def xml_unitaire(self, station, scenario, modele="GRP", QH="Q"):
u"""construit le xml format Sandre pour lecture dans l'EAO,
pour les paramètres station, modele, scenario souhaités
Paramètres :
- station code de la station
- scenario libellé du scénario modèle
- modele défaut "GRP" modèle à exporter. (GRP slmt pour le moment)
- QH défaut "Q" unité, "Q" ou "H"
"""
#construction série du même format que libhydro.simulation.Previsions
#double index [dte, prb]
if QH == "Q":
cols = ["Qprev","q10","q90"]
conv = 1000 #conversion Q des m3/s aux l/s
entite = entite = LbHsitehydro.Sitehydro(code=station)
elif QH == "H":
cols = ["Hprev","h10","h90"]
conv = 10 #conversion H des cm aux mm
entite = LbHsitehydro.Stationhydro(code=station
+STATIONS.loc[station,"suffixe_st"])
prv = self.GRPprev.loc[(station,scenario),cols].dropna()
prv.rename(columns=dict(zip(cols,[50,0,100])),inplace=True)
prv = prv.stack()
prv.index.names = ["dte","prb"]
prv *= conv #gestion unité
type_modele = "76gGRPt000"
commentaire = trim(
"""{{ContexteSimul}}
{{CodeScenarioSimul}}{}_{}{{/CodeScenarioSimul}}
{{DtBaseSimul}}{}{{/DtBaseSimul}}
{{/ContexteSimul}}"""
.format(modele,scenario,
dt.strftime(self.t_prev,"%Y-%m-%dT%H:%M:%S"))
)
simul = LbHsimulation.Simulation(
entite=entite,
grandeur=QH,
modeleprevision = LbHmodeleprevision.Modeleprevision(type_modele),
public=False,
intervenant = self.SACN,
dtprod=self.t_prev, #date dernière obs, voir doc EAO
previsions = prv,
commentaire = commentaire
)
return simul, prv
def test_base_02(self):
"""Site with 1 station."""
code = 'A3334550'
typesite = 'MAREGRAPHE'
libelle = 'La Saône [apres la crue] a Montelimar [he oui]'
stations = sitehydro.Stationhydro(code='%s01' % code,
typestation='LIMNI')
s = sitehydro.Sitehydro(code=code,
typesite=typesite,
libelle=libelle,
stations=stations)
self.assertEqual((s.code, s.typesite, s.libelle, s.stations),
(code, typesite, libelle, [stations]))
def _sitehydro_from_element(element):
"""Return a sitehydro.Sitehydro from a <SiteHydro> element."""
if element is not None:
# prepare args
args = {}
args['code'] = _value(element, 'CdSiteHydro')
args['libelle'] = _value(element, 'LbSiteHydro')
args['stations'] = [
_stationhydro_from_element(e)
for e in element.findall('StationsHydro/StationHydro')
]
typesite = _value(element, 'TypSiteHydro')
if typesite is not None:
args['typesite'] = typesite
# build Site
return _sitehydro.Sitehydro(**args)
def test_base_03(self):
"""Site with n station."""
code = 'A3334550'
typesite = 'REEL'
libelle = 'La Saône [apres la crue] a Montelimar [hé oui]'
stations = (sitehydro.Stationhydro(code='%s01' % code,
typestation='DEB'),
sitehydro.Stationhydro(code='%s02' % code,
typestation='LIMNIMERE'),
sitehydro.Stationhydro(code='%s03' % code,
typestation='LIMNIFILLE'))
s = sitehydro.Sitehydro(code=code,
typesite=typesite,
libelle=libelle,
stations=stations)
self.assertEqual((s.code, s.typesite, s.libelle, s.stations),
(code, typesite, libelle, [s for s in stations]))
def test_base_01(self):
"""Serie on a site."""
s = sitehydro.Sitehydro(code='A0445810',
libelle='Le Rhône à Marseille')
g = 'Q'
t = 16
o = obshydro.Observations(obshydro.Observation('2012-10-03 06:00', 33),
obshydro.Observation('2012-10-03 07:00', 37),
obshydro.Observation('2012-10-03 08:00', 42))
i = True
serie = obshydro.Serie(entite=s,
grandeur=g,
statut=t,
observations=o,
strict=i)
self.assertEqual((serie.entite, serie.grandeur, serie.statut,
serie.observations, serie._strict), (s, g, t, o, i))
def test_base_04(self):
"""Update stations attribute."""
code = 'A3334550'
typesite = 'REEL'
libelle = 'La Saône [apres la crue] a Montelimar [hé oui]'
stations = [
sitehydro.Stationhydro(code='%s01' % code, typestation='DEB')
]
s = sitehydro.Sitehydro(code=code,
typesite=typesite,
libelle=libelle,
stations=stations)
self.assertEqual(s.stations, stations)
s.stations = None
self.assertEqual(s.stations, [])
s.stations = stations[0]
self.assertEqual(s.stations, stations)
s.stations = stations
self.assertEqual(s.stations, stations)
def test_base_01(self):
"""Empty site."""
code = 'R5330101'
s = sitehydro.Sitehydro(code=code)
self.assertEqual((s.code, s.typesite, s.libelle, s.stations),
(code, 'REEL', None, []))
def test_fuzzy_mode_01(self):
"""Fuzzy mode test with None values."""
code = stations = None
s = sitehydro.Sitehydro(code=code, stations=stations, strict=False)
self.assertEqual((s.typesite, s.code, s.stations), ('REEL', code, []))
def test_str_02(self):
"""Test __str__ with unicode."""
s = sitehydro.Sitehydro(code='A0445533')
s.libelle = 'ℓα gαяσηηє à тσυℓσυѕє'
s.__unicode__()
s.__str__()
def test_str_01(self):
"""Test __str__ method with None values."""
s = sitehydro.Sitehydro(code=0, strict=False)
self.assertTrue(s.__str__().rfind('Site') > -1)
