arttactic 0.1.1__tar.gz

arttactic-0.1.1/LICENSE

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

arttactic-0.1.1/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: arttactic
+Version: 0.1.1
+Summary: Processing library for art auction data
+Author: Nafisa Sharif
+License: MIT License
+        
+        Copyright (c) 2026 Nafisa Sharif
+        
+        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.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=3.0.1
+Requires-Dist: openpyxl>=3.1.5
+Dynamic: license-file
+
+# arttactic
+
+A Python library for extracting and processing data from scraped art auction results. Currently designed to run on Linux or macOS, not yet tested on Windows.
+
+
+## Description
+
+`arttactic` provides tools for working with art auction datasets, including:
+
+* Cleaning and transforming auction data
+* Applying buyer’s premium calculations
+* Extracting mediums from lot information
+
+
+## Installation
+
+(Recommended) In the terminal, create a virtual environment and activate it.
+
+For example:
+
+```bash
+python3 -m venv arttactic-venv
+source arttactic-venv/bin/activate
+```
+
+Then install the arttactic library:
+
+```bash
+pip install arttactic
+```
+
+## Usage
+
+From the terminal, run the following CLI command:
+
+```bash
+run-arttactic
+```
+
+This will launch a GUI that allows you to:
+- Select a directory containing .csv files with scraped auction data,
+- Select a single file you wish to add buyer's premiums to,
+- Generate processed spreadsheets after selecting a directory,
+- Generate processed spreadsheets after selecting a directory, and also find and save new mediums,
+- Add buyer's premiums to a selected file.
+
+
+## Development
+
+(Only relevant if you wish to edit the source code.)
+To install locally in editable mode:
+
+```bash
+pip install -e .
+```

arttactic-0.1.1/README.md

@@ -0,0 +1,55 @@
+# arttactic
+
+A Python library for extracting and processing data from scraped art auction results. Currently designed to run on Linux or macOS, not yet tested on Windows.
+
+
+## Description
+
+`arttactic` provides tools for working with art auction datasets, including:
+
+* Cleaning and transforming auction data
+* Applying buyer’s premium calculations
+* Extracting mediums from lot information
+
+
+## Installation
+
+(Recommended) In the terminal, create a virtual environment and activate it.
+
+For example:
+
+```bash
+python3 -m venv arttactic-venv
+source arttactic-venv/bin/activate
+```
+
+Then install the arttactic library:
+
+```bash
+pip install arttactic
+```
+
+## Usage
+
+From the terminal, run the following CLI command:
+
+```bash
+run-arttactic
+```
+
+This will launch a GUI that allows you to:
+- Select a directory containing .csv files with scraped auction data,
+- Select a single file you wish to add buyer's premiums to,
+- Generate processed spreadsheets after selecting a directory,
+- Generate processed spreadsheets after selecting a directory, and also find and save new mediums,
+- Add buyer's premiums to a selected file.
+
+
+## Development
+
+(Only relevant if you wish to edit the source code.)
+To install locally in editable mode:
+
+```bash
+pip install -e .
+```

arttactic-0.1.1/arttactic/extraction.py

@@ -0,0 +1,101 @@
+import pandas as pd
+
+from arttactic.variables.reg_exs import yyyy, yyyy_yy, yyyy_yyyy
+
+
+
+def fill_auto_years(row: pd.Series, creation_terms: list, conceived_terms: list) -> pd.Series:
+    try:
+        info = row["Info (Auto)"]
+        row["Creation Year (Auto)"] = []
+        row["Conceived Year (Auto)"] = []
+        row["Flags (Auto)"] = []
+
+        birth_year = 0
+
+        if 'cast' in ','.join(info):
+            for substring in info:
+                substring_split = substring.split()
+                if 'cast' in substring:
+                    if substring.endswith('s'):
+                        row["Creation Year (Auto)"].append(substring[-5:-1])
+                    elif yyyy.fullmatch(substring_split[-1]):
+                        row["Creation Year (Auto)"].append(substring[-4:])
+                    elif yyyy_yy.fullmatch(substring_split[-1]):
+                        row["Creation Year (Auto)"].append(f"{substring_split[-1][:2]}{substring[-2:]}")
+                if 'dated' in substring:
+                    row["Conceived Year (Auto)"].append(substring)
+
+        else:    
+            for substring in info:
+                substring_split = substring.split()
+                if substring_split[0] in creation_terms:
+                    if len(substring_split[-1]) != 4:
+                        row["Conceived Year (Auto)"].append(substring)
+                        if substring_split[-1].endswith('s'):
+                            row["Creation Year (Auto)"].append(substring[-5:-1])
+                        else:
+                            if yyyy_yy.fullmatch(substring_split[-1]):
+                                try:
+                                    int_test = int(row["Born"])
+                                    birth_year = (str(int_test))
+                                except:
+                                    raise Exception("no birth year")
+                                if birth_year != 0:
+                                    creation_year = substring_split[-1][5:]
+                                    century = int((birth_year)[:2])
+                                    try:
+                                        if int(creation_year) > int((birth_year)[2:]):
+                                            full_year = (f"{century}{creation_year}")
+                                        elif int(creation_year) < int((birth_year)[2:]):
+                                            century = century + 1
+                                            full_year = (f"{century}{creation_year}")
+                                        row["Creation Year (Auto)"].append(full_year)
+                                    except:
+                                        pass
+                            elif yyyy_yyyy.fullmatch(substring_split[-1]):
+                                row["Creation Year (Auto)"].append(substring[-4:])
+                    else:
+                        row["Creation Year (Auto)"].append(substring[-4:])
+
+                if substring_split[0] in conceived_terms:
+                        row["Conceived Year (Auto)"].append(substring)
+
+                if 'circa' in substring:
+                        row["Conceived Year (Auto)"].append(substring)
+
+        if (len(row["Creation Year (Auto)"]) > 1) and (len(set(row["Creation Year (Auto)"])) > 1):
+            row["Flags (Auto)"] = ["Multiple creation years in lot notes"]
+            try:
+                int_test = int(row["Creation Year"])
+                if str(row["Creation Year"]) in row["Creation Year (Auto)"]:
+                    row["Creation Year (Auto)"] = row["Creation Year"]
+                else:
+                    row["Creation Year (Auto)"] = max(row["Creation Year (Auto)"])
+            except:
+                row["Creation Year (Auto)"] = max(row["Creation Year (Auto)"])
+        else:
+            if row["Creation Year (Auto)"]:
+                row["Creation Year (Auto)"] = max(row["Creation Year (Auto)"])
+    except:
+        pass
+    return row
+
+def add_flags(row: pd.Series) -> pd.Series:
+    if row["Info (Auto)"] and (len(row["Conceived Year (Auto)"]) == 0):
+        row["Flags (Auto)"].append("No conceived information in lot notes")
+            
+    if not row["Info (Auto)"]:
+        row["Flags (Auto)"].append("No date information in lot notes")
+            
+    elif row["Info (Auto)"] and (len(row["Creation Year (Auto)"]) == 0):
+        row["Flags (Auto)"].append("No creation year in lot notes")
+
+    elif str(row["Creation Year"]) != str(row["Creation Year (Auto)"]):
+        if pd.isnull(row["Creation Year"]):
+            row["Flags (Auto)"].append(f"Mismatched creation years: manual=None and auto={row['Creation Year (Auto)']}")                
+        else:
+            row["Flags (Auto)"].append(f"Mismatched creation years: manual={row['Creation Year']} and auto={row['Creation Year (Auto)']}")                
+
+    row["Flags (Auto)"] = ", ".join(row["Flags (Auto)"])
+    return row

