Commits

a2c committed e7dc12d

complete quickstart by hirajun

  • Participants
  • Parent commits 5e56665

Comments (0)

Files changed (2)

File src/flask/docs/patterns/packages.rst

 
 
 .. Simple Packages
+
 単純なパッケージ
-----------------
+----------------------------
 
 .. To convert that into a larger one, just create a new folder
    `yourapplication` inside the existing one and move everything below it.
 
 .. .. admonition:: Circular Imports
 
-.. admonition:: 循環インポート
+admonition:: 循環インポート
 
 ..   Every Python programmer hates them, and yet we just added some:
      circular imports (That's when two modules depend on each other.  In this
 .. _working-with-modules:
 
 .. Working with Modules
+
 モジュールを使う
-----------------
+---------------------------
 
 .. For larger applications with more than a dozen views it makes sense to
    split the views into modules.  First let's look at the typical structure of
 .. _modules-and-resources:
 
 .. Modules and Resources
+
 モジュールとリソース
---------------------
+-------------------------------
 
 .. versionadded:: 0.5
 

File src/flask/docs/quickstart.rst

 .. _quickstart:
 
-..  Quickstart
-  ==========
-
 クイックスタート
 =========================
 
+..  Quickstart
+  ==========
 
 ..  Eager to get started?  This page gives a good introduction in how to gets
   started with Flask.  This assumes you already have Flask installed.  If
 
 ..  ::A minimal Flask application looks something like that::
 
-最小規模のFlaskアプリケーション例を以下に示します
+最小規模のFlaskアプリケーション例を以下に示します
 
 ::
 
 ..  Head over to `http://127.0.0.1:5000/ <http://127.0.0.1:5000/>`_, you should
     see your hello world greeting.
 
-`http://127.0.0.1:5000/ <http://127.0.0.1:5000/>` 上で、"Hello World!"と出力されます。
+`http://127.0.0.1:5000/ <http://127.0.0.1:5000/>`_ 上で、"Hello World!"と出力されます。
 
+(※注意※ 外部からは見ることができません。下記参照)
 
 ..  So what did that code do?
 
     the Python interpreter and not used as imported module.
 
 5. 最後に :meth:`~flask.Flask.run` ファンクションを使い、ローカルサーバーでアプリケーションを実行します。
-    ``if __name__ == '__main__':`` は、そのスクリプトがPyrhonインタープリタから直接実行されたときだけに
-    そのサーバで走り、モジュールとしてインポートされたときには走らないことを保証します。
+   ``if __name__ == '__main__':`` は、そのスクリプトがPyrhonインタープリタから直接実行されたときだけに
+   そのサーバで走り、モジュールとしてインポートされたときには走らないことを保証します。
 
 ..  To stop the server, hit control-C.
 
 
 ..  .. admonition:: Externally Visible Server
 
-.. admonition:: 外部から見ることができるサーバー
-
 ..   If you run the server you will notice that the server is only available
      from your own computer, not from any other in the network.  This is the
      default because in debugging mode a user of the application can execute
      or trust the users on your network, you can make the server publicly
      available.
 
-サーバーを走らせた時、そのサーバーが外部ネットワークからではなく
-あなたのコンピュータだけで利用できていることを確認しましょう。
-外部から利用できないのはデフォルトの設定になっています。
-デバッグモードでそのアプリケーションのユーザーは誰でも
-あなたのコンピュータ上でPythonコードを恣意的に実行できてしまうからです。
-もし `debug` モードを使用不可にするか、ネットワーク上の全ユーザを信頼するなら、
-サーバーを公共利用にすることも可能です。
+.. admonition:: 外部から見ることができるサーバー
+
+  サーバーを走らせた時、そのサーバーが外部ネットワークからではなく
+  あなたのコンピュータだけで利用できていることを確認しましょう。
+  外部から利用できないのはデフォルトの設定になっています。
+  デバッグモードでそのアプリケーションのユーザーは誰でも
+  あなたのコンピュータ上でPythonコードを恣意的に実行できてしまうからです。
+  もし `debug` モードを使用不可にするか、ネットワーク上の全ユーザを信頼するなら、
+  サーバーを公共利用にすることも可能です。
 
 ..     Just change the call of the :meth:`~flask.Flask.run` method to look
      like this::
 
-:meth:`~flask.Flask.run` メソッドの宣言を以下のように変更してください
+:meth:`~flask.Flask.run` メソッドの宣言を以下のように変更してください
 
 ::
-       app.run(host='0.0.0.0')
+
+    app.run(host='0.0.0.0')
 
 ..     This tells your operating system to listen on a public IP.
 
 ..  There are two ways to enable debugging.  Either set that flag on the
   application object::
 
-デバッグをするために2つのやり方があります。どちらも、アプリケーションオブジェクトにフラグを立てるやり方です
+デバッグをするために2つのやり方があります。
+どちらも、アプリケーションオブジェクトにフラグを立てるやり方です。
 
 ::
 
 
 ..  Or pass it to run::
 
-省略もできます
+省略もできます
 
 ::
+
     app.run(debug=True)
 
 ..  Both will have exactly the same effect.
 
 .. admonition:: ご注意
 
-インタラクティブデバッガーはフォークした環境では動きません。
-そのため、プロダクションサーバではこのデバッガーをほとんど使えません。
-大きなセキュリティリスクとなる任意コードの実行を許してしまうことになるので、
-**プロダクションマシーンでは決して使わないでください** 。
+  インタラクティブデバッガーはフォークした環境では動きません。
+  そのため、プロダクションサーバではこのデバッガーをほとんど使えません。
+  大きなセキュリティリスクとなる任意コードの実行を許してしまうことになるので、
+  **プロダクションマシーンでは決して使わないでください** 。
 
 ..     The interactive debugger however does not work in forking environments
      which makes it nearly impossible to use on production servers but the
 
 ..  Here some examples::
 
-以下に例を示します::
+以下に例を示します。
+
+::
 
     @app.route('/')
     def index():
 ..  Variable Rules
   ``````````````
 
-現代のWebアプリケーションは非常に明快なURLを持っているため、人々はURLを覚えることができます。
+現代のWebアプリケーションは非常に単純明快なURLを持っているため、人々はURLを覚えることができます。
 これはネットワーク接続の遅い携帯デバイスから利用されるアプリケーションにとって非常に有用なことです。
 もしユーザーがインデックスページを経由せずに直接望んだページにいけるなら、ユーザーは
 そのページに繰り返し好んで訪れることになるでしょう。
 URLに変数部分を付け加えるために、 ``<variable_name>`` として特別にセクションをマーキングすることができます。
 そのような部分はファンクションへのキーワードアーギュメントとして略記されます。
 ``<converter:variable_name>`` でルールを特定することにより、コンバーターを特定することもできます。
-以下に例を示します::
+以下に例を示します。
+
+::
 
     @app.route('/user/<username>')
     def show_user_profile(username):
         # show the post with the given id, the id is an integer
         pass
 
-以下のコンバーターが存在することが分かります:
+以下のコンバーターが存在することが分かります
 
 ..  The following converters exist:
 
    そのモジュールの背景にある理念は、見た目が整っていること、且つ、アパッチの動作に
    基づいた、以前のサーバによって作られた固有のURLを持つことです。
 
-   2つのルールを例に取ります::
+   2つのルールを例に取ります。
+   
+   ::
 
         @app.route('/projects/')
         def projects():
         def about():
             pass
 
-   似たように見えますが、URLの *definition* の末尾にスラッシュが入っているかの違いがあります。
-   最初のケースでは、  `projects` という標準的URLの末尾にスラッシュが入っています。
+   似たように見えますが、URLの *定義* の末尾にスラッシュが入っているという違いがあります。
+   一つ目のケースでは、  `projects` という標準的URLの末尾にスラッシュが入っています。
    フォルダ表記に似ていますね。頭のスラッシュなしでアクセスすると、Flaskはスラッシュ付きの標準的URLに
    リダイレクトすることになります。
 
    しかし2番目の例では末尾スラッシュなしでURLが定義されています。そのため、ファイルと似たような挙動を示し、
-   頭のスラッシュなしでアクセスすると404エラーとなります。
+   末尾スラッシュを付けてアクセスすると404エラーとなります。
 
-   なぜでしょうか?ユーザがページにアクセスする際に頭のスラッシュを付け忘れてしまったら、
-   関連URLが働き続けることになります。この挙動はアパッチや他のサーバーが動く原理と同じことです。
+   なぜでしょうか?ユーザがページにアクセスする際に末尾スラッシュを付け忘れてしまっても、
+   関連URLが働き続けます。この挙動はアパッチや他のサーバーが動く原理と同じことです。
    また、そのURLはサーチエンジンが同じページを2回重複してインデックスしないように固有のURLで
    ありつづけます。
 
   the URL rule.  Unknown variable parts are appended to the URL as query
   parameter.  Here some examples:
 
-もしURLが一致したら、生成することができるのでしょうか?もちろんできます。
+もしURLが一致したら、それも生成することができるのでしょうか?もちろんできます。
 URLを特定のファンクションに対してビルドするために、 :func:`~flask.url_for` 
 ファンクションが使えます。
 そのファンクション名は一番目のアーギュメントとなり、いくつかのキーワードアーギュメントを
 取ります。そしてそのそれぞれがいくつかのURLルール知られていなURLルールの変数部分と一致します。
-不明な変数部分はクエリ変数としてURLに追加されます。以下に例を示します。:
+不明な変数部分はクエリ変数としてURLに追加されます。以下に例を示します。
 
 >>> from flask import Flask, url_for
 >>> app = Flask(__name__)
 flaskが考えるものです。以下の説明を参照してください。 :ref:`context-locals`).
 
 なぜテンプレートにハードコーディングせずにURLをビルドしたいのでしょうか?
