zc.catalog 3.0

CHANGES

值索引

值索引是一个类似于标准Zope字段索引的索引，但比标准Zope字段索引更灵活。索引允许对包含任何一组值的文档进行搜索；在一组值之间；任何（非None）值；以及任何空值。

此外，索引支持一个接口，允许检查索引值。

尽可能没有策略，旨在作为具有更多策略的索引的引擎，同时本身也有用。

创建索引时，没有wordCount，没有documentCount，并且如预期的那样相当空。

>>> from zc.catalog.index import ValueIndex
>>> index = ValueIndex()
>>> index.documentCount()
0
>>> index.wordCount()
0
>>> index.maxValue() # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...
>>> index.minValue() # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...
>>> list(index.values())
[]
>>> len(index.apply({'any_of': (5,)}))
0

索引支持索引任何值。给定索引内的所有值必须在Python版本之间保持一致排序。

>>> data = {1: 'a',
...         2: 'b',
...         3: 'a',
...         4: 'c',
...         5: 'd',
...         6: 'c',
...         7: 'c',
...         8: 'b',
...         9: 'c',
... }
>>> for k, v in data.items():
...     index.index_doc(k, v)
...

索引后，统计信息和值与新输入的内容相匹配。

>>> list(index.values())
['a', 'b', 'c', 'd']
>>> index.documentCount()
9
>>> index.wordCount()
4
>>> index.maxValue()
'd'
>>> index.minValue()
'a'
>>> list(index.ids())
[1, 2, 3, 4, 5, 6, 7, 8, 9]

索引支持四种类型的查询。第一种是‘any_of’。它接受一个值可迭代的，并返回一个包含任何值的文档ID的可迭代的。结果没有加权。

>>> list(index.apply({'any_of': ('b', 'c')}))
[2, 4, 6, 7, 8, 9]
>>> list(index.apply({'any_of': ('b',)}))
[2, 8]
>>> list(index.apply({'any_of': ('d',)}))
[5]
>>> bool(index.apply({'any_of': (42,)}))
False

另一个查询是‘any’，如果键为None，则返回所有带有任何值的索引文档ID。如果键是一个范围，则返回范围和所有具有任何值的文档ID的交集。

>>> list(index.apply({'any': None}))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> from zc.catalog.extentcatalog import FilterExtent
>>> extent = FilterExtent(lambda extent, uid, obj: True)
>>> for i in range(15):
...     extent.add(i, i)
...
>>> list(index.apply({'any': extent}))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> limited_extent = FilterExtent(lambda extent, uid, obj: True)
>>> for i in range(5):
...     limited_extent.add(i, i)
...
>>> list(index.apply({'any': limited_extent}))
[1, 2, 3, 4]

‘between’参数接受从1到4个值。第一个是最小值，默认为None，表示没有最小值；第二个是最大值，默认为None，表示没有最大值；下一个是布尔值，表示是否排除最小值，默认为False；最后一个是布尔值，表示是否排除最大值，也默认为False。结果没有加权。

>>> list(index.apply({'between': ('b', 'd')}))
[2, 4, 5, 6, 7, 8, 9]
>>> list(index.apply({'between': ('c', None)}))
[4, 5, 6, 7, 9]
>>> list(index.apply({'between': ('c',)}))
[4, 5, 6, 7, 9]
>>> list(index.apply({'between': ('b', 'd', True, True)}))
[4, 6, 7, 9]

使用无效的（在Python 3上不可比较的）参数来“between”产生无结果。

>>> list(index.apply({'between': (1, 5)}))
[]

‘none’参数接受一个范围并返回该范围内未索引的ID；它旨在用于返回没有（或空）值的docids。

>>> list(index.apply({'none': extent}))
[0, 10, 11, 12, 13, 14]

一次尝试使用多个这些会生成错误。

>>> index.apply({'between': (5,), 'any_of': (3,)})
... # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...

使用它们中的任何一个都不返回None。

>>> index.apply({}) # returns None

无效的查询名称会导致ValueErrors。

>>> index.apply({'foo': ()})
... # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...

当你取消索引一个文档时，搜索和统计信息应该更新。

>>> index.unindex_doc(5)
>>> len(index.apply({'any_of': ('d',)}))
0
>>> index.documentCount()
8
>>> index.wordCount()
3
>>> list(index.values())
['a', 'b', 'c']
>>> list(index.ids())
[1, 2, 3, 4, 6, 7, 8, 9]

重新索引一个已更改值的文档也会反映在随后的搜索和统计检查中。

>>> list(index.apply({'any_of': ('b',)}))
[2, 8]
>>> data[8] = 'e'
>>> index.index_doc(8, data[8])
>>> index.documentCount()
8
>>> index.wordCount()
4
>>> list(index.apply({'any_of': ('e',)}))
[8]
>>> list(index.apply({'any_of': ('b',)}))
[2]
>>> data[2] = 'e'
>>> index.index_doc(2, data[2])
>>> index.documentCount()
8
>>> index.wordCount()
3
>>> list(index.apply({'any_of': ('e',)}))
[2, 8]
>>> list(index.apply({'any_of': ('b',)}))
[]

重新索引现在值为None的文档会导致它从统计信息中删除。

>>> data[3] = None
>>> index.index_doc(3, data[3])
>>> index.documentCount()
7
>>> index.wordCount()
3
>>> list(index.ids())
[1, 2, 4, 6, 7, 8, 9]

这会影响确定哪些ID在索引中（是否有值）以及哪些ID不在索引中（是否有值）的方式。

>>> list(index.apply({'any': None}))
[1, 2, 4, 6, 7, 8, 9]
>>> list(index.apply({'any': extent}))
[1, 2, 4, 6, 7, 8, 9]
>>> list(index.apply({'none': extent}))
[0, 3, 5, 10, 11, 12, 13, 14]

可以使用values方法来检查给定文档ID的索引值。对于valueindex，给定doc_id的“values”的长度始终为0或1。

>>> index.values(doc_id=8)
('e',)

containsValue方法提供了一种确定值成员的方法。

>>> index.containsValue('a')
True
>>> index.containsValue('q')
False

