Coverage for tests / test_exprParserYacc.py: 8%

1# This file is part of daf_butler. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (https://www.lsst.org). 

6# See the COPYRIGHT file at the top-level directory of this distribution 

7# for details of code ownership. 

8# 

9# This software is dual licensed under the GNU General Public License and also 

10# under a 3-clause BSD license. Recipients may choose which of these licenses 

11# to use; please see the files gpl-3.0.txt and/or bsd_license.txt, 

12# respectively. If you choose the GPL option then the following text applies 

13# (but note that there is still no warranty even if you opt for BSD instead): 

14# 

15# This program is free software: you can redistribute it and/or modify 

16# it under the terms of the GNU General Public License as published by 

17# the Free Software Foundation, either version 3 of the License, or 

18# (at your option) any later version. 

19# 

20# This program is distributed in the hope that it will be useful, 

21# but WITHOUT ANY WARRANTY; without even the implied warranty of 

22# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

23# GNU General Public License for more details. 

24# 

25# You should have received a copy of the GNU General Public License 

26# along with this program. If not, see <https://www.gnu.org/licenses/>. 

27 

28"""Simple unit test for exprParser subpackage module.""" 

29 

30import unittest 

31from itertools import chain 

32 

33import astropy.time 

34 

35from lsst.daf.butler.queries.expressions.parser import ( 

36 ParseError, 

37 ParserYacc, 

38 ParserYaccError, 

39 TreeVisitor, 

40 exprTree, 

41) 

42from lsst.daf.butler.queries.expressions.parser.parserYacc import _parseTimeString 

43 

44 

45class _Visitor(TreeVisitor): 

46 """Trivial implementation of TreeVisitor.""" 

47 

48 def visitNumericLiteral(self, value, node): 

49 return f"N({value})" 

50 

51 def visitStringLiteral(self, value, node): 

52 return f"S({value})" 

53 

54 def visitTimeLiteral(self, value, node): 

55 return f"T({value})" 

56 

57 def visitUuidLiteral(self, value, node): 

58 return f"UUID({value})" 

59 

60 def visitRangeLiteral(self, start, stop, stride, node): 

61 if stride is None: 

62 return f"R({start}..{stop})" 

63 else: 

64 return f"R({start}..{stop}:{stride})" 

65 

66 def visitIdentifier(self, name, node): 

67 return f"ID({name})" 

68 

69 def visitBind(self, name, node): 

70 return f":({name})" 

71 

72 def visitUnaryOp(self, operator, operand, node): 

73 return f"U({operator} {operand})" 

74 

75 def visitBinaryOp(self, operator, lhs, rhs, node): 

76 return f"B({lhs} {operator} {rhs})" 

77 

78 def visitIsIn(self, lhs, values, not_in, node): 

79 values = ", ".join([str(val) for val in values]) 

80 if not_in: 

81 return f"!IN({lhs} ({values}))" 

82 else: 

83 return f"IN({lhs} ({values}))" 

84 

85 def visitParens(self, expression, node): 

86 return f"P({expression})" 

87 

88 def visitPointNode(self, ra, dec, node): 

89 return f"POINT({ra}, {dec})" 

90 

91 def visitCircleNode(self, ra, dec, radius, node): 

92 return f"CIRCLE({ra}, {dec}, {radius})" 

93 

94 def visitBoxNode(self, ra, dec, width, height, node): 

95 return f"BOX({ra}, {dec}, {width}, {height})" 

96 

97 def visitPolygonNode(self, vertices, node): 

98 params = ", ".join(str(param) for param in chain.from_iterable(vertices)) 

99 return f"POLYGON({params})" 

100 

101 def visitRegionNode(self, pos, node): 

102 return f"REGION({pos})" 

103 

104 def visitTupleNode(self, expression, node): 

105 return f"TUPLE({expression})" 

106 

107 def visitGlobNode(self, expression, pattern, node): 

108 return f"GLOB({expression}, {pattern})" 

109 

110 

111class ParserYaccTestCase(unittest.TestCase): 

