G#l`M iMsGuFMQ)fS/ocT9_ˆ2ĩRd$z1
]K+EAGOM4i9G5sB45(B=?٢FQfh
@
E.b =
RDA
Vjʉ! bn\DQeV#M:
2vf&ȬXĐ
u0$)"X٬`a1r>B&QL8Y^y)"h\FV@" +ȦIwV6RE1j1^ ]SɼAu^u|%%Ź7zAߏb0ȰhaGIBf}{K!rxIYjв]ԟD{w_vS.%.='x7OOpekWOpoc 7UAa.
.O On[OE\ eumdac-3.0.0/tests/data/test_datatailor.TestDataTailor.pickle.gz 0000664 0000000 0000000 00000010656 14720105632 0024711 0 ustar 00root root 0000000 0000000 gtest_datatailor.TestDataTailor.pickle ]}u?I%ٲdqSq[~מ&m: $#uTv 9} A?E6HJhEIE(Т )
͐%w{]jG!gޛ7o coԞ0D E%Ӗkx5i:Z@ZTzį LS]*ά@&; :{x[Dڵ7k֪242A"+hִo`V G^F-Ӗ,du9W@?Ҩb)xYVEj&UtUŒ@ r]:TMDeY͒ss%#i:ʥIo> D
+5I %Q~|[1Td)hN %NyXr/N\8$]ӜMD* N0WZ'hKM SKmEHRFJJQTZtH> 5CZ"@(\<.hb7aX[[[ɒnV0 61Widp1iK*#3[6fڴX%]P:
9;iS.#1'DCfX?AznZN5G+8A'HtfIfk{02j~ V2 ba>HeSImbS))7<5U68îT m)DEyTPUh^ @0أ3T4LaE)bQե
,/@hѷ|ꨨ[?D.;5{S -2;S6fl]t/ /Ԕ~p挬X;務lHJL֡
V 3'H[
=BBf:=n)HM@K!@V0&ƹw@6AԆVW';qjwd9&||ra4\< ΡlfV*%T
" 1T0MmCe@ '39h}BME6/kWEΐxe{x3pv&LZ&YB6\~q&/<{f6oaȃ.mmB"Ǚd :
'uVGu1u5 j)Nzg?, IeZ'5=X#~|'0:sPP }َ<뿡 MR*qf\A Fl>P u B:yF`Em{)`7 +ąqMNԍkKkKN`Z2C7$3μ+h93ٙtA$Ֆ
"734y
dc V) zasc5@ä^}
ynQ#cdҭ}"O!i^BsZ Gȣam"(8ys"O>yL0dz"3n& ǢiKn w)y݄"'1)TLEs0WBK3)!3QW >wK_?8'x2*`0 L%%S(d`jճ$8B>*1HDCH
B\wT)Ww- ;ͅ$$9LlUsi(3[-n &zB-:ַ֟
T"/ߴP/ [5/ǯ]/W?{%1Inc!ij+ܴ|2 mu{`&jo ƥw l݀yGL}#(^1F qlddz\ ]Fgb}NY@XDxV
CwSk{[l"(զ0,6YJFlxE\, iIDtVMbm*vf;&
)Q5sO9&luJFن Deg)Qb6G~gu^{P.u"F=$=yMj6Z 4whGR1
KԆ嫃5,ay/Ed(" Z60/>p$DJQHXn7=fUk+l"զA
)J! -6r";&3'Th QLڡ3r;YB:=.K`yg 59*
$i9
O G% i+4gVڴ,EY
\W+\!C+om$l9 Q l3@[lwđ.N_r1vv SW}+X9ہ
%R C`wkEW'X_wF Ĭkn43]?[Ya1}E2m E ,Riv4$,lϏ%g|f [0eŬ Qr+Q-öZ)J6Byoz.z)qN<O:tzc8v,zr;tw,Cea9x<
ڟƦ8H:'<4zdCsPM/]S4g@dT1TdtEz Ҵ3_5[wz%ͥGnyW(*; or ȩ%sGԒx5뮿 +;އ 51N7cQ ՞?$>nЛ w''"_1Axn|JG{?u^ 6/<+=! j'ZǺQ-wqLoFһr\tYs Q
i,K
0ڛ͙7t{űA7': sxR1ƅ1: G c,*Aa:8*͡A GР<y;~}'h Ǿn"3Fftk:؝<5k=?9P 5~prd?w7Wm9( ~^=?~N&ħy>1qiI<a}x2@Ǚq&gdĝ ͙G
7';sXa"> (z[ƶE%"M/L*ˤgT`uaaJ,\efS\>?wMB2׆!u o>9%3c/Nv Ait>qP1}H煕 >n&NA? ~埃
}?~rpGzzW$6{o>G =zw
3Xx5@.KmIVXMq93sw. s{=ocnHnb6@xĖkУ:& ZsO9'mXDJ ;c!;hv7# |8ed;&]}3WvG]kNd{你Ꮆtԝ\3f7-۔~_X;pgdnY]^LDPEQb m t{IeIR<K+c hX' \ a[DwP1
F S6(~T&:1wb;k po慹y@8(|$:=kn
EIe
Kۄ^e( 8c>;>ov&%V 7Q
7ĉqIH6SNfl2]Y(4[}
kEvX߸D mG[B `BKF`-
Bx F ax%!. 3$2 O% ׇrz(w -!j$k)6sa:(m-a @ׁ
JaABe?sϜs4zX5CM[`h?Bmb19=̉⻜I#*Ƽ "g QI ˝in sW zG`ہ!>V|re\-C? 7vR! R%5RCq"ÂkNKLs #^3#x+,#;#DSWuL3F`&q1.&"YXq:W\]B˵+yuV|RJY SoiALP ;4o&Igh? h/j ouTo7EBy}XG~@H0G.
DphF!a@ GGn2 E2iCSEM*) 0O s)EG`< ?uչȯ/ s<NGkxqirAhSE 4kqdY/Mr@m柈VZϕ
A)!dbۊ),@B"lp,MZoX]M&gN gAW`{ITh.Ku X7@hNb pPN6|!x&=?l_6<485==sse
=z/ » ,d|6 0g b,qWB|GxX/ƸJ.*zRŸ|\.)WBc݇0 :<ƽ/ _(6Fn e=W+'mLB>" ; )&? gYM 6_6
bn|ѠH!jxX5蘽'&N>"I]ΐHݦ {h[:IhO1>323_EA>?}/2LO yh7-|YE?]dxf䋯! vCr1_MpG-O@qsY}ZX
+2=uEa LܦX= zN
R7V rr: fE+Y0,kdfe+`v.$EWOٴs雍D?%n8#dxfv& OJL1/ mȦ\J
] `0% m:4-Gh|@RdU$ۀ컄rv}{!qv|o^ (%9d{K0~O yɛkEf-9F)QtM"lWmYݾPnP>W #H4v!{A{#16|xoD0oH `YAaEFb rnj_ 5j[*7봑 C"vU]4x =c߭HkJ'V8+h' .`P!btӗW PtƐ̰A`FjGb.H}2)ܰծ1WuN|˞?Ե/OA_İhTuĥǿRUo+Hn
8mDPN*]~+g+?Rk1+lH.J?F%R9Rj&3Dzdt }
~ʕR9w#T kc 8j=utDFo ycʃeuju/pB& UtnURzY(U@و&Q
e]g+bF_7l!M.vy Fo WbPwAu:Y
Pqxfl)=kR a
xp* J!'uVp/ԓl w_A9ܕ|>{ݝA 'I*_ c\0WNN+8 eumdac-3.0.0/tests/data/test_subscription.TestSubscription.pickle.gz 0000664 0000000 0000000 00000004707 14720105632 0025751 0 ustar 00root root 0000000 0000000 dtest_subscription.TestSubscription.pickle YKlqIAg2 Q~$@ٓ8N$vmJuS e;ں] c|<,-]ȉiwUl H6L}ulWq\tQ<2hwd6cXa16Lզ"lK-l8w&lKEJ<K$QwpN(rDl(+RZf[-+jVTPqUGfQP(qsT1
# TU-p6&8h*,M4T c2bvkڪ 4>{LȦ;:pLQƊC6\%sLxSٰ@Ǜb˼>,]Sŵ5jukla ڧ(8pak}2"$ߌދ ,Ҋ7$+1iQXi\Cvle˄mfA5N*ru'ҩ@;pUU%
b(&ܒ(yljpIU4Ά
LkŶVPEg+
፴{{sF Y3w'kx[,M:ٲMs;^]\Meb 6 sɆ_Q
ɭUL}~F#3sVt
l
o)_E5 z'd6 nXU @Bu.z._^]C
nt S3s _@@\> +C'ES*s #I%JDI)I+Ɍft&"UL 8 >%f%@ʕ1
x@p|* r\*3'HNS|k^:Lܨ "$dJHdd>X[#@PWI:[۠B\c5bn
Ζm&|>еbz0)[ N
Rn 6#pl l^ Ɵ*P$}bw@0͙uSm\=?yf[y~2nXh[dK?64UPZ7K Y\艼G\$ l ȇd3! hĽÉN"ش#&V( Wa/ F_1V"vNl9\~1\^n]]\,"D b"+,Q1D0f
B](_}\FG1b N3*tAEVXm}H|Dd(#
DTn +pB/ErTUR4)etT,Vd5Y :h:dlo.,f b *
D.!Mf2L: KgX25NO~?)!!S\M(K** ZNJlyꔰ)*E7yr: z#qOyݚI ,/یYr'K
~) u 2˙0w|/}(|\z*n| ,^u5 \4=0y@ <1gva"v]s | qpr"L4'ڀ5 RR65!M}/M D_л0nL;t@L_Dj13y& eumdac-3.0.0/tests/data/test_token.TestAccessToken.pickle.gz 0000664 0000000 0000000 00000003774 14720105632 0024066 0 ustar 00root root 0000000 0000000 #gtest_token.TestAccessToken.pickle Yof YeRl4naaeSt%
RL REݒsz'Q.4@}K6E } }Kٻ#EEeǎg@͒z8^Bթ,Iw 3 CԲ߆~n9pjbc. Ϡ֍wCp p \!\>?3C]sé6m1#mf0j0{ ߓ\\Bln
s-zʅ08;ta8ZpKftuץ>g Mf0{Kj`2>S.N+`;{'u
l1LZ,y'Լc,ռ\\? LJZ3/˙1ݱT ,s K8z?
`<1ZGs>wUA%(Ήn95 ϣeBNXn
@b"x3*s1j;u-Sҩ6%
k̇(,
81]< FgM( F_s-Uu6erMR'z.IlI#g{yɢ-T ..-Zz Gm<bta6Bu v01TU՞F=8x TzLV
EMA;3&,i 3f+ʾ36PгNpK1VL
U]V t黜#T5ѷ7Pj;#M_wBA24p *m!N^UOwk0ŞꢳP-)C%Nv
U+D̵z0F[K&\-FL&BJ0qa ҙ>1 wߺjR:/>!TѪUIeQ&E%U?ʊH ޘMqqӖWij$`$բ]k 1C)k&Oyj~
0ÕOa.D7"/C X y%lA)Ju7d?8lq>.yNr> $ch#a JxE0
gG=Gg"Ċsx m93>?[-[RU*|(jEP1KQktV<[ڞ^kRzMz횴=Vao!c.;#FqR9Ic(z|Cū1 eumdac-3.0.0/tests/test_cli.py 0000664 0000000 0000000 00000042214 14720105632 0016275 0 ustar 00root root 0000000 0000000 import io
import unittest
import re
import os
import datetime
import sys
from unittest.mock import patch, mock_open, MagicMock
import pytest
import eumdac
from eumdac.cli import cli
from eumdac.collection import Collection
from eumdac.errors import EumdacError
from eumdac.product import Product
def get_mock_collection(product_ids):
mock_stream = io.BytesIO(b"ProductBytes")
mock_stream.name = "MockProduct.zip"
mock_collection = MagicMock(spec=Collection)
mock_collection._id = "MockCollection"
mock_collection_search_products = []
for product_id in product_ids:
mock_product = MagicMock(spec=Product)
mock_product.open.return_value.__enter__.return_value = mock_stream
mock_product._id = product_id
mock_product.collection = mock_collection
mock_collection_search_products.append(mock_product)
mock_collection.search.return_value = mock_collection_search_products
return mock_collection
class CliExit(Exception):
pass
class CliError(Exception):
pass
class TestCommandLineInterface(unittest.TestCase):
credentials = ("abc", "xyz")
def setUp(self):
super().setUp()
self.patch_argv()
self.cli = cli
self.get_mock("argparse.ArgumentParser.exit", new=MagicMock(side_effect=CliExit))
self.mock_error = self.get_mock(
"argparse.ArgumentParser.error", new=MagicMock(side_effect=CliError)
)
self.mock_stdin = self.get_mock("eumdac.cli.sys.stdin", new_callable=mock_open())
self.mock_stdin.isatty.return_value = False
@pytest.fixture(autouse=True)
def propagate_pytest_fixtures(self, monkeypatch, tmp_path):
self.monkeypatch = monkeypatch
self.tmp_path = tmp_path
def patch_argv(self):
patcher = patch.object(sys, "argv", ["eumdac"])
patcher.start()
self.addCleanup(patcher.stop)
def get_mock(self, target, **kwargs):
patcher = patch(target, **kwargs)
mock = patcher.start()
self.addCleanup(patcher.stop)
return mock
@patch("eumdac.AccessToken")
@patch("pathlib.Path.open", new_callable=mock_open)
def test_set_credentials(self, mock_path_open, mock_AccessToken):
consumer_key, consumer_secret = self.credentials
command_line = ["--set-credentials", consumer_key, consumer_secret]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
with self.assertRaises(CliExit):
self.cli(command_line)
self.assertRegex(mock_stdout.getvalue(), r"Credentials are correct.")
mock_path_open.return_value.__enter__().write.assert_called_once_with(
f"{consumer_key},{consumer_secret}"
)
@patch("eumdac.cli.load_credentials")
@patch("eumdac.cli.DataStore")
def test_describe_list_collections(self, mock_DataStore, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
collection = MagicMock(spec=Collection)
collection.__str__.return_value = "MockCollection"
collection.title = "MockTitle"
mock_DataStore.return_value.collections = [collection]
command_line = ["describe"]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
self.assertRegex(mock_stdout.getvalue(), "MockCollection - MockTitle")
def test_print_help(self):
regex = re.compile(f"usage: (.*(\r)?\n)+EUMETSAT Data Access Client", re.MULTILINE)
command_line = ["--help"]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
with self.assertRaises(CliExit):
self.cli(command_line)
self.assertRegex(mock_stdout.getvalue(), regex)
# print help if no argument is given
command_line = []
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
self.assertRegex(mock_stdout.getvalue(), regex)
def test_print_version(self):
command_line = ["--version"]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
with self.assertRaises(CliExit):
self.cli(command_line)
self.assertRegex(mock_stdout.getvalue(), re.escape(eumdac.__version__))
def test_pipe_in(self):
self.mock_stdin.read.return_value = "--version"
with patch("eumdac.cli.sys.stdout", new_callable=io.StringIO) as mock_stdout:
with self.assertRaises(CliExit):
self.cli()
self.assertRegex(mock_stdout.getvalue(), re.escape(eumdac.__version__))
@patch("eumdac.cli.load_credentials")
@patch("eumdac.cli.DataStore")
def test_describe_collection(self, mock_DataStore, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
collection = MagicMock(spec=Collection)
collection.__str__.return_value = "MockCollection"
collection.title = "MockTitle"
collection.abstract = "MockAbstract"
collection.metadata = {"properties": {"date": "2020/"}}
mock_DataStore.return_value.get_collection.return_value = collection
command_line = ["describe", "-c", "MockCollection"]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
regex = re.compile(
f"MockCollection.*MockTitle(.*(\r)?\n)+Date:(.*(\r)?\n)+MockAbstract",
re.MULTILINE,
)
out = mock_stdout.getvalue()
self.assertRegex(out, regex)
@patch("eumdac.cli.load_credentials")
def test_describe_product_without_collection(self, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
command_line = ["describe", "-p", "MockProduct", "--debug"]
with self.assertRaises(ValueError):
self.cli(command_line)
@patch("eumdac.cli.load_credentials")
@patch("eumdac.cli.DataStore")
def test_describe_product(self, mock_DataStore, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
product = MagicMock(spec=Product)
product.__str__.return_value = "MockProduct"
product.collection = "MockCollection"
product.satellite = "MockSatellite"
product.instrument = "MockInstrument"
product.acronym = "MockAcronym"
product.sensing_start = datetime.datetime(2020, 1, 1)
product.sensing_end = datetime.datetime(2020, 1, 2)
product.size = 123456
product.ingested = datetime.datetime(2020, 1, 2)
product.md5 = "123456789"
product.entries = [
"product_file_1.nc",
"product_file_2.nc",
"product_file_3.nc",
"product_group/entry1.nc",
"product_group/entry2.nc",
"product_group/entry3/file.nc",
"metadata.xml",
]
mock_DataStore.return_value.get_product.return_value = product
expected_lines = [
"MockCollection - MockProduct",
"Platform: MockSatellite",
"Instrument: MockInstrument",
"Acronym: MockAcronym",
"Orbit: LEO",
"Sensing Start: 2020-01-01T00:00:00.000Z",
"Sensing End: 2020-01-02T00:00:00.000Z",
"Size: 123456 KB",
"Published: 2020-01-02T00:00:00.000Z",
"MD5: 123456789",
"SIP Entries:",
"product_file_1.nc",
"product_file_2.nc",
"product_file_3.nc",
"product_group/",
"- entry1.nc",
"- entry2.nc",
"- entry3/file.nc",
"metadata.xml",
"",
]
command_line = ["describe", "-c", "MockCollection", "-p", "MockProduct"]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
for line in expected_lines:
self.assertIn(line, mock_stdout.getvalue())
@patch("eumdac.cli.load_credentials")
@patch("eumdac.cli.DataStore")
def test_describe_product_flat(self, mock_DataStore, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
product = MagicMock(spec=Product)
product.__str__.return_value = "MockProduct"
product.collection = "MockCollection"
product.satellite = "MockSatellite"
product.instrument = "MockInstrument"
product.acronym = "MockAcronym"
product.sensing_start = datetime.datetime(2020, 1, 1)
product.sensing_end = datetime.datetime(2020, 1, 2)
product.size = 123456
product.ingested = datetime.datetime(2020, 1, 2)
product.md5 = "123456789"
product.entries = [
"product_file_1.nc",
"product_file_2.nc",
"product_file_3.nc",
"product_group/entry1.nc",
"product_group/entry2.nc",
"product_group/entry3/file.nc",
"metadata.xml",
]
mock_DataStore.return_value.get_product.return_value = product
expected_lines = [
"MockCollection - MockProduct",
"Platform: MockSatellite",
"Instrument: MockInstrument",
"Acronym: MockAcronym",
"Orbit: LEO",
"Sensing Start: 2020-01-01T00:00:00.000Z",
"Sensing End: 2020-01-02T00:00:00.000Z",
"Size: 123456 KB",
"Published: 2020-01-02T00:00:00.000Z",
"MD5: 123456789",
"SIP Entries:",
"product_file_1.nc",
"product_file_2.nc",
"product_file_3.nc",
"product_group/entry1.nc",
"product_group/entry2.nc",
"product_group/entry3/file.nc",
"metadata.xml",
"",
]
command_line = ["describe", "-c", "MockCollection", "-p", "MockProduct", "--flat"]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
for line in expected_lines:
self.assertIn(line, mock_stdout.getvalue())
@patch("eumdac.cli.AccessToken")
@patch("eumdac.cli.DataStore")
@patch("eumdac.cli.load_credentials")
def test_load_credentials(self, mock_load_credentials, mock_DataStore, mock_AccessToken):
mock_load_credentials.return_value = ("CONSUMER_KEY", "CONSUMER_SECRET")
mock_DataStore.return_value.collections = []
command_line = ["describe"]
self.cli(command_line)
mock_AccessToken.assert_called_once_with(("CONSUMER_KEY", "CONSUMER_SECRET"))
@patch("pathlib.Path.read_text")
@patch("eumdac.cli.DataStore")
def test_load_credentials_file_not_found(self, mock_DataStore, mock_read_text):
mock_read_text.side_effect = FileNotFoundError
command_line = (
"download -c EO:EUM:DAT:MSG:MSG15-RSS "
"--time-range 2021-09-20 2022-09-30 --limit 1 --debug"
).split()
with self.assertRaises(EumdacError):
self.cli(command_line)
@patch("eumdac.cli.get_credentials_path")
@patch("eumdac.cli.AccessToken")
@patch("eumdac.cli.DataStore")
def test_load_credentials_corrupted_file(
self, mock_DataStore, mock_AccessToken, mock_get_credentials_path
):
mock_get_credentials_path.return_value.read_text.return_value = "corrupted!"
mock_DataStore.return_value.collections = []
command_line = ["describe", "--debug"]
with self.assertRaises(EumdacError):
self.cli(command_line)
@patch("eumdac.cli.get_datastore")
@patch("eumdac.cli.load_credentials")
def test_search(self, _, mock_get_datastore):
mock_collection = MagicMock(spec=Collection)
mock_collection.search.return_value = [
"MSG4-SEVI-MSGCLMK-0100-0100-20200301121500.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301120000.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301114500.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301113000.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301111500.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301110000.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301104500.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301103000.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301101500.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301100000.000000000Z-NA",
]
mock_DataStore = MagicMock(spec=eumdac.DataStore)
mock_DataStore.get_collection.return_value = mock_collection
mock_get_datastore.return_value = mock_DataStore
command_line = [
"search",
"-s",
"2020-03-01",
"-e",
"2020-03-01T12:15",
"-c",
"EO:EUM:DAT:MSG:CLM",
"--limit",
"3",
]
expected_lines = [
"MSG4-SEVI-MSGCLMK-0100-0100-20200301121500.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301120000.000000000Z-NA",
"MSG4-SEVI-MSGCLMK-0100-0100-20200301114500.000000000Z-NA",
"",
]
expected_output = "\n".join(expected_lines)
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
self.assertEqual(mock_stdout.getvalue(), expected_output)
@patch("eumdac.cli.get_datastore")
@patch("eumdac.cli.load_credentials")
def test_search_bbox(self, _, mock_get_datastore):
mock_collection = MagicMock(spec=Collection)
mock_collection.search.return_value = [
"MockProduct-a",
"MockProduct-b",
"MockProduct-c",
"MockProduct-d",
]
mock_DataStore = MagicMock(spec=eumdac.DataStore)
mock_DataStore.get_collection.return_value = mock_collection
mock_get_datastore.return_value = mock_DataStore
command_line = [
"search",
"-c",
"MockCollection",
"--bbox",
"2.0",
"10.0",
"10.0",
"52.0",
"--limit",
"3",
]
self.cli(command_line)
print(mock_collection.call_count)
mock_collection.search.assert_called_with(bbox="2.0,10.0,10.0,52.0", set="brief")
@patch("eumdac.cli.load_credentials")
def test_local_tailor_set(self, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
tailor_url = "http://NON_EXISTANT:40000"
tailor_id = "local"
def mock_get_url_path():
return self.tmp_path
self.monkeypatch.setattr("eumdac.local_tailor.get_url_path", mock_get_url_path)
command_line = ["local-tailor", "set", tailor_id, tailor_url]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
command_line = ["local-tailor", "remove", tailor_id]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
@patch("eumdac.cli.load_credentials")
def test_local_tailor_instances(self, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
tailor_url = "http://NON_EXISTANT:40000"
tailor_id = "local"
def mock_get_url_path():
return self.tmp_path
self.monkeypatch.setattr("eumdac.local_tailor.get_url_path", mock_get_url_path)
command_line = ["local-tailor", "set", tailor_id, tailor_url]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
command_line = ["local-tailor", "instances"]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
self.assertRegex(mock_stdout.getvalue(), f".*{tailor_url}.*")
self.assertRegex(mock_stdout.getvalue(), f".*{tailor_id}.*")
self.assertRegex(mock_stdout.getvalue(), f".*OFFLINE.*")
command_line = ["local-tailor", "remove", tailor_id]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
@patch("eumdac.cli.load_credentials")
def test_local_tailor_show(self, mock_load_credentials):
mock_load_credentials.return_value = self.credentials
tailor_url = "http://NON_EXISTANT:40000"
tailor_id = "local"
def mock_get_url_path():
return self.tmp_path
self.monkeypatch.setattr("eumdac.local_tailor.get_url_path", mock_get_url_path)
command_line = ["local-tailor", "set", tailor_id, tailor_url]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
command_line = ["local-tailor", "show", tailor_id]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
self.assertRegex(mock_stdout.getvalue(), f".*{tailor_url}.*")
self.assertRegex(mock_stdout.getvalue(), f".*{tailor_id}.*")
self.assertRegex(mock_stdout.getvalue(), f".*OFFLINE.*")
command_line = ["local-tailor", "remove", tailor_id]
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
self.cli(command_line)
eumdac-3.0.0/tests/test_cli_mtg.py 0000664 0000000 0000000 00000010043 14720105632 0017137 0 ustar 00root root 0000000 0000000 import unittest
import sys
from unittest.mock import patch, mock_open, MagicMock
import eumdac
from eumdac.cli import cli
from eumdac.collection import Collection
from eumdac.order import Order
from .base import INTEGRATION_TESTING
class CliExit(Exception):
pass
class CliError(Exception):
pass
class TestCommandLineInterface(unittest.TestCase):
credentials = ("abc", "xyz")
def setUp(self):
super().setUp()
self.patch_argv()
self.get_mock("argparse.ArgumentParser.exit", new=MagicMock(side_effect=CliExit))
self.mock_error = self.get_mock(
"argparse.ArgumentParser.error", new=MagicMock(side_effect=CliError)
)
self.mock_stdin = self.get_mock("eumdac.cli.sys.stdin", new_callable=mock_open())
self.mock_stdin.isatty.return_value = False
def patch_argv(self):
patcher = patch.object(sys, "argv", ["eumdac"])
patcher.start()
self.addCleanup(patcher.stop)
def get_mock(self, target, **kwargs):
patcher = patch(target, **kwargs)
mock = patcher.start()
self.addCleanup(patcher.stop)
return mock
@unittest.skipIf(INTEGRATION_TESTING, "Covered by integration testing")
@patch("eumdac.cli.get_datastore")
@patch("eumdac.cli.load_credentials")
def test_download_coverage(self, _, mock_get_datastore):
mock_DataStore = MagicMock(spec=eumdac.DataStore)
mock_get_datastore.return_value = mock_DataStore
mock_collection = MagicMock(spec=Collection)
mock_collection.search.return_value = []
mock_DataStore.get_collection.return_value = mock_collection
command_line = [
"download",
"-c",
"EO:EUM:DAT:0665",
"--limit",
"1",
"--download-coverage",
"FD",
]
cli(command_line)
def test_is_collection_valid_for_coverage(self):
from eumdac.cli_mtg_helpers import is_collection_valid_for_coverage
# Valid collections for coverage downloading
for i in [
"0662",
"0665",
"0672",
]:
self.assertTrue(is_collection_valid_for_coverage(f"EO:EUM:DAT:{i}"))
self.assertTrue(is_collection_valid_for_coverage(f"EO:EUMIVV:DAT:{i}"))
self.assertTrue(is_collection_valid_for_coverage(f"EO:EUMVAL:DAT:{i}"))
self.assertTrue(is_collection_valid_for_coverage(f"EO:EUM:DAT:{i}:COM"))
# MTG collections invalid for coverage download
for i in [
"0659",
"0660",
"0661",
"0664",
"0667",
"0668",
"0669",
"0670",
"0671",
"0674",
"0675",
"0676",
"0677",
"0678",
"0679",
"0680",
"0681",
"0682",
"0683",
"0684",
"0685",
"0686",
"0687",
"0688",
"0689",
"0690",
"0691",
"0692",
"0693",
"0694",
"0749",
"0750",
"0751",
"0752",
"0753",
"0773",
"0774",
"0775",
"0782",
"0788",
"0789",
"0790",
"0791",
"0792",
"0793",
"0794",
"0795",
"0796",
"0799",
"0800",
"0801",
"0845",
]:
self.assertFalse(is_collection_valid_for_coverage(f"EO:EUM:DAT:{i}"))
self.assertFalse(is_collection_valid_for_coverage(f"EO:EUMIVV:DAT:{i}"))
self.assertFalse(is_collection_valid_for_coverage(f"EO:EUMVAL:DAT:{i}"))
self.assertFalse(is_collection_valid_for_coverage(f"EO:EUM:DAT:{i}:COM"))
# Invalid collections for coverage downloading
for c in ["EO:EUM:DAT:MSG:HRSEVIRI", ""]:
self.assertFalse(is_collection_valid_for_coverage(c))
eumdac-3.0.0/tests/test_cli_s3.py 0000664 0000000 0000000 00000012675 14720105632 0016712 0 ustar 00root root 0000000 0000000 import io
import unittest
import re
import os
import datetime
import sys
from datetime import datetime, timedelta
from typing import Dict
from unittest.mock import patch, mock_open, MagicMock
import eumdac
from eumdac.cli import cli
from eumdac.collection import Collection
from .base import INTEGRATION_TESTING, CONSUMER_KEY, CONSUMER_SECRET
class CliExit(Exception):
pass
class CliError(Exception):
pass
class TestCommandLineInterface(unittest.TestCase):
credentials = ("abc", "xyz")
def setUp(self):
super().setUp()
self.patch_argv()
self.get_mock("argparse.ArgumentParser.exit", new=MagicMock(side_effect=CliExit))
self.mock_error = self.get_mock(
"argparse.ArgumentParser.error", new=MagicMock(side_effect=CliError)
)
self.mock_stdin = self.get_mock("eumdac.cli.sys.stdin", new_callable=mock_open())
self.mock_stdin.isatty.return_value = False
def patch_argv(self):
patcher = patch.object(sys, "argv", ["eumdac"])
patcher.start()
self.addCleanup(patcher.stop)
def get_mock(self, target, **kwargs):
patcher = patch(target, **kwargs)
mock = patcher.start()
self.addCleanup(patcher.stop)
return mock
# @unittest.skipIf(not INTEGRATION_TESTING, "To be tested only on integration testing phase")
@unittest.skip("Skipping for integration testing temporarily")
def test_search_timeliness(self):
aweekago = datetime.now() - timedelta(days=7)
start = aweekago.strftime("%Y-%m-%d")
end = aweekago.strftime("%Y-%m-%dT03")
command_line = [
"search",
"-c",
"EO:EUM:DAT:0409",
"-s",
start,
"-e",
end,
"--limit",
"3",
]
with patch.object(eumdac.cli, "load_credentials") as mock_load_credentials:
mock_load_credentials.return_value = (CONSUMER_KEY, CONSUMER_SECRET)
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
cli(command_line + ["--timeliness", "NR"])
self.assertRegex(
mock_stdout.getvalue(),
"(.*?_NR_.*?(\r)?\n){3}",
"Expected NR products were not received",
)
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
cli(command_line + ["--timeliness", "NT"])
self.assertRegex(
mock_stdout.getvalue(),
"(.*?_NT_.*?(\r)?\n){3}",
"Expected NT products were not received",
)
# @unittest.skipIf(not INTEGRATION_TESTING, "To be tested only on integration testing phase")
@unittest.skip("Skipping for integration testing temporarily")
def test_search_orbit_number(self):
command_line = [
"search",
"-c",
"EO:EUM:DAT:0409",
"-s",
"2022-07-01",
"-e",
"2022-07-01T03",
"--limit",
"100",
]
num_full_query_output_lines: int = 0
with patch.object(eumdac.cli, "load_credentials") as mock_load_credentials:
mock_load_credentials.return_value = (CONSUMER_KEY, CONSUMER_SECRET)
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
cli(command_line)
output = mock_stdout.getvalue()
self.assertRegex(output, "(.*?.SEN3(\r)?\n)+", "Products not received")
num_full_query_output_lines = len(output.split("\n"))
with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
cli(command_line + ["--orbit", "33172"])
output = mock_stdout.getvalue()
self.assertRegex(output, "(.*?.SEN3(\r)?\n)+", "Products not received")
self.assertGreater(num_full_query_output_lines, len(output.split("\n")))
@unittest.skipIf(INTEGRATION_TESTING, "Covered by integration testing")
@patch("eumdac.cli.get_datastore")
@patch("eumdac.cli.load_credentials")
def test_sen3_search_params(self, _, mock_get_datastore):
mock_DataStore = MagicMock(spec=eumdac.DataStore)
mock_get_datastore.return_value = mock_DataStore
mock_collection = MagicMock(spec=Collection)
mock_collection.search.return_value = []
mock_DataStore.get_collection.return_value = mock_collection
command_line = [
"search",
"-s",
"2020-03-01",
"-e",
"2020-03-01T12:15",
"-c",
"EO:EUM:DAT:0409",
"--limit",
"3",
"--timeliness",
"NR",
"--orbit",
"20",
"--relorbit",
"2120",
"--cycle",
"13",
"--filename",
"*file*expr*.SEN3",
]
cli(command_line)
search_kwargs = mock_collection.search.call_args[1]
self.assertTrue(search_kwargs.get("orbit") == 20, "Unexpected orbit value")
self.assertTrue(search_kwargs.get("relorbit") == 2120, "Unexpected relorbit value")
self.assertTrue(search_kwargs.get("timeliness") == "NR", "Unexpected timeliness value")
self.assertTrue(search_kwargs.get("cycle") == 13, "Unexpected cycle value")
self.assertTrue(
search_kwargs.get("title") == "*file*expr*.SEN3", "Unexpected filename value"
)
eumdac-3.0.0/tests/test_cli_sh.py 0000664 0000000 0000000 00000013535 14720105632 0016773 0 ustar 00root root 0000000 0000000 import os
import unittest
from io import StringIO
from itertools import islice
from pathlib import Path
from shutil import rmtree
from unittest.mock import mock_open, patch
import pytest
from eumdac.cli import cli
from .base import INTEGRATION_TESTING
@pytest.fixture
@unittest.skipIf(INTEGRATION_TESTING, "Covered by integration testing")
def temp_output_dir(request):
output_dir_name = f"output_dir_{request.node.name}"
yield Path(output_dir_name)
rmtree(output_dir_name)
@pytest.fixture
@unittest.skipIf(INTEGRATION_TESTING, "Covered by integration testing")
def temp_config_dir(request):
config_dir_name = Path(f"config_dir_{request.node.name}")
os.environ["EUMDAC_CONFIG_DIR"] = str(config_dir_name)
config_dir_name.mkdir(exist_ok=True)
yield config_dir_name
rmtree(config_dir_name)
del os.environ["EUMDAC_CONFIG_DIR"]
@pytest.fixture
@unittest.skipIf(INTEGRATION_TESTING, "Covered by integration testing")
def temp_credentials(temp_config_dir):
credentials_path = temp_config_dir / "credentials"
with credentials_path.open("w") as fobj:
fobj.write("user,password")
yield credentials_path
def eumdac(args):
test_out = StringIO()
test_err = StringIO()
with patch("sys.stdout", test_out), patch("sys.stderr", test_err), patch(
"eumdac.cli.sys.stdin", new_callable=mock_open()
) as mock_stdin:
mock_stdin.isatty.return_value = False
try:
cli(args)
except SystemExit as exc:
if exc.code != 0:
raise exc
return test_out.getvalue(), test_err.getvalue()
def assert_eumdac_output(args, expected_lines):
out, err = eumdac(args)
print(out)
expected_block = "\n".join(str(x) for x in expected_lines)
error_msg = "\n{}\nvs\n{}".format(expected_block, out)
assert_list_contains(out.splitlines(), expected_lines, error_msg)
assert not err, "stderr not empty!\n" "Contents:\n" f"{err}"
def assert_list_contains(outlist, expectedlist, msg=None):
iout = iter(outlist)
iexpected = iter(expectedlist)
for exp in iexpected:
print(exp)
if isinstance(exp, tuple) and exp[0] == "order_does_not_matter":
inner_expectation = sorted(exp[1])
out_slice = sorted(islice(iout, len(exp[1])))
print(inner_expectation)
print(out_slice)
assert_list_contains(out_slice, inner_expectation)
else:
out = next(iout)
if msg:
assert exp in out, msg
else:
assert exp in out
def test_assert_list_contains():
assert_list_contains(["A1", "A2", "A3", "B1"], ["A", "A", "A", "B"])
def test_assert_list_contains_simple_assertion_error():
with pytest.raises(AssertionError):
assert_list_contains(["A1", "A2", "A3", "B1"], ["A", "B", "A", "B"])
def test_assert_list_contains_assertion_error_unequal_len():
with pytest.raises(AssertionError):
assert_list_contains(["A1", "A2", "A3"], ["A", "B", "A", "B"])
def test_assert_list_contains_with_indifferent_order():
assert_list_contains(
["A1", "A2", "A3", "B1"], ["A", ("order_does_not_matter", ["B", "A", "A"])]
)
@unittest.skipIf(INTEGRATION_TESTING, "Covered by unit testing")
def test_set_credentials(temp_config_dir):
args = "--set-credentials user password".split()
expected = (
"Credentials are correct. Token was generated:",
"Credentials are written to file",
)
with patch("eumdac.token.AccessToken.access_token", "TOKEN"):
assert_eumdac_output(args, expected)
@unittest.skipIf(INTEGRATION_TESTING, "Covered by unit testing")
def test_download_product(temp_credentials, temp_output_dir):
args = f"download -c MockCollection -p MockProduct -o {temp_output_dir} --test".split()
expected = (
"Processing",
"Using order",
"Output directory:",
"Preparing download",
"Download complete: MockProduct",
"Removing successfully finished order",
)
assert_eumdac_output(args, expected)
@unittest.skipIf(INTEGRATION_TESTING, "Covered by unit testing")
def test_skip_download_product(temp_credentials, temp_output_dir):
args = f"download -c MockCollection -p MockProduct -o {temp_output_dir} --test".split()
expected = ("Processing", "Using order", "Output directory:", "Skip")
# First run to ensure the file exists already
eumdac(args)
assert_eumdac_output(args, expected)
@unittest.skipIf(INTEGRATION_TESTING, "Covered by unit testing")
def test_download_product_entry(temp_credentials, temp_output_dir):
args = f"download -c MockCollection -p MockProduct --entry *.nc -o {temp_output_dir} --test".split()
# we expect a folder with the product name to be created when --entry is given
expected = (
"Processing",
"Using order",
"Output directory:",
(
"order_does_not_matter",
[
"Job 1: Preparing download",
"Job 1: Preparing download",
"Job 1: Download complete",
"Job 1: Download complete",
],
),
"Removing successfully finished order",
)
assert_eumdac_output(args, expected)
@unittest.skipIf(INTEGRATION_TESTING, "Covered by unit testing")
def test_download_output_dir(temp_credentials, temp_output_dir):
args = f"download -c MockCollection --time-range 2020-03-01 2020-03-01T12:15 -o {temp_output_dir} --test".split()
expected = (
"Processing",
"Using order",
"Output directory:",
(
"order_does_not_matter",
[
"Job 1: Preparing download",
"Job 2: Preparing download",
"Job 1: Download complete",
"Job 2: Download complete",
],
),
"Removing successfully finished order",
)
assert_eumdac_output(args, expected)
eumdac-3.0.0/tests/test_collection.py 0000664 0000000 0000000 00000012306 14720105632 0017660 0 ustar 00root root 0000000 0000000 from datetime import datetime
from eumdac.token import AccessToken
from eumdac.datastore import DataStore
from eumdac.collection import Collection, CollectionError
from eumdac.product import Product
from .base import INTEGRATION_TESTING, DataServiceTestCase
class TestCollection(DataServiceTestCase):
collection_id = "EO:EUM:DAT:MSG:HRSEVIRI"
def setUp(self):
super().setUp()
self.token = AccessToken(self.credentials)
self.datastore = DataStore(token=self.token)
self.collection = Collection(self.collection_id, self.datastore)
def test_string_representation(self):
self.assertEqual(self.collection_id, str(self.collection))
self.assertIn(self.collection_id, repr(self.collection))
def test_properties(self):
self.assertIsInstance(self.collection.abstract, str)
self.assertIsInstance(self.collection.title, str)
self.assertIsInstance(self.collection.metadata, dict)
self.assertIn("properties", self.collection.metadata)
# check that the whitespaces have been fixed
self.assertNotIn("\n", self.collection.abstract)
def test_search(self):
products = self.collection.search(
dtstart=datetime(2022, 10, 1, 0, 0, 0), dtend=datetime(2022, 10, 1, 1, 0, 0)
)
product_ids = [str(product) for product in products]
expected_product_ids = [
"MSG4-SEVI-MSG15-0100-NA-20221001005743.037000000Z-NA",
"MSG4-SEVI-MSG15-0100-NA-20221001004242.893000000Z-NA",
"MSG4-SEVI-MSG15-0100-NA-20221001002742.762000000Z-NA",
"MSG4-SEVI-MSG15-0100-NA-20221001001242.637000000Z-NA",
]
self.assertEqual(product_ids, expected_product_ids)
first = products.first()
self.assertIsInstance(first, Product)
def test_camparison(self):
seviri_rss = Collection("EO:EUM:DAT:MSG:MSG15-RSS", self.datastore)
avhrr_l1 = Collection("EO:EUM:DAT:METOP:AVHRRL1", self.datastore)
self.assertLess(avhrr_l1, seviri_rss)
self.assertNotEqual(avhrr_l1, seviri_rss)
def test_product_type(self):
self.assertEqual(self.collection.product_type, "HRSEVIRI")
class TestSearchResults(DataServiceTestCase):
collection_id = "EO:EUM:DAT:MSG:HRSEVIRI"
def setUp(self):
super().setUp()
self.token = AccessToken(self.credentials)
self.datastore = DataStore(token=self.token)
self.collection = Collection(self.collection_id, self.datastore)
self.search_results = self.collection.search(
dtstart=datetime(2022, 10, 1, 0, 0, 0), dtend=datetime(2022, 10, 1, 1, 0, 0)
)
def test_string_representation(self):
self.assertIn(self.collection_id, repr(self.search_results))
def test_properties(self):
total_results = self.search_results.total_results
all_results = list(self.search_results)
self.assertEqual(total_results, len(all_results))
query = self.search_results.query
self.assertIn("dtstart", query)
self.assertIn("dtend", query)
def test_update_query(self):
new_results = self.search_results.update_query(dtend=datetime(2022, 10, 1, 2, 0, 0))
# check that we created a new instance
self.assertIsNot(self.search_results, new_results)
def test_first(self):
first = self.search_results.first()
all_products = list(self.search_results)
self.assertEqual(first, all_products[0])
self.assertIsInstance(first, Product)
def test_empty_results(self):
empty_results = self.collection.search(
dtstart=datetime(2000, 1, 1, 0, 0, 0), dtend=datetime(2000, 1, 1, 0, 0, 1)
)
first = empty_results.first()
self.assertIsNone(first)
self.assertEqual(empty_results.total_results, 0)
self.assertEqual(list(empty_results), [])
def test_pagination(self):
self.datastore.collections
total_results = self.search_results.total_results
self.search_results._items_per_page = total_results
n_calls_before = len(self.requests_mock.calls)
list(self.search_results)
n_calls_after = len(self.requests_mock.calls)
self.assertEqual(n_calls_after, n_calls_before + 1)
self.search_results._items_per_page = total_results // 2
n_calls_before = len(self.requests_mock.calls)
list(self.search_results)
n_calls_after = len(self.requests_mock.calls)
self.assertEqual(n_calls_after, n_calls_before + 2)
def test_results_contain_product(self):
first = self.search_results.first()
self.assertIn(first, self.search_results)
product_id = "MSG1-SEVI-MSG15-0201-NA-20040120075736.727000000Z-NA"
other = self.datastore.get_product(self.collection_id, product_id)
self.assertNotIn(other, self.search_results)
def test_invalid_search_argument(self):
with self.assertRaisesRegex(CollectionError, r"invalid search options .*"):
self.collection.search(foo="bar")
def test_search_no_starttime(self):
results = self.collection.search(dtend=datetime(2022, 10, 1, 1, 0, 0))
def test_search_no_endtime(self):
results = self.collection.search(dtstart=datetime(2000, 1, 1, 0, 0, 0))
eumdac-3.0.0/tests/test_customisation.py 0000664 0000000 0000000 00000015533 14720105632 0020433 0 ustar 00root root 0000000 0000000 import fnmatch
import io
import time
import shutil
import unittest
from datetime import datetime
from pytest import skip
from eumdac.token import AccessToken
from eumdac.datastore import DataStore
from eumdac.tailor_models import Chain
from eumdac.datatailor import DataTailor
from eumdac.customisation import Customisation, AlreadyDeletedCustomisationError
from .base import DataServiceTestCase, INTEGRATION_TESTING
class TestCustomisation(DataServiceTestCase):
def setUp(self):
super().setUp()
self.token = AccessToken(self.credentials)
self.datatailor = DataTailor(self.token)
@unittest.skip("Temporarily skipping")
def test_full_customisation_process(self):
# format conversion
chain_config = Chain(product="HRSEVIRI", format="netcdf4", quicklook="hrseviri_png")
# search for the last product in June 2020
datastore = DataStore(self.token)
hrseviri = datastore.get_collection("EO:EUM:DAT:MSG:HRSEVIRI")
product = hrseviri.search(dtend=datetime(2020, 7, 1)).first()
# use context manager, to automatically delete customisations at the end even
# if an error occurs
with self.datatailor.new_customisation(product, chain_config) as customisation:
if not INTEGRATION_TESTING:
customisation.update_margin = 0
timeout = 900 # needed to increase to 12 minutes, overstrained DT...
tic = time.time()
while time.time() - tic < timeout:
if INTEGRATION_TESTING:
time.sleep(5)
if customisation.status == "DONE":
break
else:
raise TimeoutError(f"Cutomisation took longer than {timeout}s")
# test streaming
(png_aux_xml,) = fnmatch.filter(customisation.outputs, "*.png.aux.xml")
with customisation.stream_output(png_aux_xml) as stream:
file = io.BytesIO()
shutil.copyfileobj(stream, file)
# check properties
self.assertIsInstance(customisation.creation_time, datetime)
self.assertIsInstance(customisation.backend, str)
self.assertIsInstance(customisation.product_type, str)
self.assertIsInstance(customisation.processing_steps, list)
self.assertIsInstance(customisation.status, str)
self.assertIsInstance(customisation.progress, int)
self.assertIsInstance(customisation.duration, int)
self.assertIsInstance(customisation.outputs, list)
self.assertIsInstance(customisation.logfile, str)
expected_xml_length = 870
self.assertEqual(file.tell(), expected_xml_length)
# check that customisation has been removed
delete_url = self.datatailor.urls.get("tailor", "delete")
self.requests_mock.assert_call_count(delete_url, 1)
@unittest.skipIf(INTEGRATION_TESTING, "Integration already covered!")
def test_properties_cache(self):
customisation_id = "abcdef123"
url = self.datatailor.urls.get(
"tailor", "customisation", vars={"customisation_id": customisation_id}
)
self.requests_mock.add(
"GET",
url,
json={
customisation_id: {
"creation_time": datetime.now().strftime(Customisation._creation_time_format),
"backend_id": "backend-id",
"product_id": "product-id",
"required_processing_steps": ["a", "b", "c"],
"status": "DONE",
"progress": 100,
"processing_duration": 123,
"output_products": ["file.nc", "file.xml", "file.png"],
}
},
)
self.token._expiration = time.time() + 1000
self.token._access_token = "token"
customisation = Customisation(customisation_id, self.datatailor)
creation_time = customisation.creation_time
backend = customisation.backend
self.assertIsInstance(creation_time, datetime)
self.assertIsInstance(backend, str)
self.requests_mock.assert_call_count(url, 1)
# force reload
customisation.update_margin = 0
status = customisation.status
self.assertIsInstance(status, str)
self.requests_mock.assert_call_count(url, 2)
@unittest.skipIf(INTEGRATION_TESTING, "Integration already covered!")
def test_string_representation(self):
customisation_id = "abcdef123"
customisation = Customisation(customisation_id, self.datatailor)
self.assertEqual(customisation_id, str(customisation))
self.assertIn(customisation_id, repr(customisation))
@unittest.skipIf(INTEGRATION_TESTING, "Test Failure")
def test_cannot_fails_when_deleted(self):
self.requests_mock.add("PATCH", self.datatailor.urls.get("tailor", "delete"))
self.token._expiration = time.time() + 1000
self.token._access_token = "token"
customisation_id = "abcdef123"
customisation = Customisation(customisation_id, self.datatailor)
customisation.delete()
message = "Customisation already deleted."
with self.assertRaisesRegex(AlreadyDeletedCustomisationError, message):
customisation.status
with self.assertRaisesRegex(AlreadyDeletedCustomisationError, message):
customisation.logfile
with self.assertRaisesRegex(AlreadyDeletedCustomisationError, message):
with customisation.stream_output("file.dat") as stream:
data = stream.read()
del data
@unittest.skipIf(INTEGRATION_TESTING, "Test Failure")
def test_fail_on_unknown_stream_output(self):
customisation_id = "abcdef123"
url = self.datatailor.urls.get(
"tailor", "customisation", vars={"customisation_id": customisation_id}
)
self.requests_mock.add(
"GET",
url,
json={customisation_id: {"output_products": ["file.nc", "file.xml", "file.png"]}},
)
self.token._expiration = time.time() + 1000
self.token._access_token = "token"
customisation_id = "abcdef123"
customisation = Customisation(customisation_id, self.datatailor)
message = r"file\.dat not in "
with self.assertRaisesRegex(ValueError, message):
with customisation.stream_output("file.dat") as stream:
data = stream.read()
del data
@classmethod
def prepare_integration_test(cls):
prepare_test_customisation(cls.credentials)
def prepare_test_customisation(credentials):
"""delete all existing customisations"""
token = AccessToken(credentials)
datatailor = DataTailor(token)
for customisation in datatailor.customisations:
try:
customisation.delete()
except:
pass
eumdac-3.0.0/tests/test_datastore.py 0000664 0000000 0000000 00000002207 14720105632 0017512 0 ustar 00root root 0000000 0000000 import pytest
from eumdac.token import AccessToken
from eumdac.datastore import DataStore, DataStoreError, Product
from eumdac.collection import Collection
from .base import DataServiceTestCase
class TestDataStore(DataServiceTestCase):
def setUp(self):
super().setUp()
self.token = AccessToken(self.credentials)
self.datastore = DataStore(token=self.token)
def test_property_collections(self):
collections = self.datastore.collections
self.assertIsInstance(collections, list)
self.assertIn("EO:EUM:DAT:MSG:HRSEVIRI", map(str, collections))
self.assertIsInstance(collections[0], Collection)
def test_product_from_url(self):
valid_url = "https://api.eumetsat.int/data/download/1.0.0/collections/EO%3AEUM%3ADAT%3AMSG%3AMSG15-RSS/products/MSG4-SEVI-MSG15-0100-NA-20240404125918.061000000Z-NA"
invalid_url = "https://fake.url.int/other/api/download"
valid_product = self.datastore.get_product_from_url(valid_url)
self.assertIsInstance(valid_product, Product)
with pytest.raises(Exception):
self.datastore.get_product_from_url(invalid_url)
eumdac-3.0.0/tests/test_datatailor.py 0000664 0000000 0000000 00000017213 14720105632 0017653 0 ustar 00root root 0000000 0000000 import unittest
import time
from unittest import mock
from requests.exceptions import HTTPError
from eumdac.errors import EumdacError
from eumdac.token import AccessToken
from eumdac.datatailor import DataTailor
from eumdac.customisation import Customisation
from eumdac.tailor_models import Chain, Filter, RegionOfInterest, Quicklook
from .base import DataServiceTestCase, INTEGRATION_TESTING
# @pytest.mark.skip("Temporarily skipping")
class TestDataTailor(DataServiceTestCase):
def setUp(self):
super().setUp()
self.token = AccessToken(self.credentials)
self.datatailor = DataTailor(self.token)
@unittest.skipIf(INTEGRATION_TESTING, "Tested in unit testing phase")
def test_property_customisations(self):
token_url = self.token.urls.get("token", "token")
self.requests_mock.add(
"POST",
token_url,
json={
"access_token": "b070adda-00c8-36cd-bb8f-4f6a2d6661ce",
"scope": "am_application_scope default",
"token_type": "Bearer",
"expires_in": 970,
},
)
customisations_url = self.datatailor.urls.get("tailor", "customisations")
self.requests_mock.add(
"GET",
customisations_url,
json={
"data": [
{
"user_id": "ABC",
"creation_time": "20210810T142328Z",
"backend_id": "epct_gis_msg",
"product_id": "HRSEVIRI",
"required_processing_steps": ["format"],
"status": "DONE",
"progress": 100,
"processing_duration": 47,
"output_products": ["output.file"],
"id": "abcdef",
}
]
},
)
customisations = self.datatailor.customisations
self.assertIsInstance(customisations, list)
self.assertIsInstance(customisations[0], Customisation)
def test_properties(self):
info = self.datatailor.info
self.assertIn("epct_version", info)
user_info = self.datatailor.user_info
self.assertIsInstance(user_info["username"], str)
quota = self.datatailor.quota
self.assertIsInstance(quota, dict)
@unittest.skipIf(INTEGRATION_TESTING, "Only checking the interface.")
def test_create_customisation(self):
self.token._access_token = "b070adda-00c8-36cd-bb8f-4f6a2d6661ce"
self.token._expiration = time.time() + 1000
self.requests_mock.add(
"POST",
self.datatailor.urls.get("tailor", "customisations"),
json={"total": 1, "data": ["63f53c99"]},
)
chain_name = "MyChain"
mock_product = mock.MagicMock(name="product")
mock_product._id = "MY-PRODUCT-ID"
mock_product.collection._id = "MY-COLLECTION-ID"
customisation = self.datatailor.new_customisation(mock_product, chain_name)
self.assertIsInstance(customisation, Customisation)
def test_chain_crud(self):
url = self.datatailor.chains.url
chain = Chain(
id="hrseviri_native_to_netcdf4",
name="Native to netCDF4",
description="Convert a SEVIRI Native product to netCDF4",
product="HRSEVIRI",
format="netcdf4",
)
# create
self.datatailor.chains.create(chain)
self.requests_mock.assert_call_count(url, 1)
# read
chain_ = self.datatailor.chains.read(chain.id)
self.assertEqual(chain_, chain)
chains = self.datatailor.chains.search(product="HRSEVIRI")
self.assertIn(chain, chains)
self.assertIsInstance(chains[0], Chain)
# update
chain.description = "convert a SEVIRI native product to netCDF4"
self.datatailor.chains.update(chain)
chain_ = self.datatailor.chains.read(chain.id)
self.assertEqual(chain_, chain)
# delete
self.datatailor.chains.delete(chain)
self.requests_mock.assert_call_count(url + f"/{chain.id}", 4)
def test_filter_crud(self):
url = self.datatailor.filters.url
fltr = Filter(
id="hrseviri_water_vapour",
product="HRSEVIRI",
bands=["channel_9", "channel_10"],
name="Water Vapour",
)
# create
self.datatailor.filters.create(fltr)
self.requests_mock.assert_call_count(url, 1)
# read
fltr_ = self.datatailor.filters.read(fltr.id)
self.assertEqual(fltr_, fltr)
fltrs = self.datatailor.filters.search(product="HRSEVIRI")
self.assertIn(fltr, fltrs)
self.assertIsInstance(fltrs[0], Filter)
# update
fltr.bands = ["channel_9"]
self.datatailor.filters.update(fltr)
fltr_ = self.datatailor.filters.read(fltr.id)
self.assertEqual(fltr_, fltr)
# delete
self.datatailor.filters.delete(fltr)
self.requests_mock.assert_call_count(url + f"/{fltr.id}", 4)
def test_roi_crud(self):
url = self.datatailor.rois.url
roi = RegionOfInterest(
id="deutschland", name="Deutschland", NSWE=[54.983104, 47.302488, 5.988658, 15.016996]
)
# create
self.datatailor.rois.create(roi)
self.requests_mock.assert_call_count(url, 1)
# read
roi_ = self.datatailor.rois.read(roi.id)
self.assertEqual(roi_, roi)
# delete
self.datatailor.rois.delete(roi)
self.requests_mock.assert_call_count(url + f"/{roi.id}", 2)
def test_quicklook_crud(self):
url = self.datatailor.quicklooks.url
quicklook = Quicklook(
id="hrseviri_wv_jpeg",
name="HRSEVIRI Water Vapour",
resample_method="cubic",
stretch_method="min_max",
product="HRSEVIRI",
format="jpeg_rgb",
filter=Filter(bands=["channel_11", "channel_10", "channel_9"]),
)
# create
self.datatailor.quicklooks.create(quicklook)
self.requests_mock.assert_call_count(url, 1)
# read
quicklook_ = self.datatailor.quicklooks.read(quicklook.id)
self.assertEqual(quicklook_, quicklook)
quicklooks = self.datatailor.quicklooks.search(product="HRSEVIRI")
self.assertIn(quicklook, quicklooks)
self.assertIsInstance(quicklooks[0], Quicklook)
# update
quicklook.resample_method = "bilinear"
self.datatailor.quicklooks.update(quicklook)
quicklook_ = self.datatailor.quicklooks.read(quicklook.id)
self.assertEqual(quicklook_, quicklook)
# delete (using string)
self.datatailor.quicklooks.delete(quicklook.id)
self.requests_mock.assert_call_count(url + f"/{quicklook.id}", 4)
@classmethod
def prepare_integration_test(cls):
prepare_test_datatailor(cls.credentials)
def prepare_test_datatailor(credentials):
"""delete any resource that will be created during the test"""
token = AccessToken(credentials)
datatailor = DataTailor(token)
crud_resources = [
(datatailor.chains, "hrseviri_native_to_netcdf4"),
(datatailor.filters, "hrseviri_water_vapour"),
(datatailor.rois, "deutschland"),
(datatailor.quicklooks, "hrseviri_wv_jpeg"),
]
for api, resource_id in crud_resources:
try:
api.delete(resource_id)
except:
# Resources may or may not be there and DTWS won't send 40X error codes
# when deleting not-found resources, so the fastest way is to try
# deleting and ignore errors
pass
eumdac-3.0.0/tests/test_download_app.py 0000664 0000000 0000000 00000007076 14720105632 0020204 0 ustar 00root root 0000000 0000000 import pytest
from eumdac.download_app import (
_divide_into_chunks,
_check_chunks,
_reassemble_from_chunks,
)
from pathlib import Path
def test_divide_into_chunks():
output = _divide_into_chunks("basedir", 2948, 1000)
expected = {
Path("basedir") / "chunk.0": (0, 1000),
Path("basedir") / "chunk.1": (1000, 2000),
Path("basedir") / "chunk.2": (2000, 2948),
}
assert output == expected
def test_divide_into_chunks_bigger_chunk():
output = _divide_into_chunks("basedir", 2948, 3000)
expected = {
Path("basedir") / "chunk.0": (0, 2948),
}
assert output == expected
def test_divide_into_chunks_exact_division():
output = _divide_into_chunks("basedir", 2000, 1000)
expected = {
Path("basedir") / "chunk.0": (0, 1000),
Path("basedir") / "chunk.1": (1000, 2000),
}
assert output == expected
def _create_binary_file(file_name, num_bytes, bvalue=b"\0"):
with open(file_name, "wb") as file:
file.write(bvalue * num_bytes)
def test_check_chunks(tmp_path):
(tmp_path / Path("testprodname")).mkdir()
_create_binary_file(tmp_path / Path("testprodname") / "chunk.0", 1000)
_create_binary_file(tmp_path / Path("testprodname") / "chunk.1", 1000)
_create_binary_file(tmp_path / Path("testprodname") / "chunk.2", 948)
output = _check_chunks(
{
tmp_path / Path("testprodname") / "chunk.0": (0, 1000),
tmp_path / Path("testprodname") / "chunk.1": (1000, 2000),
tmp_path / Path("testprodname") / "chunk.2": (2000, 2948),
}
)
assert output
def test_check_chunks_invalid_size(tmp_path):
(tmp_path / Path("testprodname")).mkdir()
_create_binary_file(tmp_path / Path("testprodname") / "chunk.0", 999)
_create_binary_file(tmp_path / Path("testprodname") / "chunk.1", 1000)
_create_binary_file(tmp_path / Path("testprodname") / "chunk.2", 948)
output = _check_chunks(
{
tmp_path / Path("testprodname") / "chunk.0": (0, 1000),
tmp_path / Path("testprodname") / "chunk.1": (1000, 2000),
tmp_path / Path("testprodname") / "chunk.2": (2000, 2948),
}
)
assert output is False
def test_check_chunks_chunk_missing(tmp_path):
(tmp_path / Path("testprodname")).mkdir()
_create_binary_file(tmp_path / Path("testprodname") / "chunk.0", 999)
_create_binary_file(tmp_path / Path("testprodname") / "chunk.2", 948)
output = _check_chunks(
{
tmp_path / Path("testprodname") / "chunk.0": (0, 1000),
tmp_path / Path("testprodname") / "chunk.1": (1000, 2000),
tmp_path / Path("testprodname") / "chunk.2": (2000, 2948),
}
)
assert output is False
def test_reassemble_from_chunks(tmp_path):
(tmp_path / Path("testprodname")).mkdir()
_create_binary_file(tmp_path / Path("testprodname") / "chunk.0", 1000, b"\0")
_create_binary_file(tmp_path / Path("testprodname") / "chunk.1", 1000, b"\1")
_create_binary_file(tmp_path / Path("testprodname") / "chunk.2", 948, b"\2")
output = _reassemble_from_chunks(
{
tmp_path / Path("testprodname") / "chunk.0": (0, 1000),
tmp_path / Path("testprodname") / "chunk.1": (1000, 2000),
tmp_path / Path("testprodname") / "chunk.2": (2000, 2948),
},
tmp_path / "output",
)
assert output.stat().st_size == 2948
with output.open("rb") as outf:
bindata = outf.read()
print(type(bindata))
assert bindata[0] == 0
assert bindata[1000] == 1
assert bindata[2000] == 2
eumdac-3.0.0/tests/test_job_id.py 0000664 0000000 0000000 00000002275 14720105632 0016757 0 ustar 00root root 0000000 0000000 import pytest
from eumdac.job_id import JobIdentifier, JobIdError
def test_register():
uut = JobIdentifier(3)
uut.register("a")
assert 1 == len(uut.registered_objects)
uut.register("b")
assert 2 == len(uut.registered_objects)
uut.register("c")
assert 3 == len(uut.registered_objects)
def test_register_raise_register_same_object_twice():
uut = JobIdentifier(3)
uut.register("a")
with pytest.raises(JobIdError) as exc_info:
uut.register("a")
assert str(exc_info.value) == "Object 'a' already registered."
def test_total_jobs_exceed():
uut = JobIdentifier(1)
uut.register("a")
with pytest.raises(JobIdError) as exc_info:
uut.register("b")
assert (
str(exc_info.value) == "Too many Job IDs requested. Expected a maximum of 1 Job ID requests"
)
def test_job_id_tuple():
uut = JobIdentifier(1)
uut.register("a")
out = uut.job_id_tuple("a")
assert out[0] == 1
def test_request_non_existent_object():
uut = JobIdentifier(1)
uut.register("a")
with pytest.raises(JobIdError) as exc_info:
uut.job_id_tuple("b")
assert str(exc_info.value) == "No Job ID for 'b'. Available ones: ['a']"
eumdac-3.0.0/tests/test_local_datatailor.py 0000664 0000000 0000000 00000003543 14720105632 0021026 0 ustar 00root root 0000000 0000000 import pytest
from eumdac.errors import EumdacError
def test_urls(monkeypatch, tmp_path):
from eumdac.local_tailor import new_url_filename, all_url_filenames, resolve_url, remove_url
from eumdac.token import URLs
test_url_id = "test"
test_url = URLs()
def mock_get_url_path():
return tmp_path
monkeypatch.setattr("eumdac.local_tailor.get_url_path", mock_get_url_path)
test_path = new_url_filename(test_url_id)
assert not test_path.exists()
with test_path.open("w") as tf:
test_url.write(tf)
assert test_path.exists()
# requesting an existing id works
new_url_filename(test_url_id)
# resolving an existing url succeeds
resolve_url(test_url_id)
# remove all urls
url_paths = all_url_filenames()
for up in url_paths:
remove_url(up.stem)
assert not up.exists()
# resolving a removed url raises
with pytest.raises(EumdacError):
resolve_url(test_url_id)
def test_local_tailor(monkeypatch, tmp_path):
from eumdac.local_tailor import (
new_local_tailor,
get_local_tailor,
remove_local_tailor,
is_online,
get_api_url,
)
from eumdac.token import URLs
tailor_id = "test"
tailor_url = "http://NON.EXISTANT:40000"
def mock_get_url_path():
return tmp_path
monkeypatch.setattr("eumdac.local_tailor.get_url_path", mock_get_url_path)
tailor_path = new_local_tailor(tailor_id, tailor_url)
assert tailor_path.exists()
# creating the same tailor_id works
new_local_tailor(tailor_id, tailor_url)
_ = get_local_tailor(tailor_id)
assert is_online(tailor_path) == False
assert get_api_url(tailor_path).startswith(tailor_url)
remove_local_tailor(tailor_id)
# retrieving removed tailor_id fails
with pytest.raises(EumdacError):
get_local_tailor(tailor_id)
eumdac-3.0.0/tests/test_lockfile.py 0000664 0000000 0000000 00000001144 14720105632 0017313 0 ustar 00root root 0000000 0000000 import pytest
import tempfile
import os
from datetime import timedelta
from eumdac.lockfile import open_locked
@pytest.fixture(scope="function")
def lockfile_path(tmp_path):
lockfile = tmp_path / "lockfile"
yield lockfile
if os.path.exists(lockfile):
os.remove(lockfile)
def test_open_lock(lockfile_path):
with open_locked(lockfile_path) as lf:
assert os.path.exists(lockfile_path)
def test_multiple_lock(lockfile_path):
with open_locked(lockfile_path) as lf:
with open_locked(lockfile_path, timeout=timedelta(seconds=1)) as lf2:
assert lf2 is None
eumdac-3.0.0/tests/test_order.py 0000664 0000000 0000000 00000013066 14720105632 0016644 0 ustar 00root root 0000000 0000000 import pytest
from pathlib import Path
from dataclasses import asdict
from eumdac.tailor_models import Chain
from eumdac.order import (
Order,
new_order_filename,
latest_order_file,
all_order_filenames,
highest_number_in_order_filenames,
resolve_order,
get_default_order_dir,
)
from tests.base import FakeProduct, FakeCollection, FakeCustomisation, FakeTailor
order_test_path = Path("test_order.yml")
fake_chain = Chain()
fake_chain.id = "id"
fake_chain.description = "description"
@pytest.fixture
def products():
return [FakeProduct()]
@pytest.fixture
def tailor_order(tmp_path, products):
order = Order(order_file=tmp_path / "test_tailor_order.yml")
order.initialize(
fake_chain,
products=products,
output_dir=tmp_path / "output",
file_pattern=None,
query=None,
)
yield order
order.delete()
@pytest.fixture
def download_order(tmp_path, products):
order = Order(order_file=tmp_path / "test_download_order.yml")
order.initialize(
None, products=products, output_dir=tmp_path / "output", file_pattern=None, query=None
)
yield order
order.delete()
def test_order_status(tailor_order, products):
assert tailor_order.status() == "NOT COMPLETED"
for p in products:
tailor_order.update(None, p._id, "FAILED", None)
assert tailor_order.status() == "FAILED"
for p in products:
tailor_order.update(None, p._id, "DONE", None)
assert tailor_order.status() == "NOT COMPLETED"
for p in products:
tailor_order.update(None, p._id, "DONE", {"fn": "DOWNLOADED"})
assert tailor_order.status() == "DONE"
def test_order_collections(tailor_order, products):
for p in products:
assert p.collection._id in tailor_order.collections()
def test_order_pretty(tailor_order, download_order):
for order in [tailor_order, download_order]:
ps = order.pretty_string(True)
assert str(order) in ps
assert order.status() in ps
assert str(order.collections()) in ps
def test_order_deserialization(tailor_order):
with tailor_order.dict_from_file() as order_dict:
assert isinstance(order_dict, dict)
assert "output_dir" in order_dict
assert "chain" in order_dict
assert "products_to_process" in order_dict
for ptp in order_dict["products_to_process"].values():
assert ptp["col_id"] is not None
assert ptp["server_state"] == "UNSUBMITTED"
assert ptp["customisation"] is None
def test_order_update(tmp_path):
p = tmp_path / order_test_path
collection_id = "test_col_id"
product_id = "test_prod_id"
status = "test_status"
download_states = {"test": "test_download_state"}
query = {"test": "test_query_parameter"}
products = [FakeProduct(id=product_id, collection=FakeCollection(id=collection_id))]
order = Order(order_file=p)
order.initialize(
fake_chain,
products=products,
output_dir=tmp_path / "output",
file_pattern=None,
query=query,
)
order.update(collection_id, product_id, status, download_states)
with order.dict_from_file() as order_dict:
assert isinstance(order_dict, dict)
assert order_dict["query"] == query
for ptp in order_dict["products_to_process"].values():
assert ptp["server_state"] == status
assert ptp["download_states"] == download_states
if p.exists():
p.unlink()
def test_order_remote_delete_failed(tailor_order, products):
with tailor_order.dict_from_file() as order_dict:
for ptp in order_dict["products_to_process"].values():
ptp["server_state"] = "FAILED"
tailor_order._locked_serialize(order_dict)
for p in products:
tailor_order.update("test_customisation", p._id, "FAILED", {"fn": "DOWNLOADED"})
tailor_order.remote_delete_failed(FakeTailor())
def test_order_resolve_product_num(tailor_order, products):
cnt = 1
for p in products:
total_products, num = tailor_order.resolve_product_num(product_id=p._id)
assert total_products >= num
assert num == cnt
cnt += 1
with pytest.raises(KeyError):
_, __ = tailor_order.resolve_product_num(product_id="INVALID")
def test_order_filehandling(tmp_path):
path_order_dir = get_default_order_dir()
assert path_order_dir.exists()
order_filename1 = new_order_filename(path_order_dir)
assert order_filename1.exists()
order = Order(order_filename1)
collection_id = "test_col_id"
product_id = "test_prod_id"
products = [FakeProduct(id=product_id, collection=FakeCollection(id=collection_id))]
order.initialize(
fake_chain,
products=products,
output_dir=tmp_path / "output",
file_pattern=None,
query=None,
)
assert order_filename1.exists()
order_filename2 = new_order_filename(path_order_dir)
assert order_filename2.exists()
assert order_filename2 != order_filename1
order = Order(order_filename2)
collection_id = "test_col_id"
product_id = "test_prod_id"
products = [FakeProduct(id=product_id, collection=FakeCollection(id=collection_id))]
order.initialize(
fake_chain,
products=products,
output_dir=tmp_path / "output",
file_pattern=None,
query=None,
)
assert order_filename2.exists()
o = resolve_order(path_order_dir, "latest")
assert o._order_file == order._order_file
if order_filename1.exists():
order_filename1.unlink()
if order_filename2.exists():
order_filename2.unlink()
eumdac-3.0.0/tests/test_order_concurrency.py 0000664 0000000 0000000 00000004415 14720105632 0021254 0 ustar 00root root 0000000 0000000 from pathlib import Path
from eumdac.order import (
Order,
)
import concurrent.futures
from tests.base import FakeProduct, FakeCollection
def update_order(order, cid, pid, status, download_state):
if download_state:
download_states = {pid: download_state}
else:
download_states = None
order.update(
customisation_id=cid, product_id=pid, status=status, download_states=download_states
)
def test_order_concurrency(tmp_path):
products = []
for i in range(0, 2):
products.append(FakeProduct(id=str(i), collection=FakeCollection(str(i))))
for repetitions in range(0, 100):
o = Order(tmp_path / str(repetitions))
o.initialize(
chain=None, products=products, output_dir=Path("."), file_pattern=None, query=None
)
for p in products:
o.update(
customisation_id=p.collection._id,
product_id=p._id,
status="INIT",
download_states={p._id: "INIT"},
)
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
f_res1 = [
executor.submit(update_order, o, p.collection._id, p._id, "MOD", None)
for p in products
]
concurrent.futures.wait(
f_res1, timeout=None, return_when=concurrent.futures.ALL_COMPLETED
)
f_res2 = [
executor.submit(update_order, o, p.collection._id, p._id, None, "MOD")
for p in products
]
concurrent.futures.wait(
f_res2, timeout=None, return_when=concurrent.futures.ALL_COMPLETED
)
with o.dict_from_file() as order_d:
for product_id in order_d["products_to_process"].keys():
ss = order_d["products_to_process"][product_id]["server_state"]
if "download_states" in order_d["products_to_process"][product_id]:
download_states = order_d["products_to_process"][product_id]["download_states"]
dl_complete = [
True if ds == "MOD" else False for ds in download_states.values()
]
assert all(dl_complete)
assert ss == "MOD"
eumdac-3.0.0/tests/test_product.py 0000664 0000000 0000000 00000007736 14720105632 0017220 0 ustar 00root root 0000000 0000000 from datetime import datetime
from eumdac.token import AccessToken
from eumdac.datastore import DataStore
from eumdac.product import Product
from .base import DataServiceTestCase
class TestProduct(DataServiceTestCase):
collection_id = "EO:EUM:DAT:MSG:HRSEVIRI"
product_id = "MSG4-SEVI-MSG15-0100-NA-20221010104242.601000000Z-NA"
product_manifest = b"""
Data
Native
271175723
MSG4-SEVI-MSG15-0100-NA-20221010104242.601000000Z-NA.nat
EOPMetadata.xml
"""
def setUp(self):
super().setUp()
self.token = AccessToken(self.credentials)
self.datastore = DataStore(token=self.token)
self.product = Product(self.collection_id, self.product_id, self.datastore)
def test_string_representation(self):
self.assertEqual(self.product_id, str(self.product))
self.assertTrue(self.product_id in repr(self.product))
def test_download_entry(self):
with self.product.open("manifest.xml") as file:
filename = file.name
content = file.read()
self.assertEqual(filename, "manifest.xml")
self.assertEqual(content, self.product_manifest)
def test_properties(self):
collection = self.product.collection
self.assertEqual(str(collection), self.collection_id)
self.assertIsInstance(self.product.sensing_start, datetime)
self.assertIsInstance(self.product.sensing_end, datetime)
self.assertTrue(self.product.satellite.startswith("MSG"))
self.assertEqual(self.product.instrument, "SEVIRI")
self.assertIsInstance(self.product.size, int)
self.assertIsInstance(self.product.metadata, dict)
self.assertIn("properties", self.product.metadata)
self.assertIn("manifest.xml", self.product.entries)
self.assertIsInstance(self.product.acronym, str)
self.assertIsInstance(self.product.product_type, str)
self.assertEqual(self.product.product_type, self.product.acronym)
self.assertIsNone(self.product.timeliness)
self.assertIsInstance(self.product.md5, str)
self.assertIsInstance(self.product.processingTime, str)
self.assertIsInstance(self.product.processorVersion, str)
self.assertIsInstance(self.product.format, str)
self.assertIsInstance(self.product.qualityStatus, str)
self.assertIsInstance(self.product.ingested, datetime)
self.assertIsInstance(self.product.orbit_type, str)
self.assertIsInstance(self.product.orbit_is_LEO, bool)
self.assertIsInstance(self.product.url, str)
# These are none for GEO products
self.assertIsNone(self.product.orbit_number)
self.assertIsNone(self.product.orbit_direction)
self.assertIsNone(self.product.relative_orbit)
self.assertIsNone(self.product.cycle_number)
def test_camparison(self):
seviri_rss = Product(
"EO:EUM:DAT:MSG:MSG15-RSS",
"MSG2-SEVI-MSG15-0100-NA-20211013140918.098000000Z-NA",
self.datastore,
)
avhrr_l1 = Product(
"EO:EUM:DAT:METOP:AVHRRL1",
"AVHR_xxx_1B_M01_20211014082503Z_20211014100403Z_N_O_20211014091048Z",
self.datastore,
)
avhrr_l1_other = Product(
"EO:EUM:DAT:METOP:AVHRRL1",
"AVHR_xxx_1B_M01_20210206061303Z_20210206075503Z_N_O_20210206065931Z",
self.datastore,
)
self.assertLess(avhrr_l1, seviri_rss)
self.assertNotEqual(avhrr_l1, seviri_rss)
self.assertLess(avhrr_l1_other, avhrr_l1)
self.assertNotEqual(avhrr_l1_other, avhrr_l1)
eumdac-3.0.0/tests/test_request.py 0000664 0000000 0000000 00000003606 14720105632 0017220 0 ustar 00root root 0000000 0000000 import pytest
import datetime
import json
import requests
from eumdac.request import get, post, patch, put, delete
class MockResponse:
def __init__(self, status_code, text=None):
self.status_code = status_code
self.text = text
def test_request_calls(monkeypatch):
def mock_session_call(*args, **kwargs):
return MockResponse(200)
monkeypatch.setattr(requests.Session, "get", mock_session_call)
monkeypatch.setattr(requests.Session, "post", mock_session_call)
monkeypatch.setattr(requests.Session, "patch", mock_session_call)
monkeypatch.setattr(requests.Session, "put", mock_session_call)
monkeypatch.setattr(requests.Session, "delete", mock_session_call)
assert get("https://test.test").status_code == 200
assert post("https://test.test").status_code == 200
assert patch("https://test.test").status_code == 200
assert put("https://test.test").status_code == 200
assert delete("https://test.test").status_code == 200
@pytest.mark.parametrize("message", [0, 1, 2])
def test_request_should_retry(message):
jsons = [
{
"message": {
"retryAfter": (datetime.timedelta(seconds=5) + datetime.datetime.now()).timestamp()
* 1000,
"reason": "test",
}
},
{
"message": {
"reason": "Maximum number of connections exceeded",
}
},
{
"message": {
"reason": "Maximum number of requests exceeded",
}
},
]
from eumdac.request import _should_retry
r = MockResponse(429, json.dumps(jsons[message]))
assert _should_retry(r, 1)
@pytest.mark.parametrize("status_code", [200, 400, 500])
def test_request_should_not_retry(status_code):
from eumdac.request import _should_retry
r = MockResponse(status_code)
assert not _should_retry(r)
eumdac-3.0.0/tests/test_tailor_app.py 0000664 0000000 0000000 00000026526 14720105632 0017670 0 ustar 00root root 0000000 0000000 import pytest
from datetime import timedelta
from eumdac.customisation import CustomisationError
from eumdac.tailor_app import (
WaitForDoneCustomisationFutureFunc,
InvalidStateTransitionError,
DownloadRunFutureFunc,
StateQueryFutureFunc,
FatalEumdacError,
ExceedingNumberOfCustomisationsEumdacError,
TailorApp,
)
from eumdac.errors import EumdacError
from eumdac.job_id import JobIdentifier
from tests.base import FakeProduct, FakeCollection, FakeCustomisation, FakeTailor, FakeStore
from tests.test_order import tailor_order, products
class MockOrder:
def __init__(self):
self._no_warning_logs = True
pass
def initialize(self, chain, products, output_dir, no_warning_logs):
pass
def __str__(self):
return "test"
def deserialize(self):
return {"max_workers": 3}
def serialize(self, d):
pass
def update(self, customisation_id, product_id, status=None, download_states=None):
pass
def resolve_product_num(self, p_id):
return -1, -1
valid_transitions = [
["RUNNING", "DONE"],
["QUEUED", "RUNNING", "DONE"],
["QUEUED", "QUEUED", "QUEUED", "RUNNING", "DONE"],
["QUEUED", "QUEUED", "QUEUED", "RUNNING", "RUNNING", "RUNNING", "DONE", "DONE"],
]
@pytest.mark.parametrize("transitions", valid_transitions)
def test_valid_transitions(transitions):
def add_func(product):
return FakeCustomisation(states_to_return=transitions)
WaitForDoneCustomisationFutureFunc(
customization_add_func=add_func,
order=MockOrder(),
polling_interval=0,
job_identificator=JobIdentifier(total_jobs=1),
)(FakeProduct())
invalid_transitions = [
["RUNNING", "QUEUED"],
]
@pytest.mark.parametrize("transitions", invalid_transitions)
def test_invalid_transitions(transitions):
with pytest.raises(InvalidStateTransitionError):
def add_func(product):
return FakeCustomisation(states_to_return=transitions)
WaitForDoneCustomisationFutureFunc(
customization_add_func=add_func,
order=MockOrder(),
polling_interval=0,
job_identificator=JobIdentifier(total_jobs=1),
)(FakeProduct())
from itertools import cycle
timeout_transitions = [
cycle(["QUEUED"]),
cycle(["RUNNING"]),
]
@pytest.mark.parametrize("transitions", timeout_transitions)
def test_timeout_raised(transitions):
with pytest.raises(FatalEumdacError):
def mock_add_func(product):
return FakeCustomisation(transitions)
WaitForDoneCustomisationFutureFunc(
customization_add_func=mock_add_func,
order=MockOrder(),
timeout=0.001,
job_identificator=JobIdentifier(total_jobs=1),
)(FakeProduct())
inactive_transitions = [
cycle(["RUNNING", "INACTIVE"]),
cycle(["QUEUED", "INACTIVE"]),
]
@pytest.mark.parametrize("transitions", inactive_transitions)
def test_inactive_transitions(transitions):
with pytest.raises(EumdacError):
def mock_add_func(product):
return FakeCustomisation(transitions)
fut = WaitForDoneCustomisationFutureFunc(
customization_add_func=mock_add_func,
order=MockOrder(),
timeout=1000,
job_identificator=JobIdentifier(total_jobs=1),
)
fut(FakeProduct())
assert fut.state.name == "INACTIVE"
class FakeAdd:
def __init__(self):
self.exception_cnt = 0
def func(self, product):
if isinstance(product, tuple):
exc, max_cnt = product
if self.exception_cnt >= max_cnt:
return FakeCustomisation([])
self.exception_cnt += 1
raise CustomisationError("Could not add customisation")
return FakeCustomisation([])
eumdac_error_descriptions = [
{
"status": 400,
"title": "invalid value for parameter",
"description": "PNG (RGB) driver doesn't support 11 bands. Must be 1 (grey) or 3 (rgb) bands",
},
{
"status": 400,
"title": "invalid value for parameter",
"description": "The roi value can not be a list",
},
]
@pytest.mark.parametrize("description", eumdac_error_descriptions)
def test_concurrent_download_fail_400(description):
products = [
FakeProduct(),
]
order = MockOrder()
output_dir = "out"
token = None
def mock_add_func(product):
raise EumdacError("Test", description)
with pytest.raises(FatalEumdacError):
WaitForDoneCustomisationFutureFunc(
customization_add_func=mock_add_func,
order=MockOrder(),
job_identificator=JobIdentifier(total_jobs=1),
)(FakeProduct())
class FakeFailCustomisation(FakeCustomisation):
def __init__(self, logfile, cid=None):
self.states_to_return = iter(["QUEUED", "RUNNING", "FAILED"])
self.logfile = logfile
self._id = cid or "foo"
self.deleted = False
class FakeFailCustomisationProduct:
def __init__(self, customisation, product):
self.customisation = customisation
self.product = product
eumdac_error_logs = [
"""
2022-07-14 07:37:52 - PROCESSING.chain_runner[270] - INFO - Start process "fb6bdb44"
2022-07-14 07:37:52 - PROCESSING.chain_runner[231] - INFO - WORKER: tcp://10.0.3.141:40353
2022-07-14 07:37:52 - PROCESSING.chain_runner[232] - INFO - PID: 26
2022-07-14 07:37:52 - PROCESSING.chain_runner[233] - INFO - backend: epct_gis_hrit
2022-07-14 07:37:52 - PROCESSING.chain_runner[234] - INFO - user: delahoz
2022-07-14 07:38:04 - PROCESSING.preprocessing[56] - INFO - download from https://api.eumetsat.int/data/download/collections/EO%3AEUM%3ADAT%3AMSG%3AHRSEVIRI/products/MSG4-SEVI-MSG15-0100-NA-20220601004243.155000000Z-NA is finished
2022-07-14 07:38:07 - PROCESSING.chain_runner[401] - INFO - customisation time: 14 - process: fb6bdb44
2022-07-14 07:38:07 - PROCESSING.chain_runner[403] - ERROR - error at preprocessing.initialise_processing[516] while initializing the customization for product(s) [MSG4-SEVI-MSG15-0100-NA-20220601004243.155000000Z-NA] and for configuration {'product': 'HRSEVIRI_HRIT', 'format': 'png_rgb'}: invalid HRIT file name: '/var/dtws/users/delahoz/workspace/EPCT_HRSEVIRI_HRIT_fb6bdb44/decompressed_data/MSG4-SEVI-MSG15-0100-NA-20220601004243.155000000Z-NA.nat'
""",
"""
2022-07-14 08:14:19 - PROCESSING.api[403] - INFO - Submitted process 53a71aea - FUTURE: run_chain_async-e24f66fb1ab913b7761f9ac62b4ee281
2022-07-14 08:14:21 - PROCESSING.chain_runner[270] - INFO - Start process "53a71aea"
2022-07-14 08:14:21 - PROCESSING.chain_runner[231] - INFO - WORKER: tcp://10.0.3.151:33526
2022-07-14 08:14:21 - PROCESSING.chain_runner[232] - INFO - PID: 26
2022-07-14 08:14:21 - PROCESSING.chain_runner[233] - INFO - backend: epct_gis_eps_grib2
2022-07-14 08:14:21 - PROCESSING.chain_runner[234] - INFO - user: delahoz
2022-07-14 08:14:39 - PROCESSING.preprocessing[56] - INFO - download from https://api.eumetsat.int/data/download/collections/EO%3AEUM%3ADAT%3AMETOP%3AAVHRRL1/products/AVHR_xxx_1B_M03_20220709215503Z_20220709233703Z_N_O_20220709233331Z is finished
2022-07-14 08:14:50 - PROCESSING.preprocessing[523] - INFO - Processing details - product: AVHRRL1 chain-name: None chain-details: -product: AVHRRL1 -format: GRIB-2 -compression: Internal compression (HDF5 or NetCDF4)
2022-07-14 08:14:50 - PROCESSING.preprocessing[530] - INFO - Input products: AVHR_xxx_1B_M03_20220709215503Z_20220709233703Z_N_O_20220709233331Z.nat
2022-07-14 08:14:51 - PROCESSING.epct_gis[991] - INFO - Expected steps: ['import', 'format']
2022-07-14 08:14:51 - PROCESSING.epct_gis[994] - INFO - Starting step "IMPORT" 1/2 ...
2022-07-14 08:14:54 - PROCESSING.vrt[94] - INFO - Command line and its output ...
2022-07-14 08:14:54 - PROCESSING.epct_gis[998] - INFO - ... step "IMPORT" finished!
2022-07-14 08:14:54 - PROCESSING.epct_gis[1006] - INFO - Starting step "FORMAT" 2/2 ...
2022-07-14 08:14:54 - PROCESSING.vrt[94] - INFO - Command line and its output ...
2022-07-14 08:15:05 - PROCESSING.epct_gis[802] - INFO - ... step "FORMAT" finished!
2022-07-14 08:15:05 - PROCESSING.vrt[94] - INFO - Command line and its output ...
ERROR 6: Source dataset must have a geotransform
2022-07-14 08:15:05 - PROCESSING.vrt[94] - INFO - Command line and its output ...
ERROR 6: Source dataset must have a geotransform
2022-07-14 08:15:05 - PROCESSING.chain_runner[401] - INFO - customisation time: None - process: 53a71aea
2022-07-14 08:15:05 - PROCESSING.chain_runner[403] - ERROR - error at epct_gis.run_chain[1014] while performing the customization for product(s) [AVHR_xxx_1B_M03_20220709215503Z_20220709233703Z_N_O_20220709233331Z.nat] and for configuration {'product': 'AVHRRL1', 'format': 'grib2', 'compression': 'internal'}: INTERNAL ERROR: see Log file
""",
]
@pytest.mark.parametrize("log", eumdac_error_logs)
def test_wait_for_done_fail(log):
def mock_add_func(product):
return FakeFailCustomisation(logfile=log)
with pytest.raises(FatalEumdacError):
WaitForDoneCustomisationFutureFunc(
order=MockOrder(),
customization_add_func=mock_add_func,
job_identificator=JobIdentifier(total_jobs=1),
)(FakeProduct())
def test_state_query():
collection_id = "coid"
customisation_id = "cuid"
product_id = "pid"
success, customisation, product = StateQueryFutureFunc()(
product_id,
{"col_id": collection_id, "customisation": customisation_id},
FakeTailor(),
FakeStore(),
)
assert success
assert customisation._id == customisation_id
assert product._id == product_id
assert product.collection._id == collection_id
def test_resume(tailor_order):
ta = TailorApp(tailor_order, FakeStore(), FakeTailor())
for pi in tailor_order.iter_product_info():
assert pi.p_dict["server_state"] == "UNSUBMITTED"
ta.resume()
for pi in tailor_order.iter_product_info():
assert pi.p_dict["server_state"] == "DONE"
for fn, ds in pi.p_dict["download_states"].items():
assert ds == "DOWNLOADED"
@pytest.mark.parametrize("status_code,message,description", [(200, "test", "test")])
def test_check_nonfatal_error_response(tailor_order, status_code, message, description):
from eumdac.tailor_app import check_error_response
extra_info = {"description": description, "status": status_code}
err = EumdacError(message, extra_info)
check_error_response(err)
@pytest.mark.parametrize("status_code,message,description", [(400, "test", "test")])
def test_check_fatal_error_response(tailor_order, status_code, message, description):
from eumdac.tailor_app import check_error_response
extra_info = {"description": description, "status": status_code}
err = EumdacError(message, extra_info)
with pytest.raises(FatalEumdacError):
check_error_response(err)
@pytest.mark.parametrize(
"status_code,message,description", [(500, "test", "You are exceeding your maximum number 123")]
)
def test_check_fatal_error_response(tailor_order, status_code, message, description):
from eumdac.tailor_app import check_error_response
extra_info = {"description": description, "status": status_code}
err = EumdacError(message, extra_info)
with pytest.raises(ExceedingNumberOfCustomisationsEumdacError):
check_error_response(err)
eumdac-3.0.0/tests/test_token.py 0000664 0000000 0000000 00000005240 14720105632 0016644 0 ustar 00root root 0000000 0000000 import unittest
import time
from datetime import datetime
from responses import RequestsMock, _ensure_url_default_path
from eumdac.token import AccessToken
from .base import DataServiceTestCase, INTEGRATION_TESTING
import requests
class TestAccessToken(DataServiceTestCase):
def setUp(self):
super().setUp()
self.token = AccessToken(self.credentials)
def test_str_representation(self):
self.assertEqual(str(self.token), self.token.access_token)
@unittest.skipIf(INTEGRATION_TESTING, "Avoid revoking tokens on integration")
def test_revoke_not_expired(self):
token_url = self.token.urls.get("token", "token")
revoke_url = self.token.urls.get("token", "revoke")
self.token = AccessToken(self.credentials)
str(self.token)
# token cached, only 1 request
str(self.token)
# revoke token
self.token._revoke()
str(self.token)
str(self.token)
str(self.token)
# 1 revoke, 1 token request, then cached
self.requests_mock.assert_call_count(token_url, 2)
self.requests_mock.assert_call_count(revoke_url, 1)
def test_expired_token(self):
token_url = self.token.urls.get("token", "token")
revoke_url = self.token.urls.get("token", "revoke")
self.token = AccessToken(self.credentials, validity=15)
str(self.token)
time.sleep(30)
str(self.token)
# new token requested at least once
# (can't know how many times it'll be called, depends on server)
self._assert_was_called(self.requests_mock, token_url)
# no revoking
self.requests_mock.assert_call_count(revoke_url, 0)
def test_properties(self):
now = datetime.now()
access_token = self.token.access_token
expiration = self.token.expiration
self.assertIsInstance(access_token, str)
self.assertIsInstance(expiration, datetime)
self.assertLessEqual(now, self.token.expiration)
@unittest.skipIf(INTEGRATION_TESTING, "Check against changing value!")
def test_auth(self):
mock_token = "1f29ecb3-5973-35d5-a7e6-ec3348c9c49a"
self.token._access_token = mock_token
self.token._expiration = time.time() + 1000
request = requests.Request("GET", "some-url")
self.token.auth(request)
auth_header = request.headers.get("authorization")
self.assertEqual(auth_header, f"Bearer {mock_token}")
def _assert_was_called(self, requests_mock: RequestsMock, url: str):
call_count = len(
[1 for call in requests_mock.calls if call.request.url == _ensure_url_default_path(url)]
)
assert call_count > 0
eumdac-3.0.0/tox.ini 0000664 0000000 0000000 00000002771 14720105632 0014272 0 ustar 00root root 0000000 0000000 [tox]
requires = tox-conda
envlist = linters,typing,docstrings,py37,py38,py39,py310,py311,py312,report
[testenv]
setenv =
{py37,py38,py39,py310,py311,py312}: COVERAGE_FILE=.coverage.{envname}
allowlist_externals =
pytest
commands = pytest --cov eumdac/ --cov-report=term-missing --full-trace
extras = test
conda_channels =
conda-forge
conda_install_args =
--override-channels
conda_create_args =
--override-channels
[testenv:integration]
description = Run full integration tests against the real services
basepython = python3.9
recreate = true
setenv =
INTEGRATION_TESTING=on
commands = pytest --full-trace
passenv =
CONSUMER_KEY
CONSUMER_SECRET
[testenv:report]
description = Report combined findings using 'coverage'
depends = py37,py38,py39,py310,py311,py312
allowlist_externals =
coverage
deps = coverage
skip_install = true
commands =
coverage combine
coverage report
coverage xml
[testenv:linters]
description = Check code style using 'black'
deps =
black~=23.3.0
skip_install = true
commands =
black --line-length 100 --check --diff --color eumdac/ tests/ setup.py
[testenv:typing]
description = Check types using 'mypy'
basepython = python3.9
deps =
mypy
types-requests<2.32.0.20240905
types-PyYAML
commands =
python -m mypy --config-file=mypy.ini -p eumdac
[testenv:docstrings]
description = Check docstrings coverage using 'interrogate'
deps =
interrogate
skip_install = true
commands =
interrogate eumdac -v -c interrogate.cfg
eumdac-3.0.0/win/ 0000775 0000000 0000000 00000000000 14720105632 0013545 5 ustar 00root root 0000000 0000000 eumdac-3.0.0/win/eumdac-logo.png 0000664 0000000 0000000 00000023071 14720105632 0016452 0 ustar 00root root 0000000 0000000 PNG
IHDR \rf pHYs 8 8 vY tEXtSoftware www.inkscape.org< IDATx{x\U?'iҦLR@-m23`S m&-hTr P9ro؊>(7XL"/H LR+LK.#\f3kGuY3`w=ʨfWV<l~wT-Tע p : h
H#x@n$ L埗Zh啁?.d1a^: {>G- `>LӭU SQ} f9mO;߈@C02"31iv7߾}&!@iBmb*}4 ʳ~X
i,yv._(t:
aW 9} M_q('?
H&pt";ӯϖɺvLZ;E'
4 8kNJqkwWM `cڀkT́LӞ ꮹMkvt2ks^'P "
ZbXG7)XtA!? 5DDɤ"j@#T+p .v \
sM-' y.1s&pN,x B-tMuw.f~<` `r @L/&Pq W4' G7K'b;USAr" $AI'heZ\ҐĘ9?Y/}$O=ƭp.RXԉz
i Qi`.֚_e1` . A
q"z$5^.gz7I;މ% ""e96xLii'ãYm}}` _kA[Lx >!4Jz{;gBf|z-H B_ .YhQ=j&WJfuIo,Џ3ot3|1L2|jp< >o1 ߵ!92p0^w=E [8l_ 90<}1gyl>@F6]؛d.pj&X`| >q"# "W}5U~ԅZ ?!L2cň:į
G'=crWrkk9P}8r3FXdwec@7qEНd*G
>ԲBZ\$ˌF5ݺ~v>o;z'6t#@]J; icN!MlX 5
"\势 u3;y~Fө{ngLG :O7Nн5r[>E-Aw- /s]ZWa+ Sl۪;U9rPWQ9;o123yfkm}( =$_yTU> )9} ; 'ժ\&(udI
B N e ta&dܬ{Ea Y
`bTv ~ԗZL|L~gԇZ.!?_> 7֮
0Z -~QA^@ذvLy& s>cO^B-w0P|VuKuIDDP)S"r< ^Z@us_7W VQܷSO`bow bCTŹ^W 0htm{&@ݵ2b;fe=Dz O=35cWtqZʀ糽&1x5n; T4a{Uc~ KENBض- \ dg ~`wrW:
E3 |Yk⓭ ΟI͖J3^ L[Po/9a=e__(6V8X
~ 3V:muD]3\SH8Gwk\;GwC$ \^ D"r/ "to?_w u0DALڦr]AH 'Aʸ=z)W-J(EDD`Gt!Fbj b{0 2 Yyץs+
P`d|*Ќr@v*Lgwu@Ѻkv4/d^V{VH [# ,`yn@YK"ޝ][H U z.?p jqBby] qY@1 aaQ'\N:@v(]WuF D0
@tS: [ ( K4%$c.$
]Cu5{qr b8&Qpɬ۶.m>ݝ] @E9՛t D 3 K "2鮡LX & = ( Sw
_M'/ ( 6]k(u̸)ݡ ($k֭d[2 ڝ@:JH'b7$
& (5,c鮣H aJ
d( Ɣ]B ܗI̹L;G:1. =Etג?tReH Ak `0 }kA +k $
.eU
:0@('5w1aAw
@Q -,K e3kH Awgt#Nu Vw C$ ]u \a㺋"P$Ykt \ ۷.b@`> 3tp ">bCŰ~I ȶU%<Rr7f 2W!=G&-]. Dt]E% !=
`/ 4;x @8 0n],$OnF)J#?9Oap?:_W]c{P~/
pY*V&D Cs XC1@&MPN{ya: [w!< cL!
fd橙d{9x: 9H?hjXK:4\>x V~8iuwz P9{< !`X]BЊꚾl~-ݕy; @6"2U^g
ܖI أ16o [w`f&ź/}T: AO@:41]!a*ѾA 2 I\U d\:EJ. o 3saW1U3rZsJ2 oȢˊ9f <],KO H%cb+[|j:BDat s@9{0͚|| EB #{ݵzEE X-W1Dkё-B {!}/iM2NJcˊ4p
!OD}kqO> Eq] xf /@d۶re B l :!aeќL SxN `f$V}?η/ ًS [.XY H'W]Ä;lvÌRr/ Lm[,&? F䵏ћNƮd /{Lߜ̦/.$ F L|1xf[ATbM` ^ = {+- sla7Q13>]$ r t`Mw \s®dyŸ WN3d OA DP&[" E^ cN'bgq3ǡsp}uMT; ܥ2 ]_2EI":Lz9@jV;Im %_"TژY ;s4T5\$T5^8jO ՕU.f2Q2E)3ʣUg- gj@TJ;@&(uTՈV) ڸևԮ_D&(iLǩ\>ڼU
r=@Px^QV䧫lv!_x)]O#[ ,ձMD6dr >t?NiNW^L~QN &U֎C Y6nV^U)4ɿO/137aPlqaϮQ 'pR&fmܜI -J!jA1 Qr X zEq͖2Cg8TFr tw6 ئ҆,89jL~IdAu =/v= WIy5(|j_JtkP??
!bv_0w!o$;k^zzpiX ٴʵ> 9
}UoĠ7}vc oު҆X55'STnPs1d,3Z#\.Y`b \eL"]`6kwwFGC`e@k6 EZ7FӢfǮ `,d;a.I?O5< A6 xcn̒q@?`.ڎsW 7ĺrCƝ\B23 t%> 4q+ KYjcݷ]^
dv|[+68jAS "ǪbD>ȇ9
jR*]yPb<"j) ģí yU A]5BՕU= Ey,^ Y\v \IĖ8R GzKZND稶# z JG # q!*^{Mv9 ;㱿2RM+ !Ue mQ}: 8 07CqQeoU 6f,o xwC`{ Qv֫@N[kvc; N
v2說4 IDAT@v 5`"f4 `5 z쵦C-;Z.Cao 0RP]/
D4/lN >QHhFQ v
d|(H @&{6W2@2'k
-- (n5Ī :QK 2f`zfs @wՇ[ov&!t\l1=`.8zֱ#[D,M'O2M/ k[ޝ
?7qO?x(lW4&.?n0}.߾x+_s6!6ގ=3ڻ9/#)j '0@Ġ7wt;ПѬq}ׁp3cP=юW {`GN
f `\y#@P n0 WJ.+fZ .w$@gv[[&!Շ,@ƉN@[sϑh !`?An&;&W-6Ck[L7+#b= JbZJ M`|6S, Z&nm]H< C#U>+ 1M?ij0dbS* + } yl;&Dzؼ=չzbr R߸(>>)(Qh 1 ̒=FU&N5ٺKQą ll#1ݟG_]L>J2 Tn9:bA IxNu0A'҉9ϖʾ% 2%2a y *3u0>[;NU f7$Ec@h$ 52p$ JY0 DoLz&wu.: 2)