mathepy 1.0.0__py3-none-any.whl

mathepy/__init__.py

@@ -0,0 +1,23 @@
+# from .gen import linear_regression, logistic_regression
+from .ai_helper import ask_llm
+from .pink import pink
+from .america  import america
+from .iran import iran
+from .momo import momo
+
+from .dropnull import dropnull
+from .code import code
+from .sf import sf
+from .abc import abc
+from .liti import liti
+from .bcd import bcd
+
+
+from .hellp import hellp
+from .init import init
+
+from .lc import lc
+
+
+
+__all__ = ["ask_llm", "pink", "america", "iran", "momo", "dropnull", "code", "sf", "abc", "liti", "bcd", "hellp", "init", "lc"]

mathepy/abc.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-120b"   # change here if needed
+
+
+
+def abc(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = abc(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/ai_helper.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def ask_llm(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = ask_llm(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/america.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "moonshotai/kimi-k2-instruct-0905"   # change here if needed
+
+
+
+def america(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = america(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/bcd.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-120b"   # change here if needed
+
+
+
+def bcd(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = bcd(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/code.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def code(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = code(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/dropnull.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def dropnull(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = dropnull(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/gen.py

@@ -0,0 +1,487 @@
+def linear_regression():
+    print('''
+# numpy is used for numerical operations like arrays and square root
+import numpy as np
+
+# pandas is used for handling datasets in table format (DataFrame)
+import pandas as pd
+
+# train_test_split is used to divide the dataset into training and testing sets
+from sklearn.model_selection import train_test_split
+
+# LinearRegression is the machine learning model we will use
+from sklearn.linear_model import LinearRegression
+
+# metrics contains functions to evaluate model performance
+from sklearn import metrics
+
+
+# ------------------------------
+# STEP 1: Create Dataset
+# ------------------------------
+
+# We create a simple dataset manually
+# Hours = number of hours studied
+# Scores = exam scores obtained
+
+data = {
+    "Hours": [1,2,3,4,5,6,7,8,9,10],
+    "Scores": [10,20,30,40,52,60,70,80,90,95]
+}
+
+# Convert dictionary into pandas DataFrame (table structure)
+df = pd.DataFrame(data)
+
+print("Dataset")
+print(df)
+
+
+# ------------------------------
+# STEP 2: Define Features and Target
+# ------------------------------
+
+# X = input variable (feature)
+# We use double brackets because sklearn expects a 2D array
+
+X = df[["Hours"]]
+
+# y = target variable (what we want to predict)
+
+y = df["Scores"]
+
+print("\nFeatures (X)")
+print(X)
+
+print("\nTarget (y)")
+print(y)
+
+
+# ------------------------------
+# STEP 3: Split Data into Train and Test
+# ------------------------------
+
+# train_test_split splits the dataset into two parts:
+# training data -> model learns from this
+# testing data -> used to evaluate the model
+
+# test_size=0.2 means 20% data will be used for testing
+# random_state=42 ensures same split every time we run code
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y,
+    test_size=0.2,
+    random_state=42
+)
+
+print("\nTraining Features")
+print(X_train)
+
+print("\nTesting Features")
+print(X_test)
+
+
+# ------------------------------
+# STEP 4: Create Linear Regression Model
+# ------------------------------
+
+# LinearRegression() creates a regression model object
+# The model tries to learn a linear relationship:
+# y = mx + b
+
+model = LinearRegression()
+
+
+# ------------------------------
+# STEP 5: Train the Model
+# ------------------------------
+
+# fit() trains the model using training data
+# It calculates best slope (m) and intercept (b)
+
+model.fit(X_train, y_train)
+
+print("\nModel Training Completed")
+
+# slope of line
+print("Coefficient (m):", model.coef_)
+
+# intercept of line
+print("Intercept (b):", model.intercept_)
+
+
+# ------------------------------
+# STEP 6: Predict Values
+# ------------------------------
+
+# predict() uses the trained model to predict output for test data
+
+y_pred = model.predict(X_test)
+
+print("\nPredicted Values")
+print(y_pred)
+
+print("\nActual Values")
+print(y_test.values)
+
+
+# ------------------------------
+# STEP 7: Evaluate Model Accuracy
+# ------------------------------
+
+# Mean Absolute Error (MAE)
+# Average absolute difference between predicted and actual values
+
+mae = metrics.mean_absolute_error(y_test, y_pred)
+
+# Mean Squared Error (MSE)
+# Average of squared differences between predicted and actual values
+
+mse = metrics.mean_squared_error(y_test, y_pred)
+
+# Root Mean Squared Error (RMSE)
+# Square root of MSE (same unit as original data)
+
+rmse = np.sqrt(mse)
+
+# R² Score
+# Measures how well the model explains variance
+# Range: 0 to 1 (1 = perfect model)
+
+r2 = metrics.r2_score(y_test, y_pred)
+
+
+print("\nModel Evaluation Metrics")
+
+print("Mean Absolute Error:", mae)
+print("Mean Squared Error:", mse)
+print("Root Mean Squared Error:", rmse)
+print("R2 Score:", r2)
+
+
+# ------------------------------
+# STEP 8: Predict New Data
+# ------------------------------
+
+# Predict score for 12 hours study
+
+hours = np.array([[12]])
+
+predicted_score = model.predict(hours)
+
+print("\nPrediction for 12 hours of study")
+print("Predicted Score:", predicted_score)
+    ''')
+
+def logistic_regression():
+    print('''
+# numpy is used for numerical operations
+import numpy as np
+
+# pandas is used to handle datasets in table format
+import pandas as pd
+
+# train_test_split is used to divide the dataset into training and testing sets
+from sklearn.model_selection import train_test_split
+
+# LogisticRegression is the classification model
+from sklearn.linear_model import LogisticRegression
+
+# metrics contains functions to evaluate classification models
+from sklearn import metrics
+
+
+# ------------------------------
+# STEP 1: Create Dataset
+# ------------------------------
+
+# Hours studied vs Pass/Fail exam
+# 0 = Fail
+# 1 = Pass
+
+data = {
+    "Hours": [1,2,3,4,5,6,7,8,9,10],
+    "Pass":  [0,0,0,0,1,1,1,1,1,1]
+}
+
+df = pd.DataFrame(data)
+
+print("Dataset")
+print(df)
+
+
+# ------------------------------
+# STEP 2: Define Features and Target
+# ------------------------------
+
+# X = input feature
+X = df[["Hours"]]
+
+# y = output label (classification target)
+y = df["Pass"]
+
+print("\nFeatures (X)")
+print(X)
+
+print("\nTarget (y)")
+print(y)
+
+
+# ------------------------------
+# STEP 3: Split Dataset
+# ------------------------------
+
+# 80% training
+# 20% testing
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y,
+    test_size=0.2,
+    random_state=42
+)
+
+print("\nTraining Data")
+print(X_train)
+
+print("\nTesting Data")
+print(X_test)
+
+
+# ------------------------------
+# STEP 4: Create Logistic Regression Model
+# ------------------------------
+
+# LogisticRegression() creates classification model
+# It uses the sigmoid function
+
+model = LogisticRegression()
+
+
+# ------------------------------
+# STEP 5: Train the Model
+# ------------------------------
+
+# fit() trains the model using training data
+
+model.fit(X_train, y_train)
+
+print("\nModel Training Completed")
+
+
+# ------------------------------
+# STEP 6: Predict Class
+# ------------------------------
+
+# predict() predicts class labels (0 or 1)
+
+y_pred = model.predict(X_test)
+
+print("\nPredicted Classes")
+print(y_pred)
+
+print("\nActual Classes")
+print(y_test.values)
+
+
+# ------------------------------
+# STEP 7: Predict Probability
+# ------------------------------
+
+# predict_proba() gives probability of each class
+
+prob = model.predict_proba(X_test)
+
+print("\nPrediction Probabilities")
+print(prob)
+
+
+# ------------------------------
+# STEP 8: Evaluate Model
+# ------------------------------
+
+# Accuracy = correct predictions / total predictions
+
+accuracy = metrics.accuracy_score(y_test, y_pred)
+
+# Confusion Matrix
+# Shows correct and incorrect predictions
+
+conf_matrix = metrics.confusion_matrix(y_test, y_pred)
+
+# Classification Report
+# Includes precision, recall, F1 score
+
+report = metrics.classification_report(y_test, y_pred)
+
+print("\nAccuracy:", accuracy)
+
+print("\nConfusion Matrix")
+print(conf_matrix)
+
+print("\nClassification Report")
+print(report)
+
+
+# ------------------------------
+# STEP 9: Predict New Data
+# ------------------------------
+
+# Predict if a student who studies 7 hours will pass
+
+hours = np.array([[7]])
+
+prediction = model.predict(hours)
+
+print("\nPrediction for 7 hours study")
+print("Pass (1) or Fail (0):", prediction)
+    ''')
+
+def desicion_tree(name):
+    print('''
+# numpy for numerical operations
+import numpy as np
+
+# pandas for dataset handling
+import pandas as pd
+
+# split dataset into training and testing sets
+from sklearn.model_selection import train_test_split
+
+# Decision Tree model
+from sklearn.tree import DecisionTreeClassifier
+
+# metrics for evaluating model performance
+from sklearn import metrics
+
+
+# ------------------------------
+# STEP 1: Create Dataset
+# ------------------------------
+
+# Example dataset
+# Hours studied vs Pass/Fail exam
+
+data = {
+    "Hours": [1,2,3,4,5,6,7,8,9,10],
+    "Pass":  [0,0,0,0,1,1,1,1,1,1]
+}
+
+df = pd.DataFrame(data)
+
+print("Dataset")
+print(df)
+
+
+# ------------------------------
+# STEP 2: Define Features and Target
+# ------------------------------
+
+# X = feature (input)
+X = df[["Hours"]]
+
+# y = label (output)
+y = df["Pass"]
+
+print("\nFeatures")
+print(X)
+
+print("\nTarget")
+print(y)
+
+
+# ------------------------------
+# STEP 3: Train Test Split
+# ------------------------------
+
+# Split dataset into training and testing data
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y,
+    test_size=0.2,
+    random_state=42
+)
+
+print("\nTraining Data")
+print(X_train)
+
+print("\nTesting Data")
+print(X_test)
+
+
+# ------------------------------
+# STEP 4: Create Decision Tree Model
+# ------------------------------
+
+# DecisionTreeClassifier creates the tree model
+
+model = DecisionTreeClassifier()
+
+# parameters can also be added
+# DecisionTreeClassifier(max_depth=3)
+
+
+# ------------------------------
+# STEP 5: Train Model
+# ------------------------------
+
+# fit() trains the model
+
+model.fit(X_train, y_train)
+
+print("\nModel Training Completed")
+
+
+# ------------------------------
+# STEP 6: Predict
+# ------------------------------
+
+# predict() predicts class label
+
+y_pred = model.predict(X_test)
+
+print("\nPredicted Values")
+print(y_pred)
+
+print("\nActual Values")
+print(y_test.values)
+
+
+# ------------------------------
+# STEP 7: Evaluate Model
+# ------------------------------
+
+# Accuracy
+accuracy = metrics.accuracy_score(y_test, y_pred)
+
+# Confusion Matrix
+conf_matrix = metrics.confusion_matrix(y_test, y_pred)
+
+# Classification Report
+report = metrics.classification_report(y_test, y_pred)
+
+print("\nAccuracy:", accuracy)
+
+print("\nConfusion Matrix")
+print(conf_matrix)
+
+print("\nClassification Report")
+print(report)
+
+
+# ------------------------------
+# STEP 8: Predict New Data
+# ------------------------------
+
+# Predict pass/fail for 7 hours study
+
+hours = np.array([[7]])
+
+prediction = model.predict(hours)
+
+print("\nPrediction for 7 hours study")
+print("Pass (1) or Fail (0):", prediction)
+    ''')
+
+

mathepy/hellp.py

@@ -0,0 +1,27 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def ask_llm(password, prompt):
+    if password != "hi":
+        return "Incorrect password. Access denied."
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = ask_llm(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/init.py

@@ -0,0 +1,53 @@
+from groq import Groq
+
+SYSTEM_PROMPT = """
+You are an expert Python coding assistant.
+
+Rules:
+You will Solve Data analysis and visualization problems using Python. You will use libraries such as pandas, matplotlib, seaborn, plotly, and numpy to analyze data and create visualizations. You will write clear and efficient code to accomplish the tasks
+
+1. Respond ONLY with valid, executable Python code.
+2. Never include explanations, markdown, code fences, comments, or extra text.
+3. Return a complete runnable solution whenever possible.
+5. Ensure the code is syntactically correct.
+6. If multiple files are requested, generate a single Python script that creates them.
+
+and listen to user prompt and solve the problem using Python code. user promt is Very important
+
+"""
+
+client = Groq(
+    api_key="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"
+)
+
+MODEL = "qwen/qwen3-32b"
+
+
+def init(user_prompt: str) -> str:
+    response = client.chat.completions.create(
+        model=MODEL,
+        temperature=0.2,
+        messages=[
+            {
+                "role": "system",
+                "content": SYSTEM_PROMPT
+            },
+            {
+                "role": "user",
+                "content": user_prompt
+            }
+        ]
+    )
+
+    return response.choices[0].message.content.strip()
+
+
+if __name__ == "__main__":
+    while True:
+        prompt = input("You: ")
+
+        if prompt.lower() in {"exit", "quit"}:
+            break
+
+        answer = init(prompt)
+        print("\n" + answer + "\n")

mathepy/iran.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+ligt
+
+def iran(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = iran(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/koko.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def koko(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = koko(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/lc.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def code(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = code(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/liti.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def liti(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = liti(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/momo.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def momo(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = momo(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/pink.py

@@ -0,0 +1,25 @@
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def pink(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = pink(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy/sf.py

@@ -0,0 +1,26 @@
+
+from groq import Groq
+
+# your API key
+client = Groq(api_key="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")
+
+MODEL = "openai/gpt-oss-20b"   # change here if needed
+
+
+
+def sf(prompt):
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.choices[0].message.content
+
+
+
+if __name__ == "__main__":
+    user_prompt = input("You: ")
+    answer = sf(user_prompt)
+    print("\nLLM:", answer, "\n")

mathepy-1.0.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mathepy
+Version: 1.0.0
+Summary: Module for Quick Calculations
+Author-email: fakehu <fakehu45@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: groq
+
+# Sample Package
+
+This is a simple Python package published to PyPI.
+
+## Installation
+
+pip install sample-package
+
+## Usage
+
+from sample_package import add, greet
+

mathepy-1.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+mathepy/__init__.py,sha256=zOhyXZtE5CNTgWVjgiiNtYCzzdsuK47Wlem4kBdOEb8,527
+mathepy/abc.py,sha256=SsHWUmhpqZxl3VrSZI-eQt97W0t7DEjCH62F1OobDY8,522
+mathepy/ai_helper.py,sha256=A7lgvujkjCuRZw6jF6fr_N7Npdtay-Wp2A9Ny5k1G9E,529
+mathepy/america.py,sha256=GAwRyx6rLy05wkWVtvSnDRBohOgra-UbnUSTY3zH5_4,543
+mathepy/bcd.py,sha256=So9gmkcTcUV65nADPibgIikwWnfVqsXTr1yGAykZB0s,522
+mathepy/code.py,sha256=cjthIGKMkclU3fQnqVZ8inXWlO8Uy4jB4iRnX89ZZzo,523
+mathepy/dropnull.py,sha256=q4W0IXKgjkc2iCqyAy5j4v17nv8zniI_fwNh_NA17So,531
+mathepy/gen.py,sha256=I8F_aZIgzsWY1eoeJe5L3lNawnURpLLxxH5YZLB0YQ8,9697
+mathepy/hellp.py,sha256=aV-D8tLLTsUPV0YtJSj1AG08KXDhcPxtAaZ9py2Vi0I,616
+mathepy/init.py,sha256=XF6VpB7e8uAJbum6KjxzBp1QYlGeaj93FqT6cemMWSg,1521
+mathepy/iran.py,sha256=NgdyajJzPazCn_QOctLo90vubLA965pYaNotgdIqqZM,527
+mathepy/koko.py,sha256=OW7GlF_GreGEtLWid0RxR2a26PnQwhD1cPlvQh7cjeo,523
+mathepy/lc.py,sha256=frzZ3vFDX4pYkwc6-jhFY78eX5_kk02RsW3-UNHwZ7A,523
+mathepy/liti.py,sha256=C5420ZGYY1aDkh2iHDu9A8_6hI8FoC-2F1By-rv49aE,523
+mathepy/momo.py,sha256=mEMoIJzzmOXBVcT7DRmpzPMqdbvlhddg-NZtSTi8SgA,523
+mathepy/pink.py,sha256=sSr0uLsDx9tr715fey5l3E0TBvxwvn1DiXMMTVpYTnY,523
+mathepy/sf.py,sha256=xmyBskSrSuwUS55PGb23EW6KFmTg6pSszj9yKSlLjLA,520
+mathepy-1.0.0.dist-info/METADATA,sha256=5j9BRdG1aqnFu5miJjcdlZQGMHx0WWE0oYVtDzfQ0bA,380
+mathepy-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mathepy-1.0.0.dist-info/top_level.txt,sha256=SVHyw2ZXoluzMaycvRI_fJY-tdzjf1Td1DXZkbdSm8k,8
+mathepy-1.0.0.dist-info/RECORD,,

mathepy-1.0.0.dist-info/WHEEL

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

mathepy-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mathepy