Require python >=3.11.

Author: coady

CHANGELOG.md

@@ -4,6 +4,8 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## Unreleased
+### Changed
+* Python >=3.11 required
 
 ## [3.3.1](https://pypi.org/project/lupyne/3.3.1/) - 2025-11-02
 ### Changed

lupyne/engine/analyzers.py

@@ -1,4 +1,5 @@
 from collections.abc import Callable, Iterable, Mapping
+from typing import Self
 
 from java.io import StringReader
 from java.lang import Float
@@ -102,12 +103,12 @@ def __init__(self, tokenizer: Callable, *filters: Callable):
         self.tokenizer, self.filters = tokenizer, filters
 
     @classmethod
-    def standard(cls, *filters: Callable) -> 'Analyzer':
+    def standard(cls, *filters: Callable) -> Self:
         """Return equivalent of StandardAnalyzer with additional filters."""
         return cls(analysis.standard.StandardTokenizer, analysis.LowerCaseFilter, *filters)
 
     @classmethod
-    def whitespace(cls, *filters: Callable) -> 'Analyzer':
+    def whitespace(cls, *filters: Callable) -> Self:
         """Return equivalent of WhitespaceAnalyzer with additional filters."""
         return cls(analysis.core.WhitespaceTokenizer, *filters)
 

lupyne/engine/documents.py

@@ -3,6 +3,7 @@
 import datetime
 import operator
 from collections.abc import Callable, Iterator, Sequence
+from typing import Self
 
 import lucene
 from java.lang import Long
@@ -74,13 +75,13 @@ def __init__(self, name: str, docValuesType='', indexOptions='', dimensions=0, *
     @classmethod
     def String(
         cls, name: str, tokenized=False, omitNorms=True, indexOptions='DOCS', **settings
-    ) -> 'Field':
+    ) -> Self:
         """Return Field with default settings for strings."""
         settings.update(tokenized=tokenized, omitNorms=omitNorms, indexOptions=indexOptions)
         return cls(name, **settings)
 
     @classmethod
-    def Text(cls, name: str, indexOptions='DOCS_AND_FREQS_AND_POSITIONS', **settings) -> 'Field':
+    def Text(cls, name: str, indexOptions='DOCS_AND_FREQS_AND_POSITIONS', **settings) -> Self:
         """Return Field with default settings for text."""
         return cls(name, indexOptions=indexOptions, **settings)
 
