Upload 4 files

app.py

@@ -0,0 +1,82 @@
+import gradio as gr
+import yfinance as yf
+import csv
+import pandas as pd
+import matplotlib.pyplot as plt
+from valuation import parallel_portfolio_valuation,serialCal
+
+def get_stock_price(stock_symbol):
+    try:
+        stock = yf.Ticker(stock_symbol)
+        stock_data = stock.history(period="1d")
+        latest_close = stock_data['Close'].iloc[-1]
+        return float(latest_close)
+    except Exception as e:
+        return 0
+
+def getCompoanyInfo(portfolio):
+    #yfinance
+    company_data = []
+    
+    for stock in portfolio:
+        try:
+            stock_info = yf.Ticker(stock['symbol']).info
+            # Collect key datasets
+            company_details = {
+                'symbol': stock['symbol'],
+                'company_name': stock_info.get('longName', 'N/A'),
+                'sector': stock_info.get('sector', 'N/A'),
+                'industry': stock_info.get('industry', 'N/A'),
+                'market_cap': stock_info.get('marketCap', 'N/A'),
+                'dividend_yield': stock_info.get('dividendYield', 'N/A'),
+                'pe_ratio': stock_info.get('trailingPE', 'N/A'),
+                '52_week_high': stock_info.get('fiftyTwoWeekHigh', 'N/A'),
+                '52_week_low': stock_info.get('fiftyTwoWeekLow', 'N/A'),
+                'price': round(stock['price'],2),
+                'quantity': stock['quantity'],
+            }
+            
+            company_data.append(company_details)
+        
+        except Exception as e:
+            print(f"Error fetching data for {stock['symbol']}: {e}")
+            continue
+    
+    return pd.DataFrame(company_data)
+
+def calculatePortfolioValue(file:str):
+    portfolio = [] 
+    """
+    portfolio = [
+    {'symbol': 'AAPL', 'price': 160, 'quantity': 100},
+    {'symbol': 'GOOG', 'price': 2000, 'quantity': 50},
+    {'symbol': 'MSFT', 'price': 300, 'quantity': 200},
+   
+]
+    """
+    with open(file,"r") as fr:
+        reader = csv.reader(fr)
+        for i in list(reader)[1:]:
+            #print({'symbol':i[0],'price':get_stock_price(i[0]),'quantity':i[1]})
+            portfolio.append({'symbol':i[0],'price':get_stock_price(i[0]),'quantity':float(i[1])})
+    
+    return str(round(parallel_portfolio_valuation(portfolio),2)) + " $", getCompoanyInfo(portfolio)
+
+
+def startGradio():
+    with gr.Blocks() as demo:
+        text1 = gr.Text(value ="Stock Portfolio Valuation using multiprocessing",interactive=False,show_label=False)
+        with gr.Column():
+            file = gr.File()
+            df = gr.Dataframe()
+            parallelValue = gr.Textbox(label="Portfolio Valuation through the process of paralleization")
+            bt = gr.Button()
+        bt.click(fn=calculatePortfolioValue,inputs=[file],outputs=[parallelValue,df])
+        demo.load()
+
+    demo.launch()
+
+
+if __name__ == "__main__":
+    startGradio()
+    #calculatePortfolioValue("/Users/sarathrajan/Desktop/HPCUI/stocks_qty.csv")

requirements.txt

@@ -0,0 +1,67 @@
+aiofiles==23.2.1
+annotated-types==0.7.0
+anyio==4.6.0
+beautifulsoup4==4.12.3
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.3.0
+cycler==0.12.1
+fastapi==0.115.0
+ffmpy==0.4.0
+filelock==3.16.1
+fonttools==4.54.1
+frozendict==2.4.4
+fsspec==2024.9.0
+gradio==4.44.0
+gradio_client==1.3.0
+h11==0.14.0
+html5lib==1.1
+httpcore==1.0.5
+httpx==0.27.2
+huggingface-hub==0.25.1
+idna==3.10
+importlib_resources==6.4.5
+Jinja2==3.1.4
+kiwisolver==1.4.7
+lxml==5.3.0
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.9.2
+mdurl==0.1.2
+multitasking==0.0.11
+numpy==2.1.1
+orjson==3.10.7
+packaging==24.1
+pandas==2.2.3
+peewee==3.17.6
+pillow==10.4.0
+platformdirs==4.3.6
+pydantic==2.9.2
+pydantic_core==2.23.4
+pydub==0.25.1
+Pygments==2.18.0
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+python-multipart==0.0.12
+pytz==2024.2
+PyYAML==6.0.2
+requests==2.32.3
+rich==13.8.1
+ruff==0.6.8
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+soupsieve==2.6
+starlette==0.38.6
+tomlkit==0.12.0
+tqdm==4.66.5
+typer==0.12.5
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.2.3
+uvicorn==0.31.0
+webencodings==0.5.1
+websockets==12.0
+yfinance==0.2.43

stocks_qty.csv

