scanoss 1.12.2__py3-none-any.whl → 1.43.1__py3-none-any.whl

scanoss/threadeddependencies.py

@@ -1,52 +1,78 @@
 """
- SPDX-License-Identifier: MIT
-
-   Copyright (c) 2021, SCANOSS
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+SPDX-License-Identifier: MIT
+
+  Copyright (c) 2021, SCANOSS
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
 """
 
-import threading
+import json
 import queue
-from typing import Dict
+import threading
 from dataclasses import dataclass
+from enum import Enum
+from typing import Dict
 
 from .scancodedeps import ScancodeDeps
 from .scanossbase import ScanossBase
 from .scanossgrpc import ScanossGrpc
 
-DEP_FILE_PREFIX = "file="  # Default prefix to signify an existing parsed dependency file
+DEP_FILE_PREFIX = 'file='  # Default prefix to signify an existing parsed dependency file
+
+DEV_DEPENDENCIES = {
+    'dev',
+    'test',
+    'development',
+    'provided',
+    'runtime',
+    'devDependencies',
+    'dev-dependencies',
+    'testImplementation',
+    'testCompile',
+    'Test',
+    'require-dev',
+}
+
+
+# Define an enum class
+class SCOPE(Enum):
+    PRODUCTION = 'prod'
+    DEVELOPMENT = 'dev'
 
 
 @dataclass
 class ThreadedDependencies(ScanossBase):
-    """
+    """ """
 
-    """
     inputs: queue.Queue = queue.Queue()
     output: queue.Queue = queue.Queue()
 
-    def __init__(self, sc_deps: ScancodeDeps, grpc_api: ScanossGrpc, what_to_scan: str = None, debug: bool = False,
-                 trace: bool = False, quiet: bool = False) -> None:
-        """
-
-        """
+    def __init__(  # noqa: PLR0913
+        self,
+        sc_deps: ScancodeDeps,
+        grpc_api: ScanossGrpc,
+        what_to_scan: str = None,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+    ) -> None:
+        """ """
         super().__init__(debug, trace, quiet)
         self.sc_deps = sc_deps
         self.grpc_api = grpc_api
@@ -66,9 +92,20 @@ class ThreadedDependencies(ScanossBase):
                 return resp
         return None
 