集合索引

setindex是一个类似于传统关键字索引但更为通用的索引。索引的值预期是可迭代的；该索引允许搜索包含任何一组值、所有值或一组值之间的文档。

此外，索引支持一个接口，允许检查索引值。

尽可能没有策略，旨在作为具有更多策略的索引的引擎，同时本身也有用。

创建索引时，没有wordCount，没有documentCount，并且如预期的那样相当空。

>>> from zc.catalog.index import SetIndex
>>> index = SetIndex()
>>> index.documentCount()
0
>>> index.wordCount()
0
>>> index.maxValue() # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...
>>> index.minValue() # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...
>>> list(index.values())
[]
>>> len(index.apply({'any_of': (5,)}))
0

索引支持索引任何值。给定索引内的所有值必须在Python版本之间保持一致的排序。在实践中，在Python 3中这意味着值需要是同质的。

>>> data = {1: ['a', '1'],
...         2: ['b', 'a', '3', '4', '7'],
...         3: ['1'],
...         4: ['1', '4', 'c'],
...         5: ['7'],
...         6: ['5', '6', '7'],
...         7: ['c'],
...         8: ['1', '6'],
...         9: ['a', 'c', '2', '3', '4', '6',],
... }
>>> for k, v in data.items():
...     index.index_doc(k, v)
...

索引后，统计信息和值与新输入的内容相匹配。

>>> list(index.values())
['1', '2', '3', '4', '5', '6', '7', 'a', 'b', 'c']
>>> index.documentCount()
9
>>> index.wordCount()
10
>>> index.maxValue()
'c'
>>> index.minValue()
'1'
>>> list(index.ids())
[1, 2, 3, 4, 5, 6, 7, 8, 9]

索引支持五种查询类型。第一种是“any_of”。它接受一个值可迭代的集合，并返回一个包含任何这些值的文档id的可迭代的集合。结果是有权重的。

>>> list(index.apply({'any_of': ('b', '1', '5')}))
[1, 2, 3, 4, 6, 8]
>>> list(index.apply({'any_of': ('b', '1', '5')}))
[1, 2, 3, 4, 6, 8]
>>> list(index.apply({'any_of': ('42',)}))
[]
>>> index.apply({'any_of': ('a', '3', '7')})              # doctest: +ELLIPSIS
BTrees...FBucket([(1, 1.0), (2, 3.0), (5, 1.0), (6, 1.0), (9, 2.0)])

使用无效（在Python 3上不可比较）的参数将被忽略。

>>> list(index.apply({'any_of': (1,)}))
[]
>>> list(index.apply({'any_of': (1, '1')}))
[1, 3, 4, 8]

另一个查询是“any”。如果键为None，则返回所有索引文档id，其中包含任何值。如果键是一个范围，则返回范围与所有包含任何值的文档id的交集。

>>> list(index.apply({'any': None}))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> from zc.catalog.extentcatalog import FilterExtent
>>> extent = FilterExtent(lambda extent, uid, obj: True)
>>> for i in range(15):
...     extent.add(i, i)
...
>>> list(index.apply({'any': extent}))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> limited_extent = FilterExtent(lambda extent, uid, obj: True)
>>> for i in range(5):
...     limited_extent.add(i, i)
...
>>> list(index.apply({'any': limited_extent}))
[1, 2, 3, 4]

“all_of”参数也接受一个值可迭代的集合，但返回一个包含所有这些值的文档id的可迭代的集合。结果是无权重的。

>>> list(index.apply({'all_of': ('a',)}))
[1, 2, 9]
>>> list(index.apply({'all_of': ('3', '4')}))
[2, 9]
>>> list(index.apply({'all_of': (3, '4')}))
[]
>>> list(index.apply({'all_of': ('3', 4)}))
[]

这些测试说明了两个相关的已修复的错误。

>>> list(index.apply({'all_of': ('z', '3', '4')}))
[]
>>> list(index.apply({'all_of': ('3', '4', 'z')}))
[]

“between”参数接受从1到4个值。第一个是最小值，默认为None，表示没有最小值；第二个是最大值，默认为None，表示没有最大值；下一个是一个布尔值，表示是否排除最小值，默认为False；最后一个是一个布尔值，表示是否排除最大值，也默认为False。结果是权重的。

>>> list(index.apply({'between': ('1', '7')}))
[1, 2, 3, 4, 5, 6, 8, 9]
>>> list(index.apply({'between': ('b', None)}))
[2, 4, 7, 9]
>>> list(index.apply({'between': ('b',)}))
[2, 4, 7, 9]
>>> list(index.apply({'between': ('1', '7', True, True)}))
[2, 4, 6, 8, 9]
>>> index.apply({'between': ('2', '6')})               # doctest: +ELLIPSIS
BTrees...FBucket([(2, 2.0), (4, 1.0), (6, 2.0), (8, 1.0), (9, 4.0)])

使用无效（在Python 3上不可比较）的参数不会产生任何结果。

>>> list(index.apply({'between': (1, 7)}))
[]

‘none’参数接受一个范围并返回该范围内未索引的ID；它旨在用于返回没有（或空）值的docids。

>>> list(index.apply({'none': extent}))
[0, 10, 11, 12, 13, 14]

一次尝试使用多个这些会生成错误。

>>> index.apply({'all_of': ('5',), 'any_of': ('3',)})
... # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...

使用它们中的任何一个都不返回None。

>>> index.apply({}) # returns None

无效的查询名称会导致ValueErrors。

>>> index.apply({'foo': ()})
... # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError:...

当你取消索引一个文档时，搜索和统计信息应该更新。

>>> index.unindex_doc(6)
>>> len(index.apply({'any_of': ('5',)}))
0
>>> index.documentCount()
8
>>> index.wordCount()
9
>>> list(index.values())
['1', '2', '3', '4', '6', '7', 'a', 'b', 'c']
>>> list(index.ids())
[1, 2, 3, 4, 5, 7, 8, 9]

重新索引具有新附加值的文档也会反映在随后的搜索和统计检查中。