@@ -0,0 +1,91 @@
+Stock Symbol,Quantity
+NVDA,76
+V,16
+NVDA,77
+DIS,10
+TSLA,83
+AAPL,76
+V,63
+UNH,11
+GOOGL,98
+TSLA,88
+NFLX,77
+AAPL,22
+WMT,59
+PG,11
+NVDA,83
+PG,77
+GOOGL,41
+UNH,49
+VZ,68
+WMT,74
+HD,82
+VZ,11
+NFLX,96
+V,50
+PG,68
+PG,99
+AMZN,51
+V,14
+HD,40
+AAPL,98
+GOOGL,63
+HD,30
+NVDA,57
+BABA,38
+WMT,47
+NVDA,18
+AMZN,22
+BABA,52
+PG,1
+AMZN,5
+NVDA,21
+JNJ,84
+DIS,9
+WMT,55
+GOOGL,93
+NFLX,15
+BABA,9
+UNH,60
+WMT,22
+MSFT,14
+PYPL,57
+NVDA,28
+MA,13
+BABA,71
+GOOGL,70
+JNJ,43
+WMT,97
+GOOGL,81
+AAPL,65
+WMT,61
+UNH,81
+WMT,17
+PG,99
+GOOGL,98
+DIS,92
+NFLX,3
+VZ,57
+BABA,65
+JNJ,1
+NVDA,3
+GOOGL,32
+MSFT,92
+PG,55
+HD,21
+UNH,57
+NVDA,83
+GOOGL,28
+JNJ,30
+TSLA,45
+NVDA,65
+DIS,44
+MSFT,85
+WMT,2
+MSFT,9
+NFLX,40
+VZ,88
+V,90
+VZ,59
+HD,50
+PYPL,34

valuation.py

@@ -0,0 +1,87 @@
+import multiprocessing
+
+import random
+import math
+
+
+def complex_stock_valuation(stock):
+    # Basic value
+    base_value = stock['price'] * stock['quantity']
+    
+    # Simulate a more complex valuation model
+    pe_ratio = random.uniform(10, 30)
+    beta = random.uniform(0.5, 2.0)
+    risk_free_rate = 0.02  # 2% risk-free rate
+    market_return = 0.08  # 8% market return
+    
+    # Calculate expected return using CAPM (Capital Asset Pricing Model)
+    expected_return = risk_free_rate + beta * (market_return - risk_free_rate)
+    
+    # Calculate dividend yield
+    dividend_yield = random.uniform(0.01, 0.05)
+    
+    # Dividend Discount Model
+    growth_rate = random.uniform(0.02, 0.10)
+    intrinsic_value = (stock['price'] * dividend_yield * (1 + growth_rate)) / (expected_return - growth_rate)
+    
+    # Adjust value based on a weighted average of different factors
+    adjusted_value = (
+        base_value * 0.4 +  # 40% weight to market value
+        intrinsic_value * 0.3 +  # 30% weight to intrinsic value
+        (base_value / pe_ratio) * 0.2 +  # 20% weight to earnings-based value
+        (base_value * (1 + expected_return)) * 0.1  # 10% weight to expected future value
+    )
+    
+    # Add some non-linear complexity
+    volatility = random.uniform(0.1, 0.5)
+    adjusted_value *= math.exp(-volatility * beta)
+    
+    # Simulate some intensive calculation
+    for _ in range(1000):
+        adjusted_value = math.sqrt((adjusted_value ** 2 + base_value ** 2) / 2)
+    
+    return adjusted_value
+
+def calculate_value(portfolio_slice, queue):
+    total_value = 0
+    for stock in portfolio_slice:
+        total_value += complex_stock_valuation(stock)
+    queue.put(total_value)  # Send the result back to the main process
+
+def parallel_portfolio_valuation(portfolio, num_processes=2):
+    portfolio_size = len(portfolio)
+    num_processes = min(num_processes, portfolio_size)  # Ensure num_processes doesn't exceed portfolio_size
+    chunk_size = max(1, portfolio_size // num_processes)
+    processes = []
+    queue = multiprocessing.Queue()  # Queue for collecting results
+    chunks_processed = 0  # Keep track of how many chunks we've processed
+
+    for i in range(num_processes):
+        start_index = i * chunk_size
+        end_index = min((i + 1) * chunk_size, portfolio_size)
+        portfolio_slice = portfolio[start_index:end_index]
+        if portfolio_slice:  # Only start a process if there are items to process
+            process = multiprocessing.Process(target=calculate_value, args=(portfolio_slice, queue))
+            processes.append(process)
+            process.start()
+            chunks_processed += 1  # Increment for each chunk we process
+
+    total_value = 0
+    # Collect results for each chunk we processed
+    for _ in range(chunks_processed):
+        total_value += queue.get()
+
+    # Wait for all processes to finish
+    for process in processes:
+        process.join()
+
+    return total_value
+
+
+
+def serialCal(portfolio):
+    total = 0
+    for stock in portfolio:
+        total += complex_stock_valuation(stock)
+    return total
+