Upload 4 files

HTS_list.py

@@ -0,0 +1,205 @@
+# 99037801 for copper content; non-copper content or 99037802 goods with no copper
+Copper_primary_HTS_list = [
+  74061000, 74091990, 74130010,
+  74062000, 74092100, 74130050,
+  74071015, 74092900, 74130090,
+  74071030, 74093110, 74151000,
+  74071050, 74093150, 74152100,
+  74072115, 74093190, 74152900,
+  74072130, 74093910, 74153305,
+  74072150, 74093950, 74153310,
+  74072170, 74093990, 74153380,
+  74072190, 74094000, 74153900,
+  74072916, 74099010, 74181000,
+  74072934, 74099050, 74182010,
+  74072938, 74099090, 74182050,
+  74072940, 74101100, 74192000,
+  74072950, 74101200, 74198003,
+  74081130, 74102130, 74198006,
+  74081160, 74102160, 74198009,
+  74081900, 74102200, 74198015,
+  74082100, 74111010, 74198016,
+  74082210, 74111050, 74198017,
+  74082250, 74112110, 74198030,
+  74082910, 74112150, 74198050,
+  74082950, 74112200, 85444210,
+  74091110, 74112910, 85444220,
+  74091150, 74112950, 85444290,
+  74091910, 74121000, 85444910,
+  74091950, 74122000
+]
+
+# Steel primary HTS List
+Steel_primary_HTS_list = [
+  84313100, 84314200, 84314910, 84314990, 84321000, 84329000, 85479000, 94032000,
+  94059920, 94059940, 94062000, 94069001, 84181000, 84183000, 84184000, 84221100,
+  84501100, 84502000, 84512100, 84512900, 85098020, 85166040, 9403999020, 4029968,
+  82119120, 84291100, 85042300, 4029970, 82119125, 84291900, 85043300, 4029990,
+  82119130, 84292000, 8504909634, 2106909998, 82119140, 84293000, 8504909638,
+  2710193050, 82119150, 84294000, 8504909642, 2711120020, 82119180, 84295110,
+  85142040, 2804290010, 82119220, 84295150, 85142060, 2804400000, 82119240,
+  84295210, 85162900, 2901220000, 82119260, 84295250, 85166060, 2903421000,
+  82119290, 84295910, 86011000, 29034310, 82119300, 84295950, 86012000, 29034410,
+  82119410, 84312000, 86021000, 29034510, 82119450, 84313900, 86029000, 29034900,
+  82119510, 84314100, 86031000, 29035110, 82119550, 84314340, 86039000, 29035990,
+  82119590, 84314380, 86040000, 2903710100, 82151000, 84331100, 86050000,
+  3004909244, 82152000, 84332000, 86071100, 32081000, 82159130, 84335100,
+  8607190300, 32082000, 82159160, 84335900, 86071906, 32089000, 82159190,
+  84339010, 86071912, 32091000, 82159901, 84339050, 86071915, 32099000,
+  82159905, 8443160000, 86071990, 32139000, 82159910, 8454200010, 86072150,
+  32141000, 82159915, 8454200060, 8607301010, 33030010, 82159920, 84553000,
+  8607301050, 33030020, 82159922, 8455904000, 8607301090, 33030030, 82159924,
+  8455908000, 86073050, 33043000, 82159926, 84571000, 86079100, 33049950,
+  82159930, 84749000, 86079950, 33051000, 82159935, 84771030, 86090000, 33053000,
+  82159940, 84771040, 87011001, 33059000, 82159945, 84771090, 8701210080,
+  33069000, 82159950, 84779025, 8701220080, 33071010, 83021060, 8477908601,
+  8701230080, 33071020, 83024130, 84798955, 8701240080, 33072000, 83024160,
+  84798965, 8701290080, 33074900, 83024230, 84799045, 87013010, 33079000,
+  83024960, 84799055, 87013050, 34013010, 83052000, 84799065, 87019110,
+  34013050, 83071060, 84799075, 87019150, 34023190, 8401400000, 84799085,
+  87019210, 34024990, 84031000, 84799095, 87019250, 34025011, 8406904000,
+  8480490010, 87019310, 34025051, 84072100, 8480718045, 87019350, 34029010,
+  84079010, 8480718060, 87019410, 34029030, 84079090, 8480799010, 87019450,
+  34029050, 84082010, 8482105004, 87019510, 34031910, 84082090, 8482105008,
+  87019550, 34031950, 84099150, 8482105012, 87021031, 34039900, 84099192,
+  8482105016, 87021061, 34051000, 84099199, 8482105024, 87031010, 34052000,
+  84099991, 8482105028, 87031050, 34054000, 84099992, 8482105032, 87032101,
+  34059000, 84099999, 8482105036, 87051000, 35061050, 8410900000, 8482105052,
+  87052000, 35069110, 84118180, 8482105056, 8705900010, 35069150, 84122100,
+  8482105060, 8705900020, 35069900, 84122980, 8482105064, 87060030, 38085910,
+  8412909070, 8482105068, 87084030, 38085940, 8412909075, 8482200064,
+  87084060, 38086110, 84138100, 8482200067, 87089210, 38086150, 8413919055,
+  8482200090, 87089250, 38086210, 8413919060, 84829905, 87089260, 38086250,
+  8413919096, 84829915, 87089275, 38086910, 84143040, 84829925, 87089315,
+  38086950, 84148016, 84829935, 87089330, 38089115, 84149030, 84829945,
+  87089923, 38089125, 84149041, 84829965, 87089981, 38089130, 84151030,
+  8483101010, 87100000, 38089150, 84151060, 8483101050, 87113000, 38089410,
+  84151090, 84831050, 87115000, 38089450, 84158101, 84832040, 87116000,
+  38099100, 84158201, 84832080, 87141000, 38101000, 84158300, 84833040,
+  87161000, 38111900, 84159040, 84833080, 87163900, 38112100, 84159080,
+  84834010, 87168010, 38140010, 8417900000, 8483405020, 87168050, 38140020,
+  84182100, 84834090, 87169010, 38140050, 84182920, 84835060, 87169030,
+  38200000, 84189940, 84835090, 94017100, 3824999397, 84198150, 84836040,
+  94017900, 3827610000, 84212900, 84836080, 94031000, 3827620000, 8424100000,
+  84839020, 94039910, 3827630000, 84248990, 84839030, 9403999010, 3827640000,
+  84254200, 84839050, 9403999015, 3827650000, 84262000, 84839070, 9403999040,
+  39252000, 84269900, 84839080, 9403999045, 39269010, 84271040, 85015340,
+  9403999051, 76141010, 84271080, 85015360, 9403999061, 8202390040, 84272040,
+  85015380, 95069100, 82034060, 84272080, 8501640110, 82055955, 84279000,
+  8502310000, 82057000, 84283200, 85030035, 8207200070, 84283300, 85030045,
+  8207306062, 84283900, 85030065, 8207306095, 84286000, 85030075, 82111000,
+  84287000, 85030090, 82119110, 84289003, 85030095,
+  73012010, 73012050, 73023000, 73072110, 73072150, 73072210, 73072250, 73072300,
+  73072900, 73079110, 73079130, 73079150, 73079230, 73079290, 73079330, 73079360,
+  73079390, 73079910, 73079930, 73079950, 73081000, 73082000, 73083010, 73083050,
+  73084000, 73089030, 73089060, 73089070, 73089095, 73090000, 73101000, 73102100,
+  73102900, 73110000, 73121005, 73121010, 73121020, 73121030, 73121050, 73121060,
+  73121070, 73121080, 73121090, 73129000, 73130000, 73141210, 73141220, 73141230,
+  73141260, 73141290, 73141410, 73141420, 73141430, 73141460, 73141490, 73141901,
+  73142000, 73143110, 73143150, 73143900, 73144100, 73144200, 73144930, 73144960,
+  73145000, 73151100, 73151200, 73151900, 73152010, 73152050, 73158100, 73158210,
+  73158230, 73158250, 73158270, 73158910, 73158930, 73158950, 73159000, 73160000,
+  73170010, 73170020, 73170055, 73170065, 73170075, 73181100, 73181200, 73181300,
+  73181410, 73181450, 73181520, 73181540, 73181550, 73181560, 73181580, 73181600,
+  73181900, 73182100, 73182200, 73182300, 73182400, 73182900, 73194020, 73194030,
+  73194050, 73199010, 73199090, 73201030, 73201060, 73201090, 73202010, 73202050,
+  73209010, 73209050, 73211110, 73211130, 73211160, 73211200, 73211900, 73218110,
+  73218150, 73218210, 73218250, 73218900, 73219010, 73219020, 73219040, 73219050,
+  73219060, 73221900, 73229000, 73231000, 73239300, 73239400, 73239910, 73239930,
+  73239950, 73239970, 73239990, 73241000, 73242900, 73249000, 73259100, 73259910,
+  73259950, 73261100, 73261900, 73262000, 73269010, 73269025, 73269035, 73269045,
+  73269060, 73269086, 7317005501, 7317005502, 7317005508, 7317005511, 7317005518,
+  7317005519, 7317005520, 7317005530, 7317005540, 7317005550, 7317005570,
+  7317005590, 7317006530, 7216910010, 7302909000, 73071930, 73071990
+]
+
+# Aluminum primary HTS List
+Aluminum_primary_HTS_list = [
+  6603908100, 8302103000, 8302106030, 8302106060, 8302106090,
+  8302200000, 8302303010, 8302303060,
+  8302413000, 8302416015, 8302416045, 8302416050, 8302416080,
+  8302423010, 8302423015, 8302423065,
+  8302496035, 8302496045, 8302496055, 8302496085,
+  8302500000, 8302603000, 8302609000,
+  8305100050, 8306300000, 8414596590,
+  8415908025, 8415908045, 8415908085,
+  8418998005, 8418998050, 8418998060,
+  8419505000, 8419901000, 8422900640,
+  8424909080, 8473302000, 8473305100,
+  8479899599, 8479908500, 8479909596,
+  8481909060, 8481909085, 8486900000,
+  8487900080, 8503009520, 8508700000,
+  8513902000, 8515902000, 8516905000, 8516908050,
+  8517710000, 8517790000,
+  8529907300, 8529909760,
+  8536908585, 8538100000,
+  8541900000, 8543908885,
+  8547900020, 8547900030, 8547900040,
+  8708103050, 87081060, 8708295160,
+  8708806590, 8708996890, 8716805010,
+  8807300060, 9013908000, 9031909195,
+  9401999081, 94031000, 94032000,
+  9403991040, 9403999010, 9403999015,
+  9403999020, 9403999040, 9403999045,
+  9405994020,
+  9506114080, 9506514000, 9506516000,
+  9506594040, 9506702090,
+  9506910010, 9506910020, 9506910030,
+  9506990510, 9506990520, 9506990530,
+  9506991500, 9506992000, 9506992580,
+  9506992800, 9506995500, 9506996080,
+  9507302000, 9507304000, 9507306000,
+  9507308000, 9507906000,
+  9603908050,
+  2203000060, 2203000090,
+  4029968, 4029970, 4029990,
+  2106909998, 2710193050,
+  29034310, 29034510, 29034900, 29035110, 29035990,
+  3004909244,
+  32081000, 32082000, 32089000, 32091000, 32099000,
+  32139000, 32141000,
+  33030010, 33030020, 33030030,
+  33043000, 33049950,
+  33051000, 33053000, 33059000,
+  33069000,
+  33071010, 33071020, 33072000, 33074900, 33079000,
+  34013010, 34013050,
+  34023190, 34024990, 34025011, 34025051,
+  34029010, 34029030, 34029050,
+  34031910, 34031950, 34039900,
+  34051000, 34052000, 34054000, 34059000,
+  35061050, 35069110, 35069150, 35069900,
+  3701300000,
+  38085910, 38085940, 38086110, 38086150,
+  38086210, 38086250, 38086910, 38086950,
+  38089115, 38089125, 38089130, 38089150,
+  38089410, 38089450,
+  38099100, 38101000,
+  38111900, 38112100,
+  38140010, 38140020, 38140050,
+  38200000, 3824999397,
+  7308200035,
+  8307906000, 8309900020, 8309900025,
+  8412909070, 8412909075, 84148016, 84181000,
+  8419501000, 84248990, 8443160000,
+  84501100, 84512100,
+  84672200, 84672900, 84678100, 84678950,
+  8483405020, 8483905020,
+  8501640110, 85022000, 8502310000,
+  8503009546, 8503009570,
+  85043120, 85043140, 85043160,
+  85043300, 85043400,
+  85049020, 85049041, 85049065, 85049075, 85049096,
+  85441900, 85444290, 8544492000, 8544499000,
+  8544602000, 8544606000,
+  8716390040,
+  94017900,
+  76101000, 76109000, 76129010,
+  7615102015, 7615102025, 7615103015, 7615103025,
+  7615105020, 7615105040,
+  7615107125, 7615107130, 7615107155, 7615107180,
+  7615109100, 7615200000,
+  7616109090, 7616991000, 7616995130,
+  7616995140, 7616995190,
+  7612100000, 7612905000, 7613000000, 76141010
+]