-    def run(self, what_to_scan: str = None, deps_file: str = None, wait: bool = True) -> bool:
+    def run(
+        self,
+        what_to_scan: str = None,
+        deps_file: str = None,
+        wait: bool = True,
+        dep_scope: SCOPE = None,
+        dep_scope_include: str = None,
+        dep_scope_exclude: str = None,
+    ) -> bool:
         """
         Initiate a background scan for the specified file/dir
+        :param dep_scope_exclude: comma separated list of dependency scopes to exclude
+        :param dep_scope_include: comma separated list of dependency scopes to include
+        :param dep_scope: Enum dependency scope to use
         :param what_to_scan: file/folder to scan
         :param deps_file: file to decorate instead of scan (overrides what_to_scan option)
         :param wait: wait for completion
@@ -77,42 +114,105 @@ class ThreadedDependencies(ScanossBase):
         what_to_scan = what_to_scan if what_to_scan else self.what_to_scan
         self._errors = False
         try:
-            if deps_file:                                                  # Decorate the given dependencies file
+            if deps_file:  # Decorate the given dependencies file
                 self.print_msg(f'Decorating {deps_file} dependencies...')
-                self.inputs.put(f'{DEP_FILE_PREFIX}{deps_file}')           # Add to queue and have parent wait on it
-            else:                                                          # Search for dependencies to decorate
+                self.inputs.put(f'{DEP_FILE_PREFIX}{deps_file}')  # Add to queue and have parent wait on it
+            else:  # Search for dependencies to decorate
                 self.print_msg(f'Searching {what_to_scan} for dependencies...')
-                self.inputs.put(what_to_scan)                              # Add to queue and have parent wait on it
-            self._thread = threading.Thread(target=self.scan_dependencies, daemon=True)
+                self.inputs.put(what_to_scan)
+                # Add to queue and have parent wait on it
+            self._thread = threading.Thread(
+                target=self.scan_dependencies(dep_scope, dep_scope_include, dep_scope_exclude), daemon=True
+            )
             self._thread.start()
         except Exception as e:
             self.print_stderr(f'ERROR: Problem running threaded dependencies: {e}')
             self._errors = True
-        if wait and not self._errors:               # Wait for all inputs to complete
+        if wait and not self._errors:  # Wait for all inputs to complete
             self.complete()
         return False if self._errors else True
 
-    def scan_dependencies(self) -> None:
+    def filter_dependencies(self, deps, filter_dep) -> json:
+        files = deps.get('files', [])
+        # Iterate over files and their purls
+        for file in files:
+            if 'purls' in file:
+                # Filter purls with scope 'dependencies' and remove the scope field
+                file['purls'] = [
+                    {key: value for key, value in purl.items() if key != 'scope'}
+                    for purl in file['purls']
+                    if filter_dep(purl.get('scope'))
+                ]
+        # End of for loop
+
+        return {'files': [file for file in deps.get('files', []) if file.get('purls')]}
+
+    def filter_dependencies_by_scopes(
+        self, deps: json, dep_scope: SCOPE = None, dep_scope_include: str = None, dep_scope_exclude: str = None
+    ) -> json:
+        # Predefined set of scopes to filter
+
+        # Include all scopes
+        include_all = (dep_scope is None or dep_scope == '') and dep_scope_include is None and dep_scope_exclude is None
+        ## All dependencies, remove scope key
+        if include_all:
+            return self.filter_dependencies(deps, lambda purl: True)
+
+        # Use default list of scopes if a custom list is not set
+        if (dep_scope is not None and dep_scope != '') and dep_scope_include is None and dep_scope_exclude is None:
+            return self.filter_dependencies(
+                deps,
+                lambda purl: (dep_scope == SCOPE.PRODUCTION and purl not in DEV_DEPENDENCIES)
+                or dep_scope == SCOPE.DEVELOPMENT
+                and purl in DEV_DEPENDENCIES,
+            )
+
+        if (
+            (dep_scope_include is not None and dep_scope_include != '')
+            or dep_scope_exclude is not None
+            and dep_scope_exclude != ''
+        ):
+            # Create sets from comma-separated strings, if provided
+            exclude = set(dep_scope_exclude.split(',')) if dep_scope_exclude else set()
+            include = set(dep_scope_include.split(',')) if dep_scope_include else set()
+
+            # Define a lambda function that checks the inclusion/exclusion logic
+            return self.filter_dependencies(
+                deps, lambda purl: (exclude and purl not in exclude) or (not exclude and purl in include)
+            )
+        return None
+
+    def scan_dependencies(  # noqa: PLR0912
+        self, dep_scope: SCOPE = None, dep_scope_include: str = None, dep_scope_exclude: str = None
+    ) -> None:
         """
         Scan for dependencies from the given file/dir or from an input file (from the input queue).
         """
+        # TODO refactor to simplify branches based on PLR0912
         current_thread = threading.get_ident()
         self.print_trace(f'Starting dependency worker {current_thread}...')
         try:
-            what_to_scan = self.inputs.get(timeout=5)            # Begin processing the dependency request
+            what_to_scan = self.inputs.get(timeout=5)  # Begin processing the dependency request
             deps = None
-            if what_to_scan.startswith(DEP_FILE_PREFIX):         # We have a pre-parsed dependency file, load it
+            if what_to_scan.startswith(DEP_FILE_PREFIX):  # We have a pre-parsed dependency file, load it
                 deps = self.sc_deps.load_from_file(what_to_scan.strip(DEP_FILE_PREFIX))
-            else:                                                # Search the file/folder for dependency files to parse
-                if not self.sc_deps.run_scan(what_to_scan=what_to_scan):
-                    self._errors = True
-                else:
-                    deps = self.sc_deps.produce_from_file()
+            elif not self.sc_deps.run_scan(what_to_scan=what_to_scan):
+                self._errors = True
+            else:
+                deps = self.sc_deps.produce_from_file()
+                if dep_scope is not None:
+                    self.print_debug(f'Filtering {dep_scope.name} dependencies')
+                if dep_scope_include is not None:
+                    self.print_debug(f"Including dependencies with '{dep_scope_include.split(',')}' scopes")
+                if dep_scope_exclude is not None:
+                    self.print_debug(f"Excluding dependencies with '{dep_scope_exclude.split(',')}' scopes")
+                deps = self.filter_dependencies_by_scopes(deps, dep_scope, dep_scope_include, dep_scope_exclude)
+
             if not self._errors:
                 if deps is None:
                     self.print_stderr(f'Problem searching for dependencies for: {what_to_scan}')
                     self._errors = True
-                elif not deps or len(deps.get("files", [])) == 0:
+                elif not deps or len(deps.get('files', [])) == 0:
                     self.print_debug(f'No dependencies found to decorate for: {what_to_scan}')
                 else:
                     decorated_deps = self.grpc_api.get_dependencies(deps)
@@ -140,6 +240,7 @@ class ThreadedDependencies(ScanossBase):
             self._errors = True
         return True if not self._errors else False
 
+
 #
 # End of ThreadedDependencies Class
 #

scanoss/threadedscanning.py

@@ -1,41 +1,45 @@
 """
