Skapa en personlig portfölj/förmögenhetssimulering i Python (del 2) - Python For Finance (2024)

Välkommen till del 2 av serien med inlägg som handlar om hur du bygger din egen pythonbaserade personliga portfölj/välkomstsimuleringsmodell. I slutet av det första inlägget (som finnshär), kom vi till den punkt där vi hade modellerat vissa inflöden, vissa utflöden, vi hade tillämpat en årlig lönehöjning på våra framtida inkomstflöden, tillsammans med att tillämpa olika skattesatser på både vår aktiva inkomst (lön) och investeringsinkomst.

Vi hade också räknat in ett stokastiskt element i vår modell för att generera investeringsavkastning, genom att använda den historiska genomsnittliga månatliga avkastningen och volatiliteten för S&P Total Return-index som en proxy för "marknaden". Slutligen hade vi avslutat med att lägga till ett par rader kod som skulle registrera huruvida vår förmögenhet/tillgångsvärde reducerades till (eller under) noll vid någon punkt under den simulerade tidsperioden; vi kommer att använda detta senare för att hjälpa till att beräkna vår "risk för ruin", dvs. koppla sannolikheter till sannolikheten att hamna med tillgångar värda mindre än ett tröskelvärde (ett som vi anser är oacceptabelt att falla under - vilket inte behöver vara noll såklart).

Hela kodavsnittet från slutet av del 1 visas nedan för enkelhets skull (jag har ändrat några av utflödes- och inflödesvärdena tillbaka till sina ursprungliga nivåer bara för att göra det). VIKTIGT: Jag har också varit tvungen att inkludera användningen av yfinance-paketet för att tillåta åsidosättande av Pandas DataReader-paketet eftersom Pandas DataReader för närvarande inte är stabilt och i princip inte fungerar. Kodändringarna kommenteras nedan för att lättare kunna identifiera dem.

importera pandor som pdimport numpy som npimport slumpmässig# ändra syntax och namn på Pandas DataReader importera från pandas_datareader importera data som pdr# importera yfinance som pandas dataläsare för närvarande inte stabilimportera yfinance as yfimport datetimeimport matplotlib as mplimport matplotlib in plintlib.pyplot det numpy slumpmässiga fröet för att tillåta replikering av resultsnp.random.seed(seed=7)start, end = datetime.datetime(2000, 12, 31), datetime.datetime(2020, 1,1)# add yfinance-pandas data- reader overide (nu kan vi använda pandas data-reader-metoder igen eftersom de för närvarande är instabila)yf.pdr_override()# ändra vår nedladdning till att använda nya överstyrda metodersp = pdr.get_data_yahoo("^SP500TR", start=start, end=end )sp_monthly_pct_return = sp.resample('M').last().pct_change().mean().values[0]sp_monthly_std_dev = sp.resample('M').last().pct_change().std() .values[0]inflöden = {'active_annual_income':50_000, 'starting_assets': 250_000} outflows = {'rent':1500, 'credit_card_payment':750, 'medicinal_insurance':250, 'pension_contribution,':misc5'00, ' : 1500}variables = {'start_date' : "01/01/2020", 'years': 10, 'tax_on_active_income_gains': 0,25, 'avg_ann_income_raise':0.05, 'avg_ann_inflation'_, 't_avgins.on'_: 't_ax_0mon', 't_avgins. thly_market_returns ': sp_monthly_pct_return, 'avg_monthly_market_volatility': sp_monthly_std_dev} income_gains_storage = []investment_gains_storage = [] assets_starting_list = [inflöden['starting_assets'] = tillgångar_förmånernas_tillgångar *1 månadsvariabler =' 2 månaders variabler [2 månader] ths) : if assets_ending_list: assets_starting_list.append(assets_ending_list[-1]) assets = assets_starting_list[-1] tillgångar -= (utflöden['hyra'] + utflöden['kreditkortsbetalning'] + \ utflöden['sjukvårdsförsäkring'] + utflöden['hyra'] pension_bidrag'] + \ utflöden['misc']) om tillgångar <= 0: inv_gain = 0 ruinerad = True break market_return = np.random.normal(variables['avg_monthly_market_returns'], variables['avg_monthly_market_volatility'], 1)[ 0] investment_return = (tillgångar * market_return) * (1 - variabler['tax_on_investment_gains']) investment_gains_storage.append(investment_return) tillgångar += investment_return inkomst = (inflöden['active_annual_income'] * (1 -come_come-variables[_taxe) ) / 12 income_gains_storage.append(income) if (månad % 12 == 0): inflöden['active_annual_income'] *= (1 + (variabler['avg_ann_income_raise'])) utflöden['rent'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['kreditkortsbetalning'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['sjukvårdsförsäkring'] *= (1 + (variabler['avg_ann_inflation'])) utflöden ['pension_bidrag'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['diverse'] *= (1 + (variabler['avg_ann_inflation'])) tillgångar += inkomst assets_ending = tillgångar assets_ending_list.append( assets_ending) plt.plot(pd.Series(assets_ending_list))plt.xlabel('Månad')plt.ylabel('Ending Asset Value')plt.show()
Skapa en personlig portfölj/förmögenhetssimulering i Python (del 2) - Python For Finance (1)

