dately 2.1.3__tar.gz → 2.1.4__tar.gz

{dately-2.1.3 → dately-2.1.4}/PKG-INFO

@@ -1,15 +1,23 @@
 Metadata-Version: 2.1
 Name: dately
-Version: 2.1.3
-Summary: A library for manipulating datetime strings.
+Version: 2.1.4
+Summary: A comprehensive Python library for advanced date and time manipulation.
 Home-page: https://github.com/cedricmoorejr/dately
 Author: Cedric Moore Jr.
-Author-email: cedric@doydl.tech
+Author-email: cedricmoorejunior5@gmail.com
 License: MIT
 Project-URL: Source Code, https://github.com/cedricmoorejr/dately/tree/main/dately
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
+Classifier: Development Status :: 5 - Production/Stable
+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
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 

{dately-2.1.3 → dately-2.1.4}/dately/core.py

@@ -66,7 +66,6 @@ class DatelyDate:
     """
 
     def __dir__(self):
-        # Override the __dir__ method to exclude private methods
         original_dir = super().__dir__()
         return [item for item in original_dir if not item.startswith('_DatelyDate__')]
     
@@ -373,10 +372,34 @@ class DatelyDate:
             format, or if the tzinfo is invalid, raises an error to ensure that the function usage is clear and safe 
             within expected data types.
         """
-        if is_iso_date(datetime_strings):
-            return self.__repl_iso_timestring(datetime_strings, *args, **kwargs)
+    def replace_timestring(self, datetime_strings, *args, **kwargs):
+        filtered_kwargs = {k: v for k, v in kwargs.items() if k != 'time_indicator'}
+
+        if isinstance(datetime_strings, str):
+            if is_iso_date(datetime_strings):
+                return self.__repl_iso_timestring(datetime_strings, *args, **filtered_kwargs)
+            else:
+                return self._repl_timestring(datetime_strings, *args, **kwargs)
+        elif isinstance(datetime_strings, list):
+            return [
+                self.__repl_iso_timestring(dt_string, *args, **filtered_kwargs) if is_iso_date(dt_string)
+                else self._repl_timestring(dt_string, *args, **kwargs)
+                for dt_string in datetime_strings
+            ]
+        elif isinstance(datetime_strings, np.ndarray):
+            vectorized_iso_func = np.vectorize(
+                lambda dt_string: self.__repl_iso_timestring(dt_string, *args, **filtered_kwargs) if is_iso_date(dt_string)
+                else self._repl_timestring(dt_string, *args, **kwargs),
+                otypes=[np.object]
+            )
+            return vectorized_iso_func(datetime_strings)
+        elif isinstance(datetime_strings, pd.Series):
+            return datetime_strings.apply(
+                lambda dt_string: self.__repl_iso_timestring(dt_string, *args, **filtered_kwargs) if is_iso_date(dt_string)
+                else self._repl_timestring(dt_string, *args, **kwargs)
+            )
         else:
-            return self._repl_timestring(datetime_strings, *args, **kwargs)
+            raise ValueError("Unsupported data type. The input must be a scalar (str), list, numpy.ndarray, or pandas.Series.")
 
     def replace_datestring(self, date_strings, year=None, month=None, day=None):
         """

{dately-2.1.3 → dately-2.1.4}/dately/timeutils.py

@@ -36,11 +36,8 @@ __all__ = [
 ]
 
 def get_time():
-    # Get the current time as a timestamp
     current_time = time.time()
-    # Convert timestamp to a time tuple in local time
     local_time = time.localtime(current_time)
-    # Format the time to include hours, minutes, seconds, and microseconds
     formatted_time = time.strftime("%H:%M:%S", local_time) + f".{int(current_time % 1 * 1_000_000)}"
     return formatted_time
    
@@ -59,31 +56,23 @@ def offset_convert(number):
     str: The formatted time offset as a string with a leading sign (either '+' or '-') followed
          by two digits for hours and two digits for minutes, separated by a colon.
     """
-    # Convert string input to float if necessary
     if isinstance(number, str):
         number = float(number)
