Add application file

app.py

@@ -0,0 +1,52 @@
+import streamlit as st
+import pandas as pd
+import scholarly
+
+st.title("CSV Data Viewer")
+
+def load_data():
+    data = pd.read_csv("data.csv", sep=";", usecols=range(10))
+    return data
+
+data = load_data()
+
+# Display the data
+st.write("Data from CSV:")
+st.write(data)
+
+cit_array = []
+
+if 'doi' not in data.columns:
+    st.write("The 'doi' column does not exist in the CSV.")
+else:
+    # Loop over DOIs and retrieve citation counts
+    for index, row in data.iterrows():
+        doi = row['doi']
+        if doi:
+            # st.text(f"1 Extracting DOI: {doi}")
+            citation_count = scholarly.get_citation_count(doi)
+            if citation_count != None:
+                cit_array.append(citation_count)
+                st.text(f"DOI: {doi}, Citation Count: {citation_count}")
+            else:
+                # Handle cases where DOI is None (e.g., bytitle lookup)
+                title = row['title']
+                doi_bytitle = scholarly.get_doi_from_title(str(title))
+                # st.text(title)
+                # st.text(f"Extracting DOI from Title: {title}")
+                citation_count_title = scholarly.get_citation_count(doi_bytitle)
+                cit_array.append(citation_count_title)
+                st.text(f"DOI from Title: {title}, Citation Count: {citation_count_title}")
+                # else:
+            #     cit_array.append(None)
+
+# Add the citation count column to the DataFrame
+data['Citation Count'] = cit_array
+st.write(data)
+if not data.empty:
+    st.download_button(
+        label="Download Filtered Data as CSV",
+        data=data.to_csv(index=False).encode(),
+        file_name="filtered_data.csv",
+        key="download_filtered_data",
+    )

filterDataframe.py

@@ -0,0 +1,84 @@
+import pandas as pd
+import streamlit as st
+from pandas.api.types import (
+    is_categorical_dtype,
+    is_datetime64_any_dtype,
+    is_numeric_dtype,
+    is_object_dtype,
+)
+
+def filter_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Adds a UI on top of a dataframe to let viewers filter columns
+
+    Args:
+        df (pd.DataFrame): Original dataframe
+
+    Returns:
+        pd.DataFrame: Filtered dataframe
+    """
+    modify = st.checkbox("Add filters")
+
+    if not modify:
+        return df
+
+    df = df.copy()
+
+    # Try to convert datetimes into a standard format (datetime, no timezone)
+    for col in df.columns:
+        if is_object_dtype(df[col]):
+            try:
+                df[col] = pd.to_datetime(df[col])
+            except Exception:
+                pass
+
+        if is_datetime64_any_dtype(df[col]):
+            df[col] = df[col].dt.tz_localize(None)
+
+    modification_container = st.container()
+
+    with modification_container:
+        to_filter_columns = st.multiselect("Filter dataframe on", df.columns)
+        for column in to_filter_columns:
+            left, right = st.columns((1, 20))
+            left.write("↳")
+            # Treat columns with < 10 unique values as categorical
+            if is_categorical_dtype(df[column]) or df[column].nunique() < 10:
+                user_cat_input = right.multiselect(
+                    f"Values for {column}",
+                    df[column].unique(),
+                    default=list(df[column].unique()),
+                )
+                df = df[df[column].isin(user_cat_input)]
+            elif is_numeric_dtype(df[column]):
+                _min = float(df[column].min())
+                _max = float(df[column].max())
+                step = (_max - _min) / 100
+                user_num_input = right.slider(
+                    f"Values for {column}",
+                    _min,
+                    _max,
+                    (_min, _max),
+                    step=step,
+                )
+                df = df[df[column].between(*user_num_input)]
+            elif is_datetime64_any_dtype(df[column]):
+                user_date_input = right.date_input(
+                    f"Values for {column}",
+                    value=(
+                        df[column].min(),
+                        df[column].max(),
+                    ),
+                )
+                if len(user_date_input) == 2:
+                    user_date_input = tuple(map(pd.to_datetime, user_date_input))
+                    start_date, end_date = user_date_input
+                    df = df.loc[df[column].between(start_date, end_date)]
+            else:
+                user_text_input = right.text_input(
+                    f"Substring or regex in {column}",
+                )
+                if user_text_input:
+                    df = df[df[column].str.contains(user_text_input)]
+
+    return df

requirements.txt

@@ -0,0 +1,2 @@
+scholarly
+habanero

scholarly.py

@@ -0,0 +1,17 @@
+from habanero import counts
+from habanero import Crossref
+
+
+
+def get_citation_count(doi):
+    try:
+        cit = counts.citation_count(doi = doi)
+        return str(cit)
+    except Exception as e:
+        # print(f"Error fetching data for DOI {doi}: {e}")
+        return None
+    
+def get_doi_from_title(title):
+    cr = Crossref()
+    result = cr.works(query = title)
+    return (result['message']['items'][0]['DOI'])