credsweeper 1.12.1__py3-none-any.whl → 1.13.3__py3-none-any.whl

credsweeper/deep_scanner/rtf_scanner.py

@@ -0,0 +1,41 @@
+import logging
+from abc import ABC
+from typing import List, Optional
+
+from striprtf import striprtf
+
+from credsweeper.credentials.candidate import Candidate
+from credsweeper.deep_scanner.abstract_scanner import AbstractScanner
+from credsweeper.file_handler.data_content_provider import DataContentProvider
+from credsweeper.file_handler.string_content_provider import StringContentProvider
+from credsweeper.utils.util import Util
+
+logger = logging.getLogger(__name__)
+
+
+class RtfScanner(AbstractScanner, ABC):
+    """Implements squash file system scanning"""
+
+    @staticmethod
+    def get_lines(text: str) -> List[str]:
+        """Extracts text lines from RTF format"""
+        rtf_text = striprtf.rtf_to_text(text)
+        lines = Util.split_text(rtf_text)
+        return lines
+
+    def data_scan(
+            self,  #
+            data_provider: DataContentProvider,  #
+            depth: int,  #
+            recursive_limit_size: int) -> Optional[List[Candidate]]:
+        """Scans data as RTF"""
+        try:
+            string_data_provider = StringContentProvider(lines=RtfScanner.get_lines(data_provider.text),
+                                                         file_path=data_provider.file_path,
+                                                         file_type=data_provider.file_type,
+                                                         info=f"{data_provider.info}|RTF")
+            rtf_candidates = self.scanner.scan(string_data_provider)
+            return rtf_candidates
+        except Exception as rtf_exc:
+            logger.error(f"{data_provider.file_path}:{rtf_exc}")
+        return None

credsweeper/deep_scanner/strings_scanner.py

@@ -0,0 +1,52 @@
+import logging
+from abc import ABC
+from typing import List, Optional, Tuple
+
+from credsweeper.common.constants import MIN_DATA_LEN
+from credsweeper.credentials.candidate import Candidate
+from credsweeper.deep_scanner.abstract_scanner import AbstractScanner
+from credsweeper.file_handler.data_content_provider import DataContentProvider
+from credsweeper.file_handler.string_content_provider import StringContentProvider
+
+logger = logging.getLogger(__name__)
+
+
+class StringsScanner(AbstractScanner, ABC):
+    """Implements known binary file scanning with ASCII strings representations"""
+
+    @staticmethod
+    def get_strings(data: bytes) -> List[Tuple[str, int]]:
+        """Processes binary to found ASCII strings. Use offset instead line number."""
+        strings = []
+        offset = 0
+        line = ''
+        for n, x in enumerate(data):
+            if 0x09 == x or 0x20 <= x <= 0x7E:
+                # TAB, SPACE and visible ASCII symbols
+                if not offset:
+                    # for line number
+                    offset = n
+                line += chr(x)
+            elif MIN_DATA_LEN <= len(line):
+                strings.append((line, offset))
+                offset = 0
+                line = ''
+        if MIN_DATA_LEN <= len(line):
+            strings.append((line, offset))
+        return strings
+
+    def data_scan(
+            self,  #
+            data_provider: DataContentProvider,  #
+            depth: int,  #
+            recursive_limit_size: int) -> Optional[List[Candidate]]:
+        """Extracts data file from .ar (debian) archive and launches data_scan"""
+
+        if strings := StringsScanner.get_strings(data_provider.data):
+            string_data_provider = StringContentProvider(lines=[x[0] for x in strings],
+                                                         line_numbers=[x[1] for x in strings],
+                                                         file_path=data_provider.file_path,
+                                                         file_type=data_provider.file_type,
+                                                         info=f"{data_provider.info}|STRINGS")
+            return self.scanner.scan(string_data_provider)
+        return None if strings is None else []

credsweeper/file_handler/byte_content_provider.py

@@ -1,3 +1,4 @@
+import logging
 from functools import cached_property
 from typing import List, Optional, Generator
 
@@ -5,6 +6,8 @@ from credsweeper.file_handler.analysis_target import AnalysisTarget
 from credsweeper.file_handler.content_provider import ContentProvider
 from credsweeper.utils.util import Util
 
+logger = logging.getLogger(__name__)
+
 
 class ByteContentProvider(ContentProvider):
     """Allow to scan byte sequence instead of extra reading a file"""
