scikit-lab-kit 0.1.0__py3-none-any.whl

scikit_lab/practicals/10_association_apriori_groceries.txt

@@ -0,0 +1,65 @@
+PRACTICAL 10: ASSOCIATION - APRIORI (GROCERIES DATASET)
+
+STEPS:
+1. Install the libraries:  pip install pandas seaborn matplotlib mlxtend
+2. Load groceries.csv and remove the empty (nan / None) items from every transaction.
+3. Convert the transactions into a one-hot table using TransactionEncoder.
+4. Find the frequent itemsets with Apriori (min_support = 0.01).
+5. Plot the top 15 itemsets by support.
+6. Generate the association rules with lift >= 1.
+7. Filter the rules (antecedent length >= 2 with confidence > 0.3, and consequent length >= 2).
+8. Print the rules by the metrics lift, confidence, leverage and conviction.
+
+CODE:
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from mlxtend.preprocessing import TransactionEncoder
+from mlxtend.frequent_patterns import apriori, association_rules
+data = pd.read_csv("groceries.csv")
+print("First 5 rows of raw data:\n", data.head())
+transactions = data.values.astype(str).tolist()
+transactions = [[item for item in row if item != 'nan' and item != 'None'] for row in transactions]
+print("\nFirst 2 cleaned transactions:\n", transactions[:2])
+te = TransactionEncoder()
+te_ary = te.fit(transactions).transform(transactions)
+df = pd.DataFrame(te_ary, columns=te.columns_)
+print("\nOne-hot encoded shape:", df.shape)
+frequent_itemset = apriori(df, min_support=0.01, use_colnames=True)
+print(f"Total frequent itemsets found: {len(frequent_itemset)}")
+top_15 = frequent_itemset.nlargest(n=15, columns='support').copy()
+top_15['itemset_str'] = top_15['itemsets'].apply(lambda x: ', '.join(list(x)))
+plt.figure(figsize=(12, 6))
+colors = ['#FFB6C1', '#ADD8E6', '#98FB98', '#FFD700', '#FFA07A', '#87CEEB', '#FFC0CB', '#FF69B4', '#00FA9A', '#FF6347']
+sns.barplot(x='itemset_str', y='support', data=top_15, hue='itemset_str', palette=colors[:len(top_15)], legend=False)
+plt.xticks(rotation=45, ha='right')
+plt.title("Top Frequent Itemsets by Support")
+plt.tight_layout()
+plt.show()
+rules = association_rules(frequent_itemset, metric="lift", min_threshold=1)
+rules = rules.sort_values(by=['support'], ascending=False)
+rules["antecedent_len"] = rules["antecedents"].apply(lambda x: len(x))
+rules["consequent_len"] = rules["consequents"].apply(lambda x: len(x))
+rule_3_filtered = rules[(rules['antecedent_len'] >= 2) &
+                        (rules['confidence'] > 0.3) &
+                        (rules['lift'] > 1)].sort_values(by=['lift', 'support'], ascending=False)
+print("\nRule 3 (Antecedent Len >= 2, Conf > 0.3, Lift > 1):\n", rule_3_filtered.head())
+rule_4_filtered = rules[(rules['consequent_len'] >= 2) &
+                        (rules['lift'] > 1)].sort_values(by=['lift', 'confidence'], ascending=False)
+print("\nRule 4 (Consequent Len >= 2, Lift > 1):\n", rule_4_filtered.head())
+print("---------------------ACCURACY METRICS-------------------------------")
+rules = association_rules(frequent_itemset, metric="lift", min_threshold=1)
+print(rules)
+rules = association_rules(frequent_itemset,metric="confidence",min_threshold=1)
+print(rules)
+rules = association_rules(frequent_itemset,metric="leverage",min_threshold=1)
+print(rules)
+rules = association_rules(frequent_itemset,metric="conviction",min_threshold=1)
+print(rules)
+
+EXPLANATION:
+- Apriori finds the items that are bought together often, using the support (how frequent an itemset is).
+- TransactionEncoder turns every basket into True / False columns, one per item, which Apriori needs.
+- association_rules() makes rules like "A -> B" and measures them with support, confidence and lift (lift > 1 means the items really go together).
+- The filters keep the stronger multi-item rules (antecedent >= 2 items with confidence > 0.3, and consequent >= 2 items).
+- The last part prints the rules by lift, confidence, leverage and conviction to compare the metrics.

