ethioqen 0.1.0__tar.gz

ethioqen-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Beabfekad Zikie
+
+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.

ethioqen-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.1
+Name: ethioqen
+Version: 0.1.0
+Summary: A package for Ethiopian date and time conversions
+Home-page: https://github.com/beabzk/ethioqen
+Author: Beabfekad Zikie
+Author-email: Beabfekad Zikie <beabzk@proton.me>
+License: MIT
+Project-URL: Bug Reports, https://github.com/beabzk/ethioqen/issues
+Project-URL: Source, https://github.com/beabzk/ethioqen
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Localization
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# ethioqen: Ethiopian Calendar, Time, and Unix Timestamp Conversion
+
+> ⚠️ **Warning**: This library is in very early stages of development and should not be used in production. Contributions are crucial to make this production-ready.
+
+[![PyPI version](https://badge.fury.io/py/ethioqen.svg)](https://badge.fury.io/py/ethioqen)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build Status](https://github.com/beabzk/ethioqen/actions/workflows/main.yml/badge.svg)](https://github.com/beabzk/ethioqen/actions)
+
+`ethioqen` is a Python library that provides accurate and efficient conversions between the Ethiopian calendar, the Gregorian calendar, Ethiopian local time (12-hour format), standard 24-hour local time, and Unix timestamps.
+
+## Introduction
+
+The Ethiopian calendar is a solar calendar used in Ethiopia and Eritrea. It differs significantly from the Gregorian calendar, which is the most widely used calendar system today.
+
+**Key Differences:**
+
+* **Year Offset:** The Ethiopian calendar is typically 7-8 years behind the Gregorian calendar.
+* **Months:** It has 13 months: 12 months of 30 days each and a 13th month called *Pagume*, which has 5 days (6 days in a leap year).
+* **New Year:** The Ethiopian New Year (*Enkutatash*) falls on September 11th (or 12th in a Gregorian leap year).
+* **Leap Years:** Ethiopia follows a simple 4-year leap year cycle without the century exception found in the Gregorian calendar.
+
+**Ethiopian Local Time:**
+
+Ethiopian time uses a 12-hour clock that starts counting from dawn (around 6:00 AM standard time). This creates a 6-hour offset between Ethiopian and standard time:
+
+* 12:00 AM Ethiopian = 6:00 AM standard time
+* 1:00 AM Ethiopian = 7:00 AM standard time
+* 12:00 PM Ethiopian = 6:00 PM standard time
+* 6:00 PM Ethiopian = 12:00 AM standard time (next day)
+
+## Installation
+
+```bash
+pip install ethioqen
+```
+
+## Usage Examples
+
+### Calendar Conversions
+
+```python
+from ethioqen.calendar_conversion import convert_ethiopian_to_gregorian, convert_gregorian_to_ethiopian
+
+# Convert from Ethiopian to Gregorian
+greg_year, greg_month, greg_day = convert_ethiopian_to_gregorian(2016, 7, 6)
+print(f"{greg_year}-{greg_month}-{greg_day}")  # Output: 2024-3-15
+
+# Convert from Gregorian to Ethiopian
+eth_year, eth_month, eth_day = convert_gregorian_to_ethiopian(2024, 3, 15)
+print(f"{eth_year}-{eth_month}-{eth_day}")  # Output: 2016-7-6
+```
+
+### Time Conversions
+
+```python
+from ethioqen.time_conversion import convert_to_ethiopian_time, convert_from_ethiopian_time
+
+# Convert standard time (14:30 / 2:30 PM) to Ethiopian time
+eth_hour, eth_minute, is_day = convert_to_ethiopian_time(14, 30)
+print(f"{eth_hour}:{eth_minute} {'AM' if is_day else 'PM'}")  # Output: 8:30 PM
+
+# Convert Ethiopian time (8:30 PM) to standard time
+std_hour, std_minute = convert_from_ethiopian_time(8, 30, is_am=False)
+print(f"{std_hour:02d}:{std_minute:02d}")  # Output: 14:30
+```
+
+### Unix Timestamp Conversions
+
+```python
+from ethioqen.unix_time_conversion import ethiopian_to_unix, unix_to_ethiopian
+
+# Convert Ethiopian date/time to Unix timestamp (UTC)
+# 1:30 PM Ethiopian time
+timestamp = ethiopian_to_unix(2016, 7, 6, eth_hour=1, minute=30, is_pm=True)
+print(timestamp)  # Output: Unix timestamp
+
+# Convert Unix timestamp to Ethiopian date/time (UTC)
+eth_year, eth_month, eth_day, hour, minute, is_pm = unix_to_ethiopian(timestamp)
+print(f"{eth_year}-{eth_month}-{eth_day} {hour}:{minute:02d} {'PM' if is_pm else 'AM'}")  
+# Output: 2016-7-6 1:30 PM
+```
+
+### Timezone Support
+
+```python
+from ethioqen.unix_time_conversion import ethiopian_to_unix, unix_to_ethiopian
+
+# Convert with timezone offset (UTC+3 for Ethiopia)
+# 8:30 AM Ethiopian time
+timestamp = ethiopian_to_unix(2016, 7, 6, eth_hour=8, minute=30, is_pm=False, tz_offset=3)
+print(timestamp)  # Output: Unix timestamp adjusted for UTC+3
+
+# Convert back with timezone offset
+eth_date = unix_to_ethiopian(timestamp, tz_offset=3)
+print(f"{eth_date[0]}-{eth_date[1]}-{eth_date[2]} {eth_date[3]}:{eth_date[4]:02d} {'PM' if eth_date[5] else 'AM'}")  
+# Output: Ethiopian date/time in UTC+3
+```
+
+## Contributing
+
+We welcome contributions! Here's how you can help:
+
+1. **Report Bugs**
+   * Open an issue in the [GitHub issue tracker](https://github.com/beabzk/ethioqen/issues)
+   * Include a clear description and steps to reproduce
+
+2. **Submit Pull Requests**
+   * Fork the repository
+   * Create a new branch for your feature (`git checkout -b feature/amazing-feature`)
+   * Make your changes
+   * Write or update tests as needed
+   * Update documentation if necessary
+   * Submit a pull request
+
+3. **Coding Style**
+   * Follow PEP 8 guidelines
+   * Include docstrings for new functions/classes
+   * Add type hints where possible
+
+4. **Testing**
+   * Run the test suite: `pytest`
+   * Add tests for new features
+   * Ensure all tests pass before submitting
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

ethioqen-0.1.0/README.md

@@ -0,0 +1,127 @@
+# ethioqen: Ethiopian Calendar, Time, and Unix Timestamp Conversion
+
+> ⚠️ **Warning**: This library is in very early stages of development and should not be used in production. Contributions are crucial to make this production-ready.
+
+[![PyPI version](https://badge.fury.io/py/ethioqen.svg)](https://badge.fury.io/py/ethioqen)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build Status](https://github.com/beabzk/ethioqen/actions/workflows/main.yml/badge.svg)](https://github.com/beabzk/ethioqen/actions)
+
+`ethioqen` is a Python library that provides accurate and efficient conversions between the Ethiopian calendar, the Gregorian calendar, Ethiopian local time (12-hour format), standard 24-hour local time, and Unix timestamps.
+
+## Introduction
+
+The Ethiopian calendar is a solar calendar used in Ethiopia and Eritrea. It differs significantly from the Gregorian calendar, which is the most widely used calendar system today.
+
+**Key Differences:**
+
+* **Year Offset:** The Ethiopian calendar is typically 7-8 years behind the Gregorian calendar.
+* **Months:** It has 13 months: 12 months of 30 days each and a 13th month called *Pagume*, which has 5 days (6 days in a leap year).
+* **New Year:** The Ethiopian New Year (*Enkutatash*) falls on September 11th (or 12th in a Gregorian leap year).
+* **Leap Years:** Ethiopia follows a simple 4-year leap year cycle without the century exception found in the Gregorian calendar.
+
+**Ethiopian Local Time:**
+
+Ethiopian time uses a 12-hour clock that starts counting from dawn (around 6:00 AM standard time). This creates a 6-hour offset between Ethiopian and standard time:
+
+* 12:00 AM Ethiopian = 6:00 AM standard time
+* 1:00 AM Ethiopian = 7:00 AM standard time
+* 12:00 PM Ethiopian = 6:00 PM standard time
+* 6:00 PM Ethiopian = 12:00 AM standard time (next day)
+
+## Installation
+
+```bash
+pip install ethioqen
+```
+
+## Usage Examples
+
+### Calendar Conversions
+
+```python
+from ethioqen.calendar_conversion import convert_ethiopian_to_gregorian, convert_gregorian_to_ethiopian
+
+# Convert from Ethiopian to Gregorian
+greg_year, greg_month, greg_day = convert_ethiopian_to_gregorian(2016, 7, 6)
+print(f"{greg_year}-{greg_month}-{greg_day}")  # Output: 2024-3-15
+
+# Convert from Gregorian to Ethiopian
+eth_year, eth_month, eth_day = convert_gregorian_to_ethiopian(2024, 3, 15)
+print(f"{eth_year}-{eth_month}-{eth_day}")  # Output: 2016-7-6
+```
+
+### Time Conversions
+
+```python
+from ethioqen.time_conversion import convert_to_ethiopian_time, convert_from_ethiopian_time
+
+# Convert standard time (14:30 / 2:30 PM) to Ethiopian time
+eth_hour, eth_minute, is_day = convert_to_ethiopian_time(14, 30)
+print(f"{eth_hour}:{eth_minute} {'AM' if is_day else 'PM'}")  # Output: 8:30 PM
+
+# Convert Ethiopian time (8:30 PM) to standard time
+std_hour, std_minute = convert_from_ethiopian_time(8, 30, is_am=False)
+print(f"{std_hour:02d}:{std_minute:02d}")  # Output: 14:30
+```
+
+### Unix Timestamp Conversions
+
+```python
+from ethioqen.unix_time_conversion import ethiopian_to_unix, unix_to_ethiopian
+
+# Convert Ethiopian date/time to Unix timestamp (UTC)
+# 1:30 PM Ethiopian time
+timestamp = ethiopian_to_unix(2016, 7, 6, eth_hour=1, minute=30, is_pm=True)
+print(timestamp)  # Output: Unix timestamp
+
+# Convert Unix timestamp to Ethiopian date/time (UTC)
+eth_year, eth_month, eth_day, hour, minute, is_pm = unix_to_ethiopian(timestamp)
+print(f"{eth_year}-{eth_month}-{eth_day} {hour}:{minute:02d} {'PM' if is_pm else 'AM'}")  
+# Output: 2016-7-6 1:30 PM
+```
+
+### Timezone Support
+
+```python
+from ethioqen.unix_time_conversion import ethiopian_to_unix, unix_to_ethiopian
+
+# Convert with timezone offset (UTC+3 for Ethiopia)
+# 8:30 AM Ethiopian time
+timestamp = ethiopian_to_unix(2016, 7, 6, eth_hour=8, minute=30, is_pm=False, tz_offset=3)
+print(timestamp)  # Output: Unix timestamp adjusted for UTC+3
+
+# Convert back with timezone offset
+eth_date = unix_to_ethiopian(timestamp, tz_offset=3)
+print(f"{eth_date[0]}-{eth_date[1]}-{eth_date[2]} {eth_date[3]}:{eth_date[4]:02d} {'PM' if eth_date[5] else 'AM'}")  
+# Output: Ethiopian date/time in UTC+3
+```
+
+## Contributing
+
+We welcome contributions! Here's how you can help:
+
+1. **Report Bugs**
+   * Open an issue in the [GitHub issue tracker](https://github.com/beabzk/ethioqen/issues)
+   * Include a clear description and steps to reproduce
+
+2. **Submit Pull Requests**
+   * Fork the repository
+   * Create a new branch for your feature (`git checkout -b feature/amazing-feature`)
+   * Make your changes
+   * Write or update tests as needed
+   * Update documentation if necessary
+   * Submit a pull request
+
+3. **Coding Style**
+   * Follow PEP 8 guidelines
+   * Include docstrings for new functions/classes
+   * Add type hints where possible
+
+4. **Testing**
+   * Run the test suite: `pytest`
+   * Add tests for new features
+   * Ensure all tests pass before submitting
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

ethioqen-0.1.0/ethioqen/__init__.py

@@ -0,0 +1,4 @@
+"""
+Package initialization for ethioqen.
+"""
+__version__ = "0.1.0"

ethioqen-0.1.0/ethioqen/calendar_conversion.py

@@ -0,0 +1,111 @@
+from .exceptions import InvalidDateException
+from .utils import is_valid_ethiopian_date, DAYS_IN_ETH_MONTH
+
+def is_ethiopian_leap_year(year):
+    return year % 4 == 3
+
+def is_gregorian_leap_year(year):
+    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
+
+def _ethiopian_to_jdn(year, month, day):
+    """Convert Ethiopian date to Julian Day Number."""
+    if not is_valid_ethiopian_date(year, month, day):
+        raise InvalidDateException(f"Invalid Ethiopian date: {year}-{month}-{day}")
+    
+    ethiopian_epoch = 1723856
+    year_days = (year * 365) + (year // 4)
+    month_days = (month - 1) * 30
+    
+    return ethiopian_epoch + year_days + month_days + day - 1
+
+def _jdn_to_ethiopian(jdn):
+    """Convert Julian Day Number to Ethiopian date."""
+    ethiopian_epoch = 1723856
+    days_since_epoch = jdn - ethiopian_epoch
+
+    # Calculate initial year estimate
+    year = int((days_since_epoch - 0.25) // 365.25)
+    
+    # Calculate remaining days
+    year_days = year * 365 + year // 4
+    remaining_days = days_since_epoch - year_days
+    
+    # If we're past the end of the year, increment
+    if remaining_days >= 366 or (remaining_days >= 365 and not is_ethiopian_leap_year(year)):
+        year += 1
+        year_days = year * 365 + year // 4
+        remaining_days = days_since_epoch - year_days
+    
+    # Calculate month and day
+    month = int(remaining_days // 30) + 1
+    day = int(remaining_days % 30) + 1
+    
+    # Handle pagume
+    if month > 13:
+        month = 13
+        day = remaining_days - 360 + 1
+        
+    # Handle year transitions
+    max_pagume_days = 6 if is_ethiopian_leap_year(year) else 5
+    if month == 13 and day > max_pagume_days:
+        year += 1
+        month = 1
+        day = day - max_pagume_days
+    
+    return int(year), int(month), int(day)
+
+def _gregorian_to_jdn(year, month, day):
+    """Convert Gregorian date to Julian Day Number."""
+    if month <= 2:
+        year -= 1
+        month += 12
+    
+    a = year // 100
+    b = 2 - a + (a // 4)
+    
+    jdn = int(365.25 * (year + 4716)) + int(30.6001 * (month + 1)) + day + b - 1524
+    return jdn
+
+def _jdn_to_gregorian(jdn):
+    """Convert Julian Day Number to Gregorian date."""
+    y = 4716
+    j = 1401
+    m = 2
+    n = 12
+    r = 4
+    p = 1461
+    v = 3
+    u = 5
+    s = 153
+    w = 2
+    B = 274277
+    C = -38
+
+    f = jdn + j + (((4 * jdn + B) // 146097) * 3) // 4 + C
+    e = r * f + v
+    g = (e % p) // r
+    h = u * g + w
+    
+    day = (h % s) // u + 1
+    month = ((h // s + m) % n) + 1
+    year = (e // p) - y + (n + m - month) // n
+    
+    return year, month, day
+
+def convert_ethiopian_to_gregorian(eth_year, eth_month, eth_day):
+    """Convert an Ethiopian date to Gregorian."""
+    if not is_valid_ethiopian_date(eth_year, eth_month, eth_day):
+        raise InvalidDateException(f"Invalid Ethiopian date: {eth_year}-{eth_month}-{eth_day}")
+    
+    jdn = _ethiopian_to_jdn(eth_year, eth_month, eth_day)
+    return _jdn_to_gregorian(jdn)
+
+def convert_gregorian_to_ethiopian(greg_year, greg_month, greg_day):
+    """Convert a Gregorian date to Ethiopian."""
+    if greg_month < 1 or greg_month > 12:
+        raise InvalidDateException(f"Invalid Gregorian month: {greg_month}")
+    if greg_day < 1 or greg_day > 31:
+        raise InvalidDateException(f"Invalid Gregorian day: {greg_day}")
+        
+    jdn = _gregorian_to_jdn(greg_year, greg_month, greg_day)
+    return _jdn_to_ethiopian(jdn)

ethioqen-0.1.0/ethioqen/exceptions.py

@@ -0,0 +1,5 @@
+class InvalidDateException(Exception):
+    pass
+
+class InvalidTimeException(Exception):
+    pass

ethioqen-0.1.0/ethioqen/time_conversion.py

@@ -0,0 +1,43 @@
+from .exceptions import InvalidTimeException
+from .utils import is_valid_eth_time, is_valid_time
+
+def convert_to_ethiopian_time(hour, minute, period=None):
+    """Convert 24-hour time to Ethiopian time."""
+    if not is_valid_time(hour, minute):
+        raise InvalidTimeException(f"Invalid time: {hour}:{minute}")
+
+    # Handle 12-hour format with AM/PM
+    if period:
+        if period.upper() not in ["AM", "PM"]:
+            raise InvalidTimeException("Period must be 'AM' or 'PM'")
+        if period.upper() == "PM" and hour != 12:
+            hour += 12
+        elif period.upper() == "AM" and hour == 12:
+            hour = 0
+
+    # Ethiopian time starts 6 hours before standard time
+    eth_hour = (hour - 6) % 12
+    if eth_hour == 0:
+        eth_hour = 12
+        
+    # Determine if it's morning/day (AM) or evening/night (PM)
+    is_am = 6 <= hour < 18
+
+    return eth_hour, minute, is_am
+
+def convert_from_ethiopian_time(eth_hour, minute, is_am=True):
+    """Convert Ethiopian time to 24-hour time."""
+    if not (1 <= eth_hour <= 12) or not (0 <= minute <= 59):
+        raise InvalidTimeException(f"Invalid Ethiopian time: {eth_hour}:{minute}")
+
+    # Convert Ethiopian time to 24-hour format
+    std_hour = eth_hour % 12  # Convert 12 to 0
+    
+    # Add 6 hours to align with standard time
+    std_hour = (std_hour + 6) % 24
+    
+    # Adjust for AM/PM
+    if not is_am:
+        std_hour = (std_hour + 12) % 24
+        
+    return std_hour, minute

ethioqen-0.1.0/ethioqen/unix_time_conversion.py

@@ -0,0 +1,104 @@
+from datetime import datetime, timezone, timedelta
+from .calendar_conversion import convert_ethiopian_to_gregorian, convert_gregorian_to_ethiopian
+from .exceptions import InvalidDateException
+from .utils import is_valid_ethiopian_date
+
+def _convert_ethiopian_to_24h(hour, is_pm):
+    """Convert Ethiopian 12-hour time to 24-hour format.
+    
+    In Ethiopian time:
+    - Day starts at 12:00 AM (6:00 AM standard)
+    - 1:00 AM = 7:00 AM standard = 7 in 24h
+    - 12:00 PM = 6:00 PM standard = 18 in 24h
+    - 1:00 PM = 7:00 PM standard = 19 in 24h
+    """
+    if hour < 1 or hour > 12:
+        raise InvalidDateException(f"Invalid Ethiopian hour: {hour}")
+        
+    if hour == 12:
+        hour = 0
+        
+    if is_pm:
+        hour += 12
+        
+    # Add 6 hours to align with standard time
+    hour = (hour + 6) % 24
+    return hour
+
+def _convert_24h_to_ethiopian(hour):
+    """Convert 24-hour time to Ethiopian 12-hour format.
+    
+    Returns:
+        tuple: (hour in 1-12 format, is_pm boolean)
+    """
+    # Subtract 6 hours to align with Ethiopian time
+    eth_hour = (hour - 6) % 24
+    
+    # Convert to 12-hour format
+    is_pm = eth_hour >= 12
+    if is_pm:
+        eth_hour -= 12
+    
+    if eth_hour == 0:
+        eth_hour = 12
+        
+    return eth_hour, is_pm
+
+def ethiopian_to_unix(e_year, e_month, e_day, eth_hour=12, minute=0, is_pm=False, tz_offset=0):
+    """Convert Ethiopian date/time to Unix timestamp.
+    
+    Args:
+        e_year (int): Ethiopian year
+        e_month (int): Ethiopian month (1-13)
+        e_day (int): Ethiopian day
+        eth_hour (int, optional): Hour in Ethiopian 12-hour time (1-12). Defaults to 12.
+        minute (int, optional): Minutes (0-59). Defaults to 0.
+        is_pm (bool, optional): Whether the time is PM. Defaults to False.
+        tz_offset (int, optional): Timezone offset in hours. Defaults to 0 (UTC).
+    
+    Returns:
+        int: Unix timestamp (seconds since Unix epoch)
+    """
+    if not is_valid_ethiopian_date(e_year, e_month, e_day):
+        raise InvalidDateException(f"Invalid Ethiopian date: {e_year}-{e_month}-{e_day}")
+    if not (0 <= minute <= 59):
+        raise InvalidDateException(f"Invalid minute: {minute}")
+    
+    # Convert Ethiopian 12-hour time to 24-hour time
+    hour_24 = _convert_ethiopian_to_24h(eth_hour, is_pm)
+    
+    # Convert to Gregorian and create timestamp
+    g_year, g_month, g_day = convert_ethiopian_to_gregorian(e_year, e_month, e_day)
+    try:
+        dt = datetime(g_year, g_month, g_day, hour_24, minute, 
+                     tzinfo=timezone(timedelta(hours=tz_offset)))
+        return int(dt.timestamp())
+    except ValueError as e:
+        raise InvalidDateException(str(e))
+
+def unix_to_ethiopian(timestamp, tz_offset=0):
+    """Convert Unix timestamp to Ethiopian date/time.
+    
+    Args:
+        timestamp (int): Unix timestamp (seconds since Unix epoch)
+        tz_offset (int, optional): Timezone offset in hours. Defaults to 0 (UTC).
+    
+    Returns:
+        tuple: (year, month, day, hour, minute, is_pm)
+            hour will be in 12-hour format (1-12)
+            is_pm indicates whether the time is PM
+    """
+    try:
+        dt = datetime.fromtimestamp(timestamp, 
+                                  tz=timezone(timedelta(hours=tz_offset)))
+    except (ValueError, OSError) as e:
+        raise InvalidDateException(f"Invalid timestamp: {timestamp}")
+    
+    # Convert to Ethiopian date
+    e_year, e_month, e_day = convert_gregorian_to_ethiopian(
+        dt.year, dt.month, dt.day)
+    
+    # Convert 24-hour time to Ethiopian 12-hour time
+    eth_hour, is_pm = _convert_24h_to_ethiopian(dt.hour)
+    
+    return e_year, e_month, e_day, eth_hour, dt.minute, is_pm

ethioqen-0.1.0/ethioqen/utils.py

@@ -0,0 +1,49 @@
+# Constants
+DAYS_IN_ETH_MONTH = 30
+MONTHS_IN_ETH_YEAR = 13
+
+# Month lengths - most Ethiopian months have 30 days, except Pagume which has 5 or 6
+ETH_MONTH_LENGTHS = {
+    1: 30, 2: 30, 3: 30, 4: 30, 5: 30, 6: 30,
+    7: 30, 8: 30, 9: 30, 10: 30, 11: 30, 12: 30,
+    13: 5  # Will be 6 in leap years
+}
+
+# Time constants
+HOURS_IN_DAY = 24
+MINUTES_IN_HOUR = 60
+ETH_HOURS_IN_KENTR = 4  # Ethiopian hours in one quarter day (kentr)
+ETH_HOURS_IN_KENTR = 6  # Ethiopian hours in one sixth day
+
+def is_valid_ethiopian_date(year, month, day):
+    """Check if the given Ethiopian date is valid."""
+    if month < 1 or month > MONTHS_IN_ETH_YEAR:
+        return False
+        
+    if month == 13:
+        max_days = 6 if is_ethiopian_leap_year(year) else 5
+        if day < 1 or day > max_days:
+            return False
+    else:
+        if day < 1 or day > DAYS_IN_ETH_MONTH:
+            return False
+            
+    return True
+
+def is_ethiopian_leap_year(year):
+    """Determine if the given Ethiopian year is a leap year."""
+    return year % 4 == 3
+
+def get_ethiopian_month_length(year, month):
+    """Get the length of a given Ethiopian month in a specific year."""
+    if month == 13:
+        return 6 if is_ethiopian_leap_year(year) else 5
+    return DAYS_IN_ETH_MONTH
+
+def is_valid_eth_time(hour, minute):
+    """Validate Ethiopian time."""
+    return 0 <= hour < HOURS_IN_DAY and 0 <= minute < MINUTES_IN_HOUR
+
+def is_valid_time(hour, minute):
+    """Validate standard 24-hour time."""
+    return 0 <= hour < HOURS_IN_DAY and 0 <= minute < MINUTES_IN_HOUR

ethioqen-0.1.0/ethioqen.egg-info/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.1
+Name: ethioqen
+Version: 0.1.0
+Summary: A package for Ethiopian date and time conversions
+Home-page: https://github.com/beabzk/ethioqen
+Author: Beabfekad Zikie
+Author-email: Beabfekad Zikie <beabzk@proton.me>
+License: MIT
+Project-URL: Bug Reports, https://github.com/beabzk/ethioqen/issues
+Project-URL: Source, https://github.com/beabzk/ethioqen
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Localization
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# ethioqen: Ethiopian Calendar, Time, and Unix Timestamp Conversion
+
+> ⚠️ **Warning**: This library is in very early stages of development and should not be used in production. Contributions are crucial to make this production-ready.
+
+[![PyPI version](https://badge.fury.io/py/ethioqen.svg)](https://badge.fury.io/py/ethioqen)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build Status](https://github.com/beabzk/ethioqen/actions/workflows/main.yml/badge.svg)](https://github.com/beabzk/ethioqen/actions)
+
+`ethioqen` is a Python library that provides accurate and efficient conversions between the Ethiopian calendar, the Gregorian calendar, Ethiopian local time (12-hour format), standard 24-hour local time, and Unix timestamps.
+
+## Introduction
+
+The Ethiopian calendar is a solar calendar used in Ethiopia and Eritrea. It differs significantly from the Gregorian calendar, which is the most widely used calendar system today.
+
+**Key Differences:**
+
+* **Year Offset:** The Ethiopian calendar is typically 7-8 years behind the Gregorian calendar.
+* **Months:** It has 13 months: 12 months of 30 days each and a 13th month called *Pagume*, which has 5 days (6 days in a leap year).
+* **New Year:** The Ethiopian New Year (*Enkutatash*) falls on September 11th (or 12th in a Gregorian leap year).
+* **Leap Years:** Ethiopia follows a simple 4-year leap year cycle without the century exception found in the Gregorian calendar.
+
+**Ethiopian Local Time:**
+
+Ethiopian time uses a 12-hour clock that starts counting from dawn (around 6:00 AM standard time). This creates a 6-hour offset between Ethiopian and standard time:
+
+* 12:00 AM Ethiopian = 6:00 AM standard time
+* 1:00 AM Ethiopian = 7:00 AM standard time
+* 12:00 PM Ethiopian = 6:00 PM standard time
+* 6:00 PM Ethiopian = 12:00 AM standard time (next day)
+
+## Installation
+
+```bash
+pip install ethioqen
+```
+
+## Usage Examples
+
+### Calendar Conversions
+
+```python
+from ethioqen.calendar_conversion import convert_ethiopian_to_gregorian, convert_gregorian_to_ethiopian
+
+# Convert from Ethiopian to Gregorian
+greg_year, greg_month, greg_day = convert_ethiopian_to_gregorian(2016, 7, 6)
+print(f"{greg_year}-{greg_month}-{greg_day}")  # Output: 2024-3-15
+
+# Convert from Gregorian to Ethiopian
+eth_year, eth_month, eth_day = convert_gregorian_to_ethiopian(2024, 3, 15)
+print(f"{eth_year}-{eth_month}-{eth_day}")  # Output: 2016-7-6
+```
+
+### Time Conversions
+
+```python
+from ethioqen.time_conversion import convert_to_ethiopian_time, convert_from_ethiopian_time
+
+# Convert standard time (14:30 / 2:30 PM) to Ethiopian time
+eth_hour, eth_minute, is_day = convert_to_ethiopian_time(14, 30)
+print(f"{eth_hour}:{eth_minute} {'AM' if is_day else 'PM'}")  # Output: 8:30 PM
+
+# Convert Ethiopian time (8:30 PM) to standard time
+std_hour, std_minute = convert_from_ethiopian_time(8, 30, is_am=False)
+print(f"{std_hour:02d}:{std_minute:02d}")  # Output: 14:30
+```
+
+### Unix Timestamp Conversions
+
+```python
+from ethioqen.unix_time_conversion import ethiopian_to_unix, unix_to_ethiopian
+
+# Convert Ethiopian date/time to Unix timestamp (UTC)
+# 1:30 PM Ethiopian time
+timestamp = ethiopian_to_unix(2016, 7, 6, eth_hour=1, minute=30, is_pm=True)
+print(timestamp)  # Output: Unix timestamp
+
+# Convert Unix timestamp to Ethiopian date/time (UTC)
+eth_year, eth_month, eth_day, hour, minute, is_pm = unix_to_ethiopian(timestamp)
+print(f"{eth_year}-{eth_month}-{eth_day} {hour}:{minute:02d} {'PM' if is_pm else 'AM'}")  
+# Output: 2016-7-6 1:30 PM
+```
+
+### Timezone Support
+
+```python
+from ethioqen.unix_time_conversion import ethiopian_to_unix, unix_to_ethiopian
+
+# Convert with timezone offset (UTC+3 for Ethiopia)
+# 8:30 AM Ethiopian time
+timestamp = ethiopian_to_unix(2016, 7, 6, eth_hour=8, minute=30, is_pm=False, tz_offset=3)
+print(timestamp)  # Output: Unix timestamp adjusted for UTC+3
+
+# Convert back with timezone offset
+eth_date = unix_to_ethiopian(timestamp, tz_offset=3)
+print(f"{eth_date[0]}-{eth_date[1]}-{eth_date[2]} {eth_date[3]}:{eth_date[4]:02d} {'PM' if eth_date[5] else 'AM'}")  
+# Output: Ethiopian date/time in UTC+3
+```
+
+## Contributing
+
+We welcome contributions! Here's how you can help:
+
+1. **Report Bugs**
+   * Open an issue in the [GitHub issue tracker](https://github.com/beabzk/ethioqen/issues)
+   * Include a clear description and steps to reproduce
+
+2. **Submit Pull Requests**
+   * Fork the repository
+   * Create a new branch for your feature (`git checkout -b feature/amazing-feature`)
+   * Make your changes
+   * Write or update tests as needed
+   * Update documentation if necessary
+   * Submit a pull request
+
+3. **Coding Style**
+   * Follow PEP 8 guidelines
+   * Include docstrings for new functions/classes
+   * Add type hints where possible
+
+4. **Testing**
+   * Run the test suite: `pytest`
+   * Add tests for new features
+   * Ensure all tests pass before submitting
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

ethioqen-0.1.0/ethioqen.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+ethioqen/__init__.py
+ethioqen/calendar_conversion.py
+ethioqen/exceptions.py
+ethioqen/time_conversion.py
+ethioqen/unix_time_conversion.py
+ethioqen/utils.py
+ethioqen.egg-info/PKG-INFO
+ethioqen.egg-info/SOURCES.txt
+ethioqen.egg-info/dependency_links.txt
+ethioqen.egg-info/top_level.txt
+tests/test_calendar_conversion.py
+tests/test_time_conversion.py
+tests/test_unix_time_conversion.py

ethioqen-0.1.0/ethioqen.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ethioqen-0.1.0/ethioqen.egg-info/top_level.txt

@@ -0,0 +1 @@
+ethioqen

ethioqen-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ethioqen"
+version = "0.1.0"
+description = "A package for Ethiopian date and time conversions"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Beabfekad Zikie", email = "beabzk@proton.me"}
+]
+classifiers=[
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+     "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Localization",
+]
+
+[project.urls]
+"Bug Reports" = "https://github.com/beabzk/ethioqen/issues"
+"Source" = "https://github.com/beabzk/ethioqen"

ethioqen-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ethioqen-0.1.0/setup.py

@@ -0,0 +1,36 @@
+from setuptools import setup, find_packages
+import pathlib
+
+here = pathlib.Path(__file__).parent.resolve()
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="ethioqen",
+    version="0.1.0",
+    author="Beabfekad Zikie",
+    author_email="beabzk@proton.me",
+    description="A package for Ethiopian date and time conversions",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/beabzk/ethioqen",
+    packages=find_packages(),
+    license="MIT",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Software Development :: Localization",
+    ],
+    python_requires=">=3.8",
+    project_urls={
+        "Bug Reports": "https://github.com/beabzk/ethioqen/issues",
+        "Source": "https://github.com/beabzk/ethioqen",
+    },
+)

ethioqen-0.1.0/tests/test_calendar_conversion.py

@@ -0,0 +1,105 @@
+import pytest
+from ethioqen.calendar_conversion import (
+    convert_ethiopian_to_gregorian,
+    convert_gregorian_to_ethiopian,
+    is_ethiopian_leap_year,
+    is_gregorian_leap_year
+)
+from ethioqen.exceptions import InvalidDateException
+
+def test_ethiopian_leap_year():
+    """Test Ethiopian leap year calculation."""
+    assert is_ethiopian_leap_year(2015) == True   # 2015 E.C. is a leap year
+    assert is_ethiopian_leap_year(2016) == False  # 2016 E.C. is not a leap year
+    assert is_ethiopian_leap_year(2019) == True   # 2019 E.C. is a leap year
+
+def test_gregorian_leap_year():
+    """Test Gregorian leap year calculation."""
+    assert is_gregorian_leap_year(2020) == True   # 2020-01-01 is start of a leap year
+    assert is_gregorian_leap_year(2021) == False  # 2021-01-01 is not a leap year
+    assert is_gregorian_leap_year(2000) == True   # 2000-01-01 is a leap year (divisible by 400)
+    assert is_gregorian_leap_year(1900) == False  # 1900-01-01 is not a leap year (divisible by 100 but not 400)
+
+def test_ethiopian_to_gregorian():
+    """Test conversion from Ethiopian to Gregorian calendar."""
+    # Test some known dates
+    assert convert_ethiopian_to_gregorian(2015, 1, 1) == (2022, 9, 11)  # Ethiopian New Year
+    assert convert_ethiopian_to_gregorian(2015, 13, 6) == (2023, 9, 11)  # Last day of 2015 (leap year)
+    assert convert_ethiopian_to_gregorian(2015, 5, 1) == (2023, 1, 9)    # Regular date
+
+def test_ethiopian_to_gregorian_year_boundaries():
+    """Test Ethiopian to Gregorian conversion around year boundaries."""
+    # Year end tests (Pagume)
+    assert convert_ethiopian_to_gregorian(2015, 13, 1) == (2023, 9, 6)    # Start of Pagume 2015
+    assert convert_ethiopian_to_gregorian(2015, 13, 2) == (2023, 9, 7)    # Pagume 2
+    assert convert_ethiopian_to_gregorian(2015, 13, 3) == (2023, 9, 8)    # Pagume 3
+    assert convert_ethiopian_to_gregorian(2015, 13, 4) == (2023, 9, 9)    # Pagume 4
+    assert convert_ethiopian_to_gregorian(2015, 13, 5) == (2023, 9, 10)   # Pagume 5
+    assert convert_ethiopian_to_gregorian(2015, 13, 6) == (2023, 9, 11)   # Last day of 2015 (leap)
+    
+    # Year start tests (Meskerem)
+    assert convert_ethiopian_to_gregorian(2016, 1, 1) == (2023, 9, 12)    # New Year 2016
+    assert convert_ethiopian_to_gregorian(2016, 1, 2) == (2023, 9, 13)    # Meskerem 2
+    assert convert_ethiopian_to_gregorian(2016, 1, 3) == (2023, 9, 14)    # Meskerem 3
+    assert convert_ethiopian_to_gregorian(2016, 1, 4) == (2023, 9, 15)    # Meskerem 4
+    assert convert_ethiopian_to_gregorian(2016, 1, 5) == (2023, 9, 16)    # Meskerem 5
+
+    # Previous year tests
+    assert convert_ethiopian_to_gregorian(2014, 13, 1) == (2022, 9, 6)    # Start of Pagume 2014
+    assert convert_ethiopian_to_gregorian(2014, 13, 5) == (2022, 9, 10)   # Last day of 2014 (non-leap)
+    assert convert_ethiopian_to_gregorian(2015, 1, 1) == (2022, 9, 11)    # New Year 2015
+
+def test_gregorian_to_ethiopian():
+    """Test conversion from Gregorian to Ethiopian calendar."""
+    # Year end tests (different from eth_to_greg tests)
+    assert convert_gregorian_to_ethiopian(2023, 9, 6) == (2015, 13, 1)    # Start of Pagume
+    assert convert_gregorian_to_ethiopian(2023, 9, 7) == (2015, 13, 2)    # Pagume 2
+    assert convert_gregorian_to_ethiopian(2023, 9, 8) == (2015, 13, 3)    # Pagume 3
+    assert convert_gregorian_to_ethiopian(2023, 9, 9) == (2015, 13, 4)    # Pagume 4
+    assert convert_gregorian_to_ethiopian(2023, 9, 10) == (2015, 13, 5)   # Pagume 5
+    assert convert_gregorian_to_ethiopian(2023, 9, 11) == (2015, 13, 6)   # Last day of 2015
+
+    # Year start tests
+    assert convert_gregorian_to_ethiopian(2023, 9, 12) == (2016, 1, 1)    # Ethiopian New Year
+    assert convert_gregorian_to_ethiopian(2023, 9, 13) == (2016, 1, 2)    # Meskerem 2
+    assert convert_gregorian_to_ethiopian(2023, 9, 14) == (2016, 1, 3)    # Meskerem 3
+    assert convert_gregorian_to_ethiopian(2023, 9, 15) == (2016, 1, 4)    # Meskerem 4
+    assert convert_gregorian_to_ethiopian(2023, 9, 16) == (2016, 1, 5)    # Meskerem 5
+
+    # Previous year boundary
+    assert convert_gregorian_to_ethiopian(2022, 9, 6) == (2014, 13, 1)    # Start of Pagume 2014
+    assert convert_gregorian_to_ethiopian(2022, 9, 10) == (2014, 13, 5)   # Last day of 2014
+    assert convert_gregorian_to_ethiopian(2022, 9, 11) == (2015, 1, 1)    # Start of 2015
+
+def test_invalid_dates():
+    """Test handling of invalid dates."""
+    # Test invalid Ethiopian month
+    with pytest.raises(InvalidDateException):
+        convert_ethiopian_to_gregorian(2015, 14, 1)
+    
+    # Test invalid Ethiopian day
+    with pytest.raises(InvalidDateException):
+        convert_ethiopian_to_gregorian(2015, 1, 31)
+    
+    # Test invalid Pagume day in non-leap year
+    with pytest.raises(InvalidDateException):
+        convert_ethiopian_to_gregorian(2016, 13, 6)  # 2016 E.C. is not a leap year
+
+def test_round_trip_conversion():
+    """Test converting dates back and forth."""
+    # Test several dates to ensure they convert back correctly
+    test_dates = [
+        (2015, 1, 1),    # Ethiopian New Year
+        (2015, 7, 15),   # Middle of the year
+        (2015, 13, 5),   # Pagume 5
+        (2015, 13, 6),   # Pagume 6 (leap year)
+        (2016, 1, 1),    # New Year after leap year
+    ]
+    
+    for eth_year, eth_month, eth_day in test_dates:
+        # Convert to Gregorian
+        greg_year, greg_month, greg_day = convert_ethiopian_to_gregorian(eth_year, eth_month, eth_day)
+        # Convert back to Ethiopian
+        eth_year2, eth_month2, eth_day2 = convert_gregorian_to_ethiopian(greg_year, greg_month, greg_day)
+        # Should get the original date back
+        assert (eth_year, eth_month, eth_day) == (eth_year2, eth_month2, eth_day2)

ethioqen-0.1.0/tests/test_time_conversion.py

@@ -0,0 +1,83 @@
+import pytest
+from ethioqen.time_conversion import convert_to_ethiopian_time, convert_from_ethiopian_time
+from ethioqen.exceptions import InvalidTimeException
+
+def test_standard_to_ethiopian():
+    """Test key Ethiopian time conversions."""
+    # Morning/Day hours
+    assert convert_to_ethiopian_time(6, 0) == (12, 0, True)   # 6:00 AM -> 12:00 AM ET
+    assert convert_to_ethiopian_time(7, 0) == (1, 0, True)    # 7:00 AM -> 1:00 AM ET
+    assert convert_to_ethiopian_time(12, 0) == (6, 0, True)   # 12:00 PM -> 6:00 AM ET
+    
+    # Evening/Night hours
+    assert convert_to_ethiopian_time(18, 0) == (12, 0, False) # 6:00 PM -> 12:00 PM ET
+    assert convert_to_ethiopian_time(19, 0) == (1, 0, False)  # 7:00 PM -> 1:00 PM ET
+    assert convert_to_ethiopian_time(0, 0) == (6, 0, False)   # 12:00 AM -> 6:00 PM ET
+    assert convert_to_ethiopian_time(3, 0) == (9, 0, False)   # 3:00 AM -> 9:00 PM ET
+
+def test_ethiopian_to_standard():
+    """Test key standard time conversions."""
+    # Morning/Day hours (is_am=True)
+    assert convert_from_ethiopian_time(12, 0, True) == (6, 0)  # 12:00 AM ET -> 6:00 AM
+    assert convert_from_ethiopian_time(1, 0, True) == (7, 0)   # 1:00 AM ET -> 7:00 AM
+    assert convert_from_ethiopian_time(6, 0, True) == (12, 0)  # 6:00 AM ET -> 12:00 PM
+    
+    # Evening/Night hours (is_am=False)
+    assert convert_from_ethiopian_time(12, 0, False) == (18, 0) # 12:00 PM ET -> 6:00 PM
+    assert convert_from_ethiopian_time(1, 0, False) == (19, 0)  # 1:00 PM ET -> 7:00 PM
+    assert convert_from_ethiopian_time(6, 0, False) == (0, 0)   # 6:00 PM ET -> 12:00 AM
+    assert convert_from_ethiopian_time(9, 0, False) == (3, 0)   # 9:00 PM ET -> 3:00 AM
+
+def test_12hour_format_conversion():
+    """Test conversion using 12-hour format with AM/PM."""
+    assert convert_to_ethiopian_time(7, 0, "AM") == (1, 0, True)    # 7:00 AM -> 1:00 AM ET
+    assert convert_to_ethiopian_time(12, 0, "PM") == (6, 0, True)   # 12:00 PM -> 6:00 AM ET
+    assert convert_to_ethiopian_time(7, 0, "PM") == (1, 0, False)   # 7:00 PM -> 1:00 PM ET
+    assert convert_to_ethiopian_time(12, 0, "AM") == (6, 0, False)  # 12:00 AM -> 6:00 PM ET
+
+def test_minutes_preserved():
+    """Test that minutes are preserved in conversion."""
+    assert convert_to_ethiopian_time(6, 30) == (12, 30, True)
+    assert convert_to_ethiopian_time(18, 45) == (12, 45, False)
+    assert convert_from_ethiopian_time(12, 30, True) == (6, 30)
+    assert convert_from_ethiopian_time(12, 45, False) == (18, 45)
+
+def test_invalid_standard_time():
+    """Test error handling for invalid standard times."""
+    with pytest.raises(InvalidTimeException):
+        convert_to_ethiopian_time(24, 0)
+    with pytest.raises(InvalidTimeException):
+        convert_to_ethiopian_time(-1, 0)
+    with pytest.raises(InvalidTimeException):
+        convert_to_ethiopian_time(12, 60)
+    with pytest.raises(InvalidTimeException):
+        convert_to_ethiopian_time(12, -1)
+    with pytest.raises(InvalidTimeException):
+        convert_to_ethiopian_time(7, 0, "invalid")
+
+def test_invalid_ethiopian_time():
+    """Test error handling for invalid Ethiopian times."""
+    with pytest.raises(InvalidTimeException):
+        convert_from_ethiopian_time(13, 0, True)
+    with pytest.raises(InvalidTimeException):
+        convert_from_ethiopian_time(0, 0, True)
+    with pytest.raises(InvalidTimeException):
+        convert_from_ethiopian_time(6, 60, True)
+    with pytest.raises(InvalidTimeException):
+        convert_from_ethiopian_time(6, -1, False)
+
+def test_round_trip_conversion():
+    """Test converting times back and forth."""
+    test_cases = [
+        (6, 0),   # 6:00 AM / 12:00 AM ET
+        (7, 0),   # 7:00 AM / 1:00 AM ET
+        (12, 0),  # 12:00 PM / 6:00 AM ET
+        (18, 0),  # 6:00 PM / 12:00 PM ET
+        (0, 0),   # 12:00 AM / 6:00 PM ET
+        (3, 0),   # 3:00 AM / 9:00 PM ET
+    ]
+    
+    for hour, minute in test_cases:
+        eth_hour, eth_minute, is_am = convert_to_ethiopian_time(hour, minute)
+        std_hour, std_minute = convert_from_ethiopian_time(eth_hour, eth_minute, is_am)
+        assert (hour, minute) == (std_hour, std_minute)

ethioqen-0.1.0/tests/test_unix_time_conversion.py

@@ -0,0 +1,108 @@
+import pytest
+from datetime import datetime, timezone, timedelta
+from ethioqen.unix_time_conversion import (
+    ethiopian_to_unix, 
+    unix_to_ethiopian,
+    _convert_ethiopian_to_24h,
+    _convert_24h_to_ethiopian
+)
+from ethioqen.exceptions import InvalidDateException
+
+def test_ethiopian_12h_to_24h_conversion():
+    """Test Ethiopian 12-hour to 24-hour conversion."""
+    # Morning times
+    assert _convert_ethiopian_to_24h(12, False) == 6  # 12 AM = 6:00
+    assert _convert_ethiopian_to_24h(1, False) == 7   # 1 AM = 7:00
+    assert _convert_ethiopian_to_24h(6, False) == 12  # 6 AM = 12:00
+    
+    # Afternoon/evening times
+    assert _convert_ethiopian_to_24h(12, True) == 18  # 12 PM = 18:00
+    assert _convert_ethiopian_to_24h(1, True) == 19   # 1 PM = 19:00
+    assert _convert_ethiopian_to_24h(6, True) == 0    # 6 PM = 00:00
+
+def test_24h_to_ethiopian_12h_conversion():
+    """Test 24-hour to Ethiopian 12-hour conversion."""
+    # Morning times
+    assert _convert_24h_to_ethiopian(6) == (12, False)   # 6:00 = 12 AM
+    assert _convert_24h_to_ethiopian(7) == (1, False)    # 7:00 = 1 AM
+    assert _convert_24h_to_ethiopian(12) == (6, False)   # 12:00 = 6 AM
+    
+    # Afternoon/evening times
+    assert _convert_24h_to_ethiopian(18) == (12, True)   # 18:00 = 12 PM
+    assert _convert_24h_to_ethiopian(19) == (1, True)    # 19:00 = 1 PM
+    assert _convert_24h_to_ethiopian(0) == (6, True)     # 00:00 = 6 PM
+
+def test_ethiopian_to_unix_12h_format():
+    """Test Ethiopian to Unix conversion with 12-hour format."""
+    # Ethiopian date: 2015-01-01 12:00 AM (6:00 standard)
+    eth_timestamp = ethiopian_to_unix(2015, 1, 1, 12, 0, False)
+    greg_dt = datetime(2022, 9, 11, 6, 0, tzinfo=timezone.utc)
+    assert eth_timestamp == int(greg_dt.timestamp())
+    
+    # Ethiopian date: 2015-01-01 1:00 PM (19:00 standard)
+    eth_timestamp = ethiopian_to_unix(2015, 1, 1, 1, 0, True)
+    greg_dt = datetime(2022, 9, 11, 19, 0, tzinfo=timezone.utc)
+    assert eth_timestamp == int(greg_dt.timestamp())
+
+def test_unix_to_ethiopian_12h_format():
+    """Test Unix to Ethiopian conversion with 12-hour format."""
+    # 2022-09-11 6:00:00 UTC (Ethiopian 12:00 AM)
+    greg_dt = datetime(2022, 9, 11, 6, 0, tzinfo=timezone.utc)
+    eth_date = unix_to_ethiopian(int(greg_dt.timestamp()))
+    assert eth_date == (2015, 1, 1, 12, 0, False)
+    
+    # 2022-09-11 19:00:00 UTC (Ethiopian 1:00 PM)
+    greg_dt = datetime(2022, 9, 11, 19, 0, tzinfo=timezone.utc)
+    eth_date = unix_to_ethiopian(int(greg_dt.timestamp()))
+    assert eth_date == (2015, 1, 1, 1, 0, True)
+
+def test_ethiopian_to_unix_basic():
+    """Test basic Ethiopian to Unix timestamp conversion."""
+    eth_timestamp = ethiopian_to_unix(2015, 1, 1)
+    greg_dt = datetime(2022, 9, 11, 6, 0, tzinfo=timezone.utc)  # Default 12 AM = 6:00
+    assert eth_timestamp == int(greg_dt.timestamp())
+
+def test_ethiopian_to_unix_with_timezone():
+    """Test conversion with timezone offsets."""
+    # Ethiopian date with +3:00 timezone (Addis Ababa)
+    eth_timestamp = ethiopian_to_unix(2015, 1, 1, 12, 0, False, 3)
+    greg_dt = datetime(2022, 9, 11, 6, 0, 
+                      tzinfo=timezone(timedelta(hours=3)))
+    assert eth_timestamp == int(greg_dt.timestamp())
+
+def test_invalid_ethiopian_dates():
+    """Test error handling for invalid Ethiopian dates."""
+    with pytest.raises(InvalidDateException):
+        ethiopian_to_unix(2015, 13, 7)  # Invalid Pagume day
+    with pytest.raises(InvalidDateException):
+        ethiopian_to_unix(2015, 14, 1)  # Invalid month
+    with pytest.raises(InvalidDateException):
+        ethiopian_to_unix(2015, 1, 31)  # Invalid day
+
+def test_invalid_times():
+    """Test error handling for invalid times."""
+    with pytest.raises(InvalidDateException):
+        ethiopian_to_unix(2015, 1, 1, 13, 0)  # Invalid hour (>12)
+    with pytest.raises(InvalidDateException):
+        ethiopian_to_unix(2015, 1, 1, 0, 0)   # Invalid hour (<1)
+    with pytest.raises(InvalidDateException):
+        ethiopian_to_unix(2015, 1, 1, 12, 60) # Invalid minute
+
+def test_invalid_timestamps():
+    """Test error handling for invalid Unix timestamps."""
+    with pytest.raises(InvalidDateException):
+        unix_to_ethiopian(-62167219200)  # Too early
+    with pytest.raises(InvalidDateException):
+        unix_to_ethiopian(253402300800)  # Too late
+
+def test_round_trip_conversion():
+    """Test converting dates back and forth."""
+    original_date = (2015, 1, 1, 1, 30, True)  # Ethiopian date/time (1:30 PM)
+    # Convert to Unix timestamp
+    unix_ts = ethiopian_to_unix(
+        original_date[0], original_date[1], original_date[2],
+        original_date[3], original_date[4], original_date[5]
+    )
+    # Convert back to Ethiopian
+    result_date = unix_to_ethiopian(unix_ts)
+    assert original_date == result_date