engine

Pythonic wrapper around PyLucene search engine.

Provides high-level interfaces to indexes and documents, abstracting away java lucene primitives.

indexers

Wrappers for lucene Index{Read,Search,Writ}ers.

The final Indexer classes exposes a high-level Searcher and Writer.

TokenStream

class lupyne.engine.indexers.TokenStream[source]

TokenStream mixin with support for iteration and attributes cached as properties.

offset[source]

Start and stop character offset.

payload[source]

Payload bytes.

positionIncrement[source]

Position relative to the previous token.

term[source]

Term text.

type[source]

Lexical type.

TokenFilter

class lupyne.engine.indexers.TokenFilter(input)[source]

Bases: PythonTokenFilter, lupyne.engine.indexers.TokenStream

Create an iterable lucene TokenFilter from a TokenStream. Subclass and override incrementToken() or setattrs().

incrementToken()[source]

Advance to next token and return whether the stream is not empty.

setattrs()[source]

Customize current token.

Analyzer

class lupyne.engine.indexers.Analyzer(tokenizer, *filters)[source]

Return a lucene Analyzer which chains together a tokenizer and filters.

Parameters:
  • tokenizer – lucene Analyzer or Tokenizer factory
  • filters – lucene TokenFilters
parse(query, field='', op='', version='', parser=None, **attrs)[source]

Return parsed lucene Query.

Parameters:
  • query – query string
  • field – default query field name, sequence of names, or boost mapping
  • op – default query operator (‘or’, ‘and’)
  • version – lucene Version string
  • parser – custom PythonQueryParser class
  • attrs – additional attributes to set on the parser
tokens(text, field=None)[source]

Return lucene TokenStream from text.

IndexReader

class lupyne.engine.indexers.IndexReader(reader)[source]

Delegated lucene IndexReader, with a mapping interface of ids to document objects.

Parameters:reader – lucene IndexReader
__len__()[source]
__contains__(id)[source]
__iter__()[source]
__getitem__(id)[source]
comparator(name, type='string', parser=None)[source]

Return cache of field values suitable for sorting. Parsing values into an array is memory optimized. Map values into a list for speed optimization.

Parameters:
  • name – field name
  • type – type object or name compatible with FieldCache
  • parser – lucene FieldCache.Parser or callable applied to field values
copy(dest, query=None, exclude=None, merge=0)[source]

Copy the index to the destination directory. Optimized to use hard links if the destination is a file system path.

Parameters:
  • dest – destination directory path or lucene Directory
  • query – optional lucene Query to select documents
  • exclude – optional lucene Query to exclude documents
  • merge – optionally merge into maximum number of segments
count(name, value)[source]

Return number of documents with given term.

directory[source]

reader’s lucene Directory

docs(name, value, counts=False)[source]

Generate doc ids which contain given term, optionally with frequency counts.

morelikethis(doc, *fields, **attrs)[source]

Return MoreLikeThis query for document.

Parameters:
  • doc – document id or text
  • fields – document fields to use, optional for termvectors
  • attrs – additional attributes to set on the morelikethis object
names(option='all', **attrs)[source]

Return field names, given option description.

Changed in version 1.2: lucene 3.6 requires FieldInfo filter attributes instead of option

numbers(name, step=0, type=<type 'int'>, counts=False)[source]

Generate decoded numeric term values, optionally with frequency counts.

Parameters:
  • name – field name
  • step – precision step to select terms
  • type – int or float
  • counts – include frequency counts
path[source]

FSDirectory path

positions(name, value, payloads=False)[source]

Generate doc ids and positions which contain given term, optionally only with payloads.

positionvector(id, field, offsets=False)[source]

Generate terms and positions for given doc id and field, optionally with character offsets.

readers[source]

segment readers

segments[source]

segment filenames with document counts

spans(query, positions=False, payloads=False)[source]

Generate docs with occurrence counts for a span query.

Parameters:
  • query – lucene SpanQuery
  • positions – optionally include slice positions instead of counts
  • payloads – optionally only include slice positions with payloads
terms(name, value='', stop=None, counts=False, **fuzzy)[source]

Generate a slice of term values, optionally with frequency counts. Supports a range of terms, wildcard terms, or fuzzy terms.

Parameters:
  • name – field name
  • value – initial term text or wildcard
  • stop – optional upper bound for simple terms
  • counts – include frequency counts
  • fuzzy – optional keyword arguments for fuzzy terms
