crate 1.0.0.dev1__py3-none-any.whl → 1.0.1__py3-none-any.whl

crate-1.0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+crate/client/__init__.py,sha256=hefR2KxiciqgwZ6dd5fR4wwPHuS3Kgup-gpc7jxFNlU,1344
+crate/client/_pep440.py,sha256=iwY5wopxbgbwsT0ImANrwN3V_ZYQHhSr7lEdVT5dQRM,42
+crate/client/blob.py,sha256=aMo6ZNHGT3Zq_yR3gcpd3CKrJvfqUAhExhKtHUwC5Io,3460
+crate/client/connection.py,sha256=80v9_--YilDAaIQpejf3G_TWGz9iwUkixwHAL66sDm0,8098
+crate/client/converter.py,sha256=Qci0MNcpz1jAnjquG8Ld9LI84_iHVInrv4HMb8r5zzg,4313
+crate/client/cursor.py,sha256=Mlk-TVLzM4zSSr7GxcHK4Mjbt1KQeMfNFNrPBtGjk-c,10741
+crate/client/exceptions.py,sha256=wMyJmOB3RP5kuPeW9f0fEb-1AKZcGSTyIGvN0HqpqUw,2557
+crate/client/http.py,sha256=ddp_VSTcrMNStPjSG0CmdtRUO8dgaQZfNR_ltfs9DxI,22625
+crate/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+crate/testing/layer.py,sha256=jvHRWTRE4Zal211UO0HWPFcbprAcaGB3WyAUDR7BKFQ,13376
+crate/testing/util.py,sha256=BPEZ8DavXwyOTCmOQnP5QjQlapEw3harzKK4w2HOTA4,3264
+crate-1.0.1.dist-info/LICENSE,sha256=s_w3FXmAYQuatqsgvyYLnGyC_13KOqp3W1DUEXO9RpY,10175
+crate-1.0.1.dist-info/METADATA,sha256=nvUareNPApcQKA8AcNrTepTjFvDc72QbjzgHEUCo5Oc,5351
+crate-1.0.1.dist-info/NOTICE,sha256=jfWOHkoZKjNATGXMfgpMJdL38ki_ZZTgR6M9CUUJxrM,1159
+crate-1.0.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+crate-1.0.1.dist-info/top_level.txt,sha256=2wP2HlpxdhgTLMl9ipi168xkm6FMq9_2bf0xGGxF_OI,6
+crate-1.0.1.dist-info/RECORD,,

