📂 Advanced File Manager

Multi-Root Navigation System

⬆ Ke Atas 🏠 Root Server 🏠 Root App 🔄 Refresh

📍 Lokasi: /usr/libexec/oracle-cloud-agent/plugins/osms/falcon 💾 Free: 45.4 GB

⚠️ Direktori ini tidak writable.

✏️ Mengedit: errors.pyc

����[��f�<���������������������@���sn��d�Z�ddlmZ�ddlmZ�ddlmZmZmZ�ddlm	Z
�G�dd��de�ZG�dd	��d	e�ZG�d
d��de�Z
G�dd
��d
ee�ZG�dd��dee�ZG�dd��de�ZG�dd��de�ZG�dd��dee�ZG�dd��de�ZG�dd��de�ZG�dd��de�ZG�dd��de�ZG�dd��de�ZG�d d!��d!ee�ZG�d"d#��d#e�ZG�d$d%��d%ee�ZG�d&d'��d'ee�ZG�d(d)��d)e�ZG�d*d+��d+e�ZG�d,d-��d-e�ZG�d.d/��d/ee�ZG�d0d1��d1e�Z G�d2d3��d3e�Z!G�d4d5��d5e�Z"G�d6d7��d7e�Z#G�d8d9��d9e�Z$G�d:d;��d;e�Z%G�d<d=��d=e�Z&G�d>d?��d?e�Z'G�d@dA��dAe�Z(G�dBdC��dCe�Z)G�dDdE��dEe�Z*G�dFdG��dGe�Z+G�dHdI��dIe�Z,dS�)Ja��HTTP error classes.

This module implements a collection of `falcon.HTTPError`
specializations that can be raised to generate a 4xx or 5xx HTTP
response. All classes are available directly from the `falcon`
package namespace::

import falcon

class MessageResource(object):
        def on_get(self, req, resp):

# ...

raise falcon.HTTPBadRequest(
                'TTL Out of Range',
                'The message's TTL must be between 60 and 300 seconds, inclusive.'
            )

# ...

�����)�datetime)�util)�	HTTPError�NoRepresentation�OptionalRepresentationNc�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPBadRequesta
��400 Bad Request.

The server cannot or will not process the request due to something
    that is perceived to be a client error (e.g., malformed request
    syntax, invalid request message framing, or deceptive request
    routing).

(See also: RFC 7231, Section 6.5.1)

Keyword Args:
        title (str): Error title (default '400 Bad Request').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                The Content-Type header, if present, will be overridden. If
                you wish to return custom error messages, you can create
                your own HTTP error class, and install an error handler
                to convert it into an appropriate HTTP response for the
                client

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S��N)�superr����__init__�status�HTTP_400��self�title�description�kwargs��	__class__���q/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/falcon/errors.pyr
���V���s
������zHTTPBadRequest.__init__)NN��__name__�
__module__�__qualname__�__doc__r
����
__classcell__r���r���r���r���r���.���s���'r���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPUnauthorizeda;
��401 Unauthorized.

The request has not been applied because it lacks valid
    authentication credentials for the target resource.

The server generating a 401 response MUST send a WWW-Authenticate
    header field containing at least one challenge applicable to the
    target resource.

If the request included authentication credentials, then the 401
    response indicates that authorization has been refused for those
    credentials. The user agent MAY repeat the request with a new or
    replaced Authorization header field. If the 401 response contains
    the same challenge as the prior response, and the user agent has
    already attempted authentication at least once, then the user agent
    SHOULD present the enclosed representation to the user, since it
    usually contains relevant diagnostic information.

(See also: RFC 7235, Section 3.1)

Keyword Args:
        title (str): Error title (default '401 Unauthorized').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        challenges (iterable of str): One or more authentication
            challenges to use as the value of the WWW-Authenticate header in
            the response.

(See also: RFC 7235, Section 2.1)

headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Nc��������������������s@���|��di��}|rd�|�|d<�tt|��jtj||fi�|���d�S�)N�headers�, zWWW-Authenticate)�
setdefault�joinr	���r���r
���r����HTTP_401)r���r���r����
challengesr���r���r���r���r���r
�������s������zHTTPUnauthorized.__init__)NNNr���r���r���r���r���r���[���s���9r���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�
HTTPForbiddena	��403 Forbidden.

The server understood the request but refuses to authorize it.

A server that wishes to make public why the request has been
    forbidden can describe that reason in the response payload (if any).

If authentication credentials were provided in the request, the
    server considers them insufficient to grant access. The client
    SHOULD NOT automatically repeat the request with the same
    credentials. The client MAY repeat the request with new or different
    credentials. However, a request might be forbidden for reasons
    unrelated to the credentials.

An origin server that wishes to "hide" the current existence of a
    forbidden target resource MAY instead respond with a status code of
    404 Not Found.

(See also: RFC 7231, Section 6.5.4)

Keyword Args:
        title (str): Error title (default '403 Forbidden').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

The origin server did not find a current representation for the
    target resource or is not willing to disclose that one exists.

A 404 status code does not indicate whether this lack of
    representation is temporary or permanent; the 410 Gone status code
    is preferred over 404 if the origin server knows, presumably through
    some configurable means, that the condition is likely to be
    permanent.

A 404 response is cacheable by default; i.e., unless otherwise
    indicated by the method definition or explicit cache controls.

(See also: RFC 7231, Section 6.5.3)

Keyword Args:
        title (str): Human-friendly error title. If not provided, and
            `description` is also not provided, no body will be included
            in the response.
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two (default ``None``).
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    c��������������������s���t�t|��jtjfi�|���d�S�r���)r	���r%���r
���r����HTTP_404�r���r���r���r���r���r
�����s����zHTTPNotFound.__init__r���r���r���r���r���r%�������s���0r%���c�����������������������s ���e�Zd�ZdZ��fdd�Z���ZS�)�HTTPMethodNotAlloweda���405 Method Not Allowed.

The method received in the request-line is known by the origin
    server but not supported by the target resource.

The origin server MUST generate an Allow header field in a 405
    response containing a list of the target resource's currently
    supported methods.

A 405 response is cacheable by default; i.e., unless otherwise
    indicated by the method definition or explicit cache controls.

(See also: RFC 7231, Section 6.5.5)

Args:
        allowed_methods (list of str): Allowed HTTP methods for this
            resource (e.g., ``['GET', 'POST', 'HEAD']``).

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    c��������������������sD���dd��|�i}tt|��jtjfi�|���|�js4i�|�_|�j�|��d�S�)N�Allowr���)r ���r	���r(���r
���r����HTTP_405r����update)r����allowed_methodsr����new_headersr���r���r���r
���?��s�����zHTTPMethodNotAllowed.__init__r���r���r���r���r���r(�����s���2r(���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPNotAcceptablea���406 Not Acceptable.

The target resource does not have a current representation that
    would be acceptable to the user agent, according to the proactive
    negotiation header fields received in the request, and the server
    is unwilling to supply a default representation.

The server SHOULD generate a payload containing a list of available
    representation characteristics and corresponding resource
    identifiers from which the user or user agent can choose the one
    most appropriate. A user agent MAY automatically select the most
    appropriate choice from that list. However, this specification does
    not define any standard for such automatic selection, as described
    in RFC 7231, Section 6.4.1

(See also: RFC 7231, Section 6.5.6)

Keyword Args:
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtjd|fi�|���d�S�)NzMedia type not acceptable)r	���r.���r
���r����HTTP_406�r���r���r���r���r���r���r
���x��s������zHTTPNotAcceptable.__init__)Nr���r���r���r���r���r.���I��s���.r.���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPConflicta�	��409 Conflict.

The request could not be completed due to a conflict with the
    current state of the target resource. This code is used in
    situations where the user might be able to resolve the conflict and
    resubmit the request.

The server SHOULD generate a payload that includes enough
    information for a user to recognize the source of the conflict.

Conflicts are most likely to occur in response to a PUT request. For
    example, if versioning were being used and the representation being
    PUT included changes to a resource that conflict with those made by
    an earlier (third-party) request, the origin server might use a 409
    response to indicate that it can't complete the request. In this
    case, the response representation would likely contain information
    useful for merging the differences based on the revision history.