Nästa element vi kommer att införliva är ett som låter oss sätta ett framtida datum då vi planerar att gå i pension och i praktiken sluta arbeta, med åtföljande förväntan att vår aktiva inkomst (dvs lönen) kommer att falla dramatiskt, om inte försvinna helt. Pensionering är ett viktigt skede i livet att planera för, av många anledningar; inte bara skulle våra inflöden från lön påverkas, det är troligt att många av våra utflöden också skulle förändras. Vid pensionsåldern är det inte ovanligt att människor har betalat av eventuella utestående bolåneskulder på sina hem. Detta innebär inga fler månatliga bolåneutflöden och erbjuder andra möjligheter som t.ex. system för frisläppande av aktier, eller "neddragning" av fastigheter etc.

Av yttersta vikt är att se till att du när du går i pension har byggt upp en tillgångsbas som är tillräckligt stor för att upprätthålla dina behov och generera tillräckligt med investeringsintäkter för att täcka dina levnadskostnader, oavsett hur många år du än lever i pension.

Med detta i åtanke, låt oss börja med att lägga till ett planerat pensionsdatum (anges som år från idag till pensionering; jag har valt 25 år i framtiden eftersom det skulle placera mig i rätt ålder). Vi ska också förlänga simuleringsperioden från 10 år till 40. Jag har också lagt till ett par rader för att kontrollera om vi är före eller efter vårt planerade pensionsdatum och anpassa vår månadsinkomst (dvs. löneinflöde) därefter.

np.random.seed(seed=7)start, end = datetime.datetime(2000, 12, 31), datetime.datetime(2020, 1,1)yf.pdr_override()sp = pdr.get_data_yahoo("^SP500TR" , start=start, end=end)sp_monthly_pct_return = sp.resample('M').last().pct_change().mean().values[0]sp_monthly_std_dev = sp.resample('M').last() .pct_change().std().values[0]inflöden = {'active_annual_income':50_000, 'starting_assets': 250_000} utflöden = {'rent':1500, 'credit_card_payment':750, 'medicinal_surance', '': pension_contribution':500, 'misc': 1500}variables = {'start_date' : "01/01/2020", 'years': 40, 'retirement_year': 25, 'tax_on_active_income_gains': 0.25, 'ev_raise.income':0 'avg_ann_inflation': 0,02, 'tax_on_investment_gains': 0,35, 'avg_monthly_market_returns': sp_monthly_pct_return, 'avg_monthly_market_volatility': sp_monthly_std_dev_storage =gains_gains_gains_start =gains_gains_gains_gains_ [inflöden['starting_assets']] assets_ending_list = [] månader = variabler[ 'years'] * 12ruined = Falskt för månad inom intervallet (månader): if assets_ending_list: assets_starting_list.append(assets_ending_list[-1]) assets = assets_starting_list[-1] tillgångar -= (utflöden['hyra'] + utflöden['kreditkortsbetalning] '] + \ utflöden['sjukvårdsförsäkring'] + utflöden['pension_bidrag'] + \ utflöden['diverse']) om tillgångar <= 0: inv_gain = 0 ruinerad = True break market_return = np.random.normal(variables[' avg_monthly_market_returns'], variables['avg_monthly_market_volatility'], 1)[0] investment_return = (tillgångar * market_return) * (1 - variables['tax_on_investment_gains']) investment_gains_storage.append(investment_gains_storage.append(investment_gains_storage.append(investment_gains_storage) noll löneinkomst en gång pensionerad om månad >= variabler['pensionsår'] * 12: inkomst = 0 annat: inkomst = (inflöden['aktiv_årlig_inkomst'] * (1 - variabler['skatt_på_aktiv_inkomst_vinster'])) / 12 inkomst_vinster_lagring.append( inkomst) om (månad % 12 == 0): inflöden['active_annual_income'] *= (1 + (variabler['avg_ann_income_raise'])) utflöden['rent'] *= (1 + (variabler['avg_ann_inflation'] )) utflöden['kreditkortsbetalning'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['sjukvårdsförsäkring'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['pension_contribution'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['misc'] *= (1 + (variabler['avg_ann_inflation'])) tillgångar += inkomst assets_ending = assets assets_ending_list.append(assets_ending) plt.plot(pd .Series(assets_ending_list))plt.xlabel('Month')plt.ylabel('Ending Asset Value')plt.show()
Skapa en personlig portfölj/förmögenhetssimulering i Python (del 2) - Python For Finance (2)

