usethatapp 0.1.0__tar.gz

usethatapp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 UseThatApp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

usethatapp-0.1.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: usethatapp
+Version: 0.1.0
+Summary: For use in your UseThatApp Web Apps
+Author-email: UseThatApp <support@usethatapp.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/UseThatApp/python
+Keywords: UseThatApp,Python,Web Apps
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography==46.0.5
+Dynamic: license-file
+
+# Summary
+Use this package with your UseThatApp WebApps to acquire user license info from UseThatApp.com.
+
+# Usage
+
+## Single Page Dash App
+In a simple single page Dash-Plotly application.
+
+```python
+from dash import Dash, dcc, html, Input, Output, ClientsideFunction
+from usethatapp.webapps import get_product
+
+
+app = Dash(__name__, external_scripts=[
+    "https://cdn.jsdelivr.net/gh/UseThatApp/cdn@latest/usethatapp.js"
+])
+
+app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
+    html.Div(id='content'),
+    dcc.Store(id='access-level-store', data=None, storage_type='memory'),
+])
+
+app.clientside_callback(
+    ClientsideFunction(namespace='clientside', function_name='requestAccessLevel'),
+    Output("access-level-store", "data"),
+    Input('url', 'pathname')
+)
+
+@app.callback(
+    Output('content', 'children'), 
+    Input("access-level-store", "data")
+)
+def display_content_based_on_access(data):
+    try:
+        product = get_product(
+            data['message'],
+            public_key_path=r'/Path/To/File/Containing/UseThatApp_Public_Key',
+            private_key_path=r'/Path/To/File/Containing/My_UTA_Private_Key'
+        )
+        # display content based on licensed plan
+        if product == 'Pro':
+            return html.Div([html.H1(["Paid Content"])])
+    except Exception as e:
+        # If there's an error (e.g. clientside hasn't populated the store yet), fall back to free content
+        app.logger.exception("Error determining product: %s", e)
+    return html.Div([html.H1(["Free Content"])])
+```
+
+## Mult-Page Dash App
+In a multi-page Dash-Plotly application (using Dash Pages). The pattern below mirrors the single-page example: the main `app` registers a clientside callback that places the UseThatApp message into a `dcc.Store`, and each page reads that store (via a callback) and calls `get_product` to decide what to render.
+
+### app.py
+```python
+import dash
+from dash import Dash, html, dcc, Input, Output, ClientsideFunction
+
+APP_TITLE = "Dash App"
+
+app = Dash(
+    __name__,
+    title=APP_TITLE,
+    use_pages=True,  # Allows us to register pages
+    external_scripts=["https://cdn.jsdelivr.net/gh/UseThatApp/cdn@latest/usethatapp.js"],
+)
+
+# Top-level layout includes Location, a Store for the access payload, and the page container
+app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
+    dcc.Store(id='access-level-store', data=None, storage_type='memory'),
+    dash.page_container,
+])
+
+# Register the same clientside callback used in the single-page example to populate the store
+app.clientside_callback(
+    ClientsideFunction(namespace='clientside', function_name='requestAccessLevel'),
+    Output('access-level-store', 'data'),
+    Input('url', 'pathname')
+)
+
+server = app.server
+
+if __name__ == '__main__':
+    app.run_server(debug=True)
+```
+
+### pages/home.py
+```python
+from dash import html, register_page, Input, Output, dash
+from usethatapp.webapps import get_product
+
+register_page(
+    __name__,
+    name='Home',
+    path='/'
+)
+
+# Page layout is a placeholder container which we'll populate via a callback that
+# listens to the shared `access-level-store` placed by the clientside JS.
+def layout(**url_vars):
+    return html.Div(id='home-content')
+
+# Use dash.callback (so the callback is registered on the global app when pages are loaded)
+@dash.callback(Output('home-content', 'children'), Input('access-level-store', 'data'))
+def display_content_based_on_access(data):
+    # Use the helper function to parse the message and determine the licensed product
+    try:
+        product = get_product(
+            data['message'],
+            public_key_path=r'/Path/To/File/Containing/UseThatApp_Public_Key',
+            private_key_path=r'/Path/To/File/Containing/My_UTA_Private_Key'
+        )
+
+        if product == 'Pro':
+            return html.Div([html.H1(["Paid Content"])])
+    except Exception as e:
+        # If there's an error (e.g. clientside hasn't populated the store yet), fall back to free content
+        dash.get_app().server.logger.exception("Error determining product: %s", e)
+    return html.Div([html.H1(["Free Content"])])
+```
+
+# Change Log
+
+## Version 0.1.0 (03/19/2026)
+- Initial release 
+

