Lint quote style.

Author: coady

docs/examples.ipynb

@@ -12,5 +12,5 @@
 from .indexers import Indexer, IndexSearcher, IndexWriter, MultiSearcher
 from .queries import Query
 
-version = tuple(map(int, lucene.VERSION.split('.')))
+version = tuple(map(int, lucene.VERSION.split(".")))
 assert version >= (10,), version

lupyne/engine/__init__.py

@@ -21,7 +21,7 @@ def __next__(self):
         raise StopIteration
 
     def __getattr__(self, name):
-        cls = getattr(analysis.tokenattributes, name + 'Attribute').class_
+        cls = getattr(analysis.tokenattributes, name + "Attribute").class_
         attr = self.getAttribute(cls) if self.hasAttribute(cls) else self.addAttribute(cls)
         setattr(self, name, attr)
         return attr
@@ -127,7 +127,7 @@ def tokens(self, text: str, field: str | None = None) -> analysis.TokenStream:
         """Return lucene TokenStream from text."""
         return self.components(field, StringReader(text))[1]
 
-    def parse(self, query: str, field='', op='', parser=None, **attrs) -> search.Query:
+    def parse(self, query: str, field="", op="", parser=None, **attrs) -> search.Query:
         """Return parsed lucene Query.
 
         Args:

lupyne/engine/analyzers.py

@@ -41,17 +41,17 @@ class Field(FieldType):
     storeTermVectors = property(FieldType.storeTermVectors, FieldType.setStoreTermVectors)
     tokenized = property(FieldType.tokenized, FieldType.setTokenized)
 
-    properties = {name for name in locals() if not name.startswith('__')}
-    types = {int: 'long', float: 'double', str: 'string'}
+    properties = {name for name in locals() if not name.startswith("__")}
+    types = {int: "long", float: "double", str: "string"}
     types.update(
-        NUMERIC='long', BINARY='string', SORTED='string', SORTED_NUMERIC='long', SORTED_SET='string'
+        NUMERIC="long", BINARY="string", SORTED="string", SORTED_NUMERIC="long", SORTED_SET="string"
     )
     dimensions = property(
         FieldType.pointDimensionCount,
         lambda self, count: self.setDimensions(count, Long.BYTES),
     )
 
-    def __init__(self, name: str, docValuesType='', indexOptions='', dimensions=0, **settings):
+    def __init__(self, name: str, docValuesType="", indexOptions="", dimensions=0, **settings):
         super().__init__()
         self.name = name
         for name in self.properties.intersection(settings):
@@ -64,24 +64,24 @@ def __init__(self, name: str, docValuesType='', indexOptions='', dimensions=0, *
             self.indexOptions = getattr(index.IndexOptions, indexOptions.upper())
         if docValuesType:
             self.docValuesType = getattr(index.DocValuesType, docValuesType.upper())
-            name = docValuesType.title().replace('_', '')
-            self.docValueClass = getattr(document, name + 'DocValuesField')
+            name = docValuesType.title().replace("_", "")
+            self.docValueClass = getattr(document, name + "DocValuesField")
             if self.stored or self.indexed or self.dimensions:
                 settings = self.settings
-                del settings['docValuesType']
+                del settings["docValuesType"]
                 self.docValueLess = Field(self.name, **settings)
         assert self.stored or self.indexed or self.docvalues or self.dimensions
 
     @classmethod
     def String(
-        cls, name: str, tokenized=False, omitNorms=True, indexOptions='DOCS', **settings
+        cls, name: str, tokenized=False, omitNorms=True, indexOptions="DOCS", **settings
     ) -> 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) -> Self:
+    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)
 
@@ -97,7 +97,7 @@ def docvalues(self):
     def settings(self) -> dict:
         """dict representation of settings"""
         defaults = FieldType()
-        result = {'dimensions': self.dimensions} if self.dimensions else {}
+        result = {"dimensions": self.dimensions} if self.dimensions else {}
         for name in Field.properties:
             value = getattr(self, name)
             if value != getattr(defaults, name)():
@@ -110,7 +110,7 @@ def items(self, *values) -> Iterator[document.Field]:
             types = {int: int, float: util.NumericUtils.doubleToSortableLong}
             for value in values:
                 yield self.docValueClass(self.name, types.get(type(value), util.BytesRef)(value))
-            self = getattr(self, 'docValueLess', self)
+            self = getattr(self, "docValueLess", self)
         if self.dimensions:
             for value in values:
                 cls = document.LongPoint if isinstance(value, int) else document.DoublePoint
@@ -132,7 +132,7 @@ class NestedField(Field):
         sep: field separator used on name and values
     """
 