112 """A test case for ParserYacc""" 

113 

114 def setUp(self): 

115 pass 

116 

117 def tearDown(self): 

118 pass 

119 

120 def testInstantiate(self): 

121 """Tests for making ParserLex instances""" 

122 parser = ParserYacc() # noqa: F841 

123 

124 def testEmpty(self): 

125 """Tests for empty expression""" 

126 parser = ParserYacc() 

127 

128 # empty expression is allowed, returns None 

129 tree = parser.parse("") 

130 self.assertIsNone(tree) 

131 

132 def testParseLiteral(self): 

133 """Tests for literals (strings/numbers)""" 

134 parser = ParserYacc() 

135 

136 tree = parser.parse("1") 

137 self.assertIsInstance(tree, exprTree.NumericLiteral) 

138 self.assertEqual(tree.value, "1") 

139 self.assertEqual(str(tree), "1") 

140 

141 tree = parser.parse(".5e-2") 

142 self.assertIsInstance(tree, exprTree.NumericLiteral) 

143 self.assertEqual(tree.value, ".5e-2") 

144 self.assertEqual(str(tree), ".5e-2") 

145 

146 tree = parser.parse("'string'") 

147 self.assertIsInstance(tree, exprTree.StringLiteral) 

148 self.assertEqual(tree.value, "string") 

149 self.assertEqual(str(tree), "'string'") 

150 

151 tree = parser.parse("10..20") 

152 self.assertIsInstance(tree, exprTree.RangeLiteral) 

153 self.assertEqual(tree.start, 10) 

154 self.assertEqual(tree.stop, 20) 

155 self.assertEqual(tree.stride, None) 

156 self.assertEqual(str(tree), "10..20") 

157 

158 tree = parser.parse("-10 .. 10:5") 

159 self.assertIsInstance(tree, exprTree.RangeLiteral) 

160 self.assertEqual(tree.start, -10) 

161 self.assertEqual(tree.stop, 10) 

162 self.assertEqual(tree.stride, 5) 

163 self.assertEqual(str(tree), "-10..10:5") 

164 

165 # more extensive tests of time parsing is below 

166 tree = parser.parse("T'51544.0'") 

167 self.assertIsInstance(tree, exprTree.TimeLiteral) 

168 self.assertEqual(tree.value, astropy.time.Time(51544.0, format="mjd", scale="tai")) 

169 self.assertEqual(str(tree), "T'51544.0'") 

170 

171 tree = parser.parse("T'2020-03-30T12:20:33'") 

172 self.assertIsInstance(tree, exprTree.TimeLiteral) 

173 self.assertEqual(tree.value, astropy.time.Time("2020-03-30T12:20:33", format="isot", scale="utc")) 

174 self.assertEqual(str(tree), "T'2020-03-30T12:20:33.000'") 

175 

176 def testParseIdentifiers(self): 

177 """Tests for identifiers""" 

178 parser = ParserYacc() 

179 

180 tree = parser.parse("a") 

181 self.assertIsInstance(tree, exprTree.Identifier) 

182 self.assertEqual(tree.name, "a") 

183 self.assertEqual(str(tree), "a") 

184 

185 tree = parser.parse("a.b") 

186 self.assertIsInstance(tree, exprTree.Identifier) 

187 self.assertEqual(tree.name, "a.b") 

188 self.assertEqual(str(tree), "a.b") 

189 

190 def testParseBind(self): 

191 """Tests for bind name""" 

192 parser = ParserYacc() 

193 

194 tree = parser.parse(":a") 

195 self.assertIsInstance(tree, exprTree.BindName) 

196 self.assertEqual(tree.name, "a") 

197 self.assertEqual(str(tree), ":a") 

198 

199 with self.assertRaises(ParserYaccError): 

200 tree = parser.parse(":1") 

201 

202 def testParseParens(self): 

203 """Tests for identifiers""" 

204 parser = ParserYacc() 

205 

206 tree = parser.parse("(a)") 

