Delete libraries

libraries/fits/pants_lib.py

@@ -1,63 +0,0 @@
-from dataclasses import dataclass
-
-@dataclass
-class PantsMeasurements:
-    waist: float    # in cm
-    hips: float     # in cm
-    leg_length: float  # in cm
-
-def determine_fit(measurements: PantsMeasurements) -> str:
-    """
-    Determine the general fit for pants based on waist, hips, and leg length measurements.
-    
-    The algorithm uses two ratios:
-      - Waist-to-Hips Ratio: Lower ratios typically suggest a more tapered (slim) waist.
-      - Leg-to-Hips Ratio: Higher values indicate longer legs relative to hip size.
-    
-    Assumed thresholds for demonstration purposes:
-      - Slim Fit: if waist/hips < 0.80 and leg_length/hips >= 1.15
-      - Regular Fit: if 0.80 <= waist/hips <= 0.90 and 1.05 <= leg_length/hips < 1.15
-      - Loose Fit: otherwise
-    
-    Args:
-        measurements (PantsMeasurements): The measurements for waist, hips, and leg length.
-        
-    Returns:
-        str: A recommendation of 'Slim Fit', 'Regular Fit', or 'Loose Fit'.
-    """
-    waist_to_hip = measurements.waist / measurements.hips
-    leg_to_hip = measurements.leg_length / measurements.hips
-
-    if waist_to_hip < 0.80 and leg_to_hip >= 1.15:
-        return "Slim Fit"
-    elif 0.80 <= waist_to_hip <= 0.90 and 1.05 <= leg_to_hip < 1.15:
-        return "Regular Fit"
-    else:
-        return "Loose Fit"
-
-def get_fit(waist: float, hips: float, leg_length: float) -> str:
-    """
-    Get a fit recommendation for pants based on input measurements.
-    
-    Args:
-        waist (float): Waist measurement in cm.
-        hips (float): Hip measurement in cm.
-        leg_length (float): Leg length measurement in cm.
-        
-    Returns:
-        str: The recommended pants fit category.
-    """
-    measurements = PantsMeasurements(waist=waist, hips=hips, leg_length=leg_length)
-    return determine_fit(measurements)
-
-if __name__ == "__main__":
-    try:
-        waist_input = float(input("Enter your waist measurement (cm): "))
-        hips_input = float(input("Enter your hip measurement (cm): "))
-        leg_length_input = float(input("Enter your leg length measurement (cm): "))
-    except ValueError:
-        print("Please enter valid numeric values.")
-        exit(1)
-    
-    recommended_fit = get_fit(waist_input, hips_input, leg_length_input)
-    print(f"Based on your measurements, your recommended fit for pants is: {recommended_fit}")

libraries/fits/shirts_lib.py

@@ -1,67 +0,0 @@
-from dataclasses import dataclass
-
-@dataclass
-class BodyMeasurements:
-    shoulder: float  # in cm
-    chest: float     # in cm
-    waist: float     # in cm
-
-def determine_fit(measurements: BodyMeasurements) -> str:
-    """
-    Determine the general fit based on shoulder, chest, and waist measurements.
-    
-    The algorithm uses two simple ratios:
-      - waist-to-chest ratio: a lower ratio suggests a more tapered torso (slim fit).
-      - chest-to-shoulder ratio: a higher ratio suggests a broader chest relative to the shoulder,
-        which is often associated with a slimmer profile.
-    
-    Thresholds (assumed for demonstration purposes):
-      - Slim Fit: waist/chest < 0.85 and chest/shoulder >= 1.45
-      - Regular Fit: waist/chest between 0.85 and 0.95 and chest/shoulder between 1.3 and 1.45
-      - Loose Fit: any measurements outside the above ranges
-    
-    Args:
-        measurements (BodyMeasurements): User measurements in centimeters.
-    
-    Returns:
-        str: A recommendation of 'Slim Fit', 'Regular Fit', or 'Loose Fit'.
-    """
-    # Calculate ratios
-    waist_chest_ratio = measurements.waist / measurements.chest
-    chest_shoulder_ratio = measurements.chest / measurements.shoulder
-
-    # Determine fit based on ratio thresholds
-    if waist_chest_ratio < 0.85 and chest_shoulder_ratio >= 1.45:
-        return "Slim Fit"
-    elif 0.85 <= waist_chest_ratio <= 0.95 and 1.3 <= chest_shoulder_ratio < 1.45:
-        return "Regular Fit"
-    else:
-        return "Loose Fit"
-
-def get_fit(shoulder: float, chest: float, waist: float) -> str:
-    """
-    Get a fit recommendation based on input measurements.
-    
-    Args:
-        shoulder (float): Shoulder measurement in cm.
-        chest (float): Chest measurement in cm.
-        waist (float): Waist measurement in cm.
-    
-    Returns:
-        str: The recommended fit category.
-    """
-    measurements = BodyMeasurements(shoulder=shoulder, chest=chest, waist=waist)
-    return determine_fit(measurements)
-
-if __name__ == "__main__":
-    # Example interactive usage:
-    try:
-        shoulder_input = float(input("Enter your shoulder measurement (cm): "))
-        chest_input = float(input("Enter your chest measurement (cm): "))
-        waist_input = float(input("Enter your waist measurement (cm): "))
-    except ValueError:
-        print("Please enter valid numeric values.")
-        exit(1)
-    
-    recommended_fit = get_fit(shoulder_input, chest_input, waist_input)
-    print(f"Based on your measurements, your recommended fit is: {recommended_fit}")