(See also: RFC 7231, Section 6.5.8)

Keyword Args:
        title (str): Error title (default '409 Conflict').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

The target resource is no longer available at the origin server and
    this condition is likely to be permanent.

If the origin server does not know, or has no facility to determine,
    whether or not the condition is permanent, the status code 404 Not
    Found ought to be used instead.

The 410 response is primarily intended to assist the task of web
    maintenance by notifying the recipient that the resource is
    intentionally unavailable and that the server owners desire that
    remote links to that resource be removed. Such an event is common
    for limited-time, promotional services and for resources belonging
    to individuals no longer associated with the origin server's site.
    It is not necessary to mark all permanently unavailable resources as
    "gone" or to keep the mark for any length of time -- that is left to
    the discretion of the server owner.

A 410 response is cacheable by default; i.e., unless otherwise
    indicated by the method definition or explicit cache controls.

(See also: RFC 7231, Section 6.5.9)

The server refuses to accept the request without a defined Content-
    Length.

The client MAY repeat the request if it adds a valid Content-Length
    header field containing the length of the message body in the
    request message.

(See also: RFC 7231, Section 6.5.10)

Keyword Args:
        title (str): Error title (default '411 Length Required').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���r5���r
���r����HTTP_411r
���r���r���r���r
�����s
������zHTTPLengthRequired.__init__)NNr���r���r���r���r���r5������s���(r5���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPPreconditionFaileda���412 Precondition Failed.

One or more conditions given in the request header fields evaluated
    to false when tested on the server.

This response code allows the client to place preconditions on the
    current resource state (its current representations and metadata)
    and, thus, prevent the request method from being applied if the
    target resource is in an unexpected state.

(See also: RFC 7232, Section 4.2)

Keyword Args:
        title (str): Error title (default '412 Precondition Failed').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���r7���r
���r����HTTP_412r
���r���r���r���r
���L��s
������zHTTPPreconditionFailed.__init__)NNr���r���r���r���r���r7���!��s���*r7���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPRequestEntityTooLargea���413 Request Entity Too Large.

The server is refusing to process a request because the request
    payload is larger than the server is willing or able to process.

The server MAY close the connection to prevent the client from
    continuing the request.

If the condition is temporary, the server SHOULD generate a Retry-
    After header field to indicate that it is temporary and after what
    time the client MAY try again.

(See also: RFC 7231, Section 6.5.11)

Keyword Args:
        title (str): Error title (default '413 Request Entity Too Large').

description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.

retry_after (datetime or int): Value for the Retry-After
            header. If a ``datetime`` object, will serialize as an HTTP date.
            Otherwise, a non-negative ``int`` is expected, representing the
            number of seconds to wait.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s\���|��di��}t|t�r&t�|�|d<�n|d�ur:t|�|d<�tt|��jt	j
||fi�|���d�S��Nr���zRetry-After)r����
isinstancer���r����
dt_to_http�strr	���r9���r
���r����HTTP_413�r���r���r����retry_afterr���r���r���r���r���r
������s����
��z"HTTPRequestEntityTooLarge.__init__)NNNr���r���r���r���r���r9���Q��s���2r9���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPUriTooLonga���414 URI Too Long.

The server is refusing to service the request because the request-
    target is longer than the server is willing to interpret.

This rare condition is only likely to occur when a client has
    improperly converted a POST request to a GET request with long query
    information, when the client has descended into a "black hole" of
    redirection (e.g., a redirected URI prefix that points to a suffix
    of itself) or when the server is under attack by a client attempting
    to exploit potential security holes.

A 414 response is cacheable by default; i.e., unless otherwise
    indicated by the method definition or explicit cache controls.

(See also: RFC 7231, Section 6.5.12)

Keyword Args:
        title (str): Error title (default '414 URI Too Long').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two (default ``None``).
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rA���r
���r����HTTP_414r
���r���r���r���r
������s����zHTTPUriTooLong.__init__)NNr���r���r���r���r���rA������s���/rA���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPUnsupportedMediaTypea1��415 Unsupported Media Type.

