id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
231,900 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.reset | def reset(self):
"Initialises all needed variables to default values"
self.metadata = {}
self.items = []
self.spine = []
self.guide = []
self.pages = []
self.toc = []
self.bindings = []
self.IDENTIFIER_ID = 'id'
self.FOLDER_NAME = 'EPUB'
self._id_html = 0
self._id_image = 0
self._id_static = 0
self.title = ''
self.language = 'en'
self.direction = None
self.templates = {
'ncx': NCX_XML,
'nav': NAV_XML,
'chapter': CHAPTER_XML,
'cover': COVER_XML
}
self.add_metadata('OPF', 'generator', '', {
'name': 'generator', 'content': 'Ebook-lib %s' % '.'.join([str(s) for s in VERSION])
})
# default to using a randomly-unique identifier if one is not specified manually
self.set_identifier(str(uuid.uuid4()))
# custom prefixes and namespaces to be set to the content.opf doc
self.prefixes = []
self.namespaces = {} | python | def reset(self):
"Initialises all needed variables to default values"
self.metadata = {}
self.items = []
self.spine = []
self.guide = []
self.pages = []
self.toc = []
self.bindings = []
self.IDENTIFIER_ID = 'id'
self.FOLDER_NAME = 'EPUB'
self._id_html = 0
self._id_image = 0
self._id_static = 0
self.title = ''
self.language = 'en'
self.direction = None
self.templates = {
'ncx': NCX_XML,
'nav': NAV_XML,
'chapter': CHAPTER_XML,
'cover': COVER_XML
}
self.add_metadata('OPF', 'generator', '', {
'name': 'generator', 'content': 'Ebook-lib %s' % '.'.join([str(s) for s in VERSION])
})
# default to using a randomly-unique identifier if one is not specified manually
self.set_identifier(str(uuid.uuid4()))
# custom prefixes and namespaces to be set to the content.opf doc
self.prefixes = []
self.namespaces = {} | [
"def",
"reset",
"(",
"self",
")",
":",
"self",
".",
"metadata",
"=",
"{",
"}",
"self",
".",
"items",
"=",
"[",
"]",
"self",
".",
"spine",
"=",
"[",
"]",
"self",
".",
"guide",
"=",
"[",
"]",
"self",
".",
"pages",
"=",
"[",
"]",
"self",
".",
"toc",
"=",
"[",
"]",
"self",
".",
"bindings",
"=",
"[",
"]",
"self",
".",
"IDENTIFIER_ID",
"=",
"'id'",
"self",
".",
"FOLDER_NAME",
"=",
"'EPUB'",
"self",
".",
"_id_html",
"=",
"0",
"self",
".",
"_id_image",
"=",
"0",
"self",
".",
"_id_static",
"=",
"0",
"self",
".",
"title",
"=",
"''",
"self",
".",
"language",
"=",
"'en'",
"self",
".",
"direction",
"=",
"None",
"self",
".",
"templates",
"=",
"{",
"'ncx'",
":",
"NCX_XML",
",",
"'nav'",
":",
"NAV_XML",
",",
"'chapter'",
":",
"CHAPTER_XML",
",",
"'cover'",
":",
"COVER_XML",
"}",
"self",
".",
"add_metadata",
"(",
"'OPF'",
",",
"'generator'",
",",
"''",
",",
"{",
"'name'",
":",
"'generator'",
",",
"'content'",
":",
"'Ebook-lib %s'",
"%",
"'.'",
".",
"join",
"(",
"[",
"str",
"(",
"s",
")",
"for",
"s",
"in",
"VERSION",
"]",
")",
"}",
")",
"# default to using a randomly-unique identifier if one is not specified manually",
"self",
".",
"set_identifier",
"(",
"str",
"(",
"uuid",
".",
"uuid4",
"(",
")",
")",
")",
"# custom prefixes and namespaces to be set to the content.opf doc",
"self",
".",
"prefixes",
"=",
"[",
"]",
"self",
".",
"namespaces",
"=",
"{",
"}"
] | Initialises all needed variables to default values | [
"Initialises",
"all",
"needed",
"variables",
"to",
"default",
"values"
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L554-L592 |
231,901 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.set_identifier | def set_identifier(self, uid):
"""
Sets unique id for this epub
:Args:
- uid: Value of unique identifier for this book
"""
self.uid = uid
self.set_unique_metadata('DC', 'identifier', self.uid, {'id': self.IDENTIFIER_ID}) | python | def set_identifier(self, uid):
"""
Sets unique id for this epub
:Args:
- uid: Value of unique identifier for this book
"""
self.uid = uid
self.set_unique_metadata('DC', 'identifier', self.uid, {'id': self.IDENTIFIER_ID}) | [
"def",
"set_identifier",
"(",
"self",
",",
"uid",
")",
":",
"self",
".",
"uid",
"=",
"uid",
"self",
".",
"set_unique_metadata",
"(",
"'DC'",
",",
"'identifier'",
",",
"self",
".",
"uid",
",",
"{",
"'id'",
":",
"self",
".",
"IDENTIFIER_ID",
"}",
")"
] | Sets unique id for this epub
:Args:
- uid: Value of unique identifier for this book | [
"Sets",
"unique",
"id",
"for",
"this",
"epub"
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L594-L604 |
231,902 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.set_title | def set_title(self, title):
"""
Set title. You can set multiple titles.
:Args:
- title: Title value
"""
self.title = title
self.add_metadata('DC', 'title', self.title) | python | def set_title(self, title):
"""
Set title. You can set multiple titles.
:Args:
- title: Title value
"""
self.title = title
self.add_metadata('DC', 'title', self.title) | [
"def",
"set_title",
"(",
"self",
",",
"title",
")",
":",
"self",
".",
"title",
"=",
"title",
"self",
".",
"add_metadata",
"(",
"'DC'",
",",
"'title'",
",",
"self",
".",
"title",
")"
] | Set title. You can set multiple titles.
:Args:
- title: Title value | [
"Set",
"title",
".",
"You",
"can",
"set",
"multiple",
"titles",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L606-L616 |
231,903 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.set_cover | def set_cover(self, file_name, content, create_page=True):
"""
Set cover and create cover document if needed.
:Args:
- file_name: file name of the cover page
- content: Content for the cover image
- create_page: Should cover page be defined. Defined as bool value (optional). Default value is True.
"""
# as it is now, it can only be called once
c0 = EpubCover(file_name=file_name)
c0.content = content
self.add_item(c0)
if create_page:
c1 = EpubCoverHtml(image_name=file_name)
self.add_item(c1)
self.add_metadata(None, 'meta', '', OrderedDict([('name', 'cover'), ('content', 'cover-img')])) | python | def set_cover(self, file_name, content, create_page=True):
"""
Set cover and create cover document if needed.
:Args:
- file_name: file name of the cover page
- content: Content for the cover image
- create_page: Should cover page be defined. Defined as bool value (optional). Default value is True.
"""
# as it is now, it can only be called once
c0 = EpubCover(file_name=file_name)
c0.content = content
self.add_item(c0)
if create_page:
c1 = EpubCoverHtml(image_name=file_name)
self.add_item(c1)
self.add_metadata(None, 'meta', '', OrderedDict([('name', 'cover'), ('content', 'cover-img')])) | [
"def",
"set_cover",
"(",
"self",
",",
"file_name",
",",
"content",
",",
"create_page",
"=",
"True",
")",
":",
"# as it is now, it can only be called once",
"c0",
"=",
"EpubCover",
"(",
"file_name",
"=",
"file_name",
")",
"c0",
".",
"content",
"=",
"content",
"self",
".",
"add_item",
"(",
"c0",
")",
"if",
"create_page",
":",
"c1",
"=",
"EpubCoverHtml",
"(",
"image_name",
"=",
"file_name",
")",
"self",
".",
"add_item",
"(",
"c1",
")",
"self",
".",
"add_metadata",
"(",
"None",
",",
"'meta'",
",",
"''",
",",
"OrderedDict",
"(",
"[",
"(",
"'name'",
",",
"'cover'",
")",
",",
"(",
"'content'",
",",
"'cover-img'",
")",
"]",
")",
")"
] | Set cover and create cover document if needed.
:Args:
- file_name: file name of the cover page
- content: Content for the cover image
- create_page: Should cover page be defined. Defined as bool value (optional). Default value is True. | [
"Set",
"cover",
"and",
"create",
"cover",
"document",
"if",
"needed",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L639-L658 |
231,904 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.add_author | def add_author(self, author, file_as=None, role=None, uid='creator'):
"Add author for this document"
self.add_metadata('DC', 'creator', author, {'id': uid})
if file_as:
self.add_metadata(None, 'meta', file_as, {'refines': '#' + uid,
'property': 'file-as',
'scheme': 'marc:relators'})
if role:
self.add_metadata(None, 'meta', role, {'refines': '#' + uid,
'property': 'role',
'scheme': 'marc:relators'}) | python | def add_author(self, author, file_as=None, role=None, uid='creator'):
"Add author for this document"
self.add_metadata('DC', 'creator', author, {'id': uid})
if file_as:
self.add_metadata(None, 'meta', file_as, {'refines': '#' + uid,
'property': 'file-as',
'scheme': 'marc:relators'})
if role:
self.add_metadata(None, 'meta', role, {'refines': '#' + uid,
'property': 'role',
'scheme': 'marc:relators'}) | [
"def",
"add_author",
"(",
"self",
",",
"author",
",",
"file_as",
"=",
"None",
",",
"role",
"=",
"None",
",",
"uid",
"=",
"'creator'",
")",
":",
"self",
".",
"add_metadata",
"(",
"'DC'",
",",
"'creator'",
",",
"author",
",",
"{",
"'id'",
":",
"uid",
"}",
")",
"if",
"file_as",
":",
"self",
".",
"add_metadata",
"(",
"None",
",",
"'meta'",
",",
"file_as",
",",
"{",
"'refines'",
":",
"'#'",
"+",
"uid",
",",
"'property'",
":",
"'file-as'",
",",
"'scheme'",
":",
"'marc:relators'",
"}",
")",
"if",
"role",
":",
"self",
".",
"add_metadata",
"(",
"None",
",",
"'meta'",
",",
"role",
",",
"{",
"'refines'",
":",
"'#'",
"+",
"uid",
",",
"'property'",
":",
"'role'",
",",
"'scheme'",
":",
"'marc:relators'",
"}",
")"
] | Add author for this document | [
"Add",
"author",
"for",
"this",
"document"
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L660-L672 |
231,905 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.add_item | def add_item(self, item):
"""
Add additional item to the book. If not defined, media type and chapter id will be defined
for the item.
:Args:
- item: Item instance
"""
if item.media_type == '':
(has_guessed, media_type) = guess_type(item.get_name().lower())
if has_guessed:
if media_type is not None:
item.media_type = media_type
else:
item.media_type = has_guessed
else:
item.media_type = 'application/octet-stream'
if not item.get_id():
# make chapter_, image_ and static_ configurable
if isinstance(item, EpubHtml):
item.id = 'chapter_%d' % self._id_html
self._id_html += 1
# If there's a page list, append it to the book's page list
self.pages += item.pages
elif isinstance(item, EpubImage):
item.id = 'image_%d' % self._id_image
self._id_image += 1
else:
item.id = 'static_%d' % self._id_image
self._id_image += 1
item.book = self
self.items.append(item)
return item | python | def add_item(self, item):
"""
Add additional item to the book. If not defined, media type and chapter id will be defined
for the item.
:Args:
- item: Item instance
"""
if item.media_type == '':
(has_guessed, media_type) = guess_type(item.get_name().lower())
if has_guessed:
if media_type is not None:
item.media_type = media_type
else:
item.media_type = has_guessed
else:
item.media_type = 'application/octet-stream'
if not item.get_id():
# make chapter_, image_ and static_ configurable
if isinstance(item, EpubHtml):
item.id = 'chapter_%d' % self._id_html
self._id_html += 1
# If there's a page list, append it to the book's page list
self.pages += item.pages
elif isinstance(item, EpubImage):
item.id = 'image_%d' % self._id_image
self._id_image += 1
else:
item.id = 'static_%d' % self._id_image
self._id_image += 1
item.book = self
self.items.append(item)
return item | [
"def",
"add_item",
"(",
"self",
",",
"item",
")",
":",
"if",
"item",
".",
"media_type",
"==",
"''",
":",
"(",
"has_guessed",
",",
"media_type",
")",
"=",
"guess_type",
"(",
"item",
".",
"get_name",
"(",
")",
".",
"lower",
"(",
")",
")",
"if",
"has_guessed",
":",
"if",
"media_type",
"is",
"not",
"None",
":",
"item",
".",
"media_type",
"=",
"media_type",
"else",
":",
"item",
".",
"media_type",
"=",
"has_guessed",
"else",
":",
"item",
".",
"media_type",
"=",
"'application/octet-stream'",
"if",
"not",
"item",
".",
"get_id",
"(",
")",
":",
"# make chapter_, image_ and static_ configurable",
"if",
"isinstance",
"(",
"item",
",",
"EpubHtml",
")",
":",
"item",
".",
"id",
"=",
"'chapter_%d'",
"%",
"self",
".",
"_id_html",
"self",
".",
"_id_html",
"+=",
"1",
"# If there's a page list, append it to the book's page list",
"self",
".",
"pages",
"+=",
"item",
".",
"pages",
"elif",
"isinstance",
"(",
"item",
",",
"EpubImage",
")",
":",
"item",
".",
"id",
"=",
"'image_%d'",
"%",
"self",
".",
"_id_image",
"self",
".",
"_id_image",
"+=",
"1",
"else",
":",
"item",
".",
"id",
"=",
"'static_%d'",
"%",
"self",
".",
"_id_image",
"self",
".",
"_id_image",
"+=",
"1",
"item",
".",
"book",
"=",
"self",
"self",
".",
"items",
".",
"append",
"(",
"item",
")",
"return",
"item"
] | Add additional item to the book. If not defined, media type and chapter id will be defined
for the item.
:Args:
- item: Item instance | [
"Add",
"additional",
"item",
"to",
"the",
"book",
".",
"If",
"not",
"defined",
"media",
"type",
"and",
"chapter",
"id",
"will",
"be",
"defined",
"for",
"the",
"item",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L707-L743 |
231,906 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.get_item_with_id | def get_item_with_id(self, uid):
"""
Returns item for defined UID.
>>> book.get_item_with_id('image_001')
:Args:
- uid: UID for the item
:Returns:
Returns item object. Returns None if nothing was found.
"""
for item in self.get_items():
if item.id == uid:
return item
return None | python | def get_item_with_id(self, uid):
"""
Returns item for defined UID.
>>> book.get_item_with_id('image_001')
:Args:
- uid: UID for the item
:Returns:
Returns item object. Returns None if nothing was found.
"""
for item in self.get_items():
if item.id == uid:
return item
return None | [
"def",
"get_item_with_id",
"(",
"self",
",",
"uid",
")",
":",
"for",
"item",
"in",
"self",
".",
"get_items",
"(",
")",
":",
"if",
"item",
".",
"id",
"==",
"uid",
":",
"return",
"item",
"return",
"None"
] | Returns item for defined UID.
>>> book.get_item_with_id('image_001')
:Args:
- uid: UID for the item
:Returns:
Returns item object. Returns None if nothing was found. | [
"Returns",
"item",
"for",
"defined",
"UID",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L745-L761 |
231,907 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.get_item_with_href | def get_item_with_href(self, href):
"""
Returns item for defined HREF.
>>> book.get_item_with_href('EPUB/document.xhtml')
:Args:
- href: HREF for the item we are searching for
:Returns:
Returns item object. Returns None if nothing was found.
"""
for item in self.get_items():
if item.get_name() == href:
return item
return None | python | def get_item_with_href(self, href):
"""
Returns item for defined HREF.
>>> book.get_item_with_href('EPUB/document.xhtml')
:Args:
- href: HREF for the item we are searching for
:Returns:
Returns item object. Returns None if nothing was found.
"""
for item in self.get_items():
if item.get_name() == href:
return item
return None | [
"def",
"get_item_with_href",
"(",
"self",
",",
"href",
")",
":",
"for",
"item",
"in",
"self",
".",
"get_items",
"(",
")",
":",
"if",
"item",
".",
"get_name",
"(",
")",
"==",
"href",
":",
"return",
"item",
"return",
"None"
] | Returns item for defined HREF.
>>> book.get_item_with_href('EPUB/document.xhtml')
:Args:
- href: HREF for the item we are searching for
:Returns:
Returns item object. Returns None if nothing was found. | [
"Returns",
"item",
"for",
"defined",
"HREF",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L763-L779 |
231,908 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.get_items_of_type | def get_items_of_type(self, item_type):
"""
Returns all items of specified type.
>>> book.get_items_of_type(epub.ITEM_IMAGE)
:Args:
- item_type: Type for items we are searching for
:Returns:
Returns found items as tuple.
"""
return (item for item in self.items if item.get_type() == item_type) | python | def get_items_of_type(self, item_type):
"""
Returns all items of specified type.
>>> book.get_items_of_type(epub.ITEM_IMAGE)
:Args:
- item_type: Type for items we are searching for
:Returns:
Returns found items as tuple.
"""
return (item for item in self.items if item.get_type() == item_type) | [
"def",
"get_items_of_type",
"(",
"self",
",",
"item_type",
")",
":",
"return",
"(",
"item",
"for",
"item",
"in",
"self",
".",
"items",
"if",
"item",
".",
"get_type",
"(",
")",
"==",
"item_type",
")"
] | Returns all items of specified type.
>>> book.get_items_of_type(epub.ITEM_IMAGE)
:Args:
- item_type: Type for items we are searching for
:Returns:
Returns found items as tuple. | [
"Returns",
"all",
"items",
"of",
"specified",
"type",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L790-L802 |
231,909 | aerkalov/ebooklib | ebooklib/epub.py | EpubBook.get_items_of_media_type | def get_items_of_media_type(self, media_type):
"""
Returns all items of specified media type.
:Args:
- media_type: Media type for items we are searching for
:Returns:
Returns found items as tuple.
"""
return (item for item in self.items if item.media_type == media_type) | python | def get_items_of_media_type(self, media_type):
"""
Returns all items of specified media type.
:Args:
- media_type: Media type for items we are searching for
:Returns:
Returns found items as tuple.
"""
return (item for item in self.items if item.media_type == media_type) | [
"def",
"get_items_of_media_type",
"(",
"self",
",",
"media_type",
")",
":",
"return",
"(",
"item",
"for",
"item",
"in",
"self",
".",
"items",
"if",
"item",
".",
"media_type",
"==",
"media_type",
")"
] | Returns all items of specified media type.
:Args:
- media_type: Media type for items we are searching for
:Returns:
Returns found items as tuple. | [
"Returns",
"all",
"items",
"of",
"specified",
"media",
"type",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L804-L814 |
231,910 | LuminosoInsight/python-ftfy | ftfy/cli.py | main | def main():
"""
Run ftfy as a command-line utility.
"""
import argparse
parser = argparse.ArgumentParser(
description="ftfy (fixes text for you), version %s" % __version__
)
parser.add_argument('filename', default='-', nargs='?',
help='The file whose Unicode is to be fixed. Defaults '
'to -, meaning standard input.')
parser.add_argument('-o', '--output', type=str, default='-',
help='The file to output to. Defaults to -, meaning '
'standard output.')
parser.add_argument('-g', '--guess', action='store_true',
help="Ask ftfy to guess the encoding of your input. "
"This is risky. Overrides -e.")
parser.add_argument('-e', '--encoding', type=str, default='utf-8',
help='The encoding of the input. Defaults to UTF-8.')
parser.add_argument('-n', '--normalization', type=str, default='NFC',
help='The normalization of Unicode to apply. '
'Defaults to NFC. Can be "none".')
parser.add_argument('--preserve-entities', action='store_true',
help="Leave HTML entities as they are. The default "
"is to decode them, as long as no HTML tags "
"have appeared in the file.")
args = parser.parse_args()
encoding = args.encoding
if args.guess:
encoding = None
if args.filename == '-':
# Get a standard input stream made of bytes, so we can decode it as
# whatever encoding is necessary.
file = sys.stdin.buffer
else:
file = open(args.filename, 'rb')
if args.output == '-':
outfile = sys.stdout
else:
if os.path.realpath(args.output) == os.path.realpath(args.filename):
sys.stderr.write(SAME_FILE_ERROR_TEXT)
sys.exit(1)
outfile = open(args.output, 'w', encoding='utf-8')
normalization = args.normalization
if normalization.lower() == 'none':
normalization = None
if args.preserve_entities:
fix_entities = False
else:
fix_entities = 'auto'
try:
for line in fix_file(file, encoding=encoding,
fix_entities=fix_entities,
normalization=normalization):
try:
outfile.write(line)
except UnicodeEncodeError:
if sys.platform == 'win32':
sys.stderr.write(ENCODE_ERROR_TEXT_WINDOWS)
else:
sys.stderr.write(ENCODE_ERROR_TEXT_UNIX)
sys.exit(1)
except UnicodeDecodeError as err:
sys.stderr.write(DECODE_ERROR_TEXT % (encoding, err))
sys.exit(1) | python | def main():
"""
Run ftfy as a command-line utility.
"""
import argparse
parser = argparse.ArgumentParser(
description="ftfy (fixes text for you), version %s" % __version__
)
parser.add_argument('filename', default='-', nargs='?',
help='The file whose Unicode is to be fixed. Defaults '
'to -, meaning standard input.')
parser.add_argument('-o', '--output', type=str, default='-',
help='The file to output to. Defaults to -, meaning '
'standard output.')
parser.add_argument('-g', '--guess', action='store_true',
help="Ask ftfy to guess the encoding of your input. "
"This is risky. Overrides -e.")
parser.add_argument('-e', '--encoding', type=str, default='utf-8',
help='The encoding of the input. Defaults to UTF-8.')
parser.add_argument('-n', '--normalization', type=str, default='NFC',
help='The normalization of Unicode to apply. '
'Defaults to NFC. Can be "none".')
parser.add_argument('--preserve-entities', action='store_true',
help="Leave HTML entities as they are. The default "
"is to decode them, as long as no HTML tags "
"have appeared in the file.")
args = parser.parse_args()
encoding = args.encoding
if args.guess:
encoding = None
if args.filename == '-':
# Get a standard input stream made of bytes, so we can decode it as
# whatever encoding is necessary.
file = sys.stdin.buffer
else:
file = open(args.filename, 'rb')
if args.output == '-':
outfile = sys.stdout
else:
if os.path.realpath(args.output) == os.path.realpath(args.filename):
sys.stderr.write(SAME_FILE_ERROR_TEXT)
sys.exit(1)
outfile = open(args.output, 'w', encoding='utf-8')
normalization = args.normalization
if normalization.lower() == 'none':
normalization = None
if args.preserve_entities:
fix_entities = False
else:
fix_entities = 'auto'
try:
for line in fix_file(file, encoding=encoding,
fix_entities=fix_entities,
normalization=normalization):
try:
outfile.write(line)
except UnicodeEncodeError:
if sys.platform == 'win32':
sys.stderr.write(ENCODE_ERROR_TEXT_WINDOWS)
else:
sys.stderr.write(ENCODE_ERROR_TEXT_UNIX)
sys.exit(1)
except UnicodeDecodeError as err:
sys.stderr.write(DECODE_ERROR_TEXT % (encoding, err))
sys.exit(1) | [
"def",
"main",
"(",
")",
":",
"import",
"argparse",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
"description",
"=",
"\"ftfy (fixes text for you), version %s\"",
"%",
"__version__",
")",
"parser",
".",
"add_argument",
"(",
"'filename'",
",",
"default",
"=",
"'-'",
",",
"nargs",
"=",
"'?'",
",",
"help",
"=",
"'The file whose Unicode is to be fixed. Defaults '",
"'to -, meaning standard input.'",
")",
"parser",
".",
"add_argument",
"(",
"'-o'",
",",
"'--output'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"'-'",
",",
"help",
"=",
"'The file to output to. Defaults to -, meaning '",
"'standard output.'",
")",
"parser",
".",
"add_argument",
"(",
"'-g'",
",",
"'--guess'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"\"Ask ftfy to guess the encoding of your input. \"",
"\"This is risky. Overrides -e.\"",
")",
"parser",
".",
"add_argument",
"(",
"'-e'",
",",
"'--encoding'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"'utf-8'",
",",
"help",
"=",
"'The encoding of the input. Defaults to UTF-8.'",
")",
"parser",
".",
"add_argument",
"(",
"'-n'",
",",
"'--normalization'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"'NFC'",
",",
"help",
"=",
"'The normalization of Unicode to apply. '",
"'Defaults to NFC. Can be \"none\".'",
")",
"parser",
".",
"add_argument",
"(",
"'--preserve-entities'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"\"Leave HTML entities as they are. The default \"",
"\"is to decode them, as long as no HTML tags \"",
"\"have appeared in the file.\"",
")",
"args",
"=",
"parser",
".",
"parse_args",
"(",
")",
"encoding",
"=",
"args",
".",
"encoding",
"if",
"args",
".",
"guess",
":",
"encoding",
"=",
"None",
"if",
"args",
".",
"filename",
"==",
"'-'",
":",
"# Get a standard input stream made of bytes, so we can decode it as",
"# whatever encoding is necessary.",
"file",
"=",
"sys",
".",
"stdin",
".",
"buffer",
"else",
":",
"file",
"=",
"open",
"(",
"args",
".",
"filename",
",",
"'rb'",
")",
"if",
"args",
".",
"output",
"==",
"'-'",
":",
"outfile",
"=",
"sys",
".",
"stdout",
"else",
":",
"if",
"os",
".",
"path",
".",
"realpath",
"(",
"args",
".",
"output",
")",
"==",
"os",
".",
"path",
".",
"realpath",
"(",
"args",
".",
"filename",
")",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"SAME_FILE_ERROR_TEXT",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"outfile",
"=",
"open",
"(",
"args",
".",
"output",
",",
"'w'",
",",
"encoding",
"=",
"'utf-8'",
")",
"normalization",
"=",
"args",
".",
"normalization",
"if",
"normalization",
".",
"lower",
"(",
")",
"==",
"'none'",
":",
"normalization",
"=",
"None",
"if",
"args",
".",
"preserve_entities",
":",
"fix_entities",
"=",
"False",
"else",
":",
"fix_entities",
"=",
"'auto'",
"try",
":",
"for",
"line",
"in",
"fix_file",
"(",
"file",
",",
"encoding",
"=",
"encoding",
",",
"fix_entities",
"=",
"fix_entities",
",",
"normalization",
"=",
"normalization",
")",
":",
"try",
":",
"outfile",
".",
"write",
"(",
"line",
")",
"except",
"UnicodeEncodeError",
":",
"if",
"sys",
".",
"platform",
"==",
"'win32'",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"ENCODE_ERROR_TEXT_WINDOWS",
")",
"else",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"ENCODE_ERROR_TEXT_UNIX",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"except",
"UnicodeDecodeError",
"as",
"err",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"DECODE_ERROR_TEXT",
"%",
"(",
"encoding",
",",
"err",
")",
")",
"sys",
".",
"exit",
"(",
"1",
")"
] | Run ftfy as a command-line utility. | [
"Run",
"ftfy",
"as",
"a",
"command",
"-",
"line",
"utility",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/cli.py#L42-L114 |
231,911 | LuminosoInsight/python-ftfy | ftfy/fixes.py | fix_encoding_and_explain | def fix_encoding_and_explain(text):
"""
Re-decodes text that has been decoded incorrectly, and also return a
"plan" indicating all the steps required to fix it.
The resulting plan could be used with :func:`ftfy.fixes.apply_plan`
to fix additional strings that are broken in the same way.
"""
best_version = text
best_cost = text_cost(text)
best_plan = []
plan_so_far = []
while True:
prevtext = text
text, plan = fix_one_step_and_explain(text)
plan_so_far.extend(plan)
cost = text_cost(text)
for _, _, step_cost in plan_so_far:
cost += step_cost
if cost < best_cost:
best_cost = cost
best_version = text
best_plan = list(plan_so_far)
if text == prevtext:
return best_version, best_plan | python | def fix_encoding_and_explain(text):
"""
Re-decodes text that has been decoded incorrectly, and also return a
"plan" indicating all the steps required to fix it.
The resulting plan could be used with :func:`ftfy.fixes.apply_plan`
to fix additional strings that are broken in the same way.
"""
best_version = text
best_cost = text_cost(text)
best_plan = []
plan_so_far = []
while True:
prevtext = text
text, plan = fix_one_step_and_explain(text)
plan_so_far.extend(plan)
cost = text_cost(text)
for _, _, step_cost in plan_so_far:
cost += step_cost
if cost < best_cost:
best_cost = cost
best_version = text
best_plan = list(plan_so_far)
if text == prevtext:
return best_version, best_plan | [
"def",
"fix_encoding_and_explain",
"(",
"text",
")",
":",
"best_version",
"=",
"text",
"best_cost",
"=",
"text_cost",
"(",
"text",
")",
"best_plan",
"=",
"[",
"]",
"plan_so_far",
"=",
"[",
"]",
"while",
"True",
":",
"prevtext",
"=",
"text",
"text",
",",
"plan",
"=",
"fix_one_step_and_explain",
"(",
"text",
")",
"plan_so_far",
".",
"extend",
"(",
"plan",
")",
"cost",
"=",
"text_cost",
"(",
"text",
")",
"for",
"_",
",",
"_",
",",
"step_cost",
"in",
"plan_so_far",
":",
"cost",
"+=",
"step_cost",
"if",
"cost",
"<",
"best_cost",
":",
"best_cost",
"=",
"cost",
"best_version",
"=",
"text",
"best_plan",
"=",
"list",
"(",
"plan_so_far",
")",
"if",
"text",
"==",
"prevtext",
":",
"return",
"best_version",
",",
"best_plan"
] | Re-decodes text that has been decoded incorrectly, and also return a
"plan" indicating all the steps required to fix it.
The resulting plan could be used with :func:`ftfy.fixes.apply_plan`
to fix additional strings that are broken in the same way. | [
"Re",
"-",
"decodes",
"text",
"that",
"has",
"been",
"decoded",
"incorrectly",
"and",
"also",
"return",
"a",
"plan",
"indicating",
"all",
"the",
"steps",
"required",
"to",
"fix",
"it",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L133-L158 |
231,912 | LuminosoInsight/python-ftfy | ftfy/fixes.py | fix_one_step_and_explain | def fix_one_step_and_explain(text):
"""
Performs a single step of re-decoding text that's been decoded incorrectly.
Returns the decoded text, plus a "plan" for how to reproduce what it did.
"""
if isinstance(text, bytes):
raise UnicodeError(BYTES_ERROR_TEXT)
if len(text) == 0:
return text, []
# The first plan is to return ASCII text unchanged.
if possible_encoding(text, 'ascii'):
return text, []
# As we go through the next step, remember the possible encodings
# that we encounter but don't successfully fix yet. We may need them
# later.
possible_1byte_encodings = []
# Suppose the text was supposed to be UTF-8, but it was decoded using
# a single-byte encoding instead. When these cases can be fixed, they
# are usually the correct thing to do, so try them next.
for encoding in CHARMAP_ENCODINGS:
if possible_encoding(text, encoding):
encoded_bytes = text.encode(encoding)
encode_step = ('encode', encoding, ENCODING_COSTS.get(encoding, 0))
transcode_steps = []
# Now, find out if it's UTF-8 (or close enough). Otherwise,
# remember the encoding for later.
try:
decoding = 'utf-8'
# Check encoded_bytes for sequences that would be UTF-8,
# except they have b' ' where b'\xa0' would belong.
if ALTERED_UTF8_RE.search(encoded_bytes):
encoded_bytes = restore_byte_a0(encoded_bytes)
cost = encoded_bytes.count(0xa0) * 2
transcode_steps.append(('transcode', 'restore_byte_a0', cost))
# Check for the byte 0x1a, which indicates where one of our
# 'sloppy' codecs found a replacement character.
if encoding.startswith('sloppy') and 0x1a in encoded_bytes:
encoded_bytes = replace_lossy_sequences(encoded_bytes)
transcode_steps.append(('transcode', 'replace_lossy_sequences', 0))
if 0xed in encoded_bytes or 0xc0 in encoded_bytes:
decoding = 'utf-8-variants'
decode_step = ('decode', decoding, 0)
steps = [encode_step] + transcode_steps + [decode_step]
fixed = encoded_bytes.decode(decoding)
return fixed, steps
except UnicodeDecodeError:
possible_1byte_encodings.append(encoding)
# Look for a-hat-euro sequences that remain, and fix them in isolation.
if PARTIAL_UTF8_PUNCT_RE.search(text):
steps = [('transcode', 'fix_partial_utf8_punct_in_1252', 1)]
fixed = fix_partial_utf8_punct_in_1252(text)
return fixed, steps
# The next most likely case is that this is Latin-1 that was intended to
# be read as Windows-1252, because those two encodings in particular are
# easily confused.
if 'latin-1' in possible_1byte_encodings:
if 'windows-1252' in possible_1byte_encodings:
# This text is in the intersection of Latin-1 and
# Windows-1252, so it's probably legit.
return text, []
else:
# Otherwise, it means we have characters that are in Latin-1 but
# not in Windows-1252. Those are C1 control characters. Nobody
# wants those. Assume they were meant to be Windows-1252. Don't
# use the sloppy codec, because bad Windows-1252 characters are
# a bad sign.
encoded = text.encode('latin-1')
try:
fixed = encoded.decode('windows-1252')
steps = []
if fixed != text:
steps = [('encode', 'latin-1', 0),
('decode', 'windows-1252', 1)]
return fixed, steps
except UnicodeDecodeError:
# This text contained characters that don't even make sense
# if you assume they were supposed to be Windows-1252. In
# that case, let's not assume anything.
pass
# The cases that remain are mixups between two different single-byte
# encodings, and not the common case of Latin-1 vs. Windows-1252.
#
# These cases may be unsolvable without adding false positives, though
# I have vague ideas about how to optionally address them in the future.
# Return the text unchanged; the plan is empty.
return text, [] | python | def fix_one_step_and_explain(text):
"""
Performs a single step of re-decoding text that's been decoded incorrectly.
Returns the decoded text, plus a "plan" for how to reproduce what it did.
"""
if isinstance(text, bytes):
raise UnicodeError(BYTES_ERROR_TEXT)
if len(text) == 0:
return text, []
# The first plan is to return ASCII text unchanged.
if possible_encoding(text, 'ascii'):
return text, []
# As we go through the next step, remember the possible encodings
# that we encounter but don't successfully fix yet. We may need them
# later.
possible_1byte_encodings = []
# Suppose the text was supposed to be UTF-8, but it was decoded using
# a single-byte encoding instead. When these cases can be fixed, they
# are usually the correct thing to do, so try them next.
for encoding in CHARMAP_ENCODINGS:
if possible_encoding(text, encoding):
encoded_bytes = text.encode(encoding)
encode_step = ('encode', encoding, ENCODING_COSTS.get(encoding, 0))
transcode_steps = []
# Now, find out if it's UTF-8 (or close enough). Otherwise,
# remember the encoding for later.
try:
decoding = 'utf-8'
# Check encoded_bytes for sequences that would be UTF-8,
# except they have b' ' where b'\xa0' would belong.
if ALTERED_UTF8_RE.search(encoded_bytes):
encoded_bytes = restore_byte_a0(encoded_bytes)
cost = encoded_bytes.count(0xa0) * 2
transcode_steps.append(('transcode', 'restore_byte_a0', cost))
# Check for the byte 0x1a, which indicates where one of our
# 'sloppy' codecs found a replacement character.
if encoding.startswith('sloppy') and 0x1a in encoded_bytes:
encoded_bytes = replace_lossy_sequences(encoded_bytes)
transcode_steps.append(('transcode', 'replace_lossy_sequences', 0))
if 0xed in encoded_bytes or 0xc0 in encoded_bytes:
decoding = 'utf-8-variants'
decode_step = ('decode', decoding, 0)
steps = [encode_step] + transcode_steps + [decode_step]
fixed = encoded_bytes.decode(decoding)
return fixed, steps
except UnicodeDecodeError:
possible_1byte_encodings.append(encoding)
# Look for a-hat-euro sequences that remain, and fix them in isolation.
if PARTIAL_UTF8_PUNCT_RE.search(text):
steps = [('transcode', 'fix_partial_utf8_punct_in_1252', 1)]
fixed = fix_partial_utf8_punct_in_1252(text)
return fixed, steps
# The next most likely case is that this is Latin-1 that was intended to
# be read as Windows-1252, because those two encodings in particular are
# easily confused.
if 'latin-1' in possible_1byte_encodings:
if 'windows-1252' in possible_1byte_encodings:
# This text is in the intersection of Latin-1 and
# Windows-1252, so it's probably legit.
return text, []
else:
# Otherwise, it means we have characters that are in Latin-1 but
# not in Windows-1252. Those are C1 control characters. Nobody
# wants those. Assume they were meant to be Windows-1252. Don't
# use the sloppy codec, because bad Windows-1252 characters are
# a bad sign.
encoded = text.encode('latin-1')
try:
fixed = encoded.decode('windows-1252')
steps = []
if fixed != text:
steps = [('encode', 'latin-1', 0),
('decode', 'windows-1252', 1)]
return fixed, steps
except UnicodeDecodeError:
# This text contained characters that don't even make sense
# if you assume they were supposed to be Windows-1252. In
# that case, let's not assume anything.
pass
# The cases that remain are mixups between two different single-byte
# encodings, and not the common case of Latin-1 vs. Windows-1252.
#
# These cases may be unsolvable without adding false positives, though
# I have vague ideas about how to optionally address them in the future.
# Return the text unchanged; the plan is empty.
return text, [] | [
"def",
"fix_one_step_and_explain",
"(",
"text",
")",
":",
"if",
"isinstance",
"(",
"text",
",",
"bytes",
")",
":",
"raise",
"UnicodeError",
"(",
"BYTES_ERROR_TEXT",
")",
"if",
"len",
"(",
"text",
")",
"==",
"0",
":",
"return",
"text",
",",
"[",
"]",
"# The first plan is to return ASCII text unchanged.",
"if",
"possible_encoding",
"(",
"text",
",",
"'ascii'",
")",
":",
"return",
"text",
",",
"[",
"]",
"# As we go through the next step, remember the possible encodings",
"# that we encounter but don't successfully fix yet. We may need them",
"# later.",
"possible_1byte_encodings",
"=",
"[",
"]",
"# Suppose the text was supposed to be UTF-8, but it was decoded using",
"# a single-byte encoding instead. When these cases can be fixed, they",
"# are usually the correct thing to do, so try them next.",
"for",
"encoding",
"in",
"CHARMAP_ENCODINGS",
":",
"if",
"possible_encoding",
"(",
"text",
",",
"encoding",
")",
":",
"encoded_bytes",
"=",
"text",
".",
"encode",
"(",
"encoding",
")",
"encode_step",
"=",
"(",
"'encode'",
",",
"encoding",
",",
"ENCODING_COSTS",
".",
"get",
"(",
"encoding",
",",
"0",
")",
")",
"transcode_steps",
"=",
"[",
"]",
"# Now, find out if it's UTF-8 (or close enough). Otherwise,",
"# remember the encoding for later.",
"try",
":",
"decoding",
"=",
"'utf-8'",
"# Check encoded_bytes for sequences that would be UTF-8,",
"# except they have b' ' where b'\\xa0' would belong.",
"if",
"ALTERED_UTF8_RE",
".",
"search",
"(",
"encoded_bytes",
")",
":",
"encoded_bytes",
"=",
"restore_byte_a0",
"(",
"encoded_bytes",
")",
"cost",
"=",
"encoded_bytes",
".",
"count",
"(",
"0xa0",
")",
"*",
"2",
"transcode_steps",
".",
"append",
"(",
"(",
"'transcode'",
",",
"'restore_byte_a0'",
",",
"cost",
")",
")",
"# Check for the byte 0x1a, which indicates where one of our",
"# 'sloppy' codecs found a replacement character.",
"if",
"encoding",
".",
"startswith",
"(",
"'sloppy'",
")",
"and",
"0x1a",
"in",
"encoded_bytes",
":",
"encoded_bytes",
"=",
"replace_lossy_sequences",
"(",
"encoded_bytes",
")",
"transcode_steps",
".",
"append",
"(",
"(",
"'transcode'",
",",
"'replace_lossy_sequences'",
",",
"0",
")",
")",
"if",
"0xed",
"in",
"encoded_bytes",
"or",
"0xc0",
"in",
"encoded_bytes",
":",
"decoding",
"=",
"'utf-8-variants'",
"decode_step",
"=",
"(",
"'decode'",
",",
"decoding",
",",
"0",
")",
"steps",
"=",
"[",
"encode_step",
"]",
"+",
"transcode_steps",
"+",
"[",
"decode_step",
"]",
"fixed",
"=",
"encoded_bytes",
".",
"decode",
"(",
"decoding",
")",
"return",
"fixed",
",",
"steps",
"except",
"UnicodeDecodeError",
":",
"possible_1byte_encodings",
".",
"append",
"(",
"encoding",
")",
"# Look for a-hat-euro sequences that remain, and fix them in isolation.",
"if",
"PARTIAL_UTF8_PUNCT_RE",
".",
"search",
"(",
"text",
")",
":",
"steps",
"=",
"[",
"(",
"'transcode'",
",",
"'fix_partial_utf8_punct_in_1252'",
",",
"1",
")",
"]",
"fixed",
"=",
"fix_partial_utf8_punct_in_1252",
"(",
"text",
")",
"return",
"fixed",
",",
"steps",
"# The next most likely case is that this is Latin-1 that was intended to",
"# be read as Windows-1252, because those two encodings in particular are",
"# easily confused.",
"if",
"'latin-1'",
"in",
"possible_1byte_encodings",
":",
"if",
"'windows-1252'",
"in",
"possible_1byte_encodings",
":",
"# This text is in the intersection of Latin-1 and",
"# Windows-1252, so it's probably legit.",
"return",
"text",
",",
"[",
"]",
"else",
":",
"# Otherwise, it means we have characters that are in Latin-1 but",
"# not in Windows-1252. Those are C1 control characters. Nobody",
"# wants those. Assume they were meant to be Windows-1252. Don't",
"# use the sloppy codec, because bad Windows-1252 characters are",
"# a bad sign.",
"encoded",
"=",
"text",
".",
"encode",
"(",
"'latin-1'",
")",
"try",
":",
"fixed",
"=",
"encoded",
".",
"decode",
"(",
"'windows-1252'",
")",
"steps",
"=",
"[",
"]",
"if",
"fixed",
"!=",
"text",
":",
"steps",
"=",
"[",
"(",
"'encode'",
",",
"'latin-1'",
",",
"0",
")",
",",
"(",
"'decode'",
",",
"'windows-1252'",
",",
"1",
")",
"]",
"return",
"fixed",
",",
"steps",
"except",
"UnicodeDecodeError",
":",
"# This text contained characters that don't even make sense",
"# if you assume they were supposed to be Windows-1252. In",
"# that case, let's not assume anything.",
"pass",
"# The cases that remain are mixups between two different single-byte",
"# encodings, and not the common case of Latin-1 vs. Windows-1252.",
"#",
"# These cases may be unsolvable without adding false positives, though",
"# I have vague ideas about how to optionally address them in the future.",
"# Return the text unchanged; the plan is empty.",
"return",
"text",
",",
"[",
"]"
] | Performs a single step of re-decoding text that's been decoded incorrectly.
Returns the decoded text, plus a "plan" for how to reproduce what it did. | [
"Performs",
"a",
"single",
"step",
"of",
"re",
"-",
"decoding",
"text",
"that",
"s",
"been",
"decoded",
"incorrectly",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L161-L259 |
231,913 | LuminosoInsight/python-ftfy | ftfy/fixes.py | apply_plan | def apply_plan(text, plan):
"""
Apply a plan for fixing the encoding of text.
The plan is a list of tuples of the form (operation, encoding, cost):
- `operation` is 'encode' if it turns a string into bytes, 'decode' if it
turns bytes into a string, and 'transcode' if it keeps the type the same.
- `encoding` is the name of the encoding to use, such as 'utf-8' or
'latin-1', or the function name in the case of 'transcode'.
- The `cost` does not affect how the plan itself works. It's used by other
users of plans, namely `fix_encoding_and_explain`, which has to decide
*which* plan to use.
"""
obj = text
for operation, encoding, _ in plan:
if operation == 'encode':
obj = obj.encode(encoding)
elif operation == 'decode':
obj = obj.decode(encoding)
elif operation == 'transcode':
if encoding in TRANSCODERS:
obj = TRANSCODERS[encoding](obj)
else:
raise ValueError("Unknown transcode operation: %s" % encoding)
else:
raise ValueError("Unknown plan step: %s" % operation)
return obj | python | def apply_plan(text, plan):
"""
Apply a plan for fixing the encoding of text.
The plan is a list of tuples of the form (operation, encoding, cost):
- `operation` is 'encode' if it turns a string into bytes, 'decode' if it
turns bytes into a string, and 'transcode' if it keeps the type the same.
- `encoding` is the name of the encoding to use, such as 'utf-8' or
'latin-1', or the function name in the case of 'transcode'.
- The `cost` does not affect how the plan itself works. It's used by other
users of plans, namely `fix_encoding_and_explain`, which has to decide
*which* plan to use.
"""
obj = text
for operation, encoding, _ in plan:
if operation == 'encode':
obj = obj.encode(encoding)
elif operation == 'decode':
obj = obj.decode(encoding)
elif operation == 'transcode':
if encoding in TRANSCODERS:
obj = TRANSCODERS[encoding](obj)
else:
raise ValueError("Unknown transcode operation: %s" % encoding)
else:
raise ValueError("Unknown plan step: %s" % operation)
return obj | [
"def",
"apply_plan",
"(",
"text",
",",
"plan",
")",
":",
"obj",
"=",
"text",
"for",
"operation",
",",
"encoding",
",",
"_",
"in",
"plan",
":",
"if",
"operation",
"==",
"'encode'",
":",
"obj",
"=",
"obj",
".",
"encode",
"(",
"encoding",
")",
"elif",
"operation",
"==",
"'decode'",
":",
"obj",
"=",
"obj",
".",
"decode",
"(",
"encoding",
")",
"elif",
"operation",
"==",
"'transcode'",
":",
"if",
"encoding",
"in",
"TRANSCODERS",
":",
"obj",
"=",
"TRANSCODERS",
"[",
"encoding",
"]",
"(",
"obj",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unknown transcode operation: %s\"",
"%",
"encoding",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unknown plan step: %s\"",
"%",
"operation",
")",
"return",
"obj"
] | Apply a plan for fixing the encoding of text.
The plan is a list of tuples of the form (operation, encoding, cost):
- `operation` is 'encode' if it turns a string into bytes, 'decode' if it
turns bytes into a string, and 'transcode' if it keeps the type the same.
- `encoding` is the name of the encoding to use, such as 'utf-8' or
'latin-1', or the function name in the case of 'transcode'.
- The `cost` does not affect how the plan itself works. It's used by other
users of plans, namely `fix_encoding_and_explain`, which has to decide
*which* plan to use. | [
"Apply",
"a",
"plan",
"for",
"fixing",
"the",
"encoding",
"of",
"text",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L262-L290 |
231,914 | LuminosoInsight/python-ftfy | ftfy/fixes.py | _unescape_fixup | def _unescape_fixup(match):
"""
Replace one matched HTML entity with the character it represents,
if possible.
"""
text = match.group(0)
if text[:2] == "&#":
# character reference
try:
if text[:3] == "&#x":
codept = int(text[3:-1], 16)
else:
codept = int(text[2:-1])
if 0x80 <= codept < 0xa0:
# Decode this range of characters as Windows-1252, as Web
# browsers do in practice.
return bytes([codept]).decode('sloppy-windows-1252')
else:
return chr(codept)
except ValueError:
return text
else:
# This is a named entity; if it's a known HTML5 entity, replace
# it with the appropriate character.
try:
return entities.html5[text[1:]]
except KeyError:
return text | python | def _unescape_fixup(match):
"""
Replace one matched HTML entity with the character it represents,
if possible.
"""
text = match.group(0)
if text[:2] == "&#":
# character reference
try:
if text[:3] == "&#x":
codept = int(text[3:-1], 16)
else:
codept = int(text[2:-1])
if 0x80 <= codept < 0xa0:
# Decode this range of characters as Windows-1252, as Web
# browsers do in practice.
return bytes([codept]).decode('sloppy-windows-1252')
else:
return chr(codept)
except ValueError:
return text
else:
# This is a named entity; if it's a known HTML5 entity, replace
# it with the appropriate character.
try:
return entities.html5[text[1:]]
except KeyError:
return text | [
"def",
"_unescape_fixup",
"(",
"match",
")",
":",
"text",
"=",
"match",
".",
"group",
"(",
"0",
")",
"if",
"text",
"[",
":",
"2",
"]",
"==",
"\"&#\"",
":",
"# character reference",
"try",
":",
"if",
"text",
"[",
":",
"3",
"]",
"==",
"\"&#x\"",
":",
"codept",
"=",
"int",
"(",
"text",
"[",
"3",
":",
"-",
"1",
"]",
",",
"16",
")",
"else",
":",
"codept",
"=",
"int",
"(",
"text",
"[",
"2",
":",
"-",
"1",
"]",
")",
"if",
"0x80",
"<=",
"codept",
"<",
"0xa0",
":",
"# Decode this range of characters as Windows-1252, as Web",
"# browsers do in practice.",
"return",
"bytes",
"(",
"[",
"codept",
"]",
")",
".",
"decode",
"(",
"'sloppy-windows-1252'",
")",
"else",
":",
"return",
"chr",
"(",
"codept",
")",
"except",
"ValueError",
":",
"return",
"text",
"else",
":",
"# This is a named entity; if it's a known HTML5 entity, replace",
"# it with the appropriate character.",
"try",
":",
"return",
"entities",
".",
"html5",
"[",
"text",
"[",
"1",
":",
"]",
"]",
"except",
"KeyError",
":",
"return",
"text"
] | Replace one matched HTML entity with the character it represents,
if possible. | [
"Replace",
"one",
"matched",
"HTML",
"entity",
"with",
"the",
"character",
"it",
"represents",
"if",
"possible",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L296-L323 |
231,915 | LuminosoInsight/python-ftfy | ftfy/fixes.py | convert_surrogate_pair | def convert_surrogate_pair(match):
"""
Convert a surrogate pair to the single codepoint it represents.
This implements the formula described at:
http://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates
"""
pair = match.group(0)
codept = 0x10000 + (ord(pair[0]) - 0xd800) * 0x400 + (ord(pair[1]) - 0xdc00)
return chr(codept) | python | def convert_surrogate_pair(match):
"""
Convert a surrogate pair to the single codepoint it represents.
This implements the formula described at:
http://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates
"""
pair = match.group(0)
codept = 0x10000 + (ord(pair[0]) - 0xd800) * 0x400 + (ord(pair[1]) - 0xdc00)
return chr(codept) | [
"def",
"convert_surrogate_pair",
"(",
"match",
")",
":",
"pair",
"=",
"match",
".",
"group",
"(",
"0",
")",
"codept",
"=",
"0x10000",
"+",
"(",
"ord",
"(",
"pair",
"[",
"0",
"]",
")",
"-",
"0xd800",
")",
"*",
"0x400",
"+",
"(",
"ord",
"(",
"pair",
"[",
"1",
"]",
")",
"-",
"0xdc00",
")",
"return",
"chr",
"(",
"codept",
")"
] | Convert a surrogate pair to the single codepoint it represents.
This implements the formula described at:
http://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates | [
"Convert",
"a",
"surrogate",
"pair",
"to",
"the",
"single",
"codepoint",
"it",
"represents",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L457-L466 |
231,916 | LuminosoInsight/python-ftfy | ftfy/fixes.py | restore_byte_a0 | def restore_byte_a0(byts):
"""
Some mojibake has been additionally altered by a process that said "hmm,
byte A0, that's basically a space!" and replaced it with an ASCII space.
When the A0 is part of a sequence that we intend to decode as UTF-8,
changing byte A0 to 20 would make it fail to decode.
This process finds sequences that would convincingly decode as UTF-8 if
byte 20 were changed to A0, and puts back the A0. For the purpose of
deciding whether this is a good idea, this step gets a cost of twice
the number of bytes that are changed.
This is used as a step within `fix_encoding`.
"""
def replacement(match):
"The function to apply when this regex matches."
return match.group(0).replace(b'\x20', b'\xa0')
return ALTERED_UTF8_RE.sub(replacement, byts) | python | def restore_byte_a0(byts):
"""
Some mojibake has been additionally altered by a process that said "hmm,
byte A0, that's basically a space!" and replaced it with an ASCII space.
When the A0 is part of a sequence that we intend to decode as UTF-8,
changing byte A0 to 20 would make it fail to decode.
This process finds sequences that would convincingly decode as UTF-8 if
byte 20 were changed to A0, and puts back the A0. For the purpose of
deciding whether this is a good idea, this step gets a cost of twice
the number of bytes that are changed.
This is used as a step within `fix_encoding`.
"""
def replacement(match):
"The function to apply when this regex matches."
return match.group(0).replace(b'\x20', b'\xa0')
return ALTERED_UTF8_RE.sub(replacement, byts) | [
"def",
"restore_byte_a0",
"(",
"byts",
")",
":",
"def",
"replacement",
"(",
"match",
")",
":",
"\"The function to apply when this regex matches.\"",
"return",
"match",
".",
"group",
"(",
"0",
")",
".",
"replace",
"(",
"b'\\x20'",
",",
"b'\\xa0'",
")",
"return",
"ALTERED_UTF8_RE",
".",
"sub",
"(",
"replacement",
",",
"byts",
")"
] | Some mojibake has been additionally altered by a process that said "hmm,
byte A0, that's basically a space!" and replaced it with an ASCII space.
When the A0 is part of a sequence that we intend to decode as UTF-8,
changing byte A0 to 20 would make it fail to decode.
This process finds sequences that would convincingly decode as UTF-8 if
byte 20 were changed to A0, and puts back the A0. For the purpose of
deciding whether this is a good idea, this step gets a cost of twice
the number of bytes that are changed.
This is used as a step within `fix_encoding`. | [
"Some",
"mojibake",
"has",
"been",
"additionally",
"altered",
"by",
"a",
"process",
"that",
"said",
"hmm",
"byte",
"A0",
"that",
"s",
"basically",
"a",
"space!",
"and",
"replaced",
"it",
"with",
"an",
"ASCII",
"space",
".",
"When",
"the",
"A0",
"is",
"part",
"of",
"a",
"sequence",
"that",
"we",
"intend",
"to",
"decode",
"as",
"UTF",
"-",
"8",
"changing",
"byte",
"A0",
"to",
"20",
"would",
"make",
"it",
"fail",
"to",
"decode",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L582-L600 |
231,917 | LuminosoInsight/python-ftfy | ftfy/fixes.py | fix_partial_utf8_punct_in_1252 | def fix_partial_utf8_punct_in_1252(text):
"""
Fix particular characters that seem to be found in the wild encoded in
UTF-8 and decoded in Latin-1 or Windows-1252, even when this fix can't be
consistently applied.
One form of inconsistency we need to deal with is that some character might
be from the Latin-1 C1 control character set, while others are from the
set of characters that take their place in Windows-1252. So we first replace
those characters, then apply a fix that only works on Windows-1252 characters.
This is used as a transcoder within `fix_encoding`.
"""
def latin1_to_w1252(match):
"The function to apply when this regex matches."
return match.group(0).encode('latin-1').decode('sloppy-windows-1252')
def w1252_to_utf8(match):
"The function to apply when this regex matches."
return match.group(0).encode('sloppy-windows-1252').decode('utf-8')
text = C1_CONTROL_RE.sub(latin1_to_w1252, text)
return PARTIAL_UTF8_PUNCT_RE.sub(w1252_to_utf8, text) | python | def fix_partial_utf8_punct_in_1252(text):
"""
Fix particular characters that seem to be found in the wild encoded in
UTF-8 and decoded in Latin-1 or Windows-1252, even when this fix can't be
consistently applied.
One form of inconsistency we need to deal with is that some character might
be from the Latin-1 C1 control character set, while others are from the
set of characters that take their place in Windows-1252. So we first replace
those characters, then apply a fix that only works on Windows-1252 characters.
This is used as a transcoder within `fix_encoding`.
"""
def latin1_to_w1252(match):
"The function to apply when this regex matches."
return match.group(0).encode('latin-1').decode('sloppy-windows-1252')
def w1252_to_utf8(match):
"The function to apply when this regex matches."
return match.group(0).encode('sloppy-windows-1252').decode('utf-8')
text = C1_CONTROL_RE.sub(latin1_to_w1252, text)
return PARTIAL_UTF8_PUNCT_RE.sub(w1252_to_utf8, text) | [
"def",
"fix_partial_utf8_punct_in_1252",
"(",
"text",
")",
":",
"def",
"latin1_to_w1252",
"(",
"match",
")",
":",
"\"The function to apply when this regex matches.\"",
"return",
"match",
".",
"group",
"(",
"0",
")",
".",
"encode",
"(",
"'latin-1'",
")",
".",
"decode",
"(",
"'sloppy-windows-1252'",
")",
"def",
"w1252_to_utf8",
"(",
"match",
")",
":",
"\"The function to apply when this regex matches.\"",
"return",
"match",
".",
"group",
"(",
"0",
")",
".",
"encode",
"(",
"'sloppy-windows-1252'",
")",
".",
"decode",
"(",
"'utf-8'",
")",
"text",
"=",
"C1_CONTROL_RE",
".",
"sub",
"(",
"latin1_to_w1252",
",",
"text",
")",
"return",
"PARTIAL_UTF8_PUNCT_RE",
".",
"sub",
"(",
"w1252_to_utf8",
",",
"text",
")"
] | Fix particular characters that seem to be found in the wild encoded in
UTF-8 and decoded in Latin-1 or Windows-1252, even when this fix can't be
consistently applied.
One form of inconsistency we need to deal with is that some character might
be from the Latin-1 C1 control character set, while others are from the
set of characters that take their place in Windows-1252. So we first replace
those characters, then apply a fix that only works on Windows-1252 characters.
This is used as a transcoder within `fix_encoding`. | [
"Fix",
"particular",
"characters",
"that",
"seem",
"to",
"be",
"found",
"in",
"the",
"wild",
"encoded",
"in",
"UTF",
"-",
"8",
"and",
"decoded",
"in",
"Latin",
"-",
"1",
"or",
"Windows",
"-",
"1252",
"even",
"when",
"this",
"fix",
"can",
"t",
"be",
"consistently",
"applied",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L642-L664 |
231,918 | LuminosoInsight/python-ftfy | ftfy/formatting.py | display_ljust | def display_ljust(text, width, fillchar=' '):
"""
Return `text` left-justified in a Unicode string whose display width,
in a monospaced terminal, should be at least `width` character cells.
The rest of the string will be padded with `fillchar`, which must be
a width-1 character.
"Left" here means toward the beginning of the string, which may actually
appear on the right in an RTL context. This is similar to the use of the
word "left" in "left parenthesis".
>>> lines = ['Table flip', '(╯°□°)╯︵ ┻━┻', 'ちゃぶ台返し']
>>> for line in lines:
... print(display_ljust(line, 20, '▒'))
Table flip▒▒▒▒▒▒▒▒▒▒
(╯°□°)╯︵ ┻━┻▒▒▒▒▒▒▒
ちゃぶ台返し▒▒▒▒▒▒▒▒
This example, and the similar ones that follow, should come out justified
correctly when viewed in a monospaced terminal. It will probably not look
correct if you're viewing this code or documentation in a Web browser.
"""
if character_width(fillchar) != 1:
raise ValueError("The padding character must have display width 1")
text_width = monospaced_width(text)
if text_width == -1:
# There's a control character here, so just don't add padding
return text
padding = max(0, width - text_width)
return text + fillchar * padding | python | def display_ljust(text, width, fillchar=' '):
"""
Return `text` left-justified in a Unicode string whose display width,
in a monospaced terminal, should be at least `width` character cells.
The rest of the string will be padded with `fillchar`, which must be
a width-1 character.
"Left" here means toward the beginning of the string, which may actually
appear on the right in an RTL context. This is similar to the use of the
word "left" in "left parenthesis".
>>> lines = ['Table flip', '(╯°□°)╯︵ ┻━┻', 'ちゃぶ台返し']
>>> for line in lines:
... print(display_ljust(line, 20, '▒'))
Table flip▒▒▒▒▒▒▒▒▒▒
(╯°□°)╯︵ ┻━┻▒▒▒▒▒▒▒
ちゃぶ台返し▒▒▒▒▒▒▒▒
This example, and the similar ones that follow, should come out justified
correctly when viewed in a monospaced terminal. It will probably not look
correct if you're viewing this code or documentation in a Web browser.
"""
if character_width(fillchar) != 1:
raise ValueError("The padding character must have display width 1")
text_width = monospaced_width(text)
if text_width == -1:
# There's a control character here, so just don't add padding
return text
padding = max(0, width - text_width)
return text + fillchar * padding | [
"def",
"display_ljust",
"(",
"text",
",",
"width",
",",
"fillchar",
"=",
"' '",
")",
":",
"if",
"character_width",
"(",
"fillchar",
")",
"!=",
"1",
":",
"raise",
"ValueError",
"(",
"\"The padding character must have display width 1\"",
")",
"text_width",
"=",
"monospaced_width",
"(",
"text",
")",
"if",
"text_width",
"==",
"-",
"1",
":",
"# There's a control character here, so just don't add padding",
"return",
"text",
"padding",
"=",
"max",
"(",
"0",
",",
"width",
"-",
"text_width",
")",
"return",
"text",
"+",
"fillchar",
"*",
"padding"
] | Return `text` left-justified in a Unicode string whose display width,
in a monospaced terminal, should be at least `width` character cells.
The rest of the string will be padded with `fillchar`, which must be
a width-1 character.
"Left" here means toward the beginning of the string, which may actually
appear on the right in an RTL context. This is similar to the use of the
word "left" in "left parenthesis".
>>> lines = ['Table flip', '(╯°□°)╯︵ ┻━┻', 'ちゃぶ台返し']
>>> for line in lines:
... print(display_ljust(line, 20, '▒'))
Table flip▒▒▒▒▒▒▒▒▒▒
(╯°□°)╯︵ ┻━┻▒▒▒▒▒▒▒
ちゃぶ台返し▒▒▒▒▒▒▒▒
This example, and the similar ones that follow, should come out justified
correctly when viewed in a monospaced terminal. It will probably not look
correct if you're viewing this code or documentation in a Web browser. | [
"Return",
"text",
"left",
"-",
"justified",
"in",
"a",
"Unicode",
"string",
"whose",
"display",
"width",
"in",
"a",
"monospaced",
"terminal",
"should",
"be",
"at",
"least",
"width",
"character",
"cells",
".",
"The",
"rest",
"of",
"the",
"string",
"will",
"be",
"padded",
"with",
"fillchar",
"which",
"must",
"be",
"a",
"width",
"-",
"1",
"character",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/formatting.py#L67-L98 |
231,919 | LuminosoInsight/python-ftfy | ftfy/formatting.py | display_center | def display_center(text, width, fillchar=' '):
"""
Return `text` centered in a Unicode string whose display width, in a
monospaced terminal, should be at least `width` character cells. The rest
of the string will be padded with `fillchar`, which must be a width-1
character.
>>> lines = ['Table flip', '(╯°□°)╯︵ ┻━┻', 'ちゃぶ台返し']
>>> for line in lines:
... print(display_center(line, 20, '▒'))
▒▒▒▒▒Table flip▒▒▒▒▒
▒▒▒(╯°□°)╯︵ ┻━┻▒▒▒▒
▒▒▒▒ちゃぶ台返し▒▒▒▒
"""
if character_width(fillchar) != 1:
raise ValueError("The padding character must have display width 1")
text_width = monospaced_width(text)
if text_width == -1:
return text
padding = max(0, width - text_width)
left_padding = padding // 2
right_padding = padding - left_padding
return fillchar * left_padding + text + fillchar * right_padding | python | def display_center(text, width, fillchar=' '):
"""
Return `text` centered in a Unicode string whose display width, in a
monospaced terminal, should be at least `width` character cells. The rest
of the string will be padded with `fillchar`, which must be a width-1
character.
>>> lines = ['Table flip', '(╯°□°)╯︵ ┻━┻', 'ちゃぶ台返し']
>>> for line in lines:
... print(display_center(line, 20, '▒'))
▒▒▒▒▒Table flip▒▒▒▒▒
▒▒▒(╯°□°)╯︵ ┻━┻▒▒▒▒
▒▒▒▒ちゃぶ台返し▒▒▒▒
"""
if character_width(fillchar) != 1:
raise ValueError("The padding character must have display width 1")
text_width = monospaced_width(text)
if text_width == -1:
return text
padding = max(0, width - text_width)
left_padding = padding // 2
right_padding = padding - left_padding
return fillchar * left_padding + text + fillchar * right_padding | [
"def",
"display_center",
"(",
"text",
",",
"width",
",",
"fillchar",
"=",
"' '",
")",
":",
"if",
"character_width",
"(",
"fillchar",
")",
"!=",
"1",
":",
"raise",
"ValueError",
"(",
"\"The padding character must have display width 1\"",
")",
"text_width",
"=",
"monospaced_width",
"(",
"text",
")",
"if",
"text_width",
"==",
"-",
"1",
":",
"return",
"text",
"padding",
"=",
"max",
"(",
"0",
",",
"width",
"-",
"text_width",
")",
"left_padding",
"=",
"padding",
"//",
"2",
"right_padding",
"=",
"padding",
"-",
"left_padding",
"return",
"fillchar",
"*",
"left_padding",
"+",
"text",
"+",
"fillchar",
"*",
"right_padding"
] | Return `text` centered in a Unicode string whose display width, in a
monospaced terminal, should be at least `width` character cells. The rest
of the string will be padded with `fillchar`, which must be a width-1
character.
>>> lines = ['Table flip', '(╯°□°)╯︵ ┻━┻', 'ちゃぶ台返し']
>>> for line in lines:
... print(display_center(line, 20, '▒'))
▒▒▒▒▒Table flip▒▒▒▒▒
▒▒▒(╯°□°)╯︵ ┻━┻▒▒▒▒
▒▒▒▒ちゃぶ台返し▒▒▒▒ | [
"Return",
"text",
"centered",
"in",
"a",
"Unicode",
"string",
"whose",
"display",
"width",
"in",
"a",
"monospaced",
"terminal",
"should",
"be",
"at",
"least",
"width",
"character",
"cells",
".",
"The",
"rest",
"of",
"the",
"string",
"will",
"be",
"padded",
"with",
"fillchar",
"which",
"must",
"be",
"a",
"width",
"-",
"1",
"character",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/formatting.py#L130-L154 |
231,920 | LuminosoInsight/python-ftfy | ftfy/bad_codecs/sloppy.py | make_sloppy_codec | def make_sloppy_codec(encoding):
"""
Take a codec name, and return a 'sloppy' version of that codec that can
encode and decode the unassigned bytes in that encoding.
Single-byte encodings in the standard library are defined using some
boilerplate classes surrounding the functions that do the actual work,
`codecs.charmap_decode` and `charmap_encode`. This function, given an
encoding name, *defines* those boilerplate classes.
"""
# Make a bytestring of all 256 possible bytes.
all_bytes = bytes(range(256))
# Get a list of what they would decode to in Latin-1.
sloppy_chars = list(all_bytes.decode('latin-1'))
# Get a list of what they decode to in the given encoding. Use the
# replacement character for unassigned bytes.
if PY26:
decoded_chars = all_bytes.decode(encoding, 'replace')
else:
decoded_chars = all_bytes.decode(encoding, errors='replace')
# Update the sloppy_chars list. Each byte that was successfully decoded
# gets its decoded value in the list. The unassigned bytes are left as
# they are, which gives their decoding in Latin-1.
for i, char in enumerate(decoded_chars):
if char != REPLACEMENT_CHAR:
sloppy_chars[i] = char
# For ftfy's own purposes, we're going to allow byte 1A, the "Substitute"
# control code, to encode the Unicode replacement character U+FFFD.
sloppy_chars[0x1a] = REPLACEMENT_CHAR
# Create the data structures that tell the charmap methods how to encode
# and decode in this sloppy encoding.
decoding_table = ''.join(sloppy_chars)
encoding_table = codecs.charmap_build(decoding_table)
# Now produce all the class boilerplate. Look at the Python source for
# `encodings.cp1252` for comparison; this is almost exactly the same,
# except I made it follow pep8.
class Codec(codecs.Codec):
def encode(self, input, errors='strict'):
return codecs.charmap_encode(input, errors, encoding_table)
def decode(self, input, errors='strict'):
return codecs.charmap_decode(input, errors, decoding_table)
class IncrementalEncoder(codecs.IncrementalEncoder):
def encode(self, input, final=False):
return codecs.charmap_encode(input, self.errors, encoding_table)[0]
class IncrementalDecoder(codecs.IncrementalDecoder):
def decode(self, input, final=False):
return codecs.charmap_decode(input, self.errors, decoding_table)[0]
class StreamWriter(Codec, codecs.StreamWriter):
pass
class StreamReader(Codec, codecs.StreamReader):
pass
return codecs.CodecInfo(
name='sloppy-' + encoding,
encode=Codec().encode,
decode=Codec().decode,
incrementalencoder=IncrementalEncoder,
incrementaldecoder=IncrementalDecoder,
streamreader=StreamReader,
streamwriter=StreamWriter,
) | python | def make_sloppy_codec(encoding):
"""
Take a codec name, and return a 'sloppy' version of that codec that can
encode and decode the unassigned bytes in that encoding.
Single-byte encodings in the standard library are defined using some
boilerplate classes surrounding the functions that do the actual work,
`codecs.charmap_decode` and `charmap_encode`. This function, given an
encoding name, *defines* those boilerplate classes.
"""
# Make a bytestring of all 256 possible bytes.
all_bytes = bytes(range(256))
# Get a list of what they would decode to in Latin-1.
sloppy_chars = list(all_bytes.decode('latin-1'))
# Get a list of what they decode to in the given encoding. Use the
# replacement character for unassigned bytes.
if PY26:
decoded_chars = all_bytes.decode(encoding, 'replace')
else:
decoded_chars = all_bytes.decode(encoding, errors='replace')
# Update the sloppy_chars list. Each byte that was successfully decoded
# gets its decoded value in the list. The unassigned bytes are left as
# they are, which gives their decoding in Latin-1.
for i, char in enumerate(decoded_chars):
if char != REPLACEMENT_CHAR:
sloppy_chars[i] = char
# For ftfy's own purposes, we're going to allow byte 1A, the "Substitute"
# control code, to encode the Unicode replacement character U+FFFD.
sloppy_chars[0x1a] = REPLACEMENT_CHAR
# Create the data structures that tell the charmap methods how to encode
# and decode in this sloppy encoding.
decoding_table = ''.join(sloppy_chars)
encoding_table = codecs.charmap_build(decoding_table)
# Now produce all the class boilerplate. Look at the Python source for
# `encodings.cp1252` for comparison; this is almost exactly the same,
# except I made it follow pep8.
class Codec(codecs.Codec):
def encode(self, input, errors='strict'):
return codecs.charmap_encode(input, errors, encoding_table)
def decode(self, input, errors='strict'):
return codecs.charmap_decode(input, errors, decoding_table)
class IncrementalEncoder(codecs.IncrementalEncoder):
def encode(self, input, final=False):
return codecs.charmap_encode(input, self.errors, encoding_table)[0]
class IncrementalDecoder(codecs.IncrementalDecoder):
def decode(self, input, final=False):
return codecs.charmap_decode(input, self.errors, decoding_table)[0]
class StreamWriter(Codec, codecs.StreamWriter):
pass
class StreamReader(Codec, codecs.StreamReader):
pass
return codecs.CodecInfo(
name='sloppy-' + encoding,
encode=Codec().encode,
decode=Codec().decode,
incrementalencoder=IncrementalEncoder,
incrementaldecoder=IncrementalDecoder,
streamreader=StreamReader,
streamwriter=StreamWriter,
) | [
"def",
"make_sloppy_codec",
"(",
"encoding",
")",
":",
"# Make a bytestring of all 256 possible bytes.",
"all_bytes",
"=",
"bytes",
"(",
"range",
"(",
"256",
")",
")",
"# Get a list of what they would decode to in Latin-1.",
"sloppy_chars",
"=",
"list",
"(",
"all_bytes",
".",
"decode",
"(",
"'latin-1'",
")",
")",
"# Get a list of what they decode to in the given encoding. Use the",
"# replacement character for unassigned bytes.",
"if",
"PY26",
":",
"decoded_chars",
"=",
"all_bytes",
".",
"decode",
"(",
"encoding",
",",
"'replace'",
")",
"else",
":",
"decoded_chars",
"=",
"all_bytes",
".",
"decode",
"(",
"encoding",
",",
"errors",
"=",
"'replace'",
")",
"# Update the sloppy_chars list. Each byte that was successfully decoded",
"# gets its decoded value in the list. The unassigned bytes are left as",
"# they are, which gives their decoding in Latin-1.",
"for",
"i",
",",
"char",
"in",
"enumerate",
"(",
"decoded_chars",
")",
":",
"if",
"char",
"!=",
"REPLACEMENT_CHAR",
":",
"sloppy_chars",
"[",
"i",
"]",
"=",
"char",
"# For ftfy's own purposes, we're going to allow byte 1A, the \"Substitute\"",
"# control code, to encode the Unicode replacement character U+FFFD.",
"sloppy_chars",
"[",
"0x1a",
"]",
"=",
"REPLACEMENT_CHAR",
"# Create the data structures that tell the charmap methods how to encode",
"# and decode in this sloppy encoding.",
"decoding_table",
"=",
"''",
".",
"join",
"(",
"sloppy_chars",
")",
"encoding_table",
"=",
"codecs",
".",
"charmap_build",
"(",
"decoding_table",
")",
"# Now produce all the class boilerplate. Look at the Python source for",
"# `encodings.cp1252` for comparison; this is almost exactly the same,",
"# except I made it follow pep8.",
"class",
"Codec",
"(",
"codecs",
".",
"Codec",
")",
":",
"def",
"encode",
"(",
"self",
",",
"input",
",",
"errors",
"=",
"'strict'",
")",
":",
"return",
"codecs",
".",
"charmap_encode",
"(",
"input",
",",
"errors",
",",
"encoding_table",
")",
"def",
"decode",
"(",
"self",
",",
"input",
",",
"errors",
"=",
"'strict'",
")",
":",
"return",
"codecs",
".",
"charmap_decode",
"(",
"input",
",",
"errors",
",",
"decoding_table",
")",
"class",
"IncrementalEncoder",
"(",
"codecs",
".",
"IncrementalEncoder",
")",
":",
"def",
"encode",
"(",
"self",
",",
"input",
",",
"final",
"=",
"False",
")",
":",
"return",
"codecs",
".",
"charmap_encode",
"(",
"input",
",",
"self",
".",
"errors",
",",
"encoding_table",
")",
"[",
"0",
"]",
"class",
"IncrementalDecoder",
"(",
"codecs",
".",
"IncrementalDecoder",
")",
":",
"def",
"decode",
"(",
"self",
",",
"input",
",",
"final",
"=",
"False",
")",
":",
"return",
"codecs",
".",
"charmap_decode",
"(",
"input",
",",
"self",
".",
"errors",
",",
"decoding_table",
")",
"[",
"0",
"]",
"class",
"StreamWriter",
"(",
"Codec",
",",
"codecs",
".",
"StreamWriter",
")",
":",
"pass",
"class",
"StreamReader",
"(",
"Codec",
",",
"codecs",
".",
"StreamReader",
")",
":",
"pass",
"return",
"codecs",
".",
"CodecInfo",
"(",
"name",
"=",
"'sloppy-'",
"+",
"encoding",
",",
"encode",
"=",
"Codec",
"(",
")",
".",
"encode",
",",
"decode",
"=",
"Codec",
"(",
")",
".",
"decode",
",",
"incrementalencoder",
"=",
"IncrementalEncoder",
",",
"incrementaldecoder",
"=",
"IncrementalDecoder",
",",
"streamreader",
"=",
"StreamReader",
",",
"streamwriter",
"=",
"StreamWriter",
",",
")"
] | Take a codec name, and return a 'sloppy' version of that codec that can
encode and decode the unassigned bytes in that encoding.
Single-byte encodings in the standard library are defined using some
boilerplate classes surrounding the functions that do the actual work,
`codecs.charmap_decode` and `charmap_encode`. This function, given an
encoding name, *defines* those boilerplate classes. | [
"Take",
"a",
"codec",
"name",
"and",
"return",
"a",
"sloppy",
"version",
"of",
"that",
"codec",
"that",
"can",
"encode",
"and",
"decode",
"the",
"unassigned",
"bytes",
"in",
"that",
"encoding",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/bad_codecs/sloppy.py#L79-L150 |
231,921 | LuminosoInsight/python-ftfy | ftfy/badness.py | _make_weirdness_regex | def _make_weirdness_regex():
"""
Creates a list of regexes that match 'weird' character sequences.
The more matches there are, the weirder the text is.
"""
groups = []
# Match diacritical marks, except when they modify a non-cased letter or
# another mark.
#
# You wouldn't put a diacritical mark on a digit or a space, for example.
# You might put it on a Latin letter, but in that case there will almost
# always be a pre-composed version, and we normalize to pre-composed
# versions first. The cases that can't be pre-composed tend to be in
# large scripts without case, which are in class C.
groups.append('[^CM]M')
# Match non-Latin characters adjacent to Latin characters.
#
# This is a simplification from ftfy version 2, which compared all
# adjacent scripts. However, the ambiguities we need to resolve come from
# encodings designed to represent Latin characters.
groups.append('[Ll][AaC]')
groups.append('[AaC][Ll]')
# Match IPA letters next to capital letters.
#
# IPA uses lowercase letters only. Some accented capital letters next to
# punctuation can accidentally decode as IPA letters, and an IPA letter
# appearing next to a capital letter is a good sign that this happened.
groups.append('[LA]i')
groups.append('i[LA]')
# Match non-combining diacritics. We've already set aside the common ones
# like ^ (the CIRCUMFLEX ACCENT, repurposed as a caret, exponent sign,
# or happy eye) and assigned them to category 'o'. The remaining ones,
# like the diaeresis (¨), are pretty weird to see on their own instead
# of combined with a letter.
groups.append('2')
# Match C1 control characters, which are almost always the result of
# decoding Latin-1 that was meant to be Windows-1252.
groups.append('X')
# Match private use and unassigned characters.
groups.append('P')
groups.append('_')
# Match adjacent characters from any different pair of these categories:
# - Modifier marks (M)
# - Letter modifiers (m)
# - Miscellaneous numbers (N)
# - Symbols (1 or 3, because 2 is already weird on its own)
exclusive_categories = 'MmN13'
for cat1 in exclusive_categories:
others_range = ''.join(c for c in exclusive_categories if c != cat1)
groups.append('{cat1}[{others_range}]'.format(
cat1=cat1, others_range=others_range
))
regex = '|'.join(groups)
return re.compile(regex) | python | def _make_weirdness_regex():
"""
Creates a list of regexes that match 'weird' character sequences.
The more matches there are, the weirder the text is.
"""
groups = []
# Match diacritical marks, except when they modify a non-cased letter or
# another mark.
#
# You wouldn't put a diacritical mark on a digit or a space, for example.
# You might put it on a Latin letter, but in that case there will almost
# always be a pre-composed version, and we normalize to pre-composed
# versions first. The cases that can't be pre-composed tend to be in
# large scripts without case, which are in class C.
groups.append('[^CM]M')
# Match non-Latin characters adjacent to Latin characters.
#
# This is a simplification from ftfy version 2, which compared all
# adjacent scripts. However, the ambiguities we need to resolve come from
# encodings designed to represent Latin characters.
groups.append('[Ll][AaC]')
groups.append('[AaC][Ll]')
# Match IPA letters next to capital letters.
#
# IPA uses lowercase letters only. Some accented capital letters next to
# punctuation can accidentally decode as IPA letters, and an IPA letter
# appearing next to a capital letter is a good sign that this happened.
groups.append('[LA]i')
groups.append('i[LA]')
# Match non-combining diacritics. We've already set aside the common ones
# like ^ (the CIRCUMFLEX ACCENT, repurposed as a caret, exponent sign,
# or happy eye) and assigned them to category 'o'. The remaining ones,
# like the diaeresis (¨), are pretty weird to see on their own instead
# of combined with a letter.
groups.append('2')
# Match C1 control characters, which are almost always the result of
# decoding Latin-1 that was meant to be Windows-1252.
groups.append('X')
# Match private use and unassigned characters.
groups.append('P')
groups.append('_')
# Match adjacent characters from any different pair of these categories:
# - Modifier marks (M)
# - Letter modifiers (m)
# - Miscellaneous numbers (N)
# - Symbols (1 or 3, because 2 is already weird on its own)
exclusive_categories = 'MmN13'
for cat1 in exclusive_categories:
others_range = ''.join(c for c in exclusive_categories if c != cat1)
groups.append('{cat1}[{others_range}]'.format(
cat1=cat1, others_range=others_range
))
regex = '|'.join(groups)
return re.compile(regex) | [
"def",
"_make_weirdness_regex",
"(",
")",
":",
"groups",
"=",
"[",
"]",
"# Match diacritical marks, except when they modify a non-cased letter or",
"# another mark.",
"#",
"# You wouldn't put a diacritical mark on a digit or a space, for example.",
"# You might put it on a Latin letter, but in that case there will almost",
"# always be a pre-composed version, and we normalize to pre-composed",
"# versions first. The cases that can't be pre-composed tend to be in",
"# large scripts without case, which are in class C.",
"groups",
".",
"append",
"(",
"'[^CM]M'",
")",
"# Match non-Latin characters adjacent to Latin characters.",
"#",
"# This is a simplification from ftfy version 2, which compared all",
"# adjacent scripts. However, the ambiguities we need to resolve come from",
"# encodings designed to represent Latin characters.",
"groups",
".",
"append",
"(",
"'[Ll][AaC]'",
")",
"groups",
".",
"append",
"(",
"'[AaC][Ll]'",
")",
"# Match IPA letters next to capital letters.",
"#",
"# IPA uses lowercase letters only. Some accented capital letters next to",
"# punctuation can accidentally decode as IPA letters, and an IPA letter",
"# appearing next to a capital letter is a good sign that this happened.",
"groups",
".",
"append",
"(",
"'[LA]i'",
")",
"groups",
".",
"append",
"(",
"'i[LA]'",
")",
"# Match non-combining diacritics. We've already set aside the common ones",
"# like ^ (the CIRCUMFLEX ACCENT, repurposed as a caret, exponent sign,",
"# or happy eye) and assigned them to category 'o'. The remaining ones,",
"# like the diaeresis (¨), are pretty weird to see on their own instead",
"# of combined with a letter.",
"groups",
".",
"append",
"(",
"'2'",
")",
"# Match C1 control characters, which are almost always the result of",
"# decoding Latin-1 that was meant to be Windows-1252.",
"groups",
".",
"append",
"(",
"'X'",
")",
"# Match private use and unassigned characters.",
"groups",
".",
"append",
"(",
"'P'",
")",
"groups",
".",
"append",
"(",
"'_'",
")",
"# Match adjacent characters from any different pair of these categories:",
"# - Modifier marks (M)",
"# - Letter modifiers (m)",
"# - Miscellaneous numbers (N)",
"# - Symbols (1 or 3, because 2 is already weird on its own)",
"exclusive_categories",
"=",
"'MmN13'",
"for",
"cat1",
"in",
"exclusive_categories",
":",
"others_range",
"=",
"''",
".",
"join",
"(",
"c",
"for",
"c",
"in",
"exclusive_categories",
"if",
"c",
"!=",
"cat1",
")",
"groups",
".",
"append",
"(",
"'{cat1}[{others_range}]'",
".",
"format",
"(",
"cat1",
"=",
"cat1",
",",
"others_range",
"=",
"others_range",
")",
")",
"regex",
"=",
"'|'",
".",
"join",
"(",
"groups",
")",
"return",
"re",
".",
"compile",
"(",
"regex",
")"
] | Creates a list of regexes that match 'weird' character sequences.
The more matches there are, the weirder the text is. | [
"Creates",
"a",
"list",
"of",
"regexes",
"that",
"match",
"weird",
"character",
"sequences",
".",
"The",
"more",
"matches",
"there",
"are",
"the",
"weirder",
"the",
"text",
"is",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/badness.py#L31-L92 |
231,922 | LuminosoInsight/python-ftfy | ftfy/badness.py | sequence_weirdness | def sequence_weirdness(text):
"""
Determine how often a text has unexpected characters or sequences of
characters. This metric is used to disambiguate when text should be
re-decoded or left as is.
We start by normalizing text in NFC form, so that penalties for
diacritical marks don't apply to characters that know what to do with
them.
The following things are deemed weird:
- Lowercase letters followed by non-ASCII uppercase letters
- Non-Latin characters next to Latin characters
- Un-combined diacritical marks, unless they're stacking on non-alphabetic
characters (in languages that do that kind of thing a lot) or other
marks
- C1 control characters
- Adjacent symbols from any different pair of these categories:
- Modifier marks
- Letter modifiers
- Non-digit numbers
- Symbols (including math and currency)
The return value is the number of instances of weirdness.
"""
text2 = unicodedata.normalize('NFC', text)
weirdness = len(WEIRDNESS_RE.findall(chars_to_classes(text2)))
adjustment = (
len(MOJIBAKE_SYMBOL_RE.findall(text2)) * 2 -
len(COMMON_SYMBOL_RE.findall(text2))
)
return weirdness * 2 + adjustment | python | def sequence_weirdness(text):
"""
Determine how often a text has unexpected characters or sequences of
characters. This metric is used to disambiguate when text should be
re-decoded or left as is.
We start by normalizing text in NFC form, so that penalties for
diacritical marks don't apply to characters that know what to do with
them.
The following things are deemed weird:
- Lowercase letters followed by non-ASCII uppercase letters
- Non-Latin characters next to Latin characters
- Un-combined diacritical marks, unless they're stacking on non-alphabetic
characters (in languages that do that kind of thing a lot) or other
marks
- C1 control characters
- Adjacent symbols from any different pair of these categories:
- Modifier marks
- Letter modifiers
- Non-digit numbers
- Symbols (including math and currency)
The return value is the number of instances of weirdness.
"""
text2 = unicodedata.normalize('NFC', text)
weirdness = len(WEIRDNESS_RE.findall(chars_to_classes(text2)))
adjustment = (
len(MOJIBAKE_SYMBOL_RE.findall(text2)) * 2 -
len(COMMON_SYMBOL_RE.findall(text2))
)
return weirdness * 2 + adjustment | [
"def",
"sequence_weirdness",
"(",
"text",
")",
":",
"text2",
"=",
"unicodedata",
".",
"normalize",
"(",
"'NFC'",
",",
"text",
")",
"weirdness",
"=",
"len",
"(",
"WEIRDNESS_RE",
".",
"findall",
"(",
"chars_to_classes",
"(",
"text2",
")",
")",
")",
"adjustment",
"=",
"(",
"len",
"(",
"MOJIBAKE_SYMBOL_RE",
".",
"findall",
"(",
"text2",
")",
")",
"*",
"2",
"-",
"len",
"(",
"COMMON_SYMBOL_RE",
".",
"findall",
"(",
"text2",
")",
")",
")",
"return",
"weirdness",
"*",
"2",
"+",
"adjustment"
] | Determine how often a text has unexpected characters or sequences of
characters. This metric is used to disambiguate when text should be
re-decoded or left as is.
We start by normalizing text in NFC form, so that penalties for
diacritical marks don't apply to characters that know what to do with
them.
The following things are deemed weird:
- Lowercase letters followed by non-ASCII uppercase letters
- Non-Latin characters next to Latin characters
- Un-combined diacritical marks, unless they're stacking on non-alphabetic
characters (in languages that do that kind of thing a lot) or other
marks
- C1 control characters
- Adjacent symbols from any different pair of these categories:
- Modifier marks
- Letter modifiers
- Non-digit numbers
- Symbols (including math and currency)
The return value is the number of instances of weirdness. | [
"Determine",
"how",
"often",
"a",
"text",
"has",
"unexpected",
"characters",
"or",
"sequences",
"of",
"characters",
".",
"This",
"metric",
"is",
"used",
"to",
"disambiguate",
"when",
"text",
"should",
"be",
"re",
"-",
"decoded",
"or",
"left",
"as",
"is",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/badness.py#L157-L190 |
231,923 | LuminosoInsight/python-ftfy | ftfy/bad_codecs/__init__.py | search_function | def search_function(encoding):
"""
Register our "bad codecs" with Python's codecs API. This involves adding
a search function that takes in an encoding name, and returns a codec
for that encoding if it knows one, or None if it doesn't.
The encodings this will match are:
- Encodings of the form 'sloppy-windows-NNNN' or 'sloppy-iso-8859-N',
where the non-sloppy version is an encoding that leaves some bytes
unmapped to characters.
- The 'utf-8-variants' encoding, which has the several aliases seen
above.
"""
if encoding in _CACHE:
return _CACHE[encoding]
norm_encoding = normalize_encoding(encoding)
codec = None
if norm_encoding in UTF8_VAR_NAMES:
from ftfy.bad_codecs.utf8_variants import CODEC_INFO
codec = CODEC_INFO
elif norm_encoding.startswith('sloppy_'):
from ftfy.bad_codecs.sloppy import CODECS
codec = CODECS.get(norm_encoding)
if codec is not None:
_CACHE[encoding] = codec
return codec | python | def search_function(encoding):
"""
Register our "bad codecs" with Python's codecs API. This involves adding
a search function that takes in an encoding name, and returns a codec
for that encoding if it knows one, or None if it doesn't.
The encodings this will match are:
- Encodings of the form 'sloppy-windows-NNNN' or 'sloppy-iso-8859-N',
where the non-sloppy version is an encoding that leaves some bytes
unmapped to characters.
- The 'utf-8-variants' encoding, which has the several aliases seen
above.
"""
if encoding in _CACHE:
return _CACHE[encoding]
norm_encoding = normalize_encoding(encoding)
codec = None
if norm_encoding in UTF8_VAR_NAMES:
from ftfy.bad_codecs.utf8_variants import CODEC_INFO
codec = CODEC_INFO
elif norm_encoding.startswith('sloppy_'):
from ftfy.bad_codecs.sloppy import CODECS
codec = CODECS.get(norm_encoding)
if codec is not None:
_CACHE[encoding] = codec
return codec | [
"def",
"search_function",
"(",
"encoding",
")",
":",
"if",
"encoding",
"in",
"_CACHE",
":",
"return",
"_CACHE",
"[",
"encoding",
"]",
"norm_encoding",
"=",
"normalize_encoding",
"(",
"encoding",
")",
"codec",
"=",
"None",
"if",
"norm_encoding",
"in",
"UTF8_VAR_NAMES",
":",
"from",
"ftfy",
".",
"bad_codecs",
".",
"utf8_variants",
"import",
"CODEC_INFO",
"codec",
"=",
"CODEC_INFO",
"elif",
"norm_encoding",
".",
"startswith",
"(",
"'sloppy_'",
")",
":",
"from",
"ftfy",
".",
"bad_codecs",
".",
"sloppy",
"import",
"CODECS",
"codec",
"=",
"CODECS",
".",
"get",
"(",
"norm_encoding",
")",
"if",
"codec",
"is",
"not",
"None",
":",
"_CACHE",
"[",
"encoding",
"]",
"=",
"codec",
"return",
"codec"
] | Register our "bad codecs" with Python's codecs API. This involves adding
a search function that takes in an encoding name, and returns a codec
for that encoding if it knows one, or None if it doesn't.
The encodings this will match are:
- Encodings of the form 'sloppy-windows-NNNN' or 'sloppy-iso-8859-N',
where the non-sloppy version is an encoding that leaves some bytes
unmapped to characters.
- The 'utf-8-variants' encoding, which has the several aliases seen
above. | [
"Register",
"our",
"bad",
"codecs",
"with",
"Python",
"s",
"codecs",
"API",
".",
"This",
"involves",
"adding",
"a",
"search",
"function",
"that",
"takes",
"in",
"an",
"encoding",
"name",
"and",
"returns",
"a",
"codec",
"for",
"that",
"encoding",
"if",
"it",
"knows",
"one",
"or",
"None",
"if",
"it",
"doesn",
"t",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/bad_codecs/__init__.py#L47-L76 |
231,924 | LuminosoInsight/python-ftfy | ftfy/bad_codecs/utf8_variants.py | IncrementalDecoder._buffer_decode | def _buffer_decode(self, input, errors, final):
"""
Decode bytes that may be arriving in a stream, following the Codecs
API.
`input` is the incoming sequence of bytes. `errors` tells us how to
handle errors, though we delegate all error-handling cases to the real
UTF-8 decoder to ensure correct behavior. `final` indicates whether
this is the end of the sequence, in which case we should raise an
error given incomplete input.
Returns as much decoded text as possible, and the number of bytes
consumed.
"""
# decoded_segments are the pieces of text we have decoded so far,
# and position is our current position in the byte string. (Bytes
# before this position have been consumed, and bytes after it have
# yet to be decoded.)
decoded_segments = []
position = 0
while True:
# Use _buffer_decode_step to decode a segment of text.
decoded, consumed = self._buffer_decode_step(
input[position:],
errors,
final
)
if consumed == 0:
# Either there's nothing left to decode, or we need to wait
# for more input. Either way, we're done for now.
break
# Append the decoded text to the list, and update our position.
decoded_segments.append(decoded)
position += consumed
if final:
# _buffer_decode_step must consume all the bytes when `final` is
# true.
assert position == len(input)
return ''.join(decoded_segments), position | python | def _buffer_decode(self, input, errors, final):
"""
Decode bytes that may be arriving in a stream, following the Codecs
API.
`input` is the incoming sequence of bytes. `errors` tells us how to
handle errors, though we delegate all error-handling cases to the real
UTF-8 decoder to ensure correct behavior. `final` indicates whether
this is the end of the sequence, in which case we should raise an
error given incomplete input.
Returns as much decoded text as possible, and the number of bytes
consumed.
"""
# decoded_segments are the pieces of text we have decoded so far,
# and position is our current position in the byte string. (Bytes
# before this position have been consumed, and bytes after it have
# yet to be decoded.)
decoded_segments = []
position = 0
while True:
# Use _buffer_decode_step to decode a segment of text.
decoded, consumed = self._buffer_decode_step(
input[position:],
errors,
final
)
if consumed == 0:
# Either there's nothing left to decode, or we need to wait
# for more input. Either way, we're done for now.
break
# Append the decoded text to the list, and update our position.
decoded_segments.append(decoded)
position += consumed
if final:
# _buffer_decode_step must consume all the bytes when `final` is
# true.
assert position == len(input)
return ''.join(decoded_segments), position | [
"def",
"_buffer_decode",
"(",
"self",
",",
"input",
",",
"errors",
",",
"final",
")",
":",
"# decoded_segments are the pieces of text we have decoded so far,",
"# and position is our current position in the byte string. (Bytes",
"# before this position have been consumed, and bytes after it have",
"# yet to be decoded.)",
"decoded_segments",
"=",
"[",
"]",
"position",
"=",
"0",
"while",
"True",
":",
"# Use _buffer_decode_step to decode a segment of text.",
"decoded",
",",
"consumed",
"=",
"self",
".",
"_buffer_decode_step",
"(",
"input",
"[",
"position",
":",
"]",
",",
"errors",
",",
"final",
")",
"if",
"consumed",
"==",
"0",
":",
"# Either there's nothing left to decode, or we need to wait",
"# for more input. Either way, we're done for now.",
"break",
"# Append the decoded text to the list, and update our position.",
"decoded_segments",
".",
"append",
"(",
"decoded",
")",
"position",
"+=",
"consumed",
"if",
"final",
":",
"# _buffer_decode_step must consume all the bytes when `final` is",
"# true.",
"assert",
"position",
"==",
"len",
"(",
"input",
")",
"return",
"''",
".",
"join",
"(",
"decoded_segments",
")",
",",
"position"
] | Decode bytes that may be arriving in a stream, following the Codecs
API.
`input` is the incoming sequence of bytes. `errors` tells us how to
handle errors, though we delegate all error-handling cases to the real
UTF-8 decoder to ensure correct behavior. `final` indicates whether
this is the end of the sequence, in which case we should raise an
error given incomplete input.
Returns as much decoded text as possible, and the number of bytes
consumed. | [
"Decode",
"bytes",
"that",
"may",
"be",
"arriving",
"in",
"a",
"stream",
"following",
"the",
"Codecs",
"API",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/bad_codecs/utf8_variants.py#L88-L129 |
231,925 | LuminosoInsight/python-ftfy | ftfy/bad_codecs/utf8_variants.py | IncrementalDecoder._buffer_decode_surrogates | def _buffer_decode_surrogates(sup, input, errors, final):
"""
When we have improperly encoded surrogates, we can still see the
bits that they were meant to represent.
The surrogates were meant to encode a 20-bit number, to which we
add 0x10000 to get a codepoint. That 20-bit number now appears in
this form:
11101101 1010abcd 10efghij 11101101 1011klmn 10opqrst
The CESU8_RE above matches byte sequences of this form. Then we need
to extract the bits and assemble a codepoint number from them.
"""
if len(input) < 6:
if final:
# We found 0xed near the end of the stream, and there aren't
# six bytes to decode. Delegate to the superclass method to
# handle it as normal UTF-8. It might be a Hangul character
# or an error.
return sup(input, errors, final)
else:
# We found a surrogate, the stream isn't over yet, and we don't
# know enough of the following bytes to decode anything, so
# consume zero bytes and wait.
return '', 0
else:
if CESU8_RE.match(input):
# Given this is a CESU-8 sequence, do some math to pull out
# the intended 20-bit value, and consume six bytes.
codepoint = (
((input[1] & 0x0f) << 16) +
((input[2] & 0x3f) << 10) +
((input[4] & 0x0f) << 6) +
(input[5] & 0x3f) +
0x10000
)
return chr(codepoint), 6
else:
# This looked like a CESU-8 sequence, but it wasn't one.
# 0xed indicates the start of a three-byte sequence, so give
# three bytes to the superclass to decode as usual.
return sup(input[:3], errors, False) | python | def _buffer_decode_surrogates(sup, input, errors, final):
"""
When we have improperly encoded surrogates, we can still see the
bits that they were meant to represent.
The surrogates were meant to encode a 20-bit number, to which we
add 0x10000 to get a codepoint. That 20-bit number now appears in
this form:
11101101 1010abcd 10efghij 11101101 1011klmn 10opqrst
The CESU8_RE above matches byte sequences of this form. Then we need
to extract the bits and assemble a codepoint number from them.
"""
if len(input) < 6:
if final:
# We found 0xed near the end of the stream, and there aren't
# six bytes to decode. Delegate to the superclass method to
# handle it as normal UTF-8. It might be a Hangul character
# or an error.
return sup(input, errors, final)
else:
# We found a surrogate, the stream isn't over yet, and we don't
# know enough of the following bytes to decode anything, so
# consume zero bytes and wait.
return '', 0
else:
if CESU8_RE.match(input):
# Given this is a CESU-8 sequence, do some math to pull out
# the intended 20-bit value, and consume six bytes.
codepoint = (
((input[1] & 0x0f) << 16) +
((input[2] & 0x3f) << 10) +
((input[4] & 0x0f) << 6) +
(input[5] & 0x3f) +
0x10000
)
return chr(codepoint), 6
else:
# This looked like a CESU-8 sequence, but it wasn't one.
# 0xed indicates the start of a three-byte sequence, so give
# three bytes to the superclass to decode as usual.
return sup(input[:3], errors, False) | [
"def",
"_buffer_decode_surrogates",
"(",
"sup",
",",
"input",
",",
"errors",
",",
"final",
")",
":",
"if",
"len",
"(",
"input",
")",
"<",
"6",
":",
"if",
"final",
":",
"# We found 0xed near the end of the stream, and there aren't",
"# six bytes to decode. Delegate to the superclass method to",
"# handle it as normal UTF-8. It might be a Hangul character",
"# or an error.",
"return",
"sup",
"(",
"input",
",",
"errors",
",",
"final",
")",
"else",
":",
"# We found a surrogate, the stream isn't over yet, and we don't",
"# know enough of the following bytes to decode anything, so",
"# consume zero bytes and wait.",
"return",
"''",
",",
"0",
"else",
":",
"if",
"CESU8_RE",
".",
"match",
"(",
"input",
")",
":",
"# Given this is a CESU-8 sequence, do some math to pull out",
"# the intended 20-bit value, and consume six bytes.",
"codepoint",
"=",
"(",
"(",
"(",
"input",
"[",
"1",
"]",
"&",
"0x0f",
")",
"<<",
"16",
")",
"+",
"(",
"(",
"input",
"[",
"2",
"]",
"&",
"0x3f",
")",
"<<",
"10",
")",
"+",
"(",
"(",
"input",
"[",
"4",
"]",
"&",
"0x0f",
")",
"<<",
"6",
")",
"+",
"(",
"input",
"[",
"5",
"]",
"&",
"0x3f",
")",
"+",
"0x10000",
")",
"return",
"chr",
"(",
"codepoint",
")",
",",
"6",
"else",
":",
"# This looked like a CESU-8 sequence, but it wasn't one.",
"# 0xed indicates the start of a three-byte sequence, so give",
"# three bytes to the superclass to decode as usual.",
"return",
"sup",
"(",
"input",
"[",
":",
"3",
"]",
",",
"errors",
",",
"False",
")"
] | When we have improperly encoded surrogates, we can still see the
bits that they were meant to represent.
The surrogates were meant to encode a 20-bit number, to which we
add 0x10000 to get a codepoint. That 20-bit number now appears in
this form:
11101101 1010abcd 10efghij 11101101 1011klmn 10opqrst
The CESU8_RE above matches byte sequences of this form. Then we need
to extract the bits and assemble a codepoint number from them. | [
"When",
"we",
"have",
"improperly",
"encoded",
"surrogates",
"we",
"can",
"still",
"see",
"the",
"bits",
"that",
"they",
"were",
"meant",
"to",
"represent",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/bad_codecs/utf8_variants.py#L173-L215 |
231,926 | LuminosoInsight/python-ftfy | ftfy/__init__.py | fix_text | def fix_text(text,
*,
fix_entities='auto',
remove_terminal_escapes=True,
fix_encoding=True,
fix_latin_ligatures=True,
fix_character_width=True,
uncurl_quotes=True,
fix_line_breaks=True,
fix_surrogates=True,
remove_control_chars=True,
remove_bom=True,
normalization='NFC',
max_decode_length=10**6):
r"""
Given Unicode text as input, fix inconsistencies and glitches in it,
such as mojibake.
Let's start with some examples:
>>> print(fix_text('ünicode'))
ünicode
>>> print(fix_text('Broken text… it’s flubberific!',
... normalization='NFKC'))
Broken text... it's flubberific!
>>> print(fix_text('HTML entities <3'))
HTML entities <3
>>> print(fix_text('<em>HTML entities <3</em>'))
<em>HTML entities <3</em>
>>> print(fix_text("¯\\_(ã\x83\x84)_/¯"))
¯\_(ツ)_/¯
>>> # This example string starts with a byte-order mark, even if
>>> # you can't see it on the Web.
>>> print(fix_text('\ufeffParty like\nit’s 1999!'))
Party like
it's 1999!
>>> print(fix_text('ＬＯＵＤ ＮＯＩＳＥＳ'))
LOUD NOISES
>>> len(fix_text('fi' * 100000))
200000
>>> len(fix_text(''))
0
Based on the options you provide, ftfy applies these steps in order:
- If `remove_terminal_escapes` is True, remove sequences of bytes that are
instructions for Unix terminals, such as the codes that make text appear
in different colors.
- If `fix_encoding` is True, look for common mistakes that come from
encoding or decoding Unicode text incorrectly, and fix them if they are
reasonably fixable. See `fixes.fix_encoding` for details.
- If `fix_entities` is True, replace HTML entities with their equivalent
characters. If it's "auto" (the default), then consider replacing HTML
entities, but don't do so in text where you have seen a pair of actual
angle brackets (that's probably actually HTML and you shouldn't mess
with the entities).
- If `uncurl_quotes` is True, replace various curly quotation marks with
plain-ASCII straight quotes.
- If `fix_latin_ligatures` is True, then ligatures made of Latin letters,
such as `fi`, will be separated into individual letters. These ligatures
are usually not meaningful outside of font rendering, and often represent
copy-and-paste errors.
- If `fix_character_width` is True, half-width and full-width characters
will be replaced by their standard-width form.
- If `fix_line_breaks` is true, convert all line breaks to Unix style
(CRLF and CR line breaks become LF line breaks).
- If `fix_surrogates` is true, ensure that there are no UTF-16 surrogates
in the resulting string, by converting them to the correct characters
when they're appropriately paired, or replacing them with \ufffd
otherwise.
- If `remove_control_chars` is true, remove control characters that
are not suitable for use in text. This includes most of the ASCII control
characters, plus some Unicode controls such as the byte order mark
(U+FEFF). Useful control characters, such as Tab, Line Feed, and
bidirectional marks, are left as they are.
- If `remove_bom` is True, remove the Byte-Order Mark at the start of the
string if it exists. (This is largely redundant, because it's a special
case of `remove_control_characters`. This option will become deprecated
in a later version.)
- If `normalization` is not None, apply the specified form of Unicode
normalization, which can be one of 'NFC', 'NFKC', 'NFD', and 'NFKD'.
- The default normalization, NFC, combines characters and diacritics that
are written using separate code points, such as converting "e" plus an
acute accent modifier into "é", or converting "ka" (か) plus a dakuten
into the single character "ga" (が). Unicode can be converted to NFC
form without any change in its meaning.
- If you ask for NFKC normalization, it will apply additional
normalizations that can change the meanings of characters. For example,
ellipsis characters will be replaced with three periods, all ligatures
will be replaced with the individual characters that make them up,
and characters that differ in font style will be converted to the same
character.
- If anything was changed, repeat all the steps, so that the function is
idempotent. "&amp;" will become "&", for example, not "&".
`fix_text` will work one line at a time, with the possibility that some
lines are in different encodings, allowing it to fix text that has been
concatenated together from different sources.
When it encounters lines longer than `max_decode_length` (1 million
codepoints by default), it will not run the `fix_encoding` step, to avoid
unbounded slowdowns.
If you're certain that any decoding errors in the text would have affected
the entire text in the same way, and you don't mind operations that scale
with the length of the text, you can use `fix_text_segment` directly to
fix the whole string in one batch.
"""
if isinstance(text, bytes):
raise UnicodeError(fixes.BYTES_ERROR_TEXT)
out = []
pos = 0
while pos < len(text):
textbreak = text.find('\n', pos) + 1
fix_encoding_this_time = fix_encoding
if textbreak == 0:
textbreak = len(text)
if (textbreak - pos) > max_decode_length:
fix_encoding_this_time = False
substring = text[pos:textbreak]
if fix_entities == 'auto' and '<' in substring and '>' in substring:
# we see angle brackets together; this could be HTML
fix_entities = False
out.append(
fix_text_segment(
substring,
fix_entities=fix_entities,
remove_terminal_escapes=remove_terminal_escapes,
fix_encoding=fix_encoding_this_time,
uncurl_quotes=uncurl_quotes,
fix_latin_ligatures=fix_latin_ligatures,
fix_character_width=fix_character_width,
fix_line_breaks=fix_line_breaks,
fix_surrogates=fix_surrogates,
remove_control_chars=remove_control_chars,
remove_bom=remove_bom,
normalization=normalization
)
)
pos = textbreak
return ''.join(out) | python | def fix_text(text,
*,
fix_entities='auto',
remove_terminal_escapes=True,
fix_encoding=True,
fix_latin_ligatures=True,
fix_character_width=True,
uncurl_quotes=True,
fix_line_breaks=True,
fix_surrogates=True,
remove_control_chars=True,
remove_bom=True,
normalization='NFC',
max_decode_length=10**6):
r"""
Given Unicode text as input, fix inconsistencies and glitches in it,
such as mojibake.
Let's start with some examples:
>>> print(fix_text('ünicode'))
ünicode
>>> print(fix_text('Broken text… it’s flubberific!',
... normalization='NFKC'))
Broken text... it's flubberific!
>>> print(fix_text('HTML entities <3'))
HTML entities <3
>>> print(fix_text('<em>HTML entities <3</em>'))
<em>HTML entities <3</em>
>>> print(fix_text("¯\\_(ã\x83\x84)_/¯"))
¯\_(ツ)_/¯
>>> # This example string starts with a byte-order mark, even if
>>> # you can't see it on the Web.
>>> print(fix_text('\ufeffParty like\nit’s 1999!'))
Party like
it's 1999!
>>> print(fix_text('ＬＯＵＤ ＮＯＩＳＥＳ'))
LOUD NOISES
>>> len(fix_text('fi' * 100000))
200000
>>> len(fix_text(''))
0
Based on the options you provide, ftfy applies these steps in order:
- If `remove_terminal_escapes` is True, remove sequences of bytes that are
instructions for Unix terminals, such as the codes that make text appear
in different colors.
- If `fix_encoding` is True, look for common mistakes that come from
encoding or decoding Unicode text incorrectly, and fix them if they are
reasonably fixable. See `fixes.fix_encoding` for details.
- If `fix_entities` is True, replace HTML entities with their equivalent
characters. If it's "auto" (the default), then consider replacing HTML
entities, but don't do so in text where you have seen a pair of actual
angle brackets (that's probably actually HTML and you shouldn't mess
with the entities).
- If `uncurl_quotes` is True, replace various curly quotation marks with
plain-ASCII straight quotes.
- If `fix_latin_ligatures` is True, then ligatures made of Latin letters,
such as `fi`, will be separated into individual letters. These ligatures
are usually not meaningful outside of font rendering, and often represent
copy-and-paste errors.
- If `fix_character_width` is True, half-width and full-width characters
will be replaced by their standard-width form.
- If `fix_line_breaks` is true, convert all line breaks to Unix style
(CRLF and CR line breaks become LF line breaks).
- If `fix_surrogates` is true, ensure that there are no UTF-16 surrogates
in the resulting string, by converting them to the correct characters
when they're appropriately paired, or replacing them with \ufffd
otherwise.
- If `remove_control_chars` is true, remove control characters that
are not suitable for use in text. This includes most of the ASCII control
characters, plus some Unicode controls such as the byte order mark
(U+FEFF). Useful control characters, such as Tab, Line Feed, and
bidirectional marks, are left as they are.
- If `remove_bom` is True, remove the Byte-Order Mark at the start of the
string if it exists. (This is largely redundant, because it's a special
case of `remove_control_characters`. This option will become deprecated
in a later version.)
- If `normalization` is not None, apply the specified form of Unicode
normalization, which can be one of 'NFC', 'NFKC', 'NFD', and 'NFKD'.
- The default normalization, NFC, combines characters and diacritics that
are written using separate code points, such as converting "e" plus an
acute accent modifier into "é", or converting "ka" (か) plus a dakuten
into the single character "ga" (が). Unicode can be converted to NFC
form without any change in its meaning.
- If you ask for NFKC normalization, it will apply additional
normalizations that can change the meanings of characters. For example,
ellipsis characters will be replaced with three periods, all ligatures
will be replaced with the individual characters that make them up,
and characters that differ in font style will be converted to the same
character.
- If anything was changed, repeat all the steps, so that the function is
idempotent. "&amp;" will become "&", for example, not "&".
`fix_text` will work one line at a time, with the possibility that some
lines are in different encodings, allowing it to fix text that has been
concatenated together from different sources.
When it encounters lines longer than `max_decode_length` (1 million
codepoints by default), it will not run the `fix_encoding` step, to avoid
unbounded slowdowns.
If you're certain that any decoding errors in the text would have affected
the entire text in the same way, and you don't mind operations that scale
with the length of the text, you can use `fix_text_segment` directly to
fix the whole string in one batch.
"""
if isinstance(text, bytes):
raise UnicodeError(fixes.BYTES_ERROR_TEXT)
out = []
pos = 0
while pos < len(text):
textbreak = text.find('\n', pos) + 1
fix_encoding_this_time = fix_encoding
if textbreak == 0:
textbreak = len(text)
if (textbreak - pos) > max_decode_length:
fix_encoding_this_time = False
substring = text[pos:textbreak]
if fix_entities == 'auto' and '<' in substring and '>' in substring:
# we see angle brackets together; this could be HTML
fix_entities = False
out.append(
fix_text_segment(
substring,
fix_entities=fix_entities,
remove_terminal_escapes=remove_terminal_escapes,
fix_encoding=fix_encoding_this_time,
uncurl_quotes=uncurl_quotes,
fix_latin_ligatures=fix_latin_ligatures,
fix_character_width=fix_character_width,
fix_line_breaks=fix_line_breaks,
fix_surrogates=fix_surrogates,
remove_control_chars=remove_control_chars,
remove_bom=remove_bom,
normalization=normalization
)
)
pos = textbreak
return ''.join(out) | [
"def",
"fix_text",
"(",
"text",
",",
"*",
",",
"fix_entities",
"=",
"'auto'",
",",
"remove_terminal_escapes",
"=",
"True",
",",
"fix_encoding",
"=",
"True",
",",
"fix_latin_ligatures",
"=",
"True",
",",
"fix_character_width",
"=",
"True",
",",
"uncurl_quotes",
"=",
"True",
",",
"fix_line_breaks",
"=",
"True",
",",
"fix_surrogates",
"=",
"True",
",",
"remove_control_chars",
"=",
"True",
",",
"remove_bom",
"=",
"True",
",",
"normalization",
"=",
"'NFC'",
",",
"max_decode_length",
"=",
"10",
"**",
"6",
")",
":",
"if",
"isinstance",
"(",
"text",
",",
"bytes",
")",
":",
"raise",
"UnicodeError",
"(",
"fixes",
".",
"BYTES_ERROR_TEXT",
")",
"out",
"=",
"[",
"]",
"pos",
"=",
"0",
"while",
"pos",
"<",
"len",
"(",
"text",
")",
":",
"textbreak",
"=",
"text",
".",
"find",
"(",
"'\\n'",
",",
"pos",
")",
"+",
"1",
"fix_encoding_this_time",
"=",
"fix_encoding",
"if",
"textbreak",
"==",
"0",
":",
"textbreak",
"=",
"len",
"(",
"text",
")",
"if",
"(",
"textbreak",
"-",
"pos",
")",
">",
"max_decode_length",
":",
"fix_encoding_this_time",
"=",
"False",
"substring",
"=",
"text",
"[",
"pos",
":",
"textbreak",
"]",
"if",
"fix_entities",
"==",
"'auto'",
"and",
"'<'",
"in",
"substring",
"and",
"'>'",
"in",
"substring",
":",
"# we see angle brackets together; this could be HTML",
"fix_entities",
"=",
"False",
"out",
".",
"append",
"(",
"fix_text_segment",
"(",
"substring",
",",
"fix_entities",
"=",
"fix_entities",
",",
"remove_terminal_escapes",
"=",
"remove_terminal_escapes",
",",
"fix_encoding",
"=",
"fix_encoding_this_time",
",",
"uncurl_quotes",
"=",
"uncurl_quotes",
",",
"fix_latin_ligatures",
"=",
"fix_latin_ligatures",
",",
"fix_character_width",
"=",
"fix_character_width",
",",
"fix_line_breaks",
"=",
"fix_line_breaks",
",",
"fix_surrogates",
"=",
"fix_surrogates",
",",
"remove_control_chars",
"=",
"remove_control_chars",
",",
"remove_bom",
"=",
"remove_bom",
",",
"normalization",
"=",
"normalization",
")",
")",
"pos",
"=",
"textbreak",
"return",
"''",
".",
"join",
"(",
"out",
")"
] | r"""
Given Unicode text as input, fix inconsistencies and glitches in it,
such as mojibake.
Let's start with some examples:
>>> print(fix_text('ünicode'))
ünicode
>>> print(fix_text('Broken text… it’s flubberific!',
... normalization='NFKC'))
Broken text... it's flubberific!
>>> print(fix_text('HTML entities <3'))
HTML entities <3
>>> print(fix_text('<em>HTML entities <3</em>'))
<em>HTML entities <3</em>
>>> print(fix_text("¯\\_(ã\x83\x84)_/¯"))
¯\_(ツ)_/¯
>>> # This example string starts with a byte-order mark, even if
>>> # you can't see it on the Web.
>>> print(fix_text('\ufeffParty like\nit’s 1999!'))
Party like
it's 1999!
>>> print(fix_text('ＬＯＵＤ ＮＯＩＳＥＳ'))
LOUD NOISES
>>> len(fix_text('fi' * 100000))
200000
>>> len(fix_text(''))
0
Based on the options you provide, ftfy applies these steps in order:
- If `remove_terminal_escapes` is True, remove sequences of bytes that are
instructions for Unix terminals, such as the codes that make text appear
in different colors.
- If `fix_encoding` is True, look for common mistakes that come from
encoding or decoding Unicode text incorrectly, and fix them if they are
reasonably fixable. See `fixes.fix_encoding` for details.
- If `fix_entities` is True, replace HTML entities with their equivalent
characters. If it's "auto" (the default), then consider replacing HTML
entities, but don't do so in text where you have seen a pair of actual
angle brackets (that's probably actually HTML and you shouldn't mess
with the entities).
- If `uncurl_quotes` is True, replace various curly quotation marks with
plain-ASCII straight quotes.
- If `fix_latin_ligatures` is True, then ligatures made of Latin letters,
such as `fi`, will be separated into individual letters. These ligatures
are usually not meaningful outside of font rendering, and often represent
copy-and-paste errors.
- If `fix_character_width` is True, half-width and full-width characters
will be replaced by their standard-width form.
- If `fix_line_breaks` is true, convert all line breaks to Unix style
(CRLF and CR line breaks become LF line breaks).
- If `fix_surrogates` is true, ensure that there are no UTF-16 surrogates
in the resulting string, by converting them to the correct characters
when they're appropriately paired, or replacing them with \ufffd
otherwise.
- If `remove_control_chars` is true, remove control characters that
are not suitable for use in text. This includes most of the ASCII control
characters, plus some Unicode controls such as the byte order mark
(U+FEFF). Useful control characters, such as Tab, Line Feed, and
bidirectional marks, are left as they are.
- If `remove_bom` is True, remove the Byte-Order Mark at the start of the
string if it exists. (This is largely redundant, because it's a special
case of `remove_control_characters`. This option will become deprecated
in a later version.)
- If `normalization` is not None, apply the specified form of Unicode
normalization, which can be one of 'NFC', 'NFKC', 'NFD', and 'NFKD'.
- The default normalization, NFC, combines characters and diacritics that
are written using separate code points, such as converting "e" plus an
acute accent modifier into "é", or converting "ka" (か) plus a dakuten
into the single character "ga" (が). Unicode can be converted to NFC
form without any change in its meaning.
- If you ask for NFKC normalization, it will apply additional
normalizations that can change the meanings of characters. For example,
ellipsis characters will be replaced with three periods, all ligatures
will be replaced with the individual characters that make them up,
and characters that differ in font style will be converted to the same
character.
- If anything was changed, repeat all the steps, so that the function is
idempotent. "&amp;" will become "&", for example, not "&".
`fix_text` will work one line at a time, with the possibility that some
lines are in different encodings, allowing it to fix text that has been
concatenated together from different sources.
When it encounters lines longer than `max_decode_length` (1 million
codepoints by default), it will not run the `fix_encoding` step, to avoid
unbounded slowdowns.
If you're certain that any decoding errors in the text would have affected
the entire text in the same way, and you don't mind operations that scale
with the length of the text, you can use `fix_text_segment` directly to
fix the whole string in one batch. | [
"r",
"Given",
"Unicode",
"text",
"as",
"input",
"fix",
"inconsistencies",
"and",
"glitches",
"in",
"it",
"such",
"as",
"mojibake",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/__init__.py#L20-L186 |
231,927 | LuminosoInsight/python-ftfy | ftfy/__init__.py | fix_file | def fix_file(input_file,
encoding=None,
*,
fix_entities='auto',
remove_terminal_escapes=True,
fix_encoding=True,
fix_latin_ligatures=True,
fix_character_width=True,
uncurl_quotes=True,
fix_line_breaks=True,
fix_surrogates=True,
remove_control_chars=True,
remove_bom=True,
normalization='NFC'):
"""
Fix text that is found in a file.
If the file is being read as Unicode text, use that. If it's being read as
bytes, then we hope an encoding was supplied. If not, unfortunately, we
have to guess what encoding it is. We'll try a few common encodings, but we
make no promises. See the `guess_bytes` function for how this is done.
The output is a stream of fixed lines of text.
"""
entities = fix_entities
for line in input_file:
if isinstance(line, bytes):
if encoding is None:
line, encoding = guess_bytes(line)
else:
line = line.decode(encoding)
if fix_entities == 'auto' and '<' in line and '>' in line:
entities = False
yield fix_text_segment(
line,
fix_entities=entities,
remove_terminal_escapes=remove_terminal_escapes,
fix_encoding=fix_encoding,
fix_latin_ligatures=fix_latin_ligatures,
fix_character_width=fix_character_width,
uncurl_quotes=uncurl_quotes,
fix_line_breaks=fix_line_breaks,
fix_surrogates=fix_surrogates,
remove_control_chars=remove_control_chars,
remove_bom=remove_bom,
normalization=normalization
) | python | def fix_file(input_file,
encoding=None,
*,
fix_entities='auto',
remove_terminal_escapes=True,
fix_encoding=True,
fix_latin_ligatures=True,
fix_character_width=True,
uncurl_quotes=True,
fix_line_breaks=True,
fix_surrogates=True,
remove_control_chars=True,
remove_bom=True,
normalization='NFC'):
"""
Fix text that is found in a file.
If the file is being read as Unicode text, use that. If it's being read as
bytes, then we hope an encoding was supplied. If not, unfortunately, we
have to guess what encoding it is. We'll try a few common encodings, but we
make no promises. See the `guess_bytes` function for how this is done.
The output is a stream of fixed lines of text.
"""
entities = fix_entities
for line in input_file:
if isinstance(line, bytes):
if encoding is None:
line, encoding = guess_bytes(line)
else:
line = line.decode(encoding)
if fix_entities == 'auto' and '<' in line and '>' in line:
entities = False
yield fix_text_segment(
line,
fix_entities=entities,
remove_terminal_escapes=remove_terminal_escapes,
fix_encoding=fix_encoding,
fix_latin_ligatures=fix_latin_ligatures,
fix_character_width=fix_character_width,
uncurl_quotes=uncurl_quotes,
fix_line_breaks=fix_line_breaks,
fix_surrogates=fix_surrogates,
remove_control_chars=remove_control_chars,
remove_bom=remove_bom,
normalization=normalization
) | [
"def",
"fix_file",
"(",
"input_file",
",",
"encoding",
"=",
"None",
",",
"*",
",",
"fix_entities",
"=",
"'auto'",
",",
"remove_terminal_escapes",
"=",
"True",
",",
"fix_encoding",
"=",
"True",
",",
"fix_latin_ligatures",
"=",
"True",
",",
"fix_character_width",
"=",
"True",
",",
"uncurl_quotes",
"=",
"True",
",",
"fix_line_breaks",
"=",
"True",
",",
"fix_surrogates",
"=",
"True",
",",
"remove_control_chars",
"=",
"True",
",",
"remove_bom",
"=",
"True",
",",
"normalization",
"=",
"'NFC'",
")",
":",
"entities",
"=",
"fix_entities",
"for",
"line",
"in",
"input_file",
":",
"if",
"isinstance",
"(",
"line",
",",
"bytes",
")",
":",
"if",
"encoding",
"is",
"None",
":",
"line",
",",
"encoding",
"=",
"guess_bytes",
"(",
"line",
")",
"else",
":",
"line",
"=",
"line",
".",
"decode",
"(",
"encoding",
")",
"if",
"fix_entities",
"==",
"'auto'",
"and",
"'<'",
"in",
"line",
"and",
"'>'",
"in",
"line",
":",
"entities",
"=",
"False",
"yield",
"fix_text_segment",
"(",
"line",
",",
"fix_entities",
"=",
"entities",
",",
"remove_terminal_escapes",
"=",
"remove_terminal_escapes",
",",
"fix_encoding",
"=",
"fix_encoding",
",",
"fix_latin_ligatures",
"=",
"fix_latin_ligatures",
",",
"fix_character_width",
"=",
"fix_character_width",
",",
"uncurl_quotes",
"=",
"uncurl_quotes",
",",
"fix_line_breaks",
"=",
"fix_line_breaks",
",",
"fix_surrogates",
"=",
"fix_surrogates",
",",
"remove_control_chars",
"=",
"remove_control_chars",
",",
"remove_bom",
"=",
"remove_bom",
",",
"normalization",
"=",
"normalization",
")"
] | Fix text that is found in a file.
If the file is being read as Unicode text, use that. If it's being read as
bytes, then we hope an encoding was supplied. If not, unfortunately, we
have to guess what encoding it is. We'll try a few common encodings, but we
make no promises. See the `guess_bytes` function for how this is done.
The output is a stream of fixed lines of text. | [
"Fix",
"text",
"that",
"is",
"found",
"in",
"a",
"file",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/__init__.py#L195-L241 |
231,928 | LuminosoInsight/python-ftfy | ftfy/__init__.py | fix_text_segment | def fix_text_segment(text,
*,
fix_entities='auto',
remove_terminal_escapes=True,
fix_encoding=True,
fix_latin_ligatures=True,
fix_character_width=True,
uncurl_quotes=True,
fix_line_breaks=True,
fix_surrogates=True,
remove_control_chars=True,
remove_bom=True,
normalization='NFC'):
"""
Apply fixes to text in a single chunk. This could be a line of text
within a larger run of `fix_text`, or it could be a larger amount
of text that you are certain is in a consistent encoding.
See `fix_text` for a description of the parameters.
"""
if isinstance(text, bytes):
raise UnicodeError(fixes.BYTES_ERROR_TEXT)
if fix_entities == 'auto' and '<' in text and '>' in text:
fix_entities = False
while True:
origtext = text
if remove_terminal_escapes:
text = fixes.remove_terminal_escapes(text)
if fix_encoding:
text = fixes.fix_encoding(text)
if fix_entities:
text = fixes.unescape_html(text)
if fix_latin_ligatures:
text = fixes.fix_latin_ligatures(text)
if fix_character_width:
text = fixes.fix_character_width(text)
if uncurl_quotes:
text = fixes.uncurl_quotes(text)
if fix_line_breaks:
text = fixes.fix_line_breaks(text)
if fix_surrogates:
text = fixes.fix_surrogates(text)
if remove_control_chars:
text = fixes.remove_control_chars(text)
if remove_bom and not remove_control_chars:
# Skip this step if we've already done `remove_control_chars`,
# because it would be redundant.
text = fixes.remove_bom(text)
if normalization is not None:
text = unicodedata.normalize(normalization, text)
if text == origtext:
return text | python | def fix_text_segment(text,
*,
fix_entities='auto',
remove_terminal_escapes=True,
fix_encoding=True,
fix_latin_ligatures=True,
fix_character_width=True,
uncurl_quotes=True,
fix_line_breaks=True,
fix_surrogates=True,
remove_control_chars=True,
remove_bom=True,
normalization='NFC'):
"""
Apply fixes to text in a single chunk. This could be a line of text
within a larger run of `fix_text`, or it could be a larger amount
of text that you are certain is in a consistent encoding.
See `fix_text` for a description of the parameters.
"""
if isinstance(text, bytes):
raise UnicodeError(fixes.BYTES_ERROR_TEXT)
if fix_entities == 'auto' and '<' in text and '>' in text:
fix_entities = False
while True:
origtext = text
if remove_terminal_escapes:
text = fixes.remove_terminal_escapes(text)
if fix_encoding:
text = fixes.fix_encoding(text)
if fix_entities:
text = fixes.unescape_html(text)
if fix_latin_ligatures:
text = fixes.fix_latin_ligatures(text)
if fix_character_width:
text = fixes.fix_character_width(text)
if uncurl_quotes:
text = fixes.uncurl_quotes(text)
if fix_line_breaks:
text = fixes.fix_line_breaks(text)
if fix_surrogates:
text = fixes.fix_surrogates(text)
if remove_control_chars:
text = fixes.remove_control_chars(text)
if remove_bom and not remove_control_chars:
# Skip this step if we've already done `remove_control_chars`,
# because it would be redundant.
text = fixes.remove_bom(text)
if normalization is not None:
text = unicodedata.normalize(normalization, text)
if text == origtext:
return text | [
"def",
"fix_text_segment",
"(",
"text",
",",
"*",
",",
"fix_entities",
"=",
"'auto'",
",",
"remove_terminal_escapes",
"=",
"True",
",",
"fix_encoding",
"=",
"True",
",",
"fix_latin_ligatures",
"=",
"True",
",",
"fix_character_width",
"=",
"True",
",",
"uncurl_quotes",
"=",
"True",
",",
"fix_line_breaks",
"=",
"True",
",",
"fix_surrogates",
"=",
"True",
",",
"remove_control_chars",
"=",
"True",
",",
"remove_bom",
"=",
"True",
",",
"normalization",
"=",
"'NFC'",
")",
":",
"if",
"isinstance",
"(",
"text",
",",
"bytes",
")",
":",
"raise",
"UnicodeError",
"(",
"fixes",
".",
"BYTES_ERROR_TEXT",
")",
"if",
"fix_entities",
"==",
"'auto'",
"and",
"'<'",
"in",
"text",
"and",
"'>'",
"in",
"text",
":",
"fix_entities",
"=",
"False",
"while",
"True",
":",
"origtext",
"=",
"text",
"if",
"remove_terminal_escapes",
":",
"text",
"=",
"fixes",
".",
"remove_terminal_escapes",
"(",
"text",
")",
"if",
"fix_encoding",
":",
"text",
"=",
"fixes",
".",
"fix_encoding",
"(",
"text",
")",
"if",
"fix_entities",
":",
"text",
"=",
"fixes",
".",
"unescape_html",
"(",
"text",
")",
"if",
"fix_latin_ligatures",
":",
"text",
"=",
"fixes",
".",
"fix_latin_ligatures",
"(",
"text",
")",
"if",
"fix_character_width",
":",
"text",
"=",
"fixes",
".",
"fix_character_width",
"(",
"text",
")",
"if",
"uncurl_quotes",
":",
"text",
"=",
"fixes",
".",
"uncurl_quotes",
"(",
"text",
")",
"if",
"fix_line_breaks",
":",
"text",
"=",
"fixes",
".",
"fix_line_breaks",
"(",
"text",
")",
"if",
"fix_surrogates",
":",
"text",
"=",
"fixes",
".",
"fix_surrogates",
"(",
"text",
")",
"if",
"remove_control_chars",
":",
"text",
"=",
"fixes",
".",
"remove_control_chars",
"(",
"text",
")",
"if",
"remove_bom",
"and",
"not",
"remove_control_chars",
":",
"# Skip this step if we've already done `remove_control_chars`,",
"# because it would be redundant.",
"text",
"=",
"fixes",
".",
"remove_bom",
"(",
"text",
")",
"if",
"normalization",
"is",
"not",
"None",
":",
"text",
"=",
"unicodedata",
".",
"normalize",
"(",
"normalization",
",",
"text",
")",
"if",
"text",
"==",
"origtext",
":",
"return",
"text"
] | Apply fixes to text in a single chunk. This could be a line of text
within a larger run of `fix_text`, or it could be a larger amount
of text that you are certain is in a consistent encoding.
See `fix_text` for a description of the parameters. | [
"Apply",
"fixes",
"to",
"text",
"in",
"a",
"single",
"chunk",
".",
"This",
"could",
"be",
"a",
"line",
"of",
"text",
"within",
"a",
"larger",
"run",
"of",
"fix_text",
"or",
"it",
"could",
"be",
"a",
"larger",
"amount",
"of",
"text",
"that",
"you",
"are",
"certain",
"is",
"in",
"a",
"consistent",
"encoding",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/__init__.py#L244-L296 |
231,929 | LuminosoInsight/python-ftfy | ftfy/__init__.py | explain_unicode | def explain_unicode(text):
"""
A utility method that's useful for debugging mysterious Unicode.
It breaks down a string, showing you for each codepoint its number in
hexadecimal, its glyph, its category in the Unicode standard, and its name
in the Unicode standard.
>>> explain_unicode('(╯°□°)╯︵ ┻━┻')
U+0028 ( [Ps] LEFT PARENTHESIS
U+256F ╯ [So] BOX DRAWINGS LIGHT ARC UP AND LEFT
U+00B0 ° [So] DEGREE SIGN
U+25A1 □ [So] WHITE SQUARE
U+00B0 ° [So] DEGREE SIGN
U+0029 ) [Pe] RIGHT PARENTHESIS
U+256F ╯ [So] BOX DRAWINGS LIGHT ARC UP AND LEFT
U+FE35 ︵ [Ps] PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
U+0020 [Zs] SPACE
U+253B ┻ [So] BOX DRAWINGS HEAVY UP AND HORIZONTAL
U+2501 ━ [So] BOX DRAWINGS HEAVY HORIZONTAL
U+253B ┻ [So] BOX DRAWINGS HEAVY UP AND HORIZONTAL
"""
for char in text:
if char.isprintable():
display = char
else:
display = char.encode('unicode-escape').decode('ascii')
print('U+{code:04X} {display} [{category}] {name}'.format(
display=display_ljust(display, 7),
code=ord(char),
category=unicodedata.category(char),
name=unicodedata.name(char, '<unknown>')
)) | python | def explain_unicode(text):
"""
A utility method that's useful for debugging mysterious Unicode.
It breaks down a string, showing you for each codepoint its number in
hexadecimal, its glyph, its category in the Unicode standard, and its name
in the Unicode standard.
>>> explain_unicode('(╯°□°)╯︵ ┻━┻')
U+0028 ( [Ps] LEFT PARENTHESIS
U+256F ╯ [So] BOX DRAWINGS LIGHT ARC UP AND LEFT
U+00B0 ° [So] DEGREE SIGN
U+25A1 □ [So] WHITE SQUARE
U+00B0 ° [So] DEGREE SIGN
U+0029 ) [Pe] RIGHT PARENTHESIS
U+256F ╯ [So] BOX DRAWINGS LIGHT ARC UP AND LEFT
U+FE35 ︵ [Ps] PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
U+0020 [Zs] SPACE
U+253B ┻ [So] BOX DRAWINGS HEAVY UP AND HORIZONTAL
U+2501 ━ [So] BOX DRAWINGS HEAVY HORIZONTAL
U+253B ┻ [So] BOX DRAWINGS HEAVY UP AND HORIZONTAL
"""
for char in text:
if char.isprintable():
display = char
else:
display = char.encode('unicode-escape').decode('ascii')
print('U+{code:04X} {display} [{category}] {name}'.format(
display=display_ljust(display, 7),
code=ord(char),
category=unicodedata.category(char),
name=unicodedata.name(char, '<unknown>')
)) | [
"def",
"explain_unicode",
"(",
"text",
")",
":",
"for",
"char",
"in",
"text",
":",
"if",
"char",
".",
"isprintable",
"(",
")",
":",
"display",
"=",
"char",
"else",
":",
"display",
"=",
"char",
".",
"encode",
"(",
"'unicode-escape'",
")",
".",
"decode",
"(",
"'ascii'",
")",
"print",
"(",
"'U+{code:04X} {display} [{category}] {name}'",
".",
"format",
"(",
"display",
"=",
"display_ljust",
"(",
"display",
",",
"7",
")",
",",
"code",
"=",
"ord",
"(",
"char",
")",
",",
"category",
"=",
"unicodedata",
".",
"category",
"(",
"char",
")",
",",
"name",
"=",
"unicodedata",
".",
"name",
"(",
"char",
",",
"'<unknown>'",
")",
")",
")"
] | A utility method that's useful for debugging mysterious Unicode.
It breaks down a string, showing you for each codepoint its number in
hexadecimal, its glyph, its category in the Unicode standard, and its name
in the Unicode standard.
>>> explain_unicode('(╯°□°)╯︵ ┻━┻')
U+0028 ( [Ps] LEFT PARENTHESIS
U+256F ╯ [So] BOX DRAWINGS LIGHT ARC UP AND LEFT
U+00B0 ° [So] DEGREE SIGN
U+25A1 □ [So] WHITE SQUARE
U+00B0 ° [So] DEGREE SIGN
U+0029 ) [Pe] RIGHT PARENTHESIS
U+256F ╯ [So] BOX DRAWINGS LIGHT ARC UP AND LEFT
U+FE35 ︵ [Ps] PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
U+0020 [Zs] SPACE
U+253B ┻ [So] BOX DRAWINGS HEAVY UP AND HORIZONTAL
U+2501 ━ [So] BOX DRAWINGS HEAVY HORIZONTAL
U+253B ┻ [So] BOX DRAWINGS HEAVY UP AND HORIZONTAL | [
"A",
"utility",
"method",
"that",
"s",
"useful",
"for",
"debugging",
"mysterious",
"Unicode",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/__init__.py#L379-L411 |
231,930 | LuminosoInsight/python-ftfy | ftfy/chardata.py | _build_regexes | def _build_regexes():
"""
ENCODING_REGEXES contain reasonably fast ways to detect if we
could represent a given string in a given encoding. The simplest one is
the 'ascii' detector, which of course just determines if all characters
are between U+0000 and U+007F.
"""
# Define a regex that matches ASCII text.
encoding_regexes = {'ascii': re.compile('^[\x00-\x7f]*$')}
for encoding in CHARMAP_ENCODINGS:
# Make a sequence of characters that bytes \x80 to \xFF decode to
# in each encoding, as well as byte \x1A, which is used to represent
# the replacement character � in the sloppy-* encodings.
byte_range = bytes(list(range(0x80, 0x100)) + [0x1a])
charlist = byte_range.decode(encoding)
# The rest of the ASCII bytes -- bytes \x00 to \x19 and \x1B
# to \x7F -- will decode as those ASCII characters in any encoding we
# support, so we can just include them as ranges. This also lets us
# not worry about escaping regex special characters, because all of
# them are in the \x1B to \x7F range.
regex = '^[\x00-\x19\x1b-\x7f{0}]*$'.format(charlist)
encoding_regexes[encoding] = re.compile(regex)
return encoding_regexes | python | def _build_regexes():
"""
ENCODING_REGEXES contain reasonably fast ways to detect if we
could represent a given string in a given encoding. The simplest one is
the 'ascii' detector, which of course just determines if all characters
are between U+0000 and U+007F.
"""
# Define a regex that matches ASCII text.
encoding_regexes = {'ascii': re.compile('^[\x00-\x7f]*$')}
for encoding in CHARMAP_ENCODINGS:
# Make a sequence of characters that bytes \x80 to \xFF decode to
# in each encoding, as well as byte \x1A, which is used to represent
# the replacement character � in the sloppy-* encodings.
byte_range = bytes(list(range(0x80, 0x100)) + [0x1a])
charlist = byte_range.decode(encoding)
# The rest of the ASCII bytes -- bytes \x00 to \x19 and \x1B
# to \x7F -- will decode as those ASCII characters in any encoding we
# support, so we can just include them as ranges. This also lets us
# not worry about escaping regex special characters, because all of
# them are in the \x1B to \x7F range.
regex = '^[\x00-\x19\x1b-\x7f{0}]*$'.format(charlist)
encoding_regexes[encoding] = re.compile(regex)
return encoding_regexes | [
"def",
"_build_regexes",
"(",
")",
":",
"# Define a regex that matches ASCII text.",
"encoding_regexes",
"=",
"{",
"'ascii'",
":",
"re",
".",
"compile",
"(",
"'^[\\x00-\\x7f]*$'",
")",
"}",
"for",
"encoding",
"in",
"CHARMAP_ENCODINGS",
":",
"# Make a sequence of characters that bytes \\x80 to \\xFF decode to",
"# in each encoding, as well as byte \\x1A, which is used to represent",
"# the replacement character � in the sloppy-* encodings.",
"byte_range",
"=",
"bytes",
"(",
"list",
"(",
"range",
"(",
"0x80",
",",
"0x100",
")",
")",
"+",
"[",
"0x1a",
"]",
")",
"charlist",
"=",
"byte_range",
".",
"decode",
"(",
"encoding",
")",
"# The rest of the ASCII bytes -- bytes \\x00 to \\x19 and \\x1B",
"# to \\x7F -- will decode as those ASCII characters in any encoding we",
"# support, so we can just include them as ranges. This also lets us",
"# not worry about escaping regex special characters, because all of",
"# them are in the \\x1B to \\x7F range.",
"regex",
"=",
"'^[\\x00-\\x19\\x1b-\\x7f{0}]*$'",
".",
"format",
"(",
"charlist",
")",
"encoding_regexes",
"[",
"encoding",
"]",
"=",
"re",
".",
"compile",
"(",
"regex",
")",
"return",
"encoding_regexes"
] | ENCODING_REGEXES contain reasonably fast ways to detect if we
could represent a given string in a given encoding. The simplest one is
the 'ascii' detector, which of course just determines if all characters
are between U+0000 and U+007F. | [
"ENCODING_REGEXES",
"contain",
"reasonably",
"fast",
"ways",
"to",
"detect",
"if",
"we",
"could",
"represent",
"a",
"given",
"string",
"in",
"a",
"given",
"encoding",
".",
"The",
"simplest",
"one",
"is",
"the",
"ascii",
"detector",
"which",
"of",
"course",
"just",
"determines",
"if",
"all",
"characters",
"are",
"between",
"U",
"+",
"0000",
"and",
"U",
"+",
"007F",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/chardata.py#L25-L49 |
231,931 | LuminosoInsight/python-ftfy | ftfy/chardata.py | _build_width_map | def _build_width_map():
"""
Build a translate mapping that replaces halfwidth and fullwidth forms
with their standard-width forms.
"""
# Though it's not listed as a fullwidth character, we'll want to convert
# U+3000 IDEOGRAPHIC SPACE to U+20 SPACE on the same principle, so start
# with that in the dictionary.
width_map = {0x3000: ' '}
for i in range(0xff01, 0xfff0):
char = chr(i)
alternate = unicodedata.normalize('NFKC', char)
if alternate != char:
width_map[i] = alternate
return width_map | python | def _build_width_map():
"""
Build a translate mapping that replaces halfwidth and fullwidth forms
with their standard-width forms.
"""
# Though it's not listed as a fullwidth character, we'll want to convert
# U+3000 IDEOGRAPHIC SPACE to U+20 SPACE on the same principle, so start
# with that in the dictionary.
width_map = {0x3000: ' '}
for i in range(0xff01, 0xfff0):
char = chr(i)
alternate = unicodedata.normalize('NFKC', char)
if alternate != char:
width_map[i] = alternate
return width_map | [
"def",
"_build_width_map",
"(",
")",
":",
"# Though it's not listed as a fullwidth character, we'll want to convert",
"# U+3000 IDEOGRAPHIC SPACE to U+20 SPACE on the same principle, so start",
"# with that in the dictionary.",
"width_map",
"=",
"{",
"0x3000",
":",
"' '",
"}",
"for",
"i",
"in",
"range",
"(",
"0xff01",
",",
"0xfff0",
")",
":",
"char",
"=",
"chr",
"(",
"i",
")",
"alternate",
"=",
"unicodedata",
".",
"normalize",
"(",
"'NFKC'",
",",
"char",
")",
"if",
"alternate",
"!=",
"char",
":",
"width_map",
"[",
"i",
"]",
"=",
"alternate",
"return",
"width_map"
] | Build a translate mapping that replaces halfwidth and fullwidth forms
with their standard-width forms. | [
"Build",
"a",
"translate",
"mapping",
"that",
"replaces",
"halfwidth",
"and",
"fullwidth",
"forms",
"with",
"their",
"standard",
"-",
"width",
"forms",
"."
] | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/chardata.py#L222-L236 |
231,932 | pydata/numexpr | numexpr/utils.py | set_vml_accuracy_mode | def set_vml_accuracy_mode(mode):
"""
Set the accuracy mode for VML operations.
The `mode` parameter can take the values:
- 'high': high accuracy mode (HA), <1 least significant bit
- 'low': low accuracy mode (LA), typically 1-2 least significant bits
- 'fast': enhanced performance mode (EP)
- None: mode settings are ignored
This call is equivalent to the `vmlSetMode()` in the VML library.
See:
http://www.intel.com/software/products/mkl/docs/webhelp/vml/vml_DataTypesAccuracyModes.html
for more info on the accuracy modes.
Returns old accuracy settings.
"""
if use_vml:
acc_dict = {None: 0, 'low': 1, 'high': 2, 'fast': 3}
acc_reverse_dict = {1: 'low', 2: 'high', 3: 'fast'}
if mode not in acc_dict.keys():
raise ValueError(
"mode argument must be one of: None, 'high', 'low', 'fast'")
retval = _set_vml_accuracy_mode(acc_dict.get(mode, 0))
return acc_reverse_dict.get(retval)
else:
return None | python | def set_vml_accuracy_mode(mode):
"""
Set the accuracy mode for VML operations.
The `mode` parameter can take the values:
- 'high': high accuracy mode (HA), <1 least significant bit
- 'low': low accuracy mode (LA), typically 1-2 least significant bits
- 'fast': enhanced performance mode (EP)
- None: mode settings are ignored
This call is equivalent to the `vmlSetMode()` in the VML library.
See:
http://www.intel.com/software/products/mkl/docs/webhelp/vml/vml_DataTypesAccuracyModes.html
for more info on the accuracy modes.
Returns old accuracy settings.
"""
if use_vml:
acc_dict = {None: 0, 'low': 1, 'high': 2, 'fast': 3}
acc_reverse_dict = {1: 'low', 2: 'high', 3: 'fast'}
if mode not in acc_dict.keys():
raise ValueError(
"mode argument must be one of: None, 'high', 'low', 'fast'")
retval = _set_vml_accuracy_mode(acc_dict.get(mode, 0))
return acc_reverse_dict.get(retval)
else:
return None | [
"def",
"set_vml_accuracy_mode",
"(",
"mode",
")",
":",
"if",
"use_vml",
":",
"acc_dict",
"=",
"{",
"None",
":",
"0",
",",
"'low'",
":",
"1",
",",
"'high'",
":",
"2",
",",
"'fast'",
":",
"3",
"}",
"acc_reverse_dict",
"=",
"{",
"1",
":",
"'low'",
",",
"2",
":",
"'high'",
",",
"3",
":",
"'fast'",
"}",
"if",
"mode",
"not",
"in",
"acc_dict",
".",
"keys",
"(",
")",
":",
"raise",
"ValueError",
"(",
"\"mode argument must be one of: None, 'high', 'low', 'fast'\"",
")",
"retval",
"=",
"_set_vml_accuracy_mode",
"(",
"acc_dict",
".",
"get",
"(",
"mode",
",",
"0",
")",
")",
"return",
"acc_reverse_dict",
".",
"get",
"(",
"retval",
")",
"else",
":",
"return",
"None"
] | Set the accuracy mode for VML operations.
The `mode` parameter can take the values:
- 'high': high accuracy mode (HA), <1 least significant bit
- 'low': low accuracy mode (LA), typically 1-2 least significant bits
- 'fast': enhanced performance mode (EP)
- None: mode settings are ignored
This call is equivalent to the `vmlSetMode()` in the VML library.
See:
http://www.intel.com/software/products/mkl/docs/webhelp/vml/vml_DataTypesAccuracyModes.html
for more info on the accuracy modes.
Returns old accuracy settings. | [
"Set",
"the",
"accuracy",
"mode",
"for",
"VML",
"operations",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/utils.py#L34-L62 |
231,933 | pydata/numexpr | numexpr/utils.py | _init_num_threads | def _init_num_threads():
"""
Detects the environment variable 'NUMEXPR_MAX_THREADS' to set the threadpool
size, and if necessary the slightly redundant 'NUMEXPR_NUM_THREADS' or
'OMP_NUM_THREADS' env vars to set the initial number of threads used by
the virtual machine.
"""
# Any platform-specific short-circuits
if 'sparc' in platform.machine():
log.warning('The number of threads have been set to 1 because problems related '
'to threading have been reported on some sparc machine. '
'The number of threads can be changed using the "set_num_threads" '
'function.')
set_num_threads(1)
return 1
env_configured = False
n_cores = detect_number_of_cores()
if 'NUMEXPR_MAX_THREADS' in os.environ:
# The user has configured NumExpr in the expected way, so suppress logs.
env_configured = True
n_cores = MAX_THREADS
else:
# The use has not set 'NUMEXPR_MAX_THREADS', so likely they have not
# configured NumExpr as desired, so we emit info logs.
if n_cores > MAX_THREADS:
log.info('Note: detected %d virtual cores but NumExpr set to maximum of %d, check "NUMEXPR_MAX_THREADS" environment variable.'%(n_cores, MAX_THREADS))
if n_cores > 8:
# The historical 'safety' limit.
log.info('Note: NumExpr detected %d cores but "NUMEXPR_MAX_THREADS" not set, so enforcing safe limit of 8.'%n_cores)
n_cores = 8
# Now we check for 'NUMEXPR_NUM_THREADS' or 'OMP_NUM_THREADS' to set the
# actual number of threads used.
if 'NUMEXPR_NUM_THREADS' in os.environ:
requested_threads = int(os.environ['NUMEXPR_NUM_THREADS'])
elif 'OMP_NUM_THREADS' in os.environ:
requested_threads = int(os.environ['OMP_NUM_THREADS'])
else:
requested_threads = n_cores
if not env_configured:
log.info('NumExpr defaulting to %d threads.'%n_cores)
# The C-extension function performs its own checks against `MAX_THREADS`
set_num_threads(requested_threads)
return requested_threads | python | def _init_num_threads():
"""
Detects the environment variable 'NUMEXPR_MAX_THREADS' to set the threadpool
size, and if necessary the slightly redundant 'NUMEXPR_NUM_THREADS' or
'OMP_NUM_THREADS' env vars to set the initial number of threads used by
the virtual machine.
"""
# Any platform-specific short-circuits
if 'sparc' in platform.machine():
log.warning('The number of threads have been set to 1 because problems related '
'to threading have been reported on some sparc machine. '
'The number of threads can be changed using the "set_num_threads" '
'function.')
set_num_threads(1)
return 1
env_configured = False
n_cores = detect_number_of_cores()
if 'NUMEXPR_MAX_THREADS' in os.environ:
# The user has configured NumExpr in the expected way, so suppress logs.
env_configured = True
n_cores = MAX_THREADS
else:
# The use has not set 'NUMEXPR_MAX_THREADS', so likely they have not
# configured NumExpr as desired, so we emit info logs.
if n_cores > MAX_THREADS:
log.info('Note: detected %d virtual cores but NumExpr set to maximum of %d, check "NUMEXPR_MAX_THREADS" environment variable.'%(n_cores, MAX_THREADS))
if n_cores > 8:
# The historical 'safety' limit.
log.info('Note: NumExpr detected %d cores but "NUMEXPR_MAX_THREADS" not set, so enforcing safe limit of 8.'%n_cores)
n_cores = 8
# Now we check for 'NUMEXPR_NUM_THREADS' or 'OMP_NUM_THREADS' to set the
# actual number of threads used.
if 'NUMEXPR_NUM_THREADS' in os.environ:
requested_threads = int(os.environ['NUMEXPR_NUM_THREADS'])
elif 'OMP_NUM_THREADS' in os.environ:
requested_threads = int(os.environ['OMP_NUM_THREADS'])
else:
requested_threads = n_cores
if not env_configured:
log.info('NumExpr defaulting to %d threads.'%n_cores)
# The C-extension function performs its own checks against `MAX_THREADS`
set_num_threads(requested_threads)
return requested_threads | [
"def",
"_init_num_threads",
"(",
")",
":",
"# Any platform-specific short-circuits",
"if",
"'sparc'",
"in",
"platform",
".",
"machine",
"(",
")",
":",
"log",
".",
"warning",
"(",
"'The number of threads have been set to 1 because problems related '",
"'to threading have been reported on some sparc machine. '",
"'The number of threads can be changed using the \"set_num_threads\" '",
"'function.'",
")",
"set_num_threads",
"(",
"1",
")",
"return",
"1",
"env_configured",
"=",
"False",
"n_cores",
"=",
"detect_number_of_cores",
"(",
")",
"if",
"'NUMEXPR_MAX_THREADS'",
"in",
"os",
".",
"environ",
":",
"# The user has configured NumExpr in the expected way, so suppress logs.",
"env_configured",
"=",
"True",
"n_cores",
"=",
"MAX_THREADS",
"else",
":",
"# The use has not set 'NUMEXPR_MAX_THREADS', so likely they have not ",
"# configured NumExpr as desired, so we emit info logs.",
"if",
"n_cores",
">",
"MAX_THREADS",
":",
"log",
".",
"info",
"(",
"'Note: detected %d virtual cores but NumExpr set to maximum of %d, check \"NUMEXPR_MAX_THREADS\" environment variable.'",
"%",
"(",
"n_cores",
",",
"MAX_THREADS",
")",
")",
"if",
"n_cores",
">",
"8",
":",
"# The historical 'safety' limit.",
"log",
".",
"info",
"(",
"'Note: NumExpr detected %d cores but \"NUMEXPR_MAX_THREADS\" not set, so enforcing safe limit of 8.'",
"%",
"n_cores",
")",
"n_cores",
"=",
"8",
"# Now we check for 'NUMEXPR_NUM_THREADS' or 'OMP_NUM_THREADS' to set the ",
"# actual number of threads used.",
"if",
"'NUMEXPR_NUM_THREADS'",
"in",
"os",
".",
"environ",
":",
"requested_threads",
"=",
"int",
"(",
"os",
".",
"environ",
"[",
"'NUMEXPR_NUM_THREADS'",
"]",
")",
"elif",
"'OMP_NUM_THREADS'",
"in",
"os",
".",
"environ",
":",
"requested_threads",
"=",
"int",
"(",
"os",
".",
"environ",
"[",
"'OMP_NUM_THREADS'",
"]",
")",
"else",
":",
"requested_threads",
"=",
"n_cores",
"if",
"not",
"env_configured",
":",
"log",
".",
"info",
"(",
"'NumExpr defaulting to %d threads.'",
"%",
"n_cores",
")",
"# The C-extension function performs its own checks against `MAX_THREADS`",
"set_num_threads",
"(",
"requested_threads",
")",
"return",
"requested_threads"
] | Detects the environment variable 'NUMEXPR_MAX_THREADS' to set the threadpool
size, and if necessary the slightly redundant 'NUMEXPR_NUM_THREADS' or
'OMP_NUM_THREADS' env vars to set the initial number of threads used by
the virtual machine. | [
"Detects",
"the",
"environment",
"variable",
"NUMEXPR_MAX_THREADS",
"to",
"set",
"the",
"threadpool",
"size",
"and",
"if",
"necessary",
"the",
"slightly",
"redundant",
"NUMEXPR_NUM_THREADS",
"or",
"OMP_NUM_THREADS",
"env",
"vars",
"to",
"set",
"the",
"initial",
"number",
"of",
"threads",
"used",
"by",
"the",
"virtual",
"machine",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/utils.py#L100-L145 |
231,934 | pydata/numexpr | numexpr/utils.py | detect_number_of_cores | def detect_number_of_cores():
"""
Detects the number of cores on a system. Cribbed from pp.
"""
# Linux, Unix and MacOS:
if hasattr(os, "sysconf"):
if "SC_NPROCESSORS_ONLN" in os.sysconf_names:
# Linux & Unix:
ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
if isinstance(ncpus, int) and ncpus > 0:
return ncpus
else: # OSX:
return int(subprocess.check_output(["sysctl", "-n", "hw.ncpu"]))
# Windows:
try:
ncpus = int(os.environ.get("NUMBER_OF_PROCESSORS", ""))
if ncpus > 0:
return ncpus
except ValueError:
pass
return 1 | python | def detect_number_of_cores():
"""
Detects the number of cores on a system. Cribbed from pp.
"""
# Linux, Unix and MacOS:
if hasattr(os, "sysconf"):
if "SC_NPROCESSORS_ONLN" in os.sysconf_names:
# Linux & Unix:
ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
if isinstance(ncpus, int) and ncpus > 0:
return ncpus
else: # OSX:
return int(subprocess.check_output(["sysctl", "-n", "hw.ncpu"]))
# Windows:
try:
ncpus = int(os.environ.get("NUMBER_OF_PROCESSORS", ""))
if ncpus > 0:
return ncpus
except ValueError:
pass
return 1 | [
"def",
"detect_number_of_cores",
"(",
")",
":",
"# Linux, Unix and MacOS:",
"if",
"hasattr",
"(",
"os",
",",
"\"sysconf\"",
")",
":",
"if",
"\"SC_NPROCESSORS_ONLN\"",
"in",
"os",
".",
"sysconf_names",
":",
"# Linux & Unix:",
"ncpus",
"=",
"os",
".",
"sysconf",
"(",
"\"SC_NPROCESSORS_ONLN\"",
")",
"if",
"isinstance",
"(",
"ncpus",
",",
"int",
")",
"and",
"ncpus",
">",
"0",
":",
"return",
"ncpus",
"else",
":",
"# OSX:",
"return",
"int",
"(",
"subprocess",
".",
"check_output",
"(",
"[",
"\"sysctl\"",
",",
"\"-n\"",
",",
"\"hw.ncpu\"",
"]",
")",
")",
"# Windows:",
"try",
":",
"ncpus",
"=",
"int",
"(",
"os",
".",
"environ",
".",
"get",
"(",
"\"NUMBER_OF_PROCESSORS\"",
",",
"\"\"",
")",
")",
"if",
"ncpus",
">",
"0",
":",
"return",
"ncpus",
"except",
"ValueError",
":",
"pass",
"return",
"1"
] | Detects the number of cores on a system. Cribbed from pp. | [
"Detects",
"the",
"number",
"of",
"cores",
"on",
"a",
"system",
".",
"Cribbed",
"from",
"pp",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/utils.py#L148-L168 |
231,935 | pydata/numexpr | bench/multidim.py | chunkify | def chunkify(chunksize):
""" Very stupid "chunk vectorizer" which keeps memory use down.
This version requires all inputs to have the same number of elements,
although it shouldn't be that hard to implement simple broadcasting.
"""
def chunkifier(func):
def wrap(*args):
assert len(args) > 0
assert all(len(a.flat) == len(args[0].flat) for a in args)
nelements = len(args[0].flat)
nchunks, remain = divmod(nelements, chunksize)
out = np.ndarray(args[0].shape)
for start in range(0, nelements, chunksize):
#print(start)
stop = start+chunksize
if start+chunksize > nelements:
stop = nelements-start
iargs = tuple(a.flat[start:stop] for a in args)
out.flat[start:stop] = func(*iargs)
return out
return wrap
return chunkifier | python | def chunkify(chunksize):
""" Very stupid "chunk vectorizer" which keeps memory use down.
This version requires all inputs to have the same number of elements,
although it shouldn't be that hard to implement simple broadcasting.
"""
def chunkifier(func):
def wrap(*args):
assert len(args) > 0
assert all(len(a.flat) == len(args[0].flat) for a in args)
nelements = len(args[0].flat)
nchunks, remain = divmod(nelements, chunksize)
out = np.ndarray(args[0].shape)
for start in range(0, nelements, chunksize):
#print(start)
stop = start+chunksize
if start+chunksize > nelements:
stop = nelements-start
iargs = tuple(a.flat[start:stop] for a in args)
out.flat[start:stop] = func(*iargs)
return out
return wrap
return chunkifier | [
"def",
"chunkify",
"(",
"chunksize",
")",
":",
"def",
"chunkifier",
"(",
"func",
")",
":",
"def",
"wrap",
"(",
"*",
"args",
")",
":",
"assert",
"len",
"(",
"args",
")",
">",
"0",
"assert",
"all",
"(",
"len",
"(",
"a",
".",
"flat",
")",
"==",
"len",
"(",
"args",
"[",
"0",
"]",
".",
"flat",
")",
"for",
"a",
"in",
"args",
")",
"nelements",
"=",
"len",
"(",
"args",
"[",
"0",
"]",
".",
"flat",
")",
"nchunks",
",",
"remain",
"=",
"divmod",
"(",
"nelements",
",",
"chunksize",
")",
"out",
"=",
"np",
".",
"ndarray",
"(",
"args",
"[",
"0",
"]",
".",
"shape",
")",
"for",
"start",
"in",
"range",
"(",
"0",
",",
"nelements",
",",
"chunksize",
")",
":",
"#print(start)",
"stop",
"=",
"start",
"+",
"chunksize",
"if",
"start",
"+",
"chunksize",
">",
"nelements",
":",
"stop",
"=",
"nelements",
"-",
"start",
"iargs",
"=",
"tuple",
"(",
"a",
".",
"flat",
"[",
"start",
":",
"stop",
"]",
"for",
"a",
"in",
"args",
")",
"out",
".",
"flat",
"[",
"start",
":",
"stop",
"]",
"=",
"func",
"(",
"*",
"iargs",
")",
"return",
"out",
"return",
"wrap",
"return",
"chunkifier"
] | Very stupid "chunk vectorizer" which keeps memory use down.
This version requires all inputs to have the same number of elements,
although it shouldn't be that hard to implement simple broadcasting. | [
"Very",
"stupid",
"chunk",
"vectorizer",
"which",
"keeps",
"memory",
"use",
"down",
".",
"This",
"version",
"requires",
"all",
"inputs",
"to",
"have",
"the",
"same",
"number",
"of",
"elements",
"although",
"it",
"shouldn",
"t",
"be",
"that",
"hard",
"to",
"implement",
"simple",
"broadcasting",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/bench/multidim.py#L28-L57 |
231,936 | pydata/numexpr | numexpr/necompiler.py | expressionToAST | def expressionToAST(ex):
"""Take an expression tree made out of expressions.ExpressionNode,
and convert to an AST tree.
This is necessary as ExpressionNode overrides many methods to act
like a number.
"""
return ASTNode(ex.astType, ex.astKind, ex.value,
[expressionToAST(c) for c in ex.children]) | python | def expressionToAST(ex):
"""Take an expression tree made out of expressions.ExpressionNode,
and convert to an AST tree.
This is necessary as ExpressionNode overrides many methods to act
like a number.
"""
return ASTNode(ex.astType, ex.astKind, ex.value,
[expressionToAST(c) for c in ex.children]) | [
"def",
"expressionToAST",
"(",
"ex",
")",
":",
"return",
"ASTNode",
"(",
"ex",
".",
"astType",
",",
"ex",
".",
"astKind",
",",
"ex",
".",
"value",
",",
"[",
"expressionToAST",
"(",
"c",
")",
"for",
"c",
"in",
"ex",
".",
"children",
"]",
")"
] | Take an expression tree made out of expressions.ExpressionNode,
and convert to an AST tree.
This is necessary as ExpressionNode overrides many methods to act
like a number. | [
"Take",
"an",
"expression",
"tree",
"made",
"out",
"of",
"expressions",
".",
"ExpressionNode",
"and",
"convert",
"to",
"an",
"AST",
"tree",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L158-L166 |
231,937 | pydata/numexpr | numexpr/necompiler.py | sigPerms | def sigPerms(s):
"""Generate all possible signatures derived by upcasting the given
signature.
"""
codes = 'bilfdc'
if not s:
yield ''
elif s[0] in codes:
start = codes.index(s[0])
for x in codes[start:]:
for y in sigPerms(s[1:]):
yield x + y
elif s[0] == 's': # numbers shall not be cast to strings
for y in sigPerms(s[1:]):
yield 's' + y
else:
yield s | python | def sigPerms(s):
"""Generate all possible signatures derived by upcasting the given
signature.
"""
codes = 'bilfdc'
if not s:
yield ''
elif s[0] in codes:
start = codes.index(s[0])
for x in codes[start:]:
for y in sigPerms(s[1:]):
yield x + y
elif s[0] == 's': # numbers shall not be cast to strings
for y in sigPerms(s[1:]):
yield 's' + y
else:
yield s | [
"def",
"sigPerms",
"(",
"s",
")",
":",
"codes",
"=",
"'bilfdc'",
"if",
"not",
"s",
":",
"yield",
"''",
"elif",
"s",
"[",
"0",
"]",
"in",
"codes",
":",
"start",
"=",
"codes",
".",
"index",
"(",
"s",
"[",
"0",
"]",
")",
"for",
"x",
"in",
"codes",
"[",
"start",
":",
"]",
":",
"for",
"y",
"in",
"sigPerms",
"(",
"s",
"[",
"1",
":",
"]",
")",
":",
"yield",
"x",
"+",
"y",
"elif",
"s",
"[",
"0",
"]",
"==",
"'s'",
":",
"# numbers shall not be cast to strings",
"for",
"y",
"in",
"sigPerms",
"(",
"s",
"[",
"1",
":",
"]",
")",
":",
"yield",
"'s'",
"+",
"y",
"else",
":",
"yield",
"s"
] | Generate all possible signatures derived by upcasting the given
signature. | [
"Generate",
"all",
"possible",
"signatures",
"derived",
"by",
"upcasting",
"the",
"given",
"signature",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L169-L185 |
231,938 | pydata/numexpr | numexpr/necompiler.py | typeCompileAst | def typeCompileAst(ast):
"""Assign appropiate types to each node in the AST.
Will convert opcodes and functions to appropiate upcast version,
and add "cast" ops if needed.
"""
children = list(ast.children)
if ast.astType == 'op':
retsig = ast.typecode()
basesig = ''.join(x.typecode() for x in list(ast.children))
# Find some operation that will work on an acceptable casting of args.
for sig in sigPerms(basesig):
value = (ast.value + '_' + retsig + sig).encode('ascii')
if value in interpreter.opcodes:
break
else:
for sig in sigPerms(basesig):
funcname = (ast.value + '_' + retsig + sig).encode('ascii')
if funcname in interpreter.funccodes:
value = ('func_%sn' % (retsig + sig)).encode('ascii')
children += [ASTNode('raw', 'none',
interpreter.funccodes[funcname])]
break
else:
raise NotImplementedError(
"couldn't find matching opcode for '%s'"
% (ast.value + '_' + retsig + basesig))
# First just cast constants, then cast variables if necessary:
for i, (have, want) in enumerate(zip(basesig, sig)):
if have != want:
kind = typecode_to_kind[want]
if children[i].astType == 'constant':
children[i] = ASTNode('constant', kind, children[i].value)
else:
opname = "cast"
children[i] = ASTNode('op', kind, opname, [children[i]])
else:
value = ast.value
children = ast.children
return ASTNode(ast.astType, ast.astKind, value,
[typeCompileAst(c) for c in children]) | python | def typeCompileAst(ast):
"""Assign appropiate types to each node in the AST.
Will convert opcodes and functions to appropiate upcast version,
and add "cast" ops if needed.
"""
children = list(ast.children)
if ast.astType == 'op':
retsig = ast.typecode()
basesig = ''.join(x.typecode() for x in list(ast.children))
# Find some operation that will work on an acceptable casting of args.
for sig in sigPerms(basesig):
value = (ast.value + '_' + retsig + sig).encode('ascii')
if value in interpreter.opcodes:
break
else:
for sig in sigPerms(basesig):
funcname = (ast.value + '_' + retsig + sig).encode('ascii')
if funcname in interpreter.funccodes:
value = ('func_%sn' % (retsig + sig)).encode('ascii')
children += [ASTNode('raw', 'none',
interpreter.funccodes[funcname])]
break
else:
raise NotImplementedError(
"couldn't find matching opcode for '%s'"
% (ast.value + '_' + retsig + basesig))
# First just cast constants, then cast variables if necessary:
for i, (have, want) in enumerate(zip(basesig, sig)):
if have != want:
kind = typecode_to_kind[want]
if children[i].astType == 'constant':
children[i] = ASTNode('constant', kind, children[i].value)
else:
opname = "cast"
children[i] = ASTNode('op', kind, opname, [children[i]])
else:
value = ast.value
children = ast.children
return ASTNode(ast.astType, ast.astKind, value,
[typeCompileAst(c) for c in children]) | [
"def",
"typeCompileAst",
"(",
"ast",
")",
":",
"children",
"=",
"list",
"(",
"ast",
".",
"children",
")",
"if",
"ast",
".",
"astType",
"==",
"'op'",
":",
"retsig",
"=",
"ast",
".",
"typecode",
"(",
")",
"basesig",
"=",
"''",
".",
"join",
"(",
"x",
".",
"typecode",
"(",
")",
"for",
"x",
"in",
"list",
"(",
"ast",
".",
"children",
")",
")",
"# Find some operation that will work on an acceptable casting of args.",
"for",
"sig",
"in",
"sigPerms",
"(",
"basesig",
")",
":",
"value",
"=",
"(",
"ast",
".",
"value",
"+",
"'_'",
"+",
"retsig",
"+",
"sig",
")",
".",
"encode",
"(",
"'ascii'",
")",
"if",
"value",
"in",
"interpreter",
".",
"opcodes",
":",
"break",
"else",
":",
"for",
"sig",
"in",
"sigPerms",
"(",
"basesig",
")",
":",
"funcname",
"=",
"(",
"ast",
".",
"value",
"+",
"'_'",
"+",
"retsig",
"+",
"sig",
")",
".",
"encode",
"(",
"'ascii'",
")",
"if",
"funcname",
"in",
"interpreter",
".",
"funccodes",
":",
"value",
"=",
"(",
"'func_%sn'",
"%",
"(",
"retsig",
"+",
"sig",
")",
")",
".",
"encode",
"(",
"'ascii'",
")",
"children",
"+=",
"[",
"ASTNode",
"(",
"'raw'",
",",
"'none'",
",",
"interpreter",
".",
"funccodes",
"[",
"funcname",
"]",
")",
"]",
"break",
"else",
":",
"raise",
"NotImplementedError",
"(",
"\"couldn't find matching opcode for '%s'\"",
"%",
"(",
"ast",
".",
"value",
"+",
"'_'",
"+",
"retsig",
"+",
"basesig",
")",
")",
"# First just cast constants, then cast variables if necessary:",
"for",
"i",
",",
"(",
"have",
",",
"want",
")",
"in",
"enumerate",
"(",
"zip",
"(",
"basesig",
",",
"sig",
")",
")",
":",
"if",
"have",
"!=",
"want",
":",
"kind",
"=",
"typecode_to_kind",
"[",
"want",
"]",
"if",
"children",
"[",
"i",
"]",
".",
"astType",
"==",
"'constant'",
":",
"children",
"[",
"i",
"]",
"=",
"ASTNode",
"(",
"'constant'",
",",
"kind",
",",
"children",
"[",
"i",
"]",
".",
"value",
")",
"else",
":",
"opname",
"=",
"\"cast\"",
"children",
"[",
"i",
"]",
"=",
"ASTNode",
"(",
"'op'",
",",
"kind",
",",
"opname",
",",
"[",
"children",
"[",
"i",
"]",
"]",
")",
"else",
":",
"value",
"=",
"ast",
".",
"value",
"children",
"=",
"ast",
".",
"children",
"return",
"ASTNode",
"(",
"ast",
".",
"astType",
",",
"ast",
".",
"astKind",
",",
"value",
",",
"[",
"typeCompileAst",
"(",
"c",
")",
"for",
"c",
"in",
"children",
"]",
")"
] | Assign appropiate types to each node in the AST.
Will convert opcodes and functions to appropiate upcast version,
and add "cast" ops if needed. | [
"Assign",
"appropiate",
"types",
"to",
"each",
"node",
"in",
"the",
"AST",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L188-L228 |
231,939 | pydata/numexpr | numexpr/necompiler.py | stringToExpression | def stringToExpression(s, types, context):
"""Given a string, convert it to a tree of ExpressionNode's.
"""
old_ctx = expressions._context.get_current_context()
try:
expressions._context.set_new_context(context)
# first compile to a code object to determine the names
if context.get('truediv', False):
flags = __future__.division.compiler_flag
else:
flags = 0
c = compile(s, '<expr>', 'eval', flags)
# make VariableNode's for the names
names = {}
for name in c.co_names:
if name == "None":
names[name] = None
elif name == "True":
names[name] = True
elif name == "False":
names[name] = False
else:
t = types.get(name, default_type)
names[name] = expressions.VariableNode(name, type_to_kind[t])
names.update(expressions.functions)
# now build the expression
ex = eval(c, names)
if expressions.isConstant(ex):
ex = expressions.ConstantNode(ex, expressions.getKind(ex))
elif not isinstance(ex, expressions.ExpressionNode):
raise TypeError("unsupported expression type: %s" % type(ex))
finally:
expressions._context.set_new_context(old_ctx)
return ex | python | def stringToExpression(s, types, context):
"""Given a string, convert it to a tree of ExpressionNode's.
"""
old_ctx = expressions._context.get_current_context()
try:
expressions._context.set_new_context(context)
# first compile to a code object to determine the names
if context.get('truediv', False):
flags = __future__.division.compiler_flag
else:
flags = 0
c = compile(s, '<expr>', 'eval', flags)
# make VariableNode's for the names
names = {}
for name in c.co_names:
if name == "None":
names[name] = None
elif name == "True":
names[name] = True
elif name == "False":
names[name] = False
else:
t = types.get(name, default_type)
names[name] = expressions.VariableNode(name, type_to_kind[t])
names.update(expressions.functions)
# now build the expression
ex = eval(c, names)
if expressions.isConstant(ex):
ex = expressions.ConstantNode(ex, expressions.getKind(ex))
elif not isinstance(ex, expressions.ExpressionNode):
raise TypeError("unsupported expression type: %s" % type(ex))
finally:
expressions._context.set_new_context(old_ctx)
return ex | [
"def",
"stringToExpression",
"(",
"s",
",",
"types",
",",
"context",
")",
":",
"old_ctx",
"=",
"expressions",
".",
"_context",
".",
"get_current_context",
"(",
")",
"try",
":",
"expressions",
".",
"_context",
".",
"set_new_context",
"(",
"context",
")",
"# first compile to a code object to determine the names",
"if",
"context",
".",
"get",
"(",
"'truediv'",
",",
"False",
")",
":",
"flags",
"=",
"__future__",
".",
"division",
".",
"compiler_flag",
"else",
":",
"flags",
"=",
"0",
"c",
"=",
"compile",
"(",
"s",
",",
"'<expr>'",
",",
"'eval'",
",",
"flags",
")",
"# make VariableNode's for the names",
"names",
"=",
"{",
"}",
"for",
"name",
"in",
"c",
".",
"co_names",
":",
"if",
"name",
"==",
"\"None\"",
":",
"names",
"[",
"name",
"]",
"=",
"None",
"elif",
"name",
"==",
"\"True\"",
":",
"names",
"[",
"name",
"]",
"=",
"True",
"elif",
"name",
"==",
"\"False\"",
":",
"names",
"[",
"name",
"]",
"=",
"False",
"else",
":",
"t",
"=",
"types",
".",
"get",
"(",
"name",
",",
"default_type",
")",
"names",
"[",
"name",
"]",
"=",
"expressions",
".",
"VariableNode",
"(",
"name",
",",
"type_to_kind",
"[",
"t",
"]",
")",
"names",
".",
"update",
"(",
"expressions",
".",
"functions",
")",
"# now build the expression",
"ex",
"=",
"eval",
"(",
"c",
",",
"names",
")",
"if",
"expressions",
".",
"isConstant",
"(",
"ex",
")",
":",
"ex",
"=",
"expressions",
".",
"ConstantNode",
"(",
"ex",
",",
"expressions",
".",
"getKind",
"(",
"ex",
")",
")",
"elif",
"not",
"isinstance",
"(",
"ex",
",",
"expressions",
".",
"ExpressionNode",
")",
":",
"raise",
"TypeError",
"(",
"\"unsupported expression type: %s\"",
"%",
"type",
"(",
"ex",
")",
")",
"finally",
":",
"expressions",
".",
"_context",
".",
"set_new_context",
"(",
"old_ctx",
")",
"return",
"ex"
] | Given a string, convert it to a tree of ExpressionNode's. | [
"Given",
"a",
"string",
"convert",
"it",
"to",
"a",
"tree",
"of",
"ExpressionNode",
"s",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L273-L306 |
231,940 | pydata/numexpr | numexpr/necompiler.py | getInputOrder | def getInputOrder(ast, input_order=None):
"""Derive the input order of the variables in an expression.
"""
variables = {}
for a in ast.allOf('variable'):
variables[a.value] = a
variable_names = set(variables.keys())
if input_order:
if variable_names != set(input_order):
raise ValueError(
"input names (%s) don't match those found in expression (%s)"
% (input_order, variable_names))
ordered_names = input_order
else:
ordered_names = list(variable_names)
ordered_names.sort()
ordered_variables = [variables[v] for v in ordered_names]
return ordered_variables | python | def getInputOrder(ast, input_order=None):
"""Derive the input order of the variables in an expression.
"""
variables = {}
for a in ast.allOf('variable'):
variables[a.value] = a
variable_names = set(variables.keys())
if input_order:
if variable_names != set(input_order):
raise ValueError(
"input names (%s) don't match those found in expression (%s)"
% (input_order, variable_names))
ordered_names = input_order
else:
ordered_names = list(variable_names)
ordered_names.sort()
ordered_variables = [variables[v] for v in ordered_names]
return ordered_variables | [
"def",
"getInputOrder",
"(",
"ast",
",",
"input_order",
"=",
"None",
")",
":",
"variables",
"=",
"{",
"}",
"for",
"a",
"in",
"ast",
".",
"allOf",
"(",
"'variable'",
")",
":",
"variables",
"[",
"a",
".",
"value",
"]",
"=",
"a",
"variable_names",
"=",
"set",
"(",
"variables",
".",
"keys",
"(",
")",
")",
"if",
"input_order",
":",
"if",
"variable_names",
"!=",
"set",
"(",
"input_order",
")",
":",
"raise",
"ValueError",
"(",
"\"input names (%s) don't match those found in expression (%s)\"",
"%",
"(",
"input_order",
",",
"variable_names",
")",
")",
"ordered_names",
"=",
"input_order",
"else",
":",
"ordered_names",
"=",
"list",
"(",
"variable_names",
")",
"ordered_names",
".",
"sort",
"(",
")",
"ordered_variables",
"=",
"[",
"variables",
"[",
"v",
"]",
"for",
"v",
"in",
"ordered_names",
"]",
"return",
"ordered_variables"
] | Derive the input order of the variables in an expression. | [
"Derive",
"the",
"input",
"order",
"of",
"the",
"variables",
"in",
"an",
"expression",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L314-L333 |
231,941 | pydata/numexpr | numexpr/necompiler.py | assignLeafRegisters | def assignLeafRegisters(inodes, registerMaker):
"""Assign new registers to each of the leaf nodes.
"""
leafRegisters = {}
for node in inodes:
key = node.key()
if key in leafRegisters:
node.reg = leafRegisters[key]
else:
node.reg = leafRegisters[key] = registerMaker(node) | python | def assignLeafRegisters(inodes, registerMaker):
"""Assign new registers to each of the leaf nodes.
"""
leafRegisters = {}
for node in inodes:
key = node.key()
if key in leafRegisters:
node.reg = leafRegisters[key]
else:
node.reg = leafRegisters[key] = registerMaker(node) | [
"def",
"assignLeafRegisters",
"(",
"inodes",
",",
"registerMaker",
")",
":",
"leafRegisters",
"=",
"{",
"}",
"for",
"node",
"in",
"inodes",
":",
"key",
"=",
"node",
".",
"key",
"(",
")",
"if",
"key",
"in",
"leafRegisters",
":",
"node",
".",
"reg",
"=",
"leafRegisters",
"[",
"key",
"]",
"else",
":",
"node",
".",
"reg",
"=",
"leafRegisters",
"[",
"key",
"]",
"=",
"registerMaker",
"(",
"node",
")"
] | Assign new registers to each of the leaf nodes. | [
"Assign",
"new",
"registers",
"to",
"each",
"of",
"the",
"leaf",
"nodes",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L368-L377 |
231,942 | pydata/numexpr | numexpr/necompiler.py | assignBranchRegisters | def assignBranchRegisters(inodes, registerMaker):
"""Assign temporary registers to each of the branch nodes.
"""
for node in inodes:
node.reg = registerMaker(node, temporary=True) | python | def assignBranchRegisters(inodes, registerMaker):
"""Assign temporary registers to each of the branch nodes.
"""
for node in inodes:
node.reg = registerMaker(node, temporary=True) | [
"def",
"assignBranchRegisters",
"(",
"inodes",
",",
"registerMaker",
")",
":",
"for",
"node",
"in",
"inodes",
":",
"node",
".",
"reg",
"=",
"registerMaker",
"(",
"node",
",",
"temporary",
"=",
"True",
")"
] | Assign temporary registers to each of the branch nodes. | [
"Assign",
"temporary",
"registers",
"to",
"each",
"of",
"the",
"branch",
"nodes",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L380-L384 |
231,943 | pydata/numexpr | numexpr/necompiler.py | collapseDuplicateSubtrees | def collapseDuplicateSubtrees(ast):
"""Common subexpression elimination.
"""
seen = {}
aliases = []
for a in ast.allOf('op'):
if a in seen:
target = seen[a]
a.astType = 'alias'
a.value = target
a.children = ()
aliases.append(a)
else:
seen[a] = a
# Set values and registers so optimizeTemporariesAllocation
# doesn't get confused
for a in aliases:
while a.value.astType == 'alias':
a.value = a.value.value
return aliases | python | def collapseDuplicateSubtrees(ast):
"""Common subexpression elimination.
"""
seen = {}
aliases = []
for a in ast.allOf('op'):
if a in seen:
target = seen[a]
a.astType = 'alias'
a.value = target
a.children = ()
aliases.append(a)
else:
seen[a] = a
# Set values and registers so optimizeTemporariesAllocation
# doesn't get confused
for a in aliases:
while a.value.astType == 'alias':
a.value = a.value.value
return aliases | [
"def",
"collapseDuplicateSubtrees",
"(",
"ast",
")",
":",
"seen",
"=",
"{",
"}",
"aliases",
"=",
"[",
"]",
"for",
"a",
"in",
"ast",
".",
"allOf",
"(",
"'op'",
")",
":",
"if",
"a",
"in",
"seen",
":",
"target",
"=",
"seen",
"[",
"a",
"]",
"a",
".",
"astType",
"=",
"'alias'",
"a",
".",
"value",
"=",
"target",
"a",
".",
"children",
"=",
"(",
")",
"aliases",
".",
"append",
"(",
"a",
")",
"else",
":",
"seen",
"[",
"a",
"]",
"=",
"a",
"# Set values and registers so optimizeTemporariesAllocation",
"# doesn't get confused",
"for",
"a",
"in",
"aliases",
":",
"while",
"a",
".",
"value",
".",
"astType",
"==",
"'alias'",
":",
"a",
".",
"value",
"=",
"a",
".",
"value",
".",
"value",
"return",
"aliases"
] | Common subexpression elimination. | [
"Common",
"subexpression",
"elimination",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L387-L406 |
231,944 | pydata/numexpr | numexpr/necompiler.py | optimizeTemporariesAllocation | def optimizeTemporariesAllocation(ast):
"""Attempt to minimize the number of temporaries needed, by
reusing old ones.
"""
nodes = [n for n in ast.postorderWalk() if n.reg.temporary]
users_of = dict((n.reg, set()) for n in nodes)
node_regs = dict((n, set(c.reg for c in n.children if c.reg.temporary))
for n in nodes)
if nodes and nodes[-1] is not ast:
nodes_to_check = nodes + [ast]
else:
nodes_to_check = nodes
for n in nodes_to_check:
for c in n.children:
if c.reg.temporary:
users_of[c.reg].add(n)
unused = dict([(tc, set()) for tc in scalar_constant_kinds])
for n in nodes:
for c in n.children:
reg = c.reg
if reg.temporary:
users = users_of[reg]
users.discard(n)
if not users:
unused[reg.node.astKind].add(reg)
if unused[n.astKind]:
reg = unused[n.astKind].pop()
users_of[reg] = users_of[n.reg]
n.reg = reg | python | def optimizeTemporariesAllocation(ast):
"""Attempt to minimize the number of temporaries needed, by
reusing old ones.
"""
nodes = [n for n in ast.postorderWalk() if n.reg.temporary]
users_of = dict((n.reg, set()) for n in nodes)
node_regs = dict((n, set(c.reg for c in n.children if c.reg.temporary))
for n in nodes)
if nodes and nodes[-1] is not ast:
nodes_to_check = nodes + [ast]
else:
nodes_to_check = nodes
for n in nodes_to_check:
for c in n.children:
if c.reg.temporary:
users_of[c.reg].add(n)
unused = dict([(tc, set()) for tc in scalar_constant_kinds])
for n in nodes:
for c in n.children:
reg = c.reg
if reg.temporary:
users = users_of[reg]
users.discard(n)
if not users:
unused[reg.node.astKind].add(reg)
if unused[n.astKind]:
reg = unused[n.astKind].pop()
users_of[reg] = users_of[n.reg]
n.reg = reg | [
"def",
"optimizeTemporariesAllocation",
"(",
"ast",
")",
":",
"nodes",
"=",
"[",
"n",
"for",
"n",
"in",
"ast",
".",
"postorderWalk",
"(",
")",
"if",
"n",
".",
"reg",
".",
"temporary",
"]",
"users_of",
"=",
"dict",
"(",
"(",
"n",
".",
"reg",
",",
"set",
"(",
")",
")",
"for",
"n",
"in",
"nodes",
")",
"node_regs",
"=",
"dict",
"(",
"(",
"n",
",",
"set",
"(",
"c",
".",
"reg",
"for",
"c",
"in",
"n",
".",
"children",
"if",
"c",
".",
"reg",
".",
"temporary",
")",
")",
"for",
"n",
"in",
"nodes",
")",
"if",
"nodes",
"and",
"nodes",
"[",
"-",
"1",
"]",
"is",
"not",
"ast",
":",
"nodes_to_check",
"=",
"nodes",
"+",
"[",
"ast",
"]",
"else",
":",
"nodes_to_check",
"=",
"nodes",
"for",
"n",
"in",
"nodes_to_check",
":",
"for",
"c",
"in",
"n",
".",
"children",
":",
"if",
"c",
".",
"reg",
".",
"temporary",
":",
"users_of",
"[",
"c",
".",
"reg",
"]",
".",
"add",
"(",
"n",
")",
"unused",
"=",
"dict",
"(",
"[",
"(",
"tc",
",",
"set",
"(",
")",
")",
"for",
"tc",
"in",
"scalar_constant_kinds",
"]",
")",
"for",
"n",
"in",
"nodes",
":",
"for",
"c",
"in",
"n",
".",
"children",
":",
"reg",
"=",
"c",
".",
"reg",
"if",
"reg",
".",
"temporary",
":",
"users",
"=",
"users_of",
"[",
"reg",
"]",
"users",
".",
"discard",
"(",
"n",
")",
"if",
"not",
"users",
":",
"unused",
"[",
"reg",
".",
"node",
".",
"astKind",
"]",
".",
"add",
"(",
"reg",
")",
"if",
"unused",
"[",
"n",
".",
"astKind",
"]",
":",
"reg",
"=",
"unused",
"[",
"n",
".",
"astKind",
"]",
".",
"pop",
"(",
")",
"users_of",
"[",
"reg",
"]",
"=",
"users_of",
"[",
"n",
".",
"reg",
"]",
"n",
".",
"reg",
"=",
"reg"
] | Attempt to minimize the number of temporaries needed, by
reusing old ones. | [
"Attempt",
"to",
"minimize",
"the",
"number",
"of",
"temporaries",
"needed",
"by",
"reusing",
"old",
"ones",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L409-L439 |
231,945 | pydata/numexpr | numexpr/necompiler.py | setOrderedRegisterNumbers | def setOrderedRegisterNumbers(order, start):
"""Given an order of nodes, assign register numbers.
"""
for i, node in enumerate(order):
node.reg.n = start + i
return start + len(order) | python | def setOrderedRegisterNumbers(order, start):
"""Given an order of nodes, assign register numbers.
"""
for i, node in enumerate(order):
node.reg.n = start + i
return start + len(order) | [
"def",
"setOrderedRegisterNumbers",
"(",
"order",
",",
"start",
")",
":",
"for",
"i",
",",
"node",
"in",
"enumerate",
"(",
"order",
")",
":",
"node",
".",
"reg",
".",
"n",
"=",
"start",
"+",
"i",
"return",
"start",
"+",
"len",
"(",
"order",
")"
] | Given an order of nodes, assign register numbers. | [
"Given",
"an",
"order",
"of",
"nodes",
"assign",
"register",
"numbers",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L442-L447 |
231,946 | pydata/numexpr | numexpr/necompiler.py | setRegisterNumbersForTemporaries | def setRegisterNumbersForTemporaries(ast, start):
"""Assign register numbers for temporary registers, keeping track of
aliases and handling immediate operands.
"""
seen = 0
signature = ''
aliases = []
for node in ast.postorderWalk():
if node.astType == 'alias':
aliases.append(node)
node = node.value
if node.reg.immediate:
node.reg.n = node.value
continue
reg = node.reg
if reg.n is None:
reg.n = start + seen
seen += 1
signature += reg.node.typecode()
for node in aliases:
node.reg = node.value.reg
return start + seen, signature | python | def setRegisterNumbersForTemporaries(ast, start):
"""Assign register numbers for temporary registers, keeping track of
aliases and handling immediate operands.
"""
seen = 0
signature = ''
aliases = []
for node in ast.postorderWalk():
if node.astType == 'alias':
aliases.append(node)
node = node.value
if node.reg.immediate:
node.reg.n = node.value
continue
reg = node.reg
if reg.n is None:
reg.n = start + seen
seen += 1
signature += reg.node.typecode()
for node in aliases:
node.reg = node.value.reg
return start + seen, signature | [
"def",
"setRegisterNumbersForTemporaries",
"(",
"ast",
",",
"start",
")",
":",
"seen",
"=",
"0",
"signature",
"=",
"''",
"aliases",
"=",
"[",
"]",
"for",
"node",
"in",
"ast",
".",
"postorderWalk",
"(",
")",
":",
"if",
"node",
".",
"astType",
"==",
"'alias'",
":",
"aliases",
".",
"append",
"(",
"node",
")",
"node",
"=",
"node",
".",
"value",
"if",
"node",
".",
"reg",
".",
"immediate",
":",
"node",
".",
"reg",
".",
"n",
"=",
"node",
".",
"value",
"continue",
"reg",
"=",
"node",
".",
"reg",
"if",
"reg",
".",
"n",
"is",
"None",
":",
"reg",
".",
"n",
"=",
"start",
"+",
"seen",
"seen",
"+=",
"1",
"signature",
"+=",
"reg",
".",
"node",
".",
"typecode",
"(",
")",
"for",
"node",
"in",
"aliases",
":",
"node",
".",
"reg",
"=",
"node",
".",
"value",
".",
"reg",
"return",
"start",
"+",
"seen",
",",
"signature"
] | Assign register numbers for temporary registers, keeping track of
aliases and handling immediate operands. | [
"Assign",
"register",
"numbers",
"for",
"temporary",
"registers",
"keeping",
"track",
"of",
"aliases",
"and",
"handling",
"immediate",
"operands",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L450-L471 |
231,947 | pydata/numexpr | numexpr/necompiler.py | convertASTtoThreeAddrForm | def convertASTtoThreeAddrForm(ast):
"""Convert an AST to a three address form.
Three address form is (op, reg1, reg2, reg3), where reg1 is the
destination of the result of the instruction.
I suppose this should be called three register form, but three
address form is found in compiler theory.
"""
return [(node.value, node.reg) + tuple([c.reg for c in node.children])
for node in ast.allOf('op')] | python | def convertASTtoThreeAddrForm(ast):
"""Convert an AST to a three address form.
Three address form is (op, reg1, reg2, reg3), where reg1 is the
destination of the result of the instruction.
I suppose this should be called three register form, but three
address form is found in compiler theory.
"""
return [(node.value, node.reg) + tuple([c.reg for c in node.children])
for node in ast.allOf('op')] | [
"def",
"convertASTtoThreeAddrForm",
"(",
"ast",
")",
":",
"return",
"[",
"(",
"node",
".",
"value",
",",
"node",
".",
"reg",
")",
"+",
"tuple",
"(",
"[",
"c",
".",
"reg",
"for",
"c",
"in",
"node",
".",
"children",
"]",
")",
"for",
"node",
"in",
"ast",
".",
"allOf",
"(",
"'op'",
")",
"]"
] | Convert an AST to a three address form.
Three address form is (op, reg1, reg2, reg3), where reg1 is the
destination of the result of the instruction.
I suppose this should be called three register form, but three
address form is found in compiler theory. | [
"Convert",
"an",
"AST",
"to",
"a",
"three",
"address",
"form",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L474-L484 |
231,948 | pydata/numexpr | numexpr/necompiler.py | compileThreeAddrForm | def compileThreeAddrForm(program):
"""Given a three address form of the program, compile it a string that
the VM understands.
"""
def nToChr(reg):
if reg is None:
return b'\xff'
elif reg.n < 0:
raise ValueError("negative value for register number %s" % reg.n)
else:
if sys.version_info[0] < 3:
return chr(reg.n)
else:
# int.to_bytes is not available in Python < 3.2
#return reg.n.to_bytes(1, sys.byteorder)
return bytes([reg.n])
def quadrupleToString(opcode, store, a1=None, a2=None):
cop = chr(interpreter.opcodes[opcode]).encode('ascii')
cs = nToChr(store)
ca1 = nToChr(a1)
ca2 = nToChr(a2)
return cop + cs + ca1 + ca2
def toString(args):
while len(args) < 4:
args += (None,)
opcode, store, a1, a2 = args[:4]
s = quadrupleToString(opcode, store, a1, a2)
l = [s]
args = args[4:]
while args:
s = quadrupleToString(b'noop', *args[:3])
l.append(s)
args = args[3:]
return b''.join(l)
prog_str = b''.join([toString(t) for t in program])
return prog_str | python | def compileThreeAddrForm(program):
"""Given a three address form of the program, compile it a string that
the VM understands.
"""
def nToChr(reg):
if reg is None:
return b'\xff'
elif reg.n < 0:
raise ValueError("negative value for register number %s" % reg.n)
else:
if sys.version_info[0] < 3:
return chr(reg.n)
else:
# int.to_bytes is not available in Python < 3.2
#return reg.n.to_bytes(1, sys.byteorder)
return bytes([reg.n])
def quadrupleToString(opcode, store, a1=None, a2=None):
cop = chr(interpreter.opcodes[opcode]).encode('ascii')
cs = nToChr(store)
ca1 = nToChr(a1)
ca2 = nToChr(a2)
return cop + cs + ca1 + ca2
def toString(args):
while len(args) < 4:
args += (None,)
opcode, store, a1, a2 = args[:4]
s = quadrupleToString(opcode, store, a1, a2)
l = [s]
args = args[4:]
while args:
s = quadrupleToString(b'noop', *args[:3])
l.append(s)
args = args[3:]
return b''.join(l)
prog_str = b''.join([toString(t) for t in program])
return prog_str | [
"def",
"compileThreeAddrForm",
"(",
"program",
")",
":",
"def",
"nToChr",
"(",
"reg",
")",
":",
"if",
"reg",
"is",
"None",
":",
"return",
"b'\\xff'",
"elif",
"reg",
".",
"n",
"<",
"0",
":",
"raise",
"ValueError",
"(",
"\"negative value for register number %s\"",
"%",
"reg",
".",
"n",
")",
"else",
":",
"if",
"sys",
".",
"version_info",
"[",
"0",
"]",
"<",
"3",
":",
"return",
"chr",
"(",
"reg",
".",
"n",
")",
"else",
":",
"# int.to_bytes is not available in Python < 3.2",
"#return reg.n.to_bytes(1, sys.byteorder)",
"return",
"bytes",
"(",
"[",
"reg",
".",
"n",
"]",
")",
"def",
"quadrupleToString",
"(",
"opcode",
",",
"store",
",",
"a1",
"=",
"None",
",",
"a2",
"=",
"None",
")",
":",
"cop",
"=",
"chr",
"(",
"interpreter",
".",
"opcodes",
"[",
"opcode",
"]",
")",
".",
"encode",
"(",
"'ascii'",
")",
"cs",
"=",
"nToChr",
"(",
"store",
")",
"ca1",
"=",
"nToChr",
"(",
"a1",
")",
"ca2",
"=",
"nToChr",
"(",
"a2",
")",
"return",
"cop",
"+",
"cs",
"+",
"ca1",
"+",
"ca2",
"def",
"toString",
"(",
"args",
")",
":",
"while",
"len",
"(",
"args",
")",
"<",
"4",
":",
"args",
"+=",
"(",
"None",
",",
")",
"opcode",
",",
"store",
",",
"a1",
",",
"a2",
"=",
"args",
"[",
":",
"4",
"]",
"s",
"=",
"quadrupleToString",
"(",
"opcode",
",",
"store",
",",
"a1",
",",
"a2",
")",
"l",
"=",
"[",
"s",
"]",
"args",
"=",
"args",
"[",
"4",
":",
"]",
"while",
"args",
":",
"s",
"=",
"quadrupleToString",
"(",
"b'noop'",
",",
"*",
"args",
"[",
":",
"3",
"]",
")",
"l",
".",
"append",
"(",
"s",
")",
"args",
"=",
"args",
"[",
"3",
":",
"]",
"return",
"b''",
".",
"join",
"(",
"l",
")",
"prog_str",
"=",
"b''",
".",
"join",
"(",
"[",
"toString",
"(",
"t",
")",
"for",
"t",
"in",
"program",
"]",
")",
"return",
"prog_str"
] | Given a three address form of the program, compile it a string that
the VM understands. | [
"Given",
"a",
"three",
"address",
"form",
"of",
"the",
"program",
"compile",
"it",
"a",
"string",
"that",
"the",
"VM",
"understands",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L487-L526 |
231,949 | pydata/numexpr | numexpr/necompiler.py | precompile | def precompile(ex, signature=(), context={}):
"""Compile the expression to an intermediate form.
"""
types = dict(signature)
input_order = [name for (name, type_) in signature]
if isinstance(ex, (str, unicode)):
ex = stringToExpression(ex, types, context)
# the AST is like the expression, but the node objects don't have
# any odd interpretations
ast = expressionToAST(ex)
if ex.astType != 'op':
ast = ASTNode('op', value='copy', astKind=ex.astKind, children=(ast,))
ast = typeCompileAst(ast)
aliases = collapseDuplicateSubtrees(ast)
assignLeafRegisters(ast.allOf('raw'), Immediate)
assignLeafRegisters(ast.allOf('variable', 'constant'), Register)
assignBranchRegisters(ast.allOf('op'), Register)
# assign registers for aliases
for a in aliases:
a.reg = a.value.reg
input_order = getInputOrder(ast, input_order)
constants_order, constants = getConstants(ast)
if isReduction(ast):
ast.reg.temporary = False
optimizeTemporariesAllocation(ast)
ast.reg.temporary = False
r_output = 0
ast.reg.n = 0
r_inputs = r_output + 1
r_constants = setOrderedRegisterNumbers(input_order, r_inputs)
r_temps = setOrderedRegisterNumbers(constants_order, r_constants)
r_end, tempsig = setRegisterNumbersForTemporaries(ast, r_temps)
threeAddrProgram = convertASTtoThreeAddrForm(ast)
input_names = tuple([a.value for a in input_order])
signature = ''.join(type_to_typecode[types.get(x, default_type)]
for x in input_names)
return threeAddrProgram, signature, tempsig, constants, input_names | python | def precompile(ex, signature=(), context={}):
"""Compile the expression to an intermediate form.
"""
types = dict(signature)
input_order = [name for (name, type_) in signature]
if isinstance(ex, (str, unicode)):
ex = stringToExpression(ex, types, context)
# the AST is like the expression, but the node objects don't have
# any odd interpretations
ast = expressionToAST(ex)
if ex.astType != 'op':
ast = ASTNode('op', value='copy', astKind=ex.astKind, children=(ast,))
ast = typeCompileAst(ast)
aliases = collapseDuplicateSubtrees(ast)
assignLeafRegisters(ast.allOf('raw'), Immediate)
assignLeafRegisters(ast.allOf('variable', 'constant'), Register)
assignBranchRegisters(ast.allOf('op'), Register)
# assign registers for aliases
for a in aliases:
a.reg = a.value.reg
input_order = getInputOrder(ast, input_order)
constants_order, constants = getConstants(ast)
if isReduction(ast):
ast.reg.temporary = False
optimizeTemporariesAllocation(ast)
ast.reg.temporary = False
r_output = 0
ast.reg.n = 0
r_inputs = r_output + 1
r_constants = setOrderedRegisterNumbers(input_order, r_inputs)
r_temps = setOrderedRegisterNumbers(constants_order, r_constants)
r_end, tempsig = setRegisterNumbersForTemporaries(ast, r_temps)
threeAddrProgram = convertASTtoThreeAddrForm(ast)
input_names = tuple([a.value for a in input_order])
signature = ''.join(type_to_typecode[types.get(x, default_type)]
for x in input_names)
return threeAddrProgram, signature, tempsig, constants, input_names | [
"def",
"precompile",
"(",
"ex",
",",
"signature",
"=",
"(",
")",
",",
"context",
"=",
"{",
"}",
")",
":",
"types",
"=",
"dict",
"(",
"signature",
")",
"input_order",
"=",
"[",
"name",
"for",
"(",
"name",
",",
"type_",
")",
"in",
"signature",
"]",
"if",
"isinstance",
"(",
"ex",
",",
"(",
"str",
",",
"unicode",
")",
")",
":",
"ex",
"=",
"stringToExpression",
"(",
"ex",
",",
"types",
",",
"context",
")",
"# the AST is like the expression, but the node objects don't have",
"# any odd interpretations",
"ast",
"=",
"expressionToAST",
"(",
"ex",
")",
"if",
"ex",
".",
"astType",
"!=",
"'op'",
":",
"ast",
"=",
"ASTNode",
"(",
"'op'",
",",
"value",
"=",
"'copy'",
",",
"astKind",
"=",
"ex",
".",
"astKind",
",",
"children",
"=",
"(",
"ast",
",",
")",
")",
"ast",
"=",
"typeCompileAst",
"(",
"ast",
")",
"aliases",
"=",
"collapseDuplicateSubtrees",
"(",
"ast",
")",
"assignLeafRegisters",
"(",
"ast",
".",
"allOf",
"(",
"'raw'",
")",
",",
"Immediate",
")",
"assignLeafRegisters",
"(",
"ast",
".",
"allOf",
"(",
"'variable'",
",",
"'constant'",
")",
",",
"Register",
")",
"assignBranchRegisters",
"(",
"ast",
".",
"allOf",
"(",
"'op'",
")",
",",
"Register",
")",
"# assign registers for aliases",
"for",
"a",
"in",
"aliases",
":",
"a",
".",
"reg",
"=",
"a",
".",
"value",
".",
"reg",
"input_order",
"=",
"getInputOrder",
"(",
"ast",
",",
"input_order",
")",
"constants_order",
",",
"constants",
"=",
"getConstants",
"(",
"ast",
")",
"if",
"isReduction",
"(",
"ast",
")",
":",
"ast",
".",
"reg",
".",
"temporary",
"=",
"False",
"optimizeTemporariesAllocation",
"(",
"ast",
")",
"ast",
".",
"reg",
".",
"temporary",
"=",
"False",
"r_output",
"=",
"0",
"ast",
".",
"reg",
".",
"n",
"=",
"0",
"r_inputs",
"=",
"r_output",
"+",
"1",
"r_constants",
"=",
"setOrderedRegisterNumbers",
"(",
"input_order",
",",
"r_inputs",
")",
"r_temps",
"=",
"setOrderedRegisterNumbers",
"(",
"constants_order",
",",
"r_constants",
")",
"r_end",
",",
"tempsig",
"=",
"setRegisterNumbersForTemporaries",
"(",
"ast",
",",
"r_temps",
")",
"threeAddrProgram",
"=",
"convertASTtoThreeAddrForm",
"(",
"ast",
")",
"input_names",
"=",
"tuple",
"(",
"[",
"a",
".",
"value",
"for",
"a",
"in",
"input_order",
"]",
")",
"signature",
"=",
"''",
".",
"join",
"(",
"type_to_typecode",
"[",
"types",
".",
"get",
"(",
"x",
",",
"default_type",
")",
"]",
"for",
"x",
"in",
"input_names",
")",
"return",
"threeAddrProgram",
",",
"signature",
",",
"tempsig",
",",
"constants",
",",
"input_names"
] | Compile the expression to an intermediate form. | [
"Compile",
"the",
"expression",
"to",
"an",
"intermediate",
"form",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L554-L604 |
231,950 | pydata/numexpr | numexpr/necompiler.py | disassemble | def disassemble(nex):
"""
Given a NumExpr object, return a list which is the program disassembled.
"""
rev_opcodes = {}
for op in interpreter.opcodes:
rev_opcodes[interpreter.opcodes[op]] = op
r_constants = 1 + len(nex.signature)
r_temps = r_constants + len(nex.constants)
def getArg(pc, offset):
if sys.version_info[0] < 3:
arg = ord(nex.program[pc + offset])
op = rev_opcodes.get(ord(nex.program[pc]))
else:
arg = nex.program[pc + offset]
op = rev_opcodes.get(nex.program[pc])
try:
code = op.split(b'_')[1][offset - 1]
except IndexError:
return None
if sys.version_info[0] > 2:
# int.to_bytes is not available in Python < 3.2
#code = code.to_bytes(1, sys.byteorder)
code = bytes([code])
if arg == 255:
return None
if code != b'n':
if arg == 0:
return b'r0'
elif arg < r_constants:
return ('r%d[%s]' % (arg, nex.input_names[arg - 1])).encode('ascii')
elif arg < r_temps:
return ('c%d[%s]' % (arg, nex.constants[arg - r_constants])).encode('ascii')
else:
return ('t%d' % (arg,)).encode('ascii')
else:
return arg
source = []
for pc in range(0, len(nex.program), 4):
if sys.version_info[0] < 3:
op = rev_opcodes.get(ord(nex.program[pc]))
else:
op = rev_opcodes.get(nex.program[pc])
dest = getArg(pc, 1)
arg1 = getArg(pc, 2)
arg2 = getArg(pc, 3)
source.append((op, dest, arg1, arg2))
return source | python | def disassemble(nex):
"""
Given a NumExpr object, return a list which is the program disassembled.
"""
rev_opcodes = {}
for op in interpreter.opcodes:
rev_opcodes[interpreter.opcodes[op]] = op
r_constants = 1 + len(nex.signature)
r_temps = r_constants + len(nex.constants)
def getArg(pc, offset):
if sys.version_info[0] < 3:
arg = ord(nex.program[pc + offset])
op = rev_opcodes.get(ord(nex.program[pc]))
else:
arg = nex.program[pc + offset]
op = rev_opcodes.get(nex.program[pc])
try:
code = op.split(b'_')[1][offset - 1]
except IndexError:
return None
if sys.version_info[0] > 2:
# int.to_bytes is not available in Python < 3.2
#code = code.to_bytes(1, sys.byteorder)
code = bytes([code])
if arg == 255:
return None
if code != b'n':
if arg == 0:
return b'r0'
elif arg < r_constants:
return ('r%d[%s]' % (arg, nex.input_names[arg - 1])).encode('ascii')
elif arg < r_temps:
return ('c%d[%s]' % (arg, nex.constants[arg - r_constants])).encode('ascii')
else:
return ('t%d' % (arg,)).encode('ascii')
else:
return arg
source = []
for pc in range(0, len(nex.program), 4):
if sys.version_info[0] < 3:
op = rev_opcodes.get(ord(nex.program[pc]))
else:
op = rev_opcodes.get(nex.program[pc])
dest = getArg(pc, 1)
arg1 = getArg(pc, 2)
arg2 = getArg(pc, 3)
source.append((op, dest, arg1, arg2))
return source | [
"def",
"disassemble",
"(",
"nex",
")",
":",
"rev_opcodes",
"=",
"{",
"}",
"for",
"op",
"in",
"interpreter",
".",
"opcodes",
":",
"rev_opcodes",
"[",
"interpreter",
".",
"opcodes",
"[",
"op",
"]",
"]",
"=",
"op",
"r_constants",
"=",
"1",
"+",
"len",
"(",
"nex",
".",
"signature",
")",
"r_temps",
"=",
"r_constants",
"+",
"len",
"(",
"nex",
".",
"constants",
")",
"def",
"getArg",
"(",
"pc",
",",
"offset",
")",
":",
"if",
"sys",
".",
"version_info",
"[",
"0",
"]",
"<",
"3",
":",
"arg",
"=",
"ord",
"(",
"nex",
".",
"program",
"[",
"pc",
"+",
"offset",
"]",
")",
"op",
"=",
"rev_opcodes",
".",
"get",
"(",
"ord",
"(",
"nex",
".",
"program",
"[",
"pc",
"]",
")",
")",
"else",
":",
"arg",
"=",
"nex",
".",
"program",
"[",
"pc",
"+",
"offset",
"]",
"op",
"=",
"rev_opcodes",
".",
"get",
"(",
"nex",
".",
"program",
"[",
"pc",
"]",
")",
"try",
":",
"code",
"=",
"op",
".",
"split",
"(",
"b'_'",
")",
"[",
"1",
"]",
"[",
"offset",
"-",
"1",
"]",
"except",
"IndexError",
":",
"return",
"None",
"if",
"sys",
".",
"version_info",
"[",
"0",
"]",
">",
"2",
":",
"# int.to_bytes is not available in Python < 3.2",
"#code = code.to_bytes(1, sys.byteorder)",
"code",
"=",
"bytes",
"(",
"[",
"code",
"]",
")",
"if",
"arg",
"==",
"255",
":",
"return",
"None",
"if",
"code",
"!=",
"b'n'",
":",
"if",
"arg",
"==",
"0",
":",
"return",
"b'r0'",
"elif",
"arg",
"<",
"r_constants",
":",
"return",
"(",
"'r%d[%s]'",
"%",
"(",
"arg",
",",
"nex",
".",
"input_names",
"[",
"arg",
"-",
"1",
"]",
")",
")",
".",
"encode",
"(",
"'ascii'",
")",
"elif",
"arg",
"<",
"r_temps",
":",
"return",
"(",
"'c%d[%s]'",
"%",
"(",
"arg",
",",
"nex",
".",
"constants",
"[",
"arg",
"-",
"r_constants",
"]",
")",
")",
".",
"encode",
"(",
"'ascii'",
")",
"else",
":",
"return",
"(",
"'t%d'",
"%",
"(",
"arg",
",",
")",
")",
".",
"encode",
"(",
"'ascii'",
")",
"else",
":",
"return",
"arg",
"source",
"=",
"[",
"]",
"for",
"pc",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"nex",
".",
"program",
")",
",",
"4",
")",
":",
"if",
"sys",
".",
"version_info",
"[",
"0",
"]",
"<",
"3",
":",
"op",
"=",
"rev_opcodes",
".",
"get",
"(",
"ord",
"(",
"nex",
".",
"program",
"[",
"pc",
"]",
")",
")",
"else",
":",
"op",
"=",
"rev_opcodes",
".",
"get",
"(",
"nex",
".",
"program",
"[",
"pc",
"]",
")",
"dest",
"=",
"getArg",
"(",
"pc",
",",
"1",
")",
"arg1",
"=",
"getArg",
"(",
"pc",
",",
"2",
")",
"arg2",
"=",
"getArg",
"(",
"pc",
",",
"3",
")",
"source",
".",
"append",
"(",
"(",
"op",
",",
"dest",
",",
"arg1",
",",
"arg2",
")",
")",
"return",
"source"
] | Given a NumExpr object, return a list which is the program disassembled. | [
"Given",
"a",
"NumExpr",
"object",
"return",
"a",
"list",
"which",
"is",
"the",
"program",
"disassembled",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L633-L682 |
231,951 | pydata/numexpr | numexpr/necompiler.py | getArguments | def getArguments(names, local_dict=None, global_dict=None):
"""Get the arguments based on the names."""
call_frame = sys._getframe(2)
clear_local_dict = False
if local_dict is None:
local_dict = call_frame.f_locals
clear_local_dict = True
try:
frame_globals = call_frame.f_globals
if global_dict is None:
global_dict = frame_globals
# If `call_frame` is the top frame of the interpreter we can't clear its
# `local_dict`, because it is actually the `global_dict`.
clear_local_dict = clear_local_dict and not frame_globals is local_dict
arguments = []
for name in names:
try:
a = local_dict[name]
except KeyError:
a = global_dict[name]
arguments.append(numpy.asarray(a))
finally:
# If we generated local_dict via an explicit reference to f_locals,
# clear the dict to prevent creating extra ref counts in the caller's scope
# See https://github.com/pydata/numexpr/issues/310
if clear_local_dict:
local_dict.clear()
return arguments | python | def getArguments(names, local_dict=None, global_dict=None):
"""Get the arguments based on the names."""
call_frame = sys._getframe(2)
clear_local_dict = False
if local_dict is None:
local_dict = call_frame.f_locals
clear_local_dict = True
try:
frame_globals = call_frame.f_globals
if global_dict is None:
global_dict = frame_globals
# If `call_frame` is the top frame of the interpreter we can't clear its
# `local_dict`, because it is actually the `global_dict`.
clear_local_dict = clear_local_dict and not frame_globals is local_dict
arguments = []
for name in names:
try:
a = local_dict[name]
except KeyError:
a = global_dict[name]
arguments.append(numpy.asarray(a))
finally:
# If we generated local_dict via an explicit reference to f_locals,
# clear the dict to prevent creating extra ref counts in the caller's scope
# See https://github.com/pydata/numexpr/issues/310
if clear_local_dict:
local_dict.clear()
return arguments | [
"def",
"getArguments",
"(",
"names",
",",
"local_dict",
"=",
"None",
",",
"global_dict",
"=",
"None",
")",
":",
"call_frame",
"=",
"sys",
".",
"_getframe",
"(",
"2",
")",
"clear_local_dict",
"=",
"False",
"if",
"local_dict",
"is",
"None",
":",
"local_dict",
"=",
"call_frame",
".",
"f_locals",
"clear_local_dict",
"=",
"True",
"try",
":",
"frame_globals",
"=",
"call_frame",
".",
"f_globals",
"if",
"global_dict",
"is",
"None",
":",
"global_dict",
"=",
"frame_globals",
"# If `call_frame` is the top frame of the interpreter we can't clear its ",
"# `local_dict`, because it is actually the `global_dict`.",
"clear_local_dict",
"=",
"clear_local_dict",
"and",
"not",
"frame_globals",
"is",
"local_dict",
"arguments",
"=",
"[",
"]",
"for",
"name",
"in",
"names",
":",
"try",
":",
"a",
"=",
"local_dict",
"[",
"name",
"]",
"except",
"KeyError",
":",
"a",
"=",
"global_dict",
"[",
"name",
"]",
"arguments",
".",
"append",
"(",
"numpy",
".",
"asarray",
"(",
"a",
")",
")",
"finally",
":",
"# If we generated local_dict via an explicit reference to f_locals,",
"# clear the dict to prevent creating extra ref counts in the caller's scope",
"# See https://github.com/pydata/numexpr/issues/310",
"if",
"clear_local_dict",
":",
"local_dict",
".",
"clear",
"(",
")",
"return",
"arguments"
] | Get the arguments based on the names. | [
"Get",
"the",
"arguments",
"based",
"on",
"the",
"names",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L724-L755 |
231,952 | pydata/numexpr | numexpr/necompiler.py | evaluate | def evaluate(ex, local_dict=None, global_dict=None,
out=None, order='K', casting='safe', **kwargs):
"""Evaluate a simple array expression element-wise, using the new iterator.
ex is a string forming an expression, like "2*a+3*b". The values for "a"
and "b" will by default be taken from the calling function's frame
(through use of sys._getframe()). Alternatively, they can be specifed
using the 'local_dict' or 'global_dict' arguments.
Parameters
----------
local_dict : dictionary, optional
A dictionary that replaces the local operands in current frame.
global_dict : dictionary, optional
A dictionary that replaces the global operands in current frame.
out : NumPy array, optional
An existing array where the outcome is going to be stored. Care is
required so that this array has the same shape and type than the
actual outcome of the computation. Useful for avoiding unnecessary
new array allocations.
order : {'C', 'F', 'A', or 'K'}, optional
Controls the iteration order for operands. 'C' means C order, 'F'
means Fortran order, 'A' means 'F' order if all the arrays are
Fortran contiguous, 'C' order otherwise, and 'K' means as close to
the order the array elements appear in memory as possible. For
efficient computations, typically 'K'eep order (the default) is
desired.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur when making a copy or
buffering. Setting this to 'unsafe' is not recommended, as it can
adversely affect accumulations.
* 'no' means the data types should not be cast at all.
* 'equiv' means only byte-order changes are allowed.
* 'safe' means only casts which can preserve values are allowed.
* 'same_kind' means only safe casts or casts within a kind,
like float64 to float32, are allowed.
* 'unsafe' means any data conversions may be done.
"""
global _numexpr_last
if not isinstance(ex, (str, unicode)):
raise ValueError("must specify expression as a string")
# Get the names for this expression
context = getContext(kwargs, frame_depth=1)
expr_key = (ex, tuple(sorted(context.items())))
if expr_key not in _names_cache:
_names_cache[expr_key] = getExprNames(ex, context)
names, ex_uses_vml = _names_cache[expr_key]
arguments = getArguments(names, local_dict, global_dict)
# Create a signature
signature = [(name, getType(arg)) for (name, arg) in
zip(names, arguments)]
# Look up numexpr if possible.
numexpr_key = expr_key + (tuple(signature),)
try:
compiled_ex = _numexpr_cache[numexpr_key]
except KeyError:
compiled_ex = _numexpr_cache[numexpr_key] = NumExpr(ex, signature, **context)
kwargs = {'out': out, 'order': order, 'casting': casting,
'ex_uses_vml': ex_uses_vml}
_numexpr_last = dict(ex=compiled_ex, argnames=names, kwargs=kwargs)
with evaluate_lock:
return compiled_ex(*arguments, **kwargs) | python | def evaluate(ex, local_dict=None, global_dict=None,
out=None, order='K', casting='safe', **kwargs):
"""Evaluate a simple array expression element-wise, using the new iterator.
ex is a string forming an expression, like "2*a+3*b". The values for "a"
and "b" will by default be taken from the calling function's frame
(through use of sys._getframe()). Alternatively, they can be specifed
using the 'local_dict' or 'global_dict' arguments.
Parameters
----------
local_dict : dictionary, optional
A dictionary that replaces the local operands in current frame.
global_dict : dictionary, optional
A dictionary that replaces the global operands in current frame.
out : NumPy array, optional
An existing array where the outcome is going to be stored. Care is
required so that this array has the same shape and type than the
actual outcome of the computation. Useful for avoiding unnecessary
new array allocations.
order : {'C', 'F', 'A', or 'K'}, optional
Controls the iteration order for operands. 'C' means C order, 'F'
means Fortran order, 'A' means 'F' order if all the arrays are
Fortran contiguous, 'C' order otherwise, and 'K' means as close to
the order the array elements appear in memory as possible. For
efficient computations, typically 'K'eep order (the default) is
desired.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur when making a copy or
buffering. Setting this to 'unsafe' is not recommended, as it can
adversely affect accumulations.
* 'no' means the data types should not be cast at all.
* 'equiv' means only byte-order changes are allowed.
* 'safe' means only casts which can preserve values are allowed.
* 'same_kind' means only safe casts or casts within a kind,
like float64 to float32, are allowed.
* 'unsafe' means any data conversions may be done.
"""
global _numexpr_last
if not isinstance(ex, (str, unicode)):
raise ValueError("must specify expression as a string")
# Get the names for this expression
context = getContext(kwargs, frame_depth=1)
expr_key = (ex, tuple(sorted(context.items())))
if expr_key not in _names_cache:
_names_cache[expr_key] = getExprNames(ex, context)
names, ex_uses_vml = _names_cache[expr_key]
arguments = getArguments(names, local_dict, global_dict)
# Create a signature
signature = [(name, getType(arg)) for (name, arg) in
zip(names, arguments)]
# Look up numexpr if possible.
numexpr_key = expr_key + (tuple(signature),)
try:
compiled_ex = _numexpr_cache[numexpr_key]
except KeyError:
compiled_ex = _numexpr_cache[numexpr_key] = NumExpr(ex, signature, **context)
kwargs = {'out': out, 'order': order, 'casting': casting,
'ex_uses_vml': ex_uses_vml}
_numexpr_last = dict(ex=compiled_ex, argnames=names, kwargs=kwargs)
with evaluate_lock:
return compiled_ex(*arguments, **kwargs) | [
"def",
"evaluate",
"(",
"ex",
",",
"local_dict",
"=",
"None",
",",
"global_dict",
"=",
"None",
",",
"out",
"=",
"None",
",",
"order",
"=",
"'K'",
",",
"casting",
"=",
"'safe'",
",",
"*",
"*",
"kwargs",
")",
":",
"global",
"_numexpr_last",
"if",
"not",
"isinstance",
"(",
"ex",
",",
"(",
"str",
",",
"unicode",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"must specify expression as a string\"",
")",
"# Get the names for this expression",
"context",
"=",
"getContext",
"(",
"kwargs",
",",
"frame_depth",
"=",
"1",
")",
"expr_key",
"=",
"(",
"ex",
",",
"tuple",
"(",
"sorted",
"(",
"context",
".",
"items",
"(",
")",
")",
")",
")",
"if",
"expr_key",
"not",
"in",
"_names_cache",
":",
"_names_cache",
"[",
"expr_key",
"]",
"=",
"getExprNames",
"(",
"ex",
",",
"context",
")",
"names",
",",
"ex_uses_vml",
"=",
"_names_cache",
"[",
"expr_key",
"]",
"arguments",
"=",
"getArguments",
"(",
"names",
",",
"local_dict",
",",
"global_dict",
")",
"# Create a signature",
"signature",
"=",
"[",
"(",
"name",
",",
"getType",
"(",
"arg",
")",
")",
"for",
"(",
"name",
",",
"arg",
")",
"in",
"zip",
"(",
"names",
",",
"arguments",
")",
"]",
"# Look up numexpr if possible.",
"numexpr_key",
"=",
"expr_key",
"+",
"(",
"tuple",
"(",
"signature",
")",
",",
")",
"try",
":",
"compiled_ex",
"=",
"_numexpr_cache",
"[",
"numexpr_key",
"]",
"except",
"KeyError",
":",
"compiled_ex",
"=",
"_numexpr_cache",
"[",
"numexpr_key",
"]",
"=",
"NumExpr",
"(",
"ex",
",",
"signature",
",",
"*",
"*",
"context",
")",
"kwargs",
"=",
"{",
"'out'",
":",
"out",
",",
"'order'",
":",
"order",
",",
"'casting'",
":",
"casting",
",",
"'ex_uses_vml'",
":",
"ex_uses_vml",
"}",
"_numexpr_last",
"=",
"dict",
"(",
"ex",
"=",
"compiled_ex",
",",
"argnames",
"=",
"names",
",",
"kwargs",
"=",
"kwargs",
")",
"with",
"evaluate_lock",
":",
"return",
"compiled_ex",
"(",
"*",
"arguments",
",",
"*",
"*",
"kwargs",
")"
] | Evaluate a simple array expression element-wise, using the new iterator.
ex is a string forming an expression, like "2*a+3*b". The values for "a"
and "b" will by default be taken from the calling function's frame
(through use of sys._getframe()). Alternatively, they can be specifed
using the 'local_dict' or 'global_dict' arguments.
Parameters
----------
local_dict : dictionary, optional
A dictionary that replaces the local operands in current frame.
global_dict : dictionary, optional
A dictionary that replaces the global operands in current frame.
out : NumPy array, optional
An existing array where the outcome is going to be stored. Care is
required so that this array has the same shape and type than the
actual outcome of the computation. Useful for avoiding unnecessary
new array allocations.
order : {'C', 'F', 'A', or 'K'}, optional
Controls the iteration order for operands. 'C' means C order, 'F'
means Fortran order, 'A' means 'F' order if all the arrays are
Fortran contiguous, 'C' order otherwise, and 'K' means as close to
the order the array elements appear in memory as possible. For
efficient computations, typically 'K'eep order (the default) is
desired.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur when making a copy or
buffering. Setting this to 'unsafe' is not recommended, as it can
adversely affect accumulations.
* 'no' means the data types should not be cast at all.
* 'equiv' means only byte-order changes are allowed.
* 'safe' means only casts which can preserve values are allowed.
* 'same_kind' means only safe casts or casts within a kind,
like float64 to float32, are allowed.
* 'unsafe' means any data conversions may be done. | [
"Evaluate",
"a",
"simple",
"array",
"expression",
"element",
"-",
"wise",
"using",
"the",
"new",
"iterator",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L765-L834 |
231,953 | pydata/numexpr | numexpr/necompiler.py | re_evaluate | def re_evaluate(local_dict=None):
"""Re-evaluate the previous executed array expression without any check.
This is meant for accelerating loops that are re-evaluating the same
expression repeatedly without changing anything else than the operands.
If unsure, use evaluate() which is safer.
Parameters
----------
local_dict : dictionary, optional
A dictionary that replaces the local operands in current frame.
"""
try:
compiled_ex = _numexpr_last['ex']
except KeyError:
raise RuntimeError("not a previous evaluate() execution found")
argnames = _numexpr_last['argnames']
args = getArguments(argnames, local_dict)
kwargs = _numexpr_last['kwargs']
with evaluate_lock:
return compiled_ex(*args, **kwargs) | python | def re_evaluate(local_dict=None):
"""Re-evaluate the previous executed array expression without any check.
This is meant for accelerating loops that are re-evaluating the same
expression repeatedly without changing anything else than the operands.
If unsure, use evaluate() which is safer.
Parameters
----------
local_dict : dictionary, optional
A dictionary that replaces the local operands in current frame.
"""
try:
compiled_ex = _numexpr_last['ex']
except KeyError:
raise RuntimeError("not a previous evaluate() execution found")
argnames = _numexpr_last['argnames']
args = getArguments(argnames, local_dict)
kwargs = _numexpr_last['kwargs']
with evaluate_lock:
return compiled_ex(*args, **kwargs) | [
"def",
"re_evaluate",
"(",
"local_dict",
"=",
"None",
")",
":",
"try",
":",
"compiled_ex",
"=",
"_numexpr_last",
"[",
"'ex'",
"]",
"except",
"KeyError",
":",
"raise",
"RuntimeError",
"(",
"\"not a previous evaluate() execution found\"",
")",
"argnames",
"=",
"_numexpr_last",
"[",
"'argnames'",
"]",
"args",
"=",
"getArguments",
"(",
"argnames",
",",
"local_dict",
")",
"kwargs",
"=",
"_numexpr_last",
"[",
"'kwargs'",
"]",
"with",
"evaluate_lock",
":",
"return",
"compiled_ex",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | Re-evaluate the previous executed array expression without any check.
This is meant for accelerating loops that are re-evaluating the same
expression repeatedly without changing anything else than the operands.
If unsure, use evaluate() which is safer.
Parameters
----------
local_dict : dictionary, optional
A dictionary that replaces the local operands in current frame. | [
"Re",
"-",
"evaluate",
"the",
"previous",
"executed",
"array",
"expression",
"without",
"any",
"check",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L837-L859 |
231,954 | pydata/numexpr | bench/poly.py | compute | def compute():
"""Compute the polynomial."""
if what == "numpy":
y = eval(expr)
else:
y = ne.evaluate(expr)
return len(y) | python | def compute():
"""Compute the polynomial."""
if what == "numpy":
y = eval(expr)
else:
y = ne.evaluate(expr)
return len(y) | [
"def",
"compute",
"(",
")",
":",
"if",
"what",
"==",
"\"numpy\"",
":",
"y",
"=",
"eval",
"(",
"expr",
")",
"else",
":",
"y",
"=",
"ne",
".",
"evaluate",
"(",
"expr",
")",
"return",
"len",
"(",
"y",
")"
] | Compute the polynomial. | [
"Compute",
"the",
"polynomial",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/bench/poly.py#L34-L40 |
231,955 | MaxHalford/prince | prince/mfa.py | MFA.partial_row_coordinates | def partial_row_coordinates(self, X):
"""Returns the row coordinates for each group."""
utils.validation.check_is_fitted(self, 's_')
# Check input
if self.check_input:
utils.check_array(X, dtype=[str, np.number])
# Prepare input
X = self._prepare_input(X)
# Define the projection matrix P
P = len(X) ** 0.5 * self.U_ / self.s_
# Get the projections for each group
coords = {}
for name, cols in sorted(self.groups.items()):
X_partial = X.loc[:, cols]
if not self.all_nums_[name]:
X_partial = self.cat_one_hots_[name].transform(X_partial)
Z_partial = X_partial / self.partial_factor_analysis_[name].s_[0]
coords[name] = len(self.groups) * (Z_partial @ Z_partial.T) @ P
# Convert coords to a MultiIndex DataFrame
coords = pd.DataFrame({
(name, i): group_coords.loc[:, i]
for name, group_coords in coords.items()
for i in range(group_coords.shape[1])
})
return coords | python | def partial_row_coordinates(self, X):
"""Returns the row coordinates for each group."""
utils.validation.check_is_fitted(self, 's_')
# Check input
if self.check_input:
utils.check_array(X, dtype=[str, np.number])
# Prepare input
X = self._prepare_input(X)
# Define the projection matrix P
P = len(X) ** 0.5 * self.U_ / self.s_
# Get the projections for each group
coords = {}
for name, cols in sorted(self.groups.items()):
X_partial = X.loc[:, cols]
if not self.all_nums_[name]:
X_partial = self.cat_one_hots_[name].transform(X_partial)
Z_partial = X_partial / self.partial_factor_analysis_[name].s_[0]
coords[name] = len(self.groups) * (Z_partial @ Z_partial.T) @ P
# Convert coords to a MultiIndex DataFrame
coords = pd.DataFrame({
(name, i): group_coords.loc[:, i]
for name, group_coords in coords.items()
for i in range(group_coords.shape[1])
})
return coords | [
"def",
"partial_row_coordinates",
"(",
"self",
",",
"X",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'s_'",
")",
"# Check input",
"if",
"self",
".",
"check_input",
":",
"utils",
".",
"check_array",
"(",
"X",
",",
"dtype",
"=",
"[",
"str",
",",
"np",
".",
"number",
"]",
")",
"# Prepare input",
"X",
"=",
"self",
".",
"_prepare_input",
"(",
"X",
")",
"# Define the projection matrix P",
"P",
"=",
"len",
"(",
"X",
")",
"**",
"0.5",
"*",
"self",
".",
"U_",
"/",
"self",
".",
"s_",
"# Get the projections for each group",
"coords",
"=",
"{",
"}",
"for",
"name",
",",
"cols",
"in",
"sorted",
"(",
"self",
".",
"groups",
".",
"items",
"(",
")",
")",
":",
"X_partial",
"=",
"X",
".",
"loc",
"[",
":",
",",
"cols",
"]",
"if",
"not",
"self",
".",
"all_nums_",
"[",
"name",
"]",
":",
"X_partial",
"=",
"self",
".",
"cat_one_hots_",
"[",
"name",
"]",
".",
"transform",
"(",
"X_partial",
")",
"Z_partial",
"=",
"X_partial",
"/",
"self",
".",
"partial_factor_analysis_",
"[",
"name",
"]",
".",
"s_",
"[",
"0",
"]",
"coords",
"[",
"name",
"]",
"=",
"len",
"(",
"self",
".",
"groups",
")",
"*",
"(",
"Z_partial",
"@",
"Z_partial",
".",
"T",
")",
"@",
"P",
"# Convert coords to a MultiIndex DataFrame",
"coords",
"=",
"pd",
".",
"DataFrame",
"(",
"{",
"(",
"name",
",",
"i",
")",
":",
"group_coords",
".",
"loc",
"[",
":",
",",
"i",
"]",
"for",
"name",
",",
"group_coords",
"in",
"coords",
".",
"items",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"group_coords",
".",
"shape",
"[",
"1",
"]",
")",
"}",
")",
"return",
"coords"
] | Returns the row coordinates for each group. | [
"Returns",
"the",
"row",
"coordinates",
"for",
"each",
"group",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/mfa.py#L158-L190 |
231,956 | MaxHalford/prince | prince/mfa.py | MFA.column_correlations | def column_correlations(self, X):
"""Returns the column correlations."""
utils.validation.check_is_fitted(self, 's_')
X_global = self._build_X_global(X)
row_pc = self._row_coordinates_from_global(X_global)
return pd.DataFrame({
component: {
feature: row_pc[component].corr(X_global[feature].to_dense())
for feature in X_global.columns
}
for component in row_pc.columns
}) | python | def column_correlations(self, X):
"""Returns the column correlations."""
utils.validation.check_is_fitted(self, 's_')
X_global = self._build_X_global(X)
row_pc = self._row_coordinates_from_global(X_global)
return pd.DataFrame({
component: {
feature: row_pc[component].corr(X_global[feature].to_dense())
for feature in X_global.columns
}
for component in row_pc.columns
}) | [
"def",
"column_correlations",
"(",
"self",
",",
"X",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'s_'",
")",
"X_global",
"=",
"self",
".",
"_build_X_global",
"(",
"X",
")",
"row_pc",
"=",
"self",
".",
"_row_coordinates_from_global",
"(",
"X_global",
")",
"return",
"pd",
".",
"DataFrame",
"(",
"{",
"component",
":",
"{",
"feature",
":",
"row_pc",
"[",
"component",
"]",
".",
"corr",
"(",
"X_global",
"[",
"feature",
"]",
".",
"to_dense",
"(",
")",
")",
"for",
"feature",
"in",
"X_global",
".",
"columns",
"}",
"for",
"component",
"in",
"row_pc",
".",
"columns",
"}",
")"
] | Returns the column correlations. | [
"Returns",
"the",
"column",
"correlations",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/mfa.py#L192-L205 |
231,957 | MaxHalford/prince | prince/ca.py | CA.eigenvalues_ | def eigenvalues_(self):
"""The eigenvalues associated with each principal component."""
utils.validation.check_is_fitted(self, 's_')
return np.square(self.s_).tolist() | python | def eigenvalues_(self):
"""The eigenvalues associated with each principal component."""
utils.validation.check_is_fitted(self, 's_')
return np.square(self.s_).tolist() | [
"def",
"eigenvalues_",
"(",
"self",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'s_'",
")",
"return",
"np",
".",
"square",
"(",
"self",
".",
"s_",
")",
".",
"tolist",
"(",
")"
] | The eigenvalues associated with each principal component. | [
"The",
"eigenvalues",
"associated",
"with",
"each",
"principal",
"component",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L82-L85 |
231,958 | MaxHalford/prince | prince/ca.py | CA.explained_inertia_ | def explained_inertia_(self):
"""The percentage of explained inertia per principal component."""
utils.validation.check_is_fitted(self, 'total_inertia_')
return [eig / self.total_inertia_ for eig in self.eigenvalues_] | python | def explained_inertia_(self):
"""The percentage of explained inertia per principal component."""
utils.validation.check_is_fitted(self, 'total_inertia_')
return [eig / self.total_inertia_ for eig in self.eigenvalues_] | [
"def",
"explained_inertia_",
"(",
"self",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'total_inertia_'",
")",
"return",
"[",
"eig",
"/",
"self",
".",
"total_inertia_",
"for",
"eig",
"in",
"self",
".",
"eigenvalues_",
"]"
] | The percentage of explained inertia per principal component. | [
"The",
"percentage",
"of",
"explained",
"inertia",
"per",
"principal",
"component",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L88-L91 |
231,959 | MaxHalford/prince | prince/ca.py | CA.row_coordinates | def row_coordinates(self, X):
"""The row principal coordinates."""
utils.validation.check_is_fitted(self, 'V_')
_, row_names, _, _ = util.make_labels_and_names(X)
if isinstance(X, pd.SparseDataFrame):
X = X.to_coo().astype(float)
elif isinstance(X, pd.DataFrame):
X = X.to_numpy()
if self.copy:
X = X.copy()
# Normalise the rows so that they sum up to 1
if isinstance(X, np.ndarray):
X = X / X.sum(axis=1)[:, None]
else:
X = X / X.sum(axis=1)
return pd.DataFrame(
data=X @ sparse.diags(self.col_masses_.to_numpy() ** -0.5) @ self.V_.T,
index=row_names
) | python | def row_coordinates(self, X):
"""The row principal coordinates."""
utils.validation.check_is_fitted(self, 'V_')
_, row_names, _, _ = util.make_labels_and_names(X)
if isinstance(X, pd.SparseDataFrame):
X = X.to_coo().astype(float)
elif isinstance(X, pd.DataFrame):
X = X.to_numpy()
if self.copy:
X = X.copy()
# Normalise the rows so that they sum up to 1
if isinstance(X, np.ndarray):
X = X / X.sum(axis=1)[:, None]
else:
X = X / X.sum(axis=1)
return pd.DataFrame(
data=X @ sparse.diags(self.col_masses_.to_numpy() ** -0.5) @ self.V_.T,
index=row_names
) | [
"def",
"row_coordinates",
"(",
"self",
",",
"X",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'V_'",
")",
"_",
",",
"row_names",
",",
"_",
",",
"_",
"=",
"util",
".",
"make_labels_and_names",
"(",
"X",
")",
"if",
"isinstance",
"(",
"X",
",",
"pd",
".",
"SparseDataFrame",
")",
":",
"X",
"=",
"X",
".",
"to_coo",
"(",
")",
".",
"astype",
"(",
"float",
")",
"elif",
"isinstance",
"(",
"X",
",",
"pd",
".",
"DataFrame",
")",
":",
"X",
"=",
"X",
".",
"to_numpy",
"(",
")",
"if",
"self",
".",
"copy",
":",
"X",
"=",
"X",
".",
"copy",
"(",
")",
"# Normalise the rows so that they sum up to 1",
"if",
"isinstance",
"(",
"X",
",",
"np",
".",
"ndarray",
")",
":",
"X",
"=",
"X",
"/",
"X",
".",
"sum",
"(",
"axis",
"=",
"1",
")",
"[",
":",
",",
"None",
"]",
"else",
":",
"X",
"=",
"X",
"/",
"X",
".",
"sum",
"(",
"axis",
"=",
"1",
")",
"return",
"pd",
".",
"DataFrame",
"(",
"data",
"=",
"X",
"@",
"sparse",
".",
"diags",
"(",
"self",
".",
"col_masses_",
".",
"to_numpy",
"(",
")",
"**",
"-",
"0.5",
")",
"@",
"self",
".",
"V_",
".",
"T",
",",
"index",
"=",
"row_names",
")"
] | The row principal coordinates. | [
"The",
"row",
"principal",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L93-L116 |
231,960 | MaxHalford/prince | prince/ca.py | CA.column_coordinates | def column_coordinates(self, X):
"""The column principal coordinates."""
utils.validation.check_is_fitted(self, 'V_')
_, _, _, col_names = util.make_labels_and_names(X)
if isinstance(X, pd.SparseDataFrame):
X = X.to_coo()
elif isinstance(X, pd.DataFrame):
X = X.to_numpy()
if self.copy:
X = X.copy()
# Transpose and make sure the rows sum up to 1
if isinstance(X, np.ndarray):
X = X.T / X.T.sum(axis=1)[:, None]
else:
X = X.T / X.T.sum(axis=1)
return pd.DataFrame(
data=X @ sparse.diags(self.row_masses_.to_numpy() ** -0.5) @ self.U_,
index=col_names
) | python | def column_coordinates(self, X):
"""The column principal coordinates."""
utils.validation.check_is_fitted(self, 'V_')
_, _, _, col_names = util.make_labels_and_names(X)
if isinstance(X, pd.SparseDataFrame):
X = X.to_coo()
elif isinstance(X, pd.DataFrame):
X = X.to_numpy()
if self.copy:
X = X.copy()
# Transpose and make sure the rows sum up to 1
if isinstance(X, np.ndarray):
X = X.T / X.T.sum(axis=1)[:, None]
else:
X = X.T / X.T.sum(axis=1)
return pd.DataFrame(
data=X @ sparse.diags(self.row_masses_.to_numpy() ** -0.5) @ self.U_,
index=col_names
) | [
"def",
"column_coordinates",
"(",
"self",
",",
"X",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'V_'",
")",
"_",
",",
"_",
",",
"_",
",",
"col_names",
"=",
"util",
".",
"make_labels_and_names",
"(",
"X",
")",
"if",
"isinstance",
"(",
"X",
",",
"pd",
".",
"SparseDataFrame",
")",
":",
"X",
"=",
"X",
".",
"to_coo",
"(",
")",
"elif",
"isinstance",
"(",
"X",
",",
"pd",
".",
"DataFrame",
")",
":",
"X",
"=",
"X",
".",
"to_numpy",
"(",
")",
"if",
"self",
".",
"copy",
":",
"X",
"=",
"X",
".",
"copy",
"(",
")",
"# Transpose and make sure the rows sum up to 1",
"if",
"isinstance",
"(",
"X",
",",
"np",
".",
"ndarray",
")",
":",
"X",
"=",
"X",
".",
"T",
"/",
"X",
".",
"T",
".",
"sum",
"(",
"axis",
"=",
"1",
")",
"[",
":",
",",
"None",
"]",
"else",
":",
"X",
"=",
"X",
".",
"T",
"/",
"X",
".",
"T",
".",
"sum",
"(",
"axis",
"=",
"1",
")",
"return",
"pd",
".",
"DataFrame",
"(",
"data",
"=",
"X",
"@",
"sparse",
".",
"diags",
"(",
"self",
".",
"row_masses_",
".",
"to_numpy",
"(",
")",
"**",
"-",
"0.5",
")",
"@",
"self",
".",
"U_",
",",
"index",
"=",
"col_names",
")"
] | The column principal coordinates. | [
"The",
"column",
"principal",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L118-L141 |
231,961 | MaxHalford/prince | prince/ca.py | CA.plot_coordinates | def plot_coordinates(self, X, ax=None, figsize=(6, 6), x_component=0, y_component=1,
show_row_labels=True, show_col_labels=True, **kwargs):
"""Plot the principal coordinates."""
utils.validation.check_is_fitted(self, 's_')
if ax is None:
fig, ax = plt.subplots(figsize=figsize)
# Add style
ax = plot.stylize_axis(ax)
# Get labels and names
row_label, row_names, col_label, col_names = util.make_labels_and_names(X)
# Plot row principal coordinates
row_coords = self.row_coordinates(X)
ax.scatter(
row_coords[x_component],
row_coords[y_component],
**kwargs,
label=row_label
)
# Plot column principal coordinates
col_coords = self.column_coordinates(X)
ax.scatter(
col_coords[x_component],
col_coords[y_component],
**kwargs,
label=col_label
)
# Add row labels
if show_row_labels:
x = row_coords[x_component]
y = row_coords[y_component]
for i, label in enumerate(row_names):
ax.annotate(label, (x[i], y[i]))
# Add column labels
if show_col_labels:
x = col_coords[x_component]
y = col_coords[y_component]
for i, label in enumerate(col_names):
ax.annotate(label, (x[i], y[i]))
# Legend
ax.legend()
# Text
ax.set_title('Principal coordinates')
ei = self.explained_inertia_
ax.set_xlabel('Component {} ({:.2f}% inertia)'.format(x_component, 100 * ei[x_component]))
ax.set_ylabel('Component {} ({:.2f}% inertia)'.format(y_component, 100 * ei[y_component]))
return ax | python | def plot_coordinates(self, X, ax=None, figsize=(6, 6), x_component=0, y_component=1,
show_row_labels=True, show_col_labels=True, **kwargs):
"""Plot the principal coordinates."""
utils.validation.check_is_fitted(self, 's_')
if ax is None:
fig, ax = plt.subplots(figsize=figsize)
# Add style
ax = plot.stylize_axis(ax)
# Get labels and names
row_label, row_names, col_label, col_names = util.make_labels_and_names(X)
# Plot row principal coordinates
row_coords = self.row_coordinates(X)
ax.scatter(
row_coords[x_component],
row_coords[y_component],
**kwargs,
label=row_label
)
# Plot column principal coordinates
col_coords = self.column_coordinates(X)
ax.scatter(
col_coords[x_component],
col_coords[y_component],
**kwargs,
label=col_label
)
# Add row labels
if show_row_labels:
x = row_coords[x_component]
y = row_coords[y_component]
for i, label in enumerate(row_names):
ax.annotate(label, (x[i], y[i]))
# Add column labels
if show_col_labels:
x = col_coords[x_component]
y = col_coords[y_component]
for i, label in enumerate(col_names):
ax.annotate(label, (x[i], y[i]))
# Legend
ax.legend()
# Text
ax.set_title('Principal coordinates')
ei = self.explained_inertia_
ax.set_xlabel('Component {} ({:.2f}% inertia)'.format(x_component, 100 * ei[x_component]))
ax.set_ylabel('Component {} ({:.2f}% inertia)'.format(y_component, 100 * ei[y_component]))
return ax | [
"def",
"plot_coordinates",
"(",
"self",
",",
"X",
",",
"ax",
"=",
"None",
",",
"figsize",
"=",
"(",
"6",
",",
"6",
")",
",",
"x_component",
"=",
"0",
",",
"y_component",
"=",
"1",
",",
"show_row_labels",
"=",
"True",
",",
"show_col_labels",
"=",
"True",
",",
"*",
"*",
"kwargs",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'s_'",
")",
"if",
"ax",
"is",
"None",
":",
"fig",
",",
"ax",
"=",
"plt",
".",
"subplots",
"(",
"figsize",
"=",
"figsize",
")",
"# Add style",
"ax",
"=",
"plot",
".",
"stylize_axis",
"(",
"ax",
")",
"# Get labels and names",
"row_label",
",",
"row_names",
",",
"col_label",
",",
"col_names",
"=",
"util",
".",
"make_labels_and_names",
"(",
"X",
")",
"# Plot row principal coordinates",
"row_coords",
"=",
"self",
".",
"row_coordinates",
"(",
"X",
")",
"ax",
".",
"scatter",
"(",
"row_coords",
"[",
"x_component",
"]",
",",
"row_coords",
"[",
"y_component",
"]",
",",
"*",
"*",
"kwargs",
",",
"label",
"=",
"row_label",
")",
"# Plot column principal coordinates",
"col_coords",
"=",
"self",
".",
"column_coordinates",
"(",
"X",
")",
"ax",
".",
"scatter",
"(",
"col_coords",
"[",
"x_component",
"]",
",",
"col_coords",
"[",
"y_component",
"]",
",",
"*",
"*",
"kwargs",
",",
"label",
"=",
"col_label",
")",
"# Add row labels",
"if",
"show_row_labels",
":",
"x",
"=",
"row_coords",
"[",
"x_component",
"]",
"y",
"=",
"row_coords",
"[",
"y_component",
"]",
"for",
"i",
",",
"label",
"in",
"enumerate",
"(",
"row_names",
")",
":",
"ax",
".",
"annotate",
"(",
"label",
",",
"(",
"x",
"[",
"i",
"]",
",",
"y",
"[",
"i",
"]",
")",
")",
"# Add column labels",
"if",
"show_col_labels",
":",
"x",
"=",
"col_coords",
"[",
"x_component",
"]",
"y",
"=",
"col_coords",
"[",
"y_component",
"]",
"for",
"i",
",",
"label",
"in",
"enumerate",
"(",
"col_names",
")",
":",
"ax",
".",
"annotate",
"(",
"label",
",",
"(",
"x",
"[",
"i",
"]",
",",
"y",
"[",
"i",
"]",
")",
")",
"# Legend",
"ax",
".",
"legend",
"(",
")",
"# Text",
"ax",
".",
"set_title",
"(",
"'Principal coordinates'",
")",
"ei",
"=",
"self",
".",
"explained_inertia_",
"ax",
".",
"set_xlabel",
"(",
"'Component {} ({:.2f}% inertia)'",
".",
"format",
"(",
"x_component",
",",
"100",
"*",
"ei",
"[",
"x_component",
"]",
")",
")",
"ax",
".",
"set_ylabel",
"(",
"'Component {} ({:.2f}% inertia)'",
".",
"format",
"(",
"y_component",
",",
"100",
"*",
"ei",
"[",
"y_component",
"]",
")",
")",
"return",
"ax"
] | Plot the principal coordinates. | [
"Plot",
"the",
"principal",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L143-L199 |
231,962 | MaxHalford/prince | prince/mca.py | MCA.plot_coordinates | def plot_coordinates(self, X, ax=None, figsize=(6, 6), x_component=0, y_component=1,
show_row_points=True, row_points_size=10, show_row_labels=False,
show_column_points=True, column_points_size=30,
show_column_labels=False, legend_n_cols=1):
"""Plot row and column principal coordinates.
Args:
ax (matplotlib.Axis): A fresh one will be created and returned if not provided.
figsize ((float, float)): The desired figure size if `ax` is not provided.
x_component (int): Number of the component used for the x-axis.
y_component (int): Number of the component used for the y-axis.
show_row_points (bool): Whether to show row principal components or not.
row_points_size (float): Row principal components point size.
show_row_labels (bool): Whether to show row labels or not.
show_column_points (bool): Whether to show column principal components or not.
column_points_size (float): Column principal components point size.
show_column_labels (bool): Whether to show column labels or not.
legend_n_cols (int): Number of columns used for the legend.
Returns:
matplotlib.Axis
"""
utils.validation.check_is_fitted(self, 'total_inertia_')
if ax is None:
fig, ax = plt.subplots(figsize=figsize)
# Add style
ax = plot.stylize_axis(ax)
# Plot row principal coordinates
if show_row_points or show_row_labels:
row_coords = self.row_coordinates(X)
if show_row_points:
ax.scatter(
row_coords.iloc[:, x_component],
row_coords.iloc[:, y_component],
s=row_points_size,
label=None,
color=plot.GRAY['dark'],
alpha=0.6
)
if show_row_labels:
for _, row in row_coords.iterrows():
ax.annotate(row.name, (row[x_component], row[y_component]))
# Plot column principal coordinates
if show_column_points or show_column_labels:
col_coords = self.column_coordinates(X)
x = col_coords[x_component]
y = col_coords[y_component]
prefixes = col_coords.index.str.split('_').map(lambda x: x[0])
for prefix in prefixes.unique():
mask = prefixes == prefix
if show_column_points:
ax.scatter(x[mask], y[mask], s=column_points_size, label=prefix)
if show_column_labels:
for i, label in enumerate(col_coords[mask].index):
ax.annotate(label, (x[mask][i], y[mask][i]))
ax.legend(ncol=legend_n_cols)
# Text
ax.set_title('Row and column principal coordinates')
ei = self.explained_inertia_
ax.set_xlabel('Component {} ({:.2f}% inertia)'.format(x_component, 100 * ei[x_component]))
ax.set_ylabel('Component {} ({:.2f}% inertia)'.format(y_component, 100 * ei[y_component]))
return ax | python | def plot_coordinates(self, X, ax=None, figsize=(6, 6), x_component=0, y_component=1,
show_row_points=True, row_points_size=10, show_row_labels=False,
show_column_points=True, column_points_size=30,
show_column_labels=False, legend_n_cols=1):
"""Plot row and column principal coordinates.
Args:
ax (matplotlib.Axis): A fresh one will be created and returned if not provided.
figsize ((float, float)): The desired figure size if `ax` is not provided.
x_component (int): Number of the component used for the x-axis.
y_component (int): Number of the component used for the y-axis.
show_row_points (bool): Whether to show row principal components or not.
row_points_size (float): Row principal components point size.
show_row_labels (bool): Whether to show row labels or not.
show_column_points (bool): Whether to show column principal components or not.
column_points_size (float): Column principal components point size.
show_column_labels (bool): Whether to show column labels or not.
legend_n_cols (int): Number of columns used for the legend.
Returns:
matplotlib.Axis
"""
utils.validation.check_is_fitted(self, 'total_inertia_')
if ax is None:
fig, ax = plt.subplots(figsize=figsize)
# Add style
ax = plot.stylize_axis(ax)
# Plot row principal coordinates
if show_row_points or show_row_labels:
row_coords = self.row_coordinates(X)
if show_row_points:
ax.scatter(
row_coords.iloc[:, x_component],
row_coords.iloc[:, y_component],
s=row_points_size,
label=None,
color=plot.GRAY['dark'],
alpha=0.6
)
if show_row_labels:
for _, row in row_coords.iterrows():
ax.annotate(row.name, (row[x_component], row[y_component]))
# Plot column principal coordinates
if show_column_points or show_column_labels:
col_coords = self.column_coordinates(X)
x = col_coords[x_component]
y = col_coords[y_component]
prefixes = col_coords.index.str.split('_').map(lambda x: x[0])
for prefix in prefixes.unique():
mask = prefixes == prefix
if show_column_points:
ax.scatter(x[mask], y[mask], s=column_points_size, label=prefix)
if show_column_labels:
for i, label in enumerate(col_coords[mask].index):
ax.annotate(label, (x[mask][i], y[mask][i]))
ax.legend(ncol=legend_n_cols)
# Text
ax.set_title('Row and column principal coordinates')
ei = self.explained_inertia_
ax.set_xlabel('Component {} ({:.2f}% inertia)'.format(x_component, 100 * ei[x_component]))
ax.set_ylabel('Component {} ({:.2f}% inertia)'.format(y_component, 100 * ei[y_component]))
return ax | [
"def",
"plot_coordinates",
"(",
"self",
",",
"X",
",",
"ax",
"=",
"None",
",",
"figsize",
"=",
"(",
"6",
",",
"6",
")",
",",
"x_component",
"=",
"0",
",",
"y_component",
"=",
"1",
",",
"show_row_points",
"=",
"True",
",",
"row_points_size",
"=",
"10",
",",
"show_row_labels",
"=",
"False",
",",
"show_column_points",
"=",
"True",
",",
"column_points_size",
"=",
"30",
",",
"show_column_labels",
"=",
"False",
",",
"legend_n_cols",
"=",
"1",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'total_inertia_'",
")",
"if",
"ax",
"is",
"None",
":",
"fig",
",",
"ax",
"=",
"plt",
".",
"subplots",
"(",
"figsize",
"=",
"figsize",
")",
"# Add style",
"ax",
"=",
"plot",
".",
"stylize_axis",
"(",
"ax",
")",
"# Plot row principal coordinates",
"if",
"show_row_points",
"or",
"show_row_labels",
":",
"row_coords",
"=",
"self",
".",
"row_coordinates",
"(",
"X",
")",
"if",
"show_row_points",
":",
"ax",
".",
"scatter",
"(",
"row_coords",
".",
"iloc",
"[",
":",
",",
"x_component",
"]",
",",
"row_coords",
".",
"iloc",
"[",
":",
",",
"y_component",
"]",
",",
"s",
"=",
"row_points_size",
",",
"label",
"=",
"None",
",",
"color",
"=",
"plot",
".",
"GRAY",
"[",
"'dark'",
"]",
",",
"alpha",
"=",
"0.6",
")",
"if",
"show_row_labels",
":",
"for",
"_",
",",
"row",
"in",
"row_coords",
".",
"iterrows",
"(",
")",
":",
"ax",
".",
"annotate",
"(",
"row",
".",
"name",
",",
"(",
"row",
"[",
"x_component",
"]",
",",
"row",
"[",
"y_component",
"]",
")",
")",
"# Plot column principal coordinates",
"if",
"show_column_points",
"or",
"show_column_labels",
":",
"col_coords",
"=",
"self",
".",
"column_coordinates",
"(",
"X",
")",
"x",
"=",
"col_coords",
"[",
"x_component",
"]",
"y",
"=",
"col_coords",
"[",
"y_component",
"]",
"prefixes",
"=",
"col_coords",
".",
"index",
".",
"str",
".",
"split",
"(",
"'_'",
")",
".",
"map",
"(",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
")",
"for",
"prefix",
"in",
"prefixes",
".",
"unique",
"(",
")",
":",
"mask",
"=",
"prefixes",
"==",
"prefix",
"if",
"show_column_points",
":",
"ax",
".",
"scatter",
"(",
"x",
"[",
"mask",
"]",
",",
"y",
"[",
"mask",
"]",
",",
"s",
"=",
"column_points_size",
",",
"label",
"=",
"prefix",
")",
"if",
"show_column_labels",
":",
"for",
"i",
",",
"label",
"in",
"enumerate",
"(",
"col_coords",
"[",
"mask",
"]",
".",
"index",
")",
":",
"ax",
".",
"annotate",
"(",
"label",
",",
"(",
"x",
"[",
"mask",
"]",
"[",
"i",
"]",
",",
"y",
"[",
"mask",
"]",
"[",
"i",
"]",
")",
")",
"ax",
".",
"legend",
"(",
"ncol",
"=",
"legend_n_cols",
")",
"# Text",
"ax",
".",
"set_title",
"(",
"'Row and column principal coordinates'",
")",
"ei",
"=",
"self",
".",
"explained_inertia_",
"ax",
".",
"set_xlabel",
"(",
"'Component {} ({:.2f}% inertia)'",
".",
"format",
"(",
"x_component",
",",
"100",
"*",
"ei",
"[",
"x_component",
"]",
")",
")",
"ax",
".",
"set_ylabel",
"(",
"'Component {} ({:.2f}% inertia)'",
".",
"format",
"(",
"y_component",
",",
"100",
"*",
"ei",
"[",
"y_component",
"]",
")",
")",
"return",
"ax"
] | Plot row and column principal coordinates.
Args:
ax (matplotlib.Axis): A fresh one will be created and returned if not provided.
figsize ((float, float)): The desired figure size if `ax` is not provided.
x_component (int): Number of the component used for the x-axis.
y_component (int): Number of the component used for the y-axis.
show_row_points (bool): Whether to show row principal components or not.
row_points_size (float): Row principal components point size.
show_row_labels (bool): Whether to show row labels or not.
show_column_points (bool): Whether to show column principal components or not.
column_points_size (float): Column principal components point size.
show_column_labels (bool): Whether to show column labels or not.
legend_n_cols (int): Number of columns used for the legend.
Returns:
matplotlib.Axis | [
"Plot",
"row",
"and",
"column",
"principal",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/mca.py#L49-L126 |
231,963 | MaxHalford/prince | prince/svd.py | compute_svd | def compute_svd(X, n_components, n_iter, random_state, engine):
"""Computes an SVD with k components."""
# Determine what SVD engine to use
if engine == 'auto':
engine = 'sklearn'
# Compute the SVD
if engine == 'fbpca':
if FBPCA_INSTALLED:
U, s, V = fbpca.pca(X, k=n_components, n_iter=n_iter)
else:
raise ValueError('fbpca is not installed; please install it if you want to use it')
elif engine == 'sklearn':
U, s, V = extmath.randomized_svd(
X,
n_components=n_components,
n_iter=n_iter,
random_state=random_state
)
else:
raise ValueError("engine has to be one of ('auto', 'fbpca', 'sklearn')")
U, V = extmath.svd_flip(U, V)
return U, s, V | python | def compute_svd(X, n_components, n_iter, random_state, engine):
"""Computes an SVD with k components."""
# Determine what SVD engine to use
if engine == 'auto':
engine = 'sklearn'
# Compute the SVD
if engine == 'fbpca':
if FBPCA_INSTALLED:
U, s, V = fbpca.pca(X, k=n_components, n_iter=n_iter)
else:
raise ValueError('fbpca is not installed; please install it if you want to use it')
elif engine == 'sklearn':
U, s, V = extmath.randomized_svd(
X,
n_components=n_components,
n_iter=n_iter,
random_state=random_state
)
else:
raise ValueError("engine has to be one of ('auto', 'fbpca', 'sklearn')")
U, V = extmath.svd_flip(U, V)
return U, s, V | [
"def",
"compute_svd",
"(",
"X",
",",
"n_components",
",",
"n_iter",
",",
"random_state",
",",
"engine",
")",
":",
"# Determine what SVD engine to use",
"if",
"engine",
"==",
"'auto'",
":",
"engine",
"=",
"'sklearn'",
"# Compute the SVD",
"if",
"engine",
"==",
"'fbpca'",
":",
"if",
"FBPCA_INSTALLED",
":",
"U",
",",
"s",
",",
"V",
"=",
"fbpca",
".",
"pca",
"(",
"X",
",",
"k",
"=",
"n_components",
",",
"n_iter",
"=",
"n_iter",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'fbpca is not installed; please install it if you want to use it'",
")",
"elif",
"engine",
"==",
"'sklearn'",
":",
"U",
",",
"s",
",",
"V",
"=",
"extmath",
".",
"randomized_svd",
"(",
"X",
",",
"n_components",
"=",
"n_components",
",",
"n_iter",
"=",
"n_iter",
",",
"random_state",
"=",
"random_state",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"engine has to be one of ('auto', 'fbpca', 'sklearn')\"",
")",
"U",
",",
"V",
"=",
"extmath",
".",
"svd_flip",
"(",
"U",
",",
"V",
")",
"return",
"U",
",",
"s",
",",
"V"
] | Computes an SVD with k components. | [
"Computes",
"an",
"SVD",
"with",
"k",
"components",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/svd.py#L10-L35 |
231,964 | MaxHalford/prince | prince/pca.py | PCA.row_standard_coordinates | def row_standard_coordinates(self, X):
"""Returns the row standard coordinates.
The row standard coordinates are obtained by dividing each row principal coordinate by it's
associated eigenvalue.
"""
utils.validation.check_is_fitted(self, 's_')
return self.row_coordinates(X).div(self.eigenvalues_, axis='columns') | python | def row_standard_coordinates(self, X):
"""Returns the row standard coordinates.
The row standard coordinates are obtained by dividing each row principal coordinate by it's
associated eigenvalue.
"""
utils.validation.check_is_fitted(self, 's_')
return self.row_coordinates(X).div(self.eigenvalues_, axis='columns') | [
"def",
"row_standard_coordinates",
"(",
"self",
",",
"X",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'s_'",
")",
"return",
"self",
".",
"row_coordinates",
"(",
"X",
")",
".",
"div",
"(",
"self",
".",
"eigenvalues_",
",",
"axis",
"=",
"'columns'",
")"
] | Returns the row standard coordinates.
The row standard coordinates are obtained by dividing each row principal coordinate by it's
associated eigenvalue. | [
"Returns",
"the",
"row",
"standard",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/pca.py#L106-L113 |
231,965 | MaxHalford/prince | prince/pca.py | PCA.row_cosine_similarities | def row_cosine_similarities(self, X):
"""Returns the cosine similarities between the rows and their principal components.
The row cosine similarities are obtained by calculating the cosine of the angle shaped by
the row principal coordinates and the row principal components. This is calculated by
squaring each row projection coordinate and dividing each squared coordinate by the sum of
the squared coordinates, which results in a ratio comprised between 0 and 1 representing the
squared cosine.
"""
utils.validation.check_is_fitted(self, 's_')
squared_coordinates = np.square(self.row_coordinates(X))
total_squares = squared_coordinates.sum(axis='columns')
return squared_coordinates.div(total_squares, axis='rows') | python | def row_cosine_similarities(self, X):
"""Returns the cosine similarities between the rows and their principal components.
The row cosine similarities are obtained by calculating the cosine of the angle shaped by
the row principal coordinates and the row principal components. This is calculated by
squaring each row projection coordinate and dividing each squared coordinate by the sum of
the squared coordinates, which results in a ratio comprised between 0 and 1 representing the
squared cosine.
"""
utils.validation.check_is_fitted(self, 's_')
squared_coordinates = np.square(self.row_coordinates(X))
total_squares = squared_coordinates.sum(axis='columns')
return squared_coordinates.div(total_squares, axis='rows') | [
"def",
"row_cosine_similarities",
"(",
"self",
",",
"X",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'s_'",
")",
"squared_coordinates",
"=",
"np",
".",
"square",
"(",
"self",
".",
"row_coordinates",
"(",
"X",
")",
")",
"total_squares",
"=",
"squared_coordinates",
".",
"sum",
"(",
"axis",
"=",
"'columns'",
")",
"return",
"squared_coordinates",
".",
"div",
"(",
"total_squares",
",",
"axis",
"=",
"'rows'",
")"
] | Returns the cosine similarities between the rows and their principal components.
The row cosine similarities are obtained by calculating the cosine of the angle shaped by
the row principal coordinates and the row principal components. This is calculated by
squaring each row projection coordinate and dividing each squared coordinate by the sum of
the squared coordinates, which results in a ratio comprised between 0 and 1 representing the
squared cosine. | [
"Returns",
"the",
"cosine",
"similarities",
"between",
"the",
"rows",
"and",
"their",
"principal",
"components",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/pca.py#L125-L137 |
231,966 | MaxHalford/prince | prince/pca.py | PCA.column_correlations | def column_correlations(self, X):
"""Returns the column correlations with each principal component."""
utils.validation.check_is_fitted(self, 's_')
# Convert numpy array to pandas DataFrame
if isinstance(X, np.ndarray):
X = pd.DataFrame(X)
row_pc = self.row_coordinates(X)
return pd.DataFrame({
component: {
feature: row_pc[component].corr(X[feature])
for feature in X.columns
}
for component in row_pc.columns
}) | python | def column_correlations(self, X):
"""Returns the column correlations with each principal component."""
utils.validation.check_is_fitted(self, 's_')
# Convert numpy array to pandas DataFrame
if isinstance(X, np.ndarray):
X = pd.DataFrame(X)
row_pc = self.row_coordinates(X)
return pd.DataFrame({
component: {
feature: row_pc[component].corr(X[feature])
for feature in X.columns
}
for component in row_pc.columns
}) | [
"def",
"column_correlations",
"(",
"self",
",",
"X",
")",
":",
"utils",
".",
"validation",
".",
"check_is_fitted",
"(",
"self",
",",
"'s_'",
")",
"# Convert numpy array to pandas DataFrame",
"if",
"isinstance",
"(",
"X",
",",
"np",
".",
"ndarray",
")",
":",
"X",
"=",
"pd",
".",
"DataFrame",
"(",
"X",
")",
"row_pc",
"=",
"self",
".",
"row_coordinates",
"(",
"X",
")",
"return",
"pd",
".",
"DataFrame",
"(",
"{",
"component",
":",
"{",
"feature",
":",
"row_pc",
"[",
"component",
"]",
".",
"corr",
"(",
"X",
"[",
"feature",
"]",
")",
"for",
"feature",
"in",
"X",
".",
"columns",
"}",
"for",
"component",
"in",
"row_pc",
".",
"columns",
"}",
")"
] | Returns the column correlations with each principal component. | [
"Returns",
"the",
"column",
"correlations",
"with",
"each",
"principal",
"component",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/pca.py#L139-L155 |
231,967 | MaxHalford/prince | prince/plot.py | build_ellipse | def build_ellipse(X, Y):
"""Construct ellipse coordinates from two arrays of numbers.
Args:
X (1D array_like)
Y (1D array_like)
Returns:
float: The mean of `X`.
float: The mean of `Y`.
float: The width of the ellipse.
float: The height of the ellipse.
float: The angle of orientation of the ellipse.
"""
x_mean = np.mean(X)
y_mean = np.mean(Y)
cov_matrix = np.cov(np.vstack((X, Y)))
U, s, V = linalg.svd(cov_matrix, full_matrices=False)
chi_95 = np.sqrt(4.61) # 90% quantile of the chi-square distribution
width = np.sqrt(cov_matrix[0][0]) * chi_95 * 2
height = np.sqrt(cov_matrix[1][1]) * chi_95 * 2
eigenvector = V.T[0]
angle = np.arctan(eigenvector[1] / eigenvector[0])
return x_mean, y_mean, width, height, angle | python | def build_ellipse(X, Y):
"""Construct ellipse coordinates from two arrays of numbers.
Args:
X (1D array_like)
Y (1D array_like)
Returns:
float: The mean of `X`.
float: The mean of `Y`.
float: The width of the ellipse.
float: The height of the ellipse.
float: The angle of orientation of the ellipse.
"""
x_mean = np.mean(X)
y_mean = np.mean(Y)
cov_matrix = np.cov(np.vstack((X, Y)))
U, s, V = linalg.svd(cov_matrix, full_matrices=False)
chi_95 = np.sqrt(4.61) # 90% quantile of the chi-square distribution
width = np.sqrt(cov_matrix[0][0]) * chi_95 * 2
height = np.sqrt(cov_matrix[1][1]) * chi_95 * 2
eigenvector = V.T[0]
angle = np.arctan(eigenvector[1] / eigenvector[0])
return x_mean, y_mean, width, height, angle | [
"def",
"build_ellipse",
"(",
"X",
",",
"Y",
")",
":",
"x_mean",
"=",
"np",
".",
"mean",
"(",
"X",
")",
"y_mean",
"=",
"np",
".",
"mean",
"(",
"Y",
")",
"cov_matrix",
"=",
"np",
".",
"cov",
"(",
"np",
".",
"vstack",
"(",
"(",
"X",
",",
"Y",
")",
")",
")",
"U",
",",
"s",
",",
"V",
"=",
"linalg",
".",
"svd",
"(",
"cov_matrix",
",",
"full_matrices",
"=",
"False",
")",
"chi_95",
"=",
"np",
".",
"sqrt",
"(",
"4.61",
")",
"# 90% quantile of the chi-square distribution",
"width",
"=",
"np",
".",
"sqrt",
"(",
"cov_matrix",
"[",
"0",
"]",
"[",
"0",
"]",
")",
"*",
"chi_95",
"*",
"2",
"height",
"=",
"np",
".",
"sqrt",
"(",
"cov_matrix",
"[",
"1",
"]",
"[",
"1",
"]",
")",
"*",
"chi_95",
"*",
"2",
"eigenvector",
"=",
"V",
".",
"T",
"[",
"0",
"]",
"angle",
"=",
"np",
".",
"arctan",
"(",
"eigenvector",
"[",
"1",
"]",
"/",
"eigenvector",
"[",
"0",
"]",
")",
"return",
"x_mean",
",",
"y_mean",
",",
"width",
",",
"height",
",",
"angle"
] | Construct ellipse coordinates from two arrays of numbers.
Args:
X (1D array_like)
Y (1D array_like)
Returns:
float: The mean of `X`.
float: The mean of `Y`.
float: The width of the ellipse.
float: The height of the ellipse.
float: The angle of orientation of the ellipse. | [
"Construct",
"ellipse",
"coordinates",
"from",
"two",
"arrays",
"of",
"numbers",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/plot.py#L27-L55 |
231,968 | projecthamster/hamster | src/hamster/widgets/timeinput.py | TimeInput.set_start_time | def set_start_time(self, start_time):
""" set the start time. when start time is set, drop down list
will start from start time and duration will be displayed in
brackets
"""
start_time = start_time or dt.time()
if isinstance(start_time, dt.time): # ensure that we operate with time
self.start_time = dt.time(start_time.hour, start_time.minute)
else:
self.start_time = dt.time(start_time.time().hour, start_time.time().minute) | python | def set_start_time(self, start_time):
""" set the start time. when start time is set, drop down list
will start from start time and duration will be displayed in
brackets
"""
start_time = start_time or dt.time()
if isinstance(start_time, dt.time): # ensure that we operate with time
self.start_time = dt.time(start_time.hour, start_time.minute)
else:
self.start_time = dt.time(start_time.time().hour, start_time.time().minute) | [
"def",
"set_start_time",
"(",
"self",
",",
"start_time",
")",
":",
"start_time",
"=",
"start_time",
"or",
"dt",
".",
"time",
"(",
")",
"if",
"isinstance",
"(",
"start_time",
",",
"dt",
".",
"time",
")",
":",
"# ensure that we operate with time",
"self",
".",
"start_time",
"=",
"dt",
".",
"time",
"(",
"start_time",
".",
"hour",
",",
"start_time",
".",
"minute",
")",
"else",
":",
"self",
".",
"start_time",
"=",
"dt",
".",
"time",
"(",
"start_time",
".",
"time",
"(",
")",
".",
"hour",
",",
"start_time",
".",
"time",
"(",
")",
".",
"minute",
")"
] | set the start time. when start time is set, drop down list
will start from start time and duration will be displayed in
brackets | [
"set",
"the",
"start",
"time",
".",
"when",
"start",
"time",
"is",
"set",
"drop",
"down",
"list",
"will",
"start",
"from",
"start",
"time",
"and",
"duration",
"will",
"be",
"displayed",
"in",
"brackets"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/widgets/timeinput.py#L85-L94 |
231,969 | projecthamster/hamster | src/hamster/lib/__init__.py | extract_time | def extract_time(match):
"""extract time from a time_re match."""
hour = int(match.group('hour'))
minute = int(match.group('minute'))
return dt.time(hour, minute) | python | def extract_time(match):
"""extract time from a time_re match."""
hour = int(match.group('hour'))
minute = int(match.group('minute'))
return dt.time(hour, minute) | [
"def",
"extract_time",
"(",
"match",
")",
":",
"hour",
"=",
"int",
"(",
"match",
".",
"group",
"(",
"'hour'",
")",
")",
"minute",
"=",
"int",
"(",
"match",
".",
"group",
"(",
"'minute'",
")",
")",
"return",
"dt",
".",
"time",
"(",
"hour",
",",
"minute",
")"
] | extract time from a time_re match. | [
"extract",
"time",
"from",
"a",
"time_re",
"match",
"."
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/__init__.py#L40-L44 |
231,970 | projecthamster/hamster | src/hamster/lib/__init__.py | default_logger | def default_logger(name):
"""Return a toplevel logger.
This should be used only in the toplevel file.
Files deeper in the hierarchy should use
``logger = logging.getLogger(__name__)``,
in order to considered as children of the toplevel logger.
Beware that without a setLevel() somewhere,
the default value (warning) will be used, so no debug message will be shown.
Args:
name (str): usually `__name__` in the package toplevel __init__.py, or
`__file__` in a script file
(because __name__ would be "__main__" in this case).
"""
# https://docs.python.org/3/howto/logging.html#logging-advanced-tutorial
logger = logging.getLogger(name)
# this is a basic handler, with output to stderr
logger_handler = logging.StreamHandler()
formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
logger_handler.setFormatter(formatter)
logger.addHandler(logger_handler)
return logger | python | def default_logger(name):
"""Return a toplevel logger.
This should be used only in the toplevel file.
Files deeper in the hierarchy should use
``logger = logging.getLogger(__name__)``,
in order to considered as children of the toplevel logger.
Beware that without a setLevel() somewhere,
the default value (warning) will be used, so no debug message will be shown.
Args:
name (str): usually `__name__` in the package toplevel __init__.py, or
`__file__` in a script file
(because __name__ would be "__main__" in this case).
"""
# https://docs.python.org/3/howto/logging.html#logging-advanced-tutorial
logger = logging.getLogger(name)
# this is a basic handler, with output to stderr
logger_handler = logging.StreamHandler()
formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
logger_handler.setFormatter(formatter)
logger.addHandler(logger_handler)
return logger | [
"def",
"default_logger",
"(",
"name",
")",
":",
"# https://docs.python.org/3/howto/logging.html#logging-advanced-tutorial",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"name",
")",
"# this is a basic handler, with output to stderr",
"logger_handler",
"=",
"logging",
".",
"StreamHandler",
"(",
")",
"formatter",
"=",
"logging",
".",
"Formatter",
"(",
"'%(name)s - %(levelname)s - %(message)s'",
")",
"logger_handler",
".",
"setFormatter",
"(",
"formatter",
")",
"logger",
".",
"addHandler",
"(",
"logger_handler",
")",
"return",
"logger"
] | Return a toplevel logger.
This should be used only in the toplevel file.
Files deeper in the hierarchy should use
``logger = logging.getLogger(__name__)``,
in order to considered as children of the toplevel logger.
Beware that without a setLevel() somewhere,
the default value (warning) will be used, so no debug message will be shown.
Args:
name (str): usually `__name__` in the package toplevel __init__.py, or
`__file__` in a script file
(because __name__ would be "__main__" in this case). | [
"Return",
"a",
"toplevel",
"logger",
"."
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/__init__.py#L355-L381 |
231,971 | projecthamster/hamster | src/hamster/lib/__init__.py | Fact.serialized | def serialized(self, prepend_date=True):
"""Return a string fully representing the fact."""
name = self.serialized_name()
datetime = self.serialized_time(prepend_date)
return "%s %s" % (datetime, name) | python | def serialized(self, prepend_date=True):
"""Return a string fully representing the fact."""
name = self.serialized_name()
datetime = self.serialized_time(prepend_date)
return "%s %s" % (datetime, name) | [
"def",
"serialized",
"(",
"self",
",",
"prepend_date",
"=",
"True",
")",
":",
"name",
"=",
"self",
".",
"serialized_name",
"(",
")",
"datetime",
"=",
"self",
".",
"serialized_time",
"(",
"prepend_date",
")",
"return",
"\"%s %s\"",
"%",
"(",
"datetime",
",",
"name",
")"
] | Return a string fully representing the fact. | [
"Return",
"a",
"string",
"fully",
"representing",
"the",
"fact",
"."
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/__init__.py#L200-L204 |
231,972 | projecthamster/hamster | src/hamster/lib/layout.py | Widget._with_rotation | def _with_rotation(self, w, h):
"""calculate the actual dimensions after rotation"""
res_w = abs(w * math.cos(self.rotation) + h * math.sin(self.rotation))
res_h = abs(h * math.cos(self.rotation) + w * math.sin(self.rotation))
return res_w, res_h | python | def _with_rotation(self, w, h):
"""calculate the actual dimensions after rotation"""
res_w = abs(w * math.cos(self.rotation) + h * math.sin(self.rotation))
res_h = abs(h * math.cos(self.rotation) + w * math.sin(self.rotation))
return res_w, res_h | [
"def",
"_with_rotation",
"(",
"self",
",",
"w",
",",
"h",
")",
":",
"res_w",
"=",
"abs",
"(",
"w",
"*",
"math",
".",
"cos",
"(",
"self",
".",
"rotation",
")",
"+",
"h",
"*",
"math",
".",
"sin",
"(",
"self",
".",
"rotation",
")",
")",
"res_h",
"=",
"abs",
"(",
"h",
"*",
"math",
".",
"cos",
"(",
"self",
".",
"rotation",
")",
"+",
"w",
"*",
"math",
".",
"sin",
"(",
"self",
".",
"rotation",
")",
")",
"return",
"res_w",
",",
"res_h"
] | calculate the actual dimensions after rotation | [
"calculate",
"the",
"actual",
"dimensions",
"after",
"rotation"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L195-L199 |
231,973 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.queue_resize | def queue_resize(self):
"""request the element to re-check it's child sprite sizes"""
self._children_resize_queued = True
parent = getattr(self, "parent", None)
if parent and isinstance(parent, graphics.Sprite) and hasattr(parent, "queue_resize"):
parent.queue_resize() | python | def queue_resize(self):
"""request the element to re-check it's child sprite sizes"""
self._children_resize_queued = True
parent = getattr(self, "parent", None)
if parent and isinstance(parent, graphics.Sprite) and hasattr(parent, "queue_resize"):
parent.queue_resize() | [
"def",
"queue_resize",
"(",
"self",
")",
":",
"self",
".",
"_children_resize_queued",
"=",
"True",
"parent",
"=",
"getattr",
"(",
"self",
",",
"\"parent\"",
",",
"None",
")",
"if",
"parent",
"and",
"isinstance",
"(",
"parent",
",",
"graphics",
".",
"Sprite",
")",
"and",
"hasattr",
"(",
"parent",
",",
"\"queue_resize\"",
")",
":",
"parent",
".",
"queue_resize",
"(",
")"
] | request the element to re-check it's child sprite sizes | [
"request",
"the",
"element",
"to",
"re",
"-",
"check",
"it",
"s",
"child",
"sprite",
"sizes"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L241-L246 |
231,974 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.get_min_size | def get_min_size(self):
"""returns size required by the widget"""
if self.visible == False:
return 0, 0
else:
return ((self.min_width or 0) + self.horizontal_padding + self.margin_left + self.margin_right,
(self.min_height or 0) + self.vertical_padding + self.margin_top + self.margin_bottom) | python | def get_min_size(self):
"""returns size required by the widget"""
if self.visible == False:
return 0, 0
else:
return ((self.min_width or 0) + self.horizontal_padding + self.margin_left + self.margin_right,
(self.min_height or 0) + self.vertical_padding + self.margin_top + self.margin_bottom) | [
"def",
"get_min_size",
"(",
"self",
")",
":",
"if",
"self",
".",
"visible",
"==",
"False",
":",
"return",
"0",
",",
"0",
"else",
":",
"return",
"(",
"(",
"self",
".",
"min_width",
"or",
"0",
")",
"+",
"self",
".",
"horizontal_padding",
"+",
"self",
".",
"margin_left",
"+",
"self",
".",
"margin_right",
",",
"(",
"self",
".",
"min_height",
"or",
"0",
")",
"+",
"self",
".",
"vertical_padding",
"+",
"self",
".",
"margin_top",
"+",
"self",
".",
"margin_bottom",
")"
] | returns size required by the widget | [
"returns",
"size",
"required",
"by",
"the",
"widget"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L249-L255 |
231,975 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.insert | def insert(self, index = 0, *widgets):
"""insert widget in the sprites list at the given index.
by default will prepend."""
for widget in widgets:
self._add(widget, index)
index +=1 # as we are moving forwards
self._sort() | python | def insert(self, index = 0, *widgets):
"""insert widget in the sprites list at the given index.
by default will prepend."""
for widget in widgets:
self._add(widget, index)
index +=1 # as we are moving forwards
self._sort() | [
"def",
"insert",
"(",
"self",
",",
"index",
"=",
"0",
",",
"*",
"widgets",
")",
":",
"for",
"widget",
"in",
"widgets",
":",
"self",
".",
"_add",
"(",
"widget",
",",
"index",
")",
"index",
"+=",
"1",
"# as we are moving forwards",
"self",
".",
"_sort",
"(",
")"
] | insert widget in the sprites list at the given index.
by default will prepend. | [
"insert",
"widget",
"in",
"the",
"sprites",
"list",
"at",
"the",
"given",
"index",
".",
"by",
"default",
"will",
"prepend",
"."
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L259-L265 |
231,976 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.insert_before | def insert_before(self, target):
"""insert this widget into the targets parent before the target"""
if not target.parent:
return
target.parent.insert(target.parent.sprites.index(target), self) | python | def insert_before(self, target):
"""insert this widget into the targets parent before the target"""
if not target.parent:
return
target.parent.insert(target.parent.sprites.index(target), self) | [
"def",
"insert_before",
"(",
"self",
",",
"target",
")",
":",
"if",
"not",
"target",
".",
"parent",
":",
"return",
"target",
".",
"parent",
".",
"insert",
"(",
"target",
".",
"parent",
".",
"sprites",
".",
"index",
"(",
"target",
")",
",",
"self",
")"
] | insert this widget into the targets parent before the target | [
"insert",
"this",
"widget",
"into",
"the",
"targets",
"parent",
"before",
"the",
"target"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L268-L272 |
231,977 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.insert_after | def insert_after(self, target):
"""insert this widget into the targets parent container after the target"""
if not target.parent:
return
target.parent.insert(target.parent.sprites.index(target) + 1, self) | python | def insert_after(self, target):
"""insert this widget into the targets parent container after the target"""
if not target.parent:
return
target.parent.insert(target.parent.sprites.index(target) + 1, self) | [
"def",
"insert_after",
"(",
"self",
",",
"target",
")",
":",
"if",
"not",
"target",
".",
"parent",
":",
"return",
"target",
".",
"parent",
".",
"insert",
"(",
"target",
".",
"parent",
".",
"sprites",
".",
"index",
"(",
"target",
")",
"+",
"1",
",",
"self",
")"
] | insert this widget into the targets parent container after the target | [
"insert",
"this",
"widget",
"into",
"the",
"targets",
"parent",
"container",
"after",
"the",
"target"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L274-L278 |
231,978 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.width | def width(self):
"""width in pixels"""
alloc_w = self.alloc_w
if self.parent and isinstance(self.parent, graphics.Scene):
alloc_w = self.parent.width
def res(scene, event):
if self.parent:
self.queue_resize()
else:
scene.disconnect(self._scene_resize_handler)
self._scene_resize_handler = None
if not self._scene_resize_handler:
# TODO - disconnect on reparenting
self._scene_resize_handler = self.parent.connect("on-resize", res)
min_width = (self.min_width or 0) + self.margin_left + self.margin_right
w = alloc_w if alloc_w is not None and self.fill else min_width
w = max(w or 0, self.get_min_size()[0])
return w - self.margin_left - self.margin_right | python | def width(self):
"""width in pixels"""
alloc_w = self.alloc_w
if self.parent and isinstance(self.parent, graphics.Scene):
alloc_w = self.parent.width
def res(scene, event):
if self.parent:
self.queue_resize()
else:
scene.disconnect(self._scene_resize_handler)
self._scene_resize_handler = None
if not self._scene_resize_handler:
# TODO - disconnect on reparenting
self._scene_resize_handler = self.parent.connect("on-resize", res)
min_width = (self.min_width or 0) + self.margin_left + self.margin_right
w = alloc_w if alloc_w is not None and self.fill else min_width
w = max(w or 0, self.get_min_size()[0])
return w - self.margin_left - self.margin_right | [
"def",
"width",
"(",
"self",
")",
":",
"alloc_w",
"=",
"self",
".",
"alloc_w",
"if",
"self",
".",
"parent",
"and",
"isinstance",
"(",
"self",
".",
"parent",
",",
"graphics",
".",
"Scene",
")",
":",
"alloc_w",
"=",
"self",
".",
"parent",
".",
"width",
"def",
"res",
"(",
"scene",
",",
"event",
")",
":",
"if",
"self",
".",
"parent",
":",
"self",
".",
"queue_resize",
"(",
")",
"else",
":",
"scene",
".",
"disconnect",
"(",
"self",
".",
"_scene_resize_handler",
")",
"self",
".",
"_scene_resize_handler",
"=",
"None",
"if",
"not",
"self",
".",
"_scene_resize_handler",
":",
"# TODO - disconnect on reparenting",
"self",
".",
"_scene_resize_handler",
"=",
"self",
".",
"parent",
".",
"connect",
"(",
"\"on-resize\"",
",",
"res",
")",
"min_width",
"=",
"(",
"self",
".",
"min_width",
"or",
"0",
")",
"+",
"self",
".",
"margin_left",
"+",
"self",
".",
"margin_right",
"w",
"=",
"alloc_w",
"if",
"alloc_w",
"is",
"not",
"None",
"and",
"self",
".",
"fill",
"else",
"min_width",
"w",
"=",
"max",
"(",
"w",
"or",
"0",
",",
"self",
".",
"get_min_size",
"(",
")",
"[",
"0",
"]",
")",
"return",
"w",
"-",
"self",
".",
"margin_left",
"-",
"self",
".",
"margin_right"
] | width in pixels | [
"width",
"in",
"pixels"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L282-L305 |
231,979 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.height | def height(self):
"""height in pixels"""
alloc_h = self.alloc_h
if self.parent and isinstance(self.parent, graphics.Scene):
alloc_h = self.parent.height
min_height = (self.min_height or 0) + self.margin_top + self.margin_bottom
h = alloc_h if alloc_h is not None and self.fill else min_height
h = max(h or 0, self.get_min_size()[1])
return h - self.margin_top - self.margin_bottom | python | def height(self):
"""height in pixels"""
alloc_h = self.alloc_h
if self.parent and isinstance(self.parent, graphics.Scene):
alloc_h = self.parent.height
min_height = (self.min_height or 0) + self.margin_top + self.margin_bottom
h = alloc_h if alloc_h is not None and self.fill else min_height
h = max(h or 0, self.get_min_size()[1])
return h - self.margin_top - self.margin_bottom | [
"def",
"height",
"(",
"self",
")",
":",
"alloc_h",
"=",
"self",
".",
"alloc_h",
"if",
"self",
".",
"parent",
"and",
"isinstance",
"(",
"self",
".",
"parent",
",",
"graphics",
".",
"Scene",
")",
":",
"alloc_h",
"=",
"self",
".",
"parent",
".",
"height",
"min_height",
"=",
"(",
"self",
".",
"min_height",
"or",
"0",
")",
"+",
"self",
".",
"margin_top",
"+",
"self",
".",
"margin_bottom",
"h",
"=",
"alloc_h",
"if",
"alloc_h",
"is",
"not",
"None",
"and",
"self",
".",
"fill",
"else",
"min_height",
"h",
"=",
"max",
"(",
"h",
"or",
"0",
",",
"self",
".",
"get_min_size",
"(",
")",
"[",
"1",
"]",
")",
"return",
"h",
"-",
"self",
".",
"margin_top",
"-",
"self",
".",
"margin_bottom"
] | height in pixels | [
"height",
"in",
"pixels"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L308-L318 |
231,980 | projecthamster/hamster | src/hamster/lib/layout.py | Widget.enabled | def enabled(self):
"""whether the user is allowed to interact with the
widget. Item is enabled only if all it's parent elements are"""
enabled = self._enabled
if not enabled:
return False
if self.parent and isinstance(self.parent, Widget):
if self.parent.enabled == False:
return False
return True | python | def enabled(self):
"""whether the user is allowed to interact with the
widget. Item is enabled only if all it's parent elements are"""
enabled = self._enabled
if not enabled:
return False
if self.parent and isinstance(self.parent, Widget):
if self.parent.enabled == False:
return False
return True | [
"def",
"enabled",
"(",
"self",
")",
":",
"enabled",
"=",
"self",
".",
"_enabled",
"if",
"not",
"enabled",
":",
"return",
"False",
"if",
"self",
".",
"parent",
"and",
"isinstance",
"(",
"self",
".",
"parent",
",",
"Widget",
")",
":",
"if",
"self",
".",
"parent",
".",
"enabled",
"==",
"False",
":",
"return",
"False",
"return",
"True"
] | whether the user is allowed to interact with the
widget. Item is enabled only if all it's parent elements are | [
"whether",
"the",
"user",
"is",
"allowed",
"to",
"interact",
"with",
"the",
"widget",
".",
"Item",
"is",
"enabled",
"only",
"if",
"all",
"it",
"s",
"parent",
"elements",
"are"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L321-L332 |
231,981 | projecthamster/hamster | src/hamster/lib/layout.py | Container.resize_children | def resize_children(self):
"""default container alignment is to pile stuff just up, respecting only
padding, margin and element's alignment properties"""
width = self.width - self.horizontal_padding
height = self.height - self.vertical_padding
for sprite, props in (get_props(sprite) for sprite in self.sprites if sprite.visible):
sprite.alloc_w = width
sprite.alloc_h = height
w, h = getattr(sprite, "width", 0), getattr(sprite, "height", 0)
if hasattr(sprite, "get_height_for_width_size"):
w2, h2 = sprite.get_height_for_width_size()
w, h = max(w, w2), max(h, h2)
w = w * sprite.scale_x + props["margin_left"] + props["margin_right"]
h = h * sprite.scale_y + props["margin_top"] + props["margin_bottom"]
sprite.x = self.padding_left + props["margin_left"] + (max(sprite.alloc_w * sprite.scale_x, w) - w) * getattr(sprite, "x_align", 0)
sprite.y = self.padding_top + props["margin_top"] + (max(sprite.alloc_h * sprite.scale_y, h) - h) * getattr(sprite, "y_align", 0)
self.__dict__['_children_resize_queued'] = False | python | def resize_children(self):
"""default container alignment is to pile stuff just up, respecting only
padding, margin and element's alignment properties"""
width = self.width - self.horizontal_padding
height = self.height - self.vertical_padding
for sprite, props in (get_props(sprite) for sprite in self.sprites if sprite.visible):
sprite.alloc_w = width
sprite.alloc_h = height
w, h = getattr(sprite, "width", 0), getattr(sprite, "height", 0)
if hasattr(sprite, "get_height_for_width_size"):
w2, h2 = sprite.get_height_for_width_size()
w, h = max(w, w2), max(h, h2)
w = w * sprite.scale_x + props["margin_left"] + props["margin_right"]
h = h * sprite.scale_y + props["margin_top"] + props["margin_bottom"]
sprite.x = self.padding_left + props["margin_left"] + (max(sprite.alloc_w * sprite.scale_x, w) - w) * getattr(sprite, "x_align", 0)
sprite.y = self.padding_top + props["margin_top"] + (max(sprite.alloc_h * sprite.scale_y, h) - h) * getattr(sprite, "y_align", 0)
self.__dict__['_children_resize_queued'] = False | [
"def",
"resize_children",
"(",
"self",
")",
":",
"width",
"=",
"self",
".",
"width",
"-",
"self",
".",
"horizontal_padding",
"height",
"=",
"self",
".",
"height",
"-",
"self",
".",
"vertical_padding",
"for",
"sprite",
",",
"props",
"in",
"(",
"get_props",
"(",
"sprite",
")",
"for",
"sprite",
"in",
"self",
".",
"sprites",
"if",
"sprite",
".",
"visible",
")",
":",
"sprite",
".",
"alloc_w",
"=",
"width",
"sprite",
".",
"alloc_h",
"=",
"height",
"w",
",",
"h",
"=",
"getattr",
"(",
"sprite",
",",
"\"width\"",
",",
"0",
")",
",",
"getattr",
"(",
"sprite",
",",
"\"height\"",
",",
"0",
")",
"if",
"hasattr",
"(",
"sprite",
",",
"\"get_height_for_width_size\"",
")",
":",
"w2",
",",
"h2",
"=",
"sprite",
".",
"get_height_for_width_size",
"(",
")",
"w",
",",
"h",
"=",
"max",
"(",
"w",
",",
"w2",
")",
",",
"max",
"(",
"h",
",",
"h2",
")",
"w",
"=",
"w",
"*",
"sprite",
".",
"scale_x",
"+",
"props",
"[",
"\"margin_left\"",
"]",
"+",
"props",
"[",
"\"margin_right\"",
"]",
"h",
"=",
"h",
"*",
"sprite",
".",
"scale_y",
"+",
"props",
"[",
"\"margin_top\"",
"]",
"+",
"props",
"[",
"\"margin_bottom\"",
"]",
"sprite",
".",
"x",
"=",
"self",
".",
"padding_left",
"+",
"props",
"[",
"\"margin_left\"",
"]",
"+",
"(",
"max",
"(",
"sprite",
".",
"alloc_w",
"*",
"sprite",
".",
"scale_x",
",",
"w",
")",
"-",
"w",
")",
"*",
"getattr",
"(",
"sprite",
",",
"\"x_align\"",
",",
"0",
")",
"sprite",
".",
"y",
"=",
"self",
".",
"padding_top",
"+",
"props",
"[",
"\"margin_top\"",
"]",
"+",
"(",
"max",
"(",
"sprite",
".",
"alloc_h",
"*",
"sprite",
".",
"scale_y",
",",
"h",
")",
"-",
"h",
")",
"*",
"getattr",
"(",
"sprite",
",",
"\"y_align\"",
",",
"0",
")",
"self",
".",
"__dict__",
"[",
"'_children_resize_queued'",
"]",
"=",
"False"
] | default container alignment is to pile stuff just up, respecting only
padding, margin and element's alignment properties | [
"default",
"container",
"alignment",
"is",
"to",
"pile",
"stuff",
"just",
"up",
"respecting",
"only",
"padding",
"margin",
"and",
"element",
"s",
"alignment",
"properties"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L474-L496 |
231,982 | projecthamster/hamster | src/hamster/lib/desktop.py | DesktopIntegrations.check_hamster | def check_hamster(self):
"""refresh hamster every x secs - load today, check last activity etc."""
try:
# can't use the client because then we end up in a dbus loop
# as this is initiated in storage
todays_facts = self.storage._Storage__get_todays_facts()
self.check_user(todays_facts)
except Exception as e:
logger.error("Error while refreshing: %s" % e)
finally: # we want to go on no matter what, so in case of any error we find out about it sooner
return True | python | def check_hamster(self):
"""refresh hamster every x secs - load today, check last activity etc."""
try:
# can't use the client because then we end up in a dbus loop
# as this is initiated in storage
todays_facts = self.storage._Storage__get_todays_facts()
self.check_user(todays_facts)
except Exception as e:
logger.error("Error while refreshing: %s" % e)
finally: # we want to go on no matter what, so in case of any error we find out about it sooner
return True | [
"def",
"check_hamster",
"(",
"self",
")",
":",
"try",
":",
"# can't use the client because then we end up in a dbus loop",
"# as this is initiated in storage",
"todays_facts",
"=",
"self",
".",
"storage",
".",
"_Storage__get_todays_facts",
"(",
")",
"self",
".",
"check_user",
"(",
"todays_facts",
")",
"except",
"Exception",
"as",
"e",
":",
"logger",
".",
"error",
"(",
"\"Error while refreshing: %s\"",
"%",
"e",
")",
"finally",
":",
"# we want to go on no matter what, so in case of any error we find out about it sooner",
"return",
"True"
] | refresh hamster every x secs - load today, check last activity etc. | [
"refresh",
"hamster",
"every",
"x",
"secs",
"-",
"load",
"today",
"check",
"last",
"activity",
"etc",
"."
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/desktop.py#L52-L62 |
231,983 | projecthamster/hamster | src/hamster/lib/desktop.py | DesktopIntegrations.check_user | def check_user(self, todays_facts):
"""check if we need to notify user perhaps"""
interval = self.conf_notify_interval
if interval <= 0 or interval >= 121:
return
now = dt.datetime.now()
message = None
last_activity = todays_facts[-1] if todays_facts else None
# update duration of current task
if last_activity and not last_activity['end_time']:
delta = now - last_activity['start_time']
duration = delta.seconds / 60
if duration and duration % interval == 0:
message = _("Working on %s") % last_activity['name']
self.notify_user(message)
elif self.conf_notify_on_idle:
#if we have no last activity, let's just calculate duration from 00:00
if (now.minute + now.hour * 60) % interval == 0:
self.notify_user(_("No activity")) | python | def check_user(self, todays_facts):
"""check if we need to notify user perhaps"""
interval = self.conf_notify_interval
if interval <= 0 or interval >= 121:
return
now = dt.datetime.now()
message = None
last_activity = todays_facts[-1] if todays_facts else None
# update duration of current task
if last_activity and not last_activity['end_time']:
delta = now - last_activity['start_time']
duration = delta.seconds / 60
if duration and duration % interval == 0:
message = _("Working on %s") % last_activity['name']
self.notify_user(message)
elif self.conf_notify_on_idle:
#if we have no last activity, let's just calculate duration from 00:00
if (now.minute + now.hour * 60) % interval == 0:
self.notify_user(_("No activity")) | [
"def",
"check_user",
"(",
"self",
",",
"todays_facts",
")",
":",
"interval",
"=",
"self",
".",
"conf_notify_interval",
"if",
"interval",
"<=",
"0",
"or",
"interval",
">=",
"121",
":",
"return",
"now",
"=",
"dt",
".",
"datetime",
".",
"now",
"(",
")",
"message",
"=",
"None",
"last_activity",
"=",
"todays_facts",
"[",
"-",
"1",
"]",
"if",
"todays_facts",
"else",
"None",
"# update duration of current task",
"if",
"last_activity",
"and",
"not",
"last_activity",
"[",
"'end_time'",
"]",
":",
"delta",
"=",
"now",
"-",
"last_activity",
"[",
"'start_time'",
"]",
"duration",
"=",
"delta",
".",
"seconds",
"/",
"60",
"if",
"duration",
"and",
"duration",
"%",
"interval",
"==",
"0",
":",
"message",
"=",
"_",
"(",
"\"Working on %s\"",
")",
"%",
"last_activity",
"[",
"'name'",
"]",
"self",
".",
"notify_user",
"(",
"message",
")",
"elif",
"self",
".",
"conf_notify_on_idle",
":",
"#if we have no last activity, let's just calculate duration from 00:00",
"if",
"(",
"now",
".",
"minute",
"+",
"now",
".",
"hour",
"*",
"60",
")",
"%",
"interval",
"==",
"0",
":",
"self",
".",
"notify_user",
"(",
"_",
"(",
"\"No activity\"",
")",
")"
] | check if we need to notify user perhaps | [
"check",
"if",
"we",
"need",
"to",
"notify",
"user",
"perhaps"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/desktop.py#L65-L88 |
231,984 | projecthamster/hamster | src/hamster/storage/storage.py | Storage.stop_tracking | def stop_tracking(self, end_time):
"""Stops tracking the current activity"""
facts = self.__get_todays_facts()
if facts and not facts[-1]['end_time']:
self.__touch_fact(facts[-1], end_time)
self.facts_changed() | python | def stop_tracking(self, end_time):
"""Stops tracking the current activity"""
facts = self.__get_todays_facts()
if facts and not facts[-1]['end_time']:
self.__touch_fact(facts[-1], end_time)
self.facts_changed() | [
"def",
"stop_tracking",
"(",
"self",
",",
"end_time",
")",
":",
"facts",
"=",
"self",
".",
"__get_todays_facts",
"(",
")",
"if",
"facts",
"and",
"not",
"facts",
"[",
"-",
"1",
"]",
"[",
"'end_time'",
"]",
":",
"self",
".",
"__touch_fact",
"(",
"facts",
"[",
"-",
"1",
"]",
",",
"end_time",
")",
"self",
".",
"facts_changed",
"(",
")"
] | Stops tracking the current activity | [
"Stops",
"tracking",
"the",
"current",
"activity"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/storage/storage.py#L67-L72 |
231,985 | projecthamster/hamster | src/hamster/storage/storage.py | Storage.remove_fact | def remove_fact(self, fact_id):
"""Remove fact from storage by it's ID"""
self.start_transaction()
fact = self.__get_fact(fact_id)
if fact:
self.__remove_fact(fact_id)
self.facts_changed()
self.end_transaction() | python | def remove_fact(self, fact_id):
"""Remove fact from storage by it's ID"""
self.start_transaction()
fact = self.__get_fact(fact_id)
if fact:
self.__remove_fact(fact_id)
self.facts_changed()
self.end_transaction() | [
"def",
"remove_fact",
"(",
"self",
",",
"fact_id",
")",
":",
"self",
".",
"start_transaction",
"(",
")",
"fact",
"=",
"self",
".",
"__get_fact",
"(",
"fact_id",
")",
"if",
"fact",
":",
"self",
".",
"__remove_fact",
"(",
"fact_id",
")",
"self",
".",
"facts_changed",
"(",
")",
"self",
".",
"end_transaction",
"(",
")"
] | Remove fact from storage by it's ID | [
"Remove",
"fact",
"from",
"storage",
"by",
"it",
"s",
"ID"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/storage/storage.py#L75-L82 |
231,986 | projecthamster/hamster | src/hamster/lib/configuration.py | load_ui_file | def load_ui_file(name):
"""loads interface from the glade file; sorts out the path business"""
ui = gtk.Builder()
ui.add_from_file(os.path.join(runtime.data_dir, name))
return ui | python | def load_ui_file(name):
"""loads interface from the glade file; sorts out the path business"""
ui = gtk.Builder()
ui.add_from_file(os.path.join(runtime.data_dir, name))
return ui | [
"def",
"load_ui_file",
"(",
"name",
")",
":",
"ui",
"=",
"gtk",
".",
"Builder",
"(",
")",
"ui",
".",
"add_from_file",
"(",
"os",
".",
"path",
".",
"join",
"(",
"runtime",
".",
"data_dir",
",",
"name",
")",
")",
"return",
"ui"
] | loads interface from the glade file; sorts out the path business | [
"loads",
"interface",
"from",
"the",
"glade",
"file",
";",
"sorts",
"out",
"the",
"path",
"business"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/configuration.py#L87-L91 |
231,987 | projecthamster/hamster | src/hamster/lib/configuration.py | GConfStore._fix_key | def _fix_key(self, key):
"""
Appends the GCONF_PREFIX to the key if needed
@param key: The key to check
@type key: C{string}
@returns: The fixed key
@rtype: C{string}
"""
if not key.startswith(self.GCONF_DIR):
return self.GCONF_DIR + key
else:
return key | python | def _fix_key(self, key):
"""
Appends the GCONF_PREFIX to the key if needed
@param key: The key to check
@type key: C{string}
@returns: The fixed key
@rtype: C{string}
"""
if not key.startswith(self.GCONF_DIR):
return self.GCONF_DIR + key
else:
return key | [
"def",
"_fix_key",
"(",
"self",
",",
"key",
")",
":",
"if",
"not",
"key",
".",
"startswith",
"(",
"self",
".",
"GCONF_DIR",
")",
":",
"return",
"self",
".",
"GCONF_DIR",
"+",
"key",
"else",
":",
"return",
"key"
] | Appends the GCONF_PREFIX to the key if needed
@param key: The key to check
@type key: C{string}
@returns: The fixed key
@rtype: C{string} | [
"Appends",
"the",
"GCONF_PREFIX",
"to",
"the",
"key",
"if",
"needed"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/configuration.py#L224-L236 |
231,988 | projecthamster/hamster | src/hamster/lib/configuration.py | GConfStore._key_changed | def _key_changed(self, client, cnxn_id, entry, data=None):
"""
Callback when a gconf key changes
"""
key = self._fix_key(entry.key)[len(self.GCONF_DIR):]
value = self._get_value(entry.value, self.DEFAULTS[key])
self.emit('conf-changed', key, value) | python | def _key_changed(self, client, cnxn_id, entry, data=None):
"""
Callback when a gconf key changes
"""
key = self._fix_key(entry.key)[len(self.GCONF_DIR):]
value = self._get_value(entry.value, self.DEFAULTS[key])
self.emit('conf-changed', key, value) | [
"def",
"_key_changed",
"(",
"self",
",",
"client",
",",
"cnxn_id",
",",
"entry",
",",
"data",
"=",
"None",
")",
":",
"key",
"=",
"self",
".",
"_fix_key",
"(",
"entry",
".",
"key",
")",
"[",
"len",
"(",
"self",
".",
"GCONF_DIR",
")",
":",
"]",
"value",
"=",
"self",
".",
"_get_value",
"(",
"entry",
".",
"value",
",",
"self",
".",
"DEFAULTS",
"[",
"key",
"]",
")",
"self",
".",
"emit",
"(",
"'conf-changed'",
",",
"key",
",",
"value",
")"
] | Callback when a gconf key changes | [
"Callback",
"when",
"a",
"gconf",
"key",
"changes"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/configuration.py#L238-L245 |
231,989 | projecthamster/hamster | src/hamster/lib/configuration.py | GConfStore._get_value | def _get_value(self, value, default):
"""calls appropriate gconf function by the default value"""
vtype = type(default)
if vtype is bool:
return value.get_bool()
elif vtype is str:
return value.get_string()
elif vtype is int:
return value.get_int()
elif vtype in (list, tuple):
l = []
for i in value.get_list():
l.append(i.get_string())
return l
return None | python | def _get_value(self, value, default):
"""calls appropriate gconf function by the default value"""
vtype = type(default)
if vtype is bool:
return value.get_bool()
elif vtype is str:
return value.get_string()
elif vtype is int:
return value.get_int()
elif vtype in (list, tuple):
l = []
for i in value.get_list():
l.append(i.get_string())
return l
return None | [
"def",
"_get_value",
"(",
"self",
",",
"value",
",",
"default",
")",
":",
"vtype",
"=",
"type",
"(",
"default",
")",
"if",
"vtype",
"is",
"bool",
":",
"return",
"value",
".",
"get_bool",
"(",
")",
"elif",
"vtype",
"is",
"str",
":",
"return",
"value",
".",
"get_string",
"(",
")",
"elif",
"vtype",
"is",
"int",
":",
"return",
"value",
".",
"get_int",
"(",
")",
"elif",
"vtype",
"in",
"(",
"list",
",",
"tuple",
")",
":",
"l",
"=",
"[",
"]",
"for",
"i",
"in",
"value",
".",
"get_list",
"(",
")",
":",
"l",
".",
"append",
"(",
"i",
".",
"get_string",
"(",
")",
")",
"return",
"l",
"return",
"None"
] | calls appropriate gconf function by the default value | [
"calls",
"appropriate",
"gconf",
"function",
"by",
"the",
"default",
"value"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/configuration.py#L248-L264 |
231,990 | projecthamster/hamster | src/hamster/lib/configuration.py | GConfStore.get | def get(self, key, default=None):
"""
Returns the value of the key or the default value if the key is
not yet in gconf
"""
#function arguments override defaults
if default is None:
default = self.DEFAULTS.get(key, None)
vtype = type(default)
#we now have a valid key and type
if default is None:
logger.warn("Unknown key: %s, must specify default value" % key)
return None
if vtype not in self.VALID_KEY_TYPES:
logger.warn("Invalid key type: %s" % vtype)
return None
#for gconf refer to the full key path
key = self._fix_key(key)
if key not in self._notifications:
self._client.notify_add(key, self._key_changed, None)
self._notifications.append(key)
value = self._client.get(key)
if value is None:
self.set(key, default)
return default
value = self._get_value(value, default)
if value is not None:
return value
logger.warn("Unknown gconf key: %s" % key)
return None | python | def get(self, key, default=None):
"""
Returns the value of the key or the default value if the key is
not yet in gconf
"""
#function arguments override defaults
if default is None:
default = self.DEFAULTS.get(key, None)
vtype = type(default)
#we now have a valid key and type
if default is None:
logger.warn("Unknown key: %s, must specify default value" % key)
return None
if vtype not in self.VALID_KEY_TYPES:
logger.warn("Invalid key type: %s" % vtype)
return None
#for gconf refer to the full key path
key = self._fix_key(key)
if key not in self._notifications:
self._client.notify_add(key, self._key_changed, None)
self._notifications.append(key)
value = self._client.get(key)
if value is None:
self.set(key, default)
return default
value = self._get_value(value, default)
if value is not None:
return value
logger.warn("Unknown gconf key: %s" % key)
return None | [
"def",
"get",
"(",
"self",
",",
"key",
",",
"default",
"=",
"None",
")",
":",
"#function arguments override defaults",
"if",
"default",
"is",
"None",
":",
"default",
"=",
"self",
".",
"DEFAULTS",
".",
"get",
"(",
"key",
",",
"None",
")",
"vtype",
"=",
"type",
"(",
"default",
")",
"#we now have a valid key and type",
"if",
"default",
"is",
"None",
":",
"logger",
".",
"warn",
"(",
"\"Unknown key: %s, must specify default value\"",
"%",
"key",
")",
"return",
"None",
"if",
"vtype",
"not",
"in",
"self",
".",
"VALID_KEY_TYPES",
":",
"logger",
".",
"warn",
"(",
"\"Invalid key type: %s\"",
"%",
"vtype",
")",
"return",
"None",
"#for gconf refer to the full key path",
"key",
"=",
"self",
".",
"_fix_key",
"(",
"key",
")",
"if",
"key",
"not",
"in",
"self",
".",
"_notifications",
":",
"self",
".",
"_client",
".",
"notify_add",
"(",
"key",
",",
"self",
".",
"_key_changed",
",",
"None",
")",
"self",
".",
"_notifications",
".",
"append",
"(",
"key",
")",
"value",
"=",
"self",
".",
"_client",
".",
"get",
"(",
"key",
")",
"if",
"value",
"is",
"None",
":",
"self",
".",
"set",
"(",
"key",
",",
"default",
")",
"return",
"default",
"value",
"=",
"self",
".",
"_get_value",
"(",
"value",
",",
"default",
")",
"if",
"value",
"is",
"not",
"None",
":",
"return",
"value",
"logger",
".",
"warn",
"(",
"\"Unknown gconf key: %s\"",
"%",
"key",
")",
"return",
"None"
] | Returns the value of the key or the default value if the key is
not yet in gconf | [
"Returns",
"the",
"value",
"of",
"the",
"key",
"or",
"the",
"default",
"value",
"if",
"the",
"key",
"is",
"not",
"yet",
"in",
"gconf"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/configuration.py#L266-L303 |
231,991 | projecthamster/hamster | src/hamster/lib/configuration.py | GConfStore.set | def set(self, key, value):
"""
Sets the key value in gconf and connects adds a signal
which is fired if the key changes
"""
logger.debug("Settings %s -> %s" % (key, value))
if key in self.DEFAULTS:
vtype = type(self.DEFAULTS[key])
else:
vtype = type(value)
if vtype not in self.VALID_KEY_TYPES:
logger.warn("Invalid key type: %s" % vtype)
return False
#for gconf refer to the full key path
key = self._fix_key(key)
if vtype is bool:
self._client.set_bool(key, value)
elif vtype is str:
self._client.set_string(key, value)
elif vtype is int:
self._client.set_int(key, value)
elif vtype in (list, tuple):
#Save every value as a string
strvalues = [str(i) for i in value]
#self._client.set_list(key, gconf.VALUE_STRING, strvalues)
return True | python | def set(self, key, value):
"""
Sets the key value in gconf and connects adds a signal
which is fired if the key changes
"""
logger.debug("Settings %s -> %s" % (key, value))
if key in self.DEFAULTS:
vtype = type(self.DEFAULTS[key])
else:
vtype = type(value)
if vtype not in self.VALID_KEY_TYPES:
logger.warn("Invalid key type: %s" % vtype)
return False
#for gconf refer to the full key path
key = self._fix_key(key)
if vtype is bool:
self._client.set_bool(key, value)
elif vtype is str:
self._client.set_string(key, value)
elif vtype is int:
self._client.set_int(key, value)
elif vtype in (list, tuple):
#Save every value as a string
strvalues = [str(i) for i in value]
#self._client.set_list(key, gconf.VALUE_STRING, strvalues)
return True | [
"def",
"set",
"(",
"self",
",",
"key",
",",
"value",
")",
":",
"logger",
".",
"debug",
"(",
"\"Settings %s -> %s\"",
"%",
"(",
"key",
",",
"value",
")",
")",
"if",
"key",
"in",
"self",
".",
"DEFAULTS",
":",
"vtype",
"=",
"type",
"(",
"self",
".",
"DEFAULTS",
"[",
"key",
"]",
")",
"else",
":",
"vtype",
"=",
"type",
"(",
"value",
")",
"if",
"vtype",
"not",
"in",
"self",
".",
"VALID_KEY_TYPES",
":",
"logger",
".",
"warn",
"(",
"\"Invalid key type: %s\"",
"%",
"vtype",
")",
"return",
"False",
"#for gconf refer to the full key path",
"key",
"=",
"self",
".",
"_fix_key",
"(",
"key",
")",
"if",
"vtype",
"is",
"bool",
":",
"self",
".",
"_client",
".",
"set_bool",
"(",
"key",
",",
"value",
")",
"elif",
"vtype",
"is",
"str",
":",
"self",
".",
"_client",
".",
"set_string",
"(",
"key",
",",
"value",
")",
"elif",
"vtype",
"is",
"int",
":",
"self",
".",
"_client",
".",
"set_int",
"(",
"key",
",",
"value",
")",
"elif",
"vtype",
"in",
"(",
"list",
",",
"tuple",
")",
":",
"#Save every value as a string",
"strvalues",
"=",
"[",
"str",
"(",
"i",
")",
"for",
"i",
"in",
"value",
"]",
"#self._client.set_list(key, gconf.VALUE_STRING, strvalues)",
"return",
"True"
] | Sets the key value in gconf and connects adds a signal
which is fired if the key changes | [
"Sets",
"the",
"key",
"value",
"in",
"gconf",
"and",
"connects",
"adds",
"a",
"signal",
"which",
"is",
"fired",
"if",
"the",
"key",
"changes"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/configuration.py#L305-L334 |
231,992 | projecthamster/hamster | src/hamster/lib/configuration.py | GConfStore.day_start | def day_start(self):
"""Start of the hamster day."""
day_start_minutes = self.get("day_start_minutes")
hours, minutes = divmod(day_start_minutes, 60)
return dt.time(hours, minutes) | python | def day_start(self):
"""Start of the hamster day."""
day_start_minutes = self.get("day_start_minutes")
hours, minutes = divmod(day_start_minutes, 60)
return dt.time(hours, minutes) | [
"def",
"day_start",
"(",
"self",
")",
":",
"day_start_minutes",
"=",
"self",
".",
"get",
"(",
"\"day_start_minutes\"",
")",
"hours",
",",
"minutes",
"=",
"divmod",
"(",
"day_start_minutes",
",",
"60",
")",
"return",
"dt",
".",
"time",
"(",
"hours",
",",
"minutes",
")"
] | Start of the hamster day. | [
"Start",
"of",
"the",
"hamster",
"day",
"."
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/configuration.py#L337-L341 |
231,993 | projecthamster/hamster | src/hamster/edit_activity.py | CustomFactController.localized_fact | def localized_fact(self):
"""Make sure fact has the correct start_time."""
fact = Fact(self.activity.get_text())
if fact.start_time:
fact.date = self.date
else:
fact.start_time = dt.datetime.now()
return fact | python | def localized_fact(self):
"""Make sure fact has the correct start_time."""
fact = Fact(self.activity.get_text())
if fact.start_time:
fact.date = self.date
else:
fact.start_time = dt.datetime.now()
return fact | [
"def",
"localized_fact",
"(",
"self",
")",
":",
"fact",
"=",
"Fact",
"(",
"self",
".",
"activity",
".",
"get_text",
"(",
")",
")",
"if",
"fact",
".",
"start_time",
":",
"fact",
".",
"date",
"=",
"self",
".",
"date",
"else",
":",
"fact",
".",
"start_time",
"=",
"dt",
".",
"datetime",
".",
"now",
"(",
")",
"return",
"fact"
] | Make sure fact has the correct start_time. | [
"Make",
"sure",
"fact",
"has",
"the",
"correct",
"start_time",
"."
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/edit_activity.py#L124-L131 |
231,994 | projecthamster/hamster | src/hamster/widgets/activityentry.py | CompleteTree.set_row_positions | def set_row_positions(self):
"""creates a list of row positions for simpler manipulation"""
self.row_positions = [i * self.row_height for i in range(len(self.rows))]
self.set_size_request(0, self.row_positions[-1] + self.row_height if self.row_positions else 0) | python | def set_row_positions(self):
"""creates a list of row positions for simpler manipulation"""
self.row_positions = [i * self.row_height for i in range(len(self.rows))]
self.set_size_request(0, self.row_positions[-1] + self.row_height if self.row_positions else 0) | [
"def",
"set_row_positions",
"(",
"self",
")",
":",
"self",
".",
"row_positions",
"=",
"[",
"i",
"*",
"self",
".",
"row_height",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"rows",
")",
")",
"]",
"self",
".",
"set_size_request",
"(",
"0",
",",
"self",
".",
"row_positions",
"[",
"-",
"1",
"]",
"+",
"self",
".",
"row_height",
"if",
"self",
".",
"row_positions",
"else",
"0",
")"
] | creates a list of row positions for simpler manipulation | [
"creates",
"a",
"list",
"of",
"row",
"positions",
"for",
"simpler",
"manipulation"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/widgets/activityentry.py#L157-L160 |
231,995 | projecthamster/hamster | src/hamster/client.py | from_dbus_fact | def from_dbus_fact(fact):
"""unpack the struct into a proper dict"""
return Fact(fact[4],
start_time = dt.datetime.utcfromtimestamp(fact[1]),
end_time = dt.datetime.utcfromtimestamp(fact[2]) if fact[2] else None,
description = fact[3],
activity_id = fact[5],
category = fact[6],
tags = fact[7],
date = dt.datetime.utcfromtimestamp(fact[8]).date(),
id = fact[0]
) | python | def from_dbus_fact(fact):
"""unpack the struct into a proper dict"""
return Fact(fact[4],
start_time = dt.datetime.utcfromtimestamp(fact[1]),
end_time = dt.datetime.utcfromtimestamp(fact[2]) if fact[2] else None,
description = fact[3],
activity_id = fact[5],
category = fact[6],
tags = fact[7],
date = dt.datetime.utcfromtimestamp(fact[8]).date(),
id = fact[0]
) | [
"def",
"from_dbus_fact",
"(",
"fact",
")",
":",
"return",
"Fact",
"(",
"fact",
"[",
"4",
"]",
",",
"start_time",
"=",
"dt",
".",
"datetime",
".",
"utcfromtimestamp",
"(",
"fact",
"[",
"1",
"]",
")",
",",
"end_time",
"=",
"dt",
".",
"datetime",
".",
"utcfromtimestamp",
"(",
"fact",
"[",
"2",
"]",
")",
"if",
"fact",
"[",
"2",
"]",
"else",
"None",
",",
"description",
"=",
"fact",
"[",
"3",
"]",
",",
"activity_id",
"=",
"fact",
"[",
"5",
"]",
",",
"category",
"=",
"fact",
"[",
"6",
"]",
",",
"tags",
"=",
"fact",
"[",
"7",
"]",
",",
"date",
"=",
"dt",
".",
"datetime",
".",
"utcfromtimestamp",
"(",
"fact",
"[",
"8",
"]",
")",
".",
"date",
"(",
")",
",",
"id",
"=",
"fact",
"[",
"0",
"]",
")"
] | unpack the struct into a proper dict | [
"unpack",
"the",
"struct",
"into",
"a",
"proper",
"dict"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/client.py#L28-L39 |
231,996 | projecthamster/hamster | src/hamster/client.py | Storage.get_tags | def get_tags(self, only_autocomplete = False):
"""returns list of all tags. by default only those that have been set for autocomplete"""
return self._to_dict(('id', 'name', 'autocomplete'), self.conn.GetTags(only_autocomplete)) | python | def get_tags(self, only_autocomplete = False):
"""returns list of all tags. by default only those that have been set for autocomplete"""
return self._to_dict(('id', 'name', 'autocomplete'), self.conn.GetTags(only_autocomplete)) | [
"def",
"get_tags",
"(",
"self",
",",
"only_autocomplete",
"=",
"False",
")",
":",
"return",
"self",
".",
"_to_dict",
"(",
"(",
"'id'",
",",
"'name'",
",",
"'autocomplete'",
")",
",",
"self",
".",
"conn",
".",
"GetTags",
"(",
"only_autocomplete",
")",
")"
] | returns list of all tags. by default only those that have been set for autocomplete | [
"returns",
"list",
"of",
"all",
"tags",
".",
"by",
"default",
"only",
"those",
"that",
"have",
"been",
"set",
"for",
"autocomplete"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/client.py#L151-L153 |
231,997 | projecthamster/hamster | src/hamster/client.py | Storage.stop_tracking | def stop_tracking(self, end_time = None):
"""Stop tracking current activity. end_time can be passed in if the
activity should have other end time than the current moment"""
end_time = timegm((end_time or dt.datetime.now()).timetuple())
return self.conn.StopTracking(end_time) | python | def stop_tracking(self, end_time = None):
"""Stop tracking current activity. end_time can be passed in if the
activity should have other end time than the current moment"""
end_time = timegm((end_time or dt.datetime.now()).timetuple())
return self.conn.StopTracking(end_time) | [
"def",
"stop_tracking",
"(",
"self",
",",
"end_time",
"=",
"None",
")",
":",
"end_time",
"=",
"timegm",
"(",
"(",
"end_time",
"or",
"dt",
".",
"datetime",
".",
"now",
"(",
")",
")",
".",
"timetuple",
"(",
")",
")",
"return",
"self",
".",
"conn",
".",
"StopTracking",
"(",
"end_time",
")"
] | Stop tracking current activity. end_time can be passed in if the
activity should have other end time than the current moment | [
"Stop",
"tracking",
"current",
"activity",
".",
"end_time",
"can",
"be",
"passed",
"in",
"if",
"the",
"activity",
"should",
"have",
"other",
"end",
"time",
"than",
"the",
"current",
"moment"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/client.py#L201-L205 |
231,998 | projecthamster/hamster | src/hamster/client.py | Storage.get_category_activities | def get_category_activities(self, category_id = None):
"""Return activities for category. If category is not specified, will
return activities that have no category"""
category_id = category_id or -1
return self._to_dict(('id', 'name', 'category_id', 'category'), self.conn.GetCategoryActivities(category_id)) | python | def get_category_activities(self, category_id = None):
"""Return activities for category. If category is not specified, will
return activities that have no category"""
category_id = category_id or -1
return self._to_dict(('id', 'name', 'category_id', 'category'), self.conn.GetCategoryActivities(category_id)) | [
"def",
"get_category_activities",
"(",
"self",
",",
"category_id",
"=",
"None",
")",
":",
"category_id",
"=",
"category_id",
"or",
"-",
"1",
"return",
"self",
".",
"_to_dict",
"(",
"(",
"'id'",
",",
"'name'",
",",
"'category_id'",
",",
"'category'",
")",
",",
"self",
".",
"conn",
".",
"GetCategoryActivities",
"(",
"category_id",
")",
")"
] | Return activities for category. If category is not specified, will
return activities that have no category | [
"Return",
"activities",
"for",
"category",
".",
"If",
"category",
"is",
"not",
"specified",
"will",
"return",
"activities",
"that",
"have",
"no",
"category"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/client.py#L232-L236 |
231,999 | projecthamster/hamster | src/hamster/client.py | Storage.get_activity_by_name | def get_activity_by_name(self, activity, category_id = None, resurrect = True):
"""returns activity dict by name and optionally filtering by category.
if activity is found but is marked as deleted, it will be resurrected
unless told otherwise in the resurrect param
"""
category_id = category_id or 0
return self.conn.GetActivityByName(activity, category_id, resurrect) | python | def get_activity_by_name(self, activity, category_id = None, resurrect = True):
"""returns activity dict by name and optionally filtering by category.
if activity is found but is marked as deleted, it will be resurrected
unless told otherwise in the resurrect param
"""
category_id = category_id or 0
return self.conn.GetActivityByName(activity, category_id, resurrect) | [
"def",
"get_activity_by_name",
"(",
"self",
",",
"activity",
",",
"category_id",
"=",
"None",
",",
"resurrect",
"=",
"True",
")",
":",
"category_id",
"=",
"category_id",
"or",
"0",
"return",
"self",
".",
"conn",
".",
"GetActivityByName",
"(",
"activity",
",",
"category_id",
",",
"resurrect",
")"
] | returns activity dict by name and optionally filtering by category.
if activity is found but is marked as deleted, it will be resurrected
unless told otherwise in the resurrect param | [
"returns",
"activity",
"dict",
"by",
"name",
"and",
"optionally",
"filtering",
"by",
"category",
".",
"if",
"activity",
"is",
"found",
"but",
"is",
"marked",
"as",
"deleted",
"it",
"will",
"be",
"resurrected",
"unless",
"told",
"otherwise",
"in",
"the",
"resurrect",
"param"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/client.py#L242-L248 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.