ਸਟ੍ਰੀਮਲਿਟ ਪਾਈਥਨ ਏਕੀਕਰਣ ਵਿੱਚ JavaScript ਰਿਟਰਨ ਮੁੱਦਿਆਂ ਨੂੰ ਕਿਵੇਂ ਠੀਕ ਕਰਨਾ ਹੈ

Streamlit ਵਿੱਚ JavaScript ਏਕੀਕਰਣ ਚੁਣੌਤੀਆਂ ਨੂੰ ਪਾਰ ਕਰਨਾ

ਸਟ੍ਰੀਮਲਾਈਟ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੇਟਾ-ਸੰਚਾਲਿਤ ਵੈਬ ਐਪਸ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਾਧਨ ਹੈ, ਪਰ ਏਕੀਕ੍ਰਿਤ ਹੈ JavaScript ਫੰਕਸ਼ਨ ਕਈ ਵਾਰ ਅਚਾਨਕ ਚੁਣੌਤੀਆਂ ਪੇਸ਼ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਅਕਸਰ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਜਦੋਂ JavaScript ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਨ ਅਤੇ ਇਸਦੇ ਨਤੀਜੇ ਸਟ੍ਰੀਮਲਾਈਟ ਦੇ ਅੰਦਰ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ।

ਇੱਕ ਆਮ ਨਿਰਾਸ਼ਾ ਪੈਦਾ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਏ JavaScript ਫੰਕਸ਼ਨ ਦਾ ਵਾਪਸੀ ਮੁੱਲ ਨੂੰ ਗਲਤ ਤਰੀਕੇ ਨਾਲ 0 ਦੇ ਰੂਪ ਵਿੱਚ ਰੈਂਡਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਭਾਵੇਂ ਕਿ ਫੰਕਸ਼ਨ ਆਪਣੇ ਆਪ ਵਿੱਚ ਤਰਕ ਨਾਲ ਸਹੀ ਜਾਪਦਾ ਹੈ। ਇਹ ਸਥਿਤੀ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਉਲਝਣ ਵਿੱਚ ਪਾ ਸਕਦੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਉਹ ਜਿਹੜੇ Python ਅਤੇ JavaScript ਦੋਵਾਂ ਤੋਂ ਜਾਣੂ ਹਨ, ਜਿਸ ਨਾਲ ਸਮਾਂ-ਬਰਬਾਦ ਸਮੱਸਿਆ ਦਾ ਨਿਪਟਾਰਾ ਹੁੰਦਾ ਹੈ।

ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਉਦਾਹਰਨ ਵਿੱਚ, ਉਪਭੋਗਤਾ JavaScript ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਅਗਿਆਤ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ ਜੋ 2 ਦਾ ਮੁੱਲ ਦਿੰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਸੰਭਾਵਿਤ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਆਉਟਪੁੱਟ ਹਮੇਸ਼ਾ 0 ਦਿਖਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਕੋਡ ਵਿੱਚ ਕੀ ਗਲਤ ਹੋ ਰਿਹਾ ਹੈ ਇਸ ਬਾਰੇ ਭੰਬਲਭੂਸਾ ਪੈਦਾ ਹੁੰਦਾ ਹੈ। ਐਗਜ਼ੀਕਿਊਸ਼ਨ

ਇਹ ਲੇਖ ਮੂਲ ਮੁੱਦਿਆਂ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ ਜੋ ਸਮੱਸਿਆ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ ਅਤੇ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਟ੍ਰੀਮਲਾਈਟ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਜੋੜਨ ਲਈ ਸਹੀ ਸੰਟੈਕਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਕੋਡ ਨੂੰ ਤੋੜਾਂਗੇ, ਸੰਭਾਵਿਤ ਗਲਤ ਸੰਰਚਨਾਵਾਂ ਦੀ ਪਛਾਣ ਕਰਾਂਗੇ, ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵਿਕਲਪਕ ਪਹੁੰਚਾਂ ਦਾ ਸੁਝਾਅ ਦੇਵਾਂਗੇ ਕਿ JavaScript ਫੰਕਸ਼ਨ ਸੰਭਾਵਿਤ ਮੁੱਲ ਵਾਪਸ ਕਰਦੇ ਹਨ।

