optstrat 0.1.0__tar.gz

optstrat-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matías Roldán
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

optstrat-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: optstrat
+Version: 0.1.0
+Summary: A small Python library for building options strategies
+Author: Matías Roldán
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/roldan/optstrat
+Project-URL: Issues, https://github.com/roldan/optstrat/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# optstrat
+
+A small Python library for building options strategies.
+
+It lets you define a strategy leg by leg, calculate the payoff at expiration, and compute max profit and max loss.
+
+## Installation
+
+```bash
+pip install optstrat
+```
+
+For plotting examples:
+
+```bash
+pip install matplotlib
+```
+
+## Usage example
+
+Plot payoff using `matplotlib`:
+
+```python
+import matplotlib.pyplot as plt
+
+from optstrat import OptionStrategy
+
+strategy = OptionStrategy("Covered Call", 100, contract_size=100)
+
+# 100 shares + short 1 call contract
+strategy.long_underlying(100, quantity=100)
+strategy.short_call(110, 2.5, quantity=1)
+
+max_profit, max_loss = strategy.max_profit_and_loss()
+net_cost = strategy.net_cost()
+
+print(f"Max Profit: {max_profit}")
+print(f"Max Loss: {max_loss}")
+print(f"Cost of entering position ${net_cost}")
+for leg in strategy.legs:
+    print(leg)
+
+plt.plot(strategy.underlying_prices, strategy.payoffs)
+plt.title(strategy.name)
+plt.fill_between(
+    strategy.underlying_prices,
+    strategy.payoffs,
+    where=(strategy.payoffs > 0),
+    facecolor='g',
+    alpha=0.4,
+)
+plt.fill_between(
+    strategy.underlying_prices,
+    strategy.payoffs,
+    where=(strategy.payoffs < 0),
+    facecolor='r',
+    alpha=0.4,
+)
+plt.xlabel(r'$S_T$')
+plt.ylabel('P&L')
+plt.show()
+```
+
+## Notes
+
+- `underlying_prices` represents possible underlying prices at expiration.
+- `quantity` is the number of contracts for option legs and the number of shares for underlying legs.
+- `contract_size` applies only to option legs.
+- `strategy.net_cost()` computes the net cost of entering the position.
+- `strategy.max_profit_and_loss()` computes max profit and max loss at expiration.

optstrat-0.1.0/README.md

@@ -0,0 +1,70 @@
+# optstrat
+
+A small Python library for building options strategies.
+
+It lets you define a strategy leg by leg, calculate the payoff at expiration, and compute max profit and max loss.
+
+## Installation
+
+```bash
+pip install optstrat
+```
+
+For plotting examples:
+
+```bash
+pip install matplotlib
+```
+
+## Usage example
+
+Plot payoff using `matplotlib`:
+
+```python
+import matplotlib.pyplot as plt
+
+from optstrat import OptionStrategy
+
+strategy = OptionStrategy("Covered Call", 100, contract_size=100)
+
+# 100 shares + short 1 call contract
+strategy.long_underlying(100, quantity=100)
+strategy.short_call(110, 2.5, quantity=1)
+
+max_profit, max_loss = strategy.max_profit_and_loss()
+net_cost = strategy.net_cost()
+
+print(f"Max Profit: {max_profit}")
+print(f"Max Loss: {max_loss}")
+print(f"Cost of entering position ${net_cost}")
+for leg in strategy.legs:
+    print(leg)
+
+plt.plot(strategy.underlying_prices, strategy.payoffs)
+plt.title(strategy.name)
+plt.fill_between(
+    strategy.underlying_prices,
+    strategy.payoffs,
+    where=(strategy.payoffs > 0),
+    facecolor='g',
+    alpha=0.4,
+)
+plt.fill_between(
+    strategy.underlying_prices,
+    strategy.payoffs,
+    where=(strategy.payoffs < 0),
+    facecolor='r',
+    alpha=0.4,
+)
+plt.xlabel(r'$S_T$')
+plt.ylabel('P&L')
+plt.show()
+```
+
+## Notes
+
+- `underlying_prices` represents possible underlying prices at expiration.
+- `quantity` is the number of contracts for option legs and the number of shares for underlying legs.
+- `contract_size` applies only to option legs.
+- `strategy.net_cost()` computes the net cost of entering the position.
+- `strategy.max_profit_and_loss()` computes max profit and max loss at expiration.

optstrat-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "optstrat"
+version = "0.1.0"
+description = "A small Python library for building options strategies"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+dependencies = ["numpy"]
+authors = [
+  { name = "Matías Roldán" }
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Intended Audience :: Developers",
+  "Topic :: Office/Business :: Financial",
+]
+
+[project.urls]
+Homepage = "https://github.com/roldan/optstrat"
+Issues = "https://github.com/roldan/optstrat/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

