simple-bcp 0.3.0__tar.gz

simple_bcp-0.3.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.3
+Name: simple_bcp
+Version: 0.3.0
+Summary: A Simple yet powerfult bcp wrapper
+Author: Noam Fisher
+Author-email: noam9997@gmail.com
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: annotated-types (>=0.7.0,<0.8.0)
+Requires-Dist: packaging (>=25.0,<26.0)
+Requires-Dist: pydantic (>=2.11,<3.0)

simple_bcp-0.3.0/pyproject.toml

@@ -0,0 +1,38 @@
+[tool.poetry]
+name = "simple_bcp"
+version = "0.3.0"
+description = "A Simple yet powerfult bcp wrapper"
+authors = ["Noam Fisher <noam9997@gmail.com>"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.poetry.dependencies]
+packaging = "~=25.0"
+pydantic = "~=2.11"
+annotated-types = "~=0.7.0"
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:tool.poetry.version"]
+remote.type = "gitlab"
+build_command = "poetry build"
+
+[tool.semantic_release.branches.main]
+match = "(main|master)"
+prerelease = false
+
+[tool.semantic_release.branches.develop]
+match = "develop"
+prerelease_token = "rc"
+prerelease = true
+
+[tool.semantic_release.branches.any]
+match = "*"
+prerelease_token = "dev"
+prerelease = true
+
+[build-system]
+requires = ["poetry-core~=2.1"]
+build-backend = "poetry.core.masonry.api"

simple_bcp-0.3.0/simple_bcp/__init__.py

@@ -0,0 +1,3 @@
+from ._bcp_adapter import BCPAdapter, MsSqlDatabaseParameters
+
+__all__: list[str] = ["BCPAdapter", "MsSqlDatabaseParameters"]

simple_bcp-0.3.0/simple_bcp/_bcp_adapter.py

@@ -0,0 +1,150 @@
+import enum
+import logging
+import os
+import pathlib
+import shlex
+import shutil
+import subprocess
+import sys
+from datetime import timezone, datetime
+from typing import Annotated
+
+import packaging.version
+from annotated_types import Gt
+from pydantic import BaseModel, StringConstraints, Field
+
+_POSITIVE_INT = Annotated[int, Gt(0)]
+
+
+class MsSqlDatabaseParameters(BaseModel):
+    server_hostname: Annotated[str, StringConstraints(strip_whitespace=True, min_length=1)]
+    port: Annotated[int, Field(gt=0, lt=2 ** 16)] = 1433
+    username: str
+    password: str
+    trust_server_certificate: bool = False
+
+
+class _Mode(enum.Enum):
+    IN = "in"
+    OUT = "out"
+    QUERY_OUT = "queryout"
+    FORMAT = "format"
+
+
+class BCPAdapter:
+    def __init__(self, *, bcp_executable_path: pathlib.Path | str | None = None, ):
+        self._init_logger()
+        self._init_executable_path(executable_path=bcp_executable_path)
+        self._init_bcp_version()
+
+    def _init_logger(self):
+        self._logger = logging.getLogger(self.__class__.__name__)
+
+    def _init_executable_path(self, *, executable_path: pathlib.Path | str | None):
+        if executable_path is None:
+            default = shutil.which("bcp")
+            if default is None:
+                raise FileNotFoundError(
+                    "bcp not found in PATH. Add bcp to PATH environment variable or provide bcp_executable_path explicitly")
+            executable_path = pathlib.Path(default)
+        elif isinstance(executable_path, str):
+            executable_path = pathlib.Path(executable_path)
+
+        if not executable_path.exists():
+            raise FileNotFoundError(f"{executable_path.as_posix()} not found")
+
+        if not executable_path.is_file():
+            raise OSError(f"path {executable_path} is not a file")
+
+        self._executable_path = executable_path
+
+    def _init_bcp_version(self):
+        result = self._run_bcp_command(["-v"])
+        # `bcp -v` output example:
+        # BCP Utility for Microsoft SQL Server
+        # Copyright (C) Microsoft Corporation. All rights reserved.
+        # Version 15.0.2000.5
+        raw_version = result.strip().split()[-1]
+        self._bcp_version = packaging.version.parse(raw_version)
+        self._logger.debug(f"BCP version: {self._bcp_version}", extra={"bcp_version": str(self._bcp_version)})
+
+    def _run_bcp_command(self, command_args: list[str]) -> str:
+        command = [self._executable_path.as_posix()] + command_args
+        self._logger.debug(f"Running command: `{command}`", extra={"bcp_command": shlex.join(command)})
+        return subprocess.run(command, capture_output=True, check=True).stdout.decode()
+
+    def _resolve_output_file_path(self, *, path: pathlib.Path | str | None,
+                                  default_filename: str) -> pathlib.Path:
+        if path is None:
+            path = pathlib.Path(os.getcwd()) / default_filename
+
+        if isinstance(path, str):
+            path = pathlib.Path(path)
+
+        if path.exists():
+            raise FileExistsError(
+                f"{path} already exists, bcp requires path to a file that does not exist - and will create it by itself")
+
+        directory_path = path.absolute().parent
+        if not directory_path.exists():
+            raise FileNotFoundError(f"directory {directory_path} does not exist")
+
+        return path
+
+    def _build_command_args(self, *,
+                            mode: _Mode,
+                            source_target_specification: str,
+                            file_path: pathlib.Path,
+                            database_parameters: MsSqlDatabaseParameters,
+                            options: dict[str, str | None] = None
+                            ) -> list[str]:
+        if options is None:
+            options = {}
+
+        command = [
+            source_target_specification,
+            mode.value,
+            file_path.as_posix(),
+            "-S", database_parameters.server_hostname,
+            "-U", database_parameters.username,
+            "-P", database_parameters.password,
+        ]
+        if sys.platform == "linux" and database_parameters.trust_server_certificate:
+            command.append("-u")
+
+        for key, value in options.items():
+            command.append(key)
+            if value is not None:
+                command.append(value)
+
+        return command
+
+    def download_table(self, *, table_name: str, database_parameters: MsSqlDatabaseParameters,
+                       output_file_path: pathlib.Path | str | None = None,
+                       batch_size: _POSITIVE_INT | None = None) -> pathlib.Path:
+        """
+        download table data using bcp
+
+        :param table_name: the name of the table to download
+        :param database_parameters: connection details about the database
+        :param output_file_path: output the data to this path.
+                                 Defaults to None which means let this package decide on the path.
+                                 Notice: BCP requires the file to not exist, it will be created using the provided path.
+        :param batch_size: Specifies the number of rows per batch of downloaded data
+        :return: the path of the downloaded file
+        """
+        timestamp = datetime.now(tz=timezone.utc).strftime("%Y%m%d%H%M%S%f")
+        default_filename_prefix = "-".join(["simple_bcp", self.download_table.__name__, table_name, timestamp])
+        output_file_path = self._resolve_output_file_path(path=output_file_path,
+                                                          default_filename=default_filename_prefix)
+        options: dict[str, str | None] = {
+            "-n": None # use native type
+        }
+        if batch_size is not None:
+            options["-b"] = str(batch_size)
+        command = self._build_command_args(mode=_Mode.OUT, source_target_specification=table_name,
+                                           file_path=output_file_path, database_parameters=database_parameters,
+                                           options=options)
+        self._run_bcp_command(command)
+
+        return output_file_path