FEED Validator

for Atom and RSS and KML

Congratulations!

This is a valid RSS feed.

Recommendations

This feed is valid, but interoperability with the widest range of feed readers could be improved by implementing the following recommendations.

line 24, column 77: Image not in required format [help]

	<url>https://fsiblog.io/wp-content/uploads/2024/09/FSIBLOG-Logo-150x150.web ...
                                                                             ^

line 30, column 0: Use of unknown namespace: com-wordpress:feed-additions:1 (11 occurrences) [help]
```
<site xmlns="com-wordpress:feed-additions:1">241886150</site>	<item>
```

Source: https://fsiblog.io/feed/

<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:wfw="http://wellformedweb.org/CommentAPI/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:atom="http://www.w3.org/2005/Atom"
xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
xmlns:media="http://search.yahoo.com/mrss/" >
<channel>
<title>FSIBLOG</title>
<atom:link href="https://fsiblog.io/feed/" rel="self" type="application/rss+xml" />
<link>https://fsiblog.io</link>
<description>Future Stack Innovations Blog</description>
<lastBuildDate>Tue, 29 Apr 2025 05:26:28 +0000</lastBuildDate>
<language>en-US</language>
<sy:updatePeriod>
hourly </sy:updatePeriod>
<sy:updateFrequency>
1 </sy:updateFrequency>
<generator>https://wordpress.org/?v=6.7.2</generator>
<image>
<url>https://fsiblog.io/wp-content/uploads/2024/09/FSIBLOG-Logo-150x150.webp</url>
<title>FSIBLOG</title>
<link>https://fsiblog.io</link>
<width>32</width>
<height>32</height>
</image>
<site xmlns="com-wordpress:feed-additions:1">241886150</site> <item>
<title>How to Build a Tiny Python App That Reminds Me to Take Breaks</title>
<link>https://fsiblog.io/how-to-build-a-tiny-python-app-that-reminds-me-to-take-breaks/</link>
<comments>https://fsiblog.io/how-to-build-a-tiny-python-app-that-reminds-me-to-take-breaks/#respond</comments>
<dc:creator><![CDATA[Daniyal Ahmed]]></dc:creator>
<pubDate>Tue, 29 Apr 2025 05:26:26 +0000</pubDate>
<category><![CDATA[Python]]></category>
<category><![CDATA[Build a Tiny Python App That Reminds Me to Take Breaks]]></category>
<category><![CDATA[How to Build a Tiny Python App That Reminds Me]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2188</guid>
<description><![CDATA[Spending all day at a screen is brutal on the eyes, the back, and the brain. So I decided to whip up a desktop toast that nudges me every hour to stand, stretch, sip water anything except keep slouch-coding. What started as seven lines of Python turned into a surprisingly fun mini-project that now lives […]]]></description>
<content:encoded><![CDATA[ Spending all day at a screen is brutal on the eyes, the back, and the brain. So I decided to whip up a desktop toast that nudges me every hour to stand, stretch, sip water anything except keep slouch-coding. What started as seven lines of Python turned into a surprisingly fun mini-project that now lives in my toolbox.<ul class="wp-block-list"><li>“I only intended to write one quick script… then I fell down the rabbit-hole.”</li></ul>Below is the journey, the full code, and a handful of ideas you can riff on.<h2 class="wp-block-heading">Define Code</h2><pre class="wp-block-preformatted"><code>from plyer import notification if __name__ == "__main__": while True: notification.notify( title="ALERT!!!", message="Take a break! It has been an hour!", ) time.sleep(3600) </code></pre>Install the only dependency:<pre class="wp-block-preformatted"><code>pip install plyer</code></pre>and run:<pre class="wp-block-preformatted"><code>python break.py</code></pre>Your OS pops up a toast every 60 minutes. Job done kind of.<h2 class="wp-block-heading">What each line is doing</h2><figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>#</th><th>Code</th><th>Why it matters</th></tr></thead><tbody><tr><td>1</td><td><code>import time</code></td><td>Gives me <code>time.sleep()</code> so the script can nap between alerts.</td></tr><tr><td>2</td><td><code>from plyer import notification</code></td><td>plyer wraps each platform’s native “toast” API—works on Windows, macOS, Linux.</td></tr><tr><td>4</td><td><code>if __name__ == "__main__":</code></td><td>Runs the loop only when I execute the file directly, not when I import it elsewhere.</td></tr><tr><td>5</td><td><code>while True:</code></td><td>Endless loop until I hit Ctrl +C.</td></tr><tr><td>6-8</td><td><code>notification.notify(...)</code></td><td>Fires the visual reminder.</td></tr><tr><td>10</td><td><code>time.sleep(3600)</code></td><td>Waits one hour (3 600 s) before the next pass.</td></tr></tbody></table></figure>Great for a proof-of-concept; painful in real life. I wanted:<ul class="wp-block-list"><li>Flexible intervals (<code>--interval 20m</code>, <code>2h</code>, <code>90s</code>…)</li>
<li>Custom titles/messages</li>
<li>A finite number of pings (helpful in pomodoro workflows)</li>
<li>Random healthy-habit tips if I’m lazy</li>
<li>A gentle console beep (toast may be hidden)</li>
<li>Tidy logging with timestamps</li>
<li>Graceful shutdown no ugly tracebacks when I quit</li></ul><h2 class="wp-block-heading">Level-up: the extended script</h2>Below is break_timer.py in full, then read on for usage examples.<pre class="wp-block-preformatted"><code>#!/usr/bin/env python3 """ break_timer.py – flexible desktop break-reminder """ import argparse import datetime as dt import random import sys import time from plyer import notification # ---------- tiny knowledge base ---------- _TIPS = [ "Stand up and stretch your legs 🦵", "Look away from the screen for 20 seconds 👀", "Roll your shoulders a few times 🙆‍♂", "Drink a glass of water 💧", "Take three slow, deep breaths 😮‍💨", ] def parse_interval(text: str) -> int: """Turn '45m', '2h', '30s' into seconds (int).""" units = {'s': 1, 'm': 60, 'h': 3600} if text[-1].isdigit(): # default to minutes return int(text) * 60 value, unit = int(text[:-1]), text[-1].lower() if unit not in units: raise ValueError("Use s, m or h as units.") return value * units[unit] def beep() -> None: """Cross-platform console bell.""" print('\a', end='', flush=True) # ---------- main ---------- def main(): p = argparse.ArgumentParser(description="Desktop break reminder") p.add_argument('-i', '--interval', default='60m', help='Time between reminders (e.g. 20m, 2h, 45s).') p.add_argument('-c', '--count', type=int, default=0, help='Number of reminders then exit (0 = unlimited).') p.add_argument('-t', '--title', default='ALERT!!!', help='Notification title text.') p.add_argument('-m', '--message', help='Notification body; omit → random tip.') args = p.parse_args() wait = parse_interval(args.interval) remaining = args.count print(f"[{dt.datetime.now():%H:%M:%S}] Timer started – every " f"{wait//60 if wait>=60 else wait} " f"{'min' if wait>=60 else 'sec'} " f"({ '∞' if remaining==0 else remaining} alerts). Ctrl-C to quit.") try: while remaining != -1: # -1 means we hit the limit body = args.message or random.choice(_TIPS) notification.notify(title=args.title, message=body, app_name="Break Timer") beep() print(f"[{dt.datetime.now():%H:%M:%S}] Notified: {body}") if remaining > 0: remaining -= 1 if remaining == 0: break time.sleep(wait) except KeyboardInterrupt: print("\nStopped by user. Have a healthy day! 👋") sys.exit(0) if __name__ == "__main__": main() </code></pre><h2 class="wp-block-heading">Running the upgraded version</h2><pre class="wp-block-preformatted"><code>install plyer # one-time python break_timer.py -i 45m # ping every 45 min python break_timer.py -i 20m -c 6 # six pings then exit python break_timer.py -i 90s -t "Hydrate" \ -m "Sip some water 🚰" # custom text </code></pre><h3 class="wp-block-heading">Quick flag reference</h3><figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Flag</th><th>Example</th><th>Purpose</th></tr></thead><tbody><tr><td><code>-i</code>, <code>--interval</code></td><td><code>-i 90s</code></td><td>How often to remind (supports s/m/h suffix).</td></tr><tr><td><code>-c</code>, <code>--count</code></td><td><code>-c 4</code></td><td>Quit after N reminders.</td></tr><tr><td><code>-t</code>, <code>--title</code></td><td><code>-t "Hydrate"</code></td><td>Notification headline.</td></tr><tr><td><code>-m</code>, <code>--message</code></td><td><code>-m "Drink water"</code></td><td>Body text (skip for a random tip).</td></tr></tbody></table></figure><h2 class="wp-block-heading">Stretch goals I’m tinkering with</h2><ol class="wp-block-list"><li>System-tray icon with pause/resume for meetings.</li>
<li>Work-hours window so it only nags 09:00-18:00.</li>
<li>CSV/JSON logging to track how often I actually moved.</li>
<li>Tkinter GUI so colleagues can set it up without CLI knowledge.</li>
<li>GIF micro-exercises—imagine a shoulder-roll animation popping up.</li>
<li>Voice alert via <code>pyttsx3</code> for the perpetually alt-tabbed.</li></ol><h2 class="wp-block-heading">Final thought</h2>Writing this tiny utility reminded me why I love Python: a couple of imports + the right library = instant quality-of-life boost.Feel free to fork, tweak, and ship your own flavour. Just remember: the best code you’ll ever write might be the one that literally tells you to stop coding for a minute.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-build-a-tiny-python-app-that-reminds-me-to-take-breaks/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2188</post-id> </item>
<item>
<title>How I Built a Flexible CAPTCHA Generator & Verifier Using Python</title>
<link>https://fsiblog.io/how-i-built-a-flexible-captcha-generator-verifier-using-python/</link>
<comments>https://fsiblog.io/how-i-built-a-flexible-captcha-generator-verifier-using-python/#respond</comments>
<dc:creator><![CDATA[Daniyal Ahmed]]></dc:creator>
<pubDate>Tue, 29 Apr 2025 05:15:04 +0000</pubDate>
<category><![CDATA[Python]]></category>
<category><![CDATA[Built a Flexible CAPTCHA Generator & Verifier Using Python]]></category>
<category><![CDATA[Flexible CAPTCHA Generator & Verifier Using Python]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2185</guid>
<description><![CDATA[I’ve always enjoyed adding little “mini-projects” to my tool belt especially ones that combine clean code with a bit of visual flair. Recently I needed a dead-simple CAPTCHA for a hobby site, so I reached for the underrated captcha Python library and ended up writing a tiny CLI that now lives in my dotfiles. Deep-dive […]]]></description>
<content:encoded><![CDATA[I’ve always enjoyed adding little “mini-projects” to my tool belt especially ones that combine clean code with a bit of visual flair. Recently I needed a dead-simple CAPTCHA for a hobby site, so I reached for the underrated <code>captcha</code> Python library and ended up writing a tiny CLI that now lives in my dotfiles.<ul class="wp-block-list"><li>Walk through the original 30-line snippet line-by-line so you can see exactly what every import and call does.</li>
<li>Show you my extended, production-ready version: command-line switches, automatic verification, custom fonts/colours/noise, in-memory handling, and batch mode everything I wished the demo had on day one.</li>
<li>Share next-step ideas (FastAPI micro-service, audio CAPTCHAs, adversarial OCR tests) and wrap up with a few lessons learned.</li></ul><h2 class="wp-block-heading">Deep-dive into the “Hello World” CAPTCHA</h2>Before I rewrote anything, I wanted to know where every byte came from. Here’s the tiniest viable script, followed by a table-style breakdown:<pre class="wp-block-preformatted"><code>from PIL import Image import random, string def generate_captcha_text(length: int = 6) -> str: chars = string.ascii_letters + string.digits return ''.join(random.choices(chars, k=length)) def generate_captcha_image(captcha_text: str, image_width: int = 300) -> str: image = ImageCaptcha(width=image_width) file_name = f"{captcha_text}.png" image.write(captcha_text, file_name) return file_name if __name__ == "__main__": text = generate_captcha_text() file_path = generate_captcha_image(text) print(f"Generated CAPTCHA text: {text}") Image.open(file_path).show() </code></pre><figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>#</th><th>Code</th><th>What really happens</th></tr></thead><tbody><tr><td>1</td><td><code>from captcha.image import ImageCaptcha</code></td><td>Pulls in the renderer that bends, warps, and sprinkles noise on text simple OCR dies instantly.</td></tr><tr><td>2</td><td><code>from PIL import Image</code></td><td>Pillow lets me open/preview the PNG that <code>ImageCaptcha.write()</code> just saved.</td></tr><tr><td>3</td><td><code>import random, string</code></td><td>Core helpers: <code>random.choices()</code> (sampling with replacement) and <code>string.ascii_letters + string.digits</code> (62-char pool).</td></tr><tr><td>4-9</td><td><code>generate_captcha_text()</code></td><td>1) Builds the pool. 2) Picks <code>length</code> symbols uniformly. 3) Returns a contiguous string such as <code>A9cV4K</code>.</td></tr><tr><td>11-19</td><td><code>generate_captcha_image()</code></td><td>1) Instantiates the renderer (I can also tweak height/fonts/colours/noise).\ 2) <code>write()</code> rasterises & saves the PNG.</td></tr><tr><td>21-31</td><td><code>__main__</code> guard</td><td>Random text → image → debug print. Finally <code>Image.open().show()</code> asks my OS to preview the file.</td></tr></tbody></table></figure><h3 class="wp-block-heading">Fast tweaks</h3><figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>What I changed</th><th>One-liner</th></tr></thead><tbody><tr><td>8-char puzzle</td><td><code>generate_captcha_text(8)</code></td></tr><tr><td>Custom size/font</td><td><code>ImageCaptcha(width=280, height=90, fonts=['./Roboto-Bold.ttf'])</code></td></tr><tr><td>Black on white, 40 % noise</td><td><code>ImageCaptcha(color='black', background='white', noise_level=0.4)</code></td></tr></tbody></table></figure><h2 class="wp-block-heading">Level-up: the <code>captcha_tool.py</code> CLI</h2>One-offs are fun, but I wanted a Swiss-Army knife:<ul class="wp-block-list"><li>Flags so I can whip up 5 CAPTCHAs in one go (<code>--count 5</code>).</li>
<li>Verification loop when I’m demoing to friends (<code>--verify</code>).</li>
<li>Memory-only mode for server responses no temp files (<code>--nodisk</code>).</li>
<li>House-keeping so PNGs older than n minutes vanish automatically.</li>
<li>Colour / font / noise knobs because brand guidelines are real.</li></ul>Below is the trimmed-down version (full gist at the end). Copy-paste, rename to <code>captcha_tool.py</code>, and you’re off.<pre class="wp-block-preformatted">\<code>captcha_tool.py Generate and optionally verify CAPTCHA challenges from the command line. """ import argparse, io, random, string, sys from datetime import datetime, timedelta from pathlib import Path from captcha.image import ImageCaptcha from PIL import Image # ---------- helpers ---------- # def random_text(length: int) -> str: pool = string.ascii_letters + string.digits return "".join(random.choices(pool, k=length)) def draw_captcha(text: str, width: int = 300, height: int = 100, color: str = "black", background: str = "white", noise: float = 0.4, fonts: list[str] | None = None, to_disk: bool = True) -> tuple[str, bytes | None]: gen = ImageCaptcha(width=width, height=height, fonts=fonts, color=color, background=background, noise_level=noise) if to_disk: name = f"{datetime.utcnow().timestamp()}_{text}.png" gen.write(text, name) return name, None buf = io.BytesIO() gen.write(text, buf) return f"mem://{text}", buf.getvalue() # ---------- CLI entry-point ---------- # def main() -> None: p = argparse.ArgumentParser(description="Quick CAPTCHA generator") p.add_argument("--len", type=int, default=6, help="char length") p.add_argument("--count", type=int, default=1, help="# captchas") p.add_argument("--verify", action="store_true", help="ask user to solve") p.add_argument("--nodisk", action="store_true", help="keep in memory") p.add_argument("--clean-after", type=int, default=15, help="delete PNGs older than X minutes") args = p.parse_args() challenges: list[tuple[str, str]] = [] for _ in range(args.count): ans = random_text(args.len) fname, _ = draw_captcha(ans, to_disk=not args.nodisk) print(f"[+] CAPTCHA ready: {fname}") challenges.append((ans, fname)) if args.verify: for ans, fname in challenges: if not args.nodisk: Image.open(fname).show() guess = input("Text you see → ").strip() print("✅ Correct!\n" if guess == ans else f"❌ Nope (was {ans})\n") if not args.nodisk and args.clean_after > 0: cut = datetime.utcnow() - timedelta(minutes=args.clean_after) for png in Path(".").glob("*.png"): if datetime.utcfromtimestamp(png.stat().st_mtime) < cut: png.unlink(missing_ok=True) if __name__ == "__main__": main() </code></pre><h3 class="wp-block-heading">Quick demos</h3><figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Skill I practise</th><th>Command I run</th></tr></thead><tbody><tr><td>CLI flag parsing</td><td><code>python captcha_tool.py --len 8 --count 5</code></td></tr><tr><td>User validation</td><td><code>python captcha_tool.py --verify</code></td></tr><tr><td>Memory-only flow</td><td><code>python captcha_tool.py --nodisk</code></td></tr><tr><td>Auto cleanup</td><td><code>python captcha_tool.py --clean-after 1</code></td></tr><tr><td>Custom styling</td><td>Edit <code>draw_captcha()</code> and crank noise / fonts</td></tr></tbody></table></figure><h2 class="wp-block-heading">Where I’ll take it next</h2><ul class="wp-block-list"><li>FastAPI endpoint – <code>/captcha/new</code> returns base64 PNG + token, <code>/captcha/verify</code> checks answer and TTL.</li>
<li>Redis store – token → answer → expiry, so I never keep secrets in RAM longer than necessary.</li>
<li>Audio fallback – <code>captcha.audio.AudioCaptcha</code> for accessibility compliance.</li>
<li>Adversarial OCR tests – pipe PNGs into Tesseract, tighten noise until solve-rate < 1 %.</li>
<li>Vue widget – tiny component that fetches fresh images with <code>fetch()</code> and updates view in-place.</li></ul><h2 class="wp-block-heading">Final thought</h2>I went in needing a single throw-away CAPTCHA; I came out with a reusable CLI and a blueprint for a micro-service. The lesson? Even the tiniest scripts are opportunities to practise clean switches, separation of concerns, and automated clean-up. Next time you’re about to toss a “one-liner” into production, pause, add flags, and you might surprise yourself with how far that extra 30 minutes takes you.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-i-built-a-flexible-captcha-generator-verifier-using-python/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2185</post-id> </item>
<item>
<title>How to Fix Application Error in Twilio Voice Call with Django/Python?</title>
<link>https://fsiblog.io/how-to-fix-application-error-in-twilio-voice-call-with-django-python/</link>
<comments>https://fsiblog.io/how-to-fix-application-error-in-twilio-voice-call-with-django-python/#respond</comments>
<dc:creator><![CDATA[Daniyal Ahmed]]></dc:creator>
<pubDate>Mon, 28 Apr 2025 06:29:23 +0000</pubDate>
<category><![CDATA[Python]]></category>
<category><![CDATA[Application Error in Twilio Voice Call with Django/Python?]]></category>
<category><![CDATA[Fix Application Error in Twilio Voice Call with Django/Python?]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2182</guid>
<description><![CDATA[I’m excited to share my recent experience integrating Twilio Voice into a Django application to deliver one-time passwords (OTPs) via phone calls. When I first set up my /outbound/ endpoint, it rendered valid TwiML XML perfectly in the browser. However, triggering a call through Twilio resulted in a frustrating “Sorry, an application error has occurred” […]]]></description>
<content:encoded><![CDATA[I’m excited to share my recent experience integrating Twilio Voice into a Django application to deliver one-time passwords (OTPs) via phone calls. When I first set up my <code>/outbound/</code> endpoint, it rendered valid TwiML XML perfectly in the browser. However, triggering a call through Twilio resulted in a frustrating “Sorry, an application error has occurred” message.<ol class="wp-block-list"><li>The original code that led to the error</li>
<li>My diagnosis of what went wrong</li>
<li>A corrected implementation that works</li>
<li>Extra “practice” enhancements to deepen the integration</li></ol><h2 class="wp-block-heading">Error Code</h2>Here’s the initial view code I wrote in views.py: <details> <summary>views.py (original)</summary><pre class="wp-block-preformatted"><code>django.conf import settings from django.http import HttpResponse from twilio.rest import TwilioRestClient # legacy import import twilio.twiml def voice_call(otp, mobile_no): client = TwilioRestClient(settings.ACCOUNT_SID, settings.AUTH_TOKEN) client.calls.create( from_=settings.OTP_FROM_NUMBER, to=mobile_no, url='http://localhost:8000/outbound/', method='POST' ) def outbound(self): response = twiml.Response() response.say("Thank you for contacting our department", voice='alice') return HttpResponse(response, content_type="application/xml") </code></pre></details>This looked straightforward: trigger a call to <code>mobile_no</code> and have Twilio POST to my <code>/outbound/</code> endpoint, which returns TwiML telling it to speak a message.<h2 class="wp-block-heading">Define “Application Error”</h2>After some investigation, I identified three root issues:<ol class="wp-block-list"><li>Incorrect view signature<ul class="wp-block-list"><li>Django views must accept a <code>request</code> object as their first parameter. Defining <code>outbound(self)</code> meant Django couldn’t match the signature, resulting in an internal server error (HTTP 500).</li></ul></li>
<li>Legacy Twilio client import<ul class="wp-block-list"><li>Using <code>TwilioRestClient</code> is deprecated. The modern <code>twilio.rest.Client</code> class is more reliable and up to date.</li></ul></li>
<li>Localhost not publicly accessible<ul class="wp-block-list"><li>When Twilio’s servers attempt to fetch your TwiML at <code>http://localhost:8000/outbound/</code>, they cannot reach your local machine. Twilio requires a publicly accessible URL (for example, via an ngrok tunnel or your own domain).</li></ul></li></ol><h2 class="wp-block-heading">Correct Implementation</h2>Here’s the revised views.py that addresses all three problems: <details> <summary>views.py (fixed)</summary><pre class="wp-block-preformatted"><code>django.conf import settings from django.http import HttpResponse from django.views.decorators.csrf import csrf_exempt from twilio.rest import Client from twilio.twiml.voice_response import VoiceResponse def voice_call(request, otp, mobile_no): """ Initiates a Twilio voice call to deliver an OTP. """ client = Client(settings.ACCOUNT_SID, settings.AUTH_TOKEN) # Use a publicly accessible URL (e.g., via ngrok) twiml_url = settings.TWILIO_TWIML_URL # e.g. 'https://abcd1234.ngrok.io/outbound/' client.calls.create( from_=settings.OTP_FROM_NUMBER, to=mobile_no, url=twiml_url, method='POST' ) return HttpResponse("Call initiated", status=202) @csrf_exempt def outbound(request): """ Responds to Twilio’s webhook with TwiML instructions. """ resp = VoiceResponse() resp.say("Thank you for contacting our department. Your OTP is:", voice='alice') # Optionally inject the OTP dynamically via query string or storage otp = request.GET.get('otp', 'unknown') resp.say(otp, voice='alice') return HttpResponse(str(resp), content_type="application/xml") </code></pre></details>Key fixes explained:<ul class="wp-block-list"><li><code>outbound(request)</code>: Replaced <code>self</code> with <code>request</code> so Django can invoke it properly.</li>
<li><code>Client</code>: Swapped out the deprecated <code>TwilioRestClient</code> for the modern <code>Client</code> class.</li>
<li><code>@csrf_exempt</code>: Added to allow Twilio’s POST without a CSRF token.</li>
<li>Public URL: Set <code>TWILIO_TWIML_URL</code> in settings (for example, an ngrok tunnel) so Twilio can reach your TwiML.</li></ul><h2 class="wp-block-heading">Additional “Practice” Functionality</h2>Once you have the basics working, you can supercharge your integration. Here are a few ideas to practice:<h3 class="wp-block-heading">Error Handling & Logging</h3><pre class="wp-block-preformatted"><code> client.calls.create(…) except Exception as e: logger.error(f"Twilio call failed: {e}") return HttpResponse("Error initiating call", status=500) </code></pre><h3 class="wp-block-heading">Gather User Input</h3>Let callers press a digit and handle their response:<pre class="wp-block-preformatted"><code>twilio.twiml.voice_response import Gather @csrf_exempt def outbound(request): resp = VoiceResponse() gather = Gather(num_digits=1, action='/gather-response/', method='POST') gather.say("Press 1 to confirm receipt of the OTP.", voice='alice') resp.append(gather) resp.redirect('/outbound/') # repeat if no input return HttpResponse(str(resp), content_type="application/xml") </code></pre><h3 class="wp-block-heading">Play an Audio File</h3><pre class="wp-block-preformatted"><code>.play(url="https://example.com/hold-music.mp3")</code></pre><h3 class="wp-block-heading">Record the Call</h3>Tell Twilio to record the conversation:<pre class="wp-block-preformatted"><code>.calls.create(…, record=True)</code></pre><h3 class="wp-block-heading">Dynamic TwiML Generation</h3>Store the OTP in your database or session, then look it up in <code>outbound()</code> instead of passing it in the URL.<h2 class="wp-block-heading">Final Thoughts</h2>By correcting my view signature, updating to the modern Twilio Python client, and exposing a public TwiML URL, I eliminated the mysterious “application error.” From here, you can layer on advanced TwiML features,user input, recordings, audio playback, and more to build an interactive voice experience.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-fix-application-error-in-twilio-voice-call-with-django-python/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<enclosure url="https://example.com/hold-music.mp3" length="1256" type="audio/mpeg" />
<post-id xmlns="com-wordpress:feed-additions:1">2182</post-id> </item>
<item>
<title>How to Fix Python Application Giving Error Deployed Through Docker</title>
<link>https://fsiblog.io/how-to-fix-python-application-giving-error-deployed-through-docker/</link>
<comments>https://fsiblog.io/how-to-fix-python-application-giving-error-deployed-through-docker/#respond</comments>
<dc:creator><![CDATA[Daniyal Ahmed]]></dc:creator>
<pubDate>Mon, 28 Apr 2025 06:09:18 +0000</pubDate>
<category><![CDATA[Python]]></category>
<category><![CDATA[Fix Python Application Giving Error Deployed Through Docker]]></category>
<category><![CDATA[Python Application Giving Error Deployed Through Docker]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2178</guid>
<description><![CDATA[I’m excited to share a little troubleshooting journey I recently went through while deploying a Python web application inside Docker. If you’ve ever felt confident that “Docker makes everything just work” only to be tripped up by a bizarre bind error you’re in good company. Dockerfile & Application Code I started with the most stripped-down […]]]></description>
<content:encoded><![CDATA[I’m excited to share a little troubleshooting journey I recently went through while deploying a Python web application inside Docker. If you’ve ever felt confident that “Docker makes everything just work” only to be tripped up by a bizarre bind error you’re in good company.<ol class="wp-block-list"><li>The minimal Dockerfile and <code>main.py</code> that reproduce the problem.</li>
<li>A deep dive into the error itself and why it happens.</li>
<li>The simple fix that gets your containerized Sanic server back online.</li>
<li>A few “practice” enhancements health checks, environment-driven configuration, and basic logging to turn this demo into a sturdier template you can reuse.</li></ol><h2 class="wp-block-heading">Dockerfile & Application Code</h2>I started with the most stripped-down setup I could imagine. <details> <summary>Dockerfile</summary><pre class="wp-block-preformatted"><code>python:3.8 WORKDIR /usr/src/app # Install dependencies COPY requirements.txt ./ RUN pip install --no-cache-dir -r requirements.txt # Copy application code COPY . . EXPOSE 8000 # By default, this invokes Sanic's CLI, # which binds to ::1 (IPv6 localhost) unless overridden. CMD ["python3", "apps/main.py", "start", "--config", "config.yml"] </code></pre></details> <details> <summary>apps/main.py</summary><pre class="wp-block-preformatted"><code># apps/main.py from sanic import Sanic from sanic.response import json app = Sanic("DemoApp") @app.route("/") async def home(request): return json({"message": "Hello from inside Docker!"}) if __name__ == "__main__": # Sanic.create().run() without args binds to IPv6 localhost (::1) by default. Sanic.create(app).run( host="::1", port=8000, debug=True, autoreload=True, ) </code></pre><h3 class="wp-block-heading">Error Code</h3>When I built and ran this container, I was expecting to see my “Hello from inside Docker!” message. Instead, it crashed immediately with:<pre class="wp-block-preformatted"><code>: [Errno 99] error while attempting to bind on address ('::1', 8000, 0, 0): cannot assign requested address [INFO] Server Stopped</code></pre><h2 class="wp-block-heading">Under the Hood: What’s Really Going On</h2>At first glance, “Errno 99” might feel impenetrable, but here’s the core of the issue:<ul class="wp-block-list"><li>Sanic’s default host (when you don’t explicitly pass <code>--host</code> on the CLI) is <code>::1</code> the IPv6 loopback address.</li>
<li>Docker containers, out of the box, don’t always configure an IPv6 loopback interface. Only the IPv4 loopback (<code>127.0.0.1</code>) is guaranteed.</li>
<li>As a result, when Sanic calls <code>bind("::1", 8000)</code>, the kernel says, “I have no idea what <code>::1</code> is here,” and refuses to create the socket.</li></ul>Because the server never binds successfully, the container’s main process exits and Docker stops the container.<h2 class="wp-block-heading">The Fix: Bind to <code>0.0.0.0</code></h2>The solution is straightforward: tell Sanic to listen on IPv4’s “all interfaces” address <code>0.0.0.0</code>. This ensures it will bind to the container’s network interface that’s mapped to the host.<h3 class="wp-block-heading">Update <code>main.py</code> Directly</h3><pre class="wp-block-preformatted"><code>- Sanic.create(app).run( - host="::1", + Sanic.create(app).run( + host="0.0.0.0", # bind to all IPv4 interfaces port=8000, debug=True, autoreload=True, )</code></pre><h3 class="wp-block-heading">Override via the Docker CMD</h3>Alternatively, you can leave your code untouched and pass the bind flags in the Dockerfile:<pre class="wp-block-preformatted"><code>-CMD ["python3", "apps/main.py", "start", "--config", "config.yml"] +CMD [ + "python3", "apps/main.py", "start", + "--host", "0.0.0.0", + "--port", "8000", + "--config", "config.yml" +] </code></pre>Then rebuild and run:<pre class="wp-block-preformatted"><code>build -t demo-app . docker run -p 8000:8000 demo-app </code></pre>You should now see your Sanic server come up cleanly, and you’ll be able to <code>curl http://localhost:8000/</code> to verify the JSON response.<h2 class="wp-block-heading">Practice Enhancements</h2>Once the basic binding issue is solved, I like to add a few small improvements to turn this into a more reusable boilerplate.<h3 class="wp-block-heading">Environment Driven Configuration</h3>Hard coding host, port, and debug flags can be inflexible. Instead, read them from environment variables:<pre class="wp-block-preformatted"><code># apps/main.py import os from sanic import Sanic from sanic.response import json app = Sanic("DemoApp") @app.route("/") async def home(request): return json({"message": "Hello from inside Docker!"}) @app.route("/health") async def health(request): return json({"status": "OK"}) if __name__ == "__main__": host = os.getenv("APP_HOST", "0.0.0.0") port = int(os.getenv("APP_PORT", 8000)) debug = os.getenv("SANIC_DEBUG", "false").lower() == "true" Sanic.create(app).run( host=host, port=port, debug=debug, autoreload=debug, ) </code></pre>And in the Dockerfile:<pre class="wp-block-preformatted"><code>APP_HOST=0.0.0.0 ENV APP_PORT=8000 ENV SANIC_DEBUG=true CMD ["python3", "apps/main.py", "start"] </code></pre>Now you can tweak behavior at deploy time without rebuilding your image.<h3 class="wp-block-heading">Health-Check Endpoint</h3>I added a <code>GET /health</code> route so that Docker or Kubernetes can periodically poll it:<pre class="wp-block-preformatted"><code>@app.route("/health") async def health(request): return json({"status": "OK"}) </code></pre>This helps you wire in readiness and liveness probes in orchestrators.<h3 class="wp-block-heading">Basic Logging</h3>Sanic includes a built-in logger. A quick setup lets you log inside your routes:<pre class="wp-block-preformatted"><code>logging log = logging.getLogger("sanic.root") log.setLevel(logging.INFO) @app.route("/items/<item_id>") async def get_item(request, item_id): log.info(f"Fetching item {item_id}") # … pretend we fetch from a database … return json({"item_id": item_id}) </code></pre>With logs going to <code>stdout</code>, you can aggregate and inspect them in production.<h2 class="wp-block-heading">Final Thought</h2>I’m continually reminded that containerizing an application can surface unexpected assumptions like default IPv6 binding that never come up in local development. By explicitly binding to <code>0.0.0.0</code>, introducing environment-driven configuration, health-check endpoints, and structured logging, I’ve turned a minimal repro into a flexible starting point you can drop into almost any Python-in-Docker project.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-fix-python-application-giving-error-deployed-through-docker/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2178</post-id> </item>
<item>
<title>How to Solve Error While Installing Ruby Using RVM</title>
<link>https://fsiblog.io/how-to-solve-error-while-installing-ruby-using-rvm/</link>
<comments>https://fsiblog.io/how-to-solve-error-while-installing-ruby-using-rvm/#respond</comments>
<dc:creator><![CDATA[Shaheen Ullah]]></dc:creator>
<pubDate>Sat, 26 Apr 2025 06:57:08 +0000</pubDate>
<category><![CDATA[Ruby]]></category>
<category><![CDATA[Error While Installing Ruby Using RVM]]></category>
<category><![CDATA[Solve Error While Installing Ruby Using RVM]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2175</guid>
<description><![CDATA[I’ve been down the rabbit hole of Ruby installations more times than I care to admit. When I first tried to install Ruby 1.9.3 via RVM on Ubuntu, I hit this brick wall: $ rvm install 1.9.3Searching for binary rubies, this might take some time.Checking requirements for ubuntu.Installing requirements for ubuntu.Updating system..................................................................................................Error running 'requirements_debian_update_system ruby-1.9.3-p448',please […]]]></description>
<content:encoded><![CDATA[I’ve been down the rabbit hole of Ruby installations more times than I care to admit. When I first tried to install Ruby 1.9.3 via RVM on Ubuntu, I hit this brick wall:<pre class="wp-block-preformatted"><code>$ rvm install 1.9.3 Searching for binary rubies, this might take some time. Checking requirements for ubuntu. Installing requirements for ubuntu. Updating system.................................................................................................. Error running 'requirements_debian_update_system ruby-1.9.3-p448', please read /home/troy/.rvm/log/1379872584_ruby-1.9.3-p448/update_system.log Requirements installation failed with status: 100. </code></pre>I know that staring at “status: 100” in your terminal can feel like a dead end. I’ll walk you through how I turned that failure into a reproducible, robust installation script complete with error handling, clear logs, and extra practice steps so you can level up your Bash and RVM skills.<h2 class="wp-block-heading">Why Automate Ruby Installation?</h2>Manually typing commands each time is error-prone. A script lets me:<ul class="wp-block-list"><li>Capture errors immediately and log details.</li>
<li>Retry flaky operations without starting over.</li>
<li>Share a reproducible recipe across projects and teammates.</li></ul>Ready? Let’s dive in.<h3 class="wp-block-heading">The Installation Script</h3>Create a file <code>install_ruby.sh</code> in your home directory, then make it executable:<pre class="wp-block-preformatted"><code>chmod +x ~/install_ruby.sh </code></pre>Paste this content into it:<pre class="wp-block-preformatted"><code>#!/usr/bin/env bash # install_ruby.sh # A simple wrapper to install Ruby via RVM with error detection RUBY_VERSION="1.9.3" LOGFILE="$HOME/rvm_install_$(date +%Y%m%d_%H%M%S).log" echo "Starting Ruby $RUBY_VERSION installation at $(date)" | tee "$LOGFILE" # 1. Update and install system requirements echo "Step 1: Installing prerequisites…" | tee -a "$LOGFILE" if sudo apt-get update && \ sudo apt-get install -y curl gnupg build-essential \ libssl-dev libreadline-dev zlib1g-dev; then echo "✔ Prerequisites installed" | tee -a "$LOGFILE" else echo "✖ Failed to install prerequisites" | tee -a "$LOGFILE" exit 1 fi # 2. Import RVM GPG keys echo "Step 2: Importing RVM GPG keys…" | tee -a "$LOGFILE" command -v gpg >/dev/null || sudo apt-get install -y gnupg2 gpg --keyserver hkp://pool.sks-keyservers.net --recv-keys \ 409B6B1796C275462A1703113804BB82D39DC0E3 \ 7D2BAF1CF37B13E2069D6956105BD0E739499BDB \ &>> "$LOGFILE" || { echo "✖ GPG import failed" | tee -a "$LOGFILE"; exit 2; } # 3. Install or reload RVM echo "Step 3: Installing/reloading RVM…" | tee -a "$LOGFILE" if ! command -v rvm >/dev/null; then \curl -sSL https://get.rvm.io | bash -s stable &>> "$LOGFILE" source "$HOME/.rvm/scripts/rvm" else echo "✔ RVM already installed" | tee -a "$LOGFILE" source "$HOME/.rvm/scripts/rvm" fi # 4. Install Ruby echo "Step 4: Installing Ruby $RUBY_VERSION…" | tee -a "$LOGFILE" if rvm install "$RUBY_VERSION" &>> "$LOGFILE"; then echo "✔ Ruby installed successfully" | tee -a "$LOGFILE" else code=$? echo "✖ Ruby install failed with status $code" | tee -a "$LOGFILE" echo "Check logs: $LOGFILE and ~/.rvm/log/" | tee -a "$LOGFILE" exit $code fi # 5. Set default Ruby and verify echo "Step 5: Setting default Ruby…" | tee -a "$LOGFILE" rvm --default use "$RUBY_VERSION" &>> "$LOGFILE" ruby -v | tee -a "$LOGFILE" echo "Installation completed at $(date)" | tee -a "$LOGFILE" </code></pre>Save and run:<pre class="wp-block-preformatted"><code>~/install_ruby.sh</code></pre><h2 class="wp-block-heading">What “status: 100” Really Means</h2>Whenever RVM exits with 100, it usually signals that dependency installation failed during the <code>requirements_debian_update_system</code> phase. In plain terms, <code>apt-get install</code> hit a snag—missing packages, network hiccups, or a locked dpkg database. The detailed reason lives in:<pre class="wp-block-preformatted"><code>~/.rvm/log/<timestamp>/update_system.log</code></pre>Peek at that log to pinpoint the broken dependency.<h2 class="wp-block-heading">How the Script Works</h2><ol class="wp-block-list"><li>Prerequisite Installation I update <code>apt</code> and install libraries (OpenSSL, Readline, zlib) that Ruby’s C-extensions need.</li>
<li>GPG Key Import RVM’s install script is signed importing its public keys ensures we trust the code we’re running.</li>
<li>RVM Setup If RVM isn’t present, we bootstrap it via <code>curl</code>; otherwise, we simply reload the existing install.</li>
<li>Ruby Compile & Install All output funnels into our timestamped log for later inspection. On failure, we catch the exit code and bail.</li>
<li>Default Ruby & Verification We mark our new Ruby version as the default and print <code>ruby -v</code> so we know it worked.</li></ol><h2 class="wp-block-heading">Extra Practice Functions</h2>To stretch your Bash and RVM chops, sprinkle in these helper functions:<pre class="wp-block-preformatted"><code># List all known Ruby versions function list_rubies() { echo "Known Ruby versions:" rvm list known } # Uninstall a specific Ruby version function uninstall_ruby() { echo "Removing Ruby $1…" rvm remove "$1" } # Create & use a project gemset function setup_gemset() { echo "Creating gemset '$1'…" rvm gemset create "$1" rvm gemset use "$1" } # Retry flaky commands up to 3 times function retry() { local attempt=1 max=3 delay=5 until "$@"; do if (( attempt == max )); then echo "Command failed after $attempt tries." return 1 fi (( attempt++ )) echo "Retry $attempt/$max in $delay sec…" sleep $delay done return 0 } </code></pre>You can call, for example:<pre class="wp-block-preformatted"><code>retry sudo apt-get update</code></pre>to guard against transient network failures.<h2 class="wp-block-heading">Final Thoughts</h2>I used to dread that “status: 100” error. Now, every time it crops up, I let my script handle it logging the details, retrying if necessary, and pointing me straight to the root cause. Automating repetitive setups like Ruby installations frees up my brainpower for the fun parts.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-solve-error-while-installing-ruby-using-rvm/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2175</post-id> </item>
<item>
<title>How to Resolve _rb_ary_new_from_values Psych Bundle Error in Ruby Applications</title>
<link>https://fsiblog.io/how-to-resolve-_rb_ary_new_from_values-psych-bundle-error-in-ruby-applications/</link>
<comments>https://fsiblog.io/how-to-resolve-_rb_ary_new_from_values-psych-bundle-error-in-ruby-applications/#respond</comments>
<dc:creator><![CDATA[Shaheen Ullah]]></dc:creator>
<pubDate>Sat, 26 Apr 2025 06:39:47 +0000</pubDate>
<category><![CDATA[Ruby]]></category>
<category><![CDATA[Resolve _rb_ary_new_from_values Psych Bundle Error in Ruby]]></category>
<category><![CDATA[Resolve _rb_ary_new_from_values Psych Bundle Error in Ruby Applications]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2171</guid>
<description><![CDATA[Hi there I’m excited to walk you through a little Ruby adventure I recently had, complete with code, explanations and a sprinkle of hands-on practice. I’ll take you step by step through the problem I ran into, how I reproduced it, what it really means, and finally how I fixed it. Code Error When I […]]]></description>
<content:encoded><![CDATA[Hi there I’m excited to walk you through a little Ruby adventure I recently had, complete with code, explanations and a sprinkle of hands-on practice. I’ll take you step by step through the problem I ran into, how I reproduced it, what it really means, and finally how I fixed it.<h2 class="wp-block-heading">Code Error</h2>When I tried to start my Ruby app, my terminal spat out this scary message:<pre class="wp-block-preformatted"><code>: lazy symbol binding failed: Symbol not found: _rb_ary_new_from_values Referenced from: /Users/rich/.rvm/gems/ruby-2.2.3/gems/psych-2.0.17/lib/psych.bundle Expected in: flat namespace dyld: Symbol not found: _rb_ary_new_from_values Referenced from: /Users/rich/.rvm/gems/ruby-2.2.3/gems/psych-2.0.17/lib/psych.bundle Expected in: flat namespace Trace/BPT trap: 5 </code></pre>At first glance, it looked like my machine was missing something vital. But really, it was a version mismatch hiding under a confusing error.<h2 class="wp-block-heading">Minimal Reproduction</h2>To make sure I wasn’t chasing ghosts, I created a tiny Ruby script:<pre class="wp-block-preformatted"><code># demo.rb require 'psych' yaml_str = <<~YAML fruits: - apple - banana - cherry YAML data = Psych.load(yaml_str) puts data.inspect </code></pre>Then I ran:<pre class="wp-block-preformatted"><code>ruby demo.rb</code></pre>and sure enough, the same <code>_rb_ary_new_from_values</code> error showed up. That told me the problem wasn’t in my app it was in how <code>psych</code> was talking to Ruby.<h2 class="wp-block-heading">What the Error Means</h2><ul class="wp-block-list"><li><code>dyld: lazy symbol binding failed</code> macOS’s dynamic linker (known as <code>dyld</code>) tried to load a C-level function from the <code>psych</code> native extension but couldn’t find it.</li>
<li><code>_rb_ary_new_from_values</code> This function is part of Ruby’s C-API and was introduced in newer Ruby versions. My <code>psych</code> gem was compiled expecting that function, but at runtime I was using Ruby 2.2.3 which doesn’t provide it.</li>
<li>Root Cause A simple version mismatch: the <code>psych</code> gem version I had installed assumed a modern Ruby, but my environment was running an older one.</li></ul><h2 class="wp-block-heading">How I Fixed It</h2>I tried two approaches:<ul class="wp-block-list"><li>Upgrade Ruby I installed a newer Ruby via RVM:</li></ul><pre class="wp-block-preformatted"><code>install 2.7.6
rvm use 2.7.6 --default
gem uninstall psych
gem install psych</code></pre>Now <code>psych</code> would build against a Ruby that actually includes <code>_rb_ary_new_from_values</code>.<ul class="wp-block-list"><li>Pin <code>psych</code> to a Compatible Version If you can’t upgrade Ruby, you can choose a <code>psych</code> version that still works on 2.2.3. In my project’s <code>Gemfile</code> I added: </li></ul><pre class="wp-block-preformatted"><code>gem 'psych', '~> 2.0', '< 2.0.17'</code></pre>Then ran<pre class="wp-block-preformatted">bundle update psych</pre>Either way, rebuilding the native extension made the error disappear.<h2 class="wp-block-heading">Enhanced Demo with Error Handling & Practice</h2>I didn’t stop at just fixing it I also beefed up my demo script to:<ul class="wp-block-list"><li>Detect if <code>psych</code> fails to load</li>
<li>Fall back to Ruby’s pure-Ruby <code>YAML</code> parser</li>
<li>Offer an interactive CLI so I (or you!) can paste any YAML and see how it parses</li></ul><pre class="wp-block-preformatted"><code>#!/usr/bin/env ruby # enhanced_demo.rb begin require 'psych' PARSER = :psych rescue StandardError => e warn "[Warning] psych load failed: #{e.class} – #{e.message}" require 'yaml' PARSER = :syck end def load_yaml(str) PARSER == :psych ? Psych.load(str) : YAML.safe_load(str) end def practice_session puts "Paste YAML (end with blank line):" lines = [] loop do line = gets.chomp break if line.empty? lines << line end input = lines.join("\n") begin result = load_yaml(input) puts "✅ Parsed: #{result.inspect}" rescue StandardError => e puts "❌ Parse error: #{e.class}: #{e.message}" end end def main puts "Using parser: #{PARSER}" sample = <<~YML colors: - red - green - blue YML puts "Sample parse => #{load_yaml(sample).inspect}" puts "\n--- Your turn! ---" practice_session end main if __FILE__ == $0 </code></pre>How to try it yourself:<pre class="wp-block-preformatted"><code>+x enhanced_demo.rb ./enhanced_demo.rb </code></pre>You’ll see which parser is in use, a sample result, and then you can paste your own YAML to see it in action.<h2 class="wp-block-heading">Final Thoughts</h2>I love how a single error message can lead you down a path of discovery from learning about Ruby’s C-API symbols to mastering fallback strategies and interactive demos. If you ever bump into <code>_rb_ary_new_from_values</code> or any other missing-symbol issue, remember:<ul class="wp-block-list"><li>Check for version mismatches first</li>
<li>Upgrade Ruby or pin your gems to compatible releases</li>
<li>Recompile native extensions when in doubt</li></ul>And feel free to use my enhanced demo as a playground for understanding YAML parsing under the hood.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-resolve-_rb_ary_new_from_values-psych-bundle-error-in-ruby-applications/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2171</post-id> </item>
<item>
<title>How to Resolve Webpack Runtime Issues in Custom Next.js Scripts</title>
<link>https://fsiblog.io/how-to-resolve-webpack-runtime-issues-in-custom-next-js-scripts/</link>
<comments>https://fsiblog.io/how-to-resolve-webpack-runtime-issues-in-custom-next-js-scripts/#respond</comments>
<dc:creator><![CDATA[Bruno Naschpitz]]></dc:creator>
<pubDate>Fri, 25 Apr 2025 05:34:35 +0000</pubDate>
<category><![CDATA[Next.js]]></category>
<category><![CDATA[How to Resolve Webpack Runtime Issues in Custom Next.js]]></category>
<category><![CDATA[Resolve Webpack Runtime Issues in Custom Next.js Scripts]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2166</guid>
<description><![CDATA[If you’re working with Next.js and trying to run a custom script for RSS generation like build-rss.js, you might come across an error stating: Error: Cannot find module '../../webpack-runtime.js' This issue can arise due to various reasons, especially after upgrading Next.js or making changes to your build configuration. In this post, I will walk you […]]]></description>
<content:encoded><![CDATA[If you’re working with Next.js and trying to run a custom script for RSS generation like <code>build-rss.js</code>, you might come across an error stating:<pre class="wp-block-preformatted"><code>Error: Cannot find module '../../webpack-runtime.js'</code></pre>This issue can arise due to various reasons, especially after upgrading Next.js or making changes to your build configuration. In this post, I will walk you through the error’s explanation, the underlying issue in your configuration, and offer a solution to help you resolve it.<h2 class="wp-block-heading">Error Explanation</h2><h3 class="wp-block-heading">Error Message:</h3>The error message <code>Cannot find module '../../webpack-runtime.js'</code> is usually seen when there’s an issue with module resolution, where Node.js cannot locate the <code>webpack-runtime.js</code> file in the expected location.This could be related to a few possible causes:<ul class="wp-block-list"><li>Incorrect path or module resolution: The error may appear when Next.js expects certain files to be available, but they are either missing or not correctly linked.</li>
<li>Webpack configurations: If you’ve made custom changes to the webpack configuration (as seen in your <code>next.config.js</code>), it’s possible that these changes have affected how dependencies are bundled, leading to an issue with module resolution during the build.</li>
<li>Next.js version update: Since you mentioned that the script used to work earlier, but now it doesn’t, the issue might be related to a version update in Next.js or one of its dependencies that introduced breaking changes in the build process.</li></ul><h2 class="wp-block-heading">Issue in the Configuration</h2>In your <code>next.config.js</code>, you’re trying to dynamically modify the webpack configuration by adding a custom entry point for <code>build-rss.js</code>:<pre class="wp-block-preformatted"><code>.exports = { webpack: (config, options) => { config.module.rules.push({ test: /\.svg$/, issuer: { and: [/\.(js|ts|md)x?$/] }, use: [ { loader: '@svgr/webpack', options: { prettier: false, svgo: true, svgoConfig: { plugins: [{ removeViewBox: false }] }, titleProp: true, }, }, ], }); if (!options.dev && options.isServer) { const originalEntry = config.entry; config.entry = async () => { const entries = { ...(await originalEntry()) }; entries['./scripts/build-rss'] = './scripts/build-rss.js'; return entries; }; } if (!options.isServer) { config.resolve.fallback.fs = false; } return config; }, } </code></pre>The part of the configuration that modifies the <code>config.entry</code> is trying to inject the RSS script into the build process. However, this can sometimes lead to problems if Next.js isn’t able to resolve or find <code>webpack-runtime.js</code> properly in the new build context.<h2 class="wp-block-heading">Solution and Fix</h2><ul class="wp-block-list"><li>Check File Paths: Ensure that your <code>build-rss.js</code> script is located correctly and that the path in <code>config.entry</code> correctly points to it. The file should be inside the <code>scripts/</code> folder at the root of your project, as specified in the <code>next.config.js</code>.</li>
<li>Modify Webpack Configuration for Serverless: When using <code>node ./.next/serverless/scripts/build-rss.js</code>, ensure that the build process in a serverless setup can still access the necessary Webpack runtime files. You can try a different approach by modifying the script path resolution based on the build mode (serverless vs. regular server).</li>
<li>Test with <code>npm run build</code> First: Sometimes, running <code>npm run build</code> and ensuring that the build process completes successfully before running custom scripts can help isolate issues related to build-time configuration.</li>
<li>Next.js Version Compatibility: If the issue arose after upgrading Next.js, it might be related to compatibility issues between the custom webpack configuration and newer Next.js versions. Ensure you are using a compatible version of Next.js and check the changelogs for any breaking changes in how webpack is handled.</li>
<li>Add Fallback for Webpack Runtime: You can add a fallback in your <code>next.config.js</code> to ensure that the Webpack runtime is correctly bundled for your script. You can use something like: </li></ul><pre class="wp-block-preformatted"><code>if (!options.isServer) {
config.resolve.fallback = {
fs: false,
path: false,
webpack: require.resolve('webpack'),
};
}</code></pre><ul class="wp-block-list"><li>Simplify Webpack Configuration: Consider simplifying the custom webpack configuration temporarily to identify which part is causing the issue. For example, remove the <code>build-rss.js</code> entry configuration and test if the error still persists.</li></ul><h3 class="wp-block-heading">Improved Script Handling in <code>package.json</code></h3>You can simplify your <code>scripts</code> in <code>package.json</code> to ensure the build and export processes work seamlessly, like so:<pre class="wp-block-preformatted"><code>"scripts": { "clean": "rimraf .next", "dev": "next dev", "export": "next export", "start": "next start", "lint": "next lint", "build:development": "next build && npm run export && npm run rss:development", "build": "next build && npm run export && npm run rss", "rss:development": "node ./.next/server/scripts/build-rss.js", "rss": "node ./.next/serverless/scripts/build-rss.js" } </code></pre>Ensure that you are pointing to the correct location of <code>build-rss.js</code> depending on whether you are using a server-side build or serverless functions.<h3 class="wp-block-heading">Further Testing</h3>Once you apply these changes, follow these steps to troubleshoot and test:<ol class="wp-block-list"><li>Run a Clean Build: Use <code>npm run clean</code> and then <code>npm run build:development</code> to ensure a fresh build.</li>
<li>Test Without Custom Webpack: Temporarily remove the custom webpack modifications and test if the issue still arises.</li>
<li>Check for Updates: Ensure all dependencies are up to date by running <code>npm outdated</code> and updating packages if necessary.</li></ol><h2 class="wp-block-heading">Conclusion</h2>The error you encountered, <code>Cannot find module '../../webpack-runtime.js'</code>, is likely caused by incorrect handling of the Webpack runtime in your custom Next.js configuration. By ensuring the paths are correct, simplifying your webpack config, and checking compatibility with the Next.js version you’re using, you should be able to resolve this issue.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-resolve-webpack-runtime-issues-in-custom-next-js-scripts/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2166</post-id> </item>
<item>
<title>How to Fix Undefined Error with GraphQL Request in Next.js</title>
<link>https://fsiblog.io/how-to-fix-undefined-error-with-graphql-request-in-next-js/</link>
<comments>https://fsiblog.io/how-to-fix-undefined-error-with-graphql-request-in-next-js/#respond</comments>
<dc:creator><![CDATA[Bruno Naschpitz]]></dc:creator>
<pubDate>Fri, 25 Apr 2025 05:18:20 +0000</pubDate>
<category><![CDATA[Next.js]]></category>
<category><![CDATA[Fix Undefined Error with GraphQL Request in Next.js]]></category>
<category><![CDATA[Undefined Error with GraphQL Request in Next.js]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2163</guid>
<description><![CDATA[When you’re working with Next.js and Contentful, dynamic pages may sometimes return an “undefined” error when making GraphQL requests. This issue is common and often occurs due to improper query structure or missing error handling. I’ll explain the problem, walk through the fix, and show you the corrected code that should solve your issue. Error […]]]></description>
<content:encoded><![CDATA[When you’re working with Next.js and Contentful, dynamic pages may sometimes return an “undefined” error when making GraphQL requests. This issue is common and often occurs due to improper query structure or missing error handling. I’ll explain the problem, walk through the fix, and show you the corrected code that should solve your issue.<h2 class="wp-block-heading">Error Code</h2><pre class="wp-block-preformatted"><code>console.error("There was a problem retrieving entries with the query:", query); console.error("Error details:", error);</code></pre><h2 class="wp-block-heading">Explanation of the Error</h2><h3 class="wp-block-heading">GraphQL Query Issue:</h3>In your <code>getStaticProps</code>, you’re constructing a GraphQL query with a dynamic <code>slug</code>, but you aren’t passing the value correctly into the query. Instead of dynamically passing <code>context.params.slug</code> into the GraphQL query, you’re likely interpreting it as a string literal. This means the query is looking for an exact match of <code>"context.params.slug"</code> instead of the value you intend.<h3 class="wp-block-heading">Query Construction:</h3>The GraphQL query you’re using to fetch posts based on <code>slug</code> is not correctly formatted to handle dynamic values. This issue often causes Contentful to return an empty or undefined response when fetching dynamic pages, even though the same query works for the static news page.<h3 class="wp-block-heading">Dynamic Data Handling:</h3>The issue might also lie in how the <code>getStaticProps</code> and <code>getStaticPaths</code> functions are handling dynamic data from Contentful. If these functions aren’t receiving the expected data from Contentful, it can cause them to return an undefined result.<h2 class="wp-block-heading">Solution and Fix</h2>To fix this issue, you need to adjust how the <code>slug</code> parameter is passed into your GraphQL query and ensure that it’s properly interpolated. Below is the refactored code that resolves the issue by correctly passing the dynamic slug to the query.<h3 class="wp-block-heading">Refactored Code</h3><h4 class="wp-block-heading">News Article Page (<code>news/[slug].tsx</code>):</h4><pre class="wp-block-preformatted">tsxCopy<code>import { Box, Text } from "@chakra-ui/react";
import React from "react";
import { fetchContent } from "../../utils/contentful";
const NewsArticlePage = ({ post }) => {
// Ensure post.slug is defined before attempting to use it
if (!post) {
return <Box>No Post Found</Box>;
}
return (
<Box>
<Text>{post.title}</Text>
<Text>{post.slug}</Text>
</Box>
);
};
export default NewsArticlePage;
// Fetching data for dynamic pages
export async function getStaticProps({ params }) {
console.log("Fetching post for slug:", params.slug);
const response = await fetchContent(`
query getBlogPost($slug: String!) {
blogPostCollection(where: {slug: $slug}) {
items {
title
slug
}
}
}
`, { slug: params.slug });
console.log("Response:", response);
const post = response?.blogPostCollection?.items?.[0] || null;
if (!post) {
return { props: {} }; // Return empty props if no post found
}
return {
props: {
post,
},
};
}
export async function getStaticPaths() {
const response = await fetchContent(`
query {
blogPostCollection {
items {
slug
}
}
}
`);
const paths = response?.blogPostCollection?.items.map((post) => ({
params: { slug: post.slug },
})) || [];
return {
paths,
fallback: false,
};
}
</code></pre><h4 class="wp-block-heading">Utility Function to Fetch Data (<code>utils/contentful.js</code>):</h4><pre class="wp-block-preformatted"><code>space = process.env.NEXT_PUBLIC_CONTENTFUL_SPACE_ID; const accessToken = process.env.NEXT_PUBLIC_CONTENTFUL_ACCESS_TOKEN; export async function fetchContent(query, variables = {}) { try { const res = await fetch( `https://graphql.contentful.com/content/v1/spaces/${space}`, { method: "POST", headers: { "Content-Type": "application/json", "Authorization": `Bearer ${accessToken}`, }, body: JSON.stringify({ query, variables }), } ); if (!res.ok) { throw new Error("Network response was not ok"); } const { data } = await res.json(); return data; } catch (error) { console.error("Error fetching data from Contentful:", error); throw error; // Propagate the error to be handled elsewhere } } </code></pre><h2 class="wp-block-heading">Key Fixes:</h2><ol class="wp-block-list"><li>Query Formatting: In the GraphQL query, the <code>slug</code> value is now passed as a variable (<code>$slug</code>) and included in the request through the <code>variables</code> parameter.</li>
<li>Error Handling: I added better error handling within the <code>fetchContent</code> function using a <code>try-catch</code> block. This allows you to catch network errors or API-related issues and log them for debugging.</li>
<li>Fetching Single Post: The way the post is fetched from the response has been modified. Instead of assuming a fixed structure, we safely access the first item in the response with <code>response?.blogPostCollection?.items?.[0]</code>.</li>
<li>Dynamic Paths Handling: The <code>getStaticPaths</code> function now fetches only the <code>slug</code> field for each post, which is sufficient for generating static paths. This ensures that a dynamic page is generated for each unique <code>slug</code>.</li></ol><h2 class="wp-block-heading">Additional Functionality:</h2><ol class="wp-block-list"><li>Error Handling for Undefined Posts: I added a safeguard to handle cases where no post is found, displaying a fallback message like “No Post Found” on the page. This will help you debug if something goes wrong.</li>
<li>Query Optimization: The <code>getStaticProps</code> function is now optimized to properly accept the <code>slug</code> as a variable, reducing the chance of errors related to incorrect query construction.</li></ol><h2 class="wp-block-heading">Further Improvements:</h2><ol class="wp-block-list"><li>Fallback Handling: If you want Next.js to regenerate pages on-demand when new posts are added, you can modify the <code>getStaticPaths</code> fallback behavior to <code>true</code>. This way, it won’t block new slugs from appearing, and the page will be generated on the fly for those slugs that were not pre-generated.</li>
<li>Caching: To minimize the number of requests to Contentful and improve performance, you could implement caching mechanisms such as using a CDN or storing the data locally for a set amount of time.</li></ol><h2 class="wp-block-heading">Conclusion</h2>By ensuring the GraphQL query is properly constructed with dynamic variables and improving error handling in the fetch function, this solution should resolve the undefined error you’re encountering when working with dynamic pages in Next.js and Contentful. Always ensure that the <code>slug</code> or other dynamic parameters are correctly passed into the query, and handle edge cases like missing posts or errors gracefully.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-fix-undefined-error-with-graphql-request-in-next-js/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2163</post-id> </item>
<item>
<title>How Fix VS Code PHP Intelephense Undefined Symbol Errors in Laravel</title>
<link>https://fsiblog.io/how-fix-vs-code-php-intelephense-undefined-symbol-errors-in-laravel/</link>
<comments>https://fsiblog.io/how-fix-vs-code-php-intelephense-undefined-symbol-errors-in-laravel/#respond</comments>
<dc:creator><![CDATA[MALIK SHAFI]]></dc:creator>
<pubDate>Thu, 24 Apr 2025 05:46:53 +0000</pubDate>
<category><![CDATA[PHP]]></category>
<category><![CDATA[Fix VS Code PHP Intelephense Undefined Symbol Errors in Laravel]]></category>
<category><![CDATA[How Fix VS Code PHP Intelephense Undefined Symbol Errors in Laravel]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2159</guid>
<description><![CDATA[I’m excited to share how I tackled a pesky “undefined symbol” warning that cropped up in Visual Studio Code after today’s PHP Intelephense update. If you’re working on a Laravel project and suddenly see red squiggles under perfectly good routes even though everything runs fine this post is for you. I’ll walk through exactly what […]]]></description>
<content:encoded><![CDATA[I’m excited to share how I tackled a pesky “undefined symbol” warning that cropped up in Visual Studio Code after today’s PHP Intelephense update. If you’re working on a Laravel project and suddenly see red squiggles under perfectly good routes even though everything runs fine this post is for you. I’ll walk through exactly what happened, why Intelephense started complaining, how I fixed it, and even add a bit of practice code so you can confirm everything’s humming along smoothly.<h2 class="wp-block-heading">Error Code Snippet</h2>Here’s the exact block that triggered the false alarm in my editor:<pre class="wp-block-preformatted"><code><?php use Illuminate\Support\Facades\Route; Route::group([ 'prefix' => 'user', 'namespace' => 'Membership', 'name' => 'user.' ], function () { Route::get('profile', 'ProfileController@show')->name('profile.show'); Route::patch('profile', 'ProfileController@update')->name('profile.update'); Route::patch('change-password', 'ChangePasswordController@change')->name('change-password'); Route::get('role', 'ProfileController@getRole')->name('profile.role'); Route::get('summary', 'SummaryController@show')->name('summary'); Route::get('reserved', 'AuctionController@reservedAuction')->name('reserved'); }); </code></pre>Everything here is standard Laravel routing. There’s no typo, and the controllers exist in <code>app/Http/Controllers/Membership</code>. Yet Intelephense underlined each controller reference as “undefined symbol.”<h2 class="wp-block-heading">The “Undefined Symbol” Error</h2>Intelephense flagged lines like this:Undefined symbol: Membership\ProfileControllerThat’s a false positive Laravel resolves these classes at runtime via PSR-4 autoloading, but Intelephense didn’t know where to look in my workspace.<h2 class="wp-block-heading">Why Intelephense Complains</h2><ol class="wp-block-list"><li>PSR-4 Autoloading Laravel’s <code>composer.json</code> maps namespaces to folders.</li>
<li>Default Indexing Intelephense only scans files directly under your workspace root.</li>
<li>Missing Include Paths If you haven’t told Intelephense where your controller folders live, it won’t index them, so references look “undefined.”</li></ol><h2 class="wp-block-heading">How I Fixed It</h2><ul class="wp-block-list"><li>Open Settings in VS Code (Ctrl + <code>,</code>).</li>
<li>Search for <code>intelephense.environment.includePaths</code>.</li>
<li>Edit your <code>settings.json</code> and add the directories where your PHP classes live:</li></ul><pre class="wp-block-preformatted"><code>// settings.json
{
"intelephense.environment.includePaths": [
"app/Http/Controllers",
"app/Models"
]
}</code></pre><ul class="wp-block-list"><li>Reload VS Code so Intelephense re-indexes everything.</li>
<li>Goodbye, red squiggles!</li></ul><h2 class="wp-block-heading">Adding Practice Functionality</h2>Once my IDE stopped complaining, I wanted to be sure my routes still worked—and give myself some playground code. I extended the <code>user</code> group with three quick test endpoints:<pre class="wp-block-preformatted"><code><?php use Illuminate\Support\Facades\Route; use Illuminate\Http\Request; Route::group([ 'prefix' => 'user', 'namespace' => 'Membership', 'name' => 'user.' ], function () { // …original routes above… // 1) Return the authenticated user as JSON Route::get('me', function (Request $request) { return response()->json($request->user()); })->name('profile.me')->middleware('auth'); // 2) Search reserved auctions by date (YYYY-MM-DD) Route::get('reserved/search', 'AuctionController@searchByDate') ->name('reserved.search') ->where('date', '\d{4}-\d{2}-\d{2}'); // 3) Bulk update profile settings Route::patch('settings', 'ProfileController@bulkUpdate') ->name('settings.bulk-update'); }); </code></pre><h2 class="wp-block-heading">Practice Tasks</h2><ul class="wp-block-list"><li>Visit <code>/user/me</code> after logging in. You should see your user record in JSON.</li>
<li>Open <code>/user/reserved/search?date=2025-04-24</code> to test date filtering.</li>
<li>Send a <code>PATCH</code> to <code>/user/settings</code> with a small JSON payload to verify your bulk update logic.</li></ul><h2 class="wp-block-heading">Final Thoughts</h2>False positives from IDE tools can be an annoying distraction, but they’re usually fixable with a little configuration. Once I pointed Intelephense at my Laravel folders, those phantom “undefined symbol” errors disappeared. Adding some extra test routes not only confirmed my setup but also gave me a reusable snippet for future projects.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-fix-vs-code-php-intelephense-undefined-symbol-errors-in-laravel/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2159</post-id> </item>
<item>
<title>How to Send Specific Invoice Values with Stripe PHP Invoice</title>
<link>https://fsiblog.io/how-to-send-specific-invoice-values-with-stripe-php-invoice/</link>
<comments>https://fsiblog.io/how-to-send-specific-invoice-values-with-stripe-php-invoice/#respond</comments>
<dc:creator><![CDATA[MALIK SHAFI]]></dc:creator>
<pubDate>Thu, 24 Apr 2025 05:27:34 +0000</pubDate>
<category><![CDATA[PHP]]></category>
<category><![CDATA[How to Send Specific Invoice Values with Stripe PHP Invoice]]></category>
<category><![CDATA[Send Specific Invoice Values with Stripe PHP Invoice]]></category>
<guid isPermaLink="false">https://fsiblog.io/?p=2156</guid>
<description><![CDATA[I’m a developer who’s been in your shoes trying to get Stripe to bill customers exactly the right amount, only to discover those invoices keep coming through for £0. In this walkthrough, I’ll share my own Stripe PHP invoice setup for music lesson billing, explain where things went wrong, and offer ideas to level up […]]]></description>
<content:encoded><![CDATA[I’m a developer who’s been in your shoes trying to get Stripe to bill customers exactly the right amount, only to discover those invoices keep coming through for £0. In this walkthrough, I’ll share my own Stripe PHP invoice setup for music lesson billing, explain where things went wrong, and offer ideas to level up your invoicing flow with discounts and reminders. By the end, you’ll have a solid, working function and inspiration for extra practice features.<h2 class="wp-block-heading">Error Code</h2>Here’s the cleaned-up <code>createStripeLessonInvoice</code> function I ended up using. I’ve added clear logging, a single finalize step, and return the hosted invoice URL once everything’s locked in.<pre class="wp-block-preformatted"><code><?php require 'vendor/autoload.php'; // Load the Stripe PHP library function createStripeLessonInvoice( string $parentName, string $email, string $childName, string $instrument, string $grouping, float $costPerLesson, int $lessonCount ): ?string { \Stripe\Stripe::setApiKey('sk_test_[MYKEY]'); try { // 1) Get or create the Stripe customer $customer = getOrCreateStripeCustomer($email, $parentName, null, $childName); // 2) Calculate the total and convert to pence $totalCost = $costPerLesson * $lessonCount; $amountPence = (int) round($totalCost * 100); error_log("DEBUG: Total cost is £{$totalCost}"); error_log("DEBUG: Amount in pence: {$amountPence}"); // 3) Create a single invoice item $invoiceItem = \Stripe\InvoiceItem::create([ 'customer' => $customer->id, 'amount' => $amountPence, 'currency' => 'gbp', 'description' => "{$lessonCount} × £{$costPerLesson} lessons", 'metadata' => [ 'student_name' => $childName, 'instrument' => $instrument, 'grouping' => $grouping, 'lesson_count' => $lessonCount, 'unit_cost' => $costPerLesson, 'total_cost' => $totalCost, ], ]); // 4) Create the invoice, schedule to send in 7 days $invoice = \Stripe\Invoice::create([ 'customer' => $customer->id, 'collection_method' => 'send_invoice', 'days_until_due' => 7, 'auto_advance' => false, // we’ll call finalize manually ]); // 5) Finalize the invoice so it moves from draft to open $finalizedInvoice = $invoice->finalizeInvoice(); error_log("DEBUG: Invoice finalized: " . print_r($finalizedInvoice, true)); // 6) (Optional) Send immediately: // \Stripe\Invoice::sendInvoice($finalizedInvoice->id); // 7) Return the URL to share with your customer return $finalizedInvoice->hosted_invoice_url; } catch (\Stripe\Exception\ApiErrorException $e) { error_log('Stripe API error: ' . $e->getMessage()); return null; } } </code></pre><h2 class="wp-block-heading">Error Definition</h2>In my first iteration, I had two calls to <code>finalizeInvoice()</code> and two early <code>return</code> statements. That meant:<ul class="wp-block-list"><li>The very first <code>return</code> ran before I logged anything or finalized properly.</li>
<li>No invoice items ever attached, so Stripe generated a blank (zero-value) invoice.</li>
<li>My logs never showed the real error or amount in pence, leaving me clueless.</li></ul>By consolidating to a single finalize and moving the <code>return</code> to the end, I can see exactly what’s happening in my logs—and Stripe now charges the correct amount.<h2 class="wp-block-heading">Explanation of the Stripe Flow</h2><ol class="wp-block-list"><li><code>InvoiceItem::create</code> I add one or more line items (here, my lessons) to the customer’s upcoming invoice. Remember: Stripe expects amounts in the smallest currency unit (pence for GBP).</li>
<li><code>Invoice::create</code> This builds a draft invoice for the customer, automatically including any pending invoice items.</li>
<li><code>Invoice::finalizeInvoice</code> Finalizes the draft—locking in totals and making line items appear on the hosted invoice page.</li>
<li>(Optional) <code>Invoice::sendInvoice</code> You can call this immediately if you don’t want to wait for Stripe’s scheduled send. Otherwise, Stripe will auto-send on the date you set.</li></ol><h2 class="wp-block-heading">Additional Practice Functionality</h2>To take your invoicing further, try these extras in your own project:<h3 class="wp-block-heading">Multiple Line-Items & Discounts</h3><pre class="wp-block-preformatted"><code>function addLessonPackage($customerId, $description, $unitCost, $quantity) { \Stripe\InvoiceItem::create([ 'customer' => $customerId, 'amount' => (int) round($unitCost * $quantity * 100), 'currency' => 'gbp', 'description' => "{$quantity}× {$description}", ]); } function addDiscount($customerId, float $discountAmount) { \Stripe\InvoiceItem::create([ 'customer' => $customerId, 'amount' => -(int) round($discountAmount * 100), 'currency' => 'gbp', 'description' => "Discount: £" . number_format($discountAmount, 2), ]); } // Usage example: addLessonPackage($customer->id, 'Group Piano Lessons', 25.00, 4); addDiscount($customer->id, 10.00); </code></pre><h3 class="wp-block-heading">Automated Reminder Emails</h3>Hook into Stripe’s webhooks listen for <code>invoice.finalized</code> and then schedule your own email reminder a day before the due date. Rough sketch:<pre class="wp-block-preformatted"><code>// webhook-handler.php $payload = json_decode(file_get_contents('php://input'), true); if ($payload['type'] === 'invoice.finalized') { $invoice = $payload['data']['object']; scheduleReminderEmail( $invoice['customer_email'], (new DateTime())->setTimestamp($invoice['due_date'])->modify('-1 day') ); } </code></pre><h2 class="wp-block-heading">Final Thoughts</h2>Billing students for music lessons shouldn’t feel like wrestling with Stripe’s API. By logging pence values, finalizing once, and returning the hosted URL last, you’ll see correct invoices every time. Then, when you’re comfortable, add multiple items, apply discounts, or build reminder hooks to automate follow-ups.]]></content:encoded>
<wfw:commentRss>https://fsiblog.io/how-to-send-specific-invoice-values-with-stripe-php-invoice/feed/</wfw:commentRss>
<slash:comments>0</slash:comments>
<post-id xmlns="com-wordpress:feed-additions:1">2156</post-id> </item>
</channel>
</rss>

If you would like to create a banner that links to this page (i.e. this validation result), do the following:

Download the "valid RSS" banner.
Upload the image to your own server. (This step is important. Please do not link directly to the image on this server.)
Add this HTML to your page (change the image src attribute if necessary):

<a href="http://www.feedvalidator.org/check.cgi?url=https%3A//fsiblog.io/feed/"><img src="valid-rss-rogers.png" alt="[Valid RSS]" title="Validate my RSS feed" /></a>

If you would like to create a text link instead, here is the URL you can use:

http://www.feedvalidator.org/check.cgi?url=https%3A//fsiblog.io/feed/

Home · About · News · Docs · Terms