Upload 7 files

app.py

@@ -0,0 +1,349 @@
+import streamlit as st
+import requests
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from sklearn.linear_model import LinearRegression
+from sklearn.ensemble import RandomForestRegressor
+from datetime import datetime, timedelta
+from streamlit_option_menu import option_menu
+from markup import real_estate_app, real_estate_app_hf
+import feedparser
+
+API_URL = "https://api.coingecko.com/api/v3"
+
+PASSWORD = 'Ethan101'
+
+def authenticate(password):
+    return password == PASSWORD
+
+def get_ethereum_data():
+    response = requests.get(f"{API_URL}/coins/markets", params={"ids": "ethereum", "vs_currency": "usd"})
+    data = response.json()
+    return data
+
+def format_price(price):
+    return "{:.10f}".format(price)
+
+def get_new_tokens():
+    response = requests.get(f"{API_URL}/coins/ethereum/market_chart", params={"vs_currency": "usd", "days": 1})
+    data = response.json()
+    
+    new_tokens = []
+    for token in data["market_caps"]:
+        timestamp, market_cap = token
+        if market_cap > 20000:
+            coin_token = data["prices"][data["market_caps"].index(token)][1]
+            coin_token_hex = float_to_hex(coin_token)
+            new_tokens.append((coin_token_hex, timestamp, market_cap))
+    
+    # Sort the tokens based on the timestamp in descending order
+    new_tokens.sort(key=lambda x: x[1], reverse=True)
+    
+    return new_tokens
+
+def float_to_hex(f):
+    # Convert the float to its hexadecimal representation
+    _, hex_representation = f.hex().split('x')
+    return "0x" + hex_representation
+
+def predict_price(df_price_history, days):
+    X = df_price_history.index.values.reshape(-1, 1)
+    y = df_price_history["price"].values
+    lr_model = LinearRegression()
+    lr_model.fit(X, y)
+    last_date = df_price_history.iloc[-1]["date"]
+    lr_future_dates = pd.date_range(last_date, periods=days+1)[1:]
+    lr_future_predictions = lr_model.predict(np.array(range(1, days+1)).reshape(-1, 1))
+    rf_model = RandomForestRegressor(n_estimators=100)
+    rf_model.fit(X, y)
+    rf_future_dates = pd.date_range(last_date, periods=days+1)[1:]
+    rf_future_predictions = rf_model.predict(np.array(range(1, days+1)).reshape(-1, 1))
+
+    return lr_future_dates, lr_future_predictions, rf_future_dates, rf_future_predictions
+
+def tab1():
+    st.header("ethereum Cryptocurrency Predictions Demo")  
+    col1, col2 = st.columns([1, 2])
+    with col1:
+        st.image("Hotpot.png", use_column_width=True)
+    with col2:
+        st.markdown(real_estate_app(), unsafe_allow_html=True)
+    st.markdown(real_estate_app_hf(),unsafe_allow_html=True) 
+
+
+    github_link = '[<img src="https://badgen.net/badge/icon/github?icon=github&label">](https://github.com/ethanrom)'
+    #huggingface_link = '[<img src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue">](https://huggingface.co/ethanrom)'
+
+    st.write(github_link + '&nbsp;&nbsp;&nbsp;', unsafe_allow_html=True)
+
+def tab2():
+    ethereum_data = get_ethereum_data()
+    if ethereum_data:
+        ethereum_info = {
+            "Symbol": ethereum_data[0]["symbol"],
+            "Current Price": format_price(ethereum_data[0]["current_price"]),
+            "Market Cap": ethereum_data[0]["market_cap"],
+            "Total Volume": ethereum_data[0]["total_volume"],
+            "Circulating Supply": ethereum_data[0]["circulating_supply"],
+        }
+        df_ethereum = pd.DataFrame(ethereum_info, index=[0])
+        
+        st.markdown("## Ethereum Information")
+        st.dataframe(df_ethereum)
+        
+        # Visualize Market Cap and Total Volume
+        market_cap = ethereum_data[0]["market_cap"]
+        total_volume = ethereum_data[0]["total_volume"]
+        df_market_cap_volume = pd.DataFrame({"Metric": ["Market Cap", "Total Volume"],
+                                             "Value (USD)": [market_cap, total_volume]})
+        st.markdown("## Market Cap and Total Volume")
+        st.bar_chart(df_market_cap_volume, x="Metric", y="Value (USD)")
+        st.markdown(
+            """
+            The bar chart above shows the current market capitalization and total trading volume of Ethereum in USD.
+            """
+        )
+        
+        circulating_supply = ethereum_data[0]["circulating_supply"]
+        max_supply = ethereum_data[0]["total_supply"]
+        
+        st.markdown("## Supply Information")
+        st.write(f"**Circulating Supply:** {circulating_supply:.2f} Ethereum")
+        st.write(f"**Max Supply:** {max_supply:.2f} Ethereum")
+
+        # Additional Visualization: Pie Chart for Circulating vs. Max Supply
+        supply_data = pd.DataFrame({
+            "Supply": ["Circulating Supply", "Max Supply"],
+            "Amount (Ethereum)": [circulating_supply, max_supply]
+        })
+        fig = px.pie(supply_data, values="Amount (Ethereum)", names="Supply", title="Circulating vs. Max Supply")
+        st.markdown("## Circulating vs. Max Supply")
+        st.write(
+            """
+            The pie chart above compares the circulating supply and maximum supply of Ethereum in terms of the number of tokens.
+            """
+        )
+        st.plotly_chart(fig)
+
+        # Show new Ethereum tokens created in the last 24 hours with market cap > $20,000
+        new_tokens = get_new_tokens()
+        if new_tokens:
+            st.markdown("## New Ethereum Tokens Created in the Last 24 Hours (Market Cap > $20,000)")
+            for coin_token, timestamp, market_cap in new_tokens:
+                time_created = pd.to_datetime(timestamp, unit="ms").strftime("%H:%M:%S")
+                st.write(f"COIN TOKEN: {coin_token}, TIME CREATED: {time_created}, MARKET CAP: ${market_cap/1e6:.1f}MM")
+        else:
+            st.write("No new Ethereum tokens with market cap > $20,000 created in the last 24 hours.")
+
+
+def tab3():
+    ethereum_data = get_ethereum_data()
+    if ethereum_data:
+        response = requests.get(f"{API_URL}/coins/ethereum/market_chart", params={"vs_currency": "usd", "days": "30"})
+        price_history = response.json()
+        df_price_history = pd.DataFrame(price_history["prices"], columns=["date", "price"])
+        df_price_history["date"] = pd.to_datetime(df_price_history["date"], unit="ms")
+        
+        st.markdown("## ethereum Price History")
+        fig = px.line(df_price_history, x="date", y="price", title="ethereum Price History")
+        fig.update_layout(xaxis_title="Date", yaxis_title="Price (USD)")
+        st.plotly_chart(fig)
+        st.markdown(
+            """
+            The line chart above shows the historical price trend of ethereum over the last 30 days.
+            """
+        )
+
+        col1, col2 = st.columns(2)
+        with col1:
+        
+            price_stats = df_price_history["price"].describe()
+            st.markdown("## Price Statistics")
+            st.write(price_stats)
+        
+        with col2:
+            st.markdown("## Price Distribution")
+            fig_hist = px.histogram(df_price_history, x="price", nbins=20, title="Histogram of Price Distribution")
+            fig_hist.update_layout(xaxis_title="Price (USD)", yaxis_title="Count")
+            st.plotly_chart(fig_hist)
+        st.markdown(
+            """
+            The histogram above displays the distribution of ethereum prices over the last 30 days.
+            """
+        )
+
+    else:
+        st.write("Failed to retrieve ethereum data")
+
+
+
+def tab4():
+    ethereum_data = get_ethereum_data()
+    if ethereum_data:
+        response = requests.get(f"{API_URL}/coins/ethereum/market_chart", params={"vs_currency": "usd", "days": "30"})
+        price_history = response.json()
+        df_price_history = pd.DataFrame(price_history["prices"], columns=["date", "price"])
+        df_price_history["date"] = pd.to_datetime(df_price_history["date"], unit="ms")
+
+        # Perform predictions
+        days = 30
+        lr_future_dates, lr_future_predictions, rf_future_dates, rf_future_predictions = predict_price(df_price_history, days)
+
+        # Visualize predictions using line charts
+        st.markdown("## Price Predictions")
+        st.subheader("Linear Regression Prediction")
+        df_lr_predicted = pd.DataFrame({"Date": lr_future_dates, "Predicted Price": lr_future_predictions})
+        st.line_chart(df_lr_predicted, x="Date", y="Predicted Price")
+
+        st.subheader("Random Forest Regression Prediction")
+        df_rf_predicted = pd.DataFrame({"Date": rf_future_dates, "Predicted Price": rf_future_predictions})
+        st.line_chart(df_rf_predicted, x="Date", y="Predicted Price")
+
+        # Additional Visualization: Combined Line Chart for Actual and Predicted Prices
+        df_combined = pd.concat([df_price_history, df_lr_predicted.rename(columns={"Predicted Price": "price"})])
+        df_combined["Type"] = ["Actual"] * len(df_price_history) + ["Predicted (LR)"] * len(df_lr_predicted)
+        fig_combined = px.line(df_combined, x="date", y="price", color="Type", title="Actual vs. Predicted (LR) Prices")
+        fig_combined.update_layout(xaxis_title="Date", yaxis_title="Price (USD)")
+        st.plotly_chart(fig_combined)
+
+        # Add text explanation for predictions
+        st.markdown("## Predictions Explanation")
+        st.write(
+            """
+            The price predictions are estimated using regression models: Linear Regression (LR) and Random Forest Regression (RF).
+            The line charts show the predicted prices over the next 30 days based on historical price data.
+            """
+        )
+
+    else:
+        st.write("Failed to retrieve ethereum data")
+
+#tab5
+RSS_FEED_URLS = {
+    "CryptoNews": "https://cryptonews.com/news/feed/",
+    "CoinDesk": "https://www.coindesk.com/feed",
+    "CryptoSlate": "https://cryptoslate.com/feed/",
+    # Add more RSS feed URLs here
+}
+
+def fetch_latest_news(url):
+    feed = feedparser.parse(url)
+    entries = feed.entries[:5]  # Fetching the latest 5 news entries
+    return entries    
+
+def filter_news_by_keyword(entries, keyword):
+    filtered_entries = []
+    for entry in entries:
+        if keyword.lower() in entry.title.lower() or keyword.lower() in entry.summary.lower():
+            filtered_entries.append(entry)
+    return filtered_entries
+
+def display_news_entry(entry):
+    st.markdown(f"## {entry.title}")
+    st.write(entry.summary)
+    st.write(f"Published on: {entry.published}")
+    st.write("---")
+
+def tab5():
+    selected_feeds = st.multiselect("Select RSS Feeds", list(RSS_FEED_URLS.keys()), default=["CryptoNews"])
+    filter_keyword = st.text_input("Filter by keyword (e.g., ethereum)")
+
+    for feed in selected_feeds:
+        st.markdown(f"### {feed} News")
+
+        if feed in RSS_FEED_URLS:
+            entries = fetch_latest_news(RSS_FEED_URLS[feed])
+
+            if filter_keyword:
+                entries = filter_news_by_keyword(entries, filter_keyword)
+
+            for entry in entries:
+                display_news_entry(entry)
+        else:
+            st.write(f"No RSS feed URL found for {feed}")
+
+def tab6():
+    st.header("Download script")
+    st.markdown(
+        """
+        download the standalone python script to print new tokens
+        """
+    )
+    st.image("eth.PNG")
+    password_input = st.text_input('Enter Password', type='password')
+    if authenticate(password_input):
+        # Contents of the get_new_coins.py file
+        script_content = """
+import requests
+import pandas as pd
+
+API_URL = "https://api.coingecko.com/api/v3"
+
+def float_to_hex(f):
+    _, hex_representation = f.hex().split('x')
+    return "0x" + hex_representation
+
+def get_new_tokens():
+    response = requests.get(f"{API_URL}/coins/ethereum/market_chart", params={"vs_currency": "usd", "days": 1})
+    data = response.json()
+    
+    new_tokens = []
+    for token in data["market_caps"]:
+        timestamp, market_cap = token
+        if market_cap > 20000:
+            coin_token = data["prices"][data["market_caps"].index(token)][1]
+            coin_token_hex = float_to_hex(coin_token)
+            new_tokens.append((coin_token_hex, timestamp, market_cap))
+    return new_tokens
+
+if __name__ == "__main__":
+    new_tokens = get_new_tokens()
+    if new_tokens:
+        print("New Ethereum Tokens Created in the Last 24 Hours (Market Cap > $20,000)")
+        for coin_token, timestamp, market_cap in new_tokens:
+            time_created = pd.to_datetime(timestamp, unit="ms").strftime("%H:%M:%S")
+            print(f"COIN: {coin_token}, TIME CREATED: {time_created}, MARKET CAP: ${market_cap/1e6:.1f}MM")
+    else:
+        print("No new Ethereum tokens with market cap > $20,000 created in the last 24 hours.")
+"""
+
+        # Display the content of the script in the app
+        st.code(script_content, language="python")
+
+        # Download link for the script
+        file_name = "get_new_coins.py"
+        st.download_button(
+            label="Download get_new_coins.py",
+            data=script_content,
+            file_name=file_name,
+            mime="text/plain",
+        )
+    else:
+        # Password is incorrect, show an error message
+        st.error('Invalid password. Access denied.')
+
+def main():
+    st.set_page_config(page_title="ethereum Dashboard", page_icon=":memo:", layout="wide")
+    tabs = ["Intro", "ethereum Information", "ethereum Price History", "Price Predictions", "News", "Download Script"]
+
+    with st.sidebar:
+
+        current_tab = option_menu("Select a Tab", tabs, menu_icon="cast")
+
+    tab_functions = {
+    "Intro": tab1,
+    "ethereum Information": tab2,
+    "ethereum Price History": tab3,
+    "Price Predictions": tab4,
+    "News": tab5,
+    "Download Script": tab6,
+    }
+
+    if current_tab in tab_functions:
+        tab_functions[current_tab]()
+
+
+
+if __name__ == "__main__":
+    main()