@@ -42,7 +45,13 @@ class ByteContentProvider(ContentProvider):
     def lines(self) -> List[str]:
         """lines RO getter for ByteContentProvider"""
         if self.__lines is None:
-            self.__lines = Util.decode_bytes(self.__data)
+            text = Util.decode_text(self.__data)
+            if text is None:
+                logger.warning("Binary data detected %s %s %s", self.file_path, self.info,
+                               repr(self.__data[:32]) if isinstance(self.__data, bytes) else "NONE")
+                self.__lines = []
+            else:
+                self.__lines = Util.split_text(text)
         return self.__lines if self.__lines is not None else []
 
     def yield_analysis_target(self, min_len: int) -> Generator[AnalysisTarget, None, None]:

credsweeper/file_handler/file_path_extractor.py

@@ -127,6 +127,8 @@ class FilePathExtractor:
         Return:
             True when the file full path should be excluded according config
         """
+        if config.pedantic:
+            return False
         path = path.replace('\\', '/')
         lower_path = path.lower()
         if config.not_allowed_path_pattern.match(lower_path):

credsweeper/file_handler/text_content_provider.py

@@ -54,7 +54,13 @@ class TextContentProvider(ContentProvider):
     def lines(self) -> Optional[List[str]]:
         """lines getter for TextContentProvider"""
         if self.__lines is None:
-            self.__lines = Util.decode_bytes(self.data)
+            text = Util.decode_text(self.data)
+            if text is None:
+                logger.warning("Binary file detected %s %s %s", self.file_path, self.info,
+                               repr(self.__data[:32]) if isinstance(self.__data, bytes) else "NONE")
+                self.__lines = []
+            else:
+                self.__lines = Util.split_text(text)
         return self.__lines if self.__lines is not None else []
 
     def yield_analysis_target(self, min_len: int) -> Generator[AnalysisTarget, None, None]:

credsweeper/filters/__init__.py

@@ -13,7 +13,6 @@ from credsweeper.filters.value_base64_part_check import ValueBase64PartCheck
 from credsweeper.filters.value_basic_auth_check import ValueBasicAuthCheck
 from credsweeper.filters.value_blocklist_check import ValueBlocklistCheck
 from credsweeper.filters.value_camel_case_check import ValueCamelCaseCheck
-from credsweeper.filters.value_couple_keyword_check import ValueCoupleKeywordCheck
 from credsweeper.filters.value_dictionary_keyword_check import ValueDictionaryKeywordCheck
 from credsweeper.filters.value_discord_bot_check import ValueDiscordBotCheck
 from credsweeper.filters.value_entropy_base32_check import ValueEntropyBase32Check
@@ -30,6 +29,7 @@ from credsweeper.filters.value_json_web_token_check import ValueJsonWebTokenChec
 from credsweeper.filters.value_last_word_check import ValueLastWordCheck
 from credsweeper.filters.value_length_check import ValueLengthCheck
 from credsweeper.filters.value_method_check import ValueMethodCheck
+from credsweeper.filters.value_morphemes_check import ValueMorphemesCheck
 from credsweeper.filters.value_not_allowed_pattern_check import ValueNotAllowedPatternCheck
 from credsweeper.filters.value_not_part_encoded_check import ValueNotPartEncodedCheck
 from credsweeper.filters.value_number_check import ValueNumberCheck

credsweeper/filters/group/token_pattern.py

@@ -1,6 +1,6 @@
 from credsweeper.common.constants import GroupType
 from credsweeper.config.config import Config
-from credsweeper.filters import ValueCoupleKeywordCheck, ValueCamelCaseCheck, ValueNumberCheck, ValuePatternCheck
+from credsweeper.filters import ValueMorphemesCheck, ValueCamelCaseCheck, ValueNumberCheck, ValuePatternCheck
 from credsweeper.filters.group.group import Group
 
 
@@ -10,7 +10,7 @@ class TokenPattern(Group):
     def __init__(self, config: Config) -> None:
         super().__init__(config, GroupType.DEFAULT)
         self.filters = [
-            ValueCoupleKeywordCheck(),
+            ValueMorphemesCheck(),
             ValueNumberCheck(),
             ValueCamelCaseCheck(),
             ValuePatternCheck(),

credsweeper/filters/group/weird_base36_token.py

@@ -1,6 +1,6 @@
 from credsweeper.common.constants import GroupType
 from credsweeper.config.config import Config
-from credsweeper.filters import ValueCoupleKeywordCheck, ValuePatternCheck, ValueNumberCheck, ValueEntropyBase36Check, \
+from credsweeper.filters import ValueMorphemesCheck, ValuePatternCheck, ValueNumberCheck, ValueEntropyBase36Check, \
     ValueTokenBase36Check
 from credsweeper.filters.group.group import Group
 
@@ -11,9 +11,9 @@ class WeirdBase36Token(Group):
     def __init__(self, config: Config) -> None:
         super().__init__(config, GroupType.DEFAULT)
         self.filters = [
-            ValueCoupleKeywordCheck(),
+            ValueMorphemesCheck(threshold=1),
             ValuePatternCheck(),
             ValueNumberCheck(),
             ValueTokenBase36Check(),
-            ValueEntropyBase36Check()
+            ValueEntropyBase36Check(),
         ]

credsweeper/filters/group/weird_base64_token.py

@@ -1,6 +1,6 @@
 from credsweeper.common.constants import GroupType
 from credsweeper.config.config import Config
-from credsweeper.filters import ValueCoupleKeywordCheck, ValueNotPartEncodedCheck, \
+from credsweeper.filters import ValueMorphemesCheck, ValueNotPartEncodedCheck, \
     ValueBase64DataCheck, ValueEntropyBase64Check, ValuePatternCheck, ValueNumberCheck, ValueTokenBase64Check, \
     ValueBase64PartCheck
 from credsweeper.filters.group.group import Group
@@ -12,7 +12,7 @@ class WeirdBase64Token(Group):
     def __init__(self, config: Config) -> None:
         super().__init__(config, GroupType.DEFAULT)
         self.filters = [
-            ValueCoupleKeywordCheck(),
+            ValueMorphemesCheck(threshold=1),
             ValueNumberCheck(),
             ValueBase64DataCheck(),
             ValueTokenBase64Check(),

credsweeper/filters/value_camel_case_check.py

@@ -12,7 +12,7 @@ from credsweeper.utils.util import Util
 class ValueCamelCaseCheck(Filter):
     """Check that candidate is not written in camel case."""
 
-    CAMEL_CASE = ["^([a-z]+([A-Z][a-z]+)+)$", "^([A-Z][a-z]+([A-Z][a-z]+)+)$"]
+    CAMEL_CASE = ["[a-z]+([A-Z][a-z]+)+", "[A-Z][a-z]+([A-Z][a-z]+)+"]
     CAMEL_CASE_PATTERN = re.compile(Util.get_regex_combine_or(CAMEL_CASE))
 
     def __init__(self, config: Optional[Config] = None) -> None:
@@ -31,7 +31,7 @@ class ValueCamelCaseCheck(Filter):
         """
         if line_data.is_well_quoted_value:
             return False
