Added underscores to private functions [skip ci]

ankane · ankane · commit 240e4135bfe4 · 2024-06-03T18:40:39.000-07:00
diff --git a/pgvector/asyncpg/register.py b/pgvector/asyncpg/register.py
@@ -4,21 +4,21 @@
 async def register_vector(conn):
     await conn.set_type_codec(
         'vector',
-        encoder=Vector.to_db_binary,
-        decoder=Vector.from_db_binary,
+        encoder=Vector._to_db_binary,
+        decoder=Vector._from_db_binary,
         format='binary'
     )
 
     await conn.set_type_codec(
         'halfvec',
-        encoder=HalfVector.to_db_binary,
-        decoder=HalfVector.from_db_binary,
+        encoder=HalfVector._to_db_binary,
+        decoder=HalfVector._from_db_binary,
         format='binary'
     )
 
     await conn.set_type_codec(
         'sparsevec',
-        encoder=SparseVector.to_db_binary,
-        decoder=SparseVector.from_db_binary,
+        encoder=SparseVector._to_db_binary,
+        decoder=SparseVector._from_db_binary,
         format='binary'
     )
diff --git a/pgvector/django/functions.py b/pgvector/django/functions.py
@@ -8,11 +8,11 @@ class DistanceBase(Func):
     def __init__(self, expression, vector, **extra):
         if not hasattr(vector, 'resolve_expression'):
             if isinstance(vector, HalfVector):
-                vector = Value(HalfVector.to_db(vector))
+                vector = Value(HalfVector._to_db(vector))
             elif isinstance(vector, SparseVector):
-                vector = Value(SparseVector.to_db(vector))
+                vector = Value(SparseVector._to_db(vector))
             else:
-                vector = Value(Vector.to_db(vector))
+                vector = Value(Vector._to_db(vector))
         super().__init__(expression, vector, **extra)
 
 
diff --git a/pgvector/django/halfvec.py b/pgvector/django/halfvec.py
@@ -23,13 +23,13 @@ def db_type(self, connection):
         return 'halfvec(%d)' % self.dimensions
 
     def from_db_value(self, value, expression, connection):
-        return HalfVector.from_db(value)
+        return HalfVector._from_db(value)
 
     def to_python(self, value):
-        return HalfVector.from_db(value)
+        return HalfVector._from_db(value)
 
     def get_prep_value(self, value):
-        return HalfVector.to_db(value)
+        return HalfVector._to_db(value)
 
     def value_to_string(self, obj):
         return self.get_prep_value(self.value_from_object(obj))
diff --git a/pgvector/django/sparsevec.py b/pgvector/django/sparsevec.py
@@ -23,13 +23,13 @@ def db_type(self, connection):
         return 'sparsevec(%d)' % self.dimensions
 
     def from_db_value(self, value, expression, connection):
-        return SparseVector.from_db(value)
+        return SparseVector._from_db(value)
 
     def to_python(self, value):
-        return SparseVector.from_db(value)
+        return SparseVector._from_db(value)
 
     def get_prep_value(self, value):
-        return SparseVector.to_db(value)
+        return SparseVector._to_db(value)
 
     def value_to_string(self, obj):
         return self.get_prep_value(self.value_from_object(obj))
diff --git a/pgvector/django/vector.py b/pgvector/django/vector.py
@@ -25,15 +25,15 @@ def db_type(self, connection):
         return 'vector(%d)' % self.dimensions
 
     def from_db_value(self, value, expression, connection):
-        return Vector.from_db(value)
+        return Vector._from_db(value)
 
     def to_python(self, value):
         if isinstance(value, list):
             return np.array(value, dtype=np.float32)
-        return Vector.from_db(value)
+        return Vector._from_db(value)
 
     def get_prep_value(self, value):
-        return Vector.to_db(value)
+        return Vector._to_db(value)
 
     def value_to_string(self, obj):
         return self.get_prep_value(self.value_from_object(obj))
diff --git a/pgvector/peewee/halfvec.py b/pgvector/peewee/halfvec.py
@@ -13,10 +13,10 @@ def get_modifiers(self):
         return self.dimensions and [self.dimensions] or None
 
     def db_value(self, value):
-        return HalfVector.to_db(value)
+        return HalfVector._to_db(value)
 
     def python_value(self, value):
-        return HalfVector.from_db(value)
+        return HalfVector._from_db(value)
 
     def _distance(self, op, vector):
         return Expression(lhs=self, op=op, rhs=self.to_value(vector))
diff --git a/pgvector/peewee/sparsevec.py b/pgvector/peewee/sparsevec.py
@@ -13,10 +13,10 @@ def get_modifiers(self):
         return self.dimensions and [self.dimensions] or None
 
     def db_value(self, value):
-        return SparseVector.to_db(value)
+        return SparseVector._to_db(value)
 
     def python_value(self, value):
-        return SparseVector.from_db(value)
+        return SparseVector._from_db(value)
 
     def _distance(self, op, vector):
         return Expression(lhs=self, op=op, rhs=self.to_value(vector))
