aboutsummaryrefslogtreecommitdiffstats
path: root/test/parsing
diff options
context:
space:
mode:
Diffstat (limited to 'test/parsing')
-rw-r--r--test/parsing/__init__.py0
-rw-r--r--test/parsing/filter/__init__.py0
-rw-r--r--test/parsing/filter/test_from_string.py751
-rw-r--r--test/parsing/filter/test_to_string.py111
-rw-r--r--test/parsing/test_datefmt.py378
-rw-r--r--test/parsing/test_sort.py96
6 files changed, 1336 insertions, 0 deletions
diff --git a/test/parsing/__init__.py b/test/parsing/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/parsing/__init__.py
diff --git a/test/parsing/filter/__init__.py b/test/parsing/filter/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/parsing/filter/__init__.py
diff --git a/test/parsing/filter/test_from_string.py b/test/parsing/filter/test_from_string.py
new file mode 100644
index 0000000..180820a
--- /dev/null
+++ b/test/parsing/filter/test_from_string.py
@@ -0,0 +1,751 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import unittest
+from datetime import datetime
+
+# external imports
+from pyparsing import ParseException
+
+# tagit imports
+from tagit.utils import bsfs, errors, ns
+from tagit.utils.bsfs import ast
+
+# objects to test
+from tagit.parsing.filter.from_string import FromString
+
+
+## code ##
+
+class TestFromString(unittest.TestCase):
+ longMessage = True
+
+ def setUp(self):
+ #predicates.expose('mime', TestScope('attribute', 'mime'), 'Categorical')
+ #predicates.expose('iso', TestScope('attribute', 'iso'), 'Continuous', 'Categorical')
+ #predicates.expose('time', TestScope('generic', 't_image_create_loc'), 'TimeRange', 'Datetime')
+ #predicates.expose('tag', TestScope('generic', 'tag'), 'Categorical')
+
+ #predicates.expose('mime', TestScope('attribute', 'mime'), 'Categorical')
+ #predicates.expose('rank', TestScope('attribute', 'rank'), 'Continuous')
+ #predicates.expose('iso', TestScope('attribute', 'iso'), 'Continuous', 'Categorical')
+ #predicates.expose('time', TestScope('generic', 't_image_create_loc'), 'TimeRange', 'Datetime')
+ #predicates.expose('tag', TestScope('generic', 'tag'), 'Categorical')
+
+
+ self.schema = bsfs.schema.from_string('''
+ # common external prefixes
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+ # common bsfs prefixes
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bse: <http://bsfs.ai/schema/Entity#>
+
+ # nodes
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ bsfs:Tag rdfs:subClassOf bsfs:Node .
+
+ # literals
+ bsfs:Time rdfs:subClassOf bsfs:Literal .
+ xsd:string rdfs:subClassOf bsfs:Literal .
+ bsfs:Number rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsfs:Number .
+
+ # predicates
+ bse:mime rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:string ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:iso rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:time rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:Time;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:tag rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:Tag ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:rank rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ ''')
+ self.parse = FromString(self.schema)
+
+ def _test_number(self, query, target):
+ predicate, condition = target
+ result = self.parse(query)
+ target = ast.filter.And(ast.filter.Any(predicate, condition))
+ self.assertEqual(result, target, msg="in query '{}'".format(query))
+
+ def test_larger_than(self):
+ # larger than A (inclusive)
+ for editable in [
+ # range
+ "{predicate} in [{num}:]", "{predicate} in [{num}:[", "{predicate} in [{num}:)",
+ "{predicate} : [{num}:]", "{predicate} : [{num}:[", "{predicate} : [{num}:)",
+ "{predicate} = [{num}:]", "{predicate} = [{num}:[", "{predicate} = [{num}:)",
+ ]:
+ # positive
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(1.23, False)))
+ # negative
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(-1.23, False)))
+
+ for editable in [
+ # range
+ "{predicate} in [{num}-]", "{predicate} in [{num}-[", "{predicate} in [{num}-)",
+ "{predicate} : [{num}-]", "{predicate} : [{num}-[", "{predicate} : [{num}-)",
+ "{predicate} = [{num}-]", "{predicate} = [{num}-[", "{predicate} = [{num}-)",
+ # equation
+ "{predicate} >= {num}", "{num} <= {predicate}",
+ ]:
+ # positive
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(1.23, False)))
+ # negative
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(-1.23, False)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+ # ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime.max, True, False)))
+
+ # larger than A (exclusive)
+ for editable in [
+ # range / bracket
+ "{predicate} in ]{num}:]", "{predicate} in ]{num}:[", "{predicate} in ]{num}:)",
+ "{predicate} : ]{num}:]", "{predicate} : ]{num}:[", "{predicate} : ]{num}:)",
+ "{predicate} = ]{num}:]", "{predicate} = ]{num}:[", "{predicate} = ]{num}:)",
+ # range / parenthesis
+ "{predicate} in ({num}:]", "{predicate} in ({num}:[", "{predicate} in ({num}:)",
+ "{predicate} : ({num}:]", "{predicate} : ({num}:[", "{predicate} : ({num}:)",
+ "{predicate} = ({num}:]", "{predicate} = ({num}:[", "{predicate} = ({num}:)",
+ ]:
+ # positive
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(1.23, True)))
+ # negative
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(-1.23, True)))
+
+ for editable in [
+ # range / bracket
+ "{predicate} in ]{num}-]", "{predicate} in ]{num}-[", "{predicate} in ]{num}-)",
+ "{predicate} : ]{num}-]", "{predicate} : ]{num}-[", "{predicate} : ]{num}-)",
+ "{predicate} = ]{num}-]", "{predicate} = ]{num}-[", "{predicate} = ]{num}-)",
+ # range / parenthesis
+ "{predicate} in ({num}-]", "{predicate} in ({num}-[", "{predicate} in ({num}-)",
+ "{predicate} : ({num}-]", "{predicate} : ({num}-[", "{predicate} : ({num}-)",
+ "{predicate} = ({num}-]", "{predicate} = ({num}-[", "{predicate} = ({num}-)",
+ # equation
+ "{predicate} > {num}", "{num} < {predicate}",
+ ]:
+ # positive
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(1.23, True)))
+ # negative
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.GreaterThan(-1.23, True)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+ # ('time', ast.Datetime(datetime(2012, 4, 30, 13, 19), datetime.max, True, False)))
+
+ def test_smaller_than(self):
+ # smaller than B (inclusive)
+ for editable in [
+ # range
+ "{predicate} in [:{num}]", "{predicate} in (:{num}]", "{predicate} in ]:{num}]",
+ "{predicate} : [:{num}]", "{predicate} : (:{num}]", "{predicate} : ]:{num}]",
+ "{predicate} = [:{num}]", "{predicate} = (:{num}]", "{predicate} = ]:{num}]",
+ ]:
+ # positives
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(1.23, False)))
+ # negatives
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(-1.23, False)))
+
+ for editable in [
+ # range
+ "{predicate} in [-{num}]", "{predicate} in (-{num}]", "{predicate} in ]-{num}]",
+ "{predicate} : [-{num}]", "{predicate} : (-{num}]", "{predicate} : ]-{num}]",
+ "{predicate} = [-{num}]", "{predicate} = (-{num}]", "{predicate} = ]-{num}]",
+ # equation
+ "{predicate} <={num}", "{num} >= {predicate}",
+ ]:
+ # positives
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(1.23, False)))
+ # negatives
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(-1.23, False)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+ # ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 13, 19), False, False)))
+
+ # smaller than B (exclusive)
+ for editable in [
+ # range / bracket
+ "{predicate} in [:{num}[", "{predicate} in (:{num}[", "{predicate} in ]:{num}[",
+ "{predicate} : [:{num}[", "{predicate} : (:{num}[", "{predicate} : ]:{num}[",
+ "{predicate} = [:{num}[", "{predicate} = (:{num}[", "{predicate} = ]:{num}[",
+ # range / parenthesis
+ "{predicate} in [:{num})", "{predicate} in (:{num})", "{predicate} in ]:{num})",
+ "{predicate} : [:{num})", "{predicate} : (:{num})", "{predicate} : ]:{num})",
+ "{predicate} = [:{num})", "{predicate} = (:{num})", "{predicate} = ]:{num})",
+ ]:
+ # positives
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(1.23, True)))
+ # negatives
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(-1.23, True)))
+
+ for editable in [
+ # range / bracket
+ "{predicate} in [-{num}[", "{predicate} in (-{num}[", "{predicate} in ]-{num}[",
+ "{predicate} : [-{num}[", "{predicate} : (-{num}[", "{predicate} : ]-{num}[",
+ "{predicate} = [-{num}[", "{predicate} = (-{num}[", "{predicate} = ]-{num}[",
+ # range / parenthesis
+ "{predicate} in [-{num})", "{predicate} in (-{num})", "{predicate} in ]-{num})",
+ "{predicate} : [-{num})", "{predicate} : (-{num})", "{predicate} : ]-{num})",
+ "{predicate} = [-{num})", "{predicate} = (-{num})", "{predicate} = ]-{num})",
+ # equation
+ "{predicate} <{num}", "{num} > {predicate}",
+ ]:
+ # positives
+ self._test_number(editable.format(num=1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(1.23, True)))
+ # negatives
+ self._test_number(editable.format(num=-1.23, predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(-1.23, True)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+ # ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 13, 18), False, False)))
+
+ def test_between(self):
+ # between A and B (including A, including B)
+ for editable in [
+ # range
+ "{predicate} in [{numA}:{numB}]", "{predicate} : [{numA}:{numB}]", "{predicate} = [{numA}:{numB}]",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, False)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, False)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, False)))
+
+ for editable in [
+ # range
+ "{predicate} in [{numA}-{numB}]", "{predicate} : [{numA}-{numB}]", "{predicate} = [{numA}-{numB}]",
+ # equation
+ "{numA} <= {predicate} <= {numB}"
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, False)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, False)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, False)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+ # ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime(2014, 6, 13, 18, 28), True, False)))
+
+ # between A and B (including A, excluding B)
+ for editable in [
+ # range
+ "{predicate} in [{numA}:{numB})", "{predicate} in [{numA}:{numB}[",
+ "{predicate} : [{numA}:{numB})", "{predicate} : [{numA}:{numB}[",
+ "{predicate} = [{numA}:{numB})", "{predicate} = [{numA}:{numB}[",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, True)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, True)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, True)))
+
+ for editable in [
+ # range
+ "{predicate} in [{numA}-{numB})", "{predicate} in [{numA}-{numB}[",
+ "{predicate} : [{numA}-{numB})", "{predicate} : [{numA}-{numB}[",
+ "{predicate} = [{numA}-{numB})", "{predicate} = [{numA}-{numB}[",
+ # equation
+ "{numA} <= {predicate} < {numB}",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, True)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, True)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, True)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+ # ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime(2014, 6, 13, 18, 27), True, False)))
+
+ # between A and B (excluding A, including B)
+ for editable in [
+ # range
+ "{predicate} in ({numA}:{numB}]", "{predicate} in ]{numA}:{numB}]",
+ "{predicate} : ({numA}:{numB}]", "{predicate} : ]{numA}:{numB}]",
+ "{predicate} = ({numA}:{numB}]", "{predicate} = ]{numA}:{numB}]",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, False)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, False)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, False)))
+
+ for editable in [
+ # range
+ "{predicate} in ({numA}-{numB}]", "{predicate} in ]{numA}-{numB}]",
+ "{predicate} : ({numA}-{numB}]", "{predicate} : ]{numA}-{numB}]",
+ "{predicate} = ({numA}-{numB}]", "{predicate} = ]{numA}-{numB}]",
+ # equation
+ "{numA} < {predicate} <= {numB}",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, False)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, False)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, False)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+ # ('time', ast.Datetime(datetime(2012, 4, 30, 13, 19), datetime(2014, 6, 13, 18, 28), True, False)))
+
+ # between A and B (excluding A, excluding B)
+ for editable in [
+ "{predicate} in ({numA}:{numB})", "{predicate} in ]{numA}:{numB}[",
+ "{predicate} : ({numA}:{numB})", "{predicate} : ]{numA}:{numB}[",
+ "{predicate} = ({numA}:{numB})", "{predicate} = ]{numA}:{numB}[",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, True)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, True)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, True)))
+
+ for editable in [
+ "{predicate} in ({numA}-{numB})", "{predicate} in ]{numA}-{numB}[",
+ "{predicate} : ({numA}-{numB})", "{predicate} : ]{numA}-{numB}[",
+ "{predicate} = ({numA}-{numB})", "{predicate} = ]{numA}-{numB}[",
+ # equation
+ "{numA} < {predicate} < {numB}",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, True)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+ (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, True)))
+ # mixed
+ self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+ (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, True)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+ # ('time', ast.Datetime(datetime(2012, 4, 30, 13, 19), datetime(2014, 6, 13, 18, 27), True, False)))
+
+ def test_equal(self):
+ # equal to A
+ for editable in [
+ # range
+ "{predicate} in [{num}:{num}]", "{predicate} : [{num}:{num}]", "{predicate} = [{num}:{num}]",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', num=1.23),
+ (ns.bse.iso, ast.filter.Equals(1.23)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', num=-1.23),
+ (ns.bse.iso, ast.filter.Equals(-1.23)))
+
+ for editable in [
+ # range
+ "{predicate} in [{num}-{num}]", "{predicate} : [{num}-{num}]", "{predicate} = [{num}-{num}]",
+ # equation
+ "{predicate} = {num}", "{num} = {predicate}",
+ ]:
+ # positives
+ self._test_number(editable.format(predicate='iso', num=1.23),
+ (ns.bse.iso, ast.filter.Equals(1.23)))
+ # negatives
+ self._test_number(editable.format(predicate='iso', num=-1.23),
+ (ns.bse.iso, ast.filter.Equals(-1.23)))
+ # FIXME: date
+ #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+ # ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime(2012, 4, 30, 13, 19), True, False)))
+
+ def test_dates(self):
+ raise NotImplementedError() # FIXME
+ self._test_number("{predicate} < {num}".format(predicate='time', num="2012"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 1, 1), False, False)))
+ self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 1), False, False)))
+ self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30), False, False)))
+ self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 3 pm"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15), False, False)))
+ self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 15:34"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34), False, False)))
+ self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 15:34:12"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 12), False, False)))
+ self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 15:34:12.98"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 12, 980000), False, False)))
+
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="2012"),
+ ('time', ast.Datetime(datetime.min, datetime(2013, 1, 1), False, False)))
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 5, 1), False, False)))
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 5, 1), False, False)))
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 3 pm"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 16), False, False)))
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 15:34"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 35), False, False)))
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 15:34:12"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 13), False, False)))
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 15:34:12.98"),
+ ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 12, 980001), False, False)))
+
+ def test_timerange(self):
+ raise NotImplementedError() # FIXME
+ self._test_number("{predicate} < {num}".format(predicate='time', num="15:34"),
+ ('time', ast.TimeRange(datetime.utcfromtimestamp(0.0), datetime(1970, 1, 1, 15, 34), True, False)))
+ self._test_number("{predicate} <= {num}".format(predicate='time', num="15:34"),
+ ('time', ast.TimeRange(datetime.utcfromtimestamp(0.0), datetime(1970, 1, 1, 15, 35), True, False)))
+ self._test_number("{predicate} = {num}".format(predicate='time', num="15:34"),
+ ('time', ast.TimeRange(datetime(1970, 1, 1, 15, 34), datetime(1970, 1, 1, 15, 35), True, False)))
+ self._test_number("{predicate} > {num}".format(predicate='time', num="15:34"),
+ ('time', ast.TimeRange(datetime(1970, 1, 1, 15, 35), datetime(1970, 1, 2), True, True)))
+ self._test_number("{predicate} >= {num}".format(predicate='time', num="15:34"),
+ ('time', ast.TimeRange(datetime(1970, 1, 1, 15, 34), datetime(1970, 1, 2), True, True)))
+
+ self._test_number("{numA} <= {predicate} <= {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+ ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 34), datetime(1970, 1, 1, 15, 29), True, False)))
+ self._test_number("{numA} <= {predicate} < {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+ ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 34), datetime(1970, 1, 1, 15, 28), True, False)))
+ self._test_number("{numA} < {predicate} <= {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+ ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 35), datetime(1970, 1, 1, 15, 29), True, False)))
+ self._test_number("{numA} < {predicate} < {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+ ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 35), datetime(1970, 1, 1, 15, 28), True, False)))
+
+ def test_special(self):
+ # special cases: explicit plus sign
+ self._test_number("{predicate} in [+1.23-+4.56]".format(predicate='iso'),
+ (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, False)))
+ self._test_number("{predicate} in [-+4.56]".format(predicate='iso'),
+ (ns.bse.iso, ast.filter.LessThan(4.56, False)))
+
+ def test_errors(self):
+ # parse errors
+ for editable in [
+ # equal with exclusive
+ "{predicate} in ({num}:{num})", "{predicate} in ({num}-{num})",
+ "{predicate} in ({num}:{num}[", "{predicate} in ({num}-{num}[",
+ "{predicate} in ]{num}:{num})", "{predicate} in ]{num}-{num})",
+ "{predicate} in ]{num}:{num}[", "{predicate} in ]{num}-{num}[",
+ # invalid parentesis
+ "{predicate} in ){num}:{num}(",
+ # misc errors
+ # FIXME: Currently all special characters are allowed as categorical value.
+ # If this changes, don't forget to enable the tests below.
+ #"{predicate} in [{num}{num}]",
+ #"{predicate} [{num}:{num}:{num}]",
+ #"{predicate} = ({num})",
+ #"{predicate} = {num})",
+ ]:
+ self.assertRaises(errors.ParserError, self.parse,
+ editable.format(predicate='iso', num=1.23))
+
+ for editable in [
+ "{predicate} in [{numA}:{numB}]", "{predicate} : [{numA}:{numB}]", "{predicate} = [{numA}:{numB}]",
+ "{predicate} in ]{numA}:{numB}]", "{predicate} : ]{numA}:{numB}]", "{predicate} = ]{numA}:{numB}]",
+ "{predicate} in [{numA}:{numB}[", "{predicate} : [{numA}:{numB}[", "{predicate} = [{numA}:{numB}[",
+ "{predicate} in ({numA}:{numB}]", "{predicate} : ({numA}:{numB}]", "{predicate} = ({numA}:{numB}]",
+ "{predicate} in [{numA}:{numB})", "{predicate} : [{numA}:{numB})", "{predicate} = [{numA}:{numB})",
+ "{predicate} in ]{numA}:{numB}[", "{predicate} : ]{numA}:{numB}[", "{predicate} = ]{numA}:{numB}[",
+ "{predicate} in ]{numA}:{numB})", "{predicate} : ]{numA}:{numB})", "{predicate} = ]{numA}:{numB})",
+ "{predicate} in ({numA}:{numB}[", "{predicate} : ({numA}:{numB}[", "{predicate} = ({numA}:{numB}[",
+ "{predicate} in ({numA}:{numB})", "{predicate} : ({numA}:{numB})", "{predicate} = ({numA}:{numB})",
+ "{numA} < {predicate} < {numB}",
+ "{numA} <= {predicate} < {numB}",
+ "{numA} < {predicate} <= {numB}",
+ ]:
+ self.assertRaises(errors.ParserError, self.parse,
+ editable.format(predicate='iso', numA=4.56, numB=1.23))
+ # FIXME:
+ #self.assertRaises(errors.ParserError, self.parse,
+ # editable.format(predicate='time', numA="17:35", numB="10:55"))
+ #self.assertRaises(errors.ParserError, self.parse,
+ # editable.format(predicate='time', numA="18.12.2035", numB="5.7.1999"))
+
+ raise NotImplementedError() # FIXME
+ # special cases: empty range with boundary
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} in [:]".format(predicate='iso'))
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} in (:[".format(predicate='iso'))
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} in ]:)".format(predicate='iso'))
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} in ".format(predicate='iso'))
+ # misc
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} in [{num}{num}]".format(predicate='iso', num=1.23))
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} [{num}:{num}:{num}]".format(predicate='iso', num=1.23))
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} = ({num})".format(predicate='iso', num=1.23))
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} = ({num}".format(predicate='iso', num=1.23), dict(parseAll=True))
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+ "{predicate} = {num})".format(predicate='iso', num=1.23), dict(parseAll=True))
+ # range errors
+ self.assertRaises(errors.ParserError, self.parse, "100 >= iso < 200")
+ self.assertRaises(errors.ParserError, self.parse, "100 > iso < 200")
+ self.assertRaises(errors.ParserError, self.parse, "100 > iso <= 200")
+ self.assertRaises(errors.ParserError, self.parse, "100 >= iso <= 200")
+ self.assertRaises(errors.ParserError, self.parse, "100 = iso = 200")
+ # time/date mixture errors
+ self.assertRaises(errors.ParserError, self.parse, "12:45 < time < 17.5.2004")
+ self.assertRaises(errors.ParserError, self.parse, "17.5.2004 < time < 12:45")
+ # date/int mixture errors
+ self.assertRaises(errors.ParserError, self.parse, "17.5.2004 < time < 1245")
+ # 1245 is interpreted as the year
+ #self.assertRaises(errors.ParserError, self.parse, "1245 < time < 17.5.2004")
+ # time/int mixture errors
+ self.assertRaises(errors.ParserError, self.parse, "17:12 < time < 1245")
+ self.assertRaises(errors.ParserError, self.parse, "1712 < time < 12:45")
+
+ # empty query
+ self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString, "")
+
+
+
+
+ def _test(self, query, target):
+ result = self.parse(query)
+ target = ast.filter.And(target)
+ self.assertEqual(result, target, msg="in query '{}'".format(query))
+
+ def test_parse_existence(self):
+ self._test('has mime',
+ ast.filter.Has(ns.bse.mime))
+ self._test('has no mime',
+ ast.filter.Not(ast.filter.Has(ns.bse.mime)))
+ self._test('has not mime',
+ ast.filter.Not(ast.filter.Has(ns.bse.mime)))
+
+ def test_parse_categorical(self):
+ # positive
+ self._test("iso in 100, 200, 500",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200', '500')))
+ self._test("iso in (100, 200)",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ self._test("iso = (100, 200)",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ # FIXME!
+ #self._test("iso = 100, 200",
+ # ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ self._test("iso : (100, 200)",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ self._test("iso : 100, 200",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ self._test("iso:(100,200)",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ self._test("iso in (100,200)",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ self._test("iso in 100,200",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+ self._test("iso ~ (100,200)",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200', approx=True)))
+ self._test("iso ~ 100,200",
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200', approx=True)))
+
+ # negative
+ self._test("iso not in 100,200",
+ ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+ self._test("iso not in (100, 200)",
+ ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+ self._test("iso != 100,200",
+ ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+ self._test("iso != (100, 200)",
+ ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+ self._test("iso !~ 100,200",
+ ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200', approx=True)))
+ self._test("iso !~ (100, 200)",
+ ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200', approx=True)))
+
+ # one value
+ self._test("mime : text",
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+ self._test("mime in text",
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+ self._test("mime = text",
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+ self._test("mime ~ text",
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text', approx=True)))
+ self._test("mime != text",
+ ast.filter.All(ns.bse.mime, ast.filter.Excludes('text')))
+ self._test("mime not in text",
+ ast.filter.All(ns.bse.mime, ast.filter.Excludes('text')))
+ self._test("mime !~ text",
+ ast.filter.All(ns.bse.mime, ast.filter.Excludes('text', approx=True)))
+
+ # expressions with slash and comma
+ self._test('mime : "text"',
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+ self._test('mime : "text", "plain"',
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text', 'plain')))
+ self._test('mime : "text, plain"',
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text, plain')))
+ self._test('mime ~ "text/plain"',
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text/plain', approx=True)))
+ self._test('mime = ("text/plain", "image/jpeg")',
+ ast.filter.Any(ns.bse.mime, ast.filter.Includes('text/plain', 'image/jpeg')))
+
+ def test_parse_tag(self):
+ # only tag: tag, tags, (tag), (tags)
+ self._test("foo",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('foo'))))
+ self._test("(foo)",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('foo'))))
+ self._test("foo, bar",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar'))))
+ self._test("foo,bar",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar'))))
+ self._test("(foo, bar,foobar)",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', 'foobar'))))
+
+ # op and tag: !tag, ~tag, !~tag
+ self._test("~foo",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Substring('foo'))))
+ self._test("~ foo",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Substring('foo'))))
+ self._test("!foo",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Equals('foo')))))
+ self._test("! foo",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Equals('foo')))))
+ self._test("!~foo",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Substring('foo')))))
+ self._test("!~ foo",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Substring('foo')))))
+
+ # op and list: ! (tags), ~tags, ...
+ self._test("~ foo, bar",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', approx=True))))
+ self._test("~foo, bar",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', approx=True))))
+ self._test("~ (foo, bar)",
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', approx=True))))
+ self._test("! foo, bar",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar'))))
+ self._test("! (foo, bar)",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar'))))
+ self._test("! (foo,bar)",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar'))))
+ self._test("!~ foo, bar",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar', approx=True))))
+ self._test("!~ (foo, bar)",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar', approx=True))))
+ self._test("!~(foo,bar)",
+ ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar', approx=True))))
+
+ def test_parse_query(self):
+ # simple query
+ self.assertEqual(self.parse('foo / bar'), ast.filter.And(
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('foo'))),
+ ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('bar')))))
+ self.assertEqual(self.parse('iso in ("foo", "bar") / mime = plain'), ast.filter.And(
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('foo', 'bar')),
+ ast.filter.Any(ns.bse.mime, ast.filter.Equals('plain'))))
+ self.assertEqual(self.parse('iso in ("foo", "bar") / mime = plain'), ast.filter.And(
+ ast.filter.Any(ns.bse.iso, ast.filter.Includes('foo', 'bar')),
+ ast.filter.Any(ns.bse.mime, ast.filter.Equals('plain'))))
+ self.assertEqual(self.parse('iso = 1.23 / rank < 5'), ast.filter.And(
+ ast.filter.Any(ns.bse.iso, ast.filter.Equals(1.23)),
+ ast.filter.Any(ns.bse.rank, ast.filter.LessThan(5, True))))
+ # FIXME
+ #self.assertEqual(self.parse('time >= 12:50 / time < 13:50'), ast.filter.And(
+ # ast.filter.Any(ns.bse.time, ast.TimeRange(lo=datetime(1970, 1, 1, 12, 50), lo_inc=True, hi_inc=True)),
+ # ast.filter.Any(ns.bse.time, ast.TimeRange(hi=datetime(1970, 1, 1, 13, 50), lo_inc=True, hi_inc=False))))
+ #self.assertEqual(self.parse('time >= 17.5.2001 / time < 18.4.2002'), ast.filter.And(
+ # ast.filter.Any(ns.bse.time, ast.Datetime(lo=datetime(2001, 5, 17, 0, 0), lo_inc=True)),
+ # ast.filter.Any(ns.bse.time, ast.Datetime(hi=datetime(2002, 4, 18, 0, 0)))))
+ # mixing expressions
+ #self.assertEqual(self.parse('foo / iso in "bar" / mime ~ "text/plain" / iso < 100 / time >= 17.5.2001 / time < 13:50'), ast.filter.And(
+ # ast.filter.Any(ns.bse.tag, ast.filter.Equals('foo')),
+ # ast.filter.Any(ns.bse.iso, ast.filter.Equals('bar')),
+ # ast.filter.Any(ns.bse.mime, ast.filter.Substring('text/plain')),
+ # ast.filter.Any(ns.bse.iso, ast.filter.LessThan(100)),
+ # ast.filter.Any(ns.bse.time, ast.Datetime(lo=datetime(2001, 5, 17, 0, 0), lo_inc=True)),
+ # ast.filter.Any(ns.bse.time, ast.TimeRange(hi=datetime(1970, 1, 1, 13, 50), lo_inc=True))))
+
+ # leading/trailing slashes
+ self.assertRaises(errors.ParserError, self.parse, '/ foobar')
+ self.assertRaises(errors.ParserError, self.parse, 'foobar /')
+ self.assertRaises(errors.ParserError, self.parse, 'foobar / ')
+ self.assertRaises(errors.ParserError, self.parse, 'foo // bar')
+ self.assertRaises(errors.ParserError, self.parse, 'foo / / bar')
+
+ def test_quoting(self):
+ self._test("tag in ('(foo, bar)', foobar)",
+ ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+ self._test('tag in ("(foo, bar)", foobar)',
+ ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+ self._test('tag in ("(foo, \\"bar\\")", foobar)',
+ ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, "bar")', 'foobar')))
+ self._test('tag in ("(foo, bar)", "foobar")',
+ ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+ self._test('tag in ("(foo, bar)", \'foobar\')',
+ ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+
+ # error cases
+ self.assertRaises(errors.ParserError, self.parse, ('tag in ("(foo, bar, foobar)'))
+ self.assertRaises(errors.ParserError, self.parse, ("tag in ('(foo, bar, foobar)"))
+
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
diff --git a/test/parsing/filter/test_to_string.py b/test/parsing/filter/test_to_string.py
new file mode 100644
index 0000000..6df7360
--- /dev/null
+++ b/test/parsing/filter/test_to_string.py
@@ -0,0 +1,111 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import contextlib
+import io
+import unittest
+
+# tagit imports
+with contextlib.redirect_stderr(io.StringIO()):
+ from tagit.parsing.filter.from_string import FromString
+ from tagit.utils import bsfs, errors, ns
+ from tagit.utils.bsfs import ast
+
+ # objects to test
+ from tagit.parsing.filter.to_string import ToString
+
+
+## code ##
+
+class TestFromString(unittest.TestCase):
+ def setUp(self):
+ self.schema = bsfs.schema.from_string('''
+ # common external prefixes
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+ # common bsfs prefixes
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bse: <http://bsfs.ai/schema/Entity#>
+
+ # nodes
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ bsfs:Tag rdfs:subClassOf bsfs:Node .
+
+ # literals
+ bsfs:Time rdfs:subClassOf bsfs:Literal .
+ xsd:string rdfs:subClassOf bsfs:Literal .
+ bsfs:Number rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsfs:Number .
+
+ # predicates
+ bse:mime rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:string ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:iso rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:time rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:Time;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:tag rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:Tag ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:rank rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ ''')
+ self.to_string = ToString(self.schema)
+ self.from_string = FromString(self.schema)
+
+ def test_has(self):
+ self.assertEqual('has iso', self.to_string(self.from_string('has iso')))
+ #from debug import debug
+ #debug(locals(), globals())
+
+ def test_categorical(self):
+ self.assertEqual('iso = 100.0', self.to_string(self.from_string('iso = 100')))
+
+ def test_tag(self):
+ self.assertEqual('foobar', self.to_string(self.from_string('foobar')))
+ self.assertEqual('not foobar', self.to_string(self.from_string('not foobar')))
+ self.assertEqual('~ foobar', self.to_string(self.from_string('~ foobar')))
+ self.assertEqual('!~ foobar', self.to_string(self.from_string('!~ foobar')))
+ self.assertIn(self.to_string(self.from_string('foo, bar')), ('"foo", "bar"', '"bar", "foo"'))
+
+ def test_range(self):
+ self.assertEqual('iso < 100.0', self.to_string(self.from_string('iso < 100')))
+ self.assertEqual('iso <= 100.0', self.to_string(self.from_string('iso <= 100')))
+ self.assertEqual('iso > 100.0', self.to_string(self.from_string('iso > 100')))
+ self.assertEqual('iso >= 100.0', self.to_string(self.from_string('iso >= 100')))
+ self.assertEqual('iso = [10.0 - 100.0]', self.to_string(self.from_string('iso = [10-100]')))
+ raise NotImplementedError() # FIXME: test with dates!
+
+ def test_entity(self):
+ self.assertEqual('id in "http://example.com/entity#1234"',
+ self.to_string(self.from_string('id in "http://example.com/entity#1234"')))
+
+ def test_group(self):
+ self.assertEqual('group in "http://example.com/group#1234"',
+ self.to_string(self.from_string('group in "http://example.com/group#1234"')))
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
diff --git a/test/parsing/test_datefmt.py b/test/parsing/test_datefmt.py
new file mode 100644
index 0000000..3f80c15
--- /dev/null
+++ b/test/parsing/test_datefmt.py
@@ -0,0 +1,378 @@
+"""Test datetime parser.
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import unittest
+from datetime import date as ddate
+from datetime import time as dtime
+from datetime import datetime
+
+# external imports
+from pyparsing import ParseException
+
+# tagit imports
+from tagit.utils import errors, Struct
+
+# objects to test
+#from tagit.parsing.datefmt import DatefmtError, DateParserError, TimeParserError, DateFormatError, guess_date, guess_time, guess_datetime, increment, PRIORITIES_US, DF
+from tagit.parsing.datefmt import guess_date, guess_time, PRIORITIES_US, DateParserError, DateFormatError, TimeParserError, guess_datetime, DF, parse_datetime, increment, DateTimeParser
+
+
+## code ##
+
+class TestGuessDatetime(unittest.TestCase):
+ def test_parse_datetime(self):
+ parse_datetime = DateTimeParser()
+ cyear = ddate.today().year
+ cmon = ddate.today().month
+ cday = ddate.today().day
+
+ # date only: vary number formats
+ self.assertEqual(parse_datetime('3.4.12'), datetime(2012, 4, 3))
+ self.assertEqual(parse_datetime('15.8.19'), datetime(2019, 8, 15))
+ self.assertEqual(parse_datetime('8.11.98'), datetime(1998, 11, 8))
+ self.assertEqual(parse_datetime('10.11.12'), datetime(2012, 11, 10))
+ self.assertEqual(parse_datetime('3.4.1912'), datetime(1912, 4, 3))
+ self.assertEqual(parse_datetime('15.8.1919'), datetime(1919, 8, 15))
+ self.assertEqual(parse_datetime('8.11.1998'), datetime(1998, 11, 8))
+ self.assertEqual(parse_datetime('10.11.1912'), datetime(1912, 11, 10))
+ self.assertEqual(parse_datetime('8.1998'), datetime(1998, 8, 1))
+ self.assertEqual(parse_datetime('10.1912'), datetime(1912, 10, 1))
+ self.assertRaises(errors.ParserError, parse_datetime, 'ab.cd.ef')
+ self.assertRaises(errors.ParserError, parse_datetime, '123.123.2000')
+ self.assertRaises(errors.ParserError, parse_datetime, '.123.2000')
+ self.assertRaises(errors.ParserError, parse_datetime, '123..2000')
+ self.assertRaises(errors.ParserError, parse_datetime, '12.12.20001')
+ # date only: vary order (three-part)
+ self.assertEqual(parse_datetime('15.98.8'), datetime(1998, 8, 15))
+ self.assertEqual(parse_datetime('8.98.15'), datetime(1998, 8, 15))
+ self.assertEqual(parse_datetime('8.15.98'), datetime(1998, 8, 15))
+ self.assertEqual(parse_datetime('15.8.98'), datetime(1998, 8, 15))
+ self.assertEqual(parse_datetime('98.8.15'), datetime(1998, 8, 15))
+ self.assertEqual(parse_datetime('98.15.8'), datetime(1998, 8, 15))
+ # date only: vary order (two-part)
+ self.assertEqual(parse_datetime('15.98'), datetime(1998, 1, 15))
+ self.assertEqual(parse_datetime('08.98'), datetime(1998, 8, 1))
+ self.assertEqual(parse_datetime('08.15'), datetime(2015, 8, 1))
+ self.assertEqual(parse_datetime('15.08'), datetime(cyear, 8, 15))
+ self.assertEqual(parse_datetime('98.08'), datetime(1998, 8, 1))
+ self.assertEqual(parse_datetime('98.15'), datetime(1998, 1, 15))
+ # date only: one part
+ self.assertEqual(parse_datetime('1998'), datetime(1998, 1, 1))
+ # date only: literal month
+ self.assertEqual(parse_datetime('98.April'), datetime(1998, 4, 1))
+ # FIXME: Allow more patterns
+ #self.assertEqual(parse_datetime('98, April'), datetime(1998, 4, 1))
+ #self.assertEqual(parse_datetime('April, 15'), datetime(2015, 4, 1))
+ # date only: day with suffix
+ #self.assertEqual(parse_datetime('10th 2000'), datetime(2000, 1, 10))
+ #self.assertEqual(parse_datetime('2000, 10th'), datetime(2000, 1, 10))
+ #self.assertEqual(parse_datetime('April, 10th'), datetime(cyear, 4, 10))
+ #self.assertEqual(parse_datetime('April 10th'), datetime(cyear, 4, 10))
+ #self.assertEqual(parse_datetime('10th April'), datetime(cyear, 4, 10))
+ # date only: of notation
+ #self.assertEqual(parse_datetime('10th of April, 2000'), datetime(2000, 4, 10))
+ #self.assertEqual(parse_datetime('10th of April'), datetime(cyear, 4, 10))
+ #self.assertEqual(parse_datetime('10 of 04'), datetime(cyear, 4, 10))
+ # invalid ranges
+ self.assertRaises(DateParserError, parse_datetime, '10.93.2013')
+ self.assertRaises(DateParserError, parse_datetime, '48.10.2013')
+ self.assertRaises(DateParserError, parse_datetime, '48.93.2013')
+ self.assertRaises(DateParserError, parse_datetime, "52.74")
+
+ # time only: am/pm
+ self.assertEqual(parse_datetime("10 am"), datetime(1970, 1, 1, 10))
+ self.assertEqual(parse_datetime("10 pm"), datetime(1970, 1, 1, 22))
+ self.assertEqual(parse_datetime("10:02 pm"), datetime(1970, 1, 1, 22, 2))
+ self.assertEqual(parse_datetime("14 am"), datetime(1970, 1, 1, 14))
+ self.assertRaises(TimeParserError, parse_datetime, "14 pm")
+ # time only: 24hrs format
+ self.assertEqual(parse_datetime("1:2"), datetime(1970, 1, 1, 1, 2))
+ self.assertEqual(parse_datetime("12:34"), datetime(1970, 1, 1, 12, 34))
+ self.assertEqual(parse_datetime("12:34:54"), datetime(1970, 1, 1, 12, 34, 54))
+ self.assertEqual(parse_datetime("12:34:54.123"), datetime(1970, 1, 1, 12, 34, 54, 123000))
+ self.assertEqual(parse_datetime("1:2:3.4"), datetime(1970, 1, 1, 1, 2, 3, 400000))
+ self.assertRaises(errors.ParserError, parse_datetime, '84:12')
+ self.assertRaises(errors.ParserError, parse_datetime, '12:75')
+ self.assertRaises(errors.ParserError, parse_datetime, '12:13:84')
+ # time only: HH:MM
+ self.assertEqual(parse_datetime("54:34"), datetime(1970, 1, 1, 0, 54, 34))
+ # time only: invalid format
+ self.assertRaises(errors.ParserError, parse_datetime, '12:')
+
+ # date and time
+ self.assertEqual(parse_datetime("12:34 18.05.2012"), datetime(2012, 5, 18, 12, 34))
+ self.assertEqual(parse_datetime("12:34, 18.05.2012"), datetime(2012, 5, 18, 12, 34))
+ self.assertEqual(parse_datetime("18.05.2012 12:34"), datetime(2012, 5, 18, 12, 34))
+ self.assertEqual(parse_datetime("18.05.2012, 12:34"), datetime(2012, 5, 18, 12, 34))
+ self.assertEqual(parse_datetime("2012, 12:34"), datetime(2012, 1, 1, 12, 34))
+ self.assertEqual(parse_datetime("2012, 12am"), datetime(2012, 1, 1, 12))
+ self.assertRaises(errors.ParserError, parse_datetime, '12.34 18:05:2012')
+
+ # invalid args
+ self.assertRaises(errors.ParserError, parse_datetime, '')
+
+ def test_guess_date(self):
+ this_year = ddate.today().year
+ # some unambiguous formats
+ self.assertEqual(guess_date('18 . 05 . 2012'.split()), (ddate(2012, 5, 18), 'DMY'))
+ self.assertEqual(guess_date('18 5 2012'.split()), (ddate(2012, 5, 18), 'DMY'))
+ self.assertEqual(guess_date('2012 , 05 , 18'.split()), (ddate(2012, 5, 18), 'YMD'))
+ self.assertEqual(guess_date('2012 5 18'.split()), (ddate(2012, 5, 18), 'YMD'))
+ self.assertEqual(guess_date('18 5 2004'.split()), (ddate(2004, 5, 18), 'DMY'))
+ self.assertEqual(guess_date('2004 5 18'.split()), (ddate(2004, 5, 18), 'YMD'))
+ self.assertEqual(guess_date('10 11 12'.split()), (ddate(2012, 11, 10), 'DMY'))
+ self.assertEqual(guess_date('10 11 12'.split(), priorities=PRIORITIES_US),
+ (ddate(2012, 10, 11), 'MDY'))
+ self.assertEqual(guess_date('2012 04 05'.split()), (ddate(2012, 4, 5), 'YMD'))
+ self.assertEqual(guess_date('2012 4 5'.split()), (ddate(2012, 4, 5), 'YMD'))
+ self.assertEqual(guess_date('2012 May , 4th'.split()), (ddate(2012, 5, 4), 'YMD'))
+ self.assertEqual(guess_date('4 5 2012'.split()), (ddate(2012, 5, 4), 'DMY'))
+ self.assertEqual(guess_date('4th of May 2012'.split()), (ddate(2012, 5, 4), 'DMY'))
+ self.assertEqual(guess_date('2012 4th of May'.split()), (ddate(2012, 5, 4), 'YDM'))
+
+ # three-part format
+ # unambiguous MD ranges, full year
+ self.assertEqual(guess_date('28 11 2018'.split()), (ddate(2018, 11, 28), 'DMY'))
+ self.assertEqual(guess_date('28 2018 11'.split()), (ddate(2018, 11, 28), 'DYM'))
+ self.assertEqual(guess_date('11 28 2018'.split()), (ddate(2018, 11, 28), 'MDY'))
+ self.assertEqual(guess_date('11 2018 28'.split()), (ddate(2018, 11, 28), 'MYD'))
+ self.assertEqual(guess_date('2018 11 28'.split()), (ddate(2018, 11, 28), 'YMD'))
+ self.assertEqual(guess_date('2018 28 11'.split()), (ddate(2018, 11, 28), 'YDM'))
+ # unambiguous MDY ranges
+ self.assertEqual(guess_date('28 11 98'.split()), (ddate(1998, 11, 28), 'DMY'))
+ self.assertEqual(guess_date('28 98 11'.split()), (ddate(1998, 11, 28), 'DYM'))
+ self.assertEqual(guess_date('11 28 98'.split()), (ddate(1998, 11, 28), 'MDY'))
+ self.assertEqual(guess_date('11 98 28'.split()), (ddate(1998, 11, 28), 'MYD'))
+ self.assertEqual(guess_date('98 11 28'.split()), (ddate(1998, 11, 28), 'YMD'))
+ self.assertEqual(guess_date('98 28 11'.split()), (ddate(1998, 11, 28), 'YDM'))
+ # explicit YMD
+ self.assertEqual(guess_date('10th of April 2018'.split()), (ddate(2018, 4, 10), 'DMY'))
+ self.assertEqual(guess_date('April 10th 98'.split()), (ddate(1998, 4, 10), 'MDY'))
+ self.assertEqual(guess_date('98 April 10th'.split()), (ddate(1998, 4, 10), 'YMD'))
+ self.assertEqual(guess_date('2018 10th of April'.split()), (ddate(2018, 4, 10), 'YDM'))
+ self.assertEqual(guess_date('2018 10 of 04'.split()), (ddate(2018, 4, 10), 'YDM'))
+ # explicit MY
+ self.assertEqual(guess_date('2018 10 April'.split()), (ddate(2018, 4, 10), 'YDM'))
+ self.assertEqual(guess_date('2018 April 10'.split()), (ddate(2018, 4, 10), 'YMD'))
+ self.assertEqual(guess_date('April 10 2018'.split()), (ddate(2018, 4, 10), 'MDY'))
+ # explicit DY
+ self.assertEqual(guess_date('10th 04 98'.split()), (ddate(1998, 4, 10), 'DMY'))
+ self.assertEqual(guess_date('2018 10th 04'.split()), (ddate(2018, 4, 10), 'YDM'))
+ self.assertEqual(guess_date('2018 04 10th'.split()), (ddate(2018, 4, 10), 'YMD'))
+ # explicit DM
+ self.assertEqual(guess_date('10th April 10'.split()), (ddate(2010, 4, 10), 'DMY'))
+ self.assertEqual(guess_date('10 10th April'.split()), (ddate(2010, 4, 10), 'YDM'))
+ self.assertEqual(guess_date('10 April 10th'.split()), (ddate(2010, 4, 10), 'YMD'))
+ # ambiguous formats: explicit Y
+ self.assertEqual(guess_date('2018 04 08'.split()), (ddate(2018, 4, 8), 'YMD'))
+ self.assertEqual(guess_date('04 2018 08'.split()), (ddate(2018, 8, 4), 'DYM'))
+ self.assertEqual(guess_date('08 04 2018'.split()), (ddate(2018, 4, 8), 'DMY'))
+ self.assertEqual(guess_date('4 8 11'.split()), (ddate(2011, 8, 4), 'DMY'))
+ # ambiguous formats: explicit D
+ self.assertEqual(guess_date('10 4th 11'.split()), (ddate(2011, 10, 4), 'MDY'))
+ self.assertEqual(guess_date('11 10 4th'.split()), (ddate(2011, 10, 4), 'YMD'))
+ self.assertEqual(guess_date('4th 11 10'.split()), (ddate(2010, 11, 4), 'DMY'))
+ self.assertEqual(guess_date('4th 10 11'.split()), (ddate(2011, 10, 4), 'DMY'))
+ # ambiguous formats: explicit M
+ self.assertEqual(guess_date('April 21 08'.split()), (ddate(2008, 4, 21), 'MDY'))
+ self.assertEqual(guess_date('08 April 21'.split()), (ddate(2021, 4, 8), 'DMY'))
+ self.assertEqual(guess_date('21 08 April'.split()), (ddate(2021, 4, 8), 'YDM'))
+ # fully ambiguous
+ self.assertEqual(guess_date('04 08 10'.split()), (ddate(2010, 8, 4), 'DMY'))
+ # errors
+ self.assertRaises(DateParserError, guess_date, '2012 98 10'.split())
+ self.assertRaises(DateParserError, guess_date, 'April 98 April'.split())
+ self.assertRaises(DateParserError, guess_date, '10th 98 29'.split())
+
+ # two-part format
+ # unambiguous DY ranges
+ self.assertEqual(guess_date('28 98'.split()), (ddate(1998, 1, 28), 'DY'))
+ self.assertEqual(guess_date('98 28'.split()), (ddate(1998, 1, 28), 'YD'))
+ self.assertEqual(guess_date('2010 28'.split()), (ddate(2010, 1, 28), 'YD'))
+ self.assertEqual(guess_date('28 2010'.split()), (ddate(2010, 1, 28), 'DY'))
+ # explicit DY
+ self.assertEqual(guess_date('28th 2010'.split()), (ddate(2010, 1, 28), 'DY'))
+ self.assertEqual(guess_date('2010 28th'.split()), (ddate(2010, 1, 28), 'YD'))
+ # explicit MY
+ self.assertEqual(guess_date('2010 April'.split()), (ddate(2010, 4, 1), 'YM'))
+ self.assertEqual(guess_date('April 2010'.split()), (ddate(2010, 4, 1), 'MY'))
+ # explicit DM
+ self.assertEqual(guess_date('April 10th'.split()), (ddate(this_year, 4, 10), 'MD'))
+ self.assertEqual(guess_date('10th April'.split()), (ddate(this_year, 4, 10), 'DM'))
+ self.assertEqual(guess_date('10th of April'.split()), (ddate(this_year, 4, 10), 'DM'))
+ self.assertEqual(guess_date('10 of 04'.split()), (ddate(this_year, 4, 10), 'DM'))
+ self.assertEqual(guess_date('10th 4'.split()), (ddate(this_year, 4, 10), 'DM'))
+ # explicit Y
+ self.assertEqual(guess_date('2010 04'.split()), (ddate(2010, 4, 1), 'YM'))
+ self.assertEqual(guess_date('04 2010'.split()), (ddate(2010, 4, 1), 'MY'))
+ self.assertEqual(guess_date('04 98'.split()), (ddate(1998, 4, 1), 'MY'))
+ self.assertEqual(guess_date('98 04'.split()), (ddate(1998, 4, 1), 'YM'))
+ # explicit M
+ self.assertEqual(guess_date('April 10'.split()), (ddate(2010, 4, 1), 'MY'))
+ self.assertEqual(guess_date('10 April'.split()), (ddate(this_year, 4, 10), 'DM'))
+ # explicit D
+ self.assertEqual(guess_date('10th 08'.split()), (ddate(this_year, 8, 10), 'DM'))
+ self.assertEqual(guess_date('08 10th'.split()), (ddate(this_year, 8, 10), 'MD'))
+ # some hints
+ self.assertEqual(guess_date('18 5'.split()), (ddate(this_year, 5, 18), 'DM'))
+ self.assertEqual(guess_date('4 8'.split()), (ddate(this_year, 8, 4), 'DM'))
+ # fully ambiguous
+ self.assertEqual(guess_date('08 10'.split()), (ddate(this_year, 10, 8), 'DM'))
+
+ # one-part format
+ # full year
+ self.assertEqual(guess_date('2018'.split()), (ddate(2018, 1, 1), 'Y'))
+ # short year
+ self.assertEqual(guess_date('18'.split()), (ddate(2018, 1, 1), 'Y'))
+ self.assertEqual(guess_date('98'.split()), (ddate(1998, 1, 1), 'Y'))
+ self.assertEqual(guess_date('08'.split()), (ddate(2008, 1, 1), 'Y'))
+ # non-year token
+ self.assertRaises(DateParserError, guess_date, ('1', ))
+ self.assertRaises(DateParserError, guess_date, ('April', ))
+ self.assertRaises(DateParserError, guess_date, ('10th', ))
+
+ # other errors
+ self.assertRaises(DateParserError, guess_date, '')
+ self.assertRaises(DateParserError, guess_date, 'fuuu'.split())
+ self.assertRaises(DateParserError, guess_date, '1 fuuu'.split())
+ self.assertRaises(DateParserError, guess_date, '1 fuuu bar 2'.split())
+ self.assertRaises(DateParserError, guess_date, '1 2 3 4'.split())
+
+ def test_guess_time(self):
+ # single token
+ self.assertEqual(guess_time(['9']), (dtime(hour=9), 'h'))
+ # am/pm notation
+ self.assertEqual(guess_time("9 am".split()), (dtime(hour=9), 'h'))
+ self.assertEqual(guess_time("10 am".split()), (dtime(hour=10), 'h'))
+ self.assertEqual(guess_time("09 am".split()), (dtime(hour=9), 'h'))
+ self.assertEqual(guess_time("9 pm".split()), (dtime(hour=21), 'h'))
+ self.assertEqual(guess_time("10 pm".split()), (dtime(hour=22), 'h'))
+ self.assertEqual(guess_time("09 pm".split()), (dtime(hour=21), 'h'))
+ self.assertEqual(guess_time("10 02 am".split()), (dtime(hour=10, minute=2), 'hm'))
+ self.assertEqual(guess_time("10 02 pm".split()), (dtime(hour=22, minute=2), 'hm'))
+ self.assertEqual(guess_time("14 am".split()), (dtime(hour=14), 'h'))
+ self.assertRaises(TimeParserError, guess_time, "14 pm".split())
+
+ # 24-hrs notation
+ self.assertEqual(guess_time("12 34".split()), (dtime(hour=12, minute=34), 'hm'))
+ self.assertEqual(guess_time("15 32".split()), (dtime(hour=15, minute=32), 'hm'))
+ self.assertEqual(guess_time("12 04".split()), (dtime(hour=12, minute=4), 'hm'))
+ self.assertEqual(guess_time("12 4".split()), (dtime(hour=12, minute=4), 'hm'))
+ # range
+ self.assertEqual(guess_time("12 58".split()), (dtime(hour=12, minute=58), 'hm'))
+ self.assertEqual(guess_time("31 04".split()), (dtime(minute=31, second=4), 'ms'))
+ self.assertEqual(guess_time("31 58".split()), (dtime(minute=31, second=58), 'ms'))
+ # three terms
+ self.assertEqual(guess_time("12 34 54".split()),
+ (dtime(hour=12, minute=34, second=54), 'hms'))
+ # four terms
+ self.assertEqual(guess_time("12 34 54 984".split()),
+ (dtime(hour=12, minute=34, second=54, microsecond=984000), 'hmsn'))
+ # trailing zeros
+ self.assertEqual(guess_time("12 34 54 98400".split()),
+ (dtime(hour=12, minute=34, second=54, microsecond=984000), 'hmsn'))
+ # leading zeros
+ self.assertEqual(guess_time("12 34 54 098400".split()),
+ (dtime(hour=12, minute=34, second=54, microsecond=98400), 'hmsn'))
+
+ # invalid formats
+ self.assertRaises(TimeParserError, guess_time, [])
+ self.assertRaises(TimeParserError, guess_time, ['0', '1', '2', '3', '4'])
+ self.assertRaises(TimeParserError, guess_time, "83 02".split())
+ self.assertRaises(TimeParserError, guess_time, "52 74".split())
+
+ def test_guess_datetime(self):
+ self.assertEqual(guess_datetime(
+ Struct({'date': '18 05 2012'.split(), 'time': '12 34'.split()})),
+ (datetime(2012, 5, 18, 12, 34), 'DMYhm'))
+ self.assertEqual(guess_datetime(Struct({'date': '18 05 2012'.split()})),
+ (datetime(2012, 5, 18), 'DMY'))
+ self.assertEqual(guess_datetime(Struct({'time': '12 34'.split()})),
+ (datetime(1970, 1, 1, 12, 34), 'hm'))
+ self.assertRaises(DateFormatError, guess_datetime, Struct({}))
+
+ def test_DF(self):
+ # msb
+ self.assertRaises(DateFormatError, DF('').msb)
+ self.assertRaises(DateFormatError, DF('abc').msb)
+ self.assertRaises(DateFormatError, DF('ydHSN').msb)
+ self.assertEqual('Y', DF('Yab').msb())
+ self.assertEqual('Y', DF('YDM').msb())
+ self.assertEqual('Y', DF('MdY').msb())
+ self.assertEqual('D', DF('mDn').msb())
+ self.assertEqual('m', DF('mdn').msb())
+ self.assertEqual('n', DF('nab').msb())
+ # lsb
+ self.assertRaises(DateFormatError, DF('').lsb)
+ self.assertRaises(DateFormatError, DF('abc').lsb)
+ self.assertEqual('Y', DF('Yab').lsb())
+ self.assertEqual('D', DF('YDM').lsb())
+ self.assertEqual('M', DF('MdY').lsb())
+ self.assertEqual('n', DF('mDn').lsb())
+ self.assertEqual('n', DF('nab').lsb())
+ # is_time
+ self.assertTrue(DF('mshn').is_time())
+ self.assertTrue(DF('mh').is_time())
+ self.assertTrue(DF('h').is_time())
+ self.assertTrue(DF('m').is_time())
+ self.assertTrue(DF('s').is_time())
+ self.assertTrue(DF('n').is_time())
+ self.assertFalse(DF('').is_time())
+ self.assertFalse(DF('abc').is_time())
+ self.assertFalse(DF('Msnh').is_time())
+ self.assertFalse(DF('Ymsnh').is_time())
+ self.assertFalse(DF('Dmsnh').is_time())
+ self.assertFalse(DF('YDM').is_time())
+ # is_date
+ self.assertTrue(DF('YDM').is_date())
+ self.assertTrue(DF('YM').is_date())
+ self.assertTrue(DF('DM').is_date())
+ self.assertTrue(DF('DY').is_date())
+ self.assertTrue(DF('Y').is_date())
+ self.assertTrue(DF('D').is_date())
+ self.assertTrue(DF('M').is_date())
+ self.assertFalse(DF('').is_date())
+ self.assertFalse(DF('abc').is_date())
+ self.assertFalse(DF('YDMn').is_date())
+ self.assertFalse(DF('YDm').is_date())
+ self.assertFalse(DF('YDh').is_date())
+ self.assertFalse(DF('hmsn').is_date())
+ # valid
+ self.assertTrue(DF('Y').valid())
+ self.assertTrue(DF('YDMhsmn').valid())
+ self.assertTrue(DF('Yabc').valid())
+ self.assertFalse(DF('').valid())
+ self.assertFalse(DF('abc').valid())
+ self.assertFalse(DF('ydHSN').valid())
+
+
+ def test_increment(self):
+ self.assertRaises(DateFormatError, increment, None, '')
+ self.assertEqual(increment(datetime(1970, 1, 1, 0, 0, 0, 10), DF('n')),
+ datetime(1970, 1, 1, 0, 0, 0, 11))
+ self.assertEqual(increment(datetime(1970, 1, 1, 0, 0, 1), DF('s')),
+ datetime(1970, 1, 1, 0, 0, 2))
+ self.assertEqual(increment(datetime(1970, 1, 1, 0, 1), DF('m')),
+ datetime(1970, 1, 1, 0, 2))
+ self.assertEqual(increment(datetime(1970, 1, 1, 1), DF('h')),
+ datetime(1970, 1, 1, 2))
+ self.assertEqual(increment(datetime(1970, 1, 1, 1), DF('h')),
+ datetime(1970, 1, 1, 2))
+ self.assertEqual(increment(datetime(1970, 2, 3, 4, 5, 6), DF('D')),
+ datetime(1970, 2, 4))
+ self.assertEqual(increment(datetime(1970, 2, 3, 4, 5, 6), DF('M')),
+ datetime(1970, 3, 1))
+ self.assertEqual(increment(datetime(1970, 2, 3, 4, 5, 6), DF('Y')),
+ datetime(1971, 1, 1))
+ self.assertRaises(DateFormatError, increment, datetime(1970, 2, 3, 4, 5, 6), DF('abc'))
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
diff --git a/test/parsing/test_sort.py b/test/parsing/test_sort.py
new file mode 100644
index 0000000..40c9ee1
--- /dev/null
+++ b/test/parsing/test_sort.py
@@ -0,0 +1,96 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import unittest
+
+# tagit imports
+from tagit.utils import errors
+#from tagit.parsing.search import ast, sortkeys # FIXME: mb/port/parsing
+
+# objects to test
+from tagit.parsing.sort import sort_from_string
+
+
+## code ##
+
+class TestParseSort(unittest.TestCase):
+ def setUp(self):
+ sortkeys.expose('iso',
+ TestScope('attribute', 'iso'), 'Numerical')
+ sortkeys.expose('rank',
+ TestScope('attribute', 'rank'), 'Alphabetical', 'Numerical')
+ sortkeys.expose('time',
+ TestScope('attribute', 'time'), 'Numerical')
+ sortkeys.expose('entity',
+ TestScope('property', 'guid'), 'Alphabetical')
+ sortkeys.expose('tag',
+ TestScope('property', 't_image_create_loc'), 'Anchored')
+ sortkeys.expose('mistake',
+ TestScope('property', 't_image_create_loc'))
+
+ def test_parse_sort(self):
+ # simple patterns
+ self.assertEqual(sort_from_string("time"), ast.NumericalSort('time', False))
+ self.assertEqual(sort_from_string("entity"), ast.AlphabeticalSort('entity', False))
+ self.assertEqual(sort_from_string("time asc"), ast.NumericalSort('time', False))
+ self.assertEqual(sort_from_string("time desc"), ast.NumericalSort('time', True))
+ self.assertEqual(sort_from_string("entity desc"), ast.AlphabeticalSort('entity', True))
+ self.assertEqual(sort_from_string("sort by time"), ast.NumericalSort('time', False))
+ self.assertEqual(sort_from_string("sort by time desc"), ast.NumericalSort('time', True))
+ self.assertEqual(sort_from_string("sort by entity desc"),
+ ast.AlphabeticalSort('entity', True))
+ # full pattern
+ self.assertEqual(sort_from_string("sort alphabetically by entity upwards"),
+ ast.AlphabeticalSort('entity', False))
+ self.assertEqual(sort_from_string("sort numerically by time desc"),
+ ast.NumericalSort('time', True))
+ # invalid type
+ self.assertRaises(errors.ParserError, sort_from_string, "sort alphabetically by time desc")
+ self.assertRaises(errors.ParserError, sort_from_string, "sort numerically by entity desc")
+ self.assertRaises(errors.ParserError, sort_from_string, "sort by time similarity to AF39D281CE3")
+ self.assertRaises(errors.ParserError, sort_from_string, "sort alphabetically by tag down,")
+ # ambiguous type
+ self.assertEqual(sort_from_string("sort alphabetically by rank"),
+ ast.AlphabeticalSort('rank', False))
+ self.assertEqual(sort_from_string("sort numerically by rank"),
+ ast.NumericalSort('rank', False))
+ self.assertRaises(errors.ParserError, sort_from_string, "sort by rank")
+ # anchor pattern
+ self.assertEqual(sort_from_string("sort by tag similarity to AF39D281CE3"),
+ ast.AnchoredSort('tag', 'AF39D281CE3', False))
+ self.assertEqual(sort_from_string("tag AF39D281CE3 up"),
+ ast.AnchoredSort('tag', 'AF39D281CE3', False))
+ self.assertEqual(sort_from_string("tag AF39D281CE3 down"),
+ ast.AnchoredSort('tag', 'AF39D281CE3', True))
+ self.assertRaises(errors.ParserError, sort_from_string, "time AF39D281CE3")
+ self.assertRaises(errors.ParserError, sort_from_string, "sort by tag down,")
+ self.assertRaises(errors.ParserError, sort_from_string, "tag XXXXXXXXXXX down,")
+ # compound statements
+ self.assertEqual(sort_from_string("time, iso"),
+ ast.Order(ast.NumericalSort('time'), ast.NumericalSort('iso')))
+ self.assertEqual(sort_from_string("tag AF39D281CE3 down, time up"),
+ ast.Order(ast.AnchoredSort('tag', 'AF39D281CE3', True),
+ ast.NumericalSort('time', False)))
+ self.assertRaises(errors.ParserError, sort_from_string, "tag AF39D281CE3 down,")
+ # empty string
+ self.assertRaises(errors.ParserError, sort_from_string, "")
+ # invalid predicate
+ self.assertRaises(errors.ParserError, sort_from_string, "foobar")
+ # invalid direction
+ self.assertRaises(errors.ParserError, sort_from_string, "sort by entity sideways")
+ # invalid typedef
+ self.assertRaises(errors.ParserError, sort_from_string, "sort by mistake")
+ # missing anchor
+ self.assertRaises(errors.ParserError, sort_from_string, "sort by time similarity to")
+
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-04 06:15:53 +0000