piegy 1.0.0__py3-none-any.whl

piegy/tools/figure_tools.py

@@ -0,0 +1,206 @@
+'''
+Helper functions for making figures.
+
+Functions:
+- heatmap:          Make a heatmap based on input data. Sets title, text ... as well
+- bar:              Make a barplot. Sets title, text ... as well.
+- scatter:          Make a scatter plot. Sets title, text ... as well.
+- gen_title:        Generates a title when the plot is about an interval of time.
+- gen_text:         Generates a text about standard deviation info.
+- scale_interval:   scale interval if sim's data was already reduced.
+- ave_interval:     Calculates average value of data over a time interval.
+- ave_interval_1D:  Return in a 1D format.
+'''
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+
+# move ax a bit left if add text
+# default value is [0.125, 0.11, 0.9, 0.88]
+
+
+def heatmap(data, cmap = "Greens", annot = False, fmt = '.3g', title = None, text = None):
+    '''
+    Helper function for making heatmaps.
+
+    Inputs:
+        data:   1D data for which you want to make a heatmap. 
+        cmap:   Color of heatmap. Uses matplotlib color maps
+        annot:  Whether to show numbers of every block.
+        fmt:    Number format for annotations. How many digits you want to keep.
+        title:  The title you want to add. None means no title.
+        text:   Adds some text in a text block at the top-right corner.
+
+    Returns:
+        fig:    Seaborn heatmap.
+    '''
+
+    fig, ax = plt.subplots()
+    if text != None:
+        ax.text(0.63, 0.9, text, size = 10, linespacing = 1.5, transform = plt.gcf().transFigure)
+
+    ax = sns.heatmap(data, cmap = cmap, annot = annot, fmt = fmt)
+    ax.title.set_text(title)
+    
+    return fig
+
+
+
+def bar(data, color = "green", xlabel = None, ylabel = None, title = None, text = None):
+    '''
+    Helper Function for making barplots.
+
+    Inputs:
+        data:   2D data to make barplot.
+        color:  Uses Matplotlib colors.
+        xlabel, y_label: 
+                Label for axes.
+        title:  Title for the barplot.
+        text:   Adds some text in a text block at the top-right corner.
+    
+    Returns:
+        fig:    A Matplotlib barplot.
+    '''
+
+    N = np.array(data).size
+    xaxis = np.array([i for i in range(N)])
+    
+    # make figure larger if has more data points
+    fig, ax = plt.subplots()
+    if N > 60:
+        fig.set_size_inches(min(N * 0.12, 9.6), 4.8)
+
+    if text != None:
+        ax.text(0.63, 0.9, text, size = 10, linespacing = 1.5, transform = plt.gcf().transFigure)
+
+    ax.bar(x = xaxis, height = data, color = color)
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.title.set_text(title)
+    
+    return fig
+
+
+
+def scatter(X, Y, color = "orange", alpha = 0.25, xlabel = "x", ylabel = "y", title = None):
+    '''
+    Helper function for makeing scatter plots.
+
+    Inputs:
+        X:      x-coordinates of points.
+        Y:      y-coordinates of points.
+        Note color is Matplotlib colors.
+    
+    Returns:
+        fig:    A Matplotlib scatter plot.
+    '''
+    
+    fig, ax = plt.subplots()
+    ax.scatter(X, Y, color = color, alpha = alpha)
+    
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.title.set_text(title)
+
+    return fig
+
+
+
+def gen_title(title, start, end):
+    '''
+    Generate a title for plot when it's about an interval of time.
+    '''
+    title += ", " + str(round(start * 100, 1)) + " ~ " + str(round(end * 100, 1)) + "%"
+    return title
+
+
+
+def gen_text(ave, std):
+    '''
+    Generate text about standard deviation info.
+    '''
+    text = "ave: " + str(round(ave, 3)) + ", std: " + str(round(std, 3))
+    return text
+
+
+
+def ave_interval(data, start_index, end_index):
+    '''
+    Calculate average value of data over an interval. Return a 2D np.array
+    Assume data is 3D with shape N x M x K, then takes average on the 3rd axis.
+
+    Input:
+        data:       3D np.array or list. Will take average on the 3rd axis.
+        start_index, end_index: 
+                    over what interval to take average.
+
+    Returns:
+        data_ave:   2D np.array with shape N x M, contains average value of data.
+    '''
+    
+    N = len(data)
+    M = len(data[0])
+    
+    # plot a particular record
+    if start_index == end_index:
+        start_index = end_index - 1
+        
+    data_ave = np.zeros((N, M))
+    
+    for i in range(N):
+        for j in range(M):
+            for k in range(start_index, end_index):
+                data_ave[i][j] += data[i][j][k]
+            data_ave[i][j] /= (end_index - start_index)
+    
+    return data_ave
+
+
+
+def ave_interval_1D(data, start_index, end_index):
+    '''
+    Calculate average value of data over an interval. Return a 1D np.array.
+    Assume data is 3D and has shape (1 x M x K) or (N x 1 x K). Then implicitly 'compress' that 1 and takes average on the 3rd axis.
+
+    Input:
+        data:       3D np.array or list. One of its dimensions must have size 1. Will take average on the 3rd axis.
+        start_index, end_index: 
+                    over what interval to take average.
+
+    Returns:
+        data_ave:   1D np.array with len N * M, contains average value of data.
+    '''
+    
+    N = len(data)
+    M = len(data[0])
+
+    if start_index == end_index:
+        start_index = end_index - 1
+        
+    data_ave = np.zeros(N * M)
+    
+    for i in range(N):
+        for j in range(M):
+            for k in range(start_index, end_index):
+                data_ave[i * M + j] += data[i][j][k]
+            data_ave[i * M + j] /= (end_index - start_index)
+    
+    return data_ave
+
+
+
+def scale_interval(interval, compress_itv):
+    # scale interval if sim's data was already reduced.
+    if compress_itv < 1:
+        raise ValueError('figures.scale_interval has compress_itv < 1:', compress_itv)
+
+    interval = int(interval / compress_itv)
+    if interval == 0:
+        print('Warning: data already smoothed by an interval: sim.compress_itv =', compress_itv, 'which is coarser than your', interval)
+        interval = 1
+
+    return interval
+
+