{crate-1.0.0.dev1.dist-info → crate-1.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

crate/client/test_connection.py

@@ -1,98 +0,0 @@
-import datetime
-
-from urllib3 import Timeout
-
-from .connection import Connection
-from .http import Client
-from crate.client import connect
-from unittest import TestCase
-
-from ..testing.settings import crate_host
-
-
-class ConnectionTest(TestCase):
-
-    def test_connection_mock(self):
-        """
-        For testing purposes it is often useful to replace the client used for
-        communication with the CrateDB server with a stub or mock.
-
-        This can be done by passing an object of the Client class when calling the
-        ``connect`` method.
-        """
-
-        class MyConnectionClient:
-            active_servers = ["localhost:4200"]
-
-            def __init__(self):
-                pass
-
-            def server_infos(self, server):
-                return ("localhost:4200", "my server", "0.42.0")
-
-        connection = connect([crate_host], client=MyConnectionClient())
-        self.assertIsInstance(connection, Connection)
-        self.assertEqual(connection.client.server_infos("foo"), ('localhost:4200', 'my server', '0.42.0'))
-
-    def test_lowest_server_version(self):
-        infos = [(None, None, '0.42.3'),
-                 (None, None, '0.41.8'),
-                 (None, None, 'not a version')]
-
-        client = Client(servers="localhost:4200 localhost:4201 localhost:4202")
-        client.server_infos = lambda server: infos.pop()
-        connection = connect(client=client)
-        self.assertEqual((0, 41, 8), connection.lowest_server_version.version)
-        connection.close()
-
-    def test_invalid_server_version(self):
-        client = Client(servers="localhost:4200")
-        client.server_infos = lambda server: (None, None, "No version")
-        connection = connect(client=client)
-        self.assertEqual((0, 0, 0), connection.lowest_server_version.version)
-        connection.close()
-
-    def test_context_manager(self):
-        with connect('localhost:4200') as conn:
-            pass
-        self.assertEqual(conn._closed, True)
-
-    def test_with_timezone(self):
-        """
-        Verify the cursor objects will return timezone-aware `datetime` objects when requested to.
-        When switching the time zone at runtime on the connection object, only new cursor objects
-        will inherit the new time zone.
-        """
-
-        tz_mst = datetime.timezone(datetime.timedelta(hours=7), name="MST")
-        connection = connect('localhost:4200', time_zone=tz_mst)
-        cursor = connection.cursor()
-        self.assertEqual(cursor.time_zone.tzname(None), "MST")
-        self.assertEqual(cursor.time_zone.utcoffset(None), datetime.timedelta(seconds=25200))
-
-        connection.time_zone = datetime.timezone.utc
-        cursor = connection.cursor()
-        self.assertEqual(cursor.time_zone.tzname(None), "UTC")
-        self.assertEqual(cursor.time_zone.utcoffset(None), datetime.timedelta(0))
-
-    def test_timeout_float(self):
-        """
-        Verify setting the timeout value as a scalar (float) works.
-        """
-        with connect('localhost:4200', timeout=2.42) as conn:
-            self.assertEqual(conn.client._pool_kw["timeout"], 2.42)
-
-    def test_timeout_string(self):
-        """
-        Verify setting the timeout value as a scalar (string) works.
-        """
-        with connect('localhost:4200', timeout="2.42") as conn:
-            self.assertEqual(conn.client._pool_kw["timeout"], 2.42)
-
-    def test_timeout_object(self):
-        """
-        Verify setting the timeout value as a Timeout object works.
-        """
-        timeout = Timeout(connect=2.42, read=0.01)
-        with connect('localhost:4200', timeout=timeout) as conn:
-            self.assertEqual(conn.client._pool_kw["timeout"], timeout)

crate/client/test_cursor.py

@@ -1,341 +0,0 @@
-# -*- coding: utf-8; -*-
-#
-# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
-# license agreements.  See the NOTICE file distributed with this work for
-# additional information regarding copyright ownership.  Crate licenses
-# this file to you under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# However, if you have executed another commercial license agreement
-# with Crate these terms will supersede the license and you may use the
-# software solely pursuant to the terms of the relevant commercial agreement.
-
-import datetime
-from ipaddress import IPv4Address
-from unittest import TestCase
-from unittest.mock import MagicMock
-try:
-    import zoneinfo
-except ImportError:
-    from backports import zoneinfo
-
-import pytz
-
-from crate.client import connect
-from crate.client.converter import DataType, DefaultTypeConverter
-from crate.client.http import Client
-from crate.client.test_util import ClientMocked
-
-
-class CursorTest(TestCase):
-
-    @staticmethod
-    def get_mocked_connection():
-        client = MagicMock(spec=Client)
-        return connect(client=client)
-
-    def test_create_with_timezone_as_datetime_object(self):
-        """
-        Verify the cursor returns timezone-aware `datetime` objects when requested to.
-        Switching the time zone at runtime on the cursor object is possible.
-        Here: Use a `datetime.timezone` instance.
-        """
-
-        connection = self.get_mocked_connection()
-
-        tz_mst = datetime.timezone(datetime.timedelta(hours=7), name="MST")
-        cursor = connection.cursor(time_zone=tz_mst)
-
-        self.assertEqual(cursor.time_zone.tzname(None), "MST")
-        self.assertEqual(cursor.time_zone.utcoffset(None), datetime.timedelta(seconds=25200))
-
-        cursor.time_zone = datetime.timezone.utc
-        self.assertEqual(cursor.time_zone.tzname(None), "UTC")
-        self.assertEqual(cursor.time_zone.utcoffset(None), datetime.timedelta(0))
-
-    def test_create_with_timezone_as_pytz_object(self):
-        """
-        Verify the cursor returns timezone-aware `datetime` objects when requested to.
-        Here: Use a `pytz.timezone` instance.
-        """
-        connection = self.get_mocked_connection()
-        cursor = connection.cursor(time_zone=pytz.timezone('Australia/Sydney'))
-        self.assertEqual(cursor.time_zone.tzname(None), "Australia/Sydney")
-
-        # Apparently, when using `pytz`, the timezone object does not return an offset.
-        # Nevertheless, it works, as demonstrated per doctest in `cursor.txt`.
-        self.assertEqual(cursor.time_zone.utcoffset(None), None)
-
-    def test_create_with_timezone_as_zoneinfo_object(self):
-        """
-        Verify the cursor returns timezone-aware `datetime` objects when requested to.
-        Here: Use a `zoneinfo.ZoneInfo` instance.
-        """
-        connection = self.get_mocked_connection()
-        cursor = connection.cursor(time_zone=zoneinfo.ZoneInfo('Australia/Sydney'))
-        self.assertEqual(cursor.time_zone.key, 'Australia/Sydney')
-
-    def test_create_with_timezone_as_utc_offset_success(self):
-        """
-        Verify the cursor returns timezone-aware `datetime` objects when requested to.
-        Here: Use a UTC offset in string format.
-        """
-        connection = self.get_mocked_connection()
-        cursor = connection.cursor(time_zone="+0530")
-        self.assertEqual(cursor.time_zone.tzname(None), "+0530")
-        self.assertEqual(cursor.time_zone.utcoffset(None), datetime.timedelta(seconds=19800))
-
-        connection = self.get_mocked_connection()
-        cursor = connection.cursor(time_zone="-1145")
-        self.assertEqual(cursor.time_zone.tzname(None), "-1145")
-        self.assertEqual(cursor.time_zone.utcoffset(None), datetime.timedelta(days=-1, seconds=44100))
-
-    def test_create_with_timezone_as_utc_offset_failure(self):
-        """
-        Verify the cursor croaks when trying to create it with invalid UTC offset strings.
-        """
-        connection = self.get_mocked_connection()
-        with self.assertRaises(AssertionError) as ex:
-            connection.cursor(time_zone="foobar")
-        self.assertEqual(str(ex.exception), "Time zone 'foobar' is given in invalid UTC offset format")
-
-        connection = self.get_mocked_connection()
-        with self.assertRaises(ValueError) as ex:
-            connection.cursor(time_zone="+abcd")
-        self.assertEqual(str(ex.exception), "Time zone '+abcd' is given in invalid UTC offset format: "
-                                            "invalid literal for int() with base 10: '+ab'")
-
-    def test_create_with_timezone_connection_cursor_precedence(self):
-        """
-        Verify that the time zone specified on the cursor object instance
-        takes precedence over the one specified on the connection instance.
-        """
-        client = MagicMock(spec=Client)
-        connection = connect(client=client, time_zone=pytz.timezone('Australia/Sydney'))
-        cursor = connection.cursor(time_zone="+0530")
-        self.assertEqual(cursor.time_zone.tzname(None), "+0530")
-        self.assertEqual(cursor.time_zone.utcoffset(None), datetime.timedelta(seconds=19800))
-
-    def test_execute_with_args(self):
-        client = MagicMock(spec=Client)
-        conn = connect(client=client)
-        c = conn.cursor()
-        statement = 'select * from locations where position = ?'
-        c.execute(statement, 1)
-        client.sql.assert_called_once_with(statement, 1, None)
-        conn.close()
-
-    def test_execute_with_bulk_args(self):
-        client = MagicMock(spec=Client)
-        conn = connect(client=client)
-        c = conn.cursor()
-        statement = 'select * from locations where position = ?'
-        c.execute(statement, bulk_parameters=[[1]])
-        client.sql.assert_called_once_with(statement, None, [[1]])
-        conn.close()
-
-    def test_execute_with_converter(self):
-        client = ClientMocked()
-        conn = connect(client=client)
-
-        # Use the set of data type converters from `DefaultTypeConverter`
-        # and add another custom converter.
-        converter = DefaultTypeConverter(
-            {DataType.BIT: lambda value: value is not None and int(value[2:-1], 2) or None})
-
-        # Create a `Cursor` object with converter.
-        c = conn.cursor(converter=converter)
-
-        # Make up a response using CrateDB data types `TEXT`, `IP`,
-        # `TIMESTAMP`, `BIT`.
-        conn.client.set_next_response({
-            "col_types": [4, 5, 11, 25],
-            "cols": ["name", "address", "timestamp", "bitmask"],
-            "rows": [
-                ["foo", "10.10.10.1", 1658167836758, "B'0110'"],
-                [None, None, None, None],
-            ],
-            "rowcount": 1,
-            "duration": 123
-        })
-
-        c.execute("")
-        result = c.fetchall()
-        self.assertEqual(result, [
-            ['foo', IPv4Address('10.10.10.1'), datetime.datetime(2022, 7, 18, 18, 10, 36, 758000), 6],
-            [None, None, None, None],
-        ])
-
-        conn.close()
-
-    def test_execute_with_converter_and_invalid_data_type(self):
-        client = ClientMocked()
-        conn = connect(client=client)
-        converter = DefaultTypeConverter()
-
-        # Create a `Cursor` object with converter.
-        c = conn.cursor(converter=converter)
-
-        # Make up a response using CrateDB data types `TEXT`, `IP`,
-        # `TIMESTAMP`, `BIT`.
-        conn.client.set_next_response({
-            "col_types": [999],
-            "cols": ["foo"],
-            "rows": [
-                ["n/a"],
-            ],
-            "rowcount": 1,
-            "duration": 123
-        })
-
-        c.execute("")
-        with self.assertRaises(ValueError) as ex:
-            c.fetchone()
-        self.assertEqual(ex.exception.args, ("999 is not a valid DataType",))
-
-    def test_execute_array_with_converter(self):
-        client = ClientMocked()
-        conn = connect(client=client)
-        converter = DefaultTypeConverter()
-        cursor = conn.cursor(converter=converter)
-
-        conn.client.set_next_response({
-            "col_types": [4, [100, 5]],
-            "cols": ["name", "address"],
-            "rows": [["foo", ["10.10.10.1", "10.10.10.2"]]],
-            "rowcount": 1,
-            "duration": 123
-        })
-
-        cursor.execute("")
-        result = cursor.fetchone()
-        self.assertEqual(result, [
-            'foo',
-            [IPv4Address('10.10.10.1'), IPv4Address('10.10.10.2')],
-        ])
-
-    def test_execute_array_with_converter_and_invalid_collection_type(self):
-        client = ClientMocked()
-        conn = connect(client=client)
-        converter = DefaultTypeConverter()
-        cursor = conn.cursor(converter=converter)
-
-        # Converting collections only works for `ARRAY`s. (ID=100).
-        # When using `DOUBLE` (ID=6), it should croak.
-        conn.client.set_next_response({
-            "col_types": [4, [6, 5]],
-            "cols": ["name", "address"],
-            "rows": [["foo", ["10.10.10.1", "10.10.10.2"]]],
-            "rowcount": 1,
-            "duration": 123
-        })
-
-        cursor.execute("")
-
-        with self.assertRaises(ValueError) as ex:
-            cursor.fetchone()
-        self.assertEqual(ex.exception.args, ("Data type 6 is not implemented as collection type",))
-
-    def test_execute_nested_array_with_converter(self):
-        client = ClientMocked()
-        conn = connect(client=client)
-        converter = DefaultTypeConverter()
-        cursor = conn.cursor(converter=converter)
-
-        conn.client.set_next_response({
-            "col_types": [4, [100, [100, 5]]],
-            "cols": ["name", "address_buckets"],
-            "rows": [["foo", [["10.10.10.1", "10.10.10.2"], ["10.10.10.3"], [], None]]],
-            "rowcount": 1,
-            "duration": 123
-        })
-
-        cursor.execute("")
-        result = cursor.fetchone()
-        self.assertEqual(result, [
-            'foo',
-            [[IPv4Address('10.10.10.1'), IPv4Address('10.10.10.2')], [IPv4Address('10.10.10.3')], [], None],
-        ])
-
-    def test_executemany_with_converter(self):
-        client = ClientMocked()
-        conn = connect(client=client)
-        converter = DefaultTypeConverter()
-        cursor = conn.cursor(converter=converter)
-
-        conn.client.set_next_response({
-            "col_types": [4, 5],
-            "cols": ["name", "address"],
-            "rows": [["foo", "10.10.10.1"]],
-            "rowcount": 1,
-            "duration": 123
-        })
-
-        cursor.executemany("", [])
-        result = cursor.fetchall()
-
-        # ``executemany()`` is not intended to be used with statements returning result
-        # sets. The result will always be empty.
-        self.assertEqual(result, [])
-
-    def test_execute_with_timezone(self):
-        client = ClientMocked()
-        conn = connect(client=client)
-
-        # Create a `Cursor` object with `time_zone`.
-        tz_mst = datetime.timezone(datetime.timedelta(hours=7), name="MST")
-        c = conn.cursor(time_zone=tz_mst)
-
-        # Make up a response using CrateDB data type `TIMESTAMP`.
-        conn.client.set_next_response({
-            "col_types": [4, 11],
-            "cols": ["name", "timestamp"],
-            "rows": [
-                ["foo", 1658167836758],
-                [None, None],
-            ],
-        })
-
-        # Run execution and verify the returned `datetime` object is timezone-aware,
-        # using the designated timezone object.
-        c.execute("")
-        result = c.fetchall()
-        self.assertEqual(result, [
-            [
-                'foo',
-                datetime.datetime(2022, 7, 19, 1, 10, 36, 758000,
-                                  tzinfo=datetime.timezone(datetime.timedelta(seconds=25200), 'MST')),
-            ],
-            [
-                None,
-                None,
-            ],
-        ])
-        self.assertEqual(result[0][1].tzname(), "MST")
-
-        # Change timezone and verify the returned `datetime` object is using it.
-        c.time_zone = datetime.timezone.utc
-        c.execute("")
-        result = c.fetchall()
-        self.assertEqual(result, [
-            [
-                'foo',
-                datetime.datetime(2022, 7, 18, 18, 10, 36, 758000, tzinfo=datetime.timezone.utc),
-            ],
-            [
-                None,
-                None,
-            ],
-        ])
-        self.assertEqual(result[0][1].tzname(), "UTC")
-
-        conn.close()

crate/client/test_exceptions.py

@@ -1,14 +0,0 @@
-import unittest
-
-from crate.client import Error
-
-
-class ErrorTestCase(unittest.TestCase):
-
-    def test_error_with_msg(self):
-        err = Error("foo")
-        self.assertEqual(str(err), "foo")
-
-    def test_error_with_error_trace(self):
-        err = Error("foo", error_trace="### TRACE ###")
-        self.assertEqual(str(err), "foo\n### TRACE ###")