libraries/sizes/pants_lib.py

@@ -1,119 +0,0 @@
-from typing import List, Dict, Tuple
-from dataclasses import dataclass
-import json
-from enum import Enum
-
-class SizeLabel(Enum):
-    XS = 1
-    S = 2
-    M = 3
-    L = 4
-    XL = 5
-    XXL = 6
-
-@dataclass
-class SizeRange:
-    label: str
-    waist: List[int]
-    hip: List[int]
-    length: List[int]
-
-@dataclass
-class Brand:
-    brand: str
-    sizes: List[SizeRange]
-
-def load_size_data() -> List[Brand]:
-    """Load and parse the size data from JSON."""
-    with open('./data/size_data_pants.json', 'r') as f:
-        data = json.load(f)
-    
-    brands = []
-    for brand_data in data:
-        sizes = []
-        for size in brand_data['sizes']:
-            sizes.append(SizeRange(
-                label=size['label'],
-                waist=size['waist'],
-                hip=size['hip'],
-                length=size['length']
-            ))
-        brands.append(Brand(brand=brand_data['brand'], sizes=sizes))
-    return brands
-
-def find_size_category(measurement: int, ranges: List[List[int]]) -> List[int]:
-    """Find matching size indices for a given measurement."""
-    return [i for i, (min_val, max_val) in enumerate(ranges) if min_val <= measurement <= max_val]
-
-def get_best_size(brand_name: str, waist: int, hip: int, length: int) -> Tuple[str, Dict[str, str]]:
-    """
-    Determine the best size for given measurements and brand.
-    
-    Args:
-        brand_name (str): Name of the brand
-        waist (int): Waist measurement in cm
-        hip (int): Hip measurement in cm
-        length (int): Pants length in cm
-    
-    Returns:
-        Tuple[str, Dict[str, str]]: Recommended size label and detailed fit information
-    """
-    brands = load_size_data()
-    
-    brand = next((b for b in brands if b.brand.lower() == brand_name.lower()), None)
-    if not brand:
-        raise ValueError(f"Brand '{brand_name}' not found")
-    
-    waist_ranges = [size.waist for size in brand.sizes]
-    hip_ranges = [size.hip for size in brand.sizes]
-    length_ranges = [size.length for size in brand.sizes]
-    
-    waist_sizes = find_size_category(waist, waist_ranges)
-    hip_sizes = find_size_category(hip, hip_ranges)
-    length_sizes = find_size_category(length, length_ranges)
-    
-    if not waist_sizes or not hip_sizes or not length_sizes:
-        measurements_info = {
-            "waist": "too small" if waist < waist_ranges[0][0] else "too large" if waist > waist_ranges[-1][1] else "ok",
-            "hip": "too small" if hip < hip_ranges[0][0] else "too large" if hip > hip_ranges[-1][1] else "ok",
-            "length": "too short" if length < length_ranges[0][0] else "too long" if length > length_ranges[-1][1] else "ok"
-        }
-        return "No exact fit", measurements_info
-    
-    all_indices = waist_sizes + hip_sizes + length_sizes
-    avg_size_index = round(sum(all_indices) / len(all_indices))
-    
-    recommended_size = brand.sizes[avg_size_index].label
-    
-    fit_info = {
-        "waist": "perfect" if avg_size_index in waist_sizes else "tight" if avg_size_index > max(waist_sizes) else "loose",
-        "hip": "perfect" if avg_size_index in hip_sizes else "tight" if avg_size_index > max(hip_sizes) else "loose",
-        "length": "perfect" if avg_size_index in length_sizes else "short" if avg_size_index > max(length_sizes) else "long"
-    }
-    
-    return recommended_size, fit_info
-
-def print_size_recommendation(brand: str, waist: int, hip: int, length: int) -> None:
-    """
-    Print a formatted size recommendation.
-    
-    Args:
-        brand (str): Brand name
-        waist (int): Waist measurement in cm
-        hip (int): Hip measurement in cm
-        length (int): Pants length in cm
-    """
-    try:
-        size, fit_info = get_best_size(brand, waist, hip, length)
-        print(f"\nSize Recommendation for {brand}:")
-        print(f"Recommended size: {size}")
-        print("\nFit Details:")
-        print(f"Waist: {fit_info['waist']}")
-        print(f"Hip: {fit_info['hip']}")
-        print(f"Length: {fit_info['length']}")
-    except ValueError as e:
-        print(f"Error: {str(e)}")
-
-# Example usage
-if __name__ == "__main__":
-    print_size_recommendation("Zara", 80, 95, 105)

libraries/sizes/shirts_lib.py

