kitikiplot 0.1.3__py3-none-any.whl

kitikiplot/__init__.py

@@ -0,0 +1 @@
+from .kitikiplot import KitikiPlot

kitikiplot/kitiki_cell.py

@@ -0,0 +1,167 @@
+"""
+File Name: kitiki_cell.py
+Description: This file defines the 'KitikiCell' class for each rectangular cell in kitiki plot
+Author: Boddu Sri Pavan
+Date Created: 21-10-2024
+Last Modified: 07-12-2024
+"""
+
+from typing import List, Dict, Union
+import pandas as pd
+import matplotlib.patches as mpatches
+from matplotlib.patches import Rectangle
+from .kitiki_color_config import ColorConfig
+
+class KitikiCell(ColorConfig):
+    """
+    Represents a cell in the KitikiPlot visualization.
+
+    This class extends the ColorConfig class to add functionality for creating 
+    individual cells in a grid-based visualization.
+
+    Parameters
+    ----------
+    data : pd.DataFrame or list
+        - The input data which can be either a 'pd.DataFrame' or a 'list'.
+        - If a list is provided, it will be converted into a DataFrame using specified stride and window length.
+    stride : int (optional)
+        - The number of elements to move the window after each iteration when converting a list to a DataFrame. 
+        - Default is 1.
+    window_length : int (optional)
+        - The length of each window when converting a list to a DataFrame. 
+        - Default is 10.
+    
+    Attributes
+    ----------
+    stride : int
+        - The number of elements to move the window after each iteration when converting a list to a DataFrame.
+        - Default is 1.
+    """
+    
+    def __init__(self, data: Union[pd.DataFrame, list], stride: int = 1, window_length: int = 10) -> None:
+        """
+        Initialize the KitikiCell object by inheriting from ColorConfig.
+
+        Parameters
+        ----------
+        data : pd.DataFrame or list
+            - The input data to be processed.
+        stride : int (optional)
+            - The number of elements to move the window after each iteration when converting a list to a DataFrame. 
+            - Default is 1.
+        window_length : int (optional)
+            - The length of each window when converting a list to a DataFrame. 
+            - Default is 10.
+        
+        Attributes
+        ----------
+        stride : int
+            - The number of elements to move the window after each iteration when converting a list to a DataFrame.
+            - Default is 1.
+        """
+
+        super().__init__(data=data, stride= stride, window_length= window_length)
+
+
+    def create( self,
+                x: int,
+                y: int,
+                each_sample: List,
+                cell_width: float,
+                cell_height: float,
+                window_gap: float,
+                align: bool,
+                cmap: Union[str, Dict],
+                edge_color: str,
+                fallback_color: str,
+                hmap: Dict,
+                fallback_hatch: str,
+                display_hatch: bool,
+                transpose: bool,
+                **kitiki_cell_kwargs: dict) -> mpatches.Rectangle:
+        
+        """
+        Create a rectangular cell for the KitikiPlot visualization.
+
+        Parameters
+        ----------
+        x : int
+            - The x-coordinate of the cell in the grid.
+        y : int
+            - The y-coordinate of the cell in the grid.
+        each_sample : list
+            - A list containing each data record used for determining color and hatch patterns to plot KitikiPlot.
+        cell_width : float
+            - The width of each cell in the grid.
+            - Default is 0.5.
+        cell_height : float
+            - The height of each cell in the grid.
+            - Default is 2.0.
+        window_gap : float
+            - The gap between cells in the grid.
+            - Default is 1.0.
+        align : bool
+            - A flag indicating whether to shift consecutive bars vertically (if transpose= False), and
+              horizontally(if transpose= True) by stride value.
+            - Default is True.
+        cmap : str or dict
+            - If a string, it should be a colormap name to generate colors.
+            - If a dictionary, it should map unique values to specific colors.
+            - Default is 'rainbow'.
+        edge_color : str
+            - The color to use for the edges of the rectangle.
+            - Default is '#000000'.
+        fallback_color : str
+            - The color to use as fallback if no specific color is assigned.
+            - Default is '#FAFAFA'.
+        hmap : dict
+            - A dictionary mapping unique values to their corresponding hatch patterns.
+            - Default is '{}'.
+        fallback_hatch : str
+            - The hatch pattern to use as fallback if no specific hatch is assigned.
+            - Default is '" "' (string with single space).
+        display_hatch : bool
+            - A flag indicating whether to display hatch patterns on cells.
+            - Default is False.
+        transpose : bool
+            - A flag indicating whether to transpose the dimensions of the cells.
+            - Default is False.
+        kitiki_cell_kwargs : keyword arguments
+            - Additional keyword arguments passed to customize the Rectangle object.
+            - Default is {}.
+
+        Returns
+        -------
+        matplotlib.patches.Rectangle: A Rectangle object representing the configured cell for KitikiPlot visualization.
+        """
+
+        # Adjust dimensions if 'transpose' is set to 'False'
+        if not transpose:
+
+            # Calculate alignment factor based on whether alignment is enabled
+            align_factor= (self.rows-x)*self.stride*cell_height if align else 0
+
+            # Calculate dimensions for the rectangle based on grid position and size parameters
+            rect_dim= (window_gap*(x+1)+ cell_width*(x+1) , cell_height*(self.cols-y-1)+align_factor)
+
+        # Adjust dimensions if 'transpose' is set to 'True'
+        else:
+
+            # Set cell width to 2.0 for transposed cells to enhance visualization
+            # cell_width= 2.0
+
+            # Calculate alignment factor for transposed configuration based on whether alignment is enabled
+            align_factor= x*self.stride*cell_height if align else 0
+
+            # Calculate dimensions for the rectangle based on grid position and size parameters for transposed layout
+            rect_dim= (cell_height*(y+1)+ align_factor, window_gap*(self.rows- x+1)+ cell_width*(self.rows- x+1))
+
+        # Return a Rectangle object with specified dimensions and styles based on input parameters
+        return Rectangle( rect_dim,
+           width= cell_width, 
+           height= cell_height,
+           facecolor= cmap[0][ each_sample[y] ],
+           edgecolor= cmap[1],
+           hatch= hmap[each_sample[y]],
+           **kitiki_cell_kwargs
+           )

