weeheavy/pelican-theme
1
0
Fork 0
forked from github/pelican
Code Pull requests Activity

Translate documentation into Simplified Chinese (#3346)

Browse source
This commit is contained in:
GeorgeHu 2024-09-15 20:29:01 +08:00 • committed by GitHub
commit e609b4d78a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 10274 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

3
docs/conf.py
View file

@ -19,6 +19,9 @@ with open("../pyproject.toml", "rb") as f:
# -- General configuration ---------------------------------------------------- # -- General configuration ----------------------------------------------------
templates_path = ["_templates"] templates_path = ["_templates"]
locale_dirs = ["locale/"]
gettext_compact = False
gettext_uuid = True
extensions = [ extensions = [
"sphinx.ext.autodoc", "sphinx.ext.autodoc",
"sphinx.ext.extlinks", "sphinx.ext.extlinks",

1669
docs/locale/zh_CN/LC_MESSAGES/changelog.po Normal file
View file

File diff suppressed because it is too large Load diff

1074
docs/locale/zh_CN/LC_MESSAGES/content.po Normal file
View file

File diff suppressed because it is too large Load diff

731
docs/locale/zh_CN/LC_MESSAGES/contribute.po Normal file
View file

@ -0,0 +1,731 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-25 20:36+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../contribute.rst:2 e8f9694c47aa44e7944dae800ee528f3
msgid "Contributing and feedback guidelines"
msgstr "项目贡献与意见反馈"
#: ../../contribute.rst:4 784f37182e78474b960306a5a794ae16
msgid ""
"There are many ways to contribute to Pelican. You can improve the "
"documentation, add missing features, and fix bugs (or just report them). "
"You can also help out by reviewing and commenting on `existing issues "
"<https://github.com/getpelican/pelican/issues>`_."
msgstr ""
"有很多渠道可以参与到贡献项目中来，例如帮助改进文档、添加缺失的特性、修复与报告bug。"
"可以从查看 `已有 issues <https://github.com/getpelican/pelican/issues>`_ 开始。"
#: ../../contribute.rst:9 e17c3ff0fa71469cbe22cb4ad2640ad8
msgid ""
"Don't hesitate to fork Pelican and submit an issue or pull request on "
"GitHub. When doing so, please consider the following guidelines."
msgstr ""
"随时随地都可以fork Pelican或是在GitHub上提交issue或PR。"
#: ../../../CONTRIBUTING.rst:2 f8bc69070fab4dd7be34e1cc6a42cc02
msgid "Filing issues"
msgstr "提出issue"
#: ../../../CONTRIBUTING.rst:4 fe98a059b9c24fcc92358f2c4505174d
msgid "Before you submit a new issue, try `asking for help`_ first."
msgstr "在你提交一个新的issue之前，可以先尝试 `请求他人帮助`_ 。"
#: ../../../CONTRIBUTING.rst:5 e9fff7c354614ae28db994c0fcc121c0
msgid ""
"If determined to create a new issue, first search `Pelican Discussions`_ "
"and `existing issues`_ (open and closed) to see if your question has "
"already been answered previously."
msgstr ""
"当你决定要提出新的issue时，先在 `Pelican的讨论版`_ 和 `已有issues`_ 中搜索一下，"
"（开放关闭的issue都搜一下），来看看你的问题是不是有人之前已经提出过。"
#: ../../../CONTRIBUTING.rst:14 84cb74beed564f31810674cacf5c1f97
msgid "How to get help"
msgstr "如何获取帮助"
#: ../../../CONTRIBUTING.rst:16 0557a84947c14606be4fd0565247d85d
msgid "Before you ask for help, please make sure you do the following:"
msgstr "在寻求帮助之前，请先尝试如下步骤："
#: ../../../CONTRIBUTING.rst:18 6d59a3356e734dd196ec8a0739556b4c
msgid ""
"Read the documentation_ thoroughly. If in a hurry, at least use the "
"search field that is provided at top-left on the documentation_ pages. "
"Make sure you read the docs for the Pelican version you are using."
msgstr ""
"完整阅读 documentation_ 。如果你很急，至少先在 documentation_ 左上角的搜索栏"
"中尝试搜索。确保你阅读的文档和使用的Pelican版本相匹配。"
#: ../../../CONTRIBUTING.rst:21 4b33299936404cf98a66b672fad0e38f
msgid ""
"Use a search engine (e.g., DuckDuckGo, Google) to search for a solution "
"to your problem. Someone may have already found a solution, perhaps in "
"the form of a ':pelican-doc:`plugins` or a specific combination of "
"settings."
msgstr ""
"使用搜索引擎（例如 DuckDuckGo、Google）搜索遇到问题的解决方案。互联网上可能"
"已经有人遇到过相同的问题，解决方法可能包括使用某些 :pelican-doc:`plugins` 或配置"
"一系列的设置选项。"
#: ../../../CONTRIBUTING.rst:25 b48195d9ef674566b89aabc38139c301
msgid "Try reproducing the issue in a clean environment, ensuring you are using:"
msgstr "尝试在一个尽可能简单的环境中重现问题，并确保以下几点："
#: ../../../CONTRIBUTING.rst:27 685d2888d2c94ea9a752ec433f8b9f1f
msgid ""
"latest Pelican release (or an up-to-date Git clone of Pelican ``main`` "
"branch)"
msgstr "使用最新版本的Pelican（或是用Git克隆Pelican的main分支）"
#: ../../../CONTRIBUTING.rst:28 910a372d95d8448492eafc66eccd1ccf
msgid "latest releases of libraries used by Pelican"
msgstr "将Pelican使用的库升级到最新版本"
#: ../../../CONTRIBUTING.rst:29 c44f4dc6b05d4be29eccc889f042702c
msgid "no plugins or only those related to the issue"
msgstr "此环境中没有使用插件或是只使用和问题相关的插件"
#: ../../../CONTRIBUTING.rst:31 3abdf6131cf4412a8205b634a6651b01
msgid ""
"**NOTE:** The most common sources of problems are anomalies in (1) "
"themes, (2) plugins, (3) settings files, and (4) ``make``/``invoke`` "
"automation wrappers. If you can't reproduce your problem when using the "
"following steps to generate your site, then the problem is almost "
"certainly with one of the above-listed elements (and not Pelican "
"itself)::"
msgstr ""
"**注意：** 最常见的问题基本上都产生于主题、插件、设置文件和自动化工具 "
"``make``/``invoke`` 中。如果按照下述步骤生成站点后无法复现之前的问题，那么"
"几乎可以肯定问题出在这四个地方，而不在Pelican本身："
#: ../../../CONTRIBUTING.rst:41 f2331ea165ac4a3c8e70bf98c995f0e8
msgid ""
"If you can generate your site without problems using the steps above, "
"then your problem is unlikely to be caused by Pelican itself, and "
"therefore please consider reaching out to the maintainers of the "
"plugins/theme you are using instead of raising the topic with the Pelican"
" core community."
msgstr ""
"如果按照上述步骤能够正常生成站点，那么你的问题不太可能是由Pelican本身导致的，"
"请考虑联系对应插件/主题的维护者，而不是在Pelican内核的社区中提出问题。"
#: ../../../CONTRIBUTING.rst:46 d83b0036d4894f3ebc73e657a203d11a
msgid ""
"If despite the above efforts you still cannot resolve your problem, be "
"sure to include in your inquiry the following information, preferably in "
"the form of links to content uploaded to a `paste service`_, GitHub "
"repository, or other publicly-accessible location:"
msgstr ""
"经过上面这些努力，若您仍无法解决问题，确保你的提问中包括如下信息，可以以 "
"`paste service`_ 链接、GitHub仓库，或者其他可公开获取的形式提供："
#: ../../../CONTRIBUTING.rst:51 4281f931e9064336b267bd67a35134e9
msgid ""
"Describe what version of Pelican you are running (output of ``pelican "
"--version`` or the HEAD commit hash if you cloned the repo) and how "
"exactly you installed it (the full command you used, e.g. ``python -m pip"
" install pelican``)."
msgstr ""
"描述正在运行的Pelican版本信息（可以通过 ``pelican --version`` 命令得到，如果"
"clone的源仓库则可以查看HEAD commit的哈希值），以及你是如何安装Pelican的"
"（要包括使用到的命令，例如 ``python -m pip install pelican``）"
#: ../../../CONTRIBUTING.rst:54 b1303c98bca840efb895aceb16789eb9
msgid ""
"If you are looking for a way to get some end result, prepare a detailed "
"description of what the end result should look like (preferably in the "
"form of an image or a mock-up page) and explain in detail what you have "
"done so far to achieve it."
msgstr ""
"如果你希望产生某种特定的最终结果，请详细描述此最终结果是什么样的（最好以图片或者"
"伪页面的形式），，并且细致讲述你做了哪些尝试。"
#: ../../../CONTRIBUTING.rst:58 8fe972c4685140d5bd1c37f4635f6f09
msgid ""
"If you are trying to solve some issue, prepare a detailed description of "
"how to reproduce the problem. If the issue cannot be easily reproduced, "
"it cannot be debugged by developers or volunteers. Describe only the "
"**minimum steps** necessary to reproduce it (no extra plugins, etc.)."
msgstr ""
"如果你在尝试解决某些问题，请详细描述如何复现此问题。如果问题很难被复现，其他开发者和志愿者就很难进行调试。"
"尽量只写出复现该问题的 **最少步骤** （无额外插件）。"
#: ../../../CONTRIBUTING.rst:62 1f3874f308e64281b910dc716180ebcf
msgid ""
"Upload your settings file or any other custom code that would enable "
"people to reproduce the problem or to see what you have already tried to "
"achieve the desired end result."
msgstr ""
"上传你的配置文件以及所有自定义过的代码，这可以使得大家能够重现问题或者看到你已经"
"做出的尝试。"
#: ../../../CONTRIBUTING.rst:65 1fdc6c63f1b141c7a35233607ec0d922
msgid ""
"Upload detailed and **complete** output logs and backtraces (remember to "
"add the ``--debug`` flag: ``pelican --debug content [...]``)"
msgstr ""
"上传详细 **完整** 的输出日志以及backtraces信息（记得在执行pelican命令时加上 "
"``--debug`` 标记： ``pelican --debug content [...]`` ）"
#: ../../../CONTRIBUTING.rst:71 8741dba5da1a4990ae9c30531d05dc19
msgid ""
"Once the above preparation is ready, you can post your query as a new "
"thread in `Pelican Discussions`_. Remember to include all the information"
" you prepared."
msgstr ""
"一旦做好了上述准备，就可以在 `Pelican Discussions`_ 中发起你的问题了。记得在请求"
"中附上收集好的信息。"
#: ../../../CONTRIBUTING.rst:75 b34a3031f5d1427e92a9d1969d7b5274
msgid "Contributing code"
msgstr "贡献代码"
#: ../../../CONTRIBUTING.rst:77 e29672c736554ebbbd6efd441af19df7
msgid ""
"Before you submit a contribution, please ask whether it is desired so "
"that you don't spend a lot of time working on something that would be "
"rejected for a known reason. Consider also whether your new feature might"
" be better suited as a ':pelican-doc:`plugins` — you can `ask for help`_"
" to make that determination."
msgstr ""
"在提交代码修改前，请先询问是否需要此修改，以免你做的工作因为已知原因而被拒绝。"
"想想要添加的新特性是否更适合以 :pelican-doc:`插件` 形式完成。可以通过 "
"`如何获取帮助`_ 来帮助你作出决定。"
#: ../../../CONTRIBUTING.rst:82 e263c09fb6e5471eb0c2c3e97994322d
msgid ""
"Also, if you intend to submit a pull request to address something for "
"which there is no existing issue, there is no need to create a new issue "
"and then immediately submit a pull request that closes it. You can submit"
" the pull request by itself."
msgstr ""
"另外，如果你的PR是为了解决一个目前没有在issue中出现过的问题，那么就没有必要先创建"
"一个新的issue，而是可以直接提起PR。"
#: ../../../CONTRIBUTING.rst:87 9b08ef3e5fe4474e9306e4bfe9662fff
msgid "Using Git and GitHub"
msgstr "使用Git与GitHub"
#: ../../../CONTRIBUTING.rst:89 7ad95f82b7d04c0ca97bb958d2425e27
msgid ""
"`Create a new branch`_ specific to your change (as opposed to making your"
" commits in the ``main`` branch)."
msgstr ""
"`创建一个新的分支`_ 来标记你做的修改（而不是直接在主分支中提交）。"
#: ../../../CONTRIBUTING.rst:91 8a31c5d7ae4045cdbf2aa67e79be3f9c
msgid ""
"**Don't put multiple unrelated fixes/features in the same branch / pull "
"request.** For example, if you're working on a new feature and find a "
"bugfix that doesn't *require* your new feature, **make a new distinct "
"branch and pull request** for the bugfix. Similarly, any proposed changes"
" to code style formatting should be in a completely separate pull "
"request."
msgstr ""
"**不要把多个无关联的修复/特性修改放在同一个分支/拉去请求中。** 如果当你在做新特性的时候"
"发现了一个bug可以修复，但修复这个bug *不需要用到* 这个新特性， **那么请另外创建"
"一个分支并拉取请求。** 类似的，任何对代码风格的格式化都应该在单独的请求中拉取。"
#: ../../../CONTRIBUTING.rst:96 ef2e10f7ec5e4fbbb0f977dd09b7be49
msgid ""
"Add a ``RELEASE.md`` file in the root of the project that contains the "
"release type (major, minor, patch) and a summary of the changes that will"
" be used as the release changelog entry. For example::"
msgstr ""
"在项目根目录下添加 ``RELEASE.md`` 文件，在其中包含release的类型（主要、次要、补丁），"
"以及对项目改变的概述，这些内容会作为该release发布日志的一部分。下面是一个例子："
#: ../../../CONTRIBUTING.rst:104 24a4d63624f44f63a0ce809901455c02
msgid ""
"Check for unnecessary whitespace via ``git diff --check`` before "
"committing."
msgstr ""
"在提交前使用 ``git diff --check`` 来检查是否有无意义的空白字符。"
#: ../../../CONTRIBUTING.rst:105 11c5b82604fe4638bf9ee6e9ef0a401b
msgid ""
"First line of your commit message should start with present-tense verb, "
"be 50 characters or less, and include the relevant issue number(s) if "
"applicable. *Example:* ``Ensure proper PLUGIN_PATH behavior. Refs #428.``"
" If the commit *completely fixes* an existing bug report, please use "
"``Fixes #585`` or ``Fix #585`` syntax (so the relevant issue is "
"automatically closed upon PR merge)."
msgstr ""
"commit信息的第一行应该以现在时动词开头，并且第一行尽量保持在50字以下，并且包含相关联"
"issue的编号（如果有的话）。 例如： ``Ensure proper PLUGIN_PATH behavior. "
"Refs #428.`` 如果此项提交 *完全修复* 了某项已报告的bug，请使用例如 ``Fixes #585`` "
"或 ``Fix #585`` 的语法（这样的话相关的issue会在PR合并后自动关闭）。"
#: ../../../CONTRIBUTING.rst:110 0c1ff9d0738440e1bce853fc830278af
msgid ""
"After the first line of the commit message, add a blank line and then a "
"more detailed explanation (when relevant)."
msgstr ""
"在第一行commit信息后添加一行空白行，再进行更多相关的细节描述。"
#: ../../../CONTRIBUTING.rst:112 d817ad5d9e35488eb45d88828ee9f053
msgid ""
"`Squash your commits`_ to eliminate merge commits and ensure a clean and "
"readable commit history."
msgstr ""
"`压缩commit`_ 来消除合并commits，确保你的commit历史记录是干净可读的。"
#: ../../../CONTRIBUTING.rst:114 b7064f44923a499da3c3ce078470e269
msgid ""
"After you have issued a pull request, the continuous integration (CI) "
"system will run the test suite on all supported Python versions and check"
" for code style compliance. If any of these checks fail, you should fix "
"them. (If tests fail on the CI system but seem to pass locally, ensure "
"that local test runs aren't skipping any tests.)"
msgstr ""
"在你发出PR后，持续集成（CI）系统会在所有支持的Python版本上运行测试套件，并且"
"检查代码风格的合规性。如果出现了错误，你应该将其修复。（如果没有通过CI系统上的"
"测试但是本地测试通过了，请再检查一下，确保在本地进行了所有CI系统中的检查）"
#: ../../../CONTRIBUTING.rst:121 342f2e6c14b9441caaf3f9b6d2eb764b
msgid "Contribution quality standards"
msgstr "贡献的质量标准"
#: ../../../CONTRIBUTING.rst:123 842514f115634a5d821d48490d4aed7b
msgid ""
"Adhere to the project's code style standards. See: `Development "
"Environment`_"
msgstr ""
"遵循项目的代码风格标准。详见 `开发环境`_"
#: ../../../CONTRIBUTING.rst:124 4719590d89be4a5e94817902cc424be5
msgid ""
"Ensure your code is compatible with the `officially-supported Python "
"releases`_."
msgstr ""
"确保你的代码可以兼容 `python的官方发布版本`_"
#: ../../../CONTRIBUTING.rst:125 fa0ad5dd93e149fa8a12dd339bef9056
msgid ""
"Add docs and tests for your changes. Undocumented and untested features "
"will not be accepted."
msgstr ""
"请为你修改的内容添加文档与测试。未注有文档或没有对应测试的特性会被拒绝。"
#: ../../../CONTRIBUTING.rst:127 dc4db53c2ce34e5490a0c57ea800a4da
msgid ""
":pelican-doc:`Run all the tests <contribute>` **on all versions of Python"
" supported by Pelican** to ensure nothing was accidentally broken."
msgstr ""
"**在Pelican支持的所有Python版本上** :pelican-doc:`执行所有测试 <contribute>` ，"
"以确保没有意料之外的问题。"
#: ../../../CONTRIBUTING.rst:130 3a88c2e8326a4acd896d0ac75d4c9ccb
msgid ""
"Check out our `Git Tips`_ page or `ask for help`_ if you need assistance "
"or have any questions about these guidelines."
msgstr ""
"若需要帮助或对以上指南有任何疑惑，还可以查看我们的 `Git提示`_ 页面和 `请求帮助`_ 部分。"
#: ../../contribute.rst:15 daead9e8fb804eb6acd152b85d837182
msgid "Setting up the development environment"
msgstr "配置开发环境"
#: ../../contribute.rst:17 1ab6df98bcb141f49e278d153cc96e22
msgid ""
"While there are many ways to set up one's development environment, the "
"following instructions will utilize Pip_ and PDM_. These tools facilitate"
" managing virtual environments for separate Python projects that are "
"isolated from one another, so you can use different packages (and package"
" versions) for each."
msgstr ""
"在配置开发环境时往往有很多种方式，但下面的指南会使用 Pip_ 和 PDM_ 完成配置。这两个工具"
"都可以用于管理虚拟环境，使得不同的Python项目相互隔离，这样就可以很方便的在不同的项目中"
"使用不同的库（以及不同的库版本）。"
#: ../../contribute.rst:22 6a9c8f6ddb1d495f8a9bd1b8a131cabd
msgid "Please note that Python |min_python| is required for Pelican development."
msgstr "请注意，要进行Pelican的开发，至少需要Python |min_python|"
#: ../../contribute.rst:24 3d994e2a522141d7ada0a8fe13eb4c64
msgid ""
"*(Optional)* If you prefer to `install PDM "
"<https://pdm.fming.dev/latest/#installation>`_ once for use with multiple"
" projects, you can install it via::"
msgstr ""
"*（可选）* 若您想要 `安装PDM <https://pdm.fming.dev/latest/#installation>`_ ，"
"可以使用下面这条命令："
#: ../../contribute.rst:29 dbaa532c292048cb87926dd8b6e3141a
msgid ""
"Point your web browser to the `Pelican repository`_ and tap the **Fork** "
"button at top-right. Then clone the source for your fork and add the "
"upstream project as a Git remote::"
msgstr ""
"在Web浏览器中进入 `Pelican的代码仓库`_ ，点击右上角的 **Fork** 按钮。然后克隆"
"你自己的这份fork，最后添加项目的原仓库为远程仓库upstream："
#: ../../contribute.rst:38 adbe5d876f114645a3e1b489b2a34bd9
msgid ""
"While PDM can dynamically create and manage virtual environments, we're "
"going to manually create and activate a virtual environment::"
msgstr ""
"通过下面的命令可以手动创建并激活一个虚拟环境："
#: ../../contribute.rst:45 ../../contribute.rst:181
#: 6ede38ac05174bc19df4198e735342e0 f6d42cdd70384eaebbe115aefd0d01ec
msgid "Install the needed dependencies and set up the project::"
msgstr "安装必需的依赖并配置项目："
#: ../../contribute.rst:50 d863bf4dc76e4b18b933f2635a6a3af3
msgid "Your local environment should now be ready to go!"
msgstr "现在，你的本地开发环境就配置完成了！"
#: ../../contribute.rst:57 dc19edf71c914f48a953b379efa076c0
msgid "Development"
msgstr "开发"
#: ../../contribute.rst:59 6082eb5afbf14f86a031ed4f53d2943c
msgid ""
"Once Pelican has been set up for local development, create a topic branch"
" for your bug fix or feature::"
msgstr ""
"在配置好Pelican的本地开发环境后，请先为你的bug修复或特性增加创建一个分支："
#: ../../contribute.rst:64 1cafbaea6ec04597b62e871c0f0793b2
msgid ""
"Now you can make changes to Pelican, its documentation, and/or other "
"aspects of the project."
msgstr ""
"在切换到新建的分支后，就可以开始对Pelican的文档或其他内容做更改了。"
#: ../../contribute.rst:68 e0f5da1e216f499d86427e21c23557d4
msgid "Setting up ``git blame`` (optional)"
msgstr "配置 ``git blame`` （可选）"
#: ../../contribute.rst:70 2906e116c2dc4a2c8db78fa64820af56
msgid ""
"``git blame`` annotates lines in a file with information about the pull "
"request that last modified it. Sweeping shallow changes (like formatting)"
" can make that information less useful, so we keep a list of such changes"
" to be ignored. Run the following command to set this up in your "
"repository, adding ``--global`` if you want this setting to apply to all "
"repositories::"
msgstr ""
"``git blame`` 会在文件中的行上标注有关最后一次修改该行的PR信息。对浅层变化（如格式化）"
"进行批量更改可能会使这些信息变得不那么有用，因此我们维护一个包含此类更改的列表，"
"以便忽略它们。运行以下命令在您的存储库中设置此配置，如果希望此设置适用于所有存储库，"
"请添加 ``--global`` ："
#: ../../contribute.rst:78 36f257406a294713835841cf549e0f67
msgid ""
"As noted in a `useful article`_ about ``git blame``, there are other "
"related settings you may find to be beneficial::"
msgstr ""
"就像在 `这篇文章`_ 中提到的，还可以进行一些可能有用的额外设置："
#: ../../contribute.rst:89 37a3a813eeb84f408546bf6a83fdafd6
msgid "Running the test suite"
msgstr "运行测试套件"
#: ../../contribute.rst:91 44276ab045104e5c9ab3d2425172d7ac
msgid ""
"Each time you make changes to Pelican, there are two things to do "
"regarding tests: check that the existing tests pass, and add tests for "
"any new features or bug fixes. The tests are located in "
"``pelican/tests``, and you can run them via::"
msgstr ""
"每次对Pelican做出修改后，在测试方面需要做两个工作：检查是否能通过已有的测试、"
"为新增特性或bug修复创建测试。请将自动化测试文件放在 ``pelican/tests`` 中，"
"接着执行以下命令："
#: ../../contribute.rst:98 9557eb87ac4945ccbaf8775aa7768f6e
msgid ""
"(For more on Invoke, see ``invoke -l`` to list tasks, or "
"https://pyinvoke.org for documentation.)"
msgstr ""
"（执行 ``invoke -l`` 会列出可以调用的测试任务，关于此的更多文档请参阅 "
"https://pyinvoke.org ）"
#: ../../contribute.rst:101 d1cebbdf4fcf4be5b918613c5050d638
msgid ""
"In addition to running the test suite, it is important to also ensure "
"that any lines you changed conform to code style guidelines. You can "
"check that via::"
msgstr ""
"除了运行测试套件外，还要确保修改了的部分遵循代码风格指南。可以通过下面的命令"
"检查代码风格："
#: ../../contribute.rst:106 7a0b9ebf408f472aa786f6c3ac639240
msgid ""
"If code style violations are found in lines you changed, correct those "
"lines and re-run the above lint command until they have all been fixed. "
"You do not need to address style violations, if any, for code lines you "
"did not touch."
msgstr ""
"如果在修改过的代码中有地方违反了代码风格规范，请纠正并再次运行上述命令，直到全部纠正。"
"但是若是发现违反代码风格的地方并不是你修改的，请忽略之，不要进行纠正。"
#: ../../contribute.rst:110 74ec20f2daf74ad18cc083ad48b89dfe
msgid ""
"After making your changes and running the tests, you may see a test "
"failure mentioning that \"some generated files differ from the expected "
"functional tests output.\" If you have made changes that affect the HTML "
"output generated by Pelican, and the changes to that output are expected "
"and deemed correct given the nature of your changes, then you should "
"update the output used by the functional tests. To do so, **make sure you"
" have both** ``en_EN.utf8`` **and** ``fr_FR.utf8`` **locales installed**,"
" and then run the following command::"
msgstr ""
"在修改完代码，运行测试的过程中，你可能会看到测试失败中有提到“some generated files "
"differ from the expected functional tests output” 。这可能是由于你对代码的修改"
"影响到了Pelican的HTML输出，若输出的结果确实是你想要的，请更新功能测试所用的输出用例。"
"请确保你安装了 ``en_EN.utf8`` 和 ``fr_FR.utf8`` ，然后执行下述命令："
#: ../../contribute.rst:120 4299259dadd748238f9465eefb84727c
msgid ""
"You may also find that some tests are skipped because some dependency "
"(e.g., Pandoc) is not installed. This does not automatically mean that "
"these tests have passed; you should at least verify that any skipped "
"tests are not affected by your changes."
msgstr ""
"你还可能会发现有一些测试由于缺少依赖（例如 Pandoc）而被跳过。这并不意味着通过"
"了这些测试，请至少确保对代码的修改不会影响到这些被跳过的测试。"
#: ../../contribute.rst:125 a8835ccddf624fc1994c618ded8cc5ba
msgid ""
"You should run the test suite under each of the supported versions of "
"Python. This is best done by creating a separate Python environment for "
"each version. Tox_ is a useful tool to automate running tests inside "
"``virtualenv`` environments."
msgstr ""
"你应该在Pelican支持的所有Python版本下运行测试套件。一般会通过为每一个Python版本"
"创建一个虚拟环境来实现这一点。Tox_ 是一个用于在 ``virtualenv`` 环境中自动运行"
"测试的工具。"
#: ../../contribute.rst:133 b8b8c16b0d0743b98de5d759f79d07ba
msgid "Running a code coverage report"
msgstr "运行代码测试覆盖报告"
#: ../../contribute.rst:135 674a92a42d924931801c9f9c02463cd5
msgid ""
"Code is more likely to stay robust if it is tested. Coverage_ is a "
"library that measures how much of the code is tested. To run it::"
msgstr ""
"经过测试的代码往往具有更好的健壮性。 Coverage_ 是一个用于衡量代码测试覆盖率的库"
"执行下面的命令以调取之："
#: ../../contribute.rst:140 ecb5e7f9e83c4243ba04b58764e573b6
msgid ""
"This will show overall coverage, coverage per file, and even line-by-line"
" coverage. There is also an HTML report available::"
msgstr ""
"该命令会展示总体覆盖率以及在每个文件上的覆盖率，甚至还会展示每一行的覆盖情况。"
"同样也会有一份HTML格式的报告供您查看："
#: ../../contribute.rst:148 bad31d4cb0b644ac8ecb7885b22072a7
msgid "Building the docs"
msgstr "构建文档"
#: ../../contribute.rst:150 47e1f1caa594462d9b3b4403645abf3b
msgid ""
"If you make changes to the documentation, you should build and inspect "
"your changes before committing them::"
msgstr ""
"若你对文档进行过修改，请在commit前完成构建和检查："
#: ../../contribute.rst:155 a4961ae22c2c4de9bbc8bb98d3a3ec81
msgid ""
"Open http://localhost:8000 in your browser to review the documentation. "
"While the above task is running, any changes you make and save to the "
"documentation should automatically appear in the browser, as it live-"
"reloads when it detects changes to the documentation source files."
msgstr ""
"执行上述命令后，请在Web浏览器中打开 http://localhost:8000 来查看文档。"
"在上述命令执行时，对文档做的任何修改应该会自动反映在浏览器中。"
#: ../../contribute.rst:161 7740ec477ad747ebaa2dde2b2aef45d5
msgid "Plugin development"
msgstr "插件开发"
#: ../../contribute.rst:163 9505da5fcac24d718f59c797061d2b0f
msgid ""
"To create a *new* Pelican plugin, please refer to the `plugin template`_ "
"repository for detailed instructions."
msgstr ""
"要创建一个 *新的* Pelican插件，请参阅 `插件模板`_ 仓库以获得更为详细的指导。"
#: ../../contribute.rst:166 5fdae4611a6949b9a4c3bc82c52d3bc6
msgid ""
"If you want to contribute to an *existing* Pelican plugin, follow the "
"steps above to set up Pelican for local development, and then create a "
"directory to store cloned plugin repositories::"
msgstr ""
"若你想在 *已有* Pelican插件中做贡献，请先按前文所述步骤配置Pelican的本地开发环境，"
"然后创建一个文件夹来存放克隆下来的插件仓库："
#: ../../contribute.rst:172 0f50b12aaf3b4049999130a92fa6b670
msgid ""
"Assuming you wanted to contribute to the Simple Footnotes plugin, you "
"would first browse to the `Simple Footnotes`_ repository on GitHub and "
"tap the **Fork** button at top-right. Then clone the source for your fork"
" and add the upstream project as a Git remote::"
msgstr ""
"假设想要为Simple Footnotes插件做贡献，你应该先查看并fork `Simple Footnotes`_ "
"的Github仓库，然后克隆你自己fork的那一份，再添加原仓库作为Git远程仓库upstream："
#: ../../contribute.rst:185 2efe992372f149c3b63ca22016f8501b
msgid "Create a topic branch for your plugin bug fix or feature::"
msgstr "同样地，为你想要进行的bug修复或特性添加创建一个分支："
#: ../../contribute.rst:189 40f3c07d12cc4630bc75355c3449196d
msgid ""
"After writing new tests for your plugin changes, run the plugin test "
"suite and check for code style compliance via::"
msgstr ""
"完成修改并添加测试后，运行测试套件，并检查代码风格："
#: ../../contribute.rst:195 ba97ce962daa437cbcf2d09897394aed
msgid ""
"If style violations are found, many of them can be addressed "
"automatically via::"
msgstr ""
"若存在不合规范风格的代码，大多数情况下可以通过下述命令自动纠正："
#: ../../contribute.rst:199 a0ee1e11aaea4f5c8ba4c4704678bbaf
msgid ""
"If style violations are found even after running the above auto-"
"formatters, you will need to make additional manual changes until "
"``invoke lint`` no longer reports any code style violations."
msgstr ""
"如果在自动格式化后仍存在代码风格上的问题，请手动修正这些问题，直到执行 "
"``invoke lint`` 时不再报告问题。"
#: ../../contribute.rst:207 e9d1e344bb0d4b2fb9d08c2d71d9a342
msgid "Submitting your changes"
msgstr "提交更改"
#: ../../contribute.rst:209 716c9f94166d42299d9ee58eed4f9b53
msgid ""
"Assuming linting validation and tests pass, add a ``RELEASE.md`` file in "
"the root of the project that contains the release type (major, minor, "
"patch) and a summary of the changes that will be used as the release "
"changelog entry. For example::"
msgstr ""
"通过了风格检查和所有测试后，请在项目的根目录下添加一个 ``RELEASE.md`` 文件，"
"其中应包含发布的类型（major、minor、patch）以及代码变更的摘要，这份摘要会被用作"
"更新日志的条目。下面是一个例子："
#: ../../contribute.rst:218 656309283e5642b99981c84da9b04c86
msgid "Commit your changes and push your topic branch::"
msgstr "commit你的更改，并push对应分支："
#: ../../contribute.rst:224 16617b687db94783b5488884e4c9be1b
msgid ""
"Finally, browse to your repository fork on GitHub and submit a pull "
"request."
msgstr ""
"最后，前往Github，从你fork的仓库向原仓库提出PR。"
#: ../../contribute.rst:228 629ae326bd4e4718a8865d3925c02c3e
msgid "Logging tips"
msgstr "日志技巧"
#: ../../contribute.rst:230 486bb6ae6c484431923a96b7a7aff0c5
msgid "Try to use logging with appropriate levels."
msgstr "请仔细斟酌合适的日志等级。"
#: ../../contribute.rst:232 fbe2aed8f0f5412081461fce5d36e51e
msgid "For logging messages that are not repeated, use the usual Python way::"
msgstr "对于不重复的日志消息，使用一般的方式即可："
#: ../../contribute.rst:241 bab220240a0744f5b1170783098b5eac
#, python-format
msgid ""
"Do not format log messages yourself. Use ``%s`` formatting in messages "
"and pass arguments to logger. This is important, because the Pelican "
"logger will preprocess some arguments, such as exceptions."
msgstr ""
"请不要自己格式化日志消息，而是使用在日志消息中使用 ``%s`` 并向logger传入参数。请务必"
"遵循这一规则，因为Pelican的logger会自动预处理一些特殊的参数，例如exception。"
#: ../../contribute.rst:246 a760419565b8440ebc8b4dc8898520db
msgid "Limiting extraneous log messages"
msgstr "限制低关联日志消息"
#: ../../contribute.rst:248 dcf900d9f7d0424fabff4a9c5a7e5dc8
msgid ""
"If the log message can occur several times, you may want to limit the log"
" to prevent flooding. In order to do that, use the ``extra`` keyword "
"argument for the logging message in the following format::"
msgstr ""
"如果同一日志消息会重复多次，你会希望限制这些多余的内容。使用 ``extra`` "
"命名参数来实现这一点："
#: ../../contribute.rst:255 1ca7d769fc9348f8a5f9eef7b614522b
msgid ""
"Optionally, you can also set ``'limit_args'`` as a tuple of arguments in "
"``extra`` dict if your generic message needs formatting."
msgstr ""
"可选的，如果通用日志消息需要格式化，可以添加 ``'limit_args'`` 参数并将其对应值"
"设为一个元组。"
#: ../../contribute.rst:258 85328a267c464f9aaacb1b0ef289d624
msgid ""
"Limit is set to ``5``, i.e, first four logs with the same ``'limit_msg'``"
" are outputted normally but the fifth one will be logged using "
"``'limit_msg'`` (and ``'limit_args'`` if present). After the fifth, "
"corresponding log messages will be ignored."
msgstr ""
"限制数默认设为了 ``5`` ，即前四个有相同 ``'limit_msg'`` 参数的日志消息会正常输出，"
"但第五条这样的日志消息会呈现为 ``'limit_msg'`` 参数值本身（ ``'limit_args'`` 同理）。"
"第六条及之后的日志消息会被直接忽略。"
#: ../../contribute.rst:263 7a51dbb9559d4a579654b2ab0938d09b
msgid ""
"For example, if you want to log missing resources, use the following "
"code::"
msgstr ""
"例如，如果你想要用日志记录资源缺失的信息，可以使用下面的代码："
#: ../../contribute.rst:271 8db05f7332f3475b940fb79d24e74ce7
msgid "The log messages will be displayed as follows::"
msgstr "最终的日志消息看起来会像这样："
#: ../../contribute.rst:281 93d618c58e6e4688bebb999ddf591eaa
msgid "Outputting traceback in the logs"
msgstr "在日志中输出traceback信息"
#: ../../contribute.rst:283 3d56bb4bc804499a8d3c8f14dc614916
msgid ""
"If you're logging inside an ``except`` block, you may want to provide the"
" traceback information as well. You can do that by setting ``exc_info`` "
"keyword argument to ``True`` during logging. However, doing so by default"
" can be undesired because tracebacks are long and can be confusing to "
"regular users. Try to limit them to ``--debug`` mode like the following::"
msgstr ""
"当在 ``except`` 块中进行日志记录时，你可能会希望同时输出traceback信息。可以"
"简单地将 ``exc_info`` 参数设为 ``True`` 来实现这一功能。但是通过此方法输出的"
"traceback信息会非常长，不便于理解。可以像下述代码一样将这些信息限制在 "
"``--debug`` 模式中："
#~ msgid "latest Pelican release (or an up-to-date Git clone of Pelican master)"
#~ msgstr ""
#~ msgid ""
#~ "`Create a new branch`_ specific to "
#~ "your change (as opposed to making "
#~ "your commits in the master branch)."
#~ msgstr ""

457
docs/locale/zh_CN/LC_MESSAGES/faq.po Normal file
View file

@ -0,0 +1,457 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-07-31 22:54+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../faq.rst:2 87acb7c16d974b4eb060949b8ce40914
msgid "Frequently Asked Questions (FAQ)"
msgstr "常见问题解答"
#: ../../faq.rst:4 76aee892f7f14d0590db2d76c7cc0123
msgid "Here are some frequently asked questions about Pelican."
msgstr "以下是一些Pelican的常见问题解答。"
#: ../../faq.rst:7 c98549fdd5814984bfa3a6eaf4631d37
msgid "What's the best way to communicate a problem, question, or suggestion?"
msgstr "交流问题、疑问或提建议的最佳方式是什么？"
#: ../../faq.rst:9 dbecb306adeb482ba3b9bd68483bc372
msgid "Please read our :doc:`feedback guidelines <contribute>`."
msgstr "请参阅文档 :doc:`项目贡献与意见反馈 <contribute>` 。"
#: ../../faq.rst:12 8fe91d51140946f1b2cb131d786c1814
msgid "How can I help?"
msgstr "我可以帮上什么忙？"
#: ../../faq.rst:14 d8477da414c446b3936e73931eb4f63a
msgid ""
"There are several ways to help out. First, you can communicate any "
"Pelican suggestions or problems you might have via `Pelican Discussions "
"<https://github.com/getpelican/pelican/discussions>`_. Please first check"
" the existing list of discussions and issues (both open and closed) in "
"order to avoid submitting topics that have already been covered before."
msgstr ""
"有好多种方法可以提供帮助。首先，可以在 `Pelican讨论板块 "
"<https://github.com/getpelican/pelican/discussions>`_ "
"中提出任何关于Pelican的建议或是问题。在提问或建议之前，请先查看已关闭或开放的issues中是否已有相关内容，以避免内容上的重复。"
#: ../../faq.rst:20 95a29a97e08a452f89aa4eaad191b698
msgid ""
"If you want to contribute, please fork `the Git repository "
"<https://github.com/getpelican/pelican/>`_, create a new feature branch, "
"make your changes, and issue a pull request. Someone will review your "
"changes as soon as possible. Please refer to the :doc:`How to Contribute "
"<contribute>` section for more details."
msgstr ""
"如果你想要对项目进行贡献，请fork `Git仓库 <https://github.com/getpelican/pelican/>`_ "
"，创建一个新的功能分支，并在其中进行修改，在修改完成后提出一个PR。项目组会尽快审核你的PR。关于此的更多内容，请参见 "
":doc:`项目贡献与意见反馈 <contribute>` 一节。"
#: ../../faq.rst:26 bf7a6828eec74dc588c18e185bdd7090
msgid ""
"You can also contribute by creating themes and improving the "
"documentation."
msgstr "你可以发起的贡献当然也包括创建主题和改进文档。"
#: ../../faq.rst:29 2ce846241ce744fd81981a376d3f5fe2
msgid "Is the Pelican settings file mandatory?"
msgstr "Pelican配置文件是必要的吗？"
#: ../../faq.rst:31 527720062339422095e2c95755af5584
msgid ""
"Configuration files are optional and are just an easy way to configure "
"Pelican. For basic operations, it's possible to specify options while "
"invoking Pelican via the command line. See ``pelican --help`` for more "
"information."
msgstr ""
"配置文件是可选的，其本质是使您可以更方便地配置Pelican。对于一些基本的配置操作，完全可以在命令行中指定，调用 ``pelican "
"--help`` 可以查看pelican命令的更多信息。"
#: ../../faq.rst:36 d0ca19a2e40c4ecaa9ecba6cc677f142
msgid "Changes to the settings file take no effect"
msgstr "修改后的配置文件没有生效"
#: ../../faq.rst:38 5b741cbb28854893818826c593f8e323
msgid ""
"When experimenting with different settings (especially the metadata ones)"
" caching may interfere and the changes may not be visible. In such cases,"
" ensure that caching is disabled via ``LOAD_CONTENT_CACHE = False`` or "
"use the ``--ignore-cache`` command-line switch."
msgstr ""
"在尝试不同的配置时（尤其是尝试不同元数据时），缓存很可能会产生干扰，使得修改不可见。此时，确保配置了 ``LOAD_CONTENT_CACHE ="
" False`` 或在命令行中加上 ``--ignore-cache`` 以禁用缓存。"
#: ../../faq.rst:44 439f2221927b42f7a4c219ab1a76f849
msgid "I'm creating my own theme. How do I use Pygments for syntax highlighting?"
msgstr "在自己创建主题时，如何使用Pygments来调整语法高亮？"
#: ../../faq.rst:46 3475c1550e584c84a118ac061461f9f6
msgid ""
"Pygments adds some classes to the generated content. These classes are "
"used by themes to style code syntax highlighting via CSS. Specifically, "
"you can customize the appearance of your syntax highlighting via the "
"``.highlight pre`` class in your theme's CSS file. To see how various "
"styles can be used to render Django code, for example, use the style "
"selector drop-down at top-right on the `Pygments project demo site "
"<https://pygments.org/demo/>`_."
msgstr ""
"Pygments会为生成的内容添加一些CSS类。这些类会为主题所用，主题会通过CSS来为代码添加语法高亮。具体来说，你可以通过主题CSS文件中的 "
"``.highlight pre`` 类来自定义语法高亮的外观。在 `Pygments 项目的demo网站 "
"<https://pygments.org/demo/>`_ 上可以预览能够渲染的代码类型。"
#: ../../faq.rst:53 ecffb1f9501f46c88f799b79fc0ba343
msgid ""
"You can use the following example commands to generate a starting CSS "
"file from a Pygments built-in style (in this case, \"monokai\") and then "
"copy the generated CSS file to your new theme::"
msgstr "你可以使用下面的命令来让Pygments使用内置风格（此处为“monokai”）生成一个初始CSS文件，然后将此文件拷贝到新主题中："
#: ../../faq.rst:60 8fc71763c5c243339c9e737cc55b99da
msgid "Don't forget to import your ``pygment.css`` file from your main CSS file."
msgstr "不要忘了在你的CSS主文件中引入 ``pygment.css`` 文件。"
#: ../../faq.rst:63 ad118f1f46db423fab19f570cd789798
msgid "How do I create my own theme?"
msgstr "如何创建我自己的主题？"
#: ../../faq.rst:65 1674585960e742cbade644b63d3bb32a
msgid "Please refer to :ref:`theming-pelican`."
msgstr "请参阅 :ref:`theming-pelican` 。"
#: ../../faq.rst:68 b06c6a8df1634d20b988515af6536e2c
msgid "I want to use Markdown, but I got an error."
msgstr "我想要使用Markdown，但是出错了。"
#: ../../faq.rst:70 c0a89314dbdf4368b2e32d781c0ae95b
msgid ""
"If you try to generate Markdown content without first installing the "
"Markdown library, you may see a message that says ``No valid files found "
"in content``. Markdown is not a hard dependency for Pelican, so if you "
"have content in Markdown format, you will need to explicitly install the "
"Markdown library. You can do so by typing the following command, "
"prepending ``sudo`` if permissions require it::"
msgstr ""
"如果没有事先安装Markdown库，在生成Markdown内容时会看到一条提示 ``No valid files found in "
"content`` "
"。虽然Markdown并不是必需依赖，但如果你写的内容中含有Markdown格式，就需要安装Markdown库了。输入下面的命令以安装Markdown库，如果需要权限，请在前面添加"
" ``sudo`` ："
#: ../../faq.rst:80 a4c93b71eb914652b3f05357067f87b3
msgid "Can I use arbitrary metadata in my templates?"
msgstr "在模板中可以使用任意元数据吗？"
#: ../../faq.rst:82 6ac1579e5d8842f5bf97b87745848c6a
msgid ""
"Yes. For example, to include a modified date in a Markdown post, one "
"could include the following at the top of the article::"
msgstr "当然可以。例如，可以在Markdown帖子中包含一个“修改日期”，加在文章开头即可："
#: ../../faq.rst:87 d1ad8fa8e07c4500ab754962064749a8
msgid ""
"For reStructuredText, this metadata should of course be prefixed with a "
"colon::"
msgstr "对于reStructuredText，此元数据也应当以冒号为前缀："
#: ../../faq.rst:91 e3c9814b5b3849a7957f964565038e45
msgid ""
"This metadata can then be accessed in templates such as ``article.html`` "
"via::"
msgstr "此元数据可以在模板中获取到，例如在 ``article.html`` 中，可以像这样获取："
#: ../../faq.rst:97 11d953b5718c4baeb7f7fbbb9538c763
msgid ""
"If you want to include metadata in templates outside the article context "
"(e.g., ``base.html``), the ``if`` statement should instead be::"
msgstr "如果您想在其他模板（例如 ``base.html`` ）中获取此元数据，则 ``if`` 语句应改为："
#: ../../faq.rst:103 99ca0aeea6d14c159cf1f1b8d9cf016d
msgid ""
"How do I make my output folder structure identical to my content "
"hierarchy?"
msgstr "如何使得输出目录的结构和content目录的结构保持一致？"
#: ../../faq.rst:105 e97223e6c7c94c08a1d42f783fd67f7e
msgid "Try these settings::"
msgstr "可以尝试如下配置："
#: ../../faq.rst:112 d35f11a227ba421596458ea8f26ecde0
msgid "How do I assign custom templates on a per-page basis?"
msgstr "如何为某个页面指定某个模板？"
#: ../../faq.rst:114 287bac0946dc47feab068bdb76d0bc2e
msgid ""
"It's as simple as adding an extra line of metadata to any page or article"
" that you want to have its own template. For example, this is how it "
"would be handled for content in reST format::"
msgstr "这非常简单，在任何页面或者文章中，都可以通过多添加一行元数据来指定特定模板。例如，在reST中，使用："
#: ../../faq.rst:120 b845784299bf47629e616505000724c1
msgid "For content in Markdown format::"
msgstr "对于Markdown，则使用："
#: ../../faq.rst:124 fa734dbb540e4cda8a5be5fb1b2da124
msgid ""
"Then just make sure your theme contains the relevant template file (e.g. "
"``template_name.html``)."
msgstr "确保对应的模板文件在主题中存在即可（例如 ``template_name.html`` ）。"
#: ../../faq.rst:128 bdee9be4397f4839855295ee1a0fdd12
msgid "How can I override the generated URL of a specific page or article?"
msgstr "如何重写某一个页面或文章生成的URL？"
#: ../../faq.rst:130 ed91b5bdcbe24473a6fed738784311b8
msgid ""
"Include ``url`` and ``save_as`` metadata in any pages or articles that "
"you want to override the generated URL. Here is an example page in reST "
"format::"
msgstr "在任意页面或文章中都可以添加 ``url`` 和 ``save_as`` 元数据，这样就可以重写URL了。下面以reST格式为例："
#: ../../faq.rst:139 5aa733d8d3bd4d86920e7e142715b1f4
msgid ""
"With this metadata, the page will be written to "
"``override/url/index.html`` and Pelican will use the URL "
"``override/url/`` to link to this page."
msgstr ""
"有了这样的元数据，此页面会保存为 ``override/url/index.html`` ，Pelican会将 ``override/url/``"
" 作为链接到此页面的URL。"
#: ../../faq.rst:143 04d9890aa34d4c1e86bc7a49cd64938a
msgid "How can I use a static page as my home page?"
msgstr "如何使用一个静态页面作为主页？"
#: ../../faq.rst:145 d3e8a4e2d453446f9037fa46e6775080
msgid ""
"The override feature mentioned above can be used to specify a static page"
" as your home page. The following Markdown example could be stored in "
"``content/pages/home.md``::"
msgstr "上一个问题中提到的特性可以用于实现此需求。下面例子中的Markdown文件保存为 ``content/pages/home.md`` ："
#: ../../faq.rst:155 739da75e7ce946af99c9f577e8a284ff
msgid ""
"If the original blog index is still wanted, it can then be saved in a "
"different location by setting ``INDEX_SAVE_AS = 'blog_index.html'`` for "
"the ``'index'`` direct template."
msgstr ""
"如果仍需要原来的博客主页（即 ``'index'`` 直接模板），可以通过设置 ``INDEX_SAVE_AS = "
"'blog_index.html'`` 将其存储在其他位置。"
#: ../../faq.rst:160 5224f09821d24e4a8db6870da1266a20
msgid "What if I want to disable feed generation?"
msgstr "可以禁用订阅源生成吗？"
#: ../../faq.rst:162 8f014ffab3c44b0ebf2b0d9872bfbfa7
msgid ""
"To disable feed generation, all feed settings should be set to ``None``. "
"All but three feed settings already default to ``None``, so if you want "
"to disable all feed generation, you only need to specify the following "
"settings::"
msgstr ""
"要禁用订阅源，所有订阅源相关的配置都应被设为 ``None`` 。其中有三项设置默认为 ``None`` "
"，因此如果要彻底不生成订阅源，你只需要指定下面这些设置："
#: ../../faq.rst:172 9ab29ccca83c4ecfabcb3ad4dd17c751
msgid ""
"The word ``None`` should not be surrounded by quotes. Please note that "
"``None`` and ``''`` are not the same thing."
msgstr "``None`` 两侧不需要加引号。请注意 ``None`` 和 ``''`` 不是同一个东西。"
#: ../../faq.rst:176 fd8cbe4962d145ccadfd480419dbea9e
msgid ""
"I'm getting a warning about feeds generated without SITEURL being set "
"properly"
msgstr "Pelican警告说由于SITEURL设置不正确，无法正常生成订阅源"
#: ../../faq.rst:178 e3135e5903ec422f8d7895866ca6f365
msgid ""
"`RSS and Atom feeds require all URL links to be absolute "
"<https://validator.w3.org/feed/docs/rss2.html#comments>`_. In order to "
"properly generate links in Pelican you will need to set ``SITEURL`` to "
"the full path of your site."
msgstr ""
"`RSS和Atom订阅源要求所有URL都要链接到绝对地址 "
"<https://validator.w3.org/feed/docs/rss2.html#comments>`_ "
"。为了使得Pelican能正确生成链接，你需要将站点的 ``SITEURL`` 设置为完整路径。"
#: ../../faq.rst:183 4f2cd929dda7464cbd577d1249969920
msgid ""
"Feeds are still generated when this warning is displayed, but links "
"within may be malformed and thus the feed may not validate."
msgstr "虽然Pelican提出了警告，但是仍会生成订阅源，但其中的链接可能是无效的，这会导致订阅源不可用。"
#: ../../faq.rst:187 a9f3465fda8c4a0d9395b2d6d9d5478f
msgid "Can I force Atom feeds to show only summaries instead of article content?"
msgstr "可以让Atom订阅源只显示摘要，不显示文章内容吗？"
#: ../../faq.rst:189 baf140533501453aa8caeddfc276d8fb
msgid ""
"Instead of having to open a separate browser window to read articles, the"
" overwhelming majority of folks who use feed readers prefer to read "
"content within the feed reader itself. Mainly for that reason, Pelican "
"does not support restricting Atom feeds to only contain summaries. Unlike"
" Atom feeds, the RSS feed specification does not include a separate "
"``content`` field, so by default Pelican publishes RSS feeds that only "
"contain summaries (but can optionally be set to instead publish full "
"content RSS feeds). So the default feed generation behavior provides "
"users with a choice: subscribe to Atom feeds for full content or to RSS "
"feeds for just the summaries."
msgstr ""
"绝大多数使用订阅源阅读器的人都更喜欢直接在阅读器中阅读文章内容，而不是另外再打开窗口来阅读。因此，Pelican不支持使Atom只包含摘要。但是由于RSS不包含单独的"
" ``content`` "
"字段，因此Pelican在发布RSS时默认只包含摘要（当然也可以设置为包含文章内容）。Pelican在订阅源生成上的如此行为就可以让用户自行选择订阅类型：包含了完整内容的Atom或是只包含摘要的RSS。"
#: ../../faq.rst:200 850ac093f2764547a7df74d5d055cbd4
msgid "Is Pelican only suitable for blogs?"
msgstr "Pelican只适合用于博客吗？"
#: ../../faq.rst:202 1fb5d92096b242d09da5e0e490b34685
msgid ""
"No. Pelican can be easily configured to create and maintain any type of "
"static site. This may require a little customization of your theme and "
"Pelican configuration. For example, if you are building a launch site for"
" your product and do not need tags on your site, you could remove the "
"relevant HTML code from your theme. You can also disable generation of "
"tag-related pages via::"
msgstr "不是的。Pelican可以方便地用于创建维护任何静态站点，为此你需要对主题和配置做一些定制。例如，如果要为你的产品构建一个宣传网站，即不需要使用标签特性，从主题中移除与标签相关的HTML代码即可。另外，还可以通过下面的设置来禁用标签相关页面的生成："
#: ../../faq.rst:212 5452959b3b694cbc89bb8e91bfbef840
msgid ""
"Why does Pelican always write all HTML files even with content caching "
"enabled?"
msgstr "启用内容缓存后，为什么Pelican仍会每次都写入所有HTML文件？"
#: ../../faq.rst:214 b27b4b7256f749f1bc5970b95fa742ab
msgid ""
"In order to reliably determine whether the HTML output is different "
"before writing it, a large part of the generation environment including "
"the template contexts, imported plugins, etc. would have to be saved and "
"compared, at least in the form of a hash (which would require special "
"handling of unhashable types), because of all the possible combinations "
"of plugins, pagination, etc. which may change in many different ways. "
"This would require a lot more processing time and memory and storage "
"space. Simply writing the files each time is a lot faster and a lot more "
"reliable."
msgstr "为了确定HTML输出确实和之前的不同，模板上下文、插件等很多生成环境都需要保存并比较某种哈希值（对于不可哈希的内容类型还需要进行一些额外处理）。另外，由于插件、分页等内容的存在，输出的HTML很可能会与之前不同。因此，考虑到处理时间和存储空间，每次都重新写入全部HTML会更快更可靠。"
#: ../../faq.rst:223 dcb5b1cf0e1b413bb7c04f6deb4ad5d7
msgid ""
"However, this means that the modification time of the files changes every"
" time, so a ``rsync`` based upload will transfer them even if their "
"content hasn't changed. A simple solution is to make ``rsync`` use the "
"``--checksum`` option, which will make it compare the file checksums in a"
" much faster way than Pelican would."
msgstr ""
"然而，这样的机制会使得在每次生成站点后，文件的修改时间都会变化，因此基于 ``rsync`` "
"上传时会把没有变化的内容也进行上传。一个简便的解决方法就是给 ``rsync`` 加上 ``--checksum`` "
"选项，这会比Pelican在生成时进行校验更快。"
#: ../../faq.rst:230 628a1180f3fd4c0b8301b33e0728d2c2
msgid "How to process only a subset of all articles?"
msgstr "如何只处理一部分文章？"
#: ../../faq.rst:232 c2bfe768775342bb8386255ea1bbbe4e
msgid ""
"It is often useful to process only e.g. 10 articles for debugging "
"purposes. This can be achieved by explicitly specifying only the "
"filenames of those articles in ``ARTICLE_PATHS``. A list of such "
"filenames could be found using a command similar to ``cd content; find "
"-name '*.md' | head -n 10``."
msgstr ""
"简便起见，在调试时可能只需要处理几篇文章。可以直接在配置项 ``ARTICLE_PATHS`` 中添加需要处理文章的文件名。可以通过像 ``cd "
"content; find -name '*.md' | head -n 10`` 这样的命令获取文章文件名的列表。"
#: ../../faq.rst:238 72d30cb7a6e348c483cba0c6b6de8d3a
msgid "My tag cloud is missing/broken since I upgraded Pelican"
msgstr "在升级Pelican后，标签云消失或不可用了"
#: ../../faq.rst:240 7d07dcddab5d42d1aab6a8dbd27ce36c
msgid ""
"In an ongoing effort to streamline Pelican, tag cloud generation has been"
" moved out of Pelican core and into a separate `plugin "
"<https://github.com/pelican-plugins/tag-cloud>`_. See the :ref:`plugins` "
"documentation for further information about the Pelican plugin system."
msgstr ""
"我们一直致力于精简Pelican，标签云生成的功能已经从Pelican核心中移除，转而放到了一个单独的 `tag-cloud插件 "
"<https://github.com/pelican-plugins/tag-cloud>`_ 中。查看 :ref:`plugins` "
"文档获取更多关于Pelican插件系统的信息。"
#: ../../faq.rst:246 51c727bc21f946b8915f958312369e0f
msgid "Since I upgraded Pelican my pages are no longer rendered"
msgstr "升级Pelican后，一些页面没有被渲染"
#: ../../faq.rst:248 4a0d962bc2d844cbab3d0b3e7f6f7bba
msgid ""
"Pages were available to themes as lowercase ``pages`` and uppercase "
"``PAGES``. To bring this inline with the :ref:`templates-variables` "
"section, ``PAGES`` has been removed. This is quickly resolved by updating"
" your theme to iterate over ``pages`` instead of ``PAGES``. Just "
"replace::"
msgstr ""
"在以前的版本中，主题通过小写的 ``pages`` 和大写的 ``PAGES`` 都能获取到页面。为了使之与 :ref:`templates-"
"variables` 一节中的内容保持一致，大写的 ``PAGES`` 被删除了。只要将主题中的 ``PAGES`` 替换为 ``pages`` "
"，问题即可解决。例如将原先的："
#: ../../faq.rst:255 6167ad6b52db43d384247747db1884ca
msgid "with something like::"
msgstr "替换为："
#: ../../faq.rst:260 a7a04eb9e8e549fa8a2a72db3f35b532
msgid "How can I stop Pelican from trying to parse my static files as content?"
msgstr "如何避免让Pelican将我的静态文件解析为内容文件？（译者注：例如要将一个HTML文件作为静态文件）？"
#: ../../faq.rst:262 6baaf265738d4acaa26f7829c64a0ac5
msgid ""
"Pelican's article and page generators run before it's static generator. "
"That means if you use a setup similar to the default configuration, where"
" a static source directory is defined inside a ``*_PATHS`` setting, all "
"files that have a valid content file ending (``.html``, ``.rst``, "
"``.md``, ...) will be treated as articles or pages before they get "
"treated as static files."
msgstr ""
"Pelican的文章与页面生成器会先于静态文件生成器运行。这意味着若使用默认配置，即静态资源文件夹定义在某个 ``*_PATHS`` "
"配置项中，所有以有效内容文件后缀结尾的文件（ ``.html`` 、 ``.rst`` 、 ``.md`` "
"等）都会被视为文章或者页面，而不是静态文件。"
#: ../../faq.rst:268 e4591dd94ddd4199900b9a451d12929e
msgid ""
"To circumvent this issue either use the appropriate ``*_EXCLUDES`` "
"setting or disable the offending reader via ``READERS`` if you don't need"
" it."
msgstr ""
"为了避免这个问题，使用合适的 ``*_EXCLUDES`` 配置，在必要时还可以通过 ``READERS`` "
"配置项来直接禁用产生问题的reader。"
#: ../../faq.rst:272 ca927fe2be10411ab365bcc3e4fa4dbd
msgid "Why is [arbitrary Markdown syntax] not supported?"
msgstr "为什么不是所有的Markdown语法都支持？"
#: ../../faq.rst:274 5c9cc929a6bf4f1db9d4eed5f37fc0af
msgid ""
"Pelican does not directly handle Markdown processing and instead "
"delegates that task to the Python-Markdown_ project, the core of which "
"purposefully follows the original Markdown syntax rules and not the "
"myriad Markdown \"flavors\" that have subsequently propagated. That said,"
" Python-Markdown_ is quite modular, and the syntax you are looking for "
"may be provided by one of the many available `Markdown Extensions`_. "
"Alternatively, some folks have created Pelican plugins that support "
"Markdown variants, so that may be your best choice if there is a "
"particular variant you want to use when writing your content."
msgstr ""
"Pelican并不直接对Markdown进行处理，而是将此任务交给 Python-Markdown_ "
"项目，此项目的核心有意只遵循原始的Markdown语法规则，而不服从之后传播开的大量Markdown风格。另外， Python-Markdown_"
" 是相当模块化的，你想要使用的语法可能已经有现成的 `Markdown扩展`_ "
"进行了实现。或者，也有人创建了支持Markdown变体的Pelican插件，如果你想要用某种Markdown变体，可以在这些地方寻找支持。"

321
docs/locale/zh_CN/LC_MESSAGES/importer.po Normal file
View file

@ -0,0 +1,321 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../importer.rst:4 2e58a5582f664ba0af49aac4480bc799
msgid "Importing an existing site"
msgstr "导入已有站点"
#: ../../importer.rst:7 5182de0b717543c7a4813491755b720a
msgid "Description"
msgstr "简介"
#: ../../importer.rst:9 29a8bae0ba78486894ed4c286cd2f3b4
msgid ""
"``pelican-import`` is a command-line tool for converting articles from "
"other software to reStructuredText or Markdown. The supported import "
"formats are:"
msgstr ""
"命令行工具 ``pelican-import`` 用于将其他软件生成的文章转换成reStructuredText"
"或Markdown格式。支持导入下面这些格式："
#: ../../importer.rst:12 c670f6055ad24d818132d74951c9928c
msgid "Blogger XML export"
msgstr "Blogger XML export"
#: ../../importer.rst:13 d31ddaa8c7d54a268b379f706164de39
msgid "Dotclear export"
msgstr "Dotclear export"
#: ../../importer.rst:14 5102eb70c58240b2ad4d508a196b176e
msgid "Medium export"
msgstr "Medium export"
#: ../../importer.rst:15 2cfcdf575387417bae3a9938aa55b0e6
msgid "Tumblr API"
msgstr "Tumblr API"
#: ../../importer.rst:16 42233d68a4bc46339b284681bdbdd19c
msgid "WordPress XML export"
msgstr "WordPress XML export"
#: ../../importer.rst:17 0170dad08a80435b99a39ccaf887c5bb
msgid "RSS/Atom feed"
msgstr "RSS/Atom feed"
#: ../../importer.rst:19 077a8220f4a84dd297ec5aa7cff15a24
msgid ""
"The conversion from HTML to reStructuredText or Markdown relies on "
"`Pandoc`_. For Dotclear, if the source posts are written with Markdown "
"syntax, they will not be converted (as Pelican also supports Markdown)."
msgstr ""
"从HTML转换到reStructuredText或Markdown是依赖 `Pandoc`_ "
"完成的。对于Dotclear，若原帖子是由Markdown语法写的，则无需转换"
"（因为Pelican本就支持Markdown）。"
#: ../../importer.rst:25 e9b94b6029204b82b009d3ef23c19814
msgid ""
"Unlike Pelican, Wordpress supports multiple categories per article. These"
" are imported as a comma-separated string. You have to resolve these "
"manually, or use a plugin such as `More Categories`_ that enables "
"multiple categories per article."
msgstr ""
"和Pelican不同，在Wordpress中可以将一篇文章同时放在多个分类中。在导入时，各个分类"
"会以逗号分隔，你必须自己手动进行处理。或者也可以使用例如 `More Categories`_ "
"这样的插件，使得文章可以同时存在于多个分类中。"
#: ../../importer.rst:32 f7add19b68754b6e8a617a1d50dee759
msgid ""
"Imported pages may contain links to images that still point to the "
"original site. So you might want to download those images into your local"
" content and manually re-link them from the relevant pages of your site."
msgstr ""
"要导入的内容中可能会包含指向原站点的图片链接，你可能希望将他们全部下载下来，然后再"
"重新手动调整这些链接。"
#: ../../importer.rst:37 22cc1a514c4f42efbcf9afc3d987c42e
msgid "Dependencies"
msgstr "依赖"
#: ../../importer.rst:39 6139199770a24fc7af7ca7e556d18d5f
msgid ""
"``pelican-import`` has some dependencies not required by the rest of "
"Pelican:"
msgstr ""
"``pelican-import`` 需要用到一些其他依赖，这些依赖只会被 ``pelican-import`` 用到："
#: ../../importer.rst:41 0e8eb04bb07f4752880b873e73e7f7e5
msgid ""
"*BeautifulSoup4* and *lxml*, for WordPress and Dotclear import. Can be "
"installed like any other Python package (``pip install BeautifulSoup4 "
"lxml``)."
msgstr ""
"为了能够导入WordPress和Dotclear的内容，需要 *BeautifulSoup4* 与 *lxml* 。"
"安装方法与其他Python包相同（ ``pip install BeautifulSoup4 lxml`` ）"
#: ../../importer.rst:44 7d31c1ad4ecb4014a3ef240436b9b3e1
msgid "*Feedparser*, for feed import (``pip install feedparser``)."
msgstr "为了能够导入订阅源，需要 *Feedparser* （ ``pip install feedparser`` ）"
#: ../../importer.rst:45 db7a18b1a4534a17956c9d030dddff56
msgid ""
"*Pandoc*, see the `Pandoc site`_ for installation instructions on your "
"operating system."
msgstr ""
"还需要 *Pandoc* ，参照 `Pandoc官方网站`_ 进行安装。"
#: ../../importer.rst:53 9952881aed104ef0ac82af5339e6b149
msgid "Usage"
msgstr "用法"
#: ../../importer.rst:63 83dbe43e4d2e4d8eaf3e37724ac119e3
msgid "Positional arguments"
msgstr "位置参数"
#: ../../importer.rst:65 4a12692744024752be75d82ed74d369d
msgid "``input``"
msgstr "``input``"
#: ../../importer.rst:65 52f62f22221f4c3d964df5aced3d2a2b
msgid "The input file to read"
msgstr "需要读取的输入文件"
#: ../../importer.rst:66 acc46432d5c14ea8a5e27e6ec2b84d18
msgid "``api_key``"
msgstr "``api_key``"
#: ../../importer.rst:66 29dd358bf2fe49d8a218c56ca376f6a6
msgid ""
"(Tumblr only) api_key can be obtained from "
"https://www.tumblr.com/oauth/apps"
msgstr ""
"（只会在Tumblr中用到）从 https://www.tumblr.com/oauth/apps 中获取到的api_key"
#: ../../importer.rst:70 a81b90d51a9f4c28adc09038715cf5c2
msgid "Optional arguments"
msgstr "可选参数"
#: ../../importer.rst:72 d4d5211b75aa4103b06ad7685368af06
msgid "Show this help message and exit"
msgstr "显示此帮助信息并退出 ``pelican-import`` "
#: ../../importer.rst:73 a7bae87fe16644f4b5da7d32fdc05f95
msgid "Blogger XML export (default: False)"
msgstr "输入是否为Blogger XML格式（默认：False）"
#: ../../importer.rst:74 e8c133125ed04120bcc3737fa2a0ba60
msgid "Dotclear export (default: False)"
msgstr "输入是否为Dotclear格式（默认：False）"
#: ../../importer.rst:75 caffd159f92a4f36aadedec398823ac3
msgid "Medium export (default: False)"
msgstr "输入是否为Medium格式（默认：False）"
#: ../../importer.rst:76 f1bcaccf8e2f43f6894f2f0540c9d7ba
msgid "Tumblr API (default: False)"
msgstr "输入是否为Tumblr API格式（默认：False）"
#: ../../importer.rst:77 6131f8fa00294515a028f4bb1a3a3053
msgid "WordPress XML export (default: False)"
msgstr "输入是否为WordPress XML格式（默认：False）"
#: ../../importer.rst:78 dad00ee0aebb4550acae995ecdbb622f
msgid "Feed to parse (default: False)"
msgstr "输入是否为订阅源格式（默认：False）"
#: ../../importer.rst:80 0ca3cbbc57c64b5b88444ccde94f94ce
msgid "Output path (default: content)"
msgstr "输出路径（默认：content）"
#: ../../importer.rst:82 baa2762a4ee745028e29865720ca299d
msgid ""
"Output markup format: ``rst``, ``markdown``, or ``asciidoc`` (default: "
"``rst``)"
msgstr ""
"输出格式，可选值为： ``rst`` 、 ``markdown`` 、 ``asciidoc`` （默认： ``rst`` ）"
#: ../../importer.rst:84 53232a317a58422d8f070c245d3b7409
msgid "Put files in directories with categories name (default: False)"
msgstr "是否要将输出文件按分类名放到各文件夹中（默认：False）"
#: ../../importer.rst:86 f72e1895d9fc4facb90ddffb53b31a0a
msgid ""
"Put files recognised as pages in \"pages/\" sub- directory (blogger and "
"wordpress import only) (default: False)"
msgstr ""
"将识别为页面的文件放入“pages/” 子文件夹中（仅在blogger和wordpress中有用）（默认：False）"
#: ../../importer.rst:89 3f9315af4f1e4ced8ece96fca71cb1e7
msgid "Import only post from the specified author"
msgstr "仅导入某个作者的帖子"
#: ../../importer.rst:90 0b34125f0bb744b089fe77b86b3e50f7
msgid ""
"Strip raw HTML code that can't be converted to markup such as flash "
"embeds or iframes (default: False)"
msgstr ""
"删除无法转换的HTML代码，例如嵌入的flash或iframe（默认：False）"
#: ../../importer.rst:92 f899a119b708450bbd38913f813255c2
msgid ""
"Put wordpress custom post types in directories. If used with --dir-cat "
"option directories will be created as \"/post_type/category/\" (wordpress"
" import only)"
msgstr ""
"将wordpress中的自定义类型博文放到对应文件夹中。如果同时还使用了 --dir-cat 选项，"
"输出转换后文件时会创建诸如“/post_type/category/” 的文件夹（只在wordpress中有效）"
#: ../../importer.rst:95 627c041fab81460eafd4f5fe361bcd1a
msgid ""
"Download files uploaded to wordpress as attachments. Files will be added "
"to posts as a list in the post header and links to the files within the "
"post will be updated. All files will be downloaded, even if they aren't "
"associated with a post. Files will be downloaded with their original path"
" inside the output directory, e.g. \"output/wp-"
"uploads/date/postname/file.jpg\". (wordpress import only) (requires an "
"internet connection)"
msgstr ""
"下载作为附件上传到WordPress的文件。文件会以列表形式添加到帖子的开头，并且到这些"
"文件的链接都会进行更新。另外，即使某些文件没有在任何帖子中用到，也同样会被下载。"
"文件会被下载到输出文件夹下，并保持原始路径，例如"
"“output/wp-uploads/date/postname/file.jpg” 。（仅在wordpress中有效，"
"且需要互联网连接）"
#: ../../importer.rst:104 11162d8c497b4108a38c2a60af4a4215
msgid ""
"Disable storing slugs from imported posts within output. With this "
"disabled, your Pelican URLs may not be consistent with your original "
"posts. (default: False)"
msgstr ""
"不保存导入推文的slug，会导致Pelican的URL和原推文不一致。（默认：False）"
#: ../../importer.rst:109 f4f4b6e918d3498e927b59c5d0bae05a
msgid "Blog name used in Tumblr API"
msgstr "Tumblr API中使用的博客名"
#: ../../importer.rst:113 16e0f9bd1c6e4b338673f1800e6a4995
msgid "Examples"
msgstr "例子"
#: ../../importer.rst:115 0cf17b9fd72940c391a1bb8bf7de534b
msgid "For Blogger::"
msgstr "导入Blogger："
#: ../../importer.rst:119 3fc79daf9e9e4f5ba1a121faaabd0c9e
msgid "For Dotclear::"
msgstr "导入Dotclear："
#: ../../importer.rst:123 328ff8145b464fa2ab59505a8bc3236a
msgid "For Medium::"
msgstr "导入Medium："
#: ../../importer.rst:127 8ca5f721833142249b6d798efcb77458
msgid ""
"The Medium export is a zip file. Unzip it, and point this tool to the "
"\"posts\" subdirectory. For more information on how to export, see "
"https://help.medium.com/hc/en-us/articles/115004745787-Export-your-"
"account-data."
msgstr ""
"Medium中导出的是一个zip文件。请先解压之，然后再将其中的“posts”子目录传给此工具。 "
"https://help.medium.com/hc/en-us/articles/115004745787-Export-your-account-data "
"中有更详细的导出指导。"
#: ../../importer.rst:131 516a83a4d8cf4570a9a6fff416e5cf5a
msgid "For Tumblr::"
msgstr "导入Tumblr："
#: ../../importer.rst:135 8fcab620c0d44bb29a120d8d781f4daa
msgid "For WordPress::"
msgstr "导入WordPress："
#: ../../importer.rst:139 a929213eb21f4118b9adbb6199bd78ea
msgid "For Medium (an example of using an RSS feed):"
msgstr "导入Medium（例子中使用了RSS订阅源）："
#: ../../importer.rst:141 5e23c5d167ef4db1994f4323ac3d120e
msgid ""
"$ python -m pip install feedparser $ pelican-import --feed "
"https://medium.com/feed/@username"
msgstr ""
"$ python -m pip install feedparser $ pelican-import --feed "
"https://medium.com/feed/@username"
#: ../../importer.rst:146 b44dfe0f807049899c0560c6bf62c386
msgid "The RSS feed may only return the most recent posts — not all of them."
msgstr "RSS订阅源可能只会返回最新的帖子，而不是所有帖子。"
#: ../../importer.rst:149 575426ff787d4647b3aa2469b8b52412
msgid "Tests"
msgstr "测试"
#: ../../importer.rst:151 036d2119412b41f3a3cb69cec74ecc81
msgid "To test the module, one can use sample files:"
msgstr "可以使用下面的文件作为样例进行测试："
#: ../../importer.rst:153 482b30f9aab54717bb14218ae5fa8ea6
msgid ""
"for WordPress: https://www.wpbeginner.com/wp-themes/how-to-add-dummy-"
"content-for-theme-development-in-wordpress/"
msgstr ""
"WordPress： https://www.wpbeginner.com/wp-themes/how-to-add-dummy-content-"
"for-theme-development-in-wordpress/"
#: ../../importer.rst:154 6cb1bd10d37e4993aabece8aaed20171
msgid "for Dotclear: http://media.dotaddict.org/tda/downloads/lorem-backup.txt"
msgstr "Dotclear： http://media.dotaddict.org/tda/downloads/lorem-backup.txt"

134
docs/locale/zh_CN/LC_MESSAGES/index.po Normal file
View file

@ -0,0 +1,134 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../index.rst:2 160b5c32c524404ba295da4e89124739
msgid "Pelican |release|"
msgstr "Pelican |release|"
#: ../../index.rst:4 19170a80b4274f71b77062c7a6b90726
msgid ""
"Pelican is a static site generator, written in Python_. Highlights "
"include:"
msgstr ""
"Pelican是一个用 Python_ 写的静态站点生成器，它有诸多亮点："
#: ../../index.rst:6 6ab42a346f2c46d789cd46655195f2d3
msgid ""
"Write your content directly with your editor of choice in "
"reStructuredText_ or Markdown_ formats"
msgstr ""
"你可以直接在自己的编辑器中用 reStructuredText_ 或 Markdown_ 完成内容创作"
#: ../../index.rst:8 dbd17888530e43ce8bdfc1594947032c
msgid "Includes a simple CLI tool to (re)generate your site"
msgstr "自带了一个简单的命令行工具，你可以用它来生成你的站点"
#: ../../index.rst:9 2bbe72bda8db457a88f3d3a94d16cc0c
msgid "Easy to interface with distributed version control systems and web hooks"
msgstr "易于与分布式版本控制系统和webhook交互"
#: ../../index.rst:10 24af69b083024f2a9c4f162d54fa57c6
msgid "Completely static output is easy to host anywhere"
msgstr "生成的站点是完全静态的，可以在任何主机上轻松地部署"
#: ../../index.rst:12 1e2090f3f19d49a19a6c50524e4cd0b7
msgid "Ready to get started? Check out the :doc:`Quickstart<quickstart>` guide."
msgstr "准备好开始体验了吗？请查看 :doc:`快速入门<quickstart>` 指南。"
#: ../../index.rst:15 481a352565e84c848e018de507fbe9af
msgid "Features"
msgstr "特性"
#: ../../index.rst:17 6c7b5d9b43ca42f1b1df139e7f884d26
msgid "Pelican’s feature highlights include:"
msgstr "Pelican在特性上也有很多亮点："
#: ../../index.rst:19 464e5e8ea8324fab9c5496b317a6db97
msgid ""
"Articles (e.g., blog posts) and pages (e.g., \"About\", \"Projects\", "
"\"Contact\")"
msgstr ""
"可以生成文章（例如博客推文）和页面（例如“关于”、“联系我们”、“项目”）"
#: ../../index.rst:20 c7cc4fe6ea8145feb0ace7d0965e2634
msgid "Integration with external services"
msgstr "可以和外部服务集成"
#: ../../index.rst:21 ceb2c8a629024157946eba53638d7eb1
msgid "Site themes (created using Jinja2_ templates)"
msgstr "可以使用主题（主题使用 Jinja2_ 模板引擎创建）"
#: ../../index.rst:22 51c3defcba6c4d31a77c3aade6826f1a
msgid "Publication of articles in multiple languages"
msgstr "可以为同一篇文章发布多种语言版本"
#: ../../index.rst:23 6f7cbfae94c54318a904e9725ce73677
msgid "Generation of Atom and RSS feeds"
msgstr "可以生成Atom和Rss订阅源"
#: ../../index.rst:24 3d667d2ed98a489788f6c38a4e4a6752
msgid "Code syntax highlighting"
msgstr "可以渲染代码高亮"
#: ../../index.rst:25 bf1a1f91b821464182471a3760a59d4f
msgid "Import existing content from WordPress, Dotclear, or RSS feeds"
msgstr "可以从WordPress、Dotclear或Rss订阅源导入已有的内容"
#: ../../index.rst:26 bd82641c549645cb8b4cd3187800397c
msgid "Fast rebuild times thanks to content caching and selective output writing"
msgstr "得益于内容缓存和选择性生成设计，可以快速重新生成站点"
#: ../../index.rst:27 8dec47d1ab13410c9b99db0709c860a3
msgid "Extensible via a rich plugin ecosystem: `Pelican Plugins`_"
msgstr "可扩展性强，有丰富的插件生态： `Pelican Plugins`_"
#: ../../index.rst:30 c7e090d7d2e04ff1ac1844e56209d75b
msgid "Why the name \"Pelican\"?"
msgstr "为什么叫做“Pelican”？"
#: ../../index.rst:32 8c31222af5e24ba69acb5dd07a5b5d56
msgid ""
"\"Pelican\" is an anagram for *calepin*, which means \"notebook\" in "
"French. ;)"
msgstr ""
"“Pelican”是法语词笔记本 *calepin* 读音的回文。;)"
#: ../../index.rst:35 188f72b2bb644f978180eba22009ebc6
msgid "Source code"
msgstr "源码"
#: ../../index.rst:37 2c8804f173fb4aa8973fb4d2413c263b
msgid "You can access the source code at: https://github.com/getpelican/pelican"
msgstr "在这里可以获取Pelican的源码： https://github.com/getpelican/pelican"
#: ../../index.rst:40 06ab21b7cde94cee92193199ddc69775
msgid "How to get help, contribute, or provide feedback"
msgstr "如何获取帮助、贡献内容或是提供反馈"
#: ../../index.rst:42 7fdcc2bcaac04317a6f4114f1d9c327f
msgid ""
"See our :doc:`feedback and contribution submission guidelines "
"<contribute>`."
msgstr ""
"请查看文档 :doc:`反馈意见和贡献的提交指南 <contribute>`。"
#: ../../index.rst:45 3d15499d76e1489d8e8782c65f73bb29
msgid "Documentation"
msgstr "文档"

244
docs/locale/zh_CN/LC_MESSAGES/install.po Normal file
View file

@ -0,0 +1,244 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-25 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../install.rst:2 32d9c99d9171418c89daafbe7260daa9
msgid "Installing Pelican"
msgstr "安装Pelican"
#: ../../install.rst:4 73ec02b650044be6bb17951f4a915075
msgid ""
"Pelican currently runs best on |min_python|; earlier versions of Python "
"are not supported."
msgstr ""
"Pelican需要 |min_python| 以上版本的Python，不支持更低版本。"
#: ../../install.rst:6 9134a5a1bd9a4f54a36a3da163d859d8
msgid ""
"You can install Pelican via several different methods. The simplest is "
"via Pip_::"
msgstr ""
"有多种方法可以安装Pelican，最简单的就是通过 Pip_："
#: ../../install.rst:10 22d5948b07d14a13bc45aa14ef11e856
msgid "Or, if you plan on using Markdown::"
msgstr "如果您需要使用Markdown，请使用下面的命令安装："
#: ../../install.rst:14 b910f7faa2c84e5eb62fbd0fae2544d3
msgid ""
"(Keep in mind that some operating systems will require you to prefix the "
"above command with ``sudo`` in order to install Pelican system-wide.)"
msgstr ""
"（在某些操作系统中，需要在命令前加 ``sudo`` 才能在整个系统上安装Pelican）"
#: ../../install.rst:17 afb018b5d42e433e8107ca38dfcb545f
msgid ""
"While the above is the simplest method, the recommended approach is to "
"create a virtual environment for Pelican via virtualenv_ before "
"installing Pelican. Assuming you have virtualenv_ installed, you can then"
" open a new terminal session and create a new virtual environment for "
"Pelican::"
msgstr ""
"尽管上面是最简单的安装方法，但我们推荐使用虚拟环境 virtualenv_ 完成"
"Pelican的安装。当您安装好 virtualenv_ 后，打开一个新的命令行并"
"为Pelican创建一个虚拟环境："
#: ../../install.rst:26 7d981233f13e42b6b07fbd5fa58f69fc
msgid ""
"Once the virtual environment has been created and activated, Pelican can "
"be installed via ``python -m pip install pelican`` as noted above. "
"Alternatively, if you have the project source, you can install Pelican "
"using the distutils method::"
msgstr ""
"当创建并激活虚拟环境后，使用之前提到过的命令 ``python -m pip install pelican`` "
"就可以安装Pelican了。或者，如果您想要从源码安装，可以使用distutils方式："
#: ../../install.rst:33 c8109ae3e44541e18e713e39690009ae
msgid ""
"If you have Git installed and prefer to install the latest bleeding-edge "
"version of Pelican rather than a stable release, use the following "
"command::"
msgstr ""
"如果安装过Git，并且您希望安装Pelican的最最新版本（而不是稳定版），"
"请使用下面的命令："
#: ../../install.rst:38 2ba389e93d084dea8b702336479a0470
msgid ""
"Once Pelican is installed, you can run ``pelican --help`` to see basic "
"usage options. For more detail, refer to the :doc:`Publish<publish>` "
"section."
msgstr ""
"当您安装好Pelican，可以执行 ``pelican --help`` 命令来查看一些基本用法。"
"在 :doc:`发布站点<publish>` 章节中可以了解更多信息。"
#: ../../install.rst:42 d1850a31cca24c5281cc7c9fd748b56b
msgid "Optional packages"
msgstr "可选包"
#: ../../install.rst:44 8428281e15354c71a5aec92e9e0041b9
msgid ""
"If you plan on using `Markdown <https://pypi.org/project/Markdown/>`_ as "
"a markup format, you can install Pelican with Markdown support::"
msgstr ""
"如您希望使用 `Markdown <https://pypi.org/project/Markdown/>`_ "
"来写作，执行下面的命令来安装Markdown支持："
#: ../../install.rst:49 6dcdacecb0874afd8c88cbf814c522ba
msgid ""
"Typographical enhancements can be enabled in your settings file, but "
"first the requisite `Typogrify <https://pypi.org/project/typogrify/>`_ "
"library must be installed::"
msgstr ""
"Pelican还支持排版增强，若您需要使用，请先安装 `Typogrify "
"<https://pypi.org/project/typogrify/>`_ 库，稍后您可以在设置文件中启用它。"
#: ../../install.rst:56 d3ff6383ae9745bc9bfed85654086311
msgid "Dependencies"
msgstr "依赖"
#: ../../install.rst:58 2dc22a3fa6c242bdb5b61005e1910d79
msgid ""
"When Pelican is installed, the following dependent Python packages should"
" be automatically installed without any action on your part:"
msgstr ""
"当Pelican安装完成后，下面的所有Python依赖应该都会自动安装，"
"无需另外做任何操作："
#: ../../install.rst:61 4c7a644a29b540869d69acd10e032039
msgid ""
"`feedgenerator <https://pypi.org/project/feedgenerator/>`_, to generate "
"the Atom feeds"
msgstr ""
"`feedgenerator <https://pypi.org/project/feedgenerator/>`_，"
"用于生成Atom feeds"
#: ../../install.rst:63 365c8fb0938e4d9fbf78d110b05cb99f
msgid "`jinja2 <https://pypi.org/project/Jinja2/>`_, for templating support"
msgstr "`jinja2 <https://pypi.org/project/Jinja2/>`_，用于模板系统"
#: ../../install.rst:64 5db63207e60c4997924c3baf8aec8524
msgid "`pygments <https://pypi.org/project/Pygments/>`_, for syntax highlighting"
msgstr "`pygments <https://pypi.org/project/Pygments/>`_，用于语法高亮"
#: ../../install.rst:65 72bfb5fc2b514031a42952502746c100
msgid ""
"`docutils <https://pypi.org/project/docutils/>`_, for supporting "
"reStructuredText as an input format"
msgstr ""
"`docutils <https://pypi.org/project/docutils/>`_，"
"用于reStructuredText格式"
#: ../../install.rst:67 d00ac0c26d884a2d9d7f02fa89491892
msgid ""
"`blinker <https://pypi.org/project/blinker/>`_, an object-to-object and "
"broadcast signaling system"
msgstr ""
"`blinker <https://pypi.org/project/blinker/>`_，"
"对象-对象的信号广播系统"
#: ../../install.rst:69 0d317b007acf49fc879203fa8ffb4048
msgid ""
"`unidecode <https://pypi.org/project/Unidecode/>`_, for ASCII "
"transliterations of Unicode text utilities"
msgstr ""
"`unidecode <https://pypi.org/project/Unidecode/>`_，"
"用于将Unicode文本转为ASCII字符的音译"
#: ../../install.rst:72 ded0aae575854f149bcf2ea9efa4ba21
msgid ""
"`MarkupSafe <https://pypi.org/project/MarkupSafe/>`_, for a markup-safe "
"string implementation"
msgstr ""
"`MarkupSafe <https://pypi.org/project/MarkupSafe/>`_，"
"用于转义字符的安全处理"
#: ../../install.rst:74 eae7d8f6f84040339ccfef98e20502d8
msgid ""
"`python-dateutil <https://pypi.org/project/python-dateutil/>`_, to read "
"the date metadata"
msgstr ""
"`python-dateutil <https://pypi.org/project/python-dateutil/>`_，"
"用于读取日期相关的元数据"
#: ../../install.rst:78 cd33ec4583574c5bb879f08813b9932c
msgid "Upgrading"
msgstr "更新升级"
#: ../../install.rst:80 1513dd1e43564cb29da0a14988e0791d
msgid ""
"If you installed a stable Pelican release via Pip_ and wish to upgrade to"
" the latest stable release, you can do so by adding ``--upgrade``::"
msgstr ""
"若是通过 Pip_ 安装了稳定版本的Pelican，可以通过在安装命令中"
"添加 ``--upgrade`` 来升级到最新版："
#: ../../install.rst:85 fae6900b3acc41d4b7bb34c192fe4c08
msgid ""
"If you installed Pelican via distutils or the bleeding-edge method, "
"simply perform the same step to install the most recent version."
msgstr ""
"若是通过distutils安装或是通过Git安装了测试版的Pelican"
"重新进行一遍和安装时同样的步骤即可。"
#: ../../install.rst:89 89392d36f81f4c7eb75e9a74d1795faa
msgid "Kickstart your site"
msgstr "启动网站"
#: ../../install.rst:91 a8517a0fbbb1420297df214f50d8792d
msgid ""
"Once Pelican has been installed, you can create a skeleton project via "
"the ``pelican-quickstart`` command, which begins by asking some questions"
" about your site::"
msgstr ""
"Pelican安装完成后，通过 ``pelican-quickstart`` 命令创建项目的整体框架，"
"在运行这个命令时，您需要输入一些与站点相关的信息："
#: ../../install.rst:97 50231ba4b02d4e868995bdacbd02b27d
msgid ""
"If run inside an activated virtual environment, ``pelican-quickstart`` "
"will look for an associated project path inside "
"``$VIRTUAL_ENV/.project``. If that file exists and contains a valid "
"directory path, the new Pelican project will be saved at that location. "
"Otherwise, the default is the current working directory. To set the new "
"project path on initial invocation, use: ``pelican-quickstart --path "
"/your/desired/directory``"
msgstr ""
"如果是在虚拟环境中执行 ``pelican-quickstart`` ，系统会自动在 "
"``$VIRTUAL_ENV/.project`` 目录中查找这个命令。若这个这个命令存在"
"并且路径是正确的，一个新的Pelican项目就会在目标位置创建。否则，"
"会默认在当前的工作目录下创建这个项目。若要在初始化时指定项目路径，请使用 "
"``pelican-quickstart --path /your/desired/directory``。"
#: ../../install.rst:104 ea893addf15c47f182384509b1a3a2f7
msgid ""
"Once you finish answering all the questions, your project will consist of"
" the following hierarchy (except for *pages* — shown in parentheses below"
" — which you can optionally add yourself if you plan to create non-"
"chronological content)::"
msgstr ""
"当您回答完所有问题后，项目就会成功创建。项目中会包含下述的一些层级结构"
"（除了用括号括起来的 *pages*）。如果有一些内容不需要按时间排序，"
"您可以将它们放在（pages）所在的位置："
#: ../../install.rst:118 7d13a0cc5ebd44159fddc8de68993fc7
msgid ""
"The next step is to begin to adding content to the *content* folder that "
"has been created for you."
msgstr ""
"接下来就可以开始往 *content* 目录中添加自己创作的内容了。"

172
docs/locale/zh_CN/LC_MESSAGES/internals.po Normal file
View file

@ -0,0 +1,172 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../internals.rst:2 5d90a7c7f9dd42b5ba1fdfc05c5e9c3c
msgid "Pelican internals"
msgstr "Pelican内部机制"
#: ../../internals.rst:4 fa53597118244e8585b3b0a9fb4336c0
msgid ""
"This section describe how Pelican works internally. As you'll see, it's "
"quite simple, but a bit of documentation doesn't hurt. :)"
msgstr ""
"这一节描述了Pelican的内部运行机制。你会发现，Pelican的内部其实并不复杂。 :)"
#: ../../internals.rst:7 c9a34db098f34796b80ee62896702be2
msgid ""
"You can also find in the :doc:`report` section an excerpt of a report the"
" original author wrote with some software design information."
msgstr "你可以在 :doc:`report` 一节中找到原作者用软件设计相关内容报告的节选。"
#: ../../internals.rst:13 ac2af84842574bef9a791b416e21834e
msgid "Overall structure"
msgstr "总体结构"
#: ../../internals.rst:15 fb7aea45b8f74c9c877bf2640d47aaac
msgid ""
"What Pelican does is take a list of files and process them into some sort"
" of output. Usually, the input files are reStructuredText and Markdown "
"files, and the output is a blog, but both input and output can be "
"anything you want."
msgstr ""
"Pelican做的事情其实很简单：获取一个文件列表，并将它们处理为某种输出。通常，输入文件是"
"reStructuredText和Markdown文件，输出是一个博客，但事实上输入和输出都可以是你想要的"
"任何内容。"
#: ../../internals.rst:19 599649d1e9da4355ab02b50ea4fbdb19
msgid "The logic is separated into different classes and concepts:"
msgstr "系统的整体逻辑可以分为几个不同的类和概念："
#: ../../internals.rst:21 8ec0821a726e4ade8046921cc09b3ea3
msgid ""
"**Writers** are responsible for writing files: .html files, RSS feeds, "
"and so on. Since those operations are commonly used, the object is "
"created once and then passed to the generators."
msgstr ""
"**Writers** 负责完成 html、RSS订阅源等等内容的文件写入。因为这些操作都是比较常用的，"
"这个类只会被创建一次，然后再传给Generators。"
#: ../../internals.rst:25 63c9a61869884147a8752e9be188e0e9
msgid ""
"**Readers** are used to read from various formats (HTML, Markdown and "
"reStructuredText for now, but the system is extensible). Given a file, "
"they return metadata (author, tags, category, etc.) and content (HTML-"
"formatted)."
msgstr ""
"**Readers** 用于读取不同格式的文件（目前支持HTML、Markdown、reStructuredText，"
"但可以继续扩展）。向**Readers**输入一个文件，它会返回文档的元数据（作者、标签、"
"分类等等）与HTML格式的文档正文内容。"
#: ../../internals.rst:29 d9bc146ae213415b804cd93ebf43e340
msgid ""
"**Generators** generate the different outputs. For instance, Pelican "
"comes with ``ArticlesGenerator`` and ``PageGenerator``. Given a "
"configuration, they can do whatever they want. Most of the time, it's "
"generating files from inputs."
msgstr ""
"**Generators** 用以生成不同的输出，Pelican自带了 ``ArticlesGenerator`` 和 "
"``PageGenerator`` 。给定一套配置信息， **Generators** 可以做几乎任何事。"
"但大多数情况下，它的工作就是从输入生成文件。"
#: ../../internals.rst:34 49ef39e8677a4529a3ee226faae1526b
msgid ""
"Pelican also uses templates, so it's easy to write your own theme. The "
"syntax is `Jinja2 <https://palletsprojects.com/p/jinja/>`_ and is very "
"easy to learn, so don't hesitate to jump in and build your own theme."
msgstr ""
"Pelican使用了模板引擎，因此可以较为简单地编写自定义主题。模板语法使用的是易于学习的 "
"`Jinja2 <https://palletsprojects.com/p/jinja/>`_ ，因此快去构建你自己的主题吧。"
#: ../../internals.rst:39 1aef766f93d549afa332fad4278c4063
msgid "How to implement a new reader?"
msgstr "如何实现一个新的reader？"
#: ../../internals.rst:41 abbbfc19ccea4e3ea3716179981e3c1d
msgid ""
"Is there an awesome markup language you want to add to Pelican? Well, the"
" only thing you have to do is to create a class with a ``read`` method "
"that returns HTML content and some metadata."
msgstr ""
"若是希望为Pelican添加一个标记语言，只需要创建一个类，实现 ``read`` 方法，并在其中"
"返回元数据和以HTML表示的正文内容。"
#: ../../internals.rst:45 1e9fc1bcc9444db4b751f1c621280a32
msgid "Take a look at the Markdown reader::"
msgstr "可以看一看Markdown的reader："
#: ../../internals.rst:71 cbc4f49384964be3a0a68b1083100839
msgid "Simple, isn't it?"
msgstr "是不是很简单呢？"
#: ../../internals.rst:73 02643c7e485d49e39344570ba5639a60
msgid ""
"If your new reader requires additional Python dependencies, then you "
"should wrap their ``import`` statements in a ``try...except`` block. "
"Then inside the reader's class, set the ``enabled`` class attribute to "
"mark import success or failure. This makes it possible for users to "
"continue using their favourite markup method without needing to install "
"modules for formats they don't use."
msgstr ""
"如果新创建的reader需要额外的Python依赖，应该把 ``import`` 放在 ``try...except`` "
"块中。在reader类中，设置类属性 ``enabled`` 来标记import是否成功。这使得用户能"
"继续使用他们喜欢的标记语言而无需安装用不到的模块。"
#: ../../internals.rst:80 02deeeac368b4dbc8c7b1025275d5bd5
msgid "How to implement a new generator?"
msgstr "如何实现一个新的generator？"
#: ../../internals.rst:82 f7e5c28efbdb40c0bac7b985e8264310
msgid ""
"Generators have two important methods. You're not forced to create both; "
"only the existing ones will be called."
msgstr ""
"generator有两个重要方法。不一定两个都要创建，若只创建了一个，就会自动调用存在的方法。"
#: ../../internals.rst:85 01f2801461e043e7882167907e337d2c
msgid ""
"``generate_context``, that is called first, for all the generators. Do "
"whatever you have to do, and update the global context if needed. This "
"context is shared between all generators, and will be passed to the "
"templates. For instance, the ``PageGenerator`` ``generate_context`` "
"method finds all the pages, transforms them into objects, and populates "
"the context with them. Be careful *not* to output anything using this "
"context at this stage, as it is likely to change by the effect of other "
"generators."
msgstr ""
"``generate_context`` 会优先被调用，其中可以完成任何你想要做的事，如果需要的话，还要"
"更新全局上下文。全局上下文会在所有generator间共享，并在之后传给模板。例如 "
"``PageGenerator`` 的 ``generate_context`` 方法会找寻所有页面，并将他们转换为对象，"
"再将上下文传入其中。注意，请 *不要* 在此阶段使用该上下文输出任何内容，因为其他"
"generator还会继续影响上下文。"
#: ../../internals.rst:93 3241d04af8944c48bf162963a774000c
msgid ""
"``generate_output`` is then called. And guess what is it made for? Oh, "
"generating the output. :) It's here that you may want to look at the "
"context and call the methods of the ``writer`` object that is passed as "
"the first argument of this function. In the ``PageGenerator`` example, "
"this method will look at all the pages recorded in the global context and"
" output a file on the disk (using the writer method ``write_file``) for "
"each page encountered."
msgstr ""
"``generate_output`` 会在 ``generate_context`` 之后被调用，用于生成要输出的内容。"
"此时就需要使用上下文并调用 ``writer`` 对象的方法，此 ``writer`` 就是传入 "
"``generate_output`` 方法的第一个参数。``PageGenerator`` 的 ``generate_output`` "
"方法中，会使用writer的 ``write_file`` 方法为全局上下文中的每一个页面输出一个文件。"

206
docs/locale/zh_CN/LC_MESSAGES/pelican-themes.po Normal file
View file

@ -0,0 +1,206 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../pelican-themes.rst:2 1fce54d5389b41f4a588e9b23b646aee
msgid "pelican-themes"
msgstr "pelican-themes"
#: ../../pelican-themes.rst:7 6158b329ed7b469286405115e2ed7fa0
msgid "Description"
msgstr "简介"
#: ../../pelican-themes.rst:9 3df74d6d079945f7a4e0062ed5ea3eed
msgid ""
"``pelican-themes`` is a command line tool for managing themes for "
"Pelican. See :ref:`settings/themes` for settings related to themes."
msgstr ""
"``pelican-themes`` 是一个命令行工具，用于管理Pelican主题。有关主题的配置，"
"请参考 :ref:`设置章节中的主题 <settings/themes>` 。"
#: ../../pelican-themes.rst:14 03eb76faf4544c8dbf478752096c7d7c
msgid "Usage"
msgstr "用法"
#: ../../pelican-themes.rst:16 d5dcdc6c26094f5695061f9c53633589
msgid "pelican-themes [-h] [-l] [-i theme path [theme path ...]]"
msgstr "pelican-themes [-h] [-l] [-i theme path [theme path ...]]"
#: ../../pelican-themes.rst:17 99b7a21ca612425da217b72b8c0c9b64
msgid "[-r theme name [theme name ...]]"
msgstr "[-r theme name [theme name ...]]"
#: ../../pelican-themes.rst:18 1f64db909173426dabee822aea3b269b
msgid "[-s theme path [theme path ...]] [-v] [--version]"
msgstr "[-s theme path [theme path ...]] [-v] [--version]"
#: ../../pelican-themes.rst:21 63ef4d44a1db4176b4c3866671a93603
msgid "Optional arguments:"
msgstr "可选参数："
#: ../../pelican-themes.rst:24 348360945a0943ffa8122aad16bf0ec1
msgid "Show the help and exit"
msgstr "显示帮助信息并退出"
#: ../../pelican-themes.rst:26 aaec8d28264b45b7aac617b7140b5b13
msgid "Show the themes already installed"
msgstr "显示已安装的主题"
#: ../../pelican-themes.rst:28 c8d44b6ac6754f4e8e10a39848f042d0
msgid "One or more themes to install"
msgstr "安装一个或多个主题"
#: ../../pelican-themes.rst:30 18077fbf428e476aa218464fb0f18d8d
msgid "One or more themes to remove"
msgstr "移除一个或多个主题"
#: ../../pelican-themes.rst:32 e328d59886be45a6ae9530a0f2bea3ca
msgid ""
"Same as ``--install``, but create a symbolic link instead of copying the "
"theme. Useful for theme development"
msgstr ""
"和 ``--install`` 相同，区别在于此选项仅会创建一个符号链接到给定的目录，"
"而不会将主题完整拷贝。一般用于主题的开发"
#: ../../pelican-themes.rst:35 481c7a32a5e6400d83c9e2e56e6b94a4
msgid "Verbose output"
msgstr "开启详细输出"
#: ../../pelican-themes.rst:37 d7889dd20ac643ecad73e464ec4cfa55
msgid "Print the version of this script"
msgstr "显示此工具的版本信息"
#: ../../pelican-themes.rst:42 5c3d3aabd5304e8f9a6f0593824f1da6
msgid "Examples"
msgstr "例子"
#: ../../pelican-themes.rst:46 4d6ff63aae06482dbf22f41d4111b001
msgid "Listing the installed themes"
msgstr "列出已安装主题"
#: ../../pelican-themes.rst:48 91a9e942ea36479999586426afead753
msgid ""
"With ``pelican-themes``, you can see the available themes by using the "
"``-l`` or ``--list`` option:"
msgstr ""
"在 ``pelican-themes`` 中使用 ``-l`` 或 ``--list`` 选项，查看可用主题："
#: ../../pelican-themes.rst:62 7a2f7dc98fcc45cabc4639576d503c28
msgid ""
"In this example, we can see there are three themes available: "
"``notmyidea``, ``simple``, and ``two-column``."
msgstr ""
"在上面的例子中，可以看到有三个主题可供使用： ``notmyidea`` 、 "
"``simple`` 、和 ``two-column`` 。"
#: ../../pelican-themes.rst:65 8c03dfa908114d92b8a9aeb6673555ce
msgid ""
"``two-column`` is followed by an ``@`` because this theme is not copied "
"to the Pelican theme path, but is instead just linked to it (see "
"`Creating symbolic links`_ for details about creating symbolic links)."
msgstr ""
"主题 ``two-column`` 后有一个 ``@`` ，这是因为该主题没有被拷贝到Pelican的主题"
"路径下，而只是为其创建了一个符号链接 （详见 `创建符号链接`_ ）。"
#: ../../pelican-themes.rst:69 bc91e8c3ff4a44dd9234d0ab186d8515
msgid ""
"Note that you can combine the ``--list`` option with the ``-v`` or "
"``--verbose`` option to get more verbose output, like this:"
msgstr ""
"当然，你可以将 ``--list`` 选项和 ``-v`` 或 ``--verbose`` 结合起来，从而"
"得到更详细的输出："
#: ../../pelican-themes.rst:81 0b407ed71e6a4b428f5a582b58a47f3c
msgid "Installing themes"
msgstr "安装主题"
#: ../../pelican-themes.rst:83 e95f78a5c3b844b9a6fd2924f455748f
msgid ""
"You can install one or more themes using the ``-i`` or ``--install`` "
"option. This option takes as argument the path(s) of the theme(s) you "
"want to install, and can be combined with the ``--verbose`` option:"
msgstr ""
"使用 ``-i`` 或 ``--install`` 选项可以安装一个或多个主题。此选项将一个"
"或多个到达主题的路径作为参数，同样可以结合 ``--verbose`` 选项："
#: ../../pelican-themes.rst:103 5b20e90396564e08860b2b3a569e7166
msgid "Removing themes"
msgstr "移除主题"
#: ../../pelican-themes.rst:105 2415bf89e3804c9dbdc34814b0132b8c
msgid ""
"The ``pelican-themes`` command can also remove themes from the Pelican "
"themes path. The ``-r`` or ``--remove`` option takes as argument the "
"name(s) of the theme(s) you want to remove, and can be combined with the "
"``--verbose`` option."
msgstr ""
"``pelican-themes`` 命令同样可用于移除Pelican主题文件夹下的主题。 ``-r`` 或 "
"``--remove`` 选项以一个或多个主题的名称为参数，同样也可以结合 ``--verbose`` "
"选项使用。"
#: ../../pelican-themes.rst:122 9ea5149543a648049444220a4041da69
msgid "Creating symbolic links"
msgstr "创建符号链接"
#: ../../pelican-themes.rst:124 17cdf3146683485ea72db5fbd9c1f60a
msgid ""
"``pelican-themes`` can also install themes by creating symbolic links "
"instead of copying entire themes into the Pelican themes path."
msgstr ""
"``pelican-themes`` 也可以通过创建符号链接来安装主题，如此便无需完整拷贝主题。"
#: ../../pelican-themes.rst:127 1d2c60b41c374936a9986a852d50e898
msgid ""
"To symbolically link a theme, you can use the ``-s`` or ``--symlink``, "
"which works exactly as the ``--install`` option:"
msgstr ""
"使用 ``-s`` 或 ``--symlink`` 选项来为主题创建符号链接，用法和 ``--install`` 选项相同："
#: ../../pelican-themes.rst:134 66707a8607f549199dca6f93586d2d87
msgid ""
"In this example, the ``two-column`` theme is now symbolically linked to "
"the Pelican themes path, so we can use it, but we can also modify it "
"without having to reinstall it after each modification."
msgstr ""
"在上面的例子中， ``two-column`` 主题就已经在Pelican主题目录下创建了符号链接，"
"也可以正常使用。如此，当我们修改主题后就无需重新进行安装。"
#: ../../pelican-themes.rst:138 93ec27a473b04bca9d2930a7cb6b609c
msgid "This is useful for theme development:"
msgstr "这对主题的开发是很有用的："
#: ../../pelican-themes.rst:155 66d808308aa64fc9afcef8bdf03bca8b
msgid "Doing several things at once"
msgstr "同时执行多个操作"
#: ../../pelican-themes.rst:157 ace10a2c2f4d4adab9ade60631e82c38
msgid ""
"The ``--install``, ``--remove`` and ``--symlink`` options are not "
"mutually exclusive, so you can combine them in the same command line to "
"do more than one operation at time, like this:"
msgstr ""
"``--install`` 、 ``--remove`` 和 ``--symlink`` 可以同时使用，不会冲突，"
"因此可以在同一行命令中同时做多个操作："
#: ../../pelican-themes.rst:169 e7adbac04b6a40fd986c02e834cc1756
msgid ""
"In this example, the theme ``notmyidea-cms`` is replaced by the theme "
"``notmyidea-cms-fr``"
msgstr ""
"在上面的例子中，用 ``notmyidea-cms-fr`` 替换了 ``notmyidea-cms`` 主题。"

711
docs/locale/zh_CN/LC_MESSAGES/plugins.po Normal file
View file

@ -0,0 +1,711 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-26 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../plugins.rst:4 b1b40bca7d3748008eefe26806d5d5ef
msgid "Plugins"
msgstr "插件"
#: ../../plugins.rst:6 42ca486828e4442a9d74216d0d8bb37d
msgid ""
"Beginning with version 3.0, Pelican supports plugins. Plugins are a way "
"to add features to Pelican without having to directly modify the Pelican "
"core."
msgstr ""
"Pelican从3.0版本开始支持插件。通过插件，不必直接修改Pelican的核心代码就可以给"
"Pelican添加新功能。"
#: ../../plugins.rst:10 6bb8ab4cb7eb44ddb1ed4734f47f6781
msgid "How to use plugins"
msgstr "如何使用插件"
#: ../../plugins.rst:12 822e0bd7ce2f4433a7c39b3accde01a1
msgid ""
"Starting with version 4.5, Pelican moved to a new plugin structure "
"utilizing namespace packages that can be easily installed via Pip_. "
"Plugins supporting this structure will install under the namespace "
"package ``pelican.plugins`` and can be automatically discovered by "
"Pelican. To see a list of Pip-installed namespace plugins that are active"
" in your environment, run::"
msgstr ""
"Pelican从4.5版本开始使用了一种全新的插件结构，利用了命名空间包，"
"并且可以轻松地通过 Pip_ 进行安装。支持此结构地插件都会被安装在命名空间包 "
"``pelican.plugins`` 下，因此Pelican可以自动发现他们。下面的命令可以用于"
"查看环境中用Pip安装的所有插件："
#: ../../plugins.rst:20 2b59c5d107dc4b118dc76116910e9495
msgid ""
"If you leave the ``PLUGINS`` setting as default (``None``), Pelican will "
"automatically discover namespace plugins and register them. If, on the "
"other hand, you specify a ``PLUGINS`` setting as a list of plugins, this "
"auto-discovery will be disabled. At that point, only the plugins you "
"specify will be registered, and you must explicitly list any namespace "
"plugins as well."
msgstr ""
"若将 ``PLUGINS`` 配置项设为默认的 ``None`` ，Pelican会自动发现命名空间中的"
"插件并且将他们全部加载；若你在 ``PLUGINS`` 设置项中指定了一系列的插件，"
"Pelican就不会去自动发现插件，也就是说，你需要显式地指定所有要使用的插件。"
#: ../../plugins.rst:26 52d1968196294569a478931f7022e686
msgid ""
"If you are using the ``PLUGINS`` setting, you can specify plugins in two "
"ways. The first method specifies plugins as a list of strings. Namespace "
"plugins can be specified either by their full names "
"(``pelican.plugins.myplugin``) or by their short names (``myplugin``)::"
msgstr ""
"在配置 ``PLUGINS`` 时，有两种方式。一是用字符串列表指定插件的名称，可以是包含"
"命名空间的完整名称（例如 ``pelican.plugins.myplugin`` ），也可以是简短名称"
"（ ``myplugin``）："
#: ../../plugins.rst:35 b2c75e52e66e4000968e744ffa4b89a9
msgid ""
"Alternatively, you can import them in your settings file and pass the "
"modules::"
msgstr ""
"二是在设置文件中先import进来，再将import进的模块放在 ``PLUGINS`` 设置项中："
#: ../../plugins.rst:43 88af9139373f4cd89fa5b958196c9448
msgid ""
"When experimenting with different plugins (especially the ones that deal "
"with metadata and content) caching may interfere and the changes may not "
"be visible. In such cases disable caching with ``LOAD_CONTENT_CACHE = "
"False`` or use the ``--ignore-cache`` command-line switch."
msgstr ""
"在尝试不同的插件时（尤其是那些处理元数据和内容的插件），缓存可能会相互干扰，"
"一些更改不会生效。发生这种情况时，就需要通过设置 ``LOAD_CONTENT_CACHE = False`` "
"或使用 ``--ignore-cache`` 命令行选项禁用缓存。"
#: ../../plugins.rst:48 d0e3cd59052c4a7d995fb5e1e15d9799
msgid ""
"If your plugins are not in an importable path, you can specify a list of "
"paths via the ``PLUGIN_PATHS`` setting. As shown in the following "
"example, paths in the ``PLUGIN_PATHS`` list can be absolute or relative "
"to the settings file::"
msgstr ""
"如果插件处于无法直接进行import的路径，可以在 ``PLUGIN_PATHS`` 配置项中指定这些路径。"
"如下例所示， ``PLUGIN_PATHS`` 中的路径可以是绝对的，也可以是相对于设置文件的："
#: ../../plugins.rst:56 4c3de952a8514e5caea402392b911f0b
msgid "Where to find plugins"
msgstr "在哪儿下载插件"
#: ../../plugins.rst:57 16173c9dceb0409f89964412dd7e71e9
msgid ""
"Namespace plugins can be found in the `pelican-plugins organization`_ as "
"individual repositories. Legacy plugins are located in the `pelican-"
"plugins repository`_ and will be gradually phased out in favor of the "
"namespace versions."
msgstr ""
"新的命名空间插件可以在GitHub的 `pelican-plugins 组织`_ 中找到，每个插件都是"
"一个独立的仓库。而老的插件则可以在GitHub的 `pelican-plugins 仓库`_ 中找到。"
"这些老的插件会逐步淘汰并转移到新的命名空间版本。"
#: ../../plugins.rst:65 a30a9862112b47128f6e7b28c6836f27
msgid ""
"Please note that while we do our best to review and maintain these "
"plugins, they are submitted by the Pelican community and thus may have "
"varying levels of support and interoperability."
msgstr ""
"请注意，尽管我们尽全力审查和维护这些插件，但这些插件是Pelican社区提交的，"
"因此支持性和互操作性程度各不相同。"
#: ../../plugins.rst:70 f4e140c61c0f45ed8ac53dca3b05b1f1
msgid "How to create plugins"
msgstr "如何创建插件"
#: ../../plugins.rst:72 43013c6cf4f34ca09205e8dab0b9fa6d
msgid ""
"Plugins are based on the concept of signals. Pelican sends signals, and "
"plugins subscribe to those signals. The list of available signals is "
"documented in a subsequent section."
msgstr ""
"插件是基于信号这一概念的。Pelican会发送信号，插件则订阅这些信号。可用的信号"
"在下一节会贴出来。"
#: ../../plugins.rst:76 5377a966ab114a29acb61f79eadc632b
msgid ""
"The only rule to follow for plugins is to define a ``register`` callable,"
" in which you map the signals to your plugin logic. Let's take a simple "
"example::"
msgstr ""
"对于插件来说，唯一需要遵循的规则就是一定要定义一个可调用的 ``register`` ，"
"在 ``register`` 中需要将信号映射到插件逻辑上。下面是一个简单的例子："
#: ../../plugins.rst:93 2217318326524c62804ec94e55a4ca20
msgid ""
"Signal receivers are weakly-referenced and thus must not be defined "
"within your ``register`` callable or they will be garbage-collected "
"before the signal is emitted."
msgstr ""
"信号接收器在Pelican中是弱引用的，因此不能将它定义在可调用的 ``register`` 中，"
"否则接收器在信号发送之前就会被回收。"
#: ../../plugins.rst:97 6731cc78478a46c5a0cb51a8cd477318
msgid ""
"If multiple plugins connect to the same signal, plugins will be executed "
"in the order they are connected. With ``PLUGINS`` setting, order will be "
"as defined in the setting. If you rely on auto-discovered namespace "
"plugins, no ``PLUGINS`` setting, they will be connected in the same order"
" they are discovered (same order as ``pelican-plugins`` output). If you "
"want to specify the order explicitly, disable auto-discovery by defining "
"``PLUGINS`` in the desired order."
msgstr ""
"如果多个插件关联到同一个信号，插件将按照它们关联的前后顺序执行。但若设置了 "
"``PLUGINS`` 配置项会以此配置项中的顺序为准。如果您使用了无需PLUGINS设置的新版"
"命名空间插件，它们将按照被探测到的顺序进行连接（与 pelican-plugins 输出的顺序相同）。"
#: ../../plugins.rst:105 6dad534cc0014b78a3638a91cc4a1120
msgid "Namespace plugin structure"
msgstr "命名空间插件的结构"
#: ../../plugins.rst:107 aa6f290c3f4d42558b684d0e3487af95
msgid ""
"Namespace plugins must adhere to a certain structure in order to function"
" properly. They need to be installable (i.e. contain ``setup.py`` or "
"equivalent) and have a folder structure as follows::"
msgstr ""
"命名空间插件必须遵循特定的结构才能正常工作。这些插件需要是可安装的"
"（即包含 ``setup.py`` 或其他等效文件），并且遵循下述文件夹结构："
#: ../../plugins.rst:120 b8d73cfdb5f042cca1705f97d693263d
msgid ""
"It is crucial that ``pelican`` or ``pelican/plugins`` folder **not** "
"contain an ``__init__.py`` file. In fact, it is best to have those "
"folders empty besides the listed folders in the above structure and keep "
"your plugin related files contained solely in the "
"``pelican/plugins/myplugin`` folder to avoid any issues."
msgstr ""
"非常关键的一点就是， ``pelican`` 和 ``pelican/plugins`` 文件夹下都 **不能** 包含 "
"``__init__.py`` 文件。事实上，这两个文件夹下最好是只有上面列出的文件夹，"
"并且保证与插件相关的文件都仅包含在 ``pelican/plugins/myplugin`` 文件夹中，"
"以避免奇奇怪怪的问题。"
#: ../../plugins.rst:126 c3f08ae8c0d7415098157bbd1c99ce08
msgid ""
"To easily set up the proper structure, a `cookiecutter template for "
"plugins`_ is provided. Refer to that project's README for instructions on"
" how to use it."
msgstr ""
"为了让大家更容易就能建立正确的结构，我们为插件提供了一个 `cookiecutter模板`_ ，"
"使用方法参考此项目README文件中的指示即可。"
#: ../../plugins.rst:132 c2321eec3dc84224918172c5040a259f
msgid "List of signals"
msgstr "信号列表"
#: ../../plugins.rst:134 78c4cfefae7e412f8f6287da2e3c8d34
msgid "Here is the list of currently implemented signals:"
msgstr "下面是目前已经实现了的信号："
#: ../../plugins.rst:137 7a3c3b8b0f114d54b497ab77b09dc558
msgid "Signal"
msgstr "信号"
#: ../../plugins.rst:137 781b5c11f87f43b9ba4b3e75bee696d0
msgid "Arguments"
msgstr "参数"
#: ../../plugins.rst:137 df7d14950fed44f4a4b93908aed36060
msgid "Description"
msgstr "描述"
#: ../../plugins.rst:139 598901e7cb5b49ac9acb5f148bf7c0e7
msgid "initialized"
msgstr "initialized"
#: ../../plugins.rst:139 ../../plugins.rst:140 ../../plugins.rst:158
#: ../../plugins.rst:161 4cedbf9ee7fb4c7abe20e15e4ee1c7fb
#: 704ff7e1ddfc4eb3bd7798d25df1e668 bc98001ef73d419b8f811bbb3d3a571a
#: c9104ccaf84c48d98fafca001ec187e2
msgid "pelican object"
msgstr "pelican object"
#: ../../plugins.rst:140 6f1a09178e2c44c9bda76ed0c0025bef
msgid "finalized"
msgstr "finalized"
#: ../../plugins.rst:140 175a1d1ab8374325812a00cfd581e54e
msgid ""
"invoked after all the generators are executed and just before pelican "
"exits useful for custom post processing actions, such as: - minifying "
"js/css assets. - notify/ping search engines with an updated sitemap."
msgstr ""
"所有generator执行完成后调用，即pelican退出之前。这对于自定义后处理操作是"
"非常有用的，例如可以简化js/css资源、向搜索引擎告知更新后的sitemap。"
#: ../../plugins.rst:144 8d390b6db281423d92a4d7bd4921b4b4
msgid "generator_init"
msgstr "generator_init"
#: ../../plugins.rst:144 fef4d6e70a4c4365be408a5f1579135c
msgid "generator"
msgstr "generator"
#: ../../plugins.rst:144 dbe5ff1590dc4df38cb8fd234708c7bd
msgid "invoked in the Generator.__init__"
msgstr "在Generator.__init__中调用"
#: ../../plugins.rst:145 0324812d14d9452fbf28c286c2a10834
msgid "all_generators_finalized"
msgstr "all_generators_finalized"
#: ../../plugins.rst:145 f6170ebf34b247868d149f0efca462b3
msgid "generators"
msgstr "generators"
#: ../../plugins.rst:145 d67dff93c28146498074abbf3aeb5103
msgid "invoked after all the generators are executed and before writing output"
msgstr "在所有generator执行完后，写入输出内容前调用，"
#: ../../plugins.rst:146 0e9feed7804b4bbdb23711f9d6ad4f40
msgid "readers_init"
msgstr "readers_init"
#: ../../plugins.rst:146 f0de00423c104ecd8e60fb3450b534b4
msgid "readers"
msgstr "readers"
#: ../../plugins.rst:146 b554b35806e34e51bc5ab974fb517541
msgid "invoked in the Readers.__init__"
msgstr "在Readers.__init__中调用"
#: ../../plugins.rst:147 ../../plugins.rst:201 003cdeb23b67433e8cf70c600a42e8e4
#: 7f4a2f6665064a16bcd1b7ea347f5b49
msgid "article_generator_context"
msgstr "article_generator_context"
#: ../../plugins.rst:147 8997b3fd1a8d4efb86245916e50c31b9
msgid "article_generator, metadata"
msgstr "article_generator, metadata"
#: ../../plugins.rst:148 ../../plugins.rst:203 4496df152e48410995ae35f73e3ce0e9
#: f46672e3f919441ba2486f9641752913
msgid "article_generator_preread"
msgstr "article_generator_preread"
#: ../../plugins.rst:148 ../../plugins.rst:150 ../../plugins.rst:151
#: ../../plugins.rst:154 3408ba823f14463196f2296480e25c7d
#: 43b073d3f3ad4a2ba3d0c18447cb7cf6 c776a7323f0a41babb44daf3abfd6b85
#: f47ca0a3f9654ed4b7653fd946b2d9b6
msgid "article_generator"
msgstr "article_generator"
#: ../../plugins.rst:148 94e2a57c5b074d068f051d5de850060c
msgid ""
"invoked before a article is read in ArticlesGenerator.generate_context; "
"use if code needs to do something before every article is parsed"
msgstr ""
"在ArticlesGenerator.generate_context读取文章之前调用；若代码需要在解析每篇文章前"
"执行某些操作，就可以使用此信号。"
#: ../../plugins.rst:150 c58f32123f234e6cafa42aa4ede5bf73
msgid "article_generator_init"
msgstr "article_generator_init"
#: ../../plugins.rst:150 10d3585dc8f94d978643a9c2dc9219a9
msgid "invoked in the ArticlesGenerator.__init__"
msgstr "在ArticlesGenerator.__init__中调用"
#: ../../plugins.rst:151 93ec423e266b4ba9b941a5826e290fec
msgid "article_generator_pretaxonomy"
msgstr "article_generator_pretaxonomy"
#: ../../plugins.rst:151 27290d55819e4bfabe1624059956258f
msgid ""
"invoked before categories and tags lists are created useful when e.g. "
"modifying the list of articles to be generated so that removed articles "
"are not leaked in categories or tags"
msgstr ""
"在创建类别和标签列表之前调用。例如，当需要变更要生成的文章列表时可以使用，"
"如此可以避免一些已移除文章在分类或标签列表中泄露。"
#: ../../plugins.rst:154 ../../plugins.rst:202 12c99acda2ac45debe4fc574a246fc63
#: f3bfb220e59d473bb27601c16f5a1625
msgid "article_generator_finalized"
msgstr "article_generator_finalized"
#: ../../plugins.rst:154 4cb8ed5b4701426b8e1707c6c6b0d48f
msgid "invoked at the end of ArticlesGenerator.generate_context"
msgstr "在ArticlesGenerator.generate_context的最后调用"
#: ../../plugins.rst:155 c19a632018d44ad2b72d5cf6b7cc9c14
msgid "article_generator_write_article"
msgstr "article_generator_write_article"
#: ../../plugins.rst:155 9da20e77d40b45e292ae994fb0fbe97c
msgid "article_generator, content"
msgstr "article_generator, content"
#: ../../plugins.rst:155 a2d5bc3f72b64e47bcaccff3bf27dec2
msgid "invoked before writing each article, the article is passed as content"
msgstr "在写入每篇文章前调用，文章以内容的形式作为参数传入。"
#: ../../plugins.rst:156 0db965f5b99f49e48fc1db531c139f13
msgid "article_writer_finalized"
msgstr "article_writer_finalized"
#: ../../plugins.rst:156 c6af98478be14eb283bb95e7b6a3118c
msgid "article_generator, writer"
msgstr "article_generator, writer"
#: ../../plugins.rst:156 c48e1152864c4249886f3c7ed4ece85b
msgid ""
"invoked after all articles and related pages have been written, but "
"before the article generator is closed."
msgstr ""
"在所有文章及相关联页面写入完成后，在文章generator关闭前调用。"
#: ../../plugins.rst:158 f6af27fc844d43779d581cb4383b97ed
msgid "get_generators"
msgstr "get_generators"
#: ../../plugins.rst:158 b41e27f19c47478a8ece4f43a685f6be
msgid ""
"invoked in Pelican.get_generator_classes, can return a Generator, or "
"several generators in a tuple or in a list."
msgstr ""
"在Pelican.get_generator_classes中调用，可以返回一个Generator，也可以以一个"
"元组或列表的形式返回多个generator。"
#: ../../plugins.rst:161 f23075094c4f46958de609a44850eb6d
msgid "get_writer"
msgstr "get_writer"
#: ../../plugins.rst:161 365671a73e17434f90973ee8e632fa32
msgid "invoked in Pelican.get_writer, can return a custom Writer."
msgstr "在Pelican.get_writer前调用，可以返回一个自定义Writer。"
#: ../../plugins.rst:163 ../../plugins.rst:204 299eef53e530489a9e7366042919059f
#: 917cc78965d84285bc832cecf181ce55
msgid "page_generator_context"
msgstr "page_generator_context"
#: ../../plugins.rst:163 26f64e1dbe854ca287aa0f59b269477c
msgid "page_generator, metadata"
msgstr "page_generator, metadata"
#: ../../plugins.rst:164 ../../plugins.rst:205 c2ec4e60dda142569cdcfe5a311b21a5
#: fcd417f63054406ea7869a2a945dc819
msgid "page_generator_preread"
msgstr "page_generator_preread"
#: ../../plugins.rst:164 ../../plugins.rst:166 ../../plugins.rst:167
#: 89c2d7a279604926a290c2665fe8082a 98ab9a5bc2804442a217233f4ab8a003
#: fca779509f1742e99e3d10a6602561c9
msgid "page_generator"
msgstr "page_generator"
#: ../../plugins.rst:164 295fe11e61ba4f80a145ce06a1ffc777
msgid ""
"invoked before a page is read in PageGenerator.generate_context; use if "
"code needs to do something before every page is parsed."
msgstr ""
"在PageGenerator.generate_context读取页面前调用，若代码需要在解析每个页面前"
"执行某些操作，就可以使用此信号。"
#: ../../plugins.rst:166 ../../plugins.rst:207 4f2b1db9b6054af2b0fd0545082bcafd
#: db8ee3e356d84758b427d9f29d034000
msgid "page_generator_init"
msgstr "page_generator_init"
#: ../../plugins.rst:166 1d4e2e940e0f4dd5a151519aea710454
msgid "invoked in the PagesGenerator.__init__"
msgstr "在PagesGenerator.__init__中调用"
#: ../../plugins.rst:167 ../../plugins.rst:206 319e921c48474a43bbdac4bf43a688f2
#: 5e9b33a48c51417fb5211824b0ad008d
msgid "page_generator_finalized"
msgstr "page_generator_finalized"
#: ../../plugins.rst:167 019fa3fddf2e4725b978326f221c80bd
msgid "invoked at the end of PagesGenerator.generate_context"
msgstr "在PagesGenerator.generate_context的最后调用"
#: ../../plugins.rst:168 0f77c3c609594768a0aaed6529260b97
msgid "page_generator_write_page"
msgstr "page_generator_write_page"
#: ../../plugins.rst:168 0ca5fb200a254cff8529cb5d95e8e26e
msgid "page_generator, content"
msgstr "page_generator, content"
#: ../../plugins.rst:168 164d45dac5ab4df8abd898c1466e186d
msgid "invoked before writing each page, the page is passed as content"
msgstr "在写入每个页面前调用，页面以内容形式作为参数传入"
#: ../../plugins.rst:169 4780473ba6ae47998f891232f122b34a
msgid "page_writer_finalized"
msgstr "page_writer_finalized"
#: ../../plugins.rst:169 6c516a5ae777406ca9ed7bf27b7124c7
msgid "page_generator, writer"
msgstr "page_generator, writer"
#: ../../plugins.rst:169 e8978d0fb878427cbf686608c593aa67
msgid ""
"invoked after all pages have been written, but before the page generator "
"is closed."
msgstr "调用于所有页面写入完成后，在页面generator关闭前。"
#: ../../plugins.rst:171 ../../plugins.rst:208 47bf9969c38b4fef9e15e9d7ea67630e
#: d9a3d5d939d4499b9320ea15dbd3f26e
msgid "static_generator_context"
msgstr "static_generator_context"
#: ../../plugins.rst:171 47064012c4e447f5a1f087a7af420f8f
msgid "static_generator, metadata"
msgstr "static_generator, metadata"
#: ../../plugins.rst:172 ../../plugins.rst:209 7050e1889934465a8837ba65fa249118
#: f45c31c591fd450badd89a7f87c6f991
msgid "static_generator_preread"
msgstr "static_generator_preread"
#: ../../plugins.rst:172 ../../plugins.rst:175 ../../plugins.rst:176
#: 1e99fc14855a4a2e8d1f4758e12792d9 45cdf5c2a8d049889b4315d1ea78f462
#: b7ae37b94f2f44feb24ac32b0cdfa447
msgid "static_generator"
msgstr "static_generator"
#: ../../plugins.rst:172 431017db31bf439f8d3fb5e16b020376
msgid ""
"invoked before a static file is read in StaticGenerator.generate_context;"
" use if code needs to do something before every static file is added to "
"the staticfiles list."
msgstr ""
"在StaticGenerator.generate_context读取静态文件前调用，若代码需要在每个静态文件"
"加入静态文件列表前进行一些修改，就可以使用此信号。"
#: ../../plugins.rst:175 2a380c26f2984e659ec36248a543a4c3
msgid "static_generator_init"
msgstr "static_generator_init"
#: ../../plugins.rst:175 832447303775460c83743d831aa58290
msgid "invoked in the StaticGenerator.__init__"
msgstr "在StaticGenerator.__init__中调用"
#: ../../plugins.rst:176 b01307445d54485a9036fb0f9619ff78
msgid "static_generator_finalized"
msgstr "static_generator_finalized"
#: ../../plugins.rst:176 2f7e7e25668b44fc824bb39270c3de96
msgid "invoked at the end of StaticGenerator.generate_context"
msgstr "在StaticGenerator.generate_context的最后调用"
#: ../../plugins.rst:177 2a34785767ee416dbe41a6aa1f7e4ab1
msgid "content_object_init"
msgstr "content_object_init"
#: ../../plugins.rst:177 c41d8a8653a94d648b573b5c13db3954
msgid "content_object"
msgstr "content_object"
#: ../../plugins.rst:177 379b6d76d2f14d05bf1502d2c55b125f
msgid "invoked at the end of Content.__init__"
msgstr "在Content.__init__的最后调用"
#: ../../plugins.rst:178 10761aa6a1d54ee0a28e562bdacffebf
msgid "content_written"
msgstr "content_written"
#: ../../plugins.rst:178 001ad90e09ab4b21a702b2ed9771a156
msgid "path, context"
msgstr "path, context"
#: ../../plugins.rst:178 69b05b02e1564fe4b48dbd2926fdaec3
msgid "invoked each time a content file is written."
msgstr "每一次内容文件写入后调用。"
#: ../../plugins.rst:179 30938518f54f46028c8fd03808471be7
msgid "feed_generated"
msgstr "feed_generated"
#: ../../plugins.rst:179 e29bf37e7114454099baa21955b7fce0
msgid "context, feed"
msgstr "context, feed"
#: ../../plugins.rst:179 366ba164593242309dab922c36667dc3
msgid ""
"invoked each time a feed gets generated. Can be used to modify a feed "
"object before it gets written."
msgstr "每个feed生成前调用。可以用于在feed写入前修改之。"
#: ../../plugins.rst:181 0b6d7fc85d374b9c82c60d4a0df69fcd
msgid "feed_written"
msgstr "feed_written"
#: ../../plugins.rst:181 d3fdc3a669e9418b9f6e738c549fa151
msgid "path, context, feed"
msgstr "path, context, feed"
#: ../../plugins.rst:181 3da952e464034f8c8491caa94f0aec2d
msgid "invoked each time a feed file is written."
msgstr "每一个feed文件写入后调用。"
#: ../../plugins.rst:186 24bf768827184a8a9c2ad9d23d3549e4
msgid ""
"Avoid ``content_object_init`` signal if you intend to read ``summary`` or"
" ``content`` properties of the content object. That combination can "
"result in unresolved links when :ref:`ref-linking-to-internal-content` "
"(see `pelican-plugins bug #314`_). Use ``_summary`` and ``_content`` "
"properties instead, or, alternatively, run your plugin at a later stage "
"(e.g. ``all_generators_finalized``)."
msgstr ""
"请避免使用 ``content_object_init`` 信号读取content对象的 ``summary`` 或 "
"``content`` 属性，这可能导致在 :ref:`ref-linking-to-internal-content` 时无法"
"解析链接（请参阅 `pelican-plugins bug #314`_ ）。请改用 ``_summary`` 和 "
"``_content`` 属性，或者就在后续阶段再运行插件（例如 ``all_generators_finalized`` 时）。"
#: ../../plugins.rst:195 9222300d10c74a9eb27fc229488e63a4
msgid ""
"After Pelican 3.2, signal names were standardized. Older plugins may "
"need to be updated to use the new names:"
msgstr ""
"Pelican3.2之后，信号名都进行了标准化，较老的插件可能需要进行更新："
#: ../../plugins.rst:199 2ba779a696064672965e17c70f70d927
msgid "Old name"
msgstr "旧名称"
#: ../../plugins.rst:199 d21e933be9064983aa2cfaeca4f00cb9
msgid "New name"
msgstr "新名称"
#: ../../plugins.rst:201 805ac7c62fc94113a3481890793f5417
msgid "article_generate_context"
msgstr "article_generate_context"
#: ../../plugins.rst:202 d6f1a03ae49349b091045c8079b80d44
msgid "article_generate_finalized"
msgstr "article_generate_finalized"
#: ../../plugins.rst:203 c967c8322a744c2c970beb6b98b90743
msgid "article_generate_preread"
msgstr "article_generate_preread"
#: ../../plugins.rst:204 71adeb83fba74317ad0fac5784612a3d
msgid "pages_generate_context"
msgstr "pages_generate_context"
#: ../../plugins.rst:205 d2297a5ec351411e8a66a74d8168caa0
msgid "pages_generate_preread"
msgstr "pages_generate_preread"
#: ../../plugins.rst:206 fb572935b7f445d298ff2c9c89c59c4e
msgid "pages_generator_finalized"
msgstr "pages_generator_finalized"
#: ../../plugins.rst:207 0bb615d8a6f643a3a1a9abac2ec4f712
msgid "pages_generator_init"
msgstr "pages_generator_init"
#: ../../plugins.rst:208 beddb5f81a62458b87c0703355a7b5a4
msgid "static_generate_context"
msgstr "static_generate_context"
#: ../../plugins.rst:209 8fe8895dcb464e11bb01657e975f1352
msgid "static_generate_preread"
msgstr "static_generate_preread"
#: ../../plugins.rst:213 44b14caddfd245c18cacd755fd0023e9
msgid "Recipes"
msgstr "具体使用方法举例"
#: ../../plugins.rst:215 c24473f41cc84d028c99fa56af636037
msgid ""
"We eventually realised some of the recipes to create plugins would be "
"best shared in the documentation somewhere, so here they are!"
msgstr ""
"下面分享了一些创建插件的具体方法，请享用！"
#: ../../plugins.rst:219 96de26e8150e4339b3461d2dcc478cf3
msgid "How to create a new reader"
msgstr "如何创建一个新的reader"
#: ../../plugins.rst:221 3f26c1183b814401b333bbd8528675d9
msgid ""
"One thing you might want is to add support for your very own input "
"format. While it might make sense to add this feature in Pelican core, we"
" wisely chose to avoid this situation and instead have the different "
"readers defined via plugins."
msgstr ""
"你可能需要添加对输入文件格式的特殊支持。这似乎可以作为Pelican核心的一个功能，"
"但我们选择避免将此功能放在核心中，而是通过插件实现不同的reader。"
#: ../../plugins.rst:226 8167dcbaa6864da3b2262a2a99e08a15
msgid ""
"The rationale behind this choice is mainly that plugins are really easy "
"to write and don't slow down Pelican itself when they're not active."
msgstr ""
"做出这个决定主要是因为实现这样的格式支持插件非常容易，而且这样在不需要此功能时"
"也不会影响Pelican自身的速度。"
#: ../../plugins.rst:229 26c8185062964b52921860cfa2ce508c
msgid "No more talking — here is an example::"
msgstr "多说无益，下面是一个具体例子："
#: ../../plugins.rst:265 ea51efb1925f45e79c87d6e5488cbbcd
msgid "Adding a new generator"
msgstr "添加新的generator"
#: ../../plugins.rst:267 9e04f17a5fa1488d82d3629edf8cdf3f
msgid ""
"Adding a new generator is also really easy. You might want to have a look"
" at :doc:`internals` for more information on how to create your own "
"generator."
msgstr ""
"添加一个generator也非常简单，你可能会想要看一看 :doc:`internals` ，其中有关于"
"如何创建generator的内容。"
#: ../../plugins.rst:281 f4c92958e88a41a7a0deee697b48fc58
msgid "Adding a new writer"
msgstr "添加新的writer"
#: ../../plugins.rst:283 188bf0e8a68446458ae525c67cfe098c
msgid ""
"Adding a writer will allow you to output additional file formats to disk,"
" or change how the existing formats are written to disk. Note that only "
"one writer will be active at a time, so be sure to either subclass the "
"built-in Writer, or completely re-implement it."
msgstr ""
"添加writer可以让你将其他文件格式输出到磁盘，或者可以改变现有格式写入磁盘的方式。"
"请注意，一次只能启用一个writer，因此请确保继承了内置的Writer，并且完全重新实现之。"
#: ../../plugins.rst:288 edb5d1fa15bc48859c2912ba7c344286
msgid "Here is a basic example of how to set up your own writer::"
msgstr "下面是启用你的自定义writer的一个基本例子："
#: ../../plugins.rst:308 0df8f3318357472cbd72e17e1b5085b2
msgid "Using Plugins to Inject Content"
msgstr "使用插件添加内容"
#: ../../plugins.rst:310 d0161dbe86c44111a6295259ec8cab54
msgid ""
"You can programmatically inject articles or pages using plugins. This can"
" be useful if you plan to fetch articles from an API, for example."
msgstr ""
"可以通过插件以可编程的方式添加文章或页面。如果你打算从某些API获取文章，这就会很有用。"
#: ../../plugins.rst:313 5d5c41dbeb7243d4b497752771bc7858
msgid ""
"Following is a simple example of how one can build a plugin that injects "
"a custom article, using the ``article_generator_pretaxonomy`` signal::"
msgstr ""
"下面是一个简单的示例，说明了如何使用 ``article_generator_pretaxonomy`` "
"信号构建一个添加自定义文章的插件："

329
docs/locale/zh_CN/LC_MESSAGES/publish.po Normal file
View file

@ -0,0 +1,329 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-25 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../publish.rst:2 65617cfb871b492589d55186b708a1ce
msgid "Publish your site"
msgstr "发布站点"
#: ../../publish.rst:7 dc4c9b1c1afd477d906b892dc592bdcd
msgid "Site generation"
msgstr "站点生成"
#: ../../publish.rst:9 610c37360e2b49ec8ea630ddc224d2b7
msgid ""
"Once Pelican is installed and you have some content (e.g., in Markdown or"
" reST format), you can convert your content into HTML via the ``pelican``"
" command, specifying the path to your content and (optionally) the path "
"to your :doc:`settings<settings>` file::"
msgstr ""
"您应该已经安装好Pelican并且已经创作了一些内容了吧（以Markdown或是reST格式），"
"现在就可以将这些内容通过 ``pelican`` 命令转换为HTML了，在转换时需要指定"
"创作内容存放的路径；如果有需要， :doc:`配置<settings>` 文件的路径也可单独指定："
#: ../../publish.rst:16 6f353c84f5204d2b84c49d1557010b19
msgid ""
"The above command will generate your site and save it in the ``output/`` "
"folder, using the default theme to produce a simple site. The default "
"theme consists of very simple HTML without styling and is provided so "
"folks may use it as a basis for creating their own themes."
msgstr ""
"上面的指令会在 ``output/`` 目录下生成站点，使用的是默认的主题。默认主题只使用"
"一些简单的HTML并且不包含样式，大家往往以这个简单主题为基础来创作自己的主题。"
#: ../../publish.rst:21 bb5064d57ed144e6b85d7d3d0938f91c
msgid ""
"You can also tell Pelican to watch for your modifications, instead of "
"manually re-running it every time you want to see your changes. To enable"
" this, run the ``pelican`` command with the ``-r`` or ``--autoreload`` "
"option. On non-Windows environments, this option can also be combined "
"with the ``-l`` or ``--listen`` option to simultaneously both auto-"
"regenerate *and* serve the output at http://localhost:8000::"
msgstr ""
"你也可以让Pelican来监听对源内容文件的修改，而不是在每次修改内容后重新手动执行命令"
"来生成站点。在执行 ``pelican`` 命令时，加上 ``-r`` 或者 ``--autoreload`` 选项"
"就可以做到这一点。在非Windows环境下，这个选项还可以和 ``-l`` 或 ``--listen`` "
"搭配使用，这样就可以在自动重生成站点的基础上，同时提供在 http://localhost:8000 "
"上的访问："
#: ../../publish.rst:30 40089a6762204e27bd16afaa038a8277
msgid ""
"Pelican has other command-line switches available. Have a look at the "
"help to see all the options you can use::"
msgstr ""
"Pelican还有一些其他的命令行选项。可以在帮助中看到所有可用选项："
#: ../../publish.rst:36 4484bb6f6e2b4bd49027c98be4fa2cd8
msgid "Viewing the generated files"
msgstr "浏览生成的文件"
#: ../../publish.rst:38 4dc83b844c964bcab17af21fabd5e6b2
msgid ""
"The files generated by Pelican are static files, so you don't actually "
"need anything special to view them. You can use your browser to open the "
"generated HTML files directly::"
msgstr ""
"Pelican生成的文件都是静态的，也就是说不需要使用什么特殊的手段就可以浏览。"
"您可以直接使用浏览器打开生成的HTML文件："
#: ../../publish.rst:44 c5774634f7da4f64bb7c7d0adbcdb65b
msgid ""
"Because the above method may have trouble locating your CSS and other "
"linked assets, running Pelican's simple built-in web server will often "
"provide a more reliable previewing experience::"
msgstr ""
"事实上，上面所说的直接打开的方式可能会使CSS或其他链接上出现问题，"
"可以运行Pelican自带的简易web服务器，如此便可以获得可靠的预览体验："
#: ../../publish.rst:50 b2eab6914b854b40bd769433fbad21b7
msgid ""
"Once the web server has been started, you can preview your site at: "
"http://localhost:8000/"
msgstr ""
"当web服务器启动后，可以访问 http://localhost:8000/ 来预览您的站点。"
#: ../../publish.rst:54 3b7344cad46a4dfaa01c067dd1f4009b
msgid "Deployment"
msgstr "部署"
#: ../../publish.rst:56 de2815c211b84291a985a1d808ffbfe7
msgid ""
"After you have generated your site, previewed it in your local "
"development environment, and are ready to deploy it to production, you "
"might first re-generate your site with any production-specific settings "
"(e.g., analytics, feeds, etc.) that you may have defined::"
msgstr ""
"当您生成好站点后，可以在本地先进行预览，确认无误后，在部署前可能还需使用"
"生产环境特定的配置文件重新生成站点："
#: ../../publish.rst:63 56e568114b72443ebcf1f741f07504dc
msgid ""
"To base your publish configuration on top of your ``pelicanconf.py``, you"
" can import your ``pelicanconf`` settings by including the following line"
" in your ``publishconf.py``::"
msgstr ""
"您可以基于 ``pelicanconf.py`` 进行设置文件的配置， 在 ``publishconf.py`` "
"中import ``pelicanconf`` 就可实现（译者注：配置文件其实本质上就是一些"
"Python变量，因此import后就可以全部引入）："
#: ../../publish.rst:69 b9e1243ed9ba409890d86ef8ff85499d
msgid ""
"If you have generated a ``publishconf.py`` using ``pelican-quickstart``, "
"this line is included by default."
msgstr ""
"如果 ``publishconf.py`` 是通过 ``pelican-quickstart`` 生成的，上面这行默认就有。"
#: ../../publish.rst:72 39671d42b0bb4c828fc51c63c351402c
msgid ""
"The steps for deploying your site will depend on where it will be hosted."
" If you have SSH access to a server running Nginx or Apache, you might "
"use the ``rsync`` tool to transmit your site files::"
msgstr ""
"部署站点的方法步骤取决于网站托管的位置。对于使用SSH访问的运行着Nginx或"
"Apache的服务器，您可能需要使用 ``rsync`` 工具来传输站点文件："
#: ../../publish.rst:78 523ed256e0164a968d8580310e4a9304
msgid ""
"There are many other deployment options, some of which can be configured "
"when first setting up your site via the ``pelican-quickstart`` command. "
"See the :doc:`Tips<tips>` page for detail on publishing via GitHub Pages."
msgstr ""
"还有很多其他的部署方式供您选择，有一些在第一次通过 ``pelican-quickstart`` "
"命令建立站点时就已经配置。在 :doc:`小技巧<tips>` 中可以查看如何通过"
"Github Pages部署站点。"
#: ../../publish.rst:83 c44ecc79922d419b8627706a6694dd8c
msgid "Automation"
msgstr "自动化"
#: ../../publish.rst:85 b892dcba14a84306aa6b39295b5f81e3
msgid ""
"While the ``pelican`` command is the canonical way to generate your site,"
" automation tools can be used to streamline the generation and "
"publication flow. One of the questions asked during the ``pelican-"
"quickstart`` process pertains to whether you want to automate site "
"generation and publication. If you answered \"yes\" to that question, a "
"``tasks.py`` and ``Makefile`` will be generated in the root of your "
"project. These files, pre-populated with certain information gleaned from"
" other answers provided during the ``pelican-quickstart`` process, are "
"meant as a starting point and should be customized to fit your particular"
" needs and usage patterns. If you find one or both of these automation "
"tools to be of limited utility, these files can be deleted at any time "
"and will not affect usage of the canonical ``pelican`` command."
msgstr ""
"``pelican`` 命令是生成站点的标准方法，但同时也有自动化工具可以用来简化生成与"
"发布流程。在 ``pelican-quickstart`` 的过程中，其中一个问题就是是否启用自动站点"
"生成与发布。若您选择了 “yes”，在项目的根目录中就会生成 ``tasks.py`` "
"和 ``Makefile`` 。这些文件中预填充了一些从 ``pelican-quickstart`` 过程中"
"收集的信息，您应该从这个生成好的文件出发，再根据实际需要进一步修改。"
"另外，如果您认为这些自动化脚本文件没什么用，完全可以将他们删除，这不会对标准命令 "
"``pelican`` 产生任何影响。"
#: ../../publish.rst:98 4c49ca3a24e3462a984dda738875ed4e
msgid ""
"Following are automation tools that \"wrap\" the ``pelican`` command and "
"can simplify the process of generating, previewing, and uploading your "
"site."
msgstr ""
"下面是一些自动化工具，其中包装了 ``pelican`` 命令，可以用于简化生成、预览和"
"上传站点的过程。"
#: ../../publish.rst:102 103fb7405038442aae62b62ea0fcdbe5
msgid "Invoke"
msgstr "Invoke"
#: ../../publish.rst:104 d3e46bf8da96489e923f6497e8932538
msgid ""
"The advantage of Invoke_ is that it is written in Python and thus can be "
"used in a wide range of environments. The downside is that it must be "
"installed separately. Use the following command to install Invoke, "
"prefixing with ``sudo`` if your environment requires it::"
msgstr ""
"Invoke_ 工具使用Python作为编程语言，并且能够用在很多不同的环境中。它需要使用"
"下面的命令单独安装，在某些操作系统中可能需要在前面加上 ``sudo`` ："
#: ../../publish.rst:111 786359d08e8f45598df7b1c45e32ca0a
msgid ""
"Take a moment to open the ``tasks.py`` file that was generated in your "
"project root. You will see a number of commands, any one of which can be "
"renamed, removed, and/or customized to your liking. Using the out-of-the-"
"box configuration, you can generate your site via::"
msgstr ""
"可以打开 ``tasks.py`` 文件看看其中的代码，可以尝试更改和删除其中的命令，"
"也可以按照您的喜好自行进行其他修改。生成好的文件是开箱即用的，您可以通过"
"下面的命令生成站点："
#: ../../publish.rst:118 ../../publish.rst:166 04c6045b58c24bc1a1fd594cdcf4ef5c
#: 1e9cf29276ec4446b1b0f4a55a1ef4b8
msgid ""
"If you'd prefer to have Pelican automatically regenerate your site every "
"time a change is detected (which is handy when testing locally), use the "
"following command instead::"
msgstr ""
"若您希望Pelican在检测到变化时自动重新生成站点（在本地测试的时候很实用），"
"可以使用下面的命令："
#: ../../publish.rst:124 ../../publish.rst:172 fabe0ce08eca4c5ebd9ca65898dab138
#: ff42351e29b944a59e8df22b1cbb20f5
msgid ""
"To serve the generated site so it can be previewed in your browser at "
"http://localhost:8000/::"
msgstr ""
"下面的命令则可以让您在生成后通过浏览器访问 http://localhost:8000/ 来预览站点"
#: ../../publish.rst:129 e1b12a6c64b246f89aea105b8d7febbc
msgid ""
"To serve the generated site with automatic browser reloading every time a"
" change is detected, first ``python -m pip install livereload``, then use"
" the following command::"
msgstr ""
"在每次检测到修改重生成站点后，可以让浏览器自动进行重载。先运行 "
"``python -m pip install livereload`` 安装，再运行下面的这条命令就可以实现："
#: ../../publish.rst:135 bf0d6c7770fe4a399b81b9ebdd48fa4e
msgid ""
"If during the ``pelican-quickstart`` process you answered \"yes\" when "
"asked whether you want to upload your site via SSH, you can use the "
"following command to publish your site via rsync over SSH::"
msgstr ""
"如果在 ``pelican-quickstart`` 过程中，对是否要通过SSH上传站点问题回答了“yes”，"
"您就可以使用下面的命令借助rsync在SSH上发布站点："
#: ../../publish.rst:141 9bea9f82ce164ee5ba07349a4c4d58ea
msgid ""
"These are just a few of the commands available by default, so feel free "
"to explore ``tasks.py`` and see what other commands are available. More "
"importantly, don't hesitate to customize ``tasks.py`` to suit your "
"specific needs and preferences."
msgstr ""
"默认就可以使用的命令远不止这些，在 ``tasks.py`` 中可以找到更多可用的命令。"
"更重要的是，当您有特定需求和偏好时，直接修改 ``tasks.py`` 即可。"
#: ../../publish.rst:147 06a6e7232c6243d79ab9f43ddc28590d
msgid "Make"
msgstr "Make"
#: ../../publish.rst:149 a2a5b589cf804fcd83ee2d0fbf98c12d
msgid ""
"A ``Makefile`` is also automatically created for you when you say \"yes\""
" to the relevant question during the ``pelican-quickstart`` process. The "
"advantage of this method is that the ``make`` command is built into most "
"POSIX systems and thus doesn't require installing anything else in order "
"to use it. The downside is that non-POSIX systems (e.g., Windows) do not "
"include ``make``, and installing it on those systems can be a non-trivial"
" task."
msgstr ""
"``Makefile`` 也是自动生成的。在大多数POSIX系统中都内置了 ``make`` 命令，"
"无需安装即可使用。但在非POSIX系统（例如Windows）中并没有 ``make`` ，在这些"
"系统中安装 ``make`` 则往往比较麻烦。"
#: ../../publish.rst:156 68c38c3eb34e4e6ca9cd4a2d3646d5cb
msgid ""
"If you want to use ``make`` to generate your site using the settings in "
"``pelicanconf.py``, run::"
msgstr ""
"使用 ``make`` 命令是以 ``pelicanconf.py`` 作为配置文件来生成站点的："
#: ../../publish.rst:161 133e6e1ebf92412a85eedbe56e0b91af
msgid ""
"To generate the site for production, using the settings in "
"``publishconf.py``, run::"
msgstr ""
"使用 ``publishconf.py`` 作为配置文件来为生产环境生成站点："
#: ../../publish.rst:177 f4e250949c2145ceb03b65c875767abc
msgid ""
"Normally you would need to run ``make regenerate`` and ``make serve`` in "
"two separate terminal sessions, but you can run both at once via::"
msgstr ""
"一般来说， ``make regenerate`` 和 ``make serve`` 需要在分别在单独的终端会话中"
"运行，下面的命令相当于同时运行上述两个命令："
#: ../../publish.rst:182 1f83bbcf60134eef959370bb5ca402d9
msgid ""
"The above command will simultaneously run Pelican in regeneration mode as"
" well as serve the output at http://localhost:8000."
msgstr ""
"上面的命令会让Pelican在重生成模式下持续运行，同样地，您可以通过 "
"http://localhost:8000 访问生成的站点。"
#: ../../publish.rst:185 9274a68b1e3b4639bf638a044eda613d
msgid ""
"When you're ready to publish your site, you can upload it via the "
"method(s) you chose during the ``pelican-quickstart`` questionnaire. For "
"this example, we'll use rsync over ssh::"
msgstr ""
"当准备好发布站点时，可以使用在 ``pelican-quickstart`` 过程中选择的方法进行上传。"
"下面的例子使用rsync在ssh上完成这一工作："
#: ../../publish.rst:191 9d7e7927c183491f981aacebe14e5bf1
msgid "That's it! Your site should now be live."
msgstr "OK！您的站点现在已经可以访问了。"
#: ../../publish.rst:193 8f570acd5f494f5b9645fdbca6db6fbb
msgid ""
"(The default ``Makefile`` and ``devserver.sh`` scripts use the ``python``"
" and ``pelican`` executables to complete its tasks. If you want to use "
"different executables, such as ``python3``, you can set the ``PY`` and "
"``PELICAN`` environment variables, respectively, to override the default "
"executable names.)"
msgstr ""
"（默认的 ``Makefile`` 和 ``devserver.sh`` 脚本执行 ``python`` 和 ``pelican`` "
"来完成任务。若您希望使用其他的可执行文件，例如 ``python3`` ，设置环境变量 ``PY`` "
"和 ``PELICAN`` 来覆盖默认的可执行文件名）"

151
docs/locale/zh_CN/LC_MESSAGES/quickstart.po Normal file
View file

@ -0,0 +1,151 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-25 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../quickstart.rst:2 e5f32d61440744aab3f878488ef9e1e3
msgid "Quickstart"
msgstr "快速开始"
#: ../../quickstart.rst:4 d3762ec7c3934f85b25b04cf4024a90c
msgid ""
"Reading through all the documentation is highly recommended, but for the "
"truly impatient, following are some quick steps to get started."
msgstr ""
"强烈建议将所有文档完整地看一遍，但如果您目前没空，下面的步骤可以帮助您快速开始"
"使用Pelican。"
#: ../../quickstart.rst:8 c5982d5ecf7c445590254370b84995be
msgid "Installation"
msgstr "安装"
#: ../../quickstart.rst:10 fda7d08c05f14e2fa0c07a4a1d216db5
msgid ""
"Install Pelican (and optionally Markdown if you intend to use it) on "
"Python |min_python| by running the following command in your preferred "
"terminal, prefixing with ``sudo`` if permissions warrant::"
msgstr ""
"在命令行中执行下面的命令以安装Pelican（如果您需要Markdown支持的话，也可以同时安装之）。"
"Pelican需要使用 |min_python| 以上版本的Python。在必要情况下，请在命令前加上 ``sudo`` 。"
#: ../../quickstart.rst:17 9db650d9dc9d4ac48df4dd9fc0a246ac
msgid "Create a project"
msgstr "创建项目"
#: ../../quickstart.rst:19 2e9a72a878754604abdb27d9ec37937e
msgid ""
"First, choose a name for your project, create an appropriately-named "
"directory for your site, and switch to that directory::"
msgstr ""
"首先，给您的项目想个名字，并以合适的名字创建一个文件夹来存放您的站点。"
"接着，进入这个新创建的文件夹："
#: ../../quickstart.rst:25 da759420dd8440b485936a5a054f142a
msgid ""
"Create a skeleton project via the ``pelican-quickstart`` command, which "
"begins by asking some questions about your site::"
msgstr ""
"通过 ``pelican-quickstart`` 命令创建一个项目的框架，执行这个命令后，"
"您需要输入一些站点相关的信息："
#: ../../quickstart.rst:30 eb2d702c9f5a4981a93f805e98674cfe
msgid ""
"For questions that have default values denoted in brackets, feel free to "
"use the Return key to accept those default values [#tzlocal_fn]_. When "
"asked for your URL prefix, enter your domain name as indicated (e.g., "
"``https://example.com``)."
msgstr ""
"对于那些在括号中写了默认值的问题，完全可以直接回车以使用预设值 [#tzlocal_fn]_。"
"在输入站点URL的前缀（prefix）时，请根据提示的格式输入站点的域名（例如 "
"``https://example.com``）。"
#: ../../quickstart.rst:36 66d29d63cce0488a8ec9e43ce97035f9
msgid "Create an article"
msgstr "创作文章"
#: ../../quickstart.rst:38 03af35552ef84e4491b46d8bf8c0f51e
msgid ""
"You cannot run Pelican until you have created some content. Use your "
"preferred text editor to create your first article with the following "
"content::"
msgstr ""
"您可以使用喜欢的文本编辑器来创建第一篇文章。下面是一个样例，可以将它作为您的第一篇文章："
#: ../../quickstart.rst:47 165d46a3f9da4f949375c70115fdeb3b
msgid ""
"Given that this example article is in Markdown format, save it as "
"``~/projects/yoursite/content/keyboard-review.md``."
msgstr ""
"上面这篇文章是以Markdown的格式完成的，一定要将其保存在站点目录的content文件夹下，例如 "
"``~/projects/yoursite/content/keyboard-review.md``。"
#: ../../quickstart.rst:51 5cc306848439434f81708eddee812f0e
msgid "Generate your site"
msgstr "生成站点"
#: ../../quickstart.rst:53 03037d0c3b0b4a64b957f8284f008c9d
msgid ""
"From your project root directory, run the ``pelican`` command to generate"
" your site::"
msgstr ""
"在项目的根目录下，直接运行命令 ``pelican`` 就可以生成您自己的站点了："
#: ../../quickstart.rst:57 abadae17b6f94e36b8603bad69f6e24f
msgid ""
"Your site has now been generated inside the ``output/`` directory. (You "
"may see a warning related to feeds, but that is normal when developing "
"locally and can be ignored for now.)"
msgstr ""
"站点会生成在 ``output/`` 目录下。（此时可能会显示和feeds有关的警告，这和当前的"
"本地开发环境有关，目前可以忽略之）"
#: ../../quickstart.rst:62 7cf36e609f544f02a0c800f8412cf79c
msgid "Preview your site"
msgstr "预览站点"
#: ../../quickstart.rst:64 1a64015c5cc9401bac0a6ac953164fb3
msgid ""
"Open a new terminal session, navigate to your project root directory, and"
" run the following command to launch Pelican's web server::"
msgstr ""
"打开一个新的命令行，进入刚才项目的根目录，执行下面的命令以运行一个Pelican web服务器："
#: ../../quickstart.rst:69 eb286b4785304d22a46e90884d26de07
msgid "Preview your site by navigating to http://localhost:8000/ in your browser."
msgstr "打开浏览器，进入 http://localhost:8000/ 就可以看到刚刚生成的站点了。"
#: ../../quickstart.rst:71 1dc30b5cb267402c9da251303ff59dbf
msgid ""
"Continue reading the other documentation sections for more detail, and "
"check out the Pelican wiki's Tutorials_ page for links to community-"
"published tutorials."
msgstr ""
"请继续阅读文档中的其他部分来了解Pelican的更多用法，也可以前往Pelican的"
"wiki 教程_ 页面获取社区发布的教程。"
#: ../../quickstart.rst:78 6c135ea1cbb44400b446c0f9074e0fc5
msgid "Footnotes"
msgstr "脚注"
#: ../../quickstart.rst:80 911df4217fd94e6184502153ed0e53dc
msgid ""
"You can help localize default fields by installing the optional `tzlocal "
"<https://pypi.org/project/tzlocal/>`_ module."
msgstr ""
"您可以安装可选模块 `tzlocal <https://pypi.org/project/tzlocal/>`_ 来"
"本地化默认字段。"

249
docs/locale/zh_CN/LC_MESSAGES/report.po Normal file
View file

@ -0,0 +1,249 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../report.rst:2 bc25575efa494c7b9455e02eb5c514ab
msgid "Some history about Pelican"
msgstr "Pelican的一些历史"
#: ../../report.rst:6 959bbe068d2e4fd19e48be22706070d2
msgid ""
"This page comes from a report the original author (Alexis Métaireau) "
"wrote right after writing Pelican, in December 2010. The information may "
"not be up-to-date."
msgstr ""
"此页面来自原作者 Alexis Métaireau 在2010年12月完成Pelican后作的一篇报告，因此"
"其中涉及的具体内容可能和最新的Pelican有些出入。"
#: ../../report.rst:10 598beb4776eb4a7bb1c928979752b1f1
msgid ""
"Pelican is a simple static blog generator. It parses markup files "
"(Markdown or reStructuredText for now) and generates an HTML folder with "
"all the files in it. I've chosen to use Python to implement Pelican "
"because it seemed to be simple and to fit to my needs. I did not wanted "
"to define a class for each thing, but still wanted to keep my things "
"loosely coupled. It turns out that it was exactly what I wanted. From "
"time to time, thanks to the feedback of some users, it took me a very few"
" time to provide fixes on it. So far, I've re-factored the Pelican code "
"by two times; each time took less than 30 minutes."
msgstr ""
"Pelican是一个简单的静态博客生成器。它解析标记文件（目前主要是Markdown和"
"reStructuredText），并生成一个文件夹，其中包含了对应于标记文件的HTML。由于Python"
"很简单并且符合需求，我选择使用Python来实现Pelican。我不想为每个东西定义一个类，"
"但同时又想要各部件之间低耦合。事实证明，这正是我想要的。在发展过程中，多亏了用户"
"给的反馈，我花了些时间修复了一些问题。到目前为止，我已经将Pelican的代码重构了两次，"
"每次重构都不会超过30分钟。"
#: ../../report.rst:21 1709ab99c3144cb692afd1d1bc388921
msgid "Use case"
msgstr "使用场景"
#: ../../report.rst:23 119f315a8e6c409d98783a636ac2147c
msgid ""
"I was previously using WordPress, a solution you can host on a web server"
" to manage your blog. Most of the time, I prefer using markup languages "
"such as Markdown or reStructuredText to type my articles. To do so, I use"
" vim. I think it is important to let the people choose the tool they want"
" to write the articles. In my opinion, a blog manager should just allow "
"you to take any kind of input and transform it to a weblog. That's what "
"Pelican does. You can write your articles using the tool you want, and "
"the markup language you want, and then generate a static HTML weblog."
msgstr ""
"我之前使用的是WordPress，你可以将它部署在Web服务器上来管理博客。大多数时候，"
"我更喜欢使用Markdown或reStructuredText等标记语言来撰写文章。为此，我一般用vim"
"来写这些文章。我认为让大家自行选择用于写文章的工具是很重要的。在我看来，博客管理器"
"应该能够接受任何类型的输入并将其转换为博客站。Pelican就采取这一思想。您可以选择自己"
"喜欢的工具以及标记语言来撰写文章，然后生成静态的HTML博客站。"
#: ../../report.rst:34 1a087a07690c4c35873a7f4ce18ba52b
msgid ""
"To be flexible enough, Pelican has template support, so you can easily "
"write your own themes if you want to."
msgstr ""
"为了足够的灵活性，Pelican中支持使用模板，这样你就可以编写自己的主题了。"
#: ../../report.rst:38 fca5a0962a0d4c27aa163f2aec94b1cf
msgid "Design process"
msgstr "设计过程"
#: ../../report.rst:40 073dd0b024fa4701acc0078b84c45648
msgid ""
"Pelican came from a need I have. I started by creating a single file "
"application, and I have make it grow to support what it does by now. To "
"start, I wrote a piece of documentation about what I wanted to do. Then, "
"I created the content I wanted to parse (the reStructuredText files) and "
"started experimenting with the code. Pelican was 200 lines long and "
"contained almost ten functions and one class when it was first usable."
msgstr ""
"Pelican来源于我的需求。从单文件应用程序出发，不断成长为现在功能丰富的应用。首先，我"
"写了一份需求文档；然后创建了我想要解析的内容（reStructuredText文件），并开始"
"实验性的编写代码。Pelican的第一个能够使用的版本包含了200行代码、10个函数以及1个类。"
#: ../../report.rst:47 f407fc9ad9434f1082014eeca8c4cc89
msgid ""
"I have been facing different problems all over the time and wanted to add"
" features to Pelican while using it. The first change I have done was to "
"add the support of a settings file. It is possible to pass the options to"
" the command line, but can be tedious if there is a lot of them. In the "
"same way, I have added the support of different things over time: Atom "
"feeds, multiple themes, multiple markup support, etc. At some point, it "
"appears that the \"only one file\" mantra was not good enough for "
"Pelican, so I decided to rework a bit all that, and split this in "
"multiple different files."
msgstr ""
"我不断遇到各种问题，在使用过程中还想要往Pelican中添加功能。在对代码的第一次修改中，"
"添加了对配置文件的支持。虽然可以在命令行中往里传入选项，但当配置项多起来后，就会变得"
"异常冗长。同样地，Pelican支持了越来越多的功能：Atom订阅源、多主体支持、多标记语言"
"支持等等。在某一时刻，单文件应用已经不适合Pelican了，因此我决定多做些工作，将应用分离"
"到多个文件中。"
#: ../../report.rst:56 57b3d1ba492646e28e20396b78df8ea0
msgid "I’ve separated the logic in different classes and concepts:"
msgstr "我将系统整体逻辑分为如下几个类和概念："
#: ../../report.rst:58 2d4090dba6674569a7e1088919185aa5
msgid ""
"*writers* are responsible of all the writing process of the files. They "
"are responsible of writing .html files, RSS feeds and so on. Since those "
"operations are commonly used, the object is created once, and then passed"
" to the generators."
msgstr ""
"**Writers** 负责文件的写入工作，即负责完成 html、RSS订阅源等文件的写入。因为这些"
"操作都是比较常用的，这个类只会被创建一次，然后再传给Generators。"
#: ../../report.rst:63 a4cff6dceb8f430791edaeb3b2280924
msgid ""
"*readers* are used to read from various formats (Markdown and "
"reStructuredText for now, but the system is extensible). Given a file, "
"they return metadata (author, tags, category, etc) and content (HTML "
"formatted)."
msgstr ""
"**Readers** 用于读取不同格式的文件（目前支持Markdown、reStructuredText，"
"但可以继续扩展）。向 **Readers** 输入一个文件，它会返回文档的元数据（作者、标签、"
"分类等等）与HTML格式的文档正文内容。"
#: ../../report.rst:67 6ed9719c06c2477ea05ea30e4806ad14
msgid ""
"*generators* generate the different outputs. For instance, Pelican comes "
"with an ArticlesGenerator and PagesGenerator, into others. Given a "
"configuration, they can do whatever you want them to do. Most of the time"
" it's generating files from inputs (user inputs and files)."
msgstr ""
"**Generators** 用以生成不同的输出，Pelican自带了 ``ArticlesGenerator`` 和 "
"``PageGenerator`` 。给定一套配置信息， **Generators** 可以做几乎任何事。"
"但大多数情况下，它的工作就是从输入生成文件。"
#: ../../report.rst:72 cb5129c105b04d788a908f580a83e7e1
msgid ""
"I also deal with contents objects. They can be ``Articles``, ``Pages``, "
"``Quotes``, or whatever you want. They are defined in the ``contents.py``"
" module and represent some content to be used by the program."
msgstr ""
"同样，还要处理正文对象。正文对象可以是 ``Articles`` 、 ``Pages`` 、 ``Quotes`` "
"或者其他你想要的类型。这些对象在 ``contents.py`` 模块中完成定义，同时代表了应用中"
"使用到的内容。"
#: ../../report.rst:77 4123da2b628448359aa9ed20b2ca87d2
msgid "In more detail"
msgstr "更细节的内容"
#: ../../report.rst:79 8482492940524edf8244fc220553cd3c
msgid "Here is an overview of the classes involved in Pelican."
msgstr "以下是Pelican中涉及的类的概述。"
#: ../../report.rst:83 a8a39a1ccc154604b8bb000dff44982d
msgid ""
"The interface does not really exist, and I have added it only to clarify "
"the whole picture. I do use duck typing and not interfaces."
msgstr ""
"上图中的接口事实上并不存在，我是为了整张图的完整性才加上去的。在实际实现中，使用了"
"鸭子类型而不是接口。"
#: ../../report.rst:86 889dfae0dc4242f0b21ce831c7172001
msgid "Internally, the following process is followed:"
msgstr "应用内部按以下流程进行处理："
#: ../../report.rst:88 fc5cbf8ca65c456c90c56c00cf5ab93f
msgid ""
"First of all, the command line is parsed, and some content from the user "
"is used to initialize the different generator objects."
msgstr ""
"首先，解析命令行，并根据用户给入的一些内容来初始化不同的generator对象。"
#: ../../report.rst:91 5d0c1dc643364248820fad76c204f663
msgid ""
"A ``context`` is created. It contains the settings from the command line "
"and a settings file if provided."
msgstr ""
"创建一个 ``context`` ，其中包含了来自命令行和文件的配置信息。"
#: ../../report.rst:93 36725875f2c14e0bb8fc60b16afa1367
msgid ""
"The ``generate_context`` method of each generator is called, updating the"
" context."
msgstr ""
"调用各generator对象的 ``generate_context`` 方法来更新 ``context`` 。"
#: ../../report.rst:95 d50a4b2e38884eb38f1b66fdf7fb1eda
msgid ""
"The writer is created and given to the ``generate_output`` method of each"
" generator."
msgstr ""
"创建 **Writers** 并将其给入generator的 ``generate_output`` 方法。"
#: ../../report.rst:98 da8d9096940044f2849112fb5efcb4cb
msgid ""
"I make two calls because it is important that when the output is "
"generated by the generators, the context will not change. In other words,"
" the first method ``generate_context`` should modify the context, whereas"
" the second ``generate_output`` method should not."
msgstr ""
"由于当generator生成输出时并不会改变上下文，我进行了两次调用。换句话说，第一个方法 "
"``generate_context`` 会修改上下文，而第二个方法 ``generate_output`` 不会。"
#: ../../report.rst:103 a6350edba931463fb92ae51dd9bc253a
msgid ""
"Then, it is up to the generators to do what the want, in the "
"``generate_context`` and ``generate_content`` method. Taking the "
"``ArticlesGenerator`` class will help to understand some others concepts."
" Here is what happens when calling the ``generate_context`` method:"
msgstr ""
"然后，事情就取决于各generator在 ``generate_context`` 和 ``generate_content`` "
"中做的操作了。拿 ``ArticlesGenerator`` 举例可以帮助理解其他的一些概念。下面是调用 "
"``generate_context`` 方法后会发生的事情："
#: ../../report.rst:108 4b99ddf2cf344d0b8fbd080c15adfb64
msgid ""
"Read the folder “path”, looking for restructured text files, load each of"
" them, and construct a content object (``Article``) with it. To do so, "
"use ``Reader`` objects."
msgstr ""
"读取文件夹路径，查找并加载每个restructured文件，并为每个文件构建一个正文内容对象（ "
"``Article`` ）。此工作是由 ``Reader`` 对象完成的。"
#: ../../report.rst:111 176a7a5896904f2e9929623ef652660b
msgid "Update the ``context`` with all those articles."
msgstr "根据所有的文章更新 ``context`` 。"
#: ../../report.rst:113 bb88942c85004c4c9e0b55a72076b18f
msgid ""
"Then, the ``generate_content`` method uses the ``context`` and the "
"``writer`` to generate the wanted output."
msgstr ""
"然后， ``generate_content`` 方法使用 ``context`` 和 ``writer`` 来生成想要的输出。"

1815
docs/locale/zh_CN/LC_MESSAGES/settings.po Normal file
View file

File diff suppressed because it is too large Load diff

60
docs/locale/zh_CN/LC_MESSAGES/sphinx.po Normal file
View file

@ -0,0 +1,60 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-24 19:06+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../_templates/page.html:68 697aead398874e06aa15cfd74d134745
msgid "Back to top"
msgstr "返回顶部"
#: ../../_templates/page.html:101 f91a64e54aae49c2bd09a944ea693193
msgid "Next"
msgstr "下一节"
#: ../../_templates/page.html:113 6c3ad069077b4e2cb6e1f77cc2962881
msgid "Previous"
msgstr "前一节"
#: ../../_templates/page.html:116 e83e03d0b50c4065a9f87db25a23b3ee
msgid "Home"
msgstr "首页"
#: ../../_templates/page.html:129 1d0fdb4c0b4e420283101ba5c21ac985
#, python-format
msgid "<a href=\"%(path)s\">Copyright</a> &#169; %(copyright)s"
msgstr "<a href=\"%(path)s\">Copyright</a> &#169; %(copyright)s"
#: ../../_templates/page.html:133 0a35c662e6574da48f7ac5c6b2c82874
#, python-format
msgid ""
"Copyright &#169; %(copyright)s, <a "
"href=\"https://justinmayer.com\">Justin Mayer</a>, Alexis Metaireau, and "
"contributors"
msgstr ""
"Copyright &#169; %(copyright)s, <a "
"href=\"https://justinmayer.com\">Justin Mayer</a>, Alexis Metaireau, and "
"contributors"
#: ../../_templates/page.html:141 07b89372db484251bfcd3b54e0845bf0
#, python-format
msgid "Last updated on %(last_updated)s"
msgstr "最后更新于 %(last_updated)s"
#: ../../_templates/page.html:187 2eb9f1b479a7405290a91d8e1962f265
msgid "On this page"
msgstr "本页目录"

1269
docs/locale/zh_CN/LC_MESSAGES/themes.po Normal file
View file

File diff suppressed because it is too large Load diff

679
docs/locale/zh_CN/LC_MESSAGES/tips.po Normal file
View file

@ -0,0 +1,679 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2010–2024
# This file is distributed under the same license as the PELICAN package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: PELICAN 4\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-25 20:36+0800\n"
"PO-Revision-Date: 2024-06-27 19:00+0800\n"
"Last-Translator: GeorgeHu <dhxxhch@163.com>\n"
"Language: zh_CN\n"
"Language-Team: zh_CN <LL@li.org>\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.15.0\n"
#: ../../tips.rst:2 415f61a654104cf4826423e3aa1d3807
msgid "Tips"
msgstr "小技巧"
#: ../../tips.rst:4 1bc50144d85845f3a7f21f9ef87bba44
msgid "Here are some tips about Pelican that you might find useful."
msgstr "以下是一些实用的小技巧。"
#: ../../tips.rst:7 ../../tips.rst:264 d9115f4b162d46e6aa89d56309c1ec41
#: e693dc009e5c466d99655b705223f300
msgid "Custom 404 Pages"
msgstr "自定义404页面"
#: ../../tips.rst:9 5c7cd70793f44d3c9fcf63779755d62b
msgid ""
"When a browser requests a resource that the web server cannot find, the "
"web server usually displays a generic \"File not found\" (404) error page"
" that can be stark and unsightly. One way to provide an error page that "
"matches the theme of your site is to create a custom 404 page (*not* an "
"article), such as this Markdown-formatted example stored in "
"``content/pages/404.md``::"
msgstr ""
"当浏览器请求的资源无法在服务器中找到时，web服务器常常会显示一个通用的“File not "
"found 404”的错误页面，这可能会不太美观。为了能使用一个与站点主题相匹配的404页面"
"（注意是页面而 **不是** 文章），例如下面这个Markdown格式的例子，将此文件存为了 "
"``content/pages/404.md`` ："
#: ../../tips.rst:22 cab28bb6b2a548a09f8cc6e4778f1a78
msgid ""
"The next step is to configure your web server to display this custom page"
" instead of its default 404 page. For Nginx, add the following to your "
"configuration file's ``location`` block::"
msgstr ""
"接下来就是要配置web服务器，使其显示此自定义页面而不是默认的404页面。例如对于Nginx，"
"在配置文件的 ``location`` 块中添加下面的命令："
#: ../../tips.rst:28 f8acbc4d00de4cfb8dfd9358a8168c14
msgid "For Apache::"
msgstr "对于Apache："
#: ../../tips.rst:32 3701d02f6dba4936a86a9fbb226261e8
msgid ""
"For Amazon S3, first navigate to the ``Static Site Hosting`` menu in the "
"bucket settings on your AWS console. From there::"
msgstr ""
"对于Amazon S3实例，先在控制台的设置中找到 ``Static Site Hosting`` ，并添加："
#: ../../tips.rst:38 4d111f7cca2e49828e343ff889847358
msgid "Publishing to GitHub Pages"
msgstr "发布到GitHub Pages"
#: ../../tips.rst:40 f7fa83b00f6d4dd58d6f119725474538
msgid ""
"If you use `GitHub <https://github.com/>`_ for your Pelican site you can "
"publish your site to `GitHub Pages <https://pages.github.com/>`_ for "
"free. Your site will be published to ``https://<username>.github.io`` if "
"it's a user or organization site or to "
"``https://<username>.github.io/<repository>`` if it's a project site. "
"It's also possible to `use a custom domain with GitHub Pages "
"<https://docs.github.com/en/pages/configuring-a-custom-domain-for-your-"
"github-pages-site>`_."
msgstr ""
"如果将Pelican站点放在了 `GitHub <https://github.com/>`_ 上，那么你就可以将站点"
"免费发布在 `GitHub Pages <https://pages.github.com/>`_ 上。如果是用户或组织的"
"站点，发布的地址为 ``https://<username>.github.io`` ；如果是某个项目的站点，"
"发布的地址则为 ``https://<username>.github.io/<repository>`` 。当然也可以 "
"`在GitHub Pages上使用自定义域名 <https://docs.github.com/en/pages/configuring-a-custom-"
"domain-for-your-github-pages-site>`_ 。"
#: ../../tips.rst:46 a3167f2a605d44288b83d66f052e8cdd
msgid ""
"There are `two ways to publish a site to GitHub Pages "
"<https://docs.github.com/en/pages/getting-started-with-github-"
"pages/configuring-a-publishing-source-for-your-github-pages-site>`_:"
msgstr ""
"总的来说，有 `两种将站点发布到GitHub Pages的方法 <https://docs.github.com/en/pages"
"/getting-started-with-github-pages/configuring-a-publishing-source-for-"
"your-github-pages-site>`_ ："
#: ../../tips.rst:48 b2f270c5a15d4e3e92331c3c37db25dd
msgid ""
"**Publishing from a branch:** run ``pelican`` locally and push the output"
" directory to a special branch of your GitHub repo. GitHub will then "
"publish the contents of this branch to your GitHub Pages site."
msgstr ""
"**从某一分支发布：** 在本地运行 ``pelican`` 后将输出文件夹push到GitHub仓库的"
"某一分支。GitHub就会将该分支的内容发布到GitHub Pages上。"
#: ../../tips.rst:51 4ffdb550d8bf468dbfe4d32dfcda21cd
msgid ""
"**Publishing with a custom GitHub Actions workflow:** just push the "
"source files of your Pelican site to your GitHub repo's default branch "
"and have a custom GitHub Actions workflow run ``pelican`` for you to "
"generate the output directory and publish it to your GitHub Pages site. "
"This way you don't need to run ``pelican`` locally. You can even edit "
"your site's source files using GitHub's web interface and any changes "
"that you commit will be published."
msgstr ""
"**从自定义GitHub Actions工作流发布：** 将内容源文件推送到GitHub仓库的默认分支，"
"然后在GitHub Actions工作流中执行 ``pelican`` 以生成输出文件夹，最后将其发布到你"
"的GitHub Pages站点。此种方法下就无需在本地执行 ``pelican`` 命令了。甚至可以直接"
"在GitHub的网页中在线修改站点内容源文件。"
#: ../../tips.rst:60 0e9c34ce1a5948098a5d0812eb8ac1b4
msgid "Publishing a Project Site to GitHub Pages from a Branch"
msgstr "从某一分支发布项目站点到GitHub Pages"
#: ../../tips.rst:62 5190ebea8d8b4542ac9ecb98c297594e
msgid ""
"To publish a Pelican site as a Project Page you need to *push* the "
"content of the ``output`` dir generated by Pelican to a repository's "
"``gh-pages`` branch on GitHub."
msgstr ""
"要将Pelican站点发布为项目页面，你需要将Pelican生成的 ``output`` 目录 "
"**push** 到GitHub仓库的 ``gh-pages`` 分支。"
#: ../../tips.rst:66 e12298010e9745b59d60d31ae909fd4c
msgid ""
"The excellent `ghp-import <https://github.com/davisp/ghp-import>`_, which"
" can be installed with ``pip``, makes this process really easy."
msgstr ""
"可通过 ``pip`` 安装的 `ghp-import <https://github.com/davisp/ghp-import>`_ "
"使这一步变得非常简单。"
#: ../../tips.rst:69 cd5a5847355846dd81a0ad37858358f2
msgid ""
"For example, if the source of your Pelican site is contained in a GitHub "
"repository, and if you want to publish that Pelican site in the form of "
"Project Pages to this repository, you can then use the following::"
msgstr ""
"例如，当Pelican站点的源文件已经包含在GitHub仓库中时，可以将其作为此仓库的项目页面："
#: ../../tips.rst:77 18d3e7316a5a48acb337c3c67e94084c
msgid ""
"The ``ghp-import output`` command updates the local ``gh-pages`` branch "
"with the content of the ``output`` directory (creating the branch if it "
"doesn't already exist). The ``git push origin gh-pages`` command updates "
"the remote ``gh-pages`` branch, effectively publishing the Pelican site."
msgstr ""
"``ghp-import output`` 命令会用 ``output`` 目录下的内容更新本地的 ``gh-pages`` "
"分支（如果此分支不存在则会先创建）。接着再用 ``git push origin gh-pages`` "
"命令更新远程分支 ``gh-pages`` ，如此就能够发布Pelican站点了。"
#: ../../tips.rst:84 cc8b9d96da674850b39373728000f722
msgid ""
"The ``github`` target of the Makefile (and the ``gh_pages`` task of "
"``tasks.py``) created by the ``pelican-quickstart`` command publishes the"
" Pelican site as Project Pages, as described above."
msgstr ""
"``pelican-quickstart`` 在Makefile文件中所生成的 ``github`` 目标（以及为 "
"``gh_pages`` 任务生成的 ``tasks.py`` ）使得Pelican站点能像上面描述的那样被发布"
"为项目页面。"
#: ../../tips.rst:89 41c7b129fd334796848c4d75404dbe81
msgid "Publishing a User Site to GitHub Pages from a Branch"
msgstr "从某一分支发布用户站点到GitHub Pages"
#: ../../tips.rst:91 b379f950927d484ba91fbe649a248cfe
msgid ""
"To publish a Pelican site in the form of User Pages, you need to *push* "
"the content of the ``output`` dir generated by Pelican to the ``main`` "
"branch of your ``<username>.github.io`` repository on GitHub."
msgstr ""
"要以用户页面形式发布Pelican站点，你需要将Pelican生成的 ``output`` 目录内容 "
"**push** 到 ``<username>.github.io`` 仓库的 ``master`` 分支上。"
#: ../../tips.rst:95 6d1bd6c0ff25494e997c4efbdcd1d861
msgid "Again, you can take advantage of ``ghp-import``::"
msgstr "同样的，此处也可以使用 ``ghp-import`` ："
#: ../../tips.rst:101 45fb7ba534af4f7d828e1630e591c02a
msgid ""
"The ``git push`` command pushes the local ``gh-pages`` branch (freshly "
"updated by the ``ghp-import`` command) to the ``elemoine.github.io`` "
"repository's ``main`` branch on GitHub."
msgstr ""
"``git push`` 命令将本地的 ``gh-pages`` 分支（此分支在刚刚通过 ``ghp-import`` "
"命令进行了更新）push到了GitHub仓库 ``elemoine.github.io`` 的 ``master`` 分支。"
#: ../../tips.rst:107 b105e7dd1aef441896c0f59166808113
msgid ""
"To publish your Pelican site as User Pages, feel free to adjust the "
"``github`` target of the Makefile."
msgstr ""
"要将Pelican站点发布为用户页面，可以根据需要修改Makefile中的 ``github`` 目标。"
#: ../../tips.rst:110 87a89a932eec40e8bfdd5c756f4d54fc
msgid ""
"Another option for publishing to User Pages is to generate the output "
"files in the root directory of the project."
msgstr ""
"发布用户页面的另一种方法就是将输出文件生成在项目的根目录下。"
#: ../../tips.rst:113 dab76a45349c432cb4b763484661ec2c
msgid ""
"For example, your main project folder is ``<username>.github.io`` and you"
" can create the Pelican project in a subdirectory called ``Pelican``. "
"Then from inside the ``Pelican`` folder you can run::"
msgstr ""
"例如，项目的主文件夹是 ``<username>.github.io`` ，你可以在子目录 ``Pelican`` "
"中创建一个Pelican项目。然后你可以在这个 ``Pelican`` 文件夹中执行下面的命令："
#: ../../tips.rst:119 7f13464c92f14cc18f8c00f7dae78f93
msgid ""
"Now you can push the whole project ``<username>.github.io`` to the main "
"branch of your GitHub repository::"
msgstr ""
"接着可以将整个项目 ``<username>.github.io`` push到GitHub仓库的master分支中："
#: ../../tips.rst:124 e82ff566e32b4696863aa04216aaf355
msgid "(assuming origin is set to your remote repository)."
msgstr "（此处假设远程仓库命名为origin）。"
#: ../../tips.rst:127 1958522ba7c34537855505f1e64c7b43
msgid "Publishing to GitHub Pages Using a Custom GitHub Actions Workflow"
msgstr "使用自定义GitHub Actions工作流将站点发布GitHub Pages中"
#: ../../tips.rst:129 19c47b80d248451facd8407bd960b527
msgid ""
"Pelican-powered sites can be published to GitHub Pages via a `custom "
"workflow "
"<https://github.com/getpelican/pelican/blob/main/.github/workflows/github_pages.yml>`_."
" To use it:"
msgstr ""
"Pelican已经给你准备了一份 `自定义工作流 "
"<https://github.com/getpelican/pelican/blob/main/.github/workflows/github_pages.yml>`_"
" ，你可以直接使用此工作流发布站点："
#: ../../tips.rst:133 bdc132ef5b974d1eae684d8118e4d914
msgid ""
"Enable GitHub Pages in your repo: go to **Settings → Pages** and choose "
"**GitHub Actions** for the **Source** setting."
msgstr ""
"首先为仓库开启GitHub Pages： **Settings → Pages** 中有个 **Source** 设置项，"
"将其选择为 **GitHub Actions** 。"
#: ../../tips.rst:136 d7d197c176bd4127a75cfaf9dd29212b
msgid ""
"Commit a ``.github/workflows/pelican.yml`` file to your repo with these "
"contents:"
msgstr ""
"往你的仓库中commit一个 ``.github/workflows/pelican.yml`` 文件，文件内容如下："
#: ../../tips.rst:155 656a2b783b6043f2ac26b1e7b342732e
msgid ""
"You may want to replace the ``@main`` with the ID of a specific commit in"
" this repo in order to pin the version of the reusable workflow that "
"you're using: ``uses: "
"getpelican/pelican/.github/workflows/github_pages.yml@<COMMIT_ID>``. If "
"you do this you might want to get Dependabot to send you automated pull "
"requests to update that commit ID whenever new versions of this workflow "
"are published, like so:"
msgstr "你可能想要将 ``@main`` 替换为这个仓库中某个特定commit的ID，以便将你使用的"
"可重用工作流的版本固定下来，此时，可以使用 ``uses: getpelican/pelican/.github/workflows/"
"github_pages.yml@<COMMIT_ID>`` 。在这种情况下，你可能想让Dependabot自动向你发送"
"PR，以便在发布新版本的工作流时更新commit ID，如下所示:"
#: ../../tips.rst:172 0e2e10f42d6142e1b2f9d2251879ffad
msgid ""
"See `GitHub's docs about using Dependabot to keep your actions up to date"
" <https://docs.github.com/en/code-security/dependabot/working-with-"
"dependabot/keeping-your-actions-up-to-date-with-dependabot>`_."
msgstr "请参阅 `GitHub文档 <https://docs.github.com/en/code-security/"
"dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-"
"dependabot>`_ ，了解如何使用Dependabot使您的action保持最新。"
#: ../../tips.rst:174 2475397adfbb48af9a1d16fc0a24d9b9
msgid ""
"Go to the **Actions** tab in your repo "
"(``https://github.com/<username>/<repository>/actions``) and you should "
"see a **Deploy to GitHub Pages** action running."
msgstr ""
"选中仓库的 **Actions** 标签栏（ ``https://github.com/<username>/<repository>"
"/actions`` ），此时你应该会看到已经有一个名为 **Deploy to GitHub Pages** 的"
"action正在运行。"
#: ../../tips.rst:178 df30a15c460b442796f7f2007c283f32
msgid ""
"Once the action completes you should see your Pelican site deployed at "
"your repo's GitHub Pages URL: ``https://<username>.github.io`` for a user"
" or organization site or ``https://<username>.github.io/<repository>>`` "
"for a project site."
msgstr ""
"当此action执行完成，就能够通过仓库的GitHub Pages地址 ``https://<username>."
"github.io`` 看到部署好了的用户或组织站点了，对于项目站点，可通过 ``https://"
"<username>.github.io/<repository>`` 访问。"
#: ../../tips.rst:183 f79963fcfd204f2780ff536516e6d407
msgid "Notes:"
msgstr "注意事项："
#: ../../tips.rst:185 3a2dc6a36d38454e85265ef35c5e8010
msgid ""
"You don't need to set ``SITEURL`` or ``FEED_DOMAIN`` in your Pelican "
"settings: the workflow will set them correctly for you"
msgstr ""
"无需在Pelican配置文件中设置 ``SITEURL`` ，工作流会帮你进行设置。"
#: ../../tips.rst:188 ea406746a7db49dfa10de025a3be4a31
msgid ""
"You don't need to commit your ``--output`` / ``OUTPUT_PATH`` directory "
"(``output/``) to git: the workflow will run ``pelican`` to build the "
"output directory for you on GitHub Actions"
msgstr ""
"无需commit ``--output`` 或 ``OUTPUT_PATH`` 所指定的目录（ ``output/`` ）："
"工作流会自己执行 ``pelican`` 命令来构建输出目录。"
#: ../../tips.rst:192 a92a4068ac294a22ac80b1db68090634
msgid ""
"See `GitHub's docs about reusable workflows "
"<https://docs.github.com/en/actions/using-workflows/reusing-workflows>`_ "
"for more information."
msgstr ""
"更多信息请参阅 `GitHub可重用工作流文档 <https://docs.github.com/en/actions/using-"
"workflows/reusing-workflows>`_ 。"
#: ../../tips.rst:195 1264d8a048aa4bd7878845ba2dac0d0d
msgid ""
"A number of optional inputs can be added to the ``with:`` block when "
"calling the workflow, for example:"
msgstr ""
"有一些可选输入可以添加到工作流的 ``with:`` 块中："
#: ../../tips.rst:206 3faf65d7567244e3bc65a15dc84cf247
msgid "Here's the complete list of workflow inputs:"
msgstr "下面是工作流可用输入参数的完整列表："
#: ../../tips.rst:209 37919ce86ddb4546bd191440ba1c5b9a
msgid "Name"
msgstr "名称"
#: ../../tips.rst:209 645ae6a27c7b40ecbc795dbd698b0649
msgid "Required"
msgstr "是否必需"
#: ../../tips.rst:209 18917f8f278440e38882a4f1ca62fc8f
msgid "Description"
msgstr "描述"
#: ../../tips.rst:209 99be24eafb6d43578e6eabba25f568fe
msgid "Type"
msgstr "值的类型"
#: ../../tips.rst:209 24860d0693b84e6c9297f8733b338824
msgid "Default"
msgstr "默认值"
#: ../../tips.rst:211 7e9bb7ea151c4e8c99116dd4decbe3c1
msgid "``settings``"
msgstr "``settings``"
#: ../../tips.rst:211 647c4173846f4057920030c8f774d5ea
msgid "Yes"
msgstr "是"
#: ../../tips.rst:211 05c57822d0a249de9718a9a3c56e9e56
msgid ""
"The path to your Pelican settings file (``pelican``'s ``--settings`` "
"option), for example: ``\"publishconf.py\"``"
msgstr ""
"Pelican配置文件的路径（会被用于 ``pelican`` 命令的 ``--settings`` 选项），例如 "
"``\"publishconf.py\"`` 。"
#: ../../tips.rst:211 ../../tips.rst:216 ../../tips.rst:223 ../../tips.rst:227
#: ../../tips.rst:231 ../../tips.rst:237 ../../tips.rst:243
#: 4e21f78e86f049048a800ddd5c51e230 618fd4eb66ff45b29c98df87b145613c
#: 93083ab6eb974293820f40d16349c100 9684f50652484820b924109f31418cd7
#: 9df48660f1a84fe1af952256c7b58aec cef3fc9239d941969fda711c74994d8c
#: d09fff93593844cfbb0b270b4cd74193
msgid "string"
msgstr "string"
#: ../../tips.rst:216 f867df810054493f9d6be16271822ddb
msgid "``requirements``"
msgstr "``requirements``"
#: ../../tips.rst:216 ../../tips.rst:223 ../../tips.rst:227 ../../tips.rst:231
#: ../../tips.rst:237 ../../tips.rst:243 019e197dd56b44229549da7a2421ce37
#: 636f76c7f1ca4c61bcea4bbe39a4eb1f 671a0ff87e294e7ab0ac8cdf70fdfe1d
#: 848f43cf99c447a595f4760e2cf25f2b b425d772694640d0a7bae06c236fa1a2
#: d145c924e4f348f5ad24b51286ce61e6
msgid "No"
msgstr "否"
#: ../../tips.rst:216 0d5ee9c193994b2cac7757e881f01a42
msgid ""
"The Python requirements to install, for example to enable markdown and "
"typogrify use: ``\"pelican[markdown] typogrify\"`` or if you have a "
"requirements file: ``\"-r requirements.txt\"``"
msgstr ""
"需要安装的Python模块，例如要开启markdown和typogrify，可指定 ``\"pelican[markdown] "
"typogrify\"`` ，或者可以指定一个requirements文件： ``\"-r requirements.txt\"`` "
#: ../../tips.rst:216 67298d60de17486dbc1b6841f2c433b9
msgid "``\"pelican\"``"
msgstr "``\"pelican\"``"
#: ../../tips.rst:223 219a8d185ac440329e8aa7306e55e708
msgid "``output-path``"
msgstr "``output-path``"
#: ../../tips.rst:223 21a3530e340349afa64d7eb69b393c98
msgid "Where to output the generated files (``pelican``'s ``--output`` option)"
msgstr "生成文件的输出位置（会被用于 ``pelican`` 命令的 ``--output`` 选项）"
#: ../../tips.rst:223 dea97da0dfc24941b8850d1d26ea3cd3
msgid "``\"output/\"``"
msgstr "``\"output/\"``"
#: ../../tips.rst:227 688ac4687d7841629137bf97ce97deee
msgid "``theme``"
msgstr "``theme``"
#: ../../tips.rst:227 2c2e6b6d8a6044c0ba64d00ea1b12d40
msgid ""
"The GitHub repo URL of a custom theme to use, for example: "
"``\"https://github.com/seanh/sidecar.git\"``"
msgstr ""
"要使用的自定义主题的GitHub仓库URL，例如： ``\"https://github.com/seanh/"
"sidecar.git\"``"
#: ../../tips.rst:227 bd63884f7e60412d9a6cccc5da9c47ac
msgid "``\"\"``"
msgstr "``\"\"``"
#: ../../tips.rst:231 9527d9e89d704210baff0bb6e3e23b20
msgid "``python``"
msgstr "``python``"
#: ../../tips.rst:231 1aa44193e62647c0ba275507ea84b42c
msgid ""
"The version of Python to use to build the site, for example: ``\"3.12\"``"
" (to use the most recent version of Python 3.12, this is faster) or "
"``\"3.12.1\"`` (to use an exact version, slower)"
msgstr ""
"构建站点时使用的Python版本，例如： ``\"3.12\"`` 或 ``\"3.12.1\"``"
#: ../../tips.rst:231 d182ae2dd44c482fb3f2373a7d97087c
msgid "``\"3.12\"``"
msgstr "``\"3.12\"``"
#: ../../tips.rst:237 dc65b4e578e24d179c38066871c2c572
msgid "``siteurl``"
msgstr "``siteurl``"
#: ../../tips.rst:237 5909de5d60224c7b875753f88fd13296
msgid ""
"The base URL of your web site (Pelican's ``SITEURL`` setting). If not "
"passed this will default to the URL of your GitHub Pages site, which is "
"correct in most cases."
msgstr ""
"站点的基URL，会用于配置项 ``SITEURL`` 。若未指定，默认值为GitHub Pages站点"
"的URL，这适用于大部分情况。"
#: ../../tips.rst:237 ../../tips.rst:243 0c0b86aa4b984615afb3564b76e379ff
#: c7ddd6347a7f4467b31aaa8f4d4a2309
msgid "The URL of your GitHub Pages site."
msgstr "GitHub Pages站点的URL"
#: ../../tips.rst:243 af7d2b52c5504ac2b69490a18d14f80f
msgid "``feed_domain``"
msgstr "``feed_domain``"
#: ../../tips.rst:243 2cc126862a8047c286381aa258aad013
msgid ""
"The domain to be prepended to feed URLs (Pelican's ``FEED_DOMAIN`` "
"setting). If not passed this will default to the URL of your GitHub Pages"
" site, which is correct in most cases."
msgstr ""
"订阅源URL前要附加的域名，会用于配置项 ``FEED_DOMAIN`` 。若未指定，默认值为"
"GitHub Pages站点的URL，这适用于大部分情况。"
#: ../../tips.rst:252 b86ab8a1fa24447d99becc592411010e
msgid "\"Insecure content\" warnings from browsers"
msgstr "浏览器报“不安全的内容（Insecure content）”警告"
#: ../../tips.rst:254 c81d5f8889c14a069e55fe7472a238f2
msgid ""
"If your site uses ``https://`` and is broken because the browser is "
"blocking network requests (for example for CSS files) due to \"insecure "
"content\" this may be because GitHub Pages is generating ``http://`` URLs"
" for your site."
msgstr ""
"当站点使用 ``https://`` 时，可能会损坏，无法正常显示，这是由于浏览器阻拦了一些"
"对“不安全内容”的网络请求。可能的原因之一是GitHub Pages给你的站点生成了 ``http://`` "
"URL。"
#: ../../tips.rst:258 2a53f882b7e645149d18ce81757b9758
msgid ""
"To fix this go into your site repo's settings and enable the **Enforce "
"HTTPS** setting: go to **Settings → Pages** and check **Enforce HTTPS**. "
"Then re-run the workflow to re-deploy your site. Alternatively, you can "
"use the workflow's ``siteurl`` and ``feed_domain`` settings."
msgstr ""
"要想解决这一问题，需要为站点所在仓库开启 **强制使用HTTPS** ：点击 **Settings → Pages** "
"并在其中勾选 **Enforce HTTPS** ，接着再重新执行工作流以重新部署站点。也可以尝试"
"通过配置 ``siteurl`` 与 ``feed_domain`` 解决问题。"
#: ../../tips.rst:266 483cbd21e61841d983e2ecc8bc3006bc
msgid ""
"GitHub Pages will display the custom 404 page described above, as noted "
"in the relevant `GitHub docs "
"<https://help.github.com/articles/custom-404-pages/>`_."
msgstr ""
"如果按前述进行配置，GitHub Pages是能够正确显示自定义的404页面的，相关内容在 "
"`GitHub的文档中 <https://help.github.com/articles/custom-404-pages/>`_ 也有提到。"
#: ../../tips.rst:270 6b54e9c354f34e1f9a5a3f50d96b98c3
msgid "Update your site on each commit"
msgstr "在每次commit后都更新站点"
#: ../../tips.rst:272 2e83c0c761c94f35ae3056634d8f1552
msgid ""
"To automatically update your Pelican site on each commit, you can create "
"a post-commit hook. For example, you can add the following to "
"``.git/hooks/post-commit``::"
msgstr ""
"要想在每次commit后自动更新Pelican站点，你可以创建一个post-commit钩子。例如，"
"可以将下面的内容保存为 ``.git/hooks/post-commit`` ："
#: ../../tips.rst:279 528589366e634f15bb0a702969715286
msgid "Copy static files to the root of your site"
msgstr "将静态文件拷贝到站点根目录"
#: ../../tips.rst:281 dc4267653ef04722a0583915c05b6c88
msgid ""
"To use a `custom domain <https://help.github.com/articles/setting-up-a"
"-custom-domain-with-pages>`_ with GitHub Pages, you need to put the "
"domain of your site (e.g., ``blog.example.com``) inside a ``CNAME`` file "
"at the root of your site. To do this, create the ``content/extra/`` "
"directory and add a ``CNAME`` file to it. Then use the ``STATIC_PATHS`` "
"setting to tell Pelican to copy this file to your output directory. For "
"example::"
msgstr ""
"要将 `自定义域名 <https://help.github.com/articles/setting-up-a-custom-domain-"
"with-pages>`_ 与GitHub Pages一起使用，需要将站点的域名（例如 ``blog.example.com`` "
"）添加到站点根目录的 ``CNAME`` 文件中。为此，请创建 ``content/extra/`` 目录，并在里面添加一个 ``CNAME`` "
"文件。然后使用Pelican的 ``STATIC_PATHS`` 来告诉Pelican将此文件复制到输出目录："
#: ../../tips.rst:292 5fcdc283f55f4d8ca121cb6438c67a36
msgid "Note: use forward slashes, ``/``, even on Windows."
msgstr "请注意：务必使用正斜杠 ``/`` ，在Windows上也是。"
#: ../../tips.rst:294 326a40a1536c462ea4974ce4b560f54c
msgid ""
"You can also use the ``EXTRA_PATH_METADATA`` mechanism to place a "
"``favicon.ico`` or ``robots.txt`` at the root of any site."
msgstr ""
"利用 ``EXTRA_PATH_METADATA`` 机制，你可以将 ``favicon.ico`` 或 ``robots.txt`` "
"也拷贝到站点的根目录下。"
#: ../../tips.rst:298 4e589caa6f17438aae1d1a12819c6ef2
msgid "How to add YouTube or Vimeo Videos"
msgstr "如何添加YouTube或Vimeo视频"
#: ../../tips.rst:300 5f60f033a7084739af5ef0dce5b91197
msgid ""
"The easiest way is to paste the embed code of the video from these sites "
"directly into your source content."
msgstr ""
"最简单的方法是将这些网站的视频嵌入代码直接粘贴到您的源内容文件中。"
#: ../../tips.rst:303 5446d02bebc241e88cc30b484799696c
msgid ""
"Alternatively, you can also use Pelican plugins like ``liquid_tags``, "
"``pelican_youtube``, or ``pelican_vimeo`` to embed videos in your "
"content."
msgstr ""
"或者，您还可以使用例如 ``liquid_tags`` 、``pelican_youtube`` 或 ``pelican_vimeo`` "
"等Pelican插件将视频嵌入。"
#: ../../tips.rst:306 c871fab4a3424b0dba84c1af24f6405f
msgid ""
"Moreover, markup languages like reST and Markdown have plugins that let "
"you embed videos in the markup. You can use `reST video directive "
"<https://gist.github.com/dbrgn/2922648>`_ for reST or `mdx_video plugin "
"<https://github.com/italomaia/mdx-video>`_ for Markdown."
msgstr ""
"此外，像reST和 Markdown这样的标记语言都有对应插件可以让你在其中嵌入视频。"
"可以使用 `reST的视频指令 <https://gist.github.com/dbrgn/2922648>`_ 或者 "
"`Markdown的mdx_video插件 <https://github.com/italomaia/mdx-video>`_ 。"
#: ../../tips.rst:313 569b7609cb9d412e942001da7c4a704c
msgid "Develop Locally Using SSL"
msgstr "在本地使用SSL进行开发"
#: ../../tips.rst:315 e66f6f1cacc4466682461d251aedb929
msgid "Here's how you can set up your local pelican server to support SSL."
msgstr "以下描述了如何在本地Pelican服务器上配置SSL。"
#: ../../tips.rst:317 138c34c1b6804246b79fda266a1fd937
msgid ""
"First, create a self-signed certificate and key using ``openssl`` (this "
"creates ``cert.pem`` and ``key.pem``)::"
msgstr ""
"首先，通过 ``openssl`` 创建自签名的证书和密钥，这会生成 ``cert.pem`` 和 "
"``key.pem`` 文件："
#: ../../tips.rst:321 ac189182bc694bcaa94cd935311f4492
msgid ""
"And use this command to launch the server (the server starts within your "
"``output`` directory)::"
msgstr ""
"接着使用下面的命令来开启服务器（此服务器会在 ``output`` 目录下开启）："
#: ../../tips.rst:325 88a33744d69f4f5bbc4a43024c43d3a0
msgid "If you are using ``develop-server.sh``, add this to the top::"
msgstr "如果你使用的是 ``develop-server.sh`` 脚本，在脚本的开头添加："
#: ../../tips.rst:330 9a783977fe814657b8590185af281b1e
msgid "and modify the ``pelican.server`` line as follows::"
msgstr "然后修改按照下述修改 ``pelican.server`` 一行："
#~ msgid ""
#~ "To publish a Pelican site in the"
#~ " form of User Pages, you need "
#~ "to *push* the content of the "
#~ "``output`` dir generated by Pelican to"
#~ " the ``master`` branch of your "
#~ "``<username>.github.io`` repository on GitHub."
#~ msgstr ""
#~ msgid ""
#~ "The ``git push`` command pushes the "
#~ "local ``gh-pages`` branch (freshly "
#~ "updated by the ``ghp-import`` command)"
#~ " to the ``elemoine.github.io`` repository's "
#~ "``master`` branch on GitHub."
#~ msgstr ""
#~ msgid ""
#~ "Now you can push the whole project"
#~ " ``<username>.github.io`` to the master "
#~ "branch of your GitHub repository::"
#~ msgstr ""
#~ msgid ""
#~ "Pelican-powered sites can be published"
#~ " to GitHub Pages via a `custom "
#~ "workflow "
#~ "<https://github.com/getpelican/pelican/blob/master/.github/workflows/github_pages.yml>`_."
#~ " To use it:"
#~ msgstr ""
#~ msgid ""
#~ "You may want to replace the "
#~ "``@master`` with the ID of a "
#~ "specific commit in this repo in "
#~ "order to pin the version of the"
#~ " reusable workflow that you're using: "
#~ "``uses: "
#~ "getpelican/pelican/.github/workflows/github_pages.yml@<COMMIT_ID>``."
#~ " If you do this you might want"
#~ " to get Dependabot to send you "
#~ "automated pull requests to update that"
#~ " commit ID whenever new versions of"
#~ " this workflow are published, like "
#~ "so:"
#~ msgstr ""