binaryornot 0.5.0__py3-none-any.whl

binaryornot/__init__.py

@@ -0,0 +1 @@
+"""BinaryOrNot: ultra-lightweight pure Python package to check if a file is binary or text."""

binaryornot/__main__.py

@@ -0,0 +1,4 @@
+from .check import main
+
+if __name__ == "__main__":
+    main()

binaryornot/check.py

@@ -0,0 +1,47 @@
+"""
+binaryornot.check
+-----------------
+
+Main code for checking if a file is binary or text.
+"""
+
+import argparse
+import logging
+
+from binaryornot.helpers import get_starting_chunk, is_binary_string
+
+logger = logging.getLogger(__name__)
+
+
+def is_binary(filename):
+    """
+    :param filename: File to check.
+    :returns: True if it's a binary file, otherwise False.
+    """
+    logger.debug("is_binary: %(filename)r", locals())
+
+    # Check if the file extension is in a list of known binary types
+    #     binary_extensions = ['.pyc', ]
+    #     for ext in binary_extensions:
+    #         if filename.endswith(ext):
+    #             return True
+
+    # Check if the starting chunk is a binary string
+    chunk = get_starting_chunk(filename)
+    return is_binary_string(chunk)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Check if a file passed as argument is binary or not")
+
+    parser.add_argument(
+        "filename", help="File name to check for. If the file is not in the same folder, include full path"
+    )
+
+    args = parser.parse_args()
+
+    print(is_binary(**vars(args)))
+
+
+if __name__ == "__main__":
+    main()

binaryornot/data/binary_formats.csv

@@ -0,0 +1,50 @@
+format,family,status,magic_hex,test_file,gap_reason,source
+png,image,covered,89504e470d0a1a0a,tests/files/logo.png,,ISO/IEC 15948 s5.2
+jpeg_jfif,image,covered,ffd8ffe0,,,ITU-T T.81 + JFIF APP0 marker
+jpeg_exif,image,covered,ffd8ffe1,,,ITU-T T.81 + Exif APP1 marker
+gif87a,image,covered,474946383761,tests/files/lena.gif,,GIF87a spec header
+gif89a,image,covered,474946383961,tests/isBinaryFile/trunks.gif,,GIF89a spec header
+bmp,image,covered,424d,tests/files/rgb-3c-8b.bmp,,Microsoft BMP format
+tiff_be,image,covered,4d4d002a,tests/files/palette-1c-8b.tiff,,TIFF 6.0 spec s2 (big-endian)
+tiff_le,image,covered,49492a00,,,TIFF 6.0 spec s2 (little-endian)
+ico,image,covered,00000100,,,Microsoft ICO format
+pdf,document,covered,255044462d312e,tests/isBinaryFile/pdf.pdf,,ISO 32000 s7.5.2
+sqlite,database,covered,53514c69746520666f726d6174203300,tests/isBinaryFile/test.sqlite,,SQLite file format s1.2.1
+zip,archive,covered,504b0304,,,APPNOTE.TXT (PKWARE) s4.3.7
+gzip,archive,covered,1f8b08,,,RFC 1952 s2.3
+xz,archive,covered,fd377a585a00,,,XZ file format spec s2.1.1
+elf,executable,covered,7f454c46,,,System V ABI s4 (ELF header)
+macho_32be,executable,covered,feedface,,,Apple Mach-O format reference
+macho_32le,executable,covered,cefaedfe,,,Apple Mach-O format reference
+macho_64be,executable,covered,feedfacf,,,Apple Mach-O format reference
+macho_64le,executable,covered,cffaedfe,tests/isBinaryFile/grep,,Apple Mach-O format reference
+mz,executable,covered,4d5a,,,Microsoft PE/COFF spec (DOS header)
+java_class,executable,covered,cafebabe,,,JVM spec s4.1
+riff,media,covered,52494646,,,Microsoft RIFF spec
+ogg,media,covered,4f676753,,,Ogg bitstream format spec
+flac,media,covered,664c6143,,,FLAC format spec
+wasm,executable,covered,0061736d,,,WebAssembly spec s5.5.1
+woff,font,covered,774f4646,tests/files/glyphiconshalflings-regular.woff,,W3C WOFF spec
+otf,font,covered,4f54544f,tests/files/glyphiconshalflings-regular.otf,,OpenType spec (CFF-based)
+ttf,font,covered,0001000000,tests/files/glyphiconshalflings-regular.ttf,,OpenType/TrueType spec v1.0
+eot,font,covered,,tests/files/glyphiconshalflings-regular.eot,No universal magic; starts with file size,Microsoft EOT spec
+pyc,compiled,covered,,tests/files/hello_world.pyc,Magic varies by Python version,Python importlib source
+ds_store,metadata,covered,0000000142756431,tests/files/.DS_Store,,Apple .DS_Store reverse-engineered format
+raw_rgb,image,covered,,tests/files/pixelstream.rgb,No magic; pure pixel data,
+woff2,font,covered,774f4632,tests/files/test.woff2,,W3C WOFF2 spec
+webp,image,covered,524946460000000057454250,tests/files/logo.webp,,Google WebP container spec (RIFF+WEBP)
+mp4,media,covered,0000001866747970,tests/files/test.mp4,,ISO 14496-12 s4.3 (ftyp box)
+mp3_id3,media,covered,494433,,,ID3v2 spec s3.1
+bzip2,archive,covered,425a68,tests/files/test.bz2,,bzip2 file format
+7z,archive,covered,377abcaf271c,tests/files/test.7z,,7-Zip format spec
+ole2,document,covered,d0cf11e0a1b11ae1,tests/files/test.doc,,MS-CFB spec s2
+zstd,archive,covered,28b52ffd,tests/files/test.zst,,RFC 8878 s3.1.1
+rar,archive,covered,526172211a07,tests/files/test.rar,,RAR5 tech note
+matroska,media,covered,1a45dfa3,tests/files/test.webm,,EBML/Matroska spec
+midi,media,covered,4d546864,tests/files/test.mid,,MIDI 1.0 spec
+psd,image,covered,38425053,tests/files/test.psd,,Adobe PSD spec
+heif,image,covered,0000001c6674797068656963,tests/files/logo.heic,,ISO 23008-12 (ftyp heic)
+parquet,data,covered,50415231,tests/files/test.parquet,,Apache Parquet format spec
+dex,executable,covered,6465780a,tests/files/test.dex,,Dalvik executable format
+llvm_bc,compiled,covered,4243c0de,tests/files/test.bc,,LLVM bitcode wrapper format
+git_pack,data,covered,5041434b,tests/files/test.pack,,Git pack format spec

