dately 2.1.4__tar.gz → 2.2.0b2__tar.gz

{dately-2.1.4 → dately-2.2.0b2}/PKG-INFO

@@ -1,20 +1,18 @@
 Metadata-Version: 2.1
 Name: dately
-Version: 2.1.4
+Version: 2.2.0b2
 Summary: A comprehensive Python library for advanced date and time manipulation.
-Home-page: https://github.com/cedricmoorejr/dately
+Home-page: https://github.com/cedricmoorejr/dately/tree/v2.2.0-b.2
 Author: Cedric Moore Jr.
 Author-email: cedricmoorejunior5@gmail.com
 License: MIT
-Project-URL: Source Code, https://github.com/cedricmoorejr/dately/tree/main/dately
+Project-URL: Source Code, https://github.com/cedricmoorejr/dately/releases/tag/v2.2.0-beta.2
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10

dately-2.2.0b2/dately/mold/include/clean_str.h

@@ -0,0 +1,7 @@
+// clean_str.h
+#ifndef CLEAN_STR_H
+#define CLEAN_STR_H
+
+void clean_string(const char* input, char* output);
+
+#endif // CLEAN_STR_H

dately-2.2.0b2/dately/mold/include/iso8601T.h

@@ -0,0 +1,12 @@
+#ifndef ISO8601T_H
+#define ISO8601T_H
+
+int is_leap_year(int year);
+int validate_date(int year, int month, int day);
+int validate_time(int hour, int minute, int second);
+int is_digit(char c);
+int check_basic_format(const char* date_string);
+int check_extended_format(const char* date_string);
+int find_date_match(const char* date_string);
+
+#endif // ISO8601T_H

dately-2.2.0b2/dately/mold/include/iso8601Z.h

@@ -0,0 +1,6 @@
+#ifndef ISO8601Z_H
+#define ISO8601Z_H
+
+void replace_zulu_suffix_with_utc(char *datetime_string);
+
+#endif // ISO8601Z_H

dately-2.2.0b2/dately/mold/include/root_dir_search.h

@@ -0,0 +1,14 @@
+#ifndef ROOR_DIR_SEARCH_H
+#define ROOR_DIR_SEARCH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+char* find_directory(const char *start_path, const char *dir_name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ROOR_DIR_SEARCH_H

dately-2.2.0b2/dately/mold/include/time_zones.h

@@ -0,0 +1,21 @@
+// time_zones.h
+#ifndef TIME_ZONES_H
+#define TIME_ZONES_H
+
+typedef struct {
+    char full_name[50];
+    char region[50];
+    char offset[11];
+    char type[10];
+    char dst[7];
+} TimeZoneInfo;
+
+typedef struct {
+    char code[7];
+    TimeZoneInfo info;
+} TimeZone;
+
+extern TimeZone time_zones[];
+extern int time_zones_count;
+
+#endif // TIME_ZONES_H

dately-2.2.0b2/dately/mold/pyx/Compiled.pyx

