ஸ்ட்ரீம்லிட் பைதான்

Mia Chevalier

செவ்வாய், 15 அக்டோபர், 2024 ’அன்று’ முற்பகல் 3:04:56

ஸ்ட்ரீம்லிட்டில் ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பு சவால்களை சமாளித்தல்

ஸ்ட்ரீம்லிட் என்பது பைத்தானைப் பயன்படுத்தி தரவு-உந்துதல் வலை பயன்பாடுகளை உருவாக்குவதற்கான ஒரு சக்திவாய்ந்த கருவியாகும், ஆனால் ஒருங்கிணைக்கிறது ஜாவாஸ்கிரிப்ட் செயல்பாடுகள் சில நேரங்களில் எதிர்பாராத சவால்களை முன்வைக்கலாம். ஜாவாஸ்கிரிப்ட் குறியீட்டை இயக்க முயற்சிக்கும்போது டெவலப்பர்கள் அடிக்கடி சிக்கல்களை எதிர்கொள்கின்றனர் மற்றும் அதன் முடிவுகளை ஸ்ட்ரீம்லிட்டிற்குள் மீட்டெடுக்கிறார்கள்.

ஒரு பொதுவான ஏமாற்றம் எழும் போது a JavaScript செயல்பாட்டின் வருவாய் மதிப்பு செயல்பாடு தர்க்கரீதியாக சரியாகத் தோன்றினாலும், 0 என தவறாக வழங்கப்பட்டுள்ளது. இந்த நிலைமை டெவலப்பர்களை குழப்பலாம், குறிப்பாக பைதான் மற்றும் ஜாவாஸ்கிரிப்ட் இரண்டையும் நன்கு அறிந்தவர்கள், இது நேரத்தை எடுத்துக்கொள்ளும் சரிசெய்தலுக்கு வழிவகுக்கும்.

வழங்கப்பட்ட எடுத்துக்காட்டில், பயனர் ஜாவாஸ்கிரிப்டில் ஒரு எளிய அநாமதேய செயல்பாட்டை அழைக்க முயற்சிக்கிறார், அது 2 இன் மதிப்பை வழங்குகிறது. இருப்பினும், எதிர்பார்த்த முடிவைப் பெறுவதற்குப் பதிலாக, வெளியீடு எப்போதும் 0 ஐக் காட்டுகிறது, இதனால் குறியீட்டில் என்ன தவறு நடக்கக்கூடும் என்பதில் குழப்பம் ஏற்படுகிறது. மரணதண்டனை.

இந்தக் கட்டுரை சிக்கலை ஏற்படுத்தக்கூடிய அடிப்படைச் சிக்கல்களை ஆராய்கிறது மற்றும் ஜாவாஸ்கிரிப்டை ஸ்ட்ரீம்லிட்டுடன் சரியாக ஒருங்கிணைக்க சரியான தொடரியல் வழங்குகிறது. குறியீட்டை உடைப்போம், சாத்தியமான தவறான உள்ளமைவுகளைக் கண்டறிந்து, JavaScript செயல்பாடுகள் எதிர்பார்க்கப்படும் மதிப்புகளைத் தருவதை உறுதிசெய்ய மாற்று அணுகுமுறைகளைப் பரிந்துரைப்போம்.

