mirror of
https://github.com/ManimCommunity/manim.git
synced 2026-06-29 10:02:11 +00:00
1cd24892e5* Create crowdin.yml
* try fix yml
* Move files
* Revert "Move files"
This reverts commit 8d53826ae0.
* Update crowdin.yml
* [pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
* Changed to locale with underscore
* Changing folder for .pot files. And removing the useless sphinx-intl part.
* Updated .gitignore and crowdin configuration to follow the directory change.
* Renaming po to pot EFFECTIVELY
* Changed the file with the new (simpler) generation. Also added better display for `make i18n`
* [pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
* Change to two letters code
* Correct extension
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Mysaa <samy.avrillon@ens-lyon.fr>
Co-authored-by: Mysaa <mysaa@myssian.home>
129 lines
7.4 KiB
Text
129 lines
7.4 KiB
Text
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Manim \n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../../source/contributing/references.rst:3
|
||
msgid "Adding References"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:6
|
||
msgid "Reference to types in documentation"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:8
|
||
msgid "Always specify types with the correct **role** (see https://www.sphinx-doc.org/en/1.7/domains.html#python-roles) for the sake of proper rendering. E.g.: Use ``:class:`int``` to refer to an int type, and in general ``:class:`<path>``` to refer to a certain class (see ``Path specification`` below). See after for more specific instructions."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:16
|
||
msgid "Path specifications"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:18
|
||
msgid "If it's on stdlib: Use ``<name>`` directly. If it's a class, just the name is enough. If it's a method (``:meth:``) or attribute (``:attr:``), dotted names may be used (e.g. ``:meth:`str.to_lower```)."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:23
|
||
msgid "Example: ``:class:`int```, ``:class:`str```, ``:class:`float```, ``:class:`bool```"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:26
|
||
msgid "If it's on the same file as the docstring or, for methods and attributes, under the same class, then the name may also be specified directly."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:30
|
||
msgid "Example: ``:class:`MyClass``` referring to a class in the same file; ``:meth:`push``` referring to a method in the same class; ``:meth:`MyClass.push``` referring to a method in a different class in the same file; ``:attr:`color``` referring to an attribute in the same class; ``:attr:`MyClass.color``` referring to an attribute in a different class in the same file."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:37
|
||
msgid "If it's on a different file, then you may either use the full dotted name (e.g. ``~manim.animations.Animation``) or simply use the shortened way (``~.Animation``). Note that, if there is ambiguity, then the full dotted name must be used where the actual class can't be deduced. Also, note the ``~`` before the path - this is so that it displays just ``Animation`` instead of the full location in the rendering. It can be removed for disambiguation purposes only."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:45
|
||
msgid "Example: ``:class:`~.Animation```, ``:meth:`~.VMobject.set_color```, ``:attr:`~.VMobject.color```"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:48
|
||
msgid "If it's a class from a different module, specify the full dotted syntax."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:51
|
||
msgid "Example: ``:class:`numpy.ndarray``` for a numpy ndarray."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:54
|
||
msgid "Reference type specifications"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:56
|
||
msgid "**The following instructions refer to types of attributes, parameters, and return values.** When specifying a type mid-text, it does not necessarily have to be typeset. However, if it's a class name, a method, or an enum's attribute/variant, then it is recommended to be typeset at least on the first occurrence of the name so that the users can quickly jump to the related documentation."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:63
|
||
msgid "Class names should be wrapped in ``:class:`path_goes_here```. See examples in the subsection above."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:65
|
||
msgid "Method names should be wrapped in ``:meth:`path_goes_here```. See examples in the subsection above."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:67
|
||
msgid "Attribute names should be wrapped in ``:attr:`path_goes_here```. See examples in the subsection above."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:69
|
||
msgid "If ``None`` can also be specified, use ``Optional[type]``, where ``type`` must follow the guidelines in the current section."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:72
|
||
msgid "Example: ``Optional[:class:`str`]`` means you can either specify a ``str`` or ``None``."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:75
|
||
msgid "If more than one type is possible, use ``Union[type_1, type_2, (...), type_n]``, where all the ``type_n`` must follow the guidelines in the current section. Note that, if one of these types is ``None``, then the Union should be wrapped with ``Optional`` instead."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:81
|
||
msgid "Example: ``Union[:class:`str`, :class:`int`]`` for either ``str`` or ``int``. ``Optional[Union[:class:`int`, :class:`bool`]]`` for either ``int``, ``bool`` or ``None``."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:85
|
||
msgid "**Dictionaries:** Use ``Dict[key_type, value_type]``, where ``key_type`` and ``value_type`` must follow the guidelines in the current section."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:89
|
||
msgid "Example: ``Dict[:class:`str`, :class:`~.Mobject`]`` is a dictionary that maps strings to Mobjects. ``Dict[:class:`str`, Union[:class:`int`, :class:`MyClass`]]`` is a dictionary that maps a string to either an int or an instance of ``MyClass``."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:95
|
||
msgid "**If the parameter is a list:** Note that it is very rare to require the parameter to be exactly a ``list`` type. One could usually specify a ``tuple`` instead, for example. So, in order to cover all cases, consider:"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:100
|
||
msgid "If the parameter only needs to be an ``Iterable``, i.e., if the function only requires being able to iterate over this parameter's value (e.g. can be a ``list``, ``tuple``, ``str``, but also ``zip()``, ``iter()`` and so on), then specify ``Iterable[type_here]``, where ``type_here`` is the type of the iterable's yielded elements and should follow the format in the present section (``Type specifications``)."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:108
|
||
msgid "Example: ``Iterable[:class:`str`]`` for any iterable of strings; ``Iterable[:class:`~.Mobject`]`` for an iterable of Mobjects; etc."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:111
|
||
msgid "If you require being able to index the parameter (i.e. ``x[n]``) or retrieve its length (i.e. ``len(x)``), or even just pass it to a function that requires any of those, then specify ``Sequence``, which allows any list-like object to be specified (e.g. ``list``, ``tuple``...)"
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:117
|
||
msgid "Example: ``Sequence[:class:`str`]`` for a sequence of strings; ``Sequence[Union[:class:`str`, :class:`int`]]`` for a sequence of integers or strings."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:121
|
||
msgid "If you EXPLICITLY REQUIRE it to be a ``list`` for some reason, then use ``List[type]``, where ``type`` is the type that any element in the list will have. It must follow the guidelines in the current section."
|
||
msgstr ""
|
||
|
||
#: ../../source/contributing/references.rst:126
|
||
msgid "**If the return type is a list or tuple:** Specify ``List[type]`` for a list, ``Tuple[type_a, type_b, (...), type_n]`` for a tuple (if the elements are all different) or ``Tuple[type, ...]`` (if all elements have the same type). Each ``type_n`` on those representations corresponds to elements in the returned list/tuple and must follow the guidelines in the current section."
|
||
msgstr ""
|
||
|
||
|