RDBC-790 Embed RavenDB on package data + code style

Author: poissoncorp

MANIFEST.in

@@ -1,2 +1,3 @@
 graft ravendb_embedded/target/nuget
-include README.rst
+include README.rst
+recursive-exclude tests *

ravendb_embedded/embedded_server.py

@@ -60,19 +60,27 @@ def start_server(self, options_param: ServerOptions = None) -> None:
 
         start_server = Lazy(lambda: self._run_server(options))
 
-        if self.server_task and self.server_task.created and self.server_task != start_server:
+        if (
+            self.server_task
+            and self.server_task.created
+            and self.server_task != start_server
+        ):
             raise RuntimeError("The server was already started")
 
         self.server_task = start_server
 
         if options.security is not None:
-            self.client_pem_certificate_path = options.security.client_pem_certificate_path
+            self.client_pem_certificate_path = (
+                options.security.client_pem_certificate_path
+            )
             self.trust_store_path = options.security.ca_certificate_path
 
         start_server.get_value()
 
     def get_document_store(self, database: str) -> DocumentStore:
-        return self.get_document_store_from_options(DatabaseOptions.from_database_name(database))
+        return self.get_document_store_from_options(
+            DatabaseOptions.from_database_name(database)
+        )
 
     def _initialize_document_store(self, database_name, options):
         server_url = self.get_server_uri()
@@ -92,7 +100,9 @@ def _initialize_document_store(self, database_name, options):
 
         return store
 
-    def get_document_store_from_options(self, options: DatabaseOptions) -> DocumentStore:
+    def get_document_store_from_options(
+        self, options: DatabaseOptions
+    ) -> DocumentStore:
         database_name = options.database_record.database_name
 
         if not database_name or database_name.isspace():
@@ -104,20 +114,30 @@ def get_document_store_from_options(self, options: DatabaseOptions) -> DocumentS
 
         return self.document_stores.setdefault(database_name, lazy).get_value()
 
-    def _try_create_database(self, options: DatabaseOptions, store: DocumentStore) -> None:
+    def _try_create_database(
+        self, options: DatabaseOptions, store: DocumentStore
+    ) -> None:
         try:
-            store.maintenance.server.send(CreateDatabaseOperation(options.database_record))
+            store.maintenance.server.send(
+                CreateDatabaseOperation(options.database_record)
+            )
         except Exception as e:
             # Expected behavior when the database already exists
-            if "conflict" in e.args[0]:  # todo: change exc type when python client will implement conflict handling
-                self._log_debug(f"{options.database_record.database_name} already exists.")
+            if (
+                "conflict" in e.args[0]
+            ):  # todo: change exc type when python client will implement conflict handling
+                self._log_debug(
+                    f"{options.database_record.database_name} already exists."
+                )
             else:
                 raise e
 
     def get_server_uri(self) -> str:
         server = self.server_task
         if server is None:
-            raise RuntimeError("Please run start_server() before trying to use the server.")
+            raise RuntimeError(
+                "Please run start_server() before trying to use the server."
+            )
 
         return server.get_value()[0]
 
@@ -126,7 +146,9 @@ def _shutdown_server_process(self, process: subprocess.Popen) -> None:
             return
 
         with process:
-            if process.poll() is not None:  # Check if the process has already terminated
+            if (
+                process.poll() is not None
+            ):  # Check if the process has already terminated
                 return
 
             try:
@@ -172,13 +194,19 @@ def _run_server(self, options: ServerOptions) -> Tuple[str, subprocess.Popen]:
             process.stdout,
             startup_duration,
             options,
-            lambda line, builder: self.online(line, builder, url_ref, process, startup_duration, options),
+            lambda line, builder: self.online(
+                line, builder, url_ref, process, startup_duration, options
+            ),
         )
 
         if url_ref["value"] is None:
-            error_string = self.read_output(process.stderr, startup_duration, options, None)
+            error_string = self.read_output(
+                process.stderr, startup_duration, options, None
+            )
             self._shutdown_server_process(process)
-            raise RuntimeError(self.build_startup_exception_message(output_string, error_string))
+            raise RuntimeError(
+                self.build_startup_exception_message(output_string, error_string)
+            )
 
         return url_ref["value"], process
 
@@ -210,9 +238,13 @@ def online(
         options: ServerOptions,
     ):
         if line is None:
-            error_string = self.read_output(process.stderr, startup_duration, options, None)
+            error_string = self.read_output(
+                process.stderr, startup_duration, options, None
+            )
             self._shutdown_server_process(process)
-            raise RuntimeError(self.build_startup_exception_message("".join(builder), error_string))
+            raise RuntimeError(
+                self.build_startup_exception_message("".join(builder), error_string)
+            )
 
         prefix = "Server available on: "
         if line.startswith(prefix):