termvector(id, field, counts=False)[source]

Generate terms for given doc id and field, optionally with frequency counts.

timestamp[source]

timestamp of reader’s last commit

IndexSearcher

class lupyne.engine.indexers.IndexSearcher(directory, analyzer=None)[source]

Bases: IndexSearcher, lupyne.engine.indexers.IndexReader

Inherited lucene IndexSearcher, with a mixed-in IndexReader.

Parameters:
  • directory – directory path, lucene Directory, or lucene IndexReader
  • analyzer – lucene Analyzer, default StandardAnalyzer
__getitem__(id)[source]

Return Document.

__del__()[source]

Closes index.

filters

Mapping of cached filters by field, also used for facet counts.

groupings

Mapping of cached groupings by field, optimized for facet counts of unique fields.

sorters

Mapping of cached sorters by field and associated parsers.

spellcheckers

Mapping of cached spellcheckers by field.

termsfilters

Set of registered termsfilters.

comparator(field, type='string', parser=None)[source]

Return IndexReader.comparator() using a cached SortField if available.

correct(field, text, distance=2, minSimilarity=0.5)[source]

Generate potential words ordered by increasing edit distance and decreasing frequency. For optimal performance only iterate the required slice size of corrections.

Parameters:
  • distance – the maximum edit distance to consider for enumeration
  • minSimilarity – threshold for additional fuzzy terms after edits have been exhausted
count(*query, **options)[source]

Return number of hits for given query or term.

Parameters:
  • querysearch() compatible query, or optimally a name and value
  • options – additional search() options
distances(lng, lat, lngfield, latfield)[source]

Return distance comparator computed from cached lat/lng fields.

facets(query, *keys)[source]

Return mapping of document counts for the intersection with each facet.

Parameters:
  • query – query string, lucene Query, or lucene Filter
  • keys – field names, term tuples, or any keys to previously cached filters
get(id, *fields)[source]

Return Document with only selected fields loaded.

grouping(field, query=None, count=None, sort=None)[source]

Return Grouping for unique field and lucene search parameters.

highlighter(query, field, **kwargs)[source]

Return Highlighter or if applicable FastVectorHighlighter specific to searcher and query.

classmethod load(directory, analyzer=None)[source]

Open IndexSearcher with a lucene RAMDirectory, loading index into memory.

match(document, *queries)[source]

Generate scores for all queries against a given document mapping.

reopen(filters=False, sorters=False, spellcheckers=False)[source]

Return current IndexSearcher, only creating a new one if necessary. Any registered termsfilters are also refreshed.

Parameters:
  • filters – refresh cached facet filters
  • sorters – refresh cached sorters with associated parsers
  • spellcheckers – refresh cached spellcheckers
search(query=None, filter=None, count=None, sort=None, reverse=False, scores=False, maxscore=False, timeout=None, **parser)[source]

Run query and return Hits.

Changed in version 1.4: sort param for lucene only; use Hits.sorted with a callable

Parameters:
  • query – query string or lucene Query
  • filter – lucene Filter
  • count – maximum number of hits to retrieve
  • sort – lucene Sort parameters
  • reverse – reverse flag used with sort
  • scores – compute scores for candidate results when sorting
  • maxscore – compute maximum score of all results when sorting
  • timeout – stop search after elapsed number of seconds
  • parserAnalyzer.parse() options
sorter(field, type='string', parser=None, reverse=False)[source]

Return SortField with cached attributes if available.

spellchecker(field)[source]

Return and cache spellchecker for given field.

suggest(field, prefix, count=None)[source]

Return ordered suggested words for prefix.

MultiSearcher

class lupyne.engine.indexers.MultiSearcher(reader, analyzer=None)[source]

Bases: lupyne.engine.indexers.IndexSearcher

IndexSearcher with underlying lucene MultiReader.

Parameters:
  • reader – directory paths, Directories, IndexReaders, or a single MultiReader
  • analyzer – lucene Analyzer, default StandardAnalyzer

IndexWriter

class lupyne.engine.indexers.IndexWriter(directory=None, mode='a', analyzer=None, version=None, **attrs)[source]

Bases: IndexWriter

Inherited lucene IndexWriter. Supports setting fields parameters explicitly, so documents can be represented as dictionaries.

