def run(self, request\_type):
 
 """
 Entry point for campaign selection and list processing to send emails
 processing:
 1. active properties are fetched
 2. non global notification of these properties are fetched
 3. call to function to process satisfying entities

 Parameters
 ----------
 request\_type : str
 this parameter is determining what kind of journey campaigns we are sending, possible values are staymx, feedback and custom

 Returns
 -------
 """
 # self.logger.info("Returning property notification mapping")
 
 properties = list(self.db\_handler.properties.find({"active": True}, {"\_id": 1}))
 property\_ids = [str(item.get("\_id")) for item in properties]
 
 # self.logger.info('Total properties %s'%(len(property\_ids)))
 
 if request\_type == "staymx":
 distinct\_property\_ids = self.db\_handler.staymx\_property\_reservations.distinct("property\_id")
 elif request\_type == "feedback":
 distinct\_property\_ids = self.db\_handler.feedback\_survey\_responses.distinct("property\_id")
 
 if request\_type in ["staymx", "feedback"]:
 def is\_reservation\_available(property\_id):
 return property\_id in distinct\_property\_ids
 
 property\_ids = [property\_id for property\_id in property\_ids if is\_reservation\_available(property\_id)]
 
 # self.logger.info('Total properties after filter %s' % (len(property\_ids)))
 
 query = {
 "active": True,
 "global": {"$ne": True},
 "sources": request\_type,
 "property\_id": {"$in": property\_ids},
 "is\_draft": {"$ne": True}
 }
 
 fields = {"property\_id": 1, "notification\_type": 1, "global": 1, "survey\_id": 1}
 
 notifications = list(self.db\_handler.default\_system\_notifications.find(query, fields))
 
 self.logger.info("Total notification requests to process : " + str(len(notifications)))
 
 collection\_queue = "default\_system\_notification\_temp\_queue"
 
 # Insert queued to true for all notifications
 self.prepare\_notification\_requests(request\_type=request\_type, notifications=notifications)

 
 late\_processed = {
 'active': {'$ne': False}
 }
 
 request\_pending\_execution = list(self.marketing\_db\_handler[collection\_queue].
 find(late\_processed, {"\_id": 1}).limit(10).sort('last\_updated\_at', 1))
 
 self.\_\_execute\_request\_list(request\_list=request\_pending\_execution, request\_type=request\_type, delay=False)
 
 request\_query = {
 'queued': True,
 'is\_running': {"$ne": True},
 "source": request\_type
 }
 
 request\_list = list(
 self.marketing\_db\_handler[collection\_queue].find(request\_query, {"\_id": 1}).limit(500).sort('timestamp', 1))
 
 self.logger.info("Total request list : %s " % (len(request\_list)))
 
 request\_list = [str(request.get("\_id")) for request in request\_list]
 
 for request in request\_list:
 try:
 task\_id = None
 if request\_type == "staymx":
 handle\_staymx\_notifications.send\_with\_options(
 args=(request,),
 on\_failure=log\_error,
 on\_success=log\_result,
 )

 elif request\_type == "feedback":
 task\_id = handle\_feedback\_notifications.send\_with\_options(
 args=(request,),
 on\_failure=log\_error,
 on\_success=log\_result,
 )
 elif request\_type == "custom":
 task\_id = handle\_custom\_notifications.send\_with\_options(
 args=(request,),
 on\_failure=log\_error,
 on\_success=log\_result,
 )
 
 self.logger.info("Task id: %s" % (request))
 update = self.marketing\_db\_handler[collection\_queue].update({"\_id": ObjectId(request)}, {
 "$set": {"task\_id": str(task\_id), "task\_added\_at": datetime.utcnow()}})
 
 except:
 self.logger.info(format("Final traceback output : ", traceback.format\_exc()))
 
 # Update all requests to picked and running status if not running
 self.update\_all\_request\_running(request\_list)
 self.\_\_execute\_delayed\_tasks(
 notifications=notifications,
 request\_type=request\_type
 )

-----
This code handles queuing of default system notifications and manage their efficient executions

1. Pick all notifications to be delivered
 1, Pick active properties
 2. Pick active notifications as per configuration (staymx, feedback, custom)
2. Queue notifications 
 2. Prorities notifications
 3. Run notification on priority which are not running or was not able to picked up 
 4. In database queue all notifications and manage their states (Notification in queue, running, picked, processed)
 5. When queued, When came to running, When picked, When processed
3. To reduce traffice from notification database use cache database to query and fetch notifications 

consider yourself as experienced python developer please refractor this code and let us know the possible implementations
0982e39f-758c-4022-863c-7831af244eba
```python
def run(self, request_type):
```