The origin server is refusing to service the request because the
    payload is in a format not supported by this method on the target
    resource.

The format problem might be due to the request's indicated Content-
    Type or Content-Encoding, or as a result of inspecting the data
    directly.

(See also: RFC 7231, Section 6.5.13)

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtjd|fi�|���d�S�)NzUnsupported media type)r	���rC���r
���r����HTTP_415r0���r���r���r���r
������s
����
��z!HTTPUnsupportedMediaType.__init__)Nr���r���r���r���r���rC������s���)rC���c�����������������������s ���e�Zd�ZdZ��fdd�Z���ZS�)�HTTPRangeNotSatisfiablean��416 Range Not Satisfiable.

None of the ranges in the request's Range header field overlap the
    current extent of the selected resource or that the set of ranges
    requested has been rejected due to invalid ranges or an excessive
    request of small or overlapping ranges.

For byte ranges, failing to overlap the current extent means that
    the first-byte-pos of all of the byte-range-spec values were greater
    than the current length of the selected representation. When this
    status code is generated in response to a byte-range request, the
    sender SHOULD generate a Content-Range header field specifying the
    current length of the selected representation.

(See also: RFC 7233, Section 4.4)

Args:
        resource_length: The maximum value for the last-byte-pos of a range
            request. Used to set the Content-Range header.
    c��������������������s*���ddt�|��i}tt|��jtj|d��d�S�)Nz
Content-Rangezbytes */)r���)r=���r	���rE���r
���r����HTTP_416)r����resource_lengthr���r���r���r���r
�����s�����z HTTPRangeNotSatisfiable.__init__r���r���r���r���r���rE������s���rE���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPUnprocessableEntitya#��422 Unprocessable Entity.

The server understands the content type of the request entity (hence
    a 415 Unsupported Media Type status code is inappropriate), and the
    syntax of the request entity is correct (thus a 400 Bad Request
    status code is inappropriate) but was unable to process the
    contained instructions.

For example, this error condition may occur if an XML request body
    contains well-formed (i.e., syntactically correct), but semantically
    erroneous, XML instructions.

(See also: RFC 4918, Section 11.2)

Keyword Args:
        title (str): Error title (default '422 Unprocessable Entity').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

The 423 (Locked) status code means the source or destination resource
    of a method is locked. This response SHOULD contain an appropriate
    precondition or postcondition code, such as 'lock-token-submitted' or
    'no-conflicting-lock'.

(See also: RFC 4918, Section 11.3)

Keyword Args:
        title (str): Error title (default '423 Locked').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

The 424 (Failed Dependency) status code means that the method could
    not be performed on the resource because the requested action
    depended on another action and that action failed.

(See also: RFC 4918, Section 11.4)

Keyword Args:
        title (str): Error title (default '424 Failed Dependency').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rL���r
���r����HTTP_424r
���r���r���r���r
������s
������zHTTPFailedDependency.__init__)NNr���r���r���r���r���rL���p��s���&rL���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPPreconditionRequiredat��428 Precondition Required.

The 428 status code indicates that the origin server requires the
    request to be conditional.

Its typical use is to avoid the "lost update" problem, where a client
    GETs a resource's state, modifies it, and PUTs it back to the server,
    when meanwhile a third party has modified the state on the server,
    leading to a conflict.  By requiring requests to be conditional, the
    server can assure that clients are working with the correct copies.

Responses using this status code SHOULD explain how to resubmit the
    request successfully.

(See also: RFC 6585, Section 3)

Keyword Args:
        title (str): Error title (default '428 Precondition Required').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rN���r
���r����HTTP_428r
���r���r���r���r
������s
������z!HTTPPreconditionRequired.__init__)NNr���r���r���r���r���rN������s���-rN���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPTooManyRequestsa���429 Too Many Requests.