Nu kan vi tydligt se vilken effekt vårt lönefall efter pensioneringen har på våra slutande tillgångsvärden över tiden. Som det är helt logiskt, utan lön kommer tendensen att vår personliga förmögenhet och tillgångsbas faller över tiden. För det första måste vi fortfarande redogöra för det faktum att både våra in- och utflöden efter pensionering vanligtvis skiljer sig fundamentalt från den "normala", icke-pensioneringssituationen, och vi kommer till det på bara en sekund.

Låt oss anta att vi efter pensioneringen inte längre betalar "hyra" eller bolånebetalningar, så det nuvarande hyresutflödet på 1 500 gäller inte längre när vi når vårt pensionsdatum. Vi skulle också kunna tänka oss att våra sjukförsäkringskostnader och allmänna sjukvårdskostnader i genomsnitt skulle öka avsevärt, och att vi kanske börjar få en del pensionsinkomster varje månad. Den exakta situationen kommer att variera för varje individ, så för nu ska jag tillämpa ovanstående logik och gå därifrån.

np.random.seed(seed=7)start, end = datetime.datetime(2000, 12, 31), datetime.datetime(2020, 1,1)yf.pdr_override()sp = pdr.get_data_yahoo("^SP500TR" , start=start, end=end)sp_monthly_pct_return = sp.resample('M').last().pct_change().mean().values[0]sp_monthly_std_dev = sp.resample('M').last() .pct_change().std().values[0]inflöden = {'active_annual_income':50_000, 'starting_assets': 250_000, 'monthly_pension': 1500} # lägg till beräknade månatliga pensionsutflöden efter pensionering = {'0,':150 'credit_card_payment':750, 'medicinal_surance':250, 'pension_contribution':500, 'diverse': 1500, 'retirement_medical_expenses':850, # lägg till månatliga sjukvårdskostnader efter pensionering 'pension_diverse': övrig efter pensionering: 2000 costvariables = {'start_date' : "01/01/2020", 'years': 40, 'retirement_year': 25, 'tax_on_active_income_gains': 0,25, 'avg_ann_income_raise':0.05, 'avg_ann_ax_02': t_ann_inflation. , 'avg_monthly_market_returns': sp_monthly_pct_return, 'avg_monthly_market_volatility': sp_monthly_std_dev} income_gains_storage = []investment_gains_storage = [] assets_starting_list = [tillgångar_tillgångar] ['starter'_förmögenhetsförmögenhetsförteckningar] ['starter_tillgångar]']] 12förstörd = Falskt för månaden inom intervallet (månader): if assets_ending_list: assets_starting_list.append(assets_ending_list[-1]) assets = assets_starting_list[-1] # lägg till logik för att ta hänsyn till olika utflöden vid pensionering om månad >= variabler['pensionsår'] * 12: utflöde = utflöden ['pension_medicinska_kostnader'] + utflöden['pension_misc'] else: utflöde = (utflöden['hyra'] + utflöden['kreditkortsbetalning'] + \ utflöden['sjukvårdsförsäkring'] + utflöden['pensionsbidrag'] + \ utflöden[' misc']) tillgångar -= utflöde om tillgångar <= 0: inv_gain = 0 ruinerad = True break market_return = np.random.normal(variables['avg_monthly_market_returns'], variables['avg_monthly_market_volatility'], 1)[0] investeringsavkastning (tillgångar * marknadsavkastning) * (1 - variabler['tax_on_investment_gains']) investment_gains_storage.append(investment_return) assets += investment_return # lägg till logik för att redogöra för pension erhållen i pension utan lön om månad >= variabler['pension_år'] * 12: inkomst = inflöden['månadspension'] annat: inkomst = (inflöden['aktiv_årsinkomst'] * (1 - variabler['skatt_på_aktiva_inkomstvinster'])) / 12 inkomst_vinster_lagring.append(inkomst) if (månad % 12 == 0) : inflöden['active_annual_income'] *= (1 + (variabler['avg_ann_income_raise'])) utflöden['hyra'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['kreditkortsbetalning'] *= ( 1 + (variabler['avg_ann_inflation'])) utflöden['sjukvårdsförsäkring'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['pension_bidrag'] *= (1 + (variabler['avg_ann_inflation']) ) utflöden['misc'] *= (1 + (variabler['avg_ann_inflation'])) tillgångar += inkomst assets_ending = assets assets_ending_list.append(assets_ending) plt.plot(pd.Series(assets_ending_list))plt.xlabel(' Month') plt.ylabel('Ending Asset Value')plt.show()
Skapa en personlig portfölj/förmögenhetssimulering i Python (del 2) - Python For Finance (3)

