Upload app.py

app.py

@@ -1,147 +1,873 @@
-import io
-import random
-from typing import List, Tuple
-
-import aiohttp
-import panel as pn
-from PIL import Image
-from transformers import CLIPModel, CLIPProcessor
-
-pn.extension(design="bootstrap", sizing_mode="stretch_width")
-
-ICON_URLS = {
-    "brand-github": "https://github.com/holoviz/panel",
-    "brand-twitter": "https://twitter.com/Panel_Org",
-    "brand-linkedin": "https://www.linkedin.com/company/panel-org",
-    "message-circle": "https://discourse.holoviz.org/",
-    "brand-discord": "https://discord.gg/AXRHnJU6sP",
-}
-
-
-async def random_url(_):
-    pet = random.choice(["cat", "dog"])
-    api_url = f"https://api.the{pet}api.com/v1/images/search"
-    async with aiohttp.ClientSession() as session:
-        async with session.get(api_url) as resp:
-            return (await resp.json())[0]["url"]
-
-
-@pn.cache
-def load_processor_model(
-    processor_name: str, model_name: str
-) -> Tuple[CLIPProcessor, CLIPModel]:
-    processor = CLIPProcessor.from_pretrained(processor_name)
-    model = CLIPModel.from_pretrained(model_name)
-    return processor, model
-
-
-async def open_image_url(image_url: str) -> Image:
-    async with aiohttp.ClientSession() as session:
-        async with session.get(image_url) as resp:
-            return Image.open(io.BytesIO(await resp.read()))
-
-
-def get_similarity_scores(class_items: List[str], image: Image) -> List[float]:
-    processor, model = load_processor_model(
-        "openai/clip-vit-base-patch32", "openai/clip-vit-base-patch32"
-    )
-    inputs = processor(
-        text=class_items,
-        images=[image],
-        return_tensors="pt",  # pytorch tensors
-    )
-    outputs = model(**inputs)
-    logits_per_image = outputs.logits_per_image
-    class_likelihoods = logits_per_image.softmax(dim=1).detach().numpy()
-    return class_likelihoods[0]
-
-
-async def process_inputs(class_names: List[str], image_url: str):
-    """
-    High level function that takes in the user inputs and returns the
-    classification results as panel objects.
-    """
-    try:
-        main.disabled = True
-        if not image_url:
-            yield "##### ⚠️ Provide an image URL"
-            return
-    
-        yield "##### ⚙ Fetching image and running model..."
-        try:
-            pil_img = await open_image_url(image_url)
-            img = pn.pane.Image(pil_img, height=400, align="center")
-        except Exception as e:
-            yield f"##### 😔 Something went wrong, please try a different URL!"
-            return
-    
-        class_items = class_names.split(",")
-        class_likelihoods = get_similarity_scores(class_items, pil_img)
-    
-        # build the results column
-        results = pn.Column("##### 🎉 Here are the results!", img)
-    
-        for class_item, class_likelihood in zip(class_items, class_likelihoods):
-            row_label = pn.widgets.StaticText(
-                name=class_item.strip(), value=f"{class_likelihood:.2%}", align="center"
-            )
-            row_bar = pn.indicators.Progress(
-                value=int(class_likelihood * 100),
-                sizing_mode="stretch_width",
-                bar_color="secondary",
-                margin=(0, 10),
-                design=pn.theme.Material,
-            )
-            results.append(pn.Column(row_label, row_bar))
-        yield results
-    finally:
-        main.disabled = False
-
-
-# create widgets
-randomize_url = pn.widgets.Button(name="Randomize URL", align="end")
-
-image_url = pn.widgets.TextInput(
-    name="Image URL to classify",
-    value=pn.bind(random_url, randomize_url),
-)
-class_names = pn.widgets.TextInput(
-    name="Comma separated class names",
-    placeholder="Enter possible class names, e.g. cat, dog",
-    value="cat, dog, parrot",
-)
-
-input_widgets = pn.Column(
-    "##### 😊 Click randomize or paste a URL to start classifying!",
-    pn.Row(image_url, randomize_url),
-    class_names,
-)
-
-# add interactivity
-interactive_result = pn.panel(
-    pn.bind(process_inputs, image_url=image_url, class_names=class_names),
-    height=600,
-)
-
-# add footer
-footer_row = pn.Row(pn.Spacer(), align="center")
-for icon, url in ICON_URLS.items():
-    href_button = pn.widgets.Button(icon=icon, width=35, height=35)
-    href_button.js_on_click(code=f"window.open('{url}')")
-    footer_row.append(href_button)
-footer_row.append(pn.Spacer())
-
-# create dashboard
-main = pn.WidgetBox(
-    input_widgets,
-    interactive_result,
-    footer_row,
-)
-
-title = "Panel Demo - Image Classification"
-pn.template.BootstrapTemplate(
-    title=title,
-    main=main,
-    main_max_width="min(50%, 698px)",
-    header_background="#F08080",
-).servable(title=title)
+import panel as pn
+import pandas as pd
+import param
+from bokeh.models.formatters import PrintfTickFormatter
+
+# Initialize Panel extension for Tabulator and set a global sizing mode
+pn.extension(
+    "tabulator",
+    sizing_mode="stretch_width",
+    template="fast",
+    # theme = 'dark',
+)
+
+# --- Styling Placeholders (as per user instruction) ---
+slider_design = {}
+slider_style = {}
+slider_stylesheet = []
+
+
+# --- Helper for NumberFormatters ---
+def get_formatter(format_str):
+    if format_str == "%i":
+        return pn.widgets.tables.NumberFormatter(format="0")
+    elif format_str == "%.1f":
+        return pn.widgets.tables.NumberFormatter(format="0.0")
+    elif format_str == "%.2f":
+        return pn.widgets.tables.NumberFormatter(format="0.00")
+    elif format_str == "%.4f":
+        return pn.widgets.tables.NumberFormatter(format="0.0000")
+    elif format_str == "$%.02f":
+        return pn.widgets.tables.NumberFormatter(format="$0,0.00")
+    return format_str
+
+
+class CannabinoidEstimator(param.Parameterized):
+    # --- Input Parameters ---
+    kg_processed_per_hour = param.Number(
+        default=150.0,
+        bounds=(0, 2000),
+        step=1.0,
+        label="Biomass processed per hour (kg)",
+    )
+    finished_product_yield_pct = param.Number(
+        default=60.0,
+        bounds=(0.01, 100),
+        step=0.01,
+        label="Product yield: CBx Weight Output / Weight Input (%)",
+    )
+    kwh_rate = param.Number(
+        default=0.25, bounds=(0.01, 5), step=0.01, label="Power rate ($ per kWh)"
+    )
+    water_cost_per_1000l = param.Number(
+        default=2.50,
+        bounds=(0.01, 10),
+        step=0.01,
+        label="Water rate ($ per 1000L / m3)",
+    )
+    consumables_per_kg_bio_rate = param.Number(
+        default=0.0032,
+        bounds=(0, 10),
+        step=0.0001,
+        label="Other Consumables rate ($ per kg biomass)",
+    )
+    kwh_per_kg_bio = param.Number(
+        default=0.25,
+        bounds=(0.05, 15),
+        step=0.01,
+        label="Power consumption (kWh per kg biomass)",
+    )
+    water_liters_consumed_per_kg_bio = param.Number(
+        default=3.0,
+        bounds=(0.1, 100),
+        step=0.1,
+        label="Water consumption (liters per kg biomass)",
+    )
+    consumables_per_kg_output = param.Number(
+        default=10.0,
+        bounds=(0, 100),
+        step=0.01,
+        label="Consumables per kg finished product ($)",
+    )
+    bio_cbx_pct = param.Number(
+        default=10.0, bounds=(0, 30), step=0.1, label="Cannabinoid (CBx) in biomass (%)"
+    )
+    bio_cost = param.Number(
+        default=3.0,
+        bounds=(0, 200),
+        step=0.25,
+        label="Biomass purchase cost ($ per kg)",
+    )
+    wholesale_cbx_price = param.Number(
+        default=220.0,
+        bounds=(25, 6000),
+        step=5.0,
+        label="Gross revenue ($ per kg output)",
+    )
+    wholesale_cbx_pct = param.Number(
+        default=99.9, bounds=(0, 100), step=0.01, label="CBx in finished product (%)"
+    )
+    batch_test_cost = param.Number(
+        default=1300.0,
+        bounds=(100, 5000),
+        step=25.0,
+        label="Per-batch testing/compliance costs ($)",
+    )
+    fixed_overhead_per_week = param.Number(
+        default=2000.0, bounds=(0, 10000), step=1.0, label="Weekly fixed costs ($)"
+    )
+    workers_per_shift = param.Number(
+        default=9.0, bounds=(1, 20), step=1.0, label="Workers per shift"
+    )
+    worker_hourly_rate = param.Number(
+        default=5.0, bounds=(0.25, 50), step=0.25, label="Worker loaded pay rate ($/hr)"
+    )
+    managers_per_shift = param.Number(
+        default=1.0, bounds=(1, 10), step=1.0, label="Supervisors per shift"
+    )
+    manager_hourly_rate = param.Number(
+        default=10.0,
+        bounds=(5.0, 50),
+        step=0.25,
+        label="Supervisor loaded pay rate ($/hr)",
+    )
+    processing_hours_per_shift = param.Number(
+        default=7.0, bounds=(0.25, 8.0), step=0.25, label="Processing hours per shift"
+    )
+    labour_hours_per_shift = param.Number(
+        default=8.0, bounds=(6.0, 12), step=0.25, label="Labor hours per shift"
+    )
+    shifts_per_day = param.Number(
+        default=3.0, bounds=(1, 10), step=1.0, label="Shifts per day"
+    )
+    shifts_per_week = param.Number(
+        default=21.0, bounds=(1, 28), step=1.0, label="Shifts per week"
+    )
+
+    kg_processed_per_shift = 0.0
+    labour_cost_per_shift = 0.0
+    variable_cost_per_shift = 0.0
+    overhead_cost_per_shift = 0.0
+    saleable_kg_per_kg_bio = 0.0
+    saleable_kg_per_shift = 0.0
+    saleable_kg_per_day = 0.0
+    saleable_kg_per_week = 0.0
+    biomass_kg_per_saleable_kg = 0.0
+    internal_cogs_per_kg_bio = 0.0
+    internal_cogs_per_shift = 0.0
+    internal_cogs_per_day = 0.0
+    internal_cogs_per_week = 0.0
+    internal_cogs_per_kg_output = 0.0
+    biomass_cost_per_shift = 0.0
+    biomass_cost_per_day = 0.0
+    biomass_cost_per_week = 0.0
+    biomass_cost_per_kg_output = 0.0
+    gross_rev_per_kg_bio = 0.0
+    gross_rev_per_shift = 0.0
+    gross_rev_per_day = 0.0
+    gross_rev_per_week = 0.0
+    net_rev_per_kg_bio = 0.0
+    net_rev_per_shift = 0.0
+    net_rev_per_day = 0.0
+    net_rev_per_week = 0.0
+    net_rev_per_kg_output = 0.0
+    operating_profit_pct = 0.0
+    resin_spread_pct = 0.0
+
+    money_data_df = param.DataFrame(pd.DataFrame())
+    profit_data_df = param.DataFrame(pd.DataFrame())
+    processing_data_df = param.DataFrame(pd.DataFrame())
+
+    def __init__(self, **params):
+        super().__init__(**params)
+        self._create_sliders()
+        self.money_table = pn.widgets.Tabulator(
+            self.money_data_df,
+            formatters=self._get_money_formatters(),
+            disabled=True,
+            layout="fit_data_table",
+            sizing_mode="fixed",
+            align="center",
+            show_index=False,  # Hide index column
+        )
+        self.profit_table = pn.widgets.Tabulator(
+            self.profit_data_df,
+            disabled=True,
+            layout="fit_data_table",
+            sizing_mode="fixed",
+            align="center",
+            show_index=False,  # Hide index column
+        )
+        self.processing_table = pn.widgets.Tabulator(
+            self.processing_data_df,
+            formatters={},
+            disabled=True,
+            layout="fit_data_table",
+            sizing_mode="fixed",
+            align="center",
+            show_index=False,  # Hide index column
+        )
+        self._update_calculations()
+
+    def _create_sliders(self):
+        self.kg_processed_per_hour_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.kg_processed_per_hour,
+            name=self.param.kg_processed_per_hour.label,  # Updated
+            fixed_start=self.param.kg_processed_per_hour.bounds[0],
+            fixed_end=self.param.kg_processed_per_hour.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            # format="0",
+            format=PrintfTickFormatter(format="%i kg"),
+        )
+        self.finished_product_yield_pct_slider = (
+            pn.widgets.EditableFloatSlider.from_param(
+                self.param.finished_product_yield_pct,
+                name=self.param.finished_product_yield_pct.label,  # Updated
+                fixed_start=self.param.finished_product_yield_pct.bounds[0],
+                fixed_end=self.param.finished_product_yield_pct.bounds[1],
+                design=slider_design,
+                styles=slider_style,
+                stylesheets=slider_stylesheet,
+                format="0.00",
+            )
+        )
+        self.kwh_rate_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.kwh_rate,
+            name=self.param.kwh_rate.label,  # Updated
+            fixed_start=self.param.kwh_rate.bounds[0],
+            fixed_end=self.param.kwh_rate.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+            # format=PrintfTickFormatter(format='%.2f per kWh'),
+        )
+        self.water_cost_per_1000l_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.water_cost_per_1000l,
+            name=self.param.water_cost_per_1000l.label,  # Updated
+            fixed_start=self.param.water_cost_per_1000l.bounds[0],
+            fixed_end=self.param.water_cost_per_1000l.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+        )
+        self.consumables_per_kg_bio_rate_slider = (
+            pn.widgets.EditableFloatSlider.from_param(
+                self.param.consumables_per_kg_bio_rate,
+                name=self.param.consumables_per_kg_bio_rate.label,  # Updated
+                fixed_start=self.param.consumables_per_kg_bio_rate.bounds[0],
+                fixed_end=self.param.consumables_per_kg_bio_rate.bounds[1],
+                design=slider_design,
+                styles=slider_style,
+                stylesheets=slider_stylesheet,
+                format="0.0000",
+            )
+        )
+        self.kwh_per_kg_bio_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.kwh_per_kg_bio,
+            name=self.param.kwh_per_kg_bio.label,  # Updated
+            fixed_start=self.param.kwh_per_kg_bio.bounds[0],
+            fixed_end=self.param.kwh_per_kg_bio.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+        )
+        self.water_liters_consumed_per_kg_bio_slider = (
+            pn.widgets.EditableFloatSlider.from_param(
+                self.param.water_liters_consumed_per_kg_bio,
+                name=self.param.water_liters_consumed_per_kg_bio.label,  # Updated
+                fixed_start=self.param.water_liters_consumed_per_kg_bio.bounds[0],
+                fixed_end=self.param.water_liters_consumed_per_kg_bio.bounds[1],
+                design=slider_design,
+                styles=slider_style,
+                stylesheets=slider_stylesheet,
+                format="0.0",
+            )
+        )
+        self.consumables_per_kg_output_slider = (
+            pn.widgets.EditableFloatSlider.from_param(
+                self.param.consumables_per_kg_output,
+                name=self.param.consumables_per_kg_output.label,  # Updated
+                fixed_start=self.param.consumables_per_kg_output.bounds[0],
+                fixed_end=self.param.consumables_per_kg_output.bounds[1],
+                design=slider_design,
+                styles=slider_style,
+                stylesheets=slider_stylesheet,
+                format="0.00",
+            )
+        )
+        self.bio_cbx_pct_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.bio_cbx_pct,
+            name=self.param.bio_cbx_pct.label,  # Updated
+            fixed_start=self.param.bio_cbx_pct.bounds[0],
+            fixed_end=self.param.bio_cbx_pct.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.0",
+        )
+        self.bio_cost_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.bio_cost,
+            name=self.param.bio_cost.label,  # Updated
+            fixed_start=self.param.bio_cost.bounds[0],
+            fixed_end=self.param.bio_cost.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+        )
+        self.wholesale_cbx_price_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.wholesale_cbx_price,
+            name=self.param.wholesale_cbx_price.label,  # Updated
+            fixed_start=self.param.wholesale_cbx_price.bounds[0],
+            fixed_end=self.param.wholesale_cbx_price.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0",
+        )
+        self.wholesale_cbx_pct_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.wholesale_cbx_pct,
+            name=self.param.wholesale_cbx_pct.label,  # Updated
+            fixed_start=self.param.wholesale_cbx_pct.bounds[0],
+            fixed_end=self.param.wholesale_cbx_pct.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+        )
+        self.batch_test_cost_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.batch_test_cost,
+            name=self.param.batch_test_cost.label,  # Updated
+            fixed_start=self.param.batch_test_cost.bounds[0],
+            fixed_end=self.param.batch_test_cost.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0",
+        )
+        self.fixed_overhead_per_week_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.fixed_overhead_per_week,
+            name=self.param.fixed_overhead_per_week.label,  # Updated
+            fixed_start=self.param.fixed_overhead_per_week.bounds[0],
+            fixed_end=self.param.fixed_overhead_per_week.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0",
+        )
+        self.workers_per_shift_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.workers_per_shift,
+            name=self.param.workers_per_shift.label,  # Updated
+            fixed_start=self.param.workers_per_shift.bounds[0],
+            fixed_end=self.param.workers_per_shift.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0",
+        )
+        self.worker_hourly_rate_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.worker_hourly_rate,
+            name=self.param.worker_hourly_rate.label,  # Updated
+            fixed_start=self.param.worker_hourly_rate.bounds[0],
+            fixed_end=self.param.worker_hourly_rate.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+        )
+        self.managers_per_shift_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.managers_per_shift,
+            name=self.param.managers_per_shift.label,  # Updated
+            fixed_start=self.param.managers_per_shift.bounds[0],
+            fixed_end=self.param.managers_per_shift.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0",
+        )
+        self.manager_hourly_rate_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.manager_hourly_rate,
+            name=self.param.manager_hourly_rate.label,  # Updated
+            fixed_start=self.param.worker_hourly_rate.default,  # Keeping original logic as per file
+            fixed_end=self.param.manager_hourly_rate.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+        )
+
+        # Updated based on previous request
+        self.labour_hours_per_shift_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.labour_hours_per_shift,
+            name=self.param.labour_hours_per_shift.label,  # Updated
+            fixed_start=self.param.labour_hours_per_shift.bounds[
+                0
+            ],  # Changed in previous request
+            fixed_end=self.param.labour_hours_per_shift.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0.00",
+        )
+
+        # Updated based on previous request
+        self.processing_hours_per_shift_slider = (
+            pn.widgets.EditableFloatSlider.from_param(
+                self.param.processing_hours_per_shift,
+                name=self.param.processing_hours_per_shift.label,  # Updated
+                fixed_start=self.param.processing_hours_per_shift.bounds[0],
+                fixed_end=self.labour_hours_per_shift,  # Changed in previous request
+                design=slider_design,
+                styles=slider_style,
+                stylesheets=slider_stylesheet,
+                format="0.00",
+            )
+        )
+
+        self.shifts_per_day_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.shifts_per_day,
+            name=self.param.shifts_per_day.label,  # Updated
+            fixed_start=self.param.shifts_per_day.bounds[0],
+            fixed_end=self.param.shifts_per_day.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0",
+        )
+        self.shifts_per_week_slider = pn.widgets.EditableFloatSlider.from_param(
+            self.param.shifts_per_week,
+            name=self.param.shifts_per_week.label,  # Updated
+            fixed_start=self.param.shifts_per_week.bounds[0],
+            fixed_end=self.param.shifts_per_week.bounds[1],
+            design=slider_design,
+            styles=slider_style,
+            stylesheets=slider_stylesheet,
+            format="0",
+        )
+
+    @param.depends(
+        "kg_processed_per_hour",
+        "finished_product_yield_pct",
+        "kwh_rate",
+        "water_cost_per_1000l",
+        "consumables_per_kg_bio_rate",
+        "kwh_per_kg_bio",
+        "water_liters_consumed_per_kg_bio",
+        "consumables_per_kg_output",
+        "bio_cbx_pct",
+        "bio_cost",
+        "wholesale_cbx_price",
+        "wholesale_cbx_pct",
+        "batch_test_cost",
+        "fixed_overhead_per_week",
+        "workers_per_shift",
+        "worker_hourly_rate",
+        "managers_per_shift",
+        "manager_hourly_rate",
+        "labour_hours_per_shift",
+        "processing_hours_per_shift",
+        "shifts_per_day",
+        "shifts_per_week",
+        watch=True,
+    )
+    def _update_calculations(self, *events):
+        self.kg_processed_per_shift = (
+            self.processing_hours_per_shift * self.kg_processed_per_hour
+        )
+        if self.shifts_per_week == 0:
+            self.shifts_per_week = 1
+
+        self._calc_saleable_kg()
+        self._calc_biomass_cost()
+        self._calc_cogs()
+        self._calc_gross_revenue()
+        self._calc_net_revenue()
+
+        self.operating_profit_pct = (
+            (self.net_rev_per_kg_bio / self.gross_rev_per_kg_bio)
+            if self.gross_rev_per_kg_bio
+            else 0.0
+        )
+        self.resin_spread_pct = (
+            ((self.gross_rev_per_kg_bio - self.bio_cost) / self.bio_cost)
+            if self.bio_cost
+            else 0.0
+        )
+
+        self._update_tables_data()
+
+    @param.depends("labour_hours_per_shift", watch=True)
+    def _update_processing_hours_slider_constraints(self):
+        new_max_processing_hours = self.labour_hours_per_shift
+
+        # Get the current lower bound of the processing_hours_per_shift parameter
+        current_min_processing_hours = self.param.processing_hours_per_shift.bounds[0]
+
+        # Update the bounds of the underlying param.Number object for processing_hours_per_shift
+        # This allows the parameter to accept values up to the new maximum
+        self.param.processing_hours_per_shift.bounds = (
+            current_min_processing_hours,
+            new_max_processing_hours,
+        )
+
+        # Ensure the slider widget has been created before trying to access it
+        if hasattr(self, "processing_hours_per_shift_slider"):
+            # Update the 'end' property of the slider widget
+            self.processing_hours_per_shift_slider.end = new_max_processing_hours
+
+            # If the current value of processing_hours_per_shift is now greater than
+            # the new maximum, adjust it to be the new maximum.
+            if self.processing_hours_per_shift > new_max_processing_hours:
+                self.processing_hours_per_shift = new_max_processing_hours
+
+    def _calc_cogs(self):
+        worker_cost = self.workers_per_shift * self.worker_hourly_rate
+        manager_cost = self.managers_per_shift * self.manager_hourly_rate
+        self.labour_cost_per_shift = (
+            worker_cost + manager_cost
+        ) * self.labour_hours_per_shift
+
+        power_cost_per_kg = self.kwh_rate * self.kwh_per_kg_bio
+        water_cost_per_kg = (
+            self.water_cost_per_1000l / 1000.0
+        ) * self.water_liters_consumed_per_kg_bio
+        total_variable_consumable_cost_per_kg = (
+            self.consumables_per_kg_bio_rate + power_cost_per_kg + water_cost_per_kg
+        )
+        self.variable_cost_per_shift = (
+            total_variable_consumable_cost_per_kg * self.kg_processed_per_shift
+        )
+
+        self.overhead_cost_per_shift = (
+            self.fixed_overhead_per_week / self.shifts_per_week
+            if self.shifts_per_week > 0
+            else 0.0
+        )
+
+        shift_cogs_before_output_specific = (
+            self.labour_cost_per_shift
+            + self.variable_cost_per_shift
+            + self.overhead_cost_per_shift
+        )
+        shift_output_specific_cogs = (
+            self.consumables_per_kg_output * self.saleable_kg_per_shift
+        )
+
+        self.internal_cogs_per_shift = (
+            shift_cogs_before_output_specific + shift_output_specific_cogs
+        )
+        self.internal_cogs_per_kg_bio = (
+            self.internal_cogs_per_shift / self.kg_processed_per_shift
+            if self.kg_processed_per_shift > 0
+            else 0.0
+        )
+        self.internal_cogs_per_day = self.internal_cogs_per_shift * self.shifts_per_day
+        self.internal_cogs_per_week = (
+            self.internal_cogs_per_shift * self.shifts_per_week
+        )
+        self.internal_cogs_per_kg_output = (
+            (self.internal_cogs_per_kg_bio * self.biomass_kg_per_saleable_kg)
+            if self.biomass_kg_per_saleable_kg != 0
+            else 0.0
+        )
+
+    def _calc_gross_revenue(self):
+        self.gross_rev_per_kg_bio = (
+            self.saleable_kg_per_kg_bio * self.wholesale_cbx_price
+        )
+        self.gross_rev_per_shift = (
+            self.gross_rev_per_kg_bio * self.kg_processed_per_shift
+        )
+        self.gross_rev_per_day = self.gross_rev_per_shift * self.shifts_per_day
+        self.gross_rev_per_week = self.gross_rev_per_shift * self.shifts_per_week
+
+    def _calc_net_revenue(self):
+        self.net_rev_per_kg_bio = (
+            self.gross_rev_per_kg_bio - self.internal_cogs_per_kg_bio - self.bio_cost
+        )
+        self.net_rev_per_shift = self.net_rev_per_kg_bio * self.kg_processed_per_shift
+        self.net_rev_per_day = self.net_rev_per_shift * self.shifts_per_day
+        self.net_rev_per_week = self.net_rev_per_shift * self.shifts_per_week
+        self.net_rev_per_kg_output = (
+            (self.biomass_kg_per_saleable_kg * self.net_rev_per_kg_bio)
+            if self.biomass_kg_per_saleable_kg != 0
+            else 0.0
+        )
+
+    def _calc_biomass_cost(self):
+        self.biomass_cost_per_shift = self.kg_processed_per_shift * self.bio_cost
+        self.biomass_cost_per_day = self.biomass_cost_per_shift * self.shifts_per_day
+        self.biomass_cost_per_week = self.biomass_cost_per_shift * self.shifts_per_week
+
+    def _calc_saleable_kg(self):
+        if self.wholesale_cbx_pct == 0:
+            self.saleable_kg_per_kg_bio = 0.0
+        else:
+            self.saleable_kg_per_kg_bio = (
+                (self.bio_cbx_pct / 100.0)
+                * (self.finished_product_yield_pct / 100.0)
+                / (self.wholesale_cbx_pct / 100.0)
+            )
+        self.saleable_kg_per_shift = (
+            self.saleable_kg_per_kg_bio * self.kg_processed_per_shift
+        )
+        self.saleable_kg_per_day = self.saleable_kg_per_shift * self.shifts_per_day
+        self.saleable_kg_per_week = self.saleable_kg_per_shift * self.shifts_per_week
+        self.biomass_kg_per_saleable_kg = (
+            1 / self.saleable_kg_per_kg_bio if self.saleable_kg_per_kg_bio > 0 else 0.0
+        )
+        self.biomass_cost_per_kg_output = (
+            self.biomass_kg_per_saleable_kg * self.bio_cost
+        )
+
+    def _update_tables_data(self):
+        money_data_dict = {
+            " ": ["Biomass cost", "Processing cost", "Gross Revenue", "Net Revenue"],
+            "Per Kilogram of Biomass": [
+                self.bio_cost,
+                self.internal_cogs_per_kg_bio,
+                self.gross_rev_per_kg_bio,
+                self.net_rev_per_kg_bio,
+            ],
+            "Per Kilogram of Output": [
+                self.biomass_cost_per_kg_output,
+                self.internal_cogs_per_kg_output,
+                self.wholesale_cbx_price,
+                self.net_rev_per_kg_output,
+            ],
+            "Per Shift": [
+                self.biomass_cost_per_shift,
+                self.internal_cogs_per_shift,
+                self.gross_rev_per_shift,
+                self.net_rev_per_shift,
+            ],
+            "Per Day": [
+                self.biomass_cost_per_day,
+                self.internal_cogs_per_day,
+                self.gross_rev_per_day,
+                self.net_rev_per_day,
+            ],
+            "Per Week": [
+                self.biomass_cost_per_week,
+                self.internal_cogs_per_week,
+                self.gross_rev_per_week,
+                self.net_rev_per_week,
+            ],
+        }
+        self.money_data_df = pd.DataFrame(money_data_dict)
+        if hasattr(self, "money_table"):
+            self.money_table.value = self.money_data_df
+
+        profit_data_dict = {
+            "Metric": ["Operating Profit", "Resin Spread"],
+            "Value": [
+                f"{self.operating_profit_pct * 100.0:.2f}%",
+                f"{self.resin_spread_pct * 100.0:.2f}%",
+            ],
+        }
+        self.profit_data_df = pd.DataFrame(profit_data_dict)
+        if hasattr(self, "profit_table"):
+            self.profit_table.value = self.profit_data_df
+
+        processing_values_formatted = [
+            f"{self.kg_processed_per_shift:,.0f}",
+            f"${self.labour_cost_per_shift:,.2f}",
+            f"${self.variable_cost_per_shift:,.2f}",
+            f"${self.overhead_cost_per_shift:,.2f}",
+        ]
+        processing_data_dict = {
+            "Metric": [
+                "Kilograms Extracted per Shift",
+                "Labour Cost per Shift",
+                "Variable Cost per Shift",
+                "Overhead per Shift",
+            ],
+            "Value": processing_values_formatted,
+        }
+        self.processing_data_df = pd.DataFrame(processing_data_dict)
+        if hasattr(self, "processing_table"):
+            self.processing_table.value = self.processing_data_df
+
+    def _get_money_formatters(self):
+        return {
+            "Per Kilogram of Biomass": get_formatter("$%.02f"),
+            "Per Kilogram of Output": get_formatter("$%.02f"),
+            "Per Shift": get_formatter("$%.02f"),
+            "Per Day": get_formatter("$%.02f"),
+            "Per Week": get_formatter("$%.02f"),
+        }
+
+    def view(self):
+        col1 = pn.Column(
+            pn.pane.Markdown("## Extraction"),
+            pn.Row(
+                self.kg_processed_per_hour_slider,  # Updated
+            ),
+            pn.Row(
+                self.finished_product_yield_pct_slider,  # Updated
+            ),
+            pn.pane.Markdown("## Biomass parameters"),
+            pn.Row(
+                self.bio_cbx_pct_slider,  # Updated
+            ),
+            pn.Row(
+                self.bio_cost_slider,  # Updated
+            ),
+            sizing_mode="stretch_width",
+        )
+        col2 = pn.Column(
+            pn.pane.Markdown("## Consumable rates"),
+            pn.Row(
+                self.kwh_rate_slider,  # Updated
+            ),
+            pn.Row(
+                self.water_cost_per_1000l_slider,  # Updated
+            ),
+            pn.Row(
+                self.consumables_per_kg_bio_rate_slider,  # Updated
+            ),
+            pn.pane.Markdown("## Wholesale details"),
+            pn.Row(
+                self.wholesale_cbx_price_slider,  # Updated
+            ),
+            pn.Row(
+                self.wholesale_cbx_pct_slider,  # Updated
+            ),
+            sizing_mode="stretch_width",
+        )
+        col3 = pn.Column(
+            pn.pane.Markdown("## Variable costs"),
+            pn.Row(
+                self.kwh_per_kg_bio_slider,  # Updated
+            ),
+            pn.Row(
+                self.water_liters_consumed_per_kg_bio_slider,  # Updated
+            ),
+            pn.Row(
+                self.consumables_per_kg_output_slider,  # Updated
+            ),
+            pn.pane.Markdown("## Compliance"),
+            pn.Row(
+                self.batch_test_cost_slider,  # Updated
+            ),
+            pn.pane.Markdown("## Overhead"),
+            pn.Row(
+                self.fixed_overhead_per_week_slider,  # Updated
+            ),
+            sizing_mode="stretch_width",
+        )
+        col4 = pn.Column(
+            pn.pane.Markdown("## Worker Details"),
+            pn.Row(
+                self.workers_per_shift_slider,  # Updated
+            ),
+            pn.Row(
+                self.worker_hourly_rate_slider,  # Updated
+            ),
+            pn.Row(
+                self.managers_per_shift_slider,  # Updated
+            ),
+            pn.Row(
+                self.manager_hourly_rate_slider,  # Updated
+            ),
+            pn.pane.Markdown("## Shift details"),
+            pn.Row(
+                self.labour_hours_per_shift_slider,  # Updated
+            ),
+            pn.Row(
+                self.processing_hours_per_shift_slider,  # Updated
+            ),
+            pn.Row(
+                self.shifts_per_day_slider,  # Updated
+            ),
+            pn.Row(
+                self.shifts_per_week_slider,  # Updated
+            ),
+            sizing_mode="stretch_width",
+        )
+
+        input_grid = pn.GridSpec(sizing_mode="stretch_width", max_width=1800, margin=10)
+        input_grid[0, 0] = col1
+        input_grid[0, 1] = col2
+        input_grid[0, 2] = col3
+        input_grid[0, 3] = col4
+
+        money_table_display = pn.Column(
+            pn.pane.Markdown("### Financial Summary", styles={"text-align": "center"}),
+            self.money_table,
+        )
+
+        profit_table_display = pn.Column(
+            pn.pane.Markdown(
+                "### Profitability Metrics", styles={"text-align": "center"}
+            ),
+            self.profit_table,
+        )
+
+        processing_table_display = pn.Column(
+            pn.pane.Markdown("### Processing Summary", styles={"text-align": "center"}),
+            self.processing_table,
+        )
+
+        tables_layout = pn.Column(
+            money_table_display,
+            pn.Row(
+                processing_table_display,
+                profit_table_display,
+                align="center",
+            ),
+            #sizing_mode="stretch_width",
+            #max_width=1800,
+            margin=10,
+            align="center",
+        )
+
+        profit_weekly = pn.indicators.Number(
+            name="Weekly Profit",
+            value=self.net_rev_per_week,
+            format=f"${self.net_rev_per_week / 1000:.0f} k",
+            default_color="green",
+            align="center",
+        )
+
+        profit_pct = pn.indicators.Number(
+            name="Operating Profit",
+            value=self.operating_profit_pct,
+            format=f"{self.operating_profit_pct * 100.0:.2f}%",
+            default_color="green",
+            align="center",
+        )
+
+        indicator_layout = pn.Column(profit_pct, profit_weekly, align="center")
+
+        table_grid = pn.GridSpec(sizing_mode="stretch_width", max_width=1800, margin=10)
+        table_grid[:, 0:2] = tables_layout
+        table_grid[:, 2] = indicator_layout
+
+        main_layout = pn.Column(
+            input_grid,
+            pn.layout.Divider(margin=(10, 0)),
+            table_grid,
+            styles={"margin": "0px 10px"},
+        )
+
+        return main_layout
+
+
+estimator_app = CannabinoidEstimator()
+# To run in a Panel server:
+# pn.config.raw_css = custom_themes.get_base_css(custom_themes.DARK_THEME_VARS)
+estimator_app.view().servable(title="CBx Revenue Estimator")
+
+# Instantiate the template with widgets displayed in the sidebar
+# template = pn.template.FastListTemplate(
+#     title="CBx Revenue Estimator (FastList Panel)",
+#     #theme = custom_themes.DarkTheme,
+#     #sidebar=[freq, phase],
+# )
+
+# template.main.append(estimator_app.view())
+# template.servable()
+
+if __name__ == "__main__":
+    pn.serve(
+        estimator_app.view(),
+        title="CBx Revenue Estimator (Panel)",
+        show=True,
+        port=5007,
+    )