1pip install pywin32

1import win32com.client
2from datetime import datetime, timedelta
3import pythoncom
4
5def connect_to_outlook():
6    """
7    Establish connection to Outlook application.
8    
9    Returns:
10        Outlook application object
11    """
12    try:
13        # Initialize COM library for current thread
14        pythoncom.CoInitialize()
15        
16        # Connect to Outlook
17        outlook = win32com.client.Dispatch("Outlook.Application")
18        
19        print("✅ Connected to Outlook successfully")
20        return outlook
21    
22    except Exception as e:
23        print(f"❌ Error connecting to Outlook: {e}")
24        return None
25
26# Usage
27outlook = connect_to_outlook()

1def create_meeting(outlook, subject, start_time, duration_minutes, 
2                   attendees=None, location="", body=""):
3    """
4    Create a new calendar appointment or meeting.
5    
6    Args:
7        outlook: Outlook application object
8        subject: Meeting title
9        start_time: datetime object for meeting start
10        duration_minutes: Length of meeting in minutes
11        attendees: List of email addresses (None for appointment)
12        location: Meeting location or room
13        body: Meeting description/agenda
14    
15    Returns:
16        Created appointment item
17    """
18    try:
19        # Create appointment item
20        appointment = outlook.CreateItem(1)  # 1 = olAppointmentItem
21        
22        # Set basic properties
23        appointment.Subject = subject
24        appointment.Start = start_time
25        appointment.Duration = duration_minutes
26        appointment.Location = location
27        appointment.Body = body
28        
29        # Add reminder (15 minutes before)
30        appointment.ReminderSet = True
31        appointment.ReminderMinutesBeforeStart = 15
32        
33        # If attendees specified, convert to meeting
34        if attendees:
35            for email in attendees:
36                recipient = appointment.Recipients.Add(email)
37                recipient.Type = 1  # 1 = olRequired (required attendee)
38            
39            appointment.Recipients.ResolveAll()
40            appointment.MeetingStatus = 1  # 1 = olMeeting
41        
42        # Save the appointment
43        appointment.Save()
44        
45        print(f"✅ Meeting created: {subject}")
46        return appointment
47    
48    except Exception as e:
49        print(f"❌ Error creating meeting: {e}")
50        return None
51
52# Example usage
53tomorrow_9am = datetime.now().replace(hour=9, minute=0, second=0) + timedelta(days=1)
54
55meeting = create_meeting(
56    outlook=outlook,
57    subject="Sprint Planning Meeting",
58    start_time=tomorrow_9am,
59    duration_minutes=60,
60    attendees=["john.doe@company.com", "jane.smith@company.com"],
61    location="Conference Room A",
62    body="Agenda:\n1. Review last sprint\n2. Plan upcoming sprint\n3. Address blockers"
63)

1def get_busy_times(outlook, date, email=None):
2    """
3    Get all busy time slots for a specific date.
4    
5    Args:
6        outlook: Outlook application object
7        date: datetime date to check
8        email: Email address to check (None for current user)
9    
10    Returns:
11        List of (start_time, end_time) tuples
12    """
13    try:
14        # Get calendar folder
15        namespace = outlook.GetNamespace("MAPI")
16        
17        if email:
18            # Get shared calendar (requires permissions)
19            recipient = namespace.CreateRecipient(email)
20            recipient.Resolve()
21            calendar = namespace.GetSharedDefaultFolder(recipient, 9)  # 9 = olFolderCalendar
22        else:
23            # Get current user's calendar
24            calendar = namespace.GetDefaultFolder(9)
25        
26        # Define time range for the day
27        start_of_day = date.replace(hour=0, minute=0, second=0)
28        end_of_day = date.replace(hour=23, minute=59, second=59)
29        
30        # Get appointments for the day
31        appointments = calendar.Items
32        appointments.IncludeRecurrences = True
33        appointments.Sort("[Start]")
34        
35        # Filter to date range
36        restriction = f"[Start] >= '{start_of_day}' AND [End] <= '{end_of_day}'"
37        filtered = appointments.Restrict(restriction)
38        
39        # Collect busy times
40        busy_times = []
41        for appointment in filtered:
42            if appointment.BusyStatus in [2, 3]:  # 2=Busy, 3=OutOfOffice
43                busy_times.append((appointment.Start, appointment.End))
44        
45        return busy_times
46    
47    except Exception as e:
48        print(f"❌ Error checking availability: {e}")
49        return []
50
51
52def find_available_slot(outlook, date, duration_minutes, 
53                       start_hour=9, end_hour=17):
54    """
55    Find first available time slot on a given date.
56    
57    Args:
58        outlook: Outlook application object
59        date: datetime date to search
60        duration_minutes: Required meeting duration
61        start_hour: Business hours start (default 9 AM)
62        end_hour: Business hours end (default 5 PM)
63    
64    Returns:
65        datetime for available slot, or None if not found
66    """
67    busy_times = get_busy_times(outlook, date)
68    
69    # Create time slots (30-minute increments)
70    current_time = date.replace(hour=start_hour, minute=0, second=0)
71    end_time = date.replace(hour=end_hour, minute=0, second=0)
72    
73    while current_time < end_time:
74        slot_end = current_time + timedelta(minutes=duration_minutes)
75        
76        # Check if slot conflicts with busy times
77        is_available = True
78        for busy_start, busy_end in busy_times:
79            # Convert to datetime if needed
80            if isinstance(busy_start, str):
81                busy_start = datetime.fromisoformat(busy_start)
82            if isinstance(busy_end, str):
83                busy_end = datetime.fromisoformat(busy_end)
84            
85            # Check for overlap
86            if (current_time < busy_end and slot_end > busy_start):
87                is_available = False
88                break
89        
90        if is_available:
91            return current_time
92        
93        # Move to next 30-minute slot
94        current_time += timedelta(minutes=30)
95    
96    return None
97
98# Example: Find available time tomorrow
99tomorrow = datetime.now() + timedelta(days=1)
100available_time = find_available_slot(outlook, tomorrow, duration_minutes=60)
101
102if available_time:
103    print(f"✅ Available slot found: {available_time.strftime('%I:%M %p')}")
104else:
105    print("❌ No available slots found")

