chartout 0.0.0__tar.gz

chartout-0.0.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: chartout
+Version: 0.0.0
+Summary: Chartout - Print Your Insights, Anytime, Anywhere
+Home-page: https://chartout.io
+Download-URL: https://download_url.com
+Author: mattijn
+Author-email: info@hoekinsights.nl
+License: GPL-3.0 license
+Project-URL: Source, https://github.com/hoekinsights/chartout
+Keywords: python3 python reserve reserver reserved
+Classifier: Development Status :: 1 - Planning
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+
+## Overview
+chartout is a Python library for doing awesome things.
+This name has been reserved using [Reserver](https://github.com/openscilab/reserver).

chartout-0.0.0/README.md

@@ -0,0 +1,4 @@
+
+## Overview
+chartout is a Python library for doing awesome things.
+This name has been reserved using [Reserver](https://github.com/openscilab/reserver).

chartout-0.0.0/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""chartout modules."""

chartout-0.0.0/cart.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass, asdict
+from typing import Optional, List
+from .models import CartItem
+from .support import viz_to_cart_item, VizLike
+
+
+@dataclass
+class Cart:
+    """A class to represent a shopping cart containing CartItems.
+
+    Attributes:
+        items (List[CartItem]): A list of items in the cart, which can be
+        CartItem instances.
+    """
+
+    items: List[CartItem]
+
+    def __init__(self, items: Optional[List[CartItem]] = None):
+        """Initialize the Cart with an optional list of items.
+
+        Args:
+            items (Optional[List[CartItem]]): A list of dictionaries conforming to
+            CartItem to initialize the cart with.
+        """
+        self.items: List[CartItem] = []
+        if items is not None:
+            self.add(items)
+
+    def add(self, item: CartItem | List[CartItem] | VizLike) -> None:
+        """Add a CartItem, a list of CartItems, or a VizLike to the cart.
+
+        Args:
+            item (CartItem | List[CartItem] | VizLike): A CartItem, a list of CartItems, or a VizLike to be added to the cart.
+
+        Raises:
+            ValueError: If an item in the list is not a valid CartItem or VizLike.
+        """
+        if isinstance(item, VizLike):
+            # Convert VizLike to CartItem
+            item = viz_to_cart_item(item)
+            self.items.append(item)
+        elif isinstance(item, list):
+            for i in item:
+                if isinstance(i, dict):
+                    i = CartItem(**i)
+                self.items.append(i)
+        else:
+            if isinstance(item, dict):
+                item = CartItem(**item)
+            self.items.append(item)
+
+    def remove(self, *, index: int) -> None:
+        """Remove a CartItem from the cart by its index.
+
+        Args:
+            index (int): The index of the item to be removed from the cart.
+
+        Raises:
+            IndexError: If the index is out of range.
+        """
+        if index < 0 or index >= len(self.items):
+            raise IndexError("Index out of range.")
+        del self.items[index]
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Cart.
+
+        Returns:
+            str: A string representation of the Cart, including item IDs, names, quantities, and texture information.
+        """
+        if not self.items:
+            return "Cart(empty)"
+        
+        items_repr = "\n".join(
+            f"  - ID: {item.id}\n"
+            f"    Name: {item.name or 'Unnamed'}\n"
+            f"    Quantity: {item.quantity}\n"
+            f"    Textures: [{', '.join(texture.id for texture in item.textures)}]"
+            for item in self.items
+        )
+        return f"Cart:\n{items_repr}"
+
+    def to_dict(self):
+        return asdict(self)

chartout-0.0.0/chartout.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: chartout
+Version: 0.0.0
+Summary: Chartout - Print Your Insights, Anytime, Anywhere
+Home-page: https://chartout.io
+Download-URL: https://download_url.com
+Author: mattijn
+Author-email: info@hoekinsights.nl
+License: GPL-3.0 license
+Project-URL: Source, https://github.com/hoekinsights/chartout
+Keywords: python3 python reserve reserver reserved
+Classifier: Development Status :: 1 - Planning
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+
+## Overview
+chartout is a Python library for doing awesome things.
+This name has been reserved using [Reserver](https://github.com/openscilab/reserver).

chartout-0.0.0/chartout.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+__init__.py
+cart.py
+develop.py
+models.py
+py.typed
+setup.py
+store.py
+support.py
+texture.py
+chartout.egg-info/PKG-INFO
+chartout.egg-info/SOURCES.txt
+chartout.egg-info/dependency_links.txt
+chartout.egg-info/top_level.txt

chartout-0.0.0/chartout.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chartout-0.0.0/chartout.egg-info/top_level.txt

@@ -0,0 +1 @@
+

chartout-0.0.0/develop.py

@@ -0,0 +1,120 @@
+def altair_heatmap():
+    import altair as alt
+    import numpy as np
+    import pandas as pd
+
+    # Compute x^2 + y^2 across a 2D grid
+    x, y = np.meshgrid(range(-5, 5), range(-5, 5))
+    z = x**2 + y**2
+
+    # Convert this grid to columnar data expected by Altair
+    source = pd.DataFrame({"x": x.ravel(), "y": y.ravel(), "z": z.ravel()})
+
+    chart = alt.Chart(source).mark_rect().encode(x="x:O", y="y:O", color="z:Q")
+    return chart
+
+def altair_comet():
+    import altair as alt
+    import vega_datasets
+
+    chart = alt.Chart(
+        vega_datasets.data.barley.url,
+        title='Barley Yield comparison between 1932 and 1931'
+    ).mark_trail().encode(
+        alt.X('year:O').title(None),
+        alt.Y('variety:N').title('Variety'),
+        alt.Size('yield:Q')
+            .scale(range=[0, 12])
+            .legend(values=[20, 60])
+            .title('Barley Yield (bushels/acre)'),
+        alt.Color('delta:Q')
+            .scale(domainMid=0)
+            .title('Yield Delta (%)'),
+        alt.Tooltip(['year:O', 'yield:Q']),
+        alt.Column('site:N').title('Site')
+    ).transform_pivot(
+        "year",
+        value="yield",
+        groupby=["variety", "site"]
+    ).transform_fold(
+        ["1931", "1932"],
+        as_=["year", "yield"]
+    ).transform_calculate(
+        calculate="datum['1932'] - datum['1931']",
+        as_="delta"
+    ).configure_legend(
+        orient='bottom',
+        direction='horizontal'
+    ).configure_view(
+        stroke=None
+    )  
+    return chart  
+
+def altair_map_selection():
+    import altair as alt
+    from vega_datasets import data
+    import geopandas as gpd
+
+    # load data
+    gdf_quakies = gpd.read_file(data.earthquakes.url, driver="GeoJSON")
+    gdf_world = gpd.read_file(data.world_110m.url, driver="TopoJSON")
+
+    # defintion for interactive brush
+    brush = alt.selection_interval(
+        encodings=["longitude"], empty=False, value={"longitude": [-50, -110]}
+    )
+
+    # world disk
+    sphere = alt.Chart(alt.sphere()).mark_geoshape(
+        fill="transparent", stroke="lightgray", strokeWidth=1
+    )
+
+    # countries as shapes
+    world = alt.Chart(gdf_world).mark_geoshape(
+        fill="lightgray", stroke="white", strokeWidth=0.1
+    )
+
+    # earthquakes as dots on map
+    quakes = (
+        alt.Chart(gdf_quakies)
+        .transform_calculate(
+            lon="datum.geometry.coordinates[0]",
+            lat="datum.geometry.coordinates[1]",
+        )
+        .mark_circle(opacity=0.35, tooltip=True)
+        .encode(
+            longitude="lon:Q",
+            latitude="lat:Q",
+            color=alt.when(brush)
+            .then(alt.value("goldenrod"))
+            .otherwise(alt.value("steelblue")),
+            size=alt.Size("mag:Q").scale(
+                type="pow", range=[1, 1000], domain=[0, 7], exponent=4
+            ),
+        )
+        .add_params(brush)
+    )
+
+    # combine layers for the map
+    left_map = alt.layer(sphere, world, quakes).project(type="mercator")
+
+    # histogram of binned earthquakes
+    bars = (
+        alt.Chart(gdf_quakies)
+        .mark_bar()
+        .encode(
+            x=alt.X("mag:Q").bin(extent=[0, 7]),
+            y="count(mag):Q",
+            color=alt.value("steelblue"),
+        )
+    )
+
+    # filtered earthquakes
+    bars_overlay = bars.encode(color=alt.value("goldenrod")).transform_filter(brush)
+
+    # combine layers for histogram
+    right_bars = alt.layer(bars, bars_overlay)
+
+    # vertical concatenate map and bars
+    chart = left_map | right_bars
+    return chart

chartout-0.0.0/models.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass, field, asdict
+from typing import List, Union, Optional, Dict, Any
+
+# Data Classes
+@dataclass
+class Texture:
+    id: str
+    content: Union[str, Any]  # 'Any' can be used for alt.Chart or other types
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the Texture instance to a dictionary."""
+        return asdict(self)
+
+@dataclass
+class StoreItem:
+    id: str
+    name: Optional[str] = None
+    textures: List[Texture] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the StoreItem instance to a dictionary."""
+        return asdict(self)
+
+@dataclass
+class CartItem(StoreItem):
+    quantity: int = 1
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the CartItem instance to a dictionary."""
+        return asdict(self)
+
+@dataclass
+class ActiveItem(StoreItem):
+    textures: List[Texture] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the ActiveItem instance to a dictionary."""
+        return asdict(self)
+
+@dataclass
+class ActiveTexture:
+    texture: bytes  # Equivalent to Uint8Array in TypeScript
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the ActiveTexture instance to a dictionary."""
+        return asdict(self)
+
+@dataclass
+class InitViz:
+    images: Dict[int, bytes] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[int, bytes]:
+        """Convert the InitViz instance to a dictionary."""
+        return self.images

chartout-0.0.0/setup.cfg

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

chartout-0.0.0/setup.py

@@ -0,0 +1,47 @@
+
+import sys
+
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
+
+# invalid email
+# download url
+# url
+# project urls
+
+setup(
+    name ="chartout",
+    packages=[".",],
+    version='0.0.0',
+    description="Chartout - Print Your Insights, Anytime, Anywhere",
+    long_description="""
+## Overview
+chartout is a Python library for doing awesome things.
+This name has been reserved using [Reserver](https://github.com/openscilab/reserver).
+""",
+    long_description_content_type='text/markdown',
+    author="mattijn",
+    author_email="info@hoekinsights.nl",
+    url="https://chartout.io",
+    download_url="https://download_url.com",
+    keywords="python3 python reserve reserver reserved",
+    project_urls={
+            'Source':"https://github.com/hoekinsights/chartout",
+    },
+    install_requires="",
+    python_requires='>=3.6',
+    classifiers=[
+        'Development Status :: 1 - Planning',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+    ],
+    license="GPL-3.0 license",
+)
+

chartout-0.0.0/store.py

@@ -0,0 +1,135 @@
+import json
+import pathlib
+import urllib.request
+from typing import Any, Dict, Optional, Union
+
+import anywidget
+import traitlets
+from traitlets import TraitType
+
+from .cart import Cart
+from .models import ActiveItem, CartItem, InitViz
+from .support import (
+    VizLike,
+    is_viz_like,
+    viz_to_active_item,
+    viz_to_init_viz,
+    cart_item_to_active_item,
+)
+
+
+# Helper Classes
+class MemoryViewTrait(TraitType):
+    """A trait type that accepts memoryview objects and converts them to bytes."""
+
+    def validate(self, obj, value):
+        if isinstance(value, memoryview):
+            return bytes(value)
+        elif isinstance(value, (bytes, bytearray)):
+            return value
+        else:
+            self.error(obj, value)
+
+
+# Main Classes
+class Store(anywidget.AnyWidget):
+    """A class representing a store widget for managing cart items.
+
+    This class provides functionality to manage the state of a shopping cart,
+    including adding, removing, and serializing cart items. It uses traitlets
+    for automatic syncing with the front-end and supports JSON serialization
+    for easy data interchange.
+
+    Attributes:
+        cart (Cart): An instance of the Cart class containing items currently in the cart.
+        active (Dict[str, Any]): A dictionary representing the active item state.
+        init (Dict[str, Any]): A read-only dictionary representing the initial
+            state of the store.
+    """
+
+    # Paths for JavaScript and CSS
+    _esm = pathlib.Path("../chartout-app/bundle/Widget.js")
+    # _css = pathlib.Path("../chartout-app/bundle/styles.css")
+
+    cart = traitlets.List(
+        trait=traitlets.Dict(
+            key_trait=traitlets.Unicode(), value_trait=traitlets.Any()
+        ),
+        allow_none=True,
+        default_value=None,
+    ).tag(sync=True)
+
+    active_item = traitlets.Dict(
+        key_trait=traitlets.Unicode(), value_trait=traitlets.Any(), allow_none=True
+    ).tag(sync=True)
+
+    active_texture = traitlets.Dict(
+        key_trait=traitlets.Unicode(),
+        value_trait=MemoryViewTrait(),
+        allow_none=True,
+        default_value=None,
+        read_only=False,
+    ).tag(sync=True)
+
+    init_viz = traitlets.Dict(
+        key_trait=traitlets.Int(), value_trait=traitlets.Bytes(), allow_none=True
+    ).tag(sync=True)
+
+    def __init__(self, item: Optional[Union[Cart, VizLike]] = None, **kwargs):
+        """Initialize the Store with an optional cart or a valid Altair chart."""
+        super().__init__(**kwargs)
+        self.active_texture = None
+        if isinstance(item, Cart):
+            self.cart = item.to_dict()["items"]
+            self.init_viz = {}
+            self.active_item = (
+                cart_item_to_active_item(self.cart[0]) if len(self.cart) > 0 else None
+            )
+        elif is_viz_like(item):
+            self.cart = []
+            init_viz_obj = viz_to_init_viz(item)
+            self.init_viz = init_viz_obj.to_dict()
+            self.active_item = viz_to_active_item(init_viz_obj).to_dict()
+        elif item is not None:
+            raise TypeError("item must be of type Cart or VizLike.")
+        else:
+            self.cart = []
+            self.init_viz = {}
+            self.active_item = None
+
+    def to_json(self):
+        """Serialize the widget's state to a JSON-compatible dictionary."""
+        return {
+            "cart": self.cart,
+            "active_item": self.active_item,
+            "init_viz": self.init_viz,
+        }
+
+    def from_json(self, data: Dict[str, Any]):
+        """Deserialize JSON data into the Store."""
+        if "cart" in data:
+            self.cart = Cart()  # Initialize a new Cart instance
+            self.cart.items = [CartItem(**item) for item in data["cart"]]
+        if "active" in data:
+            self.active_item = ActiveItem(**data["active"])
+        if "init_viz" in data:
+            self.init_viz = InitViz(images=data["init_viz"]).to_dict()
+
+
+# Functions
+def customizables(debug: bool = False) -> Any:
+    """Retrieve a JSON object from the Chartout API for customizables based on category."""
+    if debug:
+        url = "http://127.0.0.1:8000/v1/products/"
+    else:
+        url = "https://api.chartout.io/v1/products/"
+    try:
+        with urllib.request.urlopen(url) as response:
+            if response.status != 200:
+                raise Exception(f"Error fetching data: {response.status}")
+            data = response.read()
+            return json.loads(data)
+    except urllib.error.URLError as e:
+        raise ConnectionError(f"Failed to connect to {url}: {e.reason}")
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Failed to parse JSON response: {e.msg}")

chartout-0.0.0/support.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+import sys
+import io
+from typing import TYPE_CHECKING, Any, TypeVar, Optional, Dict
+import uuid
+import hashlib
+import os
+import time
+
+# Conditional imports for type checking
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 10):
+        from typing import TypeGuard
+    else:
+        from typing_extensions import TypeGuard
+    import altair as alt
+
+# Import models
+from .models import ActiveItem, Texture, InitViz, CartItem
+
+# Define a new type variable for VizLike
+VizLike = TypeVar("VizLike", bound=Any)
+
+
+# Helper Functions
+def get_altair() -> Any:
+    """Get altair module (if already imported - else return None)."""
+    return sys.modules.get("altair", None)
+
+
+def is_altair_chart(chart: Any) -> TypeGuard[alt.typing.ChartType]:
+    """Check whether `chart` is an Altair Chart without importing altair."""
+    return (alt := get_altair()) is not None and alt.typing.is_chart_type(chart)
+
+
+def chart_to_png(chart: Any) -> bytes:
+    """Convert an Altair chart to PNG byte data."""
+    if is_altair_chart(chart):
+        byte_stream = io.BytesIO()
+        chart.save(byte_stream, format="png", scale_factor=2, ppi=300)
+        byte_stream.seek(0)
+        return byte_stream.getvalue()
+    else:
+        msg = f"The provided DataViz object is not supported. Got: {type(chart)}"
+        raise TypeError(msg)
+
+
+# Main Functions
+def is_viz_like(viz: VizLike) -> TypeGuard[VizLike]:
+    """Check whether `viz` is a valid Altair chart."""
+    return is_altair_chart(viz)
+
+
+def viz_to_active_item(init_viz: InitViz) -> ActiveItem:
+    """Convert an InitViz item to an ActiveItem."""
+    # Assuming the first image in the InitViz is used for the ActiveItem
+    first_image_index = next(iter(init_viz.images))
+    png_data = init_viz.images[first_image_index]
+
+    return ActiveItem(
+        name="Canvas",
+        id="canvas_10x10",
+        textures=[
+            Texture(
+                id="canvas_10x10_texture",
+                content=png_data
+            )
+        ]
+    )
+
+
+def viz_to_init_viz(viz: VizLike) -> InitViz:
+    """Convert a VizLike item to an InitViz."""
+    images = {0: chart_to_png(viz)}
+    return InitViz(images=images)
+
+
+def cart_item_to_active_item(cart_item: Dict[str, Any]) -> ActiveItem:
+    """Convert a CartItem to an ActiveItem."""
+    return ActiveItem(
+        id=cart_item['id'],
+        name=cart_item.get('name'),
+        textures=cart_item['textures']
+    )
+
+
+def viz_to_cart_item(viz: VizLike) -> CartItem:
+    """Convert a VizLike item to a CartItem."""
+    # Convert the VizLike object to PNG bytes
+    png_data = chart_to_png(viz)
+    
+    # Create a Texture instance for the CartItem
+    texture = Texture(
+        id="my_canvas_texture", 
+        content=png_data
+    )
+    
+    # Create and return a CartItem instance
+    return CartItem(
+        id="my_canvas_id", 
+        name="VizLike Item",
+        textures=[texture],
+        quantity=1
+    )
+
+
+def generate_external_id() -> str:
+    """Generate a unique external ID for order creation."""
+    # Generate a UUID
+    unique_id = uuid.uuid4().hex
+
+    # Get machine-specific information (e.g., hostname)
+    machine_info = os.uname().nodename
+
+    # Hash the machine information to keep it consistent and anonymized
+    machine_hash = hashlib.sha256(machine_info.encode()).hexdigest()
+
+    # Get the current timestamp
+    timestamp = int(time.time())
+
+    # Combine all parts to form the external_id
+    external_id = f"{unique_id}-{machine_hash[:8]}-{timestamp}"
+
+    return external_id

chartout-0.0.0/texture.py

@@ -0,0 +1,172 @@
+from typing import Any, Dict, Union, List
+import io
+from PIL import Image, ImageDraw
+
+# Import from other modules
+from .store import customizables
+from .support import is_viz_like, chart_to_png
+
+# Helper Functions
+def process_image_for_source_size(img, source_size, user_modifications=None):
+    """Resize image to fit within source_size while maintaining aspect ratio and alignment."""
+    orig_width, orig_height = img.size
+    aspect_ratio = orig_width / orig_height
+
+    # Determine new dimensions to fit within source_size while maintaining aspect ratio
+    if source_size["width"] / aspect_ratio <= source_size["height"]:
+        fit_width = source_size["width"]
+        fit_height = int(fit_width / aspect_ratio)
+    else:
+        fit_height = source_size["height"]
+        fit_width = int(fit_height * aspect_ratio)
+
+    # Resize the image to fit within the source size
+    resized_img = img.resize((fit_width, fit_height))
+
+    # Apply scale modification if provided
+    scale = user_modifications.get("scale", 1.0) if user_modifications else 1.0
+    scaled_width = int(fit_width * scale)
+    scaled_height = int(fit_height * scale)
+
+    # Resize the image based on the scale
+    scaled_img = resized_img.resize((scaled_width, scaled_height))
+
+    # Create a new canvas for the source size
+    source_canvas = Image.new(
+        "RGB", (source_size["width"], source_size["height"]), (255, 255, 255)
+    )
+
+    # Determine alignment
+    alignment = user_modifications.get(
+        "alignment",
+        source_size.get("alignment", {"horizontal": "center", "vertical": "middle"}),
+    )
+    dx = user_modifications.get("dx", 0)
+    dy = user_modifications.get("dy", 0)
+
+    if alignment["horizontal"] == "left":
+        x_pos = 0 + dx
+    elif alignment["horizontal"] == "right":
+        x_pos = source_size["width"] - scaled_width + dx
+    else:  # center
+        x_pos = (source_size["width"] - scaled_width) // 2 + dx
+
+    if alignment["vertical"] == "top":
+        y_pos = 0 + dy
+    elif alignment["vertical"] == "bottom":
+        y_pos = source_size["height"] - scaled_height + dy
+    else:  # middle
+        y_pos = (source_size["height"] - scaled_height) // 2 + dy
+
+    # Paste the scaled image onto the source canvas, clipping if necessary
+    source_canvas.paste(scaled_img, (x_pos, y_pos))
+    return source_canvas, {
+        "scaled_width": scaled_width,
+        "scaled_height": scaled_height,
+        "x_pos": x_pos,
+        "y_pos": y_pos,
+    }
+
+def position_image_on_canvas(resized_img, canvas_position, user_modifications):
+    """Position the resized image on the canvas using user modifications."""
+    # Create a tile canvas
+    tile_canvas = Image.new(
+        "RGB", (canvas_position["width"], canvas_position["height"]), (255, 255, 255)
+    )
+
+    final_img = resized_img.resize(
+        (canvas_position["width"], canvas_position["height"])
+    )
+
+    tile_canvas.paste(final_img, (0, 0))
+
+    return tile_canvas
+
+# Main Functions
+def create_tiled_image(variant):
+    """Create a tiled image from a variant."""
+    # Create a blank canvas
+    canvas_size = variant["canvas_size"]
+    canvas = Image.new("RGB", (canvas_size, canvas_size), (255, 255, 255))
+
+    for texture in variant["textures"]:
+        if texture["type"] == "image":
+            try:
+                # Check if content is a byte stream
+                if isinstance(texture["content"], bytes):
+                    img = Image.open(io.BytesIO(texture["content"]))
+                else:
+                    # Assume content is a file path
+                    img = Image.open(texture["content"])
+
+                # Ensure the image is loaded
+                img.load()
+            except Exception as e:
+                print(f"Error loading image for texture ID {texture['id']}: {e}")
+                continue
+
+            # Process image for source size
+            resized_img = process_image_for_source_size(img, texture["source_size"])
+
+            # Apply user modifications and position on canvas
+            user_modifications = texture.get("user_modifications", {})
+            tile_canvas = position_image_on_canvas(
+                resized_img, texture["canvas_position"], user_modifications
+            )
+
+            # Calculate position on the main canvas
+            x = texture["canvas_position"]["x"]
+            y = texture["canvas_position"]["y"]
+
+            # Paste the processed image onto the main canvas
+            canvas.paste(tile_canvas, (x, y))
+
+        elif texture["type"] == "color":
+            # Create a colored rectangle
+            color = texture["content"]
+            x = texture["canvas_position"]["x"]
+            y = texture["canvas_position"]["y"]
+            width = texture["canvas_position"]["width"]
+            height = texture["canvas_position"]["height"]
+            draw = ImageDraw.Draw(canvas)
+            draw.rectangle([x, y, x + width, y + height], fill=color)
+
+    # Flip the image
+    canvas = canvas.transpose(Image.FLIP_TOP_BOTTOM)
+    # Save or display the image
+    output = io.BytesIO()
+    canvas.save(output, format="PNG")
+    output.seek(0)
+    return output.getvalue()
+
+def variant_to_texture(id_variant: str, textures: List[Dict[str, Any]]) -> bytes:
+    """Create texture data image using the given variant ID and textures."""
+    # Retrieve product configurations from the API
+    products_json = customizables(debug=True)
+    my_variant = next(
+        (v for v in products_json["variants"] if v["id"] == id_variant), None
+    )
+
+    if not my_variant:
+        raise ValueError(f"Variant with ID {id_variant} not found in variants.")
+
+    # Update the variant's textures with the provided textures
+    for texture in textures:
+        for variant_texture in my_variant["textures"]:
+            if variant_texture["id"] == texture["id"]:
+                if variant_texture["type"] == "image" and is_viz_like(
+                    texture["content"]
+                ):
+                    # Convert chart to PNG if content is a chart
+                    variant_texture["content"] = chart_to_png(texture["content"])
+                else:
+                    # Directly assign content for non-chart textures
+                    variant_texture["content"] = texture["content"]
+                # Update other properties if needed
+                variant_texture["user_modifications"] = texture.get(
+                    "user_modifications", variant_texture.get("user_modifications", {})
+                )
+
+    # Create the tiled image using the updated variant
+    texture_data = create_tiled_image(my_variant)
+    return texture_data