arttactic-0.1.1/arttactic/mixed_scrapes.py

@@ -0,0 +1,378 @@
+import os
+import sys
+import pandas as pd
+from datetime import datetime
+from joblib import Parallel, delayed
+from importlib import resources
+
+from arttactic.utils.df_utils import find_and_concatenate_csvs, set_column_types, add_auto_columns
+from arttactic.utils.string_utils import clean_string, clean_birth_years, clean_death_years, return_substrings, trim_substrings, clean_short_years, find_term_in_line, remove_duplicate_mediums
+from arttactic.extraction import fill_auto_years, add_flags
+from arttactic.premiums import add_premium_columns
+from arttactic.variables.search_lists import search_terms, creation_terms, conceived_terms
+
+
+
+def define_new_dataframe() -> pd.DataFrame:
+    template_df = pd.DataFrame(columns=[
+        "Database Id",
+        "Artist",
+        "Artist First Names",
+        "Artist Last Names",
+        "Artist Chinese Name",
+        "Born",
+        "Dead",
+        "-",
+        "Title",
+        "Creation Year",
+        "Conceived Year (if other than Creation Year)",
+        "Medium (Category)",
+        "Medium (Detailed)",
+        "Height (cm)",
+        "Width (cm)",
+        "Depth (cm)",
+        "Size (Detailed)",
+        "Orientation (if 2D work)",
+        "Sqm (if 2D work)",
+        "Edition No",
+        "Size of edition",
+        "Lot Notes (Detailed)",
+        "-",
+        "Low Estimate (USD)",
+        "High Estimate (USD)",
+        "Average Estimate (USD)",
+        "Hammer Price (USD)",
+        "Aggregate Price (USD)",
+        "Price/Average",
+        "-",
+        "$1m+",
+        "$1m+ Low Estimate",
+        "$1m+ Hammer",
+        "$1m+ Premium",
+        "-",
+        "Guarantees",
+        "Type of Guarantee",
+        "Return on Guarantee",
+        "-",
+        "Unsold Comment",
+        "Paddle No.",
+        "Buyer Type",
+        "Buyer Info",
+        "Underbidder Info",
+        "Online Interest",
+        "-",
+        "Auction House",
+        "Location",
+        "Region",
+        "Sale Date",
+        "Sale Month",
+        "Quarter",
+        "1H/2H",
+        "Sale Year",
+        "-",
+        "Lot Number",
+        "Lot Sequence",
+        "Sale Title",
+        "Sale Number",
+        "Sale URL",
+        "Market Sector",
+        "Type of Sale",
+        "Timing of Sale",
+        "Sale Format",
+        "Sale Subject",
+        "Name of Single Owner",
+        "Named Collector?",
+        "Name of Collector",
+        "African Market Sector",
+        "Italian Market Sector",
+        "Latin American Market Sector",
+        "MENA Market Sector",
+        "Old Master Market Sector",
+        "Photo Market Sector",
+        "-",
+        "Currency Conversion Rate",
+        "Currency Code",
+        "-",
+        "Estimate on Request",
+        "Low Estimate (OC)",
+        "High Estimate (OC)",
+        "Average Estimate (OC)",
+        "Hammer Price (OC)",
+        "Aggregate Price (OC)",
+        "Price/Average  (OC)",
+        "-",
+        "Gender",
+        "Dead/Alive",
+        "Active Century",
+        "Nationality",
+        "Artist Region",
+        "-",
+        "Repeat Sale Id",
+        "Provenance",
+        "Auction House RS",
+        "City",
+        "Estimate",
+        "Previous Sale Value (US Premium)",
+        "Previous Sale Date",
+        "% Increase",
+        "Holding Period",
+        "CAGR",
+        "Previous Owners",
+        "Previous Sales",
+        "-",
+        "Exhibition History",
+        "Literature",
+        "-",
+        "Movement",
+        "Movement Category",
+        "Black American?",
+        "Under 45 at at Time of Sale",
+        "Fresh Paint",
+        "Continental Region",
+        "African Region",
+        "Hong Kong Region",
+        "OMP Region",
+        "Modifier",
+        "OMP Active Century",
+        "Latin American Era",
+        "MENA Era",
+        "Photo Era",
+        "CWOA",
+        "Individual/Duo/Group/Collaboration",
+        "Notes",
+        "-",
+        "Wet Paint",
+        "Charity Sale",
+        "Recipient",
+        "Type of Charity",
+        "Flipped",
+        "-",
+        "Series",
+        "Category",
+        "-",
+        "Blank 1",
+        "Blank 2",
+        "Blank 3",
+        "Blank 4",
+        "Blank 5",
+        "-",
+        "Lot url",
+        "-",
+        "Original Database ID",
+        "Previous Database ID",
+        "-",
+        "Upload Status"
+    ])
+    return template_df
+
+def populate_new_df_from_old_scrapes(template_df: pd.DataFrame, old_scrapes_df: pd.DataFrame) -> pd.DataFrame:
+    # Populate columns with data from the concatenated files
+    new_df = template_df.copy()
+    new_df["Artist"] = old_scrapes_df["artist"]
+    new_df["Born"] = old_scrapes_df["artist_born"]
+    new_df["Artist_dates"] = old_scrapes_df["artist_dates"]
+    new_df["Dead"] = old_scrapes_df["artist_died"]
+    new_df["Auction House"] = old_scrapes_df["auction_house"]
+    new_df["Creation Year"] = old_scrapes_df["created"]
+    new_df ["Currency Code"] = old_scrapes_df["currency"]
+    new_df["Size (Detailed)"] = old_scrapes_df["dimensions"]
+    new_df["Guarantees"] = old_scrapes_df["guarantee"]
+    new_df["High Estimate (OC)"] = old_scrapes_df["high_estimate"]
+    new_df["Lot Notes (Detailed)"] = old_scrapes_df["lot_notes"]
+    new_df["Lot Number"] = old_scrapes_df["lot_number"]
+    new_df["Lot url"] = old_scrapes_df["lot_url"]
+    new_df["Low Estimate (OC)"] = old_scrapes_df["low_estimate"]
+    new_df["Medium (Detailed)"] = old_scrapes_df["medium"]
+    new_df["Underbidder Info"] = old_scrapes_df["number_of_bids"]
+    new_df["Aggregate Price (OC)"] = old_scrapes_df["price_realised"]
+    new_df["Provenance"] = old_scrapes_df["provenance"]
+    new_df["Sale Date"] = old_scrapes_df["sale_date"]
+    new_df["Location"] = old_scrapes_df["sale_location"]
+    new_df["Sale Number"] = old_scrapes_df["sale_number"]
+    new_df["Sale Title"] = old_scrapes_df["sale_title"]
+    new_df["Title"] = old_scrapes_df["title"]
+    return new_df
+
+def populate_new_df_from_new_scrapes(template_df: pd.DataFrame, new_scrapes_df: pd.DataFrame) -> pd.DataFrame:
+    # Populate columns with data from the concatenated files
+    new_df = template_df.copy()
+    new_df["Artist"] = new_scrapes_df["Artist Name"]
+    new_df["Born"] = pd.Series()
+    new_df["Artist_dates"] = new_scrapes_df["Artist Dates"]
+    new_df["Dead"] = pd.Series()
+    new_df["Auction House"] = new_scrapes_df["Auction House"]
+    new_df["Creation Year"] = new_scrapes_df["Created Date"]
+    new_df ["Currency Code"] = new_scrapes_df["Currency"]
+    new_df["Size (Detailed)"] = new_scrapes_df["Dimensions"]
+    new_df["Guarantees"] = new_scrapes_df["Guarantee"]
+    new_df["High Estimate (OC)"] = new_scrapes_df["High Estimate"]
+    new_df["Lot Notes (Detailed)"] = new_scrapes_df["Lot Notes"]
+    new_df["Lot Number"] = new_scrapes_df["Lot Number"]
+    new_df["Lot url"] = new_scrapes_df["Lot URL"]
+    new_df["Low Estimate (OC)"] = new_scrapes_df["Low Estimate"]
+    new_df["Medium (Detailed)"] = new_scrapes_df["Medium"]
+    new_df["Aggregate Price (OC)"] = new_scrapes_df["Price Realised"]
+    new_df["Provenance"] = new_scrapes_df["Provenance"]
+    new_df["Sale Date"] = new_scrapes_df["Sale Date"]
+    new_df["Location"] = new_scrapes_df["Sale Location"]
+    if "Sale Number" in new_scrapes_df.columns:
+        new_df["Sale Number"] = new_scrapes_df["Sale Number"]
+    else:
+        new_df["Sale Number"] = pd.Series()
+    new_df["Sale Title"] = new_scrapes_df["Sale Name"]
+    new_df["Title"] = new_scrapes_df["Lot Name"]
+    return new_df
+
+
+def prepare_df(data_path: str) -> pd.DataFrame:
+    os.chdir(data_path)
+    old_scrapes_df, new_scrapes_df = find_and_concatenate_csvs()
+    new_df = define_new_dataframe()
+    old_scrapes_mapped = pd.DataFrame()
+    new_scrapes_mapped = pd.DataFrame()
+    if len(old_scrapes_df) > 0:
+        old_scrapes_mapped = populate_new_df_from_old_scrapes(new_df, old_scrapes_df)
+    if len(new_scrapes_df) > 0:
+        new_scrapes_mapped = populate_new_df_from_new_scrapes(new_df, new_scrapes_df)
+    df = pd.concat([old_scrapes_mapped, new_scrapes_mapped], ignore_index=True)
+    df = set_column_types(df)
+    df = add_auto_columns(df)
+    df["Aggregate Price (OC)"] = df["Aggregate Price (OC)"].apply(lambda x: str(x).replace(",",""))
+    return df
+
+
+def extract_info(df: pd.DataFrame, search_terms: list) -> pd.DataFrame:
+    for i in range(len(df)):
+        try:
+            df["Lot Notes (Auto)"][i].extend(clean_string(df["Lot Notes (Detailed)"][i]))
+        except Exception as e:
+            print("Exception cleaning lot notes: ", e)
+            print(i)
+        try:
+            int(df.loc[i,"Born"])
+        except:
+            try:
+                df["Born"].iloc[i] = (clean_birth_years(df["Artist_dates"].iloc[i]))
+            except Exception as e:
+                print("Exception extracting birth years: ", e)
+                print(i)
+        try:
+            int(df.loc[i,"Dead"])
+        except:
+            try:
+                df.loc[i,"Dead"] = (clean_death_years(df.loc[i,"Artist_dates"]))
+            except Exception as e:
+                print("Exception extracting death years: ", e)
+                print(i)
+        try:
+            #df.loc[i,"Info (Auto)"] = (return_substrings(df.loc[i,"Lot Notes (Auto)"], search_terms))
+            lot_notes_split = df["Lot Notes (Auto)"][i]
+            substrings = return_substrings(lot_notes_split, search_terms)
+            for sublist in substrings:
+                df["Info (Auto)"][i].extend(sublist)
+        except Exception as e:
+            print("Exception creating substrings: ", e)
+            print(i)
+        try:
+            trimmed = (trim_substrings(df["Info (Auto)"][i]))
+            df["Info (Auto)"][i].extend(trimmed)
+        except Exception as e:
+            print("Exception trimming substrings: ", e)
+            print(i)
+        try:
+            short_years_cleaned = clean_short_years(df.iloc[i])
+            df["Info (Auto)"][i].extend(short_years_cleaned)
+        except Exception as e:
+            print("Exception cleaning short years: ", e)
+            print(i)
+    df["Lot Notes (Auto)"] = df["Lot Notes (Auto)"].apply(lambda x : " ".join(x))
+    return df
+
+
+def extract_mediums(df: pd.DataFrame, data_path: str, find_new: bool) -> pd.DataFrame:
+    os.chdir(sys.path[0])
+    with resources.files("arttactic").joinpath("data/Medium_List.xlsx").open("rb") as f:
+        medium_data = pd.read_excel(f)
+
+    medium_list = medium_data["Medium (Detailed)"]
+    new_mediums = []
+    for i in range(len(df)):
+        df["Medium (Auto)"][i] = []
+        if type(df.loc[i, "Medium (Detailed)"]) == str:
+            df["Medium (Auto)"][i] = str(df.loc[i, "Medium (Detailed)"])
+        else:
+            if type(df["Lot Notes (Detailed)"].iloc[i]) == str:
+                split_lines = df["Lot Notes (Detailed)"].iloc[i].splitlines()
+                for line in split_lines:
+                    if any(word in line for word in search_terms) or ("grateful" in line)  or ("painter" in line) or ("florentine" in line.lower()) or (line in str(df["Title"].iloc[i])) or (line in str(df["Artist"].iloc[i])):
+                        pass
+                    elif line in medium_list:
+                        df["Medium (Auto)"].iloc[i].append(line)
+                    else:
+                        if find_new:
+                            df["Medium (Auto)"].iloc[i] = []
+                            cleaned_line = " ".join(clean_string(line))
+                            result = Parallel(n_jobs=8)(delayed(find_term_in_line)(x, cleaned_line) for x in medium_list)
+                            result_list = list(result)
+                            if len(set(result_list)) > 1:
+                                df["Medium (Auto)"].iloc[i].append(cleaned_line)
+                                new_mediums.append(cleaned_line)
+                if df["Medium (Auto)"].iloc[i] == []:
+                    cleaned_string = " ".join(clean_string(df["Lot Notes (Detailed)"].iloc[i]))
+                    for medium in medium_list:
+                        if medium.lower() in cleaned_string:
+                            df["Medium (Auto)"].iloc[i].append(medium.lower())
+                df["Medium (Auto)"].iloc[i] = remove_duplicate_mediums(df["Medium (Auto)"].iloc[i])
+                df["Medium (Auto)"].iloc[i] = ", ".join(df["Medium (Auto)"].iloc[i])  
+    if len(new_mediums) > 0:
+        new_mediums = list(set(new_mediums))
+        new_medium_df = pd.DataFrame({"Medium (Detailed)" : new_mediums})
+        combined = pd.concat([medium_data, new_medium_df])
+        combined = combined.drop_duplicates()
+        combined.to_excel("data/Medium_List.xlsx", index=False)
+    os.chdir(data_path)
+    return df
+
+
+def clean_artist_names(df: pd.DataFrame) -> pd.DataFrame:
+    for i in range(len(df)):
+        if type(df.loc[i, "Artist"]) != str:
+            df.loc[i, "Artist (Auto)"] = ""
+        else:
+            df.loc[i, "Artist (Auto)"] = df.loc[i, "Artist"].split('(')[0].strip()
+            df.loc[i, "Artist (Auto)"] = df.loc[i, "Artist (Auto)"].title()
+    return df
+
+
+def fill_years_and_add_flags(df: pd.DataFrame, creation_terms: list, conceived_terms: list) -> pd.DataFrame:
+    for i in range(len(df)):
+        try:
+            df.iloc[i] = fill_auto_years(df.iloc[i], creation_terms, conceived_terms)
+        except Exception as e:
+            print("Exception filling auto years: ", e)
+            print(i)
+        try:
+            df.iloc[i] = add_flags(df.iloc[i])
+        except Exception as e:
+            print("Exception adding flags: ", e)
+            print(i)
+    return df
+
+
+def extract_from_scrapes(data_path: str, find_new_mediums: bool=False):
+    df = prepare_df(data_path)
+    print("Preparing new spreadsheet template")
+    df = extract_info(df, search_terms)
+    print("Extracting mediums")
+    df = extract_mediums(df, data_path, find_new=find_new_mediums)
+    print("Cleaning artist names")
+    df = clean_artist_names(df)
+    print("Calculating premiums")
+    df = add_premium_columns(df)
+    print("Extracting dates")
+    df = fill_years_and_add_flags(df, creation_terms, conceived_terms)
+    date_and_time = datetime.now().strftime('%d-%m-%Y %H.%M')
+    time_now = datetime.now().strftime('%H:%M')
+    df.to_excel(f"Mapped scrape with dates {date_and_time}.xlsx", index=False)
+    print(f"File written successfully at {time_now}")
+    