-    def __init__(self, name: str, sep: str = '.', **settings):
+    def __init__(self, name: str, sep: str = ".", **settings):
         super().__init__(name, **Field.String(name, **settings).settings)
         self.sep = sep
         self.names = tuple(self.values(name))
@@ -145,7 +145,7 @@ def values(self, value: str) -> Iterator[str]:
 
     def items(self, *values: str) -> Iterator[document.Field]:
         """Generate indexed component fields."""
-        field = getattr(self, 'docValueLess', self)
+        field = getattr(self, "docValueLess", self)
         for value in values:
             for name, text in zip(self.names, self.values(value)):
                 yield document.Field(name, text, field)
@@ -176,7 +176,7 @@ def __init__(self, name: str, dimensions: int = 1, **settings):
     def timestamp(cls, date) -> float:
         """Return utc timestamp from date or time tuple."""
         if isinstance(date, datetime.date):
-            return calendar.timegm(date.timetuple()) + getattr(date, 'microsecond', 0) * 1e-6
+            return calendar.timegm(date.timetuple()) + getattr(date, "microsecond", 0) * 1e-6
         return float(calendar.timegm(tuple(date) + (None, 1, 1, 0, 0, 0)[len(date) :]))
 
     def items(self, *dates) -> Iterator[document.Field]:
@@ -327,7 +327,7 @@ def dict(self, *names: str, **defaults) -> dict:
         result = super().dict(*names, **defaults)
         result.update(__id__=self.id, __score__=self.score)
         if self.sortkeys:
-            result['__sortkeys__'] = self.sortkeys
+            result["__sortkeys__"] = self.sortkeys
         return result
 
 
@@ -348,7 +348,7 @@ class Hits:
 
     def __init__(self, searcher, scoredocs: Sequence, count=0, fields=None):
         self.searcher, self.scoredocs = searcher, scoredocs
-        if hasattr(count, 'relation'):
+        if hasattr(count, "relation"):
             cls = int if count.relation == search.TotalHits.Relation.EQUAL_TO else float
             count = cls(count.value())
         self.count, self.fields = count, fields
@@ -372,20 +372,20 @@ def __getitem__(self, index):
 
     @property
     def ids(self) -> Iterator[int]:
-        return map(operator.attrgetter('doc'), self.scoredocs)
+        return map(operator.attrgetter("doc"), self.scoredocs)
 
     @property
     def scores(self) -> Iterator[float]:
-        return map(operator.attrgetter('score'), self.scoredocs)
+        return map(operator.attrgetter("score"), self.scoredocs)
 
     @property
     def maxscore(self) -> float:
         """max score of present hits; not necessarily of all matches"""
-        return max(self.scores, default=float('nan'))
+        return max(self.scores, default=float("nan"))
 
     def items(self) -> Iterator[tuple]:
         """Generate zipped ids and scores."""
-        return map(operator.attrgetter('doc', 'score'), self.scoredocs)
+        return map(operator.attrgetter("doc", "score"), self.scoredocs)
 
     def highlights(self, query: search.Query, **fields: int) -> Iterator[dict]:
         """Generate highlighted fields for each hit.
@@ -406,7 +406,7 @@ def docvalues(self, field: str, type=None) -> dict:
 
     def groupby(
         self, func: Callable, count: int | None = None, docs: int | None = None
-    ) -> 'Groups':
+    ) -> "Groups":
         """Return ordered list of [Hits][lupyne.engine.documents.Hits] grouped by value of function applied to doc ids.
 
         Optionally limit the number of groups and docs per group.
@@ -480,7 +480,7 @@ def __init__(self, field: str, sort=None, cache=True, **attrs):
             self.groupSort = self.sortWithinGroup = sort
             self.fillSortFields = True
         if cache:
-            self.setCachingInMB(float('inf'), True)
+            self.setCachingInMB(float("inf"), True)
         for name in attrs:
             getattr(type(self), name).__set__(self, attrs[name])
 

lupyne/engine/documents.py

@@ -88,7 +88,7 @@ def __init__(self, reader):
         self.indexReader = reader
 
     def __getattr__(self, name):
-        if name == 'indexReader':
+        if name == "indexReader":
             raise AttributeError(name)
         return getattr(index.DirectoryReader.cast_(self.indexReader), name)
 
@@ -111,7 +111,7 @@ def bits(self) -> util.Bits:
     @property
     def directory(self) -> store.Directory:
         """reader's lucene Directory"""
-        return self.__getattr__('directory')()
+        return self.__getattr__("directory")()
 
     @property
     def path(self) -> str:
