bsdatetime 1.0.0__py3-none-any.whl

bsdatetime/__init__.py

@@ -0,0 +1,44 @@
+"""Bikram Sambat (Nepali) date & datetime utilities.
+
+Renamed distribution: bsdatetime (formerly bikram-sambat).
+This module preserves the public API from the former bikram_sambat package.
+"""
+
+__version__ = "1.1.0"
+
+from .config import (
+    BASE_AD,
+    BASE_BS,
+    MIN_BS_YEAR,
+    MAX_BS_YEAR,
+    BS_MONTH_NAMES,
+    BS_WEEKDAY_NAMES,
+)
+from . import utils
+from .conversion import ad_to_bs, bs_to_ad
+from .validation import is_valid_bs_date, get_bs_month_days
+from .formatting import (
+    format_bs_date,
+    parse_bs_date,
+    format_bs_datetime,
+    parse_bs_datetime,
+)
+
+__all__ = [
+    "__version__",
+    "BASE_AD",
+    "BASE_BS",
+    "MIN_BS_YEAR",
+    "MAX_BS_YEAR",
+    "BS_MONTH_NAMES",
+    "BS_WEEKDAY_NAMES",
+    "utils",
+    "ad_to_bs",
+    "bs_to_ad",
+    "is_valid_bs_date",
+    "get_bs_month_days",
+    "format_bs_date",
+    "parse_bs_date",
+    "format_bs_datetime",
+    "parse_bs_datetime",
+]

bsdatetime/bs_lookup.py

@@ -0,0 +1,10 @@
+import csv, os
+BS_YEARS = {}
+csv_path = os.path.join(os.path.dirname(__file__), "data", "calendar_bs.csv")
+with open(csv_path, newline="", encoding="utf-8") as f:
+    reader = csv.reader(f)
+    next(reader)
+    for row in reader:
+        year = int(row[0])
+        months = list(map(int, row[1:]))
+        BS_YEARS[year] = months

bsdatetime/config.py

@@ -0,0 +1,34 @@
+"""Configuration and constant values for the Bikram Sambat date utilities.
+"""
+from __future__ import annotations
+import datetime as _dt
+from .bs_lookup import BS_YEARS  # local copy of calendar data
+
+# Core Conversion Anchors
+BASE_AD: _dt.date = _dt.date(2018, 4, 14)  # 2018-04-14 AD
+BASE_BS: tuple[int, int, int] = (2075, 1, 1)  # 2075-01-01 BS
+
+# Calendar Ranges
+MIN_BS_YEAR: int = min(BS_YEARS.keys())
+MAX_BS_YEAR: int = max(BS_YEARS.keys())
+
+# Localized Names
+BS_MONTH_NAMES = [
+	"बैशाख", "जेठ", "असार", "साउन", "भदौ", "आश्विन",
+	"कार्तिक", "मंसिर", "पौष", "माघ", "फाल्गुन", "चैत्र"
+]
+
+# Weekday mapping: Sunday=0 ... Saturday=6
+BS_WEEKDAY_NAMES = [
+	"आइतबार", "सोमबार", "मंगलबार", "बुधबार", "बिहिबार", "शुक्रबार", "शनिबार"
+]
+
+__all__ = [
+	"BASE_AD",
+	"BASE_BS",
+	"MIN_BS_YEAR",
+	"MAX_BS_YEAR",
+	"BS_MONTH_NAMES",
+	"BS_WEEKDAY_NAMES",
+	"BS_YEARS",
+]

bsdatetime/conversion.py

