duckdb 0.8.2.dev3007__cp311-cp311-win_amd64.whl → 1.4.3.dev8__cp311-cp311-win_amd64.whl

pyduckdb/__init__.py

@@ -1,61 +0,0 @@
-from .value.constant import (
-    Value,
-    NullValue,
-    BooleanValue,
-    UnsignedBinaryValue,
-    UnsignedShortValue,
-    UnsignedIntegerValue,
-    UnsignedLongValue,
-    BinaryValue,
-    ShortValue,
-    IntegerValue,
-    LongValue,
-    HugeIntegerValue,
-    FloatValue,
-    DoubleValue,
-    DecimalValue,
-    StringValue,
-    UUIDValue,
-    BitValue,
-    BlobValue,
-    DateValue,
-    IntervalValue,
-    TimestampValue,
-    TimestampSecondValue,
-    TimestampMilisecondValue,
-    TimestampNanosecondValue,
-    TimestampTimeZoneValue,
-    TimeValue,
-    TimeTimeZoneValue,
-)
-
-__all__ = [
-    "Value",
-    "NullValue",
-    "BooleanValue",
-    "UnsignedBinaryValue",
-    "UnsignedShortValue",
-    "UnsignedIntegerValue",
-    "UnsignedLongValue",
-    "BinaryValue",
-    "ShortValue",
-    "IntegerValue",
-    "LongValue",
-    "HugeIntegerValue",
-    "FloatValue",
-    "DoubleValue",
-    "DecimalValue",
-    "StringValue",
-    "UUIDValue",
-    "BitValue",
-    "BlobValue",
-    "DateValue",
-    "IntervalValue",
-    "TimestampValue",
-    "TimestampSecondValue",
-    "TimestampMilisecondValue",
-    "TimestampNanosecondValue",
-    "TimestampTimeZoneValue",
-    "TimeValue",
-    "TimeTimeZoneValue",
-]

pyduckdb/filesystem.py

@@ -1,64 +0,0 @@
-from fsspec import filesystem, AbstractFileSystem
-from fsspec.implementations.memory import MemoryFileSystem
-from shutil import copyfileobj
-from .bytes_io_wrapper import BytesIOWrapper
-from io import TextIOBase
-
-
-def is_file_like(obj):
-    # We only care that we can read from the file
-    return hasattr(obj, "read") and hasattr(obj, "seek")
-
-
-class ModifiedMemoryFileSystem(MemoryFileSystem):
-    protocol = ('DUCKDB_INTERNAL_OBJECTSTORE',)
-    # defer to the original implementation that doesn't hardcode the protocol
-    _strip_protocol = classmethod(AbstractFileSystem._strip_protocol.__func__)
-
-    # Add this manually because it's apparently missing on windows???
-    def unstrip_protocol(self, name):
-        """Format FS-specific path to generic, including protocol"""
-        protos = (self.protocol,) if isinstance(self.protocol, str) else self.protocol
-        for protocol in protos:
-            if name.startswith(f"{protocol}://"):
-                return name
-        return f"{protos[0]}://{name}"
-
-    def info(self, path, **kwargs):
-        path = self._strip_protocol(path)
-        if path in self.store:
-            filelike = self.store[path]
-            return {
-                "name": path,
-                "size": getattr(filelike, "size", 0),
-                "type": "file",
-                "created": getattr(filelike, "created", None),
-            }
-        else:
-            raise FileNotFoundError(path)
-
-    def _open(
-        self,
-        path,
-        mode="rb",
-        block_size=None,
-        autocommit=True,
-        cache_options=None,
-        **kwargs,
-    ):
-        path = self._strip_protocol(path)
-        if path in self.store:
-            f = self.store[path]
-            return f
-        else:
-            raise FileNotFoundError(path)
-
-    def add_file(self, object, path):
-        if not is_file_like(object):
-            raise ValueError("Can not read from a non file-like object")
-        path = self._strip_protocol(path)
-        if isinstance(object, TextIOBase):
-            # Wrap this so that we can return a bytes object from 'read'
-            self.store[path] = BytesIOWrapper(object)
-        else:
-            self.store[path] = object

pyduckdb/spark/__init__.py

@@ -1,7 +0,0 @@
-from .sql import SparkSession, DataFrame
-from .conf import SparkConf
-from .context import SparkContext
-from ._globals import _NoValue
-from .exception import ContributionsAcceptedError
-
-__all__ = ["SparkSession", "DataFrame", "SparkConf", "SparkContext", "ContributionsAcceptedError"]

pyduckdb/spark/conf.py