>>> data[8].extend(['5', 'c'])
>>> index.index_doc(8, data[8])
>>> index.documentCount()
8
>>> index.wordCount()
10
>>> list(index.apply({'any_of': ('5',)}))
[8]
>>> list(index.apply({'any_of': ('c',)}))
[4, 7, 8, 9]

对于具有添加和删除的文档重新索引也是一样。

>>> 2 in set(index.apply({'any_of': ('7',)}))
True
>>> 2 in set(index.apply({'any_of': ('2',)}))
False
>>> data[2].pop()
'7'
>>> data[2].append('2')
>>> index.index_doc(2, data[2])
>>> 2 in set(index.apply({'any_of': ('7',)}))
False
>>> 2 in set(index.apply({'any_of': ('2',)}))
True

重新索引不再有任何值的文档会导致它从统计中被移除。

>>> del data[2][:]
>>> index.index_doc(2, data[2])
>>> index.documentCount()
7
>>> index.wordCount()
9
>>> list(index.ids())
[1, 3, 4, 5, 7, 8, 9]

这会影响确定哪些ID在索引中（是否有值）以及哪些ID不在索引中（是否有值）的方式。

>>> list(index.apply({'any': None}))
[1, 3, 4, 5, 7, 8, 9]
>>> list(index.apply({'none': extent}))
[0, 2, 6, 10, 11, 12, 13, 14]

可以使用values方法来检查给定文档id的索引值。

>>> set(index.values(doc_id=8)) == set(['1', '5', '6', 'c'])
True

containsValue方法提供了一种确定值成员的方法。

>>> index.containsValue('5')
True
>>> index.containsValue(5)
False
>>> index.containsValue('20')
False

规范化索引

index模块提供了一个标准化包装器、一个DateTime标准化器以及一个使用DateTime标准化器标准化的集合索引和值索引。

标准化包装器实现了完整的索引接口– zope.index.interfaces.IInjection、zope.index.interfaces.IIndexSearch、zope.index.interfaces.IStatistics和zc.catalog.interfaces.IIndexValues–并将所有行为委托给包装的索引，在索引看到它们之前使用标准化器标准化值。

标准化包装器目前仅支持zc.catalog.interfaces.ISetIndex和zc.catalog.interfaces.IValueIndex提供的查询。

标准化器接口需要以下方法，如接口中定义的：

def value(value)

“””对输入值进行标准化或检查约束；引发错误或返回要索引的值。”””

def any(value, index)

“””对“any_of”搜索的查询值进行标准化；返回值序列。”””

def all(value, index)

“””对“all_of”搜索的查询值进行标准化；返回查询的值。”””

def minimum(value, index)

“””对范围的“最小值”进行标准化；返回查询的值。”””

def maximum(value, index)

“””对范围的“最大值”进行标准化；返回查询的值。”””

DateTime标准化器执行以下标准化和验证。每当需要时区信息时，它都会尝试从当前交互中获取请求并将其适配到zope.interface.common.idatetime.ITZInfo；如果失败（没有请求或没有适配器），则使用系统本地时区。

• 输入值必须是带时区的日期时间。它们被归一化到创建归一化器时指定的分辨率：分辨率为0将值归一化到天；分辨率为1到小时；2到分钟；3到秒；4到微秒。

• “任何”值可以是带时区的日期时间、不带时区的日期时间或日期。日期将转换为找到的时区中给定日期的起始到结束的任何值，如上所述。不带时区的日期时间将获得找到的时区。

• “全部”值可以是带时区的日期时间或不带时区的日期时间。不带时区的日期时间将获得找到的时区。

• “最小”值可以是带时区的日期时间、不带时区的日期时间或日期。日期将转换为找到的时区中给定日期的起始时间，如上所述。不带时区的日期时间将获得找到的时区。

• “最大”值可以是带时区的日期时间、不带时区的日期时间或日期。日期将转换为找到的时区中给定日期的结束时间，如上所述。不带时区的日期时间将获得找到的时区。

首先让我们看看 DateTime normalizer，然后是它与正常化包装器和值及集合索引的集成。

索引值使用“值”进行解析。

>>> from zc.catalog.index import DateTimeNormalizer
>>> n = DateTimeNormalizer() # defaults to minutes
>>> import datetime
>>> import pytz
>>> naive_datetime = datetime.datetime(2005, 7, 15, 11, 21, 32, 104)
>>> date = naive_datetime.date()
>>> aware_datetime = naive_datetime.replace(
...     tzinfo=pytz.timezone('US/Eastern'))
>>> n.value(naive_datetime)
Traceback (most recent call last):
...
ValueError: This index only indexes timezone-aware datetimes.
>>> n.value(date)
Traceback (most recent call last):
...
ValueError: This index only indexes timezone-aware datetimes.
>>> n.value(aware_datetime) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, tzinfo=<DstTzInfo 'US/Eastern'...>)

如果我们指定不同的分辨率，结果也会不同。

>>> another = DateTimeNormalizer(1) # hours
>>> another.value(aware_datetime) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 0, tzinfo=<DstTzInfo 'US/Eastern'...>)

请注意，改变索引值的分辨率可能会产生令人惊讶的结果，因为查询不会改变它们的分辨率。因此，如果您使用比归一化器分辨率更精细的日期时间索引某物，则搜索该日期时间将找不到 doc_id。

“任何_of”查询中的值使用“任何”进行解析。“任何”应该返回一个值序列。它需要一个索引，我们将在下面模拟它。

>>> class DummyIndex(object):
...     def values(self, start, stop, exclude_start, exclude_stop):
...         assert not exclude_start and exclude_stop
...         six_hours = datetime.timedelta(hours=6)
...         res = []
...         dt = start
...         while dt < stop:
...             res.append(dt)
...             dt += six_hours
...         return res
...
>>> index = DummyIndex()
>>> tuple(n.any(naive_datetime, index)) # doctest: +ELLIPSIS
(datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Local...>),)
>>> tuple(n.any(aware_datetime, index)) # doctest: +ELLIPSIS
(datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Eastern...>),)
>>> tuple(n.any(date, index)) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
(datetime.datetime(2005, 7, 15, 0, 0, tzinfo=<...Local...>),
 datetime.datetime(2005, 7, 15, 6, 0, tzinfo=<...Local...>),
 datetime.datetime(2005, 7, 15, 12, 0, tzinfo=<...Local...>),
 datetime.datetime(2005, 7, 15, 18, 0, tzinfo=<...Local...>))

