docs: def edit(self, name=None, description=None, start_date=None, due_date=None, assignees=None, status=None):
          """Edit the details of an activity.
  
          :param name: (optionally) edit the name of the activity
          :type name: basestring or None
          :param description: (optionally) edit the description of the activity
          :type description: basestring or None
          :param start_date: (optionally) edit the start date of the activity as a datetime object (UTC time/timezone
                              aware preferred)
          :type start_date: datetime or None
          :param due_date: (optionally) edit the due_date of the activity as a datetime object (UTC time/timzeone
                              aware preferred)
          :type due_date: datetime or None
          :param assignees: (optionally) edit the assignees of the activity as a list, will overwrite all assignees
          :type assignees: list(basestring) or None
          :param status: (optionally) edit the status of the activity as a string based
                         on :class:`~pykechain.enums.ActivityType`
          :type status: basestring or None
  
          :raises NotFoundError: if a `username` in the list of assignees is not in the list of scope members
          :raises IllegalArgumentError: if the type of the inputs is not correct
          :raises APIError: if another Error occurs
          :warns: UserWarning - When a naive datetime is provided. Defaults to UTC.
  
          Example
          -------
          >>> from datetime import datetime
          >>> my_task = project.activity('Specify the wheel diameter')
          >>> my_task.edit(name='Specify wheel diameter and circumference',
          ...              description='The diameter and circumference are specified in inches',
          ...              start_date=datetime.utcnow(),  # naive time is interpreted as UTC time
          ...              assignee='testuser')
  
          If we want to provide timezone aware datetime objects we can use the 3rd party convenience library :mod:`pytz`.
          Mind that we need to fetch the timezone first and use `<timezone>.localize(<your datetime>)` to make it
          work correctly.
  
          Using `datetime(2017,6,1,23,59,0 tzinfo=<tz>)` does NOT work for most timezones with a
          daylight saving time. Check the `pytz <http://pythonhosted.org/pytz/#localized-times-and-date-arithmetic>`_
          documentation.
  
          To make it work using :mod:`pytz` and timezone aware :mod:`datetime` see the following example::
  
          >>> import pytz
          >>> start_date_tzaware = datetime.now(pytz.utc)
          >>> mytimezone = pytz.timezone('Europe/Amsterdam')
          >>> due_date_tzaware = mytimezone.localize(datetime(2019, 10, 27, 23, 59, 0))
          >>> my_task.edit(due_date=due_date_tzaware, start_date=start_date_tzaware)
  
          """
          update_dict = {'id': self.id}
          if name:
              if isinstance(name, (str, text_type)):
                  update_dict.update({'name': name})
                  self.name = name
              else:
                  raise IllegalArgumentError('Name should be a string')
  
          if description:
              if isinstance(description, (str, text_type)):
                  update_dict.update({'description': description})
                  self.description = description
              else:
                  raise IllegalArgumentError('Description should be a string')
  
          if start_date:
              if isinstance(start_date, datetime.datetime):
                  if not start_date.tzinfo:
                      warnings.warn("The startdate '{}' is naive and not timezone aware, use pytz.timezone info. "
                                    "This date is interpreted as UTC time.".format(start_date.isoformat(sep=' ')))
                  update_dict.update({'start_date': start_date.isoformat(sep='T')})
              else:
                  raise IllegalArgumentError('Start date should be a datetime.datetime() object')
  
          if due_date:
              if isinstance(due_date, datetime.datetime):
                  if not due_date.tzinfo:
                      warnings.warn("The duedate '{}' is naive and not timezone aware, use pytz.timezone info. "
                                    "This date is interpreted as UTC time.".format(due_date.isoformat(sep=' ')))
                  update_dict.update({'due_date': due_date.isoformat(sep='T')})
              else:
                  raise IllegalArgumentError('Due date should be a datetime.datetime() object')
  
          if assignees:
              if isinstance(assignees, list):
                  project = self._client.scope(pk=self.scope_id, status=None)
                  members_list = [member['username'] for member in project._json_data['members']]
                  for assignee in assignees:
                      if assignee not in members_list:
                          raise NotFoundError("Assignee '{}' should be a member of the scope".format(assignee))
                  update_dict.update({'assignees': assignees})
              else:
                  raise IllegalArgumentError('Assignees should be a list')
  
          if status:
              if isinstance(status, (str, text_type)) and status in ActivityStatus.values():
                  update_dict.update({'status': status})
              else:
                  raise IllegalArgumentError('Status should be a string')
  
          url = self._client._build_url('activity', activity_id=self.id)
          r = self._client._request('PUT', url, json=update_dict)
  
          if r.status_code != requests.codes.ok:  # pragma: no cover
              raise APIError("Could not update Activity ({})".format(r))
  
          if status:
              self._json_data['status'] = str(status)
          if assignees:
              self._json_data['assignees'] = assignees
          if due_date:
              self._json_data['due_date'] = str(due_date)
          if start_date:
              self._json_data['start_date'] = str(start_date)