buckpy-dev 0.0.1__py3-none-any.whl

buckpy/buckpy_variables.py

@@ -0,0 +1,98 @@
+"""
+This module contains the definition of the indices of the variables used in BuckPy.
+The indices of the variables listed in this module are global variables.
+"""
+
+# Index of the variables of the np_prob_var and np_case NumPy arrays
+MUAX     = 0
+MULAT_HT = 1
+MULAT_OP = 2
+HOOS     = 3
+
+# Index of the variables of the np_case NumPy array
+CBF_HT        = 4
+CBF_OP        = 5
+LFF_INST      = 6
+LFF_HT        = 7
+LFF_OP        = 8
+RFF_INST      = 9
+RFF_HT        = 10
+RFF_OP        = 11
+EAF_INST      = 12
+EAF_HT        = 13
+EAF_P_OP      = 14
+EAF_OP        = 15
+EAF_OP_UNBUCK = 16
+LDELTAF_HT    = 17
+RDELTAF_HT    = 18
+LDELTAF_OP    = 19
+RDELTAF_OP    = 20
+
+# Index of the variables of the np_scen NumPy array
+KP            = 0
+LENGTH        = 1
+ROUTE_TYPE    = 2
+BEND_RADIUS   = 3
+SW_INST       = 4
+SW_HT         = 5
+SW_OP         = 6
+SCHAR_HT      = 7
+SCHAR_OP      = 8
+SV_HT         = 9
+SV_OP         = 10
+CBF_RCM       = 11
+RLT           = 12
+FRF_HT        = 13
+FRF_P_OP      = 14
+FRF_T_OP      = 15
+FRF_OP        = 16
+L_BUCKLE_HT   = 17
+EAF_BUCKLE_HT = 18
+L_BUCKLE_OP   = 19
+EAF_BUCKLE_OP = 20
+SECTION_ID    = 21
+SECTION_KP    = 22
+SECTION_REF   = 23
+MUAX_MEAN     = 24
+MULAT_HT_MEAN = 25
+MULAT_OP_MEAN = 26
+HOOS_MEAN     = 27
+
+# Index of the variables of the np_distr NumPy array
+MUAX_ARRAY         = 0
+MUAX_CDF_ARRAY     = 1
+MULAT_ARRAY_HT     = 2
+MULAT_CDF_ARRAY_HT = 3
+MULAT_ARRAY_OP     = 4
+MULAT_CDF_ARRAY_OP = 5
+HOOS_ARRAY         = 6
+HOOS_CDF_ARRAY     = 7
+
+# Index of the variables of the np_ends NumPy array
+ROUTE_TYPE_BC = 0
+KP_FROM       = 1
+KP_TO         = 2
+REAC_INST     = 3
+REAC_HT       = 4
+REAC_OP       = 5
+
+# Index of the variables of the np_pp_buckle NumPy array
+SIM_PP        = 0
+KP_PP         = 1
+ROUTE_TYPE_PP = 2
+MUAX_PP       = 3
+MULAT_OP_PP   = 4
+HOOS_PP       = 5
+CBF_OP_PP     = 6
+VAS_PP        = 7
+
+# Index of the variables of the np_pp_plot NumPy array
+P_KP            = 0
+P_CBF_HT        = 1
+P_CBF_OP        = 2
+P_EAF_INST      = 3
+P_EAF_HT        = 4
+P_EAF_P_OP      = 5
+P_EAF_OP        = 6
+P_BETA2         = 7
+P_EAF_OP_UNBUCK = 8

buckpy/buckpy_visualisation.py