binaryornot/data/encodings.csv

@@ -0,0 +1,42 @@
+encoding,family,status,min_bytes,sample_text,gap_reason
+utf-8,unicode,covered,1,"Héllo wörld, café, naïve, résumé.",
+utf-16,unicode_bom,covered,2,"The quick brown fox jumps over the lazy dog.",
+utf-16-le,unicode,covered,8,"Pack my box with five dozen liquor jugs.",
+utf-16-be,unicode,covered,8,"How vexingly quick daft zebras jump.",
+utf-32,unicode_bom,covered,4,"Sphinx of black quartz, judge my vow.",
+utf-32-le,unicode,covered,16,"The five boxing wizards jump quickly.",
+utf-32-be,unicode,covered,16,"Jackdaws love my big sphinx of quartz.",
+utf-7,unicode,covered,1,"Hello, world! This is a test of detection.",
+ascii,single_byte,covered,1,"The quick brown fox jumps over the lazy dog.",
+iso-8859-1,single_byte,covered,4,"Héllo wörld, café, naïve, résumé, Straße.",
+iso-8859-2,single_byte,covered,4,"Příliš žluťoučký kůň úpěl ďábelské ódy.",
+iso-8859-5,single_byte,covered,4,"Съешь же ещё этих мягких французских булок.",
+iso-8859-6,single_byte,covered,4,"هذا نص تجريبي باللغة العربية.",
+iso-8859-7,single_byte,covered,4,"Αυτό είναι ένα δοκιμαστικό κείμενο.",
+iso-8859-15,single_byte,covered,4,"L'œuvre du Père Noël coûte cher en décembre.",
+windows-1250,single_byte,covered,4,"Stróż pchnął kość w quiz gędźb vel fax myjń.",
+windows-1251,single_byte,covered,4,"Широкая электрификация южных губерний.",
+windows-1252,single_byte,covered,4,"Dès Noël où un zéphyr haï me vêt de glaçons.",
+windows-1253,single_byte,covered,4,"Ξεσκεπάζω την ψυχοφθόρα βδελυγμία.",
+windows-1256,single_byte,covered,4,"نص عربي تجريبي للكشف عن الترميز الصحيح.",
+koi8-r,single_byte,covered,4,"Широкая электрификация южных губерний.",
+cp866,single_byte,covered,4,"В чащах юга жил бы цитрус? Да, но фальшивый.",
+cp850,single_byte,covered,4," Strüdel, naïf, tête-à-tête, über alles.",
+cp437,single_byte,covered,4,"Ärger mit Ölförderung in Übersee.",
+tis-620,single_byte,covered,4,"สวัสดีครับ นี่คือข้อความทดสอบภาษาไทย.",
+cp1258,single_byte,covered,4,"Garçon! Un café crème et une pièce montée.",
+mac-roman,single_byte,covered,4,"Là où le zéphyr souffle, les œufs flottent.",
+mac-cyrillic,single_byte,covered,4,"Эх, чужак! Общий съём цен шляп.",
+gb2312,cjk_legacy,covered,20,"你好世界。中文测试文本。欢迎来到这里。",
+gb18030,cjk_legacy,covered,20,"天地玄黄宇宙洪荒日月盈昃辰宿列张。",
+gbk,cjk_legacy,covered,20,"春眠不觉晓处处闻啼鸟夜来风雨声花落知多少。",
+big5,cjk_legacy,covered,20,"你好世界。歡迎來到這裡。請檢查結果。",
+shift_jis,cjk_legacy,covered,20,"こんにちは世界。日本語のテストです。",
+euc-jp,cjk_legacy,covered,20,"吾輩は猫である。名前はまだ無い。",
+euc-kr,cjk_legacy,covered,20,"안녕하세요 세계에 오신 것을 환영합니다.",
+iso-2022-jp,iso2022,covered,10,"東京特許許可局局長今日急遽許可却下。",
+iso-2022-kr,iso2022,gap,10,"안녕하세요 세계에 오신 것을 환영합니다.",SO/SI control bytes around each word inflate control_ratio to 20%
+hz,cjk_escape,covered,4,"Hello World, this is a test.",
+cp037,ebcdic,gap,1,"Hello World, this is a test.",Completely different byte mapping from ASCII
+cp500,ebcdic,gap,1,"Hello World, this is a test.",Completely different byte mapping from ASCII
+ebcdic-cp-us,ebcdic,gap,1,"Hello World, this is a test.",Completely different byte mapping from ASCII