Точка входа для выбора кампании и обработки списка для обработки отправки электронных писем:

1. Извлекаются активные свойства извлекаются
2. Неглобальные уведомления об этих свойствах 
3. Вызов функции для обработки удовлетворяющих сущностей

## Параметры

```python
request_type : str
```
Этот параметр определяет, какие туристические кампании мы отправляем, возможными значениями являются `staymx`, обратная связь и пользовательские.

## Returns

```python
self.logger.info("Returning property notification mapping")
properties = list(self.db_handler.properties.find({"active": True}, {"_id": 1}))
property_ids = [str(item.get("_id")) for item in properties]

self.logger.info('Total properties %s'%(len(property_ids)))
if request_type == "staymx":
distinct_property_ids = self.db_handler.staymx_property_reservations.distinct("property_id")
elif request_type == "feedback":
distinct_property_ids = self.db_handler.feedback_survey_responses.distinct("property_id")

if request_type in ["staymx", "feedback"]:
def is_reservation_available(property_id):
return property_id in distinct_property_ids

property_ids = [property_id for property_id in property_ids if is_reservation_available(property_id)]

self.logger.info('Total properties after filter %s' % (len(property_ids)))
query = {
"active": True,
"global": {"$ne": True},
"sources": request_type,
"property_id": {"$in": property_ids},
"is_draft": {"$ne": True}
}

fields = {"property_id": 1, "notification_type": 1, "global": 1, "survey_id": 1}

notifications = list(self.db_handler.default_system_notifications.find(query, fields))

self.logger.info("Total notification requests to process : " + str(len(notifications)))

collection_queue = "default_system_notification_temp_queue"

# Insert queued to true for all notifications

self.prepare_notification_requests(request_type=request_type, notifications=notifications)

late_processed = {
'active': {'$ne': False}
}

request_pending_execution = list(self.marketing_db_handler[collection_queue].
find(late_processed, {"_id": 1}).limit(10).sort('last_updated_at', 1))

self.__execute_request_list(request_list=request_pending_execution, request_type=request_type, delay=False)

request_query = {
'queued': True,
'is_running': {"$ne": True},
"source": request_type
}

request_list = list(
self.marketing_db_handler[collection_queue].find(request_query, {"_id": 1}).limit(500).sort('timestamp', 1))

self.logger.info("Total request list : %s " % (len(request_list)))

request_list = [str(request.get("_id")) for request in request_list]

for request in request_list:
try:
task_id = None
if request_type == "staymx":
handle_staymx_notifications.send_with_options(
args=(request,),
on_failure=log_error,
on_success=log_result,
)

elif request_type == "feedback":
task_id = handle_feedback_notifications.send_with_options(
args=(request,),
on_failure=log_error,
on_success=log_result,
)
elif request_type == "custom":
task_id = handle_custom_notifications.send_with_options(
args=(request,),
on_failure=log_error,
on_success=log_result,
)

self.logger.info("Task id: %s" % (request))
update = self.marketing_db_handler[collection_queue].update({"_id": ObjectId(request)}, {
"$set": {"task_id": str(task_id), "task_added_at": datetime.utcnow()}})

except:
self.logger.info(format("Final traceback output : ", traceback.format_exc()))

# Update all requests to picked and running status if not running

self.update_all_request_running(request_list)
self.__execute_delayed_tasks(
notifications=notifications,
request_type=request_type
)
```

Этот код обрабатывает постановку в очередь системных уведомлений по умолчанию и управляет их эффективным выполнением

1. Выберите все уведомления, которые должны быть доставлены. 
      - Выберите активные свойства
2. Выберите активные уведомления в соответствии с конфигурацией (staymx, обратная связь, пользовательские)
3. Уведомления в очереди
4. Уведомления о приоритетах
5. Запускать уведомления по приоритету, которые не запущены или не удалось получить
6. В базе данных поставить в очередь все уведомления и управлять их состояниями (Уведомление в очереди, запущено, выбрано, обработано)
7. Когда поставлено в очередь, Когда пришло к запуску, когда выбрано, когда обработано
8. Чтобы уменьшить трафик из базы данных уведомлений, используйте базу данных кэша для запроса и извлечения уведомлений

Считайте себя опытным разработчиком python, пожалуйста, переработайте этот код и сообщите нам о возможных реализациях

submitted
def(self, request\_type): """ Входный пункт для отбора кампании и обработки запросов для отправки электронных писем: "Анонсирование уведомления" Определение активных свойств: 1. получено активные свойства.
{"source": "ewof/sharegpt-instruct-unfiltered-deduped", "kind": "human", "evolved_from": null}