git init
git add .
git commit -m 'initial commit'


%load_ext autoreload
%autoreload 2


import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns


%matplotlib inline


class BookstoreModel(Model):
    """Bookstore model

    This example is based on the "Walton Bookstore" problem in *Business Analytics: Data Analysis and Decision Making* (Albright and Winston) in the chapter on Monte-Carlo simulation. Here's the basic problem (with a few modifications):

    * we have to place an order for a perishable product (e.g. a calendar),
    * there's a known unit cost for each one ordered,
    * we have a known selling price,
    * demand is uncertain but we can model it with some simple probability distribution,
    * for each unsold item, we can get a partial refund of our unit cost,
    * we need to select the order quantity for our one order for the year; orders can only be in multiples of 25.

    Attributes
    ----------
    unit_cost: float or array-like of float, optional
        Cost for each item ordered (default 7.50)
    selling_price : float or array-like of float, optional
        Selling price for each item (default 10.00)
    unit_refund : float or array-like of float, optional
        For each unsold item we receive a refund in this amount (default 2.50)
    order_quantity : float or array-like of float, optional
        Number of items ordered in the one time we get to order (default 200)
    demand : float or array-like of float, optional
        Number of items demanded by customers (default 193)
    """
    def __init__(self, unit_cost=7.50, selling_price=10.00, unit_refund=2.50,
                 order_quantity=200, demand=193):
        self.unit_cost = unit_cost
        self.selling_price = selling_price
        self.unit_refund = unit_refund
        self.order_quantity = order_quantity
        self.demand = demand

    def order_cost(self):
        """Compute total order cost"""
        return self.unit_cost * self.order_quantity

    def num_sold(self):
        """Compute number of items sold

        Assumes demand in excess of order quantity is lost.
        """
        return np.minimum(self.order_quantity, self.demand)

    def sales_revenue(self):
        """Compute total sales revenue based on number sold and selling price"""
        return self.num_sold() * self.selling_price

    def num_unsold(self):
        """Compute number of items ordered but not sold

        Demand was less than order quantity
        """
        return np.maximum(0, self.order_quantity - self.demand)

    def refund_revenue(self):
        """Compute total sales revenue based on number unsold and unit refund"""
        return self.num_unsold()  * self.unit_refund

    def total_revenue(self):
        """Compute total revenue from sales and refunds"""
        return self.sales_revenue() + self.refund_revenue()

    def profit(self):
        """Compute profit based on revenue and cost"""
        profit = self.sales_revenue() + self.refund_revenue() - self.order_cost()
        return profit


from whatif import Model

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[4], line 1
----> 1 from whatif import Model

ModuleNotFoundError: No module named 'whatif'


import sys
print('\n'.join(sys.path))

/home/mark/Documents/sandbox/downloads_whatif_packaging/whatif/notebooks
/home/mark/anaconda3/envs/aap/lib/python311.zip
/home/mark/anaconda3/envs/aap/lib/python3.11
/home/mark/anaconda3/envs/aap/lib/python3.11/lib-dynload

/home/mark/anaconda3/envs/aap/lib/python3.11/site-packages

from whatif.whatif import Model
from whatif.whatif import get_sim_results_df

# setup.py

from setuptools import find_packages, setup

setup(
    name='whatif',
    packages=find_packages("src"),
    package_dir={"": "src"},
    install_requires=['numpy', 'pandas'],
    version='0.1.0',
    description='What if analysis in Python',
    author='misken',
    license='MIT',
)

packages=find_packages("src"),
package_dir={"": "src"},

pip install -e .


from whatif import Model


model = BookstoreModel()
print(model)
print(model.profit())

{'unit_cost': 7.5, 'selling_price': 10.0, 'unit_refund': 2.5, 'order_quantity': 200, 'demand': 193}
447.5

def __str__(self):
        """
        Print dictionary of object attributes that don't include an underscore as first char
        """
        return str({key: val for (key, val) in vars(self).items() if key[0] != '_'})


from whatif import Model