kitikiplot/kitiki_color_config.py

@@ -0,0 +1,266 @@
+"""
+File Name: kitiki_color_config.py
+Description: This file defines the 'ColorConfig' class for managing input data(list, dataframe) and configuring color, hatch of kitiki plot
+Author: Boddu Sri Pavan
+Date Created: 21-10-2024
+Last Modified: 23-11-2024
+"""
+from typing import Tuple, Union, Dict
+import random
+import math
+import numpy as np
+import pandas as pd
+import matplotlib
+import matplotlib.pyplot as plt
+
+class ColorConfig:
+    """
+    Configure data, color, and hatch settings for KitikiPlot visualization.
+
+    Parameters
+    ----------
+    data : pd.DataFrame or list
+        - The input data which can be either a pandas DataFrame or a list.
+        - If a list is provided, it will be converted into a DataFrame using specified stride and window length.
+    stride : int (optional)
+        - The number of elements to move the window after each iteration when converting a list to a DataFrame. 
+        - Default is 1.
+    window_length : int (optional)
+        - The length of each window when converting a list to a DataFrame.
+        - Default is 10.
+
+    Attributes
+    ----------
+    data : pd.DataFrame
+        - The DataFrame containing the input data.
+    stride : int
+        - The number of elements to move the window after each iteration when converting a list to a DataFrame.
+        - Default is 1.
+    rows : int
+        - The number of rows in the DataFrame.
+    cols : int
+        - The number of columns in the DataFrame.
+
+    Methods
+    -------
+    Instance Methods
+        - color_config: Configure colors for unique values in the DataFrame.
+        - hatch_config: Configure hatch patterns for unique values in the DataFrame.
+        - unique_config: Find unique values and their count from the input DataFrame.
+    
+    Static Methods
+        - _convert_list_to_dataframe: Convert a list into a pandas DataFrame using sliding window.
+    """
+
+    def __init__(self, data: Union[pd.DataFrame, list], stride: int = 1, window_length: int = 10) -> None:
+        """
+        Initialize the ColorConfig object with data and optional parameters.
+        Also checks the type of input data and initializes the corresponding attributes.
+        
+        Parameters
+        ----------
+        data : pd.DataFrame or list
+            - The input data to be processed.
+        stride : int (optional)
+            - The number of elements to move the window after each iteration when converting a list to a DataFrame. 
+            - Default is 1.
+        window_length : int (optional)
+            - The length of each window when converting a list to a DataFrame. 
+            - Default is 10.
+
+        Attributes
+        ----------
+        stride : int
+            - The number of elements to move the window after each iteration when converting a list to a DataFrame.
+            - Default is 1.
+        """
+
+        # Check if 'data' is of type 'pd.DataFrame' and initialize 'data' attribute.
+        if isinstance( data, pd.DataFrame):
+            self.data= data
+
+        # Check if 'data' is of type 'list'.
+        elif isinstance( data, list):
+
+            # Convert 'list' to 'pd.DataFrame' using stride and window_length, and initialize 'data' attribute.
+            self.data= self._convert_list_to_dataframe( data, stride, window_length)
+
+        # Store the stride value
+        self.stride= stride
+
+        # Set 'rows' to number of rows in the DataFrame.
+        self.rows= self.data.shape[0]
+
+        # Set 'cols' to number of columns in the DataFrame.
+        self.cols= self.data.shape[1]
+
+    @staticmethod
+    def _convert_list_to_dataframe( data: Union[pd.DataFrame, list], stride: int = 1, window_length: int = 10) -> pd.DataFrame:
+        """
+        Convert list into a 'pd.DataFrame' by creating sliding window of specified window length.
+
+        Parameters
+        ----------
+        data : pd.DataFrame or list
+            - The input data to be processed.
+        stride : int (optional)
+            - The number of elements to move the window after each iteration when converting a list to a DataFrame. 
+            - Default is 1.
+        window_length : int (optional)
+            - The length of each window when converting a list to a DataFrame. 
+            - Default is 10.
+
+        Returns
+        -------
+        pd.DataFrame: A DataFrame containing the sliding window of data.
+        """
+
+        # Calculate the number of rows needed in the DataFrame
+        n_rows= math.ceil(max(len(data)-window_length, 0)/ stride +1)
+
+        # Initialize an empty list to hold the rows of data
+        l= []
+
+        # Generate each row based on the sliding window approach
+        for i in range( n_rows ):
+
+            # Extract a slice from the data based on current stride and window length
+            row_data= data[i*stride: i*stride+window_length]
+
+            # If the extracted row is shorter than the window length, pad it with "No_Data"
+            if len(row_data)< window_length:
+                row_data+= ["No_Data"]* (window_length- len(row_data))
+            
+            # Append the row to the list
+            l.append( row_data )
+        
+        # Convert the list of rows into a 'pd.DataFrame' and return it
+        return pd.DataFrame( l )
+
+    def unique_config(self) -> Tuple[np.ndarray, int]:
+        """
+        Find unique values and no.of unique values from input DataFrame.
+
+        Returns
+        -------
+        tuple: (unique_values, n_unique)
+            unique_values : numpy.ndarray
+                - Array of unique values present in the input DataFrame.
+            n_unique : int
+                - Number of unique values present in the input DataFrame.
+        """
+
+        # Extract unique values from the input DataFrame by flattening it
+        unique_values= pd.unique( self.data.values.ravel())
+
+        # Calculate the number of unique values found in the DataFrame
+        n_unique= unique_values.shape[0]
+
+        # Return both the array of unique values and their count
+        return unique_values, n_unique
+
+    def color_config(self, cmap: Union[str, Dict], edge_color: str, fallback_color: str) -> Tuple[Dict, str]:
+        """
+        Configure colors for unique values in the DataFrame.
+
+        Parameters
+        ----------
+        cmap : str or dict
+            - If a string, it should be a colormap name to generate colors.
+            - If a dictionary, it should map unique values to specific colors.
+            - Default is 'rainbow'.
+        edge_color : str
+            - The color to use for the edges of the rectangle.
+            - Default is '#000000'.
+        fallback_color : str
+            - The color to use as fallback if no specific color is assigned.
+            - Default is '#FAFAFA'.
+
+        Returns
+        -------
+        tuple: (color_map, edge_color)
+            color_map : dict
+                - A dictionary mapping unique values to their corresponding colors.
+            edge_color : str
+                - The specified edge color.
+        """
+
+        # Find unique values and their count from the input DataFrame
+        unique_values, n_unique= self.unique_config()
+
+        # Check if cmap is a string representing a colormap name
+        if type(cmap)== str:
+            
+            # Get the colormap and create a custom palette based on the number of unique values
+            cmap = plt.get_cmap( cmap, n_unique)
+            custom_palette = [matplotlib.colors.rgb2hex(cmap(i)) for i in range(cmap.N)]
+
+            # Create a mapping of unique values to their corresponding colors
+            color_map= dict(zip(unique_values, custom_palette))
+
+        # Check if cmap is a dictionary
+        elif type(cmap)==dict:
+
+            color_map= cmap
+
+            # Ensure all unique values are represented in the color_map
+            if len(cmap)!= n_unique:
+                for each_unique in unique_values:
+                    if each_unique not in color_map:
+
+                        # Assign fallback color for any missing unique value
+                        color_map.update( {each_unique: fallback_color} )
+
+        # Return the final color mapping and the specified edge color
+        return color_map, edge_color
+    
+    def hatch_config(self, h_map: Dict, fallback_hatch: str, display_hatch: bool) -> dict:
+        """
+        Configure hatch patterns for unique values in the DataFrame.
+
+        Parameters
+        ----------
+        hmap : dict
+            - A dictionary mapping unique values to their corresponding hatch patterns.
+            - Default is '{}'.
+        fallback_hatch : str
+            - The hatch pattern to use as fallback if no specific hatch is assigned.
+            - Default is '" "' (string with single space).
+        display_hatch : bool
+            - A flag indicating whether to display hatch patterns on cells.
+            - Default is False.
+
+        Returns
+        -------
+            dict: A dictionary mapping each unique value to its corresponding hatch pattern.
+        """
+
+        # Define a list of available hatch patterns
+        HATCH_PATTERN= ['o', '/', '*', '\\','..', '+o', 'x*', 'o-', '|', '-', '+', 'x', 'O', '.',  '//', '\\\\', '||', '--', '++', 'xx', 'oo', 'OO',  '**', '/o', '\\|', '|*', '-\\', 'O|', 'O.', '*-']
+
+        # Retrieve unique values and their count from the DataFrame
+        unique_values, n_unique= self.unique_config()
+
+        # If 'display_hatch' is False, set all hatch patterns to a space
+        if display_hatch== False:
+            h_map= dict(zip(unique_values, [" "]*n_unique))
+
+        # If 'display_hatch' is True and the length of 'h_map' matches the number of unique values
+        elif display_hatch== True and len(h_map)== n_unique:
+            h_map= dict(zip(unique_values, h_map))
+        
+        # If 'display_hatch' is True and 'h_map' has fewer entries than unique values
+        elif display_hatch== True and 0<len(h_map)< n_unique:
+            h_map= h_map
+            for each_unique_value in unique_values:
+                if each_unique_value not in h_map:
+
+                    # Assign fallback hatch pattern for any missing unique value
+                    h_map.update( {each_unique_value: fallback_hatch} )
+        
+        # If 'display_hatch' is True and 'h_map' is empty, assign default hatch patterns
+        elif display_hatch== True and len(h_map)==0:
+            h_map= dict(zip(unique_values, HATCH_PATTERN[:n_unique]))
+
+        # Return the configured 'h_map'
+        return h_map