@@ -0,0 +1,186 @@
+# Compiled.pyx
+import re
+import os
+import sys
+from libc.string cimport strdup
+from libc.stdlib cimport free  # Import free to release allocated memory
+from cython cimport unicode, boundscheck, wraparound
+from cpython cimport array
+
+cdef extern from "root_dir_search.h":
+    char* find_directory(const char *start_path, const char *dir_name)
+
+def get_directory_path(directory_name):
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    directory_path_c = find_directory(script_dir.encode('utf-8'), directory_name.encode('utf-8'))
+    if directory_path_c:
+        directory_path = directory_path_c.decode('utf-8')
+        free(directory_path_c)  # Free the allocated memory
+        return directory_path
+    else:
+        raise EnvironmentError(f"{directory_name} directory not found.")
+
+# Find the dately path
+dately_path = get_directory_path("dately")
+if dately_path:
+    sys.path.append(dately_path)
+else:
+    raise EnvironmentError("dately directory not found.")
+
+from mold.pyd.time_zones import time_zones_dict
+
+
+
+
+cdef dict __datetime_named_group_patterns__ = {
+    '%a': r'(?P<weekday>Mon|Tue|Wed|Thu|Fri|Sat|Sun)',
+    '%A': r'(?P<weekday>Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)',    
+    '%w': r'(?P<weekday>\d)',
+    '%u': r'\d',     
+    '%b': r'(?P<month>[A-Za-z]{3})',
+    '%B': r'(?P<month>[A-Za-z]+)',
+    '%m': r'(?P<month>\d{1,2})',
+    '%-m': r'(?P<month>\d{1,2})',
+    '%d': r'(?P<day>\d{1,2})',
+    '%-d': r'(?P<day>\d{1,2})',
+    '%j': r'(?P<day>\d{1,3})',
+    '%-H': r'(?P<hour24>(?:[0-9]|1[0-9]|2[0-3]|\d{1,2}))',
+    '%H': r'(?P<hour24>(?:\d{1,2}|0?[0-9]|1[0-9]|2[0-3]))',
+    '%I': r'(?P<hour12>(?:\d{1,2}|0?[1-9]|1[0-2]))',
+    '%-I': r'(?P<hour12>(?:\d{1,2}|0?[1-9]|1[0-2]))',
+    '%M': r'(?P<minute>\d{1,2})',
+    '%-M': r'(?P<minute>\d{1,2})',
+    '%S': r'(?P<second>\d{1,2})',
+    '%-S': r'(?P<second>\d{1,2})',
+    '%f': r'(?P<microsecond>\d{1,6})',
+    '%p': r'(?P<am_pm>(?:AM|PM))',
+    '%-y': r'(?P<year>\d{2})',
+    '%y': r'(?P<year>\d{2})',
+    '%Y': r'(?P<year>\d{4})',       
+    '%z': r'(?P<timezone>[\+\-](?:\d{4}|\d{2}:?\d{2}))',
+    '%Z': r'(?P<timezone>(?:[\+\-]\d{2}:[0-9]{2}|[A-Za-z\s]+|[A-Za-z]{2,4}|UTC|[\+\-]\d{2}:?\d{2}))',  
+    '%q': r'\d',
+    '%U': r'\d{1,2}',
+    '%V': r'\d{1,2})',
+}
+
+cpdef object datetime(unicode fmt):
+    cdef unicode regex = fmt
+    cdef unicode key, value
+    for key, value in __datetime_named_group_patterns__.items():
+        regex = regex.replace(key, value)
+    return re.compile(u'^' + regex + u'$')
+
+# Create regex patterns for timezone abbreviations and full timezone names
+timezone_abbrv = list(time_zones_dict.keys())
+timezone_abbrv_pattern = r'\b(' + '|'.join(timezone_abbrv) + r')\b'
+full_names = [info['full_name'] for info in time_zones_dict.values()]
+full_names_pattern = r'\b(' + '|'.join(full_names) + r')\b'
+
+# Define the regex patterns in a dictionary
+regex_patterns = {
+    "timemeridiem": r'\s*\b(AM|PM)\b\s*',
+    # Purpose: Matches a time string in the format HH:MM:SS or HH:MM:SS.microseconds.
+    "timeonly": r'(?P<hours>\d{1,2}):(?P<minutes>\d{2}):(?P<seconds>\d{2})(?:\.(?P<microseconds>\d+))?',
+    "timezone_offset": r'(?<!\d)[+-]?(?:\d{1,2}(?::\d{1,2})?|\d{3,4})(?!\d)',
+    "iana_timezone_identifier": r'\b[A-Za-z_]+/[A-Za-z_]+\b',
+    "anytime": (
+        r"(?<!\d)(\d{1,2}:\d{2}:\d{2}|\d{6})"
+        r"(?:\.\d{1,6})?"
+        r"(?:\s*[AP]M)?"
+        r"(?:\s*(?:[+-]\d{2}:?\d{2}|[+-]\d{4}|[A-Z]{3,4}|Z))?"
+        r"(?=\s|$)"
+    ),
+    # Purpose: Matches various time string formats, including HH:MM:SS, HHMMSS, with optional microseconds, AM/PM indicators, and time zone information.
+    "timeplus": (
+        r"(\d{1,2}:\d{2}:\d{2}|\d{6})"
+        r"(?:\.\d{1,6})?"
+        r"(?:\s*[AP]M)?"
+        r"(?:\s*(?:[+-]\d{2}:?\d{2}|[+-]\d{4}|[A-Z]{3,4}|Z))?"
+    ),
+    "establish_time_boundary": r'(?<!\d)(\d{1,2}:\S.*)',
+    "datetime_second": r'\d{2}:\d{2}:(\d{2})(?:\.\d+)?',
+    "datetime_minute": r'\d{2}:(\d{2})(:\d{2}(?:\.\d+)?)?',
+    "datetime_hour": r'(\d{1,2}):(\d{2})(:\d{2}(?:\.\d+)?)?',
+    "datetime_microsecond": r'\d{2}:\d{2}:\d{2}\.(\d+)',
+    "datetime_timezone": (
+        r'\b\d{1,2}(:\d{2})?Z\b|'          # Zulu time (UTC)
+        r'[\+\-]\d{2}:?\d{2}|'             # UTC offset
+        r'\b[A-Za-z]+/[A-Za-z_]+\b|'       # Continent/City format
+        r'\bAM\b|\bPM\b'                   # AM/PM indicator
+    ),
+    "timezone_abbreviation": timezone_abbrv_pattern,
+    "full_timezone_name": full_names_pattern
+}
+
+# Function to compile the regex patterns
+cpdef dict compile_regex_patterns():
+    cdef dict compiled_patterns = {}
+    for key, pattern in regex_patterns.items():
+        compiled_patterns[key] = re.compile(pattern, re.IGNORECASE)
+    return compiled_patterns
+
+# Compile the regex patterns at the module level
+compiled_patterns = compile_regex_patterns()
+
+# Function to get compiled pattern by name
+cdef object get_pattern(str name):
+    return compiled_patterns.get(name, None)
+
+# Call the get_pattern function to retrieve the compiled regex
+second_regex = get_pattern("datetime_second")
+minute_regex = get_pattern("datetime_minute")
+hour_regex = get_pattern("datetime_hour")
+microsecond_regex = get_pattern("datetime_microsecond")
+timezone_regex = get_pattern("datetime_timezone")
+timezone_offset_regex = get_pattern("timezone_offset")
+iana_timezone_identifier_regex = get_pattern("iana_timezone_identifier")
+timemeridiem_regex = get_pattern("timemeridiem")
+time_only_regex = get_pattern("timeonly")
+anytime_regex = get_pattern("anytime")
+timeboundary_regex = get_pattern("establish_time_boundary")
+timezone_abbreviation_regex  = get_pattern("timezone_abbreviation")
+full_timezone_name_regex = get_pattern("full_timezone_name")
+timeplus_regex = get_pattern("timeplus")
+
+cdef class cRegexps:
+    cdef dict time_component_patterns
+
+    def __cinit__(self):
+        self.time_component_patterns = {
+            "second": second_regex,
+            "minute": minute_regex,
+            "hour": hour_regex,
+            "microsecond": microsecond_regex,
+            "tzinfo": timezone_regex
+        }
+        
+    cpdef object get_time_fragments(self, str component):
+        return self.time_component_patterns.get(component)
+
+# Create an instance of the cRegexps class
+cdef cRegexps regexps = cRegexps()
+
+# Define module-level variables for compiled regex patterns
+datetime_regex = datetime
+get_time_fragment = regexps.get_time_fragments
+
+# Define public interface
+__all__ = [
+    'datetime_regex',
+    'timemeridiem_regex',
+    'anytime_regex',
+    'timezone_regex',
+    'timeboundary_regex',
+    'second_regex',
+    'minute_regex',
+    'hour_regex',
+    'microsecond_regex',
+    'get_time_fragment',
+    'time_only_regex',
+    'timeplus_regex',
+    'iana_timezone_identifier_regex',
+    'timezone_offset_regex',
+    'timezone_abbreviation_regex',
+    'full_timezone_name_regex',
+]