@@ -0,0 +1,114 @@
+"""Conversion between AD (Gregorian) and BS (Bikram Sambat) calendars."""
+from __future__ import annotations
+import datetime as _dt
+from .config import BASE_AD, BASE_BS, BS_YEARS, MIN_BS_YEAR, MAX_BS_YEAR
+
+__all__ = ["ad_to_bs", "bs_to_ad"]
+
+def ad_to_bs(ad_date: _dt.date):
+    """Convert an AD (Gregorian) date to a BS date tuple (year, month, day).
+    
+    Args:
+        ad_date: A datetime.date object in Gregorian calendar
+        
+    Returns:
+        tuple: (year, month, day) in Bikram Sambat calendar
+        
+    Raises:
+        ValueError: If the date is outside the supported range
+        TypeError: If ad_date is not a datetime.date object
+    """
+    if not isinstance(ad_date, _dt.date):
+        raise TypeError("ad_date must be a datetime.date object")
+        
+    days = (ad_date - BASE_AD).days
+    year, month, day = BASE_BS
+    
+    # Handle negative days (dates before BASE_AD)
+    if days < 0:
+        days = abs(days)
+        while days > 0:
+            day -= 1
+            if day < 1:
+                month -= 1
+                if month < 1:
+                    month = 12
+                    year -= 1
+                    if year < MIN_BS_YEAR:
+                        raise ValueError(f"Date {ad_date} is before supported BS range")
+                day = BS_YEARS[year][month - 1]
+            days -= 1
+    else:
+        # Handle positive days (dates after BASE_AD)
+        while days > 0:
+            if year > MAX_BS_YEAR:
+                raise ValueError(f"Date {ad_date} is after supported BS range")
+            month_days = BS_YEARS[year][month - 1]
+            if day + days <= month_days:
+                day += days
+                days = 0
+            else:
+                days -= (month_days - day + 1)
+                day = 1
+                month += 1
+                if month > 12:
+                    month = 1
+                    year += 1
+    
+    return (year, month, day)
+
+def bs_to_ad(bs_year: int, bs_month: int, bs_day: int) -> _dt.date:
+    """Convert a BS date (y,m,d) to an AD date object.
+    
+    Args:
+        bs_year: Bikram Sambat year
+        bs_month: Bikram Sambat month (1-12)
+        bs_day: Bikram Sambat day
+        
+    Returns:
+        datetime.date: Corresponding Gregorian date
+        
+    Raises:
+        ValueError: If the BS date is invalid or outside supported range
+        TypeError: If inputs are not integers
+    """
+    # Input validation
+    if not all(isinstance(x, int) for x in [bs_year, bs_month, bs_day]):
+        raise TypeError("BS date components must be integers")
+        
+    if bs_year < MIN_BS_YEAR or bs_year > MAX_BS_YEAR:
+        raise ValueError(f"BS year {bs_year} is outside supported range ({MIN_BS_YEAR}-{MAX_BS_YEAR})")
+        
+    if bs_month < 1 or bs_month > 12:
+        raise ValueError(f"BS month {bs_month} must be between 1 and 12")
+        
+    if bs_year not in BS_YEARS:
+        raise ValueError(f"No calendar data available for BS year {bs_year}")
+        
+    if bs_day < 1 or bs_day > BS_YEARS[bs_year][bs_month - 1]:
+        raise ValueError(f"BS day {bs_day} is invalid for month {bs_month} of year {bs_year}")
+    
+    ad_date = BASE_AD
+    year, month, day = BASE_BS
+    
+    # Prevent infinite loops with a safety counter
+    max_iterations = 50000  # Roughly 137 years worth of days
+    iterations = 0
+    
+    while (year, month, day) != (bs_year, bs_month, bs_day):
+        iterations += 1
+        if iterations > max_iterations:
+            raise ValueError("Conversion exceeded maximum iterations - possible infinite loop")
+            
+        ad_date += _dt.timedelta(days=1)
+        day += 1
+        if day > BS_YEARS[year][month - 1]:
+            day = 1
+            month += 1
+            if month > 12:
+                month = 1
+                year += 1
+                if year > MAX_BS_YEAR:
+                    raise ValueError("BS date is outside supported range")
+    
+    return ad_date

bsdatetime/formatting.py