-        if self.CAMEL_CASE_PATTERN.match(line_data.value):
+        if self.CAMEL_CASE_PATTERN.fullmatch(line_data.value):
             return static_keyword_checklist.check_morphemes(line_data.value.lower(), 1)
 
         return False

credsweeper/filters/value_file_path_check.py

@@ -35,6 +35,8 @@ class ValueFilePathCheck(Filter):
 
         """
         value = line_data.value
+        bit_length = len(value).bit_length()
+        morpheme_threshold = 1 if 6 > bit_length else bit_length - 4
         contains_unix_separator = '/' in value
         if contains_unix_separator:
             if ("://" in value  #
@@ -45,14 +47,14 @@ class ValueFilePathCheck(Filter):
                     or value.startswith("//") and ':' == line_data.separator):
                 # common case for url definition or aliases
                 # or _keyword_://example.com where : is the separator
-                return static_keyword_checklist.check_morphemes(value.lower(), 1)
+                return static_keyword_checklist.check_morphemes(value.lower(), morpheme_threshold)
             # base64 encoded data might look like linux path
             min_entropy = ValueEntropyBase64Check.get_min_data_entropy(len(value))
             # get minimal entropy to compare with shannon entropy of found value
             # min_entropy == 0 means that the value cannot be checked with the entropy due high variance
             for i in value:
                 if i not in self.base64stdpad_possible_set:
-                    # value contains wrong BASE64STDPAD_CHARS symbols like -_
+                    # value contains wrong BASE64STDPAD_CHARS symbols like -_.
                     break
             else:
                 # all symbols are from base64 alphabet
@@ -74,5 +76,5 @@ class ValueFilePathCheck(Filter):
                     break
             else:
                 if contains_unix_separator ^ contains_windows_separator:
-                    return static_keyword_checklist.check_morphemes(value.lower(), 1)
+                    return static_keyword_checklist.check_morphemes(value.lower(), morpheme_threshold)
         return False

credsweeper/filters/value_github_check.py

@@ -12,7 +12,7 @@ from credsweeper.filters.filter import Filter
 
 
 class ValueGitHubCheck(Filter):
-    """GitHub Classic Token validation"""
+    """NPM or GitHub Classic Token validation"""
 
     def __init__(self, config: Optional[Config] = None) -> None:
         pass
@@ -29,8 +29,9 @@ class ValueGitHubCheck(Filter):
 
         """
         # https://github.blog/2021-04-05-behind-githubs-new-authentication-token-formats/