“all_of”查询中的值使用“all”进行解析。

>>> n.all(naive_datetime, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Local...>)
>>> n.all(aware_datetime, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Eastern...>)
>>> n.all(date, index) # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError: ...

“between”查询中的最小值以及其他方法中的最小值使用“minimum”进行解析。它们还接受一个可选的 exclude 布尔值，表示是否排除最小值。对于日期时间，只有当您传递一个日期时才会有所不同。

>>> n.minimum(naive_datetime, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Local...>)
>>> n.minimum(naive_datetime, index, exclude=True) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Local...>)

>>> n.minimum(aware_datetime, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Eastern...>)
>>> n.minimum(aware_datetime, index, True) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Eastern...>)

>>> n.minimum(date, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 0, 0, tzinfo=<...Local...>)
>>> n.minimum(date, index, True) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 23, 59, 59, 999999, tzinfo=<...Local...>)

“between”查询中的最大值以及其他方法中的最大值使用“maximum”进行解析。它们也接受一个可选的 exclude 布尔值，表示是否排除最大值。对于日期时间，只有当您传递一个日期时才会有所不同。

>>> n.maximum(naive_datetime, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Local...>)
>>> n.maximum(naive_datetime, index, exclude=True) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Local...>)

>>> n.maximum(aware_datetime, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Eastern...>)
>>> n.maximum(aware_datetime, index, True) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, 32, 104, tzinfo=<...Eastern...>)

>>> n.maximum(date, index) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 23, 59, 59, 999999, tzinfo=<...Local...>)
>>> n.maximum(date, index, True) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 0, 0, tzinfo=<...Local...>)

现在让我们在一个真实索引的上下文中检查这些归一化器。

>>> from zc.catalog.index import DateTimeValueIndex, DateTimeSetIndex
>>> setindex = DateTimeSetIndex() # minutes resolution
>>> data = [] # generate some data
>>> def date_gen(
...     start=aware_datetime,
...     count=12,
...     period=datetime.timedelta(hours=10)):
...     dt = start
...     ix = 0
...     while ix < count:
...         yield dt
...         dt += period
...         ix += 1
...
>>> gen = date_gen()
>>> count = 0
>>> while True:
...     try:
...         next_ = [next(gen) for i in range(6)]
...     except StopIteration:
...         break
...     data.append((count, next_[0:1]))
...     count += 1
...     data.append((count, next_[1:3]))
...     count += 1
...     data.append((count, next_[3:6]))
...     count += 1
...
>>> print(data) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
[(0,
  [datetime.datetime(2005, 7, 15, 11, 21, 32, 104, ...<...Eastern...>)]),
 (1,
  [datetime.datetime(2005, 7, 15, 21, 21, 32, 104, ...<...Eastern...>),
   datetime.datetime(2005, 7, 16, 7, 21, 32, 104, ...<...Eastern...>)]),
 (2,
  [datetime.datetime(2005, 7, 16, 17, 21, 32, 104, ...<...Eastern...>),
   datetime.datetime(2005, 7, 17, 3, 21, 32, 104, ...<...Eastern...>),
   datetime.datetime(2005, 7, 17, 13, 21, 32, 104, ...<...Eastern...>)]),
 (3,
  [datetime.datetime(2005, 7, 17, 23, 21, 32, 104, ...<...Eastern...>)]),
 (4,
  [datetime.datetime(2005, 7, 18, 9, 21, 32, 104, ...<...Eastern...>),
   datetime.datetime(2005, 7, 18, 19, 21, 32, 104, ...<...Eastern...>)]),
 (5,
  [datetime.datetime(2005, 7, 19, 5, 21, 32, 104, ...<...Eastern...>),
   datetime.datetime(2005, 7, 19, 15, 21, 32, 104, ...<...Eastern...>),
   datetime.datetime(2005, 7, 20, 1, 21, 32, 104, ...<...Eastern...>)])]
>>> data_dict = dict(data)
>>> for doc_id, value in data:
...     setindex.index_doc(doc_id, value)
...
>>> list(setindex.ids())
[0, 1, 2, 3, 4, 5]
>>> set(setindex.values()) == set(
...     setindex.normalizer.value(v) for v in date_gen())
True

对于搜索，我们将实际使用一个请求和交互，使用一个返回东部时区的适配器。这使得示例对它们使用的机器的依赖性更小。

>>> import zope.security.management
>>> import zope.publisher.browser
>>> import zope.interface.common.idatetime
>>> import zope.publisher.interfaces
>>> request = zope.publisher.browser.TestRequest()
>>> zope.security.management.newInteraction(request)
>>> from zope import interface, component
>>> @interface.implementer(zope.interface.common.idatetime.ITZInfo)
... @component.adapter(zope.publisher.interfaces.IRequest)
... def tzinfo(req):
...     return pytz.timezone('US/Eastern')
...
>>> component.provideAdapter(tzinfo)
>>> n.all(naive_datetime, index).tzinfo is pytz.timezone('US/Eastern')
True

>>> set(setindex.apply({'any_of': (datetime.date(2005, 7, 17),
...                                datetime.date(2005, 7, 20),
...                                datetime.date(2005, 12, 31))})) == set(
...     (2, 3, 5))
True

请注意，此搜索正在使用归一化值。

>>> set(setindex.apply({'all_of': (
...     datetime.datetime(
...         2005, 7, 16, 7, 21, tzinfo=pytz.timezone('US/Eastern')),
...     datetime.datetime(
...         2005, 7, 15, 21, 21, tzinfo=pytz.timezone('US/Eastern')),)})
...     ) == set((1,))
True
>>> list(setindex.apply({'any': None}))
[0, 1, 2, 3, 4, 5]
>>> set(setindex.apply({'between': (
...     datetime.datetime(2005, 4, 1, 12), datetime.datetime(2006, 5, 1))})
...     ) == set((0, 1, 2, 3, 4, 5))
True
>>> set(setindex.apply({'between': (
...     datetime.datetime(2005, 4, 1, 12), datetime.datetime(2006, 5, 1),
...     True, True)})
...     ) == set((0, 1, 2, 3, 4, 5))
True