Parameters:
  • directory – directory path or lucene Directory, default RAMDirectory
  • mode – file mode (rwa), except updating (+) is implied
  • analyzer – lucene Analyzer, default StandardAnalyzer
  • version – lucene Version argument passed to IndexWriterConfig or StandardAnalyzer, default is latest
  • attrs – additional attributes to set on IndexWriterConfig
fields

Mapping of assigned fields. May be used directly, instead of set() method, for further customization.

__del__()[source]

Closes index.

__len__()
__iadd__(directory)[source]

Add directory (or reader, searcher, writer) to index.

add(document=(), **terms)[source]

Add document() to index with optional boost.

delete(*query, **options)[source]

Remove documents which match given query or term.

Parameters:
document(items=(), **terms)[source]

Return lucene Document from mapping of field names to one or multiple values.

set(name, cls=<class 'lupyne.engine.documents.Field'>, **params)[source]

Assign parameters to field name.

Parameters:
  • name – registered name of field
  • cls – optional Field constructor
  • params – store,index,termvector options compatible with Field
snapshot(*args, **kwds)[source]

Return context manager of an index commit snapshot.

Changed in version 1.4: lucene 4.4 identifies snapshots by commit generation

update(name, value='', document=(), **terms)[source]

Atomically delete documents which match given term and add the new document() with optional boost.

Indexer

class lupyne.engine.indexers.Indexer(directory=None, mode='a', analyzer=None, version=None, nrt=False, **attrs)[source]

Bases: lupyne.engine.indexers.IndexWriter

An all-purpose interface to an index. Creates an IndexWriter with a delegated IndexSearcher.

Parameters:nrt – optionally use a near real-time searcher
commit(merge=False, **caches)[source]

Commit writes and refresh() searcher.

Parameters:merge – merge segments with deletes, or optionally specify maximum number of segments
refresh(**caches)[source]

Store refreshed searcher with IndexSearcher.reopen() caches.

ParallelIndexer

New in version 1.2.

class lupyne.engine.indexers.ParallelIndexer(field, *args, **kwargs)[source]

Bases: lupyne.engine.indexers.Indexer

Indexer which tracks a unique identifying field. Handles atomic updates of rapidly changing fields, managing termsfilters.

termsfilters

Mapping of filters to synchronized termsfilters.

refresh(**caches)[source]

Store refreshed searcher and synchronize termsfilters.

termsfilter(filter, *others)[source]

Return TermsFilter synced to given filter and optionally associated with other indexers.

update(value, document=(), **terms)[source]

Atomically update document based on unique field.

documents

Wrappers for lucene Fields and Documents.

Document

class lupyne.engine.documents.Document(doc)[source]

Bases: dict

Multimapping of field names to values, but default getters return the first value.

dict(*names, **defaults)[source]

Return dict representation of document.

Parameters:
  • names – names of multi-valued fields to return as a list
  • defaults – include only given fields, using default values as necessary
getlist(name)[source]

Return list of all values for given field.

Hit

class lupyne.engine.documents.Hit(doc, id, score, keys=())[source]

Bases: lupyne.engine.documents.Document

A Document from a search result, with id, score, and optional sort keys.

dict(*names, **defaults)[source]

Return dict representation of document with __id__, __score__, and any sort __keys__.

Hits

class lupyne.engine.documents.Hits(searcher, scoredocs, count=None, maxscore=None, fields=None)[source]

Search results: lazily evaluated and memory efficient. Provides a read-only sequence interface to hit objects.

Parameters:
  • searcherIndexSearcher which can retrieve documents
  • scoredocs – lucene ScoreDocs
  • count – total number of hits
  • maxscore – maximum score
  • fields – optional field selectors
__len__()[source]
__getitem__(index)[source]
filter(func)[source]

Return Hits filtered by function applied to doc ids.

groupby(func)[source]

Return ordered list of Hits grouped by value of function applied to doc ids.

items()[source]

Generate zipped ids and scores.

select(*fields)[source]

Only load selected fields.

sorted(key, reverse=False)[source]

Return Hits sorted by key function applied to doc ids.

Grouping

New in version 1.3.

class lupyne.engine.documents.Grouping(searcher, field, query=None, count=None, sort=None)[source]

Delegated lucene SearchGroups with optimized faceting.

Parameters:
  • searcherIndexSearcher which can retrieve documents
  • field – unique field name to group by
  • query – lucene Query to select groups
  • count – maximum number of groups
  • sort – lucene Sort to order groups
__len__()[source]
__iter__()[source]
facets(filter)[source]