+        # https://github.blog/security/announcing-npms-new-access-token-format/
         with contextlib.suppress(Exception):
-            if line_data.value.startswith("gh") and '_' == line_data.value[3]:
+            if (line_data.value.startswith("gh") and '_' == line_data.value[3]) or line_data.value.startswith("npm_"):
                 token = line_data.value[4:-6]
                 data = token.encode(ASCII, errors="strict")
                 crc32sum = binascii.crc32(data)

credsweeper/filters/value_morphemes_check.py

@@ -0,0 +1,43 @@
+from typing import Optional
+
+from credsweeper.common import static_keyword_checklist
+from credsweeper.common.constants import MAX_LINE_LENGTH
+from credsweeper.config.config import Config
+from credsweeper.credentials.line_data import LineData
+from credsweeper.file_handler.analysis_target import AnalysisTarget
+from credsweeper.filters.filter import Filter
+
+
+class ValueMorphemesCheck(Filter):
+    """Check value for a threshold of morphemes count"""
+
+    THRESHOLDS_X3 = int(MAX_LINE_LENGTH).bit_length()
+    # one morpheme is very likely to be random generated even for 3 symbols
+    MAX_MORPHEMES_LIMIT = max(1, THRESHOLDS_X3 - 4)
+
+    def __init__(self, config: Optional[Config] = None, threshold: Optional[int] = None) -> None:
+        # threshold - minimum morphemes number in a value
+        if threshold is None:
+            # use dynamic thresholds
+            self.thresholds = [max(1, x - 4) for x in range(ValueMorphemesCheck.THRESHOLDS_X3)]
+        elif isinstance(threshold, int) and 0 <= threshold:
+            # constant thresholds for any pattern
+            self.thresholds = [threshold] * ValueMorphemesCheck.THRESHOLDS_X3
+        else:
+            raise ValueError(f"Wrong type of pattern length {type(threshold)} = {repr(threshold)}")
+
+    def run(self, line_data: LineData, target: AnalysisTarget) -> bool:
+        """Run filter checks on received credential candidate data 'line_data'.
+
+        Args:
+            line_data: credential candidate data
+            target: multiline target from which line data was obtained
+
+        Return:
+            True, if need to filter candidate and False if left
+
+        """
+        threshold_id = len(line_data.value).bit_length()
+        # use the last (max) threshold in very huge value
+        threshold = self.thresholds[threshold_id] if len(self.thresholds) > threshold_id else self.thresholds[-1]
+        return static_keyword_checklist.check_morphemes(line_data.value.lower(), threshold)

credsweeper/filters/value_string_type_check.py

@@ -51,6 +51,7 @@ class ValueStringTypeCheck(Filter):
                 and not line_data.is_comment() \
                 and not line_data.is_well_quoted_value \
                 and not line_data.is_quoted \
+                and not '0' <= line_data.value[0] <= '9' \
                 and line_data.separator and '=' in line_data.separator:
             # heterogeneous code e.g. YAML in Python uses colon sign instead equals
             return True

credsweeper/ml_model/features/feature.py

@@ -10,7 +10,7 @@ class Feature(ABC):
     """Base class for features."""
 
     def __init__(self):