“between”搜索应该很好地处理日期。

>>> set(setindex.apply({'between': (
...     datetime.date(2005, 7, 16), datetime.date(2005, 7, 17))})
...     ) == set((1, 2, 3))
True
>>> len(setindex.apply({'between': (
...     datetime.date(2005, 7, 16), datetime.date(2005, 7, 17))})
...     ) == len(setindex.apply({'between': (
...     datetime.date(2005, 7, 15), datetime.date(2005, 7, 18),
...     True, True)})
...     )
True

删除文档的工作与往常一样。

>>> setindex.unindex_doc(1)
>>> list(setindex.ids())
[0, 2, 3, 4, 5]

值、最小值和最大值可以接受不带时区的日期时间和日期。

>>> setindex.minValue() # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 15, 11, 21, ...<...Eastern...>)
>>> setindex.minValue(datetime.date(2005, 7, 17)) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 17, 3, 21, ...<...Eastern...>)

>>> setindex.maxValue() # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 20, 1, 21, ...<...Eastern...>)
>>> setindex.maxValue(datetime.date(2005, 7, 17)) # doctest: +ELLIPSIS
datetime.datetime(2005, 7, 17, 23, 21, ...<...Eastern...>)

>>> list(setindex.values(
... datetime.date(2005, 7, 17), datetime.date(2005, 7, 17)))
... # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
[datetime.datetime(2005, 7, 17, 3, 21, ...<...Eastern...>),
 datetime.datetime(2005, 7, 17, 13, 21, ...<...Eastern...>),
 datetime.datetime(2005, 7, 17, 23, 21, ...<...Eastern...>)]

>>> zope.security.management.endInteraction() # TODO put in tests tearDown

范围目录

范围目录与正常目录非常相似，只是它只索引可添加到其范围的项。范围既是过滤器也是可能与其他结果集合并的集合。过滤是我们在下面将要讨论的附加功能；我们将从简单的“什么也不做”的范围开始，它只支持第二种用法。

我们在这里创建文本需要的状态。

>>> import zope.keyreference.persistent
>>> import zope.component
>>> import zope.intid
>>> import zope.component
>>> import zope.interface.interfaces
>>> import zope.component.persistentregistry
>>> from ZODB.MappingStorage import DB
>>> import transaction

>>> zope.component.provideAdapter(
...     zope.keyreference.persistent.KeyReferenceToPersistent,
...     adapts=(zope.interface.Interface,))
>>> zope.component.provideAdapter(
...     zope.keyreference.persistent.connectionOfPersistent,
...     adapts=(zope.interface.Interface,))

>>> site_manager = None
>>> def getSiteManager(context=None):
...     if context is None:
...         if site_manager is None:
...             return zope.component.getGlobalSiteManager()
...         else:
...             return site_manager
...     else:
...         try:
...             return zope.interface.interfaces.IComponentLookup(context)
...         except TypeError as error:
...             raise zope.component.ComponentLookupError(*error.args)
...
>>> def setSiteManager(sm):
...     global site_manager
...     site_manager = sm
...     if sm is None:
...         zope.component.getSiteManager.reset()
...     else:
...         zope.component.getSiteManager.sethook(getSiteManager)
...
>>> def makeRoot():
...     db = DB()
...     conn = db.open()
...     root = conn.root()
...     site_manager = root['components'] = (
...         zope.component.persistentregistry.PersistentComponents())
...     site_manager.__bases__ = (zope.component.getGlobalSiteManager(),)
...     site_manager.registerUtility(
...         zope.intid.IntIds(family=btrees_family),
...         provided=zope.intid.interfaces.IIntIds)
...     setSiteManager(site_manager)
...     transaction.commit()
...     return root
...

>>> @zope.component.adapter(zope.interface.Interface)
... @zope.interface.implementer(zope.interface.interfaces.IComponentLookup)
... def getComponentLookup(obj):
...     return obj._p_jar.root()['components']
...
>>> zope.component.provideAdapter(getComponentLookup)

为了展示范围目录的工作，我们需要一个 intid 实用程序、一个索引和一些要索引的项。我们将在真实的 ZODB 和真实的 intid 实用程序中完成这项工作。

>>> import zc.catalog
>>> import zc.catalog.interfaces
>>> from zc.catalog import interfaces, extentcatalog
>>> from zope import interface, component
>>> from zope.interface import verify
>>> import persistent
>>> import BTrees.IFBTree

>>> root = makeRoot()
>>> intid = zope.component.getUtility(
...     zope.intid.interfaces.IIntIds, context=root)
>>> TreeSet = btrees_family.IF.TreeSet

>>> from zope.container.interfaces import IContained
>>> @interface.implementer(IContained)
... class DummyIndex(persistent.Persistent):
...     __parent__ = __name__ = None
...     def __init__(self):
...         self.uids = TreeSet()
...     def unindex_doc(self, uid):
...         if uid in self.uids:
...             self.uids.remove(uid)
...     def index_doc(self, uid, obj):
...         self.uids.insert(uid)
...     def clear(self):
...         self.uids.clear()
...     def apply(self, query):
...         return [uid for uid in self.uids if uid <= query]
...
>>> class DummyContent(persistent.Persistent):
...     def __init__(self, name, parent):
...         self.id = name
...         self.__parent__ = parent
...

>>> extent = extentcatalog.Extent(family=btrees_family)
>>> verify.verifyObject(interfaces.IExtent, extent)
True
>>> root['catalog'] = catalog = extentcatalog.Catalog(extent)
>>> verify.verifyObject(interfaces.IExtentCatalog, catalog)
True
>>> index = DummyIndex()
>>> catalog['index'] = index
>>> transaction.commit()

现在我们已经设置了一个具有索引和范围的目录。我们可以向范围添加一些数据

