Ejemplo n.º 1
0
 def setUp(self):
     self.forms = Typeform(TOKEN).forms
     if not MOCK:
         form = self.forms.create(dict(title="Form's test form", workspace={'href': WORKSPACE}))
         self.formID = form.get('id')
     else:
         self.formID = "MOCK-FORM-ID"
 def setUp(self):
     self.forms = Typeform(TOKEN).forms
     self.responses = Typeform(TOKEN).responses
     if not MOCK:
         form = self.forms.create((dict(title="Responses's test form",
                                        workspace={'href': WORKSPACE})))
         self.formID = form.get('id')
     else:
         self.formID = 'MOCK-FORM-ID'
Ejemplo n.º 3
0
def main():

    # make sure token_env has been set
    if token_env not in os.environ:
        raise Exception(f"Environment variable '{token_env}' not set")

    # retrieve the responses
    print(f"Retreiving TypeForm results for form '{form_id}'")
    responses = Typeform(os.environ[token_env]).responses

    # retrieve the responses dictionary
    dict = fetch_responses_dict(responses, form_id, only_completed_entries)

    if output_file:
        # write the responses dictionary to an output file
        write(output_file, dict)
    else:
        # print the responses to screen
        print(json.dumps(dict, indent=2))
        print(
            "No responses were written to file, and no responses were deleted."
        )
        return  # don't want to risk deleting responses if not stored

    # if True, delete the responses
    if delete_after_retrieving:
        delete_responses_list(responses, form_id, dict)
Ejemplo n.º 4
0
    def __init__(self, api_key='', *args, **kwargs):
        self.api_key = api_key
        self.typeform = Typeform(api_key)

        self.forms_count = len(self.get_forms_dict()['items'])

        self.forms_name_list = self.get_forms_list(by_name=True)
        self.forms_id_list = self.get_forms_list(by_name=False)
Ejemplo n.º 5
0
 def __init__(self,
              typeform_pat: str,
              form_id: str,
              question_weights: List[int],
              exclude_field_groups=(0, )):
     """
     :param typeform_pat: Personal Access Token from TypeForm API
     :param form_id: TypeForm Form ID
     :param question_weights: List of weights for each
     """
     self.api_client = Typeform(typeform_pat)
     self.form_id = form_id
     self.exclude_field_groups = exclude_field_groups
     self.question_weights = question_weights
class ResponsesTestCase(TestCase):
    def setUp(self):
        self.forms = Typeform(TOKEN).forms
        self.responses = Typeform(TOKEN).responses
        if not MOCK:
            form = self.forms.create((dict(title="Responses's test form",
                                           workspace={'href': WORKSPACE})))
            self.formID = form.get('id')
        else:
            self.formID = 'MOCK-FORM-ID'

    def tearDown(self):
        if not MOCK:
            list = self.forms.list(workspaceId=WORKSPACE_ID)
            forms = list.get('items', [])
            for form in forms:
                self.forms.delete(form.get('id'))

    def test_list_returns_method_and_path(self):
        """
        get all responses has the correct method and path
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            url = API_BASE_URL + '/forms/' + self.formID + '/responses'
            m.get(url, json={})
            self.responses.list(self.formID)

            history = m.request_history
            self.assertEqual(history[0].url, url)
            self.assertEqual(history[0].method, 'GET')

    def test_list_correct_params(self):
        """
        paramters are sent correctly
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            url = API_BASE_URL + '/forms/' + self.formID + '/responses'
            m.get(url, json={})
            self.responses.list(self.formID,
                                pageSize='100',
                                since='2000-01-01T00:00:00Z',
                                completed=True,
                                fields=['1', '2'])

            history = m.request_history
            query = history[0].url.split('?')[1]
            params = dict(urllib.parse.parse_qs(query))

            self.assertEqual(params.pop('page_size')[0], '100')
            self.assertEqual(params.pop('since')[0], '2000-01-01T00:00:00Z')
            self.assertEqual(params.pop('completed')[0], 'true')
            self.assertEqual(params.pop('fields')[0], '1,2')

    def test_list_fetches_responses(self):
        """
        get all responses does not throw an error
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.get(API_BASE_URL + '/forms/{}/responses'.format(self.formID),
                  json=dict(total_items=0))
            result = self.responses.list(self.formID)
            self.assertEqual(result.pop('total_items'), 0)

    def test_list_fetches_responses_with_params(self):
        """
        get all responses does not throw an error with parameters
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.get(API_BASE_URL + '/forms/{}/responses'.format(self.formID),
                  json=dict(total_items=0))
            result = self.responses.list(self.formID,
                                         pageSize=100,
                                         since='2000-01-01T00:00:00Z',
                                         completed=True,
                                         fields=['1', '2'])
            self.assertEqual(result.pop('total_items'), 0)

    def test_delete_one_token_returns_method_and_path(self):
        """
        delete response has the correct method and path when deleting one token
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            url = API_BASE_URL + '/forms/' + self.formID + '/responses?included_tokens=1'
            m.delete(url, json={})
            self.responses.delete(self.formID, includedTokens='1')

            history = m.request_history
            self.assertEqual(history[0].url, url)
            self.assertEqual(history[0].method, 'DELETE')

    def test_delete_multiple_token_returns_method_and_path(self):
        """
        delete response has the correct method and path when deleting multiple tokens
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            url = API_BASE_URL + '/forms/' + self.formID + '/responses?included_tokens=1%2C2%2C3'
            m.delete(url, json={})
            self.responses.delete(self.formID, includedTokens=['1', '2', '3'])

            history = m.request_history
            self.assertEqual(history[0].url, url)
            self.assertEqual(history[0].method, 'DELETE')