கட்டளை	பயன்பாடு மற்றும் விளக்கத்தின் எடுத்துக்காட்டு
st.empty()	ஸ்ட்ரீம்லிட் பயன்பாட்டில் ஒரு ஒதுக்கிடத்தை உருவாக்குகிறது, அது பிற உறுப்புகளுடன் புதுப்பிக்கப்படும். ஜாவாஸ்கிரிப்ட் மதிப்பை வழங்கும் வரை காத்திருப்பது போன்ற ஒத்திசைவற்ற பதில்களுக்காக காத்திருக்கும் போது இது பயனுள்ளதாக இருக்கும்.
window.parent.postMessage()	குழந்தை iframe அல்லது உட்பொதிக்கப்பட்ட உள்ளடக்கத்திலிருந்து பெற்றோர் சாளரத்திற்குச் செய்திகளை அனுப்ப JavaScript முறை பயன்படுத்தப்படுகிறது. இந்த தீர்வில், இது ஒரு JS செயல்பாட்டின் முடிவை ஸ்ட்ரீம்லிட்டின் பைதான் பின்தளத்திற்கு அனுப்ப உதவுகிறது.
@st.cache_data	டேட்டாவை மீண்டும் பயன்படுத்துவதன் மூலம் செயல்திறனை மேம்படுத்த இந்த டெக்கரேட்டர் செயல்பாடு வெளியீடுகளை கேச் செய்கிறது. ஜாவாஸ்கிரிப்ட் செய்திகளைக் கேட்பது, தேவையான மறுகணக்கீடுகள் மட்டுமே நடப்பதை உறுதி செய்வது போன்ற தொடர்ச்சியான நிகழ்வுகளைக் கையாளும் போது இது உதவியாக இருக்கும்.
html()	ஸ்ட்ரீம்லிட் பயன்பாட்டில் மூல HTML மற்றும் JavaScript குறியீட்டை வழங்க streamlit.components.v1 இன் செயல்பாடு பயன்படுத்தப்படுகிறது. இது பைதான் பின்தளத்துடன் நேரடியாக முன்பக்க ஸ்கிரிப்ட்களை ஒருங்கிணைத்து, ஊடாடுதலை செயல்படுத்துகிறது.
st.number_input()	சரியான எண்கள் மட்டுமே ஏற்றுக்கொள்ளப்படுவதை உறுதிசெய்யும் எண் உள்ளீட்டு புலத்தை உருவாக்குகிறது. இந்த எடுத்துக்காட்டில், பிழைகள் அல்லது எதிர்பாராத முடிவுகளை ஏற்படுத்தக்கூடிய தவறான உள்ளீடுகளைப் பெறுவதிலிருந்து JavaScript செயல்பாடுகளைத் தடுக்கிறது.
st.error()	விதிவிலக்குகள் அல்லது உள்ளீடு சரிபார்ப்பு தோல்விகள் ஏற்படும் போது ஸ்ட்ரீம்லிட் இடைமுகத்தில் பிழை செய்திகளைக் காட்டுகிறது. இது பயனர் கருத்தை மேம்படுத்துகிறது மற்றும் சிக்கல்களை திறம்பட தீர்க்க உதவுகிறது.
unittest.TestCase	பைத்தானில் யூனிட் டெஸ்ட் கேஸ்களை உருவாக்கப் பயன்படுகிறது. ஜாவாஸ்கிரிப்ட் மற்றும் ஸ்ட்ரீம்லிட் ஒருங்கிணைப்பு வெவ்வேறு சூழ்நிலைகளில் எதிர்பார்த்தபடி செயல்படுகிறதா என்பதை இது டெவலப்பர்களை சரிபார்க்க அனுமதிக்கிறது.
TestSession()	பயன்பாட்டுடன் பயனர் தொடர்புகளை உருவகப்படுத்த அனுமதிக்கும் ஸ்ட்ரீம்லிட்டின் சோதனை கட்டமைப்பிலிருந்து ஒரு பயன்பாடு. ஸ்ட்ரீம்லிட் கூறுகளுடன் JS செயல்பாடுகள் எவ்வாறு தொடர்பு கொள்கின்றன என்பதற்கான சோதனைகளை இயக்குவதற்கு இது மிகவும் பயனுள்ளதாக இருக்கும்.
with self.assertRaises()	குறிப்பிட்ட விதிவிலக்குகள் எதிர்பார்க்கப்படும் போது எழுப்பப்படுவதை உறுதி செய்வதற்கான பைதான் சோதனை முறை. இந்த எடுத்துக்காட்டில், தவறான உள்ளீடுகள் அனுப்பப்படும்போது ValueError ஐச் சோதிப்பதன் மூலம் உள்ளீடு கையாளுதலை இது சரிபார்க்கிறது.

ஸ்ட்ரீம்லிட் மற்றும் ஜாவாஸ்கிரிப்ட்: ஒருங்கிணைப்பு செயல்முறையைப் புரிந்துகொள்வது

வழங்கப்பட்ட எடுத்துக்காட்டுகள் எவ்வாறு ஒருங்கிணைப்பது என்பதை நிரூபிக்கின்றன ஜாவாஸ்கிரிப்ட் செயல்பாடுகள் ஊடாடுதலை மேம்படுத்த பைதான் அடிப்படையிலான ஸ்ட்ரீம்லிட் பயன்பாட்டில். முன்னோக்கி ஜாவாஸ்கிரிப்ட் குறியீடு மற்றும் பின்தளத்தில் பைதான் லாஜிக் இடையே சரியான தகவல்தொடர்பு தேவை என்பது கவனிக்கப்பட்ட முக்கிய சிக்கல்களில் ஒன்றாகும். அசல் சிக்கலில், பயனர் ஸ்ட்ரீம்லிட்டிற்குள் ஒரு JS செயல்பாட்டைச் செயல்படுத்த முயற்சித்தார், ஆனால் எதிர்பாராத முடிவைப் பெற்றார். மாடுலர் முறைகளைப் பயன்படுத்துவதன் மூலமும் ஸ்ட்ரீம்லிட்களைப் பயன்படுத்துவதன் மூலமும் இந்தச் சிக்கல் தீர்க்கப்பட்டது html() பயன்பாட்டில் நேரடியாக ஜாவாஸ்கிரிப்ட் ஸ்கிரிப்ட்களை உட்பொதிப்பதற்கான கூறு.