kitikiplot/kitikiplot.py

@@ -0,0 +1,446 @@
+"""
+File Name: Kiti.py
+Description: This file defines the 'KitikiPlot' class for generating kitki plot for categorical sequential& time-series data
+Author: Boddu Sri Pavan
+Date Created: 21-10-2024
+Last Modified: 23-11-2024
+"""
+
+from typing import List, Union
+import pandas as pd
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from .kitiki_cell import KitikiCell
+
+class KitikiPlot(KitikiCell):
+    """
+    A class to create a Kitikiplot visualization based on sliding window data.
+
+    This class extends the KitikiCell class to provide functionality for plotting 
+    KitikiPlot, where each cell can be customized with colors, hatches, 
+    and other visual properties.
+
+    Parameters
+    ----------
+    data : pd.DataFrame or list
+        - The input data to be processed.
+    stride : int (optional)
+        - The number of elements to move the window after each iteration when converting a list to a DataFrame. 
+        - Default is 1.
+    window_length : int (optional)
+        - The length of each window when converting a list to a DataFrame. 
+        - Default is 10.
+
+    Attributes
+    ----------
+    stride : int
+        - The number of elements to move the window after each iteration when converting a list to a DataFrame.
+        - Default is 1.
+    """
+     
+    def __init__(self, data: Union[pd.DataFrame, List], stride: int = 1, window_length: int = 10) -> None:
+        """
+        Initialize the KitikiPlot object by inheriting from KitikiCell.
+
+        Parameters
+        ----------
+        data : pd.DataFrame or list
+            - The input data to be processed.
+        stride : int (optional)
+            - The number of elements to move the window after each iteration when converting a list to a DataFrame. 
+            - Default is 1.
+        window_length : int (optional)
+            - The length of each window when converting a list to a DataFrame. 
+            - Default is 10.
+
+        Attributes
+        ----------
+        stride : int
+            - The number of elements to move the window after each iteration when converting a list to a DataFrame.
+            - Default is 1.
+        """
+        super().__init__(data=data, stride= stride, window_length= window_length)
+
+    def plot( self, 
+              figsize: tuple = (25, 5),
+              cell_width: float = 0.5,
+              cell_height: float = 2.0,
+              window_gap: float = 1.0,
+              window_range: str | tuple = "all",  
+              align: bool = True,         
+              cmap: str | dict = "rainbow",
+              edge_color: str = "#000000", 
+              fallback_color: str = "#FAFAFA",
+              hmap: dict = {},
+              fallback_hatch: str = " ",
+              display_hatch: bool = False,
+              transpose: bool = False,
+              xlabel: str = "Sliding Windows", 
+              ylabel: str = "Frames", 
+              display_xticks: bool = True,
+              display_yticks: bool = True,
+              xtick_prefix: str = "Window",
+              ytick_prefix: str = "Frame",
+              xticks_values: list = [],
+              yticks_values: list = [],
+              xticks_rotation: int = 0, 
+              yticks_rotation: int = 0,
+              title: str = "KitikiPlot: Intuitive Visualization for Sliding Window",
+              display_grid: bool = False,
+              display_legend: bool = False,
+              legend_hatch: bool = False,
+              legend_kwargs: dict = {},
+              kitiki_cell_kwargs: dict = {}
+            ) -> None:
+        """
+        Create and display the Kitikiplot visualization.
+
+        This method generates a plot based on the provided parameters and data. It configures 
+        colors, hatches, and dimensions for each cell in the grid.
+
+        Parameters
+        ----------
+        figsize : tuple (optional)
+            - The size of the figure (width, height).
+            - Default is (25, 5).
+        cell_width : float
+            - The width of each cell in the grid.
+            - Default is 0.5.
+        cell_height : float
+            - The height of each cell in the grid.
+            - Default is 2.0.
+        window_gap : float
+            - The gap between cells in the grid.
+            - Default is 1.0.
+        window_range : str or tuple (optional)
+            - The range of windows to display.
+            - Use "all" to show all windows or specify a tuple (start_index, end_index). 
+            - Default is "all".
+        align : bool
+            - A flag indicating whether to shift consecutive bars vertically (if transpose= False), and
+              horizontally(if transpose= True) by stride value.
+            - Default is True.
+        cmap : str or dict
+            - If a string, it should be a colormap name to generate colors.
+            - If a dictionary, it should map unique values to specific colors.
+            - Default is 'rainbow'.
+        edge_color : str
+            - The color to use for the edges of the rectangle.
+            - Default is '#000000'.
+        fallback_color : str
+            - The color to use as fallback if no specific color is assigned.
+            - Default is '#FAFAFA'.
+        hmap : dict
+            - A dictionary mapping unique values to their corresponding hatch patterns.
+            - Default is '{}'.
+        fallback_hatch : str
+            - The hatch pattern to use as fallback if no specific hatch is assigned.
+            - Default is '" "' (string with single space).
+        display_hatch : bool
+            - A flag indicating whether to display hatch patterns on cells.
+            - Default is False.
+        transpose : bool (optional)
+            - A flag indicating whether to transpose the KitikiPlot. 
+            - Default is False.
+        xlabel : str (optional)
+            - Label for the x-axis. 
+            - Default is "Sliding Windows".
+        ylabel : str (optional)
+            - Label for the y-axis. 
+            - Default is "Frames".
+        display_xticks : bool (optional)
+            - A flag indicating whether to display xticks
+            - Default is True
+        display_yticks : bool (optional)
+            - A flag indicating whether to display yticks
+            - Default is True
+        xtick_prefix : str (optional)
+            - Prefix for x-axis tick labels. 
+            - Default is "Window".
+        ytick_prefix : str (optional)
+            - Prefix for y-axis tick labels. 
+            - Default is "Frame".
+        xticks_values : list (optional)
+            - List containing the values for xticks
+            - Default is []
+        yticks_values : list (optional)
+            - List containing the values for yticks
+            - Default is []
+        xticks_rotation : int (optional)
+            - Rotation angle for x-axis tick labels. 
+            - Default is 0.
+        yticks_rotation : int (optional)
+            - Rotation angle for y-axis tick labels. 
+            - Default is 0.
+        title : str (optional)
+            - The title of the plot. 
+            - Default is "KitikiPlot: Intuitive Visualization for Sliding Window".
+        display_grid : bool (optional)
+            - A flag indicating whether to display grid on the plot.
+            - Default is False.
+        display_legend : bool (optional)
+            - A flag indicating whether to display a legend on the plot. 
+            - Default is False.
+        legend_hatch : bool (optional)
+            - A flag indicating whether to include hatch patterns in the legend. 
+            - Default is False.
+        legend_kwargs : dict (optional)
+            - Additional keyword arguments passed to customize the legend.
+            - Default is {}.
+        kitiki_cell_kwargs : dict (optional)
+            - Additional keyword arguments passed to customize individual cells.
+            - Default is {}.
+        
+        Returns
+        -------
+        None: Displays the plot directly.
+        """       
+
+        # Configure color mapping based on user input
+        self.color_map= self.color_config( cmap= cmap, edge_color= edge_color, fallback_color= fallback_color )
+        
+        # Determine if hatching should be displayed based on 'hmap' presence
+        if len(hmap)> 0:
+            display_hatch= True
+
+        # If 'display_hatch' is False and 'hmap' not given; default hatch settings are applied
+        if not display_hatch:
+            hmap= " "
+            fallback_hatch= " "
+
+        # Configure hatch mapping based on user input and conditions
+        self.hatch_map= self.hatch_config( h_map= hmap, fallback_hatch= fallback_hatch, display_hatch= display_hatch)
+
+        # Create figure and axis for plotting
+        fig, ax = plt.subplots( figsize= figsize)
+
+        # List to hold cell patches
+        patches= [] 
+
+        # Prepare data for plotting
+        data= self.data.values
+
+        # Check if the specified window range is set to "all"
+        if window_range== "all":
+
+            # If "all" is specified, set window_range to cover all rows in the data
+            window_range= range(self.rows)
+
+        else:
+
+            # If a specific range is provided, create a range object from the start to end index
+            # This allows for plotting only a subset of the data based on the user-defined range
+            window_range= range( window_range[0], window_range[1])
+
+        # Generate cells for each sample in the specified window range and time frame columns
+        for index in window_range:
+
+            each_sample= data[ index ]
+
+            for time_frame in range(self.cols):
+
+                # Create each cell using specified parameters and add it to patches list 
+                cell_gen= self.create(  x= index,
+                                        y= time_frame,
+                                        each_sample= each_sample,
+                                        cell_width= cell_width,
+                                        cell_height= cell_height,
+                                        window_gap= window_gap,
+                                        align= align,
+                                        edge_color= edge_color,
+                                        cmap= self.color_map,
+                                        fallback_color= fallback_color,
+                                        hmap= self.hatch_map,
+                                        fallback_hatch= fallback_hatch,
+                                        display_hatch= display_hatch,
+                                        transpose= transpose,
+                                        **kitiki_cell_kwargs
+                                    )
+                patches.append( cell_gen )
+
+        # Set plot titles
+        plt.title(title)
+
+        # Configure ticks based on transposition setting
+        if not transpose:
+
+            # Calculate x and y positions for ticks when not transposed
+            x_positions= [(i+1)*window_gap+(i+1)*cell_width+cell_width/2 for i in range(self.rows)]
+            
+            y_positions= [(self.rows+ self.cols- self.stride- i)*cell_height+cell_height/2 for i in range(self.stride*self.rows+self.cols)]
+
+            # Display xticks if 'display_xticks' is True
+            if display_xticks:
+
+                # Configure xticks based on input 'xticks_values'
+                if xticks_values:
+                    
+                    # Find no.of 'xticks_values'
+                    n_xticks_values= len(xticks_values)
+
+                    # Set x-ticks with the input 'xticks_values'
+                    plt.xticks( x_positions[:n_xticks_values], xticks_values, rotation= xticks_rotation)
+
+                # Configure default xticks
+                else:
+
+                    # Set x-ticks with appropriate labels (with default prefixes) and rotation
+                    plt.xticks( x_positions, [xtick_prefix+'_'+str(i+1) for i in range(self.rows)], rotation= xticks_rotation)
+            
+            # Else turn off the xticks
+            else:
+                plt.xticks([], [])
+            
+            # Display yticks if 'display_yticks' is True
+            if display_yticks:
+
+                # Configure yticks based on input 'yticks_values
+                if yticks_values:
+
+                    # Find no.of 'yticks_values'
+                    n_yticks_values= len(yticks_values)
+
+                    # Set y-ticks with the input 'yticks_values'
+                    plt.yticks( y_positions[:n_yticks_values], yticks_values, rotation= yticks_rotation)
+
+                # Configure default yticks
+                else:
+
+                    # Set y-ticks with appropriate labels and rotation
+                    plt.yticks( y_positions, [ytick_prefix+"_"+str(i) for i in range(self.stride*self.rows+self.cols)], rotation= yticks_rotation)
+            
+            # Else turn off the yticks
+            else:
+                plt.yticks([], [])
+                
+            # Draw grid lines if display_grid is True
+            if display_grid:
+                hline_positions= [(self.rows+ self.cols- self.stride- i)*cell_height for i in range(self.stride*self.rows+self.cols+1)]
+                ax.hlines(y= hline_positions+[max(hline_positions)+cell_height], xmin=0, xmax=max(x_positions) + cell_width, colors='gray', linestyles='--', linewidth=0.5)
+
+        else:
+
+            # Calculate x and y positions for ticks when transposed
+            x_positions= [(i+1)*cell_height+cell_height/2 for i in range(self.stride*(self.rows-1)+ self.cols)]
+            y_positions= [(self.rows-i+1)*window_gap+(self.rows-i+1)*cell_width+cell_width/2 for i in range(self.rows)]
+            # Display xticks if 'display_xticks' is True
+            if display_xticks:
+
+                # Configure xticks based on input 'xticks_values'
+                if xticks_values:
+
+                    # Find no.of 'xticks_values'
+                    n_xticks_values= len( xticks_values )
+
+                    # Set x-ticks with the input 'xticks_values'
+                    plt.xticks( x_positions[:n_xticks_values], xticks_values, rotation= xticks_rotation)
+
+                # Configure default xticks
+                else:
+
+                    # Set x-ticks with appropriate labels and rotation (note the switch of prefixes)
+                    plt.xticks( x_positions, [xtick_prefix+"_"+str(i+1) for i in range(self.stride*(self.rows-1)+ self.cols)], rotation= xticks_rotation)
+            
+            # Else turn off the xticks
+            else:
+                plt.xticks([], [])
+
+
+            # Display yticks if 'display_yticks' is True
+            if display_yticks:
+
+                # Configure yticks based on input 'yticks_values'
+                if yticks_values:
+
+                    # Find no.of 'yticks_values'
+                    n_yticks_values= len( yticks_values )
+
+                    # Set y-ticks with the input 'yticks_values'
+                    plt.yticks( y_positions[:n_yticks_values], yticks_values, rotation= yticks_rotation)
+                
+                # Configure default yticks
+                else:
+
+                    # Set y-ticks with appropriate labels and rotation (note the switch of prefixes)
+                    plt.yticks( y_positions, [ytick_prefix+'_'+str(i+1) for i in range(self.rows)], rotation= yticks_rotation)
+            
+            # Else turn off the yticks
+            else:
+                plt.yticks([], [])
+                
+            
+            # Draw vertical grid lines if display_grid is True
+            if display_grid:
+                vline_positions= [(i+1)*cell_height for i in range(self.stride*(self.rows-1)+ self.cols+1)]
+                ax.vlines(x= vline_positions, ymin=0, ymax=max(y_positions) + cell_width, colors='gray', linestyles='--', linewidth=0.5)
+
+        # Set label for 'x'-axis
+        plt.xlabel(xlabel)
+
+        # Set label for 'y'-axis
+        plt.ylabel(ylabel)
+            
+        # Add all created patches (cells) to axes for rendering
+        for each_patch in patches:
+            ax.add_patch( each_patch )
+
+        # Update the limits of the axes based on the current data
+        ax.relim()
+
+        # Automatically adjust the view limits to fit the data within the axes
+        ax.autoscale_view() 
+
+        # Check if a legend should be displayed based on user input
+        if display_legend:
+
+            # Call the legend method to create and display the legend on the specified axes
+            # Pass in the color map, hatch map, and any additional keyword arguments for customization
+            self.legend( ax= ax, color_map= self.color_map,hatch_map= self.hatch_map, legend_hatch= legend_hatch, **legend_kwargs  )
+
+        # Show the plot with all configurations applied
+        plt.show()
+
+    def legend(self, ax: matplotlib.axes.Axes, color_map: dict, hatch_map: dict, legend_hatch: bool, **legend_kwargs: dict ) -> matplotlib.legend.Legend:
+        """
+        Create and display legend for the KitikiPlot visualization.
+
+        Parameters
+        ----------
+        ax : matplotlib.axes.Axes
+            - The axes object where the legend will be placed.
+        color_map : dict
+            - A dictionary mapping unique values to their corresponding colors.
+        hatch_map : dict
+           -  A dictionary mapping unique values to their corresponding hatch patterns.
+        legend_hatch : bool (optional)
+            - A flag indicating whether to include hatch patterns in the legend. 
+            - Default is False.
+        legend_kwargs: dict (optional) 
+            - Additional keyword arguments passed to customize the legend.
+            - Default is {}.
+
+        Returns 
+        -------
+        matplotlib.legend.Legend: The created legend object.
+       """
+        
+        # Check if hatch patterns should be included in the legend 
+        if not legend_hatch:
+
+            # Create legend patches without hatching
+            # Each patch corresponds to a color in the color map and is labeled with its key
+            legend_patches = [mpatches.Patch(facecolor=color, label=label) for label, color in color_map[0].items()]
+
+
+        else:
+            # Create legend patches that include hatching
+            # Each patch corresponds to a color in the color map and is labeled with its key
+            # The hatch pattern is specified based on the 'hatch_map', multiplied by 2 for visibility
+            legend_patches= [mpatches.Patch(facecolor= color_map[0][key], label= key, hatch= r"{}".format(hatch_map[key]*2)) for key in color_map[0]]
+            
+        kwargs= legend_kwargs
+
+        # Return the created legend object, attaching the generated patches and any additional kwargs
+        return ax.legend(handles=legend_patches, **legend_kwargs)
+        