binaryornot/helpers.py

@@ -0,0 +1,231 @@
+"""
+binaryornot.helpers
+-------------------
+
+Helper utilities used by BinaryOrNot.
+"""
+
+import logging
+import math
+
+from binaryornot.tree import is_binary as _is_binary_by_features
+
+logger = logging.getLogger(__name__)
+
+
+def print_as_hex(s):
+    """
+    Print a string as hex bytes.
+    """
+    print(":".join(f"{ord(c):x}" for c in s))
+
+
+def get_starting_chunk(filename, length=128):
+    """
+    :param filename: File to open and get the first little chunk of.
+    :param length: Number of bytes to read, default 128.
+    :returns: Starting chunk of bytes.
+    """
+    # Ensure we open the file in binary mode
+    with open(filename, "rb") as f:
+        chunk = f.read(length)
+        return chunk
+
+
+# Bytes considered non-text control characters (excluding \t \n \r)
+_CONTROL_BYTES = frozenset(range(0, 32)) - {9, 10, 13}
+
+
+def _compute_features(chunk):
+    """Compute features for the binary/text decision tree.
+
+    Feature indices:
+      0: null_ratio           - fraction of 0x00 bytes
+      1: control_ratio        - fraction of control chars (0x01-0x08, 0x0E-0x1F)
+      2: printable_ascii_ratio - fraction of 0x20-0x7E
+      3: high_byte_ratio      - fraction of 0x80-0xFF
+      4: utf8_valid           - 1.0 if chunk decodes as UTF-8
+      5: even_null_ratio      - fraction of even-index bytes that are 0x00
+      6: odd_null_ratio       - fraction of odd-index bytes that are 0x00
+      7: byte_entropy         - Shannon entropy of byte distribution
+      8-12: BOM flags         - UTF-32 LE/BE, UTF-16 LE/BE, UTF-8 BOM
+      13: try_utf16le         - 1.0 if chunk decodes as UTF-16-LE
+      14: try_utf16be         - 1.0 if chunk decodes as UTF-16-BE
+      15: try_utf32le         - 1.0 if chunk decodes as UTF-32-LE
+      16: try_utf32be         - 1.0 if chunk decodes as UTF-32-BE
+      17: longest_printable_run - longest run of printable chars / length
+      18: try_gb2312          - 1.0 if chunk decodes as GB2312
+      19: try_big5            - 1.0 if chunk decodes as Big5
+      20: try_shift_jis       - 1.0 if chunk decodes as Shift-JIS
+      21: try_euc_jp          - 1.0 if chunk decodes as EUC-JP
+      22: try_euc_kr          - 1.0 if chunk decodes as EUC-KR
+    """
+    n = len(chunk)
+
+    null_count = chunk.count(0)
+    control_count = sum(1 for b in chunk if b in _CONTROL_BYTES)
+    printable_count = sum(1 for b in chunk if 0x20 <= b <= 0x7E)
+    high_count = sum(1 for b in chunk if b >= 0x80)
+
+    null_ratio = null_count / n
+    control_ratio = control_count / n
+    printable_ascii_ratio = printable_count / n
+    high_byte_ratio = high_count / n
+
+    try:
+        chunk.decode("utf-8")
+        utf8_valid = 1.0
+    except (UnicodeDecodeError, ValueError):
+        utf8_valid = 0.0
+
+    even_total = (n + 1) // 2
+    odd_total = n // 2
+    even_nulls = sum(1 for i in range(0, n, 2) if chunk[i] == 0)
+    odd_nulls = sum(1 for i in range(1, n, 2) if chunk[i] == 0)
+    even_null_ratio = even_nulls / even_total if even_total else 0
+    odd_null_ratio = odd_nulls / odd_total if odd_total else 0
+
+    hist = [0] * 256
+    for b in chunk:
+        hist[b] += 1
+    entropy = 0.0
+    for count in hist:
+        if count > 0:
+            p = count / n
+            entropy -= p * math.log2(p)
+
+    bom_utf32le = 1.0 if chunk[:4] == b"\xff\xfe\x00\x00" else 0.0
+    bom_utf32be = 1.0 if chunk[:4] == b"\x00\x00\xfe\xff" else 0.0
+    bom_utf16le = 1.0 if chunk[:2] == b"\xff\xfe" and chunk[:4] != b"\xff\xfe\x00\x00" else 0.0
+    bom_utf16be = 1.0 if chunk[:2] == b"\xfe\xff" else 0.0
+    bom_utf8 = 1.0 if chunk[:3] == b"\xef\xbb\xbf" else 0.0
+
+    try_utf16le = 0.0
+    try_utf16be = 0.0
+    try_utf32le = 0.0
+    try_utf32be = 0.0
+    if n >= 10:
+        try:
+            chunk.decode("utf-16-le")
+            try_utf16le = 1.0
+        except (UnicodeDecodeError, ValueError):
+            pass
+        try:
+            chunk.decode("utf-16-be")
+            try_utf16be = 1.0
+        except (UnicodeDecodeError, ValueError):
+            pass
+    if n >= 16:
+        try:
+            chunk.decode("utf-32-le")
+            try_utf32le = 1.0
+        except (UnicodeDecodeError, ValueError):
+            pass
+        try:
+            chunk.decode("utf-32-be")
+            try_utf32be = 1.0
+        except (UnicodeDecodeError, ValueError):
+            pass
+
+    max_run = 0
+    current_run = 0
+    for b in chunk:
+        if 0x20 <= b <= 0x7E or b in (9, 10, 13):
+            current_run += 1
+            if current_run > max_run:
+                max_run = current_run
+        else:
+            current_run = 0
+    longest_printable_run = max_run / n
+
+    def _try_decode(encoding):
+        try:
+            chunk.decode(encoding)
+            return 1.0
+        except (UnicodeDecodeError, ValueError):
+            return 0.0
+
+    try_gb2312 = _try_decode("gb2312") if n >= 10 else 0.0
+    try_big5 = _try_decode("big5") if n >= 10 else 0.0
+    try_shift_jis = _try_decode("shift_jis") if n >= 10 else 0.0
+    try_euc_jp = _try_decode("euc-jp") if n >= 10 else 0.0
+    try_euc_kr = _try_decode("euc-kr") if n >= 10 else 0.0
+
+    return [
+        null_ratio,
+        control_ratio,
+        printable_ascii_ratio,
+        high_byte_ratio,
+        utf8_valid,
+        even_null_ratio,
+        odd_null_ratio,
+        entropy,
+        bom_utf32le,
+        bom_utf32be,
+        bom_utf16le,
+        bom_utf16be,
+        bom_utf8,
+        try_utf16le,
+        try_utf16be,
+        try_utf32le,
+        try_utf32be,
+        longest_printable_run,
+        try_gb2312,
+        try_big5,
+        try_shift_jis,
+        try_euc_jp,
+        try_euc_kr,
+    ]
+
+
+def is_binary_string(bytes_to_check):
+    """
+    Check if a chunk of bytes appears to be binary or text.
+
+    Uses a trained decision tree on byte statistics including entropy,
+    character class ratios, encoding validity checks, and BOM detection.
+
+    :param bytes_to_check: A chunk of bytes to check.
+    :returns: True if appears to be a binary, otherwise False.
+    """
+    if not bytes_to_check:
+        return False
+
+    features = _compute_features(bytes_to_check)
+    result = _is_binary_by_features(features)
+    logger.debug(
+        "is_binary_string: %r (features=%r)",
+        result,
+        dict(
+            zip(
+                [
+                    "null",
+                    "ctrl",
+                    "ascii",
+                    "high",
+                    "utf8",
+                    "even0",
+                    "odd0",
+                    "entropy",
+                    "bom32le",
+                    "bom32be",
+                    "bom16le",
+                    "bom16be",
+                    "bom8",
+                    "try16le",
+                    "try16be",
+                    "try32le",
+                    "try32be",
+                    "run",
+                    "gb2312",
+                    "big5",
+                    "shiftjis",
+                    "eucjp",
+                    "euckr",
+                ],
+                [f"{v:.3f}" for v in features],
+                strict=True,
+            )
+        ),
+    )
+    return result