-三つの理由があります:
+三つの理由があります
 
 1. リバーシングは大抵URLをハードコーディングするより説明的です。また、あらゆる場所にある
    多くのURLを変更することなく、一息でURLの変更が出来るという大きな利点があります。
-2. URLビルドは特殊文字やUnicodeデータを飛ばす処理を行。ユーザは特に意識して何かする必要はありません。 
+2. URLビルドは特殊文字やUnicodeデータを飛ばす処理を行います。ユーザは特に意識して何かする必要はありません。 
 3. もしアプリケーションがURLルートの外にあるなら (例えば ``/`` ではなく ``/myapplication`` の中にあるとき)、 :func:`~flask.url_for` で扱うと良いです。
 
 HTTP メソッド
     def hello(name=None):
         return render_template('hello.html', name=name)
 
+..  Flask will look for templates in the `templates` folder.  So if your
+  application is a module, that folder is next to that module, if it's a
+  package it's actually inside your package:
+
 Flaskはテンプレート `templates` フォルダから探します。そのため、
 アプリケーションがモジュールでありテンプレートフォルダがモジュールの隣にあるときは、
 それがパッケージであるなら実際はあなたのパッケージ内に存在します:
 
-..  Flask will look for templates in the `templates` folder.  So if your
-  application is a module, that folder is next to that module, if it's a
-  package it's actually inside your package:
+..  **Case 1**: a module::
 