arttactic-0.1.1/arttactic/premiums.py

@@ -0,0 +1,133 @@
+import numpy as np
+import pandas as pd
+import re
+from importlib import resources
+
+
+def load_premium_data():
+    with resources.files("arttactic").joinpath("data/Buyer's Premium.xlsx").open("rb") as f:
+        return pd.read_excel(f)
+
+def get_date_row(house, location, date):
+    premium_data = load_premium_data()
+    selected_rows = premium_data[(premium_data["Auction House"] == house) & (premium_data['Location'] == location)]
+    date = pd.to_datetime(date.date())
+    if selected_rows["Date Started"].dropna().max() < date:
+        # print('latest row')
+        date_row = selected_rows[selected_rows["Date Started"] == selected_rows["Date Started"].dropna().max()]
+
+    elif date < selected_rows["Date Ended"].dropna().min():
+        # print('earliest row')
+        date_row = selected_rows[selected_rows["Date Ended"] == selected_rows["Date Ended"].dropna().min()]
+
+    else:
+        date_row = selected_rows[(pd.to_datetime(selected_rows["Date Ended"]) > date) & (selected_rows["Date Started"] < date)]
+    return date_row
+
+def find_tier(price, date_row):
+    tier_1_boundary =  date_row["tier_1_boundary"].values[0]
+    tier_2_boundary =  date_row["tier_2_boundary"].values[0]
+    tier_3_boundary =  date_row["tier_3_boundary"].values[0]
+
+    numerical_values = re.findall(r'\d+', str(price))
+
+    if len(numerical_values) > 0:
+        price = numerical_values[0]
+        if int(price) <= tier_1_boundary:
+            return 1
+        elif (int(price) > tier_1_boundary) & (int(price) <= tier_2_boundary):
+            return 2
+        elif (int(price) > tier_3_boundary):
+            if pd.isna(tier_3_boundary):
+                return 3
+            elif (int(price) <= tier_3_boundary):
+                return 3
+            elif (int(price) > tier_3_boundary):
+                return 4
+
+
+def calculate_premium(row, date_row):
+    tier_1_boundary =  date_row["tier_1_boundary"].values[0]
+    tier_2_boundary =  date_row["tier_2_boundary"].values[0]
+    tier_3_boundary =  date_row["tier_3_boundary"].values[0]
+
+    if type(row["Tier (Auto)"]) == float and row["Tier (Auto)"] > 0:
+        numerical_values = re.findall(r'\d+', str(row["Aggregate Price (OC)"]))
+        price = float(numerical_values[0])
+        # print(row["Aggregate Price (OC)"])
+        if row["Tier (Auto)"] == 1:
+            return float(price*date_row["Tier 1 %"])/float(1 + date_row["Tier 1 %"])
+        elif row["Tier (Auto)"] == 2:
+            tier1_premium = (tier_1_boundary*date_row["Tier 1 %"])/(1 + date_row["Tier 1 %"])
+            tier2_portion = price - tier_1_boundary
+            tier2_premium = (tier2_portion*date_row["Tier 2 %"])/(1 + date_row["Tier 2 %"])
+            return np.round(float(tier1_premium+tier2_premium), 2)
+        elif row["Tier (Auto)"] == 3:
+            tier1_premium = (tier_1_boundary*date_row["Tier 1 %"])/(1 + date_row["Tier 1 %"])
+            tier2_portion = tier_2_boundary - tier_1_boundary
+            tier2_premium = (tier2_portion*date_row["Tier 2 %"])/(1 + date_row["Tier 2 %"])
+            tier3_portion = price - tier_2_boundary
+            tier3_premium = (tier3_portion*date_row["Tier 3 %"])/(1 + date_row["Tier 3 %"])
+            return np.round(float(tier1_premium+tier2_premium+tier3_premium), 2)
+        elif row["Tier (Auto)"] == 4:
+            tier1_premium = (tier_1_boundary*date_row["Tier 1 %"])/(1 + date_row["Tier 1 %"])
+            tier2_portion = tier_2_boundary - tier_1_boundary
+            tier2_premium = (tier2_portion*date_row["Tier 2 %"])/(1 + date_row["Tier 2 %"])
+            tier3_portion = tier_3_boundary - tier_2_boundary
+            tier3_premium = (tier3_portion*date_row["Tier 3 %"])/(1 + date_row["Tier 3 %"])
+            tier4_portion = price - tier_3_boundary
+            tier4_premium = (tier4_portion*date_row["Tier 4 %"])/(1 + date_row["Tier 4 %"])
+            return np.round(float(tier1_premium+tier2_premium+tier3_premium+tier4_premium), 2)
+
+
+def calculate_hammer_price(row):
+    if type(row["Tier (Auto)"]) == float and row["Tier (Auto)"] > 0:
+        numerical_values = re.findall(r'\d+', str(row["Aggregate Price (OC)"]))
+        price = float(numerical_values[0])
+        return (price - row["Premium (Auto)"])
+
+
+def add_premium_columns(df):
+    auction_dict = dict(list(df.groupby(["Auction House", "Location", "Sale Date"])))
+    for key, value in auction_dict.items():
+        house = key[0]
+        location = key[1]
+        date = key[2]
+
+        if location == "York":
+            location = "New York"
+            value["Location"] = "New York"
+        if location == "Kong":
+            location = "Hong Kong"
+            value["Location"] = "Hong Kong"
+        try:
+            date = pd.to_datetime(date)
+        except:
+            individual_dates = [x for x in date.split('-')]
+            dates = []
+            for d in individual_dates:
+                try:
+                    d = pd.to_datetime(d)
+                    dates.append(d)            
+                except:
+                    pass
+            date = max(dates)
+
+
+        date_row = get_date_row(house, location, date)
+
+        if len(date_row) == 0:
+            value["Tier (Auto)"] = ""
+            value["Premium (Auto)"] = ""
+            value["Hammer Price (Auto)"] = ""
+        else:
+            value["Tier (Auto)"] = value.apply(lambda row : find_tier(row["Aggregate Price (OC)"], date_row), axis=1)
+            value["Premium (Auto)"] = value.apply(lambda row : calculate_premium(row, date_row), axis=1)
+            # print(value["Aggregate Price (OC)"])
+            value["Hammer Price (Auto)"] = value.apply(lambda row : calculate_hammer_price(row), axis=1)
+    return pd.concat(auction_dict.values())
+
+def add_premium_columns_only(data_path: str):
+    existing_data = pd.read_excel(data_path)
+    data_with_premium_columns = add_premium_columns(existing_data)
+    data_with_premium_columns.to_excel(data_path, index=False, encoding='utf-8')