app.py

@@ -0,0 +1,873 @@
+"""
+HTS Checker - Streamlit Application for HTS Tariff Auditing
+Deployed on Hugging Face Spaces
+"""
+
+import streamlit as st
+import pandas as pd
+from io import BytesIO
+import hashlib
+from hts_validator import HTSValidator, validate_dataframe, SCENARIO_SUMMARIES
+from HTS_list import Steel_primary_HTS_list, Aluminum_primary_HTS_list, Copper_primary_HTS_list
+
+
+# Page configuration
+st.set_page_config(
+    page_title="HTS Checker - Tariff Audit Tool",
+    page_icon="",
+    layout="wide"
+)
+
+
+@st.cache_data
+def load_and_validate_excel(file_content, file_name, keywords_hash):
+    """Load Excel and run validation - cached to avoid re-running on filter changes"""
+    # Read Excel with HTS columns as string
+    df = pd.read_excel(file_content, dtype={
+        "Tariff": str,
+        "Primary 1": str,
+        "Primary 2": str,
+        "Primary 3": str,
+        "Primary 4": str,
+        "Primary 5": str,
+        "Primary 6": str,
+    })
+
+    # Clean up HTS columns
+    hts_columns = ["Tariff", "Primary 1", "Primary 2", "Primary 3",
+                  "Primary 4", "Primary 5", "Primary 6"]
+    for col in hts_columns:
+        if col in df.columns:
+            df[col] = df[col].astype(str).str.replace(r'\.0$', '', regex=True)
+            df[col] = df[col].replace('nan', '')
+
+    return df
+
+
+@st.cache_data
+def run_validation(df_hash, _df, _validator):
+    """Run validation - cached based on dataframe hash"""
+    results = validate_dataframe(_df, _validator)
+    return results
+
+
+def get_df_hash(df):
+    """Get hash of dataframe for caching"""
+    return hashlib.md5(pd.util.hash_pandas_object(df).values.tobytes()).hexdigest()
+
+
+def get_keywords_hash(keywords):
+    """Get hash of keywords for cache invalidation"""
+    return hashlib.md5(str(keywords).encode()).hexdigest()
+
+# Initialize session state
+if "keywords" not in st.session_state:
+    st.session_state.keywords = {
+        "metal": ["steel", "stainless steel", "carbon steel", "iron", "metal"],
+        "aluminum": ["aluminum", "aluminium"],
+        "copper": ["copper"],
+        "zinc": ["zinc"],
+        "plastics": ["plastic", "abs", "pu", "pvc", "polyester", "nylon"]
+    }
+
+if "export_cache" not in st.session_state:
+    st.session_state.export_cache = []
+
+if "validation_results" not in st.session_state:
+    st.session_state.validation_results = None
+
+if "original_df" not in st.session_state:
+    st.session_state.original_df = None
+
+
+def get_validator():
+    """Create validator with current keyword settings"""
+    return HTSValidator(
+        metal_keywords=st.session_state.keywords["metal"],
+        aluminum_keywords=st.session_state.keywords["aluminum"],
+        copper_keywords=st.session_state.keywords["copper"],
+        zinc_keywords=st.session_state.keywords["zinc"],
+        plastics_keywords=st.session_state.keywords["plastics"]
+    )
+
+
+def color_status(val):
+    """Color code status column"""
+    if val == "PASS":
+        return "background-color: #90EE90"  # Light green
+    elif val == "FAIL":
+        return "background-color: #FFB6C1"  # Light red
+    elif val == "FLAG":
+        return "background-color: #FFFFE0"  # Light yellow
+    return ""
+
+
+def format_hts(hts_value):
+    """Format HTS value as string, removing .0 suffix"""
+    if not hts_value:
+        return ""
+    s = str(hts_value)
+    # Remove .0 suffix if present (from float conversion)
+    if s.endswith(".0"):
+        s = s[:-2]
+    return s
+
+
+def results_to_dataframe(results):
+    """Convert validation results to DataFrame"""
+    data = []
+    for r in results:
+        # Format additional HTS as strings
+        additional_hts_str = ", ".join([format_hts(h) for h in r.additional_hts if h])
+        expected_hts_str = ", ".join([format_hts(h) for h in r.expected_hts if h])
+        missing_hts_str = ", ".join([format_hts(h) for h in r.missing_hts if h])
+        unexpected_hts_str = ", ".join([format_hts(h) for h in r.unexpected_hts if h])
+
+        data.append({
+            "Entry Number": r.entry_number,
+            "Description": r.description[:100] + "..." if len(r.description) > 100 else r.description,
+            "Full Description": r.description,
+            "Primary HTS": format_hts(r.primary_hts),
+            "Additional HTS": additional_hts_str,
+            "Scenario": r.scenario_id,
+            "Scenario Summary": r.scenario_summary,
+            "Status": r.status,
+            "Expected HTS": expected_hts_str,
+            "Missing HTS": missing_hts_str,
+            "Unexpected HTS": unexpected_hts_str,
+            "Issue": r.issue
+        })
+    return pd.DataFrame(data)
+
+
+def export_to_excel(df, results_df=None):
+    """Export DataFrame to Excel with optional validation results"""
+    output = BytesIO()
+
+    with pd.ExcelWriter(output, engine="openpyxl") as writer:
+        if results_df is not None:
+            # Merge original data with validation results
+            # Use Full Description for export
+            export_df = df.copy()
+
+            # Add validation columns
+            if len(results_df) == len(export_df):
+                export_df["Scenario ID"] = results_df["Scenario"].values
+                export_df["Scenario Summary"] = results_df["Scenario Summary"].values
+                export_df["Status"] = results_df["Status"].values
+                export_df["Expected HTS"] = results_df["Expected HTS"].values
+                export_df["Missing HTS"] = results_df["Missing HTS"].values
+                export_df["Unexpected HTS"] = results_df["Unexpected HTS"].values
+                export_df["Issue Description"] = results_df["Issue"].values
+
+            export_df.to_excel(writer, sheet_name="Audit Results", index=False)
+        else:
+            df.to_excel(writer, sheet_name="Export", index=False)
+
+    output.seek(0)
+    return output
+
+
+# Main app
+st.title("HTS Checker - Tariff Audit Tool")
+st.markdown("Audit primary HTS codes against additional tariffs and description keywords")
+
+# Create tabs
+tab1, tab2, tab2b, tab3, tab4, tab5 = st.tabs([
+    "Upload & Filter",
+    "Validation Results",
+    "Unique Combinations",
+    "Keyword Management",
+    "Export Selection",
+    "HTS Reference"
+])
+
+# Tab 1: Upload & Filter
+with tab1:
+    st.header("Upload Excel File")
+
+    uploaded_file = st.file_uploader(
+        "Upload your entry report Excel file",
+        type=["xlsx", "xls"],
+        help="Upload the customizable entry report from NetCHB"
+    )
+
+    if uploaded_file is not None:
+        try:
+            # Use cached loading function
+            keywords_hash = get_keywords_hash(st.session_state.keywords)
+            df = load_and_validate_excel(uploaded_file, uploaded_file.name, keywords_hash)
+
+            st.session_state.original_df = df
+            st.success(f"Loaded {len(df)} rows")
+
+            # Display column mapping info
+            with st.expander("Column Mapping"):
+                st.markdown("""
+                **Expected Columns:**
+                - Column E: `Description` - Product description for keyword matching
+                - Column F: `Tariff` - 10-digit Primary HTS code
+                - Columns I-N: `Primary 1-6` - Additional HTS codes
+                """)
+
+                st.write("**Detected columns:**", df.columns.tolist())
+
+            # Filter controls
+            st.subheader("Filter Options")
+
+            col1, col2 = st.columns(2)
+
+            with col1:
+                hts_filter = st.text_input(
+                    "Filter by Primary HTS (partial match)",
+                    placeholder="e.g., 7301 or 730120",
+                    help="Enter partial HTS to filter entries"
+                )
+
+            with col2:
+                desc_exclude = st.text_input(
+                    "Exclude by description keyword",
+                    placeholder="e.g., polyester",
+                    help="Exclude entries containing this keyword in description"
+                )
+
+            # Apply filters
+            filtered_df = df.copy()
+
+            if hts_filter:
+                tariff_col = "Tariff" if "Tariff" in df.columns else df.columns[5]
+                filtered_df = filtered_df[
+                    filtered_df[tariff_col].astype(str).str.contains(hts_filter, na=False)
+                ]
+
+            if desc_exclude:
+                desc_col = "Description" if "Description" in df.columns else df.columns[4]
+                filtered_df = filtered_df[
+                    ~filtered_df[desc_col].astype(str).str.lower().str.contains(
+                        desc_exclude.lower(), na=False
+                    )
+                ]
+
+            st.write(f"**Showing {len(filtered_df)} of {len(df)} entries**")
+
+            # Display filtered data
+            if len(filtered_df) > 0:
+                # Show key columns
+                display_cols = ["Entry Number", "Description", "Tariff",
+                               "Primary 1", "Primary 2", "Primary 3",
+                               "Primary 4", "Primary 5", "Primary 6"]
+                display_cols = [c for c in display_cols if c in filtered_df.columns]
+
+                st.dataframe(
+                    filtered_df[display_cols].head(100),
+                    use_container_width=True
+                )
+
+                if len(filtered_df) > 100:
+                    st.info("Showing first 100 rows.")
+
+                # Run validation ONCE on full dataset (cached), then filter results
+                if "cached_full_results" not in st.session_state or st.session_state.get("cached_file_name") != uploaded_file.name:
+                    with st.spinner("Validating all entries (one-time)..."):
+                        validator = get_validator()
+                        full_results = validate_dataframe(df, validator)
+                        full_results_df = results_to_dataframe(full_results)
+                        st.session_state.cached_full_results = full_results_df
+                        st.session_state.cached_file_name = uploaded_file.name
+
+                # Filter cached results based on current filters
+                full_results_df = st.session_state.cached_full_results
+                filtered_indices = filtered_df.index.tolist()
+                filtered_results_df = full_results_df.iloc[filtered_indices].copy()
+
+                st.session_state.validation_results = filtered_results_df
+                st.session_state.filtered_df = filtered_df
+
+                st.success(f"Showing {len(filtered_df)} entries. Go to 'Validation Results' tab to review.")
+
+        except Exception as e:
+            st.error(f"Error loading file: {str(e)}")
+
+# Tab 2: Validation Results
+with tab2:
+    st.header("Validation Results")
+
+    if st.session_state.validation_results is None:
+        st.info("Upload a file and run validation first.")
+    else:
+        # Results are already a DataFrame now (cached)
+        results_df = st.session_state.validation_results.copy()
+
+        # Summary statistics
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            pass_count = len(results_df[results_df["Status"] == "PASS"])
+            st.metric("PASS", pass_count)
+        with col2:
+            fail_count = len(results_df[results_df["Status"] == "FAIL"])
+            st.metric("FAIL", fail_count)
+        with col3:
+            flag_count = len(results_df[results_df["Status"] == "FLAG"])
+            st.metric("FLAG", flag_count)
+        with col4:
+            none_count = len(results_df[results_df["Scenario"] == "NONE"])
+            st.metric("No Match", none_count)
+
+        # Filter by status
+        st.subheader("Filter Results")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            status_filter = st.multiselect(
+                "Filter by Status",
+                options=["PASS", "FAIL", "FLAG"],
+                default=["FAIL", "FLAG"]
+            )
+
+        with col2:
+            scenario_filter = st.multiselect(
+                "Filter by Scenario",
+                options=list(SCENARIO_SUMMARIES.keys()),
+                default=[]
+            )
+
+        # Apply filters
+        display_df = results_df.copy()
+
+        if status_filter:
+            display_df = display_df[display_df["Status"].isin(status_filter)]
+
+        if scenario_filter:
+            display_df = display_df[display_df["Scenario"].isin(scenario_filter)]
+
+        # Exclude "NONE" scenario by default
+        show_none = st.checkbox("Show 'No Match' entries", value=False)
+        if not show_none:
+            display_df = display_df[display_df["Scenario"] != "NONE"]
+
+        st.write(f"**Showing {len(display_df)} results**")
+
+        # Display results table
+        if len(display_df) > 0:
+            # Select columns to display
+            display_columns = [
+                "Entry Number", "Description", "Primary HTS",
+                "Additional HTS", "Scenario", "Status", "Issue"
+            ]
+
+            # Interactive filtering section
+            st.markdown("**Interactive Filters:**")
+            filter_col1, filter_col2, filter_col3 = st.columns(3)
+
+            with filter_col1:
+                hts_search = st.text_input(
+                    "Filter by Primary HTS",
+                    placeholder="e.g., 7301 or 8302",
+                    key="results_hts_filter"
+                )
+
+            with filter_col2:
+                desc_search = st.text_input(
+                    "Filter by Description",
+                    placeholder="e.g., steel, aluminum",
+                    key="results_desc_filter"
+                )
+
+            with filter_col3:
+                additional_hts_search = st.text_input(
+                    "Filter by Additional HTS",
+                    placeholder="e.g., 99038191",
+                    key="results_additional_filter"
+                )
+
+            # Apply interactive filters
+            interactive_df = display_df.copy()
+
+            if hts_search:
+                interactive_df = interactive_df[
+                    interactive_df["Primary HTS"].astype(str).str.contains(hts_search, case=False, na=False)
+                ]
+
+            if desc_search:
+                interactive_df = interactive_df[
+                    interactive_df["Description"].astype(str).str.contains(desc_search, case=False, na=False)
+                ]
+
+            if additional_hts_search:
+                interactive_df = interactive_df[
+                    interactive_df["Additional HTS"].astype(str).str.contains(additional_hts_search, case=False, na=False)
+                ]
+
+            st.write(f"**Filtered: {len(interactive_df)} of {len(display_df)} results**")
+
+            # Store interactive filtered df for export
+            st.session_state.interactive_filtered_df = interactive_df
+
+            styled_df = interactive_df[display_columns].style.applymap(
+                color_status, subset=["Status"]
+            )
+
+            st.dataframe(styled_df, use_container_width=True, height=400)
+
+            # Scenario legend
+            with st.expander("Scenario Legend"):
+                for scenario_id, summary in SCENARIO_SUMMARIES.items():
+                    st.write(f"**{scenario_id}**: {summary}")
+
+            # Bulk Export Actions
+            st.subheader("Add to Export Cache")
+            st.markdown("Use bulk actions to add **currently filtered** results to export cache")
+
+            col1, col2, col3 = st.columns(3)
+
+            with col1:
+                if st.button("Add ALL Filtered to Cache", type="primary"):
+                    added_count = 0
+                    for _, row in interactive_df.iterrows():
+                        row_dict = row.to_dict()
+                        # Check if not already in cache (by Entry + HTS + Description for uniqueness)
+                        key = (row_dict.get("Entry Number", ""), row_dict.get("Primary HTS", ""), row_dict.get("Description", ""))
+                        existing_keys = [(d.get("Entry Number", ""), d.get("Primary HTS", ""), d.get("Description", ""))
+                                        for d in st.session_state.export_cache]
+                        if key not in existing_keys:
+                            st.session_state.export_cache.append(row_dict)
+                            added_count += 1
+                    st.success(f"Added {added_count} entries to cache ({len(st.session_state.export_cache)} total)")
+
+            with col2:
+                if st.button("Add FAIL Only to Cache"):
+                    fail_df = interactive_df[interactive_df["Status"] == "FAIL"]
+                    added_count = 0
+                    for _, row in fail_df.iterrows():
+                        row_dict = row.to_dict()
+                        key = (row_dict.get("Entry Number", ""), row_dict.get("Primary HTS", ""), row_dict.get("Description", ""))
+                        existing_keys = [(d.get("Entry Number", ""), d.get("Primary HTS", ""), d.get("Description", ""))
+                                        for d in st.session_state.export_cache]
+                        if key not in existing_keys:
+                            st.session_state.export_cache.append(row_dict)
+                            added_count += 1
+                    st.success(f"Added {added_count} FAIL entries to cache")
+
+            with col3:
+                if st.button("Add FLAG Only to Cache"):
+                    flag_df = interactive_df[interactive_df["Status"] == "FLAG"]
+                    added_count = 0
+                    for _, row in flag_df.iterrows():
+                        row_dict = row.to_dict()
+                        key = (row_dict.get("Entry Number", ""), row_dict.get("Primary HTS", ""), row_dict.get("Description", ""))
+                        existing_keys = [(d.get("Entry Number", ""), d.get("Primary HTS", ""), d.get("Description", ""))
+                                        for d in st.session_state.export_cache]
+                        if key not in existing_keys:
+                            st.session_state.export_cache.append(row_dict)
+                            added_count += 1
+                    st.success(f"Added {added_count} FLAG entries to cache")
+
+            # Add by scenario
+            st.markdown("**Add by Scenario (from filtered results):**")
+            scenario_cols = st.columns(4)
+            available_scenarios = interactive_df["Scenario"].unique().tolist()
+
+            for idx, scenario in enumerate(available_scenarios[:8]):  # Limit to 8 buttons
+                col_idx = idx % 4
+                with scenario_cols[col_idx]:
+                    scenario_count = len(interactive_df[interactive_df["Scenario"] == scenario])
+                    if st.button(f"{scenario} ({scenario_count})", key=f"add_scenario_{scenario}"):
+                        scenario_df = interactive_df[interactive_df["Scenario"] == scenario]
+                        added_count = 0
+                        for _, row in scenario_df.iterrows():
+                            row_dict = row.to_dict()
+                            key = (row_dict.get("Entry Number", ""), row_dict.get("Primary HTS", ""), row_dict.get("Description", ""))
+                            existing_keys = [(d.get("Entry Number", ""), d.get("Primary HTS", ""), d.get("Description", ""))
+                                            for d in st.session_state.export_cache]
+                            if key not in existing_keys:
+                                st.session_state.export_cache.append(row_dict)
+                                added_count += 1
+                        st.success(f"Added {added_count} {scenario} entries to cache")
+
+            # Show cache status
+            st.info(f"Current cache: {len(st.session_state.export_cache)} entries. Go to 'Export Selection' tab to download.")
+
+# Tab 2b: Unique Combinations
+with tab2b:
+    st.header("Unique HTS + Description Combinations")
+    st.markdown("View unique combinations to avoid reviewing duplicates")
+
+    if st.session_state.validation_results is None:
+        st.info("Upload a file and run validation first.")
+    else:
+        results_df = st.session_state.validation_results.copy()
+
+        # Filter by status first
+        st.subheader("Filter Options")
+        col1, col2 = st.columns(2)
+
+        with col1:
+            unique_status_filter = st.multiselect(
+                "Filter by Status",
+                options=["PASS", "FAIL", "FLAG"],
+                default=["FAIL", "FLAG"],
+                key="unique_status_filter"
+            )
+
+        with col2:
+            unique_scenario_filter = st.multiselect(
+                "Filter by Scenario",
+                options=list(SCENARIO_SUMMARIES.keys()),
+                default=[],
+                key="unique_scenario_filter"
+            )
+
+        # Apply filters
+        filtered_df = results_df.copy()
+
+        if unique_status_filter:
+            filtered_df = filtered_df[filtered_df["Status"].isin(unique_status_filter)]
+
+        if unique_scenario_filter:
+            filtered_df = filtered_df[filtered_df["Scenario"].isin(unique_scenario_filter)]
+
+        # Exclude NONE by default
+        show_none_unique = st.checkbox("Show 'No Match' entries", value=False, key="show_none_unique")
+        if not show_none_unique:
+            filtered_df = filtered_df[filtered_df["Scenario"] != "NONE"]
+
+        if len(filtered_df) > 0:
+            # Group by Primary HTS + Description (use Full Description for grouping)
+            # Aggregate to get unique combinations
+            unique_df = filtered_df.groupby(
+                ["Primary HTS", "Full Description"], as_index=False
+            ).agg({
+                "Entry Number": "count",  # Count occurrences
+                "Additional HTS": "first",  # Take first (should be same for same HTS+desc)
+                "Scenario": "first",
+                "Scenario Summary": "first",
+                "Status": "first",
+                "Expected HTS": "first",
+                "Missing HTS": "first",
+                "Unexpected HTS": "first",
+                "Issue": "first"
+            }).rename(columns={"Entry Number": "Count"})
+
+            # Sort by count descending to show most common first
+            unique_df = unique_df.sort_values("Count", ascending=False)
+
+            # Create shorter description for display
+            unique_df["Description"] = unique_df["Full Description"].apply(
+                lambda x: x[:80] + "..." if len(str(x)) > 80 else x
+            )
+
+            st.write(f"**{len(unique_df)} unique combinations** (from {len(filtered_df)} total entries)")
+
+            # Interactive filters for unique view
+            st.markdown("**Search Filters:**")
+            ucol1, ucol2 = st.columns(2)
+
+            with ucol1:
+                unique_hts_search = st.text_input(
+                    "Filter by Primary HTS",
+                    placeholder="e.g., 7301 or 8302",
+                    key="unique_hts_search"
+                )
+
+            with ucol2:
+                unique_desc_search = st.text_input(
+                    "Filter by Description",
+                    placeholder="e.g., steel, aluminum",
+                    key="unique_desc_search"
+                )
+
+            # Apply search filters
+            display_unique_df = unique_df.copy()
+
+            if unique_hts_search:
+                display_unique_df = display_unique_df[
+                    display_unique_df["Primary HTS"].astype(str).str.contains(unique_hts_search, case=False, na=False)
+                ]
+
+            if unique_desc_search:
+                display_unique_df = display_unique_df[
+                    display_unique_df["Description"].astype(str).str.contains(unique_desc_search, case=False, na=False)
+                ]
+
+            st.write(f"**Showing {len(display_unique_df)} unique combinations**")
+
+            # Display columns
+            display_cols = [
+                "Primary HTS", "Description", "Additional HTS",
+                "Scenario", "Status", "Count", "Issue"
+            ]
+
+            styled_unique = display_unique_df[display_cols].style.applymap(
+                color_status, subset=["Status"]
+            )
+
+            st.dataframe(styled_unique, use_container_width=True, height=400)
+
+            # Bulk export for unique combinations
+            st.subheader("Add Unique Combinations to Cache")
+
+            col1, col2 = st.columns(2)
+
+            with col1:
+                if st.button("Add ALL Unique to Cache", type="primary", key="add_all_unique"):
+                    added_count = 0
+                    for _, row in display_unique_df.iterrows():
+                        row_dict = row.to_dict()
+                        key = (row_dict.get("Primary HTS", ""), row_dict.get("Full Description", ""))
+                        existing_keys = [(d.get("Primary HTS", ""), d.get("Full Description", ""))
+                                        for d in st.session_state.export_cache]
+                        if key not in existing_keys:
+                            st.session_state.export_cache.append(row_dict)
+                            added_count += 1
+                    st.success(f"Added {added_count} unique combinations to cache")
+
+            with col2:
+                if st.button("Add FAIL/FLAG Unique to Cache", key="add_fail_flag_unique"):
+                    fail_flag_df = display_unique_df[display_unique_df["Status"].isin(["FAIL", "FLAG"])]
+                    added_count = 0
+                    for _, row in fail_flag_df.iterrows():
+                        row_dict = row.to_dict()
+                        key = (row_dict.get("Primary HTS", ""), row_dict.get("Full Description", ""))
+                        existing_keys = [(d.get("Primary HTS", ""), d.get("Full Description", ""))
+                                        for d in st.session_state.export_cache]
+                        if key not in existing_keys:
+                            st.session_state.export_cache.append(row_dict)
+                            added_count += 1
+                    st.success(f"Added {added_count} FAIL/FLAG combinations to cache")
+
+            st.info(f"Current cache: {len(st.session_state.export_cache)} entries")
+        else:
+            st.info("No results matching the selected filters.")
+
+# Tab 3: Keyword Management
+with tab3:
+    st.header("Keyword Management")
+    st.markdown("Edit keyword lists used for validation. Changes apply immediately.")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("Metal Keywords")
+        metal_text = st.text_area(
+            "Metal keywords (one per line)",
+            value="\n".join(st.session_state.keywords["metal"]),
+            height=150,
+            key="metal_input"
+        )
+
+        st.subheader("Aluminum Keywords")
+        aluminum_text = st.text_area(
+            "Aluminum keywords (one per line)",
+            value="\n".join(st.session_state.keywords["aluminum"]),
+            height=100,
+            key="aluminum_input"
+        )
+
+        st.subheader("Copper Keywords")
+        copper_text = st.text_area(
+            "Copper keywords (one per line)",
+            value="\n".join(st.session_state.keywords["copper"]),
+            height=100,
+            key="copper_input"
+        )
+
+    with col2:
+        st.subheader("Zinc Keywords")
+        zinc_text = st.text_area(
+            "Zinc keywords (one per line)",
+            value="\n".join(st.session_state.keywords["zinc"]),
+            height=100,
+            key="zinc_input"
+        )
+
+        st.subheader("Plastics Keywords")
+        plastics_text = st.text_area(
+            "Plastics keywords (one per line)",
+            value="\n".join(st.session_state.keywords["plastics"]),
+            height=150,
+            key="plastics_input"
+        )
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("Save Keywords", type="primary"):
+            st.session_state.keywords["metal"] = [
+                k.strip() for k in metal_text.split("\n") if k.strip()
+            ]
+            st.session_state.keywords["aluminum"] = [
+                k.strip() for k in aluminum_text.split("\n") if k.strip()
+            ]
+            st.session_state.keywords["copper"] = [
+                k.strip() for k in copper_text.split("\n") if k.strip()
+            ]
+            st.session_state.keywords["zinc"] = [
+                k.strip() for k in zinc_text.split("\n") if k.strip()
+            ]
+            st.session_state.keywords["plastics"] = [
+                k.strip() for k in plastics_text.split("\n") if k.strip()
+            ]
+            # Clear cached results to force re-validation
+            if "cached_full_results" in st.session_state:
+                del st.session_state.cached_full_results
+            if "cached_file_name" in st.session_state:
+                del st.session_state.cached_file_name
+            st.success("Keywords saved! Re-upload file or refresh to apply changes.")
+
+    with col2:
+        if st.button("Reset to Defaults"):
+            st.session_state.keywords = {
+                "metal": ["steel", "stainless steel", "carbon steel", "iron", "metal"],
+                "aluminum": ["aluminum", "aluminium"],
+                "copper": ["copper"],
+                "zinc": ["zinc"],
+                "plastics": ["plastic", "abs", "pu", "pvc", "polyester", "nylon"]
+            }
+            # Clear cached results
+            if "cached_full_results" in st.session_state:
+                del st.session_state.cached_full_results
+            if "cached_file_name" in st.session_state:
+                del st.session_state.cached_file_name
+            st.success("Keywords reset to defaults!")
+            st.rerun()
+
+# Tab 4: Export Selection
+with tab4:
+    st.header("Export Selection")
+
+    if len(st.session_state.export_cache) == 0:
+        st.info("No entries in export cache. Select entries from Validation Results tab.")
+    else:
+        st.write(f"**{len(st.session_state.export_cache)} entries in cache**")
+
+        # Display cache contents
+        cache_df = pd.DataFrame(st.session_state.export_cache)
+        st.dataframe(cache_df, use_container_width=True)
+
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            if st.button("Clear Cache"):
+                st.session_state.export_cache = []
+                st.success("Cache cleared!")
+                st.rerun()
+
+        with col2:
+            # Export cached entries only
+            if st.button("Export Cache to Excel"):
+                excel_data = export_to_excel(cache_df)
+                st.download_button(
+                    label="Download Excel (Cache Only)",
+                    data=excel_data,
+                    file_name="hts_audit_cache.xlsx",
+                    mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+
+    # Export full results with original data
+    st.subheader("Export Full Results")
+
+    if st.session_state.validation_results is not None and st.session_state.original_df is not None:
+        # validation_results is already a DataFrame now
+        results_df = st.session_state.validation_results.copy()
+
+        # Status filter for export
+        export_status = st.multiselect(
+            "Export entries with status:",
+            options=["PASS", "FAIL", "FLAG"],
+            default=["FAIL", "FLAG"],
+            key="export_status_filter"
+        )
+
+        # Create filtered export
+        if export_status:
+            filtered_results = results_df[results_df["Status"].isin(export_status)]
+            filtered_indices = filtered_results.index.tolist()
+
+            if hasattr(st.session_state, "filtered_df"):
+                export_original = st.session_state.filtered_df.iloc[filtered_indices].copy()
+            else:
+                export_original = st.session_state.original_df.iloc[filtered_indices].copy()
+
+            st.write(f"**{len(filtered_results)} entries will be exported**")
+
+            if st.button("Generate Full Export", type="primary"):
+                excel_data = export_to_excel(export_original, filtered_results)
+                st.download_button(
+                    label="Download Full Excel Report",
+                    data=excel_data,
+                    file_name="hts_audit_full_report.xlsx",
+                    mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+    else:
+        st.info("Run validation first to enable full export.")
+
+# Tab 5: HTS Reference
+with tab5:
+    st.header("HTS Reference Lists")
+    st.markdown("Reference lists of Steel, Aluminum, and Copper HTS codes used for validation")
+
+    # Search filter
+    hts_search = st.text_input(
+        "Search HTS code",
+        placeholder="Enter HTS to search across all lists",
+        key="hts_reference_search"
+    )
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.subheader(f"Steel HTS ({len(Steel_primary_HTS_list)})")
+        steel_list = [str(h) for h in Steel_primary_HTS_list]
+        if hts_search:
+            steel_list = [h for h in steel_list if hts_search in h]
+        steel_df = pd.DataFrame({"Steel HTS": steel_list})
+        st.dataframe(steel_df, use_container_width=True, height=400)
+
+    with col2:
+        st.subheader(f"Aluminum HTS ({len(Aluminum_primary_HTS_list)})")
+        aluminum_list = [str(h) for h in Aluminum_primary_HTS_list]
+        if hts_search:
+            aluminum_list = [h for h in aluminum_list if hts_search in h]
+        aluminum_df = pd.DataFrame({"Aluminum HTS": aluminum_list})
+        st.dataframe(aluminum_df, use_container_width=True, height=400)
+
+    with col3:
+        st.subheader(f"Copper HTS ({len(Copper_primary_HTS_list)})")
+        copper_list = [str(h) for h in Copper_primary_HTS_list]
+        if hts_search:
+            copper_list = [h for h in copper_list if hts_search in h]
+        copper_df = pd.DataFrame({"Copper HTS": copper_list})
+        st.dataframe(copper_df, use_container_width=True, height=400)
+
+    # Show overlap info
+    st.subheader("HTS Overlap Analysis")
+    steel_set = set(str(h) for h in Steel_primary_HTS_list)
+    aluminum_set = set(str(h) for h in Aluminum_primary_HTS_list)
+    copper_set = set(str(h) for h in Copper_primary_HTS_list)
+
+    steel_aluminum = steel_set & aluminum_set
+    aluminum_copper = aluminum_set & copper_set
+    steel_copper = steel_set & copper_set
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Steel & Aluminum Overlap", len(steel_aluminum))
+        if steel_aluminum:
+            with st.expander("View overlapping HTS"):
+                st.write(sorted(steel_aluminum))
+
+    with col2:
+        st.metric("Aluminum & Copper Overlap", len(aluminum_copper))
+        if aluminum_copper:
+            with st.expander("View overlapping HTS"):
+                st.write(sorted(aluminum_copper))
+
+    with col3:
+        st.metric("Steel & Copper Overlap", len(steel_copper))
+        if steel_copper:
+            with st.expander("View overlapping HTS"):
+                st.write(sorted(steel_copper))
+
+# Footer
+st.markdown("---")
+st.markdown("HTS Checker v1.0 - Tariff Audit Tool")

hts_validator.py

@@ -0,0 +1,731 @@
+"""
+HTS Validator - Core validation logic for HTS tariff auditing
+Validates primary HTS codes against additional HTS and description keywords
+"""
+
+import re
+from typing import Dict, List, Optional, Tuple, Set
+from dataclasses import dataclass
+from HTS_list import Steel_primary_HTS_list, Aluminum_primary_HTS_list, Copper_primary_HTS_list
+
+
+# Key Additional HTS codes
+STEEL_232_CODES = {"99038190", "99038191"}
+ALUMINUM_232_CODES = {"99038507", "99038508"}
+COPPER_CODES = {"99037801", "99037802"}
+GENERAL_301_CODE = "99030133"
+MISMATCH_CODE = "99030125"
+
+# Scenario summaries
+SCENARIO_SUMMARIES = {
+    "S1": "Steel HTS + 232 tariff applied - verify 99030133 present, no 99030125",
+    "S2": "Metal keyword but NOT steel HTS - should apply 99030125, no 232 tariffs",
+    "S3": "Steel HTS but NO metal keyword - description mismatch, should apply 99030125",
+    "S4": "Aluminum HTS + 232 tariff applied - verify 99030133 present",
+    "S5": "Aluminum keyword but NOT aluminum HTS - should apply 99030125, no 232 tariffs",
+    "S6": "Aluminum HTS but NO aluminum keyword - description mismatch, should apply 99030125",
+    "S7": "Dual Steel+Aluminum HTS - matches keyword, apply corresponding 232",
+    "S7a": "Dual Steel+Aluminum HTS + BOTH keywords - flag for manual review",
+    "S8": "Dual Steel+Aluminum HTS + NO keywords - should apply 99030125",
+    "S9": "Copper keyword but NOT copper HTS - potential misclassification",
+    "S10": "Copper HTS but NO copper keyword - description mismatch",
+    "S11": "Dual Aluminum+Copper HTS + copper keyword - apply 99030133 + copper tariffs",
+    "S12": "Dual Aluminum+Copper HTS + aluminum keyword - apply 99030133 + aluminum 232",
+    "S13": "Zinc keyword - should ONLY apply 99030125, no 232 tariffs allowed",
+    "S14": "Plastics keyword + metal HTS - override, should ONLY apply 99030125",
+    "COPPER_OK": "Copper HTS + copper keyword - verify copper tariffs applied",
+    "NONE": "No applicable scenario - entry does not match any validation rules",
+}
+
+
+@dataclass
+class ValidationResult:
+    """Result of validating a single entry"""
+    entry_number: str
+    description: str
+    primary_hts: str
+    additional_hts: List[str]
+    scenario_id: str
+    scenario_summary: str
+    status: str  # PASS, FAIL, FLAG
+    expected_hts: List[str]
+    missing_hts: List[str]
+    unexpected_hts: List[str]
+    issue: str
+
+
+class HTSValidator:
+    """Validates HTS codes against descriptions and additional tariffs"""
+
+    def __init__(self,
+                 metal_keywords: Optional[List[str]] = None,
+                 aluminum_keywords: Optional[List[str]] = None,
+                 copper_keywords: Optional[List[str]] = None,
+                 zinc_keywords: Optional[List[str]] = None,
+                 plastics_keywords: Optional[List[str]] = None):
+        """Initialize validator with keyword lists"""
+
+        # Default keyword lists
+        self.metal_keywords = metal_keywords or [
+            "steel", "stainless steel", "carbon steel", "iron", "metal"
+        ]
+        self.aluminum_keywords = aluminum_keywords or [
+            "aluminum", "aluminium"
+        ]
+        self.copper_keywords = copper_keywords or [
+            "copper"
+        ]
+        self.zinc_keywords = zinc_keywords or [
+            "zinc"
+        ]
+        self.plastics_keywords = plastics_keywords or [
+            "plastic", "abs", "pu", "pvc", "polyester", "nylon"
+        ]
+
+        # Convert HTS lists to string sets for matching
+        self.steel_hts_set = self._convert_hts_list(Steel_primary_HTS_list)
+        self.aluminum_hts_set = self._convert_hts_list(Aluminum_primary_HTS_list)
+        self.copper_hts_set = self._convert_hts_list(Copper_primary_HTS_list)
+
+    def _convert_hts_list(self, hts_list: List) -> Set[str]:
+        """Convert HTS list to set of strings"""
+        return {str(hts) for hts in hts_list}
+
+    def _hts_matches_list(self, primary_hts: str, hts_set: Set[str]) -> bool:
+        """Check if primary HTS matches any entry in HTS set using prefix matching"""
+        primary_str = str(primary_hts).replace(".", "").strip()
+
+        for list_hts in hts_set:
+            list_hts_str = str(list_hts).replace(".", "").strip()
+            # Prefix match: if list entry is 8 digits, match any 10-digit starting with it
+            if len(list_hts_str) <= len(primary_str):
+                if primary_str.startswith(list_hts_str):
+                    return True
+            else:
+                # List entry is longer, check if primary starts with it
+                if list_hts_str.startswith(primary_str):
+                    return True
+        return False
+
+    def _contains_keywords(self, text: str, keywords: List[str]) -> bool:
+        """Check if text contains any of the keywords (case-insensitive, word boundary)"""
+        if not text:
+            return False
+        text_lower = text.lower()
+        for kw in keywords:
+            # Use word boundary matching to avoid partial matches (e.g., "pu" in "punch")
+            # \b matches word boundaries
+            pattern = r'\b' + re.escape(kw.lower()) + r'\b'
+            if re.search(pattern, text_lower):
+                return True
+        return False
+
+    def _get_additional_hts_set(self, additional_hts: List[str]) -> Set[str]:
+        """Convert additional HTS list to normalized set"""
+        result = set()
+        for hts in additional_hts:
+            if hts:
+                # Remove decimal points and convert to string
+                normalized = str(hts).replace(".", "").strip()
+                # Remove trailing .0 from floats
+                if normalized.endswith("0") and len(normalized) > 8:
+                    # Check if it's a float representation
+                    try:
+                        float_val = float(hts)
+                        normalized = str(int(float_val))
+                    except (ValueError, TypeError):
+                        pass
+                result.add(normalized)
+        return result
+
+    def _check_hts_present(self, hts_code: str, additional_set: Set[str]) -> bool:
+        """Check if an HTS code is present in additional HTS set"""
+        return hts_code in additional_set
+
+    def _check_any_hts_present(self, hts_codes: Set[str], additional_set: Set[str]) -> bool:
+        """Check if any of the HTS codes are present"""
+        return bool(hts_codes & additional_set)
+
+    def validate_entry(self, entry_number: str, description: str,
+                       primary_hts: str, additional_hts: List[str]) -> ValidationResult:
+        """Validate a single entry against all scenarios"""
+
+        # Normalize data
+        primary_str = str(primary_hts).replace(".", "").strip() if primary_hts else ""
+        desc = str(description) if description else ""
+        additional_set = self._get_additional_hts_set(additional_hts)
+
+        # Check which HTS lists the primary belongs to
+        in_steel = self._hts_matches_list(primary_str, self.steel_hts_set)
+        in_aluminum = self._hts_matches_list(primary_str, self.aluminum_hts_set)
+        in_copper = self._hts_matches_list(primary_str, self.copper_hts_set)
+
+        # Check description keywords
+        has_metal_kw = self._contains_keywords(desc, self.metal_keywords)
+        has_aluminum_kw = self._contains_keywords(desc, self.aluminum_keywords)
+        has_copper_kw = self._contains_keywords(desc, self.copper_keywords)
+        has_zinc_kw = self._contains_keywords(desc, self.zinc_keywords)
+        has_plastics_kw = self._contains_keywords(desc, self.plastics_keywords)
+
+        # Check which additional HTS are applied
+        has_steel_232 = self._check_any_hts_present(STEEL_232_CODES, additional_set)
+        has_aluminum_232 = self._check_any_hts_present(ALUMINUM_232_CODES, additional_set)
+        has_copper_tariff = self._check_any_hts_present(COPPER_CODES, additional_set)
+        has_301 = self._check_hts_present(GENERAL_301_CODE, additional_set)
+        has_mismatch = self._check_hts_present(MISMATCH_CODE, additional_set)
+
+        # Apply validation rules in priority order
+        return self._apply_validation_rules(
+            entry_number=entry_number,
+            description=desc,
+            primary_hts=primary_str,
+            additional_hts=list(additional_set),
+            in_steel=in_steel,
+            in_aluminum=in_aluminum,
+            in_copper=in_copper,
+            has_metal_kw=has_metal_kw,
+            has_aluminum_kw=has_aluminum_kw,
+            has_copper_kw=has_copper_kw,
+            has_zinc_kw=has_zinc_kw,
+            has_plastics_kw=has_plastics_kw,
+            has_steel_232=has_steel_232,
+            has_aluminum_232=has_aluminum_232,
+            has_copper_tariff=has_copper_tariff,
+            has_301=has_301,
+            has_mismatch=has_mismatch,
+            additional_set=additional_set
+        )
+
+    def _apply_validation_rules(self, entry_number: str, description: str,
+                                 primary_hts: str, additional_hts: List[str],
+                                 in_steel: bool, in_aluminum: bool, in_copper: bool,
+                                 has_metal_kw: bool, has_aluminum_kw: bool,
+                                 has_copper_kw: bool, has_zinc_kw: bool,
+                                 has_plastics_kw: bool, has_steel_232: bool,
+                                 has_aluminum_232: bool, has_copper_tariff: bool,
+                                 has_301: bool, has_mismatch: bool,
+                                 additional_set: Set[str]) -> ValidationResult:
+        """Apply all validation rules and return result"""
+
+        # Priority 1: Special overrides (zinc, plastics)
+
+        # S13: Zinc keyword - only 99030125, no 232 tariffs
+        if has_zinc_kw:
+            expected = [MISMATCH_CODE]
+            issues = []
+
+            if not has_mismatch:
+                issues.append("Missing 99030125")
+            if has_steel_232 or has_aluminum_232 or has_copper_tariff:
+                issues.append("Should NOT have 232/copper tariffs with zinc")
+
+            status = "PASS" if not issues else "FAIL"
+            return ValidationResult(
+                entry_number=entry_number,
+                description=description,
+                primary_hts=primary_hts,
+                additional_hts=additional_hts,
+                scenario_id="S13",
+                scenario_summary=SCENARIO_SUMMARIES["S13"],
+                status=status,
+                expected_hts=expected,
+                missing_hts=[MISMATCH_CODE] if not has_mismatch else [],
+                unexpected_hts=self._get_unexpected_232(additional_set),
+                issue="; ".join(issues) if issues else "Correct - zinc with only 99030125"
+            )
+
+        # S14: Plastics keyword + metal HTS - only 99030125
+        if has_plastics_kw and (in_steel or in_aluminum):
+            expected = [MISMATCH_CODE]
+            issues = []
+
+            if not has_mismatch:
+                issues.append("Missing 99030125")
+            if has_steel_232 or has_aluminum_232:
+                issues.append("Should NOT have 232 tariffs with plastics material")
+
+            status = "PASS" if not issues else "FAIL"
+            return ValidationResult(
+                entry_number=entry_number,
+                description=description,
+                primary_hts=primary_hts,
+                additional_hts=additional_hts,
+                scenario_id="S14",
+                scenario_summary=SCENARIO_SUMMARIES["S14"],
+                status=status,
+                expected_hts=expected,
+                missing_hts=[MISMATCH_CODE] if not has_mismatch else [],
+                unexpected_hts=self._get_unexpected_232(additional_set),
+                issue="; ".join(issues) if issues else "Correct - plastics with only 99030125"
+            )
+
+        # Priority 2: Dual list scenarios
+
+        # Dual Aluminum + Copper
+        if in_aluminum and in_copper:
+            # S11: Copper keyword
+            if has_copper_kw:
+                expected = [GENERAL_301_CODE] + list(COPPER_CODES)
+                issues = []
+
+                if not has_301:
+                    issues.append("Missing 99030133")
+                if not has_copper_tariff:
+                    issues.append("Missing copper tariff (99037801/02)")
+                if has_aluminum_232:
+                    issues.append("Should NOT have aluminum 232 when description says copper")
+
+                status = "PASS" if not issues else "FAIL"
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S11",
+                    scenario_summary=SCENARIO_SUMMARIES["S11"],
+                    status=status,
+                    expected_hts=expected,
+                    missing_hts=self._get_missing_codes([GENERAL_301_CODE], has_301, COPPER_CODES, has_copper_tariff),
+                    unexpected_hts=list(ALUMINUM_232_CODES & additional_set),
+                    issue="; ".join(issues) if issues else "Correct - dual AL/CU with copper keyword"
+                )
+
+            # S12: Aluminum keyword
+            if has_aluminum_kw:
+                expected = [GENERAL_301_CODE] + list(ALUMINUM_232_CODES)
+                issues = []
+
+                if not has_301:
+                    issues.append("Missing 99030133")
+                if not has_aluminum_232:
+                    issues.append("Missing aluminum 232 tariff (99038507/08)")
+                if has_copper_tariff:
+                    issues.append("Should NOT have copper tariff when description says aluminum")
+
+                status = "PASS" if not issues else "FAIL"
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S12",
+                    scenario_summary=SCENARIO_SUMMARIES["S12"],
+                    status=status,
+                    expected_hts=expected,
+                    missing_hts=self._get_missing_codes([GENERAL_301_CODE], has_301, ALUMINUM_232_CODES, has_aluminum_232),
+                    unexpected_hts=list(COPPER_CODES & additional_set),
+                    issue="; ".join(issues) if issues else "Correct - dual AL/CU with aluminum keyword"
+                )
+
+        # Dual Steel + Aluminum
+        if in_steel and in_aluminum:
+            # S7a: Both keywords - flag for review
+            if has_metal_kw and has_aluminum_kw:
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S7a",
+                    scenario_summary=SCENARIO_SUMMARIES["S7a"],
+                    status="FLAG",
+                    expected_hts=[],
+                    missing_hts=[],
+                    unexpected_hts=[],
+                    issue="AMBIGUOUS: Description contains both steel and aluminum keywords - manual review required"
+                )
+
+            # S7: Steel keyword
+            if has_metal_kw:
+                expected = [GENERAL_301_CODE] + list(STEEL_232_CODES)
+                issues = []
+
+                if not has_301:
+                    issues.append("Missing 99030133")
+                if not has_steel_232:
+                    issues.append("Missing steel 232 tariff (99038190/91)")
+                if has_aluminum_232:
+                    issues.append("Should NOT have aluminum 232 when description says steel")
+                if has_mismatch:
+                    issues.append("Should NOT have 99030125 with correct steel classification")
+
+                status = "PASS" if not issues else "FAIL"
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S7",
+                    scenario_summary=SCENARIO_SUMMARIES["S7"],
+                    status=status,
+                    expected_hts=expected,
+                    missing_hts=self._get_missing_codes([GENERAL_301_CODE], has_301, STEEL_232_CODES, has_steel_232),
+                    unexpected_hts=list(ALUMINUM_232_CODES & additional_set) + ([MISMATCH_CODE] if has_mismatch else []),
+                    issue="; ".join(issues) if issues else "Correct - dual ST/AL with steel keyword"
+                )
+
+            # S7: Aluminum keyword
+            if has_aluminum_kw:
+                expected = [GENERAL_301_CODE] + list(ALUMINUM_232_CODES)
+                issues = []
+
+                if not has_301:
+                    issues.append("Missing 99030133")
+                if not has_aluminum_232:
+                    issues.append("Missing aluminum 232 tariff (99038507/08)")
+                if has_steel_232:
+                    issues.append("Should NOT have steel 232 when description says aluminum")
+                if has_mismatch:
+                    issues.append("Should NOT have 99030125 with correct aluminum classification")
+
+                status = "PASS" if not issues else "FAIL"
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S7",
+                    scenario_summary=SCENARIO_SUMMARIES["S7"],
+                    status=status,
+                    expected_hts=expected,
+                    missing_hts=self._get_missing_codes([GENERAL_301_CODE], has_301, ALUMINUM_232_CODES, has_aluminum_232),
+                    unexpected_hts=list(STEEL_232_CODES & additional_set) + ([MISMATCH_CODE] if has_mismatch else []),
+                    issue="; ".join(issues) if issues else "Correct - dual ST/AL with aluminum keyword"
+                )
+
+            # S8: Neither keyword
+            expected = [MISMATCH_CODE]
+            issues = []
+
+            if not has_mismatch:
+                issues.append("Missing 99030125")
+            if has_steel_232 or has_aluminum_232:
+                issues.append("Should NOT have 232 tariffs without steel/aluminum keyword")
+
+            status = "PASS" if not issues else "FAIL"
+            return ValidationResult(
+                entry_number=entry_number,
+                description=description,
+                primary_hts=primary_hts,
+                additional_hts=additional_hts,
+                scenario_id="S8",
+                scenario_summary=SCENARIO_SUMMARIES["S8"],
+                status=status,
+                expected_hts=expected,
+                missing_hts=[MISMATCH_CODE] if not has_mismatch else [],
+                unexpected_hts=self._get_unexpected_232(additional_set),
+                issue="; ".join(issues) if issues else "Correct - dual ST/AL with no keyword, has 99030125"
+            )
+
+        # Priority 3: Single list scenarios
+
+        # Steel scenarios (S1, S2, S3)
+        if in_steel and not in_aluminum and not in_copper:
+            if has_metal_kw:
+                # S1: Steel HTS + metal keyword + 232 tariff
+                if has_steel_232:
+                    expected = [GENERAL_301_CODE]
+                    issues = []
+
+                    if not has_301:
+                        issues.append("Missing 99030133")
+                    if has_mismatch:
+                        issues.append("Should NOT have 99030125 with correct steel classification")
+
+                    status = "PASS" if not issues else "FAIL"
+                    return ValidationResult(
+                        entry_number=entry_number,
+                        description=description,
+                        primary_hts=primary_hts,
+                        additional_hts=additional_hts,
+                        scenario_id="S1",
+                        scenario_summary=SCENARIO_SUMMARIES["S1"],
+                        status=status,
+                        expected_hts=[GENERAL_301_CODE] + list(STEEL_232_CODES),
+                        missing_hts=[GENERAL_301_CODE] if not has_301 else [],
+                        unexpected_hts=[MISMATCH_CODE] if has_mismatch else [],
+                        issue="; ".join(issues) if issues else "Correct - steel HTS + keyword + 232"
+                    )
+                else:
+                    # Steel HTS + metal keyword but no 232 - should have 232
+                    issues = ["Missing steel 232 tariff (99038190/91)"]
+                    if not has_301:
+                        issues.append("Missing 99030133")
+
+                    return ValidationResult(
+                        entry_number=entry_number,
+                        description=description,
+                        primary_hts=primary_hts,
+                        additional_hts=additional_hts,
+                        scenario_id="S1",
+                        scenario_summary=SCENARIO_SUMMARIES["S1"],
+                        status="FAIL",
+                        expected_hts=[GENERAL_301_CODE] + list(STEEL_232_CODES),
+                        missing_hts=[GENERAL_301_CODE] + list(STEEL_232_CODES) if not has_301 else list(STEEL_232_CODES),
+                        unexpected_hts=[],
+                        issue="; ".join(issues)
+                    )
+            else:
+                # S3: Steel HTS but NO metal keyword
+                expected = [MISMATCH_CODE]
+                issues = []
+
+                if not has_mismatch:
+                    issues.append("Missing 99030125 - steel HTS without metal description")
+
+                status = "FLAG"  # Always flag for review
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S3",
+                    scenario_summary=SCENARIO_SUMMARIES["S3"],
+                    status=status,
+                    expected_hts=expected,
+                    missing_hts=[MISMATCH_CODE] if not has_mismatch else [],
+                    unexpected_hts=[],
+                    issue="HTS in steel list but description has no metal keywords - verify classification"
+                )
+
+        # S2: Metal keyword but NOT in steel list
+        if has_metal_kw and not in_steel:
+            expected = [MISMATCH_CODE]
+            issues = []
+
+            if not has_mismatch:
+                issues.append("Missing 99030125")
+            if has_steel_232:
+                issues.append("Should NOT have steel 232 tariff - HTS not in steel list")
+
+            status = "PASS" if not issues else "FAIL"
+            return ValidationResult(
+                entry_number=entry_number,
+                description=description,
+                primary_hts=primary_hts,
+                additional_hts=additional_hts,
+                scenario_id="S2",
+                scenario_summary=SCENARIO_SUMMARIES["S2"],
+                status=status,
+                expected_hts=expected,
+                missing_hts=[MISMATCH_CODE] if not has_mismatch else [],
+                unexpected_hts=list(STEEL_232_CODES & additional_set),
+                issue="; ".join(issues) if issues else "Correct - metal keyword with non-steel HTS"
+            )
+
+        # Aluminum scenarios (S4, S5, S6)
+        if in_aluminum and not in_steel and not in_copper:
+            if has_aluminum_kw:
+                # S4: Aluminum HTS + aluminum keyword + 232 tariff
+                if has_aluminum_232:
+                    expected = [GENERAL_301_CODE]
+                    issues = []
+
+                    if not has_301:
+                        issues.append("Missing 99030133")
+
+                    status = "PASS" if not issues else "FAIL"
+                    return ValidationResult(
+                        entry_number=entry_number,
+                        description=description,
+                        primary_hts=primary_hts,
+                        additional_hts=additional_hts,
+                        scenario_id="S4",
+                        scenario_summary=SCENARIO_SUMMARIES["S4"],
+                        status=status,
+                        expected_hts=[GENERAL_301_CODE] + list(ALUMINUM_232_CODES),
+                        missing_hts=[GENERAL_301_CODE] if not has_301 else [],
+                        unexpected_hts=[],
+                        issue="; ".join(issues) if issues else "Correct - aluminum HTS + keyword + 232"
+                    )
+                else:
+                    # Aluminum HTS + keyword but no 232
+                    issues = ["Missing aluminum 232 tariff (99038507/08)"]
+                    if not has_301:
+                        issues.append("Missing 99030133")
+
+                    return ValidationResult(
+                        entry_number=entry_number,
+                        description=description,
+                        primary_hts=primary_hts,
+                        additional_hts=additional_hts,
+                        scenario_id="S4",
+                        scenario_summary=SCENARIO_SUMMARIES["S4"],
+                        status="FAIL",
+                        expected_hts=[GENERAL_301_CODE] + list(ALUMINUM_232_CODES),
+                        missing_hts=[GENERAL_301_CODE] + list(ALUMINUM_232_CODES) if not has_301 else list(ALUMINUM_232_CODES),
+                        unexpected_hts=[],
+                        issue="; ".join(issues)
+                    )
+            else:
+                # S6: Aluminum HTS but NO aluminum keyword
+                expected = [MISMATCH_CODE]
+                issues = []
+
+                if not has_mismatch:
+                    issues.append("Missing 99030125 - aluminum HTS without aluminum description")
+
+                status = "FLAG"
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S6",
+                    scenario_summary=SCENARIO_SUMMARIES["S6"],
+                    status=status,
+                    expected_hts=expected,
+                    missing_hts=[MISMATCH_CODE] if not has_mismatch else [],
+                    unexpected_hts=[],
+                    issue="HTS in aluminum list but description has no aluminum keywords - verify classification"
+                )
+
+        # S5: Aluminum keyword but NOT in aluminum list
+        if has_aluminum_kw and not in_aluminum:
+            expected = [MISMATCH_CODE]
+            issues = []
+
+            if not has_mismatch:
+                issues.append("Missing 99030125")
+            if has_aluminum_232:
+                issues.append("Should NOT have aluminum 232 tariff - HTS not in aluminum list")
+
+            status = "PASS" if not issues else "FAIL"
+            return ValidationResult(
+                entry_number=entry_number,
+                description=description,
+                primary_hts=primary_hts,
+                additional_hts=additional_hts,
+                scenario_id="S5",
+                scenario_summary=SCENARIO_SUMMARIES["S5"],
+                status=status,
+                expected_hts=expected,
+                missing_hts=[MISMATCH_CODE] if not has_mismatch else [],
+                unexpected_hts=list(ALUMINUM_232_CODES & additional_set),
+                issue="; ".join(issues) if issues else "Correct - aluminum keyword with non-aluminum HTS"
+            )
+
+        # Copper scenarios (S9, S10, COPPER_OK)
+        if in_copper and not in_steel and not in_aluminum:
+            if has_copper_kw:
+                # COPPER_OK: Copper HTS + copper keyword
+                expected = list(COPPER_CODES)
+                issues = []
+
+                if not has_copper_tariff:
+                    issues.append("Missing copper tariff (99037801/02)")
+
+                status = "PASS" if not issues else "FAIL"
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="COPPER_OK",
+                    scenario_summary=SCENARIO_SUMMARIES["COPPER_OK"],
+                    status=status,
+                    expected_hts=expected,
+                    missing_hts=list(COPPER_CODES) if not has_copper_tariff else [],
+                    unexpected_hts=[],
+                    issue="; ".join(issues) if issues else "Correct - copper HTS + keyword"
+                )
+            else:
+                # S10: Copper HTS but NO copper keyword
+                status = "FLAG"
+                return ValidationResult(
+                    entry_number=entry_number,
+                    description=description,
+                    primary_hts=primary_hts,
+                    additional_hts=additional_hts,
+                    scenario_id="S10",
+                    scenario_summary=SCENARIO_SUMMARIES["S10"],
+                    status=status,
+                    expected_hts=[],
+                    missing_hts=[],
+                    unexpected_hts=[],
+                    issue="HTS in copper list but description has no copper keywords - verify classification"
+                )
+
+        # S9: Copper keyword but NOT in copper list
+        if has_copper_kw and not in_copper:
+            status = "FLAG"
+            return ValidationResult(
+                entry_number=entry_number,
+                description=description,
+                primary_hts=primary_hts,
+                additional_hts=additional_hts,
+                scenario_id="S9",
+                scenario_summary=SCENARIO_SUMMARIES["S9"],
+                status=status,
+                expected_hts=[],
+                missing_hts=[],
+                unexpected_hts=[],
+                issue="Description mentions copper but HTS not in copper list - potential misclassification"
+            )
+
+        # No applicable scenario
+        return ValidationResult(
+            entry_number=entry_number,
+            description=description,
+            primary_hts=primary_hts,
+            additional_hts=additional_hts,
+            scenario_id="NONE",
+            scenario_summary=SCENARIO_SUMMARIES["NONE"],
+            status="PASS",
+            expected_hts=[],
+            missing_hts=[],
+            unexpected_hts=[],
+            issue="No metal-related validation required"
+        )
+
+    def _get_unexpected_232(self, additional_set: Set[str]) -> List[str]:
+        """Get list of 232 tariffs that shouldn't be present"""
+        all_232 = STEEL_232_CODES | ALUMINUM_232_CODES | COPPER_CODES
+        return list(all_232 & additional_set)
+
+    def _get_missing_codes(self, fixed_codes: List[str], has_fixed: bool,
+                           variable_codes: Set[str], has_variable: bool) -> List[str]:
+        """Get list of missing codes"""
+        missing = []
+        if not has_fixed:
+            missing.extend(fixed_codes)
+        if not has_variable:
+            missing.extend(list(variable_codes))
+        return missing
+
+
+def validate_dataframe(df, validator: HTSValidator,
+                       description_col: str = "Description",
+                       tariff_col: str = "Tariff",
+                       entry_col: str = "Entry Number",
+                       additional_cols: List[str] = None) -> List[ValidationResult]:
+    """Validate all entries in a DataFrame"""
+
+    if additional_cols is None:
+        additional_cols = ["Primary 1", "Primary 2", "Primary 3",
+                          "Primary 4", "Primary 5", "Primary 6"]
+
+    results = []
+
+    for idx, row in df.iterrows():
+        entry_number = str(row.get(entry_col, f"Row_{idx}"))
+        description = str(row.get(description_col, ""))
+        primary_hts = str(row.get(tariff_col, ""))
+
+        # Get additional HTS codes
+        additional_hts = []
+        for col in additional_cols:
+            if col in row and row[col] is not None:
+                val = row[col]
+                if str(val).strip() and str(val).lower() != "nan":
+                    additional_hts.append(str(val))
+
+        result = validator.validate_entry(
+            entry_number=entry_number,
+            description=description,
+            primary_hts=primary_hts,
+            additional_hts=additional_hts
+        )
+        results.append(result)
+
+    return results

requirements.txt

@@ -0,0 +1,3 @@
+streamlit
+pandas
+openpyxl