@@ -1,45 +0,0 @@
-from typing import TYPE_CHECKING, Optional, List, Tuple
-from pyduckdb.spark.exception import ContributionsAcceptedError
-
-
-class SparkConf:
-    def __init__(self):
-        raise NotImplementedError
-
-    def contains(self, key: str) -> bool:
-        raise ContributionsAcceptedError
-
-    def get(self, key: str, defaultValue: Optional[str] = None) -> Optional[str]:
-        raise ContributionsAcceptedError
-
-    def getAll(self) -> List[Tuple[str, str]]:
-        raise ContributionsAcceptedError
-
-    def set(self, key: str, value: str) -> "SparkConf":
-        raise ContributionsAcceptedError
-
-    def setAll(self, pairs: List[Tuple[str, str]]) -> "SparkConf":
-        raise ContributionsAcceptedError
-
-    def setAppName(self, value: str) -> "SparkConf":
-        raise ContributionsAcceptedError
-
-    def setExecutorEnv(
-        self, key: Optional[str] = None, value: Optional[str] = None, pairs: Optional[List[Tuple[str, str]]] = None
-    ) -> "SparkConf":
-        raise ContributionsAcceptedError
-
-    def setIfMissing(self, key: str, value: str) -> "SparkConf":
-        raise ContributionsAcceptedError
-
-    def setMaster(self, value: str) -> "SparkConf":
-        raise ContributionsAcceptedError
-
-    def setSparkHome(self, value: str) -> "SparkConf":
-        raise ContributionsAcceptedError
-
-    def toDebugString(self) -> str:
-        raise ContributionsAcceptedError
-
-
-__all__ = ["SparkConf"]

pyduckdb/spark/context.py

@@ -1,162 +0,0 @@
-from typing import Optional
-import duckdb
-from duckdb import DuckDBPyConnection
-
-from pyduckdb.spark.exception import ContributionsAcceptedError
-from pyduckdb.spark.conf import SparkConf
-
-
-class SparkContext:
-    def __init__(self, master: str):
-        self._connection = duckdb.connect(master)
-
-    @property
-    def connection(self) -> DuckDBPyConnection:
-        return self._connection
-
-    def stop(self) -> None:
-        self._connection.close()
-
-    @classmethod
-    def getOrCreate(cls, conf: Optional[SparkConf] = None) -> "SparkContext":
-        raise ContributionsAcceptedError
-
-    @classmethod
-    def setSystemProperty(cls, key: str, value: str) -> None:
-        raise ContributionsAcceptedError
-
-    @property
-    def applicationId(self) -> str:
-        raise ContributionsAcceptedError
-
-    @property
-    def defaultMinPartitions(self) -> int:
-        raise ContributionsAcceptedError
-
-    @property
-    def defaultParallelism(self) -> int:
-        raise ContributionsAcceptedError
-
-    # @property
-    # def resources(self) -> Dict[str, ResourceInformation]:
-    # 	raise ContributionsAcceptedError
-
-    @property
-    def startTime(self) -> str:
-        raise ContributionsAcceptedError
-
-    @property
-    def uiWebUrl(self) -> str:
-        raise ContributionsAcceptedError
-
-    @property
-    def version(self) -> str:
-        raise ContributionsAcceptedError
-
-    def __repr__(self) -> str:
-        raise ContributionsAcceptedError
-
-    # def accumulator(self, value: ~T, accum_param: Optional[ForwardRef('AccumulatorParam[T]')] = None) -> 'Accumulator[T]':
-    # 	pass
-
-    def addArchive(self, path: str) -> None:
-        raise ContributionsAcceptedError
-
-    def addFile(self, path: str, recursive: bool = False) -> None:
-        raise ContributionsAcceptedError
-
-    def addPyFile(self, path: str) -> None:
-        raise ContributionsAcceptedError
-
-    # def binaryFiles(self, path: str, minPartitions: Optional[int] = None) -> pyduckdb.spark.rdd.RDD[typing.Tuple[str, bytes]]:
-    # 	pass
-
-    # def binaryRecords(self, path: str, recordLength: int) -> pyduckdb.spark.rdd.RDD[bytes]:
-    # 	pass
-
-    # def broadcast(self, value: ~T) -> 'Broadcast[T]':
-    # 	pass
-
-    def cancelAllJobs(self) -> None:
-        raise ContributionsAcceptedError
-
-    def cancelJobGroup(self, groupId: str) -> None:
-        raise ContributionsAcceptedError
-
-    def dump_profiles(self, path: str) -> None:
-        raise ContributionsAcceptedError
-
-    # def emptyRDD(self) -> pyduckdb.spark.rdd.RDD[typing.Any]:
-    # 	pass
-
-    def getCheckpointDir(self) -> Optional[str]:
-        raise ContributionsAcceptedError
-
-    def getConf(self) -> SparkConf:
-        raise ContributionsAcceptedError
-
-    def getLocalProperty(self, key: str) -> Optional[str]:
-        raise ContributionsAcceptedError
-
-    # def hadoopFile(self, path: str, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
-    # 	pass
-
-    # def hadoopRDD(self, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
-    # 	pass
-
-    # def newAPIHadoopFile(self, path: str, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
-    # 	pass
-
-    # def newAPIHadoopRDD(self, inputFormatClass: str, keyClass: str, valueClass: str, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, conf: Optional[Dict[str, str]] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
-    # 	pass
-
-    # def parallelize(self, c: Iterable[~T], numSlices: Optional[int] = None) -> pyspark.rdd.RDD[~T]:
-    # 	pass
-
-    # def pickleFile(self, name: str, minPartitions: Optional[int] = None) -> pyspark.rdd.RDD[typing.Any]:
-    # 	pass
-
-    # def range(self, start: int, end: Optional[int] = None, step: int = 1, numSlices: Optional[int] = None) -> pyspark.rdd.RDD[int]:
-    # 	pass
-
-    # def runJob(self, rdd: pyspark.rdd.RDD[~T], partitionFunc: Callable[[Iterable[~T]], Iterable[~U]], partitions: Optional[Sequence[int]] = None, allowLocal: bool = False) -> List[~U]:
-    # 	pass
-
-    # def sequenceFile(self, path: str, keyClass: Optional[str] = None, valueClass: Optional[str] = None, keyConverter: Optional[str] = None, valueConverter: Optional[str] = None, minSplits: Optional[int] = None, batchSize: int = 0) -> pyspark.rdd.RDD[typing.Tuple[~T, ~U]]:
-    # 	pass
-
-    def setCheckpointDir(self, dirName: str) -> None:
-        raise ContributionsAcceptedError
-
-    def setJobDescription(self, value: str) -> None:
-        raise ContributionsAcceptedError
-
-    def setJobGroup(self, groupId: str, description: str, interruptOnCancel: bool = False) -> None:
-        raise ContributionsAcceptedError
-
-    def setLocalProperty(self, key: str, value: str) -> None:
-        raise ContributionsAcceptedError
-
-    def setLogLevel(self, logLevel: str) -> None:
-        raise ContributionsAcceptedError
-
-    def show_profiles(self) -> None:
-        raise ContributionsAcceptedError
-
-    def sparkUser(self) -> str:
-        raise ContributionsAcceptedError
-
-    # def statusTracker(self) -> pyduckdb.spark.status.StatusTracker:
-    # 	raise ContributionsAcceptedError
-
-    # def textFile(self, name: str, minPartitions: Optional[int] = None, use_unicode: bool = True) -> pyspark.rdd.RDD[str]:
-    # 	pass
-
-    # def union(self, rdds: List[pyspark.rdd.RDD[~T]]) -> pyspark.rdd.RDD[~T]:
-    # 	pass
-
-    # def wholeTextFiles(self, path: str, minPartitions: Optional[int] = None, use_unicode: bool = True) -> pyspark.rdd.RDD[typing.Tuple[str, str]]:
-    # 	pass
-
-
-__all__ = ["SparkContext"]