Ejemplo n.º 7
0
from typeform import Typeform

typeform = Typeform(
    personal_token='xgHiVsz2fK4p4Tgg947WEcJBhvt76yfsachrz1qMxZf')
# tf2 = typeform.Client(personal_token='xgHiVsz2fK4p4Tgg947WEcJBhvt76yfsachrz1qMxZf')

#    typeform.forms.form('asfa').get()

# Fetch all questions from the form
all_forms = typeform.forms.get()
my_form = typeform.form('tqOCMu').get()

# my_form = typeform.form('fYvzZN').delete()
my_responses = typeform.form('tqOCMu').responses.get()

# Fetch all responses to the form with default options
# responses = forms.get_responses()

# Fetch responses with specific options
#responses = form.get_responses(limit=10, since=1487863154)

print("Forms:")
print(all_forms)
print("Questions:")

for question in my_form['fields']:
    print("{}".format(question['title']))

print("Responses: {}".format(len(my_responses['items'])))

for question in my_form['fields']:
Ejemplo n.º 8
0
 def setUp(self):
     self.forms = Typeform(TOKEN).forms
     form = self.forms.create({
         'title': 'title'
     })
     self.formID = form.get('id')
Ejemplo n.º 9
0
class FormsTestCase(TestCase):
    def setUp(self):
        self.forms = Typeform(TOKEN).forms
        form = self.forms.create({
            'title': 'title'
        })
        self.formID = form.get('id')

    def tearDown(self):
        list = self.forms.list()
        forms = list.get('items', [])
        for form in forms:
            self.forms.delete(form.get('id'))

    def test_forms_returns_method_and_path(self):
        """
        get all forms has the correct method and path
        """
        with requests_mock.mock() as m:
            m.get(API_BASE_URL+'/forms', json={})
            self.forms.list()

            history = m.request_history
            self.assertEqual(history[0].url, API_BASE_URL+'/forms')
            self.assertEqual(history[0].method, 'GET')

    def test_forms_correct_params(self):
        """
        paramters are sent correctly
        """
        with requests_mock.mock() as m:
            m.get(API_BASE_URL+'/forms', json={})
            self.forms.list(page=2, pageSize=10, search='hola', workspaceId='abc')

            history = m.request_history
            query = history[0].url.split('?')[1]
            params = dict(urllib.parse.parse_qs(query))

            self.assertEqual(params.pop('page')[0], '2')
            self.assertEqual(params.pop('page_size')[0], '10')
            self.assertEqual(params.pop('search')[0], 'hola')
            self.assertEqual(params.pop('workspace_id')[0], 'abc')

    def test_forms_get_correct_id(self):
        """
        get sends the correct UID
        """
        with requests_mock.mock() as m:
            m.get(API_BASE_URL+'/forms/'+self.formID, json={})
            self.forms.get(self.formID)

            history = m.request_history
            self.assertEqual(history[0].url, API_BASE_URL+'/forms/'+self.formID)

    def test_forms_get_sets_get_method(self):
        """
        get sets get method
        """
        with requests_mock.mock() as m:
            m.get(API_BASE_URL+'/forms/'+self.formID, json={})
            self.forms.get(self.formID)

            history = m.request_history
            self.assertEqual(history[0].method, 'GET')

    def test_forms_update_updates_a_form(self):
        """
        update updates a form
        """
        title = 'hola'
        result = self.forms.update(self.formID, data={
            'title': title
        })

        self.assertEqual(result.get('title'), title)

    def test_forms_update_as_patch_updates_a_form(self):
        """
        update as patch updates a form
        """
        result = self.forms.update(self.formID, patch=True, data=[{
            'op': 'replace',
            'path': '/title',
            'value': 'aloha'
        }])

        self.assertEqual(result, 'OK')

    def test_forms_update_sets_put_method_in_request_by_default(self):
        """
        update sets put method in request by default
        """
        with requests_mock.mock() as m:
            m.put(API_BASE_URL+'/forms/'+self.formID, json={})
            self.forms.update(self.formID, data={
                'title': 'title'
            })

            history = m.request_history

            self.assertEqual(history[0].method, 'PUT')

    def test_forms_delete_removes_the_correct_uid_form(self):
        """
        delete removes the correct uid form
        """
        get1Result = self.forms.get(self.formID)
        self.assertEqual(get1Result.get('id'), self.formID)
        self.forms.delete(self.formID)
        try:
            self.forms.get(self.formID)
        except Exception as err:
            error = str(err)
        self.assertEqual(error, 'Non existing form with uid %s' % self.formID)

    def test_forms_create_has_the_correct_path_and_method(self):
        """
        create has the correct path and method
        """
        with requests_mock.mock() as m:
            m.post(API_BASE_URL+'/forms', json={})
            self.forms.create({
                'title': 'hola'
            })

            history = m.request_history

            self.assertEqual(history[0].method, 'POST')
            self.assertEqual(history[0].url, API_BASE_URL+'/forms')

    def test_forms_create_creates_a_new_form(self):
        """
        create creates a new form
        """
        createResult = self.forms.create({
            'title': 'hola'
        })

        formID = createResult.get('id')

        getResult = self.forms.get(formID)

        self.assertIsNone(createResult.get('code', None))
        self.assertEqual(getResult.get('id'), formID)

    def test_forms_get_messages_has_the_correct_path_and_method(self):
        """
        get messages has the correct path and method
        """
        with requests_mock.mock() as m:
            m.get(API_BASE_URL+'/forms/'+self.formID+'/messages', json={})
            self.forms.messages.get(self.formID)

            history = m.request_history

            self.assertEqual(history[0].method, 'GET')
            self.assertEqual(history[0].url, API_BASE_URL+'/forms/'+self.formID+'/messages')

    def test_forms_update_messages_has_the_correct_path_and_method(self):
        """
        update messages has the correct path and method
        """
        with requests_mock.mock() as m:
            m.put(API_BASE_URL+'/forms/'+self.formID+'/messages')
            self.forms.messages.update(self.formID)

            history = m.request_history

            self.assertEqual(history[0].method, 'PUT')
            self.assertEqual(history[0].url, API_BASE_URL+'/forms/'+self.formID+'/messages')