- SPDX-License-Identifier: MIT
-
-   Copyright (c) 2021, SCANOSS
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+SPDX-License-Identifier: MIT
+
+  Copyright (c) 2021, SCANOSS
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
 """
+
+import atexit
 import os
+import queue
 import sys
 import threading
-import queue
 import time
-
-from typing import Dict, List
 from dataclasses import dataclass
+from typing import Dict, List
+
 from progress.bar import Bar
 
 from .scanossapi import ScanossApi
 from .scanossbase import ScanossBase
 
-WFP_FILE_START = "file="
-MAX_ALLOWED_THREADS = int(os.environ.get("SCANOSS_MAX_ALLOWED_THREADS")) if os.environ.get("SCANOSS_MAX_ALLOWED_THREADS") else 30
+WFP_FILE_START = 'file='
+MAX_ALLOWED_THREADS = (
+    int(os.environ.get('SCANOSS_MAX_ALLOWED_THREADS')) if os.environ.get('SCANOSS_MAX_ALLOWED_THREADS') else 30
+)
 
 
 @dataclass
@@ -45,13 +49,12 @@ class ThreadedScanning(ScanossBase):
     WFP scan requests are loaded into the input queue.
     Multiple threads pull messages off this queue, process the request and put the results into an output queue
     """
-    inputs: queue.Queue = queue.Queue()
-    output: queue.Queue = queue.Queue()
+
     bar: Bar = None
 
-    def __init__(self, scanapi: ScanossApi, debug: bool = False, trace: bool = False, quiet: bool = False,
-                 nb_threads: int = 5
-                 ) -> None:
+    def __init__(
+        self, scanapi: ScanossApi, debug: bool = False, trace: bool = False, quiet: bool = False, nb_threads: int = 5
+    ) -> None:
         """
         Initialise the ThreadedScanning class
         :param scanapi: SCANOSS API to send scan requests to
@@ -61,6 +64,8 @@ class ThreadedScanning(ScanossBase):
         :param nb_threads: Number of thread to run (default 5)
         """
         super().__init__(debug, trace, quiet)
+        self.inputs = queue.Queue()
+        self.output = queue.Queue()
         self.scanapi = scanapi
         self.nb_threads = nb_threads
         self._isatty = sys.stderr.isatty()
@@ -73,6 +78,8 @@ class ThreadedScanning(ScanossBase):
         if nb_threads > MAX_ALLOWED_THREADS:
             self.print_msg(f'Warning: Requested threads too large: {nb_threads}. Reducing to {MAX_ALLOWED_THREADS}')
             self.nb_threads = MAX_ALLOWED_THREADS
+        # Register cleanup to ensure progress bar is finished on exit
+        atexit.register(self.complete_bar)
 
     @staticmethod
     def __count_files_in_wfp(wfp: str):
@@ -97,6 +104,13 @@ class ThreadedScanning(ScanossBase):
         if self.bar:
             self.bar.finish()
 