pyduckdb/spark/exception.py

@@ -1,9 +0,0 @@
-class ContributionsAcceptedError(NotImplementedError):
-    """
-    This method is not planned to be implemented, if you would like to implement this method
-    or show your interest in this method to other members of the community,
-    feel free to open up a PR or a Discussion over on https://github.com/duckdb/duckdb
-    """
-
-
-__all__ = ["ContributionsAcceptedError"]

pyduckdb/spark/sql/catalog.py

@@ -1,78 +0,0 @@
-from typing import List, NamedTuple, Optional
-from pyduckdb.spark.sql.session import SparkSession
-
-
-class Database(NamedTuple):
-    name: str
-    description: Optional[str]
-    locationUri: str
-
-
-class Table(NamedTuple):
-    name: str
-    database: Optional[str]
-    description: Optional[str]
-    tableType: str
-    isTemporary: bool
-
-
-class Column(NamedTuple):
-    name: str
-    description: Optional[str]
-    dataType: str
-    nullable: bool
-    isPartition: bool
-    isBucket: bool
-
-
-class Function(NamedTuple):
-    name: str
-    description: Optional[str]
-    className: str
-    isTemporary: bool
-
-
-class Catalog:
-    def __init__(self, session: SparkSession):
-        self._session = session
-
-    def listDatabases(self) -> List[Database]:
-        res = self._session.conn.sql('select * from duckdb_databases()').fetchall()
-
-        def transform_to_database(x) -> Database:
-            return Database(name=x[0], description=None, locationUri='')
-
-        databases = [transform_to_database(x) for x in res]
-        return databases
-
-    def listTables(self) -> List[Table]:
-        res = self._session.conn.sql('select * from duckdb_tables()').fetchall()
-
-        def transform_to_table(x) -> Table:
-            return Table(name=x[4], database=x[0], description=x[13], tableType='', isTemporary=x[7])
-
-        tables = [transform_to_table(x) for x in res]
-        return tables
-
-    def listColumns(self, tableName: str, dbName: Optional[str] = None) -> List[Column]:
-        query = f"""
-			select * from duckdb_columns() where table_name = '{tableName}'
-		"""
-        if dbName:
-            query += f" and database_name = '{dbName}'"
-        res = self._session.conn.sql(query).fetchall()
-
-        def transform_to_column(x) -> Column:
-            return Column(name=x[6], description=None, dataType=x[11], nullable=x[8], isPartition=False, isBucket=False)
-
-        columns = [transform_to_column(x) for x in res]
-        return columns
-
-    def listFunctions(self, dbName: Optional[str] = None) -> List[Function]:
-        raise NotImplementedError
-
-    def setCurrentDatabase(self, dbName: str) -> None:
-        raise NotImplementedError
-
-
-__all__ = ["Catalog", "Table", "Column", "Function", "Database"]