>>> matches = []
>>> for i in range(100):
...     c = DummyContent(i, root)
...     root[i] = c
...     doc_id = intid.register(c)
...     catalog.index_doc(doc_id, c)
...     matches.append(doc_id)
>>> matches.sort()
>>> sorted(extent) == sorted(index.uids) == matches
True

我们可以获取范围的大小。

>>> len(extent)
100

从目录中取消索引对象应简单地将其从目录中删除，并按常规索引。

>>> matches[0] in catalog.extent
True
>>> matches[0] in catalog['index'].uids
True
>>> catalog.unindex_doc(matches[0])
>>> matches[0] in catalog.extent
False
>>> matches[0] in catalog['index'].uids
False
>>> doc_id = matches.pop(0)
>>> sorted(extent) == sorted(index.uids) == matches
True

清除目录会清除范围和包含的索引。

>>> catalog.clear()
>>> list(catalog.extent) == list(catalog['index'].uids) == []
True

更新所有索引和单个索引也会更新范围。

>>> catalog.updateIndexes()
>>> matches.insert(0, doc_id)
>>> sorted(extent) == sorted(index.uids) == matches
True

>>> index2 = DummyIndex()
>>> catalog['index2'] = index2
>>> index2.__parent__ == catalog
True
>>> index.uids.remove(matches[0]) # to confirm that only index 2 is touched
>>> catalog.updateIndex(index2)
>>> sorted(extent) == sorted(index2.uids) == matches
True
>>> matches[0] in index.uids
False
>>> matches[0] in index2.uids
True
>>> res = index.uids.insert(matches[0])

但为什么要一开始就有范围呢？它允许索引对整个索引数据的可靠集合进行操作；因此，它允许 zc.catalog 中的索引执行 NOT 操作。

范围本身提供了一些合并功能，以允许其值与其他 BTrees 数据结构合并。这包括交集、并集、差集和反向差集。给定一个名为“范围”的范围和一个名为“数据”的 IFBTree 数据结构，交集可以表示为“范围 & 数据”或“数据 & 范围”；并集可以表示为“范围 | 数据”或“数据 | 范围”；差集可以表示为“范围 - 数据”；反向差集可以表示为“数据 - 范围”。并集和交集是有权重的。

>>> extent = extentcatalog.Extent(family=btrees_family)
>>> for i in range(1, 100, 2):
...     extent.add(i, None)
...
>>> alt_set = TreeSet()
>>> _ = alt_set.update(range(0, 166, 33)) # return value is unimportant here
>>> sorted(alt_set)
[0, 33, 66, 99, 132, 165]
>>> sorted(extent & alt_set)
[33, 99]
>>> sorted(alt_set & extent)
[33, 99]
>>> sorted(extent.intersection(alt_set))
[33, 99]
>>> original = set(extent)
>>> union_matches = original.copy()
>>> union_matches.update(alt_set)
>>> union_matches = sorted(union_matches)
>>> sorted(alt_set | extent) == union_matches
True
>>> sorted(extent | alt_set) == union_matches
True
>>> sorted(extent.union(alt_set)) == union_matches
True
>>> sorted(alt_set - extent)
[0, 66, 132, 165]
>>> sorted(extent.rdifference(alt_set))
[0, 66, 132, 165]
>>> original.remove(33)
>>> original.remove(99)
>>> set(extent - alt_set) == original
True
>>> set(extent.difference(alt_set)) == original
True

我们可以向 extentcatalog.Catalog 传递自己的实例化 UID 工具。

>>> extent = extentcatalog.Extent(family=btrees_family)
>>> uidutil = zope.intid.IntIds()
>>> cat = extentcatalog.Catalog(extent, uidutil)
>>> cat["index"] = DummyIndex()
>>> cat.UIDSource is uidutil
True

>>> cat._getUIDSource() is uidutil
True

目录的 searchResults 方法返回的 ResultSet 实例使用我们的 UID 工具。

>>> obj = DummyContent(43, root)
>>> uid = uidutil.register(obj)
>>> cat.index_doc(uid, obj)
>>> res = cat.searchResults(index=uid)
>>> res.uidutil is uidutil
True

>>> list(res) == [obj]
True

searchResults 也可能返回 None。

>>> cat.searchResults() is None
True

当目录具有其 uid 源设置时，调用 updateIndex 和 updateIndexes 也同样有效。

>>> cat.clear()
>>> uid in cat.extent
False

uid 工具中的所有对象都已索引。

>>> cat.updateIndexes()
>>> uid in cat.extent
True

>>> len(cat.extent)
1

>>> obj2 = DummyContent(44, root)
>>> uid2 = uidutil.register(obj2)
>>> cat.updateIndexes()
>>> len(cat.extent)
2

>>> uid2 in cat.extent
True

>>> uidutil.unregister(obj2)

>>> cat.clear()
>>> uid in cat.extent
False
>>> cat.updateIndex(cat["index"])
>>> uid in cat.extent
True

使用自动填充的范围，调用 updateIndex 或 updateIndexes 只会更新范围中 id 的对象；如果存在，目录将使用其 uid 源通过 id 查找对象。

>>> extent = extentcatalog.NonPopulatingExtent(family=btrees_family)
>>> cat = extentcatalog.Catalog(extent, uidutil)
>>> cat["index"] = DummyIndex()

>>> extent.add(uid, obj)
>>> uid in cat["index"].uids
False

>>> cat.updateIndexes()
>>> uid in cat["index"].uids
True

>>> cat.clear()
>>> uid in cat["index"].uids
False

>>> uid in cat.extent
False

>>> cat.extent.add(uid, obj)
>>> cat.updateIndex(cat["index"])
>>> uid in cat["index"].uids
True

从 intid 工具注销先前测试的对象

>>> intid = zope.component.getUtility(
...     zope.intid.interfaces.IIntIds, context=root)
>>> for doc_id in matches:
...     intid.unregister(intid.queryObject(doc_id))

