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 51 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
245,700 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.values_list | def values_list(
self, *fields_: str, flat: bool = False
) -> "ValuesListQuery": # pylint: disable=W0621
"""
Make QuerySet returns list of tuples for given args instead of objects.
If ```flat=True`` and only one arg is passed can return flat list.
"""
return ValuesListQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
flat=flat,
fields_for_select_list=fields_,
distinct=self._distinct,
limit=self._limit,
offset=self._offset,
orderings=self._orderings,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | python | def values_list(
self, *fields_: str, flat: bool = False
) -> "ValuesListQuery": # pylint: disable=W0621
return ValuesListQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
flat=flat,
fields_for_select_list=fields_,
distinct=self._distinct,
limit=self._limit,
offset=self._offset,
orderings=self._orderings,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | [
"def",
"values_list",
"(",
"self",
",",
"*",
"fields_",
":",
"str",
",",
"flat",
":",
"bool",
"=",
"False",
")",
"->",
"\"ValuesListQuery\"",
":",
"# pylint: disable=W0621",
"return",
"ValuesListQuery",
"(",
"db",
"=",
"self",
".",
"_db",
",",
"model",
"="... | Make QuerySet returns list of tuples for given args instead of objects.
If ```flat=True`` and only one arg is passed can return flat list. | [
"Make",
"QuerySet",
"returns",
"list",
"of",
"tuples",
"for",
"given",
"args",
"instead",
"of",
"objects",
".",
"If",
"flat",
"=",
"True",
"and",
"only",
"one",
"arg",
"is",
"passed",
"can",
"return",
"flat",
"list",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L258-L277 |
245,701 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.values | def values(self, *args: str, **kwargs: str) -> "ValuesQuery":
"""
Make QuerySet return dicts instead of objects.
"""
fields_for_select = {} # type: Dict[str, str]
for field in args:
if field in fields_for_select:
raise FieldError("Duplicate key {}".format(field))
fields_for_select[field] = field
for return_as, field in kwargs.items():
if return_as in fields_for_select:
raise FieldError("Duplicate key {}".format(return_as))
fields_for_select[return_as] = field
return ValuesQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
fields_for_select=fields_for_select,
distinct=self._distinct,
limit=self._limit,
offset=self._offset,
orderings=self._orderings,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | python | def values(self, *args: str, **kwargs: str) -> "ValuesQuery":
fields_for_select = {} # type: Dict[str, str]
for field in args:
if field in fields_for_select:
raise FieldError("Duplicate key {}".format(field))
fields_for_select[field] = field
for return_as, field in kwargs.items():
if return_as in fields_for_select:
raise FieldError("Duplicate key {}".format(return_as))
fields_for_select[return_as] = field
return ValuesQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
fields_for_select=fields_for_select,
distinct=self._distinct,
limit=self._limit,
offset=self._offset,
orderings=self._orderings,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | [
"def",
"values",
"(",
"self",
",",
"*",
"args",
":",
"str",
",",
"*",
"*",
"kwargs",
":",
"str",
")",
"->",
"\"ValuesQuery\"",
":",
"fields_for_select",
"=",
"{",
"}",
"# type: Dict[str, str]",
"for",
"field",
"in",
"args",
":",
"if",
"field",
"in",
"f... | Make QuerySet return dicts instead of objects. | [
"Make",
"QuerySet",
"return",
"dicts",
"instead",
"of",
"objects",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L279-L305 |
245,702 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.delete | def delete(self) -> "DeleteQuery":
"""
Delete all objects in QuerySet.
"""
return DeleteQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | python | def delete(self) -> "DeleteQuery":
return DeleteQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | [
"def",
"delete",
"(",
"self",
")",
"->",
"\"DeleteQuery\"",
":",
"return",
"DeleteQuery",
"(",
"db",
"=",
"self",
".",
"_db",
",",
"model",
"=",
"self",
".",
"model",
",",
"q_objects",
"=",
"self",
".",
"_q_objects",
",",
"annotations",
"=",
"self",
".... | Delete all objects in QuerySet. | [
"Delete",
"all",
"objects",
"in",
"QuerySet",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L307-L317 |
245,703 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.update | def update(self, **kwargs) -> "UpdateQuery":
"""
Update all objects in QuerySet with given kwargs.
"""
return UpdateQuery(
db=self._db,
model=self.model,
update_kwargs=kwargs,
q_objects=self._q_objects,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | python | def update(self, **kwargs) -> "UpdateQuery":
return UpdateQuery(
db=self._db,
model=self.model,
update_kwargs=kwargs,
q_objects=self._q_objects,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | [
"def",
"update",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
"->",
"\"UpdateQuery\"",
":",
"return",
"UpdateQuery",
"(",
"db",
"=",
"self",
".",
"_db",
",",
"model",
"=",
"self",
".",
"model",
",",
"update_kwargs",
"=",
"kwargs",
",",
"q_objects",
"=",
... | Update all objects in QuerySet with given kwargs. | [
"Update",
"all",
"objects",
"in",
"QuerySet",
"with",
"given",
"kwargs",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L319-L330 |
245,704 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.count | def count(self) -> "CountQuery":
"""
Return count of objects in queryset instead of objects.
"""
return CountQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | python | def count(self) -> "CountQuery":
return CountQuery(
db=self._db,
model=self.model,
q_objects=self._q_objects,
annotations=self._annotations,
custom_filters=self._custom_filters,
) | [
"def",
"count",
"(",
"self",
")",
"->",
"\"CountQuery\"",
":",
"return",
"CountQuery",
"(",
"db",
"=",
"self",
".",
"_db",
",",
"model",
"=",
"self",
".",
"model",
",",
"q_objects",
"=",
"self",
".",
"_q_objects",
",",
"annotations",
"=",
"self",
".",
... | Return count of objects in queryset instead of objects. | [
"Return",
"count",
"of",
"objects",
"in",
"queryset",
"instead",
"of",
"objects",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L332-L342 |
245,705 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.first | def first(self) -> "QuerySet":
"""
Limit queryset to one object and return one object instead of list.
"""
queryset = self._clone()
queryset._limit = 1
queryset._single = True
return queryset | python | def first(self) -> "QuerySet":
queryset = self._clone()
queryset._limit = 1
queryset._single = True
return queryset | [
"def",
"first",
"(",
"self",
")",
"->",
"\"QuerySet\"",
":",
"queryset",
"=",
"self",
".",
"_clone",
"(",
")",
"queryset",
".",
"_limit",
"=",
"1",
"queryset",
".",
"_single",
"=",
"True",
"return",
"queryset"
] | Limit queryset to one object and return one object instead of list. | [
"Limit",
"queryset",
"to",
"one",
"object",
"and",
"return",
"one",
"object",
"instead",
"of",
"list",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L351-L358 |
245,706 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.get | def get(self, *args, **kwargs) -> "QuerySet":
"""
Fetch exactly one object matching the parameters.
"""
queryset = self.filter(*args, **kwargs)
queryset._limit = 2
queryset._get = True
return queryset | python | def get(self, *args, **kwargs) -> "QuerySet":
queryset = self.filter(*args, **kwargs)
queryset._limit = 2
queryset._get = True
return queryset | [
"def",
"get",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"\"QuerySet\"",
":",
"queryset",
"=",
"self",
".",
"filter",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"queryset",
".",
"_limit",
"=",
"2",
"queryset",
".",
"_... | Fetch exactly one object matching the parameters. | [
"Fetch",
"exactly",
"one",
"object",
"matching",
"the",
"parameters",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L360-L367 |
245,707 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.explain | async def explain(self) -> Any:
"""Fetch and return information about the query execution plan.
This is done by executing an ``EXPLAIN`` query whose exact prefix depends
on the database backend, as documented below.
- PostgreSQL: ``EXPLAIN (FORMAT JSON, VERBOSE) ...``
- SQLite: ``EXPLAIN QUERY PLAN ...``
- MySQL: ``EXPLAIN FORMAT=JSON ...``
.. note::
This is only meant to be used in an interactive environment for debugging
and query optimization.
**The output format may (and will) vary greatly depending on the database backend.**
"""
if self._db is None:
self._db = self.model._meta.db
return await self._db.executor_class(model=self.model, db=self._db).execute_explain(
self._make_query()
) | python | async def explain(self) -> Any:
if self._db is None:
self._db = self.model._meta.db
return await self._db.executor_class(model=self.model, db=self._db).execute_explain(
self._make_query()
) | [
"async",
"def",
"explain",
"(",
"self",
")",
"->",
"Any",
":",
"if",
"self",
".",
"_db",
"is",
"None",
":",
"self",
".",
"_db",
"=",
"self",
".",
"model",
".",
"_meta",
".",
"db",
"return",
"await",
"self",
".",
"_db",
".",
"executor_class",
"(",
... | Fetch and return information about the query execution plan.
This is done by executing an ``EXPLAIN`` query whose exact prefix depends
on the database backend, as documented below.
- PostgreSQL: ``EXPLAIN (FORMAT JSON, VERBOSE) ...``
- SQLite: ``EXPLAIN QUERY PLAN ...``
- MySQL: ``EXPLAIN FORMAT=JSON ...``
.. note::
This is only meant to be used in an interactive environment for debugging
and query optimization.
**The output format may (and will) vary greatly depending on the database backend.** | [
"Fetch",
"and",
"return",
"information",
"about",
"the",
"query",
"execution",
"plan",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L393-L413 |
245,708 | tortoise/tortoise-orm | tortoise/queryset.py | QuerySet.using_db | def using_db(self, _db: BaseDBAsyncClient) -> "QuerySet":
"""
Executes query in provided db client.
Useful for transactions workaround.
"""
queryset = self._clone()
queryset._db = _db
return queryset | python | def using_db(self, _db: BaseDBAsyncClient) -> "QuerySet":
queryset = self._clone()
queryset._db = _db
return queryset | [
"def",
"using_db",
"(",
"self",
",",
"_db",
":",
"BaseDBAsyncClient",
")",
"->",
"\"QuerySet\"",
":",
"queryset",
"=",
"self",
".",
"_clone",
"(",
")",
"queryset",
".",
"_db",
"=",
"_db",
"return",
"queryset"
] | Executes query in provided db client.
Useful for transactions workaround. | [
"Executes",
"query",
"in",
"provided",
"db",
"client",
".",
"Useful",
"for",
"transactions",
"workaround",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/queryset.py#L415-L422 |
245,709 | tortoise/tortoise-orm | tortoise/models.py | Model._check_unique_together | def _check_unique_together(cls):
"""Check the value of "unique_together" option."""
if cls._meta.unique_together is None:
return
if not isinstance(cls._meta.unique_together, (tuple, list)):
raise ConfigurationError(
"'{}.unique_together' must be a list or tuple.".format(cls.__name__)
)
elif any(
not isinstance(unique_fields, (tuple, list))
for unique_fields in cls._meta.unique_together
):
raise ConfigurationError(
"All '{}.unique_together' elements must be lists or tuples.".format(cls.__name__)
)
else:
for fields_tuple in cls._meta.unique_together:
for field_name in fields_tuple:
field = cls._meta.fields_map.get(field_name)
if not field:
raise ConfigurationError(
"'{}.unique_together' has no '{}' "
"field.".format(cls.__name__, field_name)
)
if isinstance(field, ManyToManyField):
raise ConfigurationError(
"'{}.unique_together' '{}' field refers "
"to ManyToMany field.".format(cls.__name__, field_name)
) | python | def _check_unique_together(cls):
if cls._meta.unique_together is None:
return
if not isinstance(cls._meta.unique_together, (tuple, list)):
raise ConfigurationError(
"'{}.unique_together' must be a list or tuple.".format(cls.__name__)
)
elif any(
not isinstance(unique_fields, (tuple, list))
for unique_fields in cls._meta.unique_together
):
raise ConfigurationError(
"All '{}.unique_together' elements must be lists or tuples.".format(cls.__name__)
)
else:
for fields_tuple in cls._meta.unique_together:
for field_name in fields_tuple:
field = cls._meta.fields_map.get(field_name)
if not field:
raise ConfigurationError(
"'{}.unique_together' has no '{}' "
"field.".format(cls.__name__, field_name)
)
if isinstance(field, ManyToManyField):
raise ConfigurationError(
"'{}.unique_together' '{}' field refers "
"to ManyToMany field.".format(cls.__name__, field_name)
) | [
"def",
"_check_unique_together",
"(",
"cls",
")",
":",
"if",
"cls",
".",
"_meta",
".",
"unique_together",
"is",
"None",
":",
"return",
"if",
"not",
"isinstance",
"(",
"cls",
".",
"_meta",
".",
"unique_together",
",",
"(",
"tuple",
",",
"list",
")",
")",
... | Check the value of "unique_together" option. | [
"Check",
"the",
"value",
"of",
"unique_together",
"option",
"."
] | 7d16457731905e19d4d06ccd5b4ea16d4a9447b2 | https://github.com/tortoise/tortoise-orm/blob/7d16457731905e19d4d06ccd5b4ea16d4a9447b2/tortoise/models.py#L324-L357 |
245,710 | aerkalov/ebooklib | ebooklib/epub.py | write_epub | def write_epub(name, book, options=None):
"""
Creates epub file with the content defined in EpubBook.
>>> ebooklib.write_epub('book.epub', book)
:Args:
- name: file name for the output file
- book: instance of EpubBook
- options: extra opions as dictionary (optional)
"""
epub = EpubWriter(name, book, options)
epub.process()
try:
epub.write()
except IOError:
pass | python | def write_epub(name, book, options=None):
epub = EpubWriter(name, book, options)
epub.process()
try:
epub.write()
except IOError:
pass | [
"def",
"write_epub",
"(",
"name",
",",
"book",
",",
"options",
"=",
"None",
")",
":",
"epub",
"=",
"EpubWriter",
"(",
"name",
",",
"book",
",",
"options",
")",
"epub",
".",
"process",
"(",
")",
"try",
":",
"epub",
".",
"write",
"(",
")",
"except",
... | Creates epub file with the content defined in EpubBook.
>>> ebooklib.write_epub('book.epub', book)
:Args:
- name: file name for the output file
- book: instance of EpubBook
- options: extra opions as dictionary (optional) | [
"Creates",
"epub",
"file",
"with",
"the",
"content",
"defined",
"in",
"EpubBook",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L1705-L1723 |
245,711 | aerkalov/ebooklib | ebooklib/epub.py | read_epub | def read_epub(name, options=None):
"""
Creates new instance of EpubBook with the content defined in the input file.
>>> book = ebooklib.read_epub('book.epub')
:Args:
- name: full path to the input file
- options: extra options as dictionary (optional)
:Returns:
Instance of EpubBook.
"""
reader = EpubReader(name, options)
book = reader.load()
reader.process()
return book | python | def read_epub(name, options=None):
reader = EpubReader(name, options)
book = reader.load()
reader.process()
return book | [
"def",
"read_epub",
"(",
"name",
",",
"options",
"=",
"None",
")",
":",
"reader",
"=",
"EpubReader",
"(",
"name",
",",
"options",
")",
"book",
"=",
"reader",
".",
"load",
"(",
")",
"reader",
".",
"process",
"(",
")",
"return",
"book"
] | Creates new instance of EpubBook with the content defined in the input file.
>>> book = ebooklib.read_epub('book.epub')
:Args:
- name: full path to the input file
- options: extra options as dictionary (optional)
:Returns:
Instance of EpubBook. | [
"Creates",
"new",
"instance",
"of",
"EpubBook",
"with",
"the",
"content",
"defined",
"in",
"the",
"input",
"file",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L1728-L1746 |
245,712 | aerkalov/ebooklib | ebooklib/epub.py | EpubItem.get_type | def get_type(self):
"""
Guess type according to the file extension. Might not be the best way how to do it, but it works for now.
Items can be of type:
- ITEM_UNKNOWN = 0
- ITEM_IMAGE = 1
- ITEM_STYLE = 2
- ITEM_SCRIPT = 3
- ITEM_NAVIGATION = 4
- ITEM_VECTOR = 5
- ITEM_FONT = 6
- ITEM_VIDEO = 7
- ITEM_AUDIO = 8
- ITEM_DOCUMENT = 9
- ITEM_COVER = 10
We map type according to the extensions which are defined in ebooklib.EXTENSIONS.
:Returns:
Returns type of the item as number.
"""
_, ext = zip_path.splitext(self.get_name())
ext = ext.lower()
for uid, ext_list in six.iteritems(ebooklib.EXTENSIONS):
if ext in ext_list:
return uid
return ebooklib.ITEM_UNKNOWN | python | def get_type(self):
_, ext = zip_path.splitext(self.get_name())
ext = ext.lower()
for uid, ext_list in six.iteritems(ebooklib.EXTENSIONS):
if ext in ext_list:
return uid
return ebooklib.ITEM_UNKNOWN | [
"def",
"get_type",
"(",
"self",
")",
":",
"_",
",",
"ext",
"=",
"zip_path",
".",
"splitext",
"(",
"self",
".",
"get_name",
"(",
")",
")",
"ext",
"=",
"ext",
".",
"lower",
"(",
")",
"for",
"uid",
",",
"ext_list",
"in",
"six",
".",
"iteritems",
"("... | Guess type according to the file extension. Might not be the best way how to do it, but it works for now.
Items can be of type:
- ITEM_UNKNOWN = 0
- ITEM_IMAGE = 1
- ITEM_STYLE = 2
- ITEM_SCRIPT = 3
- ITEM_NAVIGATION = 4
- ITEM_VECTOR = 5
- ITEM_FONT = 6
- ITEM_VIDEO = 7
- ITEM_AUDIO = 8
- ITEM_DOCUMENT = 9
- ITEM_COVER = 10
We map type according to the extensions which are defined in ebooklib.EXTENSIONS.
:Returns:
Returns type of the item as number. | [
"Guess",
"type",
"according",
"to",
"the",
"file",
"extension",
".",
"Might",
"not",
"be",
"the",
"best",
"way",
"how",
"to",
"do",
"it",
"but",
"it",
"works",
"for",
"now",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L158-L187 |
245,713 | aerkalov/ebooklib | ebooklib/epub.py | EpubHtml.add_link | def add_link(self, **kwgs):
"""
Add additional link to the document. Links will be embeded only inside of this document.
>>> add_link(href='styles.css', rel='stylesheet', type='text/css')
"""
self.links.append(kwgs)
if kwgs.get('type') == 'text/javascript':
if 'scripted' not in self.properties:
self.properties.append('scripted') | python | def add_link(self, **kwgs):
self.links.append(kwgs)
if kwgs.get('type') == 'text/javascript':
if 'scripted' not in self.properties:
self.properties.append('scripted') | [
"def",
"add_link",
"(",
"self",
",",
"*",
"*",
"kwgs",
")",
":",
"self",
".",
"links",
".",
"append",
"(",
"kwgs",
")",
"if",
"kwgs",
".",
"get",
"(",
"'type'",
")",
"==",
"'text/javascript'",
":",
"if",
"'scripted'",
"not",
"in",
"self",
".",
"pro... | Add additional link to the document. Links will be embeded only inside of this document.
>>> add_link(href='styles.css', rel='stylesheet', type='text/css') | [
"Add",
"additional",
"link",
"to",
"the",
"document",
".",
"Links",
"will",
"be",
"embeded",
"only",
"inside",
"of",
"this",
"document",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L299-L308 |
245,714 | aerkalov/ebooklib | ebooklib/epub.py | EpubHtml.get_links_of_type | def get_links_of_type(self, link_type):
"""
Returns list of additional links of specific type.
:Returns:
As tuple returns list of links.
"""
return (link for link in self.links if link.get('type', '') == link_type) | python | def get_links_of_type(self, link_type):
return (link for link in self.links if link.get('type', '') == link_type) | [
"def",
"get_links_of_type",
"(",
"self",
",",
"link_type",
")",
":",
"return",
"(",
"link",
"for",
"link",
"in",
"self",
".",
"links",
"if",
"link",
".",
"get",
"(",
"'type'",
",",
"''",
")",
"==",
"link_type",
")"
] | Returns list of additional links of specific type.
:Returns:
As tuple returns list of links. | [
"Returns",
"list",
"of",
"additional",
"links",
"of",
"specific",
"type",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L319-L326 |
245,715 | aerkalov/ebooklib | ebooklib/epub.py | EpubHtml.add_item | def add_item(self, item):
"""
Add other item to this document. It will create additional links according to the item type.
:Args:
- item: item we want to add defined as instance of EpubItem
"""
if item.get_type() == ebooklib.ITEM_STYLE:
self.add_link(href=item.get_name(), rel='stylesheet', type='text/css')
if item.get_type() == ebooklib.ITEM_SCRIPT:
self.add_link(src=item.get_name(), type='text/javascript') | python | def add_item(self, item):
if item.get_type() == ebooklib.ITEM_STYLE:
self.add_link(href=item.get_name(), rel='stylesheet', type='text/css')
if item.get_type() == ebooklib.ITEM_SCRIPT:
self.add_link(src=item.get_name(), type='text/javascript') | [
"def",
"add_item",
"(",
"self",
",",
"item",
")",
":",
"if",
"item",
".",
"get_type",
"(",
")",
"==",
"ebooklib",
".",
"ITEM_STYLE",
":",
"self",
".",
"add_link",
"(",
"href",
"=",
"item",
".",
"get_name",
"(",
")",
",",
"rel",
"=",
"'stylesheet'",
... | Add other item to this document. It will create additional links according to the item type.
:Args:
- item: item we want to add defined as instance of EpubItem | [
"Add",
"other",
"item",
"to",
"this",
"document",
".",
"It",
"will",
"create",
"additional",
"links",
"according",
"to",
"the",
"item",
"type",
"."
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L328-L339 |
245,716 | 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",
".",
... | 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 |
245,717 | 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):
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 |
245,718 | 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):
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 |
245,719 | 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):
# 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",
"... | 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 |
245,720 | 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",
... | Add author for this document | [
"Add",
"author",
"for",
"this",
"document"
] | 305f2dd7f02923ffabf9586a5d16266113d00c4a | https://github.com/aerkalov/ebooklib/blob/305f2dd7f02923ffabf9586a5d16266113d00c4a/ebooklib/epub.py#L660-L672 |
245,721 | 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):
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_... | 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 |
245,722 | 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):
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 |
245,723 | 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):
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 |
245,724 | 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):
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 |
245,725 | 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):
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 |
245,726 | 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():
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",
"... | 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 |
245,727 | 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):
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",
",",
... | 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 |
245,728 | 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):
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",
",",
"[",
"]",
"#... | 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 |
245,729 | 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):
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",
... | 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 |
245,730 | 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):
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\"",
":",... | 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 |
245,731 | 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):
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"... | 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 |
245,732 | 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):
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",
... | 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",
"pa... | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L582-L600 |
245,733 | 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):
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'",
")",
".",
"deco... | 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",
"... | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/fixes.py#L642-L664 |
245,734 | 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=' '):
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",
"=",
"m... | 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",
"... | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/formatting.py#L67-L98 |
245,735 | 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=' '):
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",
"=",
"... | 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",
... | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/formatting.py#L130-L154 |
245,736 | 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):
# 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",
... | 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 |
245,737 | 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():
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, bu... | 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 |
245,738 | 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):
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",
")",
")",
")",
"adjustme... | 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 |
245,739 | 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):
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... | 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"... | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/bad_codecs/__init__.py#L47-L76 |
245,740 | 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):
# 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... | 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 |
245,741 | 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):
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 ... | 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 |
245,742 | 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",
... | 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 |
245,743 | 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'):
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",
... | 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 |
245,744 | 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'):
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_qu... | 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",
"a... | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/__init__.py#L244-L296 |
245,745 | 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):
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",... | 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 |
245,746 | 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():
# 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 charact... | 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",
"... | 476acc6ad270bffe07f97d4f7cf2139acdc69633 | https://github.com/LuminosoInsight/python-ftfy/blob/476acc6ad270bffe07f97d4f7cf2139acdc69633/ftfy/chardata.py#L25-L49 |
245,747 | 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():
# 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",
... | 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 |
245,748 | 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):
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'",
","... | 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 |
245,749 | 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():
# 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 ... | 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",
"num... | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/utils.py#L100-L145 |
245,750 | 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():
# 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",
"... | 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 |
245,751 | 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):
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",
")",
"==",
"l... | 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",
... | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/bench/multidim.py#L28-L57 |
245,752 | 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):
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 |
245,753 | 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):
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... | 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 |
245,754 | 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):
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",
... | 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 |
245,755 | 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):
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",
")",
"# f... | 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 |
245,756 | 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):
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",
"=",
... | 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 |
245,757 | 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):
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",
"=",... | 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 |
245,758 | 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):
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 |
245,759 | 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):
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",
".... | Common subexpression elimination. | [
"Common",
"subexpression",
"elimination",
"."
] | 364bac13d84524e0e01db892301b2959d822dcff | https://github.com/pydata/numexpr/blob/364bac13d84524e0e01db892301b2959d822dcff/numexpr/necompiler.py#L387-L406 |
245,760 | 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):
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",
",",
"s... | 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 |
245,761 | 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):
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 |
245,762 | 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):
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",
"==",
"'al... | 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 |
245,763 | 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):
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",
"... | 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 |
245,764 | 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):
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... | 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 |
245,765 | 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={}):
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",
"]",
... | 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 |
245,766 | 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):
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",
"... | 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 |
245,767 | 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):
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"... | 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 |
245,768 | 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):
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"... | 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 |
245,769 | 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):
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",
"=",
"_num... | 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 |
245,770 | 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():
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 |
245,771 | 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):
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... | 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 |
245,772 | 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):
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_... | Returns the column correlations. | [
"Returns",
"the",
"column",
"correlations",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/mfa.py#L192-L205 |
245,773 | 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):
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 |
245,774 | 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):
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 |
245,775 | 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):
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",
"... | The row principal coordinates. | [
"The",
"row",
"principal",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L93-L116 |
245,776 | 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):
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",
... | The column principal coordinates. | [
"The",
"column",
"principal",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L118-L141 |
245,777 | 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):
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",
"=",
"Tru... | Plot the principal coordinates. | [
"Plot",
"the",
"principal",
"coordinates",
"."
] | 714c9cdfc4d9f8823eabf550a23ad01fe87c50d7 | https://github.com/MaxHalford/prince/blob/714c9cdfc4d9f8823eabf550a23ad01fe87c50d7/prince/ca.py#L143-L199 |
245,778 | 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):
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"... | 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 |
245,779 | 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):
# 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",
"==",
"'... | 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 |
245,780 | 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):
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_",
... | 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 |
245,781 | 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):
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",
")",
")",
... | 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 |
245,782 | 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):
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",
")",
":",
... | 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 |
245,783 | 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):
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",
... | 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 |
245,784 | 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):
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",
".",... | 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 |
245,785 | 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):
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",
",",
"m... | 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 |
245,786 | 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):
# 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",
".",
... | 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 |
245,787 | 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):
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",
","... | 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 |
245,788 | 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):
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",
... | 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 |
245,789 | 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):
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... | 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 |
245,790 | 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):
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",
... | 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 |
245,791 | 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):
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 |
245,792 | 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):
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 |
245,793 | 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):
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",
",",
... | 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 |
245,794 | 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):
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",... | width in pixels | [
"width",
"in",
"pixels"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L282-L305 |
245,795 | 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):
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... | height in pixels | [
"height",
"in",
"pixels"
] | ca5254eff53172796ddafc72226c394ed1858245 | https://github.com/projecthamster/hamster/blob/ca5254eff53172796ddafc72226c394ed1858245/src/hamster/lib/layout.py#L308-L318 |
245,796 | 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):
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",
"."... | 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 |
245,797 | 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):
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",
... | 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 |
245,798 | 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):
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... | 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 |
245,799 | 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):
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",
"(",
")",
"... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.