1def update_meeting(outlook, subject_to_find, new_subject=None, 
2                  new_start=None, new_duration=None, new_body=None):
3    """
4    Update an existing meeting by subject line.
5    
6    Args:
7        outlook: Outlook application object
8        subject_to_find: Current meeting subject
9        new_subject: New subject (optional)
10        new_start: New start time (optional)
11        new_duration: New duration in minutes (optional)
12        new_body: New meeting body (optional)
13    
14    Returns:
15        True if updated successfully
16    """
17    try:
18        namespace = outlook.GetNamespace("MAPI")
19        calendar = namespace.GetDefaultFolder(9)
20        
21        # Find appointment
22        appointments = calendar.Items
23        appointments.Sort("[Start]")
24        
25        for appointment in appointments:
26            if subject_to_find.lower() in appointment.Subject.lower():
27                # Update fields if provided
28                if new_subject:
29                    appointment.Subject = new_subject
30                if new_start:
31                    appointment.Start = new_start
32                if new_duration:
33                    appointment.Duration = new_duration
34                if new_body:
35                    appointment.Body = new_body
36                
37                # Save changes
38                appointment.Save()
39                print(f"✅ Meeting updated: {appointment.Subject}")
40                return True
41        
42        print(f"❌ Meeting not found: {subject_to_find}")
43        return False
44    
45    except Exception as e:
46        print(f"❌ Error updating meeting: {e}")
47        return False

1def create_meeting_with_attachment(outlook, subject, start_time, 
2                                  duration_minutes, attendees, 
3                                  attachment_path, body=""):
4    """
5    Create meeting and attach a file.
6    
7    Args:
8        outlook: Outlook application object
9        subject: Meeting title
10        start_time: Meeting start datetime
11        duration_minutes: Meeting duration
12        attendees: List of email addresses
13        attachment_path: Full path to file to attach
14        body: Meeting description
15    
16    Returns:
17        Created appointment item
18    """
19    try:
20        appointment = outlook.CreateItem(1)
21        
22        appointment.Subject = subject
23        appointment.Start = start_time
24        appointment.Duration = duration_minutes
25        appointment.Body = body
26        
27        # Add attendees
28        for email in attendees:
29            recipient = appointment.Recipients.Add(email)
30            recipient.Type = 1
31        
32        appointment.Recipients.ResolveAll()
33        appointment.MeetingStatus = 1
34        
35        # Add attachment
36        appointment.Attachments.Add(attachment_path)
37        
38        appointment.Save()
39        print(f"✅ Meeting created with attachment: {subject}")
40        
41        return appointment
42    
43    except Exception as e:
44        print(f"❌ Error creating meeting with attachment: {e}")
45        return None