@@ -188,8 +188,8 @@ def docvalues(self, name: str, type=None) -> DocValues.Sorted:
         """
         types = {int: int, float: util.NumericUtils.sortableLongToDouble}
         type = types.get(type, util.BytesRef.utf8ToString)
-        docValuesType = str(self.fieldinfos[name].docValuesType).title().replace('_', '')
-        method = getattr(index.MultiDocValues, f'get{docValuesType}Values')
+        docValuesType = str(self.fieldinfos[name].docValuesType).title().replace("_", "")
+        method = getattr(index.MultiDocValues, f"get{docValuesType}Values")
         return getattr(DocValues, docValuesType)(method(self.indexReader, name), len(self), type)
 
     def copy(
@@ -217,7 +217,7 @@ def copy(
                 writer.forceMerge(merge)
             return len(writer)
 
-    def terms(self, name: str, value='', stop='', counts=False, distance=0, prefix=0) -> Iterator:
+    def terms(self, name: str, value="", stop="", counts=False, distance=0, prefix=0) -> Iterator:
         """Generate a slice of term values, optionally with frequency counts.
 
         Args:
@@ -237,9 +237,9 @@ def terms(self, name: str, value='', stop='', counts=False, distance=0, prefix=0
         else:
             termsenum.seekCeil(util.BytesRef(value))
             terms = itertools.chain([termsenum.term()], util.BytesRefIterator.cast_(termsenum))
-        terms = map(operator.methodcaller('utf8ToString'), terms)
+        terms = map(operator.methodcaller("utf8ToString"), terms)
         predicate = (
-            partial(operator.gt, stop) if stop else operator.methodcaller('startswith', value)
+            partial(operator.gt, stop) if stop else operator.methodcaller("startswith", value)
         )
         if not distance:
             terms = itertools.takewhile(predicate, terms)
@@ -277,7 +277,7 @@ def positions(self, name: str, value, payloads=False, offsets=False) -> Iterator
     def vector(self, id, field):
         terms = self.termVectors().get(id, field)
         termsenum = terms.iterator() if terms else index.TermsEnum.EMPTY
-        terms = map(operator.methodcaller('utf8ToString'), util.BytesRefIterator.cast_(termsenum))
+        terms = map(operator.methodcaller("utf8ToString"), util.BytesRefIterator.cast_(termsenum))
         return termsenum, terms
 
     def termvector(self, id: int, field: str, counts=False) -> Iterator:
@@ -379,7 +379,7 @@ def parse(self, query, spellcheck=False, **kwargs) -> search.Query:
         if isinstance(query, search.Query):
             return query
         if spellcheck:
-            kwargs['parser'], kwargs['searcher'] = SpellParser, self
+            kwargs["parser"], kwargs["searcher"] = SpellParser, self
         return Analyzer.parse(self.analyzer, query, **kwargs)
 
     @property
@@ -400,7 +400,7 @@ def count(self, *query, **options) -> int:
 
     def collector(self, count=None, sort=None, reverse=False, scores=False, mincount=1000):
         if count is None:
-            return search.CachingCollector.create(True, float('inf'))
+            return search.CachingCollector.create(True, float("inf"))
         count = min(count, self.maxDoc() or 1)
         mincount = max(count, mincount)
         if sort is None:
@@ -523,11 +523,11 @@ class IndexWriter(index.IndexWriter):
 
     parse = IndexSearcher.parse
 
-    def __init__(self, directory, mode: str = 'a', analyzer=None, version=None, **attrs):
+    def __init__(self, directory, mode: str = "a", analyzer=None, version=None, **attrs):
         self.shared = closing()
         args = [] if analyzer is None else [self.shared.analyzer(analyzer)]
         config = index.IndexWriterConfig(*args)
-        config.openMode = index.IndexWriterConfig.OpenMode.values()['wra'.index(mode)]
+        config.openMode = index.IndexWriterConfig.OpenMode.values()["wra".index(mode)]
         for name, value in attrs.items():
             setattr(config, name, value)
         self.policy = index.SnapshotDeletionPolicy(config.indexDeletionPolicy)
@@ -578,7 +578,7 @@ def add(self, document=(), **terms):
         """Add [document][lupyne.engine.indexers.IndexWriter.document] to index with optional boost."""
         self.addDocument(self.document(document, **terms))
 
-    def update(self, name: str, value='', document=(), **terms):
+    def update(self, name: str, value="", document=(), **terms):
         """Atomically delete documents which match given term
         and add the new [document][lupyne.engine.indexers.IndexWriter.document]."""
         doc = self.document(document, **terms)
@@ -605,7 +605,7 @@ def delete(self, *query, **options):
 
     def __iadd__(self, directory):
         """Add directory (or reader, searcher, writer) to index."""
-        with closing.store(getattr(directory, 'directory', directory)) as directory:
+        with closing.store(getattr(directory, "directory", directory)) as directory:
             self.addIndexes([directory])
         return self
 
@@ -639,14 +639,14 @@ class Indexer(IndexWriter):
         nrt: optionally use a near real-time searcher
     """
 
-    def __init__(self, directory, mode='a', analyzer=None, version=None, nrt=False, **attrs):
+    def __init__(self, directory, mode="a", analyzer=None, version=None, nrt=False, **attrs):
         super().__init__(directory, mode, analyzer, version, **attrs)
         super().commit()
         self.nrt = nrt
         self.indexSearcher = IndexSearcher(self if nrt else self.directory, self.analyzer)
 
     def __getattr__(self, name):
-        if name == 'indexSearcher':
+        if name == "indexSearcher":
             raise AttributeError(name)
         return getattr(self.indexSearcher, name)
 

lupyne/engine/indexers.py

@@ -215,7 +215,7 @@ class SpanQuery(Query):
 
     def __getitem__(self, slc: slice) -> SpanQuery:
         start, stop, step = slc.indices(Integer.MAX_VALUE)
-        assert step == 1, 'slice step is not supported'
+        assert step == 1, "slice step is not supported"
         return SpanQuery(spans.SpanPositionRangeQuery, self, start, stop)
 
     def __sub__(self, other: spans.SpanQuery) -> SpanQuery:

lupyne/engine/queries.py

@@ -9,9 +9,9 @@
 from .settings import SCHEMA
 
 type_map = {
-    'Int': int,
-    'Float': float,
-    'String': str,
+    "Int": int,
+    "Float": float,
+    "String": str,
 }
 schema = {}
 if SCHEMA:  # pragma: no branch
@@ -30,15 +30,15 @@ def convert(node):
 
 def multi_valued(annotations):
     """Return set of multi-valued fields."""
-    return {name for name, tp in annotations.items() if getattr(tp, '__origin__', tp) is list}
+    return {name for name, tp in annotations.items() if getattr(tp, "__origin__", tp) is list}
 
 
 @strawberry.type
 class Document:
     """stored fields"""
 
     __annotations__ = {
-        field.name.value: convert(field.type) | None for field in schema.get('Document', [])
+        field.name.value: convert(field.type) | None for field in schema.get("Document", [])
     }
     locals().update(dict.fromkeys(__annotations__))
     locals().update(dict.fromkeys(multi_valued(__annotations__), ()))
@@ -48,7 +48,7 @@ def __init__(self, **doc):
             setattr(self, name, values[0] if getattr(type(self), name, ()) is None else values)
 
 
-sort_types = {field.name.value: convert(field.type) for field in schema.get('FieldDoc', [])}
+sort_types = {field.name.value: convert(field.type) for field in schema.get("FieldDoc", [])}
 
 
 @strawberry.type
@@ -110,5 +110,5 @@ def indexed(self) -> list:
 
     def sortfields(self, sort: list) -> dict:
         """Return mapping of fields to lucene SortFields."""
-        sort = {name.lstrip('-'): name.startswith('-') for name in sort}
+        sort = {name.lstrip("-"): name.startswith("-") for name in sort}
         return {name: self.searcher.sortfield(name, sort_types[name], sort[name]) for name in sort}

lupyne/services/base.py

@@ -112,7 +112,7 @@ def terms(self, info: Info) -> IndexedFields:
         """indexed field names"""
         fields = {}
         for name, selected in selections(*info.selected_fields).items():
-            if 'counts' in selected:
+            if "counts" in selected:
                 terms = dict(root.searcher.terms(name, counts=True))
                 fields[name] = Terms(values=terms, counts=terms.values())
             else:
@@ -127,16 +127,16 @@ def terms(self, info: Info) -> IndexedFields:
     def search(self, info: Info, q: str, count: int | None = None, sort: list[str] = []) -> Hits:
         """Run query and return hits."""
         selected = selections(*info.selected_fields)
-        if 'hits' not in selected or count == 0:
+        if "hits" not in selected or count == 0:
             return Hits(count=root.searcher.count(q), hits=[])
         sortfields = root.sortfields(sort)
         hits = root.searcher.search(
             q,
             count,
             sort=list(sortfields.values()) or None,
-            scores='score' in selected['hits'],
+            scores="score" in selected["hits"],
         )
-        hits.select(*selected['hits'].get('doc', []))
+        hits.select(*selected["hits"].get("doc", []))
         result = Hits(count=hits.count, hits=[])
         for hit in hits:
             sortkeys = dict(zip(sortfields, hit.sortkeys))
@@ -154,4 +154,4 @@ def index(self) -> Index:
 
 
 schema = strawberry.Schema(query=Query, mutation=Mutation)
-app.add_route('/graphql', strawberry.asgi.GraphQL(schema))
+app.add_route("/graphql", strawberry.asgi.GraphQL(schema))