Generate field values and counts which match given filter.

groups(count=1, sort=None, scores=False, maxscore=False)[source]

Generate grouped Hits from second pass grouping collector.

Parameters:
  • count – maximum number of docs per group
  • sort – lucene Sort to order docs within group
  • scores – compute scores for candidate results
  • maxscore – compute maximum score of all results

Field

class lupyne.engine.documents.Field(name, store=False, index='analyzed', termvector=False, analyzed=False, omitNorms=False, withPositions=False, withOffsets=False, boost=1.0, **attrs)[source]

Saved parameters which can generate lucene Fields given values.

Parameters:
  • name – name of field
  • store,index,termvector – field parameters, expressed as bools or strs, with lucene defaults
  • analyzed,omitNorms – additional index boolean settings
  • withPositions,withOffsets – additional termvector boolean settings
  • boost – boost factor
  • attrs – additional attributes to set on the field
items(*values)[source]

Generate lucene Fields suitable for adding to a document.

MapField

class lupyne.engine.documents.MapField(name, func, **kwargs)[source]

Bases: lupyne.engine.documents.Field

Field which applies a function across its values.

Parameters:func – callable
items(*values)[source]

Generate fields with mapped values.

NestedField

class lupyne.engine.documents.NestedField(name, sep='.', index=True, **kwargs)[source]

Bases: lupyne.engine.documents.Field

Field which indexes every component into its own field. Original value may be stored for convenience.

Parameters:sep – field separator used on name and values
items(*values)[source]

Generate indexed component fields.

prefix(value)[source]

Return prefix query of the closest possible prefixed field.

range(start, stop, lower=True, upper=False)[source]

Return range query of the closest possible prefixed field.

values(value)[source]

Generate component field values in order.

NumericField

class lupyne.engine.documents.NumericField(name, step=None, store=False, index=True)[source]

Bases: lupyne.engine.documents.Field

Field which indexes numbers in a prefix tree.

Parameters:
  • name – name of field
  • step – precision step
filter(start, stop, lower=True, upper=False)[source]

Return lucene NumericRangeFilter.

items(*values)[source]

Generate lucene NumericFields suitable for adding to a document.

range(start, stop, lower=True, upper=False)[source]

Return lucene NumericRangeQuery.

term(value)[source]

Return range query to match single term.

DateTimeField

class lupyne.engine.documents.DateTimeField(name, step=None, store=False, index=True)[source]

Bases: lupyne.engine.documents.NumericField

Field which indexes datetimes as a NumericField of timestamps. Supports datetimes, dates, and any prefix of time tuples.

duration(date, days=0, **delta)[source]

Return date range query within time span of date.

Parameters:
  • date – origin date or tuple
  • days,delta – timedelta parameters
items(*dates)[source]

Generate lucene NumericFields of timestamps.

prefix(date)[source]

Return range query which matches the date prefix.

range(start, stop, lower=True, upper=False)[source]

Return NumericRangeQuery of timestamps.

timestamp(date)[source]

Return utc timestamp from date or time tuple.

within(days=0, weeks=0, utc=True, **delta)[source]

Return date range query within current time and delta. If the delta is an exact number of days, then dates will be used.

Parameters:
  • days,weeks – number of days to offset from today
  • utc – optionally use utc instead of local time
  • delta – additional timedelta parameters

queries

Query wrappers and search utilities.

Query

class lupyne.engine.queries.Query(base, *args)[source]

Inherited lucene Query, with dynamic base class acquisition. Uses class methods and operator overloading for convenient query construction.

__and__(other)[source]

BooleanQuery +self +other>

__or__(other)[source]

BooleanQuery self other>

__sub__(other)[source]

BooleanQuery self -other>

classmethod all(*queries, **terms)[source]

Return BooleanQuery (AND) from queries and terms.

classmethod any(*queries, **terms)[source]

Return BooleanQuery (OR) from queries and terms.

classmethod disjunct(multiplier, *queries, **terms)[source]

Return lucene DisjunctionMaxQuery from queries and terms.

filter(cache=True)[source]

Return lucene CachingWrapperFilter, optionally just QueryWrapperFilter.

classmethod fuzzy(name, value, minimumSimilarity=None, prefixLength=0)[source]

Return lucene FuzzyQuery.

classmethod multiphrase(name, *values)[source]

Return lucene MultiPhraseQuery. None may be used as a placeholder.