1def create_recurring_meeting(outlook, subject, first_occurrence, 
2                           duration_minutes, recurrence_type, 
3                           attendees=None, end_date=None):
4    """
5    Create a recurring meeting.
6    
7    Args:
8        outlook: Outlook application object
9        subject: Meeting title
10        first_occurrence: datetime for first meeting
11        duration_minutes: Meeting duration
12        recurrence_type: 'daily', 'weekly', 'monthly'
13        attendees: List of email addresses
14        end_date: When to stop recurring (None = no end)
15    
16    Returns:
17        Created recurring appointment
18    """
19    try:
20        appointment = outlook.CreateItem(1)
21        
22        appointment.Subject = subject
23        appointment.Start = first_occurrence
24        appointment.Duration = duration_minutes
25        
26        # Set recurrence pattern
27        recurrence = appointment.GetRecurrencePattern()
28        
29        if recurrence_type.lower() == 'daily':
30            recurrence.RecurrenceType = 0  # olRecursDaily
31            recurrence.Interval = 1
32        
33        elif recurrence_type.lower() == 'weekly':
34            recurrence.RecurrenceType = 1  # olRecursWeekly
35            recurrence.Interval = 1
36            recurrence.DayOfWeekMask = 2  # Monday (2=olMonday)
37        
38        elif recurrence_type.lower() == 'monthly':
39            recurrence.RecurrenceType = 2  # olRecursMonthly
40            recurrence.Interval = 1
41            recurrence.DayOfMonth = first_occurrence.day
42        
43        # Set end date if provided
44        if end_date:
45            recurrence.PatternEndDate = end_date
46        else:
47            recurrence.NoEndDate = True
48        
49        # Add attendees if provided
50        if attendees:
51            for email in attendees:
52                recipient = appointment.Recipients.Add(email)
53                recipient.Type = 1
54            appointment.Recipients.ResolveAll()
55            appointment.MeetingStatus = 1
56        
57        appointment.Save()
58        print(f"✅ Recurring meeting created: {subject}")
59        
60        return appointment
61    
62    except Exception as e:
63        print(f"❌ Error creating recurring meeting: {e}")
64        return None
65
66# Example: Weekly team standup
67next_monday = datetime.now() + timedelta(days=(7 - datetime.now().weekday()))
68next_monday = next_monday.replace(hour=9, minute=0, second=0)
69
70recurring_meeting = create_recurring_meeting(
71    outlook=outlook,
72    subject="Weekly Team Standup",
73    first_occurrence=next_monday,
74    duration_minutes=15,
75    recurrence_type='weekly',
76    attendees=["team@company.com"]
77)