-        self.words = []
+        pass
 
     def __call__(self, candidates: List[Candidate]) -> np.ndarray:
         """Call base class for features.
@@ -25,20 +25,3 @@ class Feature(ABC):
     def extract(self, candidate: Candidate) -> Any:
         """Abstract method of base class"""
         raise NotImplementedError
-
-    @property
-    def words(self) -> List[str]:
-        """getter"""
-        return self.__words
-
-    @words.setter
-    def words(self, words: List[str]) -> None:
-        """setter"""
-        self.__words = words
-
-    def any_word_in_(self, a_string: str) -> bool:
-        """Returns true if any words in a string"""
-        for i in self.words:
-            if i in a_string:
-                return True
-        return False

credsweeper/ml_model/features/file_extension.py

@@ -19,7 +19,7 @@ class FileExtension(WordIn):
 
     def __call__(self, candidates: List[Candidate]) -> np.ndarray:
         extension_set = set(candidate.line_data_list[0].file_type.lower() for candidate in candidates)
-        return self.word_in_set(extension_set)
+        return self.word_in_(extension_set)
 
     def extract(self, candidate: Candidate) -> Any:
         raise NotImplementedError

credsweeper/ml_model/features/has_html_tag.py

@@ -1,17 +1,18 @@
 from credsweeper.common.constants import CHUNK_SIZE
 from credsweeper.credentials.candidate import Candidate
-from credsweeper.ml_model.features.feature import Feature
+from credsweeper.ml_model.features.word_in import WordIn
 from credsweeper.utils.util import Util
 
 
-class HasHtmlTag(Feature):
+class HasHtmlTag(WordIn):
     """Feature is true if line has HTML tags (HTML file)."""
 
+    HTML_WORDS = [
+        '< img', '<img', '< script', '<script', '< p', '<p', '< link', '<link', '< meta', '<meta', '< a', '<a'
+    ]
+
     def __init__(self) -> None:
-        super().__init__()
-        self.words = [
-            '< img', '<img', '< script', '<script', '< p', '<p', '< link', '<link', '< meta', '<meta', '< a', '<a'
-        ]
+        super().__init__(HasHtmlTag.HTML_WORDS)
 
     def extract(self, candidate: Candidate) -> bool:
         subtext = Util.subtext(candidate.line_data_list[0].line, candidate.line_data_list[0].value_start, CHUNK_SIZE)
@@ -19,8 +20,9 @@ class HasHtmlTag(Feature):
         if '<' not in candidate_line_data_list_0_line_lower:
             # early check
             return False
-        if self.any_word_in_(candidate_line_data_list_0_line_lower):
-            return True
+        for i in self.words:
+            if i in candidate_line_data_list_0_line_lower:
+                return True
         if "/>" in candidate_line_data_list_0_line_lower or "</" in candidate_line_data_list_0_line_lower:
             # possible closed tag
             return True

credsweeper/ml_model/features/is_secret_numeric.py

@@ -1,3 +1,5 @@
+import contextlib
+
 from credsweeper.credentials.candidate import Candidate
 from credsweeper.ml_model.features.feature import Feature
 
@@ -6,8 +8,7 @@ class IsSecretNumeric(Feature):
     """Feature is true if candidate value is a numerical value."""
 
     def extract(self, candidate: Candidate) -> bool:
-        try:
+        with contextlib.suppress(ValueError):
             float(candidate.line_data_list[0].value)
             return True
-        except ValueError:
-            return False
+        return False

credsweeper/ml_model/features/rule_name.py

@@ -19,7 +19,7 @@ class RuleName(WordIn):
 
     def __call__(self, candidates: List[Candidate]) -> np.ndarray:
         candidate_rule_set = set(x.rule_name for x in candidates)
-        return self.word_in_set(candidate_rule_set)
+        return self.word_in_(candidate_rule_set)
 
     def extract(self, candidate: Candidate) -> Any:
         raise NotImplementedError

credsweeper/ml_model/features/word_in.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import List, Any, Tuple, Set
+from typing import List, Any, Set, Union
 
 import numpy as np
 
@@ -18,42 +18,19 @@ class WordIn(Feature):
         if len(self.enumerated_words) != self.dimension:
             raise RuntimeError(f"Check duplicates:{words}")
 
-    @property
-    def enumerated_words(self) -> List[Tuple[int, str]]:
-        """getter for speedup"""
-        return self.__enumerated_words
-
-    @enumerated_words.setter
-    def enumerated_words(self, enumerated_words: List[Tuple[int, str]]) -> None:
-        """setter for speedup"""
-        self.__enumerated_words = enumerated_words
-
-    @property
-    def dimension(self) -> int:
-        """getter"""
-        return self.__dimension
-
-    @dimension.setter
-    def dimension(self, dimension: int) -> None:
-        """setter"""
-        self.__dimension = dimension
-
     @abstractmethod
     def extract(self, candidate: Candidate) -> Any:
         raise NotImplementedError
 
-    def word_in_str(self, a_string: str) -> np.ndarray:
-        """Returns array with words included in a string"""
-        result: np.ndarray = np.zeros(shape=[self.dimension], dtype=np.int8)
-        for i, word in self.enumerated_words:
-            if word in a_string:
-                result[i] = 1
-        return np.array([result])
+    @property
+    def zero(self) -> np.ndarray:
+        """Returns zero filled array for case of empty input"""
+        return np.zeros(shape=[self.dimension], dtype=np.int8)
 
-    def word_in_set(self, a_strings_set: Set[str]) -> np.ndarray:
-        """Returns array with words matches in a_strings_set"""
-        result: np.ndarray = np.zeros(shape=[self.dimension], dtype=np.int8)
+    def word_in_(self, iterable_data: Union[str, List[str], Set[str]]) -> np.ndarray:
+        """Returns array with words included in a string"""
+        result: np.ndarray = self.zero
         for i, word in self.enumerated_words:
-            if word in a_strings_set:
+            if word in iterable_data:
                 result[i] = 1
         return np.array([result])

credsweeper/ml_model/features/word_in_path.py

@@ -19,9 +19,8 @@ class WordInPath(WordIn):
             posix_lower_path = path.as_posix().lower() if path.is_absolute() else f"./{path.as_posix().lower()}"
             # prevent extra confusion from the same word in extension
             path_without_extension, _ = os.path.splitext(posix_lower_path)
-            return self.word_in_str(path_without_extension)
-        else:
-            return np.array([np.zeros(shape=[self.dimension], dtype=np.int8)])
+            return self.word_in_(path_without_extension)
+        return np.array([self.zero])
 
     def extract(self, candidate: Candidate) -> Any:
         raise NotImplementedError

credsweeper/ml_model/features/word_in_postamble.py

@@ -15,7 +15,4 @@ class WordInPostamble(WordIn):
             else candidate.line_data_list[0].value_end + ML_HUNK
         postamble = candidate.line_data_list[0].line[candidate.line_data_list[0].value_end:postamble_end].strip()
 
-        if postamble:
-            return self.word_in_str(postamble.lower())
-        else:
-            return np.array([np.zeros(shape=[self.dimension], dtype=np.int8)])
+        return self.word_in_(postamble.lower()) if postamble else np.array([self.zero])

credsweeper/ml_model/features/word_in_preamble.py

@@ -20,7 +20,4 @@ class WordInPreamble(WordIn):
                 else candidate.line_data_list[0].value_start - ML_HUNK
             preamble = candidate.line_data_list[0].line[preamble_start:candidate.line_data_list[0].value_start].strip()
 
-        if preamble:
-            return self.word_in_str(preamble.lower())
-        else:
-            return np.array([np.zeros(shape=[self.dimension], dtype=np.int8)])
+        return self.word_in_(preamble.lower()) if preamble else np.array([self.zero])

credsweeper/ml_model/features/word_in_transition.py

@@ -15,7 +15,4 @@ class WordInTransition(WordIn):
         else:
             transition = ''
 
-        if transition:
-            return self.word_in_str(transition.lower())
-        else:
-            return np.array([np.zeros(shape=[self.dimension], dtype=np.int8)])
+        return self.word_in_(transition.lower()) if transition else np.array([self.zero])

credsweeper/ml_model/features/word_in_value.py

@@ -10,6 +10,5 @@ class WordInValue(WordIn):
     def extract(self, candidate: Candidate) -> np.ndarray:
         """Returns array of matching words for first line"""
         if value := candidate.line_data_list[0].value:
-            return self.word_in_str(value.lower())
-        else:
-            return np.array([np.zeros(shape=[self.dimension], dtype=np.int8)])
+            return self.word_in_(value.lower())
+        return np.array([self.zero])

credsweeper/ml_model/features/word_in_variable.py

@@ -10,6 +10,5 @@ class WordInVariable(WordIn):
     def extract(self, candidate: Candidate) -> np.ndarray:
         """Returns array of matching words for first line"""
         if variable := candidate.line_data_list[0].variable:
-            return self.word_in_str(variable.lower())
-        else:
-            return np.zeros(shape=[self.dimension], dtype=np.int8)
+            return self.word_in_(variable.lower())
+        return np.array([self.zero])