arttactic-0.1.1/arttactic/run.py

@@ -0,0 +1,79 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox
+import warnings
+import threading
+
+from arttactic.mixed_scrapes import extract_from_scrapes
+from arttactic.premiums import add_premium_columns_only
+
+
+class ProcessScrapes(object):
+    def __init__(self, root):
+        self.root = root
+        self.data_directory = None
+        self.existing_file = None
+
+    def choose_dir(self):
+        self.data_directory = filedialog.askdirectory()
+
+    def choose_file(self):
+        self.existing_file = filedialog.askopenfilename()
+
+    def create_spreadsheet(self):
+        if self.data_directory is not None:
+            threading.Thread(
+                target=extract_from_scrapes,
+                args=(self.data_directory,),
+                daemon=True
+            ).start()
+        else:
+            messagebox.showwarning(title=None, message="No directory has been selected.")
+
+    def create_spreadsheet_find_new_mediums(self):
+        if self.data_directory is not None:
+            threading.Thread(
+                target=extract_from_scrapes,
+                args=(self.data_directory,),
+                kwargs={"find_new_mediums": True},
+                daemon=True
+            ).start()
+        else:
+            messagebox.showwarning(title=None, message="No directory has been selected.")
+
+    def create_spreadsheet_premiums_only(self):
+        if self.existing_file is not None:
+            threading.Thread(
+                target=add_premium_columns_only,
+                args=(self.existing_file,),
+                daemon=True
+            ).start()
+        else:
+            messagebox.showwarning(title=None, message="No file has been selected.")
+
+    def pack_buttons(self):
+        button1 = tk.Button(self.root, text='Select directory', command=self.choose_dir, fg='#F66441')
+        button1.pack(side='top', pady=(40,4))
+        button2 = tk.Button(self.root, text='Select file', command=self.choose_file, fg='#4D8FFB')
+        button2.pack(side='top', pady=(4,40))
+        button3 = tk.Button(self.root, text='Create spreadsheet', command=self.create_spreadsheet, fg='#F66441')
+        button3.pack(side='top', pady=4)
+        button4 = tk.Button(self.root, text='Create spreadsheet (find new mediums)', command=self.create_spreadsheet_find_new_mediums, fg='#F66441')
+        button4.pack(side='top', pady=4)
+        button5 = tk.Button(self.root, text='Add premiums to existing file', command=self.create_spreadsheet_premiums_only, fg='#4D8FFB')
+        button5.pack(side='top', pady=4)
+
+
+def main():
+    warnings.filterwarnings("ignore")
+    root = tk.Tk()
+    # img = tk.Image("photo", file="icon.png")
+    # root.iconphoto(True, img)
+    root.title("ArtTactic Scrape Processor")
+    root.geometry('400x300')
+    root.resizable(0, 0)
+    instance = ProcessScrapes(root)
+    instance.pack_buttons()
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()