piegy/tools/file_tools.py

@@ -0,0 +1,29 @@
+'''
+File-processing tools.
+
+Functions:
+- del_dirs:     Delete everything in a directory, as well as the directory itself.
+'''
+
+import os
+
+
+def del_dirs(dirs):
+    # Delete everything in a directory.
+    
+    subdirs_list = []
+    
+    for subdirs, dirs_, files in os.walk(dirs):
+        if subdirs not in subdirs_list:
+            subdirs_list.append(subdirs)
+            
+        for file in files:
+            path = os.path.join(subdirs, file)
+            if os.path.isfile(path):
+                os.remove(path)
+    
+    len_s = len(subdirs_list)
+    
+    for i in range(len_s):
+        os.rmdir(subdirs_list[len_s - i - 1])
+

piegy/videos.py

@@ -0,0 +1,322 @@
+'''
+Make mp4 videos for simulation results.
+
+Videos are made by:
+make every frame by figures.py functions, then put frames together into a video.
+
+Public Function:
+- make_video:   make video based simulation results.
+
+Private Functions
+- get_max_lim:  Get the max lim (interval) over many lims, and then expand it a bit for better accommodation.
+                Essentially takes union of those intervals. 
+- video_lim:    Find a large enough xlim and ylim for video.
+- sort_frames:  Put frames in order.
+other not documented here.
+
+'''
+
+
+from . import figures
+from .tools import file_tools as file_t
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import imageio.v2 as imageio
+import re
+from moviepy import VideoFileClip
+
+
+# a list of supported figures
+SUPPORTED_FIGURES = ['UV_heatmap', 'pi_heatmap', 'UV_bar', 'pi_bar', 'UV_hist', 'pi_hist', 'UV_pi']
+
+
+# map function name to functios in figures.py
+# functions not in this dictionary is not supported for videos.
+FUNC_DICT = {'UV_heatmap': figures.UV_heatmap, 'UV_bar': figures.UV_bar, 'UV_hist': figures.UV_hist, 
+             'pi_heatmap': figures.pi_heatmap, 'pi_bar': figures.pi_bar, 'pi_hist': figures.pi_hist, 'UV_pi': figures.UV_pi}
+
+
+# Map some color maps to regular colors, used to change colors when an invalid color name is given
+SNS_PLT_COLOR_DICT = {'Greens': 'green', 'Purples': 'purple', 'BuPu': 'violet', 'YlGn': 'yellowgreen'}
+# Map regular colors to color maps
+PLT_SNS_COLOR_DICT = {'green': 'Greens', 'purple': 'Purples', 'violet': 'BuPu', 'yellowgreen': 'YlGn'}
+
+
+
+
+def convert_color(func_name, U_color, V_color):
+    '''
+    Converts some invalid colors.
+    If making heatmap videos but gave single colors, map to color maps.
+    If making barplot or histogram videos but gave single colors, map to Matplotlib
+    '''
+
+    if 'heatmap' in func_name:
+        # if making heatmaps but give regular colors
+        if U_color in PLT_SNS_COLOR_DICT.keys():
+            print('Making heatmaps, changed \'' + U_color + '\' to \'' + PLT_SNS_COLOR_DICT[U_color] + '\'')
+            U_color = PLT_SNS_COLOR_DICT[U_color]
+        if V_color in PLT_SNS_COLOR_DICT.keys():
+            print('Making heatmaps, changed \'' + V_color + '\' to \'' + PLT_SNS_COLOR_DICT[V_color] + '\'')
+            V_color = PLT_SNS_COLOR_DICT[V_color]
+        
+        return U_color, V_color
+
+    elif 'heatmap' not in func_name:
+        # if making barplots or histogram
+        if U_color in SNS_PLT_COLOR_DICT.keys():
+            print('Not making heatmaps, changed \'' + U_color + '\' to \'' + SNS_PLT_COLOR_DICT[U_color] + '\'')
+            U_color = SNS_PLT_COLOR_DICT[U_color]
+        if V_color in SNS_PLT_COLOR_DICT.keys():
+            print('Not making heatmaps, changed \'' + V_color + '\' to \'' + SNS_PLT_COLOR_DICT[V_color] + '\'')
+            V_color = SNS_PLT_COLOR_DICT[V_color]
+
+        return U_color, V_color
+
+
+
+def get_max_lim(lims):
+    '''
+    Get the max lim over many lims, i.e., the lowest lower bound and highest upper bound.
+    And then expand it a bit for better accommodation.
+
+    Input:
+        lim:    list or np.array, has form [lim1, lim2, ...]
+    
+    Returns:
+        A max lim which contains all lims.
+    '''
+
+    lims = np.array(lims)
+    
+    lim_min = np.min(lims[:, 0]) # min of min
+    lim_max = np.max(lims[:, 1]) # max of max
+    r = lim_max - lim_min
+
+    if lim_min != 0:
+        # negative values are reached
+        # extend both upper bound and lower bound 
+        return [lim_min - r * 0.05, lim_max + r * 0.05]
+    else:
+        # only extend upper bound
+        return [0, lim_max + r * 0.05]
+
+
+
+
+def frame_lim(sim, func, frames):
+    '''
+    Find a large enough xlim and ylim for frames, if not heatmaps.
+
+    Inputs:
+        sim:        A stochastic_model.simulation object, the simulation results.
+        frames:     How many frame to make for the video.
+    
+    Returns:
+        xlim and ylim for U and V, 4 in total.
+    '''
+    
+    # take 10 samples and store their lims in list
+    U_xlist = []
+    U_ylist = []
+    V_xlist = []
+    V_ylist = []
+    
+    for i in range(10):
+        U_fig, V_fig = func(sim, start = i / 10, end = (i / 10 + 1 / frames))
+
+        U_xlist.append(U_fig.get_axes()[0].get_xlim())
+        U_ylist.append(U_fig.get_axes()[0].get_ylim())
+        V_xlist.append(V_fig.get_axes()[0].get_xlim())
+        V_ylist.append(V_fig.get_axes()[0].get_ylim())
+
+        plt.close(U_fig)
+        plt.close(V_fig)
+    
+    # get the largest 'range' based on the lists
+    U_xlim = get_max_lim(U_xlist)
+    U_ylim = get_max_lim(U_ylist)
+    V_xlim = get_max_lim(V_xlist)
+    V_ylim = get_max_lim(V_ylist)
+    
+    return U_xlim, U_ylim, V_xlim, V_ylim
+
+
+
+
+def frame_heatmap_lim(sim, func, frames):
+    '''
+    Find a large enough color bar lim for frames, if heatmaps.
+
+    Inputs:
+        sim:        A stochastic_model.simulation object, the simulation results.
+        frames:     How many frame to make for the video.
+    
+    Returns:
+        clim for U and V
+    '''
+
+    U_list = []
+    V_list = []
+
+    for i in range(10):
+        U_fig, V_fig = func(sim, start = i / 10, end = (i / 10 + 1 / frames))
+
+        U_ax = U_fig.get_axes()[0]
+        U_list.append(U_ax.collections[0].get_clim())
+        V_ax = V_fig.get_axes()[0]
+        V_list.append(V_ax.collections[0].get_clim())
+
+        plt.close(U_fig)
+        plt.close(V_fig)
+
+    U_clim = get_max_lim(U_list)
+    V_clim = get_max_lim(V_list)
+
+    return U_clim, V_clim
+
+
+
+def sort_frames(images):
+    '''
+    Put frames in order.
+
+    Inputs:
+        images: A list of dirs (frame names)
+    '''
+    numeric_part, non_numeric_part = re.match(r'(\d+) (\D+)', images).groups()
+    return (int(numeric_part), non_numeric_part)
+
+
+
+def make_mp4(dirs, frame_dirs, duration, video_name):
+    '''
+    Convert frames into a mp4 video.
+
+    Inputs:
+        dirs:       where to store the video.
+        frame_dirs: where to find frames.
+        duration:   how long the video should be.
+        video_name: name of the video.
+    '''
+
+    # png to gif
+    images = [img for img in os.listdir(frame_dirs) if img.endswith('.png')] 
+    images.sort(key = sort_frames)
+
+    image_list = []
+    for img in images:
+        img_path = os.path.join(frame_dirs, img)
+        image_list.append(imageio.imread(img_path))
+    gif_dirs = dirs + '/temp.gif'
+    imageio.mimsave(gif_dirs, image_list, format = 'gif', duration = duration)
+    
+    # gif to mp4
+    clip = VideoFileClip(gif_dirs)
+    clip.write_videofile(video_name, logger = None)
+    # delete gif
+    os.remove(gif_dirs)
+
+
+
+def make_video(sim, func_name = 'UV_heatmap', frames = 100, speed = 1.25, dpi = 120, U_color = 'Greens', V_color = 'Purples', annot = False, fmt = '.3g', del_frames = False, dirs = 'videos'):
+    '''
+    Make a mp4 video based on simulation results.
+
+    Inputs:
+    - sim:            a stochastic_model.simulation object, the simulation results.
+    - func_name:      what function to use to make the frames. Should be one of the functions in figures.py
+    - frames:         how many frames to make. Use more frames for more smooth evolutions.
+    - speed:          how long every frame should last. Use larger number for slower video.
+    - dpi:            dpi of frames
+    - U_color:        color for U's videos. Color maps or regular colors, based on what function you use.
+    - V_color:        color for V's videos.
+    - annot:          used by heatmaps. Whether to show numbers.
+    - fmt:            number format
+    - del_frames:     whether to delete frames after making video.
+    - dirs:           where to store the frames and videos.
+    '''
+    
+    if func_name not in FUNC_DICT.keys():
+        raise ValueError(func_name + ' not supported for videos.')
+    func = FUNC_DICT[func_name]
+
+    # convert color if invalid colors are given
+    U_color, V_color = convert_color(func_name, U_color, V_color)
+    
+    # print progress
+    one_progress = frames / 100
+    current_progress = one_progress
+    
+    if 'heatmap' in func_name:
+        # make sure a fixed color bar for all frames
+        U_clim, V_clim = frame_heatmap_lim(sim, func, frames)
+    else:
+        # make sure y axis not changing if not making heatmaps
+        U_xlim, U_ylim, V_xlim, V_ylim = frame_lim(sim, func, frames)
+
+    
+    U_frame_dirs = dirs + '/U-' + func_name
+    V_frame_dirs = dirs + '/V-' + func_name
+    
+    if os.path.exists(U_frame_dirs):
+        file_t.del_dirs(U_frame_dirs)
+    os.makedirs(U_frame_dirs)
+    if os.path.exists(V_frame_dirs):
+        file_t.del_dirs(V_frame_dirs)
+    os.makedirs(V_frame_dirs)
+
+        
+    #### for loop ####
+    
+    for i in range(frames):
+        if i > current_progress:
+            print('making frames', round(i / frames * 100), '%', end = '\r')
+            current_progress += one_progress
+        
+        if 'heatmap' in func_name:
+            U_fig, V_fig = func(sim, U_color, V_color, start = i / frames, end = (i + 1) / frames, annot = annot, fmt = fmt)
+        else:
+            U_fig, V_fig = func(sim, U_color, V_color, start = i / frames, end = (i + 1) / frames)
+        U_ax = U_fig.get_axes()[0]
+        V_ax = V_fig.get_axes()[0]
+        
+        if 'heatmap' in func_name:
+            U_ax.collections[0].set_clim(U_clim)
+            V_ax.collections[0].set_clim(V_clim)
+        else:
+            # make sure y axis not changing if not heatmap and not UV_pi
+            U_ax.set_ylim(U_ylim)
+            V_ax.set_ylim(V_ylim)
+            if ('hist' in func_name) or (func_name == 'UV_pi'):
+                # need to set xlim as well for UV_pi and histograms
+                U_ax.set_xlim(U_xlim)
+                V_ax.set_xlim(V_xlim)
+
+        U_fig.savefig(U_frame_dirs + '/' + str(i) + ' U' + '.png', dpi = dpi)
+        V_fig.savefig(V_frame_dirs + '/' + str(i) + ' V' + '.png', dpi = dpi)
+        
+        plt.close(U_fig)
+        plt.close(V_fig)
+        
+    #### for loop ends ####
+    
+    # frames done
+    print('making mp4...      ', end = '\r')
+    
+    # make videos based on frames
+    make_mp4(dirs, U_frame_dirs, frames * speed, dirs + '/U-' + func_name + '.mp4')
+    make_mp4(dirs, V_frame_dirs, frames * speed, dirs + '/V-' + func_name + '.mp4')
+    
+    if del_frames:
+        file_t.del_dirs(U_frame_dirs)
+        file_t.del_dirs(V_frame_dirs)
+        print('video saved: ' + dirs + ', frames deleted')
+    else:
+        print('video saved: ' + dirs + '      ')
+
+
+

