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 |
|---|---|---|---|---|---|---|---|---|---|
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_different_types(c):
expected_df = pd.Dat... | expected_df) | assert_* | variable | tests/integration/test_select.py | test_select_different_types | 53 | 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)
... | 404 | assert | numeric_literal | tests/integration/test_server.py | test_routes | 63 | 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": [1] * 10, "c": ["a"] * 10})) | assert_* | func_call | tests/integration/test_sort.py | test_sort_topk | 406 | 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
@pytest.mark.parametrize(
"input_table,gpu",
[
("string_table", False),
pytest.param(
"gpu_string_table",
True,
... | 0 | assert | numeric_literal | tests/integration/test_rex.py | test_like | 280 | 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, marks=pytest.mark.gpu)])
def test_add_rem... | KeyError) | pytest.raises | variable | tests/unit/test_context.py | test_add_remove_tables | 34 | 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
"""
)
asse | """ SELECT d FROM df2 WHERE d NOT LIKE '%c' """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_filter | 147 | 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 1 AS I, -5.34344 AS F, 'öäll' AS S """) | assert_* | string_literal | tests/integration/test_postgres.py | test_select | 109 | 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... | "input") | assert_* | string_literal | tests/unit/test_call.py | test_operation | 27 | 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... | 2 | assert | numeric_literal | tests/unit/test_call.py | test_case | 48 | 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... | first_mock | assert | variable | tests/integration/test_model.py | test_replace_and_error | 424 | null | |
dask-contrib/dask-sql | import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
def test_schemas(c):
expected_df = pd.DataFrame({"Schema": [c.schema_name, "information_schema"]})
assert_eq(c.sql("SHOW SCHEMAS"), | expected_df) | assert_* | variable | tests/integration/test_show.py | test_schemas | 12 | 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... | actual_series) | assert_* | variable | tests/integration/test_model.py | test_describe_model | 515 | 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... | ValueError, match="must be a subset") | pytest.raises | complex_expr | tests/unit/test_statistics.py | test_parquet_statistics_bad_args | 58 | 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
@pytest.mark.gpu
def test_python_decimal_to_sql():
import cudf
assert str(python_to_sql_ty... | "DECIMAL" | assert | string_literal | tests/unit/test_mapping.py | test_python_decimal_to_sql | 24 | 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, 10)) | assert_* | func_call | tests/integration/test_sample.py | test_sample | 29 | 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... | 4 | assert | numeric_literal | tests/unit/test_call.py | test_dates | 217 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
from dask_sql.mappings import python_to_sql_type
from tests.utils import assert_eq
def test_analyze(c, df):
result_df = c.sql("ANALYZE TABLE df COMPUTE STATISTICS FOR ALL COLUMNS")
# extract table and compute stats with Dask manually
expected_df = dd.concat... | expected_df) | assert_* | variable | tests/integration/test_analyze.py | test_analyze | 29 | 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 d FROM df2 WHERE d = 'a' """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_filter | 157 | 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
def test_replace_and_error(c, temporary_data_file, df):
c.sql(
"""
CREATE TABLE
new_table
AS (
SELECT 1 AS a
)
"""
)
asse | pd.DataFrame({"a": [1]})) | assert_* | func_call | tests/integration/test_create.py | test_replace_and_error | 249 | 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 df2.user_id, df2.d FROM df2 """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_select | 24 | 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 1 < a AND a < 5 """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_filter | 167 | 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"... | a_table | assert | variable | tests/integration/test_jdbc.py | check_data | 137 | 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)
... | 3 | assert | numeric_literal | tests/integration/test_server.py | test_inf_table | 208 | 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... | 7 | assert | numeric_literal | tests/unit/test_call.py | test_string_operations | 183 | 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",
[
["... | sorted(input_cols) | assert | func_call | tests/integration/test_select.py | test_multiple_column_projection | 269 | 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(
"retty",
[np.float64, np.float32, np.int64, np.int32, np.int16, np.int8, np.bool_],
)
def test_custo... | (df[["a"]] ** 2).astype(retty)) | assert_* | collection | tests/integration/test_function.py | test_custom_function_row_return_types | 67 | null | |
dask-contrib/dask-sql | import pandas as pd
from tests.utils import assert_eq
def test_union_all(c, df):
result_df = c.sql(
"""
SELECT * FROM df
UNION ALL
SELECT * FROM df
UNION ALL
SELECT * FROM df
"""
)
expected_df = pd.concat([df, df, df], ignore_index=True)
assert... | expected_df) | assert_* | variable | tests/integration/test_union.py | test_union_all | 32 | 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"... | data_len | assert | variable | tests/integration/test_jdbc.py | assert_result | 122 | 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... | None | assert | none_literal | tests/unit/test_statistics.py | test_parquet_statistics_bad_args | 51 | 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"
def test_filepath(tmpdir, parquet_ddf):
c = Context()
parquet_path = os.path.join(tmpdir, "p... | None | assert | none_literal | tests/unit/test_context.py | test_filepath | 328 | 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" | assert | string_literal | tests/unit/test_mapping.py | test_python_to_sql | 12 | 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("colnames", list(itertools.combinations(["a", "b", "c"], 2)))
def test_custom_function_any_colnames(colnames,... | got) | assert_* | variable | tests/integration/test_function.py | test_custom_function_any_colnames | 52 | null | |
dask-contrib/dask-sql | import pandas as pd
import pytest
from tests.utils import assert_eq, skipif_dask_expr_enabled
def test_over_with_sorting(c, user_table_1):
return_df = c.sql(
"""
SELECT
user_id,
b,
ROW_NUMBER() OVER (ORDER BY user_id, b) AS "R"
FROM user_table_1
"""
)
expected_d... | expected_df) | assert_* | variable | tests/integration/test_over.py | test_over_with_sorting | 20 | 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_overwrite():
PluginTest1.add_plugi... | "value_2" | assert | string_literal | tests/unit/test_utils.py | test_overwrite | 51 | null | |
dask-contrib/dask-sql | import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
def test_wrong_input(c):
with pytest.raises( | KeyError) | pytest.raises | variable | tests/integration/test_show.py | test_wrong_input | 66 | 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... | 0.9 | assert | numeric_literal | tests/unit/test_ml_utils.py | test_incremental_basic | 249 | 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"
def g(gpu=gpu):
df = pd.DataFrame({"a": [1]}) if not gpu else cudf.DataFrame({"a": [1]})... | ["a"] | assert | collection | tests/unit/test_context.py | g | 146 | 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... | 5 | assert | numeric_literal | tests/unit/test_call.py | test_math_operations | 173 | 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,... | KeyError) | pytest.raises | variable | tests/integration/test_join.py | check_broadcast_join | 551 | 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
def test_create_from_query(c, df):
with pytest.raises( | RuntimeError) | pytest.raises | variable | tests/integration/test_create.py | test_create_from_query | 119 | 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 test_join_reorder(c):
... | expected_df) | assert_* | variable | tests/integration/test_join.py | test_join_reorder | 507 | 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... | ["x", "y"] | assert | collection | tests/integration/test_model.py | test_correct_argument_passing | 363 | 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... | 0 | assert | numeric_literal | tests/unit/test_call.py | test_string_operations | 184 | 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
"""
)
asse | """ SELECT df1.user_id + 5 AS user_id, 2 * df1.b AS b FROM df1 """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_select | 18 | 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... | expected) | assert_* | variable | tests/integration/test_model.py | test_show_models | 296 | 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... | set(dir(est2)) | assert | func_call | tests/unit/test_ml_utils.py | test_incremental_basic | 251 | 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"
def test_function_adding():
c = Context()
assert not c.schema[c.schema_name].function_lists... | f | assert | variable | tests/unit/test_context.py | test_function_adding | 161 | 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... | KeyError) | pytest.raises | variable | tests/unit/test_utils.py | test_add_plugin | 39 | 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([3, 2, 3])) | assert_* | func_call | tests/unit/test_call.py | test_case | 39 | 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,... | 1 | assert | numeric_literal | tests/integration/test_join.py | check_broadcast_join | 548 | 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_column(c, df):
result_df = c.sql("SELECT... | df[["a"]]) | assert_* | complex_expr | tests/integration/test_select.py | test_select_column | 30 | 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... | len(parquet_ddf) | assert | func_call | tests/unit/test_statistics.py | test_parquet_statistics | 24 | 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... | ImportError) | pytest.raises | variable | tests/integration/test_model.py | test_wrong_training_or_prediction | 323 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from dask.datasets import timeseries
from tests.utils import assert_eq
def timeseries_df(c):
pdf = timeseries(freq="1d").compute().reset_index(drop=True)
# input nans in pandas dataframe
col1_index = np.random.randint(0, 30,... | expected_df) | assert_* | variable | tests/integration/test_groupby.py | test_groupby_split_every | 567 | null | |
dask-contrib/dask-sql | import dask.dataframe as dd
import pandas as pd
from dask_sql.mappings import python_to_sql_type
from tests.utils import assert_eq
def test_analyze(c, df):
result_df = c.sql("ANALYZE TABLE df COMPUTE STATISTICS FOR ALL COLUMNS")
# extract table and compute stats with Dask manually
expected_df = dd.concat... | expected_df[["a"]]) | assert_* | complex_expr | tests/integration/test_analyze.py | test_analyze | 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... | clf | assert | variable | tests/unit/test_ml_utils.py | test_incremental_basic | 236 | 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)
... | 200 | assert | numeric_literal | tests/integration/test_server.py | get_result_or_error | 42 | 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 | 114 | 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["b"].min().compute() | assert | func_call | tests/unit/test_statistics.py | test_parquet_statistics | 36 | 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 + b > 5 """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_filter | 187 | 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"]) | assert_* | collection | tests/integration/test_postgres.py | test_statistical_functions | 293 | 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"))
... | KeyError) | pytest.raises | variable | tests/integration/test_schema.py | test_table_schema | 24 | 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... | " n" | assert | string_literal | tests/unit/test_call.py | test_string_operations | 195 | null | |
dask-contrib/dask-sql | import pandas as pd
import pytest
from dask_sql import Context
from dask_sql.utils import ParsingException
from tests.utils import assert_eq
def test_wrong_input(c):
with pytest.raises(KeyError):
c.sql('SHOW COLUMNS FROM "wrong"."table"')
with pytest.raises(ParsingException):
c.sql('SHOW COLUM... | AttributeError) | pytest.raises | variable | tests/integration/test_show.py | test_wrong_input | 72 | null | |
dask-contrib/dask-sql | from dask_sql.datacontainer import ColumnContainer
def test_cc_limit_to():
c = ColumnContainer(["a", "b", "c"])
c2 = c.limit_to(["c", "a"])
assert c2.columns == | ["c", "a"] | assert | collection | tests/unit/test_datacontainer.py | test_cc_limit_to | 21 | 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... | "LGBMClassifier" | assert | string_literal | tests/integration/test_model.py | test_mlflow_export_lightgbm | 710 | 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_create_from_csv(c, df, temporary_data_file, gpu):
df.to_csv(temporary_data_file, index=False)
c.sql(
... | df) | assert_* | variable | tests/integration/test_create.py | test_create_from_csv | 31 | null | |
dask-contrib/dask-sql | import sqlite3
import pytest
def engine():
yield sqlite3.connect(":memory:")
def test_calc(assert_query_gives_same_result):
asse | """ SELECT a + b, a*b, a*5, a / user_id, user_id / a FROM df1 """) | assert_* | string_literal | tests/integration/test_sqlite.py | test_calc | 123 | 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")
@skipif_dask_ex... | 25 | assert | numeric_literal | tests/integration/test_filter.py | test_predicate_pushdown_isna | 362 | 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... | 15 | assert | numeric_literal | tests/unit/test_call.py | test_string_operations | 180 | 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... | timedelta(microseconds=4000) | assert | func_call | tests/unit/test_mapping.py | test_sql_to_python | 33 | null | |
dask-contrib/dask-sql | from dask.datasets import timeseries
def test_complex_query(c):
df = timeseries(freq="1d").persist()
c.create_table("timeseries", df)
result = c.sql(
"""
SELECT
lhs.name,
lhs.id,
lhs.x
FROM
timeseries AS lhs
JOIN
(... | 0 | assert | numeric_literal | tests/integration/test_complex.py | test_complex_query | 30 | 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
with pytest.raises( | RuntimeError) | pytest.raises | variable | tests/integration/test_schema.py | test_create_schema | 76 | 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... | ValueError) | pytest.raises | variable | tests/integration/test_model.py | test_wrong_training_or_prediction | 310 | 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... | 1 | assert | numeric_literal | tests/unit/test_call.py | test_case | 47 | 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... | result_df.columns | assert | complex_expr | tests/integration/test_model.py | check_trained_model | 39 | null | |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest, patch
from ddns.provider.alidns import AlidnsProvider
class TestAlidnsProvider(BaseProviderTestCase):
def setUp(self):
"""Set up test fixtures"""
super(TestAlidnsProvider, self).setUp()
self.id = "test_access_key_id"
self.token ... | "sub") | self.assertEqual | string_literal | tests/test_provider_alidns.py | test_split_zone_and_sub_success | TestAlidnsProvider | 106 | null |
NewFuture/DDNS | from __init__ import unittest
from ddns.config.config import Config # noqa: E402
class TestConfigExtra(unittest.TestCase):
def test_extra_from_env(self):
"""Test extra fields from environment config"""
env_config = {"dns": "cloudflare", "extra_proxied": "true", "extra_ttl_override": "300"}
... | "300") | self.assertEqual | string_literal | tests/test_config_extra.py | test_extra_from_env | TestConfigExtra | 58 | null |
NewFuture/DDNS | import os
from __init__ import unittest
from ddns.config.env import load_config # noqa: E402
class TestEnvExtraFields(unittest.TestCase):
def setUp(self):
"""Clear DDNS environment variables before each test"""
self._clear_env_prefix("DDNS_")
def tearDown(self):
"""Clean up after tes... | "300") | self.assertEqual | string_literal | tests/test_config_env_extra.py | test_env_extra_with_standard_vars | TestEnvExtraFields | 64 | null |
NewFuture/DDNS | import os
from __init__ import unittest
from ddns.config.env import load_config # noqa: E402
class TestEnvExtraFields(unittest.TestCase):
def setUp(self):
"""Clear DDNS environment variables before each test"""
self._clear_env_prefix("DDNS_")
def tearDown(self):
"""Clean up after tes... | "true") | self.assertEqual | string_literal | tests/test_config_env_extra.py | test_env_extra_single_field | TestEnvExtraFields | 37 | null |
NewFuture/DDNS | from __future__ import unicode_literals
from __init__ import unittest, sys
import json
import socket
import random
from ddns.util.http import HttpResponse, _decode_response_body, quote, USER_AGENT
def to_bytes(s, encoding="utf-8"):
if isinstance(s, text_type):
return s.encode(encoding)
return s
def t... | "100") | self.assertEqual | string_literal | tests/test_util_http.py | test_headers_get_case_insensitive | TestHttpResponse | 176 | null |
NewFuture/DDNS | from __init__ import unittest, patch
import tempfile
import json
import os
import sys
from ddns.config import load_configs
from ddns.config.file import load_config as load_file_config, _process_multi_providers
class TestMultiConfig(unittest.TestCase):
def setUp(self):
self.temp_dir = tempfile.mkdtemp()
... | 3) | self.assertEqual | numeric_literal | tests/test_config_init_multi.py | test_multi_provider_proxy_individual_settings | TestMultiConfig | 138 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest, patch, MagicMock
from ddns.provider.edgeone_dns import EdgeOneDnsProvider
class TestEdgeOneDnsProvider(BaseProviderTestCase):
def setUp(self):
"""Set up test fixtures"""
super(TestEdgeOneDnsProvider, self).setUp()
self.provider = EdgeOn... | "A") | self.assertEqual | string_literal | tests/test_provider_edgeone_dns.py | test_query_record_found | TestEdgeOneDnsProvider | 90 | null |
NewFuture/DDNS | import sys
from __init__ import unittest
from ddns.config.cli import load_config # noqa: E402
class TestCliExtraFields(unittest.TestCase):
def setUp(self):
"""Save original sys.argv"""
self.original_argv = sys.argv
def tearDown(self):
"""Restore original sys.argv"""
sys.argv ... | "0.5") | self.assertEqual | string_literal | tests/test_config_cli_extra.py | test_cli_extra_numeric_values | TestCliExtraFields | 98 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest
from ddns.provider._base import BaseProvider, encode_params
class TestBaseProvider(BaseProviderTestCase):
def setUp(self):
"""测试初始化"""
super(TestBaseProvider, self).setUp()
self.provider = _TestProvider()
def test_split_custom_domai... | "api") | self.assertEqual | string_literal | tests/test_provider_base.py | test_split_custom_domain_with_plus | TestBaseProvider | 141 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest, patch, MagicMock
from ddns.provider.dnspod import DnspodProvider
class TestDnspodProvider(BaseProviderTestCase):
def setUp(self):
"""测试初始化"""
super(TestDnspodProvider, self).setUp()
self.provider = DnspodProvider(self.id, self.token)
... | extra) | self.assertEqual | variable | tests/test_provider_dnspod.py | test_update_record_with_extra_params | TestDnspodProvider | 321 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest
from ddns.provider._base import BaseProvider, encode_params
class TestBaseProvider(BaseProviderTestCase):
def setUp(self):
"""测试初始化"""
super(TestBaseProvider, self).setUp()
self.provider = _TestProvider()
def test_split_custom_domai... | "www") | self.assertEqual | string_literal | tests/test_provider_base.py | test_split_custom_domain_with_tilde | TestBaseProvider | 133 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest, patch, MagicMock
from ddns.provider.dnspod import DnspodProvider
class TestDnspodProvider(BaseProviderTestCase):
def setUp(self):
"""测试初始化"""
super(TestDnspodProvider, self).setUp()
self.provider = DnspodProvider(self.id, self.token)
... | body) | self.assertIn | variable | tests/test_provider_dnspod.py | test_request_success | TestDnspodProvider | 54 | null |
NewFuture/DDNS | import platform
from __init__ import patch, unittest
from ddns.scheduler.schtasks import SchtasksScheduler
from ddns.util.try_run import try_run
class TestSchtasksScheduler(unittest.TestCase):
def setUp(self):
"""Set up test fixtures"""
self.scheduler = SchtasksScheduler()
def test_build_dd... | list) | self.assertIsInstance | variable | tests/test_scheduler_schtasks.py | test_build_ddns_command | TestSchtasksScheduler | 136 | null |
NewFuture/DDNS | import os
import platform
from __init__ import patch, unittest
from ddns.scheduler.systemd import SystemdScheduler
from ddns.util.try_run import try_run
class TestSystemdScheduler(unittest.TestCase):
def setUp(self):
"""Set up test fixtures"""
self.scheduler = SystemdScheduler()
@patch("sub... | 5) | self.assertEqual | numeric_literal | tests/test_scheduler_systemd.py | test_get_status_success | TestSystemdScheduler | 69 | null |
NewFuture/DDNS | from __init__ import unittest, patch, MagicMock, call
import os
import tempfile
import shutil
import json
import sys
import ddns.config
from ddns.config import load_configs, Config
from io import StringIO, BytesIO # For capturing stdout in Python2 and Python3
def capture_stdout_output(func, *args, **kwargs):
"""... | "600") | self.assertEqual | string_literal | tests/test_config_init.py | test_environment_config_integration | TestConfigInit | 369 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest, patch, MagicMock
from ddns.provider.noip import NoipProvider
class TestNoipProvider(BaseProviderTestCase):
def setUp(self):
"""Set up test fixtures"""
super(TestNoipProvider, self).setUp()
# No-IP uses both id (username) and token (pass... | "GET") | self.assertEqual | string_literal | tests/test_provider_noip.py | test_set_record_success_good_response | TestNoipProvider | 82 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, patch, unittest
from ddns.provider.cloudflare import CloudflareProvider
class TestCloudflareProviderIntegration(BaseProviderTestCase):
def setUp(self):
"""Set up test fixtures"""
super(TestCloudflareProviderIntegration, self).setUp()
self.id = "... | 3) | self.assertEqual | numeric_literal | tests/test_provider_cloudflare.py | test_full_workflow_create_new_record | TestCloudflareProviderIntegration | 526 | null |
NewFuture/DDNS | from __init__ import unittest
from ddns.provider._signature import hmac_sha256_authorization, sha256_hash, hmac_sha256
class TestHmacSha256Authorization(unittest.TestCase):
def test_hmac_sha256_basic_functionality(self):
"""测试 hmac_sha256 基础功能"""
key = "test_key"
message = "test_message"
... | hmac_obj2.hexdigest()) | self.assertEqual | func_call | tests/test_provider__signature.py | test_hmac_sha256_basic_functionality | TestHmacSha256Authorization | 316 | null |
NewFuture/DDNS | import sys
from __init__ import unittest
from ddns.config.cli import load_config # noqa: E402
class TestCliExtraFields(unittest.TestCase):
def setUp(self):
"""Save original sys.argv"""
self.original_argv = sys.argv
def tearDown(self):
"""Restore original sys.argv"""
sys.argv ... | 0) | self.assertEqual | numeric_literal | tests/test_config_cli_extra.py | test_cli_no_extra_args | TestCliExtraFields | 114 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest, patch, MagicMock
from ddns.provider.tencentcloud import TencentCloudProvider
class TestTencentCloudProvider(BaseProviderTestCase):
def setUp(self):
"""Set up test fixtures"""
super(TestTencentCloudProvider, self).setUp()
self.provider =... | "www") | self.assertEqual | string_literal | tests/test_provider_tencentcloud.py | test_query_record_found | TestTencentCloudProvider | 100 | null |
NewFuture/DDNS | from __future__ import unicode_literals
from __init__ import unittest
import tempfile
import shutil
import os
import json
import logging
import sys
from ddns.config import load_configs
class TestAllConfigFormatsIntegration(unittest.TestCase):
def setUp(self):
"""Set up test fixtures"""
self.temp_d... | True) | self.assertEqual | bool_literal | tests/test_config_schema_v4_1.py | test_v40_to_v41_compatibility | TestAllConfigFormatsIntegration | 184 | null |
NewFuture/DDNS | from base_test import BaseProviderTestCase, unittest
from ddns.provider.dnspod_com import DnspodComProvider
class TestDnspodComProvider(BaseProviderTestCase):
def setUp(self):
"""Set up test fixtures"""
super(TestDnspodComProvider, self).setUp()
self.id = "test_email@example.com"
s... | self.id) | self.assertEqual | complex_expr | tests/test_provider_dnspod_com.py | test_init_with_basic_config | TestDnspodComProvider | 29 | null |
NewFuture/DDNS | from __future__ import unicode_literals
from __init__ import unittest
import tempfile
import shutil
import os
import json
import logging
import sys
from ddns.config import load_configs
class TestAllConfigFormatsIntegration(unittest.TestCase):
def setUp(self):
"""Set up test fixtures"""
self.temp_d... | 1) | self.assertEqual | numeric_literal | tests/test_config_schema_v4_1.py | test_v41_backward_compatibility | TestAllConfigFormatsIntegration | 132 | null |
NewFuture/DDNS | from __future__ import unicode_literals
from __init__ import unittest, patch
import tempfile
import shutil
import os
import json
import sys
import socket
from ddns.config.file import load_config
from ddns.util.http import HttpResponse
class TestRemoteConfigFile(unittest.TestCase):
def setUp(self):
"""Set ... | 2) | self.assertEqual | numeric_literal | tests/test_config_file_remote.py | test_load_config_remote_v41_providers_format | TestRemoteConfigFile | 204 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.