arttactic-0.1.1/arttactic/utils/df_utils.py

@@ -0,0 +1,47 @@
+import pandas as pd
+import numpy as np
+import glob
+
+
+
+def find_and_concatenate_csvs():
+    # Find all the .csv files in the current folder
+    csv_files = glob.glob('*.{}'.format('csv'))
+    old_scrapes = []
+    new_scrapes = []
+    # Separate the old and new scrapes
+    for f in csv_files:
+        df = pd.read_csv(f, encoding='utf8')
+        if "artist_dates" in df.columns:
+            old_scrapes.append(df)
+        else:
+            new_scrapes.append(df)
+    # Concatenate all the .csv files
+    if len(old_scrapes) > 0:
+        old_scrapes_df = pd.concat(old_scrapes, ignore_index=True)
+    else:
+        old_scrapes_df = pd.DataFrame()
+    if len(new_scrapes) > 0:
+        new_scrapes_df = pd.concat(new_scrapes, ignore_index=True)
+    else:
+        new_scrapes_df = pd.DataFrame()
+    return old_scrapes_df, new_scrapes_df
+
+
+# Deprecated
+def set_column_types(df):
+    df['Artist_dates'] = df['Artist_dates'].astype(str)
+    # Replace '<NA>' instances with NaN in artist_born column (important for merging column later)
+    df["Artist_dates"] = df["Artist_dates"].replace('<NA>', np.nan)   
+    return df
+
+
+def add_auto_columns(df):
+    df["Lot Notes (Auto)"] = [[] for _ in range(len(df))] 
+    df["Creation Year (Auto)"] = pd.Series([None]*len(df), dtype=object)
+    df["Conceived Year (Auto)"] = pd.Series([None]*len(df), dtype=object)
+    df["Medium (Auto)"] = [ [] for _ in range(len(df)) ]
+    df["Info (Auto)"] = [ [] for _ in range(len(df)) ]
+    df["Flags (Auto)"] = pd.Series([None]*len(df), dtype=object)
+    df["Artist (Auto)"] = pd.Series([None]*len(df), dtype=object)
+    return df