207 self.assertIsInstance(tree, exprTree.Parens) 

208 self.assertIsInstance(tree.expr, exprTree.Identifier) 

209 self.assertEqual(tree.expr.name, "a") 

210 self.assertEqual(str(tree), "(a)") 

211 

212 tree = parser.parse("(:a)") 

213 self.assertIsInstance(tree, exprTree.Parens) 

214 self.assertIsInstance(tree.expr, exprTree.BindName) 

215 self.assertEqual(tree.expr.name, "a") 

216 self.assertEqual(str(tree), "(:a)") 

217 

218 def testUnaryOps(self): 

219 """Tests for unary plus and minus""" 

220 parser = ParserYacc() 

221 

222 tree = parser.parse("+a") 

223 self.assertIsInstance(tree, exprTree.UnaryOp) 

224 self.assertEqual(tree.op, "+") 

225 self.assertIsInstance(tree.operand, exprTree.Identifier) 

226 self.assertEqual(tree.operand.name, "a") 

227 self.assertEqual(str(tree), "+ a") 

228 

229 tree = parser.parse("- x.y") 

230 self.assertIsInstance(tree, exprTree.UnaryOp) 

231 self.assertEqual(tree.op, "-") 

232 self.assertIsInstance(tree.operand, exprTree.Identifier) 

233 self.assertEqual(tree.operand.name, "x.y") 

234 self.assertEqual(str(tree), "- x.y") 

235 

236 def testBinaryOps(self): 

237 """Tests for binary operators""" 

238 parser = ParserYacc() 

239 

240 tree = parser.parse("a + b") 

241 self.assertIsInstance(tree, exprTree.BinaryOp) 

242 self.assertEqual(tree.op, "+") 

243 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

244 self.assertIsInstance(tree.rhs, exprTree.Identifier) 

245 self.assertEqual(tree.lhs.name, "a") 

246 self.assertEqual(tree.rhs.name, "b") 

247 self.assertEqual(str(tree), "a + b") 

248 

249 tree = parser.parse("a - 2") 

250 self.assertIsInstance(tree, exprTree.BinaryOp) 

251 self.assertEqual(tree.op, "-") 

252 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

253 self.assertIsInstance(tree.rhs, exprTree.NumericLiteral) 

254 self.assertEqual(tree.lhs.name, "a") 

255 self.assertEqual(tree.rhs.value, "2") 

256 self.assertEqual(str(tree), "a - 2") 

257 

258 tree = parser.parse("2 * 2") 

259 self.assertIsInstance(tree, exprTree.BinaryOp) 

260 self.assertEqual(tree.op, "*") 

261 self.assertIsInstance(tree.lhs, exprTree.NumericLiteral) 

262 self.assertIsInstance(tree.rhs, exprTree.NumericLiteral) 

263 self.assertEqual(tree.lhs.value, "2") 

264 self.assertEqual(tree.rhs.value, "2") 

265 self.assertEqual(str(tree), "2 * 2") 

266 

267 tree = parser.parse("1.e5/2") 

268 self.assertIsInstance(tree, exprTree.BinaryOp) 

269 self.assertEqual(tree.op, "/") 

270 self.assertIsInstance(tree.lhs, exprTree.NumericLiteral) 

271 self.assertIsInstance(tree.rhs, exprTree.NumericLiteral) 

272 self.assertEqual(tree.lhs.value, "1.e5") 

273 self.assertEqual(tree.rhs.value, "2") 

274 self.assertEqual(str(tree), "1.e5 / 2") 

275 

276 tree = parser.parse("333%76") 

277 self.assertIsInstance(tree, exprTree.BinaryOp) 

278 self.assertEqual(tree.op, "%") 

279 self.assertIsInstance(tree.lhs, exprTree.NumericLiteral) 

280 self.assertIsInstance(tree.rhs, exprTree.NumericLiteral) 

281 self.assertEqual(tree.lhs.value, "333") 

282 self.assertEqual(tree.rhs.value, "76") 

283 self.assertEqual(str(tree), "333 % 76") 

