repo stringlengths 7 55 | path stringlengths 4 223 | func_name stringlengths 1 134 | original_string stringlengths 75 104k | language stringclasses 1 value | code stringlengths 75 104k | code_tokens listlengths 19 28.4k | docstring stringlengths 1 46.9k | docstring_tokens listlengths 1 1.97k | sha stringlengths 40 40 | url stringlengths 87 315 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
rhgrant10/Groupy | groupy/pagers.py | MessageList.set_next_page_params | def set_next_page_params(self):
"""Set the params so that the next page is fetched."""
if self.items:
index = self.get_last_item_index()
self.params[self.mode] = self.get_next_page_param(self.items[index]) | python | def set_next_page_params(self):
"""Set the params so that the next page is fetched."""
if self.items:
index = self.get_last_item_index()
self.params[self.mode] = self.get_next_page_param(self.items[index]) | [
"def",
"set_next_page_params",
"(",
"self",
")",
":",
"if",
"self",
".",
"items",
":",
"index",
"=",
"self",
".",
"get_last_item_index",
"(",
")",
"self",
".",
"params",
"[",
"self",
".",
"mode",
"]",
"=",
"self",
".",
"get_next_page_param",
"(",
"self",... | Set the params so that the next page is fetched. | [
"Set",
"the",
"params",
"so",
"that",
"the",
"next",
"page",
"is",
"fetched",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/pagers.py#L114-L118 | train |
rhgrant10/Groupy | groupy/api/blocks.py | Blocks.list | def list(self):
"""List the users you have blocked.
:return: a list of :class:`~groupy.api.blocks.Block`'s
:rtype: :class:`list`
"""
params = {'user': self.user_id}
response = self.session.get(self.url, params=params)
blocks = response.data['blocks']
return [Block(self, **block) for block in blocks] | python | def list(self):
"""List the users you have blocked.
:return: a list of :class:`~groupy.api.blocks.Block`'s
:rtype: :class:`list`
"""
params = {'user': self.user_id}
response = self.session.get(self.url, params=params)
blocks = response.data['blocks']
return [Block(self, **block) for block in blocks] | [
"def",
"list",
"(",
"self",
")",
":",
"params",
"=",
"{",
"'user'",
":",
"self",
".",
"user_id",
"}",
"response",
"=",
"self",
".",
"session",
".",
"get",
"(",
"self",
".",
"url",
",",
"params",
"=",
"params",
")",
"blocks",
"=",
"response",
".",
... | List the users you have blocked.
:return: a list of :class:`~groupy.api.blocks.Block`'s
:rtype: :class:`list` | [
"List",
"the",
"users",
"you",
"have",
"blocked",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/blocks.py#L16-L25 | train |
rhgrant10/Groupy | groupy/api/blocks.py | Blocks.between | def between(self, other_user_id):
"""Check if there is a block between you and the given user.
:return: ``True`` if the given user has been blocked
:rtype: bool
"""
params = {'user': self.user_id, 'otherUser': other_user_id}
response = self.session.get(self.url, params=params)
return response.data['between'] | python | def between(self, other_user_id):
"""Check if there is a block between you and the given user.
:return: ``True`` if the given user has been blocked
:rtype: bool
"""
params = {'user': self.user_id, 'otherUser': other_user_id}
response = self.session.get(self.url, params=params)
return response.data['between'] | [
"def",
"between",
"(",
"self",
",",
"other_user_id",
")",
":",
"params",
"=",
"{",
"'user'",
":",
"self",
".",
"user_id",
",",
"'otherUser'",
":",
"other_user_id",
"}",
"response",
"=",
"self",
".",
"session",
".",
"get",
"(",
"self",
".",
"url",
",",
... | Check if there is a block between you and the given user.
:return: ``True`` if the given user has been blocked
:rtype: bool | [
"Check",
"if",
"there",
"is",
"a",
"block",
"between",
"you",
"and",
"the",
"given",
"user",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/blocks.py#L27-L35 | train |
rhgrant10/Groupy | groupy/api/blocks.py | Blocks.block | def block(self, other_user_id):
"""Block the given user.
:param str other_user_id: the ID of the user to block
:return: the block created
:rtype: :class:`~groupy.api.blocks.Block`
"""
params = {'user': self.user_id, 'otherUser': other_user_id}
response = self.session.post(self.url, params=params)
block = response.data['block']
return Block(self, **block) | python | def block(self, other_user_id):
"""Block the given user.
:param str other_user_id: the ID of the user to block
:return: the block created
:rtype: :class:`~groupy.api.blocks.Block`
"""
params = {'user': self.user_id, 'otherUser': other_user_id}
response = self.session.post(self.url, params=params)
block = response.data['block']
return Block(self, **block) | [
"def",
"block",
"(",
"self",
",",
"other_user_id",
")",
":",
"params",
"=",
"{",
"'user'",
":",
"self",
".",
"user_id",
",",
"'otherUser'",
":",
"other_user_id",
"}",
"response",
"=",
"self",
".",
"session",
".",
"post",
"(",
"self",
".",
"url",
",",
... | Block the given user.
:param str other_user_id: the ID of the user to block
:return: the block created
:rtype: :class:`~groupy.api.blocks.Block` | [
"Block",
"the",
"given",
"user",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/blocks.py#L37-L47 | train |
rhgrant10/Groupy | groupy/api/blocks.py | Blocks.unblock | def unblock(self, other_user_id):
"""Unblock the given user.
:param str other_user_id: the ID of the user to unblock
:return: ``True`` if successful
:rtype: bool
"""
params = {'user': self.user_id, 'otherUser': other_user_id}
response = self.session.delete(self.url, params=params)
return response.ok | python | def unblock(self, other_user_id):
"""Unblock the given user.
:param str other_user_id: the ID of the user to unblock
:return: ``True`` if successful
:rtype: bool
"""
params = {'user': self.user_id, 'otherUser': other_user_id}
response = self.session.delete(self.url, params=params)
return response.ok | [
"def",
"unblock",
"(",
"self",
",",
"other_user_id",
")",
":",
"params",
"=",
"{",
"'user'",
":",
"self",
".",
"user_id",
",",
"'otherUser'",
":",
"other_user_id",
"}",
"response",
"=",
"self",
".",
"session",
".",
"delete",
"(",
"self",
".",
"url",
",... | Unblock the given user.
:param str other_user_id: the ID of the user to unblock
:return: ``True`` if successful
:rtype: bool | [
"Unblock",
"the",
"given",
"user",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/blocks.py#L49-L58 | train |
rhgrant10/Groupy | groupy/api/chats.py | Chats.list | def list(self, page=1, per_page=10):
"""List a page of chats.
:param int page: which page
:param int per_page: how many chats per page
:return: chats with other users
:rtype: :class:`~groupy.pagers.ChatList`
"""
return pagers.ChatList(self, self._raw_list, per_page=per_page,
page=page) | python | def list(self, page=1, per_page=10):
"""List a page of chats.
:param int page: which page
:param int per_page: how many chats per page
:return: chats with other users
:rtype: :class:`~groupy.pagers.ChatList`
"""
return pagers.ChatList(self, self._raw_list, per_page=per_page,
page=page) | [
"def",
"list",
"(",
"self",
",",
"page",
"=",
"1",
",",
"per_page",
"=",
"10",
")",
":",
"return",
"pagers",
".",
"ChatList",
"(",
"self",
",",
"self",
".",
"_raw_list",
",",
"per_page",
"=",
"per_page",
",",
"page",
"=",
"page",
")"
] | List a page of chats.
:param int page: which page
:param int per_page: how many chats per page
:return: chats with other users
:rtype: :class:`~groupy.pagers.ChatList` | [
"List",
"a",
"page",
"of",
"chats",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/chats.py#L17-L26 | train |
rhgrant10/Groupy | groupy/api/messages.py | Messages.list | def list(self, before_id=None, since_id=None, after_id=None, limit=20):
"""Return a page of group messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``, or ``after_id``.
:param str before_id: message ID for paging backwards
:param str after_id: message ID for paging forwards
:param str since_id: message ID for most recent messages since
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return pagers.MessageList(self, self._raw_list, before_id=before_id,
after_id=after_id, since_id=since_id,
limit=limit) | python | def list(self, before_id=None, since_id=None, after_id=None, limit=20):
"""Return a page of group messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``, or ``after_id``.
:param str before_id: message ID for paging backwards
:param str after_id: message ID for paging forwards
:param str since_id: message ID for most recent messages since
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return pagers.MessageList(self, self._raw_list, before_id=before_id,
after_id=after_id, since_id=since_id,
limit=limit) | [
"def",
"list",
"(",
"self",
",",
"before_id",
"=",
"None",
",",
"since_id",
"=",
"None",
",",
"after_id",
"=",
"None",
",",
"limit",
"=",
"20",
")",
":",
"return",
"pagers",
".",
"MessageList",
"(",
"self",
",",
"self",
".",
"_raw_list",
",",
"before... | Return a page of group messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``, or ``after_id``.
:param str before_id: message ID for paging backwards
:param str after_id: message ID for paging forwards
:param str since_id: message ID for most recent messages since
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList` | [
"Return",
"a",
"page",
"of",
"group",
"messages",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L28-L43 | train |
rhgrant10/Groupy | groupy/api/messages.py | Messages.list_since | def list_since(self, message_id, limit=None):
"""Return a page of group messages created since a message.
This is used to fetch the most recent messages after another. There
may exist messages between the one given and the ones returned. Use
:func:`list_after` to retrieve newer messages without skipping any.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return self.list(since_id=message_id, limit=limit) | python | def list_since(self, message_id, limit=None):
"""Return a page of group messages created since a message.
This is used to fetch the most recent messages after another. There
may exist messages between the one given and the ones returned. Use
:func:`list_after` to retrieve newer messages without skipping any.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return self.list(since_id=message_id, limit=limit) | [
"def",
"list_since",
"(",
"self",
",",
"message_id",
",",
"limit",
"=",
"None",
")",
":",
"return",
"self",
".",
"list",
"(",
"since_id",
"=",
"message_id",
",",
"limit",
"=",
"limit",
")"
] | Return a page of group messages created since a message.
This is used to fetch the most recent messages after another. There
may exist messages between the one given and the ones returned. Use
:func:`list_after` to retrieve newer messages without skipping any.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList` | [
"Return",
"a",
"page",
"of",
"group",
"messages",
"created",
"since",
"a",
"message",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L57-L69 | train |
rhgrant10/Groupy | groupy/api/messages.py | Messages.list_after | def list_after(self, message_id, limit=None):
"""Return a page of group messages created after a message.
This is used to page forwards through messages.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return self.list(after_id=message_id, limit=limit) | python | def list_after(self, message_id, limit=None):
"""Return a page of group messages created after a message.
This is used to page forwards through messages.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return self.list(after_id=message_id, limit=limit) | [
"def",
"list_after",
"(",
"self",
",",
"message_id",
",",
"limit",
"=",
"None",
")",
":",
"return",
"self",
".",
"list",
"(",
"after_id",
"=",
"message_id",
",",
"limit",
"=",
"limit",
")"
] | Return a page of group messages created after a message.
This is used to page forwards through messages.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: :class:`~groupy.pagers.MessageList` | [
"Return",
"a",
"page",
"of",
"group",
"messages",
"created",
"after",
"a",
"message",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L71-L81 | train |
rhgrant10/Groupy | groupy/api/messages.py | Messages.list_all_before | def list_all_before(self, message_id, limit=None):
"""Return all group messages created before a message.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: generator
"""
return self.list_before(message_id, limit=limit).autopage() | python | def list_all_before(self, message_id, limit=None):
"""Return all group messages created before a message.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: generator
"""
return self.list_before(message_id, limit=limit).autopage() | [
"def",
"list_all_before",
"(",
"self",
",",
"message_id",
",",
"limit",
"=",
"None",
")",
":",
"return",
"self",
".",
"list_before",
"(",
"message_id",
",",
"limit",
"=",
"limit",
")",
".",
"autopage",
"(",
")"
] | Return all group messages created before a message.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: generator | [
"Return",
"all",
"group",
"messages",
"created",
"before",
"a",
"message",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L92-L100 | train |
rhgrant10/Groupy | groupy/api/messages.py | Messages.list_all_after | def list_all_after(self, message_id, limit=None):
"""Return all group messages created after a message.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: generator
"""
return self.list_after(message_id, limit=limit).autopage() | python | def list_all_after(self, message_id, limit=None):
"""Return all group messages created after a message.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: generator
"""
return self.list_after(message_id, limit=limit).autopage() | [
"def",
"list_all_after",
"(",
"self",
",",
"message_id",
",",
"limit",
"=",
"None",
")",
":",
"return",
"self",
".",
"list_after",
"(",
"message_id",
",",
"limit",
"=",
"limit",
")",
".",
"autopage",
"(",
")"
] | Return all group messages created after a message.
:param str message_id: the ID of a message
:param int limit: maximum number of messages per page
:return: group messages
:rtype: generator | [
"Return",
"all",
"group",
"messages",
"created",
"after",
"a",
"message",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L102-L110 | train |
rhgrant10/Groupy | groupy/api/messages.py | Messages.create | def create(self, text=None, attachments=None, source_guid=None):
"""Create a new message in the group.
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:param str source_guid: a unique identifier for the message
:return: the created message
:rtype: :class:`~groupy.api.messages.Message`
"""
message = {
'source_guid': source_guid or str(time.time()),
}
if text is not None:
message['text'] = text
if attachments is not None:
message['attachments'] = [a.to_json() for a in attachments]
payload = {'message': message}
response = self.session.post(self.url, json=payload)
message = response.data['message']
return Message(self, **message) | python | def create(self, text=None, attachments=None, source_guid=None):
"""Create a new message in the group.
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:param str source_guid: a unique identifier for the message
:return: the created message
:rtype: :class:`~groupy.api.messages.Message`
"""
message = {
'source_guid': source_guid or str(time.time()),
}
if text is not None:
message['text'] = text
if attachments is not None:
message['attachments'] = [a.to_json() for a in attachments]
payload = {'message': message}
response = self.session.post(self.url, json=payload)
message = response.data['message']
return Message(self, **message) | [
"def",
"create",
"(",
"self",
",",
"text",
"=",
"None",
",",
"attachments",
"=",
"None",
",",
"source_guid",
"=",
"None",
")",
":",
"message",
"=",
"{",
"'source_guid'",
":",
"source_guid",
"or",
"str",
"(",
"time",
".",
"time",
"(",
")",
")",
",",
... | Create a new message in the group.
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:param str source_guid: a unique identifier for the message
:return: the created message
:rtype: :class:`~groupy.api.messages.Message` | [
"Create",
"a",
"new",
"message",
"in",
"the",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L112-L135 | train |
rhgrant10/Groupy | groupy/api/messages.py | DirectMessages.list | def list(self, before_id=None, since_id=None, **kwargs):
"""Return a page of direct messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``.
:param str before_id: message ID for paging backwards
:param str since_id: message ID for most recent messages since
:return: direct messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return pagers.MessageList(self, self._raw_list, before_id=before_id,
since_id=since_id, **kwargs) | python | def list(self, before_id=None, since_id=None, **kwargs):
"""Return a page of direct messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``.
:param str before_id: message ID for paging backwards
:param str since_id: message ID for most recent messages since
:return: direct messages
:rtype: :class:`~groupy.pagers.MessageList`
"""
return pagers.MessageList(self, self._raw_list, before_id=before_id,
since_id=since_id, **kwargs) | [
"def",
"list",
"(",
"self",
",",
"before_id",
"=",
"None",
",",
"since_id",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"pagers",
".",
"MessageList",
"(",
"self",
",",
"self",
".",
"_raw_list",
",",
"before_id",
"=",
"before_id",
",",
"... | Return a page of direct messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``.
:param str before_id: message ID for paging backwards
:param str since_id: message ID for most recent messages since
:return: direct messages
:rtype: :class:`~groupy.pagers.MessageList` | [
"Return",
"a",
"page",
"of",
"direct",
"messages",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L157-L169 | train |
rhgrant10/Groupy | groupy/api/messages.py | DirectMessages.list_all | def list_all(self, before_id=None, since_id=None, **kwargs):
"""Return all direct messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``.
:param str before_id: message ID for paging backwards
:param str since_id: message ID for most recent messages since
:return: direct messages
:rtype: generator
"""
return self.list(before_id=before_id, since_id=since_id, **kwargs).autopage() | python | def list_all(self, before_id=None, since_id=None, **kwargs):
"""Return all direct messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``.
:param str before_id: message ID for paging backwards
:param str since_id: message ID for most recent messages since
:return: direct messages
:rtype: generator
"""
return self.list(before_id=before_id, since_id=since_id, **kwargs).autopage() | [
"def",
"list_all",
"(",
"self",
",",
"before_id",
"=",
"None",
",",
"since_id",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"self",
".",
"list",
"(",
"before_id",
"=",
"before_id",
",",
"since_id",
"=",
"since_id",
",",
"*",
"*",
"kwarg... | Return all direct messages.
The messages come in reversed order (newest first). Note you can only
provide _one_ of ``before_id``, ``since_id``.
:param str before_id: message ID for paging backwards
:param str since_id: message ID for most recent messages since
:return: direct messages
:rtype: generator | [
"Return",
"all",
"direct",
"messages",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/messages.py#L194-L205 | train |
rhgrant10/Groupy | groupy/api/memberships.py | Memberships.add | def add(self, nickname, email=None, phone_number=None, user_id=None):
"""Add a user to the group.
You must provide either the email, phone number, or user_id that
uniquely identifies a user.
:param str nickname: new name for the user in the group
:param str email: email address of the user
:param str phone_number: phone number of the user
:param str user_id: user_id of the user
:return: a membership request
:rtype: :class:`MembershipRequest`
"""
member = {
'nickname': nickname,
'email': email,
'phone_number': phone_number,
'user_id': user_id,
}
return self.add_multiple(member) | python | def add(self, nickname, email=None, phone_number=None, user_id=None):
"""Add a user to the group.
You must provide either the email, phone number, or user_id that
uniquely identifies a user.
:param str nickname: new name for the user in the group
:param str email: email address of the user
:param str phone_number: phone number of the user
:param str user_id: user_id of the user
:return: a membership request
:rtype: :class:`MembershipRequest`
"""
member = {
'nickname': nickname,
'email': email,
'phone_number': phone_number,
'user_id': user_id,
}
return self.add_multiple(member) | [
"def",
"add",
"(",
"self",
",",
"nickname",
",",
"email",
"=",
"None",
",",
"phone_number",
"=",
"None",
",",
"user_id",
"=",
"None",
")",
":",
"member",
"=",
"{",
"'nickname'",
":",
"nickname",
",",
"'email'",
":",
"email",
",",
"'phone_number'",
":",... | Add a user to the group.
You must provide either the email, phone number, or user_id that
uniquely identifies a user.
:param str nickname: new name for the user in the group
:param str email: email address of the user
:param str phone_number: phone number of the user
:param str user_id: user_id of the user
:return: a membership request
:rtype: :class:`MembershipRequest` | [
"Add",
"a",
"user",
"to",
"the",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L25-L44 | train |
rhgrant10/Groupy | groupy/api/memberships.py | Memberships.add_multiple | def add_multiple(self, *users):
"""Add multiple users to the group at once.
Each given user must be a dictionary containing a nickname and either
an email, phone number, or user_id.
:param args users: the users to add
:return: a membership request
:rtype: :class:`MembershipRequest`
"""
guid = uuid.uuid4()
for i, user_ in enumerate(users):
user_['guid'] = '{}-{}'.format(guid, i)
payload = {'members': users}
url = utils.urljoin(self.url, 'add')
response = self.session.post(url, json=payload)
return MembershipRequest(self, *users, group_id=self.group_id,
**response.data) | python | def add_multiple(self, *users):
"""Add multiple users to the group at once.
Each given user must be a dictionary containing a nickname and either
an email, phone number, or user_id.
:param args users: the users to add
:return: a membership request
:rtype: :class:`MembershipRequest`
"""
guid = uuid.uuid4()
for i, user_ in enumerate(users):
user_['guid'] = '{}-{}'.format(guid, i)
payload = {'members': users}
url = utils.urljoin(self.url, 'add')
response = self.session.post(url, json=payload)
return MembershipRequest(self, *users, group_id=self.group_id,
**response.data) | [
"def",
"add_multiple",
"(",
"self",
",",
"*",
"users",
")",
":",
"guid",
"=",
"uuid",
".",
"uuid4",
"(",
")",
"for",
"i",
",",
"user_",
"in",
"enumerate",
"(",
"users",
")",
":",
"user_",
"[",
"'guid'",
"]",
"=",
"'{}-{}'",
".",
"format",
"(",
"g... | Add multiple users to the group at once.
Each given user must be a dictionary containing a nickname and either
an email, phone number, or user_id.
:param args users: the users to add
:return: a membership request
:rtype: :class:`MembershipRequest` | [
"Add",
"multiple",
"users",
"to",
"the",
"group",
"at",
"once",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L46-L64 | train |
rhgrant10/Groupy | groupy/api/memberships.py | Memberships.check | def check(self, results_id):
"""Check for results of a membership request.
:param str results_id: the ID of a membership request
:return: successfully created memberships
:rtype: :class:`list`
:raises groupy.exceptions.ResultsNotReady: if the results are not ready
:raises groupy.exceptions.ResultsExpired: if the results have expired
"""
path = 'results/{}'.format(results_id)
url = utils.urljoin(self.url, path)
response = self.session.get(url)
if response.status_code == 503:
raise exceptions.ResultsNotReady(response)
if response.status_code == 404:
raise exceptions.ResultsExpired(response)
return response.data['members'] | python | def check(self, results_id):
"""Check for results of a membership request.
:param str results_id: the ID of a membership request
:return: successfully created memberships
:rtype: :class:`list`
:raises groupy.exceptions.ResultsNotReady: if the results are not ready
:raises groupy.exceptions.ResultsExpired: if the results have expired
"""
path = 'results/{}'.format(results_id)
url = utils.urljoin(self.url, path)
response = self.session.get(url)
if response.status_code == 503:
raise exceptions.ResultsNotReady(response)
if response.status_code == 404:
raise exceptions.ResultsExpired(response)
return response.data['members'] | [
"def",
"check",
"(",
"self",
",",
"results_id",
")",
":",
"path",
"=",
"'results/{}'",
".",
"format",
"(",
"results_id",
")",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"path",
")",
"response",
"=",
"self",
".",
"session",
"."... | Check for results of a membership request.
:param str results_id: the ID of a membership request
:return: successfully created memberships
:rtype: :class:`list`
:raises groupy.exceptions.ResultsNotReady: if the results are not ready
:raises groupy.exceptions.ResultsExpired: if the results have expired | [
"Check",
"for",
"results",
"of",
"a",
"membership",
"request",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L66-L82 | train |
rhgrant10/Groupy | groupy/api/memberships.py | Memberships.update | def update(self, nickname=None, **kwargs):
"""Update your own membership.
Note that this fails on former groups.
:param str nickname: new nickname
:return: updated membership
:rtype: :class:`~groupy.api.memberships.Member`
"""
url = self.url + 'hips/update'
payload = {
'membership': {
'nickname': nickname,
},
}
payload['membership'].update(kwargs)
response = self.session.post(url, json=payload)
return Member(self, self.group_id, **response.data) | python | def update(self, nickname=None, **kwargs):
"""Update your own membership.
Note that this fails on former groups.
:param str nickname: new nickname
:return: updated membership
:rtype: :class:`~groupy.api.memberships.Member`
"""
url = self.url + 'hips/update'
payload = {
'membership': {
'nickname': nickname,
},
}
payload['membership'].update(kwargs)
response = self.session.post(url, json=payload)
return Member(self, self.group_id, **response.data) | [
"def",
"update",
"(",
"self",
",",
"nickname",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"url",
"=",
"self",
".",
"url",
"+",
"'hips/update'",
"payload",
"=",
"{",
"'membership'",
":",
"{",
"'nickname'",
":",
"nickname",
",",
"}",
",",
"}",
"... | Update your own membership.
Note that this fails on former groups.
:param str nickname: new nickname
:return: updated membership
:rtype: :class:`~groupy.api.memberships.Member` | [
"Update",
"your",
"own",
"membership",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L84-L101 | train |
rhgrant10/Groupy | groupy/api/memberships.py | Memberships.remove | def remove(self, membership_id):
"""Remove a member from the group.
:param str membership_id: the ID of a member in this group
:return: ``True`` if the member was successfully removed
:rtype: bool
"""
path = '{}/remove'.format(membership_id)
url = utils.urljoin(self.url, path)
payload = {'membership_id': membership_id}
response = self.session.post(url, json=payload)
return response.ok | python | def remove(self, membership_id):
"""Remove a member from the group.
:param str membership_id: the ID of a member in this group
:return: ``True`` if the member was successfully removed
:rtype: bool
"""
path = '{}/remove'.format(membership_id)
url = utils.urljoin(self.url, path)
payload = {'membership_id': membership_id}
response = self.session.post(url, json=payload)
return response.ok | [
"def",
"remove",
"(",
"self",
",",
"membership_id",
")",
":",
"path",
"=",
"'{}/remove'",
".",
"format",
"(",
"membership_id",
")",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"path",
")",
"payload",
"=",
"{",
"'membership_id'",
... | Remove a member from the group.
:param str membership_id: the ID of a member in this group
:return: ``True`` if the member was successfully removed
:rtype: bool | [
"Remove",
"a",
"member",
"from",
"the",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L103-L114 | train |
rhgrant10/Groupy | groupy/api/memberships.py | Member.post | def post(self, text=None, attachments=None, source_guid=None):
"""Post a direct message to the user.
:param str text: the message content
:param attachments: message attachments
:param str source_guid: a client-side unique ID for the message
:return: the message sent
:rtype: :class:`~groupy.api.messages.DirectMessage`
"""
return self.messages.create(text=text, attachments=attachments,
source_guid=source_guid) | python | def post(self, text=None, attachments=None, source_guid=None):
"""Post a direct message to the user.
:param str text: the message content
:param attachments: message attachments
:param str source_guid: a client-side unique ID for the message
:return: the message sent
:rtype: :class:`~groupy.api.messages.DirectMessage`
"""
return self.messages.create(text=text, attachments=attachments,
source_guid=source_guid) | [
"def",
"post",
"(",
"self",
",",
"text",
"=",
"None",
",",
"attachments",
"=",
"None",
",",
"source_guid",
"=",
"None",
")",
":",
"return",
"self",
".",
"messages",
".",
"create",
"(",
"text",
"=",
"text",
",",
"attachments",
"=",
"attachments",
",",
... | Post a direct message to the user.
:param str text: the message content
:param attachments: message attachments
:param str source_guid: a client-side unique ID for the message
:return: the message sent
:rtype: :class:`~groupy.api.messages.DirectMessage` | [
"Post",
"a",
"direct",
"message",
"to",
"the",
"user",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L151-L161 | train |
rhgrant10/Groupy | groupy/api/memberships.py | Member.add_to_group | def add_to_group(self, group_id, nickname=None):
"""Add the member to another group.
If a nickname is not provided the member's current nickname is used.
:param str group_id: the group_id of a group
:param str nickname: a new nickname
:return: a membership request
:rtype: :class:`MembershipRequest`
"""
if nickname is None:
nickname = self.nickname
memberships = Memberships(self.manager.session, group_id=group_id)
return memberships.add(nickname, user_id=self.user_id) | python | def add_to_group(self, group_id, nickname=None):
"""Add the member to another group.
If a nickname is not provided the member's current nickname is used.
:param str group_id: the group_id of a group
:param str nickname: a new nickname
:return: a membership request
:rtype: :class:`MembershipRequest`
"""
if nickname is None:
nickname = self.nickname
memberships = Memberships(self.manager.session, group_id=group_id)
return memberships.add(nickname, user_id=self.user_id) | [
"def",
"add_to_group",
"(",
"self",
",",
"group_id",
",",
"nickname",
"=",
"None",
")",
":",
"if",
"nickname",
"is",
"None",
":",
"nickname",
"=",
"self",
".",
"nickname",
"memberships",
"=",
"Memberships",
"(",
"self",
".",
"manager",
".",
"session",
",... | Add the member to another group.
If a nickname is not provided the member's current nickname is used.
:param str group_id: the group_id of a group
:param str nickname: a new nickname
:return: a membership request
:rtype: :class:`MembershipRequest` | [
"Add",
"the",
"member",
"to",
"another",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L195-L208 | train |
rhgrant10/Groupy | groupy/api/memberships.py | MembershipRequest.check_if_ready | def check_if_ready(self):
"""Check for and fetch the results if ready."""
try:
results = self.manager.check(self.results_id)
except exceptions.ResultsNotReady as e:
self._is_ready = False
self._not_ready_exception = e
except exceptions.ResultsExpired as e:
self._is_ready = True
self._expired_exception = e
else:
failures = self.get_failed_requests(results)
members = self.get_new_members(results)
self.results = self.__class__.Results(list(members), list(failures))
self._is_ready = True
self._not_ready_exception = None | python | def check_if_ready(self):
"""Check for and fetch the results if ready."""
try:
results = self.manager.check(self.results_id)
except exceptions.ResultsNotReady as e:
self._is_ready = False
self._not_ready_exception = e
except exceptions.ResultsExpired as e:
self._is_ready = True
self._expired_exception = e
else:
failures = self.get_failed_requests(results)
members = self.get_new_members(results)
self.results = self.__class__.Results(list(members), list(failures))
self._is_ready = True
self._not_ready_exception = None | [
"def",
"check_if_ready",
"(",
"self",
")",
":",
"try",
":",
"results",
"=",
"self",
".",
"manager",
".",
"check",
"(",
"self",
".",
"results_id",
")",
"except",
"exceptions",
".",
"ResultsNotReady",
"as",
"e",
":",
"self",
".",
"_is_ready",
"=",
"False",... | Check for and fetch the results if ready. | [
"Check",
"for",
"and",
"fetch",
"the",
"results",
"if",
"ready",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L231-L246 | train |
rhgrant10/Groupy | groupy/api/memberships.py | MembershipRequest.get_failed_requests | def get_failed_requests(self, results):
"""Return the requests that failed.
:param results: the results of a membership request check
:type results: :class:`list`
:return: the failed requests
:rtype: generator
"""
data = {member['guid']: member for member in results}
for request in self.requests:
if request['guid'] not in data:
yield request | python | def get_failed_requests(self, results):
"""Return the requests that failed.
:param results: the results of a membership request check
:type results: :class:`list`
:return: the failed requests
:rtype: generator
"""
data = {member['guid']: member for member in results}
for request in self.requests:
if request['guid'] not in data:
yield request | [
"def",
"get_failed_requests",
"(",
"self",
",",
"results",
")",
":",
"data",
"=",
"{",
"member",
"[",
"'guid'",
"]",
":",
"member",
"for",
"member",
"in",
"results",
"}",
"for",
"request",
"in",
"self",
".",
"requests",
":",
"if",
"request",
"[",
"'gui... | Return the requests that failed.
:param results: the results of a membership request check
:type results: :class:`list`
:return: the failed requests
:rtype: generator | [
"Return",
"the",
"requests",
"that",
"failed",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L248-L259 | train |
rhgrant10/Groupy | groupy/api/memberships.py | MembershipRequest.get_new_members | def get_new_members(self, results):
"""Return the newly added members.
:param results: the results of a membership request check
:type results: :class:`list`
:return: the successful requests, as :class:`~groupy.api.memberships.Members`
:rtype: generator
"""
for member in results:
guid = member.pop('guid')
yield Member(self.manager, self.group_id, **member)
member['guid'] = guid | python | def get_new_members(self, results):
"""Return the newly added members.
:param results: the results of a membership request check
:type results: :class:`list`
:return: the successful requests, as :class:`~groupy.api.memberships.Members`
:rtype: generator
"""
for member in results:
guid = member.pop('guid')
yield Member(self.manager, self.group_id, **member)
member['guid'] = guid | [
"def",
"get_new_members",
"(",
"self",
",",
"results",
")",
":",
"for",
"member",
"in",
"results",
":",
"guid",
"=",
"member",
".",
"pop",
"(",
"'guid'",
")",
"yield",
"Member",
"(",
"self",
".",
"manager",
",",
"self",
".",
"group_id",
",",
"*",
"*"... | Return the newly added members.
:param results: the results of a membership request check
:type results: :class:`list`
:return: the successful requests, as :class:`~groupy.api.memberships.Members`
:rtype: generator | [
"Return",
"the",
"newly",
"added",
"members",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L261-L272 | train |
rhgrant10/Groupy | groupy/api/memberships.py | MembershipRequest.is_ready | def is_ready(self, check=True):
"""Return ``True`` if the results are ready.
If you pass ``check=False``, no attempt is made to check again for
results.
:param bool check: whether to query for the results
:return: ``True`` if the results are ready
:rtype: bool
"""
if not self._is_ready and check:
self.check_if_ready()
return self._is_ready | python | def is_ready(self, check=True):
"""Return ``True`` if the results are ready.
If you pass ``check=False``, no attempt is made to check again for
results.
:param bool check: whether to query for the results
:return: ``True`` if the results are ready
:rtype: bool
"""
if not self._is_ready and check:
self.check_if_ready()
return self._is_ready | [
"def",
"is_ready",
"(",
"self",
",",
"check",
"=",
"True",
")",
":",
"if",
"not",
"self",
".",
"_is_ready",
"and",
"check",
":",
"self",
".",
"check_if_ready",
"(",
")",
"return",
"self",
".",
"_is_ready"
] | Return ``True`` if the results are ready.
If you pass ``check=False``, no attempt is made to check again for
results.
:param bool check: whether to query for the results
:return: ``True`` if the results are ready
:rtype: bool | [
"Return",
"True",
"if",
"the",
"results",
"are",
"ready",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L274-L286 | train |
rhgrant10/Groupy | groupy/api/memberships.py | MembershipRequest.poll | def poll(self, timeout=30, interval=2):
"""Return the results when they become ready.
:param int timeout: the maximum time to wait for the results
:param float interval: the number of seconds between checks
:return: the membership request result
:rtype: :class:`~groupy.api.memberships.MembershipResult.Results`
"""
time.sleep(interval)
start = time.time()
while time.time() - start < timeout and not self.is_ready():
time.sleep(interval)
return self.get() | python | def poll(self, timeout=30, interval=2):
"""Return the results when they become ready.
:param int timeout: the maximum time to wait for the results
:param float interval: the number of seconds between checks
:return: the membership request result
:rtype: :class:`~groupy.api.memberships.MembershipResult.Results`
"""
time.sleep(interval)
start = time.time()
while time.time() - start < timeout and not self.is_ready():
time.sleep(interval)
return self.get() | [
"def",
"poll",
"(",
"self",
",",
"timeout",
"=",
"30",
",",
"interval",
"=",
"2",
")",
":",
"time",
".",
"sleep",
"(",
"interval",
")",
"start",
"=",
"time",
".",
"time",
"(",
")",
"while",
"time",
".",
"time",
"(",
")",
"-",
"start",
"<",
"tim... | Return the results when they become ready.
:param int timeout: the maximum time to wait for the results
:param float interval: the number of seconds between checks
:return: the membership request result
:rtype: :class:`~groupy.api.memberships.MembershipResult.Results` | [
"Return",
"the",
"results",
"when",
"they",
"become",
"ready",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L288-L300 | train |
rhgrant10/Groupy | groupy/api/memberships.py | MembershipRequest.get | def get(self):
"""Return the results now.
:return: the membership request results
:rtype: :class:`~groupy.api.memberships.MembershipResult.Results`
:raises groupy.exceptions.ResultsNotReady: if the results are not ready
:raises groupy.exceptions.ResultsExpired: if the results have expired
"""
if self._expired_exception:
raise self._expired_exception
if self._not_ready_exception:
raise self._not_ready_exception
return self.results | python | def get(self):
"""Return the results now.
:return: the membership request results
:rtype: :class:`~groupy.api.memberships.MembershipResult.Results`
:raises groupy.exceptions.ResultsNotReady: if the results are not ready
:raises groupy.exceptions.ResultsExpired: if the results have expired
"""
if self._expired_exception:
raise self._expired_exception
if self._not_ready_exception:
raise self._not_ready_exception
return self.results | [
"def",
"get",
"(",
"self",
")",
":",
"if",
"self",
".",
"_expired_exception",
":",
"raise",
"self",
".",
"_expired_exception",
"if",
"self",
".",
"_not_ready_exception",
":",
"raise",
"self",
".",
"_not_ready_exception",
"return",
"self",
".",
"results"
] | Return the results now.
:return: the membership request results
:rtype: :class:`~groupy.api.memberships.MembershipResult.Results`
:raises groupy.exceptions.ResultsNotReady: if the results are not ready
:raises groupy.exceptions.ResultsExpired: if the results have expired | [
"Return",
"the",
"results",
"now",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/memberships.py#L302-L314 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.list | def list(self, page=1, per_page=10, omit=None):
"""List groups by page.
The API allows certain fields to be excluded from the results so that
very large groups can be fetched without exceeding the maximum
response size. At the time of this writing, only 'memberships' is
supported.
:param int page: page number
:param int per_page: number of groups per page
:param int omit: a comma-separated list of fields to exclude
:return: a list of groups
:rtype: :class:`~groupy.pagers.GroupList`
"""
return pagers.GroupList(self, self._raw_list, page=page,
per_page=per_page, omit=omit) | python | def list(self, page=1, per_page=10, omit=None):
"""List groups by page.
The API allows certain fields to be excluded from the results so that
very large groups can be fetched without exceeding the maximum
response size. At the time of this writing, only 'memberships' is
supported.
:param int page: page number
:param int per_page: number of groups per page
:param int omit: a comma-separated list of fields to exclude
:return: a list of groups
:rtype: :class:`~groupy.pagers.GroupList`
"""
return pagers.GroupList(self, self._raw_list, page=page,
per_page=per_page, omit=omit) | [
"def",
"list",
"(",
"self",
",",
"page",
"=",
"1",
",",
"per_page",
"=",
"10",
",",
"omit",
"=",
"None",
")",
":",
"return",
"pagers",
".",
"GroupList",
"(",
"self",
",",
"self",
".",
"_raw_list",
",",
"page",
"=",
"page",
",",
"per_page",
"=",
"... | List groups by page.
The API allows certain fields to be excluded from the results so that
very large groups can be fetched without exceeding the maximum
response size. At the time of this writing, only 'memberships' is
supported.
:param int page: page number
:param int per_page: number of groups per page
:param int omit: a comma-separated list of fields to exclude
:return: a list of groups
:rtype: :class:`~groupy.pagers.GroupList` | [
"List",
"groups",
"by",
"page",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L23-L38 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.list_all | def list_all(self, per_page=10, omit=None):
"""List all groups.
Since the order of groups is determined by recent activity, this is the
recommended way to obtain a list of all groups. See
:func:`~groupy.api.groups.Groups.list` for details about ``omit``.
:param int per_page: number of groups per page
:param int omit: a comma-separated list of fields to exclude
:return: a list of groups
:rtype: :class:`~groupy.pagers.GroupList`
"""
return self.list(per_page=per_page, omit=omit).autopage() | python | def list_all(self, per_page=10, omit=None):
"""List all groups.
Since the order of groups is determined by recent activity, this is the
recommended way to obtain a list of all groups. See
:func:`~groupy.api.groups.Groups.list` for details about ``omit``.
:param int per_page: number of groups per page
:param int omit: a comma-separated list of fields to exclude
:return: a list of groups
:rtype: :class:`~groupy.pagers.GroupList`
"""
return self.list(per_page=per_page, omit=omit).autopage() | [
"def",
"list_all",
"(",
"self",
",",
"per_page",
"=",
"10",
",",
"omit",
"=",
"None",
")",
":",
"return",
"self",
".",
"list",
"(",
"per_page",
"=",
"per_page",
",",
"omit",
"=",
"omit",
")",
".",
"autopage",
"(",
")"
] | List all groups.
Since the order of groups is determined by recent activity, this is the
recommended way to obtain a list of all groups. See
:func:`~groupy.api.groups.Groups.list` for details about ``omit``.
:param int per_page: number of groups per page
:param int omit: a comma-separated list of fields to exclude
:return: a list of groups
:rtype: :class:`~groupy.pagers.GroupList` | [
"List",
"all",
"groups",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L40-L52 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.list_former | def list_former(self):
"""List all former groups.
:return: a list of groups
:rtype: :class:`list`
"""
url = utils.urljoin(self.url, 'former')
response = self.session.get(url)
return [Group(self, **group) for group in response.data] | python | def list_former(self):
"""List all former groups.
:return: a list of groups
:rtype: :class:`list`
"""
url = utils.urljoin(self.url, 'former')
response = self.session.get(url)
return [Group(self, **group) for group in response.data] | [
"def",
"list_former",
"(",
"self",
")",
":",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"'former'",
")",
"response",
"=",
"self",
".",
"session",
".",
"get",
"(",
"url",
")",
"return",
"[",
"Group",
"(",
"self",
",",
"*",
... | List all former groups.
:return: a list of groups
:rtype: :class:`list` | [
"List",
"all",
"former",
"groups",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L54-L62 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.get | def get(self, id):
"""Get a single group by ID.
:param str id: a group ID
:return: a group
:rtype: :class:`~groupy.api.groups.Group`
"""
url = utils.urljoin(self.url, id)
response = self.session.get(url)
return Group(self, **response.data) | python | def get(self, id):
"""Get a single group by ID.
:param str id: a group ID
:return: a group
:rtype: :class:`~groupy.api.groups.Group`
"""
url = utils.urljoin(self.url, id)
response = self.session.get(url)
return Group(self, **response.data) | [
"def",
"get",
"(",
"self",
",",
"id",
")",
":",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"id",
")",
"response",
"=",
"self",
".",
"session",
".",
"get",
"(",
"url",
")",
"return",
"Group",
"(",
"self",
",",
"*",
"*",
... | Get a single group by ID.
:param str id: a group ID
:return: a group
:rtype: :class:`~groupy.api.groups.Group` | [
"Get",
"a",
"single",
"group",
"by",
"ID",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L64-L73 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.create | def create(self, name, description=None, image_url=None, share=None, **kwargs):
"""Create a new group.
Note that, although possible, there may be issues when not using an
image URL from GroupMe's image service.
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool share: whether to generate a share URL
:return: a new group
:rtype: :class:`~groupy.api.groups.Group`
"""
payload = {
'name': name,
'description': description,
'image_url': image_url,
'share': share,
}
payload.update(kwargs)
response = self.session.post(self.url, json=payload)
return Group(self, **response.data) | python | def create(self, name, description=None, image_url=None, share=None, **kwargs):
"""Create a new group.
Note that, although possible, there may be issues when not using an
image URL from GroupMe's image service.
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool share: whether to generate a share URL
:return: a new group
:rtype: :class:`~groupy.api.groups.Group`
"""
payload = {
'name': name,
'description': description,
'image_url': image_url,
'share': share,
}
payload.update(kwargs)
response = self.session.post(self.url, json=payload)
return Group(self, **response.data) | [
"def",
"create",
"(",
"self",
",",
"name",
",",
"description",
"=",
"None",
",",
"image_url",
"=",
"None",
",",
"share",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"payload",
"=",
"{",
"'name'",
":",
"name",
",",
"'description'",
":",
"descripti... | Create a new group.
Note that, although possible, there may be issues when not using an
image URL from GroupMe's image service.
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool share: whether to generate a share URL
:return: a new group
:rtype: :class:`~groupy.api.groups.Group` | [
"Create",
"a",
"new",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L75-L96 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.update | def update(self, id, name=None, description=None, image_url=None,
office_mode=None, share=None, **kwargs):
"""Update the details of a group.
.. note::
There are significant bugs in this endpoint!
1. not providing ``name`` produces 400: "Topic can't be blank"
2. not providing ``office_mode`` produces 500: "sql: Scan error on
column index 14: sql/driver: couldn't convert <nil> (<nil>) into
type bool"
Note that these issues are "handled" automatically when calling
update on a :class:`~groupy.api.groups.Group` object.
:param str id: group ID
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool office_mode: (undocumented)
:param bool share: whether to generate a share URL
:return: an updated group
:rtype: :class:`~groupy.api.groups.Group`
"""
path = '{}/update'.format(id)
url = utils.urljoin(self.url, path)
payload = {
'name': name,
'description': description,
'image_url': image_url,
'office_mode': office_mode,
'share': share,
}
payload.update(kwargs)
response = self.session.post(url, json=payload)
return Group(self, **response.data) | python | def update(self, id, name=None, description=None, image_url=None,
office_mode=None, share=None, **kwargs):
"""Update the details of a group.
.. note::
There are significant bugs in this endpoint!
1. not providing ``name`` produces 400: "Topic can't be blank"
2. not providing ``office_mode`` produces 500: "sql: Scan error on
column index 14: sql/driver: couldn't convert <nil> (<nil>) into
type bool"
Note that these issues are "handled" automatically when calling
update on a :class:`~groupy.api.groups.Group` object.
:param str id: group ID
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool office_mode: (undocumented)
:param bool share: whether to generate a share URL
:return: an updated group
:rtype: :class:`~groupy.api.groups.Group`
"""
path = '{}/update'.format(id)
url = utils.urljoin(self.url, path)
payload = {
'name': name,
'description': description,
'image_url': image_url,
'office_mode': office_mode,
'share': share,
}
payload.update(kwargs)
response = self.session.post(url, json=payload)
return Group(self, **response.data) | [
"def",
"update",
"(",
"self",
",",
"id",
",",
"name",
"=",
"None",
",",
"description",
"=",
"None",
",",
"image_url",
"=",
"None",
",",
"office_mode",
"=",
"None",
",",
"share",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"path",
"=",
"'{}/upda... | Update the details of a group.
.. note::
There are significant bugs in this endpoint!
1. not providing ``name`` produces 400: "Topic can't be blank"
2. not providing ``office_mode`` produces 500: "sql: Scan error on
column index 14: sql/driver: couldn't convert <nil> (<nil>) into
type bool"
Note that these issues are "handled" automatically when calling
update on a :class:`~groupy.api.groups.Group` object.
:param str id: group ID
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool office_mode: (undocumented)
:param bool share: whether to generate a share URL
:return: an updated group
:rtype: :class:`~groupy.api.groups.Group` | [
"Update",
"the",
"details",
"of",
"a",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L98-L133 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.destroy | def destroy(self, id):
"""Destroy a group.
:param str id: a group ID
:return: ``True`` if successful
:rtype: bool
"""
path = '{}/destroy'.format(id)
url = utils.urljoin(self.url, path)
response = self.session.post(url)
return response.ok | python | def destroy(self, id):
"""Destroy a group.
:param str id: a group ID
:return: ``True`` if successful
:rtype: bool
"""
path = '{}/destroy'.format(id)
url = utils.urljoin(self.url, path)
response = self.session.post(url)
return response.ok | [
"def",
"destroy",
"(",
"self",
",",
"id",
")",
":",
"path",
"=",
"'{}/destroy'",
".",
"format",
"(",
"id",
")",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"path",
")",
"response",
"=",
"self",
".",
"session",
".",
"post",
... | Destroy a group.
:param str id: a group ID
:return: ``True`` if successful
:rtype: bool | [
"Destroy",
"a",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L135-L145 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.join | def join(self, group_id, share_token):
"""Join a group using a share token.
:param str group_id: the group_id of a group
:param str share_token: the share token
:return: the group
:rtype: :class:`~groupy.api.groups.Group`
"""
path = '{}/join/{}'.format(group_id, share_token)
url = utils.urljoin(self.url, path)
response = self.session.post(url)
group = response.data['group']
return Group(self, **group) | python | def join(self, group_id, share_token):
"""Join a group using a share token.
:param str group_id: the group_id of a group
:param str share_token: the share token
:return: the group
:rtype: :class:`~groupy.api.groups.Group`
"""
path = '{}/join/{}'.format(group_id, share_token)
url = utils.urljoin(self.url, path)
response = self.session.post(url)
group = response.data['group']
return Group(self, **group) | [
"def",
"join",
"(",
"self",
",",
"group_id",
",",
"share_token",
")",
":",
"path",
"=",
"'{}/join/{}'",
".",
"format",
"(",
"group_id",
",",
"share_token",
")",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"path",
")",
"response",... | Join a group using a share token.
:param str group_id: the group_id of a group
:param str share_token: the share token
:return: the group
:rtype: :class:`~groupy.api.groups.Group` | [
"Join",
"a",
"group",
"using",
"a",
"share",
"token",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L147-L159 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.rejoin | def rejoin(self, group_id):
"""Rejoin a former group.
:param str group_id: the group_id of a group
:return: the group
:rtype: :class:`~groupy.api.groups.Group`
"""
url = utils.urljoin(self.url, 'join')
payload = {'group_id': group_id}
response = self.session.post(url, json=payload)
return Group(self, **response.data) | python | def rejoin(self, group_id):
"""Rejoin a former group.
:param str group_id: the group_id of a group
:return: the group
:rtype: :class:`~groupy.api.groups.Group`
"""
url = utils.urljoin(self.url, 'join')
payload = {'group_id': group_id}
response = self.session.post(url, json=payload)
return Group(self, **response.data) | [
"def",
"rejoin",
"(",
"self",
",",
"group_id",
")",
":",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"'join'",
")",
"payload",
"=",
"{",
"'group_id'",
":",
"group_id",
"}",
"response",
"=",
"self",
".",
"session",
".",
"post",
... | Rejoin a former group.
:param str group_id: the group_id of a group
:return: the group
:rtype: :class:`~groupy.api.groups.Group` | [
"Rejoin",
"a",
"former",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L161-L171 | train |
rhgrant10/Groupy | groupy/api/groups.py | Groups.change_owners | def change_owners(self, group_id, owner_id):
"""Change the owner of a group.
.. note:: you must be the owner to change owners
:param str group_id: the group_id of a group
:param str owner_id: the ID of the new owner
:return: the result
:rtype: :class:`~groupy.api.groups.ChangeOwnersResult`
"""
url = utils.urljoin(self.url, 'change_owners')
payload = {
'requests': [{
'group_id': group_id,
'owner_id': owner_id,
}],
}
response = self.session.post(url, json=payload)
result, = response.data['results'] # should be exactly one
return ChangeOwnersResult(**result) | python | def change_owners(self, group_id, owner_id):
"""Change the owner of a group.
.. note:: you must be the owner to change owners
:param str group_id: the group_id of a group
:param str owner_id: the ID of the new owner
:return: the result
:rtype: :class:`~groupy.api.groups.ChangeOwnersResult`
"""
url = utils.urljoin(self.url, 'change_owners')
payload = {
'requests': [{
'group_id': group_id,
'owner_id': owner_id,
}],
}
response = self.session.post(url, json=payload)
result, = response.data['results'] # should be exactly one
return ChangeOwnersResult(**result) | [
"def",
"change_owners",
"(",
"self",
",",
"group_id",
",",
"owner_id",
")",
":",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"'change_owners'",
")",
"payload",
"=",
"{",
"'requests'",
":",
"[",
"{",
"'group_id'",
":",
"group_id",
... | Change the owner of a group.
.. note:: you must be the owner to change owners
:param str group_id: the group_id of a group
:param str owner_id: the ID of the new owner
:return: the result
:rtype: :class:`~groupy.api.groups.ChangeOwnersResult` | [
"Change",
"the",
"owner",
"of",
"a",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L173-L192 | train |
rhgrant10/Groupy | groupy/api/groups.py | Group.update | def update(self, name=None, description=None, image_url=None,
office_mode=None, share=None, **kwargs):
"""Update the details of the group.
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool office_mode: (undocumented)
:param bool share: whether to generate a share URL
:return: an updated group
:rtype: :class:`~groupy.api.groups.Group`
"""
# note we default to the current values for name and office_mode as a
# work-around for issues with the group update endpoint
if name is None:
name = self.name
if office_mode is None:
office_mode = self.office_mode
return self.manager.update(id=self.id, name=name, description=description,
image_url=image_url, office_mode=office_mode,
share=share, **kwargs) | python | def update(self, name=None, description=None, image_url=None,
office_mode=None, share=None, **kwargs):
"""Update the details of the group.
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool office_mode: (undocumented)
:param bool share: whether to generate a share URL
:return: an updated group
:rtype: :class:`~groupy.api.groups.Group`
"""
# note we default to the current values for name and office_mode as a
# work-around for issues with the group update endpoint
if name is None:
name = self.name
if office_mode is None:
office_mode = self.office_mode
return self.manager.update(id=self.id, name=name, description=description,
image_url=image_url, office_mode=office_mode,
share=share, **kwargs) | [
"def",
"update",
"(",
"self",
",",
"name",
"=",
"None",
",",
"description",
"=",
"None",
",",
"image_url",
"=",
"None",
",",
"office_mode",
"=",
"None",
",",
"share",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"# note we default to the current values ... | Update the details of the group.
:param str name: group name (140 characters maximum)
:param str description: short description (255 characters maximum)
:param str image_url: GroupMe image service URL
:param bool office_mode: (undocumented)
:param bool share: whether to generate a share URL
:return: an updated group
:rtype: :class:`~groupy.api.groups.Group` | [
"Update",
"the",
"details",
"of",
"the",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L272-L292 | train |
rhgrant10/Groupy | groupy/api/groups.py | Group.refresh_from_server | def refresh_from_server(self):
"""Refresh the group from the server in place."""
group = self.manager.get(id=self.id)
self.__init__(self.manager, **group.data) | python | def refresh_from_server(self):
"""Refresh the group from the server in place."""
group = self.manager.get(id=self.id)
self.__init__(self.manager, **group.data) | [
"def",
"refresh_from_server",
"(",
"self",
")",
":",
"group",
"=",
"self",
".",
"manager",
".",
"get",
"(",
"id",
"=",
"self",
".",
"id",
")",
"self",
".",
"__init__",
"(",
"self",
".",
"manager",
",",
"*",
"*",
"group",
".",
"data",
")"
] | Refresh the group from the server in place. | [
"Refresh",
"the",
"group",
"from",
"the",
"server",
"in",
"place",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L314-L317 | train |
rhgrant10/Groupy | groupy/api/groups.py | Group.create_bot | def create_bot(self, name, avatar_url=None, callback_url=None, dm_notification=None,
**kwargs):
"""Create a new bot in a particular group.
:param str name: bot name
:param str avatar_url: the URL of an image to use as an avatar
:param str callback_url: a POST-back URL for each new message
:param bool dm_notification: whether to POST-back for direct messages?
:return: the new bot
:rtype: :class:`~groupy.api.bots.Bot`
"""
return self._bots.create(name=name, group_id=self.group_id,
avatar_url=avatar_url, callback_url=callback_url,
dm_notification=dm_notification) | python | def create_bot(self, name, avatar_url=None, callback_url=None, dm_notification=None,
**kwargs):
"""Create a new bot in a particular group.
:param str name: bot name
:param str avatar_url: the URL of an image to use as an avatar
:param str callback_url: a POST-back URL for each new message
:param bool dm_notification: whether to POST-back for direct messages?
:return: the new bot
:rtype: :class:`~groupy.api.bots.Bot`
"""
return self._bots.create(name=name, group_id=self.group_id,
avatar_url=avatar_url, callback_url=callback_url,
dm_notification=dm_notification) | [
"def",
"create_bot",
"(",
"self",
",",
"name",
",",
"avatar_url",
"=",
"None",
",",
"callback_url",
"=",
"None",
",",
"dm_notification",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"self",
".",
"_bots",
".",
"create",
"(",
"name",
"=",
... | Create a new bot in a particular group.
:param str name: bot name
:param str avatar_url: the URL of an image to use as an avatar
:param str callback_url: a POST-back URL for each new message
:param bool dm_notification: whether to POST-back for direct messages?
:return: the new bot
:rtype: :class:`~groupy.api.bots.Bot` | [
"Create",
"a",
"new",
"bot",
"in",
"a",
"particular",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L319-L332 | train |
rhgrant10/Groupy | groupy/api/groups.py | Group.get_membership | def get_membership(self):
"""Get your membership.
Note that your membership may not exist. For example, you do not have
a membership in a former group. Also, the group returned by the API
when rejoining a former group does not contain your membership. You
must call :func:`refresh_from_server` to update the list of members.
:return: your membership in the group
:rtype: :class:`~groupy.api.memberships.Member`
:raises groupy.exceptions.MissingMembershipError: if your membership is
not in the group data
"""
user_id = self._user.me['user_id']
for member in self.members:
if member.user_id == user_id:
return member
raise exceptions.MissingMembershipError(self.group_id, user_id) | python | def get_membership(self):
"""Get your membership.
Note that your membership may not exist. For example, you do not have
a membership in a former group. Also, the group returned by the API
when rejoining a former group does not contain your membership. You
must call :func:`refresh_from_server` to update the list of members.
:return: your membership in the group
:rtype: :class:`~groupy.api.memberships.Member`
:raises groupy.exceptions.MissingMembershipError: if your membership is
not in the group data
"""
user_id = self._user.me['user_id']
for member in self.members:
if member.user_id == user_id:
return member
raise exceptions.MissingMembershipError(self.group_id, user_id) | [
"def",
"get_membership",
"(",
"self",
")",
":",
"user_id",
"=",
"self",
".",
"_user",
".",
"me",
"[",
"'user_id'",
"]",
"for",
"member",
"in",
"self",
".",
"members",
":",
"if",
"member",
".",
"user_id",
"==",
"user_id",
":",
"return",
"member",
"raise... | Get your membership.
Note that your membership may not exist. For example, you do not have
a membership in a former group. Also, the group returned by the API
when rejoining a former group does not contain your membership. You
must call :func:`refresh_from_server` to update the list of members.
:return: your membership in the group
:rtype: :class:`~groupy.api.memberships.Member`
:raises groupy.exceptions.MissingMembershipError: if your membership is
not in the group data | [
"Get",
"your",
"membership",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L345-L362 | train |
rhgrant10/Groupy | groupy/api/groups.py | Group.update_membership | def update_membership(self, nickname=None, **kwargs):
"""Update your own membership.
Note that this fails on former groups.
:param str nickname: new nickname
:return: updated membership
:rtype: :class:`~groupy.api.members.Member`
"""
return self.memberships.update(nickname=nickname, **kwargs) | python | def update_membership(self, nickname=None, **kwargs):
"""Update your own membership.
Note that this fails on former groups.
:param str nickname: new nickname
:return: updated membership
:rtype: :class:`~groupy.api.members.Member`
"""
return self.memberships.update(nickname=nickname, **kwargs) | [
"def",
"update_membership",
"(",
"self",
",",
"nickname",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"self",
".",
"memberships",
".",
"update",
"(",
"nickname",
"=",
"nickname",
",",
"*",
"*",
"kwargs",
")"
] | Update your own membership.
Note that this fails on former groups.
:param str nickname: new nickname
:return: updated membership
:rtype: :class:`~groupy.api.members.Member` | [
"Update",
"your",
"own",
"membership",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/groups.py#L364-L373 | train |
rhgrant10/Groupy | groupy/utils.py | urljoin | def urljoin(base, path=None):
"""Join a base url with a relative path."""
# /foo/bar + baz makes /foo/bar/baz instead of /foo/baz
if path is None:
url = base
else:
if not base.endswith('/'):
base += '/'
url = urllib.parse.urljoin(base, str(path))
return url | python | def urljoin(base, path=None):
"""Join a base url with a relative path."""
# /foo/bar + baz makes /foo/bar/baz instead of /foo/baz
if path is None:
url = base
else:
if not base.endswith('/'):
base += '/'
url = urllib.parse.urljoin(base, str(path))
return url | [
"def",
"urljoin",
"(",
"base",
",",
"path",
"=",
"None",
")",
":",
"# /foo/bar + baz makes /foo/bar/baz instead of /foo/baz",
"if",
"path",
"is",
"None",
":",
"url",
"=",
"base",
"else",
":",
"if",
"not",
"base",
".",
"endswith",
"(",
"'/'",
")",
":",
"bas... | Join a base url with a relative path. | [
"Join",
"a",
"base",
"url",
"with",
"a",
"relative",
"path",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/utils.py#L8-L17 | train |
rhgrant10/Groupy | groupy/utils.py | parse_share_url | def parse_share_url(share_url):
"""Return the group_id and share_token in a group's share url.
:param str share_url: the share url of a group
"""
*__, group_id, share_token = share_url.rstrip('/').split('/')
return group_id, share_token | python | def parse_share_url(share_url):
"""Return the group_id and share_token in a group's share url.
:param str share_url: the share url of a group
"""
*__, group_id, share_token = share_url.rstrip('/').split('/')
return group_id, share_token | [
"def",
"parse_share_url",
"(",
"share_url",
")",
":",
"*",
"__",
",",
"group_id",
",",
"share_token",
"=",
"share_url",
".",
"rstrip",
"(",
"'/'",
")",
".",
"split",
"(",
"'/'",
")",
"return",
"group_id",
",",
"share_token"
] | Return the group_id and share_token in a group's share url.
:param str share_url: the share url of a group | [
"Return",
"the",
"group_id",
"and",
"share_token",
"in",
"a",
"group",
"s",
"share",
"url",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/utils.py#L20-L26 | train |
rhgrant10/Groupy | groupy/utils.py | get_rfc3339 | def get_rfc3339(when):
"""Return an RFC 3339 timestamp.
:param datetime.datetime when: a datetime in UTC
:return: RFC 3339 timestamp
:rtype: str
"""
microseconds = format(when.microsecond, '04d')[:4]
rfc3339 = '%Y-%m-%dT%H:%M:%S.{}Z'
return when.strftime(rfc3339.format(microseconds)) | python | def get_rfc3339(when):
"""Return an RFC 3339 timestamp.
:param datetime.datetime when: a datetime in UTC
:return: RFC 3339 timestamp
:rtype: str
"""
microseconds = format(when.microsecond, '04d')[:4]
rfc3339 = '%Y-%m-%dT%H:%M:%S.{}Z'
return when.strftime(rfc3339.format(microseconds)) | [
"def",
"get_rfc3339",
"(",
"when",
")",
":",
"microseconds",
"=",
"format",
"(",
"when",
".",
"microsecond",
",",
"'04d'",
")",
"[",
":",
"4",
"]",
"rfc3339",
"=",
"'%Y-%m-%dT%H:%M:%S.{}Z'",
"return",
"when",
".",
"strftime",
"(",
"rfc3339",
".",
"format",... | Return an RFC 3339 timestamp.
:param datetime.datetime when: a datetime in UTC
:return: RFC 3339 timestamp
:rtype: str | [
"Return",
"an",
"RFC",
"3339",
"timestamp",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/utils.py#L29-L38 | train |
rhgrant10/Groupy | groupy/utils.py | make_filter | def make_filter(**tests):
"""Create a filter from keyword arguments."""
tests = [AttrTest(k, v) for k, v in tests.items()]
return Filter(tests) | python | def make_filter(**tests):
"""Create a filter from keyword arguments."""
tests = [AttrTest(k, v) for k, v in tests.items()]
return Filter(tests) | [
"def",
"make_filter",
"(",
"*",
"*",
"tests",
")",
":",
"tests",
"=",
"[",
"AttrTest",
"(",
"k",
",",
"v",
")",
"for",
"k",
",",
"v",
"in",
"tests",
".",
"items",
"(",
")",
"]",
"return",
"Filter",
"(",
"tests",
")"
] | Create a filter from keyword arguments. | [
"Create",
"a",
"filter",
"from",
"keyword",
"arguments",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/utils.py#L116-L119 | train |
rhgrant10/Groupy | groupy/utils.py | Filter.find | def find(self, objects):
"""Find exactly one match in the list of objects.
:param objects: objects to filter
:type objects: :class:`list`
:return: the one matching object
:raises groupy.exceptions.NoMatchesError: if no objects match
:raises groupy.exceptions.MultipleMatchesError: if multiple objects match
"""
matches = list(self.__call__(objects))
if not matches:
raise exceptions.NoMatchesError(objects, self.tests)
elif len(matches) > 1:
raise exceptions.MultipleMatchesError(objects, self.tests,
matches=matches)
return matches[0] | python | def find(self, objects):
"""Find exactly one match in the list of objects.
:param objects: objects to filter
:type objects: :class:`list`
:return: the one matching object
:raises groupy.exceptions.NoMatchesError: if no objects match
:raises groupy.exceptions.MultipleMatchesError: if multiple objects match
"""
matches = list(self.__call__(objects))
if not matches:
raise exceptions.NoMatchesError(objects, self.tests)
elif len(matches) > 1:
raise exceptions.MultipleMatchesError(objects, self.tests,
matches=matches)
return matches[0] | [
"def",
"find",
"(",
"self",
",",
"objects",
")",
":",
"matches",
"=",
"list",
"(",
"self",
".",
"__call__",
"(",
"objects",
")",
")",
"if",
"not",
"matches",
":",
"raise",
"exceptions",
".",
"NoMatchesError",
"(",
"objects",
",",
"self",
".",
"tests",
... | Find exactly one match in the list of objects.
:param objects: objects to filter
:type objects: :class:`list`
:return: the one matching object
:raises groupy.exceptions.NoMatchesError: if no objects match
:raises groupy.exceptions.MultipleMatchesError: if multiple objects match | [
"Find",
"exactly",
"one",
"match",
"in",
"the",
"list",
"of",
"objects",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/utils.py#L89-L104 | train |
rhgrant10/Groupy | groupy/api/bots.py | Bots.list | def list(self):
"""Return a list of bots.
:return: all of your bots
:rtype: :class:`list`
"""
response = self.session.get(self.url)
return [Bot(self, **bot) for bot in response.data] | python | def list(self):
"""Return a list of bots.
:return: all of your bots
:rtype: :class:`list`
"""
response = self.session.get(self.url)
return [Bot(self, **bot) for bot in response.data] | [
"def",
"list",
"(",
"self",
")",
":",
"response",
"=",
"self",
".",
"session",
".",
"get",
"(",
"self",
".",
"url",
")",
"return",
"[",
"Bot",
"(",
"self",
",",
"*",
"*",
"bot",
")",
"for",
"bot",
"in",
"response",
".",
"data",
"]"
] | Return a list of bots.
:return: all of your bots
:rtype: :class:`list` | [
"Return",
"a",
"list",
"of",
"bots",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/bots.py#L11-L18 | train |
rhgrant10/Groupy | groupy/api/bots.py | Bots.create | def create(self, name, group_id, avatar_url=None, callback_url=None,
dm_notification=None, **kwargs):
"""Create a new bot in a particular group.
:param str name: bot name
:param str group_id: the group_id of a group
:param str avatar_url: the URL of an image to use as an avatar
:param str callback_url: a POST-back URL for each new message
:param bool dm_notification: whether to POST-back for direct messages?
:return: the new bot
:rtype: :class:`~groupy.api.bots.Bot`
"""
payload = {
'bot': {
'name': name,
'group_id': group_id,
'avatar_url': avatar_url,
'callback_url': callback_url,
'dm_notification': dm_notification,
},
}
payload['bot'].update(kwargs)
response = self.session.post(self.url, json=payload)
bot = response.data['bot']
return Bot(self, **bot) | python | def create(self, name, group_id, avatar_url=None, callback_url=None,
dm_notification=None, **kwargs):
"""Create a new bot in a particular group.
:param str name: bot name
:param str group_id: the group_id of a group
:param str avatar_url: the URL of an image to use as an avatar
:param str callback_url: a POST-back URL for each new message
:param bool dm_notification: whether to POST-back for direct messages?
:return: the new bot
:rtype: :class:`~groupy.api.bots.Bot`
"""
payload = {
'bot': {
'name': name,
'group_id': group_id,
'avatar_url': avatar_url,
'callback_url': callback_url,
'dm_notification': dm_notification,
},
}
payload['bot'].update(kwargs)
response = self.session.post(self.url, json=payload)
bot = response.data['bot']
return Bot(self, **bot) | [
"def",
"create",
"(",
"self",
",",
"name",
",",
"group_id",
",",
"avatar_url",
"=",
"None",
",",
"callback_url",
"=",
"None",
",",
"dm_notification",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"payload",
"=",
"{",
"'bot'",
":",
"{",
"'name'",
":... | Create a new bot in a particular group.
:param str name: bot name
:param str group_id: the group_id of a group
:param str avatar_url: the URL of an image to use as an avatar
:param str callback_url: a POST-back URL for each new message
:param bool dm_notification: whether to POST-back for direct messages?
:return: the new bot
:rtype: :class:`~groupy.api.bots.Bot` | [
"Create",
"a",
"new",
"bot",
"in",
"a",
"particular",
"group",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/bots.py#L20-L44 | train |
rhgrant10/Groupy | groupy/api/bots.py | Bots.post | def post(self, bot_id, text, attachments=None):
"""Post a new message as a bot to its room.
:param str bot_id: the ID of the bot
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:return: ``True`` if successful
:rtype: bool
"""
url = utils.urljoin(self.url, 'post')
payload = dict(bot_id=bot_id, text=text)
if attachments:
payload['attachments'] = [a.to_json() for a in attachments]
response = self.session.post(url, json=payload)
return response.ok | python | def post(self, bot_id, text, attachments=None):
"""Post a new message as a bot to its room.
:param str bot_id: the ID of the bot
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:return: ``True`` if successful
:rtype: bool
"""
url = utils.urljoin(self.url, 'post')
payload = dict(bot_id=bot_id, text=text)
if attachments:
payload['attachments'] = [a.to_json() for a in attachments]
response = self.session.post(url, json=payload)
return response.ok | [
"def",
"post",
"(",
"self",
",",
"bot_id",
",",
"text",
",",
"attachments",
"=",
"None",
")",
":",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"'post'",
")",
"payload",
"=",
"dict",
"(",
"bot_id",
"=",
"bot_id",
",",
"text",
... | Post a new message as a bot to its room.
:param str bot_id: the ID of the bot
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:return: ``True`` if successful
:rtype: bool | [
"Post",
"a",
"new",
"message",
"as",
"a",
"bot",
"to",
"its",
"room",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/bots.py#L46-L63 | train |
rhgrant10/Groupy | groupy/api/bots.py | Bots.destroy | def destroy(self, bot_id):
"""Destroy a bot.
:param str bot_id: the ID of the bot to destroy
:return: ``True`` if successful
:rtype: bool
"""
url = utils.urljoin(self.url, 'destroy')
payload = {'bot_id': bot_id}
response = self.session.post(url, json=payload)
return response.ok | python | def destroy(self, bot_id):
"""Destroy a bot.
:param str bot_id: the ID of the bot to destroy
:return: ``True`` if successful
:rtype: bool
"""
url = utils.urljoin(self.url, 'destroy')
payload = {'bot_id': bot_id}
response = self.session.post(url, json=payload)
return response.ok | [
"def",
"destroy",
"(",
"self",
",",
"bot_id",
")",
":",
"url",
"=",
"utils",
".",
"urljoin",
"(",
"self",
".",
"url",
",",
"'destroy'",
")",
"payload",
"=",
"{",
"'bot_id'",
":",
"bot_id",
"}",
"response",
"=",
"self",
".",
"session",
".",
"post",
... | Destroy a bot.
:param str bot_id: the ID of the bot to destroy
:return: ``True`` if successful
:rtype: bool | [
"Destroy",
"a",
"bot",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/bots.py#L65-L75 | train |
rhgrant10/Groupy | groupy/api/bots.py | Bot.post | def post(self, text, attachments=None):
"""Post a message as the bot.
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:return: ``True`` if successful
:rtype: bool
"""
return self.manager.post(self.bot_id, text, attachments) | python | def post(self, text, attachments=None):
"""Post a message as the bot.
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:return: ``True`` if successful
:rtype: bool
"""
return self.manager.post(self.bot_id, text, attachments) | [
"def",
"post",
"(",
"self",
",",
"text",
",",
"attachments",
"=",
"None",
")",
":",
"return",
"self",
".",
"manager",
".",
"post",
"(",
"self",
".",
"bot_id",
",",
"text",
",",
"attachments",
")"
] | Post a message as the bot.
:param str text: the text of the message
:param attachments: a list of attachments
:type attachments: :class:`list`
:return: ``True`` if successful
:rtype: bool | [
"Post",
"a",
"message",
"as",
"the",
"bot",
"."
] | ffd8cac57586fa1c218e3b4bfaa531142c3be766 | https://github.com/rhgrant10/Groupy/blob/ffd8cac57586fa1c218e3b4bfaa531142c3be766/groupy/api/bots.py#L88-L97 | train |
jackfirth/pyramda | pyramda/iterable/flatten.py | flatten_until | def flatten_until(is_leaf, xs):
"""
Flatten a nested sequence. A sequence could be a nested list of lists
or tuples or a combination of both
:param is_leaf: Predicate. Predicate to determine whether an item
in the iterable `xs` is a leaf node or not.
:param xs: Iterable. Nested lists or tuples
:return: list.
"""
def _flatten_until(items):
if isinstance(Iterable, items) and not is_leaf(items):
for item in items:
for i in _flatten_until(item):
yield i
else:
yield items
return list(_flatten_until(xs)) | python | def flatten_until(is_leaf, xs):
"""
Flatten a nested sequence. A sequence could be a nested list of lists
or tuples or a combination of both
:param is_leaf: Predicate. Predicate to determine whether an item
in the iterable `xs` is a leaf node or not.
:param xs: Iterable. Nested lists or tuples
:return: list.
"""
def _flatten_until(items):
if isinstance(Iterable, items) and not is_leaf(items):
for item in items:
for i in _flatten_until(item):
yield i
else:
yield items
return list(_flatten_until(xs)) | [
"def",
"flatten_until",
"(",
"is_leaf",
",",
"xs",
")",
":",
"def",
"_flatten_until",
"(",
"items",
")",
":",
"if",
"isinstance",
"(",
"Iterable",
",",
"items",
")",
"and",
"not",
"is_leaf",
"(",
"items",
")",
":",
"for",
"item",
"in",
"items",
":",
... | Flatten a nested sequence. A sequence could be a nested list of lists
or tuples or a combination of both
:param is_leaf: Predicate. Predicate to determine whether an item
in the iterable `xs` is a leaf node or not.
:param xs: Iterable. Nested lists or tuples
:return: list. | [
"Flatten",
"a",
"nested",
"sequence",
".",
"A",
"sequence",
"could",
"be",
"a",
"nested",
"list",
"of",
"lists",
"or",
"tuples",
"or",
"a",
"combination",
"of",
"both"
] | 85ab1c2f456085c9e31e3831459ee1a850ab559c | https://github.com/jackfirth/pyramda/blob/85ab1c2f456085c9e31e3831459ee1a850ab559c/pyramda/iterable/flatten.py#L9-L28 | train |
jackfirth/pyramda | pyramda/function/flip.py | flip | def flip(f):
"""
Calls the function f by flipping the first two positional
arguments
"""
def wrapped(*args, **kwargs):
return f(*flip_first_two(args), **kwargs)
f_spec = make_func_curry_spec(f)
return curry_by_spec(f_spec, wrapped) | python | def flip(f):
"""
Calls the function f by flipping the first two positional
arguments
"""
def wrapped(*args, **kwargs):
return f(*flip_first_two(args), **kwargs)
f_spec = make_func_curry_spec(f)
return curry_by_spec(f_spec, wrapped) | [
"def",
"flip",
"(",
"f",
")",
":",
"def",
"wrapped",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"f",
"(",
"*",
"flip_first_two",
"(",
"args",
")",
",",
"*",
"*",
"kwargs",
")",
"f_spec",
"=",
"make_func_curry_spec",
"(",
"f",
... | Calls the function f by flipping the first two positional
arguments | [
"Calls",
"the",
"function",
"f",
"by",
"flipping",
"the",
"first",
"two",
"positional",
"arguments"
] | 85ab1c2f456085c9e31e3831459ee1a850ab559c | https://github.com/jackfirth/pyramda/blob/85ab1c2f456085c9e31e3831459ee1a850ab559c/pyramda/function/flip.py#L10-L21 | train |
shaypal5/cachier | cachier/core.py | cachier | def cachier(stale_after=None, next_time=False, pickle_reload=True,
mongetter=None):
"""A persistent, stale-free memoization decorator.
The positional and keyword arguments to the wrapped function must be
hashable (i.e. Python's immutable built-in objects, not mutable
containers). Also, notice that since objects which are instances of
user-defined classes are hashable but all compare unequal (their hash
value is their id), equal objects across different sessions will not yield
identical keys.
Arguments
---------
stale_after (optional) : datetime.timedelta
The time delta afterwhich a cached result is considered stale. Calls
made after the result goes stale will trigger a recalculation of the
result, but whether a stale or fresh result will be returned is
determined by the optional next_time argument.
next_time (optional) : bool
If set to True, a stale result will be returned when finding one, not
waiting for the calculation of the fresh result to return. Defaults to
False.
pickle_reload (optional) : bool
If set to True, in-memory cache will be reloaded on each cache read,
enabling different threads to share cache. Should be set to False for
faster reads in single-thread programs. Defaults to True.
mongetter (optional) : callable
A callable that takes no arguments and returns a pymongo.Collection
object with writing permissions. If unset a local pickle cache is used
instead.
"""
# print('Inside the wrapper maker')
# print('mongetter={}'.format(mongetter))
# print('stale_after={}'.format(stale_after))
# print('next_time={}'.format(next_time))
if mongetter:
core = _MongoCore(mongetter, stale_after, next_time)
else:
core = _PickleCore( # pylint: disable=R0204
stale_after, next_time, pickle_reload)
def _cachier_decorator(func):
core.set_func(func)
@wraps(func)
def func_wrapper(*args, **kwds): # pylint: disable=C0111,R0911
# print('Inside general wrapper for {}.'.format(func.__name__))
ignore_cache = kwds.pop('ignore_cache', False)
overwrite_cache = kwds.pop('overwrite_cache', False)
verbose_cache = kwds.pop('verbose_cache', False)
_print = lambda x: None
if verbose_cache:
_print = print
if ignore_cache:
return func(*args, **kwds)
key, entry = core.get_entry(args, kwds)
if overwrite_cache:
return _calc_entry(core, key, func, args, kwds)
if entry is not None: # pylint: disable=R0101
_print('Entry found.')
if entry.get('value', None) is not None:
_print('Cached result found.')
if stale_after:
now = datetime.datetime.now()
if now - entry['time'] > stale_after:
_print('But it is stale... :(')
if entry['being_calculated']:
if next_time:
_print('Returning stale.')
return entry['value'] # return stale val
_print('Already calc. Waiting on change.')
try:
return core.wait_on_entry_calc(key)
except RecalculationNeeded:
return _calc_entry(core, key, func, args, kwds)
if next_time:
_print('Async calc and return stale')
try:
core.mark_entry_being_calculated(key)
_get_executor().submit(
_function_thread, core, key, func,
args, kwds)
finally:
core.mark_entry_not_calculated(key)
return entry['value']
_print('Calling decorated function and waiting')
return _calc_entry(core, key, func, args, kwds)
_print('And it is fresh!')
return entry['value']
if entry['being_calculated']:
_print('No value but being calculated. Waiting.')
try:
return core.wait_on_entry_calc(key)
except RecalculationNeeded:
return _calc_entry(core, key, func, args, kwds)
_print('No entry found. No current calc. Calling like a boss.')
return _calc_entry(core, key, func, args, kwds)
def clear_cache():
"""Clear the cache."""
core.clear_cache()
def clear_being_calculated():
"""Marks all entries in this cache as not being calculated."""
core.clear_being_calculated()
func_wrapper.clear_cache = clear_cache
func_wrapper.clear_being_calculated = clear_being_calculated
return func_wrapper
return _cachier_decorator | python | def cachier(stale_after=None, next_time=False, pickle_reload=True,
mongetter=None):
"""A persistent, stale-free memoization decorator.
The positional and keyword arguments to the wrapped function must be
hashable (i.e. Python's immutable built-in objects, not mutable
containers). Also, notice that since objects which are instances of
user-defined classes are hashable but all compare unequal (their hash
value is their id), equal objects across different sessions will not yield
identical keys.
Arguments
---------
stale_after (optional) : datetime.timedelta
The time delta afterwhich a cached result is considered stale. Calls
made after the result goes stale will trigger a recalculation of the
result, but whether a stale or fresh result will be returned is
determined by the optional next_time argument.
next_time (optional) : bool
If set to True, a stale result will be returned when finding one, not
waiting for the calculation of the fresh result to return. Defaults to
False.
pickle_reload (optional) : bool
If set to True, in-memory cache will be reloaded on each cache read,
enabling different threads to share cache. Should be set to False for
faster reads in single-thread programs. Defaults to True.
mongetter (optional) : callable
A callable that takes no arguments and returns a pymongo.Collection
object with writing permissions. If unset a local pickle cache is used
instead.
"""
# print('Inside the wrapper maker')
# print('mongetter={}'.format(mongetter))
# print('stale_after={}'.format(stale_after))
# print('next_time={}'.format(next_time))
if mongetter:
core = _MongoCore(mongetter, stale_after, next_time)
else:
core = _PickleCore( # pylint: disable=R0204
stale_after, next_time, pickle_reload)
def _cachier_decorator(func):
core.set_func(func)
@wraps(func)
def func_wrapper(*args, **kwds): # pylint: disable=C0111,R0911
# print('Inside general wrapper for {}.'.format(func.__name__))
ignore_cache = kwds.pop('ignore_cache', False)
overwrite_cache = kwds.pop('overwrite_cache', False)
verbose_cache = kwds.pop('verbose_cache', False)
_print = lambda x: None
if verbose_cache:
_print = print
if ignore_cache:
return func(*args, **kwds)
key, entry = core.get_entry(args, kwds)
if overwrite_cache:
return _calc_entry(core, key, func, args, kwds)
if entry is not None: # pylint: disable=R0101
_print('Entry found.')
if entry.get('value', None) is not None:
_print('Cached result found.')
if stale_after:
now = datetime.datetime.now()
if now - entry['time'] > stale_after:
_print('But it is stale... :(')
if entry['being_calculated']:
if next_time:
_print('Returning stale.')
return entry['value'] # return stale val
_print('Already calc. Waiting on change.')
try:
return core.wait_on_entry_calc(key)
except RecalculationNeeded:
return _calc_entry(core, key, func, args, kwds)
if next_time:
_print('Async calc and return stale')
try:
core.mark_entry_being_calculated(key)
_get_executor().submit(
_function_thread, core, key, func,
args, kwds)
finally:
core.mark_entry_not_calculated(key)
return entry['value']
_print('Calling decorated function and waiting')
return _calc_entry(core, key, func, args, kwds)
_print('And it is fresh!')
return entry['value']
if entry['being_calculated']:
_print('No value but being calculated. Waiting.')
try:
return core.wait_on_entry_calc(key)
except RecalculationNeeded:
return _calc_entry(core, key, func, args, kwds)
_print('No entry found. No current calc. Calling like a boss.')
return _calc_entry(core, key, func, args, kwds)
def clear_cache():
"""Clear the cache."""
core.clear_cache()
def clear_being_calculated():
"""Marks all entries in this cache as not being calculated."""
core.clear_being_calculated()
func_wrapper.clear_cache = clear_cache
func_wrapper.clear_being_calculated = clear_being_calculated
return func_wrapper
return _cachier_decorator | [
"def",
"cachier",
"(",
"stale_after",
"=",
"None",
",",
"next_time",
"=",
"False",
",",
"pickle_reload",
"=",
"True",
",",
"mongetter",
"=",
"None",
")",
":",
"# print('Inside the wrapper maker')",
"# print('mongetter={}'.format(mongetter))",
"# print('stale_after={}'.for... | A persistent, stale-free memoization decorator.
The positional and keyword arguments to the wrapped function must be
hashable (i.e. Python's immutable built-in objects, not mutable
containers). Also, notice that since objects which are instances of
user-defined classes are hashable but all compare unequal (their hash
value is their id), equal objects across different sessions will not yield
identical keys.
Arguments
---------
stale_after (optional) : datetime.timedelta
The time delta afterwhich a cached result is considered stale. Calls
made after the result goes stale will trigger a recalculation of the
result, but whether a stale or fresh result will be returned is
determined by the optional next_time argument.
next_time (optional) : bool
If set to True, a stale result will be returned when finding one, not
waiting for the calculation of the fresh result to return. Defaults to
False.
pickle_reload (optional) : bool
If set to True, in-memory cache will be reloaded on each cache read,
enabling different threads to share cache. Should be set to False for
faster reads in single-thread programs. Defaults to True.
mongetter (optional) : callable
A callable that takes no arguments and returns a pymongo.Collection
object with writing permissions. If unset a local pickle cache is used
instead. | [
"A",
"persistent",
"stale",
"-",
"free",
"memoization",
"decorator",
"."
] | 998233b97b9d905292e9d33413677f98d131f17d | https://github.com/shaypal5/cachier/blob/998233b97b9d905292e9d33413677f98d131f17d/cachier/core.py#L74-L185 | train |
bocong/urbandictionary-py | urbandictionary.py | defineID | def defineID(defid):
"""Search for UD's definition ID and return list of UrbanDefinition objects.
Keyword arguments:
defid -- definition ID to search for (int or str)
"""
json = _get_urban_json(UD_DEFID_URL + urlquote(str(defid)))
return _parse_urban_json(json) | python | def defineID(defid):
"""Search for UD's definition ID and return list of UrbanDefinition objects.
Keyword arguments:
defid -- definition ID to search for (int or str)
"""
json = _get_urban_json(UD_DEFID_URL + urlquote(str(defid)))
return _parse_urban_json(json) | [
"def",
"defineID",
"(",
"defid",
")",
":",
"json",
"=",
"_get_urban_json",
"(",
"UD_DEFID_URL",
"+",
"urlquote",
"(",
"str",
"(",
"defid",
")",
")",
")",
"return",
"_parse_urban_json",
"(",
"json",
")"
] | Search for UD's definition ID and return list of UrbanDefinition objects.
Keyword arguments:
defid -- definition ID to search for (int or str) | [
"Search",
"for",
"UD",
"s",
"definition",
"ID",
"and",
"return",
"list",
"of",
"UrbanDefinition",
"objects",
"."
] | aa919cd2c28563ca7f09ff80a3125de2dc7576ba | https://github.com/bocong/urbandictionary-py/blob/aa919cd2c28563ca7f09ff80a3125de2dc7576ba/urbandictionary.py#L63-L70 | train |
scraperwiki/scraperwiki-python | setup.py | has_external_dependency | def has_external_dependency(name):
'Check that a non-Python dependency is installed.'
for directory in os.environ['PATH'].split(':'):
if os.path.exists(os.path.join(directory, name)):
return True
return False | python | def has_external_dependency(name):
'Check that a non-Python dependency is installed.'
for directory in os.environ['PATH'].split(':'):
if os.path.exists(os.path.join(directory, name)):
return True
return False | [
"def",
"has_external_dependency",
"(",
"name",
")",
":",
"for",
"directory",
"in",
"os",
".",
"environ",
"[",
"'PATH'",
"]",
".",
"split",
"(",
"':'",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"join",
"(",
"dire... | Check that a non-Python dependency is installed. | [
"Check",
"that",
"a",
"non",
"-",
"Python",
"dependency",
"is",
"installed",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/setup.py#L11-L16 | train |
akaszynski/pymeshfix | pymeshfix/examples/fix.py | with_vtk | def with_vtk(plot=True):
""" Tests VTK interface and mesh repair of Stanford Bunny Mesh """
mesh = vtki.PolyData(bunny_scan)
meshfix = pymeshfix.MeshFix(mesh)
if plot:
print('Plotting input mesh')
meshfix.plot()
meshfix.repair()
if plot:
print('Plotting repaired mesh')
meshfix.plot()
return meshfix.mesh | python | def with_vtk(plot=True):
""" Tests VTK interface and mesh repair of Stanford Bunny Mesh """
mesh = vtki.PolyData(bunny_scan)
meshfix = pymeshfix.MeshFix(mesh)
if plot:
print('Plotting input mesh')
meshfix.plot()
meshfix.repair()
if plot:
print('Plotting repaired mesh')
meshfix.plot()
return meshfix.mesh | [
"def",
"with_vtk",
"(",
"plot",
"=",
"True",
")",
":",
"mesh",
"=",
"vtki",
".",
"PolyData",
"(",
"bunny_scan",
")",
"meshfix",
"=",
"pymeshfix",
".",
"MeshFix",
"(",
"mesh",
")",
"if",
"plot",
":",
"print",
"(",
"'Plotting input mesh'",
")",
"meshfix",
... | Tests VTK interface and mesh repair of Stanford Bunny Mesh | [
"Tests",
"VTK",
"interface",
"and",
"mesh",
"repair",
"of",
"Stanford",
"Bunny",
"Mesh"
] | 51873b25d8d46168479989a528db8456af6748f4 | https://github.com/akaszynski/pymeshfix/blob/51873b25d8d46168479989a528db8456af6748f4/pymeshfix/examples/fix.py#L15-L27 | train |
akaszynski/pymeshfix | pymeshfix/meshfix.py | MeshFix.load_arrays | def load_arrays(self, v, f):
"""Loads triangular mesh from vertex and face numpy arrays.
Both vertex and face arrays should be 2D arrays with each
vertex containing XYZ data and each face containing three
points.
Parameters
----------
v : np.ndarray
n x 3 vertex array.
f : np.ndarray
n x 3 face array.
"""
# Check inputs
if not isinstance(v, np.ndarray):
try:
v = np.asarray(v, np.float)
if v.ndim != 2 and v.shape[1] != 3:
raise Exception('Invalid vertex format. Shape ' +
'should be (npoints, 3)')
except BaseException:
raise Exception(
'Unable to convert vertex input to valid numpy array')
if not isinstance(f, np.ndarray):
try:
f = np.asarray(f, ctypes.c_int)
if f.ndim != 2 and f.shape[1] != 3:
raise Exception('Invalid face format. ' +
'Shape should be (nfaces, 3)')
except BaseException:
raise Exception('Unable to convert face input to valid' +
' numpy array')
self.v = v
self.f = f | python | def load_arrays(self, v, f):
"""Loads triangular mesh from vertex and face numpy arrays.
Both vertex and face arrays should be 2D arrays with each
vertex containing XYZ data and each face containing three
points.
Parameters
----------
v : np.ndarray
n x 3 vertex array.
f : np.ndarray
n x 3 face array.
"""
# Check inputs
if not isinstance(v, np.ndarray):
try:
v = np.asarray(v, np.float)
if v.ndim != 2 and v.shape[1] != 3:
raise Exception('Invalid vertex format. Shape ' +
'should be (npoints, 3)')
except BaseException:
raise Exception(
'Unable to convert vertex input to valid numpy array')
if not isinstance(f, np.ndarray):
try:
f = np.asarray(f, ctypes.c_int)
if f.ndim != 2 and f.shape[1] != 3:
raise Exception('Invalid face format. ' +
'Shape should be (nfaces, 3)')
except BaseException:
raise Exception('Unable to convert face input to valid' +
' numpy array')
self.v = v
self.f = f | [
"def",
"load_arrays",
"(",
"self",
",",
"v",
",",
"f",
")",
":",
"# Check inputs",
"if",
"not",
"isinstance",
"(",
"v",
",",
"np",
".",
"ndarray",
")",
":",
"try",
":",
"v",
"=",
"np",
".",
"asarray",
"(",
"v",
",",
"np",
".",
"float",
")",
"if... | Loads triangular mesh from vertex and face numpy arrays.
Both vertex and face arrays should be 2D arrays with each
vertex containing XYZ data and each face containing three
points.
Parameters
----------
v : np.ndarray
n x 3 vertex array.
f : np.ndarray
n x 3 face array. | [
"Loads",
"triangular",
"mesh",
"from",
"vertex",
"and",
"face",
"numpy",
"arrays",
"."
] | 51873b25d8d46168479989a528db8456af6748f4 | https://github.com/akaszynski/pymeshfix/blob/51873b25d8d46168479989a528db8456af6748f4/pymeshfix/meshfix.py#L37-L74 | train |
akaszynski/pymeshfix | pymeshfix/meshfix.py | MeshFix.mesh | def mesh(self):
"""Return the surface mesh"""
triangles = np.empty((self.f.shape[0], 4))
triangles[:, -3:] = self.f
triangles[:, 0] = 3
return vtki.PolyData(self.v, triangles, deep=False) | python | def mesh(self):
"""Return the surface mesh"""
triangles = np.empty((self.f.shape[0], 4))
triangles[:, -3:] = self.f
triangles[:, 0] = 3
return vtki.PolyData(self.v, triangles, deep=False) | [
"def",
"mesh",
"(",
"self",
")",
":",
"triangles",
"=",
"np",
".",
"empty",
"(",
"(",
"self",
".",
"f",
".",
"shape",
"[",
"0",
"]",
",",
"4",
")",
")",
"triangles",
"[",
":",
",",
"-",
"3",
":",
"]",
"=",
"self",
".",
"f",
"triangles",
"["... | Return the surface mesh | [
"Return",
"the",
"surface",
"mesh"
] | 51873b25d8d46168479989a528db8456af6748f4 | https://github.com/akaszynski/pymeshfix/blob/51873b25d8d46168479989a528db8456af6748f4/pymeshfix/meshfix.py#L77-L82 | train |
akaszynski/pymeshfix | pymeshfix/meshfix.py | MeshFix.plot | def plot(self, show_holes=True):
"""
Plot the mesh.
Parameters
----------
show_holes : bool, optional
Shows boundaries. Default True
"""
if show_holes:
edges = self.mesh.extract_edges(boundary_edges=True,
feature_edges=False,
manifold_edges=False)
plotter = vtki.Plotter()
plotter.add_mesh(self.mesh, label='mesh')
plotter.add_mesh(edges, 'r', label='edges')
plotter.plot()
else:
self.mesh.plot(show_edges=True) | python | def plot(self, show_holes=True):
"""
Plot the mesh.
Parameters
----------
show_holes : bool, optional
Shows boundaries. Default True
"""
if show_holes:
edges = self.mesh.extract_edges(boundary_edges=True,
feature_edges=False,
manifold_edges=False)
plotter = vtki.Plotter()
plotter.add_mesh(self.mesh, label='mesh')
plotter.add_mesh(edges, 'r', label='edges')
plotter.plot()
else:
self.mesh.plot(show_edges=True) | [
"def",
"plot",
"(",
"self",
",",
"show_holes",
"=",
"True",
")",
":",
"if",
"show_holes",
":",
"edges",
"=",
"self",
".",
"mesh",
".",
"extract_edges",
"(",
"boundary_edges",
"=",
"True",
",",
"feature_edges",
"=",
"False",
",",
"manifold_edges",
"=",
"F... | Plot the mesh.
Parameters
----------
show_holes : bool, optional
Shows boundaries. Default True | [
"Plot",
"the",
"mesh",
"."
] | 51873b25d8d46168479989a528db8456af6748f4 | https://github.com/akaszynski/pymeshfix/blob/51873b25d8d46168479989a528db8456af6748f4/pymeshfix/meshfix.py#L84-L104 | train |
akaszynski/pymeshfix | pymeshfix/meshfix.py | MeshFix.repair | def repair(self, verbose=False, joincomp=False,
remove_smallest_components=True):
"""Performs mesh repair using MeshFix's default repair
process.
Parameters
----------
verbose : bool, optional
Enables or disables debug printing. Disabled by default.
joincomp : bool, optional
Attempts to join nearby open components.
remove_smallest_components : bool, optional
Remove all but the largest isolated component from the
mesh before beginning the repair process. Default True
Notes
-----
Vertex and face arrays are updated inplace. Access them with:
meshfix.v
meshfix.f
"""
assert self.f.shape[1] == 3, 'Face array must contain three columns'
assert self.f.ndim == 2, 'Face array must be 2D'
self.v, self.f = _meshfix.clean_from_arrays(self.v, self.f,
verbose, joincomp,
remove_smallest_components) | python | def repair(self, verbose=False, joincomp=False,
remove_smallest_components=True):
"""Performs mesh repair using MeshFix's default repair
process.
Parameters
----------
verbose : bool, optional
Enables or disables debug printing. Disabled by default.
joincomp : bool, optional
Attempts to join nearby open components.
remove_smallest_components : bool, optional
Remove all but the largest isolated component from the
mesh before beginning the repair process. Default True
Notes
-----
Vertex and face arrays are updated inplace. Access them with:
meshfix.v
meshfix.f
"""
assert self.f.shape[1] == 3, 'Face array must contain three columns'
assert self.f.ndim == 2, 'Face array must be 2D'
self.v, self.f = _meshfix.clean_from_arrays(self.v, self.f,
verbose, joincomp,
remove_smallest_components) | [
"def",
"repair",
"(",
"self",
",",
"verbose",
"=",
"False",
",",
"joincomp",
"=",
"False",
",",
"remove_smallest_components",
"=",
"True",
")",
":",
"assert",
"self",
".",
"f",
".",
"shape",
"[",
"1",
"]",
"==",
"3",
",",
"'Face array must contain three co... | Performs mesh repair using MeshFix's default repair
process.
Parameters
----------
verbose : bool, optional
Enables or disables debug printing. Disabled by default.
joincomp : bool, optional
Attempts to join nearby open components.
remove_smallest_components : bool, optional
Remove all but the largest isolated component from the
mesh before beginning the repair process. Default True
Notes
-----
Vertex and face arrays are updated inplace. Access them with:
meshfix.v
meshfix.f | [
"Performs",
"mesh",
"repair",
"using",
"MeshFix",
"s",
"default",
"repair",
"process",
"."
] | 51873b25d8d46168479989a528db8456af6748f4 | https://github.com/akaszynski/pymeshfix/blob/51873b25d8d46168479989a528db8456af6748f4/pymeshfix/meshfix.py#L106-L133 | train |
akaszynski/pymeshfix | pymeshfix/meshfix.py | MeshFix.write | def write(self, filename, binary=True):
"""Writes a surface mesh to disk.
Written file may be an ASCII or binary ply, stl, or vtk mesh
file.
Parameters
----------
filename : str
Filename of mesh to be written. Filetype is inferred from
the extension of the filename unless overridden with
ftype. Can be one of the following types (.ply, .stl,
.vtk)
ftype : str, optional
Filetype. Inferred from filename unless specified with a
three character string. Can be one of the following:
'ply', 'stl', or 'vtk'.
Notes
-----
Binary files write much faster than ASCII.
"""
self.mesh.write(filename, binary) | python | def write(self, filename, binary=True):
"""Writes a surface mesh to disk.
Written file may be an ASCII or binary ply, stl, or vtk mesh
file.
Parameters
----------
filename : str
Filename of mesh to be written. Filetype is inferred from
the extension of the filename unless overridden with
ftype. Can be one of the following types (.ply, .stl,
.vtk)
ftype : str, optional
Filetype. Inferred from filename unless specified with a
three character string. Can be one of the following:
'ply', 'stl', or 'vtk'.
Notes
-----
Binary files write much faster than ASCII.
"""
self.mesh.write(filename, binary) | [
"def",
"write",
"(",
"self",
",",
"filename",
",",
"binary",
"=",
"True",
")",
":",
"self",
".",
"mesh",
".",
"write",
"(",
"filename",
",",
"binary",
")"
] | Writes a surface mesh to disk.
Written file may be an ASCII or binary ply, stl, or vtk mesh
file.
Parameters
----------
filename : str
Filename of mesh to be written. Filetype is inferred from
the extension of the filename unless overridden with
ftype. Can be one of the following types (.ply, .stl,
.vtk)
ftype : str, optional
Filetype. Inferred from filename unless specified with a
three character string. Can be one of the following:
'ply', 'stl', or 'vtk'.
Notes
-----
Binary files write much faster than ASCII. | [
"Writes",
"a",
"surface",
"mesh",
"to",
"disk",
"."
] | 51873b25d8d46168479989a528db8456af6748f4 | https://github.com/akaszynski/pymeshfix/blob/51873b25d8d46168479989a528db8456af6748f4/pymeshfix/meshfix.py#L135-L158 | train |
scraperwiki/scraperwiki-python | scraperwiki/utils.py | scrape | def scrape(url, params=None, user_agent=None):
'''
Scrape a URL optionally with parameters.
This is effectively a wrapper around urllib2.urlopen.
'''
headers = {}
if user_agent:
headers['User-Agent'] = user_agent
data = params and six.moves.urllib.parse.urlencode(params) or None
req = six.moves.urllib.request.Request(url, data=data, headers=headers)
f = six.moves.urllib.request.urlopen(req)
text = f.read()
f.close()
return text | python | def scrape(url, params=None, user_agent=None):
'''
Scrape a URL optionally with parameters.
This is effectively a wrapper around urllib2.urlopen.
'''
headers = {}
if user_agent:
headers['User-Agent'] = user_agent
data = params and six.moves.urllib.parse.urlencode(params) or None
req = six.moves.urllib.request.Request(url, data=data, headers=headers)
f = six.moves.urllib.request.urlopen(req)
text = f.read()
f.close()
return text | [
"def",
"scrape",
"(",
"url",
",",
"params",
"=",
"None",
",",
"user_agent",
"=",
"None",
")",
":",
"headers",
"=",
"{",
"}",
"if",
"user_agent",
":",
"headers",
"[",
"'User-Agent'",
"]",
"=",
"user_agent",
"data",
"=",
"params",
"and",
"six",
".",
"m... | Scrape a URL optionally with parameters.
This is effectively a wrapper around urllib2.urlopen. | [
"Scrape",
"a",
"URL",
"optionally",
"with",
"parameters",
".",
"This",
"is",
"effectively",
"a",
"wrapper",
"around",
"urllib2",
".",
"urlopen",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/utils.py#L21-L39 | train |
scraperwiki/scraperwiki-python | scraperwiki/utils.py | pdftoxml | def pdftoxml(pdfdata, options=""):
"""converts pdf file to xml file"""
pdffout = tempfile.NamedTemporaryFile(suffix='.pdf')
pdffout.write(pdfdata)
pdffout.flush()
xmlin = tempfile.NamedTemporaryFile(mode='r', suffix='.xml')
tmpxml = xmlin.name # "temph.xml"
cmd = 'pdftohtml -xml -nodrm -zoom 1.5 -enc UTF-8 -noframes %s "%s" "%s"' % (
options, pdffout.name, os.path.splitext(tmpxml)[0])
# can't turn off output, so throw away even stderr yeuch
cmd = cmd + " >/dev/null 2>&1"
os.system(cmd)
pdffout.close()
#xmlfin = open(tmpxml)
xmldata = xmlin.read()
xmlin.close()
return xmldata.decode('utf-8') | python | def pdftoxml(pdfdata, options=""):
"""converts pdf file to xml file"""
pdffout = tempfile.NamedTemporaryFile(suffix='.pdf')
pdffout.write(pdfdata)
pdffout.flush()
xmlin = tempfile.NamedTemporaryFile(mode='r', suffix='.xml')
tmpxml = xmlin.name # "temph.xml"
cmd = 'pdftohtml -xml -nodrm -zoom 1.5 -enc UTF-8 -noframes %s "%s" "%s"' % (
options, pdffout.name, os.path.splitext(tmpxml)[0])
# can't turn off output, so throw away even stderr yeuch
cmd = cmd + " >/dev/null 2>&1"
os.system(cmd)
pdffout.close()
#xmlfin = open(tmpxml)
xmldata = xmlin.read()
xmlin.close()
return xmldata.decode('utf-8') | [
"def",
"pdftoxml",
"(",
"pdfdata",
",",
"options",
"=",
"\"\"",
")",
":",
"pdffout",
"=",
"tempfile",
".",
"NamedTemporaryFile",
"(",
"suffix",
"=",
"'.pdf'",
")",
"pdffout",
".",
"write",
"(",
"pdfdata",
")",
"pdffout",
".",
"flush",
"(",
")",
"xmlin",
... | converts pdf file to xml file | [
"converts",
"pdf",
"file",
"to",
"xml",
"file"
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/utils.py#L42-L60 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | execute | def execute(query, data=None):
"""
Execute an arbitrary SQL query given by query, returning any
results as a list of OrderedDicts. A list of values can be supplied as an,
additional argument, which will be substituted into question marks in the
query.
"""
connection = _State.connection()
_State.new_transaction()
if data is None:
data = []
result = connection.execute(query, data)
_State.table = None
_State.metadata = None
try:
del _State.table_pending
except AttributeError:
pass
if not result.returns_rows:
return {u'data': [], u'keys': []}
return {u'data': result.fetchall(), u'keys': list(result.keys())} | python | def execute(query, data=None):
"""
Execute an arbitrary SQL query given by query, returning any
results as a list of OrderedDicts. A list of values can be supplied as an,
additional argument, which will be substituted into question marks in the
query.
"""
connection = _State.connection()
_State.new_transaction()
if data is None:
data = []
result = connection.execute(query, data)
_State.table = None
_State.metadata = None
try:
del _State.table_pending
except AttributeError:
pass
if not result.returns_rows:
return {u'data': [], u'keys': []}
return {u'data': result.fetchall(), u'keys': list(result.keys())} | [
"def",
"execute",
"(",
"query",
",",
"data",
"=",
"None",
")",
":",
"connection",
"=",
"_State",
".",
"connection",
"(",
")",
"_State",
".",
"new_transaction",
"(",
")",
"if",
"data",
"is",
"None",
":",
"data",
"=",
"[",
"]",
"result",
"=",
"connecti... | Execute an arbitrary SQL query given by query, returning any
results as a list of OrderedDicts. A list of values can be supplied as an,
additional argument, which will be substituted into question marks in the
query. | [
"Execute",
"an",
"arbitrary",
"SQL",
"query",
"given",
"by",
"query",
"returning",
"any",
"results",
"as",
"a",
"list",
"of",
"OrderedDicts",
".",
"A",
"list",
"of",
"values",
"can",
"be",
"supplied",
"as",
"an",
"additional",
"argument",
"which",
"will",
... | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L134-L159 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | select | def select(query, data=None):
"""
Perform a sql select statement with the given query (without 'select') and
return any results as a list of OrderedDicts.
"""
connection = _State.connection()
_State.new_transaction()
if data is None:
data = []
result = connection.execute('select ' + query, data)
rows = []
for row in result:
rows.append(dict(list(row.items())))
return rows | python | def select(query, data=None):
"""
Perform a sql select statement with the given query (without 'select') and
return any results as a list of OrderedDicts.
"""
connection = _State.connection()
_State.new_transaction()
if data is None:
data = []
result = connection.execute('select ' + query, data)
rows = []
for row in result:
rows.append(dict(list(row.items())))
return rows | [
"def",
"select",
"(",
"query",
",",
"data",
"=",
"None",
")",
":",
"connection",
"=",
"_State",
".",
"connection",
"(",
")",
"_State",
".",
"new_transaction",
"(",
")",
"if",
"data",
"is",
"None",
":",
"data",
"=",
"[",
"]",
"result",
"=",
"connectio... | Perform a sql select statement with the given query (without 'select') and
return any results as a list of OrderedDicts. | [
"Perform",
"a",
"sql",
"select",
"statement",
"with",
"the",
"given",
"query",
"(",
"without",
"select",
")",
"and",
"return",
"any",
"results",
"as",
"a",
"list",
"of",
"OrderedDicts",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L162-L178 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | save | def save(unique_keys, data, table_name='swdata'):
"""
Save the given data to the table specified by `table_name`
(which defaults to 'swdata'). The data must be a mapping
or an iterable of mappings. Unique keys is a list of keys that exist
for all rows and for which a unique index will be created.
"""
_set_table(table_name)
connection = _State.connection()
if isinstance(data, Mapping):
# Is a single datum
data = [data]
elif not isinstance(data, Iterable):
raise TypeError("Data must be a single mapping or an iterable "
"of mappings")
insert = _State.table.insert(prefixes=['OR REPLACE'])
for row in data:
if not isinstance(row, Mapping):
raise TypeError("Elements of data must be mappings, got {}".format(
type(row)))
fit_row(connection, row, unique_keys)
connection.execute(insert.values(row))
_State.check_last_committed() | python | def save(unique_keys, data, table_name='swdata'):
"""
Save the given data to the table specified by `table_name`
(which defaults to 'swdata'). The data must be a mapping
or an iterable of mappings. Unique keys is a list of keys that exist
for all rows and for which a unique index will be created.
"""
_set_table(table_name)
connection = _State.connection()
if isinstance(data, Mapping):
# Is a single datum
data = [data]
elif not isinstance(data, Iterable):
raise TypeError("Data must be a single mapping or an iterable "
"of mappings")
insert = _State.table.insert(prefixes=['OR REPLACE'])
for row in data:
if not isinstance(row, Mapping):
raise TypeError("Elements of data must be mappings, got {}".format(
type(row)))
fit_row(connection, row, unique_keys)
connection.execute(insert.values(row))
_State.check_last_committed() | [
"def",
"save",
"(",
"unique_keys",
",",
"data",
",",
"table_name",
"=",
"'swdata'",
")",
":",
"_set_table",
"(",
"table_name",
")",
"connection",
"=",
"_State",
".",
"connection",
"(",
")",
"if",
"isinstance",
"(",
"data",
",",
"Mapping",
")",
":",
"# Is... | Save the given data to the table specified by `table_name`
(which defaults to 'swdata'). The data must be a mapping
or an iterable of mappings. Unique keys is a list of keys that exist
for all rows and for which a unique index will be created. | [
"Save",
"the",
"given",
"data",
"to",
"the",
"table",
"specified",
"by",
"table_name",
"(",
"which",
"defaults",
"to",
"swdata",
")",
".",
"The",
"data",
"must",
"be",
"a",
"mapping",
"or",
"an",
"iterable",
"of",
"mappings",
".",
"Unique",
"keys",
"is",... | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L181-L207 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | _set_table | def _set_table(table_name):
"""
Specify the table to work on.
"""
_State.connection()
_State.reflect_metadata()
_State.table = sqlalchemy.Table(table_name, _State.metadata,
extend_existing=True)
if list(_State.table.columns.keys()) == []:
_State.table_pending = True
else:
_State.table_pending = False | python | def _set_table(table_name):
"""
Specify the table to work on.
"""
_State.connection()
_State.reflect_metadata()
_State.table = sqlalchemy.Table(table_name, _State.metadata,
extend_existing=True)
if list(_State.table.columns.keys()) == []:
_State.table_pending = True
else:
_State.table_pending = False | [
"def",
"_set_table",
"(",
"table_name",
")",
":",
"_State",
".",
"connection",
"(",
")",
"_State",
".",
"reflect_metadata",
"(",
")",
"_State",
".",
"table",
"=",
"sqlalchemy",
".",
"Table",
"(",
"table_name",
",",
"_State",
".",
"metadata",
",",
"extend_e... | Specify the table to work on. | [
"Specify",
"the",
"table",
"to",
"work",
"on",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L210-L222 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | show_tables | def show_tables():
"""
Return the names of the tables currently in the database.
"""
_State.connection()
_State.reflect_metadata()
metadata = _State.metadata
response = select('name, sql from sqlite_master where type="table"')
return {row['name']: row['sql'] for row in response} | python | def show_tables():
"""
Return the names of the tables currently in the database.
"""
_State.connection()
_State.reflect_metadata()
metadata = _State.metadata
response = select('name, sql from sqlite_master where type="table"')
return {row['name']: row['sql'] for row in response} | [
"def",
"show_tables",
"(",
")",
":",
"_State",
".",
"connection",
"(",
")",
"_State",
".",
"reflect_metadata",
"(",
")",
"metadata",
"=",
"_State",
".",
"metadata",
"response",
"=",
"select",
"(",
"'name, sql from sqlite_master where type=\"table\"'",
")",
"return... | Return the names of the tables currently in the database. | [
"Return",
"the",
"names",
"of",
"the",
"tables",
"currently",
"in",
"the",
"database",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L225-L235 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | save_var | def save_var(name, value):
"""
Save a variable to the table specified by _State.vars_table_name. Key is
the name of the variable, and value is the value.
"""
connection = _State.connection()
_State.reflect_metadata()
vars_table = sqlalchemy.Table(
_State.vars_table_name, _State.metadata,
sqlalchemy.Column('name', sqlalchemy.types.Text, primary_key=True),
sqlalchemy.Column('value_blob', sqlalchemy.types.LargeBinary),
sqlalchemy.Column('type', sqlalchemy.types.Text),
keep_existing=True
)
vars_table.create(bind=connection, checkfirst=True)
column_type = get_column_type(value)
if column_type == sqlalchemy.types.LargeBinary:
value_blob = value
else:
value_blob = unicode(value).encode('utf-8')
values = dict(name=name,
value_blob=value_blob,
# value_blob=Blob(value),
type=column_type.__visit_name__.lower())
vars_table.insert(prefixes=['OR REPLACE']).values(**values).execute() | python | def save_var(name, value):
"""
Save a variable to the table specified by _State.vars_table_name. Key is
the name of the variable, and value is the value.
"""
connection = _State.connection()
_State.reflect_metadata()
vars_table = sqlalchemy.Table(
_State.vars_table_name, _State.metadata,
sqlalchemy.Column('name', sqlalchemy.types.Text, primary_key=True),
sqlalchemy.Column('value_blob', sqlalchemy.types.LargeBinary),
sqlalchemy.Column('type', sqlalchemy.types.Text),
keep_existing=True
)
vars_table.create(bind=connection, checkfirst=True)
column_type = get_column_type(value)
if column_type == sqlalchemy.types.LargeBinary:
value_blob = value
else:
value_blob = unicode(value).encode('utf-8')
values = dict(name=name,
value_blob=value_blob,
# value_blob=Blob(value),
type=column_type.__visit_name__.lower())
vars_table.insert(prefixes=['OR REPLACE']).values(**values).execute() | [
"def",
"save_var",
"(",
"name",
",",
"value",
")",
":",
"connection",
"=",
"_State",
".",
"connection",
"(",
")",
"_State",
".",
"reflect_metadata",
"(",
")",
"vars_table",
"=",
"sqlalchemy",
".",
"Table",
"(",
"_State",
".",
"vars_table_name",
",",
"_Stat... | Save a variable to the table specified by _State.vars_table_name. Key is
the name of the variable, and value is the value. | [
"Save",
"a",
"variable",
"to",
"the",
"table",
"specified",
"by",
"_State",
".",
"vars_table_name",
".",
"Key",
"is",
"the",
"name",
"of",
"the",
"variable",
"and",
"value",
"is",
"the",
"value",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L238-L268 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | get_var | def get_var(name, default=None):
"""
Returns the variable with the provided key from the
table specified by _State.vars_table_name.
"""
alchemytypes = {"text": lambda x: x.decode('utf-8'),
"big_integer": lambda x: int(x),
"date": lambda x: x.decode('utf-8'),
"datetime": lambda x: x.decode('utf-8'),
"float": lambda x: float(x),
"large_binary": lambda x: x,
"boolean": lambda x: x==b'True'}
connection = _State.connection()
_State.new_transaction()
if _State.vars_table_name not in list(_State.metadata.tables.keys()):
return None
table = sqlalchemy.Table(_State.vars_table_name, _State.metadata)
s = sqlalchemy.select([table.c.value_blob, table.c.type])
s = s.where(table.c.name == name)
result = connection.execute(s).fetchone()
if not result:
return None
return alchemytypes[result[1]](result[0])
# This is to do the variable type conversion through the SQL engine
execute = connection.execute
execute("CREATE TEMPORARY TABLE _sw_tmp ('value' {})".format(result.type))
execute("INSERT INTO _sw_tmp VALUES (:value)", value=result.value_blob)
var = execute('SELECT value FROM _sw_tmp').fetchone().value
execute("DROP TABLE _sw_tmp")
return var.decode('utf-8') | python | def get_var(name, default=None):
"""
Returns the variable with the provided key from the
table specified by _State.vars_table_name.
"""
alchemytypes = {"text": lambda x: x.decode('utf-8'),
"big_integer": lambda x: int(x),
"date": lambda x: x.decode('utf-8'),
"datetime": lambda x: x.decode('utf-8'),
"float": lambda x: float(x),
"large_binary": lambda x: x,
"boolean": lambda x: x==b'True'}
connection = _State.connection()
_State.new_transaction()
if _State.vars_table_name not in list(_State.metadata.tables.keys()):
return None
table = sqlalchemy.Table(_State.vars_table_name, _State.metadata)
s = sqlalchemy.select([table.c.value_blob, table.c.type])
s = s.where(table.c.name == name)
result = connection.execute(s).fetchone()
if not result:
return None
return alchemytypes[result[1]](result[0])
# This is to do the variable type conversion through the SQL engine
execute = connection.execute
execute("CREATE TEMPORARY TABLE _sw_tmp ('value' {})".format(result.type))
execute("INSERT INTO _sw_tmp VALUES (:value)", value=result.value_blob)
var = execute('SELECT value FROM _sw_tmp').fetchone().value
execute("DROP TABLE _sw_tmp")
return var.decode('utf-8') | [
"def",
"get_var",
"(",
"name",
",",
"default",
"=",
"None",
")",
":",
"alchemytypes",
"=",
"{",
"\"text\"",
":",
"lambda",
"x",
":",
"x",
".",
"decode",
"(",
"'utf-8'",
")",
",",
"\"big_integer\"",
":",
"lambda",
"x",
":",
"int",
"(",
"x",
")",
","... | Returns the variable with the provided key from the
table specified by _State.vars_table_name. | [
"Returns",
"the",
"variable",
"with",
"the",
"provided",
"key",
"from",
"the",
"table",
"specified",
"by",
"_State",
".",
"vars_table_name",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L271-L306 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | create_index | def create_index(column_names, unique=False):
"""
Create a new index of the columns in column_names, where column_names is
a list of strings. If unique is True, it will be a
unique index.
"""
connection = _State.connection()
_State.reflect_metadata()
table_name = _State.table.name
table = _State.table
index_name = re.sub(r'[^a-zA-Z0-9]', '', table_name) + '_'
index_name += '_'.join(re.sub(r'[^a-zA-Z0-9]', '', x)
for x in column_names)
if unique:
index_name += '_unique'
columns = []
for column_name in column_names:
columns.append(table.columns[column_name])
current_indices = [x.name for x in table.indexes]
index = sqlalchemy.schema.Index(index_name, *columns, unique=unique)
if index.name not in current_indices:
index.create(bind=_State.engine) | python | def create_index(column_names, unique=False):
"""
Create a new index of the columns in column_names, where column_names is
a list of strings. If unique is True, it will be a
unique index.
"""
connection = _State.connection()
_State.reflect_metadata()
table_name = _State.table.name
table = _State.table
index_name = re.sub(r'[^a-zA-Z0-9]', '', table_name) + '_'
index_name += '_'.join(re.sub(r'[^a-zA-Z0-9]', '', x)
for x in column_names)
if unique:
index_name += '_unique'
columns = []
for column_name in column_names:
columns.append(table.columns[column_name])
current_indices = [x.name for x in table.indexes]
index = sqlalchemy.schema.Index(index_name, *columns, unique=unique)
if index.name not in current_indices:
index.create(bind=_State.engine) | [
"def",
"create_index",
"(",
"column_names",
",",
"unique",
"=",
"False",
")",
":",
"connection",
"=",
"_State",
".",
"connection",
"(",
")",
"_State",
".",
"reflect_metadata",
"(",
")",
"table_name",
"=",
"_State",
".",
"table",
".",
"name",
"table",
"=",
... | Create a new index of the columns in column_names, where column_names is
a list of strings. If unique is True, it will be a
unique index. | [
"Create",
"a",
"new",
"index",
"of",
"the",
"columns",
"in",
"column_names",
"where",
"column_names",
"is",
"a",
"list",
"of",
"strings",
".",
"If",
"unique",
"is",
"True",
"it",
"will",
"be",
"a",
"unique",
"index",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L309-L335 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | fit_row | def fit_row(connection, row, unique_keys):
"""
Takes a row and checks to make sure it fits in the columns of the
current table. If it does not fit, adds the required columns.
"""
new_columns = []
for column_name, column_value in list(row.items()):
new_column = sqlalchemy.Column(column_name,
get_column_type(column_value))
if not column_name in list(_State.table.columns.keys()):
new_columns.append(new_column)
_State.table.append_column(new_column)
if _State.table_pending:
create_table(unique_keys)
return
for new_column in new_columns:
add_column(connection, new_column) | python | def fit_row(connection, row, unique_keys):
"""
Takes a row and checks to make sure it fits in the columns of the
current table. If it does not fit, adds the required columns.
"""
new_columns = []
for column_name, column_value in list(row.items()):
new_column = sqlalchemy.Column(column_name,
get_column_type(column_value))
if not column_name in list(_State.table.columns.keys()):
new_columns.append(new_column)
_State.table.append_column(new_column)
if _State.table_pending:
create_table(unique_keys)
return
for new_column in new_columns:
add_column(connection, new_column) | [
"def",
"fit_row",
"(",
"connection",
",",
"row",
",",
"unique_keys",
")",
":",
"new_columns",
"=",
"[",
"]",
"for",
"column_name",
",",
"column_value",
"in",
"list",
"(",
"row",
".",
"items",
"(",
")",
")",
":",
"new_column",
"=",
"sqlalchemy",
".",
"C... | Takes a row and checks to make sure it fits in the columns of the
current table. If it does not fit, adds the required columns. | [
"Takes",
"a",
"row",
"and",
"checks",
"to",
"make",
"sure",
"it",
"fits",
"in",
"the",
"columns",
"of",
"the",
"current",
"table",
".",
"If",
"it",
"does",
"not",
"fit",
"adds",
"the",
"required",
"columns",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L338-L357 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | create_table | def create_table(unique_keys):
"""
Save the table currently waiting to be created.
"""
_State.new_transaction()
_State.table.create(bind=_State.engine, checkfirst=True)
if unique_keys != []:
create_index(unique_keys, unique=True)
_State.table_pending = False
_State.reflect_metadata() | python | def create_table(unique_keys):
"""
Save the table currently waiting to be created.
"""
_State.new_transaction()
_State.table.create(bind=_State.engine, checkfirst=True)
if unique_keys != []:
create_index(unique_keys, unique=True)
_State.table_pending = False
_State.reflect_metadata() | [
"def",
"create_table",
"(",
"unique_keys",
")",
":",
"_State",
".",
"new_transaction",
"(",
")",
"_State",
".",
"table",
".",
"create",
"(",
"bind",
"=",
"_State",
".",
"engine",
",",
"checkfirst",
"=",
"True",
")",
"if",
"unique_keys",
"!=",
"[",
"]",
... | Save the table currently waiting to be created. | [
"Save",
"the",
"table",
"currently",
"waiting",
"to",
"be",
"created",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L360-L369 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | add_column | def add_column(connection, column):
"""
Add a column to the current table.
"""
stmt = alembic.ddl.base.AddColumn(_State.table.name, column)
connection.execute(stmt)
_State.reflect_metadata() | python | def add_column(connection, column):
"""
Add a column to the current table.
"""
stmt = alembic.ddl.base.AddColumn(_State.table.name, column)
connection.execute(stmt)
_State.reflect_metadata() | [
"def",
"add_column",
"(",
"connection",
",",
"column",
")",
":",
"stmt",
"=",
"alembic",
".",
"ddl",
".",
"base",
".",
"AddColumn",
"(",
"_State",
".",
"table",
".",
"name",
",",
"column",
")",
"connection",
".",
"execute",
"(",
"stmt",
")",
"_State",
... | Add a column to the current table. | [
"Add",
"a",
"column",
"to",
"the",
"current",
"table",
"."
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L372-L378 | train |
scraperwiki/scraperwiki-python | scraperwiki/sql.py | drop | def drop():
"""
Drop the current table if it exists
"""
# Ensure the connection is up
_State.connection()
_State.table.drop(checkfirst=True)
_State.metadata.remove(_State.table)
_State.table = None
_State.new_transaction() | python | def drop():
"""
Drop the current table if it exists
"""
# Ensure the connection is up
_State.connection()
_State.table.drop(checkfirst=True)
_State.metadata.remove(_State.table)
_State.table = None
_State.new_transaction() | [
"def",
"drop",
"(",
")",
":",
"# Ensure the connection is up",
"_State",
".",
"connection",
"(",
")",
"_State",
".",
"table",
".",
"drop",
"(",
"checkfirst",
"=",
"True",
")",
"_State",
".",
"metadata",
".",
"remove",
"(",
"_State",
".",
"table",
")",
"_... | Drop the current table if it exists | [
"Drop",
"the",
"current",
"table",
"if",
"it",
"exists"
] | 75f77e27071ba667df93e740b61bbb0383ba0843 | https://github.com/scraperwiki/scraperwiki-python/blob/75f77e27071ba667df93e740b61bbb0383ba0843/scraperwiki/sql.py#L394-L403 | train |
tomduck/pandoc-tablenos | pandoc_tablenos.py | attach_attrs_table | def attach_attrs_table(key, value, fmt, meta):
"""Extracts attributes and attaches them to element."""
# We can't use attach_attrs_factory() because Table is a block-level element
if key in ['Table']:
assert len(value) == 5
caption = value[0] # caption, align, x, head, body
# Set n to the index where the attributes start
n = 0
while n < len(caption) and not \
(caption[n]['t'] == 'Str' and caption[n]['c'].startswith('{')):
n += 1
try:
attrs = extract_attrs(caption, n)
value.insert(0, attrs)
except (ValueError, IndexError):
pass | python | def attach_attrs_table(key, value, fmt, meta):
"""Extracts attributes and attaches them to element."""
# We can't use attach_attrs_factory() because Table is a block-level element
if key in ['Table']:
assert len(value) == 5
caption = value[0] # caption, align, x, head, body
# Set n to the index where the attributes start
n = 0
while n < len(caption) and not \
(caption[n]['t'] == 'Str' and caption[n]['c'].startswith('{')):
n += 1
try:
attrs = extract_attrs(caption, n)
value.insert(0, attrs)
except (ValueError, IndexError):
pass | [
"def",
"attach_attrs_table",
"(",
"key",
",",
"value",
",",
"fmt",
",",
"meta",
")",
":",
"# We can't use attach_attrs_factory() because Table is a block-level element",
"if",
"key",
"in",
"[",
"'Table'",
"]",
":",
"assert",
"len",
"(",
"value",
")",
"==",
"5",
... | Extracts attributes and attaches them to element. | [
"Extracts",
"attributes",
"and",
"attaches",
"them",
"to",
"element",
"."
] | b3c7b6a259eec5fb7c8420033d05b32640f1f266 | https://github.com/tomduck/pandoc-tablenos/blob/b3c7b6a259eec5fb7c8420033d05b32640f1f266/pandoc_tablenos.py#L89-L107 | train |
tomduck/pandoc-tablenos | pandoc_tablenos.py | process_tables | def process_tables(key, value, fmt, meta):
"""Processes the attributed tables."""
global has_unnumbered_tables # pylint: disable=global-statement
# Process block-level Table elements
if key == 'Table':
# Inspect the table
if len(value) == 5: # Unattributed, bail out
has_unnumbered_tables = True
if fmt in ['latex']:
return [RawBlock('tex', r'\begin{no-prefix-table-caption}'),
Table(*value),
RawBlock('tex', r'\end{no-prefix-table-caption}')]
return None
# Process the table
table = _process_table(value, fmt)
# Context-dependent output
attrs = table['attrs']
if table['is_unnumbered']:
if fmt in ['latex']:
return [RawBlock('tex', r'\begin{no-prefix-table-caption}'),
AttrTable(*value),
RawBlock('tex', r'\end{no-prefix-table-caption}')]
elif fmt in ['latex']:
if table['is_tagged']: # Code in the tags
tex = '\n'.join([r'\let\oldthetable=\thetable',
r'\renewcommand\thetable{%s}'%\
references[attrs[0]]])
pre = RawBlock('tex', tex)
tex = '\n'.join([r'\let\thetable=\oldthetable',
r'\addtocounter{table}{-1}'])
post = RawBlock('tex', tex)
return [pre, AttrTable(*value), post]
elif table['is_unreferenceable']:
attrs[0] = '' # The label isn't needed any further
elif fmt in ('html', 'html5') and LABEL_PATTERN.match(attrs[0]):
# Insert anchor
anchor = RawBlock('html', '<a name="%s"></a>'%attrs[0])
return [anchor, AttrTable(*value)]
elif fmt == 'docx':
# As per http://officeopenxml.com/WPhyperlink.php
bookmarkstart = \
RawBlock('openxml',
'<w:bookmarkStart w:id="0" w:name="%s"/>'
%attrs[0])
bookmarkend = \
RawBlock('openxml', '<w:bookmarkEnd w:id="0"/>')
return [bookmarkstart, AttrTable(*value), bookmarkend]
return None | python | def process_tables(key, value, fmt, meta):
"""Processes the attributed tables."""
global has_unnumbered_tables # pylint: disable=global-statement
# Process block-level Table elements
if key == 'Table':
# Inspect the table
if len(value) == 5: # Unattributed, bail out
has_unnumbered_tables = True
if fmt in ['latex']:
return [RawBlock('tex', r'\begin{no-prefix-table-caption}'),
Table(*value),
RawBlock('tex', r'\end{no-prefix-table-caption}')]
return None
# Process the table
table = _process_table(value, fmt)
# Context-dependent output
attrs = table['attrs']
if table['is_unnumbered']:
if fmt in ['latex']:
return [RawBlock('tex', r'\begin{no-prefix-table-caption}'),
AttrTable(*value),
RawBlock('tex', r'\end{no-prefix-table-caption}')]
elif fmt in ['latex']:
if table['is_tagged']: # Code in the tags
tex = '\n'.join([r'\let\oldthetable=\thetable',
r'\renewcommand\thetable{%s}'%\
references[attrs[0]]])
pre = RawBlock('tex', tex)
tex = '\n'.join([r'\let\thetable=\oldthetable',
r'\addtocounter{table}{-1}'])
post = RawBlock('tex', tex)
return [pre, AttrTable(*value), post]
elif table['is_unreferenceable']:
attrs[0] = '' # The label isn't needed any further
elif fmt in ('html', 'html5') and LABEL_PATTERN.match(attrs[0]):
# Insert anchor
anchor = RawBlock('html', '<a name="%s"></a>'%attrs[0])
return [anchor, AttrTable(*value)]
elif fmt == 'docx':
# As per http://officeopenxml.com/WPhyperlink.php
bookmarkstart = \
RawBlock('openxml',
'<w:bookmarkStart w:id="0" w:name="%s"/>'
%attrs[0])
bookmarkend = \
RawBlock('openxml', '<w:bookmarkEnd w:id="0"/>')
return [bookmarkstart, AttrTable(*value), bookmarkend]
return None | [
"def",
"process_tables",
"(",
"key",
",",
"value",
",",
"fmt",
",",
"meta",
")",
":",
"global",
"has_unnumbered_tables",
"# pylint: disable=global-statement",
"# Process block-level Table elements",
"if",
"key",
"==",
"'Table'",
":",
"# Inspect the table",
"if",
"len",
... | Processes the attributed tables. | [
"Processes",
"the",
"attributed",
"tables",
"."
] | b3c7b6a259eec5fb7c8420033d05b32640f1f266 | https://github.com/tomduck/pandoc-tablenos/blob/b3c7b6a259eec5fb7c8420033d05b32640f1f266/pandoc_tablenos.py#L195-L249 | train |
tomduck/pandoc-tablenos | pandoc_tablenos.py | main | def main():
"""Filters the document AST."""
# pylint: disable=global-statement
global PANDOCVERSION
global AttrTable
# Get the output format and document
fmt = args.fmt
doc = json.loads(STDIN.read())
# Initialize pandocxnos
# pylint: disable=too-many-function-args
PANDOCVERSION = pandocxnos.init(args.pandocversion, doc)
# Element primitives
AttrTable = elt('Table', 6)
# Chop up the doc
meta = doc['meta'] if PANDOCVERSION >= '1.18' else doc[0]['unMeta']
blocks = doc['blocks'] if PANDOCVERSION >= '1.18' else doc[1:]
# Process the metadata variables
process(meta)
# First pass
detach_attrs_table = detach_attrs_factory(Table)
insert_secnos = insert_secnos_factory(Table)
delete_secnos = delete_secnos_factory(Table)
altered = functools.reduce(lambda x, action: walk(x, action, fmt, meta),
[attach_attrs_table, insert_secnos,
process_tables, delete_secnos,
detach_attrs_table], blocks)
# Second pass
process_refs = process_refs_factory(references.keys())
replace_refs = replace_refs_factory(references,
use_cleveref_default, False,
plusname if not capitalize else
[name.title() for name in plusname],
starname, 'table')
altered = functools.reduce(lambda x, action: walk(x, action, fmt, meta),
[repair_refs, process_refs, replace_refs],
altered)
# Insert supporting TeX
if fmt in ['latex']:
rawblocks = []
if has_unnumbered_tables:
rawblocks += [RawBlock('tex', TEX0),
RawBlock('tex', TEX1),
RawBlock('tex', TEX2)]
if captionname != 'Table':
rawblocks += [RawBlock('tex', TEX3 % captionname)]
insert_rawblocks = insert_rawblocks_factory(rawblocks)
altered = functools.reduce(lambda x, action: walk(x, action, fmt, meta),
[insert_rawblocks], altered)
# Update the doc
if PANDOCVERSION >= '1.18':
doc['blocks'] = altered
else:
doc = doc[:1] + altered
# Dump the results
json.dump(doc, STDOUT)
# Flush stdout
STDOUT.flush() | python | def main():
"""Filters the document AST."""
# pylint: disable=global-statement
global PANDOCVERSION
global AttrTable
# Get the output format and document
fmt = args.fmt
doc = json.loads(STDIN.read())
# Initialize pandocxnos
# pylint: disable=too-many-function-args
PANDOCVERSION = pandocxnos.init(args.pandocversion, doc)
# Element primitives
AttrTable = elt('Table', 6)
# Chop up the doc
meta = doc['meta'] if PANDOCVERSION >= '1.18' else doc[0]['unMeta']
blocks = doc['blocks'] if PANDOCVERSION >= '1.18' else doc[1:]
# Process the metadata variables
process(meta)
# First pass
detach_attrs_table = detach_attrs_factory(Table)
insert_secnos = insert_secnos_factory(Table)
delete_secnos = delete_secnos_factory(Table)
altered = functools.reduce(lambda x, action: walk(x, action, fmt, meta),
[attach_attrs_table, insert_secnos,
process_tables, delete_secnos,
detach_attrs_table], blocks)
# Second pass
process_refs = process_refs_factory(references.keys())
replace_refs = replace_refs_factory(references,
use_cleveref_default, False,
plusname if not capitalize else
[name.title() for name in plusname],
starname, 'table')
altered = functools.reduce(lambda x, action: walk(x, action, fmt, meta),
[repair_refs, process_refs, replace_refs],
altered)
# Insert supporting TeX
if fmt in ['latex']:
rawblocks = []
if has_unnumbered_tables:
rawblocks += [RawBlock('tex', TEX0),
RawBlock('tex', TEX1),
RawBlock('tex', TEX2)]
if captionname != 'Table':
rawblocks += [RawBlock('tex', TEX3 % captionname)]
insert_rawblocks = insert_rawblocks_factory(rawblocks)
altered = functools.reduce(lambda x, action: walk(x, action, fmt, meta),
[insert_rawblocks], altered)
# Update the doc
if PANDOCVERSION >= '1.18':
doc['blocks'] = altered
else:
doc = doc[:1] + altered
# Dump the results
json.dump(doc, STDOUT)
# Flush stdout
STDOUT.flush() | [
"def",
"main",
"(",
")",
":",
"# pylint: disable=global-statement",
"global",
"PANDOCVERSION",
"global",
"AttrTable",
"# Get the output format and document",
"fmt",
"=",
"args",
".",
"fmt",
"doc",
"=",
"json",
".",
"loads",
"(",
"STDIN",
".",
"read",
"(",
")",
"... | Filters the document AST. | [
"Filters",
"the",
"document",
"AST",
"."
] | b3c7b6a259eec5fb7c8420033d05b32640f1f266 | https://github.com/tomduck/pandoc-tablenos/blob/b3c7b6a259eec5fb7c8420033d05b32640f1f266/pandoc_tablenos.py#L368-L441 | train |
mediaburst/clockwork-python | clockwork/clockwork_http.py | request | def request(url, xml):
"""Make a http request to clockwork, using the XML provided
Sets sensible headers for the request.
If there is a problem with the http connection a clockwork_exceptions.HttpException is raised
"""
r = _urllib.Request(url, xml)
r.add_header('Content-Type', 'application/xml')
r.add_header('User-Agent', 'Clockwork Python wrapper/1.0')
result = {}
try:
f = _urllib.urlopen(r)
except URLError as error:
raise clockwork_exceptions.HttpException("Error connecting to clockwork server: %s" % error)
result['data'] = f.read()
result['status'] = f.getcode()
if hasattr(f, 'headers'):
result['etag'] = f.headers.get('ETag')
result['lastmodified'] = f.headers.get('Last-Modified')
if f.headers.get('content−encoding', '') == 'gzip':
result['data'] = gzip.GzipFile(fileobj=StringIO(result['data'])).read()
if hasattr(f, 'url'):
result['url'] = f.url
result['status'] = 200
f.close()
if result['status'] != 200:
raise clockwork_exceptions.HttpException("Error connecting to clockwork server - status code %s" % result['status'])
return result | python | def request(url, xml):
"""Make a http request to clockwork, using the XML provided
Sets sensible headers for the request.
If there is a problem with the http connection a clockwork_exceptions.HttpException is raised
"""
r = _urllib.Request(url, xml)
r.add_header('Content-Type', 'application/xml')
r.add_header('User-Agent', 'Clockwork Python wrapper/1.0')
result = {}
try:
f = _urllib.urlopen(r)
except URLError as error:
raise clockwork_exceptions.HttpException("Error connecting to clockwork server: %s" % error)
result['data'] = f.read()
result['status'] = f.getcode()
if hasattr(f, 'headers'):
result['etag'] = f.headers.get('ETag')
result['lastmodified'] = f.headers.get('Last-Modified')
if f.headers.get('content−encoding', '') == 'gzip':
result['data'] = gzip.GzipFile(fileobj=StringIO(result['data'])).read()
if hasattr(f, 'url'):
result['url'] = f.url
result['status'] = 200
f.close()
if result['status'] != 200:
raise clockwork_exceptions.HttpException("Error connecting to clockwork server - status code %s" % result['status'])
return result | [
"def",
"request",
"(",
"url",
",",
"xml",
")",
":",
"r",
"=",
"_urllib",
".",
"Request",
"(",
"url",
",",
"xml",
")",
"r",
".",
"add_header",
"(",
"'Content-Type'",
",",
"'application/xml'",
")",
"r",
".",
"add_header",
"(",
"'User-Agent'",
",",
"'Cloc... | Make a http request to clockwork, using the XML provided
Sets sensible headers for the request.
If there is a problem with the http connection a clockwork_exceptions.HttpException is raised | [
"Make",
"a",
"http",
"request",
"to",
"clockwork",
"using",
"the",
"XML",
"provided",
"Sets",
"sensible",
"headers",
"for",
"the",
"request",
".",
"If",
"there",
"is",
"a",
"problem",
"with",
"the",
"http",
"connection",
"a",
"clockwork_exceptions",
".",
"Ht... | 7f8368bbed1fcb5218584fbc5094d93c6aa365d1 | https://github.com/mediaburst/clockwork-python/blob/7f8368bbed1fcb5218584fbc5094d93c6aa365d1/clockwork/clockwork_http.py#L11-L44 | train |
mediaburst/clockwork-python | clockwork/clockwork.py | API.get_balance | def get_balance(self):
"""Check the balance fot this account.
Returns a dictionary containing:
account_type: The account type
balance: The balance remaining on the account
currency: The currency used for the account balance. Assume GBP in not set"""
xml_root = self.__init_xml('Balance')
response = clockwork_http.request(BALANCE_URL, etree.tostring(xml_root, encoding='utf-8'))
data_etree = etree.fromstring(response['data'])
err_desc = data_etree.find('ErrDesc')
if err_desc is not None:
raise clockwork_exceptions.ApiException(err_desc.text, data_etree.find('ErrNo').text)
result = {}
result['account_type'] = data_etree.find('AccountType').text
result['balance'] = data_etree.find('Balance').text
result['currency'] = data_etree.find('Currency').text
return result | python | def get_balance(self):
"""Check the balance fot this account.
Returns a dictionary containing:
account_type: The account type
balance: The balance remaining on the account
currency: The currency used for the account balance. Assume GBP in not set"""
xml_root = self.__init_xml('Balance')
response = clockwork_http.request(BALANCE_URL, etree.tostring(xml_root, encoding='utf-8'))
data_etree = etree.fromstring(response['data'])
err_desc = data_etree.find('ErrDesc')
if err_desc is not None:
raise clockwork_exceptions.ApiException(err_desc.text, data_etree.find('ErrNo').text)
result = {}
result['account_type'] = data_etree.find('AccountType').text
result['balance'] = data_etree.find('Balance').text
result['currency'] = data_etree.find('Currency').text
return result | [
"def",
"get_balance",
"(",
"self",
")",
":",
"xml_root",
"=",
"self",
".",
"__init_xml",
"(",
"'Balance'",
")",
"response",
"=",
"clockwork_http",
".",
"request",
"(",
"BALANCE_URL",
",",
"etree",
".",
"tostring",
"(",
"xml_root",
",",
"encoding",
"=",
"'u... | Check the balance fot this account.
Returns a dictionary containing:
account_type: The account type
balance: The balance remaining on the account
currency: The currency used for the account balance. Assume GBP in not set | [
"Check",
"the",
"balance",
"fot",
"this",
"account",
".",
"Returns",
"a",
"dictionary",
"containing",
":",
"account_type",
":",
"The",
"account",
"type",
"balance",
":",
"The",
"balance",
"remaining",
"on",
"the",
"account",
"currency",
":",
"The",
"currency",... | 7f8368bbed1fcb5218584fbc5094d93c6aa365d1 | https://github.com/mediaburst/clockwork-python/blob/7f8368bbed1fcb5218584fbc5094d93c6aa365d1/clockwork/clockwork.py#L47-L67 | train |
mediaburst/clockwork-python | clockwork/clockwork.py | API.send | def send(self, messages):
"""Send a SMS message, or an array of SMS messages"""
tmpSms = SMS(to='', message='')
if str(type(messages)) == str(type(tmpSms)):
messages = [messages]
xml_root = self.__init_xml('Message')
wrapper_id = 0
for m in messages:
m.wrapper_id = wrapper_id
msg = self.__build_sms_data(m)
sms = etree.SubElement(xml_root, 'SMS')
for sms_element in msg:
element = etree.SubElement(sms, sms_element)
element.text = msg[sms_element]
# print etree.tostring(xml_root)
response = clockwork_http.request(SMS_URL, etree.tostring(xml_root, encoding='utf-8'))
response_data = response['data']
# print response_data
data_etree = etree.fromstring(response_data)
# Check for general error
err_desc = data_etree.find('ErrDesc')
if err_desc is not None:
raise clockwork_exceptions.ApiException(err_desc.text, data_etree.find('ErrNo').text)
# Return a consistent object
results = []
for sms in data_etree:
matching_sms = next((s for s in messages if str(s.wrapper_id) == sms.find('WrapperID').text), None)
new_result = SMSResponse(
sms = matching_sms,
id = '' if sms.find('MessageID') is None else sms.find('MessageID').text,
error_code = 0 if sms.find('ErrNo') is None else sms.find('ErrNo').text,
error_message = '' if sms.find('ErrDesc') is None else sms.find('ErrDesc').text,
success = True if sms.find('ErrNo') is None else (sms.find('ErrNo').text == 0)
)
results.append(new_result)
if len(results) > 1:
return results
return results[0] | python | def send(self, messages):
"""Send a SMS message, or an array of SMS messages"""
tmpSms = SMS(to='', message='')
if str(type(messages)) == str(type(tmpSms)):
messages = [messages]
xml_root = self.__init_xml('Message')
wrapper_id = 0
for m in messages:
m.wrapper_id = wrapper_id
msg = self.__build_sms_data(m)
sms = etree.SubElement(xml_root, 'SMS')
for sms_element in msg:
element = etree.SubElement(sms, sms_element)
element.text = msg[sms_element]
# print etree.tostring(xml_root)
response = clockwork_http.request(SMS_URL, etree.tostring(xml_root, encoding='utf-8'))
response_data = response['data']
# print response_data
data_etree = etree.fromstring(response_data)
# Check for general error
err_desc = data_etree.find('ErrDesc')
if err_desc is not None:
raise clockwork_exceptions.ApiException(err_desc.text, data_etree.find('ErrNo').text)
# Return a consistent object
results = []
for sms in data_etree:
matching_sms = next((s for s in messages if str(s.wrapper_id) == sms.find('WrapperID').text), None)
new_result = SMSResponse(
sms = matching_sms,
id = '' if sms.find('MessageID') is None else sms.find('MessageID').text,
error_code = 0 if sms.find('ErrNo') is None else sms.find('ErrNo').text,
error_message = '' if sms.find('ErrDesc') is None else sms.find('ErrDesc').text,
success = True if sms.find('ErrNo') is None else (sms.find('ErrNo').text == 0)
)
results.append(new_result)
if len(results) > 1:
return results
return results[0] | [
"def",
"send",
"(",
"self",
",",
"messages",
")",
":",
"tmpSms",
"=",
"SMS",
"(",
"to",
"=",
"''",
",",
"message",
"=",
"''",
")",
"if",
"str",
"(",
"type",
"(",
"messages",
")",
")",
"==",
"str",
"(",
"type",
"(",
"tmpSms",
")",
")",
":",
"m... | Send a SMS message, or an array of SMS messages | [
"Send",
"a",
"SMS",
"message",
"or",
"an",
"array",
"of",
"SMS",
"messages"
] | 7f8368bbed1fcb5218584fbc5094d93c6aa365d1 | https://github.com/mediaburst/clockwork-python/blob/7f8368bbed1fcb5218584fbc5094d93c6aa365d1/clockwork/clockwork.py#L69-L115 | train |
mediaburst/clockwork-python | clockwork/clockwork.py | API.__init_xml | def __init_xml(self, rootElementTag):
"""Init a etree element and pop a key in there"""
xml_root = etree.Element(rootElementTag)
key = etree.SubElement(xml_root, "Key")
key.text = self.apikey
return xml_root | python | def __init_xml(self, rootElementTag):
"""Init a etree element and pop a key in there"""
xml_root = etree.Element(rootElementTag)
key = etree.SubElement(xml_root, "Key")
key.text = self.apikey
return xml_root | [
"def",
"__init_xml",
"(",
"self",
",",
"rootElementTag",
")",
":",
"xml_root",
"=",
"etree",
".",
"Element",
"(",
"rootElementTag",
")",
"key",
"=",
"etree",
".",
"SubElement",
"(",
"xml_root",
",",
"\"Key\"",
")",
"key",
".",
"text",
"=",
"self",
".",
... | Init a etree element and pop a key in there | [
"Init",
"a",
"etree",
"element",
"and",
"pop",
"a",
"key",
"in",
"there"
] | 7f8368bbed1fcb5218584fbc5094d93c6aa365d1 | https://github.com/mediaburst/clockwork-python/blob/7f8368bbed1fcb5218584fbc5094d93c6aa365d1/clockwork/clockwork.py#L117-L122 | train |
mediaburst/clockwork-python | clockwork/clockwork.py | API.__build_sms_data | def __build_sms_data(self, message):
"""Build a dictionary of SMS message elements"""
attributes = {}
attributes_to_translate = {
'to' : 'To',
'message' : 'Content',
'client_id' : 'ClientID',
'concat' : 'Concat',
'from_name': 'From',
'invalid_char_option' : 'InvalidCharOption',
'truncate' : 'Truncate',
'wrapper_id' : 'WrapperId'
}
for attr in attributes_to_translate:
val_to_use = None
if hasattr(message, attr):
val_to_use = getattr(message, attr)
if val_to_use is None and hasattr(self, attr):
val_to_use = getattr(self, attr)
if val_to_use is not None:
attributes[attributes_to_translate[attr]] = str(val_to_use)
return attributes | python | def __build_sms_data(self, message):
"""Build a dictionary of SMS message elements"""
attributes = {}
attributes_to_translate = {
'to' : 'To',
'message' : 'Content',
'client_id' : 'ClientID',
'concat' : 'Concat',
'from_name': 'From',
'invalid_char_option' : 'InvalidCharOption',
'truncate' : 'Truncate',
'wrapper_id' : 'WrapperId'
}
for attr in attributes_to_translate:
val_to_use = None
if hasattr(message, attr):
val_to_use = getattr(message, attr)
if val_to_use is None and hasattr(self, attr):
val_to_use = getattr(self, attr)
if val_to_use is not None:
attributes[attributes_to_translate[attr]] = str(val_to_use)
return attributes | [
"def",
"__build_sms_data",
"(",
"self",
",",
"message",
")",
":",
"attributes",
"=",
"{",
"}",
"attributes_to_translate",
"=",
"{",
"'to'",
":",
"'To'",
",",
"'message'",
":",
"'Content'",
",",
"'client_id'",
":",
"'ClientID'",
",",
"'concat'",
":",
"'Concat... | Build a dictionary of SMS message elements | [
"Build",
"a",
"dictionary",
"of",
"SMS",
"message",
"elements"
] | 7f8368bbed1fcb5218584fbc5094d93c6aa365d1 | https://github.com/mediaburst/clockwork-python/blob/7f8368bbed1fcb5218584fbc5094d93c6aa365d1/clockwork/clockwork.py#L125-L150 | train |
pwaller/pyprof2calltree | pyprof2calltree.py | pstats2entries | def pstats2entries(data):
"""Helper to convert serialized pstats back to a list of raw entries.
Converse operation of cProfile.Profile.snapshot_stats()
"""
# Each entry's key is a tuple of (filename, line number, function name)
entries = {}
allcallers = {}
# first pass over stats to build the list of entry instances
for code_info, call_info in data.stats.items():
# build a fake code object
code = Code(*code_info)
# build a fake entry object. entry.calls will be filled during the
# second pass over stats
cc, nc, tt, ct, callers = call_info
entry = Entry(code, callcount=cc, reccallcount=nc - cc, inlinetime=tt,
totaltime=ct, calls=[])
# collect the new entry
entries[code_info] = entry
allcallers[code_info] = list(callers.items())
# second pass of stats to plug callees into callers
for entry in entries.values():
entry_label = cProfile.label(entry.code)
entry_callers = allcallers.get(entry_label, [])
for entry_caller, call_info in entry_callers:
cc, nc, tt, ct = call_info
subentry = Subentry(entry.code, callcount=cc, reccallcount=nc - cc,
inlinetime=tt, totaltime=ct)
# entry_caller has the same form as code_info
entries[entry_caller].calls.append(subentry)
return list(entries.values()) | python | def pstats2entries(data):
"""Helper to convert serialized pstats back to a list of raw entries.
Converse operation of cProfile.Profile.snapshot_stats()
"""
# Each entry's key is a tuple of (filename, line number, function name)
entries = {}
allcallers = {}
# first pass over stats to build the list of entry instances
for code_info, call_info in data.stats.items():
# build a fake code object
code = Code(*code_info)
# build a fake entry object. entry.calls will be filled during the
# second pass over stats
cc, nc, tt, ct, callers = call_info
entry = Entry(code, callcount=cc, reccallcount=nc - cc, inlinetime=tt,
totaltime=ct, calls=[])
# collect the new entry
entries[code_info] = entry
allcallers[code_info] = list(callers.items())
# second pass of stats to plug callees into callers
for entry in entries.values():
entry_label = cProfile.label(entry.code)
entry_callers = allcallers.get(entry_label, [])
for entry_caller, call_info in entry_callers:
cc, nc, tt, ct = call_info
subentry = Subentry(entry.code, callcount=cc, reccallcount=nc - cc,
inlinetime=tt, totaltime=ct)
# entry_caller has the same form as code_info
entries[entry_caller].calls.append(subentry)
return list(entries.values()) | [
"def",
"pstats2entries",
"(",
"data",
")",
":",
"# Each entry's key is a tuple of (filename, line number, function name)",
"entries",
"=",
"{",
"}",
"allcallers",
"=",
"{",
"}",
"# first pass over stats to build the list of entry instances",
"for",
"code_info",
",",
"call_info"... | Helper to convert serialized pstats back to a list of raw entries.
Converse operation of cProfile.Profile.snapshot_stats() | [
"Helper",
"to",
"convert",
"serialized",
"pstats",
"back",
"to",
"a",
"list",
"of",
"raw",
"entries",
"."
] | 62b99c7b366ad317d3d5e21fb73466c8baea670e | https://github.com/pwaller/pyprof2calltree/blob/62b99c7b366ad317d3d5e21fb73466c8baea670e/pyprof2calltree.py#L106-L141 | train |
pwaller/pyprof2calltree | pyprof2calltree.py | is_installed | def is_installed(prog):
"""Return whether or not a given executable is installed on the machine."""
with open(os.devnull, 'w') as devnull:
try:
if os.name == 'nt':
retcode = subprocess.call(['where', prog], stdout=devnull)
else:
retcode = subprocess.call(['which', prog], stdout=devnull)
except OSError as e:
# If where or which doesn't exist, a "ENOENT" error will occur (The
# FileNotFoundError subclass on Python 3).
if e.errno != errno.ENOENT:
raise
retcode = 1
return retcode == 0 | python | def is_installed(prog):
"""Return whether or not a given executable is installed on the machine."""
with open(os.devnull, 'w') as devnull:
try:
if os.name == 'nt':
retcode = subprocess.call(['where', prog], stdout=devnull)
else:
retcode = subprocess.call(['which', prog], stdout=devnull)
except OSError as e:
# If where or which doesn't exist, a "ENOENT" error will occur (The
# FileNotFoundError subclass on Python 3).
if e.errno != errno.ENOENT:
raise
retcode = 1
return retcode == 0 | [
"def",
"is_installed",
"(",
"prog",
")",
":",
"with",
"open",
"(",
"os",
".",
"devnull",
",",
"'w'",
")",
"as",
"devnull",
":",
"try",
":",
"if",
"os",
".",
"name",
"==",
"'nt'",
":",
"retcode",
"=",
"subprocess",
".",
"call",
"(",
"[",
"'where'",
... | Return whether or not a given executable is installed on the machine. | [
"Return",
"whether",
"or",
"not",
"a",
"given",
"executable",
"is",
"installed",
"on",
"the",
"machine",
"."
] | 62b99c7b366ad317d3d5e21fb73466c8baea670e | https://github.com/pwaller/pyprof2calltree/blob/62b99c7b366ad317d3d5e21fb73466c8baea670e/pyprof2calltree.py#L144-L159 | train |
pwaller/pyprof2calltree | pyprof2calltree.py | main | def main():
"""Execute the converter using parameters provided on the command line"""
parser = argparse.ArgumentParser()
parser.add_argument('-o', '--outfile', metavar='output_file_path',
help="Save calltree stats to <outfile>")
parser.add_argument('-i', '--infile', metavar='input_file_path',
help="Read Python stats from <infile>")
parser.add_argument('-k', '--kcachegrind',
help="Run the kcachegrind tool on the converted data",
action="store_true")
parser.add_argument('-r', '--run-script',
nargs=argparse.REMAINDER,
metavar=('scriptfile', 'args'),
dest='script',
help="Name of the Python script to run to collect"
" profiling data")
args = parser.parse_args()
outfile = args.outfile
if args.script is not None:
# collect profiling data by running the given script
if not args.outfile:
outfile = '%s.log' % os.path.basename(args.script[0])
fd, tmp_path = tempfile.mkstemp(suffix='.prof', prefix='pyprof2calltree')
os.close(fd)
try:
cmd = [
sys.executable,
'-m', 'cProfile',
'-o', tmp_path,
]
cmd.extend(args.script)
subprocess.check_call(cmd)
kg = CalltreeConverter(tmp_path)
finally:
os.remove(tmp_path)
elif args.infile is not None:
# use the profiling data from some input file
if not args.outfile:
outfile = '%s.log' % os.path.basename(args.infile)
if args.infile == outfile:
# prevent name collisions by appending another extension
outfile += ".log"
kg = CalltreeConverter(pstats.Stats(args.infile))
else:
# at least an input file or a script to run is required
parser.print_usage()
sys.exit(2)
if args.outfile is not None or not args.kcachegrind:
# user either explicitly required output file or requested by not
# explicitly asking to launch kcachegrind
sys.stderr.write("writing converted data to: %s\n" % outfile)
with open(outfile, 'w') as f:
kg.output(f)
if args.kcachegrind:
sys.stderr.write("launching kcachegrind\n")
kg.visualize() | python | def main():
"""Execute the converter using parameters provided on the command line"""
parser = argparse.ArgumentParser()
parser.add_argument('-o', '--outfile', metavar='output_file_path',
help="Save calltree stats to <outfile>")
parser.add_argument('-i', '--infile', metavar='input_file_path',
help="Read Python stats from <infile>")
parser.add_argument('-k', '--kcachegrind',
help="Run the kcachegrind tool on the converted data",
action="store_true")
parser.add_argument('-r', '--run-script',
nargs=argparse.REMAINDER,
metavar=('scriptfile', 'args'),
dest='script',
help="Name of the Python script to run to collect"
" profiling data")
args = parser.parse_args()
outfile = args.outfile
if args.script is not None:
# collect profiling data by running the given script
if not args.outfile:
outfile = '%s.log' % os.path.basename(args.script[0])
fd, tmp_path = tempfile.mkstemp(suffix='.prof', prefix='pyprof2calltree')
os.close(fd)
try:
cmd = [
sys.executable,
'-m', 'cProfile',
'-o', tmp_path,
]
cmd.extend(args.script)
subprocess.check_call(cmd)
kg = CalltreeConverter(tmp_path)
finally:
os.remove(tmp_path)
elif args.infile is not None:
# use the profiling data from some input file
if not args.outfile:
outfile = '%s.log' % os.path.basename(args.infile)
if args.infile == outfile:
# prevent name collisions by appending another extension
outfile += ".log"
kg = CalltreeConverter(pstats.Stats(args.infile))
else:
# at least an input file or a script to run is required
parser.print_usage()
sys.exit(2)
if args.outfile is not None or not args.kcachegrind:
# user either explicitly required output file or requested by not
# explicitly asking to launch kcachegrind
sys.stderr.write("writing converted data to: %s\n" % outfile)
with open(outfile, 'w') as f:
kg.output(f)
if args.kcachegrind:
sys.stderr.write("launching kcachegrind\n")
kg.visualize() | [
"def",
"main",
"(",
")",
":",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
")",
"parser",
".",
"add_argument",
"(",
"'-o'",
",",
"'--outfile'",
",",
"metavar",
"=",
"'output_file_path'",
",",
"help",
"=",
"\"Save calltree stats to <outfile>\"",
")",
... | Execute the converter using parameters provided on the command line | [
"Execute",
"the",
"converter",
"using",
"parameters",
"provided",
"on",
"the",
"command",
"line"
] | 62b99c7b366ad317d3d5e21fb73466c8baea670e | https://github.com/pwaller/pyprof2calltree/blob/62b99c7b366ad317d3d5e21fb73466c8baea670e/pyprof2calltree.py#L289-L355 | train |
pwaller/pyprof2calltree | pyprof2calltree.py | convert | def convert(profiling_data, outputfile):
"""convert `profiling_data` to calltree format and dump it to `outputfile`
`profiling_data` can either be:
- a pstats.Stats instance
- the filename of a pstats.Stats dump
- the result of a call to cProfile.Profile.getstats()
`outputfile` can either be:
- a file() instance open in write mode
- a filename
"""
converter = CalltreeConverter(profiling_data)
if is_basestring(outputfile):
with open(outputfile, "w") as f:
converter.output(f)
else:
converter.output(outputfile) | python | def convert(profiling_data, outputfile):
"""convert `profiling_data` to calltree format and dump it to `outputfile`
`profiling_data` can either be:
- a pstats.Stats instance
- the filename of a pstats.Stats dump
- the result of a call to cProfile.Profile.getstats()
`outputfile` can either be:
- a file() instance open in write mode
- a filename
"""
converter = CalltreeConverter(profiling_data)
if is_basestring(outputfile):
with open(outputfile, "w") as f:
converter.output(f)
else:
converter.output(outputfile) | [
"def",
"convert",
"(",
"profiling_data",
",",
"outputfile",
")",
":",
"converter",
"=",
"CalltreeConverter",
"(",
"profiling_data",
")",
"if",
"is_basestring",
"(",
"outputfile",
")",
":",
"with",
"open",
"(",
"outputfile",
",",
"\"w\"",
")",
"as",
"f",
":",... | convert `profiling_data` to calltree format and dump it to `outputfile`
`profiling_data` can either be:
- a pstats.Stats instance
- the filename of a pstats.Stats dump
- the result of a call to cProfile.Profile.getstats()
`outputfile` can either be:
- a file() instance open in write mode
- a filename | [
"convert",
"profiling_data",
"to",
"calltree",
"format",
"and",
"dump",
"it",
"to",
"outputfile"
] | 62b99c7b366ad317d3d5e21fb73466c8baea670e | https://github.com/pwaller/pyprof2calltree/blob/62b99c7b366ad317d3d5e21fb73466c8baea670e/pyprof2calltree.py#L370-L387 | train |
pwaller/pyprof2calltree | pyprof2calltree.py | CalltreeConverter.output | def output(self, out_file):
"""Write the converted entries to out_file"""
self.out_file = out_file
out_file.write('event: ns : Nanoseconds\n')
out_file.write('events: ns\n')
self._output_summary()
for entry in sorted(self.entries, key=_entry_sort_key):
self._output_entry(entry) | python | def output(self, out_file):
"""Write the converted entries to out_file"""
self.out_file = out_file
out_file.write('event: ns : Nanoseconds\n')
out_file.write('events: ns\n')
self._output_summary()
for entry in sorted(self.entries, key=_entry_sort_key):
self._output_entry(entry) | [
"def",
"output",
"(",
"self",
",",
"out_file",
")",
":",
"self",
".",
"out_file",
"=",
"out_file",
"out_file",
".",
"write",
"(",
"'event: ns : Nanoseconds\\n'",
")",
"out_file",
".",
"write",
"(",
"'events: ns\\n'",
")",
"self",
".",
"_output_summary",
"(",
... | Write the converted entries to out_file | [
"Write",
"the",
"converted",
"entries",
"to",
"out_file"
] | 62b99c7b366ad317d3d5e21fb73466c8baea670e | https://github.com/pwaller/pyprof2calltree/blob/62b99c7b366ad317d3d5e21fb73466c8baea670e/pyprof2calltree.py#L204-L211 | train |
pwaller/pyprof2calltree | pyprof2calltree.py | CalltreeConverter.visualize | def visualize(self):
"""Launch kcachegrind on the converted entries.
One of the executables listed in KCACHEGRIND_EXECUTABLES
must be present in the system path.
"""
available_cmd = None
for cmd in KCACHEGRIND_EXECUTABLES:
if is_installed(cmd):
available_cmd = cmd
break
if available_cmd is None:
sys.stderr.write("Could not find kcachegrind. Tried: %s\n" %
", ".join(KCACHEGRIND_EXECUTABLES))
return
if self.out_file is None:
fd, outfile = tempfile.mkstemp(".log", "pyprof2calltree")
use_temp_file = True
else:
outfile = self.out_file.name
use_temp_file = False
try:
if use_temp_file:
with io.open(fd, "w") as f:
self.output(f)
subprocess.call([available_cmd, outfile])
finally:
# clean the temporary file
if use_temp_file:
os.remove(outfile)
self.out_file = None | python | def visualize(self):
"""Launch kcachegrind on the converted entries.
One of the executables listed in KCACHEGRIND_EXECUTABLES
must be present in the system path.
"""
available_cmd = None
for cmd in KCACHEGRIND_EXECUTABLES:
if is_installed(cmd):
available_cmd = cmd
break
if available_cmd is None:
sys.stderr.write("Could not find kcachegrind. Tried: %s\n" %
", ".join(KCACHEGRIND_EXECUTABLES))
return
if self.out_file is None:
fd, outfile = tempfile.mkstemp(".log", "pyprof2calltree")
use_temp_file = True
else:
outfile = self.out_file.name
use_temp_file = False
try:
if use_temp_file:
with io.open(fd, "w") as f:
self.output(f)
subprocess.call([available_cmd, outfile])
finally:
# clean the temporary file
if use_temp_file:
os.remove(outfile)
self.out_file = None | [
"def",
"visualize",
"(",
"self",
")",
":",
"available_cmd",
"=",
"None",
"for",
"cmd",
"in",
"KCACHEGRIND_EXECUTABLES",
":",
"if",
"is_installed",
"(",
"cmd",
")",
":",
"available_cmd",
"=",
"cmd",
"break",
"if",
"available_cmd",
"is",
"None",
":",
"sys",
... | Launch kcachegrind on the converted entries.
One of the executables listed in KCACHEGRIND_EXECUTABLES
must be present in the system path. | [
"Launch",
"kcachegrind",
"on",
"the",
"converted",
"entries",
"."
] | 62b99c7b366ad317d3d5e21fb73466c8baea670e | https://github.com/pwaller/pyprof2calltree/blob/62b99c7b366ad317d3d5e21fb73466c8baea670e/pyprof2calltree.py#L213-L247 | train |
bouncer-app/flask-bouncer | flask_bouncer.py | Bouncer.get_app | def get_app(self, reference_app=None):
"""Helper method that implements the logic to look up an application."""
if reference_app is not None:
return reference_app
if self.app is not None:
return self.app
ctx = stack.top
if ctx is not None:
return ctx.app
raise RuntimeError('Application not registered on Bouncer'
' instance and no application bound'
' to current context') | python | def get_app(self, reference_app=None):
"""Helper method that implements the logic to look up an application."""
if reference_app is not None:
return reference_app
if self.app is not None:
return self.app
ctx = stack.top
if ctx is not None:
return ctx.app
raise RuntimeError('Application not registered on Bouncer'
' instance and no application bound'
' to current context') | [
"def",
"get_app",
"(",
"self",
",",
"reference_app",
"=",
"None",
")",
":",
"if",
"reference_app",
"is",
"not",
"None",
":",
"return",
"reference_app",
"if",
"self",
".",
"app",
"is",
"not",
"None",
":",
"return",
"self",
".",
"app",
"ctx",
"=",
"stack... | Helper method that implements the logic to look up an application. | [
"Helper",
"method",
"that",
"implements",
"the",
"logic",
"to",
"look",
"up",
"an",
"application",
"."
] | 41a8763520cca7d7ff1b247ab6eb3383281f5ab7 | https://github.com/bouncer-app/flask-bouncer/blob/41a8763520cca7d7ff1b247ab6eb3383281f5ab7/flask_bouncer.py#L80-L96 | train |
bouncer-app/flask-bouncer | flask_bouncer.py | Bouncer.init_app | def init_app(self, app, **kwargs):
""" Initializes the Flask-Bouncer extension for the specified application.
:param app: The application.
"""
self.app = app
self._init_extension()
self.app.before_request(self.check_implicit_rules)
if kwargs.get('ensure_authorization', False):
self.app.after_request(self.check_authorization) | python | def init_app(self, app, **kwargs):
""" Initializes the Flask-Bouncer extension for the specified application.
:param app: The application.
"""
self.app = app
self._init_extension()
self.app.before_request(self.check_implicit_rules)
if kwargs.get('ensure_authorization', False):
self.app.after_request(self.check_authorization) | [
"def",
"init_app",
"(",
"self",
",",
"app",
",",
"*",
"*",
"kwargs",
")",
":",
"self",
".",
"app",
"=",
"app",
"self",
".",
"_init_extension",
"(",
")",
"self",
".",
"app",
".",
"before_request",
"(",
"self",
".",
"check_implicit_rules",
")",
"if",
"... | Initializes the Flask-Bouncer extension for the specified application.
:param app: The application. | [
"Initializes",
"the",
"Flask",
"-",
"Bouncer",
"extension",
"for",
"the",
"specified",
"application",
"."
] | 41a8763520cca7d7ff1b247ab6eb3383281f5ab7 | https://github.com/bouncer-app/flask-bouncer/blob/41a8763520cca7d7ff1b247ab6eb3383281f5ab7/flask_bouncer.py#L98-L110 | train |
bouncer-app/flask-bouncer | flask_bouncer.py | Bouncer.check_authorization | def check_authorization(self, response):
"""checks that an authorization call has been made during the request"""
if not hasattr(request, '_authorized'):
raise Unauthorized
elif not request._authorized:
raise Unauthorized
return response | python | def check_authorization(self, response):
"""checks that an authorization call has been made during the request"""
if not hasattr(request, '_authorized'):
raise Unauthorized
elif not request._authorized:
raise Unauthorized
return response | [
"def",
"check_authorization",
"(",
"self",
",",
"response",
")",
":",
"if",
"not",
"hasattr",
"(",
"request",
",",
"'_authorized'",
")",
":",
"raise",
"Unauthorized",
"elif",
"not",
"request",
".",
"_authorized",
":",
"raise",
"Unauthorized",
"return",
"respon... | checks that an authorization call has been made during the request | [
"checks",
"that",
"an",
"authorization",
"call",
"has",
"been",
"made",
"during",
"the",
"request"
] | 41a8763520cca7d7ff1b247ab6eb3383281f5ab7 | https://github.com/bouncer-app/flask-bouncer/blob/41a8763520cca7d7ff1b247ab6eb3383281f5ab7/flask_bouncer.py#L118-L124 | train |
bouncer-app/flask-bouncer | flask_bouncer.py | Bouncer.check_implicit_rules | def check_implicit_rules(self):
""" if you are using flask classy are using the standard index,new,put,post, etc ... type routes, we will
automatically check the permissions for you
"""
if not self.request_is_managed_by_flask_classy():
return
if self.method_is_explictly_overwritten():
return
class_name, action = request.endpoint.split(':')
clazz = [classy_class for classy_class in self.flask_classy_classes if classy_class.__name__ == class_name][0]
Condition(action, clazz.__target_model__).test() | python | def check_implicit_rules(self):
""" if you are using flask classy are using the standard index,new,put,post, etc ... type routes, we will
automatically check the permissions for you
"""
if not self.request_is_managed_by_flask_classy():
return
if self.method_is_explictly_overwritten():
return
class_name, action = request.endpoint.split(':')
clazz = [classy_class for classy_class in self.flask_classy_classes if classy_class.__name__ == class_name][0]
Condition(action, clazz.__target_model__).test() | [
"def",
"check_implicit_rules",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"request_is_managed_by_flask_classy",
"(",
")",
":",
"return",
"if",
"self",
".",
"method_is_explictly_overwritten",
"(",
")",
":",
"return",
"class_name",
",",
"action",
"=",
"reque... | if you are using flask classy are using the standard index,new,put,post, etc ... type routes, we will
automatically check the permissions for you | [
"if",
"you",
"are",
"using",
"flask",
"classy",
"are",
"using",
"the",
"standard",
"index",
"new",
"put",
"post",
"etc",
"...",
"type",
"routes",
"we",
"will",
"automatically",
"check",
"the",
"permissions",
"for",
"you"
] | 41a8763520cca7d7ff1b247ab6eb3383281f5ab7 | https://github.com/bouncer-app/flask-bouncer/blob/41a8763520cca7d7ff1b247ab6eb3383281f5ab7/flask_bouncer.py#L126-L138 | train |
paulgb/penkit | penkit/textures/util.py | rotate_texture | def rotate_texture(texture, rotation, x_offset=0.5, y_offset=0.5):
"""Rotates the given texture by a given angle.
Args:
texture (texture): the texture to rotate
rotation (float): the angle of rotation in degrees
x_offset (float): the x component of the center of rotation (optional)
y_offset (float): the y component of the center of rotation (optional)
Returns:
texture: A texture.
"""
x, y = texture
x = x.copy() - x_offset
y = y.copy() - y_offset
angle = np.radians(rotation)
x_rot = x * np.cos(angle) + y * np.sin(angle)
y_rot = x * -np.sin(angle) + y * np.cos(angle)
return x_rot + x_offset, y_rot + y_offset | python | def rotate_texture(texture, rotation, x_offset=0.5, y_offset=0.5):
"""Rotates the given texture by a given angle.
Args:
texture (texture): the texture to rotate
rotation (float): the angle of rotation in degrees
x_offset (float): the x component of the center of rotation (optional)
y_offset (float): the y component of the center of rotation (optional)
Returns:
texture: A texture.
"""
x, y = texture
x = x.copy() - x_offset
y = y.copy() - y_offset
angle = np.radians(rotation)
x_rot = x * np.cos(angle) + y * np.sin(angle)
y_rot = x * -np.sin(angle) + y * np.cos(angle)
return x_rot + x_offset, y_rot + y_offset | [
"def",
"rotate_texture",
"(",
"texture",
",",
"rotation",
",",
"x_offset",
"=",
"0.5",
",",
"y_offset",
"=",
"0.5",
")",
":",
"x",
",",
"y",
"=",
"texture",
"x",
"=",
"x",
".",
"copy",
"(",
")",
"-",
"x_offset",
"y",
"=",
"y",
".",
"copy",
"(",
... | Rotates the given texture by a given angle.
Args:
texture (texture): the texture to rotate
rotation (float): the angle of rotation in degrees
x_offset (float): the x component of the center of rotation (optional)
y_offset (float): the y component of the center of rotation (optional)
Returns:
texture: A texture. | [
"Rotates",
"the",
"given",
"texture",
"by",
"a",
"given",
"angle",
"."
] | da451a30f62cfefbab285b9d6979b8dec3ac4957 | https://github.com/paulgb/penkit/blob/da451a30f62cfefbab285b9d6979b8dec3ac4957/penkit/textures/util.py#L6-L24 | train |
paulgb/penkit | penkit/textures/util.py | fit_texture | def fit_texture(layer):
"""Fits a layer into a texture by scaling each axis to (0, 1).
Does not preserve aspect ratio (TODO: make this an option).
Args:
layer (layer): the layer to scale
Returns:
texture: A texture.
"""
x, y = layer
x = (x - np.nanmin(x)) / (np.nanmax(x) - np.nanmin(x))
y = (y - np.nanmin(y)) / (np.nanmax(y) - np.nanmin(y))
return x, y | python | def fit_texture(layer):
"""Fits a layer into a texture by scaling each axis to (0, 1).
Does not preserve aspect ratio (TODO: make this an option).
Args:
layer (layer): the layer to scale
Returns:
texture: A texture.
"""
x, y = layer
x = (x - np.nanmin(x)) / (np.nanmax(x) - np.nanmin(x))
y = (y - np.nanmin(y)) / (np.nanmax(y) - np.nanmin(y))
return x, y | [
"def",
"fit_texture",
"(",
"layer",
")",
":",
"x",
",",
"y",
"=",
"layer",
"x",
"=",
"(",
"x",
"-",
"np",
".",
"nanmin",
"(",
"x",
")",
")",
"/",
"(",
"np",
".",
"nanmax",
"(",
"x",
")",
"-",
"np",
".",
"nanmin",
"(",
"x",
")",
")",
"y",
... | Fits a layer into a texture by scaling each axis to (0, 1).
Does not preserve aspect ratio (TODO: make this an option).
Args:
layer (layer): the layer to scale
Returns:
texture: A texture. | [
"Fits",
"a",
"layer",
"into",
"a",
"texture",
"by",
"scaling",
"each",
"axis",
"to",
"(",
"0",
"1",
")",
"."
] | da451a30f62cfefbab285b9d6979b8dec3ac4957 | https://github.com/paulgb/penkit/blob/da451a30f62cfefbab285b9d6979b8dec3ac4957/penkit/textures/util.py#L27-L41 | train |
paulgb/penkit | optimizer/penkit_optimize/route_util.py | check_valid_solution | def check_valid_solution(solution, graph):
"""Check that the solution is valid: every path is visited exactly once."""
expected = Counter(
i for (i, _) in graph.iter_starts_with_index()
if i < graph.get_disjoint(i)
)
actual = Counter(
min(i, graph.get_disjoint(i))
for i in solution
)
difference = Counter(expected)
difference.subtract(actual)
difference = {k: v for k, v in difference.items() if v != 0}
if difference:
print('Solution is not valid!'
'Difference in node counts (expected - actual): {}'.format(difference))
return False
return True | python | def check_valid_solution(solution, graph):
"""Check that the solution is valid: every path is visited exactly once."""
expected = Counter(
i for (i, _) in graph.iter_starts_with_index()
if i < graph.get_disjoint(i)
)
actual = Counter(
min(i, graph.get_disjoint(i))
for i in solution
)
difference = Counter(expected)
difference.subtract(actual)
difference = {k: v for k, v in difference.items() if v != 0}
if difference:
print('Solution is not valid!'
'Difference in node counts (expected - actual): {}'.format(difference))
return False
return True | [
"def",
"check_valid_solution",
"(",
"solution",
",",
"graph",
")",
":",
"expected",
"=",
"Counter",
"(",
"i",
"for",
"(",
"i",
",",
"_",
")",
"in",
"graph",
".",
"iter_starts_with_index",
"(",
")",
"if",
"i",
"<",
"graph",
".",
"get_disjoint",
"(",
"i"... | Check that the solution is valid: every path is visited exactly once. | [
"Check",
"that",
"the",
"solution",
"is",
"valid",
":",
"every",
"path",
"is",
"visited",
"exactly",
"once",
"."
] | da451a30f62cfefbab285b9d6979b8dec3ac4957 | https://github.com/paulgb/penkit/blob/da451a30f62cfefbab285b9d6979b8dec3ac4957/optimizer/penkit_optimize/route_util.py#L5-L23 | train |
paulgb/penkit | optimizer/penkit_optimize/route_util.py | get_route_from_solution | def get_route_from_solution(solution, graph):
"""Converts a solution (a list of node indices) into a list
of paths suitable for rendering."""
# As a guard against comparing invalid "solutions",
# ensure that this solution is valid.
assert check_valid_solution(solution, graph)
return [graph.get_path(i) for i in solution] | python | def get_route_from_solution(solution, graph):
"""Converts a solution (a list of node indices) into a list
of paths suitable for rendering."""
# As a guard against comparing invalid "solutions",
# ensure that this solution is valid.
assert check_valid_solution(solution, graph)
return [graph.get_path(i) for i in solution] | [
"def",
"get_route_from_solution",
"(",
"solution",
",",
"graph",
")",
":",
"# As a guard against comparing invalid \"solutions\",",
"# ensure that this solution is valid.",
"assert",
"check_valid_solution",
"(",
"solution",
",",
"graph",
")",
"return",
"[",
"graph",
".",
"g... | Converts a solution (a list of node indices) into a list
of paths suitable for rendering. | [
"Converts",
"a",
"solution",
"(",
"a",
"list",
"of",
"node",
"indices",
")",
"into",
"a",
"list",
"of",
"paths",
"suitable",
"for",
"rendering",
"."
] | da451a30f62cfefbab285b9d6979b8dec3ac4957 | https://github.com/paulgb/penkit/blob/da451a30f62cfefbab285b9d6979b8dec3ac4957/optimizer/penkit_optimize/route_util.py#L26-L34 | train |
paulgb/penkit | penkit/turtle.py | branching_turtle_generator | def branching_turtle_generator(turtle_program, turn_amount=DEFAULT_TURN,
initial_angle=DEFAULT_INITIAL_ANGLE, resolution=1):
"""Given a turtle program, creates a generator of turtle positions.
The state of the turtle consists of its position and angle.
The turtle starts at the position ``(0, 0)`` facing up. Each character in the
turtle program is processed in order and causes an update to the state.
The position component of the state is yielded at each state change. A
``(nan, nan)`` separator is emitted between state changes for which no line
should be drawn.
The turtle program consists of the following commands:
- Any letter in ``ABCDEFGHIJ`` means "move forward one unit and draw a path"
- Any letter in ``abcdefghij`` means "move forward" (no path)
- The character ``-`` means "move counter-clockwise"
- The character ``+`` means "move clockwise"
- The character ``[`` means "push a copy of the current state to the stack"
- The character ``]`` means "pop a state from the stack and return there"
- All other characters are silently ignored (this is useful when producing
programs with L-Systems)
Args:
turtle_program (str): a string or generator representing the turtle program
turn_amount (float): how much the turn commands should change the angle
initial_angle (float): if provided, the turtle starts at this angle (degrees)
resolution (int): if provided, interpolate this many points along each visible
line
Yields:
pair: The next coordinate pair, or ``(nan, nan)`` as a path separator.
"""
saved_states = list()
state = (0, 0, DEFAULT_INITIAL_ANGLE)
yield (0, 0)
for command in turtle_program:
x, y, angle = state
if command in FORWARD_COMMANDS:
new_x = x - np.cos(np.radians(angle))
new_y = y + np.sin(np.radians(angle))
state = (new_x, new_y, angle)
if command not in VISIBLE_FORWARD_COMMANDS:
yield (np.nan, np.nan)
yield (state[0], state[1])
else:
dx = new_x - x
dy = new_y - y
for frac in (1 - np.flipud(np.linspace(0, 1, resolution, False))):
yield (x + frac * dx, y + frac * dy)
elif command == CW_TURN_COMMAND:
state = (x, y, angle + turn_amount)
elif command == CCW_TURN_COMMAND:
state = (x, y, angle - turn_amount)
elif command == PUSH_STATE_COMMAND:
saved_states.append(state)
elif command == POP_STATE_COMMAND:
state = saved_states.pop()
yield (np.nan, np.nan)
x, y, _ = state
yield (x, y) | python | def branching_turtle_generator(turtle_program, turn_amount=DEFAULT_TURN,
initial_angle=DEFAULT_INITIAL_ANGLE, resolution=1):
"""Given a turtle program, creates a generator of turtle positions.
The state of the turtle consists of its position and angle.
The turtle starts at the position ``(0, 0)`` facing up. Each character in the
turtle program is processed in order and causes an update to the state.
The position component of the state is yielded at each state change. A
``(nan, nan)`` separator is emitted between state changes for which no line
should be drawn.
The turtle program consists of the following commands:
- Any letter in ``ABCDEFGHIJ`` means "move forward one unit and draw a path"
- Any letter in ``abcdefghij`` means "move forward" (no path)
- The character ``-`` means "move counter-clockwise"
- The character ``+`` means "move clockwise"
- The character ``[`` means "push a copy of the current state to the stack"
- The character ``]`` means "pop a state from the stack and return there"
- All other characters are silently ignored (this is useful when producing
programs with L-Systems)
Args:
turtle_program (str): a string or generator representing the turtle program
turn_amount (float): how much the turn commands should change the angle
initial_angle (float): if provided, the turtle starts at this angle (degrees)
resolution (int): if provided, interpolate this many points along each visible
line
Yields:
pair: The next coordinate pair, or ``(nan, nan)`` as a path separator.
"""
saved_states = list()
state = (0, 0, DEFAULT_INITIAL_ANGLE)
yield (0, 0)
for command in turtle_program:
x, y, angle = state
if command in FORWARD_COMMANDS:
new_x = x - np.cos(np.radians(angle))
new_y = y + np.sin(np.radians(angle))
state = (new_x, new_y, angle)
if command not in VISIBLE_FORWARD_COMMANDS:
yield (np.nan, np.nan)
yield (state[0], state[1])
else:
dx = new_x - x
dy = new_y - y
for frac in (1 - np.flipud(np.linspace(0, 1, resolution, False))):
yield (x + frac * dx, y + frac * dy)
elif command == CW_TURN_COMMAND:
state = (x, y, angle + turn_amount)
elif command == CCW_TURN_COMMAND:
state = (x, y, angle - turn_amount)
elif command == PUSH_STATE_COMMAND:
saved_states.append(state)
elif command == POP_STATE_COMMAND:
state = saved_states.pop()
yield (np.nan, np.nan)
x, y, _ = state
yield (x, y) | [
"def",
"branching_turtle_generator",
"(",
"turtle_program",
",",
"turn_amount",
"=",
"DEFAULT_TURN",
",",
"initial_angle",
"=",
"DEFAULT_INITIAL_ANGLE",
",",
"resolution",
"=",
"1",
")",
":",
"saved_states",
"=",
"list",
"(",
")",
"state",
"=",
"(",
"0",
",",
... | Given a turtle program, creates a generator of turtle positions.
The state of the turtle consists of its position and angle.
The turtle starts at the position ``(0, 0)`` facing up. Each character in the
turtle program is processed in order and causes an update to the state.
The position component of the state is yielded at each state change. A
``(nan, nan)`` separator is emitted between state changes for which no line
should be drawn.
The turtle program consists of the following commands:
- Any letter in ``ABCDEFGHIJ`` means "move forward one unit and draw a path"
- Any letter in ``abcdefghij`` means "move forward" (no path)
- The character ``-`` means "move counter-clockwise"
- The character ``+`` means "move clockwise"
- The character ``[`` means "push a copy of the current state to the stack"
- The character ``]`` means "pop a state from the stack and return there"
- All other characters are silently ignored (this is useful when producing
programs with L-Systems)
Args:
turtle_program (str): a string or generator representing the turtle program
turn_amount (float): how much the turn commands should change the angle
initial_angle (float): if provided, the turtle starts at this angle (degrees)
resolution (int): if provided, interpolate this many points along each visible
line
Yields:
pair: The next coordinate pair, or ``(nan, nan)`` as a path separator. | [
"Given",
"a",
"turtle",
"program",
"creates",
"a",
"generator",
"of",
"turtle",
"positions",
".",
"The",
"state",
"of",
"the",
"turtle",
"consists",
"of",
"its",
"position",
"and",
"angle",
".",
"The",
"turtle",
"starts",
"at",
"the",
"position",
"(",
"0",... | da451a30f62cfefbab285b9d6979b8dec3ac4957 | https://github.com/paulgb/penkit/blob/da451a30f62cfefbab285b9d6979b8dec3ac4957/penkit/turtle.py#L23-L89 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.