church_of_jesus_christ_api package

Submodules

church_of_jesus_christ_api.church_of_jesus_christ_api module

The module that implements ChurchOfJesusChristAPI. This module allows the user to get data from churchofjesuschrist.org.

class church_of_jesus_christ_api.church_of_jesus_christ_api.ChurchOfJesusChristAPI(username: str, password: str, proxies: dict[str, str] = None, verify_SSL: bool = None, timeout_sec: int = None)

Bases: object

A class used to interact with features found on churchofjesuschrist.org, such as getting member data, calling information, reports, etc.

convert_date_to_string_using_default_date_if_none(val, default)
download_member_photo(uuid: str = None, timeout_sec: int = None) bytes | None

Returns the raw bytes for a member’s photo in JPEG format

Parameters

uuid: str

The given member’s uuid

timeout_secint

Number of seconds to wait for a response when making a request

Returns

The raw bytes for the member’s photo, if available. None if no photo is available, throws an exception if an error occurs

get_action_and_interviews(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit action and interview list

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  data: [
    {
      items: [
        {
          age: int,
          birthdate: str,
          birthdateFormatted: str,
          email: NoneType,
          gender: str,
          husband: NoneType,
          interviewDate: NoneType,
          interviewDateDisplay: NoneType,
          name: str,
          personId: str,
          phoneNumber: str,
          status: str,
          statusDisplay: str,
          suggestedAction: str,
          suggestedActionDisplay: str,
          unitName: str,
          unitNumber: int,
          wife: NoneType
        }
      ],
      sectionTypeKey: str,
      tab: str
    }
  ]
}
get_assigned_missionaries(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns a list of the missionaries currently assigned to serve in the unit

Parameters unit : int

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    accountable: bool,
    actualAge: NoneType,
    actualAgeInMonths: NoneType,
    age: NoneType,
    birthDate: NoneType,
    birthDateFormatted: str,
    birthDateSort: NoneType,
    birthDayFormatted: NoneType,
    birthDaySort: NoneType,
    email: str,
    formattedMrn: NoneType,
    gender: NoneType,
    genderCode: NoneType,
    genderLabelShort: str,
    id: int,
    missionOfficeAddress: NoneType,
    missionUnitName: str,
    missionUnitNumber: int,
    mrn: NoneType,
    name: str,
    nameOrder: NoneType,
    nonMember: bool,
    notAccountable: bool,
    outOfUnitMember: bool,
    phone: str,
    priesthood: NoneType,
    priesthoodCode: NoneType,
    priesthoodType: NoneType,
    setApart: bool,
    spokenName: NoneType,
    sustainedDate: NoneType,
    unitName: NoneType,
    unitNumber: NoneType,
    urlAddressSearch: NoneType,
    visible: NoneType
  }
]
get_attendance(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the attendance list for the last 5 weeks

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  allAvailableDates: [
    {
      epochSeconds: int,
      isoYearMonthDay: str,
      loaded: bool,
      localeMonthDay: str
    }
  ],
  attendanceData: {
    attendees: [
      {
        cmisId: int,
        displayName: str,
        entries: [
          {
            date: {
              epochSeconds: int,
              isoYearMonthDay: str,
              loaded: bool,
              localeMonthDay: str
            },
            isMarkedAttended: bool,
            markedAttended: bool
          }
        ],
        gender: str,
        sortName: str,
        unitOrgsCombined: [
          str
        ],
        uuid: str
      }
    ],
    visitorCategories: [
      {
        countsByDate: {
          2024-06-16: int,
          2024-06-23: int,
          2024-06-30: int,
          2024-07-07: int,
          2024-07-14: int
        },
        displayName: str,
        name: str
      }
    ]
  },
  dates: [
    {
      epochSeconds: int,
      isoYearMonthDay: str,
      loaded: bool,
      localeMonthDay: str
    }
  ]
}
get_attendance_date_range(start_date: date = None, end_date: date = None, unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the attendance list for a given date range (default 1 year ago to today)

Parameters

start_date: datetime.date

The start date after which attendance will be retrieved

end_date: datetime.date

The end date after which attendance will no longer be retrieved

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  allAvailableDates: NoneType,
  attendanceData: {
    attendees: [
      {
        cmisId: NoneType,
        displayName: NoneType,
        entries: [
          {
            date: {
              epochSeconds: int,
              isoYearMonthDay: str,
              loaded: bool,
              localeMonthDay: str
            },
            isMarkedAttended: bool,
            markedAttended: bool
          }
        ],
        gender: NoneType,
        sortName: NoneType,
        unitOrgsCombined: NoneType,
        uuid: str
      }
    ],
    visitorCategories: [
      {
        countsByDate: {
          2023-07-09: int,
          2023-07-16: int,
          2023-07-23: int,
          2023-07-30: int,
          2023-08-06: int,
          2023-08-13: int,
          2023-08-20: int,
          2023-08-27: int,
          2023-09-03: int,
          2023-09-10: int,
          2023-09-17: int,
          2023-09-24: int,
          2023-10-01: int,
          2023-10-08: int,
          2023-10-15: int,
          2023-10-22: int,
          2023-10-29: int,
          2023-11-05: int,
          2023-11-12: int,
          2023-11-19: int,
          2023-11-26: int,
          2023-12-03: int,
          2023-12-10: int,
          2023-12-17: int,
          2023-12-24: int,
          2023-12-31: int,
          2024-01-07: int,
          2024-01-14: int,
          2024-01-21: int,
          2024-01-28: int,
          2024-02-04: int,
          2024-02-11: int,
          2024-02-18: int,
          2024-02-25: int,
          2024-03-03: int,
          2024-03-10: int,
          2024-03-17: int,
          2024-03-24: int,
          2024-03-31: int,
          2024-04-07: int,
          2024-04-14: int,
          2024-04-21: int,
          2024-04-28: int,
          2024-05-05: int,
          2024-05-12: int,
          2024-05-19: int,
          2024-05-26: int,
          2024-06-02: int,
          2024-06-09: int,
          2024-06-16: int,
          2024-06-23: int,
          2024-06-30: int,
          2024-07-07: int,
          2024-07-14: int
        },
        displayName: str,
        name: str
      }
    ]
  },
  dates: NoneType
}
get_birthdays(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit birthday list

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    birthdays: [
      {
        accountable: bool,
        actualAge: int,
        actualAgeInMonths: int,
        address: str,
        age: int,
        birthDate: str,
        birthDateFormatted: str,
        birthDateSort: str,
        birthDayAge: int,
        birthDayFormatted: str,
        birthDaySort: str,
        dayInteger: int,
        displayBirthdate: str,
        email: NoneType,
        formattedMrn: NoneType,
        gender: str,
        genderCode: int,
        genderLabelShort: str,
        id: int,
        monthInteger: int,
        mrn: NoneType,
        name: str,
        nameOrder: NoneType,
        nonMember: bool,
        notAccountable: bool,
        outOfUnitMember: bool,
        phone: str,
        priesthood: NoneType,
        priesthoodCode: NoneType,
        priesthoodType: NoneType,
        setApart: bool,
        spokenName: str,
        sustainedDate: NoneType,
        unitName: str,
        unitNumber: int,
        visible: NoneType
      }
    ]
  }
]
get_covenant_path_progress(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit covenant path progress record. Includes information about new members and non-members being taught by the missionaries

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  investigatorList: list,
  newMemberList: list,
  parentUnit: bool,
  readOnly: bool
}
get_directory(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit directory of households

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    address: str,
    coordinates: {
      latitude: float,
      longitude: float
    },
    editable: bool,
    members: [
      {
        countryId: int,
        displayName: str,
        editable: bool,
        email: {
          email: str
        },
        givenName: str,
        head: bool,
        householdUuid: str,
        name: str,
        phone: {
          country: int,
          e164: str,
          number: str
        },
        privacy: {
          birthDate: str,
          email: str,
          phone: str,
          photo: str
        },
        surname: str,
        unitNumber: int,
        uuid: str
      }
    ],
    movable: bool,
    name: str,
    privacy: {
      address: str,
      coordinates: str,
      photo: str
    },
    surname: str,
    unitNumber: int,
    uuid: str,
    verified: bool
  }
]
get_family_history_report(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit family history report

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  error: bool,
  participationReports: {
    addedAncestor: [
      {
        label: NoneType,
        membersAddingAncestor: int,
        monthEndDate: str,
        monthEndDisplayLabel: str,
        title: str
      }
    ],
    addedMemory: [
      {
        label: NoneType,
        membersAddingMemory: int,
        monthEndDate: str,
        monthEndDisplayLabel: str,
        title: str
      }
    ],
    loggingIn: [
      {
        label: NoneType,
        membersLoggingIn: int,
        monthEndDate: str,
        monthEndDisplayLabel: str,
        title: NoneType
      }
    ],
    membersWhoIndexed: [
      {
        label: NoneType,
        membersIndexing: int,
        monthEndDate: str,
        monthEndDisplayLabel: str,
        title: str
      }
    ],
    percentageFourGen: [
      {
        label: NoneType,
        monthEndDate: str,
        monthEndDisplayLabel: str,
        percent: float,
        title: NoneType
      }
    ],
    yearsInReport: [
      str
    ]
  },
  reportDate: str,
  submitterTrendReport: {
    trendData: [
      {
        label: str,
        months: [
          {
            month: int,
            submitters: int
          }
        ],
        year: int
      }
    ],
    ytdDiffYearOverYear: int
  },
  ytdSubmittersReports: {
    monthEndDate: str,
    summary: {
      adultPercentage: str,
      adultSubmitters: int,
      convertPercentage: str,
      convertSubmitters: int,
      percentSubmitting: float,
      totalAdults: int,
      totalConverts: int,
      totalMembersSubmitting: int,
      totalPercentage: str,
      totalPotentialSubmitters: int,
      totalYouth: int,
      totalYsa: int,
      unitName: str,
      unitNumber: int,
      youthPercentage: str,
      youthSubmitters: int,
      ysaSubmitters: int,
      ysasPercentage: str
    },
    unitTotals: [
      {
        adultPercentage: str,
        adultSubmitters: int,
        convertPercentage: str,
        convertSubmitters: int,
        percentSubmitting: float,
        totalAdults: int,
        totalConverts: int,
        totalMembersSubmitting: int,
        totalPercentage: str,
        totalPotentialSubmitters: int,
        totalYouth: int,
        totalYsa: int,
        unitName: str,
        unitNumber: int,
        youthPercentage: str,
        youthSubmitters: int,
        ysaSubmitters: int,
        ysasPercentage: str
      }
    ]
  }
}
get_full_time_missionaries(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns a list of the members from the unit currently serving missions

Parameters unit : int

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    email: str,
    endDate: str,
    member: {
      accountable: bool,
      actualAge: int,
      actualAgeInMonths: int,
      age: int,
      birthDate: str,
      birthDateFormatted: str,
      birthDateSort: str,
      birthDayFormatted: str,
      birthDaySort: str,
      email: str,
      formattedMrn: NoneType,
      gender: str,
      genderCode: int,
      genderLabelShort: str,
      id: int,
      missionOfficeAddress: NoneType,
      missionUnitName: NoneType,
      missionUnitNumber: NoneType,
      mrn: NoneType,
      name: str,
      nameOrder: NoneType,
      nonMember: bool,
      notAccountable: bool,
      outOfUnitMember: bool,
      phone: str,
      priesthood: NoneType,
      priesthoodCode: NoneType,
      priesthoodType: NoneType,
      setApart: bool,
      spokenName: NoneType,
      sustainedDate: NoneType,
      unitName: NoneType,
      unitNumber: NoneType,
      urlAddressSearch: NoneType,
      visible: NoneType
    },
    missionName: str,
    missionOfficeAddress: NoneType,
    missionUnitNumber: int,
    missionaryHomeUnitName: str,
    missionaryHomeUnitNumber: int,
    missionaryIndividualId: int,
    missionaryName: str,
    myPlanComplete: NoneType,
    myPlanSharing: NoneType,
    myPlanUrl: NoneType,
    seniorMissionary: bool,
    startDate: str,
    status: str,
    urlAddressSearch: NoneType
  }
]
get_group_members(unit: int = None, org_id: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the members of a given group, as used by the LCR message/email application

Parameters

unitint

Number of the church unit for which to retrieve the report

org_idint

Number of the suborganization of the unit for which to retrieve the members list.

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  members: [
    {
      calling: NoneType,
      cmisIndividualId: int,
      emailAddress: str,
      mrn: NoneType,
      name: str,
      positionDisplayOrder: NoneType,
      unitName: NoneType,
      unsubscribedFromEmail: bool,
      validAddress: bool
    }
  ],
  showCallings: bool,
  showUnitName: bool
}
get_key_indicators(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit key indicators

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  quarters: [
    str
  ],
  statistics: [
    {
      label: str,
      name: str,
      stats: [
        int
      ]
    }
  ]
}
get_member_callings_and_classes(member_id: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the callings and class assignments for the given member

Parameters

member_idint

ID of the member for which to retrieve information

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  authorizedToEditCallings: bool,
  authorizedToEditClassAssignments: bool,
  classAssignments: [
    {
      adultClass: bool,
      classId: int,
      className: str,
      classTypeId: int,
      defaultClass: bool,
      defaultClassTypeId: int,
      group: str,
      individualId: int,
      organization: str
    }
  ],
  householdCallings: [
    {
      activeDate: str,
      allowApprove: bool,
      allowMultiple: bool,
      allowNew: bool,
      allowVacant: bool,
      approvalRequest: bool,
      autoReleasedPositionTypeIds: NoneType,
      canHaveResponsibilities: bool,
      contactEmail: str,
      contactInfoEditable: bool,
      contactMailingAddr: NoneType,
      contactMobilePhone: NoneType,
      contactWorkPhone: NoneType,
      custom: bool,
      customNameChanged: bool,
      dualAuthPass: NoneType,
      dualAuthUser: NoneType,
      editable: bool,
      errors: {},
      expectedEndDate: NoneType,
      hasContactInfo: bool,
      hidden: bool,
      memberEmail: NoneType,
      memberId: int,
      memberName: str,
      memberNameOrder: int,
      memberPhone: NoneType,
      memberUnitName: NoneType,
      memberUnitNumber: NoneType,
      missionName: NoneType,
      missionUnitNumber: NoneType,
      missionary: bool,
      missionaryHomeUnitName: NoneType,
      mrn: NoneType,
      nameVerificationForMrn: NoneType,
      newSubOrgId: NoneType,
      ordainDate: NoneType,
      ordainedByPersonId: NoneType,
      ordainedByPersonMrn: NoneType,
      ordainedByPersonName: NoneType,
      organization: str,
      otherAllowedSubOrgs: [
        {
          children: list,
          classGroup: str,
          defaultOrgTypeIds: [
            int
          ],
          firstTypeId: int,
          gender: NoneType,
          isClass: bool,
          isCombined: bool,
          isRealClass: bool,
          isSplit: bool,
          name: str,
          orgTypeIds: [
            int
          ],
          parentName: str,
          subOrgId: int,
          unitNumber: int,
          userCanEditCallings: bool
        }
      ],
      parentOrganization: NoneType,
      pendingCalling: bool,
      pendingDelete: bool,
      pendingDualAuth: bool,
      position: str,
      positionDisplayOrder: int,
      positionId: int,
      positionTypeEnum: str,
      positionTypeId: int,
      previouslyOrdained: bool,
      releaseDate: NoneType,
      releasePositionIds: NoneType,
      requiresBishopOrdination: bool,
      requiresDualAuthorization: bool,
      requiresSetApartDateAndPerson: bool,
      responsibilities: NoneType,
      sequence: int,
      setApart: bool,
      setApartByPersonId: NoneType,
      setApartByPersonMrn: NoneType,
      setApartByPersonName: NoneType,
      setApartDate: str,
      showUnitCard: bool,
      subOrgId: int,
      subOrgTypeId: int,
      unitName: str,
      unitNumber: int,
      unpublished: bool,
      userCanEdit: bool,
      userCanEditContactInfoOnly: bool,
      userCannotEditPreviousOrdination: bool,
      vacant: bool
    }
  ],
  individualCallings: [
    {
      activeDate: str,
      allowApprove: bool,
      allowMultiple: bool,
      allowNew: bool,
      allowVacant: bool,
      approvalRequest: bool,
      autoReleasedPositionTypeIds: NoneType,
      canHaveResponsibilities: bool,
      contactEmail: str,
      contactInfoEditable: bool,
      contactMailingAddr: NoneType,
      contactMobilePhone: NoneType,
      contactWorkPhone: NoneType,
      custom: bool,
      customNameChanged: bool,
      dualAuthPass: NoneType,
      dualAuthUser: NoneType,
      editable: bool,
      errors: {},
      expectedEndDate: NoneType,
      hasContactInfo: bool,
      hidden: bool,
      memberEmail: str,
      memberId: int,
      memberName: str,
      memberNameOrder: int,
      memberPhone: NoneType,
      memberUnitName: NoneType,
      memberUnitNumber: NoneType,
      missionName: NoneType,
      missionUnitNumber: NoneType,
      missionary: bool,
      missionaryHomeUnitName: NoneType,
      mrn: NoneType,
      nameVerificationForMrn: NoneType,
      newSubOrgId: NoneType,
      ordainDate: NoneType,
      ordainedByPersonId: NoneType,
      ordainedByPersonMrn: NoneType,
      ordainedByPersonName: NoneType,
      organization: str,
      otherAllowedSubOrgs: [
        {
          children: list,
          classGroup: NoneType,
          defaultOrgTypeIds: [
            int
          ],
          firstTypeId: int,
          gender: NoneType,
          isClass: bool,
          isCombined: bool,
          isRealClass: bool,
          isSplit: bool,
          name: str,
          orgTypeIds: [
            int
          ],
          parentName: str,
          subOrgId: int,
          unitNumber: int,
          userCanEditCallings: bool
        }
      ],
      parentOrganization: NoneType,
      pendingCalling: bool,
      pendingDelete: bool,
      pendingDualAuth: bool,
      position: str,
      positionDisplayOrder: int,
      positionId: int,
      positionTypeEnum: str,
      positionTypeId: int,
      previouslyOrdained: bool,
      releaseDate: NoneType,
      releasePositionIds: NoneType,
      requiresBishopOrdination: bool,
      requiresDualAuthorization: bool,
      requiresSetApartDateAndPerson: bool,
      responsibilities: NoneType,
      sequence: int,
      setApart: bool,
      setApartByPersonId: NoneType,
      setApartByPersonMrn: NoneType,
      setApartByPersonName: NoneType,
      setApartDate: NoneType,
      showUnitCard: bool,
      subOrgId: int,
      subOrgTypeId: int,
      unitName: str,
      unitNumber: int,
      unpublished: bool,
      userCanEdit: bool,
      userCanEditContactInfoOnly: bool,
      userCannotEditPreviousOrdination: bool,
      vacant: bool
    }
  ],
  subOrgsForPotentialNewCallings: [
    {
      children: list,
      classGroup: NoneType,
      defaultOrgTypeIds: [
        int
      ],
      firstTypeId: int,
      gender: NoneType,
      isClass: bool,
      isCombined: bool,
      isRealClass: bool,
      isSplit: bool,
      name: str,
      orgTypeIds: [
        int
      ],
      parentName: str,
      subOrgId: int,
      unitNumber: int,
      userCanEditCallings: bool
    }
  ]
}
get_member_list(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit member list

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    address: {
      addressLines: [
        str
      ],
      formatted1: NoneType,
      formatted2: NoneType,
      formatted3: NoneType,
      formatted4: NoneType,
      formatted5: NoneType,
      formatted6: NoneType,
      formattedAll: list,
      formattedLine1: str,
      formattedLine2: str,
      formattedLine3: NoneType,
      formattedLine4: NoneType,
      useType: NoneType
    },
    age: int,
    birth: {
      country: NoneType,
      date: {
        calc: str,
        date: str,
        display: str
      },
      monthDay: {
        calc: str,
        date: str,
        display: str
      },
      place: NoneType
    },
    convert: bool,
    email: str,
    emails: [
      {
        email: str,
        ownerType: NoneType,
        useType: NoneType
      }
    ],
    formattedAddress: str,
    houseHoldMemberNameForList: str,
    householdAnchorPersonUuid: str,
    householdMember: {
      household: {
        address: {
          addressLines: [
            str
          ],
          formatted1: NoneType,
          formatted2: NoneType,
          formatted3: NoneType,
          formatted4: NoneType,
          formatted5: NoneType,
          formatted6: NoneType,
          formattedAll: list,
          formattedLine1: str,
          formattedLine2: str,
          formattedLine3: NoneType,
          formattedLine4: NoneType,
          useType: NoneType
        },
        anchorPerson: {
          legacyCmisId: int,
          uuid: str
        },
        directoryPreferredLocal: str,
        emails: NoneType,
        familyNameLocal: str,
        phones: NoneType,
        unit: {
          addressUnknown: NoneType,
          adminUnit: NoneType,
          cdolLink: NoneType,
          children: NoneType,
          nameLatin: NoneType,
          nameLocal: str,
          parentUnit: NoneType,
          positions: NoneType,
          unitNumber: int,
          unitType: NoneType,
          uuid: NoneType
        },
        uuid: str
      },
      householdRole: str,
      membershipUnitFlag: bool
    },
    householdNameDirectoryLocal: str,
    householdNameFamilyLocal: str,
    householdRole: str,
    householdUuid: str,
    households: NoneType,
    isAdult: bool,
    isHead: bool,
    isMember: bool,
    isOutOfUnitMember: bool,
    isProspectiveElder: bool,
    isSingleAdult: bool,
    isSpouse: bool,
    isYoungSingleAdult: bool,
    legacyCmisId: int,
    member: bool,
    membershipUnit: NoneType,
    mrn: NoneType,
    nameFamilyPreferredLocal: str,
    nameFormats: {
      certificateChurchOfficerLocal: NoneType,
      certificateOfficialLocal: NoneType,
      familyPreferredLocal: str,
      givenPreferredLocal: str,
      listOfficial: NoneType,
      listPreferred: NoneType,
      listPreferredLocal: str,
      spokenPreferredLocal: NoneType
    },
    nameGivenPreferredLocal: str,
    nameListPreferredLocal: str,
    nameOrder: int,
    outOfUnitMember: bool,
    personStatusFlags: {
      adult: bool,
      convert: bool,
      deceased: bool,
      hasPatriarchalBlessing: bool,
      member: bool,
      prospectiveElder: bool,
      singleAdult: bool,
      youngSingleAdult: bool
    },
    personUuid: str,
    phoneNumber: str,
    phones: [
      {
        internationalFormat: NoneType,
        number: str,
        ownerType: NoneType,
        useType: NoneType
      }
    ],
    positions: NoneType,
    priesthoodOffice: str,
    priesthoodTeacherOrAbove: bool,
    sex: str,
    unitName: str,
    unitNumber: int,
    unitOrgsCombined: [
      str
    ],
    uuid: str,
    wamPolicy: NoneType,
    youthBasedOnAge: bool
  }
]
get_member_service(member_id: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns member’s service assignments

Parameters

member_idint

ID of the member for which to retrieve information

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  authorizedToAddEndowment: bool,
  authorizedToEditMelchizedekPriesthood: bool,
  authorizedToPrintCertificates: bool,
  authorizedToPrintMelchizedekPriesthood: bool,
  authorizedToUpdateContactInfo: bool,
  authorizedToUpdateRecord: bool,
  authorizedToViewAnnotations: bool,
  authorizedToViewHTVT: bool,
  authorizedToViewRecord: bool,
  authorizedToViewReportBasic: bool,
  boundaryException: NoneType,
  canChangeMoveRestriction: bool,
  consentFormId: NoneType,
  consentFormMediaType: NoneType,
  family: {
    children: list,
    hohMrn: NoneType,
    marriage: {
      authorizedToViewNonMemberSpouse: bool,
      country: NoneType,
      countryId: NoneType,
      date: NoneType,
      errors: {},
      individualId: int,
      legalNameGroup: NoneType,
      madeHeadOfHousehold: bool,
      marriageId: str,
      marriageTerminated: bool,
      marriageTerminationCause: NoneType,
      memberStatus: NoneType,
      memberType: NoneType,
      mrn: str,
      nonMemberSpouseNameBirthdateNotEditable: bool,
      place: NoneType,
      preferredNameGroup: NoneType,
      restorationOfBlessingsRequired: bool,
      sealedToPriorSpouse: bool,
      sealingDate: NoneType,
      sealingTemple: NoneType,
      showTempleInfo: bool,
      spouse: {
        age: int,
        allPriesthoodOrdinations: NoneType,
        birthDate: str,
        deathDate: NoneType,
        deceased: bool,
        displayBirthDate: str,
        displayMrn: NoneType,
        gender: str,
        headOfHousehold: bool,
        id: int,
        inAuthorizedUnit: bool,
        inHousehold: bool,
        linkedRecord: bool,
        listName: str,
        maidenName: str,
        maidenOrLegalName: str,
        member: bool,
        mrn: NoneType,
        name: str,
        nameGroup: NoneType,
        noMrnInitiated: bool,
        pendingId: NoneType,
        preferredOrLegalName: str,
        priesthood: NoneType,
        priesthoodCode: NoneType,
        priesthoodType: NoneType,
        relationship: str,
        relationshipDisplay: str,
        spokenName: NoneType,
        unitNumber: int,
        unknown: bool
      },
      spouseDeceased: bool,
      spouseEditable: bool,
      spouseId: int,
      spouseInDifferentWardBranch: bool,
      spouseMember: bool,
      spouseMrn: NoneType,
      spouseUnitNumber: int,
      templeId: NoneType,
      terminationDate: NoneType,
      updateName: NoneType,
      updateRequests: NoneType,
      warnings: {}
    },
    parents: NoneType
  },
  household: {
    errors: {},
    familyNameGroup: {
      autoRomanize: bool,
      formattedLatin: str,
      formattedLocal: str,
      name1: {
        family: str,
        given: NoneType,
        label: str,
        labelKey: NoneType,
        suffix: NoneType,
        translitSource: bool,
        writingSystem: str
      },
      name2: NoneType,
      name3: NoneType
    },
    hohMrn: NoneType,
    members: [
      {
        age: int,
        allPriesthoodOrdinations: NoneType,
        birthDate: str,
        deathDate: NoneType,
        deceased: bool,
        displayBirthDate: str,
        displayMrn: NoneType,
        gender: str,
        headOfHousehold: bool,
        id: int,
        inAuthorizedUnit: bool,
        inHousehold: bool,
        linkedRecord: bool,
        listName: str,
        maidenName: NoneType,
        maidenOrLegalName: str,
        member: bool,
        mrn: NoneType,
        name: str,
        nameGroup: NoneType,
        noMrnInitiated: bool,
        pendingId: NoneType,
        preferredOrLegalName: str,
        priesthood: NoneType,
        priesthoodCode: NoneType,
        priesthoodType: NoneType,
        relationship: str,
        relationshipDisplay: str,
        spokenName: NoneType,
        unitNumber: int,
        unknown: bool
      }
    ]
  },
  individual: {
    actualAge: int,
    actualAgeInMonths: int,
    adultAgeOrMarried: bool,
    age: int,
    ageAsOfDec31: int,
    ageAsOfDec31NextYear: NoneType,
    birthCountry: NoneType,
    birthCountryId: NoneType,
    birthDate: str,
    birthDateDisplay: str,
    birthPlace: NoneType,
    canHaveCalling: bool,
    canHaveHTAssignment: bool,
    canHaveMaidenName: bool,
    canHaveVTAssignment: bool,
    confidentialEvents: NoneType,
    email: str,
    endowed: bool,
    errors: {},
    formattedHouseholdCoupleName: str,
    formattedMrn: NoneType,
    gender: str,
    hasOutOfUnitRecord: bool,
    hasPatriarchalBlessing: bool,
    head: bool,
    headInUnit: bool,
    hohId: int,
    hohName: str,
    hqMoveRestriction: bool,
    id: int,
    legalNameGroup: {
      autoRomanize: bool,
      formattedLatin: str,
      formattedLocal: str,
      name1: {
        family: str,
        given: str,
        label: str,
        labelKey: NoneType,
        suffix: NoneType,
        translitSource: bool,
        writingSystem: str
      },
      name2: NoneType,
      name3: NoneType
    },
    maidenNameGroup: {
      autoRomanize: bool,
      formattedLatin: NoneType,
      formattedLocal: NoneType,
      name1: {
        family: NoneType,
        given: NoneType,
        label: str,
        labelKey: NoneType,
        suffix: NoneType,
        translitSource: bool,
        writingSystem: str
      },
      name2: NoneType,
      name3: NoneType
    },
    mailingAddress: {
      city: NoneType,
      country: NoneType,
      district: NoneType,
      formattedLines: NoneType,
      geocodeToUnits: bool,
      lat: NoneType,
      lng: NoneType,
      membershipUpdateRequestAccepted: bool,
      postalCode: NoneType,
      standardized: NoneType,
      state: NoneType,
      street1: NoneType,
      street2: NoneType,
      units: NoneType
    },
    mailingSameAsResidential: bool,
    missionCountry: NoneType,
    missionCountryId: NoneType,
    missionLanguage: NoneType,
    missionLanguageId: NoneType,
    moveDate: NoneType,
    moveDateDuration: NoneType,
    moveRestriction: bool,
    moveRestrictionDate: NoneType,
    mrn: NoneType,
    name: str,
    nameUpdateReason: NoneType,
    notAccountable: bool,
    outOfUnit: bool,
    phone: str,
    preferredNameGroup: {
      autoRomanize: bool,
      formattedLatin: str,
      formattedLocal: str,
      name1: {
        family: str,
        given: str,
        label: str,
        labelKey: NoneType,
        suffix: NoneType,
        translitSource: bool,
        writingSystem: str
      },
      name2: NoneType,
      name3: NoneType
    },
    priesthood: str,
    priesthoodCode: int,
    primaryUnitName: str,
    primaryUnitNumber: NoneType,
    priorUnitName: NoneType,
    priorUnitNumber: NoneType,
    priorUnits: NoneType,
    recommendStatus: NoneType,
    residentialAddress: {
      city: str,
      country: int,
      district: NoneType,
      formattedLines: [
        str
      ],
      geocodeToUnits: bool,
      lat: float,
      lng: float,
      membershipUpdateRequestAccepted: bool,
      postalCode: str,
      standardized: NoneType,
      state: int,
      street1: str,
      street2: NoneType,
      units: NoneType
    },
    restorationOfBlessingsRequired: bool,
    sealedToSpouse: bool,
    spouseId: int,
    spouseInUnit: bool,
    spouseName: str,
    templeRecStatuses: NoneType,
    unitName: str,
    unitNumber: str,
    unsubscribedFromEmail: bool,
    updateRequests: NoneType,
    warnings: {}
  },
  individualName: str,
  membershipUpdateRequests: NoneType,
  ordinances: {
    allOrdinances: [
      {
        bic: bool,
        date: NoneType,
        note: NoneType,
        occurred: bool,
        ordinanceName: str,
        ordinanceType: str,
        templeId: NoneType,
        updateRequestExists: bool
      }
    ],
    baptism: {
      bic: bool,
      date: NoneType,
      note: NoneType,
      occurred: bool,
      ordinanceName: str,
      ordinanceType: str,
      templeId: NoneType,
      updateRequestExists: bool
    },
    bic: {
      bic: bool,
      date: NoneType,
      note: NoneType,
      occurred: bool,
      ordinanceName: str,
      ordinanceType: str,
      templeId: NoneType,
      updateRequestExists: bool
    },
    confirmation: {
      bic: bool,
      date: NoneType,
      note: NoneType,
      occurred: bool,
      ordinanceName: str,
      ordinanceType: str,
      templeId: NoneType,
      updateRequestExists: bool
    },
    endowment: {
      bic: bool,
      date: NoneType,
      note: NoneType,
      occurred: bool,
      ordinanceName: str,
      ordinanceType: str,
      templeId: NoneType,
      updateRequestExists: bool
    },
    errors: {},
    hasEditableFields: bool,
    ordinanceFields: [
      str
    ],
    priesthoods: {
      apostle: NoneType,
      deacon: NoneType,
      elder: {
        aaronic: bool,
        bic: bool,
        date: NoneType,
        melchizedek: bool,
        note: NoneType,
        occurred: bool,
        ordinanceName: str,
        ordinanceType: str,
        priesthoodType: NoneType,
        templeId: NoneType,
        updateRequestExists: bool
      },
      highPriest: NoneType,
      priest: NoneType,
      priesthoods: [
        {
          aaronic: bool,
          bic: bool,
          date: NoneType,
          melchizedek: bool,
          note: NoneType,
          occurred: bool,
          ordinanceName: str,
          ordinanceType: str,
          priesthoodType: NoneType,
          templeId: NoneType,
          updateRequestExists: bool
        }
      ],
      seventy: NoneType,
      teacher: NoneType,
      unknown: NoneType
    },
    restorationOfBlessings: bool,
    sealedToParents: NoneType,
    sealedToSpouse: {
      bic: bool,
      date: NoneType,
      note: NoneType,
      occurred: bool,
      ordinanceName: str,
      ordinanceType: str,
      templeId: NoneType,
      updateRequestExists: bool
    },
    updateRequests: NoneType,
    warnings: {}
  },
  outOfUnitMember: bool,
  recommend: NoneType,
  stakeOrDistrictUser: bool,
  unitLocaleData: {
    addressFields: [
      str
    ],
    hasLatinWritingSystem: bool,
    name1WritingSystem: str,
    name2WritingSystem: NoneType
  },
  withinStewardship: bool
}
get_members_with_callings(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit list of members with callings

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    activeCalender: str,
    activeDate: str,
    age: int,
    birthDate: str,
    birthDateSort: str,
    birthdDateDisplay: str,
    custom: bool,
    customSubOrgName: NoneType,
    displaySequence: NoneType,
    district: bool,
    email: str,
    errors: {},
    gender: str,
    id: int,
    leaderHomePhone: NoneType,
    leaderWorkPhone: NoneType,
    memberUnitName: str,
    memberUnitNumber: int,
    mrn: str,
    name: str,
    nameOrder: int,
    organization: str,
    outOfUnit: bool,
    parentSubOrgId: int,
    phone: str,
    position: str,
    positionId: int,
    positionTypeId: NoneType,
    priesthood: NoneType,
    setApart: bool,
    setApartCalender: str,
    setApartDate: str,
    spokenName: str,
    stake: bool,
    standardPosition: bool,
    subOrgId: int,
    subOrgType: str,
    subOrgTypeId: int,
    sustainedDate: str,
    unitName: str,
    unitNumber: int
  }
]
get_members_without_callings(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit list of members without callings

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    accountable: bool,
    actualAge: int,
    actualAgeInMonths: int,
    age: int,
    birthDate: str,
    birthDateFormatted: str,
    birthDateSort: str,
    birthDayFormatted: str,
    birthDaySort: str,
    email: str,
    formattedMrn: NoneType,
    gender: str,
    genderCode: int,
    genderLabelShort: str,
    id: int,
    mrn: NoneType,
    name: str,
    nameOrder: NoneType,
    nonMember: bool,
    notAccountable: bool,
    outOfUnitMember: bool,
    phone: str,
    priesthood: NoneType,
    priesthoodCode: NoneType,
    priesthoodType: NoneType,
    setApart: bool,
    spokenName: str,
    sustainedDate: NoneType,
    unitName: str,
    unitNumber: int,
    visible: NoneType
  }
]
get_ministering(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit ministering assignments

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  households: [
    {
      hasReliefSocietyMember: bool,
      headOfHouseholdCmisId: int,
      headOfHouseholdUuid: str,
      householdName: str,
      householdSortOrder: int,
      ministeringBrothers: [
        {
          age: int,
          assignType: str,
          interviews: [
            {
              date: str,
              id: str,
              month: int,
              timestamp: str,
              year: int
            }
          ],
          name: str,
          nameOrder: int,
          nameSort: str,
          personUuid: str,
          priesthoodOffice: str,
          unitOrgId: str,
          youthBasedOnAge: bool
        }
      ],
      ministeringSisters: list,
      unitName: str,
      unitNumber: int
    }
  ],
  individuals: [
    {
      assignments: [
        {
          age: int,
          legacyCmisId: int,
          name: str,
          nameOrder: int,
          personUuid: str,
          youthBasedOnAge: bool
        }
      ],
      companions: [
        {
          age: int,
          legacyCmisId: int,
          name: str,
          nameOrder: int,
          personUuid: str,
          youthBasedOnAge: bool
        }
      ],
      legacyCmisId: int,
      name: str,
      nameOrder: int,
      personUuid: str,
      unitOrgTypeId: int,
      youthBasedOnAge: bool
    }
  ]
}
get_ministering_full(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit ministering assignments as well as interview information

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  elders: [
    {
      companionships: [
        {
          assignmentErrors: list,
          assignmentWarnings: list,
          assignments: [
            {
              age: int,
              assignType: str,
              legacyCmisId: int,
              name: str,
              nameSort: str,
              personUuid: str,
              youthBasedOnAge: bool
            }
          ],
          id: str,
          ministerErrors: list,
          ministerWarnings: list,
          ministers: [
            {
              age: int,
              assignType: str,
              email: str,
              interviews: [
                {
                  date: str,
                  id: str,
                  month: int,
                  timestamp: str,
                  year: int
                }
              ],
              legacyCmisId: int,
              name: str,
              nameSort: str,
              personUuid: str,
              priesthoodOffice: str,
              unitOrgId: str,
              youthBasedOnAge: bool
            }
          ],
          recentlyChangedDate: str,
          recentlyChangedDateInMilliseconds: int
        }
      ],
      districtName: str,
      districtUuid: str,
      supervisorLegacyCmisId: int,
      supervisorName: str,
      supervisorPersonUuid: str
    }
  ],
  eldersQuorumSupervisors: [
    {
      name: str,
      personUuid: str,
      youthBasedOnAge: bool
    }
  ],
  error: bool,
  interviewViewAccess: bool,
  reliefSociety: [
    {
      companionships: [
        {
          assignmentErrors: list,
          assignmentWarnings: list,
          assignments: [
            {
              age: int,
              assignType: str,
              legacyCmisId: int,
              name: str,
              nameSort: str,
              personUuid: str,
              youthBasedOnAge: bool
            }
          ],
          id: str,
          ministerErrors: list,
          ministerWarnings: list,
          ministers: [
            {
              age: int,
              assignType: str,
              email: str,
              interviews: [
                {
                  date: str,
                  id: str,
                  month: int,
                  timestamp: str,
                  year: int
                }
              ],
              legacyCmisId: int,
              name: str,
              nameSort: str,
              personUuid: str,
              unitOrgId: str,
              youthBasedOnAge: bool
            }
          ],
          recentlyChangedDate: str,
          recentlyChangedDateInMilliseconds: int
        }
      ],
      districtName: str,
      districtUuid: str,
      supervisorLegacyCmisId: int,
      supervisorName: str,
      supervisorPersonUuid: str
    }
  ],
  reliefSocietySupervisors: [
    {
      name: str,
      personUuid: str,
      youthBasedOnAge: bool
    }
  ],
  unitOrgs: [
    {
      children: NoneType,
      isClass: bool,
      unitNumber: NoneType,
      unitOrgName: str,
      unitOrgTypeIds: [
        int
      ],
      unitOrgUuid: str,
      unitUuid: NoneType
    }
  ]
}
get_moved_in(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit list of recently moved in members

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    address: str,
    addressUnknown: bool,
    age: int,
    birthdate: str,
    birthdateCalc: str,
    gender: str,
    genderLabelShort: str,
    householdPosition: str,
    householdPositionEnum: str,
    householdUuid: str,
    id: int,
    locale: str,
    moveDate: str,
    moveDateCalc: str,
    moveDateOrder: int,
    name: str,
    nameOrder: int,
    phone: str,
    priesthood: NoneType,
    priorUnitName: str,
    priorUnitNumber: str,
    textAddress: str,
    unitName: str
  }
]
get_moved_out(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit list of recently moved out members

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    addressUnknown: bool,
    birthDate: str,
    deceased: bool,
    moveDate: str,
    moveDateOrder: int,
    name: str,
    nameOrder: int,
    nextUnitName: NoneType,
    nextUnitNumber: NoneType,
    priorUnit: NoneType
  }
]
get_out_of_unit_callings(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit list of members with callings out of unit

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  LIVING_INSIDE: [
    {
      activeCalender: str,
      activeDate: str,
      age: int,
      birthDate: str,
      birthDateSort: str,
      birthdDateDisplay: str,
      custom: bool,
      customSubOrgName: NoneType,
      displaySequence: int,
      district: bool,
      email: str,
      errors: {},
      gender: str,
      id: int,
      leaderHomePhone: NoneType,
      leaderWorkPhone: NoneType,
      memberUnitName: str,
      memberUnitNumber: int,
      mrn: str,
      name: str,
      nameOrder: int,
      organization: str,
      outOfUnit: bool,
      parentSubOrgId: NoneType,
      phone: str,
      position: str,
      positionId: int,
      positionTypeId: int,
      priesthood: NoneType,
      setApart: bool,
      setApartCalender: str,
      setApartDate: str,
      spokenName: str,
      stake: bool,
      standardPosition: bool,
      subOrgId: int,
      subOrgType: str,
      subOrgTypeId: int,
      sustainedDate: str,
      unitName: str,
      unitNumber: int
    }
  ],
  LIVING_OUTSIDE: list
}
get_quarterly_reports(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns all available unit quarterly reports

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  2014: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2015: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2016: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2017: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2018: {
    4: {
      childUnits: NoneType,
      converts: [
        {
          accountable: bool,
          actualAge: int,
          actualAgeInMonths: int,
          age: int,
          attendMeetings: bool,
          birthDate: str,
          birthDateFormatted: str,
          birthDateSort: str,
          birthDayFormatted: str,
          birthDaySort: str,
          email: NoneType,
          formattedMrn: NoneType,
          gender: str,
          genderCode: int,
          genderLabelShort: str,
          hasCalling: bool,
          id: int,
          inAuthorizedUnit: bool,
          mrn: NoneType,
          name: str,
          nameOrder: NoneType,
          nonMember: bool,
          notAccountable: bool,
          outOfUnitMember: bool,
          phone: NoneType,
          priesthood: NoneType,
          priesthoodCode: int,
          priesthoodType: NoneType,
          quarterlyReportUnitNumber: int,
          setApart: bool,
          spokenName: str,
          sustainedDate: NoneType,
          unitName: NoneType,
          unitNumber: NoneType,
          visible: NoneType
        }
      ],
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2019: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2020: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2021: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2022: {
    4: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2023: {
    4: {
      childUnits: NoneType,
      converts: [
        {
          accountable: bool,
          actualAge: int,
          actualAgeInMonths: int,
          age: int,
          attendMeetings: bool,
          birthDate: str,
          birthDateFormatted: str,
          birthDateSort: str,
          birthDayFormatted: str,
          birthDaySort: str,
          email: NoneType,
          formattedMrn: NoneType,
          gender: str,
          genderCode: int,
          genderLabelShort: str,
          hasCalling: NoneType,
          id: int,
          inAuthorizedUnit: bool,
          mrn: NoneType,
          name: str,
          nameOrder: NoneType,
          nonMember: bool,
          notAccountable: bool,
          outOfUnitMember: bool,
          phone: NoneType,
          priesthood: NoneType,
          priesthoodCode: NoneType,
          priesthoodType: NoneType,
          quarterlyReportUnitNumber: int,
          setApart: bool,
          spokenName: str,
          sustainedDate: NoneType,
          unitName: NoneType,
          unitNumber: NoneType,
          visible: NoneType
        }
      ],
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: str,
      lastSaveDate: str,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  },
  2024: {
    2: {
      childUnits: NoneType,
      converts: list,
      dueDate: str,
      editable: bool,
      errors: {},
      initialSubmitDate: NoneType,
      lastSaveDate: NoneType,
      overdue: bool,
      quarter: int,
      sections: [
        {
          label: str,
          nameResourceId: str,
          rows: [
            {
              actualListType: str,
              actualValue: int,
              calculated: bool,
              childUnitNumber: NoneType,
              childUnitRows: NoneType,
              editable: bool,
              helpLabel: str,
              helpResourceId: str,
              label: str,
              lineReference: NoneType,
              nameResourceId: str,
              number: int,
              potentialListType: str,
              potentialValue: int,
              propertyName: NoneType,
              updatedActualValue: NoneType,
              valueStr: NoneType,
              year1Percent: str,
              year5Percent: str
            }
          ]
        }
      ],
      submitted: bool,
      unitNumber: int,
      version: str,
      year: int
    }
  }
}
get_seminary_and_institute_quarterly_attendance(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns all availabe seminary/institute quarterly attendance reports

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  2014: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2015: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2016: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2017: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2018: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2019: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2020: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2021: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2022: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2023: {
    4: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  },
  2024: {
    3: {
      isStakeTotals: bool,
      quarter: int,
      sections: [
        {
          comment: str,
          id: int,
          name: str,
          rows: [
            {
              actual: int,
              id: int,
              name: str,
              percent: int,
              potential: int,
              tooltip: str,
              value: NoneType,
              valueIsActual: bool,
              valueIsPercent: bool,
              valueIsPotential: bool
            }
          ],
          subSections: list
        }
      ],
      unitAbbreviation: NoneType,
      unitName: str,
      unitNumber: int,
      year: int,
      yearQuarterDisplay: str
    }
  }
}
get_suborganization(org_id: int = None, unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns information for a given suborganization of a unit

Parameters org_id : int

Number of the suborganization of the unit for which to retrieve the report. Defaults to the class assignment for gendered class (Elders’ Quorum, Relief Society, etc.).

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  addableSubOrgTypes: NoneType,
  adultClass: bool,
  callings: list,
  canHaveMembers: bool,
  canShowWithNoCallings: bool,
  children: [
    {
      addableSubOrgTypes: NoneType,
      adultClass: bool,
      callings: [
        {
          activeDate: str,
          allowApprove: bool,
          allowMultiple: bool,
          allowNew: bool,
          allowVacant: bool,
          approvalRequest: bool,
          autoReleasedPositionTypeIds: NoneType,
          canHaveResponsibilities: bool,
          contactEmail: str,
          contactInfoEditable: bool,
          contactMailingAddr: NoneType,
          contactMobilePhone: NoneType,
          contactWorkPhone: NoneType,
          custom: bool,
          customNameChanged: bool,
          dualAuthPass: NoneType,
          dualAuthUser: NoneType,
          editable: bool,
          errors: {},
          expectedEndDate: NoneType,
          hasContactInfo: bool,
          hidden: bool,
          memberEmail: str,
          memberId: int,
          memberName: str,
          memberNameOrder: int,
          memberPhone: str,
          memberUnitName: str,
          memberUnitNumber: int,
          missionName: NoneType,
          missionUnitNumber: NoneType,
          missionary: bool,
          missionaryHomeUnitName: NoneType,
          mrn: NoneType,
          nameVerificationForMrn: NoneType,
          newSubOrgId: NoneType,
          ordainDate: NoneType,
          ordainedByPersonId: NoneType,
          ordainedByPersonMrn: NoneType,
          ordainedByPersonName: NoneType,
          organization: str,
          otherAllowedSubOrgs: [
            {
              children: list,
              classGroup: NoneType,
              defaultOrgTypeIds: [
                int
              ],
              firstTypeId: int,
              gender: NoneType,
              isClass: bool,
              isCombined: bool,
              isRealClass: bool,
              isSplit: bool,
              name: str,
              orgTypeIds: [
                int
              ],
              parentName: str,
              subOrgId: int,
              unitNumber: int,
              userCanEditCallings: bool
            }
          ],
          parentOrganization: NoneType,
          pendingCalling: bool,
          pendingDelete: bool,
          pendingDualAuth: bool,
          position: str,
          positionDisplayOrder: int,
          positionId: int,
          positionTypeEnum: str,
          positionTypeId: int,
          previouslyOrdained: bool,
          releaseDate: NoneType,
          releasePositionIds: NoneType,
          requiresBishopOrdination: bool,
          requiresDualAuthorization: bool,
          requiresSetApartDateAndPerson: bool,
          responsibilities: NoneType,
          sequence: int,
          setApart: bool,
          setApartByPersonId: NoneType,
          setApartByPersonMrn: NoneType,
          setApartByPersonName: NoneType,
          setApartDate: str,
          showUnitCard: bool,
          subOrgId: int,
          subOrgTypeId: int,
          unitName: NoneType,
          unitNumber: int,
          unpublished: bool,
          userCanEdit: bool,
          userCanEditContactInfoOnly: bool,
          userCannotEditPreviousOrdination: bool,
          vacant: bool
        }
      ],
      canHaveMembers: bool,
      canShowWithNoCallings: bool,
      children: list,
      classGroup: NoneType,
      classes: NoneType,
      classesCollapsed: bool,
      customOrgName: NoneType,
      customPositionsAllowed: bool,
      defaultOrgName: str,
      displayOrder: int,
      enableHT: bool,
      enableVT: bool,
      filterOffices: list,
      firstOrgType: str,
      firstOrgTypeId: int,
      firstOrgTypeName: NoneType,
      gender: NoneType,
      hasAnyAllowMultiple: bool,
      hasCustomCallings: bool,
      highCouncilOrDistrictCouncil: bool,
      instance: int,
      isSplit: bool,
      leadershipSubOrgId: NoneType,
      members: list,
      mergeableSubOrgTypeIds: list,
      missionaries: bool,
      multipleAllowed: bool,
      name: str,
      nameEditable: bool,
      orgTypeIds: [
        int
      ],
      other: bool,
      parentName: str,
      parentSubOrgId: int,
      positionTypeIdsThatCanHaveResponsibilities: list,
      priesthood: bool,
      relatedSubOrgName: NoneType,
      required: bool,
      resetable: bool,
      room: NoneType,
      size: NoneType,
      splitOrCombinedClassNotice: NoneType,
      subOrgId: int,
      supportsAttendanceRoll: bool,
      totalInstances: int,
      unitNumber: int,
      unitType: int,
      userCanEditCallings: bool,
      userCanEditClassAssignments: bool,
      userCanSeeBasicInfo: bool
    }
  ],
  classGroup: str,
  classes: NoneType,
  classesCollapsed: bool,
  customOrgName: NoneType,
  customPositionsAllowed: bool,
  defaultOrgName: str,
  displayOrder: int,
  enableHT: bool,
  enableVT: bool,
  filterOffices: [
    {
      codes: [
        int
      ],
      name: str
    }
  ],
  firstOrgType: str,
  firstOrgTypeId: int,
  firstOrgTypeName: NoneType,
  gender: str,
  hasAnyAllowMultiple: bool,
  hasCustomCallings: bool,
  highCouncilOrDistrictCouncil: bool,
  instance: int,
  isSplit: bool,
  leadershipSubOrgId: NoneType,
  members: [
    {
      accountable: bool,
      actualAge: int,
      actualAgeInMonths: int,
      address: str,
      adultAgeOrMarried: bool,
      age: int,
      birthDate: str,
      birthDateFormatted: str,
      birthDateSort: str,
      birthDayFormatted: str,
      birthDaySort: str,
      defaultClass: bool,
      defaultClassTypeId: int,
      eligibleForHomeTeachingAssignment: bool,
      email: str,
      endowed: bool,
      formattedMrn: NoneType,
      gender: str,
      genderCode: int,
      genderLabelShort: str,
      htvtAssignments: NoneType,
      htvtCompanions: NoneType,
      id: int,
      mrn: NoneType,
      name: str,
      nameOrder: int,
      nonMember: bool,
      notAccountable: bool,
      outOfUnitMember: bool,
      phone: str,
      priesthood: NoneType,
      priesthoodCode: int,
      priesthoodType: NoneType,
      sealedToSpouse: bool,
      setApart: bool,
      spokenName: str,
      sustainedDate: NoneType,
      unitName: str,
      unitNumber: int,
      visible: NoneType
    }
  ],
  mergeableSubOrgTypeIds: list,
  missionaries: bool,
  multipleAllowed: bool,
  name: str,
  nameEditable: bool,
  orgTypeIds: [
    int
  ],
  other: bool,
  parentName: str,
  parentSubOrgId: NoneType,
  positionTypeIdsThatCanHaveResponsibilities: list,
  priesthood: bool,
  relatedSubOrgName: NoneType,
  required: bool,
  resetable: bool,
  room: NoneType,
  size: NoneType,
  splitOrCombinedClassNotice: NoneType,
  subOrgId: int,
  supportsAttendanceRoll: bool,
  totalInstances: int,
  unitNumber: int,
  unitType: int,
  userCanEditCallings: bool,
  userCanEditClassAssignments: bool,
  userCanSeeBasicInfo: bool
}
get_temple_recommend_status(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the temple recommend status

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  reportData: [
    {
      endowmentDisplay: NoneType,
      endowmentSort: NoneType,
      expiredDisplay: str,
      expiredSort: str,
      genderDisplay: str,
      recommendReportLine: {
        age: int,
        baptized: bool,
        editable: bool,
        endowmentDate: NoneType,
        expirationDate: str,
        gender: str,
        issuable: bool,
        mediaType: str,
        memberName: str,
        missionary: bool,
        mrn: str,
        phoneNumber: str,
        priesthood: NoneType,
        recommendNumber: int,
        recommendStatus: str,
        recommendType: str,
        unitName: str,
        unitNumber: int
      },
      statusDisplay: str,
      statusExtended: str,
      statusFilter: str,
      typeDisplay: str,
      unitFilter: NoneType,
      youth: bool
    }
  ],
  statusFilterOptions: [
    {
      label: str,
      value: str
    }
  ],
  typeFilterOptions: [
    {
      label: str,
      value: str
    }
  ]
}
get_unit_groups(timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit groups, as used by the email/message application

Parameters

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    categoryName: str,
    groups: [
      {
        groupName: str,
        subOrgId: int
      }
    ]
  }
]
get_unit_organizations(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit calling/leadership organization structure

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

[
  {
    addableSubOrgTypes: NoneType,
    adultClass: bool,
    callings: [
      {
        activeDate: str,
        allowApprove: bool,
        allowMultiple: bool,
        allowNew: bool,
        allowVacant: bool,
        approvalRequest: bool,
        autoReleasedPositionTypeIds: NoneType,
        canHaveResponsibilities: bool,
        contactEmail: str,
        contactInfoEditable: bool,
        contactMailingAddr: {
          city: str,
          country: int,
          district: NoneType,
          formattedLines: list,
          geocodeToUnits: bool,
          lat: NoneType,
          lng: NoneType,
          membershipUpdateRequestAccepted: bool,
          postalCode: str,
          standardized: NoneType,
          state: int,
          street1: str,
          street2: NoneType,
          units: NoneType
        },
        contactMobilePhone: str,
        contactWorkPhone: NoneType,
        custom: bool,
        customNameChanged: bool,
        dualAuthPass: NoneType,
        dualAuthUser: NoneType,
        editable: bool,
        errors: {},
        expectedEndDate: NoneType,
        hasContactInfo: bool,
        hidden: bool,
        memberEmail: str,
        memberId: int,
        memberName: str,
        memberNameOrder: int,
        memberPhone: str,
        memberUnitName: str,
        memberUnitNumber: int,
        missionName: NoneType,
        missionUnitNumber: NoneType,
        missionary: bool,
        missionaryHomeUnitName: NoneType,
        mrn: NoneType,
        nameVerificationForMrn: NoneType,
        newSubOrgId: NoneType,
        ordainDate: str,
        ordainedByPersonId: int,
        ordainedByPersonMrn: str,
        ordainedByPersonName: str,
        organization: str,
        otherAllowedSubOrgs: [
          {
            children: list,
            classGroup: NoneType,
            defaultOrgTypeIds: [
              int
            ],
            firstTypeId: int,
            gender: NoneType,
            isClass: bool,
            isCombined: bool,
            isRealClass: bool,
            isSplit: bool,
            name: str,
            orgTypeIds: [
              int
            ],
            parentName: NoneType,
            subOrgId: int,
            unitNumber: int,
            userCanEditCallings: bool
          }
        ],
        parentOrganization: NoneType,
        pendingCalling: bool,
        pendingDelete: bool,
        pendingDualAuth: bool,
        position: str,
        positionDisplayOrder: int,
        positionId: int,
        positionTypeEnum: str,
        positionTypeId: int,
        previouslyOrdained: bool,
        releaseDate: NoneType,
        releasePositionIds: NoneType,
        requiresBishopOrdination: bool,
        requiresDualAuthorization: bool,
        requiresSetApartDateAndPerson: bool,
        responsibilities: NoneType,
        sequence: int,
        setApart: bool,
        setApartByPersonId: int,
        setApartByPersonMrn: str,
        setApartByPersonName: str,
        setApartDate: str,
        showUnitCard: bool,
        subOrgId: int,
        subOrgTypeId: int,
        unitName: NoneType,
        unitNumber: int,
        unpublished: bool,
        userCanEdit: bool,
        userCanEditContactInfoOnly: bool,
        userCannotEditPreviousOrdination: bool,
        vacant: bool
      }
    ],
    canHaveMembers: bool,
    canShowWithNoCallings: bool,
    children: list,
    classGroup: NoneType,
    classes: NoneType,
    classesCollapsed: bool,
    customOrgName: NoneType,
    customPositionsAllowed: bool,
    defaultOrgName: str,
    displayOrder: int,
    enableHT: bool,
    enableVT: bool,
    filterOffices: list,
    firstOrgType: str,
    firstOrgTypeId: int,
    firstOrgTypeName: NoneType,
    gender: NoneType,
    hasAnyAllowMultiple: bool,
    hasCustomCallings: bool,
    highCouncilOrDistrictCouncil: bool,
    instance: int,
    isSplit: bool,
    leadershipSubOrgId: NoneType,
    members: list,
    mergeableSubOrgTypeIds: list,
    missionaries: bool,
    multipleAllowed: bool,
    name: str,
    nameEditable: bool,
    orgTypeIds: [
      int
    ],
    other: bool,
    parentName: str,
    parentSubOrgId: NoneType,
    positionTypeIdsThatCanHaveResponsibilities: list,
    priesthood: bool,
    relatedSubOrgName: NoneType,
    required: bool,
    resetable: bool,
    room: NoneType,
    size: NoneType,
    splitOrCombinedClassNotice: NoneType,
    subOrgId: int,
    supportsAttendanceRoll: bool,
    totalInstances: int,
    unitNumber: int,
    unitType: int,
    userCanEditCallings: bool,
    userCanEditClassAssignments: bool,
    userCanSeeBasicInfo: bool
  }
]
get_unit_statistics(unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns the unit statistics

Parameters

unitint

Number of the church unit for which to retrieve the report

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  adultFemaleRecentConverts: int,
  adultFemaleRecentConvertsIndividualIds: list,
  adultMaleRecentConverts: int,
  adultMaleRecentConvertsIndividualIds: list,
  adults: int,
  adultsIndividualIds: [
    int
  ],
  baptizedNotConfirmed: int,
  baptizedNotConfirmedIndividualIds: list,
  beehive: int,
  beehiveIndividualIds: [
    int
  ],
  children: int,
  childrenAge8to11RecentConverts: int,
  childrenAge8to11RecentConvertsIndividualIds: list,
  childrenIndividualIds: [
    int
  ],
  deacons: int,
  deaconsIndividualIds: [
    int
  ],
  elders: int,
  eldersIndividualIds: [
    int
  ],
  endowedAdults: int,
  endowedAdultsIndividualIds: list,
  endowedWithRecommend: int,
  endowedWithRecommendIndividualIds: list,
  endowedWithoutRecommend: int,
  endowedWithoutRecommendIndividualIds: list,
  highPriests: int,
  highPriestsIndividualIds: [
    int
  ],
  households: int,
  householdsIndividualIds: [
    int
  ],
  householdsWithChildren: int,
  householdsWithChildrenIndividualIds: [
    int
  ],
  householdsWithSingleParentAndYouthOrChildren: int,
  householdsWithSingleParentAndYouthOrChildrenIndividualIds: [
    int
  ],
  householdsWithYouth: int,
  householdsWithYouthIndividualIds: [
    int
  ],
  householdsWithoutMelchizedekPriesthoodHolder: int,
  householdsWithoutMelchizedekPriesthoodHolderIndividualIds: [
    int
  ],
  individualsNotIncluded: int,
  individualsNotIncludedIndividualIds: [
    int
  ],
  infants: int,
  infantsIndividualIds: [
    int
  ],
  invalidBirthdate: int,
  invalidBirthdateIndividualIds: list,
  laurels: int,
  laurelsIndividualIds: [
    int
  ],
  marriedAdults: int,
  marriedAdultsIndividualIds: [
    int
  ],
  membersOfRecordAge9OrOlder: int,
  membersOfRecordAge9OrOlderIndividualIds: [
    int
  ],
  men: int,
  menIndividualIds: [
    int
  ],
  miaMaids: int,
  miaMaidsIndividualIds: [
    int
  ],
  ordainedRecentConverts: int,
  ordainedRecentConvertsIndividualIds: list,
  priests: int,
  priestsIndividualIds: [
    int
  ],
  prospectiveElders: int,
  prospectiveEldersIndividualIds: [
    int
  ],
  recentConverts: int,
  recentConvertsEligibleForOrdination: int,
  recentConvertsEligibleForOrdinationIndividualIds: list,
  recentConvertsIndividualIds: list,
  shortUnitName: NoneType,
  singleAdults: int,
  singleAdultsIndividualIds: [
    int
  ],
  teachers: int,
  teachersIndividualIds: [
    int
  ],
  totalMembers: int,
  totalMembersIndividualIds: [
    int
  ],
  unitName: NoneType,
  unitNumber: int,
  unitType: NoneType,
  unordainedRecentConverts: int,
  unordainedRecentConvertsIndividualIds: list,
  women: int,
  womenIndividualIds: [
    int
  ],
  youngMen: int,
  youngMenIndividualIds: [
    int
  ],
  youngMenRecentConverts: int,
  youngMenRecentConvertsIndividualIds: list,
  youngSingleAdults: int,
  youngSingleAdultsIndividualIds: [
    int
  ],
  youngWomen: int,
  youngWomen12_13: int,
  youngWomen12_13IndividualIds: [
    int
  ],
  youngWomen14_15: int,
  youngWomen14_15IndividualIds: [
    int
  ],
  youngWomen16_17: int,
  youngWomen16_17IndividualIds: [
    int
  ],
  youngWomenIndividualIds: [
    int
  ],
  youngWomenRecentConverts: int,
  youngWomenRecentConvertsIndividualIds: list
}
get_units(parent_unit: int = None, timeout_sec: int = None) Dict[str, Any] | List[Any]

Returns a list of child units for the given parent unit

Parameters

parent_unitint

Number of the church unit for which to retrieve a list of child units

timeout_secint

Number of seconds to wait for a response when making a request

Returns

{
  childUnits: [
    {
      name: str,
      unitNumber: int,
      unitType: str
    }
  ],
  name: str,
  unitNumber: int,
  unitType: str
}
property org_id
property session

Returns the requests session being used by the API.

property user_details

Returns the details of the user logged into this session

Returns

{
  emails: [
    {
      email: str,
      privacy: str,
      useType: str
    }
  ],
  households: [
    {
      household: {
        addresses: [
          {
            postalCode: str
          }
        ]
      }
    }
  ],
  legacyCmisId: str,
  membershipUnit: {
    areaUnit: [
      {
        unitNumber: str
      }
    ],
    country: {
      name: str,
      nameLatin: str,
      nameLocal: str
    },
    nameLocal: str,
    parentUnit: {
      nameLocal: str,
      unitNumber: str,
      unitType: {
        id: str,
        name: str
      }
    },
    templeUnit: [
      {
        nameLatin: str,
        nameLocal: str,
        unitNumber: str,
        uuid: str
      }
    ],
    unitNumber: str,
    unitType: {
      id: str,
      name: str
    },
    wardClerk: [
      {
        person: {
          emails: [
            {
              email: str,
              privacy: str,
              useType: str
            }
          ]
        }
      }
    ]
  },
  nameFormats: {
    familyPreferred: str,
    givenPreferred: str,
    listPreferred: str,
    mailPreferred: str,
    spokenPreferred: str
  },
  positions: [
    {
      positionType: {
        id: str,
        name: str
      }
    }
  ],
  uuid: str
}

Module contents