class ZendeskAction(Action): def __init__(self, config): super(ZendeskAction, self).__init__(config=config) self.email = self.config['email'] self.token = self.config['api_token'] self.subdomain = self.config['subdomain'] self.credentials = { 'email': self.email, 'token': self.token, 'subdomain': self.subdomain } self.api = Zenpy(**self.credentials) def clean_response(self, text): return text.replace('\n', ' ').replace(' ', ' ').strip() def url_for_ticket(self, ticket): return 'https://{}.zendesk.com/agent/tickets/{}'.format(self.subdomain, ticket) def api_search(self, query, search_type): return self.api.search(query, type=search_type, sort_by='created_at', sort_order='desc') def create_ticket(self, subject, description): ticket = Ticket(subject=subject, description=description) try: created_ticket_audit = self.api.tickets.create(ticket) return { 'ticket_id': created_ticket_audit.ticket.id, 'ticket_url': self.url_for_ticket(created_ticket_audit.ticket.id), 'subject': self.clean_response(subject), 'description': self.clean_response(description) } except APIException: return {'error': 'Could not create ticket with provided parameters'} except Exception as e: self.logger.error(e) return {'error': 'Could not make API request'} def search_tickets(self, query, search_type='ticket', limit=10): try: query_results = self.api_search(query, search_type) results_clean = map(lambda t: { 'ticket_id': t.id, 'ticket_url': self.url_for_ticket(t.id), 'ticket_status': t.status, 'subject': self.clean_response(t.subject), 'description': self.clean_response(t.description)}, list(query_results)[:limit] ) return {'search_results': results_clean} except APIException: return {'error': 'Could not execute search for query: {}'.format(query)} except Exception as e: self.logger.error(e) return {'error': 'There was an error executing your search'} def update_ticket(self, ticket_id, comment_text, public): try: ticket = self.api.tickets(id=ticket_id) ticket.comment = Comment(body=comment_text, public=public) self.api.tickets.update(ticket) return { 'ticket_id': ticket_id, 'ticket_url': self.url_for_ticket(ticket_id), 'body': self.clean_response(comment_text), 'public': public } except RecordNotFoundException: return {'error': 'Could not find ticket #{}'.format(ticket_id)} except Exception as e: self.logger.error(e) return {'error': 'Could not update ticket'} def update_ticket_status(self, ticket_id, status): valid_statuses = ['new', 'open', 'pending', 'solved', 'closed'] if status in valid_statuses: try: ticket = self.api.tickets(id=ticket_id) ticket.status = status self.api.tickets.update(ticket) return { 'ticket_id': ticket_id, 'ticket_url': self.url_for_ticket(ticket_id), 'status': status } except RecordNotFoundException: return {'error': 'Could not find ticket #{}'.format(ticket_id)} except Exception as e: self.logger.error(e) return {'error': 'Could not update ticket status'} else: return {'error': 'Invalid status given for ticket'}
class ZendeskConnection: def __init__(self): self._creds = { 'email': os.environ.get('ZENDESK_USER', None), 'token': os.environ.get('ZENDESK_TOKEN', None), 'subdomain': "pagarme" } self._zenpy_client = Zenpy(**self._creds) self._sl = SlackConnection.SlackConnection() self._mc = MongoConnection.MongoConnection() def _generate_comment(self, ticket): ticket_comments = "" for comment in self._zenpy_client.tickets.comments(ticket_id=ticket.id): ticket_comments += " " + str(comment) return self._remove_special_characters(ticket_comments) def _remove_special_characters(self, phrase): phrase = phrase.lower() return unidecode(phrase) def _word_in_text(self, word, text): if re.search(r'\b' + word + r'\b', text): return True return False def _tag_ticket(self, ticket): try: TAGS = tags.TAGS new_tags = [] subject = self._remove_special_characters(ticket.subject) ticket_comments = self._generate_comment(ticket) description = self._remove_special_characters(ticket.description) content = subject + " " + ticket_comments + " " + description + " " for tag in TAGS: for word in TAGS[tag]: if (self._word_in_text(word, content)) and (tag not in new_tags): new_tags.append(tag) ticket.tags.extend(new_tags) self._zenpy_client.tickets.update(ticket) except Exception as e: print(e.args) def _get_supporters(self): supporter_list = [] for supporter in self._zenpy_client.search(type='user', group_id=21164867): for email in self._mc.get_active_supporters(): if supporter.email in email['email']: try: supporter_list.append(supporter) except Exception as e: print(e.args) return supporter_list def _get_not_assigned_tickets(self): not_assigned_tickets = list() for tickets in self._zenpy_client.search(type='ticket', group_id=21164867, assignee_id=None, status=['new', 'open', 'pending']): not_assigned_tickets.append(tickets) return not_assigned_tickets def _get_assignees_tickets(self, assignees, statuses): assigned_tickets = list() for ticket in self._zenpy_client.search( type='ticket', group_id=21164867, assignee_id=assignees, status=statuses ): assigned_tickets.append(ticket) return assigned_tickets def _get_pending_interaction_tickets(self, tickets, inactiveHours): pending = list() for ticket in tickets: comments = list(self._zenpy_client.tickets.comments(ticket.id)) latest_comment = comments[len(comments)-1] now = datetime.now() latest_comment_date = datetime.strptime(str(latest_comment.created), "%Y-%m-%d %H:%M:%S+00:00") diff_in_hours = utilities.get_dates_diff_in_hours(now, latest_comment_date) if diff_in_hours >= inactiveHours: pending.append(ticket) return pending def _typing_tickets(self): not_assigned_tickets_with_type = list() fl = open("ticket_log.txt", "r+") read_file_string = fl.read() for ticket in self._get_not_assigned_tickets(): if ticket.type in ['problem', 'incident', 'question', 'task']: not_assigned_tickets_with_type.append(ticket) else: if str(ticket.id) not in read_file_string: self._sl.send_message(ticket) fl.write(" " + str(ticket.id)) fl.close() return not_assigned_tickets_with_type def _get_yesterday_tickets(self): yesterday = datetime.now() - timedelta(days=2) yesterday_tickets = self._zenpy_client.search(type='ticket', created_after=yesterday.date(), group_id=21164867) support_tickets = []; for ticket in yesterday_tickets: support_tickets.append(ticket) return support_tickets def _get_ticket_count_supporter(self): sups = self._get_supporters() ticket_count = [] for sup in sups: tickets = self._zenpy_client.search(type='ticket', group_id=21164867, status=['open', 'pending'], assignee_id=sup.id) count = len(tickets) ticket_count.append({'nome': sup.name, 'count': count, 'id': sup.id}) print('Active supporters: \n' + str(ticket_count)) return ticket_count def tag_yesterday_tickets(self): yesterday_tickets = self._get_yesterday_tickets() tagged_tickets = []; for ticket in yesterday_tickets: self._tag_ticket(ticket) tagged_tickets.append(ticket.id) print('Tagged tickets: ' + ''.join( str(tagged_tickets) ) ) def assign_tickets(self): sups = self._get_ticket_count_supporter() # Send ticket type message through slack tickets = self._typing_tickets() if sups: if len(tickets) > 0: for ticket in tickets: # Get lowest ticket count supporter lowest_ticket_count_sup = None for count in sups: if not lowest_ticket_count_sup: lowest_ticket_count_sup = count elif count['count'] < lowest_ticket_count_sup['count']: lowest_ticket_count_sup = count sup = self._mc.get_supporter_by_zendesk_id(lowest_ticket_count_sup['id']) try: # Assign the ticket ticket.assignee_id = sup['zendesk_id'] slack_id = sup['slack_id'] name = sup['name'] print(slack_id + " | " + name) self._zenpy_client.tickets.update(ticket) # Notify the supporter on slack self._sl.notify_supporter(slack_id, name, ticket) # Increase the ticket count for the agent who got it for agent in sups: if agent['id'] == lowest_ticket_count_sup['id']: agent['count'] += 1 except Exception as e: print(e.args) elif len(tickets) <= 0: print("No tickets to assign.") elif not sups: print("No active agents to assign tickets.") def notify_pending_interaction_tickets(self): supporters = list(self._mc.find_supporters()) supportersIds = map(lambda supporter: supporter["zendesk_id"], supporters) supportersTickets = self._get_assignees_tickets(supportersIds, ["open", "pending", "hold"]) minInactiveHours = 24 pendingInteractionTickets = self._get_pending_interaction_tickets(supportersTickets, minInactiveHours) if len(pendingInteractionTickets) == 0: print("No pending tickets to notify") return for supporter in supporters: supporterTickets = [ticket for ticket in pendingInteractionTickets if str(ticket.assignee_id) == supporter["zendesk_id"]] self._sl.notify_pending_interaction_tickets(supporter, supporterTickets, minInactiveHours)
def __init__(self, *args, **kwargs): creds = { "email": settings.ZENDESK_EMAIL, "token": settings.ZENDESK_TOKEN, "subdomain": settings.ZENDESK_SUBDOMAIN, } self.client = Zenpy(**creds)
def __init__(self, user, token, NoOfdays): self.creds = {'email': user, 'token': token, 'subdomain': 'qubole'} self.client = Zenpy(**self.creds) self.startTime = datetime.datetime.now() - datetime.timedelta( days=NoOfdays) self.result_generator = self.client.tickets.incremental( start_time=self.startTime)
def close_ticket(prescription): if not isinstance(prescription, MedicalPrescription): return False mticket = ZendeskTicket.objects.filter(prescription=prescription).first() zenpy_client = Zenpy(**settings.ZENDESK) if not mticket: return False ticket = zenpy_client.tickets(id=mticket.external_id) ticket.status = 'solved' if prescription.status in domain_models.MedicalPrescription.STATUS_CHOICES: new_cf = [] for cf in ticket.custom_fields: if cf.get('id', None) == 114103846891: new_cf.append({ 'id': 114103846891, 'value': prescription.status.lower() }) new_cf.append(cf) ticket.custom_fields = new_cf ticket_audit = zenpy_client.tickets.update(ticket) if ticket_audit: return True return False
def index(): try: # We use try method to keep running if there is no API available. # Default zenpy_client = Zenpy(**creds) ticket_generator = zenpy_client.tickets() return render_template('index.html', tickets=ticket_generator) except: print("Sorry, API isn't currently available")
def delete_all_tickets(): zenpy_client = Zenpy(**settings.ZENDESK) for ticket in zenpy_client.search(status="new"): zenpy_client.tickets.delete(ticket) for ticket in zenpy_client.search(status="open"): zenpy_client.tickets.delete(ticket)
def get_description(ticket_id): global zenpy_client try: zenpy_client = Zenpy(**credentials) ticket = zenpy_client.tickets(id=ticket_id) return ticket.description except Exception as e: logger.exception("get_description {}".format(e)) raise
def __init__(self): self._creds = { 'email': os.environ.get('ZENDESK_USER', None), 'token': os.environ.get('ZENDESK_TOKEN', None), 'subdomain': "pagarme" } self._zenpy_client = Zenpy(**self._creds) self._sl = SlackConnection.SlackConnection() self._mc = MongoConnection.MongoConnection()
def get_unclosed_tickets(email: str, token: str, subdomain: str) -> Iterable[Ticket]: zenpy = Zenpy(subdomain, email, token) ticket: ZendeskTicket for ticket in zenpy.tickets(): requester: ZendeskUser = ticket.requester waiting_on = None staled_at = None yield Ticket(ticket.id, ticket.subject, requester.email, requester.email, ticket.status, waiting_on, staled_at, ticket.created_at)
def update_ticket(ticket_id, message): global zenpy_client comment = "```\n{}\n```".format(message) try: zenpy_client = Zenpy(**credentials) ticket = zenpy_client.tickets(id=ticket_id) ticket.comment = Comment(body=comment, public=False) zenpy_client.tickets.update(ticket) except Exception as e: logger.exception("update_ticket {}".format(e)) raise
def validate_zendesk_credentials(subdomain: str, user_name: str, api_token: str): from zenpy import Zenpy from zenpy.lib.exception import APIException try: zendesk_client = Zenpy(subdomain=subdomain, email=user_name, token=api_token) list(zendesk_client.search(assignee='test')) except APIException as e: raise ActionFailure(e)
def __init__(self, config): super(ZendeskAction, self).__init__(config=config) self.email = self.config['email'] self.token = self.config['api_token'] self.subdomain = self.config['subdomain'] self.credentials = { 'email': self.email, 'token': self.token, 'subdomain': self.subdomain } self.api = Zenpy(**self.credentials)
def check_zendesk_ticket(foia): """Check if an open zendesk ticket exists for this FOIA""" client = Zenpy( email=settings.ZENDESK_EMAIL, subdomain=settings.ZENDESK_SUBDOMAIN, token=settings.ZENDESK_TOKEN, ) response = client.search( "{}-{}".format(foia.slug, foia.pk), type="ticket", via="api", subject="FOIAOnline", status="open", ) return len(list(response)) > 0
def close_adf_ticket(ticket): if not isinstance(ticket, ZendeskASFTicket): return False zenpy_client = Zenpy(**settings.ZENDESK) ticket = zenpy_client.tickets(id=ticket.external_id) ticket.status = 'solved' ticket_audit = zenpy_client.tickets.update(ticket) if ticket_audit: return True return False
def main(): parsed_args = singer.utils.parse_args(REQUIRED_CONFIG_KEYS) creds = {"subdomain": parsed_args.config['subdomain']} try: oauth_args = singer.utils.parse_args(OAUTH_CONFIG_KEYS) creds.update({ "oauth_token": oauth_args.config['access_token'], }) except: LOGGER.debug("Cannot find oauth configuration.") try: api_args = singer.utils.parse_args(API_CONFIG_KEYS) creds.update({ "email": api_args.config['email'], "token": api_args.config['api_token'] }) except: LOGGER.debug("Cannot find api token configuration.") client = Zenpy(**creds) if parsed_args.discover: do_discover(client) elif parsed_args.catalog: state = parsed_args.state do_sync(client, parsed_args.catalog, state, parsed_args.config['start_date'])
def create_support_request(user, email, message, attachments=()): client = Zenpy( subdomain=settings.ZENDESK_SUBDOMAIN, email=settings.ZENDESK_EMAIL, token=settings.ZENDESK_TOKEN, ) ticket_audit = client.tickets.create( Ticket( subject='Data Workspace Support Request', description=message, requester=User(email=email, name=user.get_full_name()), custom_fields=[ CustomField( id=zendesk_service_field_id, value=zendesk_service_field_value ) ], ) ) if attachments: uploads = [client.attachments.upload(x) for x in attachments] ticket_audit.ticket.comment = Comment( body='Additional attachments', uploads=[x.token for x in uploads] ) client.tickets.update(ticket_audit.ticket) return ticket_audit.ticket.id
def create_ticket(title, description, impact, history, name, email): global ticket_number zendesk_client = Zenpy(**creds) # Create a new ticket ticket_audit = zendesk_client.tickets.create( Ticket( subject=title, requester=User(name=name, email=email), comment=Comment( html_body= '<h3>Request Details</h3><pre><code>Title: {}<br>Request: {}<br>' 'Impact: {}<br>History: {}</code></pre><h3>Submitter Details</h3><pre><code>' 'Name: {}<br>Email: {}</code></pre>'.format( title, description, impact, history, name, email)), type="problem", priority="normal", requester_id="366101959011", submitter_id="366101959011", ticket_form_id="360000072631", group_id="360000964291", collaborator_ids=["443254580", "656182144"], follower_ids=["443254580", "656182144"], custom_fields=[ CustomField(id=360005680151, value='request_to_update_existing_process') ])) ticket_number = ticket_audit.ticket.id
def main(): parsed_args = singer.utils.parse_args(REQUIRED_CONFIG_KEYS) # OAuth has precedence creds = oauth_auth(parsed_args) or api_token_auth(parsed_args) session = get_session(parsed_args.config) # Pass some config options into the client rate_limit_settings = {} for key in ('proactive_ratelimit', 'proactive_ratelimit_request_interval', 'ratelimit_budget'): if key in parsed_args.config: rate_limit_settings[key] = parsed_args.config.pop(key) LOGGER.info('zenpy rate limit settings = %r', rate_limit_settings) client = Zenpy(session=session, **rate_limit_settings, **creds) if not client: LOGGER.error("""No suitable authentication keys provided.""") if parsed_args.discover: do_discover(client) elif parsed_args.catalog: state = parsed_args.state start_date = parsed_args.config['start_date'] lookback_minutes = parsed_args.config.get('lookback_minutes') do_sync(client, parsed_args.catalog, state, start_date, lookback_minutes)
def _get_client(): global zenpy_client # Zenpy will let the connection timeout after 5s and will retry 3 times if not zenpy_client: zenpy_client = Zenpy(timeout=5, **ZENPY_CREDENTIALS) return zenpy_client
def __init__(self, **kwargs): """Initialize Zendesk API client.""" creds = { "email": settings.ZENDESK_USER_EMAIL, "token": settings.ZENDESK_API_TOKEN, "subdomain": settings.ZENDESK_SUBDOMAIN, } self.client = Zenpy(**creds)
def send_to_zendesk(request_email, subject, message, user=None): ticket = create_zendesk_ticket(request_email, subject, message, user) zenpy = Zenpy( email=settings.ZENDESK_EMAIL, token=settings.ZENDESK_TOKEN, subdomain='freesound' ) zenpy.tickets.create(ticket)
def get_tickets(client: Zenpy) -> List: """ Gets all tickets from the Zendesk API for the workspace. N.B.: will be inefficient at large size, should paginate requests in future. :param client: the Zenpy client connection object :return: a list of all tickets for the client workspace """ return list(client.tickets())
def send_to_zendesk(request_email, subject, message, user=None): ticket = create_zendesk_ticket(request_email, subject, message, user) zenpy = Zenpy(email=settings.ZENDESK_EMAIL, token=settings.ZENDESK_TOKEN, subdomain='freesound') try: zenpy.tickets.create(ticket) except (ZendeskAPIException, HTTPError, ZenpyException) as e: web_logger.info('Error creating Zendesk ticket: {}'.format(str(e)))
def update_zendesk_ticket(ticket_id, comment=None, status=None): client = Zenpy( subdomain=settings.ZENDESK_SUBDOMAIN, email=settings.ZENDESK_EMAIL, token=settings.ZENDESK_TOKEN, ) ticket = client.tickets(id=ticket_id) if comment: ticket.comment = Comment(body=comment, public=False) if status: ticket.status = status client.tickets.update(ticket) return ticket
def __init__(self, connector): self.connector = connector self.settings = frappe.get_doc("Zendesk Settings", None) if not self.settings.last_user_sync: frappe.db.set_value("Zendesk Settings", None, "last_user_sync", now_datetime()) if not self.settings.last_org_sync: frappe.db.set_value("Zendesk Settings", None, "last_org_sync", now_datetime()) self.name_field = 'id' try: self.zenpy_client = Zenpy(**{ 'email' : self.settings.email, 'token' : self.settings.get_password(fieldname='api_token',raise_exception=False), 'subdomain': self.settings.subdomain }) except Exception as e: frappe.log_error(e, 'Zendesk Connection Error') try: found = False if self.settings.org_type_id: for field in self.zenpy_client.organization_fields(): if field.id == self.settings.org_type_id: found = True if found == False: for field in self.zenpy_client.organization_fields(): if field.key == 'is_supplier' and field.type == 'checkbox': frappe.db.set_value("Zendesk Settings", "Zendesk Settings", "org_type_id", field.id) found = True if found == False: self.create_custom_field() else: for field in self.zenpy_client.organization_fields(): if field.key == 'is_supplier' and field.type == 'checkbox': frappe.db.set_value("Zendesk Settings", "Zendesk Settings", "org_type_id", field.id) found = True if found == False: self.create_custom_field() except Exception as e: frappe.log_error(e, 'Zendesk Setup Error')
def zenpyz(oauth_token): creds = {"subdomain": subdomain, "oauth_token": oauth_token} # Import the Zenpy Class from zenpy import Zenpy zenpy_client = Zenpy(**creds) for comment in zenpy_client.tickets.comments(ticket_id=98): print comment.body
def etl(): s3 = boto3.client( 's3', aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"), aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"), region_name=os.getenv("AWS_DEFAULT_REGION"), ) zenpy = Zenpy( email=os.getenv("ZENDESK_EMAIL"), token=os.getenv("ZENDESK_TOKEN"), subdomain=os.getenv("OUR_SUBDOMAIN"), ) dsn_string = os.getenv("REDSHIFT_CONN_STRING") # Process nonform tickets conn = psycopg2.connect(dsn_string) conn.set_session(autocommit=True) nonform_query = "SELECT MAX(created_at) FROM zendesk.tickets WHERE LENGTH(ticket_form)=0" start_date, end_date = find_dates(conn, query=nonform_query) filename = time.strftime("%d_%m_%Y") + '_zendesk_tickets.json' extract_tickets(zenpy, start_date, end_date, filename) stage_and_load_tickets(conn, s3, filename) delete_duplicates(conn) conn.close() # Process form tickets form_dsn = "host='hostname' dbname='public' user='******' password='******' port='5439'" conn = psycopg2.connect(dsn_string) conn.set_session(autocommit=True) form_query = "SELECT MAX(created_at) FROM zendesk.tickets WHERE LENGTH(ticket_form)>0" start_date, end_date = find_dates(conn, query=form_query) ticket_forms = [ 'Pre sale product enquiry', 'Pre sale delivery enquiry', 'Pre sale invoice enquiry', 'Pre sale service enquiry', 'Pre despatch order enquiry', 'Post despatch delivery enquiry', 'Post despatch returns enquiry', 'Post despatch item damaged', 'Technical enquiry', 'Post despatch general enquiry', ] for form in tqdm(ticket_forms, leave=True): filename = time.strftime("%d_%m_%Y") + '_zendesk_tickets_' + str( form) + '.json' extract_tickets(zenpy, start_date, end_date, filename, form=form) stage_and_load_tickets(conn, s3, filename) delete_duplicates(conn) conn.close()
def zdviewtest(view_title): zd_client = Zenpy(**creds) view = next(iter(zd_client.views.search(query=view_title) or []), None) print(view.title) for ticket in zd_client.views.tickets(view): metrics = zd_client.tickets.metrics(ticket.id) dd, hh, mm = days_hours_minutes( parse(metrics.status_updated_at) - parse(metrics.created_at)) print(u"{0};{1};{2};{3};{4};{5};{6};{7}".format( ticket.id, ticket.subject, ticket.status, metrics.created_at, metrics.status_updated_at, dd, hh, mm))
def create_zendesk_ticket(self): zenpy_client = Zenpy( subdomain=settings.ZENDESK_SUBDOMAIN, email=settings.ZENDESK_EMAIL, token=settings.ZENDESK_TOKEN, ) attachments = [ value for field, value in self.cleaned_data.items() if field.startswith('attachment') and value ] if attachments: uploads = [] for attachment in attachments: upload_instance = zenpy_client.attachments.upload( attachment.temporary_file_path()) uploads.append(upload_instance.token) else: uploads = None service = SERVICE_FIELD_MAPPING[self.cleaned_data['platform']] custom_fields = [ CustomField(id=30041969, value=service), # service CustomField(id=360000180437, value=self.cleaned_data['department']), # directorate CustomField(id=45522485, value=self.cleaned_data['email']), # email CustomField(id=360000188178, value=self.cleaned_data['telephone']), # Phone number CustomField( id=360000182638, value=self.cleaned_data['request_type']), # Content request CustomField(id=360000180477, value=self.cleaned_data['publication_date_explanation'] ), # reason CustomField(id=360000180457, value=str( self.cleaned_data['publication_date'])) # due date ] ticket = zenpy_client.tickets.create( Ticket(subject=self.cleaned_data['title_of_request'], custom_fields=custom_fields, tags=['content_delivery', self.cleaned_data['platform']], comment=Comment(html_body=self.formatted_text(), uploads=uploads), requester=User(name=self.cleaned_data['name'], email=self.cleaned_data['email']))).ticket return ticket.id
def import_tickets(tickets): creds = { 'email': os.environ['DATABOT_ZD_EMAIL'], 'token': os.environ['DATABOT_ZD_TOKEN'], 'subdomain': os.environ['DATABOT_ZD_SUBDOMAIN'] } zenpy_client = Zenpy(**creds) # Create a new ticket for ticket in tickets: print ticket ticket = Ticket(**ticket) zenpy_client.ticket_import.create(ticket)
def run(self): zenpy = Zenpy.__new__(Zenpy) zenpy.__init__(zenpy, ' ', ' ') node_list = [] cache_node = container() cache_sections = self.generate_cache_sections(zenpy) for cache_section in cache_sections: node = paragraph() self.state.nested_parse(StringList(cache_section.split('\n')), 0, node) node_list.append(node) node_list.append(cache_node) return node_list
def get_client(config): """Given a `config`, create a Zenpy API client.""" zenpy_args = dict([ (zenpy_key, getattr(config, config_key, None)) for zenpy_key, config_key in [( 'email', 'email'), ('password', 'password'), ('subdomain', 'subdomain')] ]) try: zenpy_client = Zenpy(**zenpy_args) except zenpy.lib.exception.ZenpyException as exc: if getattr(config, 'unpickle_tickets', None): zenpy_args['password'] = zenpy_args['password'] or 'dummy_pass' zenpy_args['subdomain'] = zenpy_args['subdomain'] \ or 'dummy_subdomain' zenpy_args['email'] = zenpy_args['email'] or 'dummy_email' zenpy_client = Zenpy(**zenpy_args) else: raise ZTVConfigException(str(exc)) return handle_pickling(config, zenpy_client)
def run(self): zenpy = Zenpy.__new__(Zenpy) zenpy.__init__(zenpy, ' ', ' ') node_list = [] doc_sections = self.generate_sections(zenpy) output = '.. py:class:: Zenpy%s\n\n' % inspect.signature(zenpy.__class__) output += ' %s' % zenpy.__doc__ node = container() self.state.nested_parse(StringList(output.split('\n')), 0, node) node_list.append(node) for doc_section in doc_sections: node = paragraph() self.state.nested_parse(StringList(doc_section.split('\n')), 0, node) node_list.append(node) return node_list