@@ -425,12 +426,12 @@ def groupby(
             group.scoredocs = group.scoredocs[:docs]
         return Groups(self.searcher, groups[:count], len(groups), self.fields)
 
-    def filter(self, func: Callable) -> 'Hits':
+    def filter(self, func: Callable) -> Self:
         """Return [Hits][lupyne.engine.documents.Hits] filtered by function applied to doc ids."""
         scoredocs = [scoredoc for scoredoc in self.scoredocs if func(scoredoc.doc)]
         return type(self)(self.searcher, scoredocs, fields=self.fields)
 
-    def sorted(self, key: Callable, reverse=False) -> 'Hits':
+    def sorted(self, key: Callable, reverse=False) -> Self:
         """Return [Hits][lupyne.engine.documents.Hits] sorted by key function applied to doc ids."""
         scoredocs = sorted(self.scoredocs, key=lambda scoredoc: key(scoredoc.doc), reverse=reverse)
         return type(self)(self.searcher, scoredocs, self.count, self.fields)

lupyne/engine/indexers.py

@@ -5,6 +5,7 @@
 from collections.abc import Iterator, Mapping
 from functools import partial
 from pathlib import Path
+from typing import Self
 
 import lucene
 from java.io import File, IOException, StringReader
@@ -330,7 +331,7 @@ def __del__(self):
     def openIfChanged(self):
         return index.DirectoryReader.openIfChanged(index.DirectoryReader.cast_(self.indexReader))
 
-    def reopen(self) -> 'IndexSearcher':
+    def reopen(self) -> Self:
         """Return current [IndexSearcher][lupyne.engine.indexers.IndexSearcher].
 
         Only creates a new one if necessary.

lupyne/engine/queries.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Callable, Iterable
+from typing import Self
 
 from java.lang import Double, Integer, Long
 from java.util import Arrays
@@ -20,12 +23,12 @@ def __init__(self, base: search.Query, *args):
         base.__init__(self, *args)
 
     @classmethod
-    def term(cls, name: str, value) -> 'Query':
+    def term(cls, name: str, value) -> Self:
         """Return lucene TermQuery."""
         return cls(search.TermQuery, index.Term(name, value))
 
     @classmethod
-    def terms(cls, name: str, values) -> 'Query':
+    def terms(cls, name: str, values) -> Self:
         """Return lucene TermInSetQuery, optimizing a SHOULD BooleanQuery of many terms."""
         return cls(search.TermInSetQuery, name, Arrays.asList(list(map(util.BytesRef, values))))
 
@@ -65,14 +68,14 @@ def disjunct(cls, multiplier, *queries, **terms):
         return cls(search.DisjunctionMaxQuery, Arrays.asList(queries), multiplier)
 
     @classmethod
-    def span(cls, *term) -> 'SpanQuery':
+    def span(cls, *term) -> SpanQuery:
         """Return [SpanQuery][lupyne.engine.queries.SpanQuery] from term name and value or a MultiTermQuery."""
         if len(term) <= 1:
             return SpanQuery(spans.SpanMultiTermQueryWrapper, *term)
         return SpanQuery(spans.SpanTermQuery, index.Term(*term))
 
     @classmethod
-    def near(cls, name: str, *values, **kwargs) -> 'SpanQuery':
+    def near(cls, name: str, *values, **kwargs) -> SpanQuery:
         """Return [SpanNearQuery][lupyne.engine.queries.SpanQuery.near] from terms.
         Term values which supply another field name will be masked."""
         spans = (
@@ -82,12 +85,12 @@ def near(cls, name: str, *values, **kwargs) -> 'SpanQuery':
         return SpanQuery.near(*spans, **kwargs)
 
     @classmethod
-    def prefix(cls, name: str, value) -> 'Query':
+    def prefix(cls, name: str, value) -> Self:
         """Return lucene PrefixQuery."""
         return cls(search.PrefixQuery, index.Term(name, value))
 
     @classmethod
-    def range(cls, name: str, start, stop, lower=True, upper=False) -> 'Query':
+    def range(cls, name: str, start, stop, lower=True, upper=False) -> Self:
         """Return lucene RangeQuery, by default with a half-open interval."""
         start, stop = (value if value is None else util.BytesRef(value) for value in (start, stop))
         return cls(search.TermRangeQuery, name, start, stop, lower, upper)
@@ -106,27 +109,27 @@ def phrase(cls, name: str, *values, **attrs) -> search.MultiPhraseQuery:
         return builder.build()
 
     @classmethod
-    def wildcard(cls, name: str, value) -> 'Query':
+    def wildcard(cls, name: str, value) -> Self:
         """Return lucene WildcardQuery."""
         return cls(search.WildcardQuery, index.Term(name, value))
 
     @classmethod
-    def fuzzy(cls, name: str, value, *args) -> 'Query':
+    def fuzzy(cls, name: str, value, *args) -> Self:
         """Return lucene FuzzyQuery."""
         return cls(search.FuzzyQuery, index.Term(name, value), *args)
 
     @classmethod
-    def alldocs(cls) -> 'Query':
+    def alldocs(cls) -> Self:
         """Return lucene MatchAllDocsQuery."""
         return cls(search.MatchAllDocsQuery)
 
     @classmethod
-    def nodocs(cls) -> 'Query':
+    def nodocs(cls) -> Self:
         """Return lucene MatchNoDocsQuery."""
         return cls(search.MatchNoDocsQuery)
 
     @classmethod
-    def regexp(cls, name: str, value, *args) -> 'Query':
+    def regexp(cls, name: str, value, *args) -> Self:
         """Return lucene RegexpQuery."""
         return cls(search.RegexpQuery, index.Term(name, value), *args)
 
@@ -166,11 +169,11 @@ def ranges(name: str, *intervals, lower=True, upper=False) -> search.Query:
             return document.DoublePoint.newRangeQuery(name, starts, stops)
         return document.LongPoint.newRangeQuery(name, starts, stops)
 
-    def constant(self) -> 'Query':
+    def constant(self) -> Query:
         """Return lucene ConstantScoreQuery."""
         return Query(search.ConstantScoreQuery, self)
 
-    def boost(self, value: float) -> 'Query':
+    def boost(self, value: float) -> Query:
         """Return lucene BoostQuery."""
         return Query(search.BoostQuery, self, value)
 
@@ -210,30 +213,30 @@ def __rsub__(self, other):
 class SpanQuery(Query):
     """Inherited lucene SpanQuery with additional span constructors."""
 
-    def __getitem__(self, slc: slice) -> 'SpanQuery':
+    def __getitem__(self, slc: slice) -> SpanQuery:
         start, stop, step = slc.indices(Integer.MAX_VALUE)
         assert step == 1, 'slice step is not supported'
         return SpanQuery(spans.SpanPositionRangeQuery, self, start, stop)
 
-    def __sub__(self, other: spans.SpanQuery) -> 'SpanQuery':
+    def __sub__(self, other: spans.SpanQuery) -> SpanQuery:
         return SpanQuery(spans.SpanNotQuery, self, other)
 
-    def __or__(*spans_: spans.SpanQuery) -> 'SpanQuery':
+    def __or__(*spans_: spans.SpanQuery) -> SpanQuery:
         return SpanQuery(spans.SpanOrQuery, spans_)
 
     def near(*spans_, slop=0, inOrder=True):  # type: ignore
         """Return lucene SpanNearQuery from SpanQueries."""
         return SpanQuery(spans.SpanNearQuery, spans_, slop, inOrder)
 
-    def mask(self, name: str) -> 'SpanQuery':
+    def mask(self, name: str) -> SpanQuery:
         """Return lucene FieldMaskingSpanQuery, which allows combining span queries from different fields."""
         return SpanQuery(spans.FieldMaskingSpanQuery, self, name)
 
-    def containing(self, other: spans.SpanQuery) -> 'SpanQuery':
+    def containing(self, other: spans.SpanQuery) -> SpanQuery:
         """Return lucene SpanContainingQuery."""
         return SpanQuery(spans.SpanContainingQuery, self, other)
 
-    def within(self, other: spans.SpanQuery) -> 'SpanQuery':
+    def within(self, other: spans.SpanQuery) -> SpanQuery:
         """Return lucene SpanWithinQuery."""
         return SpanQuery(spans.SpanWithinQuery, self, other)
 

pyproject.toml

@@ -3,7 +3,7 @@ name = "lupyne"
 version = "3.3.1"
 description = "Pythonic search engine based on PyLucene."
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "Apache-2.0"
 authors = [{name = "Aric Coady", email = "aric.coady@gmail.com"}]
 keywords = ["lucene", "pylucene"]
@@ -12,11 +12,11 @@ classifiers = [
     "Intended Audience :: Developers",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
     "Topic :: Internet :: WWW/HTTP :: Indexing/Search",
     "Topic :: Software Development :: Libraries :: Python Modules",