ਸਟ੍ਰੀਮਲਾਈਟ ਅਤੇ ਜਾਵਾ ਸਕ੍ਰਿਪਟ: ਏਕੀਕਰਣ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਮਝਣਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਉਦਾਹਰਨਾਂ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਕਿਵੇਂ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ ਹੈ JavaScript ਫੰਕਸ਼ਨ ਇੰਟਰਐਕਟੀਵਿਟੀ ਨੂੰ ਵਧਾਉਣ ਲਈ ਪਾਈਥਨ-ਅਧਾਰਿਤ ਸਟ੍ਰੀਮਲਾਈਟ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ। ਸੰਬੋਧਿਤ ਕੀਤੇ ਗਏ ਮੁੱਖ ਮੁੱਦਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਫਰੰਟਐਂਡ JavaScript ਕੋਡ ਅਤੇ ਬੈਕਐਂਡ ਪਾਈਥਨ ਤਰਕ ਵਿਚਕਾਰ ਸਹੀ ਸੰਚਾਰ ਦੀ ਲੋੜ ਹੈ। ਅਸਲ ਸਮੱਸਿਆ ਵਿੱਚ, ਉਪਭੋਗਤਾ Streamlit ਦੇ ਅੰਦਰ ਇੱਕ JS ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਸੀ ਪਰ ਇੱਕ ਅਚਾਨਕ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰ ਰਿਹਾ ਸੀ। ਇਸ ਮੁੱਦੇ ਨੂੰ ਮਾਡਿਊਲਰ ਢੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਤੇ ਸਟ੍ਰੀਮਲਾਈਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੱਲ ਕੀਤਾ ਗਿਆ ਸੀ html() JavaScript ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਸਿੱਧੇ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਕੰਪੋਨੈਂਟ।

ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਇੱਕ ਸਧਾਰਣ JavaScript ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸੰਖਿਆ (2) ਵਾਪਸ ਕਰਨ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਨਤੀਜਾ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੈਪਚਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ window.parent.postMessage(). ਇਹ ਵਿਧੀ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ JavaScript ਫੰਕਸ਼ਨ ਤੋਂ ਆਉਟਪੁੱਟ ਪਾਈਥਨ ਬੈਕਐਂਡ 'ਤੇ ਭੇਜੀ ਜਾ ਸਕਦੀ ਹੈ, ਸਟ੍ਰੀਮਲਾਈਟ ਦੀ ਸੀਮਾ ਨੂੰ ਪਾਰ ਕਰਦੇ ਹੋਏ, ਵਾਪਸੀ ਮੁੱਲਾਂ ਨਾਲ JS ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਸਿੱਧਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਪਲੇਸਹੋਲਡਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਗਿਆ st.empty() ਐਪ ਨੂੰ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਜਵਾਬ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹੀ ਸਮੱਗਰੀ ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਪੰਨਾ ਰੀਲੋਡ ਕੀਤੇ ਬਿਨਾਂ ਨਿਰਵਿਘਨ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।