usethatapp-0.1.0/README.md

@@ -0,0 +1,126 @@
+# Summary
+Use this package with your UseThatApp WebApps to acquire user license info from UseThatApp.com.
+
+# Usage
+
+## Single Page Dash App
+In a simple single page Dash-Plotly application.
+
+```python
+from dash import Dash, dcc, html, Input, Output, ClientsideFunction
+from usethatapp.webapps import get_product
+
+
+app = Dash(__name__, external_scripts=[
+    "https://cdn.jsdelivr.net/gh/UseThatApp/cdn@latest/usethatapp.js"
+])
+
+app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
+    html.Div(id='content'),
+    dcc.Store(id='access-level-store', data=None, storage_type='memory'),
+])
+
+app.clientside_callback(
+    ClientsideFunction(namespace='clientside', function_name='requestAccessLevel'),
+    Output("access-level-store", "data"),
+    Input('url', 'pathname')
+)
+
+@app.callback(
+    Output('content', 'children'), 
+    Input("access-level-store", "data")
+)
+def display_content_based_on_access(data):
+    try:
+        product = get_product(
+            data['message'],
+            public_key_path=r'/Path/To/File/Containing/UseThatApp_Public_Key',
+            private_key_path=r'/Path/To/File/Containing/My_UTA_Private_Key'
+        )
+        # display content based on licensed plan
+        if product == 'Pro':
+            return html.Div([html.H1(["Paid Content"])])
+    except Exception as e:
+        # If there's an error (e.g. clientside hasn't populated the store yet), fall back to free content
+        app.logger.exception("Error determining product: %s", e)
+    return html.Div([html.H1(["Free Content"])])
+```
+
+## Mult-Page Dash App
+In a multi-page Dash-Plotly application (using Dash Pages). The pattern below mirrors the single-page example: the main `app` registers a clientside callback that places the UseThatApp message into a `dcc.Store`, and each page reads that store (via a callback) and calls `get_product` to decide what to render.
+
+### app.py
+```python
+import dash
+from dash import Dash, html, dcc, Input, Output, ClientsideFunction
+
+APP_TITLE = "Dash App"
+
+app = Dash(
+    __name__,
+    title=APP_TITLE,
+    use_pages=True,  # Allows us to register pages
+    external_scripts=["https://cdn.jsdelivr.net/gh/UseThatApp/cdn@latest/usethatapp.js"],
+)
+
+# Top-level layout includes Location, a Store for the access payload, and the page container
+app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
+    dcc.Store(id='access-level-store', data=None, storage_type='memory'),
+    dash.page_container,
+])
+
+# Register the same clientside callback used in the single-page example to populate the store
+app.clientside_callback(
+    ClientsideFunction(namespace='clientside', function_name='requestAccessLevel'),
+    Output('access-level-store', 'data'),
+    Input('url', 'pathname')
+)
+
+server = app.server
+
+if __name__ == '__main__':
+    app.run_server(debug=True)
+```
+
+### pages/home.py
+```python
+from dash import html, register_page, Input, Output, dash
+from usethatapp.webapps import get_product
+
+register_page(
+    __name__,
+    name='Home',
+    path='/'
+)
+
+# Page layout is a placeholder container which we'll populate via a callback that
+# listens to the shared `access-level-store` placed by the clientside JS.
+def layout(**url_vars):
+    return html.Div(id='home-content')
+
+# Use dash.callback (so the callback is registered on the global app when pages are loaded)
+@dash.callback(Output('home-content', 'children'), Input('access-level-store', 'data'))
+def display_content_based_on_access(data):
+    # Use the helper function to parse the message and determine the licensed product
+    try:
+        product = get_product(
+            data['message'],
+            public_key_path=r'/Path/To/File/Containing/UseThatApp_Public_Key',
+            private_key_path=r'/Path/To/File/Containing/My_UTA_Private_Key'
+        )
+
+        if product == 'Pro':
+            return html.Div([html.H1(["Paid Content"])])
+    except Exception as e:
+        # If there's an error (e.g. clientside hasn't populated the store yet), fall back to free content
+        dash.get_app().server.logger.exception("Error determining product: %s", e)
+    return html.Div([html.H1(["Free Content"])])
+```
+
+# Change Log
+
+## Version 0.1.0 (03/19/2026)
+- Initial release 
+