>>> class PopulatingExtent(
...     extentcatalog.FilterExtent,
...     extentcatalog.NonPopulatingExtent):
...
...     def populate(self):
...         if self.populated:
...             return
...         self.add(intid.getId(root[0]), root[0])
...         super(PopulatingExtent, self).populate()

>>> def accept_any(extent, uid, ob):
...     return True

>>> extent = PopulatingExtent(accept_any, family=btrees_family)
>>> catalog = extentcatalog.Catalog(extent)
>>> index = DummyIndex()
>>> catalog['index'] = index
>>> root['catalog2'] = catalog
>>> transaction.commit()

>>> extent.populated
False

>>> list(extent)
[]

>>> catalog.updateIndex(index)
>>> extent.populated
True

>>> list(extent) == [intid.getId(root[0])]
True

>>> list(index.uids) == [intid.getId(root[0])]
True

>>> catalog.updateIndex(index)

>>> list(extent) == [intid.getId(root[0])]
True
>>> list(index.uids) == [intid.getId(root[0])]
True

>>> index2 = DummyIndex()
>>> catalog['index2'] = index2

>>> catalog.updateIndexes()

>>> list(extent) == [intid.getId(root[0])]
True
>>> list(index.uids) == [intid.getId(root[0])]
True
>>> list(index2.uids) == [intid.getId(root[0])]
True

>>> extent = PopulatingExtent(accept_any, family=btrees_family)
>>> root['catalog3'] = catalog = extentcatalog.Catalog(extent)
>>> index1 = DummyIndex()
>>> index2 = DummyIndex()
>>> catalog['index1'] = index1
>>> catalog['index2'] = index2
>>> transaction.commit()

>>> extent.populated
False

>>> catalog.updateIndexes()

>>> extent.populated
True

>>> list(extent) == [intid.getId(root[0])]
True
>>> list(index1.uids) == [intid.getId(root[0])]
True
>>> list(index2.uids) == [intid.getId(root[0])]
True

词干提取器

分词器使用Andreas Jung的分词代码，这是一个M. F. Porter的Snowball项目的Python包装器（http://snowball.tartarus.org/index.php）。它被设计为在zope/index/text/词库中的流水线部分使用，在分词器之后。这可以使用TextIndexNG 3.x的分词功能获取zope/index/text代码的相关性排名。

它需要您已经编译并安装了Python安装中的TextIndexNG扩展程序，特别是txngstemmer。不需要包含textindexng包。

截至本文写作时（2007年1月3日），可以通过以下步骤安装必要的扩展程序

• svn co https://svn.sourceforge.net/svnroot/textindexng/extension_modules/trunk ext_mod

• cd ext_mod

• （使用您用于Zope的Python）python setup.py install

另一种方法是简单地安装TextIndexNG（见http://opensource.zopyx.com/software/textindexng3）

分词器必须实例化为期望进行分词的语言。默认为‘english’。截至本文写作时，支持以下语言，使用分词器期望的字符串包括以下内容：‘danish’，‘dutch’，‘english’，‘finnish’，‘french’，‘german’，‘italian’，‘norwegian’，‘portuguese’，‘russian’，‘spanish’，和‘swedish’。

例如，让我们使用english分词器构建一个索引。

>>> from zope.index.text import textindex, lexicon
>>> import zc.catalog.stemmer
>>> lex = lexicon.Lexicon(
...     lexicon.Splitter(), lexicon.CaseNormalizer(),
...     lexicon.StopWordRemover(), zc.catalog.stemmer.Stemmer('english'))
>>> ix = textindex.TextIndex(lex)
>>> data = [
...     (0, 'consigned consistency consoles the constables'),
...     (1, 'knaves kneeled and knocked knees, knowing no knights')]
>>> for doc_id, text in data:
...     ix.index_doc(doc_id, text)
...
>>> list(ix.apply('consoling a constable'))
[0]
>>> list(ix.apply('knightly kneel'))
[1]

请注意，具有通配符的查询术语不会被分词。

>>> list(ix.apply('constables*'))
[]

对旧数据的支持

在引入btree“家族”和BTrees.Interfaces.IBTreeFamily接口之前，由zc.catalog.index模块定义的索引使用实例属性btreemodule和IOBTree，在构造函数中初始化，并使用BTreeAPI属性。这些现在被当前实现中的family属性所取代。

这是一个白盒测试，用于验证现有数据结构（从pickle加载）可以有效地使用当前实现中的支持值。

有两个支持值集；一个用于32位btree

>>> import BTrees.IOBTree

>>> legacy32 = {
...     "btreemodule": "BTrees.IFBTree",
...     "IOBTree": BTrees.IOBTree.IOBTree,
...     }

另一个用于64位btree

>>> import BTrees.LOBTree

>>> legacy64 = {
...     "btreemodule": "BTrees.LFBTree",
...     "IOBTree": BTrees.LOBTree.LOBTree,
...     }

在每种情况下，实际的遗留结构还将包括与正确整数大小匹配的索引结构

>>> import BTrees.OOBTree
>>> import BTrees.Length

>>> legacy32["values_to_documents"] = BTrees.OOBTree.OOBTree()
>>> legacy32["documents_to_values"] = BTrees.IOBTree.IOBTree()
>>> legacy32["documentCount"] = BTrees.Length.Length(0)
>>> legacy32["wordCount"] = BTrees.Length.Length(0)

>>> legacy64["values_to_documents"] = BTrees.OOBTree.OOBTree()
>>> legacy64["documents_to_values"] = BTrees.LOBTree.LOBTree()
>>> legacy64["documentCount"] = BTrees.Length.Length(0)
>>> legacy64["wordCount"] = BTrees.Length.Length(0)

我们想要验证从遗留数据加载的实例的family属性被正确计算，并确保结构被干净地更新，不会导致只读事务变为写事务。我们需要创建符合旧数据结构的实例，将它们pickle，并证明反pickle它们会产生使用正确家族的实例。

让我们创建新实例，并强制内部数据与旧结构匹配

>>> import pickle
>>> import zc.catalog.index

>>> vi32 = zc.catalog.index.ValueIndex()
>>> vi32.__dict__ = legacy32.copy()
>>> legacy32_pickle = pickle.dumps(vi32)