class BookstoreModel(Model):
    """Bookstore model

    This example is based on the "Walton Bookstore" problem in *Business Analytics: Data Analysis and Decision Making* (Albright and Winston) in the chapter on Monte-Carlo simulation. Here's the basic problem (with a few modifications):

    * we have to place an order for a perishable product (e.g. a calendar),
    * there's a known unit cost for each one ordered,
    * we have a known selling price,
    * demand is uncertain but we can model it with some simple probability distribution,
    * for each unsold item, we can get a partial refund of our unit cost,
    * we need to select the order quantity for our one order for the year; orders can only be in multiples of 25.

    Attributes
    ----------
    unit_cost: float or array-like of float, optional
        Cost for each item ordered (default 7.50)
    selling_price : float or array-like of float, optional
        Selling price for each item (default 10.00)
    unit_refund : float or array-like of float, optional
        For each unsold item we receive a refund in this amount (default 2.50)
    order_quantity : float or array-like of float, optional
        Number of items ordered in the one time we get to order (default 200)
    demand : float or array-like of float, optional
        Number of items demanded by customers (default 193)
    """
    def __init__(self, unit_cost=7.50, selling_price=10.00, unit_refund=2.50,
                 order_quantity=200, demand=193):
        self.unit_cost = unit_cost
        self.selling_price = selling_price
        self.unit_refund = unit_refund
        self.order_quantity = order_quantity
        self.demand = demand

    def order_cost(self):
        """Compute total order cost"""
        return self.unit_cost * self.order_quantity

    def num_sold(self):
        """Compute number of items sold

        Assumes demand in excess of order quantity is lost.
        """
        return np.minimum(self.order_quantity, self.demand)

    def sales_revenue(self):
        """Compute total sales revenue based on number sold and selling price"""
        return self.num_sold() * self.selling_price

    def num_unsold(self):
        """Compute number of items ordered but not sold

        Demand was less than order quantity
        """
        return np.maximum(0, self.order_quantity - self.demand)

    def refund_revenue(self):
        """Compute total sales revenue based on number unsold and unit refund"""
        return self.num_unsold()  * self.unit_refund

    def total_revenue(self):
        """Compute total revenue from sales and refunds"""
        return self.sales_revenue() + self.refund_revenue()

    def profit(self):
        """Compute profit based on revenue and cost"""
        profit = self.sales_revenue() + self.refund_revenue() - self.order_cost()
        return profit


bookstore_model = BookstoreModel()


demand_scenarios = {'demand': [100, 150, 200, 250, 300]}


bookstore_model.data_table(demand_scenarios, ['profit'])


dir(bookstore_model)

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getstate__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__slotnames__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'data_table',
 'demand',
 'goal_seek',
 'model_to_df',
 'num_sold',
 'num_unsold',
 'order_cost',
 'order_quantity',
 'profit',
 'refund_revenue',
 'sales_revenue',
 'selling_price',
 'simulate',
 'total_revenue',
 'unit_cost',
 'unit_refund',
 'update']

%load_ext autoreload
%autoreload 2

Excel "What if?" analysis with Python - Part 4: Project management and packaging¶

Python packaging basics¶

Creating a new project using a cookiecutter¶

Overview of cookiecutter-datascience-aap project structure¶

Adding files to our new project¶

Version control¶

Source code editing¶

The whatif.py module - initial design¶

Creating a `Model` base class¶

Adding new methods to `BookstoreModel`¶

Using the Bookstore Model¶

Creating the whatif package¶

The `init.py` file¶

Installing our package and learning about that setup.py file¶

Using the Bookstore class revisited¶

What happens when we make changes to whatif.py?¶

Concluding thoughts and next steps¶

	demand	profit
0	100	-250.0
1	150	125.0
2	200	500.0
3	250	500.0
4	300	500.0

Excel "What if?" analysis with Python - Part 4: Project management and packaging¶

Python packaging basics¶

Creating a new project using a cookiecutter¶

Overview of cookiecutter-datascience-aap project structure¶

Adding files to our new project¶

Version control¶

Source code editing¶

The whatif.py module - initial design¶

Creating a Model base class¶

Adding new methods to BookstoreModel¶

Using the Bookstore Model¶

Creating the whatif package¶

The __init__.py file¶

Installing our package and learning about that setup.py file¶

Using the Bookstore class revisited¶

What happens when we make changes to whatif.py?¶

Concluding thoughts and next steps¶

Creating a `Model` base class¶

Adding new methods to `BookstoreModel`¶

The `init.py` file¶