binaryornot/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

binaryornot/tree.py

@@ -0,0 +1,230 @@
+"""Auto-generated decision tree for binary/text classification.
+
+Do not edit by hand. Regenerate with:
+    uv run --with 'scikit-learn,numpy,hypothesis' python scripts/train_detector.py
+"""
+
+
+def is_binary(features):
+    """Classify a byte chunk as binary or text.
+
+    Takes the feature list from helpers._compute_features().
+    Returns True for binary.
+    """
+    if features[1] <= 0.003906:  # control_ratio
+        if features[17] <= 0.003906:  # longest_printable_run
+            if features[4] <= 0.500000:  # utf8_valid
+                if features[19] <= 0.500000:  # try_big5
+                    if features[7] <= 1.953445:  # byte_entropy
+                        return True  # binary (100.0%, n=1)
+                    else:
+                        if features[7] <= 2.749470:  # byte_entropy
+                            return False  # text (100.0%, n=1)
+                        else:
+                            if features[7] <= 3.004886:  # byte_entropy
+                                return True  # binary (100.0%, n=1)
+                            else:
+                                return True  # binary (100.0%, n=1)
+                else:
+                    if features[21] <= 0.500000:  # try_euc_jp
+                        return False  # text (100.0%, n=1)
+                    else:
+                        return False  # text (100.0%, n=1)
+            else:
+                if features[7] <= 1.750000:  # byte_entropy
+                    return False  # text (100.0%, n=1)
+                else:
+                    return False  # text (100.0%, n=1)
+        else:
+            if features[4] <= 0.500000:  # utf8_valid
+                if features[17] <= 0.074176:  # longest_printable_run
+                    if features[7] <= 5.159404:  # byte_entropy
+                        if features[7] <= 2.659421:  # byte_entropy
+                            if features[7] <= 2.523218:  # byte_entropy
+                                return False  # text (100.0%, n=1)
+                            else:
+                                return True  # binary (100.0%, n=1)
+                        else:
+                            return False  # text (100.0%, n=1)
+                    else:
+                        return True  # binary (100.0%, n=1)
+                else:
+                    if features[7] <= 3.040512:  # byte_entropy
+                        return False  # text (100.0%, n=1)
+                    else:
+                        if features[17] <= 0.354353:  # longest_printable_run
+                            if features[2] <= 0.615079:  # printable_ascii_ratio
+                                if features[17] <= 0.267943:  # longest_printable_run
+                                    if features[7] <= 3.572021:  # byte_entropy
+                                        if features[3] <= 0.490000:  # high_byte_ratio
+                                            return False  # text (100.0%, n=1)
+                                        else:
+                                            return True  # binary (66.8%, n=1)
+                                    else:
+                                        if features[2] <= 0.458042:  # printable_ascii_ratio
+                                            return True  # binary (100.0%, n=1)
+                                        else:
+                                            return True  # binary (79.0%, n=0)
+                                else:
+                                    if features[3] <= 0.538095:  # high_byte_ratio
+                                        return True  # binary (100.0%, n=1)
+                                    else:
+                                        return False  # text (100.0%, n=1)
+                            else:
+                                if features[13] <= 0.500000:  # try_utf16le
+                                    if features[3] <= 0.348485:  # high_byte_ratio
+                                        return True  # binary (100.0%, n=1)
+                                    else:
+                                        return False  # text (100.0%, n=1)
+                                else:
+                                    if features[17] <= 0.089844:  # longest_printable_run
+                                        return False  # text (100.0%, n=1)
+                                    else:
+                                        return False  # text (100.0%, n=1)
+                        else:
+                            return True  # binary (100.0%, n=1)
+            else:
+                return False  # text (100.0%, n=1)
+    else:
+        if features[0] <= 0.163978:  # null_ratio
+            if features[4] <= 0.500000:  # utf8_valid
+                if features[7] <= 3.264621:  # byte_entropy
+                    if features[17] <= 0.052849:  # longest_printable_run
+                        if features[1] <= 0.322917:  # control_ratio
+                            return True  # binary (100.0%, n=1)
+                        else:
+                            if features[20] <= 0.500000:  # try_shift_jis
+                                return False  # text (100.0%, n=1)
+                            else:
+                                return True  # binary (100.0%, n=1)
+                    else:
+                        if features[17] <= 0.348485:  # longest_printable_run
+                            return False  # text (100.0%, n=1)
+                        else:
+                            if features[7] <= 2.951575:  # byte_entropy
+                                return False  # text (100.0%, n=1)
+                            else:
+                                if features[3] <= 0.303030:  # high_byte_ratio
+                                    return True  # binary (100.0%, n=1)
+                                else:
+                                    return True  # binary (100.0%, n=1)
+                else:
+                    if features[1] <= 0.031089:  # control_ratio
+                        if features[2] <= 0.455863:  # printable_ascii_ratio
+                            return True  # binary (100.0%, n=1)
+                        else:
+                            if features[17] <= 0.082207:  # longest_printable_run
+                                return False  # text (100.0%, n=1)
+                            else:
+                                if features[14] <= 0.500000:  # try_utf16be
+                                    return False  # text (100.0%, n=1)
+                                else:
+                                    return True  # binary (100.0%, n=1)
+                    else:
+                        if features[10] <= 0.500000:  # bom_utf16le
+                            if features[2] <= 0.455534:  # printable_ascii_ratio
+                                if features[3] <= 0.790570:  # high_byte_ratio
+                                    if features[17] <= 0.011719:  # longest_printable_run
+                                        if features[2] <= 0.140625:  # printable_ascii_ratio
+                                            return True  # binary (100.0%, n=1)
+                                        else:
+                                            return False  # text (100.0%, n=1)
+                                    else:
+                                        if features[7] <= 3.540884:  # byte_entropy
+                                            return True  # binary (95.4%, n=1)
+                                        else:
+                                            return True  # binary (99.9%, n=1)
+                                else:
+                                    return False  # text (100.0%, n=1)
+                            else:
+                                if features[17] <= 0.072300:  # longest_printable_run
+                                    if features[1] <= 0.112942:  # control_ratio
+                                        if features[7] <= 5.537264:  # byte_entropy
+                                            return False  # text (100.0%, n=1)
+                                        else:
+                                            return True  # binary (100.0%, n=1)
+                                    else:
+                                        return True  # binary (100.0%, n=1)
+                                else:
+                                    if features[7] <= 4.198218:  # byte_entropy
+                                        if features[17] <= 0.174242:  # longest_printable_run
+                                            return True  # binary (53.0%, n=0)
+                                        else:
+                                            return True  # binary (95.3%, n=1)
+                                    else:
+                                        if features[17] <= 0.096875:  # longest_printable_run
+                                            return True  # binary (89.4%, n=0)
+                                        else:
+                                            return True  # binary (100.0%, n=1)
+                        else:
+                            return False  # text (100.0%, n=1)
+            else:
+                if features[1] <= 0.575000:  # control_ratio
+                    return False  # text (100.0%, n=1)
+                else:
+                    return True  # binary (100.0%, n=1)
+        else:
+            if features[3] <= 0.098077:  # high_byte_ratio
+                if features[8] <= 0.500000:  # bom_utf32le
+                    if features[6] <= 0.125000:  # odd_null_ratio
+                        return False  # text (100.0%, n=1)
+                    else:
+                        if features[16] <= 0.500000:  # try_utf32be
+                            if features[5] <= 0.341085:  # even_null_ratio
+                                return False  # text (100.0%, n=1)
+                            else:
+                                if features[15] <= 0.500000:  # try_utf32le
+                                    if features[14] <= 0.500000:  # try_utf16be
+                                        if features[7] <= 0.864787:  # byte_entropy
+                                            return False  # text (100.0%, n=1)
+                                        else:
+                                            return True  # binary (100.0%, n=1)
+                                    else:
+                                        return True  # binary (100.0%, n=1)
+                                else:
+                                    if features[1] <= 0.925781:  # control_ratio
+                                        return False  # text (100.0%, n=1)
+                                    else:
+                                        return True  # binary (100.0%, n=1)
+                        else:
+                            if features[17] <= 0.003906:  # longest_printable_run
+                                return True  # binary (100.0%, n=1)
+                            else:
+                                return False  # text (100.0%, n=1)
+                else:
+                    return False  # text (100.0%, n=1)
+            else:
+                if features[7] <= 5.169243:  # byte_entropy
+                    if features[0] <= 0.765625:  # null_ratio
+                        if features[2] <= 0.378571:  # printable_ascii_ratio
+                            if features[20] <= 0.500000:  # try_shift_jis
+                                return False  # text (100.0%, n=1)
+                            else:
+                                if features[14] <= 0.500000:  # try_utf16be
+                                    if features[7] <= 3.188246:  # byte_entropy
+                                        return False  # text (100.0%, n=1)
+                                    else:
+                                        return True  # binary (100.0%, n=1)
+                                else:
+                                    return False  # text (100.0%, n=1)
+                        else:
+                            if features[13] <= 0.500000:  # try_utf16le
+                                if features[3] <= 0.320000:  # high_byte_ratio
+                                    return True  # binary (100.0%, n=1)
+                                else:
+                                    return False  # text (100.0%, n=1)
+                            else:
+                                if features[7] <= 2.892092:  # byte_entropy
+                                    return False  # text (100.0%, n=1)
+                                else:
+                                    return False  # text (100.0%, n=1)
+                    else:
+                        if features[5] <= 0.921875:  # even_null_ratio
+                            if features[2] <= 0.027344:  # printable_ascii_ratio
+                                return True  # binary (100.0%, n=1)
+                            else:
+                                return True  # binary (100.0%, n=1)
+                        else:
+                            return False  # text (100.0%, n=1)
+                else:
+                    return True  # binary (100.0%, n=1)