get_new_coins.py

@@ -0,0 +1,34 @@
+import requests
+import pandas as pd
+
+API_URL = "https://api.coingecko.com/api/v3"
+
+def float_to_hex(f):
+    _, hex_representation = f.hex().split('x')
+    return "0x" + hex_representation
+
+def get_new_tokens():
+    response = requests.get(f"{API_URL}/coins/ethereum/market_chart", params={"vs_currency": "usd", "days": 1})
+    data = response.json()
+    
+    new_tokens = []
+    for token in data["market_caps"]:
+        timestamp, market_cap = token
+        if market_cap > 20000:
+            coin_token = data["prices"][data["market_caps"].index(token)][1]
+            coin_token_hex = float_to_hex(coin_token)
+            new_tokens.append((coin_token_hex, timestamp, market_cap))
+    
+    new_tokens.sort(key=lambda x: x[1], reverse=True)
+    
+    return new_tokens
+
+if __name__ == "__main__":
+    new_tokens = get_new_tokens()
+    if new_tokens:
+        print("New Ethereum Tokens Created in the Last 24 Hours (Market Cap > $20,000)")
+        for coin_token, timestamp, market_cap in new_tokens:
+            time_created = pd.to_datetime(timestamp, unit="ms").strftime("%H:%M:%S")
+            print(f"COIN: {coin_token}, TIME CREATED: {time_created}, MARKET CAP: ${market_cap/1e6:.1f}MM")
+    else:
+        print("No new Ethereum tokens with market cap > $20,000 created in the last 24 hours.")