முதல் ஸ்கிரிப்ட்டில், ஒரு நிலையான எண்ணை (2) திரும்பப் பெற எளிய ஜாவாஸ்கிரிப்ட் செயல்பாடு அழைக்கப்படுகிறது. window.parent.postMessage(). இந்த முறை இன்றியமையாதது, ஏனெனில் ஜாவாஸ்கிரிப்ட் செயல்பாட்டிலிருந்து வெளியீடு பைதான் பின்தளத்திற்கு அனுப்பப்படுவதை உறுதிசெய்கிறது, ஸ்ட்ரீம்லிட்டின் வரம்பைக் கடந்து திரும்பும் மதிப்புகளுடன் JS செயல்படுத்தலை நேரடியாக ஆதரிக்காது. ஒதுக்கிடத்தைப் பயன்படுத்தி உருவாக்கப்பட்டது st.empty() ஜாவாஸ்கிரிப்ட் பதிலைப் பெற்றவுடன், பக்கம் மீண்டும் ஏற்றப்படாமல் மென்மையான பயனர் அனுபவத்தை உறுதிசெய்யும் வகையில், உள்ளடக்கத்தைப் புதுப்பிக்க பயன்பாட்டை அனுமதிக்கிறது.

இரண்டாவது அணுகுமுறை மாடுலாரிட்டி மற்றும் பிழை கையாளுதல் ஆகியவற்றை அறிமுகப்படுத்துவதன் மூலம் இதை உருவாக்குகிறது. இங்கே, ஒரு எண் உள்ளீட்டு புலம் உருவாக்கப்பட்டது st.number_input() பயனர்கள் ஜாவாஸ்கிரிப்ட் செயல்பாட்டிற்கு தரவை அனுப்ப அனுமதிக்கிறது, இது ஒரு எளிய கணக்கீட்டைச் செய்கிறது. முயற்சி-தவிர தொகுதிகளைச் சேர்ப்பது தவறான உள்ளீடுகள் முன்கூட்டியே பிடிக்கப்படுவதை உறுதிசெய்கிறது, இது பயன்பாட்டு செயலிழப்புகளைத் தடுக்கிறது. இந்த மட்டு அணுகுமுறை குறியீட்டை மீண்டும் பயன்படுத்தக்கூடியதாகவும் மாற்றியமைக்கக்கூடியதாகவும் ஆக்குகிறது, இது ஜாவாஸ்கிரிப்ட் லாஜிக் அல்லது உள்ளீடு சரிபார்ப்பு விதிகளை மாற்றுவதன் மூலம் டெவலப்பர்கள் செயல்பாட்டை விரிவாக்க அனுமதிக்கிறது.

தீர்வின் இறுதிப் பகுதியானது பைத்தானைப் பயன்படுத்தி அலகு சோதனைகளை எழுதுவதை உள்ளடக்கியது அலகு சோதனை கட்டமைப்பு. இந்த சோதனைகள் ஸ்ட்ரீம்லிட் மற்றும் ஜாவாஸ்கிரிப்ட் கூறுகள் இரண்டும் வெவ்வேறு சூழ்நிலைகளில் சரியாக வேலை செய்வதை உறுதி செய்கின்றன. பயன்பாடு சோதனை அமர்வு() பயன்பாட்டுடன் பயனர் தொடர்புகளை உருவகப்படுத்த அனுமதிக்கிறது, டெவலப்பர்களுக்கு சாத்தியமான பிழைகளை அடையாளம் காண உதவுகிறது. கூடுதலாக, போன்ற முறைகள் வலியுறுத்துகிறது() விதிவிலக்குகளைக் கையாளுவதைச் சரிபார்க்கவும், பிழைகள் அழகாக நிர்வகிக்கப்படுவதை உறுதிசெய்யவும். ஒட்டுமொத்தமாக, ஸ்ட்ரீம்லிட், ஜாவாஸ்கிரிப்ட் மற்றும் சரியான சோதனை நுட்பங்களின் கலவையானது ஊடாடும் இணைய பயன்பாடுகளை உருவாக்குவதற்கான வலுவான கட்டமைப்பை உருவாக்குகிறது.