dately-2.2.0b2/dately/mold/pyx/UniversalDateFormatter.pyx

@@ -0,0 +1,189 @@
+from cython cimport cdivision
+from cpython cimport bool
+from cpython.datetime cimport datetime
+import re
+
+__all__ = [
+    'zero_handling_date_formats',
+    'non_padded_to_zero_padded_specifiers',
+    'has_leading_zero',
+    'date_format_leading_zero',
+    'replace_non_padded_with_padded',
+]
+
+
+# Declare the dictionary types for better performance
+cdef dict _zero_handling_date_formats
+cdef dict _non_padded_to_zero_padded_specifiers
+
+# Initialize the dictionaries
+_zero_handling_date_formats = {
+    'day': {
+        'no_leading_zero': {
+            'format': '%-d',
+            'description': 'Day of the month as a decimal number without leading zero (1 to 31)'
+        },
+        'zero_padded': {
+            'format': '%d',
+            'description': 'Day of the month as a zero-padded decimal number (01 to 31)'
+        }
+    },
+    'month': {
+        'no_leading_zero': {
+            'format': '%-m',
+            'description': 'Month as a decimal number without leading zero (1 to 12)'
+        },
+        'zero_padded': {
+            'format': '%m',
+            'description': 'Month as a zero-padded decimal number (01 to 12)'
+        }
+    },
+    'year': {
+        'no_leading_zero': {
+            'format': '%-y',
+            'description': 'Year without century as a decimal number without leading zero (0 to 99)'
+        },
+        'zero_padded': {
+            'format': '%y',
+            'description': 'Year without century as a zero-padded decimal number (00 to 99)'
+        }
+    },
+    'hour24': {
+        'no_leading_zero': {
+            'format': '%-H',
+            'description': 'Hour (24-hour clock) as a decimal number without leading zero (0 to 23)'
+        },
+        'zero_padded': {
+            'format': '%H',
+            'description': 'Hour (24-hour clock) as a zero-padded decimal number (00 to 23)'
+        }
+    },
+    'hour12': {
+        'no_leading_zero': {
+            'format': '%-I',
+            'description': 'Hour (12-hour clock) as a decimal number without leading zero (1 to 12)'
+        },
+        'zero_padded': {
+            'format': '%I',
+            'description': 'Hour (12-hour clock) as a zero-padded decimal number (01 to 12)'
+        }
+    },
+    'minute': {
+        'no_leading_zero': {
+            'format': '%-M',
+            'description': 'Minute as a decimal number without leading zero (0 to 59)'
+        },
+        'zero_padded': {
+            'format': '%M',
+            'description': 'Minute as a zero-padded decimal number (00 to 59)'
+        }
+    },
+    'second': {
+        'no_leading_zero': {
+            'format': '%-S',
+            'description': 'Second as a decimal number without leading zero (0 to 59)'
+        },
+        'zero_padded': {
+            'format': '%S',
+            'description': 'Second as a zero-padded decimal number (00 to 59)'
+        }
+    }
+}
+
+_non_padded_to_zero_padded_specifiers = {
+    '%-d': '%d',
+    '%-m': '%m',
+    '%-y': '%y',
+    '%-H': '%H',
+    '%-I': '%I',
+    '%-M': '%M',
+    '%-S': '%S'
+}
+
+# Use cdef to declare return types for functions
+cdef dict get_zero_handling_date_formats():
+    return _zero_handling_date_formats
+
+cdef dict get_non_padded_to_zero_padded_specifiers():
+    return _non_padded_to_zero_padded_specifiers
+
+def zero_handling_date_formats():
+    return get_zero_handling_date_formats()
+
+def non_padded_to_zero_padded_specifiers(ret_format=None):
+    if ret_format == 'no_leading_zero':
+        return list(_non_padded_to_zero_padded_specifiers.keys())
+    elif ret_format == 'leading_zero':
+        return list(_non_padded_to_zero_padded_specifiers.values())
+    else:
+        return _non_padded_to_zero_padded_specifiers
+
+
+@cdivision(True)
+def has_leading_zero(object input_str):
+    cdef str integer_part
+    cdef int len_integer_part
+
+    input_str = str(input_str)
+
+    # Check if the converted input string is a valid number
+    if not input_str.replace('-', '', 1).replace('.', '', 1).isdigit():
+        return None  # Return None if it's not a valid number
+
+    # Special case for "0"
+    if input_str == "0" or input_str == "-0":
+        return None  # Return None for "0" or "-0"
+
+    # Check if the integer part has exactly two digits
+    integer_part = input_str.split('.')[0].strip('-')
+    len_integer_part = len(integer_part)
+    
+    if len_integer_part == 2 and integer_part != '00':
+        return None  # Return None for whole numbers with exactly two digits, except '00'
+
+    # Check if the integer part has more than two digits
+    if len_integer_part > 2:
+        return None  # Return None if the integer part has more than two digits
+
+    # Check for leading zero in whole numbers or in the integer part of decimal numbers
+    if input_str[0] == '-' and input_str[1] == '0':
+        return True
+    elif input_str[0] == '0' and input_str[1] != '.':
+        return True
+    elif input_str.startswith('0.') and input_str != '0.':
+        return True
+        
+    return False
+
+
+# Helper function to check format specifications
+cdef bint has_non_padded_specifier(str format_string):
+    non_padded_specifiers = non_padded_to_zero_padded_specifiers(ret_format='no_leading_zero')
+    return any(spec in format_string for spec in non_padded_specifiers)
+
+cpdef str date_format_leading_zero(datetime date, str format_string):
+    cdef str platform_compatible_format, formatted_date, orig, repl
+    if has_non_padded_specifier(format_string):
+        platform_compatible_format = format_string
+        for orig, repl in non_padded_to_zero_padded_specifiers().items():
+            platform_compatible_format = platform_compatible_format.replace(orig, repl)
+        
+        formatted_date = date.strftime(platform_compatible_format)
+        
+        for orig in non_padded_to_zero_padded_specifiers(ret_format='no_leading_zero'):
+            if orig in format_string:
+                formatted_date = re.sub(r'\b0(?=\d)', '', formatted_date)
+        return formatted_date
+    else:
+        return date.strftime(format_string)
+
+
+cpdef str replace_non_padded_with_padded(str input_format):
+    cdef str category, non_padded, zero_padded
+    # Directly use the dictionary without additional function calls for better performance
+    for category in _zero_handling_date_formats:
+        non_padded = _zero_handling_date_formats[category]['no_leading_zero']['format']
+        zero_padded = _zero_handling_date_formats[category]['zero_padded']['format']
+        input_format = input_format.replace(non_padded, zero_padded)
+    return input_format
+

