https://developer.zendesk.com/rest_api/docs/core/group_memberships#delete-membership
324032
def group_membership_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/group_memberships/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
590071
def GroupsDelete(self, group_id):
        
        if self.__SenseApiCall__('/groups/{0}.json'.format(group_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
1302564
def delete(options = {})
      options = options.merge(
        group_name: @group_name,
        policy_name: @name
      )
      resp = @client.delete_group_policy(options)
      resp.data
    end
218023
def remove_user_from_group(self, username, groupname):
        
        url = self._options['server'] + '/rest/api/latest/group/user'
        x = {'groupname': groupname,
             'username': username}

        self._session.delete(url, params=x)

        return True
64731
@DELETE
    @Path("/{name}" + ServerAPI.GET_CORPORATE_GROUPIDS)
    public Response removeCorporateGroupIdPrefix(@Auth final DbCredential credential, @PathParam("name") final String organizationId, final String corporateGroupId){
        LOG.info("Got an remove a corporate groupId prefix request for organization " + organizationId +".");
        if(!credential.getRoles().contains(DbCredential.AvailableRoles.DATA_UPDATER)){
            throw new WebApplicationException(Response.status(Response.Status.UNAUTHORIZED).build());
        }

        if(corporateGroupId == null || corporateGroupId.isEmpty()){
            LOG.error("No corporate GroupId to remove!");
            return Response.serverError().status(HttpStatus.BAD_REQUEST_400).build();
        }

        getOrganizationHandler().removeCorporateGroupId(organizationId, corporateGroupId);

        return Response.ok("done").build();
    }
1337795
def deletegroup(self, group_id):
        
        request = requests.delete(
            '{0}/{1}'.format(self.groups_url, group_id),
            headers=self.headers, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        return request.status_code == 200
1185438
function deleteGroup(connections, options, groupParams, cb) {
  var validate = validation(groupParams);
  function validateParams(cb) {
    validate.has("_id", cb);
  }
  validateParams(function(err) {
    if (err) {
      return cb(err);
    }
    var conn = connections.mongooseConnection;
    var groupsModel = models.get(conn, models.MODELNAMES.GROUPS);
    groupsModel.findById(groupParams._id).remove(cb);
  });
}
4183
def group_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/groups/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
941205
def group_memberships(self, group_id, **kwargs):
        ""
        api_path = "/api/v2/groups/{group_id}/memberships.json"
        api_path = api_path.format(group_id=group_id)
        return self.call(api_path, **kwargs)
308342
public Response deleteMemberGroup(String roomName, String groupName) {
        return restClient.delete("chatrooms/" + roomName + "/members/group/" + groupName,
                new HashMap<String, String>());
    }
89988
private Membership removeMembership(Session session, String id, boolean broadcast) throws Exception
   {
      MembershipByUserGroupTypeWrapper mWrapper;
      try
      {
         mWrapper = findMembership(session, id);
      }
      catch (ItemNotFoundException e)
      {
         return null;
      }
      catch (PathNotFoundException e)
      {
         return null;
      }

      if (broadcast)
      {
         preDelete(mWrapper.membership);
      }

      removeMembership(mWrapper.refUserNode, mWrapper.refTypeNode);
      session.save();

      removeFromCache(mWrapper.membership);

      if (broadcast)
      {
         postDelete(mWrapper.membership);
      }

      return mWrapper.membership;
   }
848258
def member_del(self, cluster_id, member_id):
        """"""
        cluster = self._storage[cluster_id]
        result = cluster.member_remove(member_id)
        self._storage[cluster_id] = cluster
        return result
325305
def del_membership(self, user, role):
        
        if not self.has_membership(user, role):
            return True
        targetRecord = AuthMembership.objects(creator=self.client, user=user).first()
        if not targetRecord:
            return True
        for group in targetRecord.groups:
            if group.role==role:
                targetRecord.groups.remove(group)
        targetRecord.save()
        return True
656282
function deleteUser(username, done) {
  return getUser(username, function(getUserErr, user) {
    if (getUserErr) {
      return done(getUserErr);
    }

    if (!user) {
      return done(new Error(`user '${username}' not found`));
    }

    user.tokens.forEach((token) => token.destroy());
    user.groups.forEach((group) => { group.members.remove(user.id); group.save(); });
    user.leading.forEach((group) => { group.leaders.remove(user.id); group.save(); });
    user.destroy(done);
  });
}
79932
@Path("/{solutionId}/{memberType}/{memberId}")
    @ApiOperation(value="Delete a solution or remove a member from a solution",
        notes="Supported memberTypes: requests, tasks, processes, solutions.", response=StatusMessage.class)
    public JSONObject delete(String path, JSONObject content, Map<String,String> headers)
    throws ServiceException, JSONException {
        String id = getSegment(path, 1);
        String rel = getSegment(path, 2);

        SolutionServices solutionServices = ServiceLocator.getSolutionServices();
        if (rel == null) {
            solutionServices.deleteSolution(id);
        }
        else if (rel.equals("requests")) {
            String requestId = getSegment(path, 3);
            solutionServices.removeMemberFromSolution(id, MemberType.MasterRequest, requestId);
        }
        else if (rel.equals("tasks")) {
            String taskInstanceId = getSegment(path, 3);
            solutionServices.removeMemberFromSolution(id, MemberType.TaskInstance, taskInstanceId);
        }
        else if (rel.equals("processes")) {
            String processInstanceId = getSegment(path, 3);
            solutionServices.removeMemberFromSolution(id, MemberType.ProcessInstance, processInstanceId);
        }
        else if (rel.equals("solutions")) {
            String taskInstanceId = getSegment(path, 3);
            solutionServices.removeMemberFromSolution(id, MemberType.Solution, taskInstanceId);
        }
        return null;
    }
942900
def remove_group(id):
    
    acl_url = urljoin(_acl_url(), 'groups/{}'.format(id))
    try:
        r = http.delete(acl_url)
        print(r.status_code)
    except DCOSHTTPException as e:
        if e.response.status_code != 400:
            raise
1147468
def remove_from_group(self, group, user):
        
        data = {'group': group, 'user': user}
        return self.post('removeUserFromGroup', data)