-**Case 1**: a module::
+**Case 1**: モジュール::
 
     /application.py
     /templates
         /hello.html
 
-**Case 2**: a package::
+..  **Case 2**: a package::
+
+**Case 2**: パッケージ::
 
     /application
         /__init__.py
         /templates
             /hello.html
 
-For templates you can use the full power of Jinja2 templates.  Head over
-to the `Jinja2 Template Documentation
-<http://jinja.pocoo.org/2/documentation/templates>`_ for more information.
+..  For templates you can use the full power of Jinja2 templates.  Head over
+  to the `Jinja2 Template Documentation
+  <http://jinja.pocoo.org/2/documentation/templates>`_ for more information.
 
-Here an example template:
+テンプレートを作る際、Jinja2のテンプレートをフル活用することができます。
+深く知りたければ、 `Jinja2 Template Documentation
+<http://jinja.pocoo.org/2/documentation/templates>`_ を参照してください。
+
+..  Here an example template:
+
+以下にテンプレート例を示します:
 
 .. sourcecode:: html+jinja
 
       <h1>Hello World!</h1>
     {% endif %}
 
-Inside templates you also have access to the :class:`~flask.request`,
-:class:`~flask.session` and :class:`~flask.g` [#]_ objects
-as well as the :func:`~flask.get_flashed_messages` function.
+..  Inside templates you also have access to the :class:`~flask.request`,
+  :class:`~flask.session` and :class:`~flask.g` [#]_ objects
+  as well as the :func:`~flask.get_flashed_messages` function.
 
-Templates are especially useful if inheritance is used.  If you want to
-know how that works, head over to the :ref:`template-inheritance` pattern
-documentation.  Basically template inheritance makes it possible to keep
-certain elements on each page (like header, navigation and footer).
+テンプレートでは、 :class:`~flask.request` 、 :class:`~flask.session` 、 :class:`~flask.g` [#] 
+オブジェクトも :func:`~flask.get_flashed_messages` ファンクションと同時にアクセスされます。
 
-Automatic escaping is enabled, so if name contains HTML it will be escaped
-automatically.  If you can trust a variable and you know that it will be
-safe HTML (because for example it came from a module that converts wiki
-markup to HTML) you can mark it as safe by using the
-:class:`~jinja2.Markup` class or by using the ``|safe`` filter in the
-template.  Head over to the Jinja 2 documentation for more examples.
+..  Templates are especially useful if inheritance is used.  If you want to
+  know how that works, head over to the :ref:`template-inheritance` pattern
+  documentation.  Basically template inheritance makes it possible to keep
+  certain elements on each page (like header, navigation and footer).
 
-Here a basic introduction in how the :class:`~jinja2.Markup` class works:
+テンプレートは継承が行われる場合にとても有用です。それがどのような働きによるものなのか知りたければ
+:ref:`template-inheritance` パターンドキュメントを参照してください。
+基本的にテンプレートの継承では、それぞれのページ(ヘッダー、ナビゲーション、フッターなど)
+上のある要素を保持することができます。
+
+..  Automatic escaping is enabled, so if name contains HTML it will be escaped
+  automatically.  If you can trust a variable and you know that it will be
+  safe HTML (because for example it came from a module that converts wiki
+  markup to HTML) you can mark it as safe by using the
+  :class:`~jinja2.Markup` class or by using the ``|safe`` filter in the
+  template.  Head over to the Jinja 2 documentation for more examples.
+
+自動エスケープも使えます。もし名前にHTMLが含まれていたら自動的にエスケープされます。
+変数が信頼でき、それが安全なHTMLであることが分かっていれば(例えばwikiマークアップをHTMLに
+コンバートするモジュールに起因するもの)、 :class:`~jinja2.Markup` クラスあるいは
+テンプレート内の ``|safe`` フィルタを使って安全にマークすることができます。
+より多くの例は、Jinja2ドキュメントを参照してください。
+
+..  Here a basic introduction in how the :class:`~jinja2.Markup` class works:
+
+:class:`~jinja2.Markup` クラスがどう働くかについて、簡単な紹介があります:
 
 >>> from flask import Markup
 >>> Markup('<strong>Hello %s!</strong>') % '<blink>hacker</blink>'
 >>> Markup('<em>Marked up</em> &raquo; HTML').striptags()
 u'Marked up \xbb HTML'
 
-.. versionchanged:: 0.5
+..  .. versionchanged:: 0.5
 
-   Autoescaping is no longer enabled for all templates.  The following
-   extensions for templates trigger autoescaping: ``.html``, ``.htm``,
-   ``.xml``, ``.xhtml``.  Templates loaded from string will have
-   autoescaping disabled.
+..     Autoescaping is no longer enabled for all templates.  The following
+     extensions for templates trigger autoescaping: ``.html``, ``.htm``,
+     ``.xml``, ``.xhtml``.  Templates loaded from string will have
+     autoescaping disabled.
 
-.. [#] Unsure what that :class:`~flask.g` object is? It's something you
+..  .. [#] Unsure what that :class:`~flask.g` object is? It's something you
    can store information on yourself, check the documentation of that
    object (:class:`~flask.g`) and the :ref:`sqlite3` for more
    information.
 
+.. versionchanged:: 0.5
 
-Accessing Request Data
-----------------------
+   自動エスケープはすべてのテンプレートで使用できます。テンプレートに
+   以下のような拡張子があると、自動エスケープが行われます: ``.html``, ``.htm``,
+   ``.xml``, ``.xhtml``.  stringからロードされたテンプレートは自動エスケープ
+   不可になっているでしょう。
 
-For web applications it's crucial to react to the data a client sent to
-the server.  In Flask this information is provided by the global
-:class:`~flask.request` object.  If you have some experience with Python
-you might be wondering how that object can be global and how Flask
-manages to still be threadsafe.  The answer are context locals:
+.. [#] :class:`~flask.g` オブジェクトが何者だかあやふやですか?It's something you
+   これは情報を保存するものです。(:class:`~flask.g`)オブジェクトに関するドキュメントを
+   参照してください。また、より深く知るには :ref:`sqlite3` を参照してください。
 
+..  Accessing Request Data
+  ----------------------
+
+リクエストデータへのアクセス
+--------------------------------
+
+..  For web applications it's crucial to react to the data a client sent to
+  the server.  In Flask this information is provided by the global
+  :class:`~flask.request` object.  If you have some experience with Python
+  you might be wondering how that object can be global and how Flask
+  manages to still be threadsafe.  The answer are context locals:
+
+Webアプリケーションにとってクライアントがサーバに送ったデータに反応するのは重要なことだ。
+Flaskではこの情報は :class:`~flask.request` というグローバルオブジェクトから供給される。
+Python経験者はそのオブジェクトがいかにしてグローバルたりえるのか、どのようにFlaskが
+スレッドセーフで働くのか、不思議に思うかもしれない。
+その答えは、コンテクストローカルである:
 
 .. _context-locals:
 
-Context Locals
-``````````````
+..  Context Locals
+  ``````````````
 
-.. admonition:: Insider Information
+コンテクストローカル
+`````````````````````````````
 
-   If you want to understand how that works and how you can implement
-   tests with context locals, read this section, otherwise just skip it.
+..  .. admonition:: Insider Information
 
-Certain objects in Flask are global objects, but not just a standard
-global object, but actually a proxy to an object that is local to a
-specific context.  What a mouthful.  But that is actually quite easy to
-understand.
+..     If you want to understand how that works and how you can implement
+..     tests with context locals, read this section, otherwise just skip it.
 
-Imagine the context being the handling thread.  A request comes in and the
-webserver decides to spawn a new thread (or something else, the
-underlying object is capable of dealing with other concurrency systems
-than threads as well).  When Flask starts its internal request handling it
-figures out that the current thread is the active context and binds the
-current application and the WSGI environments to that context (thread).
-It does that in an intelligent way that one application can invoke another
-application without breaking.
+.. admonition:: 内部情報
 
-So what does this mean to you?  Basically you can completely ignore that
-this is the case unless you are unittesting or something different.  You
-will notice that code that depends on a request object will suddenly break
-because there is no request object.  The solution is creating a request
-object yourself and binding it to the context.  The easiest solution for
-unittesting is by using the :meth:`~flask.Flask.test_request_context`
-context manager.  In combination with the `with` statement it will bind a
-test request so that you can interact with it.  Here an example::
+   コンテクストローカルがどのようにして働くか、そのテストをどうやって実装するかを
+   知りたければ、この項を読んでください。そうでなければ読み飛ばしても構いません。
+
+..  Certain objects in Flask are global objects, but not just a standard
+  global object, but actually a proxy to an object that is local to a
+  specific context.  What a mouthful.  But that is actually quite easy to
+  understand.
+
+Flaskのいくつかのオブジェクトはグローバルですが、俗に言うグローバルオブジェクトでは
+なく、特定のコンテクストに対してローカルなオブジェクトに対するプロキシです。 
+なんのこっちゃですね。しかし、理解するのは簡単です。
+
+..  Imagine the context being the handling thread.  A request comes in and the
+  webserver decides to spawn a new thread (or something else, the
+  underlying object is capable of dealing with other concurrency systems
+  than threads as well).  When Flask starts its internal request handling it
+  figures out that the current thread is the active context and binds the
+  current application and the WSGI environments to that context (thread).
+  It does that in an intelligent way that one application can invoke another
+  application without breaking.
+
+スレッドをハンドルするコンテクストを思い浮かべてください。リクエストが出され、
+ウェブサーバは新しいスレッド(もしくは他の、その根底にある、
+他の並列システムをスレッドと同様に扱うことができるようなオブジェクト)を立てようとします。
+Flaskが内部リクエストを扱おうとするとき、現在のスレッドがアクティブコンテクストであり、現在の
+アプリケーションとそのコンテクスト(スレッド)に対するWSGI環境をバインドすることが分かります。
+アプリケーションが他のアプリケーションを停止することなく起動する賢いやり方です。
+
+..  So what does this mean to you?  Basically you can completely ignore that
+  this is the case unless you are unittesting or something different.  You
+  will notice that code that depends on a request object will suddenly break
+  because there is no request object.  The solution is creating a request
+  object yourself and binding it to the context.  The easiest solution for
+  unittesting is by using the :meth:`~flask.Flask.test_request_context`
+  context manager.  In combination with the `with` statement it will bind a
+  test request so that you can interact with it.  Here an example::
+
+これは何を意味するでしょうか?基本的に、これがユニットテストないしその他のケースを
+除外したものであるということを完全に無視することができるということです。
+ということは、リクエストオブジェクトが無ければ、リクエストオブジェクトに依存するコードは
+急停止してしまいます。その解決策は、リクエストオブジェクト自体を新しく作ることと、
+それをコンテクストにバインドすることです。ユニットテストに対する最も簡単な解決策は、
+:meth:`~flask.Flask.test_request_context` コンテクストマネージャーを使用することです。
+context manager.  In combination with the `with` ステートメントの組み合わせにおいては、
+相互にやりとりできるようにテストリクエストがバインドされます。以下に例を示します::
 
     from flask import request
 
         assert request.path == '/hello'
         assert request.method == 'POST'
 
-The other possibility is passing a whole WSGI environment to the
-:meth:`~flask.Flask.request_context` method::
+..  The other possibility is passing a whole WSGI environment to the
+  :meth:`~flask.Flask.request_context` method::
+
+WSGI環境全体を
+:meth:`~flask.Flask.request_context` メソッドに通すやり方も考えられます::
 
     from flask import request
 
     with app.request_context(environ):
         assert request.method == 'POST'
 
-The Request Object
-``````````````````
+..  The Request Object
+  ``````````````````
 
-The request object is documented in the API section and we will not cover
-it here in detail (see :class:`~flask.request`), but just mention some of
-the most common operations.  First of all you have to import it from the
-the `flask` module::
+リクエストオブジェクト
+``````````````````````````
+
+..  The request object is documented in the API section and we will not cover
+  it here in detail (see :class:`~flask.request`), but just mention some of
+  the most common operations.  First of all you have to import it from the
+  the `flask` module::
+
+リクエストオブジェクトはAPIの項で記述されており、ここでは詳細について述べません
+( :class:`~flask.request` を参照してください)が、最もよく使われるオペレーション
+についてだけご説明します。まず、requestを `flask` モジュールからimportしてください::
 
     from flask import request
 
-The current request method is available by using the
-:attr:`~flask.request.method` attribute.  To access form data (data
-transmitted in a `POST` or `PUT` request) you can use the
-:attr:`~flask.request.form` attribute.  Here a full example of the two
-attributes mentioned above::
+..  The current request method is available by using the
+  :attr:`~flask.request.method` attribute.  To access form data (data
+  transmitted in a `POST` or `PUT` request) you can use the
+  :attr:`~flask.request.form` attribute.  Here a full example of the two
+  attributes mentioned above::
+
+現在のリクエストメソッドは :attr:`~flask.request.method` 属性を使うことによって
+使用できます。フォームデータ( `POST` または `PUT` リクエストでやりとりされるデータ)に
+アクセスするには、 :attr:`~flask.request.form` 属性を使うことができます。
+以下に上記2属性を使用した例を示します::
 
     @app.route('/login', methods=['POST', 'GET'])
     def login():
         # this is executed if the request method was GET or the
         # credentials were invalid
 
-What happens if the key does not exist in the `form` attribute?  In that
-case a special :exc:`KeyError` is raised.  You can catch it like a
-standard :exc:`KeyError` but if you don't do that, a HTTP 400 Bad Request
-error page is shown instead.  So for many situations you don't have to
-deal with that problem.
+..  What happens if the key does not exist in the `form` attribute?  In that
+  case a special :exc:`KeyError` is raised.  You can catch it like a
+  standard :exc:`KeyError` but if you don't do that, a HTTP 400 Bad Request
+  error page is shown instead.  So for many situations you don't have to
+  deal with that problem.
 
-To access parameters submitted in the URL (``?key=value``) you can use the
-:attr:`~flask.request.args` attribute::
+`form` 属性にキーが存在しなかった場合どうなるのでしょうか?その場合、
+特殊な :exc:`KeyError` が起こります。 それは通常の :exc:`KeyError` と同じように受け取れますが、
+受け取らなかった場合、HTTP 400 Bad Requestのエラーページが代わりに表示されます。
+そのため、多くの場合敢えてその問題を扱う必要はありません。
+
+..  To access parameters submitted in the URL (``?key=value``) you can use the
+  :attr:`~flask.request.args` attribute::
+
+URL (``?key=value``)で提起されたパラメータにアクセスするには、
+:attr:`~flask.request.args` 属性を使うことができます::
 
     searchword = request.args.get('q', '')
 
-We recommend accessing URL parameters with `get` or by catching the
-`KeyError` because users might change the URL and presenting them a 400
-bad request page in that case is a bit user unfriendly.
+..  We recommend accessing URL parameters with `get` or by catching the
+  `KeyError` because users might change the URL and presenting them a 400
+  bad request page in that case is a bit user unfriendly.
 
-For a full list of methods and attributes on that object, head over to the
-:class:`~flask.request` documentation.
+`get` を使うか、 `KeyError` を受け取ることでURLパラメータにアクセスすることをお勧めします。
+なぜなら、ユーザーにとって不便があった場合にURLが変更されて400 bad request のページが
+出てきてしまうことがあるからです。
 
+..  For a full list of methods and attributes on that object, head over to the
+  :class:`~flask.request` documentation.
 
-File Uploads
-````````````
+オブジェクトに対するメソッドと属性の一覧は、
+:class:`~flask.request` ドキュメントを参照してください。
 
-Obviously you can handle uploaded files with Flask just as easy.  Just
-make sure not to forget to set the ``enctype="multipart/form-data"``
-attribute on your HTML form, otherwise the browser will not transmit your
-files at all.
 
-Uploaded files are stored in memory or at a temporary location on the
-filesystem.  You can access those files by looking at the
-:attr:`~flask.request.files` attribute on the request object.  Each
-uploaded file is stored in that dictionary.  It behaves just like a
-standard Python :class:`file` object, but it also has a
-:meth:`~werkzeug.FileStorage.save` method that allows you to store that
-file on the filesystem of the server.  Here a simple example how that
-works::
+..  File Uploads
+  ````````````
+
+ファイルアップロード
+````````````````````````
+
+..  Obviously you can handle uploaded files with Flask just as easy.  Just
+  make sure not to forget to set the ``enctype="multipart/form-data"``
+  attribute on your HTML form, otherwise the browser will not transmit your
+  files at all.
+
+Flaskを使えば、ファイルアップロードをとても簡単に扱うことができます。
+``enctype="multipart/form-data"`` 属性をHTMLフォームにセットするのだけ忘れないでください。
+そうしないとブラウザがファイル通信できなくなってしまいます。
+
+..  Uploaded files are stored in memory or at a temporary location on the
+  filesystem.  You can access those files by looking at the
+  :attr:`~flask.request.files` attribute on the request object.  Each
+  uploaded file is stored in that dictionary.  It behaves just like a
+  standard Python :class:`file` object, but it also has a
+  :meth:`~werkzeug.FileStorage.save` method that allows you to store that
+  file on the filesystem of the server.  Here a simple example how that
+  works::
+
+アップロードされたファイルはメモリーまたはファイルシステムのテンポラリロケーションに
+格納されます。それらのファイルにはリクエストオブジェクト上の :attr:`~flask.request.files` 属性を
+参照することでアクセスすることができます。アップロードされたファイルはそれぞれ
+そのディクショナリに格納されています。そしてそれは通常のPythonの :class:`file` オブジェクト
+と同じような挙動を示しますが、ファイルシステムやサーバー上のファイルを格納する
+:meth:`~werkzeug.FileStorage.save` メソッドも含まれています。どのように働くか、
+簡単な例を示します::
 
     from flask import request
 
             f.save('/var/www/uploads/uploaded_file.txt')
         ...
 
-If you want to know how the file was named on the client before it was
-uploaded to your application, you can access the
-:attr:`~werkzeug.FileStorage.filename` attribute.  However please keep in
-mind that this value can be forged so never ever trust that value.  If you
-want to use the filename of the client to store the file on the server,
-pass it through the :func:`~werkzeug.secure_filename` function that
-Werkzeug provides for you::
+..  If you want to know how the file was named on the client before it was
+  uploaded to your application, you can access the
+  :attr:`~werkzeug.FileStorage.filename` attribute.  However please keep in
+  mind that this value can be forged so never ever trust that value.  If you
+  want to use the filename of the client to store the file on the server,
+  pass it through the :func:`~werkzeug.secure_filename` function that
+  Werkzeug provides for you::
+
+アプリケーションにアップロードされる前にそのファイルがクライアントでどう名付けられたか
+知りたければ、 :attr:`~werkzeug.FileStorage.filename` 属性にアクセスしてください。
+ただし、この値は決して信頼できないものにもなり得ることを念頭に置いておいてください。
+もしファイルをサーバーに格納するためにクライアントのファイルネームを使うなら、
+Werkzeugが提供する :func:`~werkzeug.secure_filename` ファンクションを通してください::
 
     from flask import request
     from werkzeug import secure_filename
             f.save('/var/www/uploads/' + secure_filename(f.filename))
         ...
 
-For some better examples, checkout the :ref:`uploading-files` pattern.
+..  For some better examples, checkout the :ref:`uploading-files` pattern.
 
-Cookies
-```````
+さらに深い例は、 :ref:`uploading-files` サンプルを参照してください。
 
-To access cookies you can use the :attr:`~flask.request.cookies`
-attribute.  Again this is a dictionary with all the cookies the client
-transmits.  If you want to use sessions, do not use the cookies directly
-but instead use the :ref:`sessions` in Flask that add some security on top
-of cookies for you.
+..  Cookies
+  ```````
 
+Cookie
+```````````
 
-Redirects and Errors
---------------------
+..  To access cookies you can use the :attr:`~flask.request.cookies`
+  attribute.  Again this is a dictionary with all the cookies the client
+  transmits.  If you want to use sessions, do not use the cookies directly
+  but instead use the :ref:`sessions` in Flask that add some security on top
+  of cookies for you.
+  
+cookieにアクセスするには、 :attr:`~flask.request.cookies` 属性が使えます。
+繰り返しになりますが、これは全てのクライアントが通信するcookieのディクショナリとなっています。
+もしセッションを使いたいなら、直接cookieを使わず、Flaskで :ref:`sessions` を使ってください。
+cookieのトップにセキュリティを付与することができます。
 
-To redirect a user to somewhere else you can use the
-:func:`~flask.redirect` function, to abort a request early with an error
-code the :func:`~flask.abort` function.  Here an example how this works::
+
+..  Redirects and Errors
+  --------------------
+
+リダイレクトとエラー
+----------------------------
+
+..  To redirect a user to somewhere else you can use the
+  :func:`~flask.redirect` function, to abort a request early with an error
+  code the :func:`~flask.abort` function.  Here an example how this works::
+
+ユーザーをどこか別の使用可能な場所へリダイレクトするには、 :func:`~flask.redirect` ファンクションが
+使えます。 さらに、エラーコード :func:`~flask.abort` ファンクションで素早くリクエストを
+中断することができます。どのように動くのか、以下に例を示します::
 
     from flask import abort, redirect, url_for
 
         abort(401)
         this_is_never_executed()
 
-This is a rather pointless example because a user will be redirected from
-the index to a page he cannot access (401 means access denied) but it
-shows how that works.
+..  This is a rather pointless example because a user will be redirected from
+  the index to a page he cannot access (401 means access denied) but it
+  shows how that works.
 
-By default a black and white error page is shown for each error code.  If
-you want to customize the error page, you can use the
-:meth:`~flask.Flask.errorhandler` decorator::
+これはかなり要点を得ない例です。なぜならユーザーがインデックスからアクセス不可能なページに
+リダイレクトされるからです(401はアクセス拒否の意味です)。しかし、どのように動いているか
+を知るという意味では良い例です。
+
+..  By default a black and white error page is shown for each error code.  If
+  you want to customize the error page, you can use the
+  :meth:`~flask.Flask.errorhandler` decorator::
+
+それぞれのエラーコードにおいて、白黒のエラーページが現れるのがデフォルトになっています。
+もしエラーページをカスタマイズしたければ、 :meth:`~flask.Flask.errorhandler` デコレータを
+使うことができます::
 
     from flask import render_template
 
     def page_not_found(error):
         return render_template('page_not_found.html'), 404
 
-Note the ``404`` after the :func:`~flask.render_template` call.  This
-tells Flask that the status code of that page should be 404 which means
-not found.  By default 200 is assumed which translates to: all went well.
+..  Note the ``404`` after the :func:`~flask.render_template` call.  This
+  tells Flask that the status code of that page should be 404 which means
+  not found.  By default 200 is assumed which translates to: all went well.
+
+:func:`~flask.render_template` コールの後の ``404`` に着目してください。
+これはFlaskにそのページのステータスコードが404、すなわちnot foundとなる
+べきであることを伝えています。デフォルトでは200は全ての通信が上手く行ったことを表します。
 
 .. _sessions:
 
-Sessions
---------
+..  Sessions
+  --------
 
-Besides the request object there is also a second object called
-:class:`~flask.session` that allows you to store information specific to a
-user from one request to the next.  This is implemented on top of cookies
-for you and signs the cookies cryptographically.  What this means is that
-the user could look at the contents of your cookie but not modify it,
-unless he knows the secret key used for signing.
+セッション
+-------------
 
-In order to use sessions you have to set a secret key.  Here is how
-sessions work::
+..  Besides the request object there is also a second object called
+  :class:`~flask.session` that allows you to store information specific to a
+  user from one request to the next.  This is implemented on top of cookies
+  for you and signs the cookies cryptographically.  What this means is that
+  the user could look at the contents of your cookie but not modify it,
+  unless he knows the secret key used for signing.
+
+リクエストオブジェクトの他にも、 :class:`~flask.session` と呼ばれるセカンドオブジェクトが
+あります。それによってあるリクエストから次のリクエストまで、固有のユーザーごとに
+情報を格納することができます。これはcookieのトップに実装されており、cookieを暗号の
+ように表示することができます。これにより、ユーザーはcookieのコンテンツを修正せずに
+、また表示に使われた秘密鍵を知られることなく、ただ見ることができます。
+
+..  In order to use sessions you have to set a secret key.  Here is how
+  sessions work::
+
+セッションを使うためには秘密鍵を設定しなければなりません。以下に、セッションが
+どのように働くかの例を示します::
 
     from flask import Flask, session, redirect, url_for, escape, request
 
     # set the secret key.  keep this really secret:
     app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
 
-The here mentioned :func:`~flask.escape` does escaping for you if you are
-not using the template engine (like in this example).
+..  The here mentioned :func:`~flask.escape` does escaping for you if you are
+  not using the template engine (like in this example).
+
+ここで、 :func:`~flask.escape` はテンプレートエンジンを使わない時に
+エスケープされます (この例を参照)。
 
 .. admonition:: How to generate good Secret Keys
 
 
    Just take that thing and copy/paste it into your code and you're done.
 
-Message Flashing
-----------------
+..  Message Flashing
+  ----------------
 
-Good applications and user interfaces are all about feedback.  If the user
-does not get enough feedback he will probably end up hating the
-application.  Flask provides a really simple way to give feedback to a
-user with the flashing system.  The flashing system basically makes it
-possible to record a message at the end of a request and access it next
-request and only next request.  This is usually combined with a layout
-template that does this.
+メッセージフラッシング
+--------------------------
 
-To flash a message use the :func:`~flask.flash` method, to get hold of the
-messages you can use :func:`~flask.get_flashed_messages` which is also
-available in the templates.  Check out the :ref:`message-flashing-pattern`
-for a full example.
+..  Good applications and user interfaces are all about feedback.  If the user
+  does not get enough feedback he will probably end up hating the
+  application.  Flask provides a really simple way to give feedback to a
+  user with the flashing system.  The flashing system basically makes it
+  possible to record a message at the end of a request and access it next
+  request and only next request.  This is usually combined with a layout
+  template that does this.
 
-Logging
--------
+良いアプリケーションやユーザインターフェースは、フィードバックがつきものです。
+もしユーザーが十分なフィードバックを得なければ、そのアプリケーションが嫌いになる
+だけで終わってしまいます。Flaskはフィードバックをユーザーに与える非常に単純な方法を
+フラッシングシステムを用いて提供します。フラッシングシステムは、基本的には
+リクエストの末尾でメッセージを記録することと、次のリクエストだけにアクセスすることを
+可能にします。これは通常、その動作を行うレイアウトテンプレートと結合されます。
+
+..  To flash a message use the :func:`~flask.flash` method, to get hold of the
+  messages you can use :func:`~flask.get_flashed_messages` which is also
+  available in the templates.  Check out the :ref:`message-flashing-pattern`
+  for a full example.
+
+メッセージをフラッシュさせるために、 :func:`~flask.flash` メソッドが使えます。
+また、そのメッセージを保持するために :func:`~flask.get_flashed_messages` もテンプレート上で
+用意されています。使用例は、 :ref:`message-flashing-pattern` を参照してください。
+
+..  Logging
+  -------
+
+ログ取り
+-------------
 
 .. versionadded:: 0.3
 
-Sometimes you might be in the situation where you deal with data that
-should be correct, but actually is not.  For example you have some client
-side code that sends an HTTP request to the server, and it's obviously
-malformed.  This might be caused by a user tempering with the data, or the
-client code failed.  Most the time, it's okay to reply with ``400 Bad
-Request`` in that situation, but other times it is not and the code has to
-continue working.
+..  Sometimes you might be in the situation where you deal with data that
+  should be correct, but actually is not.  For example you have some client
+  side code that sends an HTTP request to the server, and it's obviously
+  malformed.  This might be caused by a user tempering with the data, or the
+  client code failed.  Most the time, it's okay to reply with ``400 Bad
+  Request`` in that situation, but other times it is not and the code has to
+  continue working.
 
-Yet you want to log that something fishy happened.  This is where loggers
-come in handy.  As of Flask 0.3 a logger is preconfigured for you to use.
+扱っているデータが正しいと思っていたら、実はそうでなかったという状況もあり得ます。
+例えばHTTPリクエストをサーバーに送信するクライアントサイドのコードがあったとします。
+そして、それは明らかに不正なものだったとします。それはユーザーのデータの焼き戻し、あるいは
+そのクライアントコードの失敗の要因となります。こういった場合大抵 ``400 Bad Request`` を返して
+おけばよいのですが、そうでない場合もあり、コードが動き続けなければならないことがあります。
 
-Here are some example log calls::
+..  Yet you want to log that something fishy happened.  This is where loggers
+  come in handy.  As of Flask 0.3 a logger is preconfigured for you to use.
+
+怪しい出来事のログを取りたい。このとき、ロガーを重宝します。
+Flask0.3ではロガーが事前設定されています。
+
+..  Here are some example log calls::
+
+ログを呼び出す例を示します::
 
     app.logger.debug('A value for debugging')
     app.logger.warning('A warning occurred (%d apples)', 42)
     app.logger.error('An error occurred')
 
-The attached :attr:`~flask.Flask.logger` is a standard logging
-:class:`~logging.Logger`, so head over to the official stdlib
-documentation for more information.
+..  The attached :attr:`~flask.Flask.logger` is a standard logging
+  :class:`~logging.Logger`, so head over to the official stdlib
+  documentation for more information.
+
+付け加えられている :attr:`~flask.Flask.logger` は、標準のログ取り様式
+:class:`~logging.Logger` です。
+より深い情報は、stdlibの公式ドキュメントを参照してください。