classmethod near(name, *values, **kwargs)[source]

Return SpanNearQuery from terms. Term values which supply another field name will be masked.

classmethod phrase(name, *values)[source]

Return lucene PhraseQuery. None may be used as a placeholder.

classmethod prefix(name, value)[source]

Return lucene PrefixQuery.

classmethod range(name, start, stop, lower=True, upper=False)[source]

Return lucene RangeQuery, by default with a half-open interval.

classmethod span(*term)[source]

Return SpanQuery from term name and value or a MultiTermQuery.

classmethod term(name, value, boost=1.0)[source]

Return lucene TermQuery.

terms()[source]

Generate set of query term items.

classmethod wildcard(name, value)[source]

Return lucene WildcardQuery.

BooleanQuery

class lupyne.engine.queries.BooleanQuery(base, *args)[source]

Bases: lupyne.engine.queries.Query

Inherited lucene BooleanQuery with sequence interface to clauses.

__len__()[source]
__iter__()[source]
__getitem__(index)[source]
__iand__(other)[source]

add +other

__ior__(other)[source]

add other

__isub__(other)[source]

add -other

SpanQuery

class lupyne.engine.queries.SpanQuery(base, *args)[source]

Bases: lupyne.engine.queries.Query

Inherited lucene SpanQuery with additional span constructors.

__getitem__(slc)[source]

<SpanFirstQuery: spanFirst(self, other.stop)>

__sub__(other)[source]

<SpanNotQuery: spanNot(self, other)>

__or__(*spans_)[source]

<SpanOrQuery: spanOr(spans)>

filter(cache=True)[source]

Return lucene CachingSpanFilter, optionally just SpanQueryFilter.

mask(name)[source]

Return lucene FieldMaskingSpanQuery, which allows combining span queries from different fields.

near(*spans_, **kwargs)[source]

Return lucene SpanNearQuery from SpanQueries.

Parameters:
  • slop – default 0
  • inOrder – default True
  • collectPayloads – default True
payload(*values)[source]

Return lucene SpanPayloadCheckQuery from payload values.

TermsFilter

New in version 1.2.

class lupyne.engine.queries.TermsFilter(field, values=())[source]

Bases: CachingWrapperFilter

Caching filter based on a unique field and set of matching values. Optimized for many terms and docs, with support for incremental updates. Suitable for searching external metadata associated with indexed identifiers. Call refresh() to cache a new (or reopened) searcher.

Parameters:
  • field – field name
  • values – initial term values, synchronized with the cached filters
add(*values)[source]

Add a few term values.

discard(*values)[source]

Discard a few term values.

filter(values, cache=True)[source]

Return lucene TermsFilter, optionally using the FieldCache.

refresh(searcher)[source]

Refresh cached bitsets of current values for new segments of searcher.

update(values, op='or', cache=True)[source]

Update allowed values and corresponding cached bitsets.

Parameters:
  • values – additional term values
  • op – set operation used to combine terms and docs: and, or, andNot
  • cache – optionally cache all term values using FieldCache

SortField

class lupyne.engine.queries.SortField(name, type='string', parser=None, reverse=False)[source]

Bases: SortField

Inherited lucene SortField used for caching FieldCache parsers.

Parameters:
  • name – field name
  • type – type object or name compatible with SortField constants
  • parser – lucene FieldCache.Parser or callable applied to field values
  • reverse – reverse flag used with sort
comparator(searcher)[source]

Return indexed values from default FieldCache using the given searcher.

filter(start, stop, lower=True, upper=False)[source]

Return lucene FieldCacheRangeFilter based on field and type.

terms(filter, *readers)[source]

Generate field cache terms from docs which match filter from all segments.

Highlighter

class lupyne.engine.queries.Highlighter(searcher, query, field, terms=False, fields=False, tag='', formatter=None, encoder=None)[source]

Bases: Highlighter

Inherited lucene Highlighter with stored analysis options.

Parameters:
  • searcherIndexSearcher used for analysis, scoring, and optionally text retrieval
  • query – lucene Query
  • field – field name of text
  • terms – highlight any matching term in query regardless of position
  • fields – highlight matching terms from any field
  • tag – optional html tag name
  • formatter – optional lucene Formatter
  • encoder – optional lucene Encoder
fragments(doc, count=1)[source]

Return highlighted text fragments.

Parameters:
  • doc – text string or doc id to be highlighted
  • count – maximum number of fragments