kitikiplot-0.1.3.dist-info/LICENSE

@@ -0,0 +1,23 @@
+Copyright (C) 2024 Boddu Sri Pavan
+
+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.

kitikiplot-0.1.3.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: kitikiplot
+Version: 0.1.3
+Summary: A Python library to visualize categorical sliding window data.
+Home-page: https://github.com/BodduSriPavan-111/kitikiplot
+Author: Boddu Sri Pavan
+Author-email: boddusripavan111@gmail.com
+License: LICENSE
+Project-URL: Bug Tracker, https://github.com/BodduSriPavan-111/kitikiplot/issues
+Project-URL: Documentation, https://github.com/BodduSriPavan-111/kitikiplot/wiki
+Project-URL: Source Code, https://github.com/BodduSriPavan-111/kitikiplot
+Keywords: sliding window,sequential,time-series,genome,categorical data
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+![plot](https://drive.google.com/uc?id=1kzO8VZC38-ktIezrnFvH1b7K84zGBrsL)
+
+<div align="center">
+
+![PyPI](https://img.shields.io/pypi/v/kitikiplot?color=blueviolet)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/kitikiplot?color=gold)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.14632005.svg)](https://doi.org/10.5281/zenodo.14632005)
+![License](https://img.shields.io/github/license/BodduSriPavan-111/kitikiplot?color=green)
+
+</div>
+
+# KitikiPlot
+KitikiPlot is a Python library for visualizing sequential and time-series categorical "Sliding Window" data. <br>
+(The term 'kitiki' means 'window' in Telugu)
+
+Our preprint is published in **TechRxiv**. Find it <a href="https://www.techrxiv.org/users/877016/articles/1256589-kitikiplot-a-python-library-to-visualize-categorical-sliding-window-data"> here <a/>
+
+Research paper is published in **GIS Science Journal** Volume 12 Issue 1, 186-193, 2025 (Scopus indexed with Impact factor **6.1**). </br>
+Read it here: <a href="https://zenodo.org/records/14632005">https://zenodo.org/records/14632005</a>
+<!--
+## Table of Contents</h2>
+- [Why Kitkiplot?](#What-and-why)
+- [Getting Started](#getting-started)
+- [Contribute](#contribute)
+- [Maintainer(s)](#maintainer(s))
+- [Citation](#citation)
+
+## Why Kitikiplot?
+-->
+
+### Examples 
+Genome Visualization can be found in [Genome.ipynb](https://github.com/BodduSriPavan-111/kitikiplot/blob/add-comments/examples/Genome.ipynb)
+![plot](https://drive.google.com/uc?id=1vpRcqUsalg64ILluCgcXfoaUfcqQfHVN)
+<br><br>
+Weather Pattern in [Weather Pattern.ipynb](https://github.com/BodduSriPavan-111/kitikiplot/blob/add-comments/examples/Weather_Pattern.ipynb)
+![plot](https://drive.google.com/uc?id=1tl5XefYfBqQTap1X0iDNoY3upk0FHFni)
+<br><br>
+CO Trend in Air in [Air_Quality.ipynb](https://github.com/BodduSriPavan-111/kitikiplot/blob/add-comments/examples/Air_Quality.ipynb)
+![plot](https://drive.google.com/uc?id=1LTFgNDX-OlTwkSQjsWA3x6xHRLyu_a6O)
+<br>
+
+### Getting Started
+Install the package via pip:
+```
+pip install kitikiplot
+```
+#### Usage
+```py
+from kitikiplot import KitikiPlot
+
+data = [] # DataFrame or list of sliding window data
+
+ktk= KitikiPlot( data= data )
+
+ktk.plot( display_legend= True ) # Display the legend
+```
+Check out the complete <b>guide of customization</b> [here](https://github.com/BodduSriPavan-111/kitikiplot/blob/main/examples/Usage_Guide.ipynb).
+
+Please refer <a href="https://github.com/BodduSriPavan-111/kitikiplot/blob/main/CONTRIBUTING.md">CONTRIBUTING.md</a> for <b>contributions</b> to kitikiplot.
+
+### Author
+<a href="https://www.linkedin.com/in/boddusripavan/"> Boddu Sri Pavan </a> & 
+<a href="https://www.linkedin.com/in/boddu-swathi-sree-2a2a58332/"> Boddu Swathi Sree </a>
+
+## Citation
+APA <br>
+> Boddu Sri Pavan, Chandrasheker Thummanagoti, & Boddu Swathi Sree. (2025). KitikiPlot A Python library to visualize categorical sliding window data. https://doi.org/10.5281/zenodo.14632005.
+
+IEEE <br>
+> Boddu Sri Pavan, Chandrasheker Thummanagotiand Boddu Swathi Sree, “KitikiPlot A Python library to visualize categorical sliding window data”, 2025, doi: 10.5281/zenodo.14632005.
+
+BibTeX <br>
+> @misc{boddu_sri_pavan_2025_14632005,       <br>
+>  author       = {Boddu Sri Pavan and       <br>
+>                  Chandrasheker Thummanagoti and       <br>
+>                  Boddu Swathi Sree},       <br>
+>  title        = {KitikiPlot A Python library to visualize       <br>
+>                   categorical sliding window data       <br>
+>                  },       <br>
+>  month        = jan,       <br>
+>  year         = 2025,       <br>
+>  publisher    = {Zenodo},       <br>
+>  doi          = {10.5281/zenodo.14632005},       <br>
+>  url          = {https://doi.org/10.5281/zenodo.14632005},       <br>
+>}
+
+## Thank You !

kitikiplot-0.1.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+kitikiplot/__init__.py,sha256=7LpJy1V-PZ-JlfjsnRMjMXxTKaFt0JP0mj-A0SgS-sE,34
+kitikiplot/kitiki_cell.py,sha256=N356LoJACH7qjoVn0T0GpLPVmXnyr6bBmM19dhLY7J8,6796
+kitikiplot/kitiki_color_config.py,sha256=_HsOr1txgj8E4-Xro6-ekLSRH0FSrSnzvpXjAD2AbMw,10718
+kitikiplot/kitikiplot.py,sha256=eOxtrRjg2u7AeDw4l1qE6qwutTlmKur_xpqLAnJViSs,19203
+kitikiplot-0.1.3.dist-info/LICENSE,sha256=14Bs-3ieyNjj9kCnVLv8CHRXEvQVM6P5uLe-pz7cBI0,1088
+kitikiplot-0.1.3.dist-info/METADATA,sha256=u8L2vcbiRYzw6_1uuNGlo0ZcCC0-z0UK3pYwQ8WObs4,4714
+kitikiplot-0.1.3.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+kitikiplot-0.1.3.dist-info/top_level.txt,sha256=nqjD8Sil5L7rfBQtnmLdJMR-u2BdVFnusZlOIU0Yd00,11
+kitikiplot-0.1.3.dist-info/RECORD,,

kitikiplot-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kitikiplot-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+kitikiplot