-    
     sign = '+' if number >= 0 else '-'
-    # Get the absolute value
     abs_number = abs(number)
-    # Extract hours and minutes
     hours = int(abs_number)
     minutes = int((abs_number - hours) * 60)
-    # Format the result as +-HH:MM
     formatted_time = f"{sign}{hours:02}:{minutes:02}"
     return formatted_time
 
 def datetime_offset(offset):
-    # Validate the offset
     if not isinstance(offset, (int, float)):
         raise ValueError("Offset must be an integer or float representing hours.")
-    # Create a timezone object for datetime's tzinfo
     timezone = datetime.timezone(datetime.timedelta(hours=offset))
     return timezone
 
 def strTime(datetime_string):
     """ Extracts and returns detailed time information from a datetime string. """
-    # Regex for finding time
     time_exists = timeboundary_regex.search(datetime_string)
     
     if time_exists:
@@ -91,11 +80,9 @@ def strTime(datetime_string):
         full_time_end_position = time_exists.end()
         full_time_string = time_exists.group()
 
-        # Search for more specific time details within the extracted time string
         time_match = time_only_regex.search(full_time_string)
         
         if time_match:
-            # If a specific time format is found, return start, end, and the actual time value as a dictionary
             time_details = {
                 'time_found': time_match.group(),
                 'start': time_match.start() + full_time_start_position,
@@ -132,16 +119,10 @@ def stripTimeIndicator(datetime_string):
         time_end = match['time_details']["end"]
         fulltime_start = match['full_time_details']['start']
         fulltime_end = match['full_time_details']["end"]
-        
         timezone_data = datetime_string[time_end:]
-        
         if timezone_data == '':
             return datetime_string
-
-        # Remove the time indicator
         cleaned_string = re.sub(timemeridiem_regex, ' ', timezone_data)
-
-        # Combine the parts
         return datetime_string[:fulltime_start] + time_match + cleaned_string + datetime_string[fulltime_end:]
            
     return datetime_string
@@ -182,10 +163,8 @@ def remove_marker(text):
     Returns:
     str: The cleaned text without the specified marker.
     """
-    # Define the regex pattern to match the specific string to remove
     pattern = re.compile(r" NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET")
 
-    # Replace the matched string with nothing (effectively removing it)
     cleaned_text = pattern.sub("", text)
     return cleaned_text
 
@@ -205,15 +184,11 @@ def make_datetime_string(date_string):
         str: A standardized datetime string. If the format is date-only, '00:00:00.000000 NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET' is appended to the date string. If the format
              includes time information or is not detected, the original date string is returned.
     """
-    # Define the regex pattern for time extraction
     time_pattern = anytime_regex
     no_other_time_placeholder = "NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET"
-
-    # Search for the time component in the date string
     match = time_pattern.search(date_string)
 
     if match:
-        # Check if the matched time component has a valid tzinfo
         time_component = match.group()
         tzinfo_pattern = gtf('tzinfo')
         if tzinfo_pattern.search(time_component):
@@ -221,7 +196,6 @@ def make_datetime_string(date_string):
         else:
             return f"{date_string.strip()} {get_time()} {no_other_time_placeholder}"
     else:
-        # If no time component is found, append '00:00:00.000000 NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET' to the date string
         return f"{date_string.strip()} {get_time()} {no_other_time_placeholder}"
        
 def validate_timezone(datetime_string):
@@ -233,7 +207,6 @@ def validate_timezone(datetime_string):
         timezone_data = timezone_data.lstrip()
         if timezone_data == '':
             return True, "The time string is valid."
-        # Check the occurrences of each component
         if len(timemeridiem_regex.findall(timezone_data)) > 1:
             return False, "More than one time indicator found."
         if len(timezone_offset_regex.findall(timezone_data)) > 1:
@@ -254,27 +227,19 @@ def validate_date(date_string, date_format):
     then identifies the components of the date (month, day, year) and 
     checks their validity based on standard calendar rules.
     """
-    # Extract any localized time fragment and clean the string.
     date_str = stripTime(date_string)
-
-    # This dictionary will store the spans of each component.
     components_spans = {"month": None, "day": None, "year": None}
-
-    # Single pass to find month, day, and year
     pattern = datetime_pattern_search(date_format)
     match = pattern.match(date_str)
     if match:
-        # Iterate through possible date components
         for key in components_spans.keys():
-            if key in match.groupdict():  # Check if the current component was found in the match
-                components_spans[key] = match.span(key)  # Store the span of the component
+            if key in match.groupdict():
+                components_spans[key] = match.span(key)
                 
-    # Extract day, month, and year based on their spans in the string
     day = int(date_str[slice(*components_spans['day'])])
     month = int(date_str[slice(*components_spans['month'])])
     year = int(date_str[slice(*components_spans['year'])])
     
-    # Define the maximum days in each month, adjusting February based on leap year
     month_days = {1: 31, 2: 29 if is_leap_year(year) else 28, 3: 31, 4: 30, 5: 31, 6: 30,
                   7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
     if month < 1 or month > 12:
@@ -369,42 +334,29 @@ def replace_time_by_position(datetime_string, component, new_value):
 
     time_component_pattern = gtf(component)
     gt_time_pattern_match = timeboundary_regex.search(datetime_string)
-
     if gt_time_pattern_match:
         time_start_position = gt_time_pattern_match.start()
         time_end_position = gt_time_pattern_match.end()
         time_matched_value = gt_time_pattern_match.group()
-
         if component == 'tzinfo':
             new_value = offset_convert(new_value)
             time_component_matches = list(time_component_pattern.finditer(time_matched_value))
             if time_component_matches:
-                # Find the match with the largest end position
                 largest_match = max(time_component_matches, key=lambda m: m.end())
-                # Replace all tzinfo matches with the new value
                 part_before = datetime_string[:time_start_position + time_component_matches[0].start()]
                 part_after = datetime_string[time_start_position + largest_match.end():]
                 datetime_string = part_before + new_value + part_after
                 return datetime_string.replace('NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET', new_value).strip()
             else:
-                # Replace the placeholders with the new tzinfo value
                 return datetime_string.replace('NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET', new_value).strip()
-
-        # Match the specific component within the matched time
         time_component_match = time_component_pattern.search(time_matched_value)
         if time_component_match:
-            # Replace the component with the new value
             part_before = datetime_string[:time_start_position + time_component_match.start(1)]
             part_after = datetime_string[time_start_position + time_component_match.end(1):]
 
             if component == 'microsecond':
                 new_value = hundred_thousandths_place(new_value, decimal=False)
-                
             datetime_string = part_before + new_value + part_after
-            
             return datetime_string.replace('NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET', '').strip()
-
-    # Always remove placeholders if they exist
     datetime_string = datetime_string.replace('NO_MERIDIEM_NO_TIMEZONE_NO_OFFSET', '').strip()
-
     return datetime_string

{dately-2.1.3 → dately-2.1.4}/dately/timezone.py

@@ -3,7 +3,6 @@ import json
 import tempfile
 import shutil
 import requests
-from requests.exceptions import ConnectionError, HTTPError, Timeout
 import time
 import random
 import re
@@ -12,8 +11,13 @@ import pandas as pd
 from .mskutils import *
 from .sysutils import *
 
+TimeZoner = None
 
-## API Handler
+
+class NoAPIKeysError(Exception):
+    """Exception raised when no API keys are available."""
+    pass
+   
 class Request:
     def __init__(self, base_url='aHR0cDovL2FwaS50aW1lem9uZWRiLmNvbS92Mi4xL2xpc3QtdGltZS16b25lP2tleT0=', use_api_key=True):
         """ Initialize the API utility with the given base URL. """
@@ -42,14 +46,27 @@ class Request:
             response = requests.get(url, timeout=10)
             response.raise_for_status()
             self.api_keys = response.json()
+        except requests.exceptions.HTTPError as e:
+            print(f"HTTP error occurred: {e}")
+            self.api_keys = {}
+        except requests.exceptions.ConnectionError as e:
+            print(f"Connection error occurred: {e}")
+            self.api_keys = {}
+        except requests.exceptions.Timeout as e:
+            print(f"Timeout occurred: {e}")
+            self.api_keys = {}
         except Exception as e:
+            print(f"An unexpected error occurred: {e}")
             self.api_keys = {}
-
+        except requests.exceptions.SSLError as e:
+            print(f"SSL error occurred: {e}")
+            self.api_keys = {}            
+            
     def get_random_key(self):
         """Get a random API key from the available keys."""
         keys = list(self.api_keys.keys())
         if not keys:
-            raise Exception("No API keys available")
+            raise NoAPIKeysError("No API keys available")
         
         random_key = random.choice(keys)
         while random_key == self.last_key and len(keys) > 1:
@@ -61,12 +78,7 @@ class Request:
         return api_key
 
     def update_base_url(self, new_url):
-        """
-        Update the base URL for the API utility.
-
-        Parameters:
-        new_url (str): The new base URL for the API endpoint.
-        """
+        """ Update the base URL for the API utility. """
         self.base_url = new_url
 
     def set_use_api_key(self, use_api_key):
@@ -97,21 +109,15 @@ class Request:
             reset_time = UnixTime.Date(self.rate_limit_reset)
         else:
             reset_time = 'unknown'
-        # print(f"Rate limit status:\n"
-        #       f"  Limit: {self.rate_limit_limit}\n"
-        #       f"  Remaining: {self.rate_limit_remaining}\n"
-        #       f"  Reset: {reset_time}")
 
     def make_request(self, params, headers=None):
         """ Make a request to the specified API. """
         current_time = time.time()
         time_since_last_request = current_time - self.last_request_time
 
-        # Ensure at least 2 seconds have passed since the last request
         if time_since_last_request < 2:
             time.sleep(2 - time_since_last_request)
 
-        # Ensure we are not exceeding the rate limit
         if self.rate_limit_remaining is not None and self.rate_limit_remaining <= 0:
             if self.rate_limit_reset is not None:
                 reset_time = UnixTime.Date(self.rate_limit_reset)
@@ -132,29 +138,21 @@ class Request:
         if self.use_api_key:
             api_key = self.get_random_key()
             params['key'] = api_key
-        
-        # Ensure the 'format' parameter is always set to 'json' if not already specified
+
         if 'format' not in params:
             params['format'] = 'json'
 
         try:
             response = requests.get(self.base_url, params=params, headers=headers, timeout=10)
             response.raise_for_status()
-
-            # Extract and update rate limit information
             rate_limit_info = self.extract_rate_limit_info(response.headers)
-
-            self.last_request_time = time.time()  # Update the last request time
-            
-            # Log the rate limit status automatically
+            self.last_request_time = time.time()
             self.log_rate_limit_status()
-
             return {
                 'response': response.json(),
                 'rate_limit_info': rate_limit_info
             }
         except Exception as e:
-            # Log the rate limit status automatically even in case of error
             self.log_rate_limit_status()
 
             return {
@@ -165,7 +163,6 @@ class Request:
 
 
 
-
 class parse_zoneinfo_html_table:
     """
     This class is designed to parse an HTML IANA Time Zones table from a specified URL, clean the HTML content,
@@ -205,18 +202,13 @@ class parse_zoneinfo_html_table:
 
     def extract_table_from_html(self):
         try:
-            # Find and extract the whole table
             table_html = self.extract_tag_contents(self.html_content, 'table', first_only=True)
             if not table_html:
                 return None, None
-
-            # Extract table headers
             headers = []
             headers_html = self.extract_tag_contents(table_html, 'tr', first_only=True)
             for header_content in self.extract_tag_contents(headers_html, 'th'):
                 headers.append(self.clean_html(header_content).strip())
-
-            # Extract table rows
             rows = []
             row_tags = self.extract_tag_contents(table_html, 'tr')[1:]
             for row_html in row_tags:
@@ -251,23 +243,18 @@ class TimezoneOffset:
     """Converts a numeric or string time offset into a formatted string representing the offset in hours and minutes."""
     @staticmethod
     def format(offset):
-        # Check if the value is a string
         if isinstance(offset, str):
             offset = offset.strip()
 
-            # Handle the case where the offset is "UTC"
             if offset == "UTC":
                 return "+00:00"
 
-            # Handle the case where the offset is an all-caps abbreviation
             if offset.isupper():
                 return offset
         
-            # Check if the value is already in the correct HH:MM format
             if re.match(r'^[+-]\d{2}:\d{2}$', offset):
                 return offset
         
-        # Handle the case where offset is given as a string with hours and optional minutes
         pattern_hm = r'^([+-]?)(\d{1,2})(?::?(\d{1,2})?)?$'
         match_hm = re.match(pattern_hm, str(offset).strip())
         if match_hm:
@@ -292,7 +279,6 @@ class TimezoneOffset:
             except ValueError:
                 return None
 
-        # Handle the case where offset is given as total seconds
         pattern_seconds = r'^([+-]?)(\d+)$'
         match_seconds = re.match(pattern_seconds, str(offset).strip())
         if match_seconds:
@@ -423,24 +409,21 @@ class tzoneDataManager:
             shutil.rmtree(self.storage_dir)
 
 
-
-
 class DatelyTz:
     """DatelyTz class is responsible for managing timezone data retrieval."""
     def __init__(self, rq_instance=None):
         """Initialize the DatelyTz class. Loads data from file if it exists, otherwise fetches from the API and saves it."""
         self.tzone_manager = tzoneDataManager()
-        self.Request = rq_instance  # Assign rq_instance to self.Request
+        self.Request = rq_instance
 
         if tzoneDataManager.data_file_exists():
             self.tzone_manager.load_data_from_file()
             self.timezonedata = self.tzone_manager.timezonedata
         else:
-            self.timezonedata = self._from_api()  # Note the change here
+            self.timezonedata = self._from_api()
             self.tzone_manager.timezonedata = self.timezonedata
             self.tzone_manager.save_data_to_file()
             
-            # Update self.timezonedata to include the full dataset with IANA table data
             self.tzone_manager.load_data_from_file()
             self.timezonedata = self.tzone_manager.timezonedata
 
@@ -452,7 +435,7 @@ class DatelyTz:
         result = self.Request.make_request(params)
         if 'response' in result:
             data = result['response']
-            return self._format_api_data(data)  # Changed cls to self
+            return self._format_api_data(data)
         else:
             return result
 
@@ -472,18 +455,6 @@ class DatelyTz:
             return data
 
 
-
-rq_instance = Request(use_api_key=True)
-
-# Create an instance of DatelyTz
-tz = DatelyTz(rq_instance)
-
-# Access the time zone data from tzoneDataManager instance
-timezonedata = tz.tzone_manager.timezonedata
-
-
-
-
 class ZoneInfoManager:
     """
     A class to manage and query time zone information.
@@ -523,7 +494,6 @@ class ZoneInfoManager:
         self.ObservesDST = self.__get_zones_by_dst_observance()
 
     def __dir__(self):
-        # Override the __dir__ method to exclude private methods and attributes
         original_dir = super().__dir__()
         return [item for item in original_dir if not item.startswith('_')]
 
@@ -626,16 +596,13 @@ class ZoneInfoManager:
         if not self.__Request:
             return None
 
-        # Temporarily update the base URL
         original_url = self.__Request.base_url
         temp = Shift.type.map('aHR0cDovL3dvcmxkdGltZWFwaS5vcmcvYXBpL3RpbWV6b25lLw==', zone_name, ret=True)
         self.__Request.update_base_url(temp)
         
         try:
-            # Make the request without parameters
             result = self.__Request.make_request(params={})
         finally:
-            # Restore the original base URL
             self.__Request.update_base_url(original_url)
 
         if 'response' in result:
@@ -643,11 +610,23 @@ class ZoneInfoManager:
         else:
             return result
 
-# Create an instance of ZoneInfoManager
-TimeZoner = ZoneInfoManager(timezonedata, rq_instance)
 
+try:
+    rq_instance = Request(use_api_key=True)
+    tz = DatelyTz(rq_instance)
+    timezonedata = tz.tzone_manager.timezonedata
+    TimeZoner = ZoneInfoManager(timezonedata, rq_instance)
+except Exception as e:
+    print(f"Failed to initialize TimeZoner due to: {e}")
 
-
-__all__ = ['TimeZoner']
+# TimeZoner Fail
+if TimeZoner is None:
+    class ImportError(Exception):
+        def __init__(self, message="TimeZoner could not be imported correctly and cannot be used."):
+            self.message = message
+            super().__init__(self.message)
+    
+    TimeZoner = lambda *args, **kwargs: (_ for _ in ()).throw(ImportError())
 
 
+__all__ = ['TimeZoner']

{dately-2.1.3 → dately-2.1.4}/dately.egg-info/PKG-INFO

@@ -1,15 +1,23 @@
 Metadata-Version: 2.1
 Name: dately
-Version: 2.1.3
-Summary: A library for manipulating datetime strings.
+Version: 2.1.4
+Summary: A comprehensive Python library for advanced date and time manipulation.
 Home-page: https://github.com/cedricmoorejr/dately
 Author: Cedric Moore Jr.
-Author-email: cedric@doydl.tech
+Author-email: cedricmoorejunior5@gmail.com
 License: MIT
 Project-URL: Source Code, https://github.com/cedricmoorejr/dately/tree/main/dately
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
+Classifier: Development Status :: 5 - Production/Stable
+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
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 

dately-2.1.4/setup.py

@@ -0,0 +1,53 @@
+from setuptools import setup, find_packages
+import sys
+
+# Check if the system is Windows
+if sys.platform != 'win32':
+    raise RuntimeError('This package is only compatible with Windows.')
+
+
+setup(
+    name='dately',
+    version="2.1.4",
+    author='Cedric Moore Jr.',
+    author_email='cedricmoorejunior5@gmail.com',
+    description='A comprehensive Python library for advanced date and time manipulation.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/cedricmoorejr/dately',
+    project_urls={
+        'Source Code': 'https://github.com/cedricmoorejr/dately/tree/main/dately',
+    },
+    packages=find_packages(),
+    package_data={
+        'dately': [
+            'mold/pyd/*.pyd',
+            'mold/pyd/cdatetime/*.pyd'
+        ],
+    },
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: Microsoft :: Windows',
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',        
+    ],
+    python_requires='>=3.8',
+    install_requires=[
+        'numpy',
+        'pandas',
+        'pytz',
+        'requests',
+    ],
+    license='MIT',
+)
+
+
+
+

dately-2.1.3/setup.py

@@ -1,41 +0,0 @@
-from setuptools import setup, find_packages
-import sys
-
-# Check if the system is Windows
-if sys.platform != 'win32':
-    raise RuntimeError("This package is only compatible with Windows.")
-
-
-setup(
-    name="dately",
-    version="2.1.3",
-    author="Cedric Moore Jr.",
-    author_email="cedric@doydl.tech",
-    description="A library for manipulating datetime strings.",
-    long_description=open("README.md").read(),
-    long_description_content_type="text/markdown",
-    url="https://github.com/cedricmoorejr/dately",
-    project_urls={
-        "Source Code": "https://github.com/cedricmoorejr/dately/tree/main/dately",
-    },
-    packages=find_packages(),
-    package_data={
-        'dately': [
-            'mold/pyd/*.pyd',
-            'mold/pyd/cdatetime/*.pyd'
-        ],
-    },
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: Microsoft :: Windows",
-    ],
-    python_requires='>=3.8',
-    install_requires=[
-        "numpy",
-        "pandas",
-        "pytz",
-        "requests",
-    ],
-    license="MIT",
-)