repo_id stringclasses 409
values | prefix large_stringlengths 34 36.3k | target large_stringlengths 1 498 | assertion_type stringclasses 31
values | difficulty stringclasses 8
values | test_file stringlengths 10 121 | test_function stringlengths 1 104 | test_class stringlengths 0 51 | lineno int32 2 11.3k | commit_idx int32 |
|---|---|---|---|---|---|---|---|---|---|
XKNX/xknx | from pathlib import Path
import pytest
from xknx.exceptions.exception import InvalidSecureConfiguration
from xknx.secure.keyring import (
InterfaceType,
Keyring,
XMLDevice,
XMLInterface,
sync_load_keyring,
verify_keyring_signature,
)
from xknx.telegram import GroupAddress, IndividualAddress
c... | [] | assert | collection | test/secure_tests/keyring_test.py | test_load_data_secure_ip | TestKeyRing | 105 | null |
XKNX/xknx | import pytest
from xknx.cemi import (
CEMIFlags,
CEMIFrame,
CEMILData,
CEMIMessageCode,
CEMIMPropReadRequest,
CEMIMPropReadResponse,
CEMIMPropWriteRequest,
CEMIMPropWriteResponse,
)
from xknx.cemi.const import CEMIErrorCode
from xknx.exceptions import ConversionError, CouldNotParseCEMI,... | 9 | assert | numeric_literal | test/cemi_tests/cemi_frame_test.py | test_valid_read_con | 315 | null | |
XKNX/xknx | import pytest
from xknx.exceptions import CouldNotParseKNXIP
from xknx.knxip import (
HPAI,
ConnectRequest,
ConnectRequestInformation,
ConnectRequestType,
KNXIPFrame,
TunnellingLayer,
)
from xknx.telegram import IndividualAddress
class TestKNXIPConnectRequest:
def test_tunnel_connect_requ... | raw | assert | variable | test/knxip_tests/connect_request_test.py | test_tunnel_connect_request | TestKNXIPConnectRequest | 51 | null |
XKNX/xknx | from unittest.mock import Mock, patch
from xknx import XKNX
from xknx.devices import Light
from xknx.devices.light import ColorTemperatureType
from xknx.dpt import DPTArray, DPTBinary
from xknx.dpt.dpt_242 import XYYColor
from xknx.telegram import GroupAddress, Telegram
from xknx.telegram.apci import GroupValueRead, G... | 3 | assert | numeric_literal | test/devices_tests/light_test.py | test_set_individual_color | TestLight | 793 | null |
XKNX/xknx | import asyncio
from typing import Any
from unittest.mock import Mock, create_autospec, patch
import pytest
from xknx import XKNX
from xknx.exceptions import XKNXException
from xknx.io import GatewayScanFilter, GatewayScanner
from xknx.io.gateway_scanner import GatewayDescriptor
from xknx.io.transport import UDPTransp... | [] | assert | collection | test/io_tests/gateway_scanner_test.py | test_scan_timeout | TestGatewayScanner | 363 | null |
XKNX/xknx | import pytest
from xknx.exceptions import ConversionError, CouldNotParseKNXIP
from xknx.knxip import HPAI, HostProtocol
class TestKNXIPHPAI:
def test_hpai_udp(self) -> None:
"""Test parsing and streaming HPAI KNX/IP fragment."""
raw = bytes((0x08, 0x01, 0xC0, 0xA8, 0x2A, 0x01, 0x84, 0x95))
... | raw | assert | variable | test/knxip_tests/hpai_test.py | test_hpai_udp | TestKNXIPHPAI | 24 | null |
XKNX/xknx | import datetime
import pytest
from xknx import XKNX
from xknx.devices import Weather
from xknx.devices.weather import WeatherCondition
from xknx.dpt import DPTArray, DPTBinary
from xknx.telegram import GroupAddress, Telegram
from xknx.telegram.apci import GroupValueWrite
class TestWeather:
async def test_wind_b... | "°" | assert | string_literal | test/devices_tests/weather_test.py | test_wind_bearing | TestWeather | 164 | null |
XKNX/xknx | import datetime
from typing import Any
import pytest
from xknx.dpt import DPTArray, DPTDate
from xknx.dpt.dpt_11 import KNXDate
from xknx.exceptions import ConversionError, CouldNotParseTelegram
class TestKNXDate:
@pytest.mark.parametrize(
("date", "value"),
[
(datetime.date(1990, 1,... | date | assert | variable | test/dpt_tests/dpt_11_date_test.py | test_as_date | TestKNXDate | 58 | null |
XKNX/xknx | from typing import Any
import pytest
from xknx.dpt import DPTArray, DPTBinary, DPTEnumData
from xknx.dpt.dpt_1 import (
Ack,
Alarm,
BinaryValue,
Bool,
ConsumerProducer,
DayNight,
DimSendStyle,
DPT1BitEnum,
DPTAck,
DPTAlarm,
DPTBinaryValue,
DPTBool,
DPTConsumerProduc... | DPTBinary(1) | assert | func_call | test/dpt_tests/dpt_1_test.py | test_to_knx | TestDPT1 | 111 | null |
XKNX/xknx | import pytest
from xknx.dpt import DPTArray, DPTBinary
from xknx.exceptions import ConversionError
class TestDPT:
def test_compare_binary(self) -> None:
"""Test comparison of DPTBinary objects."""
assert DPTBinary(0) == DPTBinary(0)
assert DPTBinary(0) == DPTBinary(False)
assert D... | DPTBinary(2) | assert | func_call | test/dpt_tests/payload_test.py | test_compare_binary | TestDPT | 17 | null |
XKNX/xknx | import pytest
from xknx.dpt import DPTArray, DPTBinary
from xknx.exceptions import ConversionError
class TestDPT:
def test_compare_array(self) -> None:
"""Test comparison of DPTArray objects."""
assert DPTArray(()) == DPTArray(())
assert DPTArray([1]) == | DPTArray((1,)) | assert | func_call | test/dpt_tests/payload_test.py | test_compare_array | TestDPT | 25 | null |
XKNX/xknx | import datetime
from typing import Any
import pytest
from xknx.dpt import DPTArray, DPTBinary, DPTTime
from xknx.dpt.dpt_10 import KNXDay, KNXTime
from xknx.exceptions import ConversionError, CouldNotParseTelegram
class TestKNXTime:
@pytest.mark.parametrize(
("data", "value"),
[
(
... | value | assert | variable | test/dpt_tests/dpt_10_time_test.py | test_dict | TestKNXTime | 35 | null |
XKNX/xknx | from unittest.mock import AsyncMock, Mock, patch
import pytest
from xknx import XKNX
from xknx.devices import BinarySensor, Device, Light, Switch
from xknx.telegram import GroupAddress
class TestDevices:
def test_len(self) -> None:
"""Test len() function."""
xknx = XKNX()
assert len(xknx... | 1 | assert | numeric_literal | test/devices_tests/devices_test.py | test_len | TestDevices | 92 | null |
XKNX/xknx | import asyncio
from unittest.mock import AsyncMock, Mock
import pytest
from xknx import XKNX
from xknx.core import XknxConnectionState
from xknx.core.task_registry import Task
from ..conftest import EventLoopClockAdvancer
class TestTaskRegistry:
@pytest.mark.parametrize("target", ["async", "sync"])
async d... | 1 | assert | numeric_literal | test/core_tests/task_registry_test.py | test_start_task | TestTaskRegistry | 29 | null |
XKNX/xknx | from typing import Any
import pytest
from xknx.dpt import (
DPTArray,
DPTColorRGB,
DPTColorRGBW,
DPTColorXYY,
RGBColor,
RGBWColor,
XYYColor,
)
from xknx.exceptions import ConversionError, CouldNotParseTelegram
class TestRGBColor:
@pytest.mark.parametrize(
("data", "value"),
... | value | assert | variable | test/dpt_tests/dpt_color_test.py | test_dict | TestRGBColor | 33 | null |
XKNX/xknx | import asyncio
from unittest.mock import AsyncMock, MagicMock, Mock, call, patch
import pytest
from xknx import XKNX
from xknx.dpt import DPTArray, DPTBinary
from xknx.exceptions import CommunicationError, CouldNotParseTelegram
from xknx.telegram import AddressFilter, Telegram, TelegramDirection
from xknx.telegram.ad... | None | assert | none_literal | test/core_tests/telegram_queue_test.py | test_callback_decoded_telegram_data | TestTelegramQueue | 236 | null |
dask-contrib/dask-sql | from datetime import timedelta
import numpy as np
import pandas as pd
import pytest
from dask_sql._datafusion_lib import SqlTypeName
from dask_sql.mappings import python_to_sql_type, similar_type, sql_to_python_value
def test_python_to_sql():
assert str(python_to_sql_type(np.dtype("int32"))) == "INTEGER"
as... | "TIMESTAMP" | assert | string_literal | tests/unit/test_mapping.py | test_python_to_sql | 13 | null | |
dask-contrib/dask-sql | from datetime import datetime
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from tests.utils import assert_eq
def test_random(c):
query_with_seed = """
SELECT
RAND(0) AS "0",
RAND_INTEGER(0, 10) AS "1"
"""
result_df =... | "float64" | assert | string_literal | tests/integration/test_rex.py | test_random | 158 | null | |
dask-contrib/dask-sql | import pandas as pd
import pytest
from dask import dataframe as dd
from dask.utils_test import hlg_layer
from dask_sql.physical.utils.filter import attempt_predicate_pushdown
from dask_sql.utils import Pluggable, is_frame
from tests.utils import skipif_dask_expr_enabled
def test_add_plugin():
PluginTest1.add_plug... | "value" | assert | string_literal | tests/unit/test_utils.py | test_add_plugin | 36 | null | |
dask-contrib/dask-sql | import sqlite3
import pytest
def engine():
yield sqlite3.connect(":memory:")
def test_sort(assert_query_gives_same_result):
asse | """ SELECT user_id, b FROM df1 ORDER BY b NULLS FIRST, user_id DESC NULLS FIRST """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_sort | 57 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT CASE WHEN user_id <> 3 THEN 4 ELSE 2 END FROM df2 """) | assert_* | string_literal | tests/integration/test_postgres.py | test_select | 115 | null | |
dask-contrib/dask-sql | import os
import pickle
import sys
import joblib
import pandas as pd
import pytest
from packaging.version import parse as parseVersion
from tests.utils import assert_eq
sklearn = pytest.importorskip("sklearn")
SKLEARN_EQ_140 = parseVersion(sklearn.__version__) == parseVersion("1.4.0")
def check_trained_model(c, mo... | KeyError) | pytest.raises | variable | tests/integration/test_model.py | test_wrong_training_or_prediction | 300 | null | |
dask-contrib/dask-sql | import sqlite3
from datetime import datetime, timedelta
import dask.config
import numpy as np
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.utils import ParsingException
from tests.utils import assert_eq, convert_nullable_columns, skipif_dask_expr_enabled
def eq_sqlite(sql, **dfs):
... | df[["val"]]) | assert_* | complex_expr | tests/integration/test_compatibility.py | test_query_case_sensitivity | 1,073 | null | |
dask-contrib/dask-sql | import datetime
import operator
from unittest.mock import MagicMock
import dask.dataframe as dd
import numpy as np
import pandas as pd
import dask_sql.physical.rex.core.call as call
from tests.utils import assert_eq
df1 = dd.from_pandas(pd.DataFrame({"a": [1, 2, 3]}), npartitions=1)
df2 = dd.from_pandas(pd.DataFrame... | "test" | assert | string_literal | tests/unit/test_call.py | test_operation | 26 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT * FROM df1 """) | assert_* | string_literal | tests/integration/test_postgres.py | test_select | 58 | null | |
dask-contrib/dask-sql | import numpy as np
import pytest
from tests.utils import assert_eq
def get_system_sample(df, fraction, seed):
random_state = np.random.RandomState(seed)
random_choice = random_state.choice(
[True, False],
size=df.npartitions,
replace=True,
p=[fraction, 1 - fraction],
)
... | get_system_sample(ddf, 0.20, 11)) | assert_* | func_call | tests/integration/test_sample.py | test_sample | 33 | null | |
dask-contrib/dask-sql | from datetime import timedelta
import numpy as np
import pandas as pd
import pytest
from dask_sql._datafusion_lib import SqlTypeName
from dask_sql.mappings import python_to_sql_type, similar_type, sql_to_python_value
def test_python_to_sql():
assert str(python_to_sql_type(np.dtype("int32"))) == "INTEGER"
ass... | "TIMESTAMP_WITH_LOCAL_TIME_ZONE" | assert | string_literal | tests/unit/test_mapping.py | test_python_to_sql | 14 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
def app_client():
c = Context()
c.sql("SELECT 1 + 1").compute()
_init_app(app, c)
... | 100 | assert | numeric_literal | tests/integration/test_server.py | get_result_or_error | 52 | null | |
dask-contrib/dask-sql | import datetime
import operator
from unittest.mock import MagicMock
import dask.dataframe as dd
import numpy as np
import pandas as pd
import dask_sql.physical.rex.core.call as call
from tests.utils import assert_eq
df1 = dd.from_pandas(pd.DataFrame({"a": [1, 2, 3]}), npartitions=1)
df2 = dd.from_pandas(pd.DataFrame... | pd.Series([1, 2, 3])) | assert_* | func_call | tests/unit/test_call.py | test_math_operations | 157 | null | |
dask-contrib/dask-sql | import os
import pickle
import sys
import joblib
import pandas as pd
import pytest
from packaging.version import parse as parseVersion
from tests.utils import assert_eq
sklearn = pytest.importorskip("sklearn")
SKLEARN_EQ_140 = parseVersion(sklearn.__version__) == parseVersion("1.4.0")
def check_trained_model(c, mo... | RuntimeError) | pytest.raises | variable | tests/integration/test_model.py | test_replace_and_error | 397 | null | |
dask-contrib/dask-sql | from datetime import timedelta
import numpy as np
import pandas as pd
import pytest
from dask_sql._datafusion_lib import SqlTypeName
from dask_sql.mappings import python_to_sql_type, similar_type, sql_to_python_value
def test_sql_to_python():
assert sql_to_python_value(SqlTypeName.VARCHAR, "test 123") == | "test 123" | assert | string_literal | tests/unit/test_mapping.py | test_sql_to_python | 30 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT a FROM df1 WHERE user_id = 3 AND a > 0.5 """) | assert_* | string_literal | tests/integration/test_postgres.py | test_filter | 193 | null | |
dask-contrib/dask-sql | import os
import sys
import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql import Context
from tests.utils import assert_eq
DEFAULT_INT_TYPE = "INTEGER" if sys.platform == "win32" else "BIGINT"
@pytest.mark.parametrize(
"gpu",
[
False,
pytest.param(
True,
... | data_frame) | assert_* | variable | tests/unit/test_context.py | test_sql | 59 | null | |
dask-contrib/dask-sql | from dask_sql.datacontainer import ColumnContainer
def test_cc_init():
c = ColumnContainer(["a", "b", "c"])
assert c.columns == ["a", "b", "c"]
assert c.mapping() == | [("a", "a"), ("b", "b"), ("c", "c")] | assert | collection | tests/unit/test_datacontainer.py | test_cc_init | 8 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from dask_sql.server.presto_jdbc import create_meta_data
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
schema = "a_schema"
table = "a_table"... | result | assert | variable | tests/integration/test_jdbc.py | assert_result | 118 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT POSITION('a' IN s), POSITION('ZL' IN s) FROM df3 """) | assert_* | string_literal | tests/integration/test_postgres.py | test_string_position | 266 | null | |
dask-contrib/dask-sql | from dask_sql.datacontainer import ColumnContainer
def test_cc_rename():
c = ColumnContainer(["a", "b", "c"])
c2 = c.rename({"a": "A", "b": "a"})
assert c2.columns == | ["A", "a", "c"] | assert | collection | tests/unit/test_datacontainer.py | test_cc_rename | 32 | null | |
dask-contrib/dask-sql | from collections.abc import Sequence
import dask
import dask.array as da
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.array.utils import assert_eq as assert_eq_ar
from dask.dataframe.utils import assert_eq as assert_eq_df
from sklearn.base import clone
from sklearn.decompo... | r) | assert_* | variable | tests/unit/test_ml_utils.py | _assert_eq | 103 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
import dask_sql
from tests.utils import assert_eq
@pytest.mark.parametrize(
"gpu",
[
False,
pytest.param(True, marks=pytest.mark.gpu),
],
)
def test_cluster_memory(client, c, df, gpu):
client.publish_dataset(df=dd.from_panda... | return_df) | assert_* | variable | tests/integration/test_create.py | test_cluster_memory | 62 | null | |
dask-contrib/dask-sql | import sqlite3
from datetime import datetime, timedelta
import dask.config
import numpy as np
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.utils import ParsingException
from tests.utils import assert_eq, convert_nullable_columns, skipif_dask_expr_enabled
def eq_sqlite(sql, **dfs):
... | expected) | assert_* | variable | tests/integration/test_compatibility.py | test_column_name_starting_with_number | 1,089 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT d FROM df2 WHERE (d NOT LIKE '%%c') IS NULL """) | assert_* | string_literal | tests/integration/test_postgres.py | test_filter | 213 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from dask_sql.server.presto_jdbc import create_meta_data
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
schema = "a_schema"
table = "a_table"... | col_len | assert | variable | tests/integration/test_jdbc.py | assert_result | 121 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.datacontainer import Statistics
from dask_sql.physical.utils.statistics import parquet_statistics
from tests.utils import skipif_dask_expr_enabled
pytestmark = skipif_dask_expr_enabled(
reason="Parquet statist... | Statistics(row_count=15) | assert | func_call | tests/unit/test_statistics.py | test_dc_statistics | 66 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import numpy as np
import pytest
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
@pytest.mark.xfail(reason="WIP DataFusion")
def test_table_schema(c, df):
original_df = c.sql("SELECT * FROM df")
assert_eq(original_df, c.sql("SELECT * FROM root.df"))
... | c.sql("SELECT * FROM bar")) | assert_* | func_call | tests/integration/test_schema.py | test_table_schema | 22 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql.context import Context
from tests.utils import assert_eq
def check_sort_topk(df, layer, contains=True):
if dd._dask_expr_enabled():
from dask_expr._reductions import NLargest, NSmallest
if layer == "nsmallest":
... | pd.DataFrame({"a": [float("nan"), 1] * 5, "b": [1] * 10, "c": ["a"] * 10})) | assert_* | func_call | tests/integration/test_sort.py | test_sort_topk | 428 | null | |
dask-contrib/dask-sql | from dask_sql.datacontainer import ColumnContainer
def test_cc_init():
c = ColumnContainer(["a", "b", "c"])
assert c.columns == | ["a", "b", "c"] | assert | collection | tests/unit/test_datacontainer.py | test_cc_init | 7 | null | |
dask-contrib/dask-sql | from collections.abc import Sequence
import dask
import dask.array as da
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.array.utils import assert_eq as assert_eq_ar
from dask.dataframe.utils import assert_eq as assert_eq_df
from sklearn.base import clone
from sklearn.decompo... | expected | assert | variable | tests/unit/test_ml_utils.py | test_parallelpostfit_basic | 159 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT d FROM df2 WHERE d NOT LIKE '%%c' """) | assert_* | string_literal | tests/integration/test_postgres.py | test_filter | 203 | null | |
dask-contrib/dask-sql | from datetime import datetime
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from tests.utils import assert_eq
def test_random(c):
query_with_seed = """
SELECT
RAND(0) AS "0",
RAND_INTEGER(0, 10) AS "1"
"""
result_df =... | "Int64" | assert | string_literal | tests/integration/test_rex.py | test_random | 159 | null | |
dask-contrib/dask-sql | from datetime import timedelta
import numpy as np
import pandas as pd
import pytest
from dask_sql._datafusion_lib import SqlTypeName
from dask_sql.mappings import python_to_sql_type, similar_type, sql_to_python_value
def test_sql_to_python():
assert sql_to_python_value(SqlTypeName.VARCHAR, "test 123") == "test 1... | 653 | assert | numeric_literal | tests/unit/test_mapping.py | test_sql_to_python | 32 | null | |
dask-contrib/dask-sql | import dask
import dask.dataframe as dd
import pandas as pd
import pytest
from dask.utils_test import hlg_layer
from packaging.version import parse as parseVersion
from tests.utils import assert_eq, skipif_dask_expr_enabled
DASK_GT_2022_4_2 = parseVersion(dask.__version__) >= parseVersion("2022.4.2")
@pytest.mark.pa... | expected_df) | assert_* | variable | tests/integration/test_filter.py | test_predicate_pushdown | 233 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT c, d FROM df2 ORDER BY c NULLS FIRST, d NULLS FIRST, user_id NULLS FIRST LIMIT 10 OFFSET 20 """) | assert_* | string_literal | tests/integration/test_postgres.py | test_limit | 156 | null | |
dask-contrib/dask-sql | import numpy as np
import pandas as pd
import pytest
from dask.dataframe.optimize import optimize_dataframe_getitem
from dask.utils_test import hlg_layer
from dask_sql.utils import ParsingException
from tests.utils import assert_eq, skipif_dask_expr_enabled
def test_singular_column_selection(c):
df = pd.DataFrame... | single_col_result["b"]) | assert_* | complex_expr | tests/integration/test_select.py | test_singular_column_selection | 248 | null | |
dask-contrib/dask-sql | from unittest.mock import MagicMock, patch
import pytest
from dask import config as dask_config
from prompt_toolkit.application import create_app_session
from prompt_toolkit.input import create_pipe_input
from prompt_toolkit.output import DummyOutput
from prompt_toolkit.shortcuts import PromptSession
from dask_sql._c... | "Quitting dask-sql ...\n" | assert | string_literal | tests/integration/test_cmd.py | test_quit | 135 | null | |
dask-contrib/dask-sql | from datetime import datetime
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from tests.utils import assert_eq
def test_case(c, df):
result_df = c.sql(
"""
SELECT
(CASE WHEN a = 3 THEN 1 END) AS "S1",
(CASE WHEN a > 0 THEN a ELSE 1 END) AS "S2",
... | expected_df) | assert_* | variable | tests/integration/test_rex.py | test_case | 54 | null | |
dask-contrib/dask-sql | import os
import sys
from unittest import mock
import dask.dataframe as dd
import pandas as pd
import pytest
import yaml
from dask import config as dask_config
import dask_sql # noqa: F401
from dask_sql import Context
from tests.utils import skipif_dask_expr_enabled
@pytest.mark.skipif(
sys.version_info < (3, 1... | explain_string | assert | variable | tests/unit/test_config.py | test_dynamic_partition_pruning | 143 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT c, d FROM df2 ORDER BY c NULLS FIRST, d NULLS FIRST, user_id NULLS FIRST """) | assert_* | string_literal | tests/integration/test_postgres.py | test_sort | 145 | null | |
dask-contrib/dask-sql | import itertools
import operator
import sys
import dask.dataframe as dd
import numpy as np
import pytest
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
def test_custom_function(c, df):
def f(x):
return x**2
c.register_function(f, "f", [("x", np.float64)], np.float64)
... | df[["a"]] ** 2) | assert_* | complex_expr | tests/integration/test_function.py | test_custom_function | 21 | null | |
dask-contrib/dask-sql | import numpy as np
import pandas as pd
import pytest
from dask.dataframe.optimize import optimize_dataframe_getitem
from dask.utils_test import hlg_layer
from dask_sql.utils import ParsingException
from tests.utils import assert_eq, skipif_dask_expr_enabled
def test_select(c, df):
result_df = c.sql("SELECT * FROM... | df) | assert_* | variable | tests/integration/test_select.py | test_select | 14 | null | |
dask-contrib/dask-sql | import numpy as np
import pytest
from tests.utils import assert_eq
def get_system_sample(df, fraction, seed):
random_state = np.random.RandomState(seed)
random_choice = random_state.choice(
[True, False],
size=df.npartitions,
replace=True,
p=[fraction, 1 - fraction],
)
... | get_system_sample(ddf, 0.00001, 10)) | assert_* | func_call | tests/integration/test_sample.py | test_sample | 41 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from dask_sql.server.presto_jdbc import create_meta_data
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
schema = "a_schema"
table = "a_table"... | 4) | assert_* | numeric_literal | tests/integration/test_jdbc.py | test_jdbc_has_table | 85 | null | |
dask-contrib/dask-sql | import itertools
import operator
import sys
import dask.dataframe as dd
import numpy as np
import pytest
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
def test_reregistration(c):
def f(x):
return x**2
# The same is fine
c.register_function(f, "f", [("x", np.float6... | ValueError) | pytest.raises | variable | tests/integration/test_function.py | test_reregistration | 192 | null | |
dask-contrib/dask-sql | import os
import tempfile
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.datasets import timeseries as dd_timeseries
from dask.distributed import Client
from tests.utils import assert_eq, convert_nullable_columns
DISTRIBUTED_TESTS = os.getenv("DASK_SQL_DISTRIBUTED_TESTS", ... | dask_result) | assert_* | variable | tests/integration/fixtures.py | _assert_query_gives_same_result | 344 | null | |
dask-contrib/dask-sql | from contextlib import nullcontext
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.utils_test import hlg_layer
from dask_sql import Context
from dask_sql.datacontainer import Statistics
from tests.utils import assert_eq, skipif_dask_expr_enabled
@pytest.mark.filterwarnings(... | 0 | assert | numeric_literal | tests/integration/test_join.py | test_intersect | 399 | null | |
dask-contrib/dask-sql | from dask_sql.datacontainer import ColumnContainer
def test_cc_init():
c = ColumnContainer(["a", "b", "c"])
assert c.columns == ["a", "b", "c"]
assert c.mapping() == [("a", "a"), ("b", "b"), ("c", "c")]
c = ColumnContainer(["a", "b", "c"], {"a": "1", "b": "2", "c": "3"})
assert c.columns == ["a"... | [("a", "1"), ("b", "2"), ("c", "3")] | assert | collection | tests/unit/test_datacontainer.py | test_cc_init | 13 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql import Context
from tests.utils import assert_eq
fugue_sql = pytest.importorskip("fugue_sql")
from dask_sql.integrations.fugue import fsql_dask # noqa: E402
def test_fugue_workflow(client):
dag = fugue_sql.FugueSQLWorkflow()
df = d... | pd.DataFrame({"a": [1], "b": ["world"]})) | assert_* | func_call | tests/integration/test_fugue.py | test_fugue_workflow | 20 | null | |
dask-contrib/dask-sql | from datetime import timedelta
import numpy as np
import pandas as pd
import pytest
from dask_sql._datafusion_lib import SqlTypeName
from dask_sql.mappings import python_to_sql_type, similar_type, sql_to_python_value
def test_sql_to_python():
assert sql_to_python_value(SqlTypeName.VARCHAR, "test 123") == "test 1... | np.int64 | assert | complex_expr | tests/unit/test_mapping.py | test_sql_to_python | 31 | null | |
dask-contrib/dask-sql | import sqlite3
import pytest
def engine():
yield sqlite3.connect(":memory:")
def test_select(assert_query_gives_same_result):
assert_query_gives_same_result(
"""
SELECT * FROM df1
"""
)
assert_query_gives_same_result(
"""
SELECT df1.user_id + 5 AS user_id, 2 * df1... | """ SELECT 1 AS I, -5.34344 AS F, 'öäll' AS S """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_select | 30 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql import Context
from tests.utils import assert_eq
fugue_sql = pytest.importorskip("fugue_sql")
from dask_sql.integrations.fugue import fsql_dask # noqa: E402
@pytest.mark.flaky(reruns=4, condition="sys.version_info < (3, 10)")
def test_dask... | c.schema[c.schema_name].tables | assert | complex_expr | tests/integration/test_fugue.py | test_dask_fsql | 82 | null | |
dask-contrib/dask-sql | import os
import sys
from unittest import mock
import dask.dataframe as dd
import pandas as pd
import pytest
import yaml
from dask import config as dask_config
import dask_sql # noqa: F401
from dask_sql import Context
from tests.utils import skipif_dask_expr_enabled
def test_dask_setconfig():
dask_config.set({"... | {"bar": 1} | assert | collection | tests/unit/test_config.py | test_dask_setconfig | 102 | null | |
dask-contrib/dask-sql | from collections.abc import Sequence
import dask
import dask.array as da
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.array.utils import assert_eq as assert_eq_ar
from dask.dataframe.utils import assert_eq as assert_eq_df
from sklearn.base import clone
from sklearn.decompo... | right_attrs2 | assert | variable | tests/unit/test_ml_utils.py | assert_estimator_equal | 139 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
def app_client():
c = Context()
c.sql("SELECT 1 + 1").compute()
_init_app(app, c)
... | 1 | assert | numeric_literal | tests/integration/test_server.py | test_nullable_int_table | 233 | null | |
dask-contrib/dask-sql | import os
import sys
from unittest import mock
import dask.dataframe as dd
import pandas as pd
import pytest
import yaml
from dask import config as dask_config
import dask_sql # noqa: F401
from dask_sql import Context
from tests.utils import skipif_dask_expr_enabled
def test_dask_setconfig():
dask_config.set({"... | {"bar": 1, "baz": "2"} | assert | collection | tests/unit/test_config.py | test_dask_setconfig | 101 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | """ SELECT user_id, b FROM df1 ORDER BY b NULLS FIRST, user_id DESC NULLS FIRST """) | assert_* | string_literal | tests/integration/test_postgres.py | test_sort | 136 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
def app_client():
c = Context()
c.sql("SELECT 1 + 1").compute()
_init_app(app, c)
... | 700 | assert | numeric_literal | tests/integration/test_server.py | test_add_and_query | 158 | null | |
dask-contrib/dask-sql | from contextlib import nullcontext
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.utils_test import hlg_layer
from dask_sql import Context
from dask_sql.datacontainer import Statistics
from tests.utils import assert_eq, skipif_dask_expr_enabled
def check_broadcast_join(df,... | val | assert | variable | tests/integration/test_join.py | check_broadcast_join | 549 | null | |
dask-contrib/dask-sql | import itertools
import operator
import sys
import dask.dataframe as dd
import numpy as np
import pytest
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
def test_aggregate_function(c):
fagg = dd.Aggregation("f", lambda x: x.sum(), lambda x: x.sum())
c.register_aggregation(fagg, ... | return_df["S"]) | assert_* | complex_expr | tests/integration/test_function.py | test_aggregate_function | 177 | null | |
dask-contrib/dask-sql | from contextlib import nullcontext
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.utils_test import hlg_layer
from dask_sql import Context
from dask_sql.datacontainer import Statistics
from tests.utils import assert_eq, skipif_dask_expr_enabled
@pytest.mark.filterwarnings(... | 3 | assert | numeric_literal | tests/integration/test_join.py | test_intersect | 384 | null | |
dask-contrib/dask-sql | import numpy as np
import pandas as pd
import pytest
from dask.dataframe.optimize import optimize_dataframe_getitem
from dask.utils_test import hlg_layer
from dask_sql.utils import ParsingException
from tests.utils import assert_eq, skipif_dask_expr_enabled
@pytest.mark.parametrize(
"input_cols",
[
["... | len(input_cols)) | assert_* | func_call | tests/integration/test_select.py | test_multiple_column_projection | 267 | null | |
dask-contrib/dask-sql | import os
import sys
from unittest import mock
import dask.dataframe as dd
import pandas as pd
import pytest
import yaml
from dask import config as dask_config
import dask_sql # noqa: F401
from dask_sql import Context
from tests.utils import skipif_dask_expr_enabled
def test_env_variable():
with mock.patch.dict... | 200 | assert | numeric_literal | tests/unit/test_config.py | test_env_variable | 36 | null | |
dask-contrib/dask-sql | from unittest.mock import MagicMock, patch
import pytest
from dask import config as dask_config
from prompt_toolkit.application import create_app_session
from prompt_toolkit.input import create_pipe_input
from prompt_toolkit.output import DummyOutput
from prompt_toolkit.shortcuts import PromptSession
from dask_sql._c... | captured.out | assert | complex_expr | tests/integration/test_cmd.py | test_meta_commands | 72 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
def app_client():
c = Context()
c.sql("SELECT 1 + 1").compute()
_init_app(app, c)
... | 405 | assert | numeric_literal | tests/integration/test_server.py | test_routes | 61 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import numpy as np
import pytest
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
def test_create_schema(c):
c.sql("CREATE SCHEMA new_schema")
assert "new_schema" in | c.schema | assert | complex_expr | tests/integration/test_schema.py | test_create_schema | 74 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql.context import Context
from tests.utils import assert_eq
def check_sort_topk(df, layer, contains=True):
if dd._dask_expr_enabled():
from dask_expr._reductions import NLargest, NSmallest
if layer == "nsmallest":
... | pd.DataFrame({"a": [1.0] * 10, "b": [3] * 10, "c": ["c"] * 10})) | assert_* | func_call | tests/integration/test_sort.py | test_sort_topk | 416 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.datacontainer import Statistics
from dask_sql.physical.utils.statistics import parquet_statistics
from tests.utils import skipif_dask_expr_enabled
pytestmark = skipif_dask_expr_enabled(
reason="Parquet statist... | parquet_ddf.npartitions | assert | complex_expr | tests/unit/test_statistics.py | test_parquet_statistics | 23 | null | |
dask-contrib/dask-sql | from time import sleep
import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.server.app import _init_app, app
from dask_sql.server.presto_jdbc import create_meta_data
from tests.integration.fixtures import DISTRIBUTED_TESTS
pytest.importorskip("requests")
schema = "a_schema"
table = "a_table"... | context_result | assert | variable | tests/integration/test_jdbc.py | test_jdbc_has_columns | 114 | null | |
dask-contrib/dask-sql | import sys
import pytest
pytestmark = pytest.mark.xfail(
condition=sys.platform in ("win32", "darwin"),
reason="hive testing not supported on Windows/macOS",
)
docker = pytest.importorskip("docker")
sqlalchemy = pytest.importorskip("sqlalchemy")
def engine():
client = docker.from_env()
network = cli... | ["user_id", "a", "b", "user_id_2", "c", "d"]) | assert_* | collection | tests/integration/test_postgres.py | test_join | 123 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql.context import Context
from tests.utils import assert_eq
@pytest.mark.parametrize("gpu", [False, pytest.param(True, marks=pytest.mark.gpu)])
def test_sort_not_allowed(c, gpu):
table_name = "gpu_user_table_1" if gpu else "user_table_1"
... | Exception) | pytest.raises | variable | tests/integration/test_sort.py | test_sort_not_allowed | 303 | null | |
dask-contrib/dask-sql | import os
import sys
from unittest import mock
import dask.dataframe as dd
import pandas as pd
import pytest
import yaml
from dask import config as dask_config
import dask_sql # noqa: F401
from dask_sql import Context
from tests.utils import skipif_dask_expr_enabled
def test_custom_yaml(tmpdir):
custom_config =... | dask_config.get("sql") | assert | func_call | tests/unit/test_config.py | test_custom_yaml | 29 | null | |
dask-contrib/dask-sql | import itertools
import operator
import sys
import dask.dataframe as dd
import numpy as np
import pytest
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
@pytest.mark.parametrize("k", [1, 1.5, True])
@pytest.mark.parametrize(
"op", [operator.add, operator.sub, operator.mul, operator.... | expected_df) | assert_* | variable | tests/integration/test_function.py | test_custom_function_row_args | 92 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
from dask_sql import Context
from tests.utils import assert_eq
fugue_sql = pytest.importorskip("fugue_sql")
from dask_sql.integrations.fugue import fsql_dask # noqa: E402
def assert_fsql(df: pd.DataFrame) -> None:
assert_eq(df, | pd.DataFrame({"a": [1]})) | assert_* | func_call | tests/integration/test_fugue.py | assert_fsql | 46 | null | |
dask-contrib/dask-sql | import datetime
import operator
from unittest.mock import MagicMock
import dask.dataframe as dd
import numpy as np
import pandas as pd
import dask_sql.physical.rex.core.call as call
from tests.utils import assert_eq
df1 = dd.from_pandas(pd.DataFrame({"a": [1, 2, 3]}), npartitions=1)
df2 = dd.from_pandas(pd.DataFrame... | 20 | assert | numeric_literal | tests/unit/test_call.py | test_dates | 206 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
import pytest
import dask_sql
from tests.utils import assert_eq
@pytest.mark.parametrize(
"gpu",
[
False,
pytest.param(
True,
marks=pytest.mark.gpu,
),
],
)
def test_view_table_persist(c, temporary_data_file, d... | pd.DataFrame({"c": [10]})) | assert_* | func_call | tests/integration/test_create.py | test_view_table_persist | 234 | null | |
dask-contrib/dask-sql | import numpy as np
import pytest
from tests.utils import assert_eq
def get_system_sample(df, fraction, seed):
random_state = np.random.RandomState(seed)
random_choice = random_state.choice(
[True, False],
size=df.npartitions,
replace=True,
p=[fraction, 1 - fraction],
)
... | get_system_sample(ddf, 0.50, 10)) | assert_* | func_call | tests/integration/test_sample.py | test_sample | 37 | null | |
dask-contrib/dask-sql | import numpy as np
import pandas as pd
import pytest
from dask.dataframe.optimize import optimize_dataframe_getitem
from dask.utils_test import hlg_layer
from dask_sql.utils import ParsingException
from tests.utils import assert_eq, skipif_dask_expr_enabled
def test_timezones(c, datetime_table):
result_df = c.sql... | datetime_table) | assert_* | variable | tests/integration/test_select.py | test_timezones | 123 | null | |
dask-contrib/dask-sql | import sqlite3
import pytest
def engine():
yield sqlite3.connect(":memory:")
def test_filter(assert_query_gives_same_result):
assert_query_gives_same_result(
"""
SELECT
a
FROM df1
WHERE
user_id = 3 AND a > 0.5
"""
)
assert_query_gives_same_... | """ SELECT * FROM df1 WHERE a < 5 AND b < 5 """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_filter | 177 | null | |
dask-contrib/dask-sql | import datetime
import operator
from unittest.mock import MagicMock
import dask.dataframe as dd
import numpy as np
import pandas as pd
import dask_sql.physical.rex.core.call as call
from tests.utils import assert_eq
df1 = dd.from_pandas(pd.DataFrame({"a": [1, 2, 3]}), npartitions=1)
df2 = dd.from_pandas(pd.DataFrame... | 6 | assert | numeric_literal | tests/unit/test_call.py | test_reduce | 33 | null | |
dask-contrib/dask-sql | from collections.abc import Sequence
import dask
import dask.array as da
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.array.utils import assert_eq as assert_eq_ar
from dask.dataframe.utils import assert_eq as assert_eq_df
from sklearn.base import clone
from sklearn.decompo... | expected) | assert_* | variable | tests/unit/test_ml_utils.py | test_predict | 184 | null | |
dask-contrib/dask-sql | import os
import shutil
import tempfile
import pandas as pd
import pytest
from dask_sql.context import Context
from tests.utils import assert_eq, skipif_dask_expr_enabled
pytestmark = skipif_dask_expr_enabled(
reason="Intake doesn't yet have proper dask-expr support"
)
intake = pytest.importorskip("intake")
de... | expected_df) | assert_* | variable | tests/integration/test_intake.py | check_read_table | 51 | null | |
dask-contrib/dask-sql | import os
import pickle
import sys
import joblib
import pandas as pd
import pytest
from packaging.version import parse as parseVersion
from tests.utils import assert_eq
sklearn = pytest.importorskip("sklearn")
SKLEARN_EQ_140 = parseVersion(sklearn.__version__) == parseVersion("1.4.0")
def check_trained_model(c, mo... | "DaskXGBClassifier" | assert | string_literal | tests/integration/test_model.py | test_mlflow_export_xgboost | 676 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.