ਦੂਜੀ ਪਹੁੰਚ ਇਸ 'ਤੇ ਮਾਡਿਊਲਰਿਟੀ ਅਤੇ ਐਰਰ ਹੈਂਡਲਿੰਗ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਕੇ ਬਣਦੀ ਹੈ। ਇੱਥੇ, ਇੱਕ ਸੰਖਿਆਤਮਕ ਇਨਪੁਟ ਖੇਤਰ ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ st.number_input() ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ JavaScript ਫੰਕਸ਼ਨ ਵਿੱਚ ਡੇਟਾ ਪਾਸ ਕਰਨ ਦਿੰਦਾ ਹੈ, ਜੋ ਫਿਰ ਇੱਕ ਸਧਾਰਨ ਗਣਨਾ ਕਰਦਾ ਹੈ। ਅਜ਼ਮਾਇਸ਼-ਸਿਵਾਏ ਬਲਾਕਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਅਵੈਧ ਇਨਪੁਟਸ ਜਲਦੀ ਫੜੇ ਗਏ ਹਨ, ਐਪਲੀਕੇਸ਼ਨ ਕਰੈਸ਼ਾਂ ਨੂੰ ਰੋਕਦੇ ਹੋਏ। ਇਹ ਮਾਡਯੂਲਰ ਪਹੁੰਚ ਕੋਡ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਅਤੇ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਸਿਰਫ਼ JavaScript ਤਰਕ ਜਾਂ ਇਨਪੁਟ ਪ੍ਰਮਾਣਿਕਤਾ ਨਿਯਮਾਂ ਨੂੰ ਸੋਧ ਕੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦਾ ਵਿਸਥਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਮਿਲਦੀ ਹੈ।

ਹੱਲ ਦੇ ਅੰਤਮ ਹਿੱਸੇ ਵਿੱਚ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਯੂਨਿਟ ਟੈਸਟ ਲਿਖਣਾ ਸ਼ਾਮਲ ਹੈ ਯੂਨਿਟ ਟੈਸਟ ਫਰੇਮਵਰਕ ਇਹ ਟੈਸਟ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹਨ ਕਿ Streamlit ਅਤੇ JavaScript ਦੋਵੇਂ ਭਾਗ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ। ਦੀ ਵਰਤੋਂ ਟੈਸਟ ਸੈਸ਼ਨ() ਸੰਭਾਵੀ ਬੱਗਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਡਿਵੈਲਪਰਾਂ ਦੀ ਮਦਦ ਕਰਦੇ ਹੋਏ, ਐਪ ਨਾਲ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨਾਂ ਦੇ ਸਿਮੂਲੇਸ਼ਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤਰੀਕੇ ਜਿਵੇਂ ਕਿ assertRaises() ਅਪਵਾਦਾਂ ਦੇ ਪ੍ਰਬੰਧਨ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰੋ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ ਕਿ ਤਰੁੱਟੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੁੱਲ ਮਿਲਾ ਕੇ, Streamlit, JavaScript, ਅਤੇ ਸਹੀ ਟੈਸਟਿੰਗ ਤਕਨੀਕਾਂ ਦਾ ਸੁਮੇਲ ਇੰਟਰਐਕਟਿਵ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਲਈ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਫਰੇਮਵਰਕ ਬਣਾਉਂਦਾ ਹੈ।

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 ਅਤੇ Streamlit ਨਾਲ ਦੋ-ਪੱਖੀ ਸੰਚਾਰ ਦਾ ਲਾਭ ਉਠਾਉਣਾ

ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਸਟ੍ਰੀਮਲਾਈਟ, ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪਰ ਅਕਸਰ ਘੱਟ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਪਹਿਲੂ ਫਰੰਟਐਂਡ (ਜਾਵਾ ਸਕ੍ਰਿਪਟ) ਅਤੇ ਬੈਕਐਂਡ (ਪਾਈਥਨ) ਵਿਚਕਾਰ ਦੋ-ਦਿਸ਼ਾ ਸੰਚਾਰ ਸਥਾਪਤ ਕਰ ਰਿਹਾ ਹੈ। ਜਦੋਂ ਕਿ ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਸਧਾਰਨ ਵਿਜ਼ੂਅਲ ਤੱਤਾਂ ਲਈ JavaScript ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਇੱਕ ਡੂੰਘੀ ਏਕੀਕਰਣ ਗਤੀਸ਼ੀਲ ਅੱਪਡੇਟ ਅਤੇ ਹੋਰ ਇੰਟਰਐਕਟਿਵ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਆਗਿਆ ਦੇ ਸਕਦਾ ਹੈ। ਪਹਿਲਾਂ ਵਿਚਾਰਿਆ ਗਿਆ ਮੁੱਦਾ, ਜਿੱਥੇ JavaScript ਫੰਕਸ਼ਨ ਸੰਭਾਵਿਤ ਮੁੱਲ ਦੀ ਬਜਾਏ 0 ਵਾਪਸ ਕਰਦਾ ਹੈ, ਦੋ ਤਕਨਾਲੋਜੀਆਂ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਗੁੰਮ ਸੰਚਾਰ ਪੁਲ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ।