scikit_lab/practicals/11_association_apriori_own_dataset.txt

@@ -0,0 +1,140 @@
+PRACTICAL 11: ASSOCIATION - APRIORI (OWN DATASET)
+
+Dataset taken: Travel.csv (read as travel1.csv)
+
+STEPS:
+1. Install the libraries:  pip install pandas seaborn matplotlib mlxtend
+2. Load the travel csv and drop the Traveler_ID column.
+3. Convert the numeric columns into groups: Age -> Age_Group, Average_Spend_USD -> Spend_Level (low / medium / high), Travel_Frequency_per_Year -> Freq_Level.
+4. Add the column name before every text value (for example City_Paris) so the items are unique.
+5. Convert every row into a transaction and one-hot encode it with TransactionEncoder.
+6. Find the frequent itemsets with Apriori (min_support = 0.05) and plot the top 15.
+7. Generate the association rules (lift >= 1) and print them by lift.
+8. Print the multi-condition rules (antecedent length >= 2, confidence > 0.3) and the high-confidence rules (confidence >= 0.5).
+
+CODE:
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+from mlxtend.frequent_patterns import apriori, association_rules
+from mlxtend.preprocessing import TransactionEncoder
+data = pd.read_csv("travel1.csv")
+if "Traveler_ID" in data.columns:
+    data = data.drop(columns=["Traveler_ID"])
+if "Age" in data.columns:
+    data["Age_Group"] = pd.cut(
+        data["Age"],
+        bins=[0, 25, 40, 60, 100],
+        labels=["Age_18-25", "Age_26-40", "Age_41-60", "Age_60+"],
+    )
+    data = data.drop(columns=["Age"])
+if "Average_Spend_USD" in data.columns:
+    data["Spend_Level"] = pd.qcut(
+        data["Average_Spend_USD"],
+        q=3,
+        labels=["Spend_Low", "Spend_Medium", "Spend_High"],
+    )
+    data = data.drop(columns=["Average_Spend_USD"])
+if "Travel_Frequency_per_Year" in data.columns:
+    data["Freq_Level"] = pd.qcut(
+        data["Travel_Frequency_per_Year"],
+        q=3,
+        labels=["Freq_Low", "Freq_Medium", "Freq_High"],
+        duplicates="drop",
+    )
+    data = data.drop(columns=["Travel_Frequency_per_Year"])
+for col in data.select_dtypes(include=["object", "category"]).columns:
+    data[col] = col + "_" + data[col].astype(str)
+transactions = data.values.tolist()
+transactions = [
+    [str(item) for item in row if pd.notna(item) and item != "nan"]
+    for row in transactions
+]
+te = TransactionEncoder()
+te_ary = te.fit(transactions).transform(transactions)
+df = pd.DataFrame(te_ary, columns=te.columns_)
+print("Encoded Dataset Shape:", df.shape)
+frequent_itemsets = apriori(df, min_support=0.05, use_colnames=True)
+print(f"Total Frequent Itemsets Generated: {len(frequent_itemsets)}")
+# Plot Top Itemsets
+plt.figure(figsize=(12, 6))
+top_itemsets = frequent_itemsets.nlargest(n=15, columns="support").copy()
+top_itemsets["itemsets_str"] = top_itemsets["itemsets"].apply(
+    lambda x: ", ".join(list(x))
+)
+sns.barplot(
+    x="itemsets_str",
+    y="support",
+    data=top_itemsets,
+    palette="Blues_r",
+    hue="itemsets_str",
+    legend=False,
+)
+plt.xticks(rotation=45, ha="right")
+plt.title("Top 15 Itemsets by Support")
+plt.tight_layout()
+plt.show()
+# Generate and Filter Association Rules
+rules = association_rules(frequent_itemsets, metric="lift", min_threshold=1.0)
+if not rules.empty:
+    rules["antecedent_len"] = rules["antecedents"].apply(len)
+    rules["consequent_len"] = rules["consequents"].apply(len)
+    # Convert frozensets to readable strings for display
+    display_rules = rules.copy()
+    display_rules["antecedents"] = display_rules["antecedents"].apply(
+        lambda x: list(x)
+    )
+    display_rules["consequents"] = display_rules["consequents"].apply(
+        lambda x: list(x)
+    )
+    print("\n--- ALL VALID RULES (Sorted by Lift) ---")
+    print(
+        display_rules.sort_values(by="lift", ascending=False)[
+            ["antecedents", "consequents", "support", "confidence", "lift"]
+        ].head(10)
+    )
+    print("\n--- MULTI-CONDITION RULES (Antecedent Len >= 2 & Conf > 0.3) ---")
+    filtered_rules_1 = display_rules[
+        (display_rules["antecedent_len"] >= 2)
+        & (display_rules["confidence"] > 0.3)
+        & (display_rules["lift"] > 1.0)
+    ].sort_values(by=["lift", "support"], ascending=False)
+    print(
+        filtered_rules_1[
+            ["antecedents", "consequents", "support", "confidence", "lift"]
+        ].head(10)
+    )
+    print("\n--- HIGH-CONFIDENCE ACCURACY METRICS ---")
+    high_conf_rules = association_rules(
+        frequent_itemsets, metric="confidence", min_threshold=0.5
+    )
+    high_conf_rules["antecedents"] = high_conf_rules["antecedents"].apply(
+        lambda x: list(x)
+    )
+    high_conf_rules["consequents"] = high_conf_rules["consequents"].apply(
+        lambda x: list(x)
+    )
+    print(
+        high_conf_rules.sort_values(by="confidence", ascending=False)[
+            [
+                "antecedents",
+                "consequents",
+                "support",
+                "confidence",
+                "lift",
+                "leverage",
+                "conviction",
+            ]
+        ].head(10)
+    )
+else:
+    print(
+        "No association rules met the threshold. Consider lowering min_support."
+    )
+
+EXPLANATION:
+- Travel data is not in basket form, so the numeric columns (age, spend, frequency) are first converted into groups like Age_26-40 or Spend_High.
+- Each text value gets its column name in front, so every row becomes a "basket" of items such as Destination_Paris.
+- Apriori finds the combinations of items that occur in at least 5% of the travellers.
+- The rules (like "Age_26-40 + Spend_High -> Freq_High") are ranked by lift and filtered by confidence.
+- If no rule meets the threshold, the program prints a message to lower min_support.