Ejemplo n.º 10
0
def erg_form(fid):
    "Return a JSON-encoded Typeform form with id fid"
    f = Typeform.form(form_uid)
    pass
Ejemplo n.º 11
0
def index():
    f = Typeform()
    return f.get()
"""
Reshape initial cultural habits responses in a pandas dataframe and save it in data/dataframe_api_responses.csv.
"""
import json
import os
import re

import pandas as pd
from typeform import Typeform

API_KEY = os.getenv("TYPEFORM_API_KEY")
FORM_ID = os.getenv("PROD_FORM_ID")

# We use the python API to retrieve data on questions
typeform = Typeform(API_KEY)
form = typeform.forms.get(FORM_ID)
fields = (pd.DataFrame(form.get("fields")).rename(columns={
    "id": "question_id"
}).drop("type", axis=1))

# We open the json of saved answers obtained from the API
with open("data/api_responses.json") as json_file:
    responses = json.load(json_file)

# number of users (list of answers for each user)
print(len(responses))

# we want one line for each user answer
dataframe = (pd.DataFrame(responses).explode("answers").dropna().assign(
    network_id=lambda df: df.metadata.apply(lambda metadata: metadata.get(
        "network_id")),
Ejemplo n.º 13
0
class FormsTestCase(TestCase):
    def setUp(self):
        self.forms = Typeform(TOKEN).forms
        if not MOCK:
            form = self.forms.create(
                dict(title="Form's test form", workspace={'href': WORKSPACE}))
            self.formID = form.get('id')
        else:
            self.formID = 'MOCK-FORM-ID'

    def tearDown(self):
        if not MOCK:
            list = self.forms.list(workspaceId=WORKSPACE_ID)
            forms = list.get('items', [])
            for form in forms:
                self.forms.delete(form.get('id'))

    def test_forms_returns_method_and_path(self):
        """
        get all forms has the correct method and path
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.get(API_BASE_URL + '/forms', json={})
            self.forms.list(workspaceId=WORKSPACE_ID)

            history = m.request_history
            self.assertEqual(
                history[0].url,
                API_BASE_URL + '/forms?workspace_id={}'.format(WORKSPACE_ID))
            self.assertEqual(history[0].method, 'GET')

    def test_forms_correct_params(self):
        """
        paramters are sent correctly
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.get(API_BASE_URL + '/forms', json={})
            self.forms.list(page=2,
                            pageSize=10,
                            search='forms_correct_params',
                            workspaceId=WORKSPACE_ID)

            history = m.request_history
            query = history[0].url.split('?')[1]
            params = dict(urllib.parse.parse_qs(query))

            self.assertEqual(params.pop('page')[0], '2')
            self.assertEqual(params.pop('page_size')[0], '10')
            self.assertEqual(params.pop('search')[0], 'forms_correct_params')
            self.assertEqual(params.pop('workspace_id')[0], WORKSPACE_ID)

    def test_forms_get_correct_id(self):
        """
        get sends the correct UID
        """
        with requests_mock.mock() as m:
            m.get(API_BASE_URL + '/forms/' + self.formID, json={})
            self.forms.get(self.formID)

            history = m.request_history
            self.assertEqual(history[0].url,
                             API_BASE_URL + '/forms/' + self.formID)

    def test_forms_get_sets_get_method(self):
        """
        get sets get method
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.get(API_BASE_URL + '/forms/' + self.formID, json={})
            self.forms.get(self.formID)

            history = m.request_history
            self.assertEqual(history[0].method, 'GET')

    def test_forms_update_updates_a_form(self):
        """
        update updates a form
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            title = 'forms_update_updates_a_form'
            m.put(API_BASE_URL + '/forms/' + self.formID,
                  json=dict(title=title))
            result = self.forms.update(self.formID, data={'title': title})

            self.assertEqual(result.get('title'), title)

    def test_forms_update_as_patch_updates_a_form(self):
        """
        update as patch updates a form
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.patch(API_BASE_URL + '/forms/' + self.formID, json='OK')
            result = self.forms.update(
                self.formID,
                patch=True,
                data=[
                    dict(op='replace',
                         path='/title',
                         value='forms_update_as_patch_updates_a_form')
                ])

            self.assertEqual(result, 'OK')

    def test_forms_update_sets_put_method_in_request_by_default(self):
        """
        update sets put method in request by default
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.put(API_BASE_URL + '/forms/' + self.formID, json={})
            self.forms.update(
                self.formID,
                data={
                    'title':
                    'forms_update_sets_put_method_in_request_by_default'
                })

            history = m.request_history

            self.assertEqual(history[0].method, 'PUT')

    def test_forms_delete_removes_the_correct_uid_form(self):
        """
        delete removes the correct uid form
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.get(API_BASE_URL + '/forms/{}'.format(self.formID),
                  json=dict(id=str(self.formID)))
            m.delete(API_BASE_URL + '/forms/{}'.format(self.formID), json={})

            get_one_result = self.forms.get(self.formID)
            self.assertEqual(get_one_result.get('id'), self.formID)
            self.forms.delete(self.formID)
            m.get(API_BASE_URL + '/forms/{}'.format(self.formID),
                  json=dict(code='FORM_NOT_FOUND',
                            description='Non existing form with uid {}'.format(
                                self.formID)))
            try:
                self.forms.get(self.formID)
            except Exception as err:
                error = str(err)
            self.assertEqual(error,
                             'Non existing form with uid %s' % self.formID)

    def test_forms_create_has_the_correct_path_and_method(self):
        """
        create has the correct path and method
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.post(API_BASE_URL + '/forms', json={})
            self.forms.create(
                dict(title='forms_create_has_the_correct_path_and_method',
                     workspace={'href': WORKSPACE}))

            history = m.request_history

            self.assertEqual(history[0].method, 'POST')
            self.assertEqual(history[0].url, API_BASE_URL + '/forms')

    def test_forms_create_creates_a_new_form(self):
        """
        create creates a new form
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.post(API_BASE_URL + '/forms', json=dict(id=str(self.formID)))
            m.get(API_BASE_URL + '/forms/{}'.format(self.formID),
                  json=dict(id=str(self.formID)))

            create_result = self.forms.create(
                dict(
                    title='forms_create_creates_a_new_form',
                    workspace={'href': WORKSPACE},
                ))

            formID = create_result.get('id')

            result = self.forms.get(formID)

            self.assertIsNone(create_result.get('code', None))
            self.assertEqual(result.get('id'), formID)

    def test_forms_get_messages_has_the_correct_path_and_method(self):
        """
        get messages has the correct path and method
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.get(API_BASE_URL + '/forms/' + self.formID + '/messages',
                  json={})
            self.forms.messages.get(self.formID)

            history = m.request_history

            self.assertEqual(history[0].method, 'GET')
            self.assertEqual(
                history[0].url,
                API_BASE_URL + '/forms/' + self.formID + '/messages')

    def test_forms_update_messages_has_the_correct_path_and_method(self):
        """
        update messages has the correct path and method
        """
        with requests_mock.mock(real_http=not MOCK) as m:
            m.put(API_BASE_URL + '/forms/' + self.formID + '/messages')
            self.forms.messages.update(self.formID)

            history = m.request_history

            self.assertEqual(history[0].method, 'PUT')
            self.assertEqual(
                history[0].url,
                API_BASE_URL + '/forms/' + self.formID + '/messages')
Ejemplo n.º 14
0
 def fetch_typeform_form_cat(self):
     token_env = 'TYPEFORM_TOKEN'
     if token_env not in os.environ:
         raise Exception(f"Environment variable '{token_env}' not set")
     forms = Typeform(os.environ[token_env]).forms
     return forms
Ejemplo n.º 15
0
from typeform import Typeform


typeform = Typeform('<typeform-api-token>')
forms = typeform.forms

fields = []


# Sample: multiple chpoice question
multiple_choice = {
      "ref": "<Reference_to_this_question>",
    "title": "<question itself>",
    "type": "multiple_choice",
    "properties": {
        "randomize": False,
        "allow_multiple_selection": False,
        "allow_other_choice": True,
        "vertical_alignment": True,
        "choices": [
          {
            "label": "<multiple choice option_1>",
            "ref": "<reference_to_option_1>"
          },
          {
            "label": "<multiple choice option_2>",
            "ref": "<reference_to_option_2>"
          },
          {
            "label": "<multiple choice option_n>",
            "ref": "<reference_to_option_n>"