arttactic-0.1.1/arttactic/utils/string_utils.py

@@ -0,0 +1,119 @@
+import pandas as pd
+import re
+
+import os
+print (os.getcwd())
+
+from arttactic.variables.reg_exs import bd_year, yy, yyyy, yyyys, yyyy_yy, yyyy_yyyy, yyyys_yyyys
+
+
+
+def clean_string(string_to_clean: str) -> list:
+    string_to_clean = str(string_to_clean).lower()
+    string_to_clean = re.sub(",","",string_to_clean)
+    string_to_clean = re.sub("’","",string_to_clean)
+    string_to_clean = re.sub("‘","",string_to_clean)
+    string_to_clean = re.sub("'","",string_to_clean)
+    string_to_clean = re.sub("\"","",string_to_clean)
+    string_to_clean = re.sub(";","",string_to_clean)
+    string_to_clean = re.sub("\[","",string_to_clean)
+    string_to_clean = re.sub("]","",string_to_clean)
+    string_to_clean = re.sub("xad","",string_to_clean)
+    string_to_clean = re.sub("\\\\","",string_to_clean)
+    string_to_clean = re.sub("\."," ",string_to_clean)
+    string_to_clean = re.sub("<br>","",string_to_clean)
+    string_to_clean = re.sub("<i>","",string_to_clean)
+    string_to_clean = re.sub("</i>","",string_to_clean)
+    return string_to_clean.split()
+
+
+def clean_birth_years(artist_dates) -> int:
+    try:
+        return int(re.findall(bd_year, artist_dates)[0])
+    except:
+        return float("NaN")
+
+
+def clean_death_years(artist_dates) -> int:
+    try:
+        dates = re.findall(bd_year, artist_dates)
+        if len(dates) == 2:
+            return int(dates[1])
+    except:
+        return float("NaN")
+
+
+def return_substrings(lot_notes_split: list, search_terms: list) -> list:
+    substrings = []
+    for term in search_terms:  
+        if term == "cast":
+            limit = 14
+        elif term == "enlarged":
+            limit = 8
+        else:
+            limit = 6
+
+        for i,word in enumerate(lot_notes_split):
+            if word == term:
+                word_position = i
+                substring = lot_notes_split[word_position:word_position+limit]
+                substrings.append(list(substring))
+    return substrings
+
+
+def trim_substrings(substrings: list) -> list:
+    new_substrings = []
+    for i,substring in enumerate(substrings):
+        b = re.findall(r'\d{2}', ' '.join(substring))
+        for word in substring:
+            try:
+                if b[-1] in word:
+                    trimmed_substring = substring[:(substring.index(word)+1)]
+                    new_substrings.append(trimmed_substring)
+            except:
+                pass
+    return new_substrings
+
+
+def clean_short_years(row: pd.Series) -> list:
+    new_substrings = row["Info (Auto)"]
+    birth_year = 0
+    filtered_substrings = []
+    
+    for substring in new_substrings:
+        if yy.fullmatch(substring[-1]) and "label" not in substring:
+            short_creation_year = int(substring[-1])
+            try:
+                birth_year = (row["Born"])
+            except:
+                raise Exception("no birth year")
+            if birth_year > 0:
+                century = int(str(birth_year)[:2])
+                    
+                try:
+                    if short_creation_year > int(str(birth_year)[2:]):
+                        substring[-1] = (f"{century}{short_creation_year}")
+                    elif short_creation_year < int(str(birth_year)[2:]):
+                        century = century + 1
+                        if len(str(short_creation_year)) == 2:
+                            substring[-1] = (f"{century}{short_creation_year}")
+                        elif len(str(short_creation_year)) == 1:
+                            substring[-1] = (f"{century}0{short_creation_year}")
+                except:
+                    pass
+        if (yyyy.fullmatch(substring[-1])) or (yyyys.fullmatch(substring[-1])) or (yyyy_yyyy.fullmatch(substring[-1])) or (yyyy_yy.fullmatch(substring[-1])) or (yyyys_yyyys.fullmatch(substring[-1])):
+            filtered_substrings.append(' '.join(substring))
+    return filtered_substrings
+
+
+def find_term_in_line(term, line):
+    if re.search(r'\b'+re.escape(term)+r'\b', line):
+        return line
+
+def remove_duplicate_mediums(raw_medium_output: list):
+    cleaned_medium_output = []
+    raw_medium_output.sort(key=len)
+    for i,word in enumerate(raw_medium_output):
+        if word not in " ".join(raw_medium_output[i+1:]):
+            cleaned_medium_output.append(word)
+    return cleaned_medium_output