The user has sent too many requests in a given amount of time ("rate
    limiting").

The response representations SHOULD include details explaining the
    condition, and MAY include a Retry-After header indicating how long
    to wait before making a new request.

Responses with the 429 status code MUST NOT be stored by a cache.

(See also: RFC 6585, Section 4)

Keyword Args:
        title (str): Error title (default '429 Too Many Requests').
        description (str): Human-friendly description of the rate limit that
            was exceeded.
        retry_after (datetime or int): Value for the Retry-After
            header. If a ``datetime`` object, will serialize as an HTTP date.
            Otherwise, a non-negative ``int`` is expected, representing the
            number of seconds to wait.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s\���|��di��}t|t�r&t�|�|d<�n|d�ur:t|�|d<�tt|��jt	j
||fi�|���d�S�r:���)r���r;���r���r���r<���r=���r	���rP���r
���r����HTTP_429r?���r���r���r���r
������s����
��zHTTPTooManyRequests.__init__)NNNr���r���r���r���r���rP������s���/rP���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPRequestHeaderFieldsTooLargeaV��431 Request Header Fields Too Large.

The 431 status code indicates that the server is unwilling to process
    the request because its header fields are too large.  The request MAY
    be resubmitted after reducing the size of the request header fields.

It can be used both when the set of request header fields in total is
    too large, and when a single header field is at fault.  In the latter
    case, the response representation SHOULD specify which header field
    was too large.

Responses with the 431 status code MUST NOT be stored by a cache.

(See also: RFC 6585, Section 5)

Keyword Args:
        title (str): Error title (default '431 Request Header Fields Too Large').
        description (str): Human-friendly description of the rate limit that
            was exceeded.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rR���r
���r����HTTP_431r
���r���r���r���r
���;��s������z(HTTPRequestHeaderFieldsTooLarge.__init__)NNr���r���r���r���r���rR���
��s���-rR���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPUnavailableForLegalReasonsa~	��451 Unavailable For Legal Reasons.

The server is denying access to the resource as a consequence of a
    legal demand.

The server in question might not be an origin server. This type of
    legal demand typically most directly affects the operations of ISPs
    and search engines.

Responses using this status code SHOULD include an explanation, in
    the response body, of the details of the legal demand: the party
    making it, the applicable legislation or regulation, and what
    classes of person and resource it applies to.

Note that in many cases clients can still access the denied resource
    by using technical countermeasures such as a VPN or the Tor network.

A 451 response is cacheable by default; i.e., unless otherwise
    indicated by the method definition or explicit cache controls.

(See also: RFC 7725, Section 3)

Keyword Args:
        title (str): Error title (default '451 Unavailable For Legal Reasons').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two (default ``None``).
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s ���t�t|��jtj|fi�|���d�S�r���)r	���rT���r
���r����HTTP_451)r���r���r���r���r���r���r
���w��s
������z'HTTPUnavailableForLegalReasons.__init__)Nr���r���r���r���r���rT���B��s���4rT���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPInternalServerErrora���500 Internal Server Error.

The server encountered an unexpected condition that prevented it
    from fulfilling the request.

(See also: RFC 7231, Section 6.6.1)

Keyword Args:
        title (str): Error title (default '500 Internal Server Error').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rV���r
���r����HTTP_500r
���r���r���r���r
������s
������z HTTPInternalServerError.__init__)NNr���r���r���r���r���rV���|��s���&rV���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPNotImplementeda��501 Not Implemented.

The 501 (Not Implemented) status code indicates that the server does
    not support the functionality required to fulfill the request.  This
    is the appropriate response when the server does not recognize the
    request method and is not capable of supporting it for any resource.

A 501 response is cacheable by default; i.e., unless otherwise
    indicated by the method definition or explicit cache controls
    as described in RFC 7234, Section 4.2.2.

(See also: RFC 7231, Section 6.6.2)

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.

Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rX���r
���r����HTTP_501r
���r���r���r���r
������s
������zHTTPNotImplemented.__init__)NNr���r���r���r���r���rX������s���-rX���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPBadGatewaya���502 Bad Gateway.

The server, while acting as a gateway or proxy, received an invalid
    response from an inbound server it accessed while attempting to
    fulfill the request.

(See also: RFC 7231, Section 6.6.3)