scikit_lab/practicals/12_fp_tree_association.txt

@@ -0,0 +1,36 @@
+PRACTICAL 12: FP-TREE ASSOCIATION
+
+Dataset: disney_movies.csv
+
+STEPS:
+1. Install the library:  pip install pyfpgrowth
+2. Read disney_movies.csv with the csv module (utf8 encoding) and keep every row as a list.
+3. Remove the empty values from each row and remove the header row.
+4. Print some records (first 10) to check the data.
+5. Find the frequent patterns with find_frequent_patterns (minimum support count = 2).
+6. Generate the association rules from the patterns with generate_association_rules (minimum confidence = 0.7).
+7. Print the patterns and the rules.
+
+CODE:
+import pyfpgrowth
+import csv
+with open('disney_movies.csv',encoding="utf8",newline='') as f:
+    reader=csv.reader(f)
+    data=list(reader)
+for i in range(len(data))    :
+    if '' in data[i]:
+        data[i]=[x for x in data[i] if x]
+data.pop(0)
+print("some records",data[0:10])
+patterns=pyfpgrowth.find_frequent_patterns(data,2)
+print("pattern",patterns)
+print()
+rules=pyfpgrowth.generate_association_rules(patterns,0.7)
+print("rules output",rules)
+
+EXPLANATION:
+- FP-Growth is a faster alternative to Apriori: it builds a compact FP-tree of the transactions and does not generate candidate itemsets.
+- Each row of the csv (one movie with its details) is treated as one transaction after the empty cells are removed.
+- find_frequent_patterns(data, 2) returns the item patterns that appear in at least 2 transactions.
+- generate_association_rules(patterns, 0.7) keeps only the rules whose confidence is 70% or more.
+- The output is a dictionary of patterns with their counts and the rules in the form: antecedent -> (consequent, confidence).

scikit_lab/practicals/13_classifiers_explanation.txt

