psqlpy 0.10.1__cp311-cp311-win_amd64.whl → 0.11.1__cp311-cp311-win_amd64.whl

psqlpy/__init__.py

@@ -13,10 +13,13 @@ from psqlpy._internal import (
     ReadVariant,
     SingleQueryResult,
     SslMode,
-    SynchronousCommit,
     TargetSessionAttrs,
     Transaction,
     connect,
+    connect_pool,
+)
+from psqlpy.exceptions import (
+    Error,
 )
 
 __all__ = [
@@ -25,6 +28,7 @@ __all__ = [
     "ConnectionPool",
     "ConnectionPoolBuilder",
     "Cursor",
+    "Error",
     "IsolationLevel",
     "KeepaliveConfig",
     "Listener",
@@ -34,8 +38,8 @@ __all__ = [
     "ReadVariant",
     "SingleQueryResult",
     "SslMode",
-    "SynchronousCommit",
     "TargetSessionAttrs",
     "Transaction",
     "connect",
+    "connect_pool",
 ]

psqlpy/_internal/__init__.pyi

@@ -150,38 +150,6 @@ class SingleQueryResult:
         Type that return passed function.
         """
 
-class SynchronousCommit(Enum):
-    """
-    Synchronous_commit option for transactions.
-
-    ### Variants:
-    - `On`: The meaning may change based on whether you have
-        a synchronous standby or not.
-        If there is a synchronous standby,
-        setting the value to on will result in waiting till “remote flush”.
-    - `Off`: As the name indicates, the commit acknowledgment can come before
-        flushing the records to disk.
-        This is generally called as an asynchronous commit.
-        If the PostgreSQL instance crashes,
-        the last few asynchronous commits might be lost.
-    - `Local`: WAL records are written and flushed to local disks.
-        In this case, the commit will be acknowledged after the
-        local WAL Write and WAL flush completes.
-    - `RemoteWrite`: WAL records are successfully handed over to
-        remote instances which acknowledged back
-        about the write (not flush).
-    - `RemoteApply`: This will result in commits waiting until replies from the
-        current synchronous standby(s) indicate they have received
-        the commit record of the transaction and applied it so
-        that it has become visible to queries on the standby(s).
-    """
-
-    On = 1
-    Off = 2
-    Local = 3
-    RemoteWrite = 4
-    RemoteApply = 5
-
 class IsolationLevel(Enum):
     """Isolation Level for transactions."""
 
@@ -285,11 +253,12 @@ class KeepaliveConfig:
         """Initialize new config."""
 
 class Cursor:
-    """Represent opened cursor in a transaction.
+    """Represent binary cursor in a transaction.
 
     It can be used as an asynchronous iterator.
     """
 
+    array_size: int
     cursor_name: str
     querystring: str
     parameters: ParamsT = None
@@ -314,118 +283,27 @@ class Cursor:
 
         Execute DECLARE command for the cursor.
         """
-    async def close(self: Self) -> None:
+    def close(self: Self) -> None:
         """Close the cursor.
 
         Execute CLOSE command for the cursor.
         """
-    async def fetch(
-        self: Self,
-        fetch_number: int | None = None,
-    ) -> QueryResult:
-        """Fetch next <fetch_number> rows.
-
-        By default fetches 10 next rows.
-
-        ### Parameters:
-        - `fetch_number`: how many rows need to fetch.
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_next(
-        self: Self,
-    ) -> QueryResult:
-        """Fetch next row.
-
-        Execute FETCH NEXT
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_prior(
-        self: Self,
-    ) -> QueryResult:
-        """Fetch previous row.
-
-        Execute FETCH PRIOR
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_first(
-        self: Self,
-    ) -> QueryResult:
-        """Fetch first row.
-
-        Execute FETCH FIRST
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_last(
-        self: Self,
-    ) -> QueryResult:
-        """Fetch last row.
-
-        Execute FETCH LAST
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_absolute(
-        self: Self,
-        absolute_number: int,
-    ) -> QueryResult:
-        """Fetch absolute rows.
-
-        Execute FETCH ABSOLUTE <absolute_number>.
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_relative(
-        self: Self,
-        relative_number: int,
-    ) -> QueryResult:
-        """Fetch absolute rows.
-
-        Execute FETCH RELATIVE <relative_number>.
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_forward_all(
-        self: Self,
-    ) -> QueryResult:
-        """Fetch forward all rows.
-
-        Execute FETCH FORWARD ALL.
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_backward(
-        self: Self,
-        backward_count: int,
-    ) -> QueryResult:
-        """Fetch backward rows.
-
-        Execute FETCH BACKWARD <backward_count>.
-
-        ### Returns:
-        result as `QueryResult`.
-        """
-    async def fetch_backward_all(
+    async def execute(
         self: Self,
+        querystring: str,
+        parameters: ParamsT = None,
     ) -> QueryResult:
-        """Fetch backward all rows.
+        """Start cursor with querystring and parameters.
 
-        Execute FETCH BACKWARD ALL.
-
-        ### Returns:
-        result as `QueryResult`.
+        Method should be used instead of context manager
+        and `start` method.
         """
+    async def fetchone(self: Self) -> QueryResult:
+        """Return next one row from the cursor."""
+    async def fetchmany(self: Self, size: int | None = None) -> QueryResult:
+        """Return <size> rows from the cursor."""
+    async def fetchall(self: Self, size: int | None = None) -> QueryResult:
+        """Return all remaining rows from the cursor."""
 
 class Transaction:
     """Single connection for executing queries.
@@ -463,6 +341,26 @@ class Transaction:
 
         `commit()` can be called only once per transaction.
         """
+    async def rollback(self: Self) -> None:
+        """Rollback all queries in the transaction.
+
+        It can be done only one, after execution transaction marked
+        as `done`.
+
+        ### Example:
+        ```python
+        import asyncio
+
+        from psqlpy import PSQLPool, QueryResult
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            connection = await db_pool.connection()
+            transaction = connection.transaction()
+            await transaction.execute(...)
+            await transaction.rollback()
+        ```
+        """
     async def execute(
         self: Self,
         querystring: str,
@@ -744,26 +642,6 @@ class Transaction:
             await transaction.rollback_savepoint("my_savepoint")
         ```
         """
-    async def rollback(self: Self) -> None:
-        """Rollback all queries in the transaction.
-
-        It can be done only one, after execution transaction marked
-        as `done`.
-
-        ### Example:
-        ```python
-        import asyncio
-
-        from psqlpy import PSQLPool, QueryResult
-
-        async def main() -> None:
-            db_pool = PSQLPool()
-            connection = await db_pool.connection()
-            transaction = connection.transaction()
-            await transaction.execute(...)
-            await transaction.rollback()
-        ```
-        """
     async def rollback_savepoint(self: Self, savepoint_name: str) -> None:
         """ROLLBACK to the specified `savepoint_name`.
 
@@ -818,8 +696,6 @@ class Transaction:
         querystring: str,
         parameters: ParamsT = None,
         fetch_number: int | None = None,
-        scroll: bool | None = None,
-        prepared: bool = True,
     ) -> Cursor:
         """Create new cursor object.
 
@@ -829,9 +705,6 @@ class Transaction:
         - `querystring`: querystring to execute.
         - `parameters`: list of parameters to pass in the query.
         - `fetch_number`: how many rows need to fetch.
-        - `scroll`: SCROLL or NO SCROLL cursor.
-        - `prepared`: should the querystring be prepared before the request.
-            By default any querystring will be prepared.
 
         ### Returns:
         new initialized cursor.
@@ -886,6 +759,34 @@ class Transaction:
         number of inserted rows;
         """
 
+async def connect(
+    dsn: str | None = None,
+    username: str | None = None,
+    password: str | None = None,
+    host: str | None = None,
+    hosts: list[str] | None = None,
+    port: int | None = None,
+    ports: list[int] | None = None,
+    db_name: str | None = None,
+    target_session_attrs: TargetSessionAttrs | None = None,
+    options: str | None = None,
+    application_name: str | None = None,
+    connect_timeout_sec: int | None = None,
+    connect_timeout_nanosec: int | None = None,
+    tcp_user_timeout_sec: int | None = None,
+    tcp_user_timeout_nanosec: int | None = None,
+    keepalives: bool | None = None,
+    keepalives_idle_sec: int | None = None,
+    keepalives_idle_nanosec: int | None = None,
+    keepalives_interval_sec: int | None = None,
+    keepalives_interval_nanosec: int | None = None,
+    keepalives_retries: int | None = None,
+    load_balance_hosts: LoadBalanceHosts | None = None,
+    ssl_mode: SslMode | None = None,
+    ca_file: str | None = None,
+) -> Connection:
+    """Create new standalone connection."""
+
 class Connection:
     """Connection from Database Connection Pool.
 
@@ -905,6 +806,25 @@ class Connection:
         exception: BaseException | None,
         traceback: types.TracebackType | None,
     ) -> None: ...
+    async def prepare(
+        self,
+        querystring: str,
+        parameters: ParamsT = None,
+    ) -> PreparedStatement:
+        """Prepare statement.
+
+        Return representation of prepared statement.
+        """
+    async def commit(self: Self) -> None:
+        """Commit the transaction.
+
+        Do nothing if there is no active transaction.
+        """
+    async def rollback(self: Self) -> None:
+        """Rollback the transaction.
+
+        Do nothing if there is no active transaction.
+        """
     async def execute(
         self: Self,
         querystring: str,
@@ -1089,7 +1009,6 @@ class Connection:
         isolation_level: IsolationLevel | None = None,
         read_variant: ReadVariant | None = None,
         deferrable: bool | None = None,
-        synchronous_commit: SynchronousCommit | None = None,
     ) -> Transaction:
         """Create new transaction.
 
@@ -1097,15 +1016,12 @@ class Connection:
         - `isolation_level`: configure isolation level of the transaction.
         - `read_variant`: configure read variant of the transaction.
         - `deferrable`: configure deferrable of the transaction.
-        - `synchronous_commit`: configure synchronous_commit option for transaction.
         """
     def cursor(
         self: Self,
         querystring: str,
         parameters: ParamsT = None,
         fetch_number: int | None = None,
-        scroll: bool | None = None,
-        prepared: bool = True,
     ) -> Cursor:
         """Create new cursor object.
 
@@ -1115,9 +1031,6 @@ class Connection:
         - `querystring`: querystring to execute.
         - `parameters`: list of parameters to pass in the query.
         - `fetch_number`: how many rows need to fetch.
-        - `scroll`: SCROLL or NO SCROLL cursor.
-        - `prepared`: should the querystring be prepared before the request.
-            By default any querystring will be prepared.
 
         ### Returns:
         new initialized cursor.
@@ -1142,12 +1055,13 @@ class Connection:
                         ...  # do something with this result.
         ```
         """
-    def back_to_pool(self: Self) -> None:
+    def close(self: Self) -> None:
         """Return connection back to the pool.
 
         It necessary to commit all transactions and close all cursor
         made by this connection. Otherwise, it won't have any practical usage.
         """
+
     async def binary_copy_to_table(
         self: Self,
         source: bytes | bytearray | Buffer | BytesIO,
@@ -1336,7 +1250,7 @@ class ConnectionPool:
     def close(self: Self) -> None:
         """Close the connection pool."""
 
-def connect(
+def connect_pool(
     dsn: str | None = None,
     username: str | None = None,
     password: str | None = None,
@@ -1857,3 +1771,15 @@ class ListenerNotificationMsg:
     channel: str
     payload: str
     connection: Connection
+
+class Column:
+    name: str
+    table_oid: int | None
+
+class PreparedStatement:
+    async def execute(self: Self) -> QueryResult:
+        """Execute prepared statement."""
+    def cursor(self: Self) -> Cursor:
+        """Create new server-side cursor based on prepared statement."""
+    def columns(self: Self) -> list[Column]:
+        """Return information about statement columns."""

psqlpy/_internal/exceptions.pyi

@@ -1,7 +1,68 @@
-class RustPSQLDriverPyBaseError(Exception):
-    """Base PSQL-Rust-Engine exception."""
+class WarningError(Exception):
+    """
+    Exception raised for important warnings
+    like data truncations while inserting, etc.
+    """
+
+class Error(Exception):
+    """
+    Exception that is the base class of all other error exceptions.
 
-class BaseConnectionPoolError(RustPSQLDriverPyBaseError):
+    You can use this to catch all errors with one single except statement.
+    """
+
+class InterfaceError(Error):
+    """
+    Exception raised for errors that are related to the
+    database interface rather than the database itself.
+    """
+
+class DatabaseError(Error):
+    """Exception raised for errors that are related to the database."""
+
+class DataError(DatabaseError):
+    """
+    Exception raised for errors that are due to problems with
+    the processed data like division by zero, numeric value out of range, etc.
+    """
+
+class OperationalError(DatabaseError):
+    """
+    Exception raised for errors that are related to the database’s operation
+    and not necessarily under the control of the programmer,
+    e.g. an unexpected disconnect occurs, the data source name is not found,
+    a transaction could not be processed, a memory allocation error
+    occurred during processing, etc.
+    """
+
+class IntegrityError(DatabaseError):
+    """
+    Exception raised when the relational integrity of the
+    database is affected, e.g. a foreign key check fails.
+    """
+
+class InternalError(DatabaseError):
+    """
+    Exception raised when the database encounters an internal error,
+    e.g. the cursor is not valid anymore, the transaction is out of sync, etc.
+    """
+
+class ProgrammingError(DatabaseError):
+    """
+    Exception raised for programming errors, e.g. table not found or
+    already exists, syntax error in the SQL statement,
+    wrong number of parameters specified, etc.
+    """
+
+class NotSupportedError(DatabaseError):
+    """
+    Exception raised in case a method or database API was used which
+    is not supported by the database, e.g. requesting a .rollback()
+    on a connection that does not support transaction
+    or has transactions turned off.
+    """
+
+class BaseConnectionPoolError(InterfaceError):
     """Base error for all Connection Pool errors."""
 
 class ConnectionPoolBuildError(BaseConnectionPoolError):
@@ -13,7 +74,7 @@ class ConnectionPoolConfigurationError(BaseConnectionPoolError):
 class ConnectionPoolExecuteError(BaseConnectionPoolError):
     """Error in connection pool execution."""
 
-class BaseConnectionError(RustPSQLDriverPyBaseError):
+class BaseConnectionError(InterfaceError):
     """Base error for Connection errors."""
 
 class ConnectionExecuteError(BaseConnectionError):
@@ -22,7 +83,7 @@ class ConnectionExecuteError(BaseConnectionError):
 class ConnectionClosedError(BaseConnectionError):
     """Error if underlying connection is already closed."""
 
-class BaseTransactionError(RustPSQLDriverPyBaseError):
+class BaseTransactionError(InterfaceError):
     """Base error for all transaction errors."""
 
 class TransactionBeginError(BaseTransactionError):
@@ -43,7 +104,7 @@ class TransactionExecuteError(BaseTransactionError):
 class TransactionClosedError(BaseTransactionError):
     """Error if underlying connection is already closed."""
 
-class BaseCursorError(RustPSQLDriverPyBaseError):
+class BaseCursorError(InterfaceError):
     """Base error for Cursor errors."""
 
 class CursorStartError(BaseCursorError):
@@ -58,29 +119,27 @@ class CursorFetchError(BaseCursorError):
 class CursorClosedError(BaseCursorError):
     """Error if underlying connection is already closed."""
 
-class UUIDValueConvertError(RustPSQLDriverPyBaseError):
+class UUIDValueConvertError(DataError):
     """Error if it's impossible to convert py string UUID into rust UUID."""
 
-class MacAddrConversionError(RustPSQLDriverPyBaseError):
+class MacAddrConversionError(DataError):
     """Error if cannot convert MacAddr string value to rust type."""
 
-class RustToPyValueMappingError(RustPSQLDriverPyBaseError):
+class RustToPyValueMappingError(DataError):
     """Error if it is not possible to covert rust type to python.
 
     You can get it if you database contains data type that it not
     supported by this library.
-
-    It's better to handle this exception.
     """
 
-class PyToRustValueMappingError(RustPSQLDriverPyBaseError):
+class PyToRustValueMappingError(DataError):
     """Error if it is not possible to covert python type to rust.
 
     You can get this exception when executing queries with parameters.
     So, if there are no parameters for the query, don't handle this error.
     """
 
-class BaseListenerError(RustPSQLDriverPyBaseError):
+class BaseListenerError(InterfaceError):
     """Base error for all Listener errors."""
 
 class ListenerStartError(BaseListenerError):

psqlpy/exceptions.py

@@ -13,12 +13,20 @@ from ._internal.exceptions import (
     CursorCloseError,
     CursorFetchError,
     CursorStartError,
+    DatabaseError,
+    DataError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    InternalError,
     ListenerCallbackError,
     ListenerClosedError,
     ListenerStartError,
     MacAddrConversionError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
     PyToRustValueMappingError,
-    RustPSQLDriverPyBaseError,
     RustToPyValueMappingError,
     TransactionBeginError,
     TransactionClosedError,
@@ -27,6 +35,7 @@ from ._internal.exceptions import (
     TransactionRollbackError,
     TransactionSavepointError,
     UUIDValueConvertError,
+    WarningError,
 )
 
 __all__ = [
@@ -44,12 +53,20 @@ __all__ = [
     "CursorClosedError",
     "CursorFetchError",
     "CursorStartError",
+    "DataError",
+    "DatabaseError",
+    "Error",
+    "IntegrityError",
+    "InterfaceError",
+    "InternalError",
     "ListenerCallbackError",
     "ListenerClosedError",
     "ListenerStartError",
     "MacAddrConversionError",
+    "NotSupportedError",
+    "OperationalError",
+    "ProgrammingError",
     "PyToRustValueMappingError",
-    "RustPSQLDriverPyBaseError",
     "RustToPyValueMappingError",
     "TransactionBeginError",
     "TransactionClosedError",
@@ -58,4 +75,5 @@ __all__ = [
     "TransactionRollbackError",
     "TransactionSavepointError",
     "UUIDValueConvertError",
+    "WarningError",
 ]

{psqlpy-0.10.1.dist-info → psqlpy-0.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psqlpy
-Version: 0.10.1
+Version: 0.11.1
 Classifier: Typing :: Typed
 Classifier: Topic :: Database
 Classifier: Development Status :: 4 - Beta
@@ -33,6 +33,8 @@ Project-URL: documentation, https://psqlpy-python.github.io/
 
 [![PyPI - Python Version](https://img.shields.io/badge/PYTHON-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue?style=for-the-badge
 )](https://pypi.org/project/psqlpy/)
+[![PyPI - Python Version](https://img.shields.io/badge/Tested%20On%20PostgreSQL-14%20%7C%2015%20%7C%2016%20%7C17-2be28a?style=for-the-badge
+)](https://pypi.org/project/psqlpy/)
 [![PyPI](https://img.shields.io/pypi/v/psqlpy?style=for-the-badge)](https://pypi.org/project/psqlpy/)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/psqlpy?style=for-the-badge)](https://pypistats.org/packages/psqlpy)
 

psqlpy-0.11.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+psqlpy-0.11.1.dist-info/METADATA,sha256=KpwIK7lou-sjErrbZJ8dWhsSIHh-7Rk6h8hZiRcTRUc,3598
+psqlpy-0.11.1.dist-info/WHEEL,sha256=Kw8y023UaufEXFM028WbBCk7rJUUAhAX1Zw-54pv0m4,96
+psqlpy-0.11.1.dist-info/entry_points.txt,sha256=kNGHhl8cqbZ25PuaS-Ez-7jl3_b_4rIajMSmdJzmKNo,74
+psqlpy-0.11.1.dist-info/licenses/LICENSE,sha256=hZGPaqvpChxSPLSye1juW8quOxD19gGadYEu-41ATTw,1098
+psqlpy/__init__.py,sha256=JrmJTSxkjPdQzh7R2yTM-EATT_TJIVGyvGmsGzRDKJo,883
+psqlpy/_internal.cp311-win_amd64.pyd,sha256=_85PmJMheTsifKp4wR62mgNoLkj3EpWFR3joZPOATJE,10764288
+psqlpy/_internal/__init__.pyi,sha256=2vUK7k_b226EGq9xJUAn7ViygOV3F1A9qzPVP01WUjA,60092
+psqlpy/_internal/exceptions.pyi,sha256=P86gr4UkDwMB5H6VoEs4FOtDMoiUobv7heCh_Mpp_vg,5122
+psqlpy/_internal/extra_types.pyi,sha256=lVhIO5fcxWXpxJbRtOS418RihIHmFfu-U3Tvo0YS3n8,17626
+psqlpy/_internal/row_factories.pyi,sha256=Knkyt4nY2ZI539cZsfyr87EJgmW-z4Nq4nKTokC9YMI,1516
+psqlpy/exceptions.py,sha256=gHPwwaC76p1Q9yidq3wqbCInzNKosmNQuJskCtIosiE,2052
+psqlpy/extra_types.py,sha256=Lg-KK1uxUjHh-13iRp4ahEWPCR3GMBiDV2xCt63mVIw,1716
+psqlpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+psqlpy/row_factories.py,sha256=nTrgfvsS2SqfZcAB5FCrnkLTUIqyPnZjGMMD1nATrPM,113
+psqlpy-0.11.1.dist-info/RECORD,,

{psqlpy-0.10.1.dist-info → psqlpy-0.11.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.8.3)
+Generator: maturin (1.8.6)
 Root-Is-Purelib: false
 Tag: cp311-cp311-win_amd64

psqlpy-0.11.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[sqlalchemy.dialects]
+psqlpy=psqlpy_sqlalchemy.dialect:PSQLPyAsyncDialect

psqlpy-0.10.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-psqlpy-0.10.1.dist-info/METADATA,sha256=-XaZeEewPSb5vgNW-6NjbwAMhF-nGyd426YvSs5pQek,3419
-psqlpy-0.10.1.dist-info/WHEEL,sha256=tAGdc4C2KTz7B2CZ8Jf3DcKSAviAbCg44UH9ma2gYww,96
-psqlpy-0.10.1.dist-info/licenses/LICENSE,sha256=hZGPaqvpChxSPLSye1juW8quOxD19gGadYEu-41ATTw,1098
-psqlpy/exceptions.py,sha256=cDq9N8vonHEmxm3vffUU4X2MYixcabtKah_itBuZvb4,1700
-psqlpy/extra_types.py,sha256=Lg-KK1uxUjHh-13iRp4ahEWPCR3GMBiDV2xCt63mVIw,1716
-psqlpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-psqlpy/row_factories.py,sha256=nTrgfvsS2SqfZcAB5FCrnkLTUIqyPnZjGMMD1nATrPM,113
-psqlpy/_internal/exceptions.pyi,sha256=Px3CHk8xvQ6rM4Z7pGK4sxipSqXAzH4ZvojBuLem2zI,3279
-psqlpy/_internal/extra_types.pyi,sha256=lVhIO5fcxWXpxJbRtOS418RihIHmFfu-U3Tvo0YS3n8,17626
-psqlpy/_internal/row_factories.pyi,sha256=Knkyt4nY2ZI539cZsfyr87EJgmW-z4Nq4nKTokC9YMI,1516
-psqlpy/_internal/__init__.pyi,sha256=z2a1_8r2T8ck45YHFhXqsPFX2EfxyVp6QpXWR6-mhkk,61785
-psqlpy/__init__.py,sha256=_HeRs_hIl9Bo5aOzL0MkkOsR2o3TWhWE-eKwkgTRNqU,831
-psqlpy/_internal.cp311-win_amd64.pyd,sha256=-nqLDxbPiuHav2LeU1BZ-D6sJ7QTxLFxjpq_qnWPf5k,10716160
-psqlpy-0.10.1.dist-info/RECORD,,