FastVectorHighlighter

class lupyne.engine.queries.FastVectorHighlighter(searcher, query, field, terms=False, fields=False, tag='', fragListBuilder=None, fragmentsBuilder=None)[source]

Bases: FastVectorHighlighter

Inherited lucene FastVectorHighlighter with stored query. Fields must be stored and have term vectors with offsets and positions.

Parameters:
  • searcherIndexSearcher with stored term vectors
  • query – lucene Query
  • field – field name of text
  • terms – highlight any matching term in query regardless of position
  • fields – highlight matching terms from any field
  • tag – optional html tag name
  • fragListBuilder – optional lucene FragListBuilder
  • fragmentsBuilder – optional lucene FragmentsBuilder
fragments(id, count=1, size=100)[source]

Return highlighted text fragments.

Parameters:
  • id – document id
  • count – maximum number of fragments
  • size – maximum number of characters in fragment

SpellChecker

class lupyne.engine.queries.SpellChecker(*args, **kwargs)[source]

Bases: dict

Correct spellings and suggest words for queries. Supply a vocabulary mapping words to (reverse) sort keys, such as document frequencies.

correct(word)[source]

Generate ordered sets of words by increasing edit distance.

edits(word, length=0)[source]

Return set of potential words one edit distance away, mapped to valid prefix lengths.

suggest(prefix, count=None)[source]

Return ordered suggested words for prefix.

SpellParser

class lupyne.engine.queries.SpellParser[source]

Inherited lucene QueryParser which corrects spelling. Assign a searcher attribute or override correct() implementation.

searcher

IndexSearcher

correct(term)[source]

Return term with text replaced as necessary.

rewrite(query)[source]

Return term or phrase query with corrected terms substituted.

spatial

Geospatial fields.

Latitude/longitude coordinates are encoded into the quadkeys of MS Virtual Earth, which are also compatible with Google Maps and OSGEO Tile Map Service. See http://www.maptiler.org/google-maps-coordinates-tile-bounds-projection/.

The quadkeys are then indexed using a prefix tree, creating a cartesian tier of tiles.

Tiler

class lupyne.engine.spatial.Tiler(tileSize=256)[source]

Utilities for transforming lat/lngs, projected coordinates, and tile coordinates.

coords(tile)[source]

Return TMS coordinates of tile.

decode(tile)[source]

Return lat/lng bounding box (bottom, left, top, right) of tile.

encode(lat, lng, precision)[source]

Return tile from latitude, longitude and precision level.

project(lat, lon)

Converts given lat/lon in WGS84 Datum to XY in Spherical Mercator EPSG:900913

radiate(lat, lng, distance, precision, limit=inf)[source]

Generate tile keys within distance of given point, adjusting precision to limit the number considered.

walk(left, bottom, right, top, precision)[source]

Generate tile keys which span bounding box of meters.

PointField

class lupyne.engine.spatial.PointField(name, precision=30, **kwargs)[source]

Bases: lupyne.engine.documents.NumericField, lupyne.engine.spatial.Tiler

Geospatial points, which create a tiered index of tiles. Points must still be stored if exact distances are required upon retrieval.

Parameters:precision – zoom level, i.e., length of encoded value
items(*points)[source]

Generate tiles from points (lng, lat).

near(lng, lat, precision=None)[source]

Return prefix query for point at given precision.

prefix(tile)[source]

Return range query which is equivalent to the prefix of the tile.

ranges(tiles)[source]

Generate range queries by grouping adjacent tiles.

within(lng, lat, distance, limit=4)[source]

Return range queries for any tiles which could be within distance of given point.

Parameters:
  • lng,lat – point
  • distance – search radius in meters
  • limit – maximum number of tiles to consider

PolygonField

class lupyne.engine.spatial.PolygonField(name, precision=30, **kwargs)[source]

Bases: lupyne.engine.spatial.PointField

PointField which implicitly supports polygons (technically linear rings of points). Differs from points in that all necessary tiles are included to match the points’ boundary. As with PointField, the tiered tiles are a search optimization, not a distance calculator.

items(*polygons)[source]

Generate all covered tiles from polygons.

DistanceComparator

class lupyne.engine.spatial.DistanceComparator(lng, lat, lngs, lats)[source]

Bases: lupyne.engine.spatial.Tiler

Distance comparator computed from cached lat/lngs.

__getitem__(id)[source]