>>> vi64 = zc.catalog.index.ValueIndex()
>>> vi64.__dict__ = legacy64.copy()
>>> legacy64_pickle = pickle.dumps(vi64)

现在，让我们反pickle这些结构并验证它们。我们首先从32位版本开始

>>> vi32 = pickle.loads(legacy32_pickle)

>>> vi32.__dict__["btreemodule"]
'BTrees.IFBTree'
>>> vi32.__dict__["IOBTree"]
<type 'BTrees.IOBTree.IOBTree'>

>>> "family" in vi32.__dict__
False

>>> vi32._p_changed
False

family属性返回BTrees.family32单例

>>> vi32.family is BTrees.family32
True

一旦访问，遗留值已经从实例字典中清除

>>> "btreemodule" in vi32.__dict__
False
>>> "IOBTree" in vi32.__dict__
False
>>> "BTreeAPI" in vi32.__dict__
False

将这些属性作为属性访问始终提供正确值

>>> vi32.btreemodule
'BTrees.IFBTree'
>>> vi32.IOBTree
<type 'BTrees.IOBTree.IOBTree'>
>>> vi32.BTreeAPI
<module 'BTrees.IFBTree' from ...>

尽管实例字典已经被清理，但更改标志尚未设置。这样处理是为了避免将只读事务转换为写事务

>>> vi32._p_changed
False

64位版本提供等效的行为

>>> vi64 = pickle.loads(legacy64_pickle)

>>> vi64.__dict__["btreemodule"]
'BTrees.LFBTree'
>>> vi64.__dict__["IOBTree"]
<type 'BTrees.LOBTree.LOBTree'>

>>> "family" in vi64.__dict__
False

>>> vi64._p_changed
False

>>> vi64.family is BTrees.family64
True

>>> "btreemodule" in vi64.__dict__
False
>>> "IOBTree" in vi64.__dict__
False
>>> "BTreeAPI" in vi64.__dict__
False

>>> vi64.btreemodule
'BTrees.LFBTree'
>>> vi64.IOBTree
<type 'BTrees.LOBTree.LOBTree'>
>>> vi64.BTreeAPI
<module 'BTrees.LFBTree' from ...>

>>> vi64._p_changed
False

现在，如果我们有一个遗留结构并显式设置family属性，旧的数据结构将被清除并替换为新结构。如果对象与数据管理器相关联，则更改标志也将被设置

>>> class DataManager(object):
...     def register(self, ob):
...         pass

>>> vi64 = pickle.loads(legacy64_pickle)
>>> vi64._p_jar = DataManager()
>>> vi64.family = BTrees.family64

>>> vi64._p_changed
True

>>> "btreemodule" in vi64.__dict__
False
>>> "IOBTree" in vi64.__dict__
False
>>> "BTreeAPI" in vi64.__dict__
False

>>> "family" in vi64.__dict__
True
>>> vi64.family is BTrees.family64
True

>>> vi64.btreemodule
'BTrees.LFBTree'
>>> vi64.IOBTree
<type 'BTrees.LOBTree.LOBTree'>
>>> vi64.BTreeAPI
<module 'BTrees.LFBTree' from ...>

globber

globber 接收一个查询，并将任何不是 glob 的术语转换为以星号结尾的形式。最初，它被认为是一个非常廉价的分词技巧。作者现在对其价值表示怀疑，并希望可以使用新的分词管道选项来代替。尽管如此，这里有一个它在工作中使用的例子。

>>> from zope.index.text import textindex
>>> index = textindex.TextIndex()
>>> lex = index.lexicon
>>> from zc.catalog import globber
>>> globber.glob('foo bar and baz or (b?ng not boo)', lex)
'(((foo* and bar*) and baz*) or (b?ng and not boo*))'

可调用包装器

如果我们想索引从文档中容易推导出的某个值，我们必须定义一个具有该值作为属性的接口，并创建一个计算此值并实现此接口的适配器。如果只想存储一个容易推导出的值，所有这些都很麻烦。CallableWrapper 通过将文档转换为可调用的转换器中的索引值来解决此问题。

以下是一个虚构的例子。假设我们有知道其燃油效率（以每加仑英里数表示）的汽车，但我们想索引它们的燃油效率（以每100公里升数表示）。

>>> class Car(object):
...     def __init__(self, mpg):
...         self.mpg = mpg

>>> def mpg2lp100(car):
...     return 100.0/(1.609344/3.7854118 * car.mpg)

让我们创建一个索引，该索引将索引汽车的每100公里升数评级。

>>> from zc.catalog import index, catalogindex
>>> idx = catalogindex.CallableWrapper(index.ValueIndex(), mpg2lp100)

让我们向索引中添加几辆汽车！

>>> hummer = Car(10.0)
>>> beamer = Car(22.0)
>>> civic = Car(45.0)

>>> idx.index_doc(1, hummer)
>>> idx.index_doc(2, beamer)
>>> idx.index_doc(3, civic)

索引的值应该是转换后的每100公里升数评级。

>>> list(idx.values()) # doctest: +ELLIPSIS
[5.22699076283393..., 10.691572014887601, 23.521458432752723]

我们可以查询消耗燃料在一定范围内的汽车

>>> list(idx.apply({'between': (5.0, 7.0)}))
[3]

zc.catalog浏览器支持

zc.catalog.browser 包为 SetIndex 和 ValueIndex 添加了简单的 TTW 添加/检查功能。

首先，我们需要一个浏览器，以便我们可以测试 Web UI。

>>> from zope.testbrowser.wsgi import Browser
>>> browser = Browser()
>>> browser.handleErrors = False
>>> browser.addHeader('Authorization', 'Basic mgr:mgrpw')
>>> browser.addHeader('Accept-Language', 'en-US')
>>> browser.open('https://127.0.0.1/')

现在我们需要添加一个目录，这些索引将驻留在其中。

>>> browser.open('https://127.0.0.1/++etc++site/default/@@+/')
>>> browser.getControl('Catalog').click()
>>> browser.getControl(name='id').value = 'catalog'
>>> browser.getControl('Add').click()