1#!/usr/bin/env python3
2"""
3Outlook Calendar Automation
4Automate meeting scheduling, availability checking, and calendar management.
5"""
6
7import win32com.client
8import pythoncom
9from datetime import datetime, timedelta
10
11
12class OutlookCalendarAutomation:
13    """Automate Outlook calendar operations."""
14    
15    def __init__(self):
16        """Initialize Outlook connection."""
17        pythoncom.CoInitialize()
18        self.outlook = win32com.client.Dispatch("Outlook.Application")
19        self.namespace = self.outlook.GetNamespace("MAPI")
20        self.calendar = self.namespace.GetDefaultFolder(9)  # 9 = Calendar
21    
22    def create_meeting(self, subject, start_time, duration_minutes,
23                      attendees=None, location="", body="", 
24                      reminder_minutes=15):
25        """Create a calendar meeting or appointment."""
26        appointment = self.outlook.CreateItem(1)
27        
28        appointment.Subject = subject
29        appointment.Start = start_time
30        appointment.Duration = duration_minutes
31        appointment.Location = location
32        appointment.Body = body
33        appointment.ReminderSet = True
34        appointment.ReminderMinutesBeforeStart = reminder_minutes
35        
36        if attendees:
37            for email in attendees:
38                recipient = appointment.Recipients.Add(email)
39                recipient.Type = 1
40            appointment.Recipients.ResolveAll()
41            appointment.MeetingStatus = 1
42        
43        appointment.Save()
44        return appointment
45    
46    def get_busy_times(self, date):
47        """Get all busy periods for a date."""
48        start = date.replace(hour=0, minute=0, second=0)
49        end = date.replace(hour=23, minute=59, second=59)
50        
51        appointments = self.calendar.Items
52        appointments.IncludeRecurrences = True
53        restriction = f"[Start] >= '{start}' AND [End] <= '{end}'"
54        filtered = appointments.Restrict(restriction)
55        
56        busy_times = []
57        for apt in filtered:
58            if apt.BusyStatus in [2, 3]:
59                busy_times.append((apt.Start, apt.End))
60        
61        return busy_times
62    
63    def find_next_available(self, duration_minutes, start_hour=9, 
64                          end_hour=17, days_ahead=7):
65        """Find next available time slot."""
66        for day_offset in range(days_ahead):
67            check_date = datetime.now() + timedelta(days=day_offset)
68            
69            # Skip weekends
70            if check_date.weekday() >= 5:
71                continue
72            
73            busy = self.get_busy_times(check_date)
74            
75            current = check_date.replace(hour=start_hour, minute=0)
76            end = check_date.replace(hour=end_hour, minute=0)
77            
78            while current < end:
79                slot_end = current + timedelta(minutes=duration_minutes)
80                
81                available = True
82                for busy_start, busy_end in busy:
83                    if current < busy_end and slot_end > busy_start:
84                        available = False
85                        break
86                
87                if available:
88                    return current
89                
90                current += timedelta(minutes=30)
91        
92        return None
93    
94    def schedule_smart_meeting(self, subject, duration_minutes, 
95                             attendees, body=""):
96        """Automatically find time and schedule meeting."""
97        available_time = self.find_next_available(duration_minutes)
98        
99        if not available_time:
100            print("❌ No available time found in next 7 days")
101            return None
102        
103        return self.create_meeting(
104            subject=subject,
105            start_time=available_time,
106            duration_minutes=duration_minutes,
107            attendees=attendees,
108            body=body
109        )
110
111
112def main():
113    """Example usage."""
114    
115    # Initialize automation
116    calendar = OutlookCalendarAutomation()
117    
118    # Example 1: Create a simple meeting tomorrow at 2 PM
119    tomorrow_2pm = datetime.now().replace(hour=14, minute=0) + timedelta(days=1)
120    meeting1 = calendar.create_meeting(
121        subject="Project Review",
122        start_time=tomorrow_2pm,
123        duration_minutes=60,
124        attendees=["colleague@company.com"],
125        location="Zoom",
126        body="Let's review project progress and next steps."
127    )
128    print(f"✅ Created: {meeting1.Subject}")
129    
130    # Example 2: Smart scheduling - finds next available time
131    meeting2 = calendar.schedule_smart_meeting(
132        subject="Client Strategy Session",
133        duration_minutes=90,
134        attendees=["client@example.com", "manager@company.com"],
135        body="Quarterly strategy discussion"
136    )
137    if meeting2:
138        print(f"✅ Auto-scheduled for: {meeting2.Start}")
139    
140    # Example 3: Check availability for specific date
141    check_date = datetime.now() + timedelta(days=2)
142    busy_times = calendar.get_busy_times(check_date)
143    print(f"\n📅 Busy times on {check_date.strftime('%Y-%m-%d')}:")
144    for start, end in busy_times:
145        print(f"  {start.strftime('%I:%M %p')} - {end.strftime('%I:%M %p')}")
146
147
148if __name__ == "__main__":
149    main()

1def schedule_weekly_reports():
2    """Schedule recurring Friday afternoon report meetings."""
3    calendar = OutlookCalendarAutomation()
4    
5    # Find next Friday
6    days_ahead = (4 - datetime.now().weekday()) % 7
7    next_friday = datetime.now() + timedelta(days=days_ahead)
8    next_friday = next_friday.replace(hour=15, minute=0, second=0)
9    
10    recurrence = calendar.outlook.CreateItem(1)
11    recurrence.Subject = "Weekly Status Reports"
12    recurrence.Start = next_friday
13    recurrence.Duration = 30
14    
15    pattern = recurrence.GetRecurrencePattern()
16    pattern.RecurrenceType = 1  # Weekly
17    pattern.DayOfWeekMask = 16  # Friday
18    pattern.NoEndDate = True
19    
20    recurrence.Save()
21    print("✅ Weekly meeting scheduled")

1def schedule_interview_rounds(candidates, duration=60):
2    """Schedule interviews for multiple candidates."""
3    calendar = OutlookCalendarAutomation()
4    
5    scheduled = []
6    for candidate in candidates:
7        available = calendar.find_next_available(duration)
8        
9        if available:
10            meeting = calendar.create_meeting(
11                subject=f"Interview: {candidate['name']}",
12                start_time=available,
13                duration_minutes=duration,
14                attendees=[candidate['email'], "hr@company.com"],
15                body=f"Interview for {candidate['position']} position"
16            )
17            scheduled.append((candidate['name'], available))
18        
19    return scheduled