diff --git a/pgvector/peewee/vector.py b/pgvector/peewee/vector.py
@@ -13,10 +13,10 @@ def get_modifiers(self):
         return self.dimensions and [self.dimensions] or None
 
     def db_value(self, value):
-        return Vector.to_db(value)
+        return Vector._to_db(value)
 
     def python_value(self, value):
-        return Vector.from_db(value)
+        return Vector._from_db(value)
 
     def _distance(self, op, vector):
         return Expression(lhs=self, op=op, rhs=self.to_value(vector))
diff --git a/pgvector/psycopg/bit.py b/pgvector/psycopg/bit.py
@@ -8,15 +8,15 @@ class BitDumper(Dumper):
     format = Format.TEXT
 
     def dump(self, obj):
-        return Bit.to_db(obj).encode('utf8')
+        return Bit._to_db(obj).encode('utf8')
 
 
 class BitBinaryDumper(BitDumper):
 
     format = Format.BINARY
 
     def dump(self, obj):
-        return Bit.to_db_binary(obj)
+        return Bit._to_db_binary(obj)
 
 
 def register_bit_info(context, info):
diff --git a/pgvector/psycopg/halfvec.py b/pgvector/psycopg/halfvec.py
@@ -8,15 +8,15 @@ class HalfVectorDumper(Dumper):
     format = Format.TEXT
 
     def dump(self, obj):
-        return HalfVector.to_db(obj).encode('utf8')
+        return HalfVector._to_db(obj).encode('utf8')
 
 
 class HalfVectorBinaryDumper(HalfVectorDumper):
 
     format = Format.BINARY
 
     def dump(self, obj):
-        return HalfVector.to_db_binary(obj)
+        return HalfVector._to_db_binary(obj)
 
 
 class HalfVectorLoader(Loader):
@@ -26,7 +26,7 @@ class HalfVectorLoader(Loader):
     def load(self, data):
         if isinstance(data, memoryview):
             data = bytes(data)
-        return HalfVector.from_db(data.decode('utf8'))
+        return HalfVector._from_db(data.decode('utf8'))
 
 
 class HalfVectorBinaryLoader(HalfVectorLoader):
@@ -36,7 +36,7 @@ class HalfVectorBinaryLoader(HalfVectorLoader):
     def load(self, data):
         if isinstance(data, memoryview):
             data = bytes(data)
-        return HalfVector.from_db_binary(data)
+        return HalfVector._from_db_binary(data)
 
 
 def register_halfvec_info(context, info):
diff --git a/pgvector/psycopg/sparsevec.py b/pgvector/psycopg/sparsevec.py
@@ -8,15 +8,15 @@ class SparseVectorDumper(Dumper):
     format = Format.TEXT
 
     def dump(self, obj):
-        return SparseVector.to_db(obj).encode('utf8')
+        return SparseVector._to_db(obj).encode('utf8')
 
 
 class SparseVectorBinaryDumper(SparseVectorDumper):
 
     format = Format.BINARY
 
     def dump(self, obj):
-        return SparseVector.to_db_binary(obj)
+        return SparseVector._to_db_binary(obj)
 
 
 class SparseVectorLoader(Loader):
@@ -26,7 +26,7 @@ class SparseVectorLoader(Loader):
     def load(self, data):
         if isinstance(data, memoryview):
             data = bytes(data)
-        return SparseVector.from_db(data.decode('utf8'))
+        return SparseVector._from_db(data.decode('utf8'))
 
 
 class SparseVectorBinaryLoader(SparseVectorLoader):
@@ -36,7 +36,7 @@ class SparseVectorBinaryLoader(SparseVectorLoader):
     def load(self, data):
         if isinstance(data, memoryview):
             data = bytes(data)
-        return SparseVector.from_db_binary(data)
+        return SparseVector._from_db_binary(data)
 
 
 def register_sparsevec_info(context, info):
diff --git a/pgvector/psycopg/vector.py b/pgvector/psycopg/vector.py
@@ -8,15 +8,15 @@ class VectorDumper(Dumper):
     format = Format.TEXT
 
     def dump(self, obj):
-        return Vector.to_db(obj).encode('utf8')
+        return Vector._to_db(obj).encode('utf8')
 
 
 class VectorBinaryDumper(VectorDumper):
 
     format = Format.BINARY
 
     def dump(self, obj):
-        return Vector.to_db_binary(obj)
+        return Vector._to_db_binary(obj)
 
 
 class VectorLoader(Loader):
@@ -26,7 +26,7 @@ class VectorLoader(Loader):
     def load(self, data):
         if isinstance(data, memoryview):
             data = bytes(data)
-        return Vector.from_db(data.decode('utf8'))
+        return Vector._from_db(data.decode('utf8'))
 
 
 class VectorBinaryLoader(VectorLoader):
@@ -36,7 +36,7 @@ class VectorBinaryLoader(VectorLoader):
     def load(self, data):
         if isinstance(data, memoryview):
             data = bytes(data)
-        return Vector.from_db_binary(data)
+        return Vector._from_db_binary(data)
 
 
 def register_vector_info(context, info):