284 

285 # tests for overlaps operator 

286 tree = parser.parse("region1 OVERLAPS region2") 

287 self.assertIsInstance(tree, exprTree.BinaryOp) 

288 self.assertEqual(tree.op, "OVERLAPS") 

289 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

290 self.assertIsInstance(tree.rhs, exprTree.Identifier) 

291 self.assertEqual(str(tree), "region1 OVERLAPS region2") 

292 

293 # time ranges with literals 

294 tree = parser.parse("(T'2020-01-01', T'2020-01-02') overlaps (T'2020-01-01', T'2020-01-02')") 

295 self.assertIsInstance(tree, exprTree.BinaryOp) 

296 self.assertEqual(tree.op, "OVERLAPS") 

297 self.assertIsInstance(tree.lhs, exprTree.TupleNode) 

298 self.assertIsInstance(tree.rhs, exprTree.TupleNode) 

299 self.assertEqual( 

300 str(tree), 

301 ( 

302 "(T'2020-01-01 00:00:00.000', T'2020-01-02 00:00:00.000') " 

303 "OVERLAPS (T'2020-01-01 00:00:00.000', T'2020-01-02 00:00:00.000')" 

304 ), 

305 ) 

306 

307 # but syntax allows anything, it's visitor responsibility to decide 

308 # what are the right operands 

309 tree = parser.parse("x+y Overlaps function(x-y)") 

310 self.assertIsInstance(tree, exprTree.BinaryOp) 

311 self.assertEqual(tree.op, "OVERLAPS") 

312 self.assertIsInstance(tree.lhs, exprTree.BinaryOp) 

313 self.assertIsInstance(tree.rhs, exprTree.FunctionCall) 

314 self.assertEqual(str(tree), "x + y OVERLAPS function(x - y)") 

315 

316 def testIsIn(self): 

317 """Tests for IN""" 

318 parser = ParserYacc() 

319 

320 tree = parser.parse("a in (1,2,'X')") 

321 self.assertIsInstance(tree, exprTree.IsIn) 

322 self.assertFalse(tree.not_in) 

323 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

324 self.assertEqual(tree.lhs.name, "a") 

325 self.assertIsInstance(tree.values, list) 

326 self.assertEqual(len(tree.values), 3) 

327 self.assertIsInstance(tree.values[0], exprTree.NumericLiteral) 

328 self.assertEqual(tree.values[0].value, "1") 

329 self.assertIsInstance(tree.values[1], exprTree.NumericLiteral) 

330 self.assertEqual(tree.values[1].value, "2") 

331 self.assertIsInstance(tree.values[2], exprTree.StringLiteral) 

332 self.assertEqual(tree.values[2].value, "X") 

333 self.assertEqual(str(tree), "a IN (1, 2, 'X')") 

334 

335 tree = parser.parse("10 not in (1000, 2000..3000:100)") 

336 self.assertIsInstance(tree, exprTree.IsIn) 

337 self.assertTrue(tree.not_in) 

338 self.assertIsInstance(tree.lhs, exprTree.NumericLiteral) 

339 self.assertEqual(tree.lhs.value, "10") 

340 self.assertIsInstance(tree.values, list) 

341 self.assertEqual(len(tree.values), 2) 

342 self.assertIsInstance(tree.values[0], exprTree.NumericLiteral) 

343 self.assertEqual(tree.values[0].value, "1000") 

344 self.assertIsInstance(tree.values[1], exprTree.RangeLiteral) 

345 self.assertEqual(tree.values[1].start, 2000) 

346 self.assertEqual(tree.values[1].stop, 3000) 

347 self.assertEqual(tree.values[1].stride, 100) 

348 self.assertEqual(str(tree), "10 NOT IN (1000, 2000..3000:100)") 

349 

350 tree = parser.parse("10 in (-1000, -2000)") 

351 self.assertIsInstance(tree, exprTree.IsIn) 

352 self.assertFalse(tree.not_in) 

353 self.assertIsInstance(tree.lhs, exprTree.NumericLiteral) 