@@ -234,7 +266,11 @@ def read_output_line() -> Optional[str]:
                     line_ = output_queue.get_nowait()
                     return line_
                 except queue.Empty:
-                    if options.max_server_startup_time_duration - startup_duration.elapsed() <= timedelta(seconds=0):
+                    if (
+                        options.max_server_startup_time_duration
+                        - startup_duration.elapsed()
+                        <= timedelta(seconds=0)
+                    ):
                         return None
                     time.sleep(1)
 

ravendb_embedded/options.py

@@ -8,7 +8,11 @@
 from ravendb.exceptions.raven_exceptions import RavenException
 from ravendb.serverwide.database_record import DatabaseRecord
 
-from ravendb_embedded.provide import ProvideRavenDBServer, ExtractFromPkgResourceServerProvider, ExternalServerProvider
+from ravendb_embedded.provide import (
+    ProvideRavenDBServer,
+    ExtractFromPkgResourceServerProvider,
+    ExternalServerProvider,
+)
 
 
 class DatabaseOptions:
@@ -72,12 +76,16 @@ def secured(
             raise ValueError("certificate cannot be None")
 
         if self.security is not None:
-            raise RuntimeError("The security has already been set up for this ServerOptions object")
+            raise RuntimeError(
+                "The security has already been set up for this ServerOptions object"
+            )
 
         try:
             self.security = SecurityOptions()
             self.security.server_pfx_certificate_path = server_pfx_certificate_path
-            self.security.server_pfx_certificate_password = server_pfx_certificate_password
+            self.security.server_pfx_certificate_password = (
+                server_pfx_certificate_password
+            )
             self.security.client_pem_certificate_path = client_pem_certificate_path
             if ca_certificate_path:
                 self.security.ca_certificate_path = ca_certificate_path

ravendb_embedded/raven_server_runner.py

@@ -7,7 +7,9 @@
 from ravendb.exceptions.raven_exceptions import RavenException
 
 from ravendb_embedded.options import ServerOptions
-from ravendb_embedded.runtime_framework_version_matcher import RuntimeFrameworkVersionMatcher
+from ravendb_embedded.runtime_framework_version_matcher import (
+    RuntimeFrameworkVersionMatcher,
+)
 
 
 class CommandLineArgumentEscaper:
@@ -43,7 +45,9 @@ def run(options: ServerOptions) -> subprocess.Popen:
                 break
 
         if server_dll_path is None:
-            raise RavenException("Server file was not found in any of the expected locations.")
+            raise RavenException(
+                "Server file was not found in any of the expected locations."
+            )
 
         if not options.dot_net_path.strip():
             raise ValueError("dot_net_path cannot be None or whitespace")
@@ -86,7 +90,9 @@ def run(options: ServerOptions) -> subprocess.Popen:
                     ]
                 )
             if options.security.client_pem_certificate_path:
-                with open(options.security.client_pem_certificate_path, "rb") as cert_file:
+                with open(
+                    options.security.client_pem_certificate_path, "rb"
+                ) as cert_file:
                     cert_data = cert_file.read()
 
                 cert = x509.load_pem_x509_certificate(cert_data, default_backend())
@@ -112,7 +118,9 @@ def run(options: ServerOptions) -> subprocess.Popen:
             command_line_args.insert(1, framework_version)
             command_line_args.insert(1, "--fx-version")
 