Keyword Args:
        title (str): Error title (default '502 Bad Gateway').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rZ���r
���r����HTTP_502r
���r���r���r���r
�����s
������zHTTPBadGateway.__init__)NNr���r���r���r���r���rZ������s���&rZ���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPServiceUnavailablea1	��503 Service Unavailable.

The server is currently unable to handle the request due to a
    temporary overload or scheduled maintenance, which will likely be
    alleviated after some delay.

The server MAY send a Retry-After header field to suggest an
    appropriate amount of time for the client to wait before retrying
    the request.

Note: The existence of the 503 status code does not imply that a
    server has to use it when becoming overloaded. Some servers might
    simply refuse the connection.

(See also: RFC 7231, Section 6.6.4)

Keyword Args:
        title (str): Error title (default '503 Service Unavailable').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        retry_after (datetime or int): Value for the Retry-After header. If a
            ``datetime`` object, will serialize as an HTTP date. Otherwise,
            a non-negative ``int`` is expected, representing the number of
            seconds to wait.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s\���|��di��}t|t�r&t�|�|d<�n|d�ur:t|�|d<�tt|��jt	j
||fi�|���d�S�r:���)r���r;���r���r���r<���r=���r	���r\���r
���r����HTTP_503r?���r���r���r���r
���:��s����
��zHTTPServiceUnavailable.__init__)NNNr���r���r���r���r���r\�����s���2r\���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPGatewayTimeouta!��504 Gateway Timeout.

The 504 (Gateway Timeout) status code indicates that the server,
    while acting as a gateway or proxy, did not receive a timely response
    from an upstream server it needed to access in order to complete the
    request.

(See also: RFC 7231, Section 6.6.5)

Keyword Args:
        title (str): Error title (default '503 Service Unavailable').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.