get_new_coins_auto.py

@@ -0,0 +1,39 @@
+import requests
+import pandas as pd
+import time
+
+API_URL = "https://api.coingecko.com/api/v3"
+
+def float_to_hex(f):
+    _, hex_representation = f.hex().split('x')
+    return "0x" + hex_representation
+
+def get_new_tokens():
+    response = requests.get(f"{API_URL}/coins/ethereum/market_chart", params={"vs_currency": "usd", "days": 1})
+    data = response.json()
+    
+    new_tokens = []
+    for token in data["market_caps"]:
+        timestamp, market_cap = token
+        if market_cap > 20000:
+            coin_token = data["prices"][data["market_caps"].index(token)][1]
+            coin_token_hex = float_to_hex(coin_token)
+            new_tokens.append((coin_token_hex, timestamp, market_cap))
+    
+    new_tokens.sort(key=lambda x: x[1], reverse=True)
+    
+    return new_tokens
+
+if __name__ == "__main__":
+    while True:
+        new_tokens = get_new_tokens()
+        if new_tokens:
+            print("New Ethereum Tokens Created in the Last 24 Hours (Market Cap > $20,000)")
+            for coin_token, timestamp, market_cap in new_tokens:
+                time_created = pd.to_datetime(timestamp, unit="ms").strftime("%H:%M:%S")
+                print(f"COIN: {coin_token}, TIME CREATED: {time_created}, MARKET CAP: ${market_cap/1e6:.1f}MM")
+        else:
+            print("No new Ethereum tokens with market cap > $20,000 created in the last 24 hours.")
+        
+        # Wait for 60 seconds before updating again
+        time.sleep(60)