optstrat-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

optstrat-0.1.0/src/optstrat/__init__.py

@@ -0,0 +1,3 @@
+from .option_strategy import Kind, Leg, OptionStrategy, Side
+
+__all__ = ["Kind", "Leg", "OptionStrategy", "Side"]

optstrat-0.1.0/src/optstrat/option_strategy.py

@@ -0,0 +1,164 @@
+from enum import Enum
+
+import numpy as np
+
+class Kind(Enum):
+    CALL = 'call'
+    PUT = 'put'
+    UNDERLYING = 'underlying'
+
+class Side(Enum):
+    LONG = 1
+    SHORT = -1
+
+class Leg:
+
+    def __init__(self, kind: Kind, side: Side, entry_price, quantity=1, K=None):
+        self.kind = kind
+        self.side = side
+        self.entry_price = entry_price
+        self.quantity = quantity
+        self.K = K
+    
+    def __repr__(self):
+        side = self.side.name
+        qty = f' x{self.quantity}' if self.quantity != 1 else ''
+        if self.kind == Kind.UNDERLYING:
+            return f'{side} {self.kind.value} @ {self.entry_price}{qty}'
+        return f'{side} {self.kind.value} {self.K} @ {self.entry_price}{qty}'
+
+class OptionStrategy:
+    """Build an option strategy leg by leg and compute payoff at expiration.
+
+    Quantity semantics:
+    - option legs use `quantity` as number of contracts
+    - underlying legs use `quantity` as number of shares
+
+    `contract_size` applies only to option legs.
+    """
+
+    def __init__(self, name, S0, price_range_ratio=0.5, step=1, contract_size=100):
+        self.name = name
+        self.S0 = S0
+        self.contract_size = contract_size
+        self.underlying_prices = np.arange(S0 * price_range_ratio, S0 * (1 + price_range_ratio), step)
+        self.payoffs = np.zeros_like(self.underlying_prices, dtype=float)
+        self.legs = []
+           
+    def _apply(self, kind: Kind, side: Side, entry_price, quantity=1, K=None):
+        if kind == Kind.CALL:
+            intrinsic = np.maximum(self.underlying_prices - K, 0)
+            payoffs = (side.value * intrinsic - side.value * entry_price) * quantity * self.contract_size
+        elif kind == Kind.PUT:
+            intrinsic = np.maximum(K - self.underlying_prices, 0)
+            payoffs = (side.value * intrinsic - side.value * entry_price) * quantity * self.contract_size
+        elif kind == Kind.UNDERLYING:
+            payoffs = side.value * (self.underlying_prices - entry_price) * quantity
+
+        self.payoffs += payoffs
+        self.legs.append(Leg(kind, side, entry_price, quantity, K=K))
+
+    def long_call(self, K, entry_price, quantity=1):
+        """Add a long call.
+
+        Parameters:
+            K: Strike price.
+            entry_price: Premium paid per contract.
+            quantity: Number of option contracts.
+        """
+        self._apply(Kind.CALL, Side.LONG, entry_price, quantity, K=K)
+    
+    def short_call(self, K, entry_price, quantity=1):
+        """Add a short call.
+
+        Parameters:
+            K: Strike price.
+            entry_price: Premium received per contract.
+            quantity: Number of option contracts.
+        """
+        self._apply(Kind.CALL, Side.SHORT, entry_price, quantity, K=K)
+    
+    def long_put(self, K, entry_price, quantity=1):
+        """Add a long put.
+
+        Parameters:
+            K: Strike price.
+            entry_price: Premium paid per contract.
+            quantity: Number of option contracts.
+        """
+        self._apply(Kind.PUT, Side.LONG, entry_price, quantity, K=K)
+      
+    def short_put(self, K, entry_price, quantity=1):
+        """Add a short put.
+
+        Parameters:
+            K: Strike price.
+            entry_price: Premium received per contract.
+            quantity: Number of option contracts.
+        """
+        self._apply(Kind.PUT, Side.SHORT, entry_price, quantity, K=K)
+
+    def long_underlying(self, entry_price, quantity=1):
+        """Add a long underlying position.
+
+        Parameters:
+            entry_price: Entry price per share.
+            quantity: Number of shares.
+        """
+        self._apply(Kind.UNDERLYING, Side.LONG, entry_price, quantity)
+
+    def short_underlying(self, entry_price, quantity=1):
+        """Add a short underlying position.
+
+        Parameters:
+            entry_price: Entry price per share.
+            quantity: Number of shares.
+        """
+        self._apply(Kind.UNDERLYING, Side.SHORT, entry_price, quantity)
+
+    def net_cost(self):
+        """Return the net cost of entering the strategy."""
+        return sum(
+            leg.entry_price * leg.quantity * leg.side.value * self.contract_size
+            if leg.kind in (Kind.CALL, Kind.PUT)
+            else leg.entry_price * leg.quantity * leg.side.value
+            for leg in self.legs
+        )
+
+    def max_profit_and_loss(self):
+        """Return max profit and max loss at expiration."""
+        prices = {0}
+        for leg in self.legs:
+            if leg.K is not None:
+                prices.add(leg.K)
+
+        def payoff_at(price):
+            payoff = 0
+            for leg in self.legs:
+                if leg.kind == Kind.CALL:
+                    intrinsic = max(price - leg.K, 0)
+                    payoff += (leg.side.value * intrinsic - leg.side.value * leg.entry_price) * leg.quantity * self.contract_size
+                elif leg.kind == Kind.PUT:
+                    intrinsic = max(leg.K - price, 0)
+                    payoff += (leg.side.value * intrinsic - leg.side.value * leg.entry_price) * leg.quantity * self.contract_size
+                elif leg.kind == Kind.UNDERLYING:
+                    payoff += leg.side.value * (price - leg.entry_price) * leg.quantity
+            return payoff
+
+        slope = 0
+        for leg in self.legs:
+            if leg.kind == Kind.CALL:
+                slope += leg.side.value * leg.quantity * self.contract_size
+            elif leg.kind == Kind.UNDERLYING:
+                slope += leg.side.value * leg.quantity
+
+        payoffs = [payoff_at(price) for price in sorted(prices)]
+        max_profit = max(payoffs)
+        max_loss = min(payoffs)
+
+        if slope > 0:
+            max_profit = np.inf
+        elif slope < 0:
+            max_loss = -np.inf
+
+        return max_profit, max_loss