ஸ்ட்ரீம்லிட் மற்றும் பைதான் மூலம் ஜாவாஸ்கிரிப்ட் செயல்படுத்தல் சிக்கல்களைத் தீர்க்கிறது

இந்த அணுகுமுறை ஜாவாஸ்கிரிப்டை பைத்தானுடன் ஒருங்கிணைப்பதை ஸ்ட்ரீம்லிட்டைப் பயன்படுத்தி முன்னோக்கி ஊடாடுவதை நிரூபிக்கிறது.

import streamlit as st  
from streamlit.components.v1 import html  

# Approach 1: Simple JS function to return a value  
def js_code():  
    return """  
    <script>   
        function returnNumber() {  
            return 2;  
        }  
        const result = returnNumber();  
        window.parent.postMessage(result, "*");  
    </script>   
    """  

# Displaying HTML + JS in Streamlit and capturing response  
response = st.empty()  
html(js_code(), height=0)  

# Using JavaScript listener to capture the returned value  
st.write("Waiting for JavaScript response...")  

# Listening for the message event from JavaScript  
@st.cache_data  
def listen_for_js_message(data):  
    response.write(f"JavaScript returned: {data}")

இருவழி தகவல்தொடர்புடன் மாடுலர் ஸ்ட்ரீம்லிட்-ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பை உருவாக்குதல்

இந்த பதிப்பு பிழை கையாளுதல் மற்றும் மட்டுப்படுத்தப்பட்ட பின்தளம் + முன்பகுதி அமைப்புடன் செயல்பாட்டை நீட்டிக்கிறது.

import streamlit as st  
from streamlit.components.v1 import html  
import json  

# JS function wrapped in modular code  
def js_function(value):  
    return f"""  
    <script>  
        function calculateDouble(input) {{  
            return input * 2;  
        }}  
        const result = calculateDouble({value});  
        window.parent.postMessage(result, "*");  
    </script>  
    """  

# Input validation and error handling  
try:  
    user_input = st.number_input("Enter a number", min_value=0)  
    if user_input:  
        html(js_function(user_input), height=0)  
except ValueError as e:  
    st.error(f"Invalid input: {e}")  

# JavaScript response handling  
def handle_js_response(data):  
    try:  
        result = json.loads(data)  
        st.success(f"JavaScript returned: {result}")  
    except Exception as e:  
        st.error(f"Failed to parse response: {e}")

ஜாவாஸ்கிரிப்ட் மற்றும் ஸ்ட்ரீம்லிட் குறியீடு ஒருங்கிணைப்புக்கான அலகு சோதனைகள்

யூனிட் சோதனைகளைச் சேர்ப்பது ஜாவாஸ்கிரிப்ட் செயல்பாட்டை உறுதி செய்கிறது மற்றும் ஸ்ட்ரீம்லிட் இடைமுகம் பல சூழல்களில் எதிர்பார்த்தபடி செயல்படும்.

import unittest  
from streamlit.testing import TestSession  

# Unit test for JavaScript output  
class TestJavaScriptIntegration(unittest.TestCase):  
    def test_js_output(self):  
        session = TestSession()  
        response = session.run(js_function(5))  
        self.assertEqual(response, 10, "Expected 10 as the JS function result.")  

# Unit test for Streamlit input handling  
    def test_invalid_input(self):  
        with self.assertRaises(ValueError):  
            js_function("invalid")  

# Execute the tests  
if __name__ == "__main__":  
    unittest.main()

ஜாவாஸ்கிரிப்ட் மற்றும் ஸ்ட்ரீம்லிட் மூலம் இருதரப்பு தொடர்புகளை மேம்படுத்துதல்