354 self.assertEqual(tree.lhs.value, "10") 

355 self.assertIsInstance(tree.values, list) 

356 self.assertEqual(len(tree.values), 2) 

357 self.assertIsInstance(tree.values[0], exprTree.NumericLiteral) 

358 self.assertEqual(tree.values[0].value, "-1000") 

359 self.assertIsInstance(tree.values[1], exprTree.NumericLiteral) 

360 self.assertEqual(tree.values[1].value, "-2000") 

361 self.assertEqual(str(tree), "10 IN (-1000, -2000)") 

362 

363 # test for time contained in time range, all literals 

364 tree = parser.parse("T'2020-01-01' in (T'2020-01-01', T'2020-01-02')") 

365 self.assertIsInstance(tree, exprTree.IsIn) 

366 self.assertFalse(tree.not_in) 

367 self.assertIsInstance(tree.lhs, exprTree.TimeLiteral) 

368 self.assertEqual(len(tree.values), 2) 

369 self.assertIsInstance(tree.values[0], exprTree.TimeLiteral) 

370 self.assertIsInstance(tree.values[1], exprTree.TimeLiteral) 

371 self.assertEqual( 

372 str(tree), 

373 "T'2020-01-01 00:00:00.000' IN (T'2020-01-01 00:00:00.000', T'2020-01-02 00:00:00.000')", 

374 ) 

375 

376 # test for time range contained in time range 

377 tree = parser.parse("(T'2020-01-01', t1) in (T'2020-01-01', t2)") 

378 self.assertIsInstance(tree, exprTree.IsIn) 

379 self.assertFalse(tree.not_in) 

380 self.assertIsInstance(tree.lhs, exprTree.TupleNode) 

381 self.assertEqual(len(tree.values), 2) 

382 self.assertIsInstance(tree.values[0], exprTree.TimeLiteral) 

383 self.assertIsInstance(tree.values[1], exprTree.Identifier) 

384 self.assertEqual(str(tree), "(T'2020-01-01 00:00:00.000', t1) IN (T'2020-01-01 00:00:00.000', t2)") 

385 

386 # test for point in region (we don't have region syntax yet, use 

387 # identifier) 

388 tree = parser.parse("point(1, 2) in (region1)") 

389 self.assertIsInstance(tree, exprTree.IsIn) 

390 self.assertFalse(tree.not_in) 

391 self.assertIsInstance(tree.lhs, exprTree.PointNode) 

392 self.assertEqual(len(tree.values), 1) 

393 self.assertIsInstance(tree.values[0], exprTree.Identifier) 

394 self.assertEqual(str(tree), "POINT(1, 2) IN (region1)") 

395 

396 # Test that bind can appear in RHS. 

397 tree = parser.parse("a in (:in)") 

398 self.assertIsInstance(tree, exprTree.IsIn) 

399 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

400 self.assertEqual(len(tree.values), 1) 

401 self.assertIsInstance(tree.values[0], exprTree.BindName) 

402 self.assertEqual(str(tree), "a IN (:in)") 

403 

404 tree = parser.parse("a not in (:a, :b, c, 1)") 

405 self.assertIsInstance(tree, exprTree.IsIn) 

406 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

407 self.assertEqual(len(tree.values), 4) 

408 self.assertIsInstance(tree.values[0], exprTree.BindName) 

409 self.assertIsInstance(tree.values[1], exprTree.BindName) 

410 self.assertIsInstance(tree.values[2], exprTree.Identifier) 

411 self.assertIsInstance(tree.values[3], exprTree.NumericLiteral) 

412 self.assertEqual(str(tree), "a NOT IN (:a, :b, c, 1)") 

413 

414 expr = ( 

415 "id in (" 

416 "UUID('38a42b54-0822-4dce-93b7-47e9b0d8ad66'), " 

417 "UUID('782fb690-281a-4787-9b6e-f5324a9b6369'), " 

418 ":uuid" 

419 ")" 

420 ) 