@@ -0,0 +1,51 @@
+PRACTICAL 13: CLASSIFIERS EXPLANATION (PCA, SVM, RANDOM FOREST)
+
+(The code for these three is given in Practical 7: 4. PCA, 5. SVM and 6. Random Forest.)
+
+
+1. PCA (PRINCIPAL COMPONENT ANALYSIS)
+
+STEPS:
+1. Standardize the data (mean 0, standard deviation 1).
+2. Calculate the covariance matrix of the features.
+3. Find the eigenvectors (directions) and eigenvalues (importance) of the matrix.
+4. Sort them and keep the top components (usually 80% to 95% of the variance), then project the data on them.
+
+EXPLANATION:
+- PCA is an unsupervised dimensionality reduction method: it reduces many features into a few new ones called principal components.
+- The principal components are combinations of the original features, and PC1 holds the maximum variance.
+- Each next component is perpendicular (uncorrelated) to the earlier ones and holds the next highest variance.
+- Standardization is needed first, otherwise a feature with large numbers (like salary) would dominate.
+- Dropping the last components loses little information but makes the data simpler.
+
+
+2. SVM (SUPPORT VECTOR MACHINE)
+
+STEPS:
+1. Plot the data points of the two classes.
+2. Find the hyperplane (decision boundary) that separates the classes.
+3. Choose the hyperplane with the maximum margin, with the support vectors (nearest points) on its edges.
+4. If the data is not linearly separable, apply a kernel (linear, polynomial or RBF) to separate it in a higher dimension.
+
+EXPLANATION:
+- SVM is a supervised classifier that finds the widest "street" between the two classes.
+- Only the support vectors (the points closest to the boundary) decide the position of the boundary.
+- Parameter C controls the balance: high C allows fewer mistakes (risk of overfitting), low C gives a wider margin.
+- The kernel trick lets SVM draw curved boundaries without actually moving the data to a higher dimension.
+- The RBF kernel is the common choice for complex, non-linear data.
+
+
+3. RANDOM FOREST
+
+STEPS:
+1. Bootstrapping: take a random sample (with replacement) of the rows for each tree.
+2. Feature randomness: at each split, let the tree choose from a random subset of the features only.
+3. Train every decision tree fully on its own sample.
+4. Aggregation: every tree votes and the majority class is the final answer (average for regression).
+
+EXPLANATION:
+- Random forest is an ensemble method that combines many decision trees ("wisdom of the crowd").
+- Different rows and different features make every tree different, so their errors cancel out.
+- A single deep tree overfits easily, but the forest generalizes better.
+- For classification the majority vote is used, for regression the average of the tree outputs.
+- It also gives feature importance, which shows the most useful features.

scikit_lab/practicals/14_pca.txt

@@ -0,0 +1,16 @@
+PRACTICAL 14: PRINCIPAL COMPONENT ANALYSIS (PCA)
+
+(The PCA code with the explained-variance plot is given in Practical 7: 4. PCA.)
+
+STEPS:
+1. Standardize the data: make every feature have mean 0 and standard deviation 1.
+2. Calculate the covariance matrix to see how the features vary together.
+3. Find the principal components: the eigenvectors (directions) and eigenvalues (importance) of the covariance matrix.
+4. Pick the top k components that keep most of the variance (for example 95%) and transform the data by projecting it on them.
+
+EXPLANATION:
+- PCA is a dimensionality reduction technique that reduces the number of features while keeping the most important information.
+- It converts correlated features into a smaller set of uncorrelated features called principal components.
+- PC1 is the direction of maximum variance and PC2 is the next best direction, perpendicular to PC1.
+- Example: with the two features Radius and Area, most of the spread lies along PC1, so projecting on PC1 turns 2D data into 1D with little loss.
+- The explained variance ratio tells how much information each component keeps.

scikit_lab/viewer.py