உடன் பணிபுரியும் போது ஸ்ட்ரீம்லிட், ஒரு சக்திவாய்ந்த ஆனால் பெரும்பாலும் பயன்படுத்தப்படாத அம்சம் முன்பக்கம் (ஜாவாஸ்கிரிப்ட்) மற்றும் பின்தளத்தில் (பைதான்) இடையே இருதரப்பு தொடர்பை ஏற்படுத்துவதாகும். பல டெவலப்பர்கள் எளிய காட்சி கூறுகளுக்கு JavaScript ஐப் பயன்படுத்துகையில், ஒரு ஆழமான ஒருங்கிணைப்பு மாறும் மேம்படுத்தல்கள் மற்றும் அதிக ஊடாடும் வலை பயன்பாடுகளை அனுமதிக்கும். முன்னர் விவாதிக்கப்பட்ட சிக்கல், ஜாவாஸ்கிரிப்ட் செயல்பாடு எதிர்பார்க்கப்படும் மதிப்பிற்குப் பதிலாக 0 ஐத் தருகிறது, இரண்டு தொழில்நுட்பங்களுக்கிடையில் காணாமல் போன தொடர்புப் பாலத்தை சுட்டிக்காட்டுகிறது.

இந்தச் சவாலைச் சமாளிப்பதற்கான ஒரு வழி, ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி, பைதான் செயல்பாடுகளைத் தூண்டுவதற்கும் அதற்கு நேர்மாறாகவும், தடையற்ற தரவு ஓட்டத்தை உருவாக்குகிறது. ஜாவாஸ்கிரிப்டை நேரடியாக ஸ்ட்ரீம்லிட்டில் உட்பொதிப்பதன் மூலம் இதை அடையலாம் html() செயல்பாடு மற்றும் நிகழ்வு கேட்போர் போன்றவற்றைப் பயன்படுத்துதல் window.parent.postMessage(). முக்கியமாக, பெற்றோர்-குழந்தை தொடர்பு மாதிரி சரியாக அமைக்கப்பட்டிருப்பதை உறுதிசெய்வது, பைதான் பக்கமானது இந்த நிகழ்வுகளைப் படம்பிடித்து அதற்கேற்ப பதிலளிக்கத் தயாராக உள்ளது. இரு முனைகளிலும் சரியான பிழை கையாளுதல் எதிர்பாராத உள்ளீடுகள் தகவல்தொடர்பு ஓட்டத்தில் குறுக்கிடாமல் இருப்பதை உறுதி செய்கிறது.

ஆராய மற்றொரு பயனுள்ள கருவி மறைக்கப்பட்ட பயன்பாடு ஆகும் HTML JavaScript குறியீட்டில் உள்ள படிவங்கள், தரவை தற்காலிகமாகச் சேமிக்கலாம் அல்லது பக்கத்தை மீண்டும் ஏற்றாமல் பின்தளத்தில் அழைப்புகளைத் தூண்டலாம். இது மிகவும் பதிலளிக்கக்கூடிய பயனர் தொடர்புகளை அனுமதிக்கிறது. கூடுதலாக, ஜாவாஸ்கிரிப்ட் நூலகங்களை (காட்சிப்படுத்தலுக்கான D3.js போன்றவை) ஸ்ட்ரீம்லிட்டில் ஒருங்கிணைப்பதன் மூலம் அடிப்படை விளக்கப்படங்களுக்கு அப்பாற்பட்ட மேம்பட்ட அம்சங்களைத் திறக்க முடியும். இந்த அணுகுமுறையானது ஒரு எளிய பைதான் பயன்பாட்டை நவீன ஒற்றைப் பக்க பயன்பாடாக உணரும் மிகவும் ஆற்றல் வாய்ந்த இடைமுகமாக மாற்றும்.

ஸ்ட்ரீம்லிட் மற்றும் ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பு பற்றிய பொதுவான கேள்விகள்