arttactic-0.1.1/arttactic/variables/reg_exs.py

@@ -0,0 +1,16 @@
+import re
+
+
+bd_year = re.compile(r'\d{4}')
+
+yy = re.compile(r'\d{2}') # c
+
+yyyy = re.compile(r'\d{4}') # d
+
+yyyys = re.compile(r'[1-2][0-9][0-9][0-9][s]') # e
+
+yyyy_yy = re.compile(r'[1-2][0-9][0-9][0-9]-[0-9][0-9]') # g
+
+yyyy_yyyy = re.compile(r'[1-2][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]') # f
+
+yyyys_yyyys = re.compile(r'[1-2][0-9][0-9][0-9][s]-[1-2][0-9][0-9][0-9][s]') # w

arttactic-0.1.1/arttactic/variables/search_lists.py

@@ -0,0 +1,43 @@
+
+search_terms = [
+        "drawn",
+        "enlarged",
+        "dated",
+        "executed",
+        "painted",
+        "photographed",
+        "printed",
+        "manufactured",
+        "produced",
+        "begun",
+        "cast",
+        "made",
+        "created",
+        "published",
+        "screenprint in colors",
+        "conceived",
+        "designed"
+        ]
+
+creation_terms = [
+        "drawn",
+        "enlarged",
+        "dated",
+        "executed",
+        "painted",
+        "photographed",
+        "printed",
+        "manufactured",
+        "produced",
+        "begun",
+        "cast",
+        "made",
+        "created",
+        "published",
+        "screenprint in colors"
+        ]
+
+conceived_terms = [
+        "conceived",
+        "designed"
+        ]

