CyMySQL 1.1.1__tar.gz → 1.1.2__tar.gz

{cymysql-1.1.1 → cymysql-1.1.2}/CyMySQL.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CyMySQL
-Version: 1.1.1
+Version: 1.1.2
 Summary: Python MySQL Driver using Cython
 Author-email: Yutaka Matsubara <yutaka.matsubara@gmail.com>
 Maintainer-email: Hajime Nakagami <nakagami@gmail.com>
@@ -57,7 +57,7 @@ Or without cythonize
 
 ::
 
-   $ NO_CYTHON=1 pip instal cymysql
+   $ NO_CYTHON=1 pip install cymysql
 
 Example
 ---------------

{cymysql-1.1.1 → cymysql-1.1.2}/CyMySQL.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ cymysql/cursors.py
 cymysql/err.py
 cymysql/packet.py
 cymysql/packet.pyx
+cymysql/py.typed
 cymysql/result.py
 cymysql/result.pyx
 cymysql/socketwrapper.py

cymysql-1.1.2/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.rst LICENSE
+recursive-include cymysql *.pyx *.pxd py.typed
+global-exclude *.c

{cymysql-1.1.1 → cymysql-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CyMySQL
-Version: 1.1.1
+Version: 1.1.2
 Summary: Python MySQL Driver using Cython
 Author-email: Yutaka Matsubara <yutaka.matsubara@gmail.com>
 Maintainer-email: Hajime Nakagami <nakagami@gmail.com>
@@ -57,7 +57,7 @@ Or without cythonize
 
 ::
 
-   $ NO_CYTHON=1 pip instal cymysql
+   $ NO_CYTHON=1 pip install cymysql
 
 Example
 ---------------

{cymysql-1.1.1 → cymysql-1.1.2}/README.rst

@@ -33,7 +33,7 @@ Or without cythonize
 
 ::
 
-   $ NO_CYTHON=1 pip instal cymysql
+   $ NO_CYTHON=1 pip install cymysql
 
 Example
 ---------------

{cymysql-1.1.1 → cymysql-1.1.2}/cymysql/__init__.py

@@ -22,6 +22,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 '''
+from typing import Any
+
 from cymysql import converters
 from cymysql.converters import escape_dict, escape_sequence, escape_string
 from cymysql.err import (
@@ -45,19 +47,19 @@ paramstyle = "format"
 
 class DBAPISet(frozenset):
 
-    def __ne__(self, other):
+    def __ne__(self, other: Any) -> bool:
         if isinstance(other, set):
             return super(DBAPISet, self).__ne__(self, other)
         else:
             return other not in self
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, frozenset):
             return frozenset.__eq__(self, other)
         else:
             return other in self
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return frozenset.__hash__(self)
 
 
@@ -76,18 +78,19 @@ DATETIME = TIMESTAMP
 ROWID = DBAPISet()
 
 
-def Binary(x):
+def Binary(x: Any) -> bytes:
     """Return x as a binary type."""
     return bytes(x)
 
 
-def connect(*args, **kwargs):
+def connect(*args: Any, **kwargs: Any) -> Connection:
     conn = Connection(*args, **kwargs)
     conn._connect()
     conn._initialize()
     return conn
 
 
+
 NULL = "NULL"
 
 __all__ = [

{cymysql-1.1.1 → cymysql-1.1.2}/cymysql/__version__.py

@@ -1,2 +1,2 @@
-VERSION = (1, 1, 1)
+VERSION = (1, 1, 2)
 __version__ = '%s.%s.%s' % VERSION

{cymysql-1.1.1 → cymysql-1.1.2}/cymysql/aio/__init__.py

@@ -1,3 +1,12 @@
 from .connections import AsyncConnection, connect
-from .pool import create_pool
 from .cursors import AsyncCursor, AsyncDictCursor
+from .pool import create_pool
+
+__all__ = [
+    'AsyncConnection',
+    'connect',
+    'create_pool',
+    'AsyncCursor',
+    'AsyncDictCursor',
+]
+

{cymysql-1.1.1 → cymysql-1.1.2}/cymysql/aio/connections.py

@@ -1,25 +1,30 @@
-import sys
-import ssl
 import asyncio
+import ssl
 import struct
+import sys
+from typing import TYPE_CHECKING, Any
+
+from ..charset import charset_by_name
 from ..connections import (
     Connection,
+    _xor,
     byte2int,
-    int2byte,
+    int2bytes,
     pack_int24,
-    _xor,
 )
-from .cursors import AsyncCursor
-from ..charset import  charset_by_name
+from ..constants import CLIENT, COMMAND
+from ..err import InterfaceError
 from ..packet import MysqlPacket
+from .cursors import AsyncCursor
 from .result import AsyncMySQLResult
 from .socketwrapper import AsyncSocketWrapper
-from ..constants import CLIENT, COMMAND
-from ..err import InterfaceError
+
+if TYPE_CHECKING:
+    from .cursors import AsyncCursor
 
 
 class AsyncConnection(Connection):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         if kwargs.get("loop"):
             self.loop = kwargs.get("loop")
             del kwargs["loop"]
@@ -28,10 +33,10 @@ class AsyncConnection(Connection):
         super().__init__(*args, **kwargs)
         self.last_usage = self.loop.time()
 
-    def _connect(self):
+    def _connect(self) -> None:
         self.socket = AsyncSocketWrapper(self._get_socket(), self.compress)
 
-    async def _initialize(self):
+    async def _initialize(self) -> None:
         self.socket.setblocking(False)
         await self._get_server_information()
         await self._request_authentication()
@@ -49,16 +54,16 @@ class AsyncConnection(Connection):
 
             self.commit()
 
-    async def close(self):
+    async def close(self) -> None:
         ''' Send the quit message and close the socket '''
         if self.socket is None:
             return
-        send_data = b'\x01\x00\x00\x00' + int2byte(COMMAND.COM_QUIT)
+        send_data = b'\x01\x00\x00\x00' + int2bytes(COMMAND.COM_QUIT)
         await self.socket.send_packet(send_data, self.loop)
         self.socket.close()
         self.socket = None
 
-    async def autocommit(self, value):
+    async def autocommit(self, value: bool) -> None:
         ''' Set whether or not to commit after every execute() '''
         if value:
             q = "SET AUTOCOMMIT = 1"
@@ -71,7 +76,7 @@ class AsyncConnection(Connection):
             exc, value, tb = sys.exc_info()
             self.errorhandler(None, exc, value)
 
-    async def commit(self):
+    async def commit(self) -> None:
         ''' Commit changes to stable storage '''
         try:
             await self._execute_command(COMMAND.COM_QUERY, "COMMIT")
@@ -80,7 +85,7 @@ class AsyncConnection(Connection):
             exc, value, tb = sys.exc_info()
             self.errorhandler(None, exc, value)
 
-    async def rollback(self):
+    async def rollback(self) -> None:
         ''' Roll back the current transaction '''
         try:
             await self._execute_command(COMMAND.COM_QUERY, "ROLLBACK")
@@ -89,7 +94,7 @@ class AsyncConnection(Connection):
             exc, value, tb = sys.exc_info()
             self.errorhandler(None, exc, value)
 
-    def cursor(self, cursor=None):
+    def cursor(self, cursor: type[AsyncCursor] | None = None) -> AsyncCursor:
         self.last_usage = self.loop.time()
         if cursor is None:
             cursor = self.cursorclass
@@ -97,30 +102,30 @@ class AsyncConnection(Connection):
             cursor = AsyncCursor
         return cursor(self)
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> 'AsyncConnection':
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         if self.socket is not None:
             await self.close()
 
     # The following methods are INTERNAL USE ONLY (called from Cursor)
-    async def query(self, sql):
+    async def query(self, sql: str | bytes) -> None:
         await self._execute_command(COMMAND.COM_QUERY, sql)
         self._result = AsyncMySQLResult(self)
         await self._result.read_result()
 
-    async def next_result(self):
+    async def next_result(self) -> None:
         self._result = AsyncMySQLResult(self)
         await self._result.read_result()
 
-    def affected_rows(self):
+    def affected_rows(self) -> int:
         if self._result:
-            self._result._affected_rows
+            return self._result._affected_rows
         else:
             return 0
 
-    async def kill(self, thread_id):
+    async def kill(self, thread_id: int) -> bool:
         arg = struct.pack('<I', thread_id)
         try:
             await self._execute_command(COMMAND.COM_PROCESS_KILL, arg)
@@ -131,7 +136,7 @@ class AsyncConnection(Connection):
             self.errorhandler(None, exc, value)
         return False
 
-    async def ping(self, reconnect=True):
+    async def ping(self, reconnect: bool = True) -> bool | None:
         ''' Check if the server is alive '''
         try:
             await self._execute_command(COMMAND.COM_PING, "")
@@ -147,7 +152,7 @@ class AsyncConnection(Connection):
         pkt = await self.read_packet()
         return pkt.is_ok_packet()
 
-    async def set_charset(self, charset):
+    async def set_charset(self, charset: str) -> None:
         try:
             if charset:
                 await self._execute_command(COMMAND.COM_QUERY, "SET NAMES %s" %
@@ -158,12 +163,12 @@ class AsyncConnection(Connection):
             exc, value, tb = sys.exc_info()
             self.errorhandler(None, exc, value)
 
-    async def read_packet(self):
+    async def read_packet(self) -> MysqlPacket:
         """Read an entire "mysql packet" in its entirety from the network
         and return a MysqlPacket type that represents the results."""
         return MysqlPacket(await self.socket.recv_packet(self.loop), self.charset, self.encoding)
 
-    async def _request_authentication(self):
+    async def _request_authentication(self) -> None:
         if self.user is None:
             raise ValueError("Did not specify a username")
 
@@ -175,32 +180,32 @@ class AsyncConnection(Connection):
         data_init = (
             struct.pack('<i', self.client_flag) +
             struct.pack("<I", 1) +
-            int2byte(charset_id) + int2byte(0)*23
+            int2bytes(charset_id) + int2bytes(0)*23
         )
 
         if self.ssl and self.server_capabilities & CLIENT.SSL:
-            data = pack_int24(len(data_init)) + int2byte(next_packet) + data_init
+            data = pack_int24(len(data_init)) + int2bytes(next_packet) + data_init
             await self.socket.send_uncompress_packet(data, self.loop)
             next_packet += 1
             self.socket = ssl.wrap_socket(self.socket, keyfile=self.key,
                                           certfile=self.cert,
                                           ca_certs=self.ca)
 
-        data = data_init + user + int2byte(0)
+        data = data_init + user + int2bytes(0)
         authresp = self._scramble()
 
         if self.server_capabilities & CLIENT.SECURE_CONNECTION:
-            data += int2byte(len(authresp)) + authresp
+            data += int2bytes(len(authresp)) + authresp
         else:
-            data += authresp + int2byte(0)
+            data += authresp + int2bytes(0)
 
         if self.db and self.server_capabilities & CLIENT.CONNECT_WITH_DB:
-            data += self.db.encode(self.encoding) + int2byte(0)
+            data += self.db.encode(self.encoding) + int2bytes(0)
 
         if self.server_capabilities & CLIENT.PLUGIN_AUTH:
-            data += self.auth_plugin_name.encode(self.encoding) + int2byte(0)
+            data += self.auth_plugin_name.encode(self.encoding) + int2bytes(0)
 
-        data = pack_int24(len(data)) + int2byte(next_packet) + data
+        data = pack_int24(len(data)) + int2bytes(next_packet) + data
         next_packet += 2
 
         await self.socket.send_uncompress_packet(data, self.loop)
@@ -214,7 +219,7 @@ class AsyncConnection(Connection):
             j = auth_packet.find(b'\0', i + 1)
             self.salt = auth_packet[i + 1:j]
             data = self._scramble()
-            data = pack_int24(len(data)) + int2byte(next_packet) + data
+            data = pack_int24(len(data)) + int2bytes(next_packet) + data
             next_packet += 2
             await self.socket.send_uncompress_packet(data, self.loop)
             auth_packet = await self.socket.recv_uncompress_packet(self.loop)
@@ -222,18 +227,19 @@ class AsyncConnection(Connection):
         if self.auth_plugin_name == 'caching_sha2_password':
             await self._caching_sha2_authentication2(auth_packet, next_packet)
 
-    async def _execute_command(self, command, sql):
+    async def _execute_command(self, command: int, sql: str | bytes) -> None:
         if not self.socket:
             self.errorhandler(None, InterfaceError, (-1, 'socket not found'))
 
-        sql = sql.encode(self.encoding)
+        if isinstance(sql, str):
+            sql = sql.encode(self.encoding)
 
         if len(sql) + 1 > 0xffffff:
             raise ValueError('Sending query packet is too large')
-        prelude = struct.pack('<i', len(sql)+1) + int2byte(command)
+        prelude = struct.pack('<i', len(sql)+1) + int2bytes(command)
         await self.socket.send_packet(prelude + sql, self.loop)
 
-    async def _caching_sha2_authentication2(self, auth_packet, next_packet):
+    async def _caching_sha2_authentication2(self, auth_packet: bytes, next_packet: int) -> None:
         # https://dev.mysql.com/doc/dev/mysql-server/latest/page_caching_sha2_authentication_exchanges.html
         if auth_packet == b'\x01\x03':   # fast_auth_success
             await self.read_packet()
@@ -247,7 +253,7 @@ class AsyncConnection(Connection):
         else:
             # request_public_key
             data = b'\x02'
-            data = pack_int24(len(data)) + int2byte(next_packet) + data
+            data = pack_int24(len(data)) + int2bytes(next_packet) + data
             next_packet += 2
             await self.socket.send_uncompress_packet(data, self.loop)
             response = await self.read_packet()
@@ -260,20 +266,20 @@ class AsyncConnection(Connection):
             password = self.password.encode(self.encoding) + b'\x00'
             data = cipher.encrypt(_xor(password, self.salt))
 
-        data = pack_int24(len(data)) + int2byte(next_packet) + data
+        data = pack_int24(len(data)) + int2bytes(next_packet) + data
         next_packet += 2
         await self.socket.send_packet(data, self.loop)
 
         await self.read_packet()
 
-    async def _get_server_information(self):
+    async def _get_server_information(self) -> None:
         # https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::Handshake
         i = 0
         data = await self.socket.recv_uncompress_packet(self.loop)
 
         self.protocol_version = byte2int(data[i:i+1])
         i += 1
-        str_end = data.find(int2byte(0), i)
+        str_end = data.find(int2bytes(0), i)
         self.server_version = data[i:str_end].decode('utf-8')
         i = str_end + 1
         self.server_thread_id = struct.unpack('<I', data[i:i+4])
@@ -304,11 +310,12 @@ class AsyncConnection(Connection):
                 rest_salt_len = max(13, salt_len-8)
                 self.salt += data[i:i+rest_salt_len-1]
                 i += rest_salt_len
-            self.auth_plugin_name = data[i:data.find(int2byte(0), i)].decode('utf-8')
+            self.auth_plugin_name = data[i:data.find(int2bytes(0), i)].decode('utf-8')
 
 
-async def connect(*args, **kwargs):
+async def connect(*args: Any, **kwargs: Any) -> AsyncConnection:
     conn = AsyncConnection(*args, **kwargs)
     conn._connect()
     await conn._initialize()
     return conn
+

{cymysql-1.1.1 → cymysql-1.1.2}/cymysql/aio/context.py

@@ -2,20 +2,21 @@
 # https://github.com/aio-libs/aiomysql/blob/master/aiomysql/utils.py
 
 from collections.abc import Coroutine
+from typing import Any
 
 
 class _ContextManager(Coroutine):
 
     __slots__ = ('_coro', '_obj')
 
-    def __init__(self, coro):
+    def __init__(self, coro: Any) -> None:
         self._coro = coro
-        self._obj = None
+        self._obj: Any = None
 
-    def send(self, value):
+    def send(self, value: Any) -> Any:
         return self._coro.send(value)
 
-    def throw(self, typ, val=None, tb=None):
+    def throw(self, typ: Any, val: Any = None, tb: Any = None) -> Any:
         if val is None:
             return self._coro.throw(typ)
         elif tb is None:
@@ -23,41 +24,41 @@ class _ContextManager(Coroutine):
         else:
             return self._coro.throw(typ, val, tb)
 
-    def close(self):
+    def close(self) -> None:
         return self._coro.close()
 
     @property
-    def gi_frame(self):
+    def gi_frame(self) -> Any:
         return self._coro.gi_frame
 
     @property
-    def gi_running(self):
+    def gi_running(self) -> Any:
         return self._coro.gi_running
 
     @property
-    def gi_code(self):
+    def gi_code(self) -> Any:
         return self._coro.gi_code
 
-    def __next__(self):
+    def __next__(self) -> Any:
         return self.send(None)
 
-    def __iter__(self):
+    def __iter__(self) -> Any:
         return self._coro.__await__()
 
-    def __await__(self):
+    def __await__(self) -> Any:
         return self._coro.__await__()
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> Any:
         self._obj = await self._coro
         return self._obj
 
-    async def __aexit__(self, exc_type, exc, tb):
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
         await self._obj.close()
         self._obj = None
 
 
 class _PoolContextManager(_ContextManager):
-    async def __aexit__(self, exc_type, exc, tb):
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
         self._obj.close()
         await self._obj.wait_closed()
         self._obj = None
@@ -67,16 +68,16 @@ class _PoolAcquireContextManager(_ContextManager):
 
     __slots__ = ('_coro', '_conn', '_pool')
 
-    def __init__(self, coro, pool):
+    def __init__(self, coro: Any, pool: Any) -> None:
         self._coro = coro
-        self._conn = None
-        self._pool = pool
+        self._conn: Any = None
+        self._pool: Any = pool
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> Any:
         self._conn = await self._coro
         return self._conn
 
-    async def __aexit__(self, exc_type, exc, tb):
+    async def __aexit__(self, exc_type: Any, exc, tb) -> None:
         try:
             await self._pool.release(self._conn)
         finally:
@@ -101,29 +102,30 @@ class _PoolConnectionContextManager:
 
     __slots__ = ('_pool', '_conn')
 
-    def __init__(self, pool, conn):
-        self._pool = pool
-        self._conn = conn
+    def __init__(self, pool: Any, conn: Any) -> None:
+        self._pool: Any = pool
+        self._conn: Any = conn
 
-    def __enter__(self):
+    def __enter__(self) -> Any:
         assert self._conn
         return self._conn
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         try:
             self._pool.release(self._conn)
         finally:
             self._pool = None
             self._conn = None
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> Any:
         assert not self._conn
         self._conn = await self._pool.acquire()
         return self._conn
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         try:
             await self._pool.release(self._conn)
         finally:
             self._pool = None
             self._conn = None
+