markup.py

@@ -0,0 +1,27 @@
+def real_estate_app():
+    return """
+    <h3 style='text-align: center;'>Introduction</h3>
+            
+    <p>This app allows you to view info about ethereum as well as predicted prices</p>
+
+    <h4>Information:</h4>
+    <ul>
+        <li><b>Real-Time Price Tracking:</b> You can view the current price of ethereum and track its fluctuations over time.</li>
+        <li><b>Market Data Analysis:</b> Analyze the market trends, trading volume, and other key metrics related to ethereum.</li>
+    </ul>
+    </div>         
+    """
+
+def real_estate_app_hf():
+    return """
+    <div style='text-align: left;'>
+    <h3 style='text-align: center;'>About this Demo</h3>
+    <br>
+    <h4>How to use:</h4>
+    <ul>
+    <li><b>Price Tracking:</b> The app will automatically fetch and display the latest price of ethereum. You can also view historical price data using interactive charts.</li>
+    <li><b>Market Analysis:</b> Explore market indicators such as trading volume, market capitalization, and price change percentage. Visualize these metrics through graphs and charts.</li>
+    </ul>
+    <br>
+    </div>
+    """

requirements.txt

@@ -0,0 +1,6 @@
+pandas
+numpy
+streamlit_option_menu
+plotly
+scikit-learn
+feedparser