@@ -0,0 +1,419 @@
+"""
+This module contains the plot functions of BuckPy result files.
+"""
+import time
+import pandas as pd
+import matplotlib.pyplot as plt
+
+def read_output(output_file_name):
+
+    '''
+    Read the data from the BuckPy result file.
+
+    Parameters
+    ----------
+    output_file_name : string
+        File path of the BuckPy result file.
+
+    Returns
+    -------
+    df_sets : pandas DataFrame
+        DataFrame containing the data in the 'Sets' tab.
+    df_buckle : pandas DataFrame
+        DataFrame containing the data related to the number of buckles.
+    df_force_prof : pandas DataFrame
+        DataFrame containing the force profile data.
+    '''
+
+    # Read all tabs in the BuckPy result file
+    all_sheets_dict = pd.read_excel(output_file_name, sheet_name = None)
+
+    # Read the 'Sets', 'No Buckles' and 'Force Profiles' tabs
+    df_sets = all_sheets_dict['Sets']
+    df_buckle = all_sheets_dict['No Buckles']
+    df_force_prof = all_sheets_dict['Force Profiles']
+
+    return df_sets, df_buckle, df_force_prof
+
+def assembly_dataframe_bend_sleeper_ilt(df):
+
+    '''
+    Read the route bend data from the BuckPy input file and select the KP
+    of the 'Bend', 'Sleeper', 'RCM' and 'ILT' from the 'Route Type' column.
+
+    Parameters
+    ----------
+    df : pandas DataFrame
+        DataFrame containing the data in the 'Route' tab.
+
+    Returns
+    -------
+    df1 : pandas DataFrame
+        DataFrame containing the 'Bend' route type data.
+    df2 : pandas DataFrame
+        DataFrame containing the 'Sleeper' route type data.
+    df3 : pandas DataFrame
+        DataFrame containing the 'RCM' route type data.
+    df4 : pandas DataFrame
+        DataFrame containing the 'ILT' route type data.
+    '''
+
+    # Select route bend and KP columns
+    cols = ['Route Type', 'Point ID From', 'Point ID To', 'KP From', 'KP To']
+    df = df[cols]
+
+    # Select rows of route bend from 'Route Type'
+    df1 = df.loc[df['Route Type'] == 'Bend'].copy()
+    df1 = df1.reset_index(drop = True)
+
+    # Select rows of sleeper from 'Point ID'
+    df2 = df.iloc[1:-1].loc[df['Route Type'] == 'Sleeper'].copy()
+    df2 = df2.reset_index(drop = True)
+
+    # Select rows of RCM from 'Point ID'
+    df3 = df.iloc[1:-1].loc[df['Route Type'] == 'RCM'].copy()
+    df3 = df3.reset_index(drop = True)
+
+    # Select rows of ILT from 'Point ID'
+    df4 = df.iloc[1:-1].loc[df['Point ID From'].str.contains('ILT') &
+                            df['Point ID To'].str.contains('ILT')].copy()
+    df4 = df4.reset_index(drop = True)
+
+    return df1, df2, df3, df4
+
+def assembly_double_rows(df):
+
+    """
+    Double each row of the dataframe based on KP.
+
+    Parameters
+    ----------
+    df : pandas DataFrame
+        DataFrame containing the KP and results.
+
+    Returns
+    -------
+    df : pandas DataFrame
+        DataFrame containing the doubled rows of KP and results.
+    """
+
+    # Double each row of the df
+    df_temp1 = df.copy()
+    df_temp1 = df_temp1.rename(columns = {'KP To (m)': 'KP'})
+    df_temp1 = df_temp1.drop(labels = 'KP From (m)', axis = 1)
+    df_temp1['sort'] = 1
+
+    df_temp2 = df.copy()
+    df_temp2 = df_temp2.rename(columns = {'KP From (m)': 'KP'})
+    df_temp2 = df_temp2.drop(labels = 'KP To (m)', axis = 1)
+    df_temp2['sort'] = 2
+
+    # Double the rows except the start and end
+    df = pd.concat([df_temp1, df_temp2])
+    df = df.sort_values(by = ['KP', 'sort']).reset_index(drop = True)
+
+    # Double the start and end rows and fill nan with 0
+    first_row = pd.DataFrame({'KP': [df['KP'].min()]})
+    last_row = pd.DataFrame({'KP': [df['KP'].max()]})
+    df = pd.concat([first_row, df, last_row], ignore_index = True)
+    df = df.fillna(0)
+
+    return df
+
+def assembly_dataframe_plot(df_sets, df_pps):
+
+    """
+    Assemble the dataframes on the probabilistic results and
+    post-processing input data from BuckPy.
+
+    Parameters
+    ----------
+    df_sets : pandas DataFrame
+        DataFrame containing the output data in the  'Sets' tab.
+    df_pps : pandas DataFrame
+        DataFrame containing the input data in the 'Post-Processing' tab.
+
+    Returns
+    -------
+    df : pandas DataFrame
+        DataFrame containing the doubled rows of KP and results.
+    """
+
+    # Accept both legacy and current post-processing schemas
+    if {"pp_set", "KP_from", "KP_to"}.issubset(df_pps.columns):
+        df_pps = df_pps.rename(columns={
+            "pp_set": "Set Label",
+            "KP_from": "KP From (m)",
+            "KP_to": "KP To (m)",
+        })
+    else:
+        df_pps = df_pps.rename(columns={
+            "Post-Processing Set": "Set Label",
+            "KP From": "KP From (m)",
+            "KP To": "KP To (m)",
+        })
+    df_pps = df_pps[["Set Label", "KP From (m)", "KP To (m)"]]
+
+    # DataFrame of the 'Sets' tab from the BuckPy output
+    df_sets = df_sets[['Set Label', 'KP From (m)', 'KP To (m)', 'Probability of Buckling',
+                       'Characteristic VAS Probability',
+                       'Characteristic VAS, Unconditional (m)',
+                       'Characteristic Lateral Breakout Friction Probability',
+                       'Characteristic Lateral Breakout Friction, Buckles',
+                       'Lateral Breakout Friction, HE, Geotech']]
+
+    # Add sets without outputs
+    df = pd.concat([df_sets, df_pps])
+    df = df.drop_duplicates(subset = ['Set Label', 'KP From (m)', 'KP To (m)'],
+                            keep = 'first')
+    df = df.sort_values(by = ['KP From (m)'])
+
+    # Double each row for KP
+    df = assembly_double_rows(df)
+
+    # Add initial and final rows with zeros
+    df_temp1 = pd.DataFrame({'KP': [df['KP'].min()],
+                             'Probability of Buckling': [0.0],
+                             'Characteristic VAS, Unconditional (m)': [0.0],
+                             'Characteristic Lateral Breakout Friction, Buckles': [0.0]})
+    df_temp2 = pd.DataFrame({'KP': [df['KP'].max()],
+                             'Probability of Buckling': [0.0],
+                             'Characteristic VAS, Unconditional (m)': [0.0],
+                             'Characteristic Lateral Breakout Friction, Buckles': [0.0]})
+    df = pd.concat([df_temp1, df, df_temp2], ignore_index = True)
+    df = df.fillna(0.0)
+
+    # Replace 0.0 with NaN for Geotech friction column
+    df.loc[df['Characteristic Lateral Breakout Friction, Buckles'] == 0.0,
+           'Lateral Breakout Friction, HE, Geotech'] = 0.0
+
+    return df
+
+def plot_bend_sleeper_ilt(a1, df1, df2, df3, df4, y_max):
+
+    """
+    Plot route bend, sleeper and ILT.
+
+    Parameters
+    ----------
+    a1 : Matplotlib plot
+        Axis of the Matplotlib plot.
+    df1 : pandas DataFrame
+        Dataframe containing the locations of the route bends.
+    df2 : pandas DataFrame
+        Dataframe containing the locations of sleepers.
+    df3 : pandas DataFrame
+        Dataframe containing the locations of RCMs.
+    df4 : pandas DataFrame
+        Dataframe containing the locations of ILTs.
+    """
+
+    # Plot bends
+    for index, row in df1.iterrows():
+        if index == 0:
+            a1.plot([row['KP From'], row['KP To']], 2 * [0.1 * y_max],
+                    color = 'C2', label = 'Route Bend', linestyle = 'dotted')
+        else:
+            a1.plot([row['KP From'], row['KP To']], 2 * [0.1 * y_max],
+                    color = 'C2', linestyle = 'dotted')
+
+    # Plot sleepers
+    for index, row in df2.iterrows():
+        kp_centre = 0.5 * (row['KP From'] + row['KP To'])
+        if index == 0:
+            a1.scatter(kp_centre, 0.1 * y_max,
+                       color = 'C3', label = 'Sleeper', marker = '*')
+        else:
+            a1.scatter(kp_centre, 0.1 * y_max,
+                       color = 'C3', marker = '*')
+
+    # Plot RCMs
+    for index, row in df3.iterrows():
+        kp_centre = 0.5 * (row['KP From'] + row['KP To'])
+        if index == 0:
+            a1.scatter(kp_centre, 0.1 * y_max,
+                       color = 'C4', label = 'RCM', marker = 'o')
+        else:
+            a1.scatter(kp_centre, 0.1 * y_max,
+                       color = 'C4', marker = 'o')
+
+    # Plot ILTs
+    for index, row in df4.iterrows():
+        kp_centre = 0.5 * (row['KP From'] + row['KP To'])
+        if index == 0:
+            a1.scatter(kp_centre, 0.1 * y_max,
+                       color = 'C5', label = 'ILT', marker = '+')
+        else:
+            a1.scatter(kp_centre, 0.1 * y_max,
+                       color = 'C5', marker = '+')
+
+def plot_results(file_name, df_no_buckles, df_force_profiles,
+                 df_bends, df_sleepers, df_rcms, df_ilts, df_set_pps):
+
+    """
+    Plot probabilistic results of BuckPy in 6 subplots:
+    Row 1: unbuckled EAF, Number of Buckles, VAS;
+    Row 2: buckled EAF, Probobality of Buckling, Friction.
+
+    Parameters
+    ----------
+    file_name : str
+        The name of the output image file.
+    df_no_buckles : pandas DataFrame
+        DataFrame containing the data related to the number of buckles.
+    df_force_profiles : pandas DataFrame
+        DataFrame containing the force profile data.
+    df_bends : pandas DataFrame
+        DataFrame containing the 'Bend' route type data.
+    df_sleepers : pandas DataFrame
+        DataFrame containing the 'Sleeper' route type data.
+    df_rcms : pandas DataFrame
+        DataFrame containing the 'RCM' route type data.
+    df_ilts : pandas DataFrame
+        DataFrame containing the 'ILT' route type data.
+    df_set_pps : pandas DataFrame
+        DataFrame containing the doubled rows of KP and results from
+        'Sets' and 'Post-Processing' tabs.
+    """
+
+    # Generate matplolib figure
+    fig = plt.figure()
+    dpi_size = 110
+    fig.set_size_inches(19.2 * 100 / dpi_size, 10.8 * 100 / dpi_size)
+
+    # Subplot 1: Plot probabilistic results of the unbuckled EAF
+    a1 = fig.add_subplot(231)
+    a1.plot(df_force_profiles['KP (m)'],
+            df_force_profiles['EAF Operation [without Buckling] (kN)'])
+
+    a1.set_xlabel('KP (m)')
+    a1.set_ylabel('EAF [without Buckling] (kN)')
+    a1.grid()
+
+    # Subplot 2: Plot distribution of number of buckles
+    a2 = fig.add_subplot(232)
+    a2.plot(df_no_buckles['Number of Buckles'], df_no_buckles['Probability of Buckling'])
+
+    a2.set_xlabel('Number of Buckles')
+    a2.set_ylabel('Probability of Buckling')
+    a2.grid()
+
+    # Subplot 3: Plot characteristic VAS with route bend, sleeper, RCM and ILT
+    a3 = fig.add_subplot(233)
+    a3.plot(df_set_pps['KP'], df_set_pps['Characteristic VAS, Unconditional (m)'],
+            label = 'BuckPy')
+    plot_bend_sleeper_ilt(a3, df_bends, df_sleepers, df_rcms, df_ilts,
+                          df_set_pps['Characteristic VAS, Unconditional (m)'].max())
+
+    a3.set_xlabel('KP (m)')
+    a3.set_ylabel('Characteristic VAS (m)')
+    a3.legend()
+    a3.grid()
+
+    # Subplot 4: Plot probabilistic results of the buckled EAF
+    a4 = fig.add_subplot(234)
+    a4.plot(df_force_profiles['KP (m)'],
+            df_force_profiles['EAF Operation (kN)'])
+
+    a4.set_xlabel('KP (m)')
+    a4.set_ylabel('EAF [with Buckling] (kN)')
+    a4.grid()
+
+    # Subplot 5: Plot probabilities of buckling with route bend, sleeper, RCM and ILT
+    a5 = fig.add_subplot(235)
+    a5.plot(df_set_pps['KP'], df_set_pps['Probability of Buckling'], label = 'BuckPy')
+    plot_bend_sleeper_ilt(a5, df_bends, df_sleepers, df_rcms, df_ilts,
+                          df_set_pps['Probability of Buckling'].max())
+
+    a5.set_xlabel('KP (m)')
+    a5.set_ylabel('Probability of Buckling')
+    a5.legend()
+    a5.grid()
+
+    # Subplot 6: Plot characteristic friction with route bend, sleeper, RCM and ILT
+    prob_exceed_char_fric = df_set_pps[
+        'Characteristic Lateral Breakout Friction Probability'
+    ].max()
+    a6 = fig.add_subplot(236)
+    a6.plot(df_set_pps['KP'], df_set_pps['Characteristic Lateral Breakout Friction, Buckles'],
+            label = f'P{int(100 * prob_exceed_char_fric)} Buckle Friction')
+    a6.plot(df_set_pps['KP'], df_set_pps['Lateral Breakout Friction, HE, Geotech'],
+            label = f'P{int(100 * prob_exceed_char_fric)} Geotech Friction', linestyle = 'dashed')
+    plot_bend_sleeper_ilt(a6, df_bends, df_sleepers, df_rcms, df_ilts,
+                          df_set_pps['Characteristic Lateral Breakout Friction, Buckles'].max())
+
+    a6.set_xlabel('KP (m)')
+    a6.set_ylabel('Breakout Lateral Friction')
+    a6.legend()
+    a6.grid()
+
+    # Save the image file and close the plot
+    fig_manager=plt.get_current_fig_manager()
+    try:
+        fig_manager.window.state('zoomed')
+    except AttributeError:
+        pass
+    try:
+        fig_manager.window.showMaximized()
+    except AttributeError:
+        pass
+    plt.subplots_adjust(
+        left = 0.1, bottom = 0.1, right = 0.95, top = 0.925, wspace = 0.225, hspace = 0.2)
+    plt.savefig(file_name, dpi = dpi_size)
+    # plt.show()
+    plt.close()
+
+def plot_buckpy(work_dir, input_file_name, scen_df, route_df, pp_df, bl_verbose):
+    """
+    Plot the probabilistic buckling results from BuckPy result files.
+
+    Parameters
+    ----------
+    work_dir : str
+        The working directory where the analysis files are located.
+    input_file_name : str
+        The name of the input file.
+    scen_df : pandas DataFrame
+        DataFrame containing scenario data.
+    route_df : pandas DataFrame
+        DataFrame containing route data.
+    pp_df : pandas DataFrame
+        DataFrame containing post-processing data.
+    bl_verbose : bool, optional
+        Flag to enable verbose output. Default is False.
+    
+    Returns
+    -------
+    None
+    """
+
+    # Obtain pipeline ID and scenario number from the scenario dataframe
+    pipeline_id = scen_df["Pipeline"].values[0]
+    scenario_no = scen_df["Scenario"].values[0]
+
+    # Starting time of the plot buckpy results module
+    start_time = time.time()
+
+    # Print in the terminal that the plot of the results has started
+    if bl_verbose:
+        print("5. Plot results")
+
+    # Read the probabilistic outputs from the result Excel file
+    file_name_temp = f"{work_dir}/{input_file_name.split('.')[0]}_{pipeline_id}_scen{scenario_no}"
+    output_file_name = f"{file_name_temp}_outputs.xlsx"
+    df_set, df_no_buckle, df_force_profile = read_output(output_file_name)
+
+    # Assembly dataframes with the location of sleepers, RCMs, ILTs and route bends
+    df_bend, df_sleeper, df_rcm, df_ilt = assembly_dataframe_bend_sleeper_ilt(route_df)
+
+    # Assembly a dataframe with the "Sets" results using "Post-Processing" tab of input
+    df_set_pp = assembly_dataframe_plot(df_set, pp_df)
+
+    # Print in the terminal the time taken to plot results
+    if bl_verbose:
+        print(f'   Time taken to plot results: {time.time() - start_time:.1f}s')
+
+    # Plot the 6 subplots and save the figure to file
+    plot_file_name = f"{file_name_temp}_plots-2.png"
+    plot_results(plot_file_name, df_no_buckle, df_force_profile,
+                 df_bend, df_sleeper, df_rcm, df_ilt, df_set_pp)