+    def __del__(self):
+        """Ensure progress bar is cleaned up when object is destroyed"""
+        try:
+            self.complete_bar()
+        except Exception:
+            pass  # Ignore errors during cleanup
+
     def set_bar(self, bar: Bar) -> None:
         """
         Set the Progress Bar to display progress while scanning
@@ -130,7 +144,7 @@ class ThreadedScanning(ScanossBase):
         :param wfp: WFP to add to queue
         """
         if wfp is None or wfp == '':
-            self.print_stderr(f'Warning: empty WFP. Skipping from scan...')
+            self.print_stderr('Warning: empty WFP. Skipping from scan...')
         else:
             self.inputs.put(wfp)
 
@@ -158,8 +172,9 @@ class ThreadedScanning(ScanossBase):
         """
         qsize = self.inputs.qsize()
         if qsize < self.nb_threads:
-            self.print_debug(f'Input queue ({qsize}) smaller than requested threads: {self.nb_threads}. '
-                             f'Reducing to queue size.')
+            self.print_debug(
+                f'Input queue ({qsize}) smaller than requested threads: {self.nb_threads}. Reducing to queue size.'
+            )
             self.nb_threads = qsize
         else:
             self.print_debug(f'Starting {self.nb_threads} threads to process {qsize} requests...')
@@ -171,7 +186,7 @@ class ThreadedScanning(ScanossBase):
         except Exception as e:
             self.print_stderr(f'ERROR: Problem running threaded scanning: {e}')
             self._errors = True
-        if wait:                    # Wait for all inputs to complete
+        if wait:  # Wait for all inputs to complete
             self.complete()
         return False if self._errors else True
 
@@ -180,7 +195,7 @@ class ThreadedScanning(ScanossBase):
         Wait for input queue to complete processing and complete the worker threads
         """
         self.inputs.join()
-        self._stop_event.set()       # Tell the worker threads to stop
+        self._stop_event.set()  # Tell the worker threads to stop
         try:
             for t in self._threads:  # Complete the threads
                 t.join(timeout=5)
@@ -199,7 +214,7 @@ class ThreadedScanning(ScanossBase):
         api_error = False
         while not self._stop_event.is_set():
             wfp = None
-            if not self.inputs.empty():          # Only try to get a message if there is one on the queue
+            if not self.inputs.empty():  # Only try to get a message if there is one on the queue
                 try:
                     wfp = self.inputs.get(timeout=5)
                     if api_error:  # API error encountered, so stop processing anymore requests
@@ -228,6 +243,7 @@ class ThreadedScanning(ScanossBase):
                 time.sleep(1)  # Sleep while waiting for the queue depth to build up
         self.print_trace(f'Thread complete ({current_thread}).')
 
+
 #
 # End of ThreadedScanning Class
 #

scanoss/utils/__init__.py

@@ -0,0 +1,23 @@
+"""
+SPDX-License-Identifier: MIT
+
+  Copyright (c) 2024, SCANOSS
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+"""

scanoss/utils/abstract_presenter.py

