repo_id
stringlengths 21
96
| file_path
stringlengths 31
155
| content
stringlengths 1
92.9M
| __index_level_0__
int64 0
0
|
|---|---|---|---|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/join.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.pair cimport pair
from libcpp.vector cimport vector
from rmm._lib.device_uvector cimport device_uvector
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport size_type
ctypedef unique_ptr[device_uvector[size_type]] gather_map_type
cdef extern from "cudf/join.hpp" namespace "cudf" nogil:
cdef pair[gather_map_type, gather_map_type] inner_join(
const table_view left_keys,
const table_view right_keys,
) except +
cdef pair[gather_map_type, gather_map_type] left_join(
const table_view left_keys,
const table_view right_keys,
) except +
cdef pair[gather_map_type, gather_map_type] full_join(
const table_view left_keys,
const table_view right_keys,
) except +
cdef gather_map_type left_semi_join(
const table_view left_keys,
const table_view right_keys,
) except +
cdef gather_map_type left_anti_join(
const table_view left_keys,
const table_view right_keys,
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/expressions.pxd
|
# Copyright (c) 2022-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.scalar.scalar cimport (
duration_scalar,
numeric_scalar,
timestamp_scalar,
)
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/ast/expressions.hpp" namespace "cudf::ast" nogil:
ctypedef enum ast_operator:
# Binary operators
ADD "cudf::ast::ast_operator::ADD"
SUB "cudf::ast::ast_operator::SUB"
MUL "cudf::ast::ast_operator::MUL"
DIV "cudf::ast::ast_operator::DIV"
TRUE_DIV "cudf::ast::ast_operator::TRUE_DIV"
FLOOR_DIV "cudf::ast::ast_operator::FLOOR_DIV"
MOD "cudf::ast::ast_operator::MOD"
PYMOD "cudf::ast::ast_operator::PYMOD"
POW "cudf::ast::ast_operator::POW"
EQUAL "cudf::ast::ast_operator::EQUAL"
NULL_EQUAL "cudf::ast::ast_operator::NULL_EQUAL"
NOT_EQUAL "cudf::ast::ast_operator::NOT_EQUAL"
LESS "cudf::ast::ast_operator::LESS"
GREATER "cudf::ast::ast_operator::GREATER"
LESS_EQUAL "cudf::ast::ast_operator::LESS_EQUAL"
GREATER_EQUAL "cudf::ast::ast_operator::GREATER_EQUAL"
BITWISE_AND "cudf::ast::ast_operator::BITWISE_AND"
BITWISE_OR "cudf::ast::ast_operator::BITWISE_OR"
BITWISE_XOR "cudf::ast::ast_operator::BITWISE_XOR"
NULL_LOGICAL_AND "cudf::ast::ast_operator::NULL_LOGICAL_AND"
LOGICAL_AND "cudf::ast::ast_operator::LOGICAL_AND"
NULL_LOGICAL_OR "cudf::ast::ast_operator::NULL_LOGICAL_OR"
LOGICAL_OR "cudf::ast::ast_operator::LOGICAL_OR"
# Unary operators
IDENTITY "cudf::ast::ast_operator::IDENTITY"
IS_NULL "cudf::ast::ast_operator::IS_NULL"
SIN "cudf::ast::ast_operator::SIN"
COS "cudf::ast::ast_operator::COS"
TAN "cudf::ast::ast_operator::TAN"
ARCSIN "cudf::ast::ast_operator::ARCSIN"
ARCCOS "cudf::ast::ast_operator::ARCCOS"
ARCTAN "cudf::ast::ast_operator::ARCTAN"
SINH "cudf::ast::ast_operator::SINH"
COSH "cudf::ast::ast_operator::COSH"
TANH "cudf::ast::ast_operator::TANH"
ARCSINH "cudf::ast::ast_operator::ARCSINH"
ARCCOSH "cudf::ast::ast_operator::ARCCOSH"
ARCTANH "cudf::ast::ast_operator::ARCTANH"
EXP "cudf::ast::ast_operator::EXP"
LOG "cudf::ast::ast_operator::LOG"
SQRT "cudf::ast::ast_operator::SQRT"
CBRT "cudf::ast::ast_operator::CBRT"
CEIL "cudf::ast::ast_operator::CEIL"
FLOOR "cudf::ast::ast_operator::FLOOR"
ABS "cudf::ast::ast_operator::ABS"
RINT "cudf::ast::ast_operator::RINT"
BIT_INVERT "cudf::ast::ast_operator::BIT_INVERT"
NOT "cudf::ast::ast_operator::NOT"
cdef cppclass expression:
pass
ctypedef enum table_reference:
LEFT "cudf::ast::table_reference::LEFT"
RIGHT "cudf::ast::table_reference::RIGHT"
cdef cppclass literal(expression):
# Due to https://github.com/cython/cython/issues/3198, we need to
# specify a return type for templated constructors.
literal literal[T](numeric_scalar[T] &) except +
literal literal[T](timestamp_scalar[T] &) except +
literal literal[T](duration_scalar[T] &) except +
cdef cppclass column_reference(expression):
# Allow for default C++ parameters by declaring multiple constructors
# with the default parameters optionally omitted.
column_reference(size_type) except +
column_reference(size_type, table_reference) except +
cdef cppclass operation(expression):
operation(ast_operator, const expression &)
operation(ast_operator, const expression &, const expression&)
cdef cppclass column_name_reference(expression):
# column_name_reference is only meant for use in file I/O such as the
# Parquet reader.
column_name_reference(string) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/reshape.pxd
|
# Copyright (c) 2019, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/reshape.hpp" namespace "cudf" nogil:
cdef unique_ptr[column] interleave_columns(
table_view source_table
) except +
cdef unique_ptr[table] tile(
table_view source_table, size_type count
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/filling.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view, mutable_column_view
from cudf._lib.cpp.scalar.scalar cimport scalar
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/filling.hpp" namespace "cudf" nogil:
cdef unique_ptr[column] fill(
const column_view & input,
size_type begin,
size_type end,
const scalar & value
) except +
cdef void fill_in_place(
const mutable_column_view & destination,
size_type beign,
size_type end,
const scalar & value
) except +
cdef unique_ptr[table] repeat(
const table_view & input,
const column_view & count,
) except +
cdef unique_ptr[table] repeat(
const table_view & input,
size_type count
) except +
cdef unique_ptr[column] sequence(
size_type size,
const scalar & init,
const scalar & step
) except +
cdef unique_ptr[column] calendrical_month_sequence(
size_type n,
const scalar& init,
size_type months,
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/transform.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.pair cimport pair
from libcpp.string cimport string
from rmm._lib.device_buffer cimport device_buffer
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.expressions cimport expression
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport bitmask_type, data_type, size_type
cdef extern from "cudf/transform.hpp" namespace "cudf" nogil:
cdef pair[unique_ptr[device_buffer], size_type] bools_to_mask (
column_view input
) except +
cdef unique_ptr[column] mask_to_bools (
bitmask_type* bitmask, size_type begin_bit, size_type end_bit
) except +
cdef pair[unique_ptr[device_buffer], size_type] nans_to_nulls(
column_view input
) except +
cdef unique_ptr[column] transform(
column_view input,
string unary_udf,
data_type output_type,
bool is_ptx
) except +
cdef pair[unique_ptr[table], unique_ptr[column]] encode(
table_view input
) except +
cdef pair[unique_ptr[column], table_view] one_hot_encode(
column_view input_column,
column_view categories
)
cdef unique_ptr[column] compute_column(
const table_view table,
const expression& expr
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/copying.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libc.stdint cimport int32_t, int64_t, uint8_t
from libcpp cimport bool
from libcpp.functional cimport reference_wrapper
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from rmm._lib.device_buffer cimport device_buffer
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view, mutable_column_view
from cudf._lib.cpp.scalar.scalar cimport scalar
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport size_type
from cudf._lib.exception_handler cimport cudf_exception_handler
ctypedef const scalar constscalar
cdef extern from "cudf/copying.hpp" namespace "cudf" nogil:
cpdef enum class out_of_bounds_policy(bool):
NULLIFY
DONT_CHECK
cdef unique_ptr[table] gather (
const table_view& source_table,
const column_view& gather_map,
out_of_bounds_policy policy
) except +cudf_exception_handler
cdef unique_ptr[column] shift(
const column_view& input,
size_type offset,
const scalar& fill_values
) except +
cdef unique_ptr[table] scatter (
table_view source_table,
column_view scatter_map,
table_view target_table,
) except +
cdef unique_ptr[table] scatter (
vector[reference_wrapper[constscalar]] source_scalars,
column_view indices,
table_view target,
) except +
ctypedef enum mask_allocation_policy:
NEVER 'cudf::mask_allocation_policy::NEVER',
RETAIN 'cudf::mask_allocation_policy::RETAIN',
ALWAYS 'cudf::mask_allocation_policy::ALWAYS'
cdef unique_ptr[column] empty_like (
column_view input_column
) except +
cdef unique_ptr[column] allocate_like (
column_view input_column,
mask_allocation_policy policy
) except +
cdef unique_ptr[column] allocate_like (
column_view input_column,
size_type size,
mask_allocation_policy policy
) except +
cdef unique_ptr[table] empty_like (
table_view input_table
) except +
cdef void copy_range_in_place (
column_view input_column,
mutable_column_view target_column,
size_type input_begin,
size_type input_end,
size_type target_begin
) except +
cdef unique_ptr[column] copy_range (
column_view input_column,
column_view target_column,
size_type input_begin,
size_type input_end,
size_type target_begin
) except +
cdef vector[column_view] slice (
column_view input_column,
vector[size_type] indices
) except +
cdef vector[table_view] slice (
table_view input_table,
vector[size_type] indices
) except +
cdef vector[column_view] split (
column_view input_column,
vector[size_type] splits
) except +
cdef vector[table_view] split (
table_view input_table,
vector[size_type] splits
) except +
cdef unique_ptr[column] copy_if_else (
column_view lhs,
column_view rhs,
column_view boolean_mask
) except +
cdef unique_ptr[column] copy_if_else (
scalar lhs,
column_view rhs,
column_view boolean_mask
) except +
cdef unique_ptr[column] copy_if_else (
column_view lhs,
scalar rhs,
column_view boolean_mask
) except +
cdef unique_ptr[column] copy_if_else (
scalar lhs,
scalar rhs,
column_view boolean_mask
) except +
cdef unique_ptr[table] boolean_mask_scatter (
table_view input,
table_view target,
column_view boolean_mask
) except +
cdef unique_ptr[table] boolean_mask_scatter (
vector[reference_wrapper[constscalar]] input,
table_view target,
column_view boolean_mask
) except +
cdef unique_ptr[scalar] get_element (
column_view input,
size_type index
) except +
ctypedef enum sample_with_replacement:
FALSE 'cudf::sample_with_replacement::FALSE',
TRUE 'cudf::sample_with_replacement::TRUE',
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/interop.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport shared_ptr, unique_ptr
from libcpp.string cimport string
from libcpp.vector cimport vector
from pyarrow.lib cimport CScalar, CTable
from cudf._lib.types import cudf_to_np_types, np_to_cudf_types
from cudf._lib.cpp.scalar.scalar cimport scalar
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
cdef extern from "dlpack/dlpack.h" nogil:
ctypedef struct DLManagedTensor:
void(*deleter)(DLManagedTensor*) except +
cdef extern from "cudf/interop.hpp" namespace "cudf" \
nogil:
cdef unique_ptr[table] from_dlpack(const DLManagedTensor* tensor
) except +
DLManagedTensor* to_dlpack(table_view input_table
) except +
cdef unique_ptr[table] from_arrow(CTable input) except +
cdef unique_ptr[scalar] from_arrow(CScalar input) except +
cdef cppclass column_metadata:
column_metadata() except +
column_metadata(string name_) except +
string name
vector[column_metadata] children_meta
cdef shared_ptr[CTable] to_arrow(
table_view input,
vector[column_metadata] metadata,
) except +
cdef shared_ptr[CScalar] to_arrow(
const scalar& input,
column_metadata metadata,
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/concatenate.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from rmm._lib.device_buffer cimport device_buffer
from cudf._lib.cpp.column.column cimport column, column_view
from cudf._lib.cpp.table.table cimport table, table_view
from cudf._lib.cpp.utilities.host_span cimport host_span
cdef extern from "cudf/concatenate.hpp" namespace "cudf" nogil:
# The versions of concatenate taking vectors don't exist in libcudf
# C++, but passing a vector works because a host_span is implicitly
# constructable from a vector. In case they are needed in the future,
# host_span versions can be added, e.g:
#
# cdef device_buffer concatenate_masks "cudf::concatenate_masks"(
# host_span[column_view] views
# ) except +
cdef device_buffer concatenate_masks "cudf::concatenate_masks"(
const vector[column_view] views
) except +
cdef unique_ptr[column] concatenate_columns "cudf::concatenate"(
const vector[column_view] columns
) except +
cdef unique_ptr[table] concatenate_tables "cudf::concatenate"(
const vector[table_view] tables
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/hash.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libc.stdint cimport uint32_t
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
cdef extern from "cudf/hashing.hpp" namespace "cudf" nogil:
ctypedef enum hash_id "cudf::hash_id":
HASH_IDENTITY "cudf::hash_id::HASH_IDENTITY"
HASH_MURMUR3 "cudf::hash_id::HASH_MURMUR3"
HASH_SPARK_MURMUR3 "cudf::hash_id::HASH_SPARK_MURMUR3"
HASH_MD5 "cudf::hash_id::HASH_MD5"
cdef unique_ptr[column] hash "cudf::hash" (
const table_view& input,
const hash_id hash_function,
const uint32_t seed
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/contiguous_split.pxd
|
# Copyright (c) 2023, NVIDIA CORPORATION.
from libc.stdint cimport uint8_t
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from rmm._lib.device_buffer cimport device_buffer
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/contiguous_split.hpp" namespace "cudf" nogil:
cdef cppclass packed_columns:
unique_ptr[vector[uint8_t]] metadata
unique_ptr[device_buffer] gpu_data
cdef struct contiguous_split_result:
table_view table
vector[device_buffer] all_data
cdef vector[contiguous_split_result] contiguous_split (
table_view input_table,
vector[size_type] splits
) except +
cdef packed_columns pack (const table_view& input) except +
cdef table_view unpack (const packed_columns& input) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings_udf.pxd
|
# Copyright (c) 2022-2023, NVIDIA CORPORATION.
from libc.stdint cimport uint8_t, uint16_t
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from libcpp.vector cimport vector
from rmm._lib.device_buffer cimport DeviceBuffer, device_buffer
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/udf/udf_string.hpp" namespace \
"cudf::strings::udf" nogil:
cdef cppclass udf_string
cdef extern from "cudf/strings/udf/udf_apis.hpp" namespace \
"cudf::strings::udf" nogil:
cdef unique_ptr[device_buffer] to_string_view_array(column_view) except +
cdef unique_ptr[column] column_from_udf_string_array(
udf_string* strings, size_type size,
) except +
cdef void free_udf_string_array(
udf_string* strings, size_type size
) except +
cdef extern from "cudf/strings/detail/char_tables.hpp" namespace \
"cudf::strings::detail" nogil:
cdef const uint8_t* get_character_flags_table() except +
cdef const uint16_t* get_character_cases_table() except +
cdef const void* get_special_case_mapping_table() except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/transpose.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.pair cimport pair
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.table.table_view cimport table_view
cdef extern from "cudf/transpose.hpp" namespace "cudf" nogil:
cdef pair[
unique_ptr[column],
table_view
] transpose(
table_view input_table
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/labeling.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "cudf/labeling/label_bins.hpp" namespace "cudf" nogil:
ctypedef enum inclusive:
YES "cudf::inclusive::YES"
NO "cudf::inclusive::NO"
cdef unique_ptr[column] label_bins (
const column_view &input,
const column_view &left_edges,
inclusive left_inclusive,
const column_view &right_edges,
inclusive right_inclusive
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/null_mask.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libc.stdint cimport int32_t
from libcpp.pair cimport pair
from rmm._lib.device_buffer cimport device_buffer
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport bitmask_type, mask_state, size_type
ctypedef int32_t underlying_type_t_mask_state
cdef extern from "cudf/null_mask.hpp" namespace "cudf" nogil:
cdef device_buffer copy_bitmask "cudf::copy_bitmask" (
column_view view
) except +
cdef size_t bitmask_allocation_size_bytes (
size_type number_of_bits,
size_t padding_boundary
) except +
cdef size_t bitmask_allocation_size_bytes (
size_type number_of_bits
) except +
cdef device_buffer create_null_mask (
size_type size,
mask_state state
) except +
cdef pair[device_buffer, size_type] bitmask_and(
table_view view
)
cdef pair[device_buffer, size_type] bitmask_or(
table_view view
)
cdef size_type null_count(
const bitmask_type * bitmask,
size_type start,
size_type stop,
)
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/sorting.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from cudf._lib.types import cudf_to_np_types, np_to_cudf_types
cimport cudf._lib.cpp.types as libcudf_types
from cudf._lib.cpp.aggregation cimport rank_method
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
cdef extern from "cudf/sorting.hpp" namespace "cudf" nogil:
cdef unique_ptr[column] sorted_order(
table_view source_table,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
cdef unique_ptr[column] stable_sorted_order(
table_view source_table,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
cdef unique_ptr[column] rank(
column_view input_view,
rank_method method,
libcudf_types.order column_order,
libcudf_types.null_policy null_handling,
libcudf_types.null_order null_precedence,
bool percentage) except +
cdef bool is_sorted(
const table_view& table,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
cdef unique_ptr[table] segmented_sort_by_key(
const table_view& values,
const table_view& keys,
const column_view& segment_offsets,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
cdef unique_ptr[table] stable_segmented_sort_by_key(
const table_view& values,
const table_view& keys,
const column_view& segment_offsets,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
cdef unique_ptr[table] sort_by_key(
const table_view& values,
const table_view& keys,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
cdef unique_ptr[table] stable_sort_by_key(
const table_view& values,
const table_view& keys,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
cdef unique_ptr[table] sort(
table_view source_table,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/search.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
cimport cudf._lib.cpp.types as libcudf_types
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.table.table_view cimport table_view
cdef extern from "cudf/search.hpp" namespace "cudf" nogil:
cdef unique_ptr[column] lower_bound(
table_view haystack,
table_view needles,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence,
) except +
cdef unique_ptr[column] upper_bound(
table_view haystack,
table_view needles,
vector[libcudf_types.order] column_order,
vector[libcudf_types.null_order] null_precedence,
) except +
cdef unique_ptr[column] contains(
column_view haystack,
column_view needles,
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/replace.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.types import cudf_to_np_types, np_to_cudf_types
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view, mutable_column_view
from cudf._lib.cpp.scalar.scalar cimport scalar
cdef extern from "cudf/replace.hpp" namespace "cudf" nogil:
ctypedef enum replace_policy:
PRECEDING 'cudf::replace_policy::PRECEDING',
FOLLOWING 'cudf::replace_policy::FOLLOWING'
cdef unique_ptr[column] replace_nulls(
column_view source_column,
column_view replacement_column) except +
cdef unique_ptr[column] replace_nulls(
column_view source_column,
scalar replacement) except +
cdef unique_ptr[column] replace_nulls(
column_view source_column,
replace_policy replace_policy) except +
cdef unique_ptr[column] find_and_replace_all(
column_view source_column,
column_view values_to_replace,
column_view replacement_values) except +
cdef unique_ptr[column] clamp(
column_view source_column,
scalar lo, scalar lo_replace,
scalar hi, scalar hi_replace) except +
cdef unique_ptr[column] clamp(
column_view source_column,
scalar lo, scalar hi) except +
cdef extern from "cudf/replace.hpp" namespace "cudf" nogil:
cdef unique_ptr[column] normalize_nans_and_zeros(
column_view source_column) except +
cdef void normalize_nans_and_zeros(
mutable_column_view source_column) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/datetime.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport scalar
cdef extern from "cudf/datetime.hpp" namespace "cudf::datetime" nogil:
cdef unique_ptr[column] extract_year(const column_view& column) except +
cdef unique_ptr[column] extract_month(const column_view& column) except +
cdef unique_ptr[column] extract_day(const column_view& column) except +
cdef unique_ptr[column] extract_weekday(const column_view& column) except +
cdef unique_ptr[column] extract_hour(const column_view& column) except +
cdef unique_ptr[column] extract_minute(const column_view& column) except +
cdef unique_ptr[column] extract_second(const column_view& column) except +
cdef unique_ptr[column] extract_millisecond_fraction(
const column_view& column
) except +
cdef unique_ptr[column] extract_microsecond_fraction(
const column_view& column
) except +
cdef unique_ptr[column] extract_nanosecond_fraction(
const column_view& column
) except +
ctypedef enum rounding_frequency "cudf::datetime::rounding_frequency":
DAY "cudf::datetime::rounding_frequency::DAY"
HOUR "cudf::datetime::rounding_frequency::HOUR"
MINUTE "cudf::datetime::rounding_frequency::MINUTE"
SECOND "cudf::datetime::rounding_frequency::SECOND"
MILLISECOND "cudf::datetime::rounding_frequency::MILLISECOND"
MICROSECOND "cudf::datetime::rounding_frequency::MICROSECOND"
NANOSECOND "cudf::datetime::rounding_frequency::NANOSECOND"
cdef unique_ptr[column] ceil_datetimes(
const column_view& column, rounding_frequency freq
) except +
cdef unique_ptr[column] floor_datetimes(
const column_view& column, rounding_frequency freq
) except +
cdef unique_ptr[column] round_datetimes(
const column_view& column, rounding_frequency freq
) except +
cdef unique_ptr[column] add_calendrical_months(
const column_view& timestamps,
const column_view& months
) except +
cdef unique_ptr[column] day_of_year(const column_view& column) except +
cdef unique_ptr[column] is_leap_year(const column_view& column) except +
cdef unique_ptr[column] last_day_of_month(
const column_view& column
) except +
cdef unique_ptr[column] extract_quarter(const column_view& column) except +
cdef unique_ptr[column] days_in_month(const column_view& column) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/groupby.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.functional cimport reference_wrapper
from libcpp.memory cimport unique_ptr
from libcpp.pair cimport pair
from libcpp.vector cimport vector
from cudf._lib.cpp.aggregation cimport (
groupby_aggregation,
groupby_scan_aggregation,
)
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.replace cimport replace_policy
from cudf._lib.cpp.scalar.scalar cimport scalar
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport null_order, null_policy, order, size_type
from cudf._lib.cpp.utilities.host_span cimport host_span
# workaround for https://github.com/cython/cython/issues/3885
ctypedef const scalar constscalar
cdef extern from "cudf/groupby.hpp" \
namespace "cudf::groupby" nogil:
cdef cppclass aggregation_request:
aggregation_request() except +
column_view values
vector[unique_ptr[groupby_aggregation]] aggregations
cdef cppclass scan_request:
scan_request() except +
column_view values
vector[unique_ptr[groupby_scan_aggregation]] aggregations
cdef cppclass aggregation_result:
vector[unique_ptr[column]] results
cdef cppclass groups \
"cudf::groupby::groupby::groups" nogil:
unique_ptr[table] keys
vector[size_type] offsets
unique_ptr[table] values
cdef cppclass groupby:
groupby(const table_view& keys) except +
groupby(
const table_view& keys,
null_policy include_null_keys
) except +
groupby(
const table_view& keys,
null_policy include_null_keys,
bool keys_are_sorted,
) except +
groupby(
const table_view& keys,
null_policy include_null_keys,
bool keys_are_sorted,
const vector[order]& column_order,
) except +
groupby(
const table_view& keys,
null_policy include_null_keys,
bool keys_are_sorted,
const vector[order]& column_order,
const vector[null_order]& null_precedence
) except +
pair[
unique_ptr[table],
vector[aggregation_result]
] aggregate(
const vector[aggregation_request]& requests,
) except +
pair[
unique_ptr[table],
vector[aggregation_result]
] scan(
const vector[scan_request]& requests,
) except +
pair[
unique_ptr[table],
unique_ptr[table]
] shift(
const table_view values,
const vector[size_type] offset,
const vector[reference_wrapper[constscalar]] fill_values
) except +
groups get_groups() except +
groups get_groups(table_view values) except +
pair[unique_ptr[table], unique_ptr[table]] replace_nulls(
const table_view& value,
const vector[replace_policy] replace_policy
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/unary.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libc.stdint cimport int32_t
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport data_type
ctypedef int32_t underlying_type_t_unary_op
cdef extern from "cudf/unary.hpp" namespace "cudf" nogil:
ctypedef enum unary_operator:
SIN "cudf::unary_operator::SIN"
COS "cudf::unary_operator::COS"
TAN "cudf::unary_operator::TAN"
ARCSIN "cudf::unary_operator::ARCSIN"
ARCCOS "cudf::unary_operator::ARCCOS"
ARCTAN "cudf::unary_operator::ARCTAN"
SINH "cudf::unary_operator::SINH"
COSH "cudf::unary_operator::COSH"
TANH "cudf::unary_operator::TANH"
ARCSINH "cudf::unary_operator::ARCSINH"
ARCCOSH "cudf::unary_operator::ARCCOSH"
ARCTANH "cudf::unary_operator::ARCTANH"
EXP "cudf::unary_operator::EXP"
LOG "cudf::unary_operator::LOG"
SQRT "cudf::unary_operator::SQRT"
CBRT "cudf::unary_operator::CBRT"
CEIL "cudf::unary_operator::CEIL"
FLOOR "cudf::unary_operator::FLOOR"
ABS "cudf::unary_operator::ABS"
RINT "cudf::unary_operator::RINT"
BIT_INVERT "cudf::unary_operator::BIT_INVERT"
NOT "cudf::unary_operator::NOT"
cdef extern unique_ptr[column] unary_operation(
column_view input,
unary_operator op) except +
cdef extern unique_ptr[column] is_null(column_view input) except +
cdef extern unique_ptr[column] is_valid(column_view input) except +
cdef extern unique_ptr[column] cast(
column_view input,
data_type out_type) except +
cdef extern unique_ptr[column] is_nan(column_view input) except +
cdef extern unique_ptr[column] is_not_nan(column_view input) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/table/table.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.table.table_view cimport mutable_table_view, table_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/table/table.hpp" namespace "cudf" nogil:
cdef cppclass table:
table(const table&) except +
table(table_view) except +
size_type num_columns() except +
size_type num_rows() except +
table_view view() except +
mutable_table_view mutable_view() except +
vector[unique_ptr[column]] release() except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/table/table_view.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.vector cimport vector
from cudf._lib.cpp.column.column_view cimport column_view, mutable_column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/table/table_view.hpp" namespace "cudf" nogil:
cdef cppclass table_view:
table_view() except +
table_view(const vector[column_view]) except +
column_view column(size_type column_index) except +
size_type num_columns() except +
size_type num_rows() except +
table_view select(vector[size_type] column_indices) except +
cdef cppclass mutable_table_view:
mutable_table_view() except +
mutable_table_view(const vector[mutable_column_view]) except +
mutable_column_view column(size_type column_index) except +
size_type num_columns() except +
size_type num_rows() except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/find.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/find.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] contains(
column_view source_strings,
string_scalar target) except +
cdef unique_ptr[column] contains(
column_view source_strings,
column_view target_strings) except +
cdef unique_ptr[column] ends_with(
column_view source_strings,
string_scalar target) except +
cdef unique_ptr[column] ends_with(
column_view source_strings,
column_view target_strings) except +
cdef unique_ptr[column] starts_with(
column_view source_strings,
string_scalar target) except +
cdef unique_ptr[column] starts_with(
column_view source_strings,
column_view target_strings) except +
cdef unique_ptr[column] find(
column_view source_strings,
string_scalar target,
size_type start,
size_type stop) except +
cdef unique_ptr[column] rfind(
column_view source_strings,
string_scalar target,
size_type start,
size_type stop) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/find_multiple.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "cudf/strings/find_multiple.hpp" namespace "cudf::strings" \
nogil:
cdef unique_ptr[column] find_multiple(
column_view source_strings,
column_view targets) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/strip.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.strings.side_type cimport side_type
cdef extern from "cudf/strings/strip.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] strip(
column_view source_strings,
side_type stype,
string_scalar to_strip) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/combine.pxd
|
# Copyright (c) 2020-2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.table.table_view cimport table_view
cdef extern from "cudf/strings/combine.hpp" namespace "cudf::strings" nogil:
ctypedef enum separator_on_nulls:
YES 'cudf::strings::separator_on_nulls::YES'
NO 'cudf::strings::separator_on_nulls::NO'
ctypedef enum output_if_empty_list:
EMPTY_STRING 'cudf::strings::output_if_empty_list::EMPTY_STRING'
NULL_ELEMENT 'cudf::strings::output_if_empty_list::NULL_ELEMENT'
cdef unique_ptr[column] concatenate(
table_view source_strings,
string_scalar separator,
string_scalar narep) except +
cdef unique_ptr[column] join_strings(
column_view source_strings,
string_scalar separator,
string_scalar narep) except +
cdef unique_ptr[column] join_list_elements(
column_view lists_strings_column,
column_view separators,
string_scalar separator_narep,
string_scalar string_narep,
separator_on_nulls separate_nulls,
output_if_empty_list empty_list_policy) except +
cdef unique_ptr[column] join_list_elements(
column_view lists_strings_column,
string_scalar separator,
string_scalar narep,
separator_on_nulls separate_nulls,
output_if_empty_list empty_list_policy) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/attributes.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "cudf/strings/attributes.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] count_characters(
column_view source_strings) except +
cdef unique_ptr[column] count_bytes(
column_view source_strings) except +
cdef unique_ptr[column] code_points(
column_view source_strings) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/findall.pxd
|
# Copyright (c) 2019-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.strings.regex_program cimport regex_program
cdef extern from "cudf/strings/findall.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] findall(
column_view source_strings,
regex_program) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/extract.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.strings.regex_program cimport regex_program
from cudf._lib.cpp.table.table cimport table
cdef extern from "cudf/strings/extract.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[table] extract(
column_view source_strings,
regex_program) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/translate.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.pair cimport pair
from libcpp.vector cimport vector
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.types cimport char_utf8
cdef extern from "cudf/strings/translate.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] translate(
column_view source_strings,
vector[pair[char_utf8, char_utf8]] chars_table) except +
ctypedef enum filter_type:
KEEP 'cudf::strings::filter_type::KEEP',
REMOVE 'cudf::strings::filter_type::REMOVE'
cdef unique_ptr[column] filter_characters(
column_view source_strings,
vector[pair[char_utf8, char_utf8]] chars_table,
filter_type keep,
string_scalar replacement) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/json.pxd
|
# Copyright (c) 2021-2023, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport scalar, string_scalar
cdef extern from "cudf/json/json.hpp" namespace "cudf" nogil:
cdef cppclass get_json_object_options:
get_json_object_options() except +
# getters
bool get_allow_single_quotes() except +
bool get_strip_quotes_from_single_strings() except +
bool get_missing_fields_as_nulls() except +
# setters
void set_allow_single_quotes(bool val) except +
void set_strip_quotes_from_single_strings(bool val) except +
void set_missing_fields_as_nulls(bool val) except +
cdef unique_ptr[column] get_json_object(
column_view col,
string_scalar json_path,
get_json_object_options options,
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/repeat.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/repeat_strings.hpp" namespace "cudf::strings" \
nogil:
cdef unique_ptr[column] repeat_strings(
column_view strings,
size_type repeat) except +
cdef unique_ptr[column] repeat_strings(
column_view strings,
column_view repeats) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/contains.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.strings.regex_program cimport regex_program
cdef extern from "cudf/strings/contains.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] contains_re(
column_view source_strings,
regex_program) except +
cdef unique_ptr[column] count_re(
column_view source_strings,
regex_program) except +
cdef unique_ptr[column] matches_re(
column_view source_strings,
regex_program) except +
cdef unique_ptr[column] like(
column_view source_strings,
string_scalar pattern,
string_scalar escape) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/wrap.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/wrap.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] wrap(
column_view source_strings,
size_type width) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/char_types.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
cdef extern from "cudf/strings/char_types/char_types.hpp" \
namespace "cudf::strings" nogil:
ctypedef enum string_character_types:
DECIMAL 'cudf::strings::string_character_types::DECIMAL'
NUMERIC 'cudf::strings::string_character_types::NUMERIC'
DIGIT 'cudf::strings::string_character_types::DIGIT'
ALPHA 'cudf::strings::string_character_types::ALPHA'
SPACE 'cudf::strings::string_character_types::SPACE'
UPPER 'cudf::strings::string_character_types::UPPER'
LOWER 'cudf::strings::string_character_types::LOWER'
ALPHANUM 'cudf::strings::string_character_types::ALPHANUM'
CASE_TYPES 'cudf::strings::string_character_types::CASE_TYPES'
ALL_TYPES 'cudf::strings::string_character_types::ALL_TYPES'
cdef extern from "cudf/strings/char_types/char_types.hpp" \
namespace "cudf::strings" nogil:
cdef unique_ptr[column] all_characters_of_type(
column_view source_strings,
string_character_types types,
string_character_types verify_types) except +
cdef unique_ptr[column] filter_characters_of_type(
column_view source_strings,
string_character_types types_to_remove,
string_scalar replacement,
string_character_types types_to_keep) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/regex_program.pxd
|
# Copyright (c) 2022-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.strings.regex_flags cimport regex_flags
cdef extern from "cudf/strings/regex/regex_program.hpp" \
namespace "cudf::strings" nogil:
cdef cppclass regex_program:
@staticmethod
unique_ptr[regex_program] create(
string pattern,
regex_flags flags
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/padding.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libc.stdint cimport int32_t
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.strings.side_type cimport side_type
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/padding.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] pad(
column_view source_strings,
size_type width,
side_type side,
string fill_char) except +
cdef unique_ptr[column] zfill(
column_view source_strings,
size_type width) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/side_type.pxd
|
# Copyright (c) 2022, NVIDIA CORPORATION.
from libc.stdint cimport int32_t
cdef extern from "cudf/strings/side_type.hpp" namespace "cudf::strings" nogil:
ctypedef enum side_type:
LEFT 'cudf::strings::side_type::LEFT'
RIGHT 'cudf::strings::side_type::RIGHT'
BOTH 'cudf::strings::side_type::BOTH'
ctypedef int32_t underlying_type_t_side_type
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/substring.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport numeric_scalar
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/slice.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] slice_strings(
column_view source_strings,
numeric_scalar[size_type] start,
numeric_scalar[size_type] end,
numeric_scalar[size_type] step) except +
cdef unique_ptr[column] slice_strings(
column_view source_strings,
column_view starts,
column_view stops) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/capitalize.pxd
|
# Copyright (c) 2020-2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "cudf/strings/capitalize.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] capitalize(
const column_view & strings) except +
cdef unique_ptr[column] title(
const column_view & strings) except +
cdef unique_ptr[column] is_title(
const column_view & strings) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/case.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "cudf/strings/case.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] to_lower(
const column_view & strings) except +
cdef unique_ptr[column] to_upper(
const column_view & strings) except +
cdef unique_ptr[column] swapcase(
const column_view & strings) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/replace.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libc.stdint cimport int32_t
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/replace.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] replace_slice(
column_view source_strings,
string_scalar repl,
size_type start,
size_type stop) except +
cdef unique_ptr[column] replace(
column_view source_strings,
string_scalar target,
string_scalar repl,
int32_t maxrepl) except +
cdef unique_ptr[column] replace(
column_view source_strings,
column_view target_strings,
column_view repl_strings) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/regex_flags.pxd
|
# Copyright (c) 2022, NVIDIA CORPORATION.
cdef extern from "cudf/strings/regex/flags.hpp" \
namespace "cudf::strings" nogil:
ctypedef enum regex_flags:
DEFAULT 'cudf::strings::regex_flags::DEFAULT'
MULTILINE 'cudf::strings::regex_flags::MULTILINE'
DOTALL 'cudf::strings::regex_flags::DOTALL'
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/replace_re.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from libcpp.vector cimport vector
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.strings.regex_program cimport regex_program
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/replace_re.hpp" namespace "cudf::strings" nogil:
cdef unique_ptr[column] replace_re(
column_view source_strings,
regex_program,
string_scalar repl,
size_type maxrepl) except +
cdef unique_ptr[column] replace_with_backrefs(
column_view source_strings,
regex_program,
string repl) except +
cdef unique_ptr[column] replace_re(
column_view source_strings,
vector[string] patterns,
column_view repls) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/split/split.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.strings.regex_program cimport regex_program
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/strings/split/split.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[table] split(
column_view source_strings,
string_scalar delimiter,
size_type maxsplit) except +
cdef unique_ptr[table] rsplit(
column_view source_strings,
string_scalar delimiter,
size_type maxsplit) except +
cdef unique_ptr[column] split_record(
column_view source_strings,
string_scalar delimiter,
size_type maxsplit) except +
cdef unique_ptr[column] rsplit_record(
column_view source_strings,
string_scalar delimiter,
size_type maxsplit) except +
cdef extern from "cudf/strings/split/split_re.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[table] split_re(
const column_view& source_strings,
regex_program,
size_type maxsplit) except +
cdef unique_ptr[table] rsplit_re(
const column_view& source_strings,
regex_program,
size_type maxsplit) except +
cdef unique_ptr[column] split_record_re(
const column_view& source_strings,
regex_program,
size_type maxsplit) except +
cdef unique_ptr[column] rsplit_record_re(
const column_view& source_strings,
regex_program,
size_type maxsplit) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/split/partition.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.table.table cimport table
cdef extern from "cudf/strings/split/partition.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[table] partition(
column_view source_strings,
string_scalar delimiter) except +
cdef unique_ptr[table] rpartition(
column_view source_strings,
string_scalar delimiter) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_ipv4.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "cudf/strings/convert/convert_ipv4.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] ipv4_to_integers(
column_view input_col) except +
cdef unique_ptr[column] integers_to_ipv4(
column_view input_col) except +
cdef unique_ptr[column] is_ipv4(
column_view source_strings
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_durations.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport data_type
cdef extern from "cudf/strings/convert/convert_durations.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] to_durations(
const column_view & strings_col,
data_type duration_type,
const string & format) except +
cdef unique_ptr[column] from_durations(
const column_view & durations,
const string & format) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_datetime.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport data_type
cdef extern from "cudf/strings/convert/convert_datetime.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] to_timestamps(
column_view input_col,
data_type timestamp_type,
string format) except +
cdef unique_ptr[column] from_timestamps(
column_view input_col,
string format,
column_view input_strings_names) except +
cdef unique_ptr[column] is_timestamp(
column_view input_col,
string format) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_integers.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport data_type
cdef extern from "cudf/strings/convert/convert_integers.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] to_integers(
column_view input_col,
data_type output_type) except +
cdef unique_ptr[column] from_integers(
column_view input_col) except +
cdef unique_ptr[column] is_integer(
column_view source_strings
) except +
cdef unique_ptr[column] hex_to_integers(
column_view input_col,
data_type output_type) except +
cdef unique_ptr[column] is_hex(
column_view source_strings
) except +
cdef unique_ptr[column] integers_to_hex(
column_view input_col) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_floats.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport data_type
cdef extern from "cudf/strings/convert/convert_floats.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] to_floats(
column_view input_col,
data_type output_type) except +
cdef unique_ptr[column] from_floats(
column_view input_col) except +
cdef unique_ptr[column] is_float(
column_view source_strings
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_urls.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "cudf/strings/convert/convert_urls.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] url_encode(
column_view input_col) except +
cdef unique_ptr[column] url_decode(
column_view input_col) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_booleans.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
cdef extern from "cudf/strings/convert/convert_booleans.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] to_booleans(
column_view input_col,
string_scalar true_string) except +
cdef unique_ptr[column] from_booleans(
column_view input_col,
string_scalar true_string,
string_scalar false_string) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_lists.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
cdef extern from "cudf/strings/convert/convert_lists.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] format_list_column(
column_view input_col,
string_scalar na_rep,
column_view separators) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/strings/convert/convert_fixed_point.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport data_type
cdef extern from "cudf/strings/convert/convert_fixed_point.hpp" namespace \
"cudf::strings" nogil:
cdef unique_ptr[column] to_fixed_point(
column_view input_col,
data_type output_type) except +
cdef unique_ptr[column] from_fixed_point(
column_view input_col) except +
cdef unique_ptr[column] is_fixed_point(
column_view source_strings,
data_type output_type
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/gather.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.lists.lists_column_view cimport lists_column_view
cdef extern from "cudf/lists/gather.hpp" namespace "cudf::lists" nogil:
cdef unique_ptr[column] segmented_gather(
const lists_column_view source_column,
const lists_column_view gather_map_list
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/combine.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.table.table_view cimport table_view
cdef extern from "cudf/lists/combine.hpp" namespace \
"cudf::lists" nogil:
ctypedef enum concatenate_null_policy:
IGNORE "cudf::lists::concatenate_null_policy::IGNORE"
NULLIFY_OUTPUT_ROW \
"cudf::lists::concatenate_null_policy::NULLIFY_OUTPUT_ROW"
cdef unique_ptr[column] concatenate_rows(
const table_view input_table
) except +
cdef unique_ptr[column] concatenate_list_elements(
const table_view input_table,
) except +
cdef unique_ptr[column] concatenate_list_elements(
const column_view input_table,
concatenate_null_policy null_policy
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/extract.pxd
|
# Copyright (c) 2021-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column, column_view
from cudf._lib.cpp.lists.lists_column_view cimport lists_column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/lists/extract.hpp" namespace "cudf::lists" nogil:
cdef unique_ptr[column] extract_list_element(
const lists_column_view,
size_type
) except +
cdef unique_ptr[column] extract_list_element(
const lists_column_view,
column_view
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/explode.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/lists/explode.hpp" namespace "cudf" nogil:
cdef unique_ptr[table] explode_outer(
const table_view,
size_type explode_column_idx,
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/stream_compaction.pxd
|
# Copyright (c) 2021-2022, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.lists.lists_column_view cimport lists_column_view
from cudf._lib.cpp.types cimport nan_equality, null_equality
cdef extern from "cudf/lists/stream_compaction.hpp" \
namespace "cudf::lists" nogil:
cdef unique_ptr[column] distinct(
const lists_column_view lists_column,
null_equality nulls_equal,
nan_equality nans_equal
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/lists_column_view.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from cudf._lib.cpp.column.column_view cimport column_view, mutable_column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/lists/lists_column_view.hpp" namespace "cudf" nogil:
cdef cppclass lists_column_view(column_view):
lists_column_view(const column_view& lists_column) except +
column_view parent() except +
column_view offsets() except +
column_view child() except +
cdef enum:
offsets_column_index "cudf::lists_column_view::offsets_column_index"
child_column_index "cudf::lists_column_view::child_column_index"
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/count_elements.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.lists.lists_column_view cimport lists_column_view
cdef extern from "cudf/lists/count_elements.hpp" namespace "cudf::lists" nogil:
cdef unique_ptr[column] count_elements(const lists_column_view) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/contains.pxd
|
# Copyright (c) 2021-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.lists.lists_column_view cimport lists_column_view
from cudf._lib.cpp.scalar.scalar cimport scalar
from cudf._lib.exception_handler cimport cudf_exception_handler
cdef extern from "cudf/lists/contains.hpp" namespace "cudf::lists" nogil:
cdef unique_ptr[column] contains(
lists_column_view lists,
scalar search_key,
) except +cudf_exception_handler
cdef unique_ptr[column] index_of(
lists_column_view lists,
scalar search_key,
) except +cudf_exception_handler
cdef unique_ptr[column] index_of(
lists_column_view lists,
column_view search_keys,
) except +cudf_exception_handler
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/lists/sorting.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.lists.lists_column_view cimport lists_column_view
from cudf._lib.cpp.types cimport null_order, order
cdef extern from "cudf/lists/sorting.hpp" namespace "cudf::lists" nogil:
cdef unique_ptr[column] sort_lists(
const lists_column_view source_column,
order column_order,
null_order null_precedence
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/jaccard.pxd
|
# Copyright (c) 2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "nvtext/jaccard.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] jaccard_index(
const column_view &input1,
const column_view &input2,
size_type width
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/normalize.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "nvtext/normalize.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] normalize_spaces(
const column_view & strings
) except +
cdef unique_ptr[column] normalize_characters(
const column_view & strings,
bool do_lower_case
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/edit_distance.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "nvtext/edit_distance.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] edit_distance(
const column_view & strings,
const column_view & targets
) except +
cdef unique_ptr[column] edit_distance_matrix(
const column_view & strings
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/tokenize.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.types cimport size_type
cdef extern from "nvtext/tokenize.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] tokenize(
const column_view & strings,
const string_scalar & delimiter
) except +
cdef unique_ptr[column] tokenize(
const column_view & strings,
const column_view & delimiters
) except +
cdef unique_ptr[column] count_tokens(
const column_view & strings,
const string_scalar & delimiter
) except +
cdef unique_ptr[column] count_tokens(
const column_view & strings,
const column_view & delimiters
) except +
cdef unique_ptr[column] character_tokenize(
const column_view & strings
) except +
cdef unique_ptr[column] detokenize(
const column_view & strings,
const column_view & row_indices,
const string_scalar & separator
) except +
cdef struct tokenize_vocabulary "nvtext::tokenize_vocabulary":
pass
cdef unique_ptr[tokenize_vocabulary] load_vocabulary(
const column_view & strings
) except +
cdef unique_ptr[column] tokenize_with_vocabulary(
const column_view & strings,
const tokenize_vocabulary & vocabulary,
const string_scalar & delimiter,
size_type default_id
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/subword_tokenize.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libc.stdint cimport uint16_t, uint32_t
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
cdef extern from "nvtext/subword_tokenize.hpp" namespace "nvtext" nogil:
cdef cppclass tokenizer_result "nvtext::tokenizer_result":
uint32_t nrows_tensor
uint32_t sequence_length
unique_ptr[column] tensor_token_ids
unique_ptr[column] tensor_attention_mask
unique_ptr[column] tensor_metadata
cdef struct hashed_vocabulary "nvtext::hashed_vocabulary":
uint16_t first_token_id
uint16_t separator_token_id
uint16_t unknown_token_id
uint32_t outer_hash_a
uint32_t outer_hash_b
uint16_t num_bin
unique_ptr[column] table
unique_ptr[column] bin_coefficients
unique_ptr[column] bin_offsets
cdef unique_ptr[hashed_vocabulary] load_vocabulary_file(
const string &filename_hashed_vocabulary
) except +
cdef tokenizer_result subword_tokenize(
const column_view & strings,
hashed_vocabulary & hashed_vocablary_obj,
uint32_t max_sequence_length,
uint32_t stride,
bool do_lower,
bool do_truncate
) except +
cdef tokenizer_result subword_tokenize(
const column_view &strings,
const string &filename_hashed_vocabulary,
uint32_t max_sequence_length,
uint32_t stride,
bool do_lower,
bool do_truncate
) except +
cdef extern from "<utility>" namespace "std" nogil:
cdef tokenizer_result move(tokenizer_result)
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/minhash.pxd
|
# Copyright (c) 2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "nvtext/minhash.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] minhash(
const column_view &strings,
const column_view &seeds,
const size_type width,
) except +
cdef unique_ptr[column] minhash64(
const column_view &strings,
const column_view &seeds,
const size_type width,
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/ngrams_tokenize.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.types cimport size_type
cdef extern from "nvtext/ngrams_tokenize.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] ngrams_tokenize(
const column_view & strings,
size_type ngrams,
const string_scalar & delimiter,
const string_scalar & separator
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/byte_pair_encode.pxd
|
# Copyright (c) 2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
cdef extern from "nvtext/byte_pair_encoding.hpp" namespace "nvtext" nogil:
cdef struct bpe_merge_pairs "nvtext::bpe_merge_pairs":
pass
cdef unique_ptr[bpe_merge_pairs] load_merge_pairs(
const column_view &merge_pairs
) except +
cdef unique_ptr[column] byte_pair_encoding(
const column_view &strings,
const bpe_merge_pairs &merge_pairs,
const string_scalar &separator
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/stemmer.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libc.stdint cimport int32_t
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.types cimport size_type
cdef extern from "nvtext/stemmer.hpp" namespace "nvtext" nogil:
ctypedef enum letter_type:
CONSONANT 'nvtext::letter_type::CONSONANT'
VOWEL 'nvtext::letter_type::VOWEL'
cdef unique_ptr[column] porter_stemmer_measure(
const column_view & strings
) except +
cdef unique_ptr[column] is_letter(
column_view source_strings,
letter_type ltype,
size_type character_index) except +
cdef unique_ptr[column] is_letter(
column_view source_strings,
letter_type ltype,
column_view indices) except +
ctypedef int32_t underlying_type_t_letter_type
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/replace.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.types cimport size_type
cdef extern from "nvtext/replace.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] replace_tokens(
const column_view & strings,
const column_view & targets,
const column_view & replacements,
const string_scalar & delimiter
) except +
cdef unique_ptr[column] filter_tokens(
const column_view & strings,
size_type min_token_length,
const string_scalar & replacement,
const string_scalar & delimiter
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/nvtext/generate_ngrams.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.scalar.scalar cimport string_scalar
from cudf._lib.cpp.types cimport size_type
cdef extern from "nvtext/generate_ngrams.hpp" namespace "nvtext" nogil:
cdef unique_ptr[column] generate_ngrams(
const column_view &strings,
size_type ngrams,
const string_scalar & separator
) except +
cdef unique_ptr[column] generate_character_ngrams(
const column_view &strings,
size_type ngrams
) except +
cdef unique_ptr[column] hash_character_ngrams(
const column_view &strings,
size_type ngrams
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/scalar/scalar.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libc.stdint cimport int32_t, int64_t
from libcpp cimport bool
from libcpp.string cimport string
from cudf._lib.cpp.column.column_view cimport column_view
from cudf._lib.cpp.table.table_view cimport table_view
from cudf._lib.cpp.types cimport data_type
from cudf._lib.cpp.wrappers.decimals cimport scale_type
cdef extern from "cudf/scalar/scalar.hpp" namespace "cudf" nogil:
cdef cppclass scalar:
scalar() except +
scalar(scalar other) except +
data_type type() except +
void set_valid_async(bool is_valid) except +
bool is_valid() except +
cdef cppclass numeric_scalar[T](scalar):
numeric_scalar() except +
numeric_scalar(numeric_scalar other) except +
numeric_scalar(T value) except +
numeric_scalar(T value, bool is_valid) except +
void set_value(T value) except +
T value() except +
cdef cppclass timestamp_scalar[T](scalar):
timestamp_scalar() except +
timestamp_scalar(timestamp_scalar other) except +
timestamp_scalar(int64_t value) except +
timestamp_scalar(int64_t value, bool is_valid) except +
timestamp_scalar(int32_t value) except +
timestamp_scalar(int32_t value, bool is_valid) except +
int64_t ticks_since_epoch_64 "ticks_since_epoch"() except +
int32_t ticks_since_epoch_32 "ticks_since_epoch"() except +
T value() except +
cdef cppclass duration_scalar[T](scalar):
duration_scalar() except +
duration_scalar(duration_scalar other) except +
duration_scalar(int64_t value) except +
duration_scalar(int64_t value, bool is_valid) except +
duration_scalar(int32_t value) except +
duration_scalar(int32_t value, bool is_valid) except +
int64_t ticks "count"() except +
T value() except +
cdef cppclass string_scalar(scalar):
string_scalar() except +
string_scalar(string st) except +
string_scalar(string st, bool is_valid) except +
string_scalar(string_scalar other) except +
string to_string() except +
cdef cppclass fixed_point_scalar[T](scalar):
fixed_point_scalar() except +
fixed_point_scalar(int64_t value,
scale_type scale,
bool is_valid) except +
fixed_point_scalar(data_type value,
scale_type scale,
bool is_valid) except +
int64_t value() except +
# TODO: Figure out how to add an int32 overload of value()
cdef cppclass list_scalar(scalar):
list_scalar(column_view col) except +
list_scalar(column_view col, bool is_valid) except +
column_view view() except +
cdef cppclass struct_scalar(scalar):
struct_scalar(table_view cols, bool valid) except +
table_view view() except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/wrappers/decimals.pxd
|
# Copyright (c) 2021-2022, NVIDIA CORPORATION.
from libc.stdint cimport int32_t, int64_t
from cudf._lib.cpp.types cimport int128
cdef extern from "cudf/fixed_point/fixed_point.hpp" namespace "numeric" nogil:
# cython type stub to help resolve to numeric::decimal64
ctypedef int64_t decimal64
# cython type stub to help resolve to numeric::decimal32
ctypedef int64_t decimal32
# cython type stub to help resolve to numeric::decimal128
ctypedef int128 decimal128
cdef cppclass scale_type:
scale_type(int32_t)
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/wrappers/timestamps.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libc.stdint cimport int64_t
cdef extern from "cudf/wrappers/timestamps.hpp" namespace "cudf" nogil:
ctypedef int64_t timestamp_s
ctypedef int64_t timestamp_ms
ctypedef int64_t timestamp_us
ctypedef int64_t timestamp_ns
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/wrappers/durations.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libc.stdint cimport int64_t
cdef extern from "cudf/wrappers/durations.hpp" namespace "cudf" nogil:
ctypedef int64_t duration_s
ctypedef int64_t duration_ms
ctypedef int64_t duration_us
ctypedef int64_t duration_ns
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/column/column_factories.pxd
|
# Copyright (c) 2020, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from cudf._lib.cpp.column.column cimport column
from cudf._lib.cpp.scalar.scalar cimport scalar
from cudf._lib.cpp.types cimport data_type, mask_state, size_type
cdef extern from "cudf/column/column_factories.hpp" namespace "cudf" nogil:
cdef unique_ptr[column] make_numeric_column(data_type type,
size_type size,
mask_state state) except +
cdef unique_ptr[column] make_column_from_scalar (const scalar & s,
size_type size) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/column/column_view.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.vector cimport vector
from cudf._lib.cpp.types cimport bitmask_type, data_type, size_type
cdef extern from "cudf/column/column_view.hpp" namespace "cudf" nogil:
cdef cppclass column_view:
column_view() except +
column_view(const column_view& other) except +
column_view& operator=(const column_view&) except +
column_view(
data_type type,
size_type size,
const void* data
) except +
column_view(
data_type type,
size_type size,
const void* data,
const bitmask_type* null_mask
) except +
column_view(
data_type type,
size_type size,
const void* data,
const bitmask_type* null_mask,
size_type null_count
) except +
column_view(
data_type type,
size_type size,
const void* data,
const bitmask_type* null_mask,
size_type null_count,
size_type offset
) except +
column_view(
data_type type,
size_type size,
const void* data,
const bitmask_type* null_mask,
size_type null_count,
size_type offset,
vector[column_view] children
) except +
const T* data[T]() except +
const T* head[T]() except +
const bitmask_type* null_mask() except +
size_type size() except +
data_type type() except +
bool nullable() except +
size_type null_count() except +
bool has_nulls() except +
size_type offset() except +
size_type num_children() except +
column_view child(size_type) except +
cdef cppclass mutable_column_view:
mutable_column_view() except +
mutable_column_view(const mutable_column_view&) except +
mutable_column_view& operator=(const mutable_column_view&) except +
mutable_column_view(
data_type type,
size_type size,
const void* data
) except +
mutable_column_view(
data_type type,
size_type size,
const void* data,
const bitmask_type* null_mask
) except +
mutable_column_view(
data_type type,
size_type size,
const void* data,
const bitmask_type* null_mask,
size_type null_count
) except +
mutable_column_view(
data_type type,
size_type size,
const void* data,
const bitmask_type* null_mask,
size_type null_count,
size_type offset
) except +
mutable_column_view(
data_type type, size_type size, const void* data,
const bitmask_type* null_mask, size_type null_count,
size_type offset, vector[mutable_column_view] children
) except +
T* data[T]() except +
T* head[T]() except +
bitmask_type* null_mask() except +
size_type size() except +
data_type type() except +
bool nullable() except +
size_type null_count() except +
bool has_nulls() except +
size_type offset() except +
size_type num_children() except +
mutable_column_view& child(size_type) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/column/column.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from rmm._lib.device_buffer cimport device_buffer
from cudf._lib.cpp.column.column_view cimport column_view, mutable_column_view
from cudf._lib.cpp.types cimport data_type, size_type
cdef extern from "cudf/column/column.hpp" namespace "cudf" nogil:
cdef cppclass column_contents "cudf::column::contents":
unique_ptr[device_buffer] data
unique_ptr[device_buffer] null_mask
vector[unique_ptr[column]] children
cdef cppclass column:
column() except +
column(const column& other) except +
column(column_view view) except +
size_type size() except +
size_type null_count() except +
bool has_nulls() except +
data_type type() except +
column_view view() except +
mutable_column_view mutable_view() except +
column_contents release() except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/utilities/host_span.pxd
|
# Copyright (c) 2021, NVIDIA CORPORATION.
from libcpp.vector cimport vector
cdef extern from "cudf/utilities/span.hpp" namespace "cudf" nogil:
cdef cppclass host_span[T]:
host_span() except +
host_span(vector[T]) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/timezone.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.optional cimport optional
from libcpp.string cimport string
from cudf._lib.cpp.table.table cimport table
cdef extern from "cudf/timezone.hpp" namespace "cudf" nogil:
unique_ptr[table] make_timezone_transition_table(
optional[string] tzif_dir,
string timezone_name
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/csv.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libc.stdint cimport uint8_t
from libcpp cimport bool
from libcpp.map cimport map
from libcpp.memory cimport shared_ptr, unique_ptr
from libcpp.string cimport string
from libcpp.vector cimport vector
cimport cudf._lib.cpp.io.types as cudf_io_types
cimport cudf._lib.cpp.table.table_view as cudf_table_view
from cudf._lib.cpp.types cimport data_type, size_type
cdef extern from "cudf/io/csv.hpp" \
namespace "cudf::io" nogil:
cdef cppclass csv_reader_options:
csv_reader_options() except +
# Getter
cudf_io_types.source_info get_source() except +
# Reader settings
cudf_io_types.compression_type get_compression() except +
size_t get_byte_range_offset() except +
size_t get_byte_range_size() except +
vector[string] get_names() except +
string get_prefix() except +
bool is_enabled_mangle_dupe_cols() except +
# Filter settings
vector[string] get_use_cols_names() except +
vector[int] get_use_cols_indexes() except +
size_type get_nrows() except +
size_type get_skiprows() except +
size_type get_skipfooter() except +
size_type get_header() except +
# Parsing settings
char get_lineterminator() except +
char get_delimiter() except +
char get_thousands() except +
char get_decimal() except +
char get_comment() except +
bool is_enabled_windowslinetermination() except +
bool is_enabled_delim_whitespace() except +
bool is_enabled_skipinitialspace() except +
bool is_enabled_skip_blank_lines() except +
cudf_io_types.quote_style get_quoting() except +
char get_quotechar() except +
bool is_enabled_doublequote() except +
vector[string] get_parse_dates_names() except +
vector[int] get_parse_dates_indexes() except +
vector[string] get_parse_hex_names() except +
vector[int] get_parse_hex_indexes() except +
# Conversion settings
vector[string] get_dtype() except +
vector[string] get_true_values() except +
vector[string] get_false_values() except +
vector[string] get_na_values() except +
bool is_enabled_keep_default_na() except +
bool is_enabled_na_filter() except +
bool is_enabled_dayfirst() except +
# setter
# Reader settings
void set_compression(cudf_io_types.compression_type comp) except +
void set_byte_range_offset(size_t val) except +
void set_byte_range_size(size_t val) except +
void set_names(vector[string] val) except +
void set_prefix(string pfx) except +
void set_mangle_dupe_cols(bool val) except +
# Filter settings
void set_use_cols_names(vector[string] col_names) except +
void set_use_cols_indexes(vector[int] col_ind) except +
void set_nrows(size_type n_rows) except +
void set_skiprows(size_type val) except +
void set_skipfooter(size_type val) except +
void set_header(size_type hdr) except +
# Parsing settings
void set_lineterminator(char val) except +
void set_delimiter(char val) except +
void set_thousands(char val) except +
void set_decimal(char val) except +
void set_comment(char val) except +
void enable_windowslinetermination(bool val) except +
void enable_delim_whitespace(bool val) except +
void enable_skipinitialspace(bool val) except +
void enable_skip_blank_lines(bool val) except +
void set_quoting(cudf_io_types.quote_style style) except +
void set_quotechar(char val) except +
void set_doublequote(bool val) except +
void set_parse_dates(vector[string]) except +
void set_parse_dates(vector[int]) except +
void set_parse_hex(vector[string]) except +
void set_parse_hex(vector[int]) except +
# Conversion settings
void set_dtypes(vector[data_type] types) except +
void set_dtypes(map[string, data_type] types) except +
void set_true_values(vector[string] vals) except +
void set_false_values(vector[string] vals) except +
void set_na_values(vector[string] vals) except +
void enable_keep_default_na(bool val) except +
void enable_na_filter(bool val) except +
void enable_dayfirst(bool val) except +
void set_timestamp_type(data_type type) except +
@staticmethod
csv_reader_options_builder builder(
cudf_io_types.source_info src
) except +
cdef cppclass csv_reader_options_builder:
csv_reader_options_builder() except +
csv_reader_options_builder(
cudf_io_types.source_info src
) except +
csv_reader_options_builder& source(
cudf_io_types.source_info info
) except +
# Reader settings
csv_reader_options_builder& compression(
cudf_io_types.compression_type comp
) except +
csv_reader_options_builder& byte_range_offset(size_t val) except +
csv_reader_options_builder& byte_range_size(size_t val) except +
csv_reader_options_builder& names(vector[string] val) except +
csv_reader_options_builder& prefix(string pfx) except +
csv_reader_options_builder& mangle_dupe_cols(bool val) except +
# Filter settings
csv_reader_options_builder& use_cols_names(
vector[string] col_names
) except +
csv_reader_options_builder& use_cols_indexes(
vector[int] col_ind
) except +
csv_reader_options_builder& nrows(size_type n_rows) except +
csv_reader_options_builder& skiprows(size_type val) except +
csv_reader_options_builder& skipfooter(size_type val) except +
csv_reader_options_builder& header(size_type hdr) except +
# Parsing settings
csv_reader_options_builder& lineterminator(char val) except +
csv_reader_options_builder& delimiter(char val) except +
csv_reader_options_builder& thousands(char val) except +
csv_reader_options_builder& decimal(char val) except +
csv_reader_options_builder& comment(char val) except +
csv_reader_options_builder& windowslinetermination(bool val) except +
csv_reader_options_builder& delim_whitespace(bool val) except +
csv_reader_options_builder& skipinitialspace(bool val) except +
csv_reader_options_builder& skip_blank_lines(bool val) except +
csv_reader_options_builder& quoting(
cudf_io_types.quote_style style
) except +
csv_reader_options_builder& quotechar(char val) except +
csv_reader_options_builder& doublequote(bool val) except +
csv_reader_options_builder& parse_dates(vector[string]) except +
csv_reader_options_builder& parse_dates(vector[int]) except +
# Conversion settings
csv_reader_options_builder& dtypes(vector[string] types) except +
csv_reader_options_builder& dtypes(vector[data_type] types) except +
csv_reader_options_builder& dtypes(
map[string, data_type] types
) except +
csv_reader_options_builder& true_values(vector[string] vals) except +
csv_reader_options_builder& false_values(vector[string] vals) except +
csv_reader_options_builder& na_values(vector[string] vals) except +
csv_reader_options_builder& keep_default_na(bool val) except +
csv_reader_options_builder& na_filter(bool val) except +
csv_reader_options_builder& dayfirst(bool val) except +
csv_reader_options_builder& timestamp_type(data_type type) except +
csv_reader_options build() except +
cdef cudf_io_types.table_with_metadata read_csv(
csv_reader_options &options
) except +
cdef cppclass csv_writer_options:
csv_writer_options() except +
cudf_io_types.sink_info get_sink() except +
cudf_table_view.table_view get_table() except +
cudf_io_types.table_metadata get_metadata() except +
string get_na_rep() except +
bool is_enabled_include_header() except +
size_type get_rows_per_chunk() except +
string get_line_terminator() except +
char get_inter_column_delimiter() except +
string get_true_value() except +
string get_false_value() except +
vector[string] get_names() except +
# setter
void set_metadata(cudf_io_types.table_metadata* val) except +
void set_na_rep(string val) except +
void enable_include_header(bool val) except +
void set_rows_per_chunk(size_type val) except +
void set_line_terminator(string term) except +
void set_inter_column_delimiter(char delim) except +
void set_true_value(string val) except +
void set_false_value(string val) except +
void set_names(vector[string] val) except +
@staticmethod
csv_writer_options_builder builder(
cudf_io_types.sink_info sink,
cudf_table_view.table_view table
) except +
cdef cppclass csv_writer_options_builder:
csv_writer_options_builder() except +
csv_writer_options_builder(
cudf_io_types.sink_info sink,
cudf_table_view.table_view table
) except +
csv_writer_options_builder& names(vector[string] val) except +
csv_writer_options_builder& na_rep(string val) except +
csv_writer_options_builder& include_header(bool val) except +
csv_writer_options_builder& rows_per_chunk(size_type val) except +
csv_writer_options_builder& line_terminator(string term) except +
csv_writer_options_builder& inter_column_delimiter(char delim) except +
csv_writer_options_builder& true_value(string val) except +
csv_writer_options_builder& false_value(string val) except +
csv_writer_options build() except +
cdef void write_csv(csv_writer_options args) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/types.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libc.stdint cimport uint8_t
from libcpp cimport bool
from libcpp.map cimport map
from libcpp.memory cimport shared_ptr, unique_ptr
from libcpp.pair cimport pair
from libcpp.string cimport string
from libcpp.unordered_map cimport unordered_map
from libcpp.vector cimport vector
from pyarrow.includes.libarrow cimport CRandomAccessFile
cimport cudf._lib.cpp.io.data_sink as cudf_io_data_sink
cimport cudf._lib.cpp.io.datasource as cudf_io_datasource
cimport cudf._lib.cpp.table.table_view as cudf_table_view
from cudf._lib.cpp.table.table cimport table
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/io/types.hpp" \
namespace "cudf::io" nogil:
ctypedef enum quote_style:
QUOTE_MINIMAL "cudf::io::quote_style::MINIMAL"
QUOTE_ALL "cudf::io::quote_style::ALL"
QUOTE_NONNUMERIC "cudf::io::quote_style::NONNUMERIC"
QUOTE_NONE "cudf::io::quote_style::NONE"
ctypedef enum compression_type:
NONE "cudf::io::compression_type::NONE"
AUTO "cudf::io::compression_type::AUTO"
SNAPPY "cudf::io::compression_type::SNAPPY"
GZIP "cudf::io::compression_type::GZIP"
BZIP2 "cudf::io::compression_type::BZIP2"
BROTLI "cudf::io::compression_type::BROTLI"
ZIP "cudf::io::compression_type::ZIP"
XZ "cudf::io::compression_type::XZ"
ZLIB "cudf::io::compression_type::ZLIB"
LZ4 "cudf::io::compression_type::LZ4"
LZO "cudf::io::compression_type::LZO"
ZSTD "cudf::io::compression_type::ZSTD"
ctypedef enum io_type:
FILEPATH "cudf::io::io_type::FILEPATH"
HOST_BUFFER "cudf::io::io_type::HOST_BUFFER"
VOID "cudf::io::io_type::VOID"
USER_IMPLEMENTED "cudf::io::io_type::USER_IMPLEMENTED"
ctypedef enum statistics_freq:
STATISTICS_NONE = 0,
STATISTICS_ROWGROUP = 1,
STATISTICS_PAGE = 2,
STATISTICS_COLUMN = 3,
ctypedef enum dictionary_policy:
NEVER = 0,
ADAPTIVE = 1,
ALWAYS = 2,
cdef cppclass column_name_info:
string name
vector[column_name_info] children
cdef cppclass table_metadata:
table_metadata() except +
vector[string] column_names
map[string, string] user_data
vector[unordered_map[string, string]] per_file_user_data
vector[column_name_info] schema_info
cdef cppclass table_with_metadata:
unique_ptr[table] tbl
table_metadata metadata
cdef cppclass column_in_metadata:
column_in_metadata& set_name(const string& name)
column_in_metadata& set_nullability(bool nullable)
column_in_metadata& set_list_column_as_map()
column_in_metadata& set_int96_timestamps(bool req)
column_in_metadata& set_decimal_precision(uint8_t precision)
column_in_metadata& child(size_type i)
column_in_metadata& set_output_as_binary(bool binary)
string get_name()
cdef cppclass table_input_metadata:
table_input_metadata() except +
table_input_metadata(const cudf_table_view.table_view& table) except +
vector[column_in_metadata] column_metadata
cdef cppclass partition_info:
size_type start_row
size_type num_rows
partition_info()
partition_info(size_type start_row, size_type num_rows) except +
cdef cppclass host_buffer:
const char* data
size_t size
host_buffer()
host_buffer(const char* data, size_t size)
cdef cppclass source_info:
io_type type
const vector[string]& filepaths() except +
const vector[host_buffer]& buffers() except +
vector[shared_ptr[CRandomAccessFile]] files
source_info() except +
source_info(const vector[string] &filepaths) except +
source_info(const vector[host_buffer] &host_buffers) except +
source_info(cudf_io_datasource.datasource *source) except +
source_info(const vector[cudf_io_datasource.datasource*] &datasources) except +
cdef cppclass sink_info:
io_type type
const vector[string]& filepaths()
const vector[vector[char] *]& buffers()
const vector[cudf_io_data_sink.data_sink *]& user_sinks()
sink_info() except +
sink_info(string file_path) except +
sink_info(vector[string] file_path) except +
sink_info(vector[char] * buffer) except +
sink_info(cudf_io_data_sink.data_sink * user_sink) except +
sink_info(vector[cudf_io_data_sink.data_sink *] user_sink) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/datasource.pxd
|
# Copyright (c) 2023, NVIDIA CORPORATION.
cdef extern from "cudf/io/datasource.hpp" \
namespace "cudf::io" nogil:
cdef cppclass datasource:
pass
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/json.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libc.stdint cimport uint8_t
from libcpp cimport bool
from libcpp.map cimport map
from libcpp.memory cimport shared_ptr, unique_ptr
from libcpp.string cimport string
from libcpp.vector cimport vector
cimport cudf._lib.cpp.io.types as cudf_io_types
cimport cudf._lib.cpp.table.table_view as cudf_table_view
from cudf._lib.cpp.types cimport data_type, size_type
cdef extern from "cudf/io/json.hpp" \
namespace "cudf::io" nogil:
cdef struct schema_element:
data_type type
map[string, schema_element] child_types
cdef cppclass json_reader_options:
json_reader_options() except +
cudf_io_types.source_info get_source() except +
vector[string] get_dtypes() except +
cudf_io_types.compression_type get_compression() except +
size_type get_byte_range_offset() except +
size_type get_byte_range_size() except +
bool is_enabled_lines() except +
bool is_enabled_dayfirst() except +
bool is_enabled_experimental() except +
# setter
void set_dtypes(vector[data_type] types) except +
void set_dtypes(map[string, schema_element] types) except +
void set_compression(
cudf_io_types.compression_type compression
) except +
void set_byte_range_offset(size_type offset) except +
void set_byte_range_size(size_type size) except +
void enable_lines(bool val) except +
void enable_dayfirst(bool val) except +
void enable_experimental(bool val) except +
void enable_keep_quotes(bool val) except +
@staticmethod
json_reader_options_builder builder(
cudf_io_types.source_info src
) except +
cdef cppclass json_reader_options_builder:
json_reader_options_builder() except +
json_reader_options_builder(
cudf_io_types.source_info src
) except +
json_reader_options_builder& dtypes(
vector[string] types
) except +
json_reader_options_builder& dtypes(
vector[data_type] types
) except +
json_reader_options_builder& dtypes(
map[string, schema_element] types
) except +
json_reader_options_builder& compression(
cudf_io_types.compression_type compression
) except +
json_reader_options_builder& byte_range_offset(
size_type offset
) except +
json_reader_options_builder& byte_range_size(
size_type size
) except +
json_reader_options_builder& lines(
bool val
) except +
json_reader_options_builder& dayfirst(
bool val
) except +
json_reader_options_builder& legacy(
bool val
) except +
json_reader_options_builder& keep_quotes(
bool val
) except +
json_reader_options build() except +
cdef cudf_io_types.table_with_metadata read_json(
json_reader_options &options) except +
cdef cppclass json_writer_options:
json_writer_options() except +
cudf_io_types.sink_info get_sink() except +
cudf_table_view.table_view get_table() except +
string get_na_rep() except +
bool is_enabled_include_nulls() except +
bool is_enabled_lines() except +
bool is_enabled_experimental() except +
size_type get_rows_per_chunk() except +
string get_true_value() except +
string get_false_value() except +
# setter
void set_table(cudf_table_view.table_view tbl) except +
void set_metadata(cudf_io_types.table_metadata meta) except +
void set_na_rep(string val) except +
void enable_include_nulls(bool val) except +
void enable_lines(bool val) except +
void set_rows_per_chunk(size_type val) except +
void set_true_value(string val) except +
void set_false_value(string val) except +
@staticmethod
json_writer_options_builder builder(
cudf_io_types.sink_info sink,
cudf_table_view.table_view tbl
) except +
cdef cppclass json_writer_options_builder:
json_writer_options_builder() except +
json_writer_options_builder(
cudf_io_types.source_info src,
cudf_table_view.table_view tbl
) except +
json_writer_options_builder& table(
cudf_table_view.table_view tbl
) except +
json_writer_options_builder& metadata(
cudf_io_types.table_metadata meta
) except +
json_writer_options_builder& na_rep(string val) except +
json_writer_options_builder& include_nulls(bool val) except +
json_writer_options_builder& lines(bool val) except +
json_writer_options_builder& rows_per_chunk(size_type val) except +
json_writer_options_builder& true_value(string val) except +
json_writer_options_builder& false_value(string val) except +
json_writer_options build() except +
cdef cudf_io_types.table_with_metadata write_json(
json_writer_options &options) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/parquet.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libc.stdint cimport uint8_t
from libcpp cimport bool
from libcpp.functional cimport reference_wrapper
from libcpp.map cimport map
from libcpp.memory cimport shared_ptr, unique_ptr
from libcpp.optional cimport optional
from libcpp.string cimport string
from libcpp.vector cimport vector
cimport cudf._lib.cpp.io.types as cudf_io_types
cimport cudf._lib.cpp.table.table_view as cudf_table_view
from cudf._lib.cpp.expressions cimport expression
from cudf._lib.cpp.types cimport data_type, size_type
cdef extern from "cudf/io/parquet.hpp" namespace "cudf::io" nogil:
cdef cppclass parquet_reader_options:
parquet_reader_options() except +
cudf_io_types.source_info get_source_info() except +
vector[vector[size_type]] get_row_groups() except +
const optional[reference_wrapper[expression]]& get_filter() except +
data_type get_timestamp_type() except +
bool is_enabled_use_pandas_metadata() except +
# setter
void set_columns(vector[string] col_names) except +
void set_row_groups(vector[vector[size_type]] row_grp) except +
void enable_use_pandas_metadata(bool val) except +
void set_timestamp_type(data_type type) except +
@staticmethod
parquet_reader_options_builder builder(
cudf_io_types.source_info src
) except +
cdef cppclass parquet_reader_options_builder:
parquet_reader_options_builder() except +
parquet_reader_options_builder(
cudf_io_types.source_info src
) except +
parquet_reader_options_builder& columns(
vector[string] col_names
) except +
parquet_reader_options_builder& row_groups(
vector[vector[size_type]] row_grp
) except +
parquet_reader_options_builder& use_pandas_metadata(
bool val
) except +
parquet_reader_options_builder& timestamp_type(
data_type type
) except +
parquet_reader_options build() except +
cdef cudf_io_types.table_with_metadata read_parquet(
parquet_reader_options args) except +
cdef cppclass parquet_writer_options:
parquet_writer_options() except +
cudf_io_types.sink_info get_sink_info() except +
cudf_io_types.compression_type get_compression() except +
cudf_io_types.statistics_freq get_stats_level() except +
cudf_table_view.table_view get_table() except +
const optional[cudf_io_types.table_input_metadata]& get_metadata(
) except +
string get_column_chunks_file_paths() except +
size_t get_row_group_size_bytes() except +
size_type get_row_group_size_rows() except +
size_t get_max_page_size_bytes() except +
size_type get_max_page_size_rows() except +
void set_partitions(
vector[cudf_io_types.partition_info] partitions
) except +
void set_metadata(
cudf_io_types.table_input_metadata m
) except +
void set_key_value_metadata(
vector[map[string, string]] kvm
) except +
void set_stats_level(
cudf_io_types.statistics_freq sf
) except +
void set_compression(
cudf_io_types.compression_type compression
) except +
void set_column_chunks_file_paths(
vector[string] column_chunks_file_paths
) except +
void set_int96_timestamps(
bool enabled
) except +
void set_utc_timestamps(
bool enabled
) except +
void set_row_group_size_bytes(size_t val) except +
void set_row_group_size_rows(size_type val) except +
void set_max_page_size_bytes(size_t val) except +
void set_max_page_size_rows(size_type val) except +
void enable_write_v2_headers(bool val) except +
void set_dictionary_policy(cudf_io_types.dictionary_policy policy)except +
@staticmethod
parquet_writer_options_builder builder(
cudf_io_types.sink_info sink_,
cudf_table_view.table_view table_
) except +
cdef cppclass parquet_writer_options_builder:
parquet_writer_options_builder() except +
parquet_writer_options_builder(
cudf_io_types.sink_info sink_,
cudf_table_view.table_view table_
) except +
parquet_writer_options_builder& partitions(
vector[cudf_io_types.partition_info] partitions
) except +
parquet_writer_options_builder& metadata(
cudf_io_types.table_input_metadata m
) except +
parquet_writer_options_builder& key_value_metadata(
vector[map[string, string]] kvm
) except +
parquet_writer_options_builder& stats_level(
cudf_io_types.statistics_freq sf
) except +
parquet_writer_options_builder& compression(
cudf_io_types.compression_type compression
) except +
parquet_writer_options_builder& column_chunks_file_paths(
vector[string] column_chunks_file_paths
) except +
parquet_writer_options_builder& int96_timestamps(
bool enabled
) except +
parquet_writer_options_builder& utc_timestamps(
bool enabled
) except +
parquet_writer_options_builder& row_group_size_bytes(
size_t val
) except +
parquet_writer_options_builder& row_group_size_rows(
size_type val
) except +
parquet_writer_options_builder& max_page_size_bytes(
size_t val
) except +
parquet_writer_options_builder& max_page_size_rows(
size_type val
) except +
parquet_writer_options_builder& write_v2_headers(
bool val
) except +
parquet_writer_options_builder& dictionary_policy(
cudf_io_types.dictionary_policy val
) except +
parquet_writer_options build() except +
cdef unique_ptr[vector[uint8_t]] write_parquet(
parquet_writer_options args
) except +
cdef cppclass chunked_parquet_writer_options:
chunked_parquet_writer_options() except +
cudf_io_types.sink_info get_sink() except +
cudf_io_types.compression_type get_compression() except +
cudf_io_types.statistics_freq get_stats_level() except +
const optional[cudf_io_types.table_input_metadata]& get_metadata(
) except +
size_t get_row_group_size_bytes() except +
size_type get_row_group_size_rows() except +
size_t get_max_page_size_bytes() except +
size_type get_max_page_size_rows() except +
void set_metadata(
cudf_io_types.table_input_metadata m
) except +
void set_key_value_metadata(
vector[map[string, string]] kvm
) except +
void set_stats_level(
cudf_io_types.statistics_freq sf
) except +
void set_compression(
cudf_io_types.compression_type compression
) except +
void set_int96_timestamps(
bool enabled
) except +
void set_utc_timestamps(
bool enabled
) except +
void set_row_group_size_bytes(size_t val) except +
void set_row_group_size_rows(size_type val) except +
void set_max_page_size_bytes(size_t val) except +
void set_max_page_size_rows(size_type val) except +
void enable_write_v2_headers(bool val) except +
void set_dictionary_policy(cudf_io_types.dictionary_policy policy)except +
@staticmethod
chunked_parquet_writer_options_builder builder(
cudf_io_types.sink_info sink_,
) except +
cdef cppclass chunked_parquet_writer_options_builder:
chunked_parquet_writer_options_builder() except +
chunked_parquet_writer_options_builder(
cudf_io_types.sink_info sink_,
) except +
chunked_parquet_writer_options_builder& metadata(
cudf_io_types.table_input_metadata m
) except +
chunked_parquet_writer_options_builder& key_value_metadata(
vector[map[string, string]] kvm
) except +
chunked_parquet_writer_options_builder& stats_level(
cudf_io_types.statistics_freq sf
) except +
chunked_parquet_writer_options_builder& compression(
cudf_io_types.compression_type compression
) except +
chunked_parquet_writer_options_builder& int96_timestamps(
bool enabled
) except +
chunked_parquet_writer_options_builder& utc_timestamps(
bool enabled
) except +
chunked_parquet_writer_options_builder& row_group_size_bytes(
size_t val
) except +
chunked_parquet_writer_options_builder& row_group_size_rows(
size_type val
) except +
chunked_parquet_writer_options_builder& max_page_size_bytes(
size_t val
) except +
chunked_parquet_writer_options_builder& max_page_size_rows(
size_type val
) except +
parquet_writer_options_builder& write_v2_headers(
bool val
) except +
parquet_writer_options_builder& dictionary_policy(
cudf_io_types.dictionary_policy val
) except +
chunked_parquet_writer_options build() except +
cdef cppclass parquet_chunked_writer:
parquet_chunked_writer() except +
parquet_chunked_writer(chunked_parquet_writer_options args) except +
parquet_chunked_writer& write(
cudf_table_view.table_view table_,
) except +
parquet_chunked_writer& write(
const cudf_table_view.table_view& table_,
const vector[cudf_io_types.partition_info]& partitions,
) except +
unique_ptr[vector[uint8_t]] close(
vector[string] column_chunks_file_paths,
) except +
cdef unique_ptr[vector[uint8_t]] merge_row_group_metadata(
const vector[unique_ptr[vector[uint8_t]]]& metadata_list
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/avro.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libcpp.string cimport string
from libcpp.vector cimport vector
cimport cudf._lib.cpp.io.types as cudf_io_types
from cudf._lib.cpp.types cimport size_type
cdef extern from "cudf/io/avro.hpp" \
namespace "cudf::io" nogil:
cdef cppclass avro_reader_options:
avro_reader_options() except +
cudf_io_types.source_info get_source() except +
vector[string] get_columns() except +
size_type get_skip_rows() except +
size_type get_num_rows() except +
# setters
void set_columns(vector[string] col_names) except +
void set_skip_rows(size_type val) except +
void set_num_rows(size_type val) except +
@staticmethod
avro_reader_options_builder builder(
cudf_io_types.source_info src
) except +
cdef cppclass avro_reader_options_builder:
avro_reader_options_builder() except +
avro_reader_options_builder(
cudf_io_types.source_info src
) except +
avro_reader_options_builder& columns(vector[string] col_names) except +
avro_reader_options_builder& skip_rows(size_type val) except +
avro_reader_options_builder& num_rows(size_type val) except +
avro_reader_options build() except +
cdef cudf_io_types.table_with_metadata read_avro(
avro_reader_options &options
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/orc_metadata.pxd
|
# Copyright (c) 2020-2021, NVIDIA CORPORATION.
from libcpp.string cimport string
from libcpp.vector cimport vector
cimport cudf._lib.cpp.io.types as cudf_io_types
cdef extern from "cudf/io/orc_metadata.hpp" \
namespace "cudf::io" nogil:
cdef cppclass raw_orc_statistics:
vector[string] column_names
vector[string] file_stats
vector[vector[string]] stripes_stats
cdef raw_orc_statistics read_raw_orc_statistics(
cudf_io_types.source_info src_info
) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/data_sink.pxd
|
# Copyright (c) 2023, NVIDIA CORPORATION.
cdef extern from "cudf/io/data_sink.hpp" \
namespace "cudf::io" nogil:
cdef cppclass data_sink:
pass
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/text.pxd
|
# Copyright (c) 2020-2022, NVIDIA CORPORATION.
from libc.stdint cimport uint64_t
from libcpp cimport bool
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from cudf._lib.cpp.column.column cimport column
cdef extern from "cudf/io/text/byte_range_info.hpp" \
namespace "cudf::io::text" nogil:
cdef cppclass byte_range_info:
byte_range_info() except +
byte_range_info(size_t offset, size_t size) except +
cdef extern from "cudf/io/text/data_chunk_source.hpp" \
namespace "cudf::io::text" nogil:
cdef cppclass data_chunk_source:
data_chunk_source() except +
cdef extern from "cudf/io/text/data_chunk_source_factories.hpp" \
namespace "cudf::io::text" nogil:
unique_ptr[data_chunk_source] make_source(string data) except +
unique_ptr[data_chunk_source] \
make_source_from_file(string filename) except +
unique_ptr[data_chunk_source] \
make_source_from_bgzip_file(string filename) except +
unique_ptr[data_chunk_source] \
make_source_from_bgzip_file(string filename,
uint64_t virtual_begin,
uint64_t virtual_end) except +
cdef extern from "cudf/io/text/multibyte_split.hpp" \
namespace "cudf::io::text" nogil:
cdef cppclass parse_options:
byte_range_info byte_range
bool strip_delimiters
parse_options() except +
unique_ptr[column] multibyte_split(data_chunk_source source,
string delimiter,
parse_options options) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/arrow_io_source.pxd
|
# Copyright (c) 2023, NVIDIA CORPORATION.
from libcpp.memory cimport shared_ptr
from libcpp.string cimport string
from pyarrow.includes.libarrow cimport CRandomAccessFile
cimport cudf._lib.cpp.io.datasource as cudf_io_datasource
cdef extern from "cudf/io/arrow_io_source.hpp" \
namespace "cudf::io" nogil:
cdef cppclass arrow_io_source(cudf_io_datasource.datasource):
arrow_io_source(const string& arrow_uri) except +
arrow_io_source(shared_ptr[CRandomAccessFile]) except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/cpp/io/orc.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libc.stdint cimport uint8_t
from libcpp cimport bool
from libcpp.map cimport map
from libcpp.memory cimport shared_ptr, unique_ptr
from libcpp.optional cimport optional
from libcpp.string cimport string
from libcpp.vector cimport vector
cimport cudf._lib.cpp.io.types as cudf_io_types
cimport cudf._lib.cpp.table.table_view as cudf_table_view
from cudf._lib.cpp.types cimport data_type, size_type
cdef extern from "cudf/io/orc.hpp" \
namespace "cudf::io" nogil:
cdef cppclass orc_reader_options:
orc_reader_options() except +
cudf_io_types.source_info get_source() except +
vector[vector[size_type]] get_stripes() except +
size_type get_skip_rows() except +
size_type get_num_rows() except +
bool is_enabled_use_index() except +
bool is_enabled_use_np_dtypes() except +
data_type get_timestamp_type() except +
bool is_enabled_decimals_as_float64() except +
int get_forced_decimals_scale() except +
void set_columns(vector[string] col_names) except +
void set_stripes(vector[vector[size_type]] strps) except +
void set_skip_rows(size_type rows) except +
void set_num_rows(size_type nrows) except +
void enable_use_index(bool val) except +
void enable_use_np_dtypes(bool val) except +
void set_timestamp_type(data_type type) except +
@staticmethod
orc_reader_options_builder builder(
cudf_io_types.source_info src
) except +
cdef cppclass orc_reader_options_builder:
orc_reader_options_builder() except +
orc_reader_options_builder(cudf_io_types.source_info &src) except +
orc_reader_options_builder& columns(vector[string] col_names) except +
orc_reader_options_builder& \
stripes(vector[vector[size_type]] strps) except +
orc_reader_options_builder& skip_rows(size_type rows) except +
orc_reader_options_builder& num_rows(size_type nrows) except +
orc_reader_options_builder& use_index(bool val) except +
orc_reader_options_builder& use_np_dtypes(bool val) except +
orc_reader_options_builder& timestamp_type(data_type type) except +
orc_reader_options build() except +
cdef cudf_io_types.table_with_metadata read_orc(
orc_reader_options opts
) except +
cdef cppclass orc_writer_options:
orc_writer_options()
cudf_io_types.sink_info get_sink() except +
cudf_io_types.compression_type get_compression() except +
bool is_enabled_statistics() except +
size_t get_stripe_size_bytes() except +
size_type get_stripe_size_rows() except +
size_type get_row_index_stride() except +
cudf_table_view.table_view get_table() except +
const optional[cudf_io_types.table_input_metadata]& get_metadata(
) except +
# setter
void set_compression(cudf_io_types.compression_type comp) except +
void enable_statistics(bool val) except +
void set_stripe_size_bytes(size_t val) except +
void set_stripe_size_rows(size_type val) except +
void set_row_index_stride(size_type val) except +
void set_table(cudf_table_view.table_view tbl) except +
void set_metadata(cudf_io_types.table_input_metadata meta) except +
void set_key_value_metadata(map[string, string] kvm) except +
@staticmethod
orc_writer_options_builder builder(
cudf_io_types.sink_info &sink,
cudf_table_view.table_view &tbl
) except +
cdef cppclass orc_writer_options_builder:
# setter
orc_writer_options_builder& compression(
cudf_io_types.compression_type comp
) except +
orc_writer_options_builder& enable_statistics(bool val) except +
orc_writer_options_builder& stripe_size_bytes(size_t val) except +
orc_writer_options_builder& stripe_size_rows(size_type val) except +
orc_writer_options_builder& row_index_stride(size_type val) except +
orc_writer_options_builder& table(
cudf_table_view.table_view tbl
) except +
orc_writer_options_builder& metadata(
cudf_io_types.table_input_metadata meta
) except +
orc_writer_options_builder& key_value_metadata(
map[string, string] kvm
) except +
orc_writer_options build() except +
cdef void write_orc(orc_writer_options options) except +
cdef cppclass chunked_orc_writer_options:
chunked_orc_writer_options() except +
cudf_io_types.sink_info get_sink() except +
cudf_io_types.compression_type get_compression() except +
bool enable_statistics() except +
size_t stripe_size_bytes() except +
size_type stripe_size_rows() except +
size_type row_index_stride() except +
cudf_table_view.table_view get_table() except +
const optional[cudf_io_types.table_input_metadata]& get_metadata(
) except +
# setter
void set_compression(cudf_io_types.compression_type comp) except +
void enable_statistics(bool val) except +
void set_stripe_size_bytes(size_t val) except +
void set_stripe_size_rows(size_type val) except +
void set_row_index_stride(size_type val) except +
void set_table(cudf_table_view.table_view tbl) except +
void set_metadata(
cudf_io_types.table_input_metadata meta
) except +
void set_key_value_metadata(map[string, string] kvm) except +
@staticmethod
chunked_orc_writer_options_builder builder(
cudf_io_types.sink_info &sink
) except +
cdef cppclass chunked_orc_writer_options_builder:
# setter
chunked_orc_writer_options_builder& compression(
cudf_io_types.compression_type comp
) except +
chunked_orc_writer_options_builder& enable_statistics(
bool val
) except +
orc_writer_options_builder& stripe_size_bytes(size_t val) except +
orc_writer_options_builder& stripe_size_rows(size_type val) except +
orc_writer_options_builder& row_index_stride(size_type val) except +
chunked_orc_writer_options_builder& table(
cudf_table_view.table_view tbl
) except +
chunked_orc_writer_options_builder& metadata(
cudf_io_types.table_input_metadata meta
) except +
chunked_orc_writer_options_builder& key_value_metadata(
map[string, string] kvm
) except +
chunked_orc_writer_options build() except +
cdef cppclass orc_chunked_writer:
orc_chunked_writer() except +
orc_chunked_writer(chunked_orc_writer_options args) except +
orc_chunked_writer& write(
cudf_table_view.table_view table_,
) except +
void close() except +
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/io/utils.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport unique_ptr
from libcpp.vector cimport vector
from cudf._lib.column cimport Column
from cudf._lib.cpp.io.data_sink cimport data_sink
from cudf._lib.cpp.io.types cimport column_name_info, sink_info, source_info
cdef source_info make_source_info(list src) except*
cdef sink_info make_sinks_info(
list src, vector[unique_ptr[data_sink]] & data) except*
cdef sink_info make_sink_info(src, unique_ptr[data_sink] & data) except*
cdef update_struct_field_names(
table,
vector[column_name_info]& schema_info)
cdef Column update_column_struct_field_names(
Column col,
column_name_info& info
)
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/io/datasource.pxd
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport shared_ptr
from cudf._lib.cpp.io.arrow_io_source cimport arrow_io_source
from cudf._lib.cpp.io.datasource cimport datasource
cdef class Datasource:
cdef datasource* get_datasource(self) except * nogil
cdef class NativeFileDatasource(Datasource):
cdef shared_ptr[arrow_io_source] c_datasource
cdef datasource* get_datasource(self) nogil
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/io/CMakeLists.txt
|
# =============================================================================
# Copyright (c) 2022, NVIDIA CORPORATION.
#
# Licensed 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.
# =============================================================================
set(cython_sources datasource.pyx utils.pyx)
set(linked_libraries cudf::cudf)
rapids_cython_create_modules(
CXX
SOURCE_FILES "${cython_sources}"
LINKED_LIBRARIES "${linked_libraries}" MODULE_PREFIX io_ ASSOCIATED_TARGETS cudf
)
set(targets_using_numpy_and_arrow_headers io_datasource io_utils)
foreach(target IN LISTS targets_using_numpy_and_arrow_headers)
target_include_directories(${target} PRIVATE "${NumPy_INCLUDE_DIRS}")
target_include_directories(${target} PRIVATE "${PYARROW_INCLUDE_DIR}")
endforeach()
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/io/utils.pyx
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from cpython.buffer cimport PyBUF_READ
from cpython.memoryview cimport PyMemoryView_FromMemory
from libcpp.memory cimport unique_ptr
from libcpp.string cimport string
from libcpp.utility cimport move
from libcpp.vector cimport vector
from cudf._lib.column cimport Column
from cudf._lib.cpp.io.data_sink cimport data_sink
from cudf._lib.cpp.io.datasource cimport datasource
from cudf._lib.cpp.io.types cimport (
column_name_info,
host_buffer,
sink_info,
source_info,
)
from cudf._lib.io.datasource cimport Datasource
import codecs
import errno
import io
import os
from cudf.api.types import is_struct_dtype
# Converts the Python source input to libcudf IO source_info
# with the appropriate type and source values
cdef source_info make_source_info(list src) except*:
if not src:
raise ValueError("Need to pass at least one source")
cdef const unsigned char[::1] c_buffer
cdef vector[host_buffer] c_host_buffers
cdef vector[string] c_files
cdef Datasource csrc
cdef vector[datasource*] c_datasources
empty_buffer = False
if isinstance(src[0], bytes):
empty_buffer = True
for buffer in src:
if (len(buffer) > 0):
c_buffer = buffer
c_host_buffers.push_back(host_buffer(<char*>&c_buffer[0],
c_buffer.shape[0]))
empty_buffer = False
elif isinstance(src[0], io.BytesIO):
for bio in src:
c_buffer = bio.getbuffer() # check if empty?
c_host_buffers.push_back(host_buffer(<char*>&c_buffer[0],
c_buffer.shape[0]))
# Otherwise src is expected to be a numeric fd, string path, or PathLike.
# TODO (ptaylor): Might need to update this check if accepted input types
# change when UCX and/or cuStreamz support is added.
elif isinstance(src[0], Datasource):
for csrc in src:
c_datasources.push_back(csrc.get_datasource())
return source_info(c_datasources)
elif isinstance(src[0], (int, float, complex, basestring, os.PathLike)):
# If source is a file, return source_info where type=FILEPATH
if not all(os.path.isfile(file) for file in src):
raise FileNotFoundError(errno.ENOENT,
os.strerror(errno.ENOENT),
src)
files = [<string> str(elem).encode() for elem in src]
c_files = files
return source_info(c_files)
else:
raise TypeError("Unrecognized input type: {}".format(type(src[0])))
if empty_buffer is True:
c_host_buffers.push_back(host_buffer(<char*>NULL, 0))
return source_info(c_host_buffers)
# Converts the Python sink input to libcudf IO sink_info.
cdef sink_info make_sinks_info(
list src, vector[unique_ptr[data_sink]] & sink
) except*:
cdef vector[data_sink *] data_sinks
cdef vector[string] paths
if isinstance(src[0], io.StringIO):
data_sinks.reserve(len(src))
for s in src:
sink.push_back(unique_ptr[data_sink](new iobase_data_sink(s)))
data_sinks.push_back(sink.back().get())
return sink_info(data_sinks)
elif isinstance(src[0], io.TextIOBase):
data_sinks.reserve(len(src))
for s in src:
# Files opened in text mode expect writes to be str rather than
# bytes, which requires conversion from utf-8. If the underlying
# buffer is utf-8, we can bypass this conversion by writing
# directly to it.
if codecs.lookup(s.encoding).name not in {"utf-8", "ascii"}:
raise NotImplementedError(f"Unsupported encoding {s.encoding}")
sink.push_back(
unique_ptr[data_sink](new iobase_data_sink(s.buffer))
)
data_sinks.push_back(sink.back().get())
return sink_info(data_sinks)
elif isinstance(src[0], io.IOBase):
data_sinks.reserve(len(src))
for s in src:
sink.push_back(unique_ptr[data_sink](new iobase_data_sink(s)))
data_sinks.push_back(sink.back().get())
return sink_info(data_sinks)
elif isinstance(src[0], (basestring, os.PathLike)):
paths.reserve(len(src))
for s in src:
paths.push_back(<string> os.path.expanduser(s).encode())
return sink_info(move(paths))
else:
raise TypeError("Unrecognized input type: {}".format(type(src)))
cdef sink_info make_sink_info(src, unique_ptr[data_sink] & sink) except*:
cdef vector[unique_ptr[data_sink]] datasinks
cdef sink_info info = make_sinks_info([src], datasinks)
if not datasinks.empty():
sink.swap(datasinks[0])
return info
# Adapts a python io.IOBase object as a libcudf IO data_sink. This lets you
# write from cudf to any python file-like object (File/BytesIO/SocketIO etc)
cdef cppclass iobase_data_sink(data_sink):
object buf
iobase_data_sink(object buf_):
this.buf = buf_
void host_write(const void * data, size_t size) with gil:
if isinstance(buf, io.StringIO):
buf.write(PyMemoryView_FromMemory(<char*>data, size, PyBUF_READ)
.tobytes().decode())
else:
buf.write(PyMemoryView_FromMemory(<char*>data, size, PyBUF_READ))
void flush() with gil:
buf.flush()
size_t bytes_written() with gil:
return buf.tell()
cdef update_struct_field_names(
table,
vector[column_name_info]& schema_info
):
for i, (name, col) in enumerate(table._data.items()):
table._data[name] = update_column_struct_field_names(
col, schema_info[i]
)
cdef Column update_column_struct_field_names(
Column col,
column_name_info& info
):
cdef vector[string] field_names
if col.children:
children = list(col.children)
for i, child in enumerate(children):
children[i] = update_column_struct_field_names(
child,
info.children[i]
)
col.set_base_children(tuple(children))
if is_struct_dtype(col):
field_names.reserve(len(col.base_children))
for i in range(info.children.size()):
field_names.push_back(info.children[i].name)
col = col._rename_fields(
field_names
)
return col
| 0 |
rapidsai_public_repos/cudf/python/cudf/cudf/_lib
|
rapidsai_public_repos/cudf/python/cudf/cudf/_lib/io/datasource.pyx
|
# Copyright (c) 2020-2023, NVIDIA CORPORATION.
from libcpp.memory cimport shared_ptr
from pyarrow.includes.libarrow cimport CRandomAccessFile
from pyarrow.lib cimport NativeFile
from cudf._lib.cpp.io.arrow_io_source cimport arrow_io_source
from cudf._lib.cpp.io.datasource cimport datasource
cdef class Datasource:
cdef datasource* get_datasource(self) except * nogil:
with gil:
raise NotImplementedError("get_datasource() should not "
+ "be directly invoked here")
cdef class NativeFileDatasource(Datasource):
def __cinit__(self, NativeFile native_file,):
cdef shared_ptr[CRandomAccessFile] ra_src
ra_src = native_file.get_random_access_file()
self.c_datasource.reset(new arrow_io_source(ra_src))
cdef datasource* get_datasource(self) nogil:
return <datasource *> (self.c_datasource.get())
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.