Ok koden ovan implementerar logiken vi har diskuterat hittills. Det börjar dock bli lite rörigt och skulle verkligen kunna göra med att städas upp. Det finns några delar av manuset som skulle kunna slås in som funktioner – de två delarna som kommer att tänka på är de för att beräkna våra in- och utflöden varje period. Låt oss börja med utflödena:

def calculate_outflows(month, outflows, variables): # logik för att ta hänsyn till olika utflöden vid pensionering om månad >= variabler['pensionsår'] * 12: utflöde = utflöden['pension_medicinska_kostnader'] + utflöden['pension_misc'] annat: # logik för att ta hänsyn till olika utflöden före pensionering utflöde = (utflöden['hyra'] + utflöden['kreditkortsbetalning'] + \ utflöden['sjukvårdsförsäkring'] + utflöden['pension_bidrag'] + \ utflöden['diverse']) # varje år, öka värdena enligt den årliga inflationsinmatningen om (månad % 12 == 0) och (månad > 0): utflöden['hyra'] *= (1 + (variabler['avg_ann_inflation'])) utflöden[' credit_card_payment'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['medicinal_insurance'] *= (1 + (variabler['avg_ann_inflation'])) utflöden['pension_contribution'] *= (1 + (variabler) ['avg_ann_inflation'])) utflöden['diverse'] *= (1 + (variabler['avg_ann_inflation'])) returutflöde

Och nu våra inkomster (exklusive våra investeringsintäkter – vi kommer att skapa en separat funktion för det).

def calculate_income(månad, inflöden, variabler): # logik för att ta hänsyn till olika inflöden i pension om månad >= variabler['pensionsår'] * 12: inkomst = inflöden['månadspension'] annat: # logik för att redogöra för olika inflöden före pensionsinkomst = (inflöden['aktiv_årsinkomst'] * (1 - variabler['skatt_på_aktiv_inkomst_vinster'])) / 12 om (månad % 12 == 0) och (månad > 0): inflöden['aktiv_årsinkomst'] *= (1 + (variabler['avg_ann_income_raise'])) avkastningsinkomst

Och nu för att införliva det i vårt huvudmanus:

np.random.seed(seed=7)start, end = datetime.datetime(2000, 12, 31), datetime.datetime(2020, 1,1)yf.pdr_override()sp = pdr.get_data_yahoo("^SP500TR" , start=start, end=end)sp_monthly_pct_return = sp.resample('M').last().pct_change().mean().values[0]sp_monthly_std_dev = sp.resample('M').last() .pct_change().std().values[0]inflöden = {'active_annual_income':50_000, 'starting_assets': 250_000, 'monthly_pension': 1500} utflöden = {'rent':1500, 'credit_card_50,' medical_insurance':250, 'pension_contribution':500, 'misc': 1500, 'retirement_medical_expenses':850, 'retirement_misc': 2000} variables = {'start_date' : "01/01/2020", 'years': 40 'pensionsår': 25, 'tax_on_active_income_gains': 0.25, 'avg_ann_income_raise':0.05, 'avg_ann_inflation': 0.02, 'tax_on_investment_gains': 0.35, 'avg_returth_monthly_market: thly_market_volatility': sp_monthly_std_dev} income_gains_storage = []investment_gains_storage = [] assets_starting_list = [inflöden['starting_assets']] assets_ending_list = [] månader = variabler['år'] * 12ruined = Falskt för månad inom intervallet(månader): if assets_ending_list: assets_starting_list.append(assets_ending_list[-1]_starttillgångar_lista =[-1]_starttillgångar -1] # beräkna utflöden med hjälp av skapad funktion utflöde = beräkna_utflöden(månad, utflöden, variabler) tillgångar -= utflöde om tillgångar <= 0: inv_gain = 0 ruinerad = True break market_return = np.random.normal(variables['avg_monthly_market_returns'] , variabler['avg_monthly_market_volatility'], 1)[0] investment_return = (tillgångar * market_return) * (1 - variables['tax_on_investment_gains']) investment_gains_storage.append(investment_return) tillgångar += investeringsfunktion_avkastning beräkna skapad funktion_avkastning # calculate (månad, inflöden, variabler) income_gains_storage.append(income) # ta bort koden som tidigare fanns här angående den årliga ökningen av värden assets += inkomst assets_ending = assets assets_ending_list.append(assets_ending) plt.plot(pd.Series(assets_ending_list) )plt.xlabel('Month')plt.ylabel('Ending Asset Value')plt.show()
Skapa en personlig portfölj/förmögenhetssimulering i Python (del 2) - Python For Finance (4)

Vi kan se från plottet ovan att resultaten är desamma som de vi genererade innan vi lade till användningen av funktioner, vilket bådar gott och antyder att funktionerna har strukturerats och tillämpats korrekt. Vi kanske också vill ta koden som används för att beräkna den månatliga investeringsinkomsten och förvränga den till en funktion. Detta gör att vi lättare kan lägga till komplexitet till logiken om det behövs.

def calculate_investment_gains(tillgångar, variabler): om tillgångar <= 0: inv_gains = 0 else: market_return = np.random.normal(variables['avg_monthly_market_returns'], variables['avg_monthly_market_volatility'], *v_gains] market_return return inv_gains

Och nu för att lägga till den nya funktionen för investeringsvinster i vårt manus:

np.random.seed(seed=7)start, end = datetime.datetime(2000, 12, 31), datetime.datetime(2020, 1,1)yf.pdr_override()sp = pdr.get_data_yahoo("^SP500TR" , start=start, end=end)sp_monthly_pct_return = sp.resample('M').last().pct_change().mean().values[0]sp_monthly_std_dev = sp.resample('M').last() .pct_change().std().values[0]inflöden = {'active_annual_income':50_000, 'starting_assets': 250_000, 'monthly_pension': 1500} utflöden = {'rent':1500, 'credit_card_50,' medical_insurance':250, 'pension_contribution':500, 'misc': 1500, 'retirement_medical_expenses':850, 'retirement_misc': 2000} variables = {'start_date' : "01/01/2020", 'years': 40 'pensionsår': 25, 'tax_on_active_income_gains': 0.25, 'avg_ann_income_raise':0.05, 'avg_ann_inflation': 0.02, 'tax_on_investment_gains': 0.35, 'avg_returth_monthly_market: thly_market_volatility': sp_monthly_std_dev} income_gains_storage = []investment_gains_storage = [] assets_starting_list = [inflöden['starting_assets']] assets_ending_list = [] månader = variabler['år'] * 12ruined = Falskt för månad inom intervallet(månader): if assets_ending_list: assets_starting_list.append(assets_ending_list[-1]_starttillgångar_lista =[-1]_starttillgångar -1] utflöde = calculate_outflows(månad, utflöden, variabler) tillgångar -= utflöde # ändrade ``om``-kodblocket nedan för att ta hänsyn till användningen av ny funktion om tillgångar <= 0: ruinerad = True break # använd vår nya funktion för att beräkna investeringsavkastning investment_return = calculate_investment_gains(tillgångar, variabler) investment_gains_storage.append(investment_return) tillgångar += investeringsavkastning inkomst = beräkna_inkomst(månad, inflöden, variabler) income_gains_storage.append(income_return) assets.append(income_return) assets. ) plt.plot(pd.Series(assets_ending_list))plt.xlabel('Månad')plt.ylabel('Ending Asset Value')plt.show()
Skapa en personlig portfölj/förmögenhetssimulering i Python (del 2) - Python For Finance (5)

Bara för att veta hur vi har flyttat beräkningen av månatlig avkastning inuti en funktion och inte har inkluderat inställningen av numpy-frövärdet i den funktionen betyder att nu, varje gång vi kör den, kommer vi att få lite olika resultat. Jag inkluderade inte inställningen av det slumpmässiga fröet som om jag hade gjort det, varje månads avkastning på marknaden skulle ha varit exakt densamma, vilket naturligtvis inte är vad vi vill ha i det här fallet.

Nu när vi har rensat upp koden lite och börjat omstrukturera en del av logiken till separata funktioner ska jag lämna den här för det här läget. Det finns fortfarande mycket att göra innan vi är klara och vi kommer att hämta det igen i del 3.

lära sig pythonpytonormpython för finansiering

I am a financial modeling and Python programming enthusiast with extensive experience in building personal portfolio and wealth simulation models. My expertise lies in utilizing Python for financial analysis, incorporating stochastic elements in modeling investment returns, and assessing the impact of various factors such as taxes and inflation on financial outcomes.

In the provided Python code snippets, the author is demonstrating how to build a Python-based personal portfolio and wealth simulation model. The model takes into account various financial aspects, including inflows, outflows, salary raises, tax rates on active and investment income, stochastic elements in investment returns, and the calculation of "risk of ruin."

Let's break down the key concepts used in the provided code:

  1. Financial Model Initialization:

    • The code initializes variables such as starting date, simulation period, and key financial parameters.
    • Inflows and outflows are defined, including active annual income, starting assets, and various monthly expenses.
  2. Stochastic Element in Investment Returns:

    • Historical mean monthly return and volatility of the S&P Total Return index are used to simulate investment returns with a stochastic element.
  3. Simulation Loop:

    • The main simulation loop iterates through each month over the specified simulation period.
    • It calculates the impact of various inflows (income) and outflows (expenses) on the overall wealth.
  4. Retirement Planning:

    • The code introduces a retirement planning element by specifying a future retirement year.
    • After retirement, monthly salary inflow decreases or becomes zero, impacting the overall financial scenario.
  5. Refactoring Code into Functions:

    • The author refactors parts of the code into functions, improving readability and modularization.
    • Functions are created for calculating outflows, income, and investment gains, contributing to code organization.
  6. Graphical Representation:

    • Matplotlib is used to create a plot showing the trend of ending asset values over the simulated time period.

The model is designed to be dynamic, allowing for the inclusion of various financial parameters and retirement planning considerations. It provides a visual representation of how different factors can influence one's financial position over time. The code is continually refined, with plans to explore additional aspects in future posts (Part 3).

Skapa en personlig portfölj/förmögenhetssimulering i Python (del 2) - Python For Finance (2024)

References

Top Articles
Latest Posts
Article information

Author: Melvina Ondricka

Last Updated:

Views: 6066

Rating: 4.8 / 5 (68 voted)

Reviews: 91% of readers found this page helpful

Author information

Name: Melvina Ondricka

Birthday: 2000-12-23

Address: Suite 382 139 Shaniqua Locks, Paulaborough, UT 90498

Phone: +636383657021

Job: Dynamic Government Specialist

Hobby: Kite flying, Watching movies, Knitting, Model building, Reading, Wood carving, Paintball

Introduction: My name is Melvina Ondricka, I am a helpful, fancy, friendly, innocent, outstanding, courageous, thoughtful person who loves writing and wants to share my knowledge and understanding with you.