binaryornot-0.5.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: binaryornot
+Version: 0.5.0
+Summary: Ultra-lightweight pure Python package to check if a file is binary or text.
+Project-URL: bugs, https://github.com/binaryornot/binaryornot/issues
+Project-URL: changelog, https://github.com/binaryornot/binaryornot/releases
+Project-URL: documentation, https://binaryornot.github.io/binaryornot/
+Project-URL: homepage, https://github.com/binaryornot/binaryornot
+Author-email: Audrey Roy Greenfeld <aroy@alum.mit.edu>
+Maintainer-email: Audrey Roy Greenfeld <aroy@alum.mit.edu>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# BinaryOrNot
+
+Python library and CLI tool to check if a file is binary or text. Zero dependencies.
+
+```python
+from binaryornot.check import is_binary
+
+is_binary("image.png")    # True
+is_binary("README.md")    # False
+is_binary("data.sqlite")  # True
+is_binary("report.csv")   # False
+```
+
+```sh
+$ binaryornot image.png
+True
+```
+
+## Install
+
+```sh
+pip install binaryornot
+```
+
+## Why not just check for null bytes?
+
+That's the first thing everyone tries. It works until it doesn't:
+
+- A UTF-16 text file is full of null bytes. Your tool thinks it's binary and corrupts it.
+- A Big5 or GB2312 text file has high-ASCII bytes everywhere. Looks binary by byte ratios alone.
+- A font file (.woff, .eot) is clearly binary but might not have null bytes in the first chunk.
+
+BinaryOrNot reads the first 128 bytes and runs them through a trained decision tree that considers byte ratios, Shannon entropy, encoding validity, BOM detection, and more. It handles all the edge cases above correctly, with zero dependencies.
+
+Tested against [37 text encodings and 49 binary formats](https://binaryornot.github.io/binaryornot/usage/), verified by parametrized tests driven from coverage CSVs.
+
+## API
+
+One function:
+
+```python
+from binaryornot.check import is_binary
+
+is_binary(filename)  # returns True or False
+```
+
+There's also `is_binary_string()` if you already have bytes:
+
+```python
+from binaryornot.helpers import is_binary_string
+
+is_binary_string(b"\x00\x01\x02")  # True
+is_binary_string(b"hello world")   # False
+```
+
+[Full documentation](https://binaryornot.github.io/binaryornot/) covers the detection algorithm in detail.
+
+## Credits
+
+Created by [Audrey Roy Greenfeld](https://audrey.feldroy.com).

binaryornot-0.5.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+binaryornot/__init__.py,sha256=OQjHzR0Rewtt-cTpYKKDAA2XUBpLGuUeb9JRak15Nqs,95
+binaryornot/__main__.py,sha256=OLoOkeoAmMnJvnXLTuzot_UdlUPr1665bvRXMtgzIEM,63
+binaryornot/check.py,sha256=JlZ04JwB6_EklLdhup-PilLB2nTlN0PfndGzru8xs70,1147
+binaryornot/helpers.py,sha256=_ejKNcTMiiKCvED7jGSX6njM_vFCvbmqHcAk-hVweOg,7050
+binaryornot/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+binaryornot/tree.py,sha256=jpA2_UOV1Sc3L-VW-1DYMYLBfgNJg_lvebf8jOwCj8o,13093
+binaryornot/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+binaryornot/data/binary_formats.csv,sha256=TFDAgDhZPa6StowTdcTxZpxqIYuhFuWhW4QJkQRv_JI,3738
+binaryornot/data/encodings.csv,sha256=8A82R9syvD2whLGFy6X7ndrfuSSuNEsrePCl7WxLk0A,3734
+binaryornot-0.5.0.dist-info/METADATA,sha256=BrJwB8wye4JgNo8xNdlPtu8pOOih_xaT4bdu0zzc0qs,2755
+binaryornot-0.5.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+binaryornot-0.5.0.dist-info/entry_points.txt,sha256=ZcvM7LFMwzNBFbY4-8IJp2t4dyeDLziu2WGYfINyNew,55
+binaryornot-0.5.0.dist-info/licenses/LICENSE,sha256=A_Rr9DwQHmSvZLn4GKyXg2GCkPclKWiBdZyTyS0veWg,1078
+binaryornot-0.5.0.dist-info/RECORD,,

binaryornot-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

binaryornot-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+binaryornot = binaryornot.check:main

binaryornot-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026, Audrey Roy Greenfeld
+
+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.