pyduckdb/spark/sql/conf.py

@@ -1,23 +0,0 @@
-from typing import Optional, Union
-from pyduckdb.spark._globals import _NoValueType, _NoValue
-from duckdb import DuckDBPyConnection
-
-
-class RuntimeConfig:
-    def __init__(self, connection: DuckDBPyConnection):
-        self._connection = connection
-
-    def set(self, key: str, value: str) -> None:
-        raise NotImplementedError
-
-    def isModifiable(self, key: str) -> bool:
-        raise NotImplementedError
-
-    def unset(self, key: str) -> None:
-        raise NotImplementedError
-
-    def get(self, key: str, default: Union[Optional[str], _NoValueType] = _NoValue) -> str:
-        raise NotImplementedError
-
-
-__all__ = ["RuntimeConfig"]

pyduckdb/spark/sql/dataframe.py

@@ -1,75 +0,0 @@
-from ..exception import ContributionsAcceptedError
-
-from typing import TYPE_CHECKING, List
-
-from .readwriter import DataFrameWriter
-from .types import Row, StructType
-from .type_utils import duckdb_to_spark_schema
-import duckdb
-
-if TYPE_CHECKING:
-    from .session import SparkSession
-
-
-class DataFrame:
-    def __init__(self, relation: duckdb.DuckDBPyRelation, session: "SparkSession"):
-        self.relation = relation
-        self.session = session
-        self._schema = duckdb_to_spark_schema(self.relation.columns, self.relation.types) if self.relation else None
-
-    def show(self) -> None:
-        self.relation.show()
-
-    def createOrReplaceTempView(self, name: str) -> None:
-        raise NotImplementedError
-
-    def createGlobalTempView(self, name: str) -> None:
-        raise NotImplementedError
-
-    @property
-    def schema(self) -> StructType:
-        """Returns the schema of this :class:`DataFrame` as a :class:`pyduckdb.spark.sql.types.StructType`.
-
-        .. versionadded:: 1.3.0
-
-        Examples
-        --------
-        >>> df.schema
-        StructType([StructField('age', IntegerType(), True),
-                    StructField('name', StringType(), True)])
-        """
-        return self._schema
-
-    @property
-    def write(self) -> DataFrameWriter:
-        return DataFrameWriter(self)
-
-    def printSchema(self):
-        raise ContributionsAcceptedError
-
-    def _cast_types(self, *types) -> "DataFrame":
-        existing_columns = self.relation.columns
-        types_count = len(types)
-        assert types_count == len(existing_columns)
-        cast_expressions = [f'"{existing}"::{target_type}' for existing, target_type in zip(existing_columns, types)]
-        cast_expressions = ', '.join(cast_expressions)
-        new_rel = self.relation.project(cast_expressions)
-        return DataFrame(new_rel, self.session)
-
-    def toDF(self, *cols) -> "DataFrame":
-        existing_columns = self.relation.columns
-        column_count = len(cols)
-        assert column_count == len(existing_columns)
-        projections = [f'"{existing}" as "{new}"' for existing, new in zip(existing_columns, cols)]
-        projections = ', '.join(projections)
-        new_rel = self.relation.project(projections)
-        return DataFrame(new_rel, self.session)
-
-    def collect(self) -> List[Row]:
-        columns = self.relation.columns
-        result = self.relation.fetchall()
-        rows = [Row(**dict(zip(columns, x))) for x in result]
-        return rows
-
-
-__all__ = ["DataFrame"]