-        process_builder = subprocess.Popen(command_line_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        process_builder = subprocess.Popen(
+            command_line_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
         process = process_builder
 
         return process

ravendb_embedded/runtime_framework_version_matcher.py

@@ -26,8 +26,12 @@ def match(cls, options: ServerOptions) -> str:
         return cls.match_runtime(runtime, runtimes)
 
     @staticmethod
-    def match_runtime(runtime: RuntimeFrameworkVersion, runtimes: List[RuntimeFrameworkVersion]) -> str:
-        sorted_runtimes = sorted(runtimes, key=lambda x: (x.major, x.minor, x.patch), reverse=True)
+    def match_runtime(
+        runtime: RuntimeFrameworkVersion, runtimes: List[RuntimeFrameworkVersion]
+    ) -> str:
+        sorted_runtimes = sorted(
+            runtimes, key=lambda x: (x.major, x.minor, x.patch), reverse=True
+        )
 
         for version in sorted_runtimes:
             if runtime.match(version):
@@ -44,7 +48,10 @@ def needs_match(cls, options: ServerOptions) -> bool:
             return False
 
         framework_version = options.framework_version.lower()
-        if cls.WILDCARD not in framework_version and cls.GREATER_OR_EQUAL not in framework_version:
+        if (
+            cls.WILDCARD not in framework_version
+            and cls.GREATER_OR_EQUAL not in framework_version
+        ):
             return False
 
         return True
@@ -59,14 +66,19 @@ def get_framework_versions(options: ServerOptions):
 
         try:
             with subprocess.Popen(
-                process_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+                process_command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
             ) as process:
                 inside_runtimes = False
                 runtime_lines = []
 
                 for line in process.stdout:
                     line = line.strip()
-                    if line.startswith(".NET runtimes installed:") or line.startswith(".NET Core runtimes installed:"):
+                    if line.startswith(".NET runtimes installed:") or line.startswith(
+                        ".NET Core runtimes installed:"
+                    ):
                         inside_runtimes = True
                         continue
                     if inside_runtimes and line.startswith("Microsoft.NETCore.App"):
@@ -81,7 +93,9 @@ def get_framework_versions(options: ServerOptions):
                     runtimes.append(RuntimeFrameworkVersion(values[1]))
 
         except Exception as e:
-            raise RuntimeError("Unable to execute dotnet to retrieve list of installed runtimes") from e
+            raise RuntimeError(
+                "Unable to execute dotnet to retrieve list of installed runtimes"
+            ) from e
         finally:
             if process:
                 process.kill()
@@ -100,22 +114,28 @@ def __init__(self, framework_version: str):
 
         framework_version = framework_version.lower()
 
-        suffixes = [s for s in framework_version.split(self.SUFFIX_SEPARATOR) if s.strip()]
+        suffixes = [
+            s for s in framework_version.split(self.SUFFIX_SEPARATOR) if s.strip()
+        ]
         if len(suffixes) != 1:
             framework_version = suffixes[0]
             self.suffix = self.SUFFIX_SEPARATOR.join(suffixes[1:])
         else:
             self.suffix = None
 
-        versions = [v.strip() for v in framework_version.split(self.SEPARATORS) if v.strip()]
+        versions = [
+            v.strip() for v in framework_version.split(self.SEPARATORS) if v.strip()
+        ]
         for i, version in enumerate(versions):
             if RuntimeFrameworkVersionMatcher.WILDCARD not in version:
                 tuple_values = self.parse(version)
                 self._set(i, version, *tuple_values)
                 continue
 
             if version != RuntimeFrameworkVersionMatcher.WILDCARD:
-                raise RuntimeError(f"Wildcard character must be a sole part of the version string, but was '{version}'")
+                raise RuntimeError(
+                    f"Wildcard character must be a sole part of the version string, but was '{version}'"
+                )
 
             self._set(i, None, None, MatchingType.EQUAL)
 
@@ -161,12 +181,22 @@ def parse(value: str) -> Tuple[int, MatchingType]:
         value_as_int = int(value_to_parse)
         return value_as_int, matching_type
 
-    def _set(self, i: int, value_as_string: Optional[str], value: Optional[int], matching_type: MatchingType) -> None:
+    def _set(
+        self,
+        i: int,
+        value_as_string: Optional[str],
+        value: Optional[int],
+        matching_type: MatchingType,
+    ) -> None:
         if i == 0:
-            self.assert_matching_type("major", value_as_string, MatchingType.EQUAL, matching_type)
+            self.assert_matching_type(
+                "major", value_as_string, MatchingType.EQUAL, matching_type
+            )
             self.major = value
         elif i == 1:
-            self.assert_matching_type("minor", value_as_string, MatchingType.EQUAL, matching_type)
+            self.assert_matching_type(
+                "minor", value_as_string, MatchingType.EQUAL, matching_type
+            )
             self.minor = value
         elif i == 2:
             self.assert_matching_type("patch", value_as_string, None, matching_type)
@@ -189,7 +219,10 @@ def assert_matching_type(
                 f"is not allowed when suffix ('{self.suffix}') is set."
             )
 
-        if expected_matching_type is not None and expected_matching_type != matching_type:
+        if (
+            expected_matching_type is not None
+            and expected_matching_type != matching_type
+        ):
             raise RuntimeError(
                 f"Cannot set '{field_name}' with value '{value_as_string}' "
                 f"because '{self.matching_type_to_string(matching_type)}' "
@@ -213,9 +246,15 @@ def match(self, version: RuntimeFrameworkVersion) -> bool:
             return False
 
         if self.patch is not None:
-            if self.patch_matching_type == MatchingType.EQUAL and self.patch != version.patch:
+            if (
+                self.patch_matching_type == MatchingType.EQUAL
+                and self.patch != version.patch
+            ):
                 return False
-            elif self.patch_matching_type == MatchingType.GREATER_OR_EQUAL and self.patch > version.patch:
+            elif (
+                self.patch_matching_type == MatchingType.GREATER_OR_EQUAL
+                and self.patch > version.patch
+            ):
                 return False
 
         return self.suffix == version.suffix

requirements.txt

@@ -1,4 +1,3 @@
 setuptools~=68.2.0
 ravendb>=5.2.4
-cryptography~=42.0.0
-tqdm~=4.66.1
+cryptography~=42.0.0