arttactic-0.1.1/arttactic.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: arttactic
+Version: 0.1.1
+Summary: Processing library for art auction data
+Author: Nafisa Sharif
+License: MIT License
+        
+        Copyright (c) 2026 Nafisa Sharif
+        
+        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.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=3.0.1
+Requires-Dist: openpyxl>=3.1.5
+Dynamic: license-file
+
+# arttactic
+
+A Python library for extracting and processing data from scraped art auction results. Currently designed to run on Linux or macOS, not yet tested on Windows.
+
+
+## Description
+
+`arttactic` provides tools for working with art auction datasets, including:
+
+* Cleaning and transforming auction data
+* Applying buyer’s premium calculations
+* Extracting mediums from lot information
+
+
+## Installation
+
+(Recommended) In the terminal, create a virtual environment and activate it.
+
+For example:
+
+```bash
+python3 -m venv arttactic-venv
+source arttactic-venv/bin/activate
+```
+
+Then install the arttactic library:
+
+```bash
+pip install arttactic
+```
+
+## Usage
+
+From the terminal, run the following CLI command:
+
+```bash
+run-arttactic
+```
+
+This will launch a GUI that allows you to:
+- Select a directory containing .csv files with scraped auction data,
+- Select a single file you wish to add buyer's premiums to,
+- Generate processed spreadsheets after selecting a directory,
+- Generate processed spreadsheets after selecting a directory, and also find and save new mediums,
+- Add buyer's premiums to a selected file.
+
+
+## Development
+
+(Only relevant if you wish to edit the source code.)
+To install locally in editable mode:
+
+```bash
+pip install -e .
+```

arttactic-0.1.1/arttactic.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+arttactic/__init__.py
+arttactic/extraction.py
+arttactic/mixed_scrapes.py
+arttactic/premiums.py
+arttactic/run.py
+arttactic.egg-info/PKG-INFO
+arttactic.egg-info/SOURCES.txt
+arttactic.egg-info/dependency_links.txt
+arttactic.egg-info/entry_points.txt
+arttactic.egg-info/requires.txt
+arttactic.egg-info/top_level.txt
+arttactic/data/Buyer's Premium.xlsx
+arttactic/data/Medium_List.xlsx
+arttactic/data/__init__.py
+arttactic/utils/__init__.py
+arttactic/utils/df_utils.py
+arttactic/utils/string_utils.py
+arttactic/variables/__init__.py
+arttactic/variables/reg_exs.py
+arttactic/variables/search_lists.py

arttactic-0.1.1/arttactic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

arttactic-0.1.1/arttactic.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+run-arttactic = arttactic.run:main

arttactic-0.1.1/arttactic.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pandas>=3.0.1
+openpyxl>=3.1.5

arttactic-0.1.1/arttactic.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+arttactic
+dist
+test_env

arttactic-0.1.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "arttactic"
+version = "0.1.1"
+description = "Processing library for art auction data"
+readme = {file="README.md", content-type = "text/markdown"}
+requires-python = ">=3.8"
+authors = [
+    {name="Nafisa Sharif"}
+]
+license = {file="LICENSE"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+dependencies = [
+    "pandas>=3.0.1",
+    "openpyxl>=3.1.5"
+]
+
+[tool.setuptools.package-data]
+arttactic = ["data/*.xlsx"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[project.scripts]
+run-arttactic = "arttactic.run:main"

arttactic-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+