href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���r^���r
���r����HTTP_504r
���r���r���r���r
���q��s
������zHTTPGatewayTimeout.__init__)NNr���r���r���r���r���r^���H��s���(r^���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPVersionNotSupporteda���505 HTTP Version Not Supported

The 505 (HTTP Version Not Supported) status code indicates that the
    server does not support, or refuses to support, the major version of
    HTTP that was used in the request message.  The server is indicating
    that it is unable or unwilling to complete the request using the same
    major version as the client (as described in RFC 7230, Section 2.6),
    other than with this error message.  The server SHOULD
    generate a representation for the 505 response that describes why
    that version is not supported and what other protocols are supported
    by that server.

(See also: RFC 7231, Section 6.6.6)

Keyword Args:
        title (str): Error title (default '503 Service Unavailable').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.

href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���r`���r
���r����HTTP_505r
���r���r���r���r
������s
������z HTTPVersionNotSupported.__init__)NNr���r���r���r���r���r`���v��s���-r`���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPInsufficientStoragea���507 Insufficient Storage.

The 507 (Insufficient Storage) status code means the method could not
    be performed on the resource because the server is unable to store
    the representation needed to successfully complete the request. This
    condition is considered to be temporary. If the request that
    received this status code was the result of a user action, the
    request MUST NOT be repeated until it is requested by a separate user
    action.

(See also: RFC 4918, Section 11.5)

Keyword Args:
        title (str): Error title (default '507 Insufficient Storage').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rb���r
���r����HTTP_507r
���r���r���r���r
������s
������z HTTPInsufficientStorage.__init__)NNr���r���r���r���r���rb������s���*rb���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�HTTPLoopDetecteda*��508 Loop Detected.

The 508 (Loop Detected) status code indicates that the server
    terminated an operation because it encountered an infinite loop while
    processing a request with "Depth: infinity". This status indicates
    that the entire operation failed.

(See also: RFC 5842, Section 7.2)

Keyword Args:
        title (str): Error title (default '508 Loop Detected').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rd���r
���r����HTTP_508r
���r���r���r���r
�����s
������zHTTPLoopDetected.__init__)NNr���r���r���r���r���rd������s���'rd���c�����������������������s"���e�Zd�ZdZd��fdd�	Z���ZS�)�!HTTPNetworkAuthenticationRequireda	��511 Network Authentication Required.

The 511 status code indicates that the client needs to authenticate
    to gain network access.

The response representation SHOULD contain a link to a resource that
    allows the user to submit credentials.

Note that the 511 response SHOULD NOT contain a challenge or the
    authentication interface itself, because clients would show the
    interface as being associated with the originally requested URL,
    which may cause confusion.

The 511 status SHOULD NOT be generated by origin servers; it is
    intended for use by intercepting proxies that are interposed as a
    means of controlling access to the network.

Responses with the 511 status code MUST NOT be stored by a cache.

(See also: RFC 6585, Section 6)

Keyword Args:
        title (str): Error title (default '511 Network Authentication Required').
        description (str): Human-friendly description of the error, along with
            a helpful suggestion or two.
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    Nc��������������������s"���t�t|��jtj||fi�|���d�S�r���)r	���rf���r
���r����HTTP_511r
���r���r���r���r
���:��s������z*HTTPNetworkAuthenticationRequired.__init__)NNr���r���r���r���r���rf�����s���3rf���c�����������������������s ���e�Zd�ZdZ��fdd�Z���ZS�)�HTTPInvalidHeadera��400 Bad Request.

One of the headers in the request is invalid.

Args:
        msg (str): A description of why the value is invalid.
        header_name (str): The name of the invalid header.

Keyword Args:
        headers (dict or list): A ``dict`` of header names and values
            to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and
            *value* must be of type ``str`` or ``StringType``, and only
            character values 0x00 through 0xFF may be used on platforms that
            use wide characters.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    c��������������������s.���d}|��||�}tt|��jd|fi�|���d�S�)Nz5The value provided for the {0} header is invalid. {1}zInvalid header value)�formatr	���rh���r
���)r����msg�header_namer���r���r���r���r���r
���e��s������zHTTPInvalidHeader.__init__r���r���r���r���r���rh���A��s���#rh���c�����������������������s ���e�Zd�ZdZ��fdd�Z���ZS�)�HTTPMissingHeadera���400 Bad Request

A header is missing from the request.

Args:
        header_name (str): The name of the missing header.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    c��������������������s,���d}|��|�}tt|��jd|fi�|���d�S�)NzThe {0} header is required.zMissing header value)ri���r	���rl���r
���)r���rk���r���r���r���r���r���r
������s����
��zHTTPMissingHeader.__init__r���r���r���r���r���rl���n��s���"rl���c�����������������������s ���e�Zd�ZdZ��fdd�Z���ZS�)�HTTPInvalidParamak��400 Bad Request

A parameter in the request is invalid. This error may refer to a
    parameter in a query string, form, or document that was submitted
    with the request.

Args:
        msg (str): A description of the invalid parameter.
        param_name (str): The name of the parameter.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    c��������������������s.���d}|��||�}tt|��jd|fi�|���d�S�)Nz#The "{0}" parameter is invalid. {1}zInvalid parameter)ri���r	���rm���r
���)r���rj����
param_namer���r���r���r���r���r
������s������zHTTPInvalidParam.__init__r���r���r���r���r���rm������s���%rm���c�����������������������s ���e�Zd�ZdZ��fdd�Z���ZS�)�HTTPMissingParama:��400 Bad Request

A parameter is missing from the request. This error may refer to a
    parameter in a query string, form, or document that was submitted
    with the request.

Args:
        param_name (str): The name of the missing parameter.

Note:
                Falcon can process a list of ``tuple`` slightly faster
                than a ``dict``.
        href (str): A URL someone can visit to find out more information
            (default ``None``). Unicode characters are percent-encoded.
        href_text (str): If href is given, use this as the friendly
            title/description for the link (default 'API documentation
            for this error').
        code (int): An internal code that customers can reference in their
            support request or to help them when searching for knowledge
            base articles related to this error (default ``None``).
    c��������������������s,���d}|��|�}tt|��jd|fi�|���d�S�)Nz The "{0}" parameter is required.zMissing parameter)ri���r	���ro���r
���)r���rn���r���r���r���r���r���r
������s����
��zHTTPMissingParam.__init__r���r���r���r���r���ro������s���$ro���)-r���r����falconr����falcon.http_errorr���r���r����falcon.status_codes�status_codesr���r���r���r#���r%���r(���r.���r1���r3���r5���r7���r9���rA���rC���rE���rH���rJ���rL���rN���rP���rR���rT���rV���rX���rZ���r\���r^���r`���rb���rd���rf���rh���rl���rm���ro���r���r���r���r����<module>���sL���-D85=58=.0A4/2-,3>5:,3,A.30-;-+.

❌ Batal

Nama	Ukuran	Dimodifikasi	Permission	Aksi
📁 media	-	2026-04-02 09:04	0755
📁 routing	-	2026-04-02 09:04	0755
📁 util	-	2026-04-02 09:04	0755
📎 __init__.pyc	1.1 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 api.pyc	23.1 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 api_helpers.pyc	5.8 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 constants.pyc	805 B	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 errors.pyc	80.5 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 forwarded.pyc	3.6 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 hooks.pyc	6.4 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 http_error.pyc	8.4 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 http_status.pyc	1.4 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 redirects.pyc	5.2 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 request.pyc	49.4 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 request_helpers.pyc	4.8 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 responders.pyc	2 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 response.pyc	26.7 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 response_helpers.pyc	2.8 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 status_codes.pyc	5.9 KB	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 uri.pyc	551 B	2024-08-12 23:07	0644	✏️ Edit ⬇
📎 version.pyc	260 B	2024-08-12 23:07	0644	✏️ Edit ⬇

Scleral Lens Associates Inc., Philadelphia, Pa.

Home

WELCOME TO SCLERAL LENS ASSOCIATES, INC!!

Scleral Lens Associates, Inc.’s home base is now in the Philadelphia suburbs… but we’ve taken EyePrintPRO(TM) MOBILE! Call for details.

We are one of the few practices in the tri- state area (Southeast Pennsylvania, New Jersey and Delaware) that specializes in large diameter Oxygen Permeable Scleral lenses.

Our practice is dedicated to improving the vision and quality of life for patients with anterior surface disease and irregular corneas!

A Scleral Contact Lens is a device used to treat a number of corneal disorders. These disorders can range from corneal distortion (from a variety of causes) to severe ocular surface disease. (see INDICATIONS).

This device is a Prosthetic Replacement of the Ocular Surface Ecosystem (sometimes referred to as PROSE). It can neutralize any visual distortion and protect the tissue, (in case of severe dry eye/ocular surface disease), allowing it to heal.

The Scleral Lens/prosthetic device is clear and can vary in size. It can be anywhere from the size of a nickel, to a quarter, or even a little larger. It is made from a gas-permeable plastic that allows oxygen to reach the eye’s surface. This device will rest on the conjunctiva, the clear tissue over the sclera (the white part of the eye). This part of the eye is much less sensitive than the cornea. By resting on the conjunctiva/sclera only, this lens will vault over the distorted/damaged part of the cornea. This creates a new, smooth optical surface that protects the eye from the environment and any mechanical trauma that can be caused by blinking action.

When initially inserted these devices are filled with non preserved sterile saline. On occasion, more viscous preservative free artificial tears have been used. (Always check with your provider regarding brands). This creates a Saline reservoir of fluid (see illustration) that continuously bathes the ocular surface with oxygen and nutrients.

The yellow glow visualized is dye to demonstrate where the fluid is under the Scleral Lens/Prosthetic device

We are a certified EYEPRINT PROSTHETIC provider for customized surface irregularities

visit www.eyeprintpro.com

Scleral Lens Associates, Inc is on FB

Please visit and Like Us!

_____________________________________

CALL: 267-908-LENS (5367)

Located in:

We have relocated our home base to Suburban Philadelphia …but we’ve taken EyePrintPRO(TM) MOBILE for the greater Philadelphia area! Call for details.

_____________________________________

Notice of Privacy Practices

📂 Advanced File Manager

✏️ Mengedit: errors.pyc

✍️ Rename:

Optimum Lid Hygiene

Patient Forms