எனது ஜாவாஸ்கிரிப்ட் செயல்பாடு எப்பொழுதும் ஸ்ட்ரீம்லிட்டில் 0-ஐ ஏன் வழங்கும்?
ஏனெனில் பிரச்சினை ஏற்படுகிறது Streamlit ஜாவாஸ்கிரிப்ட் செயல்பாடுகளிலிருந்து நேரடி வருவாய் மதிப்புகளை இயல்பாக ஆதரிக்காது. நீங்கள் பயன்படுத்த வேண்டும் window.parent.postMessage() மதிப்பை மீண்டும் பின்தளத்திற்கு அனுப்ப.
ஜாவாஸ்கிரிப்ட் மூலம் ஊடாடும் டாஷ்போர்டுகளை உருவாக்க நான் ஸ்ட்ரீம்லிட்டைப் பயன்படுத்தலாமா?
ஆம்! Streamlit மூலம் JavaScript ஐ உட்பொதிக்க உங்களை அனுமதிக்கிறது html() கூறு. இது டைனமிக் டாஷ்போர்டுகளுக்கான ஜாவாஸ்கிரிப்ட்-அடிப்படையிலான ஊடாடலுடன் பைதான் லாஜிக்கை இணைக்க டெவலப்பர்களுக்கு உதவுகிறது.
பங்கு என்ன st.empty() வழங்கப்பட்ட குறியீட்டில்?
st.empty() ஸ்ட்ரீம்லிட் பயன்பாட்டில் ஒரு ஒதுக்கிடத்தை உருவாக்குகிறது, இது பின்னர் ஜாவாஸ்கிரிப்ட் பதில்கள் அல்லது பிற உள்ளடக்கத்துடன் மாறும் வகையில் புதுப்பிக்கப்படும்.
பயனர் உள்ளீட்டை JavaScriptக்கு அனுப்பும் முன் நான் எவ்வாறு சரிபார்க்க முடியும்?
நீங்கள் பயன்படுத்தலாம் st.number_input() எண் மதிப்புகளுக்கு அல்லது try-except விதிவிலக்குகளைக் கையாளும் தொகுதிகள் மற்றும் சரியான உள்ளீடுகள் மட்டுமே அனுப்பப்படுவதை உறுதிசெய்யும்.
ஸ்ட்ரீம்லிட்டுடன் மூன்றாம் தரப்பு ஜாவாஸ்கிரிப்ட் நூலகங்களைப் பயன்படுத்தலாமா?
ஆம், வெளிப்புற நூலகங்கள் போன்றவை D3.js அல்லது Chart.js இதைப் பயன்படுத்தி ஸ்ட்ரீம்லிட் பயன்பாடுகளில் உட்பொதிக்க முடியும் html() கூறு, காட்சிப்படுத்தல் திறன்களை மேம்படுத்துகிறது.

ஸ்ட்ரீம்லிட்-ஜாவாஸ்கிரிப்ட் சவால்கள் பற்றிய இறுதி எண்ணங்கள்

ஸ்ட்ரீம்லிட்டில் ஜாவாஸ்கிரிப்ட் செயல்பாடுகளின் சரியான ஒருங்கிணைப்புக்கு ஃப்ரண்ட்எண்ட்-பேக்கெண்ட் தகவல்தொடர்பு பற்றிய ஆழமான புரிதல் தேவை. பயன்படுத்தி html() போன்ற முறைகளுடன் கூறுகள் postMessage() வரம்புகளை கடந்து இரு அடுக்குகளுக்கு இடையே தடையற்ற தரவு பரிமாற்றத்தை அடைய உதவுகிறது.

சரிசெய்தலுக்கு அப்பால், டெவலப்பர்கள் யூனிட் சோதனைகள் மற்றும் சரியான உள்ளீடு சரிபார்ப்பு ஆகியவற்றை இணைத்து செயல்திறனை மேம்படுத்துவதில் கவனம் செலுத்த வேண்டும். இந்த அணுகுமுறை தொழில்நுட்பச் சிக்கல்களைத் தீர்ப்பது மட்டுமல்லாமல், நவீன வலைப் பயன்பாடுகளில் பல்வேறு பயன்பாட்டு நிகழ்வுகளுக்கு Streamlit பயன்பாடுகளை மிகவும் திறமையாகவும், அளவிடக்கூடியதாகவும், ஊடாடத்தக்கதாகவும் ஆக்குகிறது.

ஸ்ட்ரீம்லிட்-ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்புக்கான குறிப்புகள் மற்றும் ஆதாரங்கள்

ஸ்ட்ரீம்லிட் கூறுகள் மற்றும் ஜாவாஸ்கிரிப்ட் உட்பொதித்தல் பற்றிய விவரங்கள்: ஸ்ட்ரீம்லிட் ஆவணப்படுத்தல்
பயன்படுத்துவது பற்றிய தகவல் postMessage() ஜாவாஸ்கிரிப்ட்டில் குறுக்கு சாளர தொடர்பு: MDN வெப் டாக்ஸ்
மலைப்பாம்பு அலகு சோதனை ஸ்ட்ரீம்லிட் பயன்பாடுகளைச் சோதிப்பதற்கான தொகுதி வழிகாட்டி: பைதான் அதிகாரப்பூர்வ ஆவணம்

ஸ்ட்ரீம்லிட் பைதான் ஒருங்கிணைப்பில் ஜாவாஸ்கிரிப்ட் ரிட்டர்ன் சிக்கல்களை எவ்வாறு சரிசெய்வது