421 tree = parser.parse(expr) 

422 self.assertIsInstance(tree, exprTree.IsIn) 

423 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

424 self.assertEqual(len(tree.values), 3) 

425 self.assertIsInstance(tree.values[0], exprTree.UuidLiteral) 

426 self.assertIsInstance(tree.values[1], exprTree.UuidLiteral) 

427 self.assertIsInstance(tree.values[2], exprTree.BindName) 

428 self.assertEqual( 

429 str(tree), 

430 ( 

431 "id IN (" 

432 "UUID('38a42b54-0822-4dce-93b7-47e9b0d8ad66'), " 

433 "UUID('782fb690-281a-4787-9b6e-f5324a9b6369'), " 

434 ":uuid" 

435 ")" 

436 ), 

437 ) 

438 

439 # parens on right hand side are required 

440 with self.assertRaises(ParseError): 

441 parser.parse("point(1, 2) in region1") 

442 

443 # and we don't support full expressions in RHS list 

444 with self.assertRaises(ParseError): 

445 parser.parse("point(1, 2) in (x + y)") 

446 

447 def testCompareOps(self): 

448 """Tests for comparison operators""" 

449 parser = ParserYacc() 

450 

451 for op in ("=", "!=", "<", "<=", ">", ">="): 

452 tree = parser.parse(f"a {op} 10") 

453 self.assertIsInstance(tree, exprTree.BinaryOp) 

454 self.assertEqual(tree.op, op) 

455 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

456 self.assertIsInstance(tree.rhs, exprTree.NumericLiteral) 

457 self.assertEqual(tree.lhs.name, "a") 

458 self.assertEqual(tree.rhs.value, "10") 

459 self.assertEqual(str(tree), f"a {op} 10") 

460 

461 tree = parser.parse(f"a {op} :b") 

462 self.assertIsInstance(tree, exprTree.BinaryOp) 

463 self.assertEqual(tree.op, op) 

464 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

465 self.assertIsInstance(tree.rhs, exprTree.BindName) 

466 self.assertEqual(tree.lhs.name, "a") 

467 self.assertEqual(tree.rhs.name, "b") 

468 self.assertEqual(str(tree), f"a {op} :b") 

469 

470 tree = parser.parse(f":b {op} a") 

471 self.assertIsInstance(tree, exprTree.BinaryOp) 

472 self.assertEqual(tree.op, op) 

473 self.assertIsInstance(tree.lhs, exprTree.BindName) 

474 self.assertIsInstance(tree.rhs, exprTree.Identifier) 

475 self.assertEqual(tree.lhs.name, "b") 

476 self.assertEqual(tree.rhs.name, "a") 

477 self.assertEqual(str(tree), f":b {op} a") 

478 

479 def testBoolOps(self): 

480 """Tests for boolean operators""" 

481 parser = ParserYacc() 

482 

483 for op in ("OR", "AND"): 

484 tree = parser.parse(f"a {op} b") 

485 self.assertIsInstance(tree, exprTree.BinaryOp) 

486 self.assertEqual(tree.op, op) 

487 self.assertIsInstance(tree.lhs, exprTree.Identifier) 

488 self.assertIsInstance(tree.rhs, exprTree.Identifier) 

489 self.assertEqual(tree.lhs.name, "a") 

490 self.assertEqual(tree.rhs.name, "b") 

491 self.assertEqual(str(tree), f"a {op} b") 

492 

493 tree = parser.parse("NOT b") 

494 self.assertIsInstance(tree, exprTree.UnaryOp) 

495 self.assertEqual(tree.op, "NOT") 

496 self.assertIsInstance(tree.operand, exprTree.Identifier) 

497 self.assertEqual(tree.operand.name, "b") 

498 self.assertEqual(str(tree), "NOT b") 

499 

500 def testFunctionCall(self): 

501 """Tests for function calls""" 

502 parser = ParserYacc() 

503 

504 tree = parser.parse("f()") 

505 self.assertIsInstance(tree, exprTree.FunctionCall) 