ਇਸ ਚੁਣੌਤੀ ਨੂੰ ਦੂਰ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਪਾਈਥਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਟਰਿੱਗਰ ਕਰਨ ਲਈ ਅਤੇ ਇਸਦੇ ਉਲਟ, ਡੇਟਾ ਦਾ ਇੱਕ ਸਹਿਜ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਹੈ। ਇਹ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਿੱਧਾ ਸਟ੍ਰੀਮਲਾਈਟ ਵਿੱਚ ਏਮਬੈਡ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ html() ਫੰਕਸ਼ਨ ਅਤੇ ਇਵੈਂਟ ਸਰੋਤਿਆਂ ਨੂੰ ਰੁਜ਼ਗਾਰ ਦੇਣਾ ਜਿਵੇਂ ਕਿ window.parent.postMessage(). ਕੁੰਜੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਮਾਤਾ-ਪਿਤਾ-ਬੱਚੇ ਦੇ ਸੰਚਾਰ ਮਾਡਲ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਥਾਪਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਾਈਥਨ ਸਾਈਡ ਇਹਨਾਂ ਘਟਨਾਵਾਂ ਨੂੰ ਹਾਸਲ ਕਰਨ ਲਈ ਤਿਆਰ ਹੈ ਅਤੇ ਇਸਦੇ ਅਨੁਸਾਰ ਜਵਾਬ ਦੇਣ ਲਈ ਤਿਆਰ ਹੈ। ਦੋਵਾਂ ਸਿਰਿਆਂ 'ਤੇ ਸਹੀ ਤਰੁੱਟੀ ਨੂੰ ਸੰਭਾਲਣਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਅਚਾਨਕ ਇਨਪੁਟ ਸੰਚਾਰ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਿਘਨ ਨਹੀਂ ਪਾਉਂਦੇ ਹਨ।

ਖੋਜਣ ਲਈ ਇੱਕ ਹੋਰ ਉਪਯੋਗੀ ਸੰਦ ਹੈ ਲੁਕਿਆ ਹੋਇਆ ਦੀ ਵਰਤੋਂ HTML JavaScript ਕੋਡ ਦੇ ਅੰਦਰ ਫਾਰਮ, ਜੋ ਪੰਨੇ ਨੂੰ ਰੀਲੋਡ ਕੀਤੇ ਬਿਨਾਂ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਡਾਟਾ ਸਟੋਰ ਕਰ ਸਕਦਾ ਹੈ ਜਾਂ ਬੈਕਐਂਡ ਕਾਲਾਂ ਨੂੰ ਟਰਿੱਗਰ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਵਧੇਰੇ ਜਵਾਬਦੇਹ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨਾਂ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, JavaScript ਲਾਇਬ੍ਰੇਰੀਆਂ (ਜਿਵੇਂ ਕਿ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ D3.js) ਨੂੰ ਸਟ੍ਰੀਮਲਿਟ ਵਿੱਚ ਜੋੜਨਾ ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਅਨਲੌਕ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਬੁਨਿਆਦੀ ਚਾਰਟ ਤੋਂ ਪਰੇ ਹਨ। ਇਹ ਪਹੁੰਚ ਇੱਕ ਸਧਾਰਨ ਪਾਈਥਨ ਐਪ ਨੂੰ ਇੱਕ ਉੱਚ ਗਤੀਸ਼ੀਲ ਇੰਟਰਫੇਸ ਵਿੱਚ ਬਦਲ ਸਕਦੀ ਹੈ ਜੋ ਇੱਕ ਆਧੁਨਿਕ ਸਿੰਗਲ-ਪੇਜ ਐਪਲੀਕੇਸ਼ਨ ਵਾਂਗ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ।