autofuzzts 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

autofuzzts/preprocess/prep_for_model.py

@@ -1,70 +1,70 @@
-import pandas as pd
-import warnings
-from sklearn.preprocessing import LabelEncoder
-
-def prepare_for_model(df: pd.DataFrame, number_of_lags: int):
-    """
-    Prepare clustering data for modeling.
-    
-    Parameters:
-    - df (pd.DataFrame): The input DataFrame containing clustering data.
-    - number_of_lags (int): The number of lag features to create.
-
-    Returns:
-    - X_train (pd.DataFrame): Features for training the model.
-    - y_train (np.ndarray): Target variable for training the model.
-    """
-    
-    # Prepare the 'cluster' column
-    df.loc[:, "cluster"] = df["cluster"].str.replace("set_", "").astype(int).copy()
-
-    # Create lagged features
-    for i in range(1, number_of_lags + 1):
-        df.loc[:, "cluster_lag" + str(i)] = df["cluster"].shift(i).copy()
-        df.loc[:, "membership_value_lag" + str(i)] = df["membership_value"].shift(i).copy()
-        df.loc[:, "left_lag" + str(i)] = df["left"].shift(i).copy()
-
-    # Reset warning filter
-    warnings.filterwarnings("default", category=pd.errors.SettingWithCopyWarning)
-
-    # Prepare the model DataFrame
-    df_model = df.copy()
-    df_model.drop(columns=["membership_value", "left"], inplace=True)
-    df_model.rename(columns={"X_value": "Y"}, inplace=True)
-
-    numeric_cols = df_model.select_dtypes(include=['float64', 'int64']).columns
-    df_model[numeric_cols] = df_model[numeric_cols].fillna(0)
-
-
-    # Separate target and features
-    y_train = df_model["cluster"]
-    X_train = df_model.drop(columns=["Y", "cluster"])
-
-    # Encode categorical columns
-    label_encoder = LabelEncoder()
-    encoded_cols = []
-
-    # Loop through columns and encode if they start with 'cluster_'
-    for col in X_train.columns:
-        if col.startswith("cluster_"):
-            X_train[col] = label_encoder.fit_transform(X_train[col])
-            encoded_cols.append(col)
-
-    # Label encode y_train
-    y_train = label_encoder.fit_transform(y_train)
-
-    return X_train, y_train
-
-def prepare_for_model_val_set(df_val_fp: pd.DataFrame, df_train_fp: pd.DataFrame, n_lags: pd.DataFrame):
-    '''
-    Prepare validation set. Attach to the begginning of val set rows from the end of the train set (based on numbef of lags). In the end remove the attached rows.
-    '''
-    df_concat = pd.concat([df_train_fp.tail(n_lags), df_val_fp], axis=0).reset_index(drop=True)
-
-
-    X_val, y_val = prepare_for_model(df=df_concat, number_of_lags=n_lags)
-
-    X_val = X_val.iloc[n_lags:]
-    y_val = y_val[n_lags:]
-
-    return X_val, y_val
+import pandas as pd
+import warnings
+from sklearn.preprocessing import LabelEncoder
+
+def prepare_for_model(df: pd.DataFrame, number_of_lags: int):
+    """
+    Prepare fuzzy partitioned data for modeling.
+    
+    Parameters:
+    - df (pd.DataFrame): The input DataFrame containing fuzzy partitioned data.
+    - number_of_lags (int): The number of lag features to create.
+
+    Returns:
+    - X_train (pd.DataFrame): Features for training the model.
+    - y_train (np.ndarray): Target variable for training the model.
+    """
+    
+    # Prepare the 'fuzzy_set' column
+    df.loc[:, "fuzzy_set"] = df["fuzzy_set"].str.replace("set_", "").astype(int).copy()
+
+    # Create lagged features
+    for i in range(1, number_of_lags + 1):
+        df.loc[:, "fuzzy_set_lag" + str(i)] = df["fuzzy_set"].shift(i).copy()
+        df.loc[:, "membership_value_lag" + str(i)] = df["membership_value"].shift(i).copy()
+        df.loc[:, "left_lag" + str(i)] = df["left"].shift(i).copy()
+
+    # Reset warning filter
+    warnings.filterwarnings("default", category=pd.errors.SettingWithCopyWarning)
+
+    # Prepare the model DataFrame
+    df_model = df.copy()
+    df_model.drop(columns=["membership_value", "left"], inplace=True)
+    df_model.rename(columns={"X_value": "Y"}, inplace=True)
+
+    numeric_cols = df_model.select_dtypes(include=['float64', 'int64']).columns
+    df_model[numeric_cols] = df_model[numeric_cols].fillna(0)
+
+
+    # Separate target and features
+    y_train = df_model["fuzzy_set"]
+    X_train = df_model.drop(columns=["Y", "fuzzy_set"])
+
+    # Encode categorical columns
+    label_encoder = LabelEncoder()
+    encoded_cols = []
+
+    # Loop through columns and encode if they start with 'fuzzy_set_'
+    for col in X_train.columns:
+        if col.startswith("fuzzy_set_"):
+            X_train[col] = label_encoder.fit_transform(X_train[col])
+            encoded_cols.append(col)
+
+    # Label encode y_train
+    y_train = label_encoder.fit_transform(y_train)
+
+    return X_train, y_train
+
+def prepare_for_model_val_set(df_val_fp: pd.DataFrame, df_train_fp: pd.DataFrame, n_lags: pd.DataFrame):
+    '''
+    Prepare validation set. Attach to the begginning of val set rows from the end of the train set (based on numbef of lags). In the end remove the attached rows.
+    '''
+    df_concat = pd.concat([df_train_fp.tail(n_lags), df_val_fp], axis=0).reset_index(drop=True)
+
+
+    X_val, y_val = prepare_for_model(df=df_concat, number_of_lags=n_lags)
+
+    X_val = X_val.iloc[n_lags:]
+    y_val = y_val[n_lags:]
+
+    return X_val, y_val

autofuzzts/preprocess/preprocess.py

@@ -1,63 +1,63 @@
-import pandas as pd
-import numpy as np
-from sklearn.preprocessing import MinMaxScaler
-from typing import Literal
-
-
-def preprocess_data(df: pd.DataFrame, diff_type: Literal['perc', 'abs'] = 'perc', scaler: MinMaxScaler = None) -> pd.DataFrame:
-    """
-    Prepares time series data by calculating differences, scaling, and selecting rows.
-    
-    Parameters:
-        df (pd.DataFrame): Input DataFrame with a single column named 'Y' containing the time series data.
-        diff_type (str): Type of difference to calculate ('perc' for percentage, 'abs' for absolute). Default is 'perc'.
-        n_rows (int): Number of rows to retain from the end. If -1, use all rows.
-    
-    Returns:
-        np.ndarray: The preprocessed data, scaled and ready for further processing.
-        MinMaxScaler: The scaler used for scaling, useful for inverse transformation.
-    """
-    
-    # Step 1: Calculate the difference based on user choice
-    if diff_type == 'perc':
-        df['diff'] = df['Y'].pct_change()  # Percentage difference
-    elif diff_type == 'abs':
-        df['diff'] = df['Y'].diff()  # Absolute difference
-    else:
-        raise ValueError("Invalid diff_type. Choose 'perc' for percentage or 'abs' for absolute.")
-    
-
-    ## Replace infinite values with 1 or -1
-    df['diff'] = np.where(df['diff'] == np.inf, 1, df['diff'])
-    df['diff'] = np.where(df['diff'] == -np.inf, -1, df['diff'])
-
-    ## If diff is bellow 0.01 quantile or 0.99 quantile, replace with 0.01 or 0.99 quantile
-    df['diff'] = np.where(df['diff'] < df['diff'].quantile(0.01), df['diff'].quantile(0.01), df['diff'])
-    df['diff'] = np.where(df['diff'] > df['diff'].quantile(0.99), df['diff'].quantile(0.99), df['diff'])
-
-
-    ## Relace NaNs with 0
-    df['diff'] = df['diff'].fillna(0)  # Replace NaNs with 0, or adjust as needed
-
-    # Step 2: Scale only the 'diff' column
-    if scaler is None:  # If no scaler is provided, create a new one (otherwise use the existing one)
-        scaler = MinMaxScaler()
-
-    df_scaled = df.copy()
-    df_scaled['diff_scaled'] = scaler.fit_transform(df[['diff']])  # Scale 'diff' column only
- 
-
-
-
-    return df_scaled, scaler  # Return scaled data and scaler for possible inverse transform
-
-def preprocess_data_val(df: pd.DataFrame,df_train: pd.DataFrame, diff_type: Literal['perc', 'abs'] = 'perc', scaler: MinMaxScaler = None):
-    '''
-    Attach last row of train set to the beginnig of the val set and preprocess the data. In the end remove the attached row.
-    '''
-    df_concat = pd.concat([df_train.tail(1), df], axis=0)
-    df_preprocessed, scaler = preprocess_data(df=df_concat, diff_type=diff_type, scaler=scaler)
-    df_preprocessed = df_preprocessed.iloc[1:]
-    return df_preprocessed
-
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+from typing import Literal
+
+
+def preprocess_data(df: pd.DataFrame, diff_type: Literal['perc', 'abs'] = 'perc', scaler: MinMaxScaler = None) -> pd.DataFrame:
+    """
+    Prepares time series data by calculating differences, scaling, and selecting rows.
+    
+    Parameters:
+        df (pd.DataFrame): Input DataFrame with a single column named 'Y' containing the time series data.
+        diff_type (str): Type of difference to calculate ('perc' for percentage, 'abs' for absolute). Default is 'perc'.
+        n_rows (int): Number of rows to retain from the end. If -1, use all rows.
+    
+    Returns:
+        np.ndarray: The preprocessed data, scaled and ready for further processing.
+        MinMaxScaler: The scaler used for scaling, useful for inverse transformation.
+    """
+    
+    # Step 1: Calculate the difference based on user choice
+    if diff_type == 'perc':
+        df['diff'] = df['Y'].pct_change()  # Percentage difference
+    elif diff_type == 'abs':
+        df['diff'] = df['Y'].diff()  # Absolute difference
+    else:
+        raise ValueError("Invalid diff_type. Choose 'perc' for percentage or 'abs' for absolute.")
+    
+
+    ## Replace infinite values with 1 or -1
+    df['diff'] = np.where(df['diff'] == np.inf, 1, df['diff'])
+    df['diff'] = np.where(df['diff'] == -np.inf, -1, df['diff'])
+
+    ## If diff is bellow 0.01 quantile or 0.99 quantile, replace with 0.01 or 0.99 quantile
+    df['diff'] = np.where(df['diff'] < df['diff'].quantile(0.01), df['diff'].quantile(0.01), df['diff'])
+    df['diff'] = np.where(df['diff'] > df['diff'].quantile(0.99), df['diff'].quantile(0.99), df['diff'])
+
+
+    ## Relace NaNs with 0
+    df['diff'] = df['diff'].fillna(0)  # Replace NaNs with 0, or adjust as needed
+
+    # Step 2: Scale only the 'diff' column
+    if scaler is None:  # If no scaler is provided, create a new one (otherwise use the existing one)
+        scaler = MinMaxScaler()
+
+    df_scaled = df.copy()
+    df_scaled['diff_scaled'] = scaler.fit_transform(df[['diff']])  # Scale 'diff' column only
+ 
+
+
+
+    return df_scaled, scaler  # Return scaled data and scaler for possible inverse transform
+
+def preprocess_data_val(df: pd.DataFrame,df_train: pd.DataFrame, diff_type: Literal['perc', 'abs'] = 'perc', scaler: MinMaxScaler = None):
+    '''
+    Attach last row of train set to the beginnig of the val set and preprocess the data. In the end remove the attached row.
+    '''
+    df_concat = pd.concat([df_train.tail(1), df], axis=0)
+    df_preprocessed, scaler = preprocess_data(df=df_concat, diff_type=diff_type, scaler=scaler)
+    df_preprocessed = df_preprocessed.iloc[1:]
+    return df_preprocessed
+
     

{autofuzzts-0.1.1.dist-info → autofuzzts-0.1.3.dist-info}/METADATA

@@ -1,146 +1,161 @@
-Metadata-Version: 2.4
-Name: autofuzzts
-Version: 0.1.1
-Summary: 'Time series forecasting using fuzzy logic and AutoML'
-Author-email: Jan Timko <jantimko16@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/yourusername/autofuzzts
-Project-URL: Repository, https://github.com/yourusername/autofuzzts
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy>=1.26.0
-Requires-Dist: pandas>=2.2.0
-Requires-Dist: scikit-learn>=1.5.0
-Requires-Dist: scipy>=1.15.0
-Requires-Dist: xgboost>=3.0.0
-Requires-Dist: lightgbm>=4.6.0
-Requires-Dist: tpot>=1.0.0
-Requires-Dist: optuna>=4.3.0
-Requires-Dist: matplotlib>=3.10.0
-Requires-Dist: seaborn>=0.13.0
-Requires-Dist: requests>=2.32.0
-Requires-Dist: PyYAML>=6.0.0
-Requires-Dist: joblib>=1.4.0
-Requires-Dist: tqdm>=4.67.0
-Dynamic: license-file
-
-# AutoFuzzTS
-
-Time series forecasting library using fuzzy logic and automated machine learning.  
-Build and evaluate time series models automatically using fuzzy logic and AutoML techniques.
-
-## Installation
-
-```bash
-pip install autofuzzts
-```
-
-## 🚀 Quick Start
-
-### Load and prepare your time series data
-```python
-import pandas as pd
-
-# Load dataset into a pandas DataFrame
-data = pd.read_csv("../clean_data/ADBE_yf_hourly_cleaned.csv").head(240)
-
-# Select the target column to forecast
-data_column_name = "close_price"
-df = data[[data_column_name]].copy()
-
-# Split into train, validation, and test sets
-test_len = len(df) // 5
-val_len = len(df) // 5
-train_len = len(df) - test_len - val_len
-
-df_train = df[:train_len]
-df_val = df[train_len:(train_len + val_len)]
-df_test = df[(train_len + val_len):]
-```
-
----
-
-### Tune hyperparameters using Bayesian search
-```python
-from autofuzzts import pipeline
-
-# Run Bayesian optimization for fuzzy pipeline configuration
-best_config, best_rmse = pipeline.tune_hyperparameters_bayes(
-    train_set=df_train,
-    val_set=df_val,
-    n_trials=20,
-    metric="rmse"
-)
-
-print(f"Best configuration: {best_config}")
-```
-
-**Example output:**
-```
-Best configuration: {'n_clusters': 19, 'number_of_lags': 2, 'fuzzy_part_func': 'Triangle'}
-```
-
----
-
-### Train, calibrate, and predict
-```python
-from autofuzzts import fit_calibrate_predict
-
-# Train model, calibrate, and make one-step-ahead predictions
-pred_set, pred_center_points, pred_test = fit_calibrate_predict(
-    train_set=df_train,
-    test_set=df_test,
-    config=best_config,
-    model_type="xgb"
-)
-```
-
-This returns:
-- `pred_set`: predicted fuzzy sets  
-- `pred_center_points`: corresponding fuzzy center values  
-- `pred_test`: crisp numeric predictions (one-step-ahead forecast)
-
----
-
-##  Function Overview
-
-### `fit_calibrate_predict()`
-
-```python
-fit_calibrate_predict(
-    train_set: pd.DataFrame,
-    test_set: pd.DataFrame,
-    config: dict,
-    model_type: Literal['xgb', 'mlp', 'tpot'] = 'xgb',
-    number_cv_calib: int = 5,
-    diff_type: Literal['perc', 'abs'] = 'perc',
-    covariates: list[str] | None = None,
-    exclude_bool: bool = False
-) -> float
-```
-
-Trains and calibrates a fuzzy time series model on the training set using
-cross-validation, then predicts on the test set and returns performance metrics.
-
----
-
-## Description
-
-AutoFuzzTS automates the process of fuzzy time series modeling by:
-- building and testing multiple fuzzy pipelines,  
-- tuning hyperparameters using Bayesian optimization, and  
-- integrating tuned classification models -  **XGBoost**, **MLP**, or **TPOT**.
-
-This allows for rapid experimentation and selection of optimal configurations 
-for forecasting tasks.
-
----
-
-
----
-
-## 📄 License
-
-This project is licensed under the MIT License.
-
+Metadata-Version: 2.4
+Name: autofuzzts
+Version: 0.1.3
+Summary: 'Time series forecasting using fuzzy logic and AutoML'
+Author-email: Jan Timko <jantimko16@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jtimko16/AutoFuzzTS
+Project-URL: Repository, https://github.com/jtimko16/AutoFuzzTS
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: scikit-learn>=1.5.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: xgboost>=3.0.0
+Requires-Dist: lightgbm>=4.6.0
+Requires-Dist: tpot>=1.0.0
+Requires-Dist: optuna>=4.3.0
+Requires-Dist: matplotlib>=3.10.0
+Requires-Dist: seaborn>=0.13.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: PyYAML>=6.0.0
+Requires-Dist: joblib>=1.4.0
+Requires-Dist: tqdm>=4.67.0
+Dynamic: license-file
+
+# AutoFuzzTS
+
+Time series forecasting library using fuzzy logic and automated machine learning.  
+Build and evaluate time series models automatically using fuzzy logic and AutoML techniques.
+
+The package is designed for academic benchmarking and controlled experimentation in one-step-ahead time-series forecasting. It assumes a fixed train/validation/test split and focuses on reproducible model comparison rather than real-time deployment.
+
+## Installation
+
+```bash
+pip install autofuzzts
+```
+
+## 🚀 Quick Start
+
+### Load and prepare your time series data
+```python
+import pandas as pd
+
+# Load dataset into a pandas DataFrame
+data = pd.read_csv('../../data/sample_datasets/NYSE.csv')
+data.head(10)
+```
+
+```python
+# Select the target column to forecast
+data_column_name = "Close"
+df = data[[data_column_name]].copy()
+
+# Split into train, validation, and test sets
+test_len = len(df) // 5
+val_len = len(df) // 5
+train_len = len(df) - test_len - val_len
+
+df_train = df[:train_len]
+df_val = df[train_len:(train_len + val_len)]
+df_test = df[(train_len + val_len):]
+```
+
+---
+
+### Tune hyperparameters using Bayesian search
+```python
+from autofuzzts import pipeline
+
+# Run Bayesian optimization for fuzzy pipeline configuration
+best_config, best_rmse = pipeline.tune_hyperparameters_bayes(
+    train_set=df_train,
+    val_set=df_val,
+    n_trials=20,
+    metric="rmse"
+)
+
+print(f"Best configuration: {best_config}")
+```
+
+**Example output:**
+```
+Best configuration: {'n_fuzzy_sets': 13, 'number_of_lags': 6, 'fuzzy_part_func': 'Cosine'}
+```
+
+---
+
+### Train, calibrate, and predict
+```python
+from autofuzzts import fit_calibrate_predict
+
+# Train model, calibrate, and make one-step-ahead predictions
+pred_set, pred_center_points, pred_test = fit_calibrate_predict(
+    train_set=df_train,
+    test_set=df_test,
+    config=best_config,
+    model_type="xgb"
+)
+```
+
+This returns:
+- `pred_set`: predicted fuzzy sets  
+- `pred_center_points`: corresponding fuzzy center values  
+- `pred_test`: crisp numeric predictions (one-step-ahead forecast)
+
+---
+
+##  Function Overview
+
+### `fit_calibrate_predict()`
+
+```python
+fit_calibrate_predict(
+    train_set: pd.DataFrame,
+    test_set: pd.DataFrame,
+    config: dict,
+    model_type: Literal['xgb', 'mlp', 'tpot'] = 'xgb',
+    number_cv_calib: int = 5,
+    diff_type: Literal['perc', 'abs'] = 'perc',
+    covariates: list[str] | None = None,
+    exclude_bool: bool = False
+) -> float
+```
+
+Trains and calibrates a fuzzy time series model on the training set using
+cross-validation, then predicts on the test set and returns performance metrics.
+
+---
+
+## Description
+
+AutoFuzzTS automates the process of fuzzy time series modeling by:
+- building and testing multiple fuzzy pipelines,  
+- tuning hyperparameters using Bayesian optimization, and  
+- integrating tuned classification models -  **XGBoost**, **MLP**, or **TPOT**.
+
+This allows for rapid experimentation and selection of optimal configurations 
+for forecasting tasks.
+
+---
+## 📄 Reference
+
+This code is based on the research:
+
+**Optimizing stock price forecasting: a hybrid approach using fuzziness and automated machine learning**  
+*Jan Timko, Radwa El Shawi, Stefania Tomasiello*  
+*Expert Systems with Applications*, Volume 259, 2025, 128844  
+
+[Read on ScienceDirect](https://www.sciencedirect.com/science/article/pii/S0957417425024613)
+
+If you use this code in your research or projects, please cite the paper.
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License.
+

autofuzzts-0.1.3.dist-info/RECORD

@@ -0,0 +1,23 @@
+autofuzzts/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/config.py,sha256=IheqZ8IH2Y7n2KZT_kYs9hVNJAWyY0zZo039TgXoFko,377
+autofuzzts/pipeline.py,sha256=Y6AqYpPNuOLqfTO6Mt7NOvwXnZ_VY1pKPcIfWcD5kgg,15772
+autofuzzts/data/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/data/data_loader.py,sha256=UxpIyeerMGDeFlblWVSdfVdzQc_rv7IHh1M4BqwzxHk,259
+autofuzzts/data_validation/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/data_validation/validate.py,sha256=Z1YPGr_muFFfyLv3DG32a74Am7IBIeMrwjglxJKN1vg,1412
+autofuzzts/evaluation/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/models/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/models/fuzzy_classifier.py,sha256=0b_EG1y90gn4ped1Zm4QMeJzRuQnxabB865vVW0lCZk,3289
+autofuzzts/models/mlp_nas.py,sha256=-N550H7nNtZJL9d72MPVTLpFGWq7DH4QmKkh7gJMDxw,2958
+autofuzzts/partition/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/partition/fuzzy_part_fun.py,sha256=t3uZba9-QiKwMb9kfU-7fLJqfKT9aKmPZ7cqpqvt_lE,2992
+autofuzzts/partition/partition.py,sha256=ih-3ulRz24JoHlpGCbTxJrmL2DdylSXWMnlzTO6zTpY,4334
+autofuzzts/partition/visualize_partition.py,sha256=vCEefgyPuP4Jr6uL9VfrdWE80Q0StGGaPyiIrs-vUt8,879
+autofuzzts/preprocess/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/preprocess/prep_for_model.py,sha256=8U3VxVLi0eIOHaNQGcGVweq2V0g497cCHm4dVFX2PdE,2527
+autofuzzts/preprocess/preprocess.py,sha256=hC_Y84JKB030dCsnTKhJVaZLy7ARlqwxpKdT7ioyET4,2724
+autofuzzts-0.1.3.dist-info/licenses/LICENSE,sha256=0YpXiCONotJkGz-eE74pd-R3hInmIyMJ-buT7NwiLxI,1066
+autofuzzts-0.1.3.dist-info/METADATA,sha256=ajA7jHEbk-BMM_iqe1hQXVdlcGHmfpjfk8J-R6yTStg,4321
+autofuzzts-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+autofuzzts-0.1.3.dist-info/top_level.txt,sha256=YHgbVRUPg-x2WX7FKyJMUAeI9o46c8XFiR_eYKtXIxc,11
+autofuzzts-0.1.3.dist-info/RECORD,,

{autofuzzts-0.1.1.dist-info → autofuzzts-0.1.3.dist-info}/WHEEL

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

{autofuzzts-0.1.1.dist-info → autofuzzts-0.1.3.dist-info}/licenses/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Jan Timko
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Jan Timko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.