506 self.assertEqual(tree.name, "f") 

507 self.assertEqual(tree.args, []) 

508 self.assertEqual(str(tree), "f()") 

509 

510 tree = parser.parse("f1(a)") 

511 self.assertIsInstance(tree, exprTree.FunctionCall) 

512 self.assertEqual(tree.name, "f1") 

513 self.assertEqual(len(tree.args), 1) 

514 self.assertIsInstance(tree.args[0], exprTree.Identifier) 

515 self.assertEqual(tree.args[0].name, "a") 

516 self.assertEqual(str(tree), "f1(a)") 

517 

518 tree = parser.parse("f2(:a, :b)") 

519 self.assertIsInstance(tree, exprTree.FunctionCall) 

520 self.assertEqual(tree.name, "f2") 

521 self.assertEqual(len(tree.args), 2) 

522 self.assertIsInstance(tree.args[0], exprTree.BindName) 

523 self.assertEqual(tree.args[0].name, "a") 

524 self.assertIsInstance(tree.args[1], exprTree.BindName) 

525 self.assertEqual(tree.args[1].name, "b") 

526 self.assertEqual(str(tree), "f2(:a, :b)") 

527 

528 tree = parser.parse("anything_goes('a', x+y, ((a AND b) or (C = D)), NOT T < 42., Z IN (1,2,3,4))") 

529 self.assertIsInstance(tree, exprTree.FunctionCall) 

530 self.assertEqual(tree.name, "anything_goes") 

531 self.assertEqual(len(tree.args), 5) 

532 self.assertIsInstance(tree.args[0], exprTree.StringLiteral) 

533 self.assertIsInstance(tree.args[1], exprTree.BinaryOp) 

534 self.assertIsInstance(tree.args[2], exprTree.Parens) 

535 self.assertIsInstance(tree.args[3], exprTree.UnaryOp) 

536 self.assertIsInstance(tree.args[4], exprTree.IsIn) 

537 self.assertEqual( 

538 str(tree), "anything_goes('a', x + y, ((a AND b) OR (C = D)), NOT T < 42., Z IN (1, 2, 3, 4))" 

539 ) 

540 

541 with self.assertRaises(ParseError): 

542 parser.parse("f.ff()") 

543 

544 def testPointNode(self): 

545 """Tests for POINT() function""" 

546 parser = ParserYacc() 

547 

548 # POINT function makes special node type 

549 tree = parser.parse("POINT(Object.ra, 0.0)") 

550 self.assertIsInstance(tree, exprTree.PointNode) 

551 self.assertIsInstance(tree.ra, exprTree.Identifier) 

552 self.assertEqual(tree.ra.name, "Object.ra") 

553 self.assertIsInstance(tree.dec, exprTree.NumericLiteral) 

554 self.assertEqual(tree.dec.value, "0.0") 

555 self.assertEqual(str(tree), "POINT(Object.ra, 0.0)") 

556 

557 # it is not case sensitive 

558 tree = parser.parse("Point(1, 1)") 

559 self.assertIsInstance(tree, exprTree.PointNode) 

560 self.assertEqual(str(tree), "POINT(1, 1)") 

561 

562 def testCircleNode(self): 

563 """Tests for CIRCLE() function""" 

564 parser = ParserYacc() 

565 

566 tree = parser.parse("CIRCLE(Object.ra, Object.dec, 0.1)") 

567 self.assertIsInstance(tree, exprTree.CircleNode) 

568 self.assertIsInstance(tree.ra, exprTree.Identifier) 

569 self.assertEqual(tree.ra.name, "Object.ra") 

570 self.assertIsInstance(tree.dec, exprTree.Identifier) 

571 self.assertEqual(tree.dec.name, "Object.dec") 

572 self.assertIsInstance(tree.radius, exprTree.NumericLiteral) 

573 self.assertEqual(tree.radius.value, "0.1") 

574 self.assertEqual(str(tree), "CIRCLE(Object.ra, Object.dec, 0.1)") 

575 