usethatapp-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=82.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "usethatapp"
+version = "0.1.0"
+description = "For use in your UseThatApp Web Apps"
+readme = "README.md"
+authors = [{ name = "UseThatApp", email = "support@usethatapp.com"}]
+license = "MIT"
+license-files= ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["UseThatApp", "Python", "Web Apps"]
+dependencies = [
+    "cryptography == 46.0.5",
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/UseThatApp/python"

usethatapp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

usethatapp-0.1.0/usethatapp/encryption.py

@@ -0,0 +1,79 @@
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+
+
+def decrypt_message(private_key: rsa.RSAPrivateKey, encrypted_message: bytes) -> bytes:
+    """Decrypts a message
+
+    Note: Uses SHA256 encryption
+
+    Args:
+        private_key: the private key used for decryption
+        encrypted_message: the message to be decrypted
+
+    Returns:
+        The decrypted message
+    """
+    decrypted_message = private_key.decrypt(
+        encrypted_message,
+        padding.OAEP(
+            mgf=padding.MGF1(algorithm=hashes.SHA256()),
+            algorithm=hashes.SHA256(),
+            label=None
+        )
+    )
+    return decrypted_message
+
+
+def verify_signature(public_key: rsa.RSAPublicKey, signature: bytes, message: bytes) -> bool:
+    """Verifies a signature on an encrypted message
+
+    Note: Uses SHA256 encryption
+
+    Args:
+        public_key: the public key used for signature verification
+        signature: the signature to be verified
+        message: the message signed by the signature
+
+    Returns:
+        True if verification passes, False otherwise
+    """
+    try:
+        public_key.verify(
+            signature,
+            message,
+            padding.PSS(
+                mgf=padding.MGF1(hashes.SHA256()),
+                salt_length=padding.PSS.MAX_LENGTH
+            ),
+            hashes.SHA256()
+        )
+    except InvalidSignature:
+        return False
+    return True
+
+
+class Keys:
+
+    @classmethod
+    def read_public_key_from_string(cls, pem_str: str) -> rsa.RSAPublicKey:
+        pem_public_key = pem_str.encode().decode('unicode-escape').encode()
+        return serialization.load_pem_public_key(pem_public_key)
+
+    @classmethod
+    def read_public_key_from_file(cls, file_path: str) -> rsa.RSAPublicKey:
+        with open(file_path, 'rb') as key_file:
+            return serialization.load_pem_public_key(key_file.read())
+
+    @classmethod
+    def read_private_key_from_string(cls, pem_str: str) -> rsa.RSAPrivateKey:
+        pem_private_key = pem_str.encode().decode('unicode-escape').encode()
+        return serialization.load_pem_private_key(pem_private_key, password=None)
+
+    @classmethod
+    def read_private_key_from_file(cls, file_path: str) -> rsa.RSAPrivateKey:
+        with open(file_path, 'rb') as key_file:
+            return serialization.load_pem_private_key(key_file.read(), password=None)
+
+

usethatapp-0.1.0/usethatapp/webapps.py

@@ -0,0 +1,97 @@
+from typing import Union
+import json
+
+from .encryption import Keys, decrypt_message, verify_signature
+
+
+def _normalize_hex(h: str) -> str:
+    if h is None:
+        raise ValueError("hex input is None")
+    h = h.strip()
+    if h.startswith("0x") or h.startswith("0X"):
+        h = h[2:]
+    if len(h) % 2 != 0:
+        # hex strings must have an even length
+        raise ValueError("invalid hex string (odd length)")
+    return h
+
+
+def get_product(
+    message,
+    public_key_path: str,
+    private_key_path: str,
+    encoding: str = "utf-8",
+) -> Union[str, bytes]:
+    """Verify a hex signature and decrypt a hex-encoded encrypted message from a JSON message.
+
+    Args:
+        message: a dict or JSON string containing two keys: "signature" and "contents",
+                 both values should be hex strings (optionally prefixed with 0x).
+        public_key_path: path to the PEM public key file used to verify the signature
+        private_key_path: path to the PEM private key file used to decrypt the message
+        encoding: if provided, the decrypted bytes will be decoded to a string using this encoding;
+                  if decoding fails, the raw bytes are returned.
+
+    Returns:
+        The decrypted message as a string (when decoding succeeds) or bytes.
+
+    Raises:
+        ValueError: on invalid inputs, missing keys, or failed signature verification.
+    """
+    # accept either a dict or a JSON string
+    if isinstance(message, str):
+        try:
+            message_obj = json.loads(message)
+        except Exception as e:
+            raise ValueError(f"failed to parse message JSON: {e}")
+    elif isinstance(message, dict):
+        message_obj = message
+    else:
+        raise ValueError("message must be a dict or JSON string")
+
+    # extract expected fields
+    try:
+        signature_hex = message_obj["signature"]
+        encrypted_message_hex = message_obj.get("contents") or message_obj.get("content")
+    except Exception as e:
+        raise ValueError(f"message must contain 'signature' and 'contents' fields: {e}")
+
+    if encrypted_message_hex is None:
+        raise ValueError("message missing 'contents' field")
+
+    # normalize and convert hex inputs to bytes
+    try:
+        sig_hex = _normalize_hex(signature_hex)
+        msg_hex = _normalize_hex(encrypted_message_hex)
+        signature = bytes.fromhex(sig_hex)
+        encrypted_message = bytes.fromhex(msg_hex)
+    except ValueError as e:
+        raise ValueError(f"invalid hex input: {e}")
+
+    # load keys from files using the Keys helpers in encryption.py
+    try:
+        public_key = Keys.read_public_key_from_file(public_key_path)
+    except Exception as e:
+        raise ValueError(f"failed to read public key from '{public_key_path}': {e}")
+
+    try:
+        private_key = Keys.read_private_key_from_file(private_key_path)
+    except Exception as e:
+        raise ValueError(f"failed to read private key from '{private_key_path}': {e}")
+
+    # verify the signature against the encrypted message
+    verified = verify_signature(public_key, signature, encrypted_message)
+    if not verified:
+        raise ValueError("signature verification failed")
+
+    # decrypt the message
+    decrypted = decrypt_message(private_key, encrypted_message)
+
+    # try to decode to text; if decoding fails, return raw bytes
+    try:
+        return decrypted.decode(encoding)
+    except Exception:
+        return decrypted
+
+
+__all__ = ["get_product"]

usethatapp-0.1.0/usethatapp.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: usethatapp
+Version: 0.1.0
+Summary: For use in your UseThatApp Web Apps
+Author-email: UseThatApp <support@usethatapp.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/UseThatApp/python
+Keywords: UseThatApp,Python,Web Apps
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography==46.0.5
+Dynamic: license-file
+
+# Summary
+Use this package with your UseThatApp WebApps to acquire user license info from UseThatApp.com.
+
+# Usage
+
+## Single Page Dash App
+In a simple single page Dash-Plotly application.
+
+```python
+from dash import Dash, dcc, html, Input, Output, ClientsideFunction
+from usethatapp.webapps import get_product
+
+
+app = Dash(__name__, external_scripts=[
+    "https://cdn.jsdelivr.net/gh/UseThatApp/cdn@latest/usethatapp.js"
+])
+
+app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
+    html.Div(id='content'),
+    dcc.Store(id='access-level-store', data=None, storage_type='memory'),
+])
+
+app.clientside_callback(
+    ClientsideFunction(namespace='clientside', function_name='requestAccessLevel'),
+    Output("access-level-store", "data"),
+    Input('url', 'pathname')
+)
+
+@app.callback(
+    Output('content', 'children'), 
+    Input("access-level-store", "data")
+)
+def display_content_based_on_access(data):
+    try:
+        product = get_product(
+            data['message'],
+            public_key_path=r'/Path/To/File/Containing/UseThatApp_Public_Key',
+            private_key_path=r'/Path/To/File/Containing/My_UTA_Private_Key'
+        )
+        # display content based on licensed plan
+        if product == 'Pro':
+            return html.Div([html.H1(["Paid Content"])])
+    except Exception as e:
+        # If there's an error (e.g. clientside hasn't populated the store yet), fall back to free content
+        app.logger.exception("Error determining product: %s", e)
+    return html.Div([html.H1(["Free Content"])])
+```
+
+## Mult-Page Dash App
+In a multi-page Dash-Plotly application (using Dash Pages). The pattern below mirrors the single-page example: the main `app` registers a clientside callback that places the UseThatApp message into a `dcc.Store`, and each page reads that store (via a callback) and calls `get_product` to decide what to render.
+
+### app.py
+```python
+import dash
+from dash import Dash, html, dcc, Input, Output, ClientsideFunction
+
+APP_TITLE = "Dash App"
+
+app = Dash(
+    __name__,
+    title=APP_TITLE,
+    use_pages=True,  # Allows us to register pages
+    external_scripts=["https://cdn.jsdelivr.net/gh/UseThatApp/cdn@latest/usethatapp.js"],
+)
+
+# Top-level layout includes Location, a Store for the access payload, and the page container
+app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
+    dcc.Store(id='access-level-store', data=None, storage_type='memory'),
+    dash.page_container,
+])
+
+# Register the same clientside callback used in the single-page example to populate the store
+app.clientside_callback(
+    ClientsideFunction(namespace='clientside', function_name='requestAccessLevel'),
+    Output('access-level-store', 'data'),
+    Input('url', 'pathname')
+)
+
+server = app.server
+
+if __name__ == '__main__':
+    app.run_server(debug=True)
+```
+
+### pages/home.py
+```python
+from dash import html, register_page, Input, Output, dash
+from usethatapp.webapps import get_product
+
+register_page(
+    __name__,
+    name='Home',
+    path='/'
+)
+
+# Page layout is a placeholder container which we'll populate via a callback that
+# listens to the shared `access-level-store` placed by the clientside JS.
+def layout(**url_vars):
+    return html.Div(id='home-content')
+
+# Use dash.callback (so the callback is registered on the global app when pages are loaded)
+@dash.callback(Output('home-content', 'children'), Input('access-level-store', 'data'))
+def display_content_based_on_access(data):
+    # Use the helper function to parse the message and determine the licensed product
+    try:
+        product = get_product(
+            data['message'],
+            public_key_path=r'/Path/To/File/Containing/UseThatApp_Public_Key',
+            private_key_path=r'/Path/To/File/Containing/My_UTA_Private_Key'
+        )
+
+        if product == 'Pro':
+            return html.Div([html.H1(["Paid Content"])])
+    except Exception as e:
+        # If there's an error (e.g. clientside hasn't populated the store yet), fall back to free content
+        dash.get_app().server.logger.exception("Error determining product: %s", e)
+    return html.Div([html.H1(["Free Content"])])
+```
+
+# Change Log
+
+## Version 0.1.0 (03/19/2026)
+- Initial release 
+

usethatapp-0.1.0/usethatapp.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+usethatapp/__init__.py
+usethatapp/encryption.py
+usethatapp/webapps.py
+usethatapp.egg-info/PKG-INFO
+usethatapp.egg-info/SOURCES.txt
+usethatapp.egg-info/dependency_links.txt
+usethatapp.egg-info/requires.txt
+usethatapp.egg-info/top_level.txt

usethatapp-0.1.0/usethatapp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

usethatapp-0.1.0/usethatapp.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography==46.0.5

usethatapp-0.1.0/usethatapp.egg-info/top_level.txt

@@ -0,0 +1 @@
+usethatapp