Add documentation (#45)

* Add documentation using pdoc

* Added documentation using pdoc

* Update github actions

* Update examples

Author: rgaveiga

.github/actions/cached-venv/action.yml

@@ -5,7 +5,7 @@ runs:
   using: composite
   steps:
     - name: Cache virtual environment
-      uses: actions/cache@v2
+      uses: actions/cache@v4
       env:
         cache-name: cache-venv-1
       with:

.gitignore

@@ -5,3 +5,4 @@ __pycache__
 dist
 run_check
 *.old
+runpdoc.bat

CHANGELOG.md

@@ -1,5 +1,15 @@
 # CHANGELOG
 
+## 1.4.3 (2025-04-14)
+
+- Updated docstrings.
+- Added documentation with `pdoc`.
+- Changed __init__.py for compatibility with `pdoc` autodocumentation.
+- Removed `BaseLeg` from models.py.
+- Changed `StrategyType` to `StrategyLegType` in models.py for clarity.
+- Removed "normal" as an alias for "black-scholes" to avoid confusion with Bachelier model.
+- Updated Readme.md.
+
 ## 1.4.2 (2025-01-25)
 
 - Removed `expected_profit` and `expected_loss` calculation from `_get_pop_bs` in support.py; implementation was not correct, giving wrong results when compared with Monte Carlo simulations

README.md

@@ -1,7 +1,9 @@
+![OptionLab](optionlab.png)
+
 # OptionLab
 
 This package is a lightweight library written entirely in Python, designed to provide 
-quick evaluation of option strategies.
+quick evaluation of option strategy ideas.
 
 The code produces various outputs, including the profit/loss profile of the strategy on 
 a user-defined target date, the range of stock prices for which the strategy is 
@@ -10,22 +12,16 @@ each leg of the strategy using the Black-Sholes model, the resulting debit or cr
 trading account, the maximum and minimum returns within a specified lower and higher price 
 range of the underlying asset, and an estimate of the strategy's probability of profit.
 
-The probability of profit (PoP) on the user-defined target date for the strategy is calculated 
-by default using the Black-Scholes model. Alternatively, the user can provide an array of 
-underlying asset prices following a distribution other than the normal (e.g. Laplace) or 
-model other than the Black-Scholes model (e.g. Heston model) that will be used in the calculations.
-
-Despite the code having been developed with option strategies in mind, it can also be 
-used for strategies that combine options with stocks and/or take into account the 
-profits or losses of closed trades.
-
 If you have any questions, corrections, comments or suggestions, just 
 [drop a message](mailto:[email protected]).
 
 You can also reach me on [Linkedin](https://www.linkedin.com/in/roberto-gomes-phd-8a718317b/) or 
 follow me on [X](https://x.com/rgaveiga). When I have some free time, which is rare, I publish articles 
 on [Medium](https://medium.com/@rgaveiga).
 
+If you want to support this and other open source projects that I maintain, become a 
+[sponsor on Github](https://github.com/sponsors/rgaveiga).
+
 ## Installation
 
 The easiest way to install **OptionLab** is using **pip**:
@@ -34,55 +30,9 @@ The easiest way to install **OptionLab** is using **pip**:
 pip install optionlab
 ```
 
-## Basic usage
-
-The evaluation of a strategy is done by calling the `run_strategy` function provided by 
-the library. This function receives the input data either as a Python dictionary or an 
-`Inputs` object. For example, let's say we wanted to calculate the probability of profit 
-for naked calls on Apple stocks with maturity on December 17, 2021. The strategy setup 
-consisted of selling 100 175.00 strike calls for 1.15 each on November 22, 2021.
-
-```python
-input_data = {
-    "stock_price": 164.04,
-    "start_date": "2021-11-22",
-    "target_date": "2021-12-17",
-    "volatility": 0.272,
-    "interest_rate": 0.0002,
-    "min_stock": 120,
-    "max_stock": 200,
-    "strategy": [
-        {
-            "type": "call",
-            "strike": 175.0,
-            "premium": 1.15,
-            "n": 100,
-            "action":"sell"
-        }
-    ],
-}
-```
-
-After defining the input data as a Python dictionary, we pass it to the `run_strategy` 
-function as shown below:
-
-```python
-from optionlab import run_strategy, plot_pl
-
-out = run_strategy(input_data)
-
-print(out)
-
-plot_pl(out)
-```
-
-The variable `out` is an `Outputs` object that contains the results from the 
-calculations. By calling `print` with `out` as an argument, these results are 
-displayed on screen. The `plot_pl` function, in turn, takes an `Outputs` object as 
-its argument and plots the profit/loss diagram for the strategy.
+## Documentation
 
-Usage examples for a number of popular options trading strategies can be found in the 
-Jupyter notebooks in the **examples** directory.
+You can access the API documentation for **OptionLab** on the [project's GitHub Pages site](https://rgaveiga.github.io/optionlab).
 
 ## Contributions
 

docs/index.html

@@ -0,0 +1,7 @@
+<!doctype html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="refresh" content="0; url=./optionlab.html"/>
+</head>
+</html>