piegy-1.0.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: piegy
+Version: 1.0.0
+Summary: Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory
+Author-email: Chenning Xu <cxu7@caltech.edu>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2025, Chenning Xu
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Source, https://github.com/Chenning04/piegy.git
+Project-URL: Documentation, https://piegy.readthedocs.io/en/
+Keywords: Game Theory,Evolutionary Game Theory,Spatial Model,Stochastic Model,Payoff Driven
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: imageio>=2.37.0
+Requires-Dist: moviepy>=2.1.1
+Requires-Dist: seaborn>=0.13.2
+Dynamic: license-file
+
+# piegy
+
+The package full name is: Payoff-Driven Stochastic Spatial Model for Evolutionary Game Theory
+
+Provides a stochastic spatial model for simulating the interaction and evolution of two species in either 1D or 2D space, as well as analytic tools.
+
+## Installation
+
+```bash
+pip install piegy
+```
+
+## Documentation and Source
+
+See source code at: [GitHub-piegy repo](https://github.com/Chenning04/piegy.git). 
+The *piegy* documentation at: [piegy docs](https://piegy.readthedocs.io/en/). 
+
+## How the Model Works
+
+Our model can be summarized as "classical game theory endowed with a spatial structure and payoff-driven migration rules". Consider two species, predators and preys (denote by *U* and *V*), in a rectangular region. We divide the region into N by M patches and simulate their interaction within a patch by classical game theory (i.e., payoff matrices and carrying capacity). Interactions across patches are simulated by payoff-driven migration rules. An individual migrates to a neighboring patch with probability weighted by payoff in the neighbors.
+
+We use the Gillepie algorithm as the fundamental event-selection algorithm. At each time step, one event is selected and let happen; and step sizes are continuous, dependent on the current state in the space. Data are recorded every some specified time interval.
+
+## Analytic Tools
+
+The *piegy* package also provides a wide range of analytic and supportive tools alongside the main model, such as plotting, numerical tools, data saving & reading, etc. We also provide the *piegy.videos* module for more direct visualizations like how population distribution change over time.
+
+## Examples
+
+To get started, simply get our demo model and run simulation:
+
+```python
+from piegy import model, figures
+
+sim = model.demo_model()
+model.run(sim)
+
+dynamics = figures.UV_dyna(sim)
+U_hmap, V_hmap = figures.UV_heatmap(sim)
+```
+
+The figures reveal the population dynamics and steady state distribution.
+
+
+## Acknowledgments
+
+- Thanks Professor Daniel Cooney at University of Illinois Urbana-Champaign. This package is developed alongside a project with Prof. Cooney and received enormous help from him.
+- Special thanks to the open-source community for making this package possible.

piegy-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+piegy/__init__.py,sha256=Lrh6NegSvo6LOCXg_tBTu804eicnHpQY2zmE0FchjKE,3241
+piegy/__version__.py,sha256=H58EUm6wBWYw2Q4gXk5PznfRrEry4c4zk7c--daUx_8,365
+piegy/analysis.py,sha256=1cF06igQMGJGVjLiyhtgepGk8fYhzvL0orI48tOK1qY,8713
+piegy/data_tools.py,sha256=dXESWglAXN4q79ZG8wtpZftJoiiaOJFU7NSaip1ZTq0,3518
+piegy/figures.py,sha256=46Vg6AsWswF-juGbyndaRaChrdVuzPbpRQQd9grTWfk,17842
+piegy/model.py,sha256=2Y49NDzdtog9effo9Lr_-psu5NMBF3iH9BeE8zhCHZ8,45700
+piegy/test_var.py,sha256=fk_e0Hko6zNfsOx-SMnnEcsgeu6fx0rQcdfuXGceY7U,20892
+piegy/videos.py,sha256=vW0F9WYDvPVJM0fHM_0Vi9Y8ZSVfJBcuCLJ2lLXeZ2U,10410
+piegy/tools/__init__.py,sha256=eYOl_HJHDonYexfrmKh3koOlxvtSo46vH6jHvCEEB4k,300
+piegy/tools/figure_tools.py,sha256=qhuMPZn2krEzjhjmAd6ac9QVBeCWUkSdCGOz7RASAhA,5931
+piegy/tools/file_tools.py,sha256=ncxFWeHfIE-GYLQlOrahFlhBgqPyuY3R5_93fpQeCEs,630
+piegy-1.0.0.dist-info/licenses/LICENSE.txt,sha256=wfzEht_CxOcfGGmg3f3at4mWJb9rTBjA51mXLl_3O3g,1498
+piegy-1.0.0.dist-info/METADATA,sha256=hn5JGkA5jBMN2toZ0xPdJ-0munvYBE-BzcOMKWb-d-g,5035
+piegy-1.0.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+piegy-1.0.0.dist-info/top_level.txt,sha256=k4QLYL8PqdqDuy95-4NZD_FVLqJDsmq67tpKkBn4vMw,6
+piegy-1.0.0.dist-info/RECORD,,

piegy-1.0.0.dist-info/WHEEL

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