@@ -1,131 +0,0 @@
-from typing import List, Dict, Union, Tuple
-from dataclasses import dataclass
-import json
-from enum import Enum
-
-class SizeLabel(Enum):
-    XS = 1
-    S = 2
-    M = 3
-    L = 4
-    XL = 5
-    XXL = 6
-
-@dataclass
-class SizeRange:
-    label: str
-    chest: List[int]
-    waist: List[int]
-    shoulder: List[int]
-
-@dataclass
-class Brand:
-    brand: str
-    sizes: List[SizeRange]
-
-def load_size_data() -> List[Brand]:
-    """Load and parse the size data from JSON."""
-    with open('./data/size_data_shirts.json', 'r') as f:
-        data = json.load(f)
-    
-    brands = []
-    for brand_data in data:
-        sizes = []
-        for size in brand_data['sizes']:
-            sizes.append(SizeRange(
-                label=size['label'],
-                chest=size['chest'],
-                waist=size['waist'],
-                shoulder=size['shoulder']
-            ))
-        brands.append(Brand(brand=brand_data['brand'], sizes=sizes))
-    return brands
-
-def find_size_category(measurement: int, ranges: List[List[int]]) -> List[int]:
-    """Find matching size indices for a given measurement."""
-    matching_sizes = []
-    for i, (min_val, max_val) in enumerate(ranges):
-        if min_val <= measurement <= max_val:
-            matching_sizes.append(i)
-    return matching_sizes
-
-def get_best_size(brand_name: str, chest: int, waist: int, shoulder: int) -> Tuple[str, Dict[str, str]]:
-    """
-    Determine the best size for given measurements and brand.
-    
-    Args:
-        brand_name (str): Name of the brand (e.g., "Zara", "H&M", "Dior")
-        chest (int): Chest measurement in centimeters
-        waist (int): Waist measurement in centimeters
-        shoulder (int): Shoulder measurement in centimeters
-    
-    Returns:
-        Tuple[str, Dict[str, str]]: Recommended size label and detailed fit information
-    """
-    brands = load_size_data()
-    
-    # Find the brand
-    brand = next((b for b in brands if b.brand.lower() == brand_name.lower()), None)
-    if not brand:
-        raise ValueError(f"Brand '{brand_name}' not found")
-    
-    # Get all size ranges for the brand
-    chest_ranges = [size.chest for size in brand.sizes]
-    waist_ranges = [size.waist for size in brand.sizes]
-    shoulder_ranges = [size.shoulder for size in brand.sizes]
-    
-    # Find matching sizes for each measurement
-    chest_sizes = find_size_category(chest, chest_ranges)
-    waist_sizes = find_size_category(waist, waist_ranges)
-    shoulder_sizes = find_size_category(shoulder, shoulder_ranges)
-    
-    # If any measurement doesn't fit in any range
-    if not chest_sizes or not waist_sizes or not shoulder_sizes:
-        measurements_info = {
-            "chest": "too small" if chest < chest_ranges[0][0] else "too large" if chest > chest_ranges[-1][1] else "ok",
-            "waist": "too small" if waist < waist_ranges[0][0] else "too large" if waist > waist_ranges[-1][1] else "ok",
-            "shoulder": "too small" if shoulder < shoulder_ranges[0][0] else "too large" if shoulder > shoulder_ranges[-1][1] else "ok"
-        }
-        return "No exact fit", measurements_info
-    
-    # Calculate the average size index
-    all_indices = chest_sizes + waist_sizes + shoulder_sizes
-    avg_size_index = round(sum(all_indices) / len(all_indices))
-    
-    # Get the recommended size label
-    recommended_size = brand.sizes[avg_size_index].label
-    
-    # Prepare detailed fit information
-    fit_info = {
-        "chest": "perfect" if avg_size_index in chest_sizes else "tight" if avg_size_index > max(chest_sizes) else "loose",
-        "waist": "perfect" if avg_size_index in waist_sizes else "tight" if avg_size_index > max(waist_sizes) else "loose",
-        "shoulder": "perfect" if avg_size_index in shoulder_sizes else "tight" if avg_size_index > max(shoulder_sizes) else "loose"
-    }
-    
-    return recommended_size, fit_info
-
-def print_size_recommendation(brand: str, chest: int, waist: int, shoulder: int) -> None:
-    """
-    Print a formatted size recommendation.
-    
-    Args:
-        brand (str): Brand name
-        chest (int): Chest measurement in cm
-        waist (int): Waist measurement in cm
-        shoulder (int): Shoulder measurement in cm
-    """
-    try:
-        size, fit_info = get_best_size(brand, chest, waist, shoulder)
-        print(f"\nSize Recommendation for {brand}:")
-        print(f"Recommended size: {size}")
-        print("\nFit Details:")
-        print(f"Chest: {fit_info['chest']}")
-        print(f"Waist: {fit_info['waist']}")
-        print(f"Shoulder: {fit_info['shoulder']}")
-    except ValueError as e:
-        print(f"Error: {str(e)}")
-
-# Example usage
-if __name__ == "__main__":
-    # Example measurements
-    print_size_recommendation("Zara", 95, 80, 43)  # Example measurements