576 tree = parser.parse("Circle(0.5 + 0.1, -1 * :bind_name, 1 / 10)") 

577 self.assertIsInstance(tree, exprTree.CircleNode) 

578 self.assertEqual(str(tree), "CIRCLE(0.5 + 0.1, - 1 * :bind_name, 1 / 10)") 

579 

580 with self.assertRaises(ValueError): 

581 tree = parser.parse("Circle()") 

582 with self.assertRaises(ValueError): 

583 tree = parser.parse("Circle(0., 0.)") 

584 with self.assertRaises(ValueError): 

585 tree = parser.parse("Circle(0., 0., 0., 0.)") 

586 with self.assertRaises(ValueError): 

587 tree = parser.parse("Circle('1', 1, 1)") 

588 

589 def testBoxNode(self): 

590 """Tests for BOX() function""" 

591 parser = ParserYacc() 

592 

593 tree = parser.parse("BOX(Object.ra, Object.dec, 0.1, 2.)") 

594 self.assertIsInstance(tree, exprTree.BoxNode) 

595 self.assertIsInstance(tree.ra, exprTree.Identifier) 

596 self.assertEqual(tree.ra.name, "Object.ra") 

597 self.assertIsInstance(tree.dec, exprTree.Identifier) 

598 self.assertEqual(tree.dec.name, "Object.dec") 

599 self.assertIsInstance(tree.width, exprTree.NumericLiteral) 

600 self.assertEqual(tree.width.value, "0.1") 

601 self.assertIsInstance(tree.height, exprTree.NumericLiteral) 

602 self.assertEqual(tree.height.value, "2.") 

603 self.assertEqual(str(tree), "BOX(Object.ra, Object.dec, 0.1, 2.)") 

604 

605 tree = parser.parse("box(0.5 + 0.1, -1 * :bind_name, 1 / 10, 42.)") 

606 self.assertIsInstance(tree, exprTree.BoxNode) 

607 self.assertEqual(str(tree), "BOX(0.5 + 0.1, - 1 * :bind_name, 1 / 10, 42.)") 

608 

609 with self.assertRaises(ValueError): 

610 tree = parser.parse("box()") 

611 with self.assertRaises(ValueError): 

612 tree = parser.parse("box(0., 0.)") 

613 with self.assertRaises(ValueError): 

614 tree = parser.parse("box(0., 0., 0., 0., 1)") 

615 with self.assertRaises(ValueError): 

616 tree = parser.parse("box(:a IN (100), 1, 1, 1)") 

617 

618 def testPolygonNode(self): 

619 """Tests for POLYGON() function""" 

620 parser = ParserYacc() 

621 

622 tree = parser.parse("POLYGON(0, 0, 1, 0, 1, 1)") 

623 self.assertIsInstance(tree, exprTree.PolygonNode) 

624 self.assertEqual(len(tree.vertices), 3) 

625 for ra, dec in tree.vertices: 

626 self.assertIsInstance(ra, exprTree.NumericLiteral) 

627 self.assertIsInstance(dec, exprTree.NumericLiteral) 

628 self.assertEqual([ra.value for ra, dec in tree.vertices], ["0", "1", "1"]) 

629 self.assertEqual([dec.value for ra, dec in tree.vertices], ["0", "0", "1"]) 

630 self.assertEqual(str(tree), "POLYGON(0, 0, 1, 0, 1, 1)") 

631 

632 with self.assertRaisesRegex(ValueError, "POLYGON requires at least three vertices"): 

633 tree = parser.parse("POLYGON()") 

634 with self.assertRaisesRegex(ValueError, "POLYGON requires at least three vertices"): 

635 tree = parser.parse("POLYGON(0., 0., 1., 1.)") 

636 with self.assertRaisesRegex(ValueError, "POLYGON requires even number of arguments"): 

637 tree = parser.parse("polygon(0, 0, 1, 0, 1, 1, 2)") 

638 with self.assertRaisesRegex( 

639 ValueError, "POLYGON argument must be either numeric expression or bind value" 

640 ):