dately-2.2.0b2/dately/mold/pyx/clean_str.pyx

@@ -0,0 +1,10 @@
+# clean_str.pyx
+cdef extern from "clean_str.h":
+    void clean_string(const char* input, char* output)
+
+def cleanstr(input_string):
+    cdef bytes input_bytes = input_string.encode('utf-8')  # Ensure the bytes object persists
+    cdef const char* input_c = input_bytes  # Safe cast to a C string
+    cdef char output_c[150]  # Adjust the size based on expected input lengths
+    clean_string(input_c, output_c)
+    return output_c.decode('utf-8')

dately-2.2.0b2/dately/mold/pyx/iso8601T.pyx

@@ -0,0 +1,5 @@
+cdef extern from "iso8601T.h":
+    int find_date_match(const char* date_string)
+
+cpdef bint isISOT(str date_string):
+    return find_date_match(date_string.encode('utf-8')) != 0

dately-2.2.0b2/dately/mold/pyx/iso8601Z.pyx

@@ -0,0 +1,12 @@
+cdef extern from "iso8601z.h":
+    void replace_zulu_suffix_with_utc(char *datetime_string)
+
+cpdef str replaceZ(str datetime_string):
+    cdef bytes datetime_bytes = datetime_string.encode('utf-8')
+    cdef char *datetime_cstring = datetime_bytes
+
+    # Call the C function
+    replace_zulu_suffix_with_utc(datetime_cstring)
+    
+    # Convert the C string back to a Python string
+    return datetime_cstring.decode('utf-8')