buckpy_dev-0.0.1.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: buckpy-dev
+Version: 0.0.1
+Summary: BuckPy: Lateral buckling formation algorithm
+Home-page: https://github.com/buckpy-org/buckpy
+Author: ismael-ripoll
+License: GPL-3.0-or-later
+Project-URL: Documentation, https://buckpy-org-dev.github.io/
+Project-URL: Source, https://github.com/buckpy-org/buckpy
+Project-URL: Tracker, https://github.com/buckpy-org/buckpy/issues
+Keywords: pipelines,buckling,engineering,reliability,simulation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib==3.8.3
+Requires-Dist: multiprocess==0.70.16
+Requires-Dist: numba==0.59.0
+Requires-Dist: numpy==1.26.4
+Requires-Dist: openpyxl==3.1.5
+Requires-Dist: pandas==2.2.1
+Requires-Dist: scipy==1.12.0
+Requires-Dist: xlrd==2.0.1
+Requires-Dist: XlsxWriter==3.2.0
+Requires-Dist: pysubsea==0.1.5
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# BUCKPY
+Probabilistic Lateral Buckling Algorithm.
+
+## Project Philosophy
+**BuckPy** is an open-source algorithm developed to facilitate the implementation of the probabilistic lateral buckling methodology presented in [Lateral Buckling Design using the Friction Distributions at the Expected Buckles (PDF)](docs/_static/SPT%202023%20-%20Lateral%20Buckling%20Design%20using%20the%20Friction%20Distributions%20at%20the%20Expected%20Buckles.pdf), published by Ismael R., Carlos S., and Emilien B. at the 2023 Subsea Pipeline Technology Congress in London (SPT 2023).
+
+The code is available on [GitHub](https://github.com/Xodus-Group/BuckPy), allowing the pipeline community to review, expand, and use it under the [GNU General Public License v3.0](https://github.com/Xodus-Group/BuckPy/blob/main/LICENSE).
+
+## Documentation
+See the [BuckPy Documentation Website](https://buckpy-org.github.io/) for full usage guides, technical references, benchmarking, API references, and updates.

buckpy_dev-0.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+buckpy/__init__.py,sha256=BXg5L76psWvzLb8-pq2mDHWuL6laXSLyxZ8L0F6YE5Y,171
+buckpy/buckfast_input_file_writer_.py,sha256=S36fHAdrK_kRxJ9Y2qJiw3hevJ5pOlboiXu2mWJVsM0,44078
+buckpy/buckpy.py,sha256=niIeMIRYmJ8NzKW-1MIUkuKtGumKL_Hi5DS4xwygqNw,4584
+buckpy/buckpy_gui.py,sha256=35nyOCYjAUtMbkfKop23az8f4nJ8rJaJeKWbwPCpuaw,18287
+buckpy/buckpy_postprocessing.py,sha256=wjHOLdQMbH79TkpXlag28wDvshVObly8aKh9curbSK4,56200
+buckpy/buckpy_preprocessing_current.py,sha256=tlnL4S7m_VdxKjemD8X2Qq5PonJgT05A8Zgrx2Mnnjw,46234
+buckpy/buckpy_preprocessing_legacy.py,sha256=sVtt60JznBb1FxVq025R2Pkm6fHiQv5K79Ln-8_A_DY,35085
+buckpy/buckpy_solver.py,sha256=It7MOWe3AeRJDc04qyFoDx8jJHA2AsJHxgaqRbCvot8,33994
+buckpy/buckpy_variables.py,sha256=f2bs_JUGtl6FCp9URLboVVnoK25Yi4ni_VM1i9Q-a1w,2167
+buckpy/buckpy_visualisation.py,sha256=-oaUF0aIfIgD8YY2jd4J9ogdAutznbyHuxk62VFBBfs,15296
+buckpy/_static/logo.png,sha256=Z8vVUhEd375gLQ1i1EAtFftWdDRj9bkX7upsX6RzcQM,1587
+buckpy/_static/logo.svg,sha256=3o31r4Uxex2NkzDaEjJJnm4hrOGBgi8M_A1pRplmKGQ,287
+buckpy_dev-0.0.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+buckpy_dev-0.0.1.dist-info/METADATA,sha256=JbToGKoILvVX-65jkcphTzzaHMkzn6TQbWOG_9mm2Ro,2354
+buckpy_dev-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+buckpy_dev-0.0.1.dist-info/entry_points.txt,sha256=0K11SznPK4y9PGXGalBCkQen1L-1FJDQTCNvANlPYKQ,38
+buckpy_dev-0.0.1.dist-info/top_level.txt,sha256=XC8Z-oELh-egh28D_WMP5yiF4V075BQuNh1lg1_8-mM,7
+buckpy_dev-0.0.1.dist-info/RECORD,,

buckpy_dev-0.0.1.dist-info/WHEEL

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

buckpy_dev-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+buckpy = buckpy:run