@@ -0,0 +1,103 @@
+from abc import ABC, abstractmethod
+
+from scanoss.scanossbase import ScanossBase
+
+
+class AbstractPresenter(ABC):
+    """
+    Abstract presenter class for presenting output in a given format.
+    Subclasses must implement the _format_json_output and _format_plain_output methods.
+    """
+
+    def __init__(
+        self,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+        output_file: str = None,
+        output_format: str = None,
+    ):
+        """
+        Initialize the presenter with the given output file and format.
+        """
+        self.AVAILABLE_OUTPUT_FORMATS = ['json', 'plain', 'cyclonedx', 'spdxlite', 'csv', 'raw']
+        self.base = ScanossBase(debug=debug, trace=trace, quiet=quiet)
+        self.output_file = output_file
+        self.output_format = output_format
+
+    def present(self, output_format: str = None, output_file: str = None):
+        """
+        Present the formatted output to a file if provided; otherwise, print to stdout.
+        """
+        file_path = output_file or self.output_file
+        fmt = output_format or self.output_format
+
+        if fmt and fmt not in self.AVAILABLE_OUTPUT_FORMATS:
+            raise ValueError(
+                f"ERROR: Invalid output format '{fmt}'. Valid values are: {', '.join(self.AVAILABLE_OUTPUT_FORMATS)}"
+            )
+
+        if fmt == 'json':
+            content = self._format_json_output()
+        elif fmt == 'plain':
+            content = self._format_plain_output()
+        elif fmt == 'cyclonedx':
+            content = self._format_cyclonedx_output()
+        elif fmt == 'spdxlite':
+            content = self._format_spdxlite_output()
+        elif fmt == 'csv':
+            content = self._format_csv_output()
+        elif fmt == 'raw':
+            content = self._format_raw_output()
+        else:
+            content = self._format_plain_output()
+
+        self._present_output(content, file_path)
+
+    def _present_output(self, content: str, file_path: str = None):
+        """
+        If a file path is provided, write to that file; otherwise, print the content to stdout.
+        """
+        self.base.print_to_file_or_stdout(content, file_path)
+
+    @abstractmethod
+    def _format_cyclonedx_output(self) -> str:
+        """
+        Return a CycloneDX string representation of the data.
+        """
+        pass
+
+    @abstractmethod
+    def _format_spdxlite_output(self) -> str:
+        """
+        Return a SPDX-Lite string representation of the data.
+        """
+        pass
+
+    @abstractmethod
+    def _format_csv_output(self) -> str:
+        """
+        Return a CSV string representation of the data.
+        """
+        pass
+
+    @abstractmethod
+    def _format_json_output(self) -> str:
+        """
+        Return a JSON string representation of the data.
+        """
+        pass
+
+    @abstractmethod
+    def _format_plain_output(self) -> str:
+        """
+        Return a plain text string representation of the data.
+        """
+        pass
+
+    @abstractmethod
+    def _format_raw_output(self) -> str:
+        """
+        Return a raw string representation of the data.
+        """
+        pass

scanoss/utils/crc64.py

@@ -0,0 +1,96 @@
+"""
+SPDX-License-Identifier: MIT
+
+  Copyright (c) 2025, SCANOSS
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+"""
+
+import struct
+from typing import List
+
+
+class CRC64:
+    """
+    CRC64 ECMA implementation matching Go's hash/crc64 package.
+    Uses polynomial: 0xC96C5795D7870F42
+    """
+
+    POLY = 0xC96C5795D7870F42
+    _TABLE = None
+
+    def __init__(self):
+        if CRC64._TABLE is None:
+            CRC64._TABLE = self._make_table()
+        self.crc = 0xFFFFFFFFFFFFFFFF  # Initial value
+
+    def _make_table(self) -> list:
+        """Generate the CRC64 lookup table."""
+        table = []
+        for i in range(256):
+            crc = i
+            for _ in range(8):
+                if crc & 1:
+                    crc = (crc >> 1) ^ self.POLY
+                else:
+                    crc >>= 1
+            table.append(crc)
+        return table
+
+    def update(self, data: bytes) -> None:
+        """Update the CRC with new data."""
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+
+        crc = self.crc
+        for b in data:
+            crc = (crc >> 8) ^ CRC64._TABLE[(crc ^ b) & 0xFF]  # Use class-level table
+        self.crc = crc
+
+    def digest(self) -> int:
+        """Get the current CRC value."""
+        return self.crc ^ 0xFFFFFFFFFFFFFFFF  # Final XOR value
+
+    def hexdigest(self):
+        """Get the current CRC value as a hexadecimal string."""
+        return format(self.digest(), '016x')
+
+    @classmethod
+    def checksum(cls, data: bytes) -> int:
+        """Calculate CRC64 checksum for the given data."""
+        crc = cls()
+        crc.update(data)
+        return crc.digest()
+
+    @classmethod
+    def get_hash_buff(cls, buff: bytes) -> List[bytes]:
+        """
+        Get the hash value of the given buffer, and converts it to 8 bytes in big-endian order.
+
+        Args:
+            buff (bytes): The buffer to get the hash value of.
+
+        Returns:
+            bytes: The hash value of the given buffer, and converts it to 8 bytes in big-endian order.
+        """
+        crc = cls()
+        crc.update(buff)
+        hash_val = crc.digest()
+
+        return list(struct.pack('>Q', hash_val))