dately-2.2.0b2/dately/mold/pyx/time_zones.pyx

@@ -0,0 +1,41 @@
+# time_zones.pyx
+cdef extern from "time_zones.h":
+    ctypedef struct TimeZoneInfo:
+        char full_name[50]
+        char region[50]
+        char offset[11]
+        char type[10]
+        char dst[7]
+
+    ctypedef struct TimeZone:
+        char code[7]
+        TimeZoneInfo info
+
+    extern TimeZone time_zones[]
+    extern int time_zones_count
+
+cdef dict get_time_zones_impl():
+    cdef dict result = {}
+    cdef int i
+    cdef TimeZone tz
+    for i in range(time_zones_count):
+        tz = time_zones[i]
+        result[tz.code.decode('utf-8')] = {
+            "full_name": tz.info.full_name.decode('utf-8'),
+            "region": tz.info.region.decode('utf-8'),
+            "offset": tz.info.offset.decode('utf-8'),
+            "type": tz.info.type.decode('utf-8'),
+            "dst": tz.info.dst.decode('utf-8')
+        }
+    return result
+
+cpdef dict get_time_zones():
+    return get_time_zones_impl()
+   
+# Assign dict
+time_zones_dict = get_time_zones()
+
+# Define public interface
+__all__ = [
+    'time_zones_dict'
+]