docs: def create_service(self, name, scope, description=None, version=None,
                         service_type=ServiceType.PYTHON_SCRIPT,
                         environment_version=ServiceEnvironmentVersion.PYTHON_3_5,
                         pkg_path=None):
          """
          Create a Service.
  
          A service can be created only providing the name (and scope). Other information can be added later.
          If you provide a path to the `kecpkg` (or python script) to upload (`pkg_path`) on creation,
          this `kecpkg` will be uploaded in one go. If the later fails, the service is still there, and the package is
          not uploaded.
  
          Permission to upload a script is restricted to a superuser, a user in the `GG:Configurators` group and a Scope
          Manager of the scope to which you are uploading the script.
  
          :param name: Name of the service
          :type name: basestring
          :param scope: Scope where the create the Service under
          :type scope: :class:`models.Scope`
          :param description: (optional) description of the Service
          :type description: basestring or None
          :param version: (optional) version information of the Service
          :type version: basestring or None
          :param service_type: (optional) service type of the service (refer to :class:`pykechain.enums.ServiceType`),
                               defaults to `PYTHON_SCRIPT`
          :type service_type: basestring or None
          :param environment_version: (optional) execution environment of the service (refer to
           :class:`pykechain.enums.ServiceEnvironmentVersion`), defaults to `PYTHON_3_5`
          :type environment_version: basestring or None
          :param pkg_path: (optional) full path name to the `kecpkg` (or python script) to upload
          :type pkg_path: basestring or None
          :return: the created :class:`models.Service`
          :raises IllegalArgumentError: When the provided arguments are incorrect
          :raises APIError: In case of failure of the creation or failure to upload the pkg_path
          :raises OSError: In case of failure to locate the `pkg_path`
          """
          if service_type not in ServiceType.values():
              raise IllegalArgumentError("The type should be of one of {}".format(ServiceType.values()))
  
          if environment_version not in ServiceEnvironmentVersion.values():
              raise IllegalArgumentError("The environment version should be of one of {}".
                                         format(ServiceEnvironmentVersion.values()))
  
          data = {
              "name": name,
              "scope": scope,
              "description": description,
              "script_type": service_type,
              "script_version": version,
              "env_version": environment_version,
          }
  
          response = self._request('POST', self._build_url('services'),
                                   data=data)
  
          if response.status_code != requests.codes.created:  # pragma: no cover
              raise APIError("Could not create service ({})".format((response, response.json())))
  
          service = Service(response.json().get('results')[0], client=self)
  
          if pkg_path:
              # upload the package
              service.upload(pkg_path)
  
          # refresh service contents in place
          service.refresh()
  
          return service