@@ -0,0 +1,100 @@
+"""Formatting and parsing for BS dates and datetimes."""
+from __future__ import annotations
+import datetime as _dt
+from .config import BS_MONTH_NAMES, BS_WEEKDAY_NAMES
+from .conversion import bs_to_ad
+from .validation import is_valid_bs_date
+
+__all__ = [
+    "format_bs_date",
+    "parse_bs_date",
+    "format_bs_datetime", 
+    "parse_bs_datetime",
+]
+
+def _weekday_to_custom(ad_weekday: int) -> int:
+    """Convert Python weekday to custom Sunday=0 mapping."""
+    return (ad_weekday + 1) % 7
+
+def format_bs_date(bs_year: int, bs_month: int, bs_day: int, fmt: str = "%Y-%m-%d") -> str:
+    """Format a BS date according to the given format string."""
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    weekday = _weekday_to_custom(ad_date.weekday())
+    replacements = {
+        "%Y": f"{bs_year:04d}",
+        "%m": f"{bs_month:02d}",
+        "%d": f"{bs_day:02d}",
+        "%B": BS_MONTH_NAMES[bs_month - 1],
+        "%A": BS_WEEKDAY_NAMES[weekday],
+    }
+    out = fmt
+    for k, v in replacements.items():
+        out = out.replace(k, v)
+    return out
+
+def parse_bs_date(text: str, fmt: str = "%Y-%m-%d"):
+    """Parse a BS date string according to the given format."""
+    fmt_parts = fmt.split('-')
+    txt_parts = text.split('-')
+    if len(fmt_parts) != len(txt_parts):
+        raise ValueError("Date string does not match format")
+    y = m = d = None
+    for f, t in zip(fmt_parts, txt_parts):
+        if f == "%Y":
+            y = int(t)
+        elif f == "%m":
+            m = int(t)
+        elif f == "%d":
+            d = int(t)
+        elif f == "%B":
+            if t in BS_MONTH_NAMES:
+                m = BS_MONTH_NAMES.index(t) + 1
+            else:
+                raise ValueError("Invalid month name")
+        else:
+            raise ValueError("Unsupported token")
+    if None in (y, m, d):
+        raise ValueError("Incomplete date")
+    if not is_valid_bs_date(y, m, d):
+        raise ValueError("Invalid BS date")
+    return (y, m, d)
+
+def format_bs_datetime(bs_year: int, bs_month: int, bs_day: int, hour: int=0, minute: int=0, second: int=0, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
+    """Format a BS datetime according to the given format string."""
+    date_fmt, time_fmt = (fmt.split(' ', 1) + [""])[:2] if ' ' in fmt else (fmt, "")
+    date_part = format_bs_date(bs_year, bs_month, bs_day, date_fmt)
+    if not time_fmt:
+        return date_part
+    rep = {
+        "%H": f"{hour:02d}",
+        "%M": f"{minute:02d}",
+        "%S": f"{second:02d}",
+    }
+    time_out = time_fmt
+    for k, v in rep.items():
+        time_out = time_out.replace(k, v)
+    return f"{date_part} {time_out}".strip()
+
+def parse_bs_datetime(text: str, fmt: str = "%Y-%m-%d %H:%M:%S"):
+    """Parse a BS datetime string according to the given format."""
+    if ' ' not in fmt:
+        y, m, d = parse_bs_date(text, fmt)
+        return (y, m, d, 0, 0, 0)
+    date_fmt, time_fmt = fmt.split(' ', 1)
+    date_part, time_part = text.split(' ', 1)
+    y, m, d = parse_bs_date(date_part, date_fmt)
+    t_tokens = time_fmt.split(':')
+    v_tokens = time_part.split(':')
+    if len(t_tokens) != len(v_tokens):
+        raise ValueError("Time portion mismatch")
+    hour = minute = second = 0
+    for f, v in zip(t_tokens, v_tokens):
+        if f == "%H":
+            hour = int(v)
+        elif f == "%M":
+            minute = int(v)
+        elif f == "%S":
+            second = int(v)
+        else:
+            raise ValueError("Unsupported time token")
+    return (y, m, d, hour, minute, second)

bsdatetime/utils.py

@@ -0,0 +1,194 @@
+"""Utility functions for Bikram Sambat date operations."""
+
+import datetime
+from .config import MIN_BS_YEAR, MAX_BS_YEAR, BS_WEEKDAY_NAMES, BS_MONTH_NAMES
+from . import conversion as _conversion
+from . import validation as _validation
+from . import formatting as _formatting
+
+# Public re-exports
+ad_to_bs = _conversion.ad_to_bs
+bs_to_ad = _conversion.bs_to_ad
+is_valid_bs_date = _validation.is_valid_bs_date
+get_bs_month_days = _validation.get_bs_month_days
+format_bs_date = _formatting.format_bs_date
+parse_bs_date = _formatting.parse_bs_date
+format_bs_datetime = _formatting.format_bs_datetime
+parse_bs_datetime = _formatting.parse_bs_datetime
+
+__all__ = [
+    # conversion
+    "ad_to_bs", "bs_to_ad",
+    # validation
+    "is_valid_bs_date", "get_bs_month_days", "get_bs_year_range",
+    # formatting
+    "format_bs_date", "parse_bs_date", "format_bs_datetime", "parse_bs_datetime",
+    # misc helpers
+    "difference_between_bs_dates", "add_days_to_bs_date", "subtract_days_from_bs_date",
+    "get_current_bs_date", "get_current_bs_datetime", "bs_date_to_ordinal", "ordinal_to_bs_date",
+    "is_leap_year_bs", "get_bs_week_number", "get_bs_quarter", "get_bs_fiscal_year",
+    "get_bs_date_components", "get_bs_date_range", "get_bs_date_from_string",
+    "bs_date_to_timestamp", "timestamp_to_bs_date", "bs_datetime_to_timestamp", "timestamp_to_bs_datetime",
+    "get_bs_month_name", "get_bs_weekday_name",
+]
+
+def get_bs_year_range():
+    """Get the range of supported BS years."""
+    return (MIN_BS_YEAR, MAX_BS_YEAR)
+
+def get_bs_month_name(bs_month):
+    """Get the Nepali name of the BS month."""
+    if not isinstance(bs_month, int):
+        raise TypeError("BS month must be an integer")
+    if 1 <= bs_month <= 12:
+        return BS_MONTH_NAMES[bs_month - 1]
+    raise ValueError(f"Invalid BS month: {bs_month}. Must be between 1 and 12")
+
+def get_bs_weekday_name(weekday):
+    """Get the Nepali name of the weekday."""
+    if not isinstance(weekday, int):
+        raise TypeError("Weekday must be an integer")
+    if 0 <= weekday <= 6:
+        return BS_WEEKDAY_NAMES[weekday]
+    raise ValueError(f"Invalid weekday: {weekday}. Must be between 0 and 6")
+
+def add_days_to_bs_date(bs_year, bs_month, bs_day, days_to_add):
+    """Add days to a BS date."""
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    new_ad_date = ad_date + datetime.timedelta(days=days_to_add)
+    return ad_to_bs(new_ad_date)
+
+def subtract_days_from_bs_date(bs_year, bs_month, bs_day, days_to_subtract):
+    """Subtract days from a BS date."""
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    new_ad_date = ad_date - datetime.timedelta(days=days_to_subtract)
+    return ad_to_bs(new_ad_date)
+
+def difference_between_bs_dates(bs_date1, bs_date2):
+    """Calculate difference in days between two BS dates."""
+    ad_date1 = bs_to_ad(*bs_date1)
+    ad_date2 = bs_to_ad(*bs_date2)
+    return (ad_date2 - ad_date1).days
+
+def get_current_bs_date():
+    """Get current BS date."""
+    ad_date = datetime.date.today()
+    return ad_to_bs(ad_date)
+
+def get_current_bs_datetime():
+    """Get current BS date and time."""
+    now = datetime.datetime.now()
+    bs_date = ad_to_bs(now.date())
+    return bs_date + (now.hour, now.minute, now.second)
+
+def bs_date_to_ordinal(bs_year, bs_month, bs_day):
+    """Convert BS date to ordinal number."""
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    return ad_date.toordinal()
+
+def ordinal_to_bs_date(ordinal):
+    """Convert ordinal number to BS date."""
+    ad_date = datetime.date.fromordinal(ordinal)
+    return ad_to_bs(ad_date)
+
+def is_leap_year_bs(bs_year):
+    """Check if BS year is a leap year (simplified)."""
+    if bs_year < MIN_BS_YEAR or bs_year > MAX_BS_YEAR:
+        raise ValueError("BS year out of supported range")
+    ad_date = bs_to_ad(bs_year, 1, 1)
+    ad_year = ad_date.year
+    return (ad_year % 4 == 0 and ad_year % 100 != 0) or (ad_year % 400 == 0)
+
+def get_bs_week_number(bs_year, bs_month, bs_day):
+    """Get ISO week number for BS date."""
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    return ad_date.isocalendar()[1]
+
+def get_bs_quarter(bs_month):
+    """Get quarter for BS month."""
+    if 1 <= bs_month <= 3:
+        return 1
+    elif 4 <= bs_month <= 6:
+        return 2
+    elif 7 <= bs_month <= 9:
+        return 3
+    elif 10 <= bs_month <= 12:
+        return 4
+    else:
+        raise ValueError("Invalid BS month")
+
+def get_bs_fiscal_year(bs_year, bs_month):
+    """Get fiscal year for BS date (starts in Ashwin)."""
+    if bs_month >= 7:
+        start_year = bs_year
+        end_year = bs_year + 1
+    else:
+        start_year = bs_year - 1
+        end_year = bs_year
+    return f"{start_year}-{end_year}"
+
+def get_bs_date_components(bs_year, bs_month, bs_day):
+    """Get BS date components as dictionary."""
+    if not is_valid_bs_date(bs_year, bs_month, bs_day):
+        raise ValueError("Invalid BS date")
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    weekday = (ad_date.weekday() + 1) % 7
+    return {
+        "year": bs_year,
+        "month": bs_month,
+        "day": bs_day,
+        "month_name": get_bs_month_name(bs_month),
+        "weekday_name": get_bs_weekday_name(weekday)
+    }
+
+def get_bs_date_range(start_bs_date, end_bs_date):
+    """Generate list of BS dates between two dates."""
+    start_ad_date = bs_to_ad(*start_bs_date)
+    end_ad_date = bs_to_ad(*end_bs_date)
+    if start_ad_date > end_ad_date:
+        raise ValueError("Start date must be before or equal to end date")
+    delta_days = (end_ad_date - start_ad_date).days
+    bs_dates = []
+    for i in range(delta_days + 1):
+        current_ad_date = start_ad_date + datetime.timedelta(days=i)
+        bs_dates.append(ad_to_bs(current_ad_date))
+    return bs_dates
+
+def get_bs_date_from_string(date_string):
+    """Parse BS date from string in various formats."""
+    common_formats = [
+        "%Y-%m-%d",
+        "%Y/%m/%d",
+        "%d-%m-%Y",
+        "%d/%m/%Y",
+    ]
+    for fmt in common_formats:
+        try:
+            return parse_bs_date(date_string, fmt)
+        except ValueError:
+            continue
+    raise ValueError("Date string does not match any known format")
+
+# Timestamp helpers
+def bs_date_to_timestamp(bs_year, bs_month, bs_day):
+    """Convert BS date to Unix timestamp."""
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    return int(datetime.datetime(ad_date.year, ad_date.month, ad_date.day).timestamp())
+
+def timestamp_to_bs_date(ts):
+    """Convert Unix timestamp to BS date."""
+    ad_dt = datetime.datetime.fromtimestamp(ts)
+    return ad_to_bs(ad_dt.date())
+
+def bs_datetime_to_timestamp(bs_year, bs_month, bs_day, hour=0, minute=0, second=0):
+    """Convert BS datetime to Unix timestamp."""
+    ad_date = bs_to_ad(bs_year, bs_month, bs_day)
+    ad_dt = datetime.datetime(ad_date.year, ad_date.month, ad_date.day, hour, minute, second)
+    return int(ad_dt.timestamp())
+
+def timestamp_to_bs_datetime(ts):
+    """Convert Unix timestamp to BS datetime."""
+    ad_dt = datetime.datetime.fromtimestamp(ts)
+    y, m, d = ad_to_bs(ad_dt.date())
+    return (y, m, d, ad_dt.hour, ad_dt.minute, ad_dt.second)
+

bsdatetime/validation.py

@@ -0,0 +1,21 @@
+"""Validation helpers for BS dates."""
+from __future__ import annotations
+from .config import BS_YEARS
+
+__all__ = ["is_valid_bs_date", "get_bs_month_days"]
+
+def is_valid_bs_date(year: int, month: int, day: int) -> bool:
+    """Check if a BS date is valid."""
+    if year not in BS_YEARS:
+        return False
+    if not (1 <= month <= 12):
+        return False
+    if not (1 <= day <= BS_YEARS[year][month - 1]):
+        return False
+    return True
+
+def get_bs_month_days(year: int, month: int) -> int:
+    """Get the number of days in a BS month."""
+    if year in BS_YEARS and 1 <= month <= 12:
+        return BS_YEARS[year][month - 1]
+    raise ValueError("Invalid BS year or month")

bsdatetime-1.0.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: bsdatetime
+Version: 1.0.0
+Summary: Bikram Sambat (Nepali) date/datetime conversion and utilities
+Home-page: https://github.com/Rajendra-Katuwal/bsdatetime
+Author: Rajendra Katuwal
+Author-email: Rajendra Katuwal <raj.katuwal2061@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Rajendra-Katuwal/bsdatetime
+Project-URL: Documentation, https://rajendra-katuwal.github.io/bsdatetime.docs/
+Project-URL: Issues, https://github.com/Rajendra-Katuwal/bsdatetime/issues
+Project-URL: Source, https://github.com/Rajendra-Katuwal/bsdatetime
+Keywords: bikram sambat,nepali,calendar,date,datetime,conversion
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Internationalization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# bsdatetime
+
+Lightweight, dependency‑free Bikram Sambat (Nepali) calendar utilities for Python.
+
+Documentation: https://rajendra-katuwal.github.io/bsdatetime.docs/
+
+## What it does
+* Convert between Gregorian (AD) and Bikram Sambat (BS)
+* Format / parse BS dates (localized month + weekday names)
+* Validate dates, get fiscal year, week number, ranges
+* Provide current BS date/time helpers
+
+## Install
+```bash
+pip install bsdatetime
+```
+
+## Quick start
+```python
+import datetime, bsdatetime as bs
+
+ad = datetime.date(2024, 12, 25)
+bs_tuple = bs.ad_to_bs(ad)          # (2081, 9, 9)
+ad_back = bs.bs_to_ad(*bs_tuple)    # 2024-12-25
+text = bs.format_bs_date(*bs_tuple, "%B %d, %Y")  # भदौ 09, 2081
+current_bs = bs.utils.get_current_bs_date()
+```
+
+Core API (most used)
+* ad_to_bs(date)
+* bs_to_ad(y, m, d)
+* format_bs_date(y, m, d, fmt)
+* parse_bs_date(text, fmt)
+* is_valid_bs_date(y, m, d)
+* utils.get_current_bs_date()
+
+Supported range: BS 1975–2100 (≈ AD 1918–2043)
+
+## Django?
+Use the companion package for model fields:
+```bash
+pip install django-bsdatetime
+```
+
+## License
+MIT

bsdatetime-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+bsdatetime/__init__.py,sha256=sWuzyWMSrr2L9YmIU5SxgMWhsrwq-8mVGBJfeEBaUdQ,960
+bsdatetime/bs_lookup.py,sha256=mLqhdOIwLc_28xqIwd7yGb3oTTyCgS9YKJTZlHiiJ_w,340
+bsdatetime/config.py,sha256=Vh3z8JS8eW_2Effe4T5Apjo-WpWG6pbFd2Vu0H8LPwM,1092
+bsdatetime/conversion.py,sha256=j6nXTqgbFCxa6oReywzkyiXg92aTFJf_Oz5AWvYmaq8,4042
+bsdatetime/formatting.py,sha256=-4KlTRL6t8ZLaih4e0rMkxcFT1HiM81LYrkpIQFaO_0,3601
+bsdatetime/utils.py,sha256=BzQNiFoWk8CnrRRFDxShXUaqtSXz41s76d4jFUpHMRE,7300
+bsdatetime/validation.py,sha256=nm-2wQ3huIPeUFVkVJtn2xENc8bavJJZql0XGzbyElg,709
+bsdatetime-1.0.0.dist-info/licenses/LICENSE,sha256=ZyF1-rB6W4yPWcNMiDCd_vg6t1yXGtmVx5Ewd2f7jMo,1094
+bsdatetime-1.0.0.dist-info/METADATA,sha256=lj8_t_BqJYo2q7l3wwucMcIOfOOaNrSMPC7JcwC6AGw,2638
+bsdatetime-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bsdatetime-1.0.0.dist-info/top_level.txt,sha256=N0jO3BS_m6QK9Cy815lMRFsWspi-IducsC59bE88YaE,11
+bsdatetime-1.0.0.dist-info/RECORD,,

bsdatetime-1.0.0.dist-info/WHEEL

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

bsdatetime-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rajendra Katuwal
+
+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.

bsdatetime-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bsdatetime