@@ -0,0 +1,106 @@
+"""Numbered DAML (scikit-learn) practical viewer. Prints everything in red.
+
+* Terminal / cmd / PowerShell : ANSI red escape codes.
+* IDLE                        : IDLE ignores ANSI codes, but it shows
+                                 sys.stderr in red, so text goes there.
+"""
+import os
+import sys
+from pathlib import Path
+
+PRACTICALS_DIR = Path(__file__).parent / "practicals"
+
+RED = "\033[31m"
+RESET = "\033[0m"
+
+# (menu number, file name, menu title)
+REGISTRY = [
+    ("1", "01_data_cleaning_missing_values.txt", "Data cleaning - missing values"),
+    ("2", "02_data_cleaning_noisy_data.txt", "Data cleaning - noisy data (outliers)"),
+    ("3", "03_data_cleaning_on_dataset.txt", "Data cleaning on a dataset (loan credit)"),
+    ("4", "04_preprocessing_contingency.txt", "Preprocessing - correlation and contingency table"),
+    ("5", "05_eda.txt", "Exploratory data analysis (EDA)"),
+    ("6", "06_decision_tree.txt", "Decision tree"),
+    ("7", "07_compare_classification_models.txt", "Comparing classification models"),
+    ("8", "08_classification_improvement.txt", "Classification improvement (bagging, boosting)"),
+    ("9", "09_clustering.txt", "Clustering (K-Means, hierarchical)"),
+    ("10", "10_association_apriori_groceries.txt", "Association - Apriori (groceries)"),
+    ("11", "11_association_apriori_own_dataset.txt", "Association - Apriori (own dataset)"),
+    ("12", "12_fp_tree_association.txt", "FP-Tree association"),
+    ("13", "13_classifiers_explanation.txt", "Classifiers explanation (PCA, SVM, Random Forest)"),
+    ("14", "14_pca.txt", "Principal Component Analysis (PCA)"),
+]
+
+_IN_IDLE = "idlelib.run" in sys.modules or "idlelib.pyshell" in sys.modules
+_USE_ANSI = (not _IN_IDLE) and sys.stdout.isatty() and "NO_COLOR" not in os.environ
+
+if _USE_ANSI and os.name == "nt":
+    os.system("")  # switches on ANSI escape handling in Windows consoles
+
+
+def _red(text="", end="\n"):
+    """Write text in red (see module docstring)."""
+    if _IN_IDLE:
+        sys.stderr.write(text + end)
+        sys.stderr.flush()
+    elif _USE_ANSI:
+        sys.stdout.write(RED + text + RESET + end)
+        sys.stdout.flush()
+    else:
+        sys.stdout.write(text + end)
+        sys.stdout.flush()
+
+
+def _ask(prompt):
+    _red(prompt, end="")
+    return input().strip()
+
+
+def _read(filename):
+    return (PRACTICALS_DIR / filename).read_text(encoding="utf-8")
+
+
+def _lookup(choice):
+    """Return the file name for a menu number, or None."""
+    choice = choice.strip()
+    for number, filename, _title in REGISTRY:
+        if choice == number:
+            return filename
+    return None
+
+
+def show_menu():
+    _red("SCIKIT-LEARN LAB: DAML PRACTICALS")
+    for number, _filename, title in REGISTRY:
+        _red("  {:<4}{}".format(number, title))
+    _red("  m   Show this menu")
+    _red("  0   Exit")
+    _red()
+
+
+def main():
+    while True:
+        try:
+            choice = _ask("Enter number (0 to exit): ")
+        except (EOFError, KeyboardInterrupt):
+            _red()
+            break
+        if choice == "0":
+            break
+        if choice.lower() == "m":
+            show_menu()
+            continue
+        name = _lookup(choice)
+        if name is None:
+            _red("Invalid number.")
+            continue
+        _red(_read(name))
+        try:
+            _ask("\nPress Enter to continue...")
+        except (EOFError, KeyboardInterrupt):
+            _red()
+            break
+
+
+if __name__ == "__main__":
+    main()

scikit_lab_kit-0.1.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: scikit-lab-kit
+Version: 0.1.0
+Summary: Numbered DAML (scikit-learn) practicals: steps, code and short explanation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# scikit-lab-kit
+
+Numbered viewer for the DAML practicals (steps, code and a short explanation), shown in **red**.
+Type a number to show a practical, `m` to show the menu, `0` to exit.
+
+## Install
+```
+python -m pip install scikit-lab-kit
+```
+
+## Run
+```
+python -m scikit_lab
+```
+or in IDLE / Python:
+```python
+import scikit_lab
+scikit_lab.main()
+```
+
+## Menu
+| No. | Practical |
+|-----|-----------|
+| 1 | Data cleaning - missing values |
+| 2 | Data cleaning - noisy data (outliers) |
+| 3 | Data cleaning on a dataset (loan credit) |
+| 4 | Preprocessing - correlation and contingency table |
+| 5 | Exploratory data analysis (EDA) |
+| 6 | Decision tree |
+| 7 | Comparing classification models |
+| 8 | Classification improvement (bagging, boosting) |
+| 9 | Clustering (K-Means, hierarchical) |
+| 10 | Association - Apriori (groceries) |
+| 11 | Association - Apriori (own dataset) |
+| 12 | FP-Tree association |
+| 13 | Classifiers explanation (PCA, SVM, Random Forest) |
+| 14 | Principal Component Analysis (PCA) |
+
+This package only displays text; it does not run the practical code.

