product_info = dict(flag_info = {'flag1':[0],
                                 'flag2':[1],
                                 'flag3':[2,3]},
                     max_value = 65535,
                     num_bits  = 8)

unpack_to_array(qa, 'manual', custom_product_info = product_info)

unpack_to_array(qa, product = custom_product_info)

def pack_from_dict(flag_dict, product, num_bits):
    """
    Where keys are flag names, values are arrays all the same shape. 
    product is a custom product spec. num_bits should be 8,16, or 32
    """
    
    qa_array = np.empty(shaped like input, dtyp = product[numbits])
    
    for flag in products:
        if 1 bit:
            qa_array[flag_bit] = qa_dict[flag]
    
        if > 1 bit:
            # ie. take an array of possible values 0,1,2,3 and convert to two bits.
            temp_qa_array = unpackbits(qa_dict(flag))
            for ii in bits:
                qa_array[flag_bit] = temp_qa_array[flag_bit] # or something like that

qa_values = 2388
bits = [0,0,0,0,1,0,1,0,1,3,1,1]

upack_to_array(qa, 'MOD13Q1_DetailedQA', flags='all')

import numpy as np
from unpackqa.tools.unpackbits import unpackbits
from functools import partial

import timeit
import pandas as pd
import seaborn as sns

# Option 1: NumPy's Binary Representation
dec2bin_numpy = np.vectorize(partial(np.binary_repr, width = 8))

# Option 2: Python's Built-in Binary Conversion
dec2bin_py = np.vectorize(lambda v: bin(v).lstrip('0b').rjust(8, '0'))

# Option 3: Bitwise Operators
def dec2bin_bitwise(x):
    'For a 2D NumPy array as input'
    shp = x.shape
    return np.fliplr((x.ravel()[:,None] & (1 << np.arange(8))) > 0)\
        .astype(np.uint8).reshape((*shp, 8))

def dec2bin_bitwise2(x):
    'For a 2D NumPy array as input'
    shp = x.shape
    return ((x.ravel()[:,None] & (1 << np.arange(7, -1, -1))) > 0)\
        .astype(np.uint8).reshape((*shp, 8))
        
# Option 4: NumPy's unpackbits()
def dec2bin_unpack(x, axis = None):
    'For an arbitrary NumPy array a input'
    axis = x.ndim if axis is None else axis
    return np.unpackbits(x[...,None], axis = axis)[...,-8:]

# the quickest method from https://stackoverflow.com/a/51509307/6615512
# can unpack an arbitrary bit length.
def unpackbits_so(x, num_bits=8):
    xshape = list(x.shape)
    x = x.reshape([-1, 1])
    mask = 2**np.arange(num_bits, dtype=x.dtype).reshape([1, num_bits])
    return (x & mask).astype(bool).astype(int).reshape(xshape + [num_bits])


# unpackqa package unpack method, hard coded to 8 bits
# found here: https://github.com/sdtaylor/unpackqa/blob/main/unpackqa/tools/unpackbits.py
dec2bin_unpackqa = lambda x: unpackbits(qa_array=x, num_bits=8)


method_list = {
#    'dec2bin_numpy' : dec2bin_numpy,    # these 2 are always the slowest
#    'dec2bin_py' : dec2bin_py,
    'dec2bin_bitwise' : dec2bin_bitwise,
    'dec2bin_bitwise2' : dec2bin_bitwise2,
    'dec2bin_unpack' : dec2bin_unpack,
    'dec2bin_SO_method': unpackbits_so,
    'unpackqa_method' : dec2bin_unpackqa
    }

#------------------------------------
# testing a small array
arr = np.arange(400).reshape((20,20)).astype(np.uint8)
for method_name, method in method_list.items():
    result = timeit.timeit(lambda: method(arr), number=1000) 
    print('{} - {}s'.format(method_name,round(result,3)))



#------------------------
# testing on larger arrays
# array sizes to test. These will end up being 
# (10,10), (100,100), etc.
array_sizes = [10,100,200,500,1000,2000,4000]

results = []
for s in array_sizes:
    arr = np.repeat([100], repeats=s*s).reshape((s,s)).astype(np.uint8)
    for method_name, method in method_list.items():
        result = timeit.timeit(lambda: method(arr), number=5)
        
        results.append(dict(
            method = method_name,
            array_size = s,
            time = result
            ))


results = pd.DataFrame(results)

sns.set_style(style="whitegrid")
sns.lineplot(x='array_size', y='time',hue='method', data=results, palette="tab10", linewidth=2.5)

dec2bin_bitwise - 0.038s
dec2bin_bitwise2 - 0.026s
dec2bin_unpack - 0.009s
dec2bin_SO_method - 0.018s
unpackqa_method - 0.034s