optstrat-0.1.0/src/optstrat.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: optstrat
+Version: 0.1.0
+Summary: A small Python library for building options strategies
+Author: Matías Roldán
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/roldan/optstrat
+Project-URL: Issues, https://github.com/roldan/optstrat/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# optstrat
+
+A small Python library for building options strategies.
+
+It lets you define a strategy leg by leg, calculate the payoff at expiration, and compute max profit and max loss.
+
+## Installation
+
+```bash
+pip install optstrat
+```
+
+For plotting examples:
+
+```bash
+pip install matplotlib
+```
+
+## Usage example
+
+Plot payoff using `matplotlib`:
+
+```python
+import matplotlib.pyplot as plt
+
+from optstrat import OptionStrategy
+
+strategy = OptionStrategy("Covered Call", 100, contract_size=100)
+
+# 100 shares + short 1 call contract
+strategy.long_underlying(100, quantity=100)
+strategy.short_call(110, 2.5, quantity=1)
+
+max_profit, max_loss = strategy.max_profit_and_loss()
+net_cost = strategy.net_cost()
+
+print(f"Max Profit: {max_profit}")
+print(f"Max Loss: {max_loss}")
+print(f"Cost of entering position ${net_cost}")
+for leg in strategy.legs:
+    print(leg)
+
+plt.plot(strategy.underlying_prices, strategy.payoffs)
+plt.title(strategy.name)
+plt.fill_between(
+    strategy.underlying_prices,
+    strategy.payoffs,
+    where=(strategy.payoffs > 0),
+    facecolor='g',
+    alpha=0.4,
+)
+plt.fill_between(
+    strategy.underlying_prices,
+    strategy.payoffs,
+    where=(strategy.payoffs < 0),
+    facecolor='r',
+    alpha=0.4,
+)
+plt.xlabel(r'$S_T$')
+plt.ylabel('P&L')
+plt.show()
+```
+
+## Notes
+
+- `underlying_prices` represents possible underlying prices at expiration.
+- `quantity` is the number of contracts for option legs and the number of shares for underlying legs.
+- `contract_size` applies only to option legs.
+- `strategy.net_cost()` computes the net cost of entering the position.
+- `strategy.max_profit_and_loss()` computes max profit and max loss at expiration.

optstrat-0.1.0/src/optstrat.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/optstrat/__init__.py
+src/optstrat/option_strategy.py
+src/optstrat.egg-info/PKG-INFO
+src/optstrat.egg-info/SOURCES.txt
+src/optstrat.egg-info/dependency_links.txt
+src/optstrat.egg-info/requires.txt
+src/optstrat.egg-info/top_level.txt

optstrat-0.1.0/src/optstrat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

optstrat-0.1.0/src/optstrat.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

optstrat-0.1.0/src/optstrat.egg-info/top_level.txt

@@ -0,0 +1 @@
+optstrat