diff --git a/pgvector/psycopg2/halfvec.py b/pgvector/psycopg2/halfvec.py
@@ -7,11 +7,11 @@ def __init__(self, value):
         self._value = value
 
     def getquoted(self):
-        return adapt(HalfVector.to_db(self._value)).getquoted()
+        return adapt(HalfVector._to_db(self._value)).getquoted()
 
 
 def cast_halfvec(value, cur):
-    return HalfVector.from_db(value)
+    return HalfVector._from_db(value)
 
 
 def register_halfvec_info(oid):
diff --git a/pgvector/psycopg2/sparsevec.py b/pgvector/psycopg2/sparsevec.py
@@ -7,11 +7,11 @@ def __init__(self, value):
         self._value = value
 
     def getquoted(self):
-        return adapt(SparseVector.to_db(self._value)).getquoted()
+        return adapt(SparseVector._to_db(self._value)).getquoted()
 
 
 def cast_sparsevec(value, cur):
-    return SparseVector.from_db(value)
+    return SparseVector._from_db(value)
 
 
 def register_sparsevec_info(oid):
diff --git a/pgvector/psycopg2/vector.py b/pgvector/psycopg2/vector.py
@@ -8,11 +8,11 @@ def __init__(self, value):
         self._value = value
 
     def getquoted(self):
-        return adapt(Vector.to_db(self._value)).getquoted()
+        return adapt(Vector._to_db(self._value)).getquoted()
 
 
 def cast_vector(value, cur):
-    return Vector.from_db(value)
+    return Vector._from_db(value)
 
 
 def register_vector_info(oid):
diff --git a/pgvector/sqlalchemy/halfvec.py b/pgvector/sqlalchemy/halfvec.py
@@ -18,19 +18,19 @@ def get_col_spec(self, **kw):
 
     def bind_processor(self, dialect):
         def process(value):
-            return HalfVector.to_db(value, self.dim)
+            return HalfVector._to_db(value, self.dim)
         return process
 
     def literal_processor(self, dialect):
         string_literal_processor = self._string._cached_literal_processor(dialect)
 
         def process(value):
-            return string_literal_processor(HalfVector.to_db(value, self.dim))
+            return string_literal_processor(HalfVector._to_db(value, self.dim))
         return process
 
     def result_processor(self, dialect, coltype):
         def process(value):
-            return HalfVector.from_db(value)
+            return HalfVector._from_db(value)
         return process
 
     class comparator_factory(UserDefinedType.Comparator):
diff --git a/pgvector/sqlalchemy/sparsevec.py b/pgvector/sqlalchemy/sparsevec.py
@@ -18,19 +18,19 @@ def get_col_spec(self, **kw):
 
     def bind_processor(self, dialect):
         def process(value):
-            return SparseVector.to_db(value, self.dim)
+            return SparseVector._to_db(value, self.dim)
         return process
 
     def literal_processor(self, dialect):
         string_literal_processor = self._string._cached_literal_processor(dialect)
 
         def process(value):
-            return string_literal_processor(SparseVector.to_db(value, self.dim))
+            return string_literal_processor(SparseVector._to_db(value, self.dim))
         return process
 
     def result_processor(self, dialect, coltype):
         def process(value):
-            return SparseVector.from_db(value)
+            return SparseVector._from_db(value)
         return process
 
     class comparator_factory(UserDefinedType.Comparator):
diff --git a/pgvector/sqlalchemy/vector.py b/pgvector/sqlalchemy/vector.py
@@ -18,19 +18,19 @@ def get_col_spec(self, **kw):
 
     def bind_processor(self, dialect):
         def process(value):
-            return Vector.to_db(value, self.dim)
+            return Vector._to_db(value, self.dim)
         return process
 
     def literal_processor(self, dialect):
         string_literal_processor = self._string._cached_literal_processor(dialect)
 
         def process(value):
-            return string_literal_processor(Vector.to_db(value, self.dim))
+            return string_literal_processor(Vector._to_db(value, self.dim))
         return process
 
     def result_processor(self, dialect, coltype):
         def process(value):
-            return Vector.from_db(value)
+            return Vector._from_db(value)
         return process
 
     class comparator_factory(UserDefinedType.Comparator):
diff --git a/pgvector/utils/bit.py b/pgvector/utils/bit.py
@@ -37,15 +37,13 @@ def from_binary(value):
         buf = np.frombuffer(value, dtype=np.uint8, offset=4)
         return Bit(np.unpackbits(buf, count=count).astype(bool))
 
-    # TODO move rest
-
-    def to_db(value):
+    def _to_db(value):
         if not isinstance(value, Bit):
             raise ValueError('expected bit')
 
         return value.to_text()
 
-    def to_db_binary(value):
+    def _to_db_binary(value):
         if not isinstance(value, Bit):
             raise ValueError('expected bit')
 
diff --git a/pgvector/utils/halfvec.py b/pgvector/utils/halfvec.py
diff --git a/pgvector/utils/sparsevec.py b/pgvector/utils/sparsevec.py
diff --git a/pgvector/utils/vector.py b/pgvector/utils/vector.py