scikit_lab_kit-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+scikit_lab/__init__.py,sha256=IVBTwNz12dnoR-9fQFnh2qEdBzCRG1eCjxTzTq1WkeA,45
+scikit_lab/__main__.py,sha256=WtCt1iyekjUh0YPYLne9Fd6e3DsB83PZQYetYMvCNNY,64
+scikit_lab/viewer.py,sha256=qsNEJxtUg5IwAaRox3vQ-9SVfgy0tkOgB1yFBjsHNA0,3459
+scikit_lab/practicals/01_data_cleaning_missing_values.txt,sha256=k6Tc041AD7wv-aM4bYYepibD1u2pky3A0lQjCtvtsrw,3112
+scikit_lab/practicals/02_data_cleaning_noisy_data.txt,sha256=Ol_Qk5mjAks6tI7DwWIs8qW35WuyCsHAdjN9_NL0MJM,2786
+scikit_lab/practicals/03_data_cleaning_on_dataset.txt,sha256=ASWs2lqKRvtkTtPQkPzlaZXZbJlfU7Nlrc9SFEyl-ys,2489
+scikit_lab/practicals/04_preprocessing_contingency.txt,sha256=76I9QXBVpOTZr3Fpf8cJRVEmtHKd04nXz7IpqqHc4ZU,1970
+scikit_lab/practicals/05_eda.txt,sha256=uLOUJo6fAc4AZVv88A7CW2tWrFhUbk3-ZDv8WFbhmNY,8933
+scikit_lab/practicals/06_decision_tree.txt,sha256=TAvl84rpLoF7LvxEw3VKsgAmOu1hLm0m3LmJauUxshk,3243
+scikit_lab/practicals/07_compare_classification_models.txt,sha256=xqI7nNgZyM5t5hSre5GYMwl8uF-E1cLQpzUYlgk88nw,14540
+scikit_lab/practicals/08_classification_improvement.txt,sha256=LHPscbQl7m64KKaPbHCZZLfXNls0tg-KhOGLuN_LZho,7253
+scikit_lab/practicals/09_clustering.txt,sha256=UP2Hab0tPmN2iKneAFXvGcuztTybNHP15z0qt2niItE,4060
+scikit_lab/practicals/10_association_apriori_groceries.txt,sha256=9F9TrGDl1KWLvlYfDHmRdOlNMy6RjfuNvIbGSvmX4VA,3796
+scikit_lab/practicals/11_association_apriori_own_dataset.txt,sha256=cKRqxwRU9heVJAYwBEqInF0N5-oCwrG2QYQeo9_-zvI,5592
+scikit_lab/practicals/12_fp_tree_association.txt,sha256=aZ1PK7ni1SPgq8aIBHKlr4vVIcxfHAD_g3H6BfqlCow,1616
+scikit_lab/practicals/13_classifiers_explanation.txt,sha256=O1r9lZFXy9e2QxmUhZot2W6zM1l6B_dN2ML3w0Ir3EQ,2752
+scikit_lab/practicals/14_pca.txt,sha256=2YXSof0_RLxJLcZDTEF_RSxSDG1TQH3okhafU2rzpvI,1117
+scikit_lab_kit-0.1.0.dist-info/METADATA,sha256=1wSpaCmyuoETi8KY4GW9Aok9XhMq4y1-655a2ajzmmw,1333
+scikit_lab_kit-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+scikit_lab_kit-0.1.0.dist-info/entry_points.txt,sha256=Onb6irRSKSLmYmt3pg25Boci5You7plxD-KHV7yt8ac,54
+scikit_lab_kit-0.1.0.dist-info/top_level.txt,sha256=rqf279cQXctZGv0ZqAsLxerY-ogJVUTE_fsdSTeccHE,11
+scikit_lab_kit-0.1.0.dist-info/RECORD,,

scikit_lab_kit-0.1.0.dist-info/WHEEL

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

scikit_lab_kit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scikit-lab = scikit_lab.viewer:main

scikit_lab_kit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+scikit_lab