Add files using upload-large-folder tool

lib/python3.10/site-packages/grpc/aio/_call.py

@@ -0,0 +1,764 @@
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Invocation-side implementation of gRPC Asyncio Python."""
+
+import asyncio
+import enum
+from functools import partial
+import inspect
+import logging
+import traceback
+from typing import (
+    Any,
+    AsyncIterator,
+    Generator,
+    Generic,
+    Optional,
+    Tuple,
+    Union,
+)
+
+import grpc
+from grpc import _common
+from grpc._cython import cygrpc
+
+from . import _base_call
+from ._metadata import Metadata
+from ._typing import DeserializingFunction
+from ._typing import DoneCallbackType
+from ._typing import EOFType
+from ._typing import MetadatumType
+from ._typing import RequestIterableType
+from ._typing import RequestType
+from ._typing import ResponseType
+from ._typing import SerializingFunction
+
+__all__ = "AioRpcError", "Call", "UnaryUnaryCall", "UnaryStreamCall"
+
+_LOCAL_CANCELLATION_DETAILS = "Locally cancelled by application!"
+_GC_CANCELLATION_DETAILS = "Cancelled upon garbage collection!"
+_RPC_ALREADY_FINISHED_DETAILS = "RPC already finished."
+_RPC_HALF_CLOSED_DETAILS = 'RPC is half closed after calling "done_writing".'
+_API_STYLE_ERROR = (
+    "The iterator and read/write APIs may not be mixed on a single RPC."
+)
+
+_OK_CALL_REPRESENTATION = (
+    '<{} of RPC that terminated with:\n\tstatus = {}\n\tdetails = "{}"\n>'
+)
+
+_NON_OK_CALL_REPRESENTATION = (
+    "<{} of RPC that terminated with:\n"
+    "\tstatus = {}\n"
+    '\tdetails = "{}"\n'
+    '\tdebug_error_string = "{}"\n'
+    ">"
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AioRpcError(grpc.RpcError):
+    """An implementation of RpcError to be used by the asynchronous API.
+
+    Raised RpcError is a snapshot of the final status of the RPC, values are
+    determined. Hence, its methods no longer needs to be coroutines.
+    """
+
+    _code: grpc.StatusCode
+    _details: Optional[str]
+    _initial_metadata: Optional[Metadata]
+    _trailing_metadata: Optional[Metadata]
+    _debug_error_string: Optional[str]
+
+    def __init__(
+        self,
+        code: grpc.StatusCode,
+        initial_metadata: Metadata,
+        trailing_metadata: Metadata,
+        details: Optional[str] = None,
+        debug_error_string: Optional[str] = None,
+    ) -> None:
+        """Constructor.
+
+        Args:
+          code: The status code with which the RPC has been finalized.
+          details: Optional details explaining the reason of the error.
+          initial_metadata: Optional initial metadata that could be sent by the
+            Server.
+          trailing_metadata: Optional metadata that could be sent by the Server.
+        """
+
+        super().__init__()
+        self._code = code
+        self._details = details
+        self._initial_metadata = initial_metadata
+        self._trailing_metadata = trailing_metadata
+        self._debug_error_string = debug_error_string
+
+    def code(self) -> grpc.StatusCode:
+        """Accesses the status code sent by the server.
+
+        Returns:
+          The `grpc.StatusCode` status code.
+        """
+        return self._code
+
+    def details(self) -> Optional[str]:
+        """Accesses the details sent by the server.
+
+        Returns:
+          The description of the error.
+        """
+        return self._details
+
+    def initial_metadata(self) -> Metadata:
+        """Accesses the initial metadata sent by the server.
+
+        Returns:
+          The initial metadata received.
+        """
+        return self._initial_metadata
+
+    def trailing_metadata(self) -> Metadata:
+        """Accesses the trailing metadata sent by the server.
+
+        Returns:
+          The trailing metadata received.
+        """
+        return self._trailing_metadata
+
+    def debug_error_string(self) -> str:
+        """Accesses the debug error string sent by the server.
+
+        Returns:
+          The debug error string received.
+        """
+        return self._debug_error_string
+
+    def _repr(self) -> str:
+        """Assembles the error string for the RPC error."""
+        return _NON_OK_CALL_REPRESENTATION.format(
+            self.__class__.__name__,
+            self._code,
+            self._details,
+            self._debug_error_string,
+        )
+
+    def __repr__(self) -> str:
+        return self._repr()
+
+    def __str__(self) -> str:
+        return self._repr()
+
+    def __reduce__(self):
+        return (
+            type(self),
+            (
+                self._code,
+                self._initial_metadata,
+                self._trailing_metadata,
+                self._details,
+                self._debug_error_string,
+            ),
+        )
+
+
+def _create_rpc_error(
+    initial_metadata: Metadata, status: cygrpc.AioRpcStatus
+) -> AioRpcError:
+    return AioRpcError(
+        _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[status.code()],
+        Metadata.from_tuple(initial_metadata),
+        Metadata.from_tuple(status.trailing_metadata()),
+        details=status.details(),
+        debug_error_string=status.debug_error_string(),
+    )
+
+
+class Call:
+    """Base implementation of client RPC Call object.
+
+    Implements logic around final status, metadata and cancellation.
+    """
+
+    _loop: asyncio.AbstractEventLoop
+    _code: grpc.StatusCode
+    _cython_call: cygrpc._AioCall
+    _metadata: Tuple[MetadatumType, ...]
+    _request_serializer: SerializingFunction
+    _response_deserializer: DeserializingFunction
+
+    def __init__(
+        self,
+        cython_call: cygrpc._AioCall,
+        metadata: Metadata,
+        request_serializer: SerializingFunction,
+        response_deserializer: DeserializingFunction,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        self._loop = loop
+        self._cython_call = cython_call
+        self._metadata = tuple(metadata)
+        self._request_serializer = request_serializer
+        self._response_deserializer = response_deserializer
+
+    def __del__(self) -> None:
+        # The '_cython_call' object might be destructed before Call object
+        if hasattr(self, "_cython_call"):
+            if not self._cython_call.done():
+                self._cancel(_GC_CANCELLATION_DETAILS)
+
+    def cancelled(self) -> bool:
+        return self._cython_call.cancelled()
+
+    def _cancel(self, details: str) -> bool:
+        """Forwards the application cancellation reasoning."""
+        if not self._cython_call.done():
+            self._cython_call.cancel(details)
+            return True
+        else:
+            return False
+
+    def cancel(self) -> bool:
+        return self._cancel(_LOCAL_CANCELLATION_DETAILS)
+
+    def done(self) -> bool:
+        return self._cython_call.done()
+
+    def add_done_callback(self, callback: DoneCallbackType) -> None:
+        cb = partial(callback, self)
+        self._cython_call.add_done_callback(cb)
+
+    def time_remaining(self) -> Optional[float]:
+        return self._cython_call.time_remaining()
+
+    async def initial_metadata(self) -> Metadata:
+        raw_metadata_tuple = await self._cython_call.initial_metadata()
+        return Metadata.from_tuple(raw_metadata_tuple)
+
+    async def trailing_metadata(self) -> Metadata:
+        raw_metadata_tuple = (
+            await self._cython_call.status()
+        ).trailing_metadata()
+        return Metadata.from_tuple(raw_metadata_tuple)
+
+    async def code(self) -> grpc.StatusCode:
+        cygrpc_code = (await self._cython_call.status()).code()
+        return _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[cygrpc_code]
+
+    async def details(self) -> str:
+        return (await self._cython_call.status()).details()
+
+    async def debug_error_string(self) -> str:
+        return (await self._cython_call.status()).debug_error_string()
+
+    async def _raise_for_status(self) -> None:
+        if self._cython_call.is_locally_cancelled():
+            raise asyncio.CancelledError()
+        code = await self.code()
+        if code != grpc.StatusCode.OK:
+            raise _create_rpc_error(
+                await self.initial_metadata(), await self._cython_call.status()
+            )
+
+    def _repr(self) -> str:
+        return repr(self._cython_call)
+
+    def __repr__(self) -> str:
+        return self._repr()
+
+    def __str__(self) -> str:
+        return self._repr()
+
+
+class _APIStyle(enum.IntEnum):
+    UNKNOWN = 0
+    ASYNC_GENERATOR = 1
+    READER_WRITER = 2
+
+
+class _UnaryResponseMixin(Call, Generic[ResponseType]):
+    _call_response: asyncio.Task
+
+    def _init_unary_response_mixin(self, response_task: asyncio.Task):
+        self._call_response = response_task
+
+    def cancel(self) -> bool:
+        if super().cancel():
+            self._call_response.cancel()
+            return True
+        else:
+            return False
+
+    def __await__(self) -> Generator[Any, None, ResponseType]:
+        """Wait till the ongoing RPC request finishes."""
+        try:
+            response = yield from self._call_response
+        except asyncio.CancelledError:
+            # Even if we caught all other CancelledError, there is still
+            # this corner case. If the application cancels immediately after
+            # the Call object is created, we will observe this
+            # `CancelledError`.
+            if not self.cancelled():
+                self.cancel()
+            raise
+
+        # NOTE(lidiz) If we raise RpcError in the task, and users doesn't
+        # 'await' on it. AsyncIO will log 'Task exception was never retrieved'.
+        # Instead, if we move the exception raising here, the spam stops.
+        # Unfortunately, there can only be one 'yield from' in '__await__'. So,
+        # we need to access the private instance variable.
+        if response is cygrpc.EOF:
+            if self._cython_call.is_locally_cancelled():
+                raise asyncio.CancelledError()
+            else:
+                raise _create_rpc_error(
+                    self._cython_call._initial_metadata,
+                    self._cython_call._status,
+                )
+        else:
+            return response
+
+
+class _StreamResponseMixin(Call):
+    _message_aiter: AsyncIterator[ResponseType]
+    _preparation: asyncio.Task
+    _response_style: _APIStyle
+
+    def _init_stream_response_mixin(self, preparation: asyncio.Task):
+        self._message_aiter = None
+        self._preparation = preparation
+        self._response_style = _APIStyle.UNKNOWN
+
+    def _update_response_style(self, style: _APIStyle):
+        if self._response_style is _APIStyle.UNKNOWN:
+            self._response_style = style
+        elif self._response_style is not style:
+            raise cygrpc.UsageError(_API_STYLE_ERROR)
+
+    def cancel(self) -> bool:
+        if super().cancel():
+            self._preparation.cancel()
+            return True
+        else:
+            return False
+
+    async def _fetch_stream_responses(self) -> ResponseType:
+        message = await self._read()
+        while message is not cygrpc.EOF:
+            yield message
+            message = await self._read()
+
+        # If the read operation failed, Core should explain why.
+        await self._raise_for_status()
+
+    def __aiter__(self) -> AsyncIterator[ResponseType]:
+        self._update_response_style(_APIStyle.ASYNC_GENERATOR)
+        if self._message_aiter is None:
+            self._message_aiter = self._fetch_stream_responses()
+        return self._message_aiter
+
+    async def _read(self) -> ResponseType:
+        # Wait for the request being sent
+        await self._preparation
+
+        # Reads response message from Core
+        try:
+            raw_response = await self._cython_call.receive_serialized_message()
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            raise
+
+        if raw_response is cygrpc.EOF:
+            return cygrpc.EOF
+        else:
+            return _common.deserialize(
+                raw_response, self._response_deserializer
+            )
+
+    async def read(self) -> Union[EOFType, ResponseType]:
+        if self.done():
+            await self._raise_for_status()
+            return cygrpc.EOF
+        self._update_response_style(_APIStyle.READER_WRITER)
+
+        response_message = await self._read()
+
+        if response_message is cygrpc.EOF:
+            # If the read operation failed, Core should explain why.
+            await self._raise_for_status()
+        return response_message
+
+
+class _StreamRequestMixin(Call):
+    _metadata_sent: asyncio.Event
+    _done_writing_flag: bool
+    _async_request_poller: Optional[asyncio.Task]
+    _request_style: _APIStyle
+
+    def _init_stream_request_mixin(
+        self, request_iterator: Optional[RequestIterableType]
+    ):
+        self._metadata_sent = asyncio.Event()
+        self._done_writing_flag = False
+
+        # If user passes in an async iterator, create a consumer Task.
+        if request_iterator is not None:
+            self._async_request_poller = self._loop.create_task(
+                self._consume_request_iterator(request_iterator)
+            )
+            self._request_style = _APIStyle.ASYNC_GENERATOR
+        else:
+            self._async_request_poller = None
+            self._request_style = _APIStyle.READER_WRITER
+
+    def _raise_for_different_style(self, style: _APIStyle):
+        if self._request_style is not style:
+            raise cygrpc.UsageError(_API_STYLE_ERROR)
+
+    def cancel(self) -> bool:
+        if super().cancel():
+            if self._async_request_poller is not None:
+                self._async_request_poller.cancel()
+            return True
+        else:
+            return False
+
+    def _metadata_sent_observer(self):
+        self._metadata_sent.set()
+
+    async def _consume_request_iterator(
+        self, request_iterator: RequestIterableType
+    ) -> None:
+        try:
+            if inspect.isasyncgen(request_iterator) or hasattr(
+                request_iterator, "__aiter__"
+            ):
+                async for request in request_iterator:
+                    try:
+                        await self._write(request)
+                    except AioRpcError as rpc_error:
+                        _LOGGER.debug(
+                            (
+                                "Exception while consuming the"
+                                " request_iterator: %s"
+                            ),
+                            rpc_error,
+                        )
+                        return
+            else:
+                for request in request_iterator:
+                    try:
+                        await self._write(request)
+                    except AioRpcError as rpc_error:
+                        _LOGGER.debug(
+                            (
+                                "Exception while consuming the"
+                                " request_iterator: %s"
+                            ),
+                            rpc_error,
+                        )
+                        return
+
+            await self._done_writing()
+        except:  # pylint: disable=bare-except
+            # Client iterators can raise exceptions, which we should handle by
+            # cancelling the RPC and logging the client's error. No exceptions
+            # should escape this function.
+            _LOGGER.debug(
+                "Client request_iterator raised exception:\n%s",
+                traceback.format_exc(),
+            )
+            self.cancel()
+
+    async def _write(self, request: RequestType) -> None:
+        if self.done():
+            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
+        if self._done_writing_flag:
+            raise asyncio.InvalidStateError(_RPC_HALF_CLOSED_DETAILS)
+        if not self._metadata_sent.is_set():
+            await self._metadata_sent.wait()
+            if self.done():
+                await self._raise_for_status()
+
+        serialized_request = _common.serialize(
+            request, self._request_serializer
+        )
+        try:
+            await self._cython_call.send_serialized_message(serialized_request)
+        except cygrpc.InternalError as err:
+            self._cython_call.set_internal_error(str(err))
+            await self._raise_for_status()
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            raise
+
+    async def _done_writing(self) -> None:
+        if self.done():
+            # If the RPC is finished, do nothing.
+            return
+        if not self._done_writing_flag:
+            # If the done writing is not sent before, try to send it.
+            self._done_writing_flag = True
+            try:
+                await self._cython_call.send_receive_close()
+            except asyncio.CancelledError:
+                if not self.cancelled():
+                    self.cancel()
+                raise
+
+    async def write(self, request: RequestType) -> None:
+        self._raise_for_different_style(_APIStyle.READER_WRITER)
+        await self._write(request)
+
+    async def done_writing(self) -> None:
+        """Signal peer that client is done writing.
+
+        This method is idempotent.
+        """
+        self._raise_for_different_style(_APIStyle.READER_WRITER)
+        await self._done_writing()
+
+    async def wait_for_connection(self) -> None:
+        await self._metadata_sent.wait()
+        if self.done():
+            await self._raise_for_status()
+
+
+class UnaryUnaryCall(_UnaryResponseMixin, Call, _base_call.UnaryUnaryCall):
+    """Object for managing unary-unary RPC calls.
+
+    Returned when an instance of `UnaryUnaryMultiCallable` object is called.
+    """
+
+    _request: RequestType
+    _invocation_task: asyncio.Task
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        request: RequestType,
+        deadline: Optional[float],
+        metadata: Metadata,
+        credentials: Optional[grpc.CallCredentials],
+        wait_for_ready: Optional[bool],
+        channel: cygrpc.AioChannel,
+        method: bytes,
+        request_serializer: SerializingFunction,
+        response_deserializer: DeserializingFunction,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata,
+            request_serializer,
+            response_deserializer,
+            loop,
+        )
+        self._request = request
+        self._context = cygrpc.build_census_context()
+        self._invocation_task = loop.create_task(self._invoke())
+        self._init_unary_response_mixin(self._invocation_task)
+
+    async def _invoke(self) -> ResponseType:
+        serialized_request = _common.serialize(
+            self._request, self._request_serializer
+        )
+
+        # NOTE(lidiz) asyncio.CancelledError is not a good transport for status,
+        # because the asyncio.Task class do not cache the exception object.
+        # https://github.com/python/cpython/blob/edad4d89e357c92f70c0324b937845d652b20afd/Lib/asyncio/tasks.py#L785
+        try:
+            serialized_response = await self._cython_call.unary_unary(
+                serialized_request, self._metadata, self._context
+            )
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+
+        if self._cython_call.is_ok():
+            return _common.deserialize(
+                serialized_response, self._response_deserializer
+            )
+        else:
+            return cygrpc.EOF
+
+    async def wait_for_connection(self) -> None:
+        await self._invocation_task
+        if self.done():
+            await self._raise_for_status()
+
+
+class UnaryStreamCall(_StreamResponseMixin, Call, _base_call.UnaryStreamCall):
+    """Object for managing unary-stream RPC calls.
+
+    Returned when an instance of `UnaryStreamMultiCallable` object is called.
+    """
+
+    _request: RequestType
+    _send_unary_request_task: asyncio.Task
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        request: RequestType,
+        deadline: Optional[float],
+        metadata: Metadata,
+        credentials: Optional[grpc.CallCredentials],
+        wait_for_ready: Optional[bool],
+        channel: cygrpc.AioChannel,
+        method: bytes,
+        request_serializer: SerializingFunction,
+        response_deserializer: DeserializingFunction,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata,
+            request_serializer,
+            response_deserializer,
+            loop,
+        )
+        self._request = request
+        self._context = cygrpc.build_census_context()
+        self._send_unary_request_task = loop.create_task(
+            self._send_unary_request()
+        )
+        self._init_stream_response_mixin(self._send_unary_request_task)
+
+    async def _send_unary_request(self) -> ResponseType:
+        serialized_request = _common.serialize(
+            self._request, self._request_serializer
+        )
+        try:
+            await self._cython_call.initiate_unary_stream(
+                serialized_request, self._metadata, self._context
+            )
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            raise
+
+    async def wait_for_connection(self) -> None:
+        await self._send_unary_request_task
+        if self.done():
+            await self._raise_for_status()
+
+
+# pylint: disable=too-many-ancestors
+class StreamUnaryCall(
+    _StreamRequestMixin, _UnaryResponseMixin, Call, _base_call.StreamUnaryCall
+):
+    """Object for managing stream-unary RPC calls.
+
+    Returned when an instance of `StreamUnaryMultiCallable` object is called.
+    """
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        request_iterator: Optional[RequestIterableType],
+        deadline: Optional[float],
+        metadata: Metadata,
+        credentials: Optional[grpc.CallCredentials],
+        wait_for_ready: Optional[bool],
+        channel: cygrpc.AioChannel,
+        method: bytes,
+        request_serializer: SerializingFunction,
+        response_deserializer: DeserializingFunction,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata,
+            request_serializer,
+            response_deserializer,
+            loop,
+        )
+
+        self._context = cygrpc.build_census_context()
+        self._init_stream_request_mixin(request_iterator)
+        self._init_unary_response_mixin(loop.create_task(self._conduct_rpc()))
+
+    async def _conduct_rpc(self) -> ResponseType:
+        try:
+            serialized_response = await self._cython_call.stream_unary(
+                self._metadata, self._metadata_sent_observer, self._context
+            )
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            raise
+
+        if self._cython_call.is_ok():
+            return _common.deserialize(
+                serialized_response, self._response_deserializer
+            )
+        else:
+            return cygrpc.EOF
+
+
+class StreamStreamCall(
+    _StreamRequestMixin, _StreamResponseMixin, Call, _base_call.StreamStreamCall
+):
+    """Object for managing stream-stream RPC calls.
+
+    Returned when an instance of `StreamStreamMultiCallable` object is called.
+    """
+
+    _initializer: asyncio.Task
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        request_iterator: Optional[RequestIterableType],
+        deadline: Optional[float],
+        metadata: Metadata,
+        credentials: Optional[grpc.CallCredentials],
+        wait_for_ready: Optional[bool],
+        channel: cygrpc.AioChannel,
+        method: bytes,
+        request_serializer: SerializingFunction,
+        response_deserializer: DeserializingFunction,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata,
+            request_serializer,
+            response_deserializer,
+            loop,
+        )
+        self._context = cygrpc.build_census_context()
+        self._initializer = self._loop.create_task(self._prepare_rpc())
+        self._init_stream_request_mixin(request_iterator)
+        self._init_stream_response_mixin(self._initializer)
+
+    async def _prepare_rpc(self):
+        """This method prepares the RPC for receiving/sending messages.
+
+        All other operations around the stream should only happen after the
+        completion of this method.
+        """
+        try:
+            await self._cython_call.initiate_stream_stream(
+                self._metadata, self._metadata_sent_observer, self._context
+            )
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            # No need to raise RpcError here, because no one will `await` this task.

lib/python3.10/site-packages/grpc/aio/_typing.py

@@ -0,0 +1,43 @@
+# Copyright 2019 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Common types for gRPC Async API"""
+
+from typing import (
+    Any,
+    AsyncIterable,
+    Callable,
+    Iterable,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+from grpc._cython.cygrpc import EOF
+
+from ._metadata import Metadata
+from ._metadata import MetadataKey
+from ._metadata import MetadataValue
+
+RequestType = TypeVar("RequestType")
+ResponseType = TypeVar("ResponseType")
+SerializingFunction = Callable[[Any], bytes]
+DeserializingFunction = Callable[[bytes], Any]
+MetadatumType = Tuple[MetadataKey, MetadataValue]
+MetadataType = Union[Metadata, Sequence[MetadatumType]]
+ChannelArgumentType = Sequence[Tuple[str, Any]]
+EOFType = type(EOF)
+DoneCallbackType = Callable[[Any], None]
+RequestIterableType = Union[Iterable[Any], AsyncIterable[Any]]
+ResponseIterableType = AsyncIterable[Any]

lib/python3.10/site-packages/grpc/beta/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

lib/python3.10/site-packages/grpc/beta/_client_adaptations.py

@@ -0,0 +1,1015 @@
+# Copyright 2016 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Translates gRPC's client-side API into gRPC's client-side Beta API."""
+
+import grpc
+from grpc import _common
+from grpc.beta import _metadata
+from grpc.beta import interfaces
+from grpc.framework.common import cardinality
+from grpc.framework.foundation import future
+from grpc.framework.interfaces.face import face
+
+# pylint: disable=too-many-arguments,too-many-locals,unused-argument
+
+_STATUS_CODE_TO_ABORTION_KIND_AND_ABORTION_ERROR_CLASS = {
+    grpc.StatusCode.CANCELLED: (
+        face.Abortion.Kind.CANCELLED,
+        face.CancellationError,
+    ),
+    grpc.StatusCode.UNKNOWN: (
+        face.Abortion.Kind.REMOTE_FAILURE,
+        face.RemoteError,
+    ),
+    grpc.StatusCode.DEADLINE_EXCEEDED: (
+        face.Abortion.Kind.EXPIRED,
+        face.ExpirationError,
+    ),
+    grpc.StatusCode.UNIMPLEMENTED: (
+        face.Abortion.Kind.LOCAL_FAILURE,
+        face.LocalError,
+    ),
+}
+
+
+def _effective_metadata(metadata, metadata_transformer):
+    non_none_metadata = () if metadata is None else metadata
+    if metadata_transformer is None:
+        return non_none_metadata
+    else:
+        return metadata_transformer(non_none_metadata)
+
+
+def _credentials(grpc_call_options):
+    return None if grpc_call_options is None else grpc_call_options.credentials
+
+
+def _abortion(rpc_error_call):
+    code = rpc_error_call.code()
+    pair = _STATUS_CODE_TO_ABORTION_KIND_AND_ABORTION_ERROR_CLASS.get(code)
+    error_kind = face.Abortion.Kind.LOCAL_FAILURE if pair is None else pair[0]
+    return face.Abortion(
+        error_kind,
+        rpc_error_call.initial_metadata(),
+        rpc_error_call.trailing_metadata(),
+        code,
+        rpc_error_call.details(),
+    )
+
+
+def _abortion_error(rpc_error_call):
+    code = rpc_error_call.code()
+    pair = _STATUS_CODE_TO_ABORTION_KIND_AND_ABORTION_ERROR_CLASS.get(code)
+    exception_class = face.AbortionError if pair is None else pair[1]
+    return exception_class(
+        rpc_error_call.initial_metadata(),
+        rpc_error_call.trailing_metadata(),
+        code,
+        rpc_error_call.details(),
+    )
+
+
+class _InvocationProtocolContext(interfaces.GRPCInvocationContext):
+    def disable_next_request_compression(self):
+        pass  # TODO(https://github.com/grpc/grpc/issues/4078): design, implement.
+
+
+class _Rendezvous(future.Future, face.Call):
+    def __init__(self, response_future, response_iterator, call):
+        self._future = response_future
+        self._iterator = response_iterator
+        self._call = call
+
+    def cancel(self):
+        return self._call.cancel()
+
+    def cancelled(self):
+        return self._future.cancelled()
+
+    def running(self):
+        return self._future.running()
+
+    def done(self):
+        return self._future.done()
+
+    def result(self, timeout=None):
+        try:
+            return self._future.result(timeout=timeout)
+        except grpc.RpcError as rpc_error_call:
+            raise _abortion_error(rpc_error_call)
+        except grpc.FutureTimeoutError:
+            raise future.TimeoutError()
+        except grpc.FutureCancelledError:
+            raise future.CancelledError()
+
+    def exception(self, timeout=None):
+        try:
+            rpc_error_call = self._future.exception(timeout=timeout)
+            if rpc_error_call is None:
+                return None
+            else:
+                return _abortion_error(rpc_error_call)
+        except grpc.FutureTimeoutError:
+            raise future.TimeoutError()
+        except grpc.FutureCancelledError:
+            raise future.CancelledError()
+
+    def traceback(self, timeout=None):
+        try:
+            return self._future.traceback(timeout=timeout)
+        except grpc.FutureTimeoutError:
+            raise future.TimeoutError()
+        except grpc.FutureCancelledError:
+            raise future.CancelledError()
+
+    def add_done_callback(self, fn):
+        self._future.add_done_callback(lambda ignored_callback: fn(self))
+
+    def __iter__(self):
+        return self
+
+    def _next(self):
+        try:
+            return next(self._iterator)
+        except grpc.RpcError as rpc_error_call:
+            raise _abortion_error(rpc_error_call)
+
+    def __next__(self):
+        return self._next()
+
+    def next(self):
+        return self._next()
+
+    def is_active(self):
+        return self._call.is_active()
+
+    def time_remaining(self):
+        return self._call.time_remaining()
+
+    def add_abortion_callback(self, abortion_callback):
+        def done_callback():
+            if self.code() is not grpc.StatusCode.OK:
+                abortion_callback(_abortion(self._call))
+
+        registered = self._call.add_callback(done_callback)
+        return None if registered else done_callback()
+
+    def protocol_context(self):
+        return _InvocationProtocolContext()
+
+    def initial_metadata(self):
+        return _metadata.beta(self._call.initial_metadata())
+
+    def terminal_metadata(self):
+        return _metadata.beta(self._call.terminal_metadata())
+
+    def code(self):
+        return self._call.code()
+
+    def details(self):
+        return self._call.details()
+
+
+def _blocking_unary_unary(
+    channel,
+    group,
+    method,
+    timeout,
+    with_call,
+    protocol_options,
+    metadata,
+    metadata_transformer,
+    request,
+    request_serializer,
+    response_deserializer,
+):
+    try:
+        multi_callable = channel.unary_unary(
+            _common.fully_qualified_method(group, method),
+            request_serializer=request_serializer,
+            response_deserializer=response_deserializer,
+        )
+        effective_metadata = _effective_metadata(metadata, metadata_transformer)
+        if with_call:
+            response, call = multi_callable.with_call(
+                request,
+                timeout=timeout,
+                metadata=_metadata.unbeta(effective_metadata),
+                credentials=_credentials(protocol_options),
+            )
+            return response, _Rendezvous(None, None, call)
+        else:
+            return multi_callable(
+                request,
+                timeout=timeout,
+                metadata=_metadata.unbeta(effective_metadata),
+                credentials=_credentials(protocol_options),
+            )
+    except grpc.RpcError as rpc_error_call:
+        raise _abortion_error(rpc_error_call)
+
+
+def _future_unary_unary(
+    channel,
+    group,
+    method,
+    timeout,
+    protocol_options,
+    metadata,
+    metadata_transformer,
+    request,
+    request_serializer,
+    response_deserializer,
+):
+    multi_callable = channel.unary_unary(
+        _common.fully_qualified_method(group, method),
+        request_serializer=request_serializer,
+        response_deserializer=response_deserializer,
+    )
+    effective_metadata = _effective_metadata(metadata, metadata_transformer)
+    response_future = multi_callable.future(
+        request,
+        timeout=timeout,
+        metadata=_metadata.unbeta(effective_metadata),
+        credentials=_credentials(protocol_options),
+    )
+    return _Rendezvous(response_future, None, response_future)
+
+
+def _unary_stream(
+    channel,
+    group,
+    method,
+    timeout,
+    protocol_options,
+    metadata,
+    metadata_transformer,
+    request,
+    request_serializer,
+    response_deserializer,
+):
+    multi_callable = channel.unary_stream(
+        _common.fully_qualified_method(group, method),
+        request_serializer=request_serializer,
+        response_deserializer=response_deserializer,
+    )
+    effective_metadata = _effective_metadata(metadata, metadata_transformer)
+    response_iterator = multi_callable(
+        request,
+        timeout=timeout,
+        metadata=_metadata.unbeta(effective_metadata),
+        credentials=_credentials(protocol_options),
+    )
+    return _Rendezvous(None, response_iterator, response_iterator)
+
+
+def _blocking_stream_unary(
+    channel,
+    group,
+    method,
+    timeout,
+    with_call,
+    protocol_options,
+    metadata,
+    metadata_transformer,
+    request_iterator,
+    request_serializer,
+    response_deserializer,
+):
+    try:
+        multi_callable = channel.stream_unary(
+            _common.fully_qualified_method(group, method),
+            request_serializer=request_serializer,
+            response_deserializer=response_deserializer,
+        )
+        effective_metadata = _effective_metadata(metadata, metadata_transformer)
+        if with_call:
+            response, call = multi_callable.with_call(
+                request_iterator,
+                timeout=timeout,
+                metadata=_metadata.unbeta(effective_metadata),
+                credentials=_credentials(protocol_options),
+            )
+            return response, _Rendezvous(None, None, call)
+        else:
+            return multi_callable(
+                request_iterator,
+                timeout=timeout,
+                metadata=_metadata.unbeta(effective_metadata),
+                credentials=_credentials(protocol_options),
+            )
+    except grpc.RpcError as rpc_error_call:
+        raise _abortion_error(rpc_error_call)
+
+
+def _future_stream_unary(
+    channel,
+    group,
+    method,
+    timeout,
+    protocol_options,
+    metadata,
+    metadata_transformer,
+    request_iterator,
+    request_serializer,
+    response_deserializer,
+):
+    multi_callable = channel.stream_unary(
+        _common.fully_qualified_method(group, method),
+        request_serializer=request_serializer,
+        response_deserializer=response_deserializer,
+    )
+    effective_metadata = _effective_metadata(metadata, metadata_transformer)
+    response_future = multi_callable.future(
+        request_iterator,
+        timeout=timeout,
+        metadata=_metadata.unbeta(effective_metadata),
+        credentials=_credentials(protocol_options),
+    )
+    return _Rendezvous(response_future, None, response_future)
+
+
+def _stream_stream(
+    channel,
+    group,
+    method,
+    timeout,
+    protocol_options,
+    metadata,
+    metadata_transformer,
+    request_iterator,
+    request_serializer,
+    response_deserializer,
+):
+    multi_callable = channel.stream_stream(
+        _common.fully_qualified_method(group, method),
+        request_serializer=request_serializer,
+        response_deserializer=response_deserializer,
+    )
+    effective_metadata = _effective_metadata(metadata, metadata_transformer)
+    response_iterator = multi_callable(
+        request_iterator,
+        timeout=timeout,
+        metadata=_metadata.unbeta(effective_metadata),
+        credentials=_credentials(protocol_options),
+    )
+    return _Rendezvous(None, response_iterator, response_iterator)
+
+
+class _UnaryUnaryMultiCallable(face.UnaryUnaryMultiCallable):
+    def __init__(
+        self,
+        channel,
+        group,
+        method,
+        metadata_transformer,
+        request_serializer,
+        response_deserializer,
+    ):
+        self._channel = channel
+        self._group = group
+        self._method = method
+        self._metadata_transformer = metadata_transformer
+        self._request_serializer = request_serializer
+        self._response_deserializer = response_deserializer
+
+    def __call__(
+        self,
+        request,
+        timeout,
+        metadata=None,
+        with_call=False,
+        protocol_options=None,
+    ):
+        return _blocking_unary_unary(
+            self._channel,
+            self._group,
+            self._method,
+            timeout,
+            with_call,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request,
+            self._request_serializer,
+            self._response_deserializer,
+        )
+
+    def future(self, request, timeout, metadata=None, protocol_options=None):
+        return _future_unary_unary(
+            self._channel,
+            self._group,
+            self._method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request,
+            self._request_serializer,
+            self._response_deserializer,
+        )
+
+    def event(
+        self,
+        request,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+
+class _UnaryStreamMultiCallable(face.UnaryStreamMultiCallable):
+    def __init__(
+        self,
+        channel,
+        group,
+        method,
+        metadata_transformer,
+        request_serializer,
+        response_deserializer,
+    ):
+        self._channel = channel
+        self._group = group
+        self._method = method
+        self._metadata_transformer = metadata_transformer
+        self._request_serializer = request_serializer
+        self._response_deserializer = response_deserializer
+
+    def __call__(self, request, timeout, metadata=None, protocol_options=None):
+        return _unary_stream(
+            self._channel,
+            self._group,
+            self._method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request,
+            self._request_serializer,
+            self._response_deserializer,
+        )
+
+    def event(
+        self,
+        request,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+
+class _StreamUnaryMultiCallable(face.StreamUnaryMultiCallable):
+    def __init__(
+        self,
+        channel,
+        group,
+        method,
+        metadata_transformer,
+        request_serializer,
+        response_deserializer,
+    ):
+        self._channel = channel
+        self._group = group
+        self._method = method
+        self._metadata_transformer = metadata_transformer
+        self._request_serializer = request_serializer
+        self._response_deserializer = response_deserializer
+
+    def __call__(
+        self,
+        request_iterator,
+        timeout,
+        metadata=None,
+        with_call=False,
+        protocol_options=None,
+    ):
+        return _blocking_stream_unary(
+            self._channel,
+            self._group,
+            self._method,
+            timeout,
+            with_call,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request_iterator,
+            self._request_serializer,
+            self._response_deserializer,
+        )
+
+    def future(
+        self, request_iterator, timeout, metadata=None, protocol_options=None
+    ):
+        return _future_stream_unary(
+            self._channel,
+            self._group,
+            self._method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request_iterator,
+            self._request_serializer,
+            self._response_deserializer,
+        )
+
+    def event(
+        self,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+
+class _StreamStreamMultiCallable(face.StreamStreamMultiCallable):
+    def __init__(
+        self,
+        channel,
+        group,
+        method,
+        metadata_transformer,
+        request_serializer,
+        response_deserializer,
+    ):
+        self._channel = channel
+        self._group = group
+        self._method = method
+        self._metadata_transformer = metadata_transformer
+        self._request_serializer = request_serializer
+        self._response_deserializer = response_deserializer
+
+    def __call__(
+        self, request_iterator, timeout, metadata=None, protocol_options=None
+    ):
+        return _stream_stream(
+            self._channel,
+            self._group,
+            self._method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request_iterator,
+            self._request_serializer,
+            self._response_deserializer,
+        )
+
+    def event(
+        self,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+
+class _GenericStub(face.GenericStub):
+    def __init__(
+        self,
+        channel,
+        metadata_transformer,
+        request_serializers,
+        response_deserializers,
+    ):
+        self._channel = channel
+        self._metadata_transformer = metadata_transformer
+        self._request_serializers = request_serializers or {}
+        self._response_deserializers = response_deserializers or {}
+
+    def blocking_unary_unary(
+        self,
+        group,
+        method,
+        request,
+        timeout,
+        metadata=None,
+        with_call=None,
+        protocol_options=None,
+    ):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _blocking_unary_unary(
+            self._channel,
+            group,
+            method,
+            timeout,
+            with_call,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def future_unary_unary(
+        self,
+        group,
+        method,
+        request,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _future_unary_unary(
+            self._channel,
+            group,
+            method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def inline_unary_stream(
+        self,
+        group,
+        method,
+        request,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _unary_stream(
+            self._channel,
+            group,
+            method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def blocking_stream_unary(
+        self,
+        group,
+        method,
+        request_iterator,
+        timeout,
+        metadata=None,
+        with_call=None,
+        protocol_options=None,
+    ):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _blocking_stream_unary(
+            self._channel,
+            group,
+            method,
+            timeout,
+            with_call,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request_iterator,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def future_stream_unary(
+        self,
+        group,
+        method,
+        request_iterator,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _future_stream_unary(
+            self._channel,
+            group,
+            method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request_iterator,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def inline_stream_stream(
+        self,
+        group,
+        method,
+        request_iterator,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _stream_stream(
+            self._channel,
+            group,
+            method,
+            timeout,
+            protocol_options,
+            metadata,
+            self._metadata_transformer,
+            request_iterator,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def event_unary_unary(
+        self,
+        group,
+        method,
+        request,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+    def event_unary_stream(
+        self,
+        group,
+        method,
+        request,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+    def event_stream_unary(
+        self,
+        group,
+        method,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+    def event_stream_stream(
+        self,
+        group,
+        method,
+        receiver,
+        abortion_callback,
+        timeout,
+        metadata=None,
+        protocol_options=None,
+    ):
+        raise NotImplementedError()
+
+    def unary_unary(self, group, method):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _UnaryUnaryMultiCallable(
+            self._channel,
+            group,
+            method,
+            self._metadata_transformer,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def unary_stream(self, group, method):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _UnaryStreamMultiCallable(
+            self._channel,
+            group,
+            method,
+            self._metadata_transformer,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def stream_unary(self, group, method):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _StreamUnaryMultiCallable(
+            self._channel,
+            group,
+            method,
+            self._metadata_transformer,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def stream_stream(self, group, method):
+        request_serializer = self._request_serializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        response_deserializer = self._response_deserializers.get(
+            (
+                group,
+                method,
+            )
+        )
+        return _StreamStreamMultiCallable(
+            self._channel,
+            group,
+            method,
+            self._metadata_transformer,
+            request_serializer,
+            response_deserializer,
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+
+class _DynamicStub(face.DynamicStub):
+    def __init__(self, backing_generic_stub, group, cardinalities):
+        self._generic_stub = backing_generic_stub
+        self._group = group
+        self._cardinalities = cardinalities
+
+    def __getattr__(self, attr):
+        method_cardinality = self._cardinalities.get(attr)
+        if method_cardinality is cardinality.Cardinality.UNARY_UNARY:
+            return self._generic_stub.unary_unary(self._group, attr)
+        elif method_cardinality is cardinality.Cardinality.UNARY_STREAM:
+            return self._generic_stub.unary_stream(self._group, attr)
+        elif method_cardinality is cardinality.Cardinality.STREAM_UNARY:
+            return self._generic_stub.stream_unary(self._group, attr)
+        elif method_cardinality is cardinality.Cardinality.STREAM_STREAM:
+            return self._generic_stub.stream_stream(self._group, attr)
+        else:
+            raise AttributeError(
+                '_DynamicStub object has no attribute "%s"!' % attr
+            )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+
+def generic_stub(
+    channel,
+    host,
+    metadata_transformer,
+    request_serializers,
+    response_deserializers,
+):
+    return _GenericStub(
+        channel,
+        metadata_transformer,
+        request_serializers,
+        response_deserializers,
+    )
+
+
+def dynamic_stub(
+    channel,
+    service,
+    cardinalities,
+    host,
+    metadata_transformer,
+    request_serializers,
+    response_deserializers,
+):
+    return _DynamicStub(
+        _GenericStub(
+            channel,
+            metadata_transformer,
+            request_serializers,
+            response_deserializers,
+        ),
+        service,
+        cardinalities,
+    )

lib/python3.10/site-packages/grpc/beta/_metadata.py

@@ -0,0 +1,56 @@
+# Copyright 2017 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""API metadata conversion utilities."""
+
+import collections
+
+_Metadatum = collections.namedtuple(
+    "_Metadatum",
+    (
+        "key",
+        "value",
+    ),
+)
+
+
+def _beta_metadatum(key, value):
+    beta_key = key if isinstance(key, (bytes,)) else key.encode("ascii")
+    beta_value = value if isinstance(value, (bytes,)) else value.encode("ascii")
+    return _Metadatum(beta_key, beta_value)
+
+
+def _metadatum(beta_key, beta_value):
+    key = beta_key if isinstance(beta_key, (str,)) else beta_key.decode("utf8")
+    if isinstance(beta_value, (str,)) or key[-4:] == "-bin":
+        value = beta_value
+    else:
+        value = beta_value.decode("utf8")
+    return _Metadatum(key, value)
+
+
+def beta(metadata):
+    if metadata is None:
+        return ()
+    else:
+        return tuple(_beta_metadatum(key, value) for key, value in metadata)
+
+
+def unbeta(beta_metadata):
+    if beta_metadata is None:
+        return ()
+    else:
+        return tuple(
+            _metadatum(beta_key, beta_value)
+            for beta_key, beta_value in beta_metadata
+        )

lib/python3.10/site-packages/grpc/beta/_server_adaptations.py

@@ -0,0 +1,465 @@
+# Copyright 2016 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Translates gRPC's server-side API into gRPC's server-side Beta API."""
+
+import collections
+import threading
+
+import grpc
+from grpc import _common
+from grpc.beta import _metadata
+from grpc.beta import interfaces
+from grpc.framework.common import cardinality
+from grpc.framework.common import style
+from grpc.framework.foundation import abandonment
+from grpc.framework.foundation import logging_pool
+from grpc.framework.foundation import stream
+from grpc.framework.interfaces.face import face
+
+# pylint: disable=too-many-return-statements
+
+_DEFAULT_POOL_SIZE = 8
+
+
+class _ServerProtocolContext(interfaces.GRPCServicerContext):
+    def __init__(self, servicer_context):
+        self._servicer_context = servicer_context
+
+    def peer(self):
+        return self._servicer_context.peer()
+
+    def disable_next_response_compression(self):
+        pass  # TODO(https://github.com/grpc/grpc/issues/4078): design, implement.
+
+
+class _FaceServicerContext(face.ServicerContext):
+    def __init__(self, servicer_context):
+        self._servicer_context = servicer_context
+
+    def is_active(self):
+        return self._servicer_context.is_active()
+
+    def time_remaining(self):
+        return self._servicer_context.time_remaining()
+
+    def add_abortion_callback(self, abortion_callback):
+        raise NotImplementedError(
+            "add_abortion_callback no longer supported server-side!"
+        )
+
+    def cancel(self):
+        self._servicer_context.cancel()
+
+    def protocol_context(self):
+        return _ServerProtocolContext(self._servicer_context)
+
+    def invocation_metadata(self):
+        return _metadata.beta(self._servicer_context.invocation_metadata())
+
+    def initial_metadata(self, initial_metadata):
+        self._servicer_context.send_initial_metadata(
+            _metadata.unbeta(initial_metadata)
+        )
+
+    def terminal_metadata(self, terminal_metadata):
+        self._servicer_context.set_terminal_metadata(
+            _metadata.unbeta(terminal_metadata)
+        )
+
+    def code(self, code):
+        self._servicer_context.set_code(code)
+
+    def details(self, details):
+        self._servicer_context.set_details(details)
+
+
+def _adapt_unary_request_inline(unary_request_inline):
+    def adaptation(request, servicer_context):
+        return unary_request_inline(
+            request, _FaceServicerContext(servicer_context)
+        )
+
+    return adaptation
+
+
+def _adapt_stream_request_inline(stream_request_inline):
+    def adaptation(request_iterator, servicer_context):
+        return stream_request_inline(
+            request_iterator, _FaceServicerContext(servicer_context)
+        )
+
+    return adaptation
+
+
+class _Callback(stream.Consumer):
+    def __init__(self):
+        self._condition = threading.Condition()
+        self._values = []
+        self._terminated = False
+        self._cancelled = False
+
+    def consume(self, value):
+        with self._condition:
+            self._values.append(value)
+            self._condition.notify_all()
+
+    def terminate(self):
+        with self._condition:
+            self._terminated = True
+            self._condition.notify_all()
+
+    def consume_and_terminate(self, value):
+        with self._condition:
+            self._values.append(value)
+            self._terminated = True
+            self._condition.notify_all()
+
+    def cancel(self):
+        with self._condition:
+            self._cancelled = True
+            self._condition.notify_all()
+
+    def draw_one_value(self):
+        with self._condition:
+            while True:
+                if self._cancelled:
+                    raise abandonment.Abandoned()
+                elif self._values:
+                    return self._values.pop(0)
+                elif self._terminated:
+                    return None
+                else:
+                    self._condition.wait()
+
+    def draw_all_values(self):
+        with self._condition:
+            while True:
+                if self._cancelled:
+                    raise abandonment.Abandoned()
+                elif self._terminated:
+                    all_values = tuple(self._values)
+                    self._values = None
+                    return all_values
+                else:
+                    self._condition.wait()
+
+
+def _run_request_pipe_thread(
+    request_iterator, request_consumer, servicer_context
+):
+    thread_joined = threading.Event()
+
+    def pipe_requests():
+        for request in request_iterator:
+            if not servicer_context.is_active() or thread_joined.is_set():
+                return
+            request_consumer.consume(request)
+            if not servicer_context.is_active() or thread_joined.is_set():
+                return
+        request_consumer.terminate()
+
+    request_pipe_thread = threading.Thread(target=pipe_requests)
+    request_pipe_thread.daemon = True
+    request_pipe_thread.start()
+
+
+def _adapt_unary_unary_event(unary_unary_event):
+    def adaptation(request, servicer_context):
+        callback = _Callback()
+        if not servicer_context.add_callback(callback.cancel):
+            raise abandonment.Abandoned()
+        unary_unary_event(
+            request,
+            callback.consume_and_terminate,
+            _FaceServicerContext(servicer_context),
+        )
+        return callback.draw_all_values()[0]
+
+    return adaptation
+
+
+def _adapt_unary_stream_event(unary_stream_event):
+    def adaptation(request, servicer_context):
+        callback = _Callback()
+        if not servicer_context.add_callback(callback.cancel):
+            raise abandonment.Abandoned()
+        unary_stream_event(
+            request, callback, _FaceServicerContext(servicer_context)
+        )
+        while True:
+            response = callback.draw_one_value()
+            if response is None:
+                return
+            else:
+                yield response
+
+    return adaptation
+
+
+def _adapt_stream_unary_event(stream_unary_event):
+    def adaptation(request_iterator, servicer_context):
+        callback = _Callback()
+        if not servicer_context.add_callback(callback.cancel):
+            raise abandonment.Abandoned()
+        request_consumer = stream_unary_event(
+            callback.consume_and_terminate,
+            _FaceServicerContext(servicer_context),
+        )
+        _run_request_pipe_thread(
+            request_iterator, request_consumer, servicer_context
+        )
+        return callback.draw_all_values()[0]
+
+    return adaptation
+
+
+def _adapt_stream_stream_event(stream_stream_event):
+    def adaptation(request_iterator, servicer_context):
+        callback = _Callback()
+        if not servicer_context.add_callback(callback.cancel):
+            raise abandonment.Abandoned()
+        request_consumer = stream_stream_event(
+            callback, _FaceServicerContext(servicer_context)
+        )
+        _run_request_pipe_thread(
+            request_iterator, request_consumer, servicer_context
+        )
+        while True:
+            response = callback.draw_one_value()
+            if response is None:
+                return
+            else:
+                yield response
+
+    return adaptation
+
+
+class _SimpleMethodHandler(
+    collections.namedtuple(
+        "_MethodHandler",
+        (
+            "request_streaming",
+            "response_streaming",
+            "request_deserializer",
+            "response_serializer",
+            "unary_unary",
+            "unary_stream",
+            "stream_unary",
+            "stream_stream",
+        ),
+    ),
+    grpc.RpcMethodHandler,
+):
+    pass
+
+
+def _simple_method_handler(
+    implementation, request_deserializer, response_serializer
+):
+    if implementation.style is style.Service.INLINE:
+        if implementation.cardinality is cardinality.Cardinality.UNARY_UNARY:
+            return _SimpleMethodHandler(
+                False,
+                False,
+                request_deserializer,
+                response_serializer,
+                _adapt_unary_request_inline(implementation.unary_unary_inline),
+                None,
+                None,
+                None,
+            )
+        elif implementation.cardinality is cardinality.Cardinality.UNARY_STREAM:
+            return _SimpleMethodHandler(
+                False,
+                True,
+                request_deserializer,
+                response_serializer,
+                None,
+                _adapt_unary_request_inline(implementation.unary_stream_inline),
+                None,
+                None,
+            )
+        elif implementation.cardinality is cardinality.Cardinality.STREAM_UNARY:
+            return _SimpleMethodHandler(
+                True,
+                False,
+                request_deserializer,
+                response_serializer,
+                None,
+                None,
+                _adapt_stream_request_inline(
+                    implementation.stream_unary_inline
+                ),
+                None,
+            )
+        elif (
+            implementation.cardinality is cardinality.Cardinality.STREAM_STREAM
+        ):
+            return _SimpleMethodHandler(
+                True,
+                True,
+                request_deserializer,
+                response_serializer,
+                None,
+                None,
+                None,
+                _adapt_stream_request_inline(
+                    implementation.stream_stream_inline
+                ),
+            )
+    elif implementation.style is style.Service.EVENT:
+        if implementation.cardinality is cardinality.Cardinality.UNARY_UNARY:
+            return _SimpleMethodHandler(
+                False,
+                False,
+                request_deserializer,
+                response_serializer,
+                _adapt_unary_unary_event(implementation.unary_unary_event),
+                None,
+                None,
+                None,
+            )
+        elif implementation.cardinality is cardinality.Cardinality.UNARY_STREAM:
+            return _SimpleMethodHandler(
+                False,
+                True,
+                request_deserializer,
+                response_serializer,
+                None,
+                _adapt_unary_stream_event(implementation.unary_stream_event),
+                None,
+                None,
+            )
+        elif implementation.cardinality is cardinality.Cardinality.STREAM_UNARY:
+            return _SimpleMethodHandler(
+                True,
+                False,
+                request_deserializer,
+                response_serializer,
+                None,
+                None,
+                _adapt_stream_unary_event(implementation.stream_unary_event),
+                None,
+            )
+        elif (
+            implementation.cardinality is cardinality.Cardinality.STREAM_STREAM
+        ):
+            return _SimpleMethodHandler(
+                True,
+                True,
+                request_deserializer,
+                response_serializer,
+                None,
+                None,
+                None,
+                _adapt_stream_stream_event(implementation.stream_stream_event),
+            )
+    raise ValueError()
+
+
+def _flatten_method_pair_map(method_pair_map):
+    method_pair_map = method_pair_map or {}
+    flat_map = {}
+    for method_pair in method_pair_map:
+        method = _common.fully_qualified_method(method_pair[0], method_pair[1])
+        flat_map[method] = method_pair_map[method_pair]
+    return flat_map
+
+
+class _GenericRpcHandler(grpc.GenericRpcHandler):
+    def __init__(
+        self,
+        method_implementations,
+        multi_method_implementation,
+        request_deserializers,
+        response_serializers,
+    ):
+        self._method_implementations = _flatten_method_pair_map(
+            method_implementations
+        )
+        self._request_deserializers = _flatten_method_pair_map(
+            request_deserializers
+        )
+        self._response_serializers = _flatten_method_pair_map(
+            response_serializers
+        )
+        self._multi_method_implementation = multi_method_implementation
+
+    def service(self, handler_call_details):
+        method_implementation = self._method_implementations.get(
+            handler_call_details.method
+        )
+        if method_implementation is not None:
+            return _simple_method_handler(
+                method_implementation,
+                self._request_deserializers.get(handler_call_details.method),
+                self._response_serializers.get(handler_call_details.method),
+            )
+        elif self._multi_method_implementation is None:
+            return None
+        else:
+            try:
+                return None  # TODO(nathaniel): call the multimethod.
+            except face.NoSuchMethodError:
+                return None
+
+
+class _Server(interfaces.Server):
+    def __init__(self, grpc_server):
+        self._grpc_server = grpc_server
+
+    def add_insecure_port(self, address):
+        return self._grpc_server.add_insecure_port(address)
+
+    def add_secure_port(self, address, server_credentials):
+        return self._grpc_server.add_secure_port(address, server_credentials)
+
+    def start(self):
+        self._grpc_server.start()
+
+    def stop(self, grace):
+        return self._grpc_server.stop(grace)
+
+    def __enter__(self):
+        self._grpc_server.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._grpc_server.stop(None)
+        return False
+
+
+def server(
+    service_implementations,
+    multi_method_implementation,
+    request_deserializers,
+    response_serializers,
+    thread_pool,
+    thread_pool_size,
+):
+    generic_rpc_handler = _GenericRpcHandler(
+        service_implementations,
+        multi_method_implementation,
+        request_deserializers,
+        response_serializers,
+    )
+    if thread_pool is None:
+        effective_thread_pool = logging_pool.pool(
+            _DEFAULT_POOL_SIZE if thread_pool_size is None else thread_pool_size
+        )
+    else:
+        effective_thread_pool = thread_pool
+    return _Server(
+        grpc.server(effective_thread_pool, handlers=(generic_rpc_handler,))
+    )

lib/python3.10/site-packages/grpc/beta/implementations.py

@@ -0,0 +1,345 @@
+# Copyright 2015-2016 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Entry points into the Beta API of gRPC Python."""
+
+# threading is referenced from specification in this module.
+import threading  # pylint: disable=unused-import
+
+# interfaces, cardinality, and face are referenced from specification in this
+# module.
+import grpc
+from grpc import _auth
+from grpc.beta import _client_adaptations
+from grpc.beta import _metadata
+from grpc.beta import _server_adaptations
+from grpc.beta import interfaces  # pylint: disable=unused-import
+from grpc.framework.common import cardinality  # pylint: disable=unused-import
+from grpc.framework.interfaces.face import face  # pylint: disable=unused-import
+
+# pylint: disable=too-many-arguments
+
+ChannelCredentials = grpc.ChannelCredentials
+ssl_channel_credentials = grpc.ssl_channel_credentials
+CallCredentials = grpc.CallCredentials
+
+
+def metadata_call_credentials(metadata_plugin, name=None):
+    def plugin(context, callback):
+        def wrapped_callback(beta_metadata, error):
+            callback(_metadata.unbeta(beta_metadata), error)
+
+        metadata_plugin(context, wrapped_callback)
+
+    return grpc.metadata_call_credentials(plugin, name=name)
+
+
+def google_call_credentials(credentials):
+    """Construct CallCredentials from GoogleCredentials.
+
+    Args:
+      credentials: A GoogleCredentials object from the oauth2client library.
+
+    Returns:
+      A CallCredentials object for use in a GRPCCallOptions object.
+    """
+    return metadata_call_credentials(_auth.GoogleCallCredentials(credentials))
+
+
+access_token_call_credentials = grpc.access_token_call_credentials
+composite_call_credentials = grpc.composite_call_credentials
+composite_channel_credentials = grpc.composite_channel_credentials
+
+
+class Channel(object):
+    """A channel to a remote host through which RPCs may be conducted.
+
+    Only the "subscribe" and "unsubscribe" methods are supported for application
+    use. This class' instance constructor and all other attributes are
+    unsupported.
+    """
+
+    def __init__(self, channel):
+        self._channel = channel
+
+    def subscribe(self, callback, try_to_connect=None):
+        """Subscribes to this Channel's connectivity.
+
+        Args:
+          callback: A callable to be invoked and passed an
+            interfaces.ChannelConnectivity identifying this Channel's connectivity.
+            The callable will be invoked immediately upon subscription and again for
+            every change to this Channel's connectivity thereafter until it is
+            unsubscribed.
+          try_to_connect: A boolean indicating whether or not this Channel should
+            attempt to connect if it is not already connected and ready to conduct
+            RPCs.
+        """
+        self._channel.subscribe(callback, try_to_connect=try_to_connect)
+
+    def unsubscribe(self, callback):
+        """Unsubscribes a callback from this Channel's connectivity.
+
+        Args:
+          callback: A callable previously registered with this Channel from having
+            been passed to its "subscribe" method.
+        """
+        self._channel.unsubscribe(callback)
+
+
+def insecure_channel(host, port):
+    """Creates an insecure Channel to a remote host.
+
+    Args:
+      host: The name of the remote host to which to connect.
+      port: The port of the remote host to which to connect.
+        If None only the 'host' part will be used.
+
+    Returns:
+      A Channel to the remote host through which RPCs may be conducted.
+    """
+    channel = grpc.insecure_channel(
+        host if port is None else "%s:%d" % (host, port)
+    )
+    return Channel(channel)
+
+
+def secure_channel(host, port, channel_credentials):
+    """Creates a secure Channel to a remote host.
+
+    Args:
+      host: The name of the remote host to which to connect.
+      port: The port of the remote host to which to connect.
+        If None only the 'host' part will be used.
+      channel_credentials: A ChannelCredentials.
+
+    Returns:
+      A secure Channel to the remote host through which RPCs may be conducted.
+    """
+    channel = grpc.secure_channel(
+        host if port is None else "%s:%d" % (host, port), channel_credentials
+    )
+    return Channel(channel)
+
+
+class StubOptions(object):
+    """A value encapsulating the various options for creation of a Stub.
+
+    This class and its instances have no supported interface - it exists to define
+    the type of its instances and its instances exist to be passed to other
+    functions.
+    """
+
+    def __init__(
+        self,
+        host,
+        request_serializers,
+        response_deserializers,
+        metadata_transformer,
+        thread_pool,
+        thread_pool_size,
+    ):
+        self.host = host
+        self.request_serializers = request_serializers
+        self.response_deserializers = response_deserializers
+        self.metadata_transformer = metadata_transformer
+        self.thread_pool = thread_pool
+        self.thread_pool_size = thread_pool_size
+
+
+_EMPTY_STUB_OPTIONS = StubOptions(None, None, None, None, None, None)
+
+
+def stub_options(
+    host=None,
+    request_serializers=None,
+    response_deserializers=None,
+    metadata_transformer=None,
+    thread_pool=None,
+    thread_pool_size=None,
+):
+    """Creates a StubOptions value to be passed at stub creation.
+
+    All parameters are optional and should always be passed by keyword.
+
+    Args:
+      host: A host string to set on RPC calls.
+      request_serializers: A dictionary from service name-method name pair to
+        request serialization behavior.
+      response_deserializers: A dictionary from service name-method name pair to
+        response deserialization behavior.
+      metadata_transformer: A callable that given a metadata object produces
+        another metadata object to be used in the underlying communication on the
+        wire.
+      thread_pool: A thread pool to use in stubs.
+      thread_pool_size: The size of thread pool to create for use in stubs;
+        ignored if thread_pool has been passed.
+
+    Returns:
+      A StubOptions value created from the passed parameters.
+    """
+    return StubOptions(
+        host,
+        request_serializers,
+        response_deserializers,
+        metadata_transformer,
+        thread_pool,
+        thread_pool_size,
+    )
+
+
+def generic_stub(channel, options=None):
+    """Creates a face.GenericStub on which RPCs can be made.
+
+    Args:
+      channel: A Channel for use by the created stub.
+      options: A StubOptions customizing the created stub.
+
+    Returns:
+      A face.GenericStub on which RPCs can be made.
+    """
+    effective_options = _EMPTY_STUB_OPTIONS if options is None else options
+    return _client_adaptations.generic_stub(
+        channel._channel,  # pylint: disable=protected-access
+        effective_options.host,
+        effective_options.metadata_transformer,
+        effective_options.request_serializers,
+        effective_options.response_deserializers,
+    )
+
+
+def dynamic_stub(channel, service, cardinalities, options=None):
+    """Creates a face.DynamicStub with which RPCs can be invoked.
+
+    Args:
+      channel: A Channel for the returned face.DynamicStub to use.
+      service: The package-qualified full name of the service.
+      cardinalities: A dictionary from RPC method name to cardinality.Cardinality
+        value identifying the cardinality of the RPC method.
+      options: An optional StubOptions value further customizing the functionality
+        of the returned face.DynamicStub.
+
+    Returns:
+      A face.DynamicStub with which RPCs can be invoked.
+    """
+    effective_options = _EMPTY_STUB_OPTIONS if options is None else options
+    return _client_adaptations.dynamic_stub(
+        channel._channel,  # pylint: disable=protected-access
+        service,
+        cardinalities,
+        effective_options.host,
+        effective_options.metadata_transformer,
+        effective_options.request_serializers,
+        effective_options.response_deserializers,
+    )
+
+
+ServerCredentials = grpc.ServerCredentials
+ssl_server_credentials = grpc.ssl_server_credentials
+
+
+class ServerOptions(object):
+    """A value encapsulating the various options for creation of a Server.
+
+    This class and its instances have no supported interface - it exists to define
+    the type of its instances and its instances exist to be passed to other
+    functions.
+    """
+
+    def __init__(
+        self,
+        multi_method_implementation,
+        request_deserializers,
+        response_serializers,
+        thread_pool,
+        thread_pool_size,
+        default_timeout,
+        maximum_timeout,
+    ):
+        self.multi_method_implementation = multi_method_implementation
+        self.request_deserializers = request_deserializers
+        self.response_serializers = response_serializers
+        self.thread_pool = thread_pool
+        self.thread_pool_size = thread_pool_size
+        self.default_timeout = default_timeout
+        self.maximum_timeout = maximum_timeout
+
+
+_EMPTY_SERVER_OPTIONS = ServerOptions(None, None, None, None, None, None, None)
+
+
+def server_options(
+    multi_method_implementation=None,
+    request_deserializers=None,
+    response_serializers=None,
+    thread_pool=None,
+    thread_pool_size=None,
+    default_timeout=None,
+    maximum_timeout=None,
+):
+    """Creates a ServerOptions value to be passed at server creation.
+
+    All parameters are optional and should always be passed by keyword.
+
+    Args:
+      multi_method_implementation: A face.MultiMethodImplementation to be called
+        to service an RPC if the server has no specific method implementation for
+        the name of the RPC for which service was requested.
+      request_deserializers: A dictionary from service name-method name pair to
+        request deserialization behavior.
+      response_serializers: A dictionary from service name-method name pair to
+        response serialization behavior.
+      thread_pool: A thread pool to use in stubs.
+      thread_pool_size: The size of thread pool to create for use in stubs;
+        ignored if thread_pool has been passed.
+      default_timeout: A duration in seconds to allow for RPC service when
+        servicing RPCs that did not include a timeout value when invoked.
+      maximum_timeout: A duration in seconds to allow for RPC service when
+        servicing RPCs no matter what timeout value was passed when the RPC was
+        invoked.
+
+    Returns:
+      A StubOptions value created from the passed parameters.
+    """
+    return ServerOptions(
+        multi_method_implementation,
+        request_deserializers,
+        response_serializers,
+        thread_pool,
+        thread_pool_size,
+        default_timeout,
+        maximum_timeout,
+    )
+
+
+def server(service_implementations, options=None):
+    """Creates an interfaces.Server with which RPCs can be serviced.
+
+    Args:
+      service_implementations: A dictionary from service name-method name pair to
+        face.MethodImplementation.
+      options: An optional ServerOptions value further customizing the
+        functionality of the returned Server.
+
+    Returns:
+      An interfaces.Server with which RPCs can be serviced.
+    """
+    effective_options = _EMPTY_SERVER_OPTIONS if options is None else options
+    return _server_adaptations.server(
+        service_implementations,
+        effective_options.multi_method_implementation,
+        effective_options.request_deserializers,
+        effective_options.response_serializers,
+        effective_options.thread_pool,
+        effective_options.thread_pool_size,
+    )

lib/python3.10/site-packages/grpc/beta/interfaces.py

@@ -0,0 +1,163 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Constants and interfaces of the Beta API of gRPC Python."""
+
+import abc
+
+import grpc
+
+ChannelConnectivity = grpc.ChannelConnectivity
+# FATAL_FAILURE was a Beta-API name for SHUTDOWN
+ChannelConnectivity.FATAL_FAILURE = ChannelConnectivity.SHUTDOWN
+
+StatusCode = grpc.StatusCode
+
+
+class GRPCCallOptions(object):
+    """A value encapsulating gRPC-specific options passed on RPC invocation.
+
+    This class and its instances have no supported interface - it exists to
+    define the type of its instances and its instances exist to be passed to
+    other functions.
+    """
+
+    def __init__(self, disable_compression, subcall_of, credentials):
+        self.disable_compression = disable_compression
+        self.subcall_of = subcall_of
+        self.credentials = credentials
+
+
+def grpc_call_options(disable_compression=False, credentials=None):
+    """Creates a GRPCCallOptions value to be passed at RPC invocation.
+
+    All parameters are optional and should always be passed by keyword.
+
+    Args:
+      disable_compression: A boolean indicating whether or not compression should
+        be disabled for the request object of the RPC. Only valid for
+        request-unary RPCs.
+      credentials: A CallCredentials object to use for the invoked RPC.
+    """
+    return GRPCCallOptions(disable_compression, None, credentials)
+
+
+GRPCAuthMetadataContext = grpc.AuthMetadataContext
+GRPCAuthMetadataPluginCallback = grpc.AuthMetadataPluginCallback
+GRPCAuthMetadataPlugin = grpc.AuthMetadataPlugin
+
+
+class GRPCServicerContext(abc.ABC):
+    """Exposes gRPC-specific options and behaviors to code servicing RPCs."""
+
+    @abc.abstractmethod
+    def peer(self):
+        """Identifies the peer that invoked the RPC being serviced.
+
+        Returns:
+          A string identifying the peer that invoked the RPC being serviced.
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def disable_next_response_compression(self):
+        """Disables compression of the next response passed by the application."""
+        raise NotImplementedError()
+
+
+class GRPCInvocationContext(abc.ABC):
+    """Exposes gRPC-specific options and behaviors to code invoking RPCs."""
+
+    @abc.abstractmethod
+    def disable_next_request_compression(self):
+        """Disables compression of the next request passed by the application."""
+        raise NotImplementedError()
+
+
+class Server(abc.ABC):
+    """Services RPCs."""
+
+    @abc.abstractmethod
+    def add_insecure_port(self, address):
+        """Reserves a port for insecure RPC service once this Server becomes active.
+
+        This method may only be called before calling this Server's start method is
+        called.
+
+        Args:
+          address: The address for which to open a port.
+
+        Returns:
+          An integer port on which RPCs will be serviced after this link has been
+            started. This is typically the same number as the port number contained
+            in the passed address, but will likely be different if the port number
+            contained in the passed address was zero.
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def add_secure_port(self, address, server_credentials):
+        """Reserves a port for secure RPC service after this Server becomes active.
+
+        This method may only be called before calling this Server's start method is
+        called.
+
+        Args:
+          address: The address for which to open a port.
+          server_credentials: A ServerCredentials.
+
+        Returns:
+          An integer port on which RPCs will be serviced after this link has been
+            started. This is typically the same number as the port number contained
+            in the passed address, but will likely be different if the port number
+            contained in the passed address was zero.
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def start(self):
+        """Starts this Server's service of RPCs.
+
+        This method may only be called while the server is not serving RPCs (i.e. it
+        is not idempotent).
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def stop(self, grace):
+        """Stops this Server's service of RPCs.
+
+        All calls to this method immediately stop service of new RPCs. When existing
+        RPCs are aborted is controlled by the grace period parameter passed to this
+        method.
+
+        This method may be called at any time and is idempotent. Passing a smaller
+        grace value than has been passed in a previous call will have the effect of
+        stopping the Server sooner. Passing a larger grace value than has been
+        passed in a previous call will not have the effect of stopping the server
+        later.
+
+        Args:
+          grace: A duration of time in seconds to allow existing RPCs to complete
+            before being aborted by this Server's stopping. May be zero for
+            immediate abortion of all in-progress RPCs.
+
+        Returns:
+          A threading.Event that will be set when this Server has completely
+          stopped. The returned event may not be set until after the full grace
+          period (if some ongoing RPC continues for the full length of the period)
+          of it may be set much sooner (such as if this Server had no RPCs underway
+          at the time it was stopped or if all RPCs that it had underway completed
+          very early in the grace period).
+        """
+        raise NotImplementedError()

lib/python3.10/site-packages/grpc/beta/utilities.py

@@ -0,0 +1,153 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Utilities for the gRPC Python Beta API."""
+
+import threading
+import time
+
+# implementations is referenced from specification in this module.
+from grpc.beta import implementations  # pylint: disable=unused-import
+from grpc.beta import interfaces
+from grpc.framework.foundation import callable_util
+from grpc.framework.foundation import future
+
+_DONE_CALLBACK_EXCEPTION_LOG_MESSAGE = (
+    'Exception calling connectivity future "done" callback!'
+)
+
+
+class _ChannelReadyFuture(future.Future):
+    def __init__(self, channel):
+        self._condition = threading.Condition()
+        self._channel = channel
+
+        self._matured = False
+        self._cancelled = False
+        self._done_callbacks = []
+
+    def _block(self, timeout):
+        until = None if timeout is None else time.time() + timeout
+        with self._condition:
+            while True:
+                if self._cancelled:
+                    raise future.CancelledError()
+                elif self._matured:
+                    return
+                else:
+                    if until is None:
+                        self._condition.wait()
+                    else:
+                        remaining = until - time.time()
+                        if remaining < 0:
+                            raise future.TimeoutError()
+                        else:
+                            self._condition.wait(timeout=remaining)
+
+    def _update(self, connectivity):
+        with self._condition:
+            if (
+                not self._cancelled
+                and connectivity is interfaces.ChannelConnectivity.READY
+            ):
+                self._matured = True
+                self._channel.unsubscribe(self._update)
+                self._condition.notify_all()
+                done_callbacks = tuple(self._done_callbacks)
+                self._done_callbacks = None
+            else:
+                return
+
+        for done_callback in done_callbacks:
+            callable_util.call_logging_exceptions(
+                done_callback, _DONE_CALLBACK_EXCEPTION_LOG_MESSAGE, self
+            )
+
+    def cancel(self):
+        with self._condition:
+            if not self._matured:
+                self._cancelled = True
+                self._channel.unsubscribe(self._update)
+                self._condition.notify_all()
+                done_callbacks = tuple(self._done_callbacks)
+                self._done_callbacks = None
+            else:
+                return False
+
+        for done_callback in done_callbacks:
+            callable_util.call_logging_exceptions(
+                done_callback, _DONE_CALLBACK_EXCEPTION_LOG_MESSAGE, self
+            )
+
+        return True
+
+    def cancelled(self):
+        with self._condition:
+            return self._cancelled
+
+    def running(self):
+        with self._condition:
+            return not self._cancelled and not self._matured
+
+    def done(self):
+        with self._condition:
+            return self._cancelled or self._matured
+
+    def result(self, timeout=None):
+        self._block(timeout)
+        return None
+
+    def exception(self, timeout=None):
+        self._block(timeout)
+        return None
+
+    def traceback(self, timeout=None):
+        self._block(timeout)
+        return None
+
+    def add_done_callback(self, fn):
+        with self._condition:
+            if not self._cancelled and not self._matured:
+                self._done_callbacks.append(fn)
+                return
+
+        fn(self)
+
+    def start(self):
+        with self._condition:
+            self._channel.subscribe(self._update, try_to_connect=True)
+
+    def __del__(self):
+        with self._condition:
+            if not self._cancelled and not self._matured:
+                self._channel.unsubscribe(self._update)
+
+
+def channel_ready_future(channel):
+    """Creates a future.Future tracking when an implementations.Channel is ready.
+
+    Cancelling the returned future.Future does not tell the given
+    implementations.Channel to abandon attempts it may have been making to
+    connect; cancelling merely deactivates the return future.Future's
+    subscription to the given implementations.Channel's connectivity.
+
+    Args:
+      channel: An implementations.Channel.
+
+    Returns:
+      A future.Future that matures when the given Channel has connectivity
+        interfaces.ChannelConnectivity.READY.
+    """
+    ready_future = _ChannelReadyFuture(channel)
+    ready_future.start()
+    return ready_future

lib/python3.10/site-packages/nltk-3.8.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+
+[console_scripts]
+nltk=nltk.cli:cli

lib/python3.10/site-packages/nltk/VERSION

@@ -0,0 +1 @@
+3.8.1

lib/python3.10/site-packages/nltk/__init__.py

@@ -0,0 +1,209 @@
+# Natural Language Toolkit (NLTK)
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Authors: Steven Bird <stevenbird1@gmail.com>
+#          Edward Loper <edloper@gmail.com>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+The Natural Language Toolkit (NLTK) is an open source Python library
+for Natural Language Processing.  A free online book is available.
+(If you use the library for academic research, please cite the book.)
+
+Steven Bird, Ewan Klein, and Edward Loper (2009).
+Natural Language Processing with Python.  O'Reilly Media Inc.
+https://www.nltk.org/book/
+
+isort:skip_file
+"""
+
+import os
+
+# //////////////////////////////////////////////////////
+# Metadata
+# //////////////////////////////////////////////////////
+
+# Version.  For each new release, the version number should be updated
+# in the file VERSION.
+try:
+    # If a VERSION file exists, use it!
+    version_file = os.path.join(os.path.dirname(__file__), "VERSION")
+    with open(version_file) as infile:
+        __version__ = infile.read().strip()
+except NameError:
+    __version__ = "unknown (running code interactively?)"
+except OSError as ex:
+    __version__ = "unknown (%s)" % ex
+
+if __doc__ is not None:  # fix for the ``python -OO``
+    __doc__ += "\n@version: " + __version__
+
+
+# Copyright notice
+__copyright__ = """\
+Copyright (C) 2001-2023 NLTK Project.
+
+Distributed and Licensed under the Apache License, Version 2.0,
+which is included by reference.
+"""
+
+__license__ = "Apache License, Version 2.0"
+# Description of the toolkit, keywords, and the project's primary URL.
+__longdescr__ = """\
+The Natural Language Toolkit (NLTK) is a Python package for
+natural language processing.  NLTK requires Python 3.7, 3.8, 3.9, 3.10 or 3.11."""
+__keywords__ = [
+    "NLP",
+    "CL",
+    "natural language processing",
+    "computational linguistics",
+    "parsing",
+    "tagging",
+    "tokenizing",
+    "syntax",
+    "linguistics",
+    "language",
+    "natural language",
+    "text analytics",
+]
+__url__ = "https://www.nltk.org/"
+
+# Maintainer, contributors, etc.
+__maintainer__ = "NLTK Team"
+__maintainer_email__ = "nltk.team@gmail.com"
+__author__ = __maintainer__
+__author_email__ = __maintainer_email__
+
+# "Trove" classifiers for Python Package Index.
+__classifiers__ = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Human Machine Interfaces",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Text Processing",
+    "Topic :: Text Processing :: Filters",
+    "Topic :: Text Processing :: General",
+    "Topic :: Text Processing :: Indexing",
+    "Topic :: Text Processing :: Linguistic",
+]
+
+from nltk.internals import config_java
+
+# support numpy from pypy
+try:
+    import numpypy
+except ImportError:
+    pass
+
+# Override missing methods on environments where it cannot be used like GAE.
+import subprocess
+
+if not hasattr(subprocess, "PIPE"):
+
+    def _fake_PIPE(*args, **kwargs):
+        raise NotImplementedError("subprocess.PIPE is not supported.")
+
+    subprocess.PIPE = _fake_PIPE
+if not hasattr(subprocess, "Popen"):
+
+    def _fake_Popen(*args, **kwargs):
+        raise NotImplementedError("subprocess.Popen is not supported.")
+
+    subprocess.Popen = _fake_Popen
+
+###########################################################
+# TOP-LEVEL MODULES
+###########################################################
+
+# Import top-level functionality into top-level namespace
+
+from nltk.collocations import *
+from nltk.decorators import decorator, memoize
+from nltk.featstruct import *
+from nltk.grammar import *
+from nltk.probability import *
+from nltk.text import *
+from nltk.util import *
+from nltk.jsontags import *
+
+###########################################################
+# PACKAGES
+###########################################################
+
+from nltk.chunk import *
+from nltk.classify import *
+from nltk.inference import *
+from nltk.metrics import *
+from nltk.parse import *
+from nltk.tag import *
+from nltk.tokenize import *
+from nltk.translate import *
+from nltk.tree import *
+from nltk.sem import *
+from nltk.stem import *
+
+# Packages which can be lazily imported
+# (a) we don't import *
+# (b) they're slow to import or have run-time dependencies
+#     that can safely fail at run time
+
+from nltk import lazyimport
+
+app = lazyimport.LazyModule("app", locals(), globals())
+chat = lazyimport.LazyModule("chat", locals(), globals())
+corpus = lazyimport.LazyModule("corpus", locals(), globals())
+draw = lazyimport.LazyModule("draw", locals(), globals())
+toolbox = lazyimport.LazyModule("toolbox", locals(), globals())
+
+# Optional loading
+
+try:
+    import numpy
+except ImportError:
+    pass
+else:
+    from nltk import cluster
+
+from nltk.downloader import download, download_shell
+
+try:
+    import tkinter
+except ImportError:
+    pass
+else:
+    try:
+        from nltk.downloader import download_gui
+    except RuntimeError as e:
+        import warnings
+
+        warnings.warn(
+            "Corpus downloader GUI not loaded "
+            "(RuntimeError during import: %s)" % str(e)
+        )
+
+# explicitly import all top-level modules (ensuring
+# they override the same names inadvertently imported
+# from a subpackage)
+
+from nltk import ccg, chunk, classify, collocations
+from nltk import data, featstruct, grammar, help, inference, metrics
+from nltk import misc, parse, probability, sem, stem, wsd
+from nltk import tag, tbl, text, tokenize, translate, tree, util
+
+
+# FIXME:  override any accidentally imported demo, see https://github.com/nltk/nltk/issues/2116
+def demo():
+    print("To run the demo code for a module, type nltk.module.demo()")

lib/python3.10/site-packages/nltk/book.py

@@ -0,0 +1,213 @@
+# Natural Language Toolkit: Some texts for exploration in chapter 1 of the book
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from nltk.corpus import (
+    genesis,
+    gutenberg,
+    inaugural,
+    nps_chat,
+    treebank,
+    webtext,
+    wordnet,
+)
+from nltk.probability import FreqDist
+from nltk.text import Text
+from nltk.util import bigrams
+
+print("*** Introductory Examples for the NLTK Book ***")
+print("Loading text1, ..., text9 and sent1, ..., sent9")
+print("Type the name of the text or sentence to view it.")
+print("Type: 'texts()' or 'sents()' to list the materials.")
+
+text1 = Text(gutenberg.words("melville-moby_dick.txt"))
+print("text1:", text1.name)
+
+text2 = Text(gutenberg.words("austen-sense.txt"))
+print("text2:", text2.name)
+
+text3 = Text(genesis.words("english-kjv.txt"), name="The Book of Genesis")
+print("text3:", text3.name)
+
+text4 = Text(inaugural.words(), name="Inaugural Address Corpus")
+print("text4:", text4.name)
+
+text5 = Text(nps_chat.words(), name="Chat Corpus")
+print("text5:", text5.name)
+
+text6 = Text(webtext.words("grail.txt"), name="Monty Python and the Holy Grail")
+print("text6:", text6.name)
+
+text7 = Text(treebank.words(), name="Wall Street Journal")
+print("text7:", text7.name)
+
+text8 = Text(webtext.words("singles.txt"), name="Personals Corpus")
+print("text8:", text8.name)
+
+text9 = Text(gutenberg.words("chesterton-thursday.txt"))
+print("text9:", text9.name)
+
+
+def texts():
+    print("text1:", text1.name)
+    print("text2:", text2.name)
+    print("text3:", text3.name)
+    print("text4:", text4.name)
+    print("text5:", text5.name)
+    print("text6:", text6.name)
+    print("text7:", text7.name)
+    print("text8:", text8.name)
+    print("text9:", text9.name)
+
+
+sent1 = ["Call", "me", "Ishmael", "."]
+sent2 = [
+    "The",
+    "family",
+    "of",
+    "Dashwood",
+    "had",
+    "long",
+    "been",
+    "settled",
+    "in",
+    "Sussex",
+    ".",
+]
+sent3 = [
+    "In",
+    "the",
+    "beginning",
+    "God",
+    "created",
+    "the",
+    "heaven",
+    "and",
+    "the",
+    "earth",
+    ".",
+]
+sent4 = [
+    "Fellow",
+    "-",
+    "Citizens",
+    "of",
+    "the",
+    "Senate",
+    "and",
+    "of",
+    "the",
+    "House",
+    "of",
+    "Representatives",
+    ":",
+]
+sent5 = [
+    "I",
+    "have",
+    "a",
+    "problem",
+    "with",
+    "people",
+    "PMing",
+    "me",
+    "to",
+    "lol",
+    "JOIN",
+]
+sent6 = [
+    "SCENE",
+    "1",
+    ":",
+    "[",
+    "wind",
+    "]",
+    "[",
+    "clop",
+    "clop",
+    "clop",
+    "]",
+    "KING",
+    "ARTHUR",
+    ":",
+    "Whoa",
+    "there",
+    "!",
+]
+sent7 = [
+    "Pierre",
+    "Vinken",
+    ",",
+    "61",
+    "years",
+    "old",
+    ",",
+    "will",
+    "join",
+    "the",
+    "board",
+    "as",
+    "a",
+    "nonexecutive",
+    "director",
+    "Nov.",
+    "29",
+    ".",
+]
+sent8 = [
+    "25",
+    "SEXY",
+    "MALE",
+    ",",
+    "seeks",
+    "attrac",
+    "older",
+    "single",
+    "lady",
+    ",",
+    "for",
+    "discreet",
+    "encounters",
+    ".",
+]
+sent9 = [
+    "THE",
+    "suburb",
+    "of",
+    "Saffron",
+    "Park",
+    "lay",
+    "on",
+    "the",
+    "sunset",
+    "side",
+    "of",
+    "London",
+    ",",
+    "as",
+    "red",
+    "and",
+    "ragged",
+    "as",
+    "a",
+    "cloud",
+    "of",
+    "sunset",
+    ".",
+]
+
+
+def sents():
+    print("sent1:", " ".join(sent1))
+    print("sent2:", " ".join(sent2))
+    print("sent3:", " ".join(sent3))
+    print("sent4:", " ".join(sent4))
+    print("sent5:", " ".join(sent5))
+    print("sent6:", " ".join(sent6))
+    print("sent7:", " ".join(sent7))
+    print("sent8:", " ".join(sent8))
+    print("sent9:", " ".join(sent9))

lib/python3.10/site-packages/nltk/cli.py

@@ -0,0 +1,55 @@
+# Natural Language Toolkit: NLTK Command-Line Interface
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+
+import click
+from tqdm import tqdm
+
+from nltk import word_tokenize
+from nltk.util import parallelize_preprocess
+
+CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+@click.version_option()
+def cli():
+    pass
+
+
+@cli.command("tokenize")
+@click.option(
+    "--language",
+    "-l",
+    default="en",
+    help="The language for the Punkt sentence tokenization.",
+)
+@click.option(
+    "--preserve-line",
+    "-l",
+    default=True,
+    is_flag=True,
+    help="An option to keep the preserve the sentence and not sentence tokenize it.",
+)
+@click.option("--processes", "-j", default=1, help="No. of processes.")
+@click.option("--encoding", "-e", default="utf8", help="Specify encoding of file.")
+@click.option(
+    "--delimiter", "-d", default=" ", help="Specify delimiter to join the tokens."
+)
+def tokenize_file(language, preserve_line, processes, encoding, delimiter):
+    """This command tokenizes text stream using nltk.word_tokenize"""
+    with click.get_text_stream("stdin", encoding=encoding) as fin:
+        with click.get_text_stream("stdout", encoding=encoding) as fout:
+            # If it's single process, joblib parallelization is slower,
+            # so just process line by line normally.
+            if processes == 1:
+                for line in tqdm(fin.readlines()):
+                    print(delimiter.join(word_tokenize(line)), end="\n", file=fout)
+            else:
+                for outline in parallelize_preprocess(
+                    word_tokenize, fin.readlines(), processes, progress_bar=True
+                ):
+                    print(delimiter.join(outline), end="\n", file=fout)

lib/python3.10/site-packages/nltk/collections.py

@@ -0,0 +1,661 @@
+# Natural Language Toolkit: Collections
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import bisect
+
+# this unused import is for python 2.7
+from collections import Counter, defaultdict, deque
+from functools import total_ordering
+from itertools import chain, islice
+
+from nltk.internals import raise_unorderable_types, slice_bounds
+
+##########################################################################
+# Ordered Dictionary
+##########################################################################
+
+
+class OrderedDict(dict):
+    def __init__(self, data=None, **kwargs):
+        self._keys = self.keys(data, kwargs.get("keys"))
+        self._default_factory = kwargs.get("default_factory")
+        if data is None:
+            dict.__init__(self)
+        else:
+            dict.__init__(self, data)
+
+    def __delitem__(self, key):
+        dict.__delitem__(self, key)
+        self._keys.remove(key)
+
+    def __getitem__(self, key):
+        try:
+            return dict.__getitem__(self, key)
+        except KeyError:
+            return self.__missing__(key)
+
+    def __iter__(self):
+        return (key for key in self.keys())
+
+    def __missing__(self, key):
+        if not self._default_factory and key not in self._keys:
+            raise KeyError()
+        return self._default_factory()
+
+    def __setitem__(self, key, item):
+        dict.__setitem__(self, key, item)
+        if key not in self._keys:
+            self._keys.append(key)
+
+    def clear(self):
+        dict.clear(self)
+        self._keys.clear()
+
+    def copy(self):
+        d = dict.copy(self)
+        d._keys = self._keys
+        return d
+
+    def items(self):
+        # returns iterator under python 3 and list under python 2
+        return zip(self.keys(), self.values())
+
+    def keys(self, data=None, keys=None):
+        if data:
+            if keys:
+                assert isinstance(keys, list)
+                assert len(data) == len(keys)
+                return keys
+            else:
+                assert (
+                    isinstance(data, dict)
+                    or isinstance(data, OrderedDict)
+                    or isinstance(data, list)
+                )
+                if isinstance(data, dict) or isinstance(data, OrderedDict):
+                    return data.keys()
+                elif isinstance(data, list):
+                    return [key for (key, value) in data]
+        elif "_keys" in self.__dict__:
+            return self._keys
+        else:
+            return []
+
+    def popitem(self):
+        if not self._keys:
+            raise KeyError()
+
+        key = self._keys.pop()
+        value = self[key]
+        del self[key]
+        return (key, value)
+
+    def setdefault(self, key, failobj=None):
+        dict.setdefault(self, key, failobj)
+        if key not in self._keys:
+            self._keys.append(key)
+
+    def update(self, data):
+        dict.update(self, data)
+        for key in self.keys(data):
+            if key not in self._keys:
+                self._keys.append(key)
+
+    def values(self):
+        # returns iterator under python 3
+        return map(self.get, self._keys)
+
+
+######################################################################
+# Lazy Sequences
+######################################################################
+
+
+@total_ordering
+class AbstractLazySequence:
+    """
+    An abstract base class for read-only sequences whose values are
+    computed as needed.  Lazy sequences act like tuples -- they can be
+    indexed, sliced, and iterated over; but they may not be modified.
+
+    The most common application of lazy sequences in NLTK is for
+    corpus view objects, which provide access to the contents of a
+    corpus without loading the entire corpus into memory, by loading
+    pieces of the corpus from disk as needed.
+
+    The result of modifying a mutable element of a lazy sequence is
+    undefined.  In particular, the modifications made to the element
+    may or may not persist, depending on whether and when the lazy
+    sequence caches that element's value or reconstructs it from
+    scratch.
+
+    Subclasses are required to define two methods: ``__len__()``
+    and ``iterate_from()``.
+    """
+
+    def __len__(self):
+        """
+        Return the number of tokens in the corpus file underlying this
+        corpus view.
+        """
+        raise NotImplementedError("should be implemented by subclass")
+
+    def iterate_from(self, start):
+        """
+        Return an iterator that generates the tokens in the corpus
+        file underlying this corpus view, starting at the token number
+        ``start``.  If ``start>=len(self)``, then this iterator will
+        generate no tokens.
+        """
+        raise NotImplementedError("should be implemented by subclass")
+
+    def __getitem__(self, i):
+        """
+        Return the *i* th token in the corpus file underlying this
+        corpus view.  Negative indices and spans are both supported.
+        """
+        if isinstance(i, slice):
+            start, stop = slice_bounds(self, i)
+            return LazySubsequence(self, start, stop)
+        else:
+            # Handle negative indices
+            if i < 0:
+                i += len(self)
+            if i < 0:
+                raise IndexError("index out of range")
+            # Use iterate_from to extract it.
+            try:
+                return next(self.iterate_from(i))
+            except StopIteration as e:
+                raise IndexError("index out of range") from e
+
+    def __iter__(self):
+        """Return an iterator that generates the tokens in the corpus
+        file underlying this corpus view."""
+        return self.iterate_from(0)
+
+    def count(self, value):
+        """Return the number of times this list contains ``value``."""
+        return sum(1 for elt in self if elt == value)
+
+    def index(self, value, start=None, stop=None):
+        """Return the index of the first occurrence of ``value`` in this
+        list that is greater than or equal to ``start`` and less than
+        ``stop``.  Negative start and stop values are treated like negative
+        slice bounds -- i.e., they count from the end of the list."""
+        start, stop = slice_bounds(self, slice(start, stop))
+        for i, elt in enumerate(islice(self, start, stop)):
+            if elt == value:
+                return i + start
+        raise ValueError("index(x): x not in list")
+
+    def __contains__(self, value):
+        """Return true if this list contains ``value``."""
+        return bool(self.count(value))
+
+    def __add__(self, other):
+        """Return a list concatenating self with other."""
+        return LazyConcatenation([self, other])
+
+    def __radd__(self, other):
+        """Return a list concatenating other with self."""
+        return LazyConcatenation([other, self])
+
+    def __mul__(self, count):
+        """Return a list concatenating self with itself ``count`` times."""
+        return LazyConcatenation([self] * count)
+
+    def __rmul__(self, count):
+        """Return a list concatenating self with itself ``count`` times."""
+        return LazyConcatenation([self] * count)
+
+    _MAX_REPR_SIZE = 60
+
+    def __repr__(self):
+        """
+        Return a string representation for this corpus view that is
+        similar to a list's representation; but if it would be more
+        than 60 characters long, it is truncated.
+        """
+        pieces = []
+        length = 5
+        for elt in self:
+            pieces.append(repr(elt))
+            length += len(pieces[-1]) + 2
+            if length > self._MAX_REPR_SIZE and len(pieces) > 2:
+                return "[%s, ...]" % ", ".join(pieces[:-1])
+        return "[%s]" % ", ".join(pieces)
+
+    def __eq__(self, other):
+        return type(self) == type(other) and list(self) == list(other)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if type(other) != type(self):
+            raise_unorderable_types("<", self, other)
+        return list(self) < list(other)
+
+    def __hash__(self):
+        """
+        :raise ValueError: Corpus view objects are unhashable.
+        """
+        raise ValueError("%s objects are unhashable" % self.__class__.__name__)
+
+
+class LazySubsequence(AbstractLazySequence):
+    """
+    A subsequence produced by slicing a lazy sequence.  This slice
+    keeps a reference to its source sequence, and generates its values
+    by looking them up in the source sequence.
+    """
+
+    MIN_SIZE = 100
+    """
+    The minimum size for which lazy slices should be created.  If
+    ``LazySubsequence()`` is called with a subsequence that is
+    shorter than ``MIN_SIZE``, then a tuple will be returned instead.
+    """
+
+    def __new__(cls, source, start, stop):
+        """
+        Construct a new slice from a given underlying sequence.  The
+        ``start`` and ``stop`` indices should be absolute indices --
+        i.e., they should not be negative (for indexing from the back
+        of a list) or greater than the length of ``source``.
+        """
+        # If the slice is small enough, just use a tuple.
+        if stop - start < cls.MIN_SIZE:
+            return list(islice(source.iterate_from(start), stop - start))
+        else:
+            return object.__new__(cls)
+
+    def __init__(self, source, start, stop):
+        self._source = source
+        self._start = start
+        self._stop = stop
+
+    def __len__(self):
+        return self._stop - self._start
+
+    def iterate_from(self, start):
+        return islice(
+            self._source.iterate_from(start + self._start), max(0, len(self) - start)
+        )
+
+
+class LazyConcatenation(AbstractLazySequence):
+    """
+    A lazy sequence formed by concatenating a list of lists.  This
+    underlying list of lists may itself be lazy.  ``LazyConcatenation``
+    maintains an index that it uses to keep track of the relationship
+    between offsets in the concatenated lists and offsets in the
+    sublists.
+    """
+
+    def __init__(self, list_of_lists):
+        self._list = list_of_lists
+        self._offsets = [0]
+
+    def __len__(self):
+        if len(self._offsets) <= len(self._list):
+            for _ in self.iterate_from(self._offsets[-1]):
+                pass
+        return self._offsets[-1]
+
+    def iterate_from(self, start_index):
+        if start_index < self._offsets[-1]:
+            sublist_index = bisect.bisect_right(self._offsets, start_index) - 1
+        else:
+            sublist_index = len(self._offsets) - 1
+
+        index = self._offsets[sublist_index]
+
+        # Construct an iterator over the sublists.
+        if isinstance(self._list, AbstractLazySequence):
+            sublist_iter = self._list.iterate_from(sublist_index)
+        else:
+            sublist_iter = islice(self._list, sublist_index, None)
+
+        for sublist in sublist_iter:
+            if sublist_index == (len(self._offsets) - 1):
+                assert (
+                    index + len(sublist) >= self._offsets[-1]
+                ), "offsets not monotonic increasing!"
+                self._offsets.append(index + len(sublist))
+            else:
+                assert self._offsets[sublist_index + 1] == index + len(
+                    sublist
+                ), "inconsistent list value (num elts)"
+
+            yield from sublist[max(0, start_index - index) :]
+
+            index += len(sublist)
+            sublist_index += 1
+
+
+class LazyMap(AbstractLazySequence):
+    """
+    A lazy sequence whose elements are formed by applying a given
+    function to each element in one or more underlying lists.  The
+    function is applied lazily -- i.e., when you read a value from the
+    list, ``LazyMap`` will calculate that value by applying its
+    function to the underlying lists' value(s).  ``LazyMap`` is
+    essentially a lazy version of the Python primitive function
+    ``map``.  In particular, the following two expressions are
+    equivalent:
+
+        >>> from nltk.collections import LazyMap
+        >>> function = str
+        >>> sequence = [1,2,3]
+        >>> map(function, sequence) # doctest: +SKIP
+        ['1', '2', '3']
+        >>> list(LazyMap(function, sequence))
+        ['1', '2', '3']
+
+    Like the Python ``map`` primitive, if the source lists do not have
+    equal size, then the value None will be supplied for the
+    'missing' elements.
+
+    Lazy maps can be useful for conserving memory, in cases where
+    individual values take up a lot of space.  This is especially true
+    if the underlying list's values are constructed lazily, as is the
+    case with many corpus readers.
+
+    A typical example of a use case for this class is performing
+    feature detection on the tokens in a corpus.  Since featuresets
+    are encoded as dictionaries, which can take up a lot of memory,
+    using a ``LazyMap`` can significantly reduce memory usage when
+    training and running classifiers.
+    """
+
+    def __init__(self, function, *lists, **config):
+        """
+        :param function: The function that should be applied to
+            elements of ``lists``.  It should take as many arguments
+            as there are ``lists``.
+        :param lists: The underlying lists.
+        :param cache_size: Determines the size of the cache used
+            by this lazy map.  (default=5)
+        """
+        if not lists:
+            raise TypeError("LazyMap requires at least two args")
+
+        self._lists = lists
+        self._func = function
+        self._cache_size = config.get("cache_size", 5)
+        self._cache = {} if self._cache_size > 0 else None
+
+        # If you just take bool() of sum() here _all_lazy will be true just
+        # in case n >= 1 list is an AbstractLazySequence.  Presumably this
+        # isn't what's intended.
+        self._all_lazy = sum(
+            isinstance(lst, AbstractLazySequence) for lst in lists
+        ) == len(lists)
+
+    def iterate_from(self, index):
+        # Special case: one lazy sublist
+        if len(self._lists) == 1 and self._all_lazy:
+            for value in self._lists[0].iterate_from(index):
+                yield self._func(value)
+            return
+
+        # Special case: one non-lazy sublist
+        elif len(self._lists) == 1:
+            while True:
+                try:
+                    yield self._func(self._lists[0][index])
+                except IndexError:
+                    return
+                index += 1
+
+        # Special case: n lazy sublists
+        elif self._all_lazy:
+            iterators = [lst.iterate_from(index) for lst in self._lists]
+            while True:
+                elements = []
+                for iterator in iterators:
+                    try:
+                        elements.append(next(iterator))
+                    except:  # FIXME: What is this except really catching? StopIteration?
+                        elements.append(None)
+                if elements == [None] * len(self._lists):
+                    return
+                yield self._func(*elements)
+                index += 1
+
+        # general case
+        else:
+            while True:
+                try:
+                    elements = [lst[index] for lst in self._lists]
+                except IndexError:
+                    elements = [None] * len(self._lists)
+                    for i, lst in enumerate(self._lists):
+                        try:
+                            elements[i] = lst[index]
+                        except IndexError:
+                            pass
+                    if elements == [None] * len(self._lists):
+                        return
+                yield self._func(*elements)
+                index += 1
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            sliced_lists = [lst[index] for lst in self._lists]
+            return LazyMap(self._func, *sliced_lists)
+        else:
+            # Handle negative indices
+            if index < 0:
+                index += len(self)
+            if index < 0:
+                raise IndexError("index out of range")
+            # Check the cache
+            if self._cache is not None and index in self._cache:
+                return self._cache[index]
+            # Calculate the value
+            try:
+                val = next(self.iterate_from(index))
+            except StopIteration as e:
+                raise IndexError("index out of range") from e
+            # Update the cache
+            if self._cache is not None:
+                if len(self._cache) > self._cache_size:
+                    self._cache.popitem()  # discard random entry
+                self._cache[index] = val
+            # Return the value
+            return val
+
+    def __len__(self):
+        return max(len(lst) for lst in self._lists)
+
+
+class LazyZip(LazyMap):
+    """
+    A lazy sequence whose elements are tuples, each containing the i-th
+    element from each of the argument sequences.  The returned list is
+    truncated in length to the length of the shortest argument sequence. The
+    tuples are constructed lazily -- i.e., when you read a value from the
+    list, ``LazyZip`` will calculate that value by forming a tuple from
+    the i-th element of each of the argument sequences.
+
+    ``LazyZip`` is essentially a lazy version of the Python primitive function
+    ``zip``.  In particular, an evaluated LazyZip is equivalent to a zip:
+
+        >>> from nltk.collections import LazyZip
+        >>> sequence1, sequence2 = [1, 2, 3], ['a', 'b', 'c']
+        >>> zip(sequence1, sequence2) # doctest: +SKIP
+        [(1, 'a'), (2, 'b'), (3, 'c')]
+        >>> list(LazyZip(sequence1, sequence2))
+        [(1, 'a'), (2, 'b'), (3, 'c')]
+        >>> sequences = [sequence1, sequence2, [6,7,8,9]]
+        >>> list(zip(*sequences)) == list(LazyZip(*sequences))
+        True
+
+    Lazy zips can be useful for conserving memory in cases where the argument
+    sequences are particularly long.
+
+    A typical example of a use case for this class is combining long sequences
+    of gold standard and predicted values in a classification or tagging task
+    in order to calculate accuracy.  By constructing tuples lazily and
+    avoiding the creation of an additional long sequence, memory usage can be
+    significantly reduced.
+    """
+
+    def __init__(self, *lists):
+        """
+        :param lists: the underlying lists
+        :type lists: list(list)
+        """
+        LazyMap.__init__(self, lambda *elts: elts, *lists)
+
+    def iterate_from(self, index):
+        iterator = LazyMap.iterate_from(self, index)
+        while index < len(self):
+            yield next(iterator)
+            index += 1
+        return
+
+    def __len__(self):
+        return min(len(lst) for lst in self._lists)
+
+
+class LazyEnumerate(LazyZip):
+    """
+    A lazy sequence whose elements are tuples, each containing a count (from
+    zero) and a value yielded by underlying sequence.  ``LazyEnumerate`` is
+    useful for obtaining an indexed list. The tuples are constructed lazily
+    -- i.e., when you read a value from the list, ``LazyEnumerate`` will
+    calculate that value by forming a tuple from the count of the i-th
+    element and the i-th element of the underlying sequence.
+
+    ``LazyEnumerate`` is essentially a lazy version of the Python primitive
+    function ``enumerate``.  In particular, the following two expressions are
+    equivalent:
+
+        >>> from nltk.collections import LazyEnumerate
+        >>> sequence = ['first', 'second', 'third']
+        >>> list(enumerate(sequence))
+        [(0, 'first'), (1, 'second'), (2, 'third')]
+        >>> list(LazyEnumerate(sequence))
+        [(0, 'first'), (1, 'second'), (2, 'third')]
+
+    Lazy enumerations can be useful for conserving memory in cases where the
+    argument sequences are particularly long.
+
+    A typical example of a use case for this class is obtaining an indexed
+    list for a long sequence of values.  By constructing tuples lazily and
+    avoiding the creation of an additional long sequence, memory usage can be
+    significantly reduced.
+    """
+
+    def __init__(self, lst):
+        """
+        :param lst: the underlying list
+        :type lst: list
+        """
+        LazyZip.__init__(self, range(len(lst)), lst)
+
+
+class LazyIteratorList(AbstractLazySequence):
+    """
+    Wraps an iterator, loading its elements on demand
+    and making them subscriptable.
+    __repr__ displays only the first few elements.
+    """
+
+    def __init__(self, it, known_len=None):
+        self._it = it
+        self._len = known_len
+        self._cache = []
+
+    def __len__(self):
+        if self._len:
+            return self._len
+        for _ in self.iterate_from(len(self._cache)):
+            pass
+        self._len = len(self._cache)
+        return self._len
+
+    def iterate_from(self, start):
+        """Create a new iterator over this list starting at the given offset."""
+        while len(self._cache) < start:
+            v = next(self._it)
+            self._cache.append(v)
+        i = start
+        while i < len(self._cache):
+            yield self._cache[i]
+            i += 1
+        try:
+            while True:
+                v = next(self._it)
+                self._cache.append(v)
+                yield v
+        except StopIteration:
+            pass
+
+    def __add__(self, other):
+        """Return a list concatenating self with other."""
+        return type(self)(chain(self, other))
+
+    def __radd__(self, other):
+        """Return a list concatenating other with self."""
+        return type(self)(chain(other, self))
+
+
+######################################################################
+# Trie Implementation
+######################################################################
+class Trie(dict):
+    """A Trie implementation for strings"""
+
+    LEAF = True
+
+    def __init__(self, strings=None):
+        """Builds a Trie object, which is built around a ``dict``
+
+        If ``strings`` is provided, it will add the ``strings``, which
+        consist of a ``list`` of ``strings``, to the Trie.
+        Otherwise, it'll construct an empty Trie.
+
+        :param strings: List of strings to insert into the trie
+            (Default is ``None``)
+        :type strings: list(str)
+
+        """
+        super().__init__()
+        if strings:
+            for string in strings:
+                self.insert(string)
+
+    def insert(self, string):
+        """Inserts ``string`` into the Trie
+
+        :param string: String to insert into the trie
+        :type string: str
+
+        :Example:
+
+        >>> from nltk.collections import Trie
+        >>> trie = Trie(["abc", "def"])
+        >>> expected = {'a': {'b': {'c': {True: None}}}, \
+                        'd': {'e': {'f': {True: None}}}}
+        >>> trie == expected
+        True
+
+        """
+        if len(string):
+            self[string[0]].insert(string[1:])
+        else:
+            # mark the string is complete
+            self[Trie.LEAF] = None
+
+    def __missing__(self, key):
+        self[key] = Trie()
+        return self[key]

lib/python3.10/site-packages/nltk/collocations.py

@@ -0,0 +1,412 @@
+# Natural Language Toolkit: Collocations and Association Measures
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Joel Nothman <jnothman@student.usyd.edu.au>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+"""
+Tools to identify collocations --- words that often appear consecutively
+--- within corpora. They may also be used to find other associations between
+word occurrences.
+See Manning and Schutze ch. 5 at https://nlp.stanford.edu/fsnlp/promo/colloc.pdf
+and the Text::NSP Perl package at http://ngram.sourceforge.net
+
+Finding collocations requires first calculating the frequencies of words and
+their appearance in the context of other words. Often the collection of words
+will then requiring filtering to only retain useful content terms. Each ngram
+of words may then be scored according to some association measure, in order
+to determine the relative likelihood of each ngram being a collocation.
+
+The ``BigramCollocationFinder`` and ``TrigramCollocationFinder`` classes provide
+these functionalities, dependent on being provided a function which scores a
+ngram given appropriate frequency counts. A number of standard association
+measures are provided in bigram_measures and trigram_measures.
+"""
+
+# Possible TODOs:
+# - consider the distinction between f(x,_) and f(x) and whether our
+#   approximation is good enough for fragmented data, and mention it
+# - add a n-gram collocation finder with measures which only utilise n-gram
+#   and unigram counts (raw_freq, pmi, student_t)
+
+import itertools as _itertools
+
+# these two unused imports are referenced in collocations.doctest
+from nltk.metrics import (
+    BigramAssocMeasures,
+    ContingencyMeasures,
+    QuadgramAssocMeasures,
+    TrigramAssocMeasures,
+)
+from nltk.metrics.spearman import ranks_from_scores, spearman_correlation
+from nltk.probability import FreqDist
+from nltk.util import ngrams
+
+
+class AbstractCollocationFinder:
+    """
+    An abstract base class for collocation finders whose purpose is to
+    collect collocation candidate frequencies, filter and rank them.
+
+    As a minimum, collocation finders require the frequencies of each
+    word in a corpus, and the joint frequency of word tuples. This data
+    should be provided through nltk.probability.FreqDist objects or an
+    identical interface.
+    """
+
+    def __init__(self, word_fd, ngram_fd):
+        self.word_fd = word_fd
+        self.N = word_fd.N()
+        self.ngram_fd = ngram_fd
+
+    @classmethod
+    def _build_new_documents(
+        cls, documents, window_size, pad_left=False, pad_right=False, pad_symbol=None
+    ):
+        """
+        Pad the document with the place holder according to the window_size
+        """
+        padding = (pad_symbol,) * (window_size - 1)
+        if pad_right:
+            return _itertools.chain.from_iterable(
+                _itertools.chain(doc, padding) for doc in documents
+            )
+        if pad_left:
+            return _itertools.chain.from_iterable(
+                _itertools.chain(padding, doc) for doc in documents
+            )
+
+    @classmethod
+    def from_documents(cls, documents):
+        """Constructs a collocation finder given a collection of documents,
+        each of which is a list (or iterable) of tokens.
+        """
+        # return cls.from_words(_itertools.chain(*documents))
+        return cls.from_words(
+            cls._build_new_documents(documents, cls.default_ws, pad_right=True)
+        )
+
+    @staticmethod
+    def _ngram_freqdist(words, n):
+        return FreqDist(tuple(words[i : i + n]) for i in range(len(words) - 1))
+
+    def _apply_filter(self, fn=lambda ngram, freq: False):
+        """Generic filter removes ngrams from the frequency distribution
+        if the function returns True when passed an ngram tuple.
+        """
+        tmp_ngram = FreqDist()
+        for ngram, freq in self.ngram_fd.items():
+            if not fn(ngram, freq):
+                tmp_ngram[ngram] = freq
+        self.ngram_fd = tmp_ngram
+
+    def apply_freq_filter(self, min_freq):
+        """Removes candidate ngrams which have frequency less than min_freq."""
+        self._apply_filter(lambda ng, freq: freq < min_freq)
+
+    def apply_ngram_filter(self, fn):
+        """Removes candidate ngrams (w1, w2, ...) where fn(w1, w2, ...)
+        evaluates to True.
+        """
+        self._apply_filter(lambda ng, f: fn(*ng))
+
+    def apply_word_filter(self, fn):
+        """Removes candidate ngrams (w1, w2, ...) where any of (fn(w1), fn(w2),
+        ...) evaluates to True.
+        """
+        self._apply_filter(lambda ng, f: any(fn(w) for w in ng))
+
+    def _score_ngrams(self, score_fn):
+        """Generates of (ngram, score) pairs as determined by the scoring
+        function provided.
+        """
+        for tup in self.ngram_fd:
+            score = self.score_ngram(score_fn, *tup)
+            if score is not None:
+                yield tup, score
+
+    def score_ngrams(self, score_fn):
+        """Returns a sequence of (ngram, score) pairs ordered from highest to
+        lowest score, as determined by the scoring function provided.
+        """
+        return sorted(self._score_ngrams(score_fn), key=lambda t: (-t[1], t[0]))
+
+    def nbest(self, score_fn, n):
+        """Returns the top n ngrams when scored by the given function."""
+        return [p for p, s in self.score_ngrams(score_fn)[:n]]
+
+    def above_score(self, score_fn, min_score):
+        """Returns a sequence of ngrams, ordered by decreasing score, whose
+        scores each exceed the given minimum score.
+        """
+        for ngram, score in self.score_ngrams(score_fn):
+            if score > min_score:
+                yield ngram
+            else:
+                break
+
+
+class BigramCollocationFinder(AbstractCollocationFinder):
+    """A tool for the finding and ranking of bigram collocations or other
+    association measures. It is often useful to use from_words() rather than
+    constructing an instance directly.
+    """
+
+    default_ws = 2
+
+    def __init__(self, word_fd, bigram_fd, window_size=2):
+        """Construct a BigramCollocationFinder, given FreqDists for
+        appearances of words and (possibly non-contiguous) bigrams.
+        """
+        AbstractCollocationFinder.__init__(self, word_fd, bigram_fd)
+        self.window_size = window_size
+
+    @classmethod
+    def from_words(cls, words, window_size=2):
+        """Construct a BigramCollocationFinder for all bigrams in the given
+        sequence.  When window_size > 2, count non-contiguous bigrams, in the
+        style of Church and Hanks's (1990) association ratio.
+        """
+        wfd = FreqDist()
+        bfd = FreqDist()
+
+        if window_size < 2:
+            raise ValueError("Specify window_size at least 2")
+
+        for window in ngrams(words, window_size, pad_right=True):
+            w1 = window[0]
+            if w1 is None:
+                continue
+            wfd[w1] += 1
+            for w2 in window[1:]:
+                if w2 is not None:
+                    bfd[(w1, w2)] += 1
+        return cls(wfd, bfd, window_size=window_size)
+
+    def score_ngram(self, score_fn, w1, w2):
+        """Returns the score for a given bigram using the given scoring
+        function.  Following Church and Hanks (1990), counts are scaled by
+        a factor of 1/(window_size - 1).
+        """
+        n_all = self.N
+        n_ii = self.ngram_fd[(w1, w2)] / (self.window_size - 1.0)
+        if not n_ii:
+            return
+        n_ix = self.word_fd[w1]
+        n_xi = self.word_fd[w2]
+        return score_fn(n_ii, (n_ix, n_xi), n_all)
+
+
+class TrigramCollocationFinder(AbstractCollocationFinder):
+    """A tool for the finding and ranking of trigram collocations or other
+    association measures. It is often useful to use from_words() rather than
+    constructing an instance directly.
+    """
+
+    default_ws = 3
+
+    def __init__(self, word_fd, bigram_fd, wildcard_fd, trigram_fd):
+        """Construct a TrigramCollocationFinder, given FreqDists for
+        appearances of words, bigrams, two words with any word between them,
+        and trigrams.
+        """
+        AbstractCollocationFinder.__init__(self, word_fd, trigram_fd)
+        self.wildcard_fd = wildcard_fd
+        self.bigram_fd = bigram_fd
+
+    @classmethod
+    def from_words(cls, words, window_size=3):
+        """Construct a TrigramCollocationFinder for all trigrams in the given
+        sequence.
+        """
+        if window_size < 3:
+            raise ValueError("Specify window_size at least 3")
+
+        wfd = FreqDist()
+        wildfd = FreqDist()
+        bfd = FreqDist()
+        tfd = FreqDist()
+        for window in ngrams(words, window_size, pad_right=True):
+            w1 = window[0]
+            if w1 is None:
+                continue
+            for w2, w3 in _itertools.combinations(window[1:], 2):
+                wfd[w1] += 1
+                if w2 is None:
+                    continue
+                bfd[(w1, w2)] += 1
+                if w3 is None:
+                    continue
+                wildfd[(w1, w3)] += 1
+                tfd[(w1, w2, w3)] += 1
+        return cls(wfd, bfd, wildfd, tfd)
+
+    def bigram_finder(self):
+        """Constructs a bigram collocation finder with the bigram and unigram
+        data from this finder. Note that this does not include any filtering
+        applied to this finder.
+        """
+        return BigramCollocationFinder(self.word_fd, self.bigram_fd)
+
+    def score_ngram(self, score_fn, w1, w2, w3):
+        """Returns the score for a given trigram using the given scoring
+        function.
+        """
+        n_all = self.N
+        n_iii = self.ngram_fd[(w1, w2, w3)]
+        if not n_iii:
+            return
+        n_iix = self.bigram_fd[(w1, w2)]
+        n_ixi = self.wildcard_fd[(w1, w3)]
+        n_xii = self.bigram_fd[(w2, w3)]
+        n_ixx = self.word_fd[w1]
+        n_xix = self.word_fd[w2]
+        n_xxi = self.word_fd[w3]
+        return score_fn(n_iii, (n_iix, n_ixi, n_xii), (n_ixx, n_xix, n_xxi), n_all)
+
+
+class QuadgramCollocationFinder(AbstractCollocationFinder):
+    """A tool for the finding and ranking of quadgram collocations or other association measures.
+    It is often useful to use from_words() rather than constructing an instance directly.
+    """
+
+    default_ws = 4
+
+    def __init__(self, word_fd, quadgram_fd, ii, iii, ixi, ixxi, iixi, ixii):
+        """Construct a QuadgramCollocationFinder, given FreqDists for appearances of words,
+        bigrams, trigrams, two words with one word and two words between them, three words
+        with a word between them in both variations.
+        """
+        AbstractCollocationFinder.__init__(self, word_fd, quadgram_fd)
+        self.iii = iii
+        self.ii = ii
+        self.ixi = ixi
+        self.ixxi = ixxi
+        self.iixi = iixi
+        self.ixii = ixii
+
+    @classmethod
+    def from_words(cls, words, window_size=4):
+        if window_size < 4:
+            raise ValueError("Specify window_size at least 4")
+        ixxx = FreqDist()
+        iiii = FreqDist()
+        ii = FreqDist()
+        iii = FreqDist()
+        ixi = FreqDist()
+        ixxi = FreqDist()
+        iixi = FreqDist()
+        ixii = FreqDist()
+
+        for window in ngrams(words, window_size, pad_right=True):
+            w1 = window[0]
+            if w1 is None:
+                continue
+            for w2, w3, w4 in _itertools.combinations(window[1:], 3):
+                ixxx[w1] += 1
+                if w2 is None:
+                    continue
+                ii[(w1, w2)] += 1
+                if w3 is None:
+                    continue
+                iii[(w1, w2, w3)] += 1
+                ixi[(w1, w3)] += 1
+                if w4 is None:
+                    continue
+                iiii[(w1, w2, w3, w4)] += 1
+                ixxi[(w1, w4)] += 1
+                ixii[(w1, w3, w4)] += 1
+                iixi[(w1, w2, w4)] += 1
+
+        return cls(ixxx, iiii, ii, iii, ixi, ixxi, iixi, ixii)
+
+    def score_ngram(self, score_fn, w1, w2, w3, w4):
+        n_all = self.N
+        n_iiii = self.ngram_fd[(w1, w2, w3, w4)]
+        if not n_iiii:
+            return
+        n_iiix = self.iii[(w1, w2, w3)]
+        n_xiii = self.iii[(w2, w3, w4)]
+        n_iixi = self.iixi[(w1, w2, w4)]
+        n_ixii = self.ixii[(w1, w3, w4)]
+
+        n_iixx = self.ii[(w1, w2)]
+        n_xxii = self.ii[(w3, w4)]
+        n_xiix = self.ii[(w2, w3)]
+        n_ixix = self.ixi[(w1, w3)]
+        n_ixxi = self.ixxi[(w1, w4)]
+        n_xixi = self.ixi[(w2, w4)]
+
+        n_ixxx = self.word_fd[w1]
+        n_xixx = self.word_fd[w2]
+        n_xxix = self.word_fd[w3]
+        n_xxxi = self.word_fd[w4]
+        return score_fn(
+            n_iiii,
+            (n_iiix, n_iixi, n_ixii, n_xiii),
+            (n_iixx, n_ixix, n_ixxi, n_xixi, n_xxii, n_xiix),
+            (n_ixxx, n_xixx, n_xxix, n_xxxi),
+            n_all,
+        )
+
+
+def demo(scorer=None, compare_scorer=None):
+    """Finds bigram collocations in the files of the WebText corpus."""
+    from nltk.metrics import (
+        BigramAssocMeasures,
+        ranks_from_scores,
+        spearman_correlation,
+    )
+
+    if scorer is None:
+        scorer = BigramAssocMeasures.likelihood_ratio
+    if compare_scorer is None:
+        compare_scorer = BigramAssocMeasures.raw_freq
+
+    from nltk.corpus import stopwords, webtext
+
+    ignored_words = stopwords.words("english")
+    word_filter = lambda w: len(w) < 3 or w.lower() in ignored_words
+
+    for file in webtext.fileids():
+        words = [word.lower() for word in webtext.words(file)]
+
+        cf = BigramCollocationFinder.from_words(words)
+        cf.apply_freq_filter(3)
+        cf.apply_word_filter(word_filter)
+
+        corr = spearman_correlation(
+            ranks_from_scores(cf.score_ngrams(scorer)),
+            ranks_from_scores(cf.score_ngrams(compare_scorer)),
+        )
+        print(file)
+        print("\t", [" ".join(tup) for tup in cf.nbest(scorer, 15)])
+        print(f"\t Correlation to {compare_scorer.__name__}: {corr:0.4f}")
+
+
+# Slows down loading too much
+# bigram_measures = BigramAssocMeasures()
+# trigram_measures = TrigramAssocMeasures()
+
+if __name__ == "__main__":
+    import sys
+
+    from nltk.metrics import BigramAssocMeasures
+
+    try:
+        scorer = eval("BigramAssocMeasures." + sys.argv[1])
+    except IndexError:
+        scorer = None
+    try:
+        compare_scorer = eval("BigramAssocMeasures." + sys.argv[2])
+    except IndexError:
+        compare_scorer = None
+
+    demo(scorer, compare_scorer)
+
+__all__ = [
+    "BigramCollocationFinder",
+    "TrigramCollocationFinder",
+    "QuadgramCollocationFinder",
+]

lib/python3.10/site-packages/nltk/compat.py

@@ -0,0 +1,43 @@
+# Natural Language Toolkit: Compatibility
+#
+# Copyright (C) 2001-2023 NLTK Project
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import os
+from functools import wraps
+
+# ======= Compatibility for datasets that care about Python versions ========
+
+# The following datasets have a /PY3 subdirectory containing
+# a full copy of the data which has been re-encoded or repickled.
+DATA_UPDATES = [
+    ("chunkers", "maxent_ne_chunker"),
+    ("help", "tagsets"),
+    ("taggers", "maxent_treebank_pos_tagger"),
+    ("tokenizers", "punkt"),
+]
+
+_PY3_DATA_UPDATES = [os.path.join(*path_list) for path_list in DATA_UPDATES]
+
+
+def add_py3_data(path):
+    for item in _PY3_DATA_UPDATES:
+        if item in str(path) and "/PY3" not in str(path):
+            pos = path.index(item) + len(item)
+            if path[pos : pos + 4] == ".zip":
+                pos += 4
+            path = path[:pos] + "/PY3" + path[pos:]
+            break
+    return path
+
+
+# for use in adding /PY3 to the second (filename) argument
+# of the file pointers in data.py
+def py3_data(init_func):
+    def _decorator(*args, **kwargs):
+        args = (args[0], add_py3_data(args[1])) + args[2:]
+        return init_func(*args, **kwargs)
+
+    return wraps(init_func)(_decorator)

lib/python3.10/site-packages/nltk/data.py

@@ -0,0 +1,1441 @@
+# Natural Language Toolkit: Utility functions
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <edloper@gmail.com>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Functions to find and load NLTK resource files, such as corpora,
+grammars, and saved processing objects.  Resource files are identified
+using URLs, such as ``nltk:corpora/abc/rural.txt`` or
+``https://raw.githubusercontent.com/nltk/nltk/develop/nltk/test/toy.cfg``.
+The following URL protocols are supported:
+
+  - ``file:path``: Specifies the file whose path is *path*.
+    Both relative and absolute paths may be used.
+
+  - ``https://host/path``: Specifies the file stored on the web
+    server *host* at path *path*.
+
+  - ``nltk:path``: Specifies the file stored in the NLTK data
+    package at *path*.  NLTK will search for these files in the
+    directories specified by ``nltk.data.path``.
+
+If no protocol is specified, then the default protocol ``nltk:`` will
+be used.
+
+This module provides to functions that can be used to access a
+resource file, given its URL: ``load()`` loads a given resource, and
+adds it to a resource cache; and ``retrieve()`` copies a given resource
+to a local file.
+"""
+
+import codecs
+import functools
+import os
+import pickle
+import re
+import sys
+import textwrap
+import zipfile
+from abc import ABCMeta, abstractmethod
+from gzip import WRITE as GZ_WRITE
+from gzip import GzipFile
+from io import BytesIO, TextIOWrapper
+from urllib.request import url2pathname, urlopen
+
+try:
+    from zlib import Z_SYNC_FLUSH as FLUSH
+except ImportError:
+    from zlib import Z_FINISH as FLUSH
+
+from nltk import grammar, sem
+from nltk.compat import add_py3_data, py3_data
+from nltk.internals import deprecated
+
+textwrap_indent = functools.partial(textwrap.indent, prefix="  ")
+
+######################################################################
+# Search Path
+######################################################################
+
+path = []
+"""A list of directories where the NLTK data package might reside.
+   These directories will be checked in order when looking for a
+   resource in the data package.  Note that this allows users to
+   substitute in their own versions of resources, if they have them
+   (e.g., in their home directory under ~/nltk_data)."""
+
+# User-specified locations:
+_paths_from_env = os.environ.get("NLTK_DATA", "").split(os.pathsep)
+path += [d for d in _paths_from_env if d]
+if "APPENGINE_RUNTIME" not in os.environ and os.path.expanduser("~/") != "~/":
+    path.append(os.path.expanduser("~/nltk_data"))
+
+if sys.platform.startswith("win"):
+    # Common locations on Windows:
+    path += [
+        os.path.join(sys.prefix, "nltk_data"),
+        os.path.join(sys.prefix, "share", "nltk_data"),
+        os.path.join(sys.prefix, "lib", "nltk_data"),
+        os.path.join(os.environ.get("APPDATA", "C:\\"), "nltk_data"),
+        r"C:\nltk_data",
+        r"D:\nltk_data",
+        r"E:\nltk_data",
+    ]
+else:
+    # Common locations on UNIX & OS X:
+    path += [
+        os.path.join(sys.prefix, "nltk_data"),
+        os.path.join(sys.prefix, "share", "nltk_data"),
+        os.path.join(sys.prefix, "lib", "nltk_data"),
+        "/usr/share/nltk_data",
+        "/usr/local/share/nltk_data",
+        "/usr/lib/nltk_data",
+        "/usr/local/lib/nltk_data",
+    ]
+
+
+######################################################################
+# Util Functions
+######################################################################
+
+
+def gzip_open_unicode(
+    filename,
+    mode="rb",
+    compresslevel=9,
+    encoding="utf-8",
+    fileobj=None,
+    errors=None,
+    newline=None,
+):
+    if fileobj is None:
+        fileobj = GzipFile(filename, mode, compresslevel, fileobj)
+    return TextIOWrapper(fileobj, encoding, errors, newline)
+
+
+def split_resource_url(resource_url):
+    """
+    Splits a resource url into "<protocol>:<path>".
+
+    >>> windows = sys.platform.startswith('win')
+    >>> split_resource_url('nltk:home/nltk')
+    ('nltk', 'home/nltk')
+    >>> split_resource_url('nltk:/home/nltk')
+    ('nltk', '/home/nltk')
+    >>> split_resource_url('file:/home/nltk')
+    ('file', '/home/nltk')
+    >>> split_resource_url('file:///home/nltk')
+    ('file', '/home/nltk')
+    >>> split_resource_url('file:///C:/home/nltk')
+    ('file', '/C:/home/nltk')
+    """
+    protocol, path_ = resource_url.split(":", 1)
+    if protocol == "nltk":
+        pass
+    elif protocol == "file":
+        if path_.startswith("/"):
+            path_ = "/" + path_.lstrip("/")
+    else:
+        path_ = re.sub(r"^/{0,2}", "", path_)
+    return protocol, path_
+
+
+def normalize_resource_url(resource_url):
+    r"""
+    Normalizes a resource url
+
+    >>> windows = sys.platform.startswith('win')
+    >>> os.path.normpath(split_resource_url(normalize_resource_url('file:grammar.fcfg'))[1]) == \
+    ... ('\\' if windows else '') + os.path.abspath(os.path.join(os.curdir, 'grammar.fcfg'))
+    True
+    >>> not windows or normalize_resource_url('file:C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file:C:\\dir\\file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file:C:\\dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file://C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file:////C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('nltk:C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('nltk:C:\\dir\\file') == 'file:///C:/dir/file'
+    True
+    >>> windows or normalize_resource_url('file:/dir/file/toy.cfg') == 'file:///dir/file/toy.cfg'
+    True
+    >>> normalize_resource_url('nltk:home/nltk')
+    'nltk:home/nltk'
+    >>> windows or normalize_resource_url('nltk:/home/nltk') == 'file:///home/nltk'
+    True
+    >>> normalize_resource_url('https://example.com/dir/file')
+    'https://example.com/dir/file'
+    >>> normalize_resource_url('dir/file')
+    'nltk:dir/file'
+    """
+    try:
+        protocol, name = split_resource_url(resource_url)
+    except ValueError:
+        # the resource url has no protocol, use the nltk protocol by default
+        protocol = "nltk"
+        name = resource_url
+    # use file protocol if the path is an absolute path
+    if protocol == "nltk" and os.path.isabs(name):
+        protocol = "file://"
+        name = normalize_resource_name(name, False, None)
+    elif protocol == "file":
+        protocol = "file://"
+        # name is absolute
+        name = normalize_resource_name(name, False, None)
+    elif protocol == "nltk":
+        protocol = "nltk:"
+        name = normalize_resource_name(name, True)
+    else:
+        # handled by urllib
+        protocol += "://"
+    return "".join([protocol, name])
+
+
+def normalize_resource_name(resource_name, allow_relative=True, relative_path=None):
+    """
+    :type resource_name: str or unicode
+    :param resource_name: The name of the resource to search for.
+        Resource names are posix-style relative path names, such as
+        ``corpora/brown``.  Directory names will automatically
+        be converted to a platform-appropriate path separator.
+        Directory trailing slashes are preserved
+
+    >>> windows = sys.platform.startswith('win')
+    >>> normalize_resource_name('.', True)
+    './'
+    >>> normalize_resource_name('./', True)
+    './'
+    >>> windows or normalize_resource_name('dir/file', False, '/') == '/dir/file'
+    True
+    >>> not windows or normalize_resource_name('C:/file', False, '/') == '/C:/file'
+    True
+    >>> windows or normalize_resource_name('/dir/file', False, '/') == '/dir/file'
+    True
+    >>> windows or normalize_resource_name('../dir/file', False, '/') == '/dir/file'
+    True
+    >>> not windows or normalize_resource_name('/dir/file', True, '/') == 'dir/file'
+    True
+    >>> windows or normalize_resource_name('/dir/file', True, '/') == '/dir/file'
+    True
+    """
+    is_dir = bool(re.search(r"[\\/.]$", resource_name)) or resource_name.endswith(
+        os.path.sep
+    )
+    if sys.platform.startswith("win"):
+        resource_name = resource_name.lstrip("/")
+    else:
+        resource_name = re.sub(r"^/+", "/", resource_name)
+    if allow_relative:
+        resource_name = os.path.normpath(resource_name)
+    else:
+        if relative_path is None:
+            relative_path = os.curdir
+        resource_name = os.path.abspath(os.path.join(relative_path, resource_name))
+    resource_name = resource_name.replace("\\", "/").replace(os.path.sep, "/")
+    if sys.platform.startswith("win") and os.path.isabs(resource_name):
+        resource_name = "/" + resource_name
+    if is_dir and not resource_name.endswith("/"):
+        resource_name += "/"
+    return resource_name
+
+
+######################################################################
+# Path Pointers
+######################################################################
+
+
+class PathPointer(metaclass=ABCMeta):
+    """
+    An abstract base class for 'path pointers,' used by NLTK's data
+    package to identify specific paths.  Two subclasses exist:
+    ``FileSystemPathPointer`` identifies a file that can be accessed
+    directly via a given absolute path.  ``ZipFilePathPointer``
+    identifies a file contained within a zipfile, that can be accessed
+    by reading that zipfile.
+    """
+
+    @abstractmethod
+    def open(self, encoding=None):
+        """
+        Return a seekable read-only stream that can be used to read
+        the contents of the file identified by this path pointer.
+
+        :raise IOError: If the path specified by this pointer does
+            not contain a readable file.
+        """
+
+    @abstractmethod
+    def file_size(self):
+        """
+        Return the size of the file pointed to by this path pointer,
+        in bytes.
+
+        :raise IOError: If the path specified by this pointer does
+            not contain a readable file.
+        """
+
+    @abstractmethod
+    def join(self, fileid):
+        """
+        Return a new path pointer formed by starting at the path
+        identified by this pointer, and then following the relative
+        path given by ``fileid``.  The path components of ``fileid``
+        should be separated by forward slashes, regardless of
+        the underlying file system's path separator character.
+        """
+
+
+class FileSystemPathPointer(PathPointer, str):
+    """
+    A path pointer that identifies a file which can be accessed
+    directly via a given absolute path.
+    """
+
+    @py3_data
+    def __init__(self, _path):
+        """
+        Create a new path pointer for the given absolute path.
+
+        :raise IOError: If the given path does not exist.
+        """
+
+        _path = os.path.abspath(_path)
+        if not os.path.exists(_path):
+            raise OSError("No such file or directory: %r" % _path)
+        self._path = _path
+
+        # There's no need to call str.__init__(), since it's a no-op;
+        # str does all of its setup work in __new__.
+
+    @property
+    def path(self):
+        """The absolute path identified by this path pointer."""
+        return self._path
+
+    def open(self, encoding=None):
+        stream = open(self._path, "rb")
+        if encoding is not None:
+            stream = SeekableUnicodeStreamReader(stream, encoding)
+        return stream
+
+    def file_size(self):
+        return os.stat(self._path).st_size
+
+    def join(self, fileid):
+        _path = os.path.join(self._path, fileid)
+        return FileSystemPathPointer(_path)
+
+    def __repr__(self):
+        return "FileSystemPathPointer(%r)" % self._path
+
+    def __str__(self):
+        return self._path
+
+
+@deprecated("Use gzip.GzipFile instead as it also uses a buffer.")
+class BufferedGzipFile(GzipFile):
+    """A ``GzipFile`` subclass for compatibility with older nltk releases.
+
+    Use ``GzipFile`` directly as it also buffers in all supported
+    Python versions.
+    """
+
+    @py3_data
+    def __init__(
+        self, filename=None, mode=None, compresslevel=9, fileobj=None, **kwargs
+    ):
+        """Return a buffered gzip file object."""
+        GzipFile.__init__(self, filename, mode, compresslevel, fileobj)
+
+    def write(self, data):
+        # This is identical to GzipFile.write but does not return
+        # the bytes written to retain compatibility.
+        super().write(data)
+
+
+class GzipFileSystemPathPointer(FileSystemPathPointer):
+    """
+    A subclass of ``FileSystemPathPointer`` that identifies a gzip-compressed
+    file located at a given absolute path.  ``GzipFileSystemPathPointer`` is
+    appropriate for loading large gzip-compressed pickle objects efficiently.
+    """
+
+    def open(self, encoding=None):
+        stream = GzipFile(self._path, "rb")
+        if encoding:
+            stream = SeekableUnicodeStreamReader(stream, encoding)
+        return stream
+
+
+class ZipFilePathPointer(PathPointer):
+    """
+    A path pointer that identifies a file contained within a zipfile,
+    which can be accessed by reading that zipfile.
+    """
+
+    @py3_data
+    def __init__(self, zipfile, entry=""):
+        """
+        Create a new path pointer pointing at the specified entry
+        in the given zipfile.
+
+        :raise IOError: If the given zipfile does not exist, or if it
+        does not contain the specified entry.
+        """
+        if isinstance(zipfile, str):
+            zipfile = OpenOnDemandZipFile(os.path.abspath(zipfile))
+
+        # Check that the entry exists:
+        if entry:
+
+            # Normalize the entry string, it should be relative:
+            entry = normalize_resource_name(entry, True, "/").lstrip("/")
+
+            try:
+                zipfile.getinfo(entry)
+            except Exception as e:
+                # Sometimes directories aren't explicitly listed in
+                # the zip file.  So if `entry` is a directory name,
+                # then check if the zipfile contains any files that
+                # are under the given directory.
+                if entry.endswith("/") and [
+                    n for n in zipfile.namelist() if n.startswith(entry)
+                ]:
+                    pass  # zipfile contains a file in that directory.
+                else:
+                    # Otherwise, complain.
+                    raise OSError(
+                        f"Zipfile {zipfile.filename!r} does not contain {entry!r}"
+                    ) from e
+        self._zipfile = zipfile
+        self._entry = entry
+
+    @property
+    def zipfile(self):
+        """
+        The zipfile.ZipFile object used to access the zip file
+        containing the entry identified by this path pointer.
+        """
+        return self._zipfile
+
+    @property
+    def entry(self):
+        """
+        The name of the file within zipfile that this path
+        pointer points to.
+        """
+        return self._entry
+
+    def open(self, encoding=None):
+        data = self._zipfile.read(self._entry)
+        stream = BytesIO(data)
+        if self._entry.endswith(".gz"):
+            stream = GzipFile(self._entry, fileobj=stream)
+        elif encoding is not None:
+            stream = SeekableUnicodeStreamReader(stream, encoding)
+        return stream
+
+    def file_size(self):
+        return self._zipfile.getinfo(self._entry).file_size
+
+    def join(self, fileid):
+        entry = f"{self._entry}/{fileid}"
+        return ZipFilePathPointer(self._zipfile, entry)
+
+    def __repr__(self):
+        return f"ZipFilePathPointer({self._zipfile.filename!r}, {self._entry!r})"
+
+    def __str__(self):
+        return os.path.normpath(os.path.join(self._zipfile.filename, self._entry))
+
+
+######################################################################
+# Access Functions
+######################################################################
+
+# Don't use a weak dictionary, because in the common case this
+# causes a lot more reloading that necessary.
+_resource_cache = {}
+"""A dictionary used to cache resources so that they won't
+   need to be loaded more than once."""
+
+
+def find(resource_name, paths=None):
+    """
+    Find the given resource by searching through the directories and
+    zip files in paths, where a None or empty string specifies an absolute path.
+    Returns a corresponding path name.  If the given resource is not
+    found, raise a ``LookupError``, whose message gives a pointer to
+    the installation instructions for the NLTK downloader.
+
+    Zip File Handling:
+
+      - If ``resource_name`` contains a component with a ``.zip``
+        extension, then it is assumed to be a zipfile; and the
+        remaining path components are used to look inside the zipfile.
+
+      - If any element of ``nltk.data.path`` has a ``.zip`` extension,
+        then it is assumed to be a zipfile.
+
+      - If a given resource name that does not contain any zipfile
+        component is not found initially, then ``find()`` will make a
+        second attempt to find that resource, by replacing each
+        component *p* in the path with *p.zip/p*.  For example, this
+        allows ``find()`` to map the resource name
+        ``corpora/chat80/cities.pl`` to a zip file path pointer to
+        ``corpora/chat80.zip/chat80/cities.pl``.
+
+      - When using ``find()`` to locate a directory contained in a
+        zipfile, the resource name must end with the forward slash
+        character.  Otherwise, ``find()`` will not locate the
+        directory.
+
+    :type resource_name: str or unicode
+    :param resource_name: The name of the resource to search for.
+        Resource names are posix-style relative path names, such as
+        ``corpora/brown``.  Directory names will be
+        automatically converted to a platform-appropriate path separator.
+    :rtype: str
+    """
+    resource_name = normalize_resource_name(resource_name, True)
+
+    # Resolve default paths at runtime in-case the user overrides
+    # nltk.data.path
+    if paths is None:
+        paths = path
+
+    # Check if the resource name includes a zipfile name
+    m = re.match(r"(.*\.zip)/?(.*)$|", resource_name)
+    zipfile, zipentry = m.groups()
+
+    # Check each item in our path
+    for path_ in paths:
+        # Is the path item a zipfile?
+        if path_ and (os.path.isfile(path_) and path_.endswith(".zip")):
+            try:
+                return ZipFilePathPointer(path_, resource_name)
+            except OSError:
+                # resource not in zipfile
+                continue
+
+        # Is the path item a directory or is resource_name an absolute path?
+        elif not path_ or os.path.isdir(path_):
+            if zipfile is None:
+                p = os.path.join(path_, url2pathname(resource_name))
+                if os.path.exists(p):
+                    if p.endswith(".gz"):
+                        return GzipFileSystemPathPointer(p)
+                    else:
+                        return FileSystemPathPointer(p)
+            else:
+                p = os.path.join(path_, url2pathname(zipfile))
+                if os.path.exists(p):
+                    try:
+                        return ZipFilePathPointer(p, zipentry)
+                    except OSError:
+                        # resource not in zipfile
+                        continue
+
+    # Fallback: if the path doesn't include a zip file, then try
+    # again, assuming that one of the path components is inside a
+    # zipfile of the same name.
+    if zipfile is None:
+        pieces = resource_name.split("/")
+        for i in range(len(pieces)):
+            modified_name = "/".join(pieces[:i] + [pieces[i] + ".zip"] + pieces[i:])
+            try:
+                return find(modified_name, paths)
+            except LookupError:
+                pass
+
+    # Identify the package (i.e. the .zip file) to download.
+    resource_zipname = resource_name.split("/")[1]
+    if resource_zipname.endswith(".zip"):
+        resource_zipname = resource_zipname.rpartition(".")[0]
+    # Display a friendly error message if the resource wasn't found:
+    msg = str(
+        "Resource \33[93m{resource}\033[0m not found.\n"
+        "Please use the NLTK Downloader to obtain the resource:\n\n"
+        "\33[31m"  # To display red text in terminal.
+        ">>> import nltk\n"
+        ">>> nltk.download('{resource}')\n"
+        "\033[0m"
+    ).format(resource=resource_zipname)
+    msg = textwrap_indent(msg)
+
+    msg += "\n  For more information see: https://www.nltk.org/data.html\n"
+
+    msg += "\n  Attempted to load \33[93m{resource_name}\033[0m\n".format(
+        resource_name=resource_name
+    )
+
+    msg += "\n  Searched in:" + "".join("\n    - %r" % d for d in paths)
+    sep = "*" * 70
+    resource_not_found = f"\n{sep}\n{msg}\n{sep}\n"
+    raise LookupError(resource_not_found)
+
+
+def retrieve(resource_url, filename=None, verbose=True):
+    """
+    Copy the given resource to a local file.  If no filename is
+    specified, then use the URL's filename.  If there is already a
+    file named ``filename``, then raise a ``ValueError``.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    """
+    resource_url = normalize_resource_url(resource_url)
+    if filename is None:
+        if resource_url.startswith("file:"):
+            filename = os.path.split(resource_url)[-1]
+        else:
+            filename = re.sub(r"(^\w+:)?.*/", "", resource_url)
+    if os.path.exists(filename):
+        filename = os.path.abspath(filename)
+        raise ValueError("File %r already exists!" % filename)
+
+    if verbose:
+        print(f"Retrieving {resource_url!r}, saving to {filename!r}")
+
+    # Open the input & output streams.
+    infile = _open(resource_url)
+
+    # Copy infile -> outfile, using 64k blocks.
+    with open(filename, "wb") as outfile:
+        while True:
+            s = infile.read(1024 * 64)  # 64k blocks.
+            outfile.write(s)
+            if not s:
+                break
+
+    infile.close()
+
+
+#: A dictionary describing the formats that are supported by NLTK's
+#: load() method.  Keys are format names, and values are format
+#: descriptions.
+FORMATS = {
+    "pickle": "A serialized python object, stored using the pickle module.",
+    "json": "A serialized python object, stored using the json module.",
+    "yaml": "A serialized python object, stored using the yaml module.",
+    "cfg": "A context free grammar.",
+    "pcfg": "A probabilistic CFG.",
+    "fcfg": "A feature CFG.",
+    "fol": "A list of first order logic expressions, parsed with "
+    "nltk.sem.logic.Expression.fromstring.",
+    "logic": "A list of first order logic expressions, parsed with "
+    "nltk.sem.logic.LogicParser.  Requires an additional logic_parser "
+    "parameter",
+    "val": "A semantic valuation, parsed by nltk.sem.Valuation.fromstring.",
+    "raw": "The raw (byte string) contents of a file.",
+    "text": "The raw (unicode string) contents of a file. ",
+}
+
+#: A dictionary mapping from file extensions to format names, used
+#: by load() when format="auto" to decide the format for a
+#: given resource url.
+AUTO_FORMATS = {
+    "pickle": "pickle",
+    "json": "json",
+    "yaml": "yaml",
+    "cfg": "cfg",
+    "pcfg": "pcfg",
+    "fcfg": "fcfg",
+    "fol": "fol",
+    "logic": "logic",
+    "val": "val",
+    "txt": "text",
+    "text": "text",
+}
+
+
+def load(
+    resource_url,
+    format="auto",
+    cache=True,
+    verbose=False,
+    logic_parser=None,
+    fstruct_reader=None,
+    encoding=None,
+):
+    """
+    Load a given resource from the NLTK data package.  The following
+    resource formats are currently supported:
+
+      - ``pickle``
+      - ``json``
+      - ``yaml``
+      - ``cfg`` (context free grammars)
+      - ``pcfg`` (probabilistic CFGs)
+      - ``fcfg`` (feature-based CFGs)
+      - ``fol`` (formulas of First Order Logic)
+      - ``logic`` (Logical formulas to be parsed by the given logic_parser)
+      - ``val`` (valuation of First Order Logic model)
+      - ``text`` (the file contents as a unicode string)
+      - ``raw`` (the raw file contents as a byte string)
+
+    If no format is specified, ``load()`` will attempt to determine a
+    format based on the resource name's file extension.  If that
+    fails, ``load()`` will raise a ``ValueError`` exception.
+
+    For all text formats (everything except ``pickle``, ``json``, ``yaml`` and ``raw``),
+    it tries to decode the raw contents using UTF-8, and if that doesn't
+    work, it tries with ISO-8859-1 (Latin-1), unless the ``encoding``
+    is specified.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    :type cache: bool
+    :param cache: If true, add this resource to a cache.  If load()
+        finds a resource in its cache, then it will return it from the
+        cache rather than loading it.
+    :type verbose: bool
+    :param verbose: If true, print a message when loading a resource.
+        Messages are not displayed when a resource is retrieved from
+        the cache.
+    :type logic_parser: LogicParser
+    :param logic_parser: The parser that will be used to parse logical
+        expressions.
+    :type fstruct_reader: FeatStructReader
+    :param fstruct_reader: The parser that will be used to parse the
+        feature structure of an fcfg.
+    :type encoding: str
+    :param encoding: the encoding of the input; only used for text formats.
+    """
+    resource_url = normalize_resource_url(resource_url)
+    resource_url = add_py3_data(resource_url)
+
+    # Determine the format of the resource.
+    if format == "auto":
+        resource_url_parts = resource_url.split(".")
+        ext = resource_url_parts[-1]
+        if ext == "gz":
+            ext = resource_url_parts[-2]
+        format = AUTO_FORMATS.get(ext)
+        if format is None:
+            raise ValueError(
+                "Could not determine format for %s based "
+                'on its file\nextension; use the "format" '
+                "argument to specify the format explicitly." % resource_url
+            )
+
+    if format not in FORMATS:
+        raise ValueError(f"Unknown format type: {format}!")
+
+    # If we've cached the resource, then just return it.
+    if cache:
+        resource_val = _resource_cache.get((resource_url, format))
+        if resource_val is not None:
+            if verbose:
+                print(f"<<Using cached copy of {resource_url}>>")
+            return resource_val
+
+    # Let the user know what's going on.
+    if verbose:
+        print(f"<<Loading {resource_url}>>")
+
+    # Load the resource.
+    opened_resource = _open(resource_url)
+
+    if format == "raw":
+        resource_val = opened_resource.read()
+    elif format == "pickle":
+        resource_val = pickle.load(opened_resource)
+    elif format == "json":
+        import json
+
+        from nltk.jsontags import json_tags
+
+        resource_val = json.load(opened_resource)
+        tag = None
+        if len(resource_val) != 1:
+            tag = next(resource_val.keys())
+        if tag not in json_tags:
+            raise ValueError("Unknown json tag.")
+    elif format == "yaml":
+        import yaml
+
+        resource_val = yaml.safe_load(opened_resource)
+    else:
+        # The resource is a text format.
+        binary_data = opened_resource.read()
+        if encoding is not None:
+            string_data = binary_data.decode(encoding)
+        else:
+            try:
+                string_data = binary_data.decode("utf-8")
+            except UnicodeDecodeError:
+                string_data = binary_data.decode("latin-1")
+        if format == "text":
+            resource_val = string_data
+        elif format == "cfg":
+            resource_val = grammar.CFG.fromstring(string_data, encoding=encoding)
+        elif format == "pcfg":
+            resource_val = grammar.PCFG.fromstring(string_data, encoding=encoding)
+        elif format == "fcfg":
+            resource_val = grammar.FeatureGrammar.fromstring(
+                string_data,
+                logic_parser=logic_parser,
+                fstruct_reader=fstruct_reader,
+                encoding=encoding,
+            )
+        elif format == "fol":
+            resource_val = sem.read_logic(
+                string_data,
+                logic_parser=sem.logic.LogicParser(),
+                encoding=encoding,
+            )
+        elif format == "logic":
+            resource_val = sem.read_logic(
+                string_data, logic_parser=logic_parser, encoding=encoding
+            )
+        elif format == "val":
+            resource_val = sem.read_valuation(string_data, encoding=encoding)
+        else:
+            raise AssertionError(
+                "Internal NLTK error: Format %s isn't "
+                "handled by nltk.data.load()" % (format,)
+            )
+
+    opened_resource.close()
+
+    # If requested, add it to the cache.
+    if cache:
+        try:
+            _resource_cache[(resource_url, format)] = resource_val
+            # TODO: add this line
+            # print('<<Caching a copy of %s>>' % (resource_url,))
+        except TypeError:
+            # We can't create weak references to some object types, like
+            # strings and tuples.  For now, just don't cache them.
+            pass
+
+    return resource_val
+
+
+def show_cfg(resource_url, escape="##"):
+    """
+    Write out a grammar file, ignoring escaped and empty lines.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    :type escape: str
+    :param escape: Prepended string that signals lines to be ignored
+    """
+    resource_url = normalize_resource_url(resource_url)
+    resource_val = load(resource_url, format="text", cache=False)
+    lines = resource_val.splitlines()
+    for l in lines:
+        if l.startswith(escape):
+            continue
+        if re.match("^$", l):
+            continue
+        print(l)
+
+
+def clear_cache():
+    """
+    Remove all objects from the resource cache.
+    :see: load()
+    """
+    _resource_cache.clear()
+
+
+def _open(resource_url):
+    """
+    Helper function that returns an open file object for a resource,
+    given its resource URL.  If the given resource URL uses the "nltk:"
+    protocol, or uses no protocol, then use ``nltk.data.find`` to find
+    its path, and open it with the given mode; if the resource URL
+    uses the 'file' protocol, then open the file with the given mode;
+    otherwise, delegate to ``urllib2.urlopen``.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    """
+    resource_url = normalize_resource_url(resource_url)
+    protocol, path_ = split_resource_url(resource_url)
+
+    if protocol is None or protocol.lower() == "nltk":
+        return find(path_, path + [""]).open()
+    elif protocol.lower() == "file":
+        # urllib might not use mode='rb', so handle this one ourselves:
+        return find(path_, [""]).open()
+    else:
+        return urlopen(resource_url)
+
+
+######################################################################
+# Lazy Resource Loader
+######################################################################
+
+
+class LazyLoader:
+    @py3_data
+    def __init__(self, _path):
+        self._path = _path
+
+    def __load(self):
+        resource = load(self._path)
+        # This is where the magic happens!  Transform ourselves into
+        # the object by modifying our own __dict__ and __class__ to
+        # match that of `resource`.
+        self.__dict__ = resource.__dict__
+        self.__class__ = resource.__class__
+
+    def __getattr__(self, attr):
+        self.__load()
+        # This looks circular, but its not, since __load() changes our
+        # __class__ to something new:
+        return getattr(self, attr)
+
+    def __repr__(self):
+        self.__load()
+        # This looks circular, but its not, since __load() changes our
+        # __class__ to something new:
+        return repr(self)
+
+
+######################################################################
+# Open-On-Demand ZipFile
+######################################################################
+
+
+class OpenOnDemandZipFile(zipfile.ZipFile):
+    """
+    A subclass of ``zipfile.ZipFile`` that closes its file pointer
+    whenever it is not using it; and re-opens it when it needs to read
+    data from the zipfile.  This is useful for reducing the number of
+    open file handles when many zip files are being accessed at once.
+    ``OpenOnDemandZipFile`` must be constructed from a filename, not a
+    file-like object (to allow re-opening).  ``OpenOnDemandZipFile`` is
+    read-only (i.e. ``write()`` and ``writestr()`` are disabled.
+    """
+
+    @py3_data
+    def __init__(self, filename):
+        if not isinstance(filename, str):
+            raise TypeError("ReopenableZipFile filename must be a string")
+        zipfile.ZipFile.__init__(self, filename)
+        assert self.filename == filename
+        self.close()
+        # After closing a ZipFile object, the _fileRefCnt needs to be cleared
+        # for Python2and3 compatible code.
+        self._fileRefCnt = 0
+
+    def read(self, name):
+        assert self.fp is None
+        self.fp = open(self.filename, "rb")
+        value = zipfile.ZipFile.read(self, name)
+        # Ensure that _fileRefCnt needs to be set for Python2and3 compatible code.
+        # Since we only opened one file here, we add 1.
+        self._fileRefCnt += 1
+        self.close()
+        return value
+
+    def write(self, *args, **kwargs):
+        """:raise NotImplementedError: OpenOnDemandZipfile is read-only"""
+        raise NotImplementedError("OpenOnDemandZipfile is read-only")
+
+    def writestr(self, *args, **kwargs):
+        """:raise NotImplementedError: OpenOnDemandZipfile is read-only"""
+        raise NotImplementedError("OpenOnDemandZipfile is read-only")
+
+    def __repr__(self):
+        return repr("OpenOnDemandZipFile(%r)" % self.filename)
+
+
+######################################################################
+# Seekable Unicode Stream Reader
+######################################################################
+
+
+class SeekableUnicodeStreamReader:
+    """
+    A stream reader that automatically encodes the source byte stream
+    into unicode (like ``codecs.StreamReader``); but still supports the
+    ``seek()`` and ``tell()`` operations correctly.  This is in contrast
+    to ``codecs.StreamReader``, which provide *broken* ``seek()`` and
+    ``tell()`` methods.
+
+    This class was motivated by ``StreamBackedCorpusView``, which
+    makes extensive use of ``seek()`` and ``tell()``, and needs to be
+    able to handle unicode-encoded files.
+
+    Note: this class requires stateless decoders.  To my knowledge,
+    this shouldn't cause a problem with any of python's builtin
+    unicode encodings.
+    """
+
+    DEBUG = True  # : If true, then perform extra sanity checks.
+
+    @py3_data
+    def __init__(self, stream, encoding, errors="strict"):
+        # Rewind the stream to its beginning.
+        stream.seek(0)
+
+        self.stream = stream
+        """The underlying stream."""
+
+        self.encoding = encoding
+        """The name of the encoding that should be used to encode the
+           underlying stream."""
+
+        self.errors = errors
+        """The error mode that should be used when decoding data from
+           the underlying stream.  Can be 'strict', 'ignore', or
+           'replace'."""
+
+        self.decode = codecs.getdecoder(encoding)
+        """The function that is used to decode byte strings into
+           unicode strings."""
+
+        self.bytebuffer = b""
+        """A buffer to use bytes that have been read but have not yet
+           been decoded.  This is only used when the final bytes from
+           a read do not form a complete encoding for a character."""
+
+        self.linebuffer = None
+        """A buffer used by ``readline()`` to hold characters that have
+           been read, but have not yet been returned by ``read()`` or
+           ``readline()``.  This buffer consists of a list of unicode
+           strings, where each string corresponds to a single line.
+           The final element of the list may or may not be a complete
+           line.  Note that the existence of a linebuffer makes the
+           ``tell()`` operation more complex, because it must backtrack
+           to the beginning of the buffer to determine the correct
+           file position in the underlying byte stream."""
+
+        self._rewind_checkpoint = 0
+        """The file position at which the most recent read on the
+           underlying stream began.  This is used, together with
+           ``_rewind_numchars``, to backtrack to the beginning of
+           ``linebuffer`` (which is required by ``tell()``)."""
+
+        self._rewind_numchars = None
+        """The number of characters that have been returned since the
+           read that started at ``_rewind_checkpoint``.  This is used,
+           together with ``_rewind_checkpoint``, to backtrack to the
+           beginning of ``linebuffer`` (which is required by ``tell()``)."""
+
+        self._bom = self._check_bom()
+        """The length of the byte order marker at the beginning of
+           the stream (or None for no byte order marker)."""
+
+    # /////////////////////////////////////////////////////////////////
+    # Read methods
+    # /////////////////////////////////////////////////////////////////
+
+    def read(self, size=None):
+        """
+        Read up to ``size`` bytes, decode them using this reader's
+        encoding, and return the resulting unicode string.
+
+        :param size: The maximum number of bytes to read.  If not
+            specified, then read as many bytes as possible.
+        :type size: int
+        :rtype: unicode
+        """
+        chars = self._read(size)
+
+        # If linebuffer is not empty, then include it in the result
+        if self.linebuffer:
+            chars = "".join(self.linebuffer) + chars
+            self.linebuffer = None
+            self._rewind_numchars = None
+
+        return chars
+
+    def discard_line(self):
+        if self.linebuffer and len(self.linebuffer) > 1:
+            line = self.linebuffer.pop(0)
+            self._rewind_numchars += len(line)
+        else:
+            self.stream.readline()
+
+    def readline(self, size=None):
+        """
+        Read a line of text, decode it using this reader's encoding,
+        and return the resulting unicode string.
+
+        :param size: The maximum number of bytes to read.  If no
+            newline is encountered before ``size`` bytes have been read,
+            then the returned value may not be a complete line of text.
+        :type size: int
+        """
+        # If we have a non-empty linebuffer, then return the first
+        # line from it.  (Note that the last element of linebuffer may
+        # not be a complete line; so let _read() deal with it.)
+        if self.linebuffer and len(self.linebuffer) > 1:
+            line = self.linebuffer.pop(0)
+            self._rewind_numchars += len(line)
+            return line
+
+        readsize = size or 72
+        chars = ""
+
+        # If there's a remaining incomplete line in the buffer, add it.
+        if self.linebuffer:
+            chars += self.linebuffer.pop()
+            self.linebuffer = None
+
+        while True:
+            startpos = self.stream.tell() - len(self.bytebuffer)
+            new_chars = self._read(readsize)
+
+            # If we're at a '\r', then read one extra character, since
+            # it might be a '\n', to get the proper line ending.
+            if new_chars and new_chars.endswith("\r"):
+                new_chars += self._read(1)
+
+            chars += new_chars
+            lines = chars.splitlines(True)
+            if len(lines) > 1:
+                line = lines[0]
+                self.linebuffer = lines[1:]
+                self._rewind_numchars = len(new_chars) - (len(chars) - len(line))
+                self._rewind_checkpoint = startpos
+                break
+            elif len(lines) == 1:
+                line0withend = lines[0]
+                line0withoutend = lines[0].splitlines(False)[0]
+                if line0withend != line0withoutend:  # complete line
+                    line = line0withend
+                    break
+
+            if not new_chars or size is not None:
+                line = chars
+                break
+
+            # Read successively larger blocks of text.
+            if readsize < 8000:
+                readsize *= 2
+
+        return line
+
+    def readlines(self, sizehint=None, keepends=True):
+        """
+        Read this file's contents, decode them using this reader's
+        encoding, and return it as a list of unicode lines.
+
+        :rtype: list(unicode)
+        :param sizehint: Ignored.
+        :param keepends: If false, then strip newlines.
+        """
+        return self.read().splitlines(keepends)
+
+    def next(self):
+        """Return the next decoded line from the underlying stream."""
+        line = self.readline()
+        if line:
+            return line
+        else:
+            raise StopIteration
+
+    def __next__(self):
+        return self.next()
+
+    def __iter__(self):
+        """Return self"""
+        return self
+
+    def __del__(self):
+        # let garbage collector deal with still opened streams
+        if not self.closed:
+            self.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def xreadlines(self):
+        """Return self"""
+        return self
+
+    # /////////////////////////////////////////////////////////////////
+    # Pass-through methods & properties
+    # /////////////////////////////////////////////////////////////////
+
+    @property
+    def closed(self):
+        """True if the underlying stream is closed."""
+        return self.stream.closed
+
+    @property
+    def name(self):
+        """The name of the underlying stream."""
+        return self.stream.name
+
+    @property
+    def mode(self):
+        """The mode of the underlying stream."""
+        return self.stream.mode
+
+    def close(self):
+        """
+        Close the underlying stream.
+        """
+        self.stream.close()
+
+    # /////////////////////////////////////////////////////////////////
+    # Seek and tell
+    # /////////////////////////////////////////////////////////////////
+
+    def seek(self, offset, whence=0):
+        """
+        Move the stream to a new file position.  If the reader is
+        maintaining any buffers, then they will be cleared.
+
+        :param offset: A byte count offset.
+        :param whence: If 0, then the offset is from the start of the file
+            (offset should be positive), if 1, then the offset is from the
+            current position (offset may be positive or negative); and if 2,
+            then the offset is from the end of the file (offset should
+            typically be negative).
+        """
+        if whence == 1:
+            raise ValueError(
+                "Relative seek is not supported for "
+                "SeekableUnicodeStreamReader -- consider "
+                "using char_seek_forward() instead."
+            )
+        self.stream.seek(offset, whence)
+        self.linebuffer = None
+        self.bytebuffer = b""
+        self._rewind_numchars = None
+        self._rewind_checkpoint = self.stream.tell()
+
+    def char_seek_forward(self, offset):
+        """
+        Move the read pointer forward by ``offset`` characters.
+        """
+        if offset < 0:
+            raise ValueError("Negative offsets are not supported")
+        # Clear all buffers.
+        self.seek(self.tell())
+        # Perform the seek operation.
+        self._char_seek_forward(offset)
+
+    def _char_seek_forward(self, offset, est_bytes=None):
+        """
+        Move the file position forward by ``offset`` characters,
+        ignoring all buffers.
+
+        :param est_bytes: A hint, giving an estimate of the number of
+            bytes that will be needed to move forward by ``offset`` chars.
+            Defaults to ``offset``.
+        """
+        if est_bytes is None:
+            est_bytes = offset
+        bytes = b""
+
+        while True:
+            # Read in a block of bytes.
+            newbytes = self.stream.read(est_bytes - len(bytes))
+            bytes += newbytes
+
+            # Decode the bytes to characters.
+            chars, bytes_decoded = self._incr_decode(bytes)
+
+            # If we got the right number of characters, then seek
+            # backwards over any truncated characters, and return.
+            if len(chars) == offset:
+                self.stream.seek(-len(bytes) + bytes_decoded, 1)
+                return
+
+            # If we went too far, then we can back-up until we get it
+            # right, using the bytes we've already read.
+            if len(chars) > offset:
+                while len(chars) > offset:
+                    # Assume at least one byte/char.
+                    est_bytes += offset - len(chars)
+                    chars, bytes_decoded = self._incr_decode(bytes[:est_bytes])
+                self.stream.seek(-len(bytes) + bytes_decoded, 1)
+                return
+
+            # Otherwise, we haven't read enough bytes yet; loop again.
+            est_bytes += offset - len(chars)
+
+    def tell(self):
+        """
+        Return the current file position on the underlying byte
+        stream.  If this reader is maintaining any buffers, then the
+        returned file position will be the position of the beginning
+        of those buffers.
+        """
+        # If nothing's buffered, then just return our current filepos:
+        if self.linebuffer is None:
+            return self.stream.tell() - len(self.bytebuffer)
+
+        # Otherwise, we'll need to backtrack the filepos until we
+        # reach the beginning of the buffer.
+
+        # Store our original file position, so we can return here.
+        orig_filepos = self.stream.tell()
+
+        # Calculate an estimate of where we think the newline is.
+        bytes_read = (orig_filepos - len(self.bytebuffer)) - self._rewind_checkpoint
+        buf_size = sum(len(line) for line in self.linebuffer)
+        est_bytes = int(
+            bytes_read * self._rewind_numchars / (self._rewind_numchars + buf_size)
+        )
+
+        self.stream.seek(self._rewind_checkpoint)
+        self._char_seek_forward(self._rewind_numchars, est_bytes)
+        filepos = self.stream.tell()
+
+        # Sanity check
+        if self.DEBUG:
+            self.stream.seek(filepos)
+            check1 = self._incr_decode(self.stream.read(50))[0]
+            check2 = "".join(self.linebuffer)
+            assert check1.startswith(check2) or check2.startswith(check1)
+
+        # Return to our original filepos (so we don't have to throw
+        # out our buffer.)
+        self.stream.seek(orig_filepos)
+
+        # Return the calculated filepos
+        return filepos
+
+    # /////////////////////////////////////////////////////////////////
+    # Helper methods
+    # /////////////////////////////////////////////////////////////////
+
+    def _read(self, size=None):
+        """
+        Read up to ``size`` bytes from the underlying stream, decode
+        them using this reader's encoding, and return the resulting
+        unicode string.  ``linebuffer`` is not included in the result.
+        """
+        if size == 0:
+            return ""
+
+        # Skip past the byte order marker, if present.
+        if self._bom and self.stream.tell() == 0:
+            self.stream.read(self._bom)
+
+        # Read the requested number of bytes.
+        if size is None:
+            new_bytes = self.stream.read()
+        else:
+            new_bytes = self.stream.read(size)
+        bytes = self.bytebuffer + new_bytes
+
+        # Decode the bytes into unicode characters
+        chars, bytes_decoded = self._incr_decode(bytes)
+
+        # If we got bytes but couldn't decode any, then read further.
+        if (size is not None) and (not chars) and (len(new_bytes) > 0):
+            while not chars:
+                new_bytes = self.stream.read(1)
+                if not new_bytes:
+                    break  # end of file.
+                bytes += new_bytes
+                chars, bytes_decoded = self._incr_decode(bytes)
+
+        # Record any bytes we didn't consume.
+        self.bytebuffer = bytes[bytes_decoded:]
+
+        # Return the result
+        return chars
+
+    def _incr_decode(self, bytes):
+        """
+        Decode the given byte string into a unicode string, using this
+        reader's encoding.  If an exception is encountered that
+        appears to be caused by a truncation error, then just decode
+        the byte string without the bytes that cause the trunctaion
+        error.
+
+        Return a tuple ``(chars, num_consumed)``, where ``chars`` is
+        the decoded unicode string, and ``num_consumed`` is the
+        number of bytes that were consumed.
+        """
+        while True:
+            try:
+                return self.decode(bytes, "strict")
+            except UnicodeDecodeError as exc:
+                # If the exception occurs at the end of the string,
+                # then assume that it's a truncation error.
+                if exc.end == len(bytes):
+                    return self.decode(bytes[: exc.start], self.errors)
+
+                # Otherwise, if we're being strict, then raise it.
+                elif self.errors == "strict":
+                    raise
+
+                # If we're not strict, then re-process it with our
+                # errors setting.  This *may* raise an exception.
+                else:
+                    return self.decode(bytes, self.errors)
+
+    _BOM_TABLE = {
+        "utf8": [(codecs.BOM_UTF8, None)],
+        "utf16": [(codecs.BOM_UTF16_LE, "utf16-le"), (codecs.BOM_UTF16_BE, "utf16-be")],
+        "utf16le": [(codecs.BOM_UTF16_LE, None)],
+        "utf16be": [(codecs.BOM_UTF16_BE, None)],
+        "utf32": [(codecs.BOM_UTF32_LE, "utf32-le"), (codecs.BOM_UTF32_BE, "utf32-be")],
+        "utf32le": [(codecs.BOM_UTF32_LE, None)],
+        "utf32be": [(codecs.BOM_UTF32_BE, None)],
+    }
+
+    def _check_bom(self):
+        # Normalize our encoding name
+        enc = re.sub("[ -]", "", self.encoding.lower())
+
+        # Look up our encoding in the BOM table.
+        bom_info = self._BOM_TABLE.get(enc)
+
+        if bom_info:
+            # Read a prefix, to check against the BOM(s)
+            bytes = self.stream.read(16)
+            self.stream.seek(0)
+
+            # Check for each possible BOM.
+            for (bom, new_encoding) in bom_info:
+                if bytes.startswith(bom):
+                    if new_encoding:
+                        self.encoding = new_encoding
+                    return len(bom)
+
+        return None
+
+
+__all__ = [
+    "path",
+    "PathPointer",
+    "FileSystemPathPointer",
+    "BufferedGzipFile",
+    "GzipFileSystemPathPointer",
+    "GzipFileSystemPathPointer",
+    "find",
+    "retrieve",
+    "FORMATS",
+    "AUTO_FORMATS",
+    "load",
+    "show_cfg",
+    "clear_cache",
+    "LazyLoader",
+    "OpenOnDemandZipFile",
+    "GzipFileSystemPathPointer",
+    "SeekableUnicodeStreamReader",
+]

lib/python3.10/site-packages/nltk/decorators.py

@@ -0,0 +1,251 @@
+"""
+Decorator module by Michele Simionato <michelesimionato@libero.it>
+Copyright Michele Simionato, distributed under the terms of the BSD License (see below).
+http://www.phyast.pitt.edu/~micheles/python/documentation.html
+
+Included in NLTK for its support of a nice memoization decorator.
+"""
+
+__docformat__ = "restructuredtext en"
+
+## The basic trick is to generate the source code for the decorated function
+## with the right signature and to evaluate it.
+## Uncomment the statement 'print >> sys.stderr, func_src'  in _decorator
+## to understand what is going on.
+
+__all__ = ["decorator", "new_wrapper", "getinfo"]
+
+import sys
+
+# Hack to keep NLTK's "tokenize" module from colliding with the "tokenize" in
+# the Python standard library.
+OLD_SYS_PATH = sys.path[:]
+sys.path = [p for p in sys.path if p and "nltk" not in str(p)]
+import inspect
+
+sys.path = OLD_SYS_PATH
+
+
+def __legacysignature(signature):
+    """
+    For retrocompatibility reasons, we don't use a standard Signature.
+    Instead, we use the string generated by this method.
+    Basically, from a Signature we create a string and remove the default values.
+    """
+    listsignature = str(signature)[1:-1].split(",")
+    for counter, param in enumerate(listsignature):
+        if param.count("=") > 0:
+            listsignature[counter] = param[0 : param.index("=")].strip()
+        else:
+            listsignature[counter] = param.strip()
+    return ", ".join(listsignature)
+
+
+def getinfo(func):
+    """
+    Returns an info dictionary containing:
+    - name (the name of the function : str)
+    - argnames (the names of the arguments : list)
+    - defaults (the values of the default arguments : tuple)
+    - signature (the signature : str)
+    - fullsignature (the full signature : Signature)
+    - doc (the docstring : str)
+    - module (the module name : str)
+    - dict (the function __dict__ : str)
+
+    >>> def f(self, x=1, y=2, *args, **kw): pass
+
+    >>> info = getinfo(f)
+
+    >>> info["name"]
+    'f'
+    >>> info["argnames"]
+    ['self', 'x', 'y', 'args', 'kw']
+
+    >>> info["defaults"]
+    (1, 2)
+
+    >>> info["signature"]
+    'self, x, y, *args, **kw'
+
+    >>> info["fullsignature"]
+    <Signature (self, x=1, y=2, *args, **kw)>
+    """
+    assert inspect.ismethod(func) or inspect.isfunction(func)
+    argspec = inspect.getfullargspec(func)
+    regargs, varargs, varkwargs = argspec[:3]
+    argnames = list(regargs)
+    if varargs:
+        argnames.append(varargs)
+    if varkwargs:
+        argnames.append(varkwargs)
+    fullsignature = inspect.signature(func)
+    # Convert Signature to str
+    signature = __legacysignature(fullsignature)
+
+    # pypy compatibility
+    if hasattr(func, "__closure__"):
+        _closure = func.__closure__
+        _globals = func.__globals__
+    else:
+        _closure = func.func_closure
+        _globals = func.func_globals
+
+    return dict(
+        name=func.__name__,
+        argnames=argnames,
+        signature=signature,
+        fullsignature=fullsignature,
+        defaults=func.__defaults__,
+        doc=func.__doc__,
+        module=func.__module__,
+        dict=func.__dict__,
+        globals=_globals,
+        closure=_closure,
+    )
+
+
+def update_wrapper(wrapper, model, infodict=None):
+    "akin to functools.update_wrapper"
+    infodict = infodict or getinfo(model)
+    wrapper.__name__ = infodict["name"]
+    wrapper.__doc__ = infodict["doc"]
+    wrapper.__module__ = infodict["module"]
+    wrapper.__dict__.update(infodict["dict"])
+    wrapper.__defaults__ = infodict["defaults"]
+    wrapper.undecorated = model
+    return wrapper
+
+
+def new_wrapper(wrapper, model):
+    """
+    An improvement over functools.update_wrapper. The wrapper is a generic
+    callable object. It works by generating a copy of the wrapper with the
+    right signature and by updating the copy, not the original.
+    Moreovoer, 'model' can be a dictionary with keys 'name', 'doc', 'module',
+    'dict', 'defaults'.
+    """
+    if isinstance(model, dict):
+        infodict = model
+    else:  # assume model is a function
+        infodict = getinfo(model)
+    assert (
+        not "_wrapper_" in infodict["argnames"]
+    ), '"_wrapper_" is a reserved argument name!'
+    src = "lambda %(signature)s: _wrapper_(%(signature)s)" % infodict
+    funcopy = eval(src, dict(_wrapper_=wrapper))
+    return update_wrapper(funcopy, model, infodict)
+
+
+# helper used in decorator_factory
+def __call__(self, func):
+    return new_wrapper(lambda *a, **k: self.call(func, *a, **k), func)
+
+
+def decorator_factory(cls):
+    """
+    Take a class with a ``.caller`` method and return a callable decorator
+    object. It works by adding a suitable __call__ method to the class;
+    it raises a TypeError if the class already has a nontrivial __call__
+    method.
+    """
+    attrs = set(dir(cls))
+    if "__call__" in attrs:
+        raise TypeError(
+            "You cannot decorate a class with a nontrivial " "__call__ method"
+        )
+    if "call" not in attrs:
+        raise TypeError("You cannot decorate a class without a " ".call method")
+    cls.__call__ = __call__
+    return cls
+
+
+def decorator(caller):
+    """
+    General purpose decorator factory: takes a caller function as
+    input and returns a decorator with the same attributes.
+    A caller function is any function like this::
+
+     def caller(func, *args, **kw):
+         # do something
+         return func(*args, **kw)
+
+    Here is an example of usage:
+
+    >>> @decorator
+    ... def chatty(f, *args, **kw):
+    ...     print("Calling %r" % f.__name__)
+    ...     return f(*args, **kw)
+
+    >>> chatty.__name__
+    'chatty'
+
+    >>> @chatty
+    ... def f(): pass
+    ...
+    >>> f()
+    Calling 'f'
+
+    decorator can also take in input a class with a .caller method; in this
+    case it converts the class into a factory of callable decorator objects.
+    See the documentation for an example.
+    """
+    if inspect.isclass(caller):
+        return decorator_factory(caller)
+
+    def _decorator(func):  # the real meat is here
+        infodict = getinfo(func)
+        argnames = infodict["argnames"]
+        assert not (
+            "_call_" in argnames or "_func_" in argnames
+        ), "You cannot use _call_ or _func_ as argument names!"
+        src = "lambda %(signature)s: _call_(_func_, %(signature)s)" % infodict
+        # import sys; print >> sys.stderr, src # for debugging purposes
+        dec_func = eval(src, dict(_func_=func, _call_=caller))
+        return update_wrapper(dec_func, func, infodict)
+
+    return update_wrapper(_decorator, caller)
+
+
+def getattr_(obj, name, default_thunk):
+    "Similar to .setdefault in dictionaries."
+    try:
+        return getattr(obj, name)
+    except AttributeError:
+        default = default_thunk()
+        setattr(obj, name, default)
+        return default
+
+
+@decorator
+def memoize(func, *args):
+    dic = getattr_(func, "memoize_dic", dict)
+    # memoize_dic is created at the first call
+    if args in dic:
+        return dic[args]
+    result = func(*args)
+    dic[args] = result
+    return result
+
+
+##########################     LEGALESE    ###############################
+
+##   Redistributions of source code must retain the above copyright
+##   notice, this list of conditions and the following disclaimer.
+##   Redistributions in bytecode form must reproduce the above copyright
+##   notice, this list of conditions and the following disclaimer in
+##   the documentation and/or other materials provided with the
+##   distribution.
+
+##   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+##   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+##   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+##   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+##   HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+##   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+##   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+##   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+##   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+##   TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+##   USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+##   DAMAGE.

lib/python3.10/site-packages/nltk/downloader.py

@@ -0,0 +1,2559 @@
+# Natural Language Toolkit: Corpus & Model Downloader
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <edloper@gmail.com>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+The NLTK corpus and module downloader.  This module defines several
+interfaces which can be used to download corpora, models, and other
+data packages that can be used with NLTK.
+
+Downloading Packages
+====================
+If called with no arguments, ``download()`` will display an interactive
+interface which can be used to download and install new packages.
+If Tkinter is available, then a graphical interface will be shown,
+otherwise a simple text interface will be provided.
+
+Individual packages can be downloaded by calling the ``download()``
+function with a single argument, giving the package identifier for the
+package that should be downloaded:
+
+    >>> download('treebank') # doctest: +SKIP
+    [nltk_data] Downloading package 'treebank'...
+    [nltk_data]   Unzipping corpora/treebank.zip.
+
+NLTK also provides a number of \"package collections\", consisting of
+a group of related packages.  To download all packages in a
+colleciton, simply call ``download()`` with the collection's
+identifier:
+
+    >>> download('all-corpora') # doctest: +SKIP
+    [nltk_data] Downloading package 'abc'...
+    [nltk_data]   Unzipping corpora/abc.zip.
+    [nltk_data] Downloading package 'alpino'...
+    [nltk_data]   Unzipping corpora/alpino.zip.
+      ...
+    [nltk_data] Downloading package 'words'...
+    [nltk_data]   Unzipping corpora/words.zip.
+
+Download Directory
+==================
+By default, packages are installed in either a system-wide directory
+(if Python has sufficient access to write to it); or in the current
+user's home directory.  However, the ``download_dir`` argument may be
+used to specify a different installation target, if desired.
+
+See ``Downloader.default_download_dir()`` for more a detailed
+description of how the default download directory is chosen.
+
+NLTK Download Server
+====================
+Before downloading any packages, the corpus and module downloader
+contacts the NLTK download server, to retrieve an index file
+describing the available packages.  By default, this index file is
+loaded from ``https://raw.githubusercontent.com/nltk/nltk_data/gh-pages/index.xml``.
+If necessary, it is possible to create a new ``Downloader`` object,
+specifying a different URL for the package index file.
+
+Usage::
+
+    python nltk/downloader.py [-d DATADIR] [-q] [-f] [-k] PACKAGE_IDS
+
+or::
+
+    python -m nltk.downloader [-d DATADIR] [-q] [-f] [-k] PACKAGE_IDS
+"""
+# ----------------------------------------------------------------------
+
+"""
+
+  0     1  2    3
+[label][----][label][----]
+[column  ][column     ]
+
+Notes
+=====
+Handling data files..  Some questions:
+
+* Should the data files be kept zipped or unzipped?  I say zipped.
+
+* Should the data files be kept in svn at all?  Advantages: history;
+  automatic version numbers; 'svn up' could be used rather than the
+  downloader to update the corpora.  Disadvantages: they're big,
+  which makes working from svn a bit of a pain.  And we're planning
+  to potentially make them much bigger.  I don't think we want
+  people to have to download 400MB corpora just to use nltk from svn.
+
+* Compromise: keep the data files in trunk/data rather than in
+  trunk/nltk.  That way you can check them out in svn if you want
+  to; but you don't need to, and you can use the downloader instead.
+
+* Also: keep models in mind.  When we change the code, we'd
+  potentially like the models to get updated.  This could require a
+  little thought.
+
+* So.. let's assume we have a trunk/data directory, containing a bunch
+  of packages.  The packages should be kept as zip files, because we
+  really shouldn't be editing them much (well -- we may edit models
+  more, but they tend to be binary-ish files anyway, where diffs
+  aren't that helpful).  So we'll have trunk/data, with a bunch of
+  files like abc.zip and treebank.zip and propbank.zip.  For each
+  package we could also have eg treebank.xml and propbank.xml,
+  describing the contents of the package (name, copyright, license,
+  etc).  Collections would also have .xml files.  Finally, we would
+  pull all these together to form a single index.xml file.  Some
+  directory structure wouldn't hurt.  So how about::
+
+    /trunk/data/ ....................... root of data svn
+      index.xml ........................ main index file
+      src/ ............................. python scripts
+      packages/ ........................ dir for packages
+        corpora/ ....................... zip & xml files for corpora
+        grammars/ ...................... zip & xml files for grammars
+        taggers/ ....................... zip & xml files for taggers
+        tokenizers/ .................... zip & xml files for tokenizers
+        etc.
+      collections/ ..................... xml files for collections
+
+  Where the root (/trunk/data) would contain a makefile; and src/
+  would contain a script to update the info.xml file.  It could also
+  contain scripts to rebuild some of the various model files.  The
+  script that builds index.xml should probably check that each zip
+  file expands entirely into a single subdir, whose name matches the
+  package's uid.
+
+Changes I need to make:
+  - in index: change "size" to "filesize" or "compressed-size"
+  - in index: add "unzipped-size"
+  - when checking status: check both compressed & uncompressed size.
+    uncompressed size is important to make sure we detect a problem
+    if something got partially unzipped.  define new status values
+    to differentiate stale vs corrupt vs corruptly-uncompressed??
+    (we shouldn't need to re-download the file if the zip file is ok
+    but it didn't get uncompressed fully.)
+  - add other fields to the index: author, license, copyright, contact,
+    etc.
+
+the current grammars/ package would become a single new package (eg
+toy-grammars or book-grammars).
+
+xml file should have:
+  - authorship info
+  - license info
+  - copyright info
+  - contact info
+  - info about what type of data/annotation it contains?
+  - recommended corpus reader?
+
+collections can contain other collections.  they can also contain
+multiple package types (corpora & models).  Have a single 'basics'
+package that includes everything we talk about in the book?
+
+n.b.: there will have to be a fallback to the punkt tokenizer, in case
+they didn't download that model.
+
+default: unzip or not?
+
+"""
+import functools
+import itertools
+import os
+import shutil
+import subprocess
+import sys
+import textwrap
+import threading
+import time
+import warnings
+import zipfile
+from hashlib import md5
+from xml.etree import ElementTree
+
+try:
+    TKINTER = True
+    from tkinter import Button, Canvas, Entry, Frame, IntVar, Label, Menu, TclError, Tk
+    from tkinter.messagebox import showerror
+
+    from nltk.draw.table import Table
+    from nltk.draw.util import ShowText
+except ImportError:
+    TKINTER = False
+    TclError = ValueError
+
+from urllib.error import HTTPError, URLError
+from urllib.request import urlopen
+
+import nltk
+
+# urllib2 = nltk.internals.import_from_stdlib('urllib2')
+
+
+######################################################################
+# Directory entry objects (from the data server's index file)
+######################################################################
+
+
+class Package:
+    """
+    A directory entry for a downloadable package.  These entries are
+    extracted from the XML index file that is downloaded by
+    ``Downloader``.  Each package consists of a single file; but if
+    that file is a zip file, then it can be automatically decompressed
+    when the package is installed.
+    """
+
+    def __init__(
+        self,
+        id,
+        url,
+        name=None,
+        subdir="",
+        size=None,
+        unzipped_size=None,
+        checksum=None,
+        svn_revision=None,
+        copyright="Unknown",
+        contact="Unknown",
+        license="Unknown",
+        author="Unknown",
+        unzip=True,
+        **kw,
+    ):
+        self.id = id
+        """A unique identifier for this package."""
+
+        self.name = name or id
+        """A string name for this package."""
+
+        self.subdir = subdir
+        """The subdirectory where this package should be installed.
+           E.g., ``'corpora'`` or ``'taggers'``."""
+
+        self.url = url
+        """A URL that can be used to download this package's file."""
+
+        self.size = int(size)
+        """The filesize (in bytes) of the package file."""
+
+        self.unzipped_size = int(unzipped_size)
+        """The total filesize of the files contained in the package's
+           zipfile."""
+
+        self.checksum = checksum
+        """The MD-5 checksum of the package file."""
+
+        self.svn_revision = svn_revision
+        """A subversion revision number for this package."""
+
+        self.copyright = copyright
+        """Copyright holder for this package."""
+
+        self.contact = contact
+        """Name & email of the person who should be contacted with
+           questions about this package."""
+
+        self.license = license
+        """License information for this package."""
+
+        self.author = author
+        """Author of this package."""
+
+        ext = os.path.splitext(url.split("/")[-1])[1]
+        self.filename = os.path.join(subdir, id + ext)
+        """The filename that should be used for this package's file.  It
+           is formed by joining ``self.subdir`` with ``self.id``, and
+           using the same extension as ``url``."""
+
+        self.unzip = bool(int(unzip))  # '0' or '1'
+        """A flag indicating whether this corpus should be unzipped by
+           default."""
+
+        # Include any other attributes provided by the XML file.
+        self.__dict__.update(kw)
+
+    @staticmethod
+    def fromxml(xml):
+        if isinstance(xml, str):
+            xml = ElementTree.parse(xml)
+        for key in xml.attrib:
+            xml.attrib[key] = str(xml.attrib[key])
+        return Package(**xml.attrib)
+
+    def __lt__(self, other):
+        return self.id < other.id
+
+    def __repr__(self):
+        return "<Package %s>" % self.id
+
+
+class Collection:
+    """
+    A directory entry for a collection of downloadable packages.
+    These entries are extracted from the XML index file that is
+    downloaded by ``Downloader``.
+    """
+
+    def __init__(self, id, children, name=None, **kw):
+        self.id = id
+        """A unique identifier for this collection."""
+
+        self.name = name or id
+        """A string name for this collection."""
+
+        self.children = children
+        """A list of the ``Collections`` or ``Packages`` directly
+           contained by this collection."""
+
+        self.packages = None
+        """A list of ``Packages`` contained by this collection or any
+           collections it recursively contains."""
+
+        # Include any other attributes provided by the XML file.
+        self.__dict__.update(kw)
+
+    @staticmethod
+    def fromxml(xml):
+        if isinstance(xml, str):
+            xml = ElementTree.parse(xml)
+        for key in xml.attrib:
+            xml.attrib[key] = str(xml.attrib[key])
+        children = [child.get("ref") for child in xml.findall("item")]
+        return Collection(children=children, **xml.attrib)
+
+    def __lt__(self, other):
+        return self.id < other.id
+
+    def __repr__(self):
+        return "<Collection %s>" % self.id
+
+
+######################################################################
+# Message Passing Objects
+######################################################################
+
+
+class DownloaderMessage:
+    """A status message object, used by ``incr_download`` to
+    communicate its progress."""
+
+
+class StartCollectionMessage(DownloaderMessage):
+    """Data server has started working on a collection of packages."""
+
+    def __init__(self, collection):
+        self.collection = collection
+
+
+class FinishCollectionMessage(DownloaderMessage):
+    """Data server has finished working on a collection of packages."""
+
+    def __init__(self, collection):
+        self.collection = collection
+
+
+class StartPackageMessage(DownloaderMessage):
+    """Data server has started working on a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class FinishPackageMessage(DownloaderMessage):
+    """Data server has finished working on a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class StartDownloadMessage(DownloaderMessage):
+    """Data server has started downloading a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class FinishDownloadMessage(DownloaderMessage):
+    """Data server has finished downloading a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class StartUnzipMessage(DownloaderMessage):
+    """Data server has started unzipping a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class FinishUnzipMessage(DownloaderMessage):
+    """Data server has finished unzipping a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class UpToDateMessage(DownloaderMessage):
+    """The package download file is already up-to-date"""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class StaleMessage(DownloaderMessage):
+    """The package download file is out-of-date or corrupt"""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class ErrorMessage(DownloaderMessage):
+    """Data server encountered an error"""
+
+    def __init__(self, package, message):
+        self.package = package
+        if isinstance(message, Exception):
+            self.message = str(message)
+        else:
+            self.message = message
+
+
+class ProgressMessage(DownloaderMessage):
+    """Indicates how much progress the data server has made"""
+
+    def __init__(self, progress):
+        self.progress = progress
+
+
+class SelectDownloadDirMessage(DownloaderMessage):
+    """Indicates what download directory the data server is using"""
+
+    def __init__(self, download_dir):
+        self.download_dir = download_dir
+
+
+######################################################################
+# NLTK Data Server
+######################################################################
+
+
+class Downloader:
+    """
+    A class used to access the NLTK data server, which can be used to
+    download corpora and other data packages.
+    """
+
+    # /////////////////////////////////////////////////////////////////
+    # Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    INDEX_TIMEOUT = 60 * 60  # 1 hour
+    """The amount of time after which the cached copy of the data
+       server index will be considered 'stale,' and will be
+       re-downloaded."""
+
+    DEFAULT_URL = "https://raw.githubusercontent.com/nltk/nltk_data/gh-pages/index.xml"
+    """The default URL for the NLTK data server's index.  An
+       alternative URL can be specified when creating a new
+       ``Downloader`` object."""
+
+    # /////////////////////////////////////////////////////////////////
+    # Status Constants
+    # /////////////////////////////////////////////////////////////////
+
+    INSTALLED = "installed"
+    """A status string indicating that a package or collection is
+       installed and up-to-date."""
+    NOT_INSTALLED = "not installed"
+    """A status string indicating that a package or collection is
+       not installed."""
+    STALE = "out of date"
+    """A status string indicating that a package or collection is
+       corrupt or out-of-date."""
+    PARTIAL = "partial"
+    """A status string indicating that a collection is partially
+       installed (i.e., only some of its packages are installed.)"""
+
+    # /////////////////////////////////////////////////////////////////
+    # Constructor
+    # /////////////////////////////////////////////////////////////////
+
+    def __init__(self, server_index_url=None, download_dir=None):
+        self._url = server_index_url or self.DEFAULT_URL
+        """The URL for the data server's index file."""
+
+        self._collections = {}
+        """Dictionary from collection identifier to ``Collection``"""
+
+        self._packages = {}
+        """Dictionary from package identifier to ``Package``"""
+
+        self._download_dir = download_dir
+        """The default directory to which packages will be downloaded."""
+
+        self._index = None
+        """The XML index file downloaded from the data server"""
+
+        self._index_timestamp = None
+        """Time at which ``self._index`` was downloaded.  If it is more
+           than ``INDEX_TIMEOUT`` seconds old, it will be re-downloaded."""
+
+        self._status_cache = {}
+        """Dictionary from package/collection identifier to status
+           string (``INSTALLED``, ``NOT_INSTALLED``, ``STALE``, or
+           ``PARTIAL``).  Cache is used for packages only, not
+           collections."""
+
+        self._errors = None
+        """Flag for telling if all packages got successfully downloaded or not."""
+
+        # decide where we're going to save things to.
+        if self._download_dir is None:
+            self._download_dir = self.default_download_dir()
+
+    # /////////////////////////////////////////////////////////////////
+    # Information
+    # /////////////////////////////////////////////////////////////////
+
+    def list(
+        self,
+        download_dir=None,
+        show_packages=True,
+        show_collections=True,
+        header=True,
+        more_prompt=False,
+        skip_installed=False,
+    ):
+        lines = 0  # for more_prompt
+        if download_dir is None:
+            download_dir = self._download_dir
+            print("Using default data directory (%s)" % download_dir)
+        if header:
+            print("=" * (26 + len(self._url)))
+            print(" Data server index for <%s>" % self._url)
+            print("=" * (26 + len(self._url)))
+            lines += 3  # for more_prompt
+        stale = partial = False
+
+        categories = []
+        if show_packages:
+            categories.append("packages")
+        if show_collections:
+            categories.append("collections")
+        for category in categories:
+            print("%s:" % category.capitalize())
+            lines += 1  # for more_prompt
+            for info in sorted(getattr(self, category)(), key=str):
+                status = self.status(info, download_dir)
+                if status == self.INSTALLED and skip_installed:
+                    continue
+                if status == self.STALE:
+                    stale = True
+                if status == self.PARTIAL:
+                    partial = True
+                prefix = {
+                    self.INSTALLED: "*",
+                    self.STALE: "-",
+                    self.PARTIAL: "P",
+                    self.NOT_INSTALLED: " ",
+                }[status]
+                name = textwrap.fill(
+                    "-" * 27 + (info.name or info.id), 75, subsequent_indent=27 * " "
+                )[27:]
+                print("  [{}] {} {}".format(prefix, info.id.ljust(20, "."), name))
+                lines += len(name.split("\n"))  # for more_prompt
+                if more_prompt and lines > 20:
+                    user_input = input("Hit Enter to continue: ")
+                    if user_input.lower() in ("x", "q"):
+                        return
+                    lines = 0
+            print()
+        msg = "([*] marks installed packages"
+        if stale:
+            msg += "; [-] marks out-of-date or corrupt packages"
+        if partial:
+            msg += "; [P] marks partially installed collections"
+        print(textwrap.fill(msg + ")", subsequent_indent=" ", width=76))
+
+    def packages(self):
+        self._update_index()
+        return self._packages.values()
+
+    def corpora(self):
+        self._update_index()
+        return [pkg for (id, pkg) in self._packages.items() if pkg.subdir == "corpora"]
+
+    def models(self):
+        self._update_index()
+        return [pkg for (id, pkg) in self._packages.items() if pkg.subdir != "corpora"]
+
+    def collections(self):
+        self._update_index()
+        return self._collections.values()
+
+    # /////////////////////////////////////////////////////////////////
+    # Downloading
+    # /////////////////////////////////////////////////////////////////
+
+    def _info_or_id(self, info_or_id):
+        if isinstance(info_or_id, str):
+            return self.info(info_or_id)
+        else:
+            return info_or_id
+
+    # [xx] When during downloading is it 'safe' to abort?  Only unsafe
+    # time is *during* an unzip -- we don't want to leave a
+    # partially-unzipped corpus in place because we wouldn't notice
+    # it.  But if we had the exact total size of the unzipped corpus,
+    # then that would be fine.  Then we could abort anytime we want!
+    # So this is really what we should do.  That way the threaded
+    # downloader in the gui can just kill the download thread anytime
+    # it wants.
+
+    def incr_download(self, info_or_id, download_dir=None, force=False):
+        # If they didn't specify a download_dir, then use the default one.
+        if download_dir is None:
+            download_dir = self._download_dir
+            yield SelectDownloadDirMessage(download_dir)
+
+        # If they gave us a list of ids, then download each one.
+        if isinstance(info_or_id, (list, tuple)):
+            yield from self._download_list(info_or_id, download_dir, force)
+            return
+
+        # Look up the requested collection or package.
+        try:
+            info = self._info_or_id(info_or_id)
+        except (OSError, ValueError) as e:
+            yield ErrorMessage(None, f"Error loading {info_or_id}: {e}")
+            return
+
+        # Handle collections.
+        if isinstance(info, Collection):
+            yield StartCollectionMessage(info)
+            yield from self.incr_download(info.children, download_dir, force)
+            yield FinishCollectionMessage(info)
+
+        # Handle Packages (delegate to a helper function).
+        else:
+            yield from self._download_package(info, download_dir, force)
+
+    def _num_packages(self, item):
+        if isinstance(item, Package):
+            return 1
+        else:
+            return len(item.packages)
+
+    def _download_list(self, items, download_dir, force):
+        # Look up the requested items.
+        for i in range(len(items)):
+            try:
+                items[i] = self._info_or_id(items[i])
+            except (OSError, ValueError) as e:
+                yield ErrorMessage(items[i], e)
+                return
+
+        # Download each item, re-scaling their progress.
+        num_packages = sum(self._num_packages(item) for item in items)
+        progress = 0
+        for i, item in enumerate(items):
+            if isinstance(item, Package):
+                delta = 1.0 / num_packages
+            else:
+                delta = len(item.packages) / num_packages
+            for msg in self.incr_download(item, download_dir, force):
+                if isinstance(msg, ProgressMessage):
+                    yield ProgressMessage(progress + msg.progress * delta)
+                else:
+                    yield msg
+
+            progress += 100 * delta
+
+    def _download_package(self, info, download_dir, force):
+        yield StartPackageMessage(info)
+        yield ProgressMessage(0)
+
+        # Do we already have the current version?
+        status = self.status(info, download_dir)
+        if not force and status == self.INSTALLED:
+            yield UpToDateMessage(info)
+            yield ProgressMessage(100)
+            yield FinishPackageMessage(info)
+            return
+
+        # Remove the package from our status cache
+        self._status_cache.pop(info.id, None)
+
+        # Check for (and remove) any old/stale version.
+        filepath = os.path.join(download_dir, info.filename)
+        if os.path.exists(filepath):
+            if status == self.STALE:
+                yield StaleMessage(info)
+            os.remove(filepath)
+
+        # Ensure the download_dir exists
+        if not os.path.exists(download_dir):
+            os.makedirs(download_dir)
+        if not os.path.exists(os.path.join(download_dir, info.subdir)):
+            os.makedirs(os.path.join(download_dir, info.subdir))
+
+        # Download the file.  This will raise an IOError if the url
+        # is not found.
+        yield StartDownloadMessage(info)
+        yield ProgressMessage(5)
+        try:
+            infile = urlopen(info.url)
+            with open(filepath, "wb") as outfile:
+                num_blocks = max(1, info.size / (1024 * 16))
+                for block in itertools.count():
+                    s = infile.read(1024 * 16)  # 16k blocks.
+                    outfile.write(s)
+                    if not s:
+                        break
+                    if block % 2 == 0:  # how often?
+                        yield ProgressMessage(min(80, 5 + 75 * (block / num_blocks)))
+            infile.close()
+        except OSError as e:
+            yield ErrorMessage(
+                info,
+                "Error downloading %r from <%s>:" "\n  %s" % (info.id, info.url, e),
+            )
+            return
+        yield FinishDownloadMessage(info)
+        yield ProgressMessage(80)
+
+        # If it's a zipfile, uncompress it.
+        if info.filename.endswith(".zip"):
+            zipdir = os.path.join(download_dir, info.subdir)
+            # Unzip if we're unzipping by default; *or* if it's already
+            # been unzipped (presumably a previous version).
+            if info.unzip or os.path.exists(os.path.join(zipdir, info.id)):
+                yield StartUnzipMessage(info)
+                for msg in _unzip_iter(filepath, zipdir, verbose=False):
+                    # Somewhat of a hack, but we need a proper package reference
+                    msg.package = info
+                    yield msg
+                yield FinishUnzipMessage(info)
+
+        yield FinishPackageMessage(info)
+
+    def download(
+        self,
+        info_or_id=None,
+        download_dir=None,
+        quiet=False,
+        force=False,
+        prefix="[nltk_data] ",
+        halt_on_error=True,
+        raise_on_error=False,
+        print_error_to=sys.stderr,
+    ):
+
+        print_to = functools.partial(print, file=print_error_to)
+        # If no info or id is given, then use the interactive shell.
+        if info_or_id is None:
+            # [xx] hmm -- changing self._download_dir here seems like
+            # the wrong thing to do.  Maybe the _interactive_download
+            # function should make a new copy of self to use?
+            if download_dir is not None:
+                self._download_dir = download_dir
+            self._interactive_download()
+            return True
+
+        else:
+            # Define a helper function for displaying output:
+            def show(s, prefix2=""):
+                print_to(
+                    textwrap.fill(
+                        s,
+                        initial_indent=prefix + prefix2,
+                        subsequent_indent=prefix + prefix2 + " " * 4,
+                    )
+                )
+
+            for msg in self.incr_download(info_or_id, download_dir, force):
+                # Error messages
+                if isinstance(msg, ErrorMessage):
+                    show(msg.message)
+                    if raise_on_error:
+                        raise ValueError(msg.message)
+                    if halt_on_error:
+                        return False
+                    self._errors = True
+                    if not quiet:
+                        print_to("Error installing package. Retry? [n/y/e]")
+                        choice = input().strip()
+                        if choice in ["y", "Y"]:
+                            if not self.download(
+                                msg.package.id,
+                                download_dir,
+                                quiet,
+                                force,
+                                prefix,
+                                halt_on_error,
+                                raise_on_error,
+                            ):
+                                return False
+                        elif choice in ["e", "E"]:
+                            return False
+
+                # All other messages
+                if not quiet:
+                    # Collection downloading messages:
+                    if isinstance(msg, StartCollectionMessage):
+                        show("Downloading collection %r" % msg.collection.id)
+                        prefix += "   | "
+                        print_to(prefix)
+                    elif isinstance(msg, FinishCollectionMessage):
+                        print_to(prefix)
+                        prefix = prefix[:-4]
+                        if self._errors:
+                            show(
+                                "Downloaded collection %r with errors"
+                                % msg.collection.id
+                            )
+                        else:
+                            show("Done downloading collection %s" % msg.collection.id)
+
+                    # Package downloading messages:
+                    elif isinstance(msg, StartPackageMessage):
+                        show(
+                            "Downloading package %s to %s..."
+                            % (msg.package.id, download_dir)
+                        )
+                    elif isinstance(msg, UpToDateMessage):
+                        show("Package %s is already up-to-date!" % msg.package.id, "  ")
+                    # elif isinstance(msg, StaleMessage):
+                    #    show('Package %s is out-of-date or corrupt' %
+                    #         msg.package.id, '  ')
+                    elif isinstance(msg, StartUnzipMessage):
+                        show("Unzipping %s." % msg.package.filename, "  ")
+
+                    # Data directory message:
+                    elif isinstance(msg, SelectDownloadDirMessage):
+                        download_dir = msg.download_dir
+        return True
+
+    def is_stale(self, info_or_id, download_dir=None):
+        return self.status(info_or_id, download_dir) == self.STALE
+
+    def is_installed(self, info_or_id, download_dir=None):
+        return self.status(info_or_id, download_dir) == self.INSTALLED
+
+    def clear_status_cache(self, id=None):
+        if id is None:
+            self._status_cache.clear()
+        else:
+            self._status_cache.pop(id, None)
+
+    def status(self, info_or_id, download_dir=None):
+        """
+        Return a constant describing the status of the given package
+        or collection.  Status can be one of ``INSTALLED``,
+        ``NOT_INSTALLED``, ``STALE``, or ``PARTIAL``.
+        """
+        if download_dir is None:
+            download_dir = self._download_dir
+        info = self._info_or_id(info_or_id)
+
+        # Handle collections:
+        if isinstance(info, Collection):
+            pkg_status = [self.status(pkg.id) for pkg in info.packages]
+            if self.STALE in pkg_status:
+                return self.STALE
+            elif self.PARTIAL in pkg_status:
+                return self.PARTIAL
+            elif self.INSTALLED in pkg_status and self.NOT_INSTALLED in pkg_status:
+                return self.PARTIAL
+            elif self.NOT_INSTALLED in pkg_status:
+                return self.NOT_INSTALLED
+            else:
+                return self.INSTALLED
+
+        # Handle packages:
+        else:
+            filepath = os.path.join(download_dir, info.filename)
+            if download_dir != self._download_dir:
+                return self._pkg_status(info, filepath)
+            else:
+                if info.id not in self._status_cache:
+                    self._status_cache[info.id] = self._pkg_status(info, filepath)
+                return self._status_cache[info.id]
+
+    def _pkg_status(self, info, filepath):
+        if not os.path.exists(filepath):
+            return self.NOT_INSTALLED
+
+        # Check if the file has the correct size.
+        try:
+            filestat = os.stat(filepath)
+        except OSError:
+            return self.NOT_INSTALLED
+        if filestat.st_size != int(info.size):
+            return self.STALE
+
+        # Check if the file's checksum matches
+        if md5_hexdigest(filepath) != info.checksum:
+            return self.STALE
+
+        # If it's a zipfile, and it's been at least partially
+        # unzipped, then check if it's been fully unzipped.
+        if filepath.endswith(".zip"):
+            unzipdir = filepath[:-4]
+            if not os.path.exists(unzipdir):
+                return self.INSTALLED  # but not unzipped -- ok!
+            if not os.path.isdir(unzipdir):
+                return self.STALE
+
+            unzipped_size = sum(
+                os.stat(os.path.join(d, f)).st_size
+                for d, _, files in os.walk(unzipdir)
+                for f in files
+            )
+            if unzipped_size != info.unzipped_size:
+                return self.STALE
+
+        # Otherwise, everything looks good.
+        return self.INSTALLED
+
+    def update(self, quiet=False, prefix="[nltk_data] "):
+        """
+        Re-download any packages whose status is STALE.
+        """
+        self.clear_status_cache()
+        for pkg in self.packages():
+            if self.status(pkg) == self.STALE:
+                self.download(pkg, quiet=quiet, prefix=prefix)
+
+    # /////////////////////////////////////////////////////////////////
+    # Index
+    # /////////////////////////////////////////////////////////////////
+
+    def _update_index(self, url=None):
+        """A helper function that ensures that self._index is
+        up-to-date.  If the index is older than self.INDEX_TIMEOUT,
+        then download it again."""
+        # Check if the index is already up-to-date.  If so, do nothing.
+        if not (
+            self._index is None
+            or url is not None
+            or time.time() - self._index_timestamp > self.INDEX_TIMEOUT
+        ):
+            return
+
+        # If a URL was specified, then update our URL.
+        self._url = url or self._url
+
+        # Download the index file.
+        self._index = nltk.internals.ElementWrapper(
+            ElementTree.parse(urlopen(self._url)).getroot()
+        )
+        self._index_timestamp = time.time()
+
+        # Build a dictionary of packages.
+        packages = [Package.fromxml(p) for p in self._index.findall("packages/package")]
+        self._packages = {p.id: p for p in packages}
+
+        # Build a dictionary of collections.
+        collections = [
+            Collection.fromxml(c) for c in self._index.findall("collections/collection")
+        ]
+        self._collections = {c.id: c for c in collections}
+
+        # Replace identifiers with actual children in collection.children.
+        for collection in self._collections.values():
+            for i, child_id in enumerate(collection.children):
+                if child_id in self._packages:
+                    collection.children[i] = self._packages[child_id]
+                elif child_id in self._collections:
+                    collection.children[i] = self._collections[child_id]
+                else:
+                    print(
+                        "removing collection member with no package: {}".format(
+                            child_id
+                        )
+                    )
+                    del collection.children[i]
+
+        # Fill in collection.packages for each collection.
+        for collection in self._collections.values():
+            packages = {}
+            queue = [collection]
+            for child in queue:
+                if isinstance(child, Collection):
+                    queue.extend(child.children)
+                elif isinstance(child, Package):
+                    packages[child.id] = child
+                else:
+                    pass
+            collection.packages = packages.values()
+
+        # Flush the status cache
+        self._status_cache.clear()
+
+    def index(self):
+        """
+        Return the XML index describing the packages available from
+        the data server.  If necessary, this index will be downloaded
+        from the data server.
+        """
+        self._update_index()
+        return self._index
+
+    def info(self, id):
+        """Return the ``Package`` or ``Collection`` record for the
+        given item."""
+        self._update_index()
+        if id in self._packages:
+            return self._packages[id]
+        if id in self._collections:
+            return self._collections[id]
+        raise ValueError("Package %r not found in index" % id)
+
+    def xmlinfo(self, id):
+        """Return the XML info record for the given item"""
+        self._update_index()
+        for package in self._index.findall("packages/package"):
+            if package.get("id") == id:
+                return package
+        for collection in self._index.findall("collections/collection"):
+            if collection.get("id") == id:
+                return collection
+        raise ValueError("Package %r not found in index" % id)
+
+    # /////////////////////////////////////////////////////////////////
+    # URL & Data Directory
+    # /////////////////////////////////////////////////////////////////
+
+    def _get_url(self):
+        """The URL for the data server's index file."""
+        return self._url
+
+    def _set_url(self, url):
+        """
+        Set a new URL for the data server. If we're unable to contact
+        the given url, then the original url is kept.
+        """
+        original_url = self._url
+        try:
+            self._update_index(url)
+        except:
+            self._url = original_url
+            raise
+
+    url = property(_get_url, _set_url)
+
+    def default_download_dir(self):
+        """
+        Return the directory to which packages will be downloaded by
+        default.  This value can be overridden using the constructor,
+        or on a case-by-case basis using the ``download_dir`` argument when
+        calling ``download()``.
+
+        On Windows, the default download directory is
+        ``PYTHONHOME/lib/nltk``, where *PYTHONHOME* is the
+        directory containing Python, e.g. ``C:\\Python25``.
+
+        On all other platforms, the default directory is the first of
+        the following which exists or which can be created with write
+        permission: ``/usr/share/nltk_data``, ``/usr/local/share/nltk_data``,
+        ``/usr/lib/nltk_data``, ``/usr/local/lib/nltk_data``, ``~/nltk_data``.
+        """
+        # Check if we are on GAE where we cannot write into filesystem.
+        if "APPENGINE_RUNTIME" in os.environ:
+            return
+
+        # Check if we have sufficient permissions to install in a
+        # variety of system-wide locations.
+        for nltkdir in nltk.data.path:
+            if os.path.exists(nltkdir) and nltk.internals.is_writable(nltkdir):
+                return nltkdir
+
+        # On Windows, use %APPDATA%
+        if sys.platform == "win32" and "APPDATA" in os.environ:
+            homedir = os.environ["APPDATA"]
+
+        # Otherwise, install in the user's home directory.
+        else:
+            homedir = os.path.expanduser("~/")
+            if homedir == "~/":
+                raise ValueError("Could not find a default download directory")
+
+        # append "nltk_data" to the home directory
+        return os.path.join(homedir, "nltk_data")
+
+    def _get_download_dir(self):
+        """
+        The default directory to which packages will be downloaded.
+        This defaults to the value returned by ``default_download_dir()``.
+        To override this default on a case-by-case basis, use the
+        ``download_dir`` argument when calling ``download()``.
+        """
+        return self._download_dir
+
+    def _set_download_dir(self, download_dir):
+        self._download_dir = download_dir
+        # Clear the status cache.
+        self._status_cache.clear()
+
+    download_dir = property(_get_download_dir, _set_download_dir)
+
+    # /////////////////////////////////////////////////////////////////
+    # Interactive Shell
+    # /////////////////////////////////////////////////////////////////
+
+    def _interactive_download(self):
+        # Try the GUI first; if that doesn't work, try the simple
+        # interactive shell.
+        if TKINTER:
+            try:
+                DownloaderGUI(self).mainloop()
+            except TclError:
+                DownloaderShell(self).run()
+        else:
+            DownloaderShell(self).run()
+
+
+class DownloaderShell:
+    def __init__(self, dataserver):
+        self._ds = dataserver
+
+    def _simple_interactive_menu(self, *options):
+        print("-" * 75)
+        spc = (68 - sum(len(o) for o in options)) // (len(options) - 1) * " "
+        print("    " + spc.join(options))
+        print("-" * 75)
+
+    def run(self):
+        print("NLTK Downloader")
+        while True:
+            self._simple_interactive_menu(
+                "d) Download",
+                "l) List",
+                " u) Update",
+                "c) Config",
+                "h) Help",
+                "q) Quit",
+            )
+            user_input = input("Downloader> ").strip()
+            if not user_input:
+                print()
+                continue
+            command = user_input.lower().split()[0]
+            args = user_input.split()[1:]
+            try:
+                if command == "l":
+                    print()
+                    self._ds.list(self._ds.download_dir, header=False, more_prompt=True)
+                elif command == "h":
+                    self._simple_interactive_help()
+                elif command == "c":
+                    self._simple_interactive_config()
+                elif command in ("q", "x"):
+                    return
+                elif command == "d":
+                    self._simple_interactive_download(args)
+                elif command == "u":
+                    self._simple_interactive_update()
+                else:
+                    print("Command %r unrecognized" % user_input)
+            except HTTPError as e:
+                print("Error reading from server: %s" % e)
+            except URLError as e:
+                print("Error connecting to server: %s" % e.reason)
+            # try checking if user_input is a package name, &
+            # downloading it?
+            print()
+
+    def _simple_interactive_download(self, args):
+        if args:
+            for arg in args:
+                try:
+                    self._ds.download(arg, prefix="    ")
+                except (OSError, ValueError) as e:
+                    print(e)
+        else:
+            while True:
+                print()
+                print("Download which package (l=list; x=cancel)?")
+                user_input = input("  Identifier> ")
+                if user_input.lower() == "l":
+                    self._ds.list(
+                        self._ds.download_dir,
+                        header=False,
+                        more_prompt=True,
+                        skip_installed=True,
+                    )
+                    continue
+                elif user_input.lower() in ("x", "q", ""):
+                    return
+                elif user_input:
+                    for id in user_input.split():
+                        try:
+                            self._ds.download(id, prefix="    ")
+                        except (OSError, ValueError) as e:
+                            print(e)
+                    break
+
+    def _simple_interactive_update(self):
+        while True:
+            stale_packages = []
+            stale = partial = False
+            for info in sorted(getattr(self._ds, "packages")(), key=str):
+                if self._ds.status(info) == self._ds.STALE:
+                    stale_packages.append((info.id, info.name))
+
+            print()
+            if stale_packages:
+                print("Will update following packages (o=ok; x=cancel)")
+                for pid, pname in stale_packages:
+                    name = textwrap.fill(
+                        "-" * 27 + (pname), 75, subsequent_indent=27 * " "
+                    )[27:]
+                    print("  [ ] {} {}".format(pid.ljust(20, "."), name))
+                print()
+
+                user_input = input("  Identifier> ")
+                if user_input.lower() == "o":
+                    for pid, pname in stale_packages:
+                        try:
+                            self._ds.download(pid, prefix="    ")
+                        except (OSError, ValueError) as e:
+                            print(e)
+                    break
+                elif user_input.lower() in ("x", "q", ""):
+                    return
+            else:
+                print("Nothing to update.")
+                return
+
+    def _simple_interactive_help(self):
+        print()
+        print("Commands:")
+        print(
+            "  d) Download a package or collection     u) Update out of date packages"
+        )
+        print("  l) List packages & collections          h) Help")
+        print("  c) View & Modify Configuration          q) Quit")
+
+    def _show_config(self):
+        print()
+        print("Data Server:")
+        print("  - URL: <%s>" % self._ds.url)
+        print("  - %d Package Collections Available" % len(self._ds.collections()))
+        print("  - %d Individual Packages Available" % len(self._ds.packages()))
+        print()
+        print("Local Machine:")
+        print("  - Data directory: %s" % self._ds.download_dir)
+
+    def _simple_interactive_config(self):
+        self._show_config()
+        while True:
+            print()
+            self._simple_interactive_menu(
+                "s) Show Config", "u) Set Server URL", "d) Set Data Dir", "m) Main Menu"
+            )
+            user_input = input("Config> ").strip().lower()
+            if user_input == "s":
+                self._show_config()
+            elif user_input == "d":
+                new_dl_dir = input("  New Directory> ").strip()
+                if new_dl_dir in ("", "x", "q", "X", "Q"):
+                    print("  Cancelled!")
+                elif os.path.isdir(new_dl_dir):
+                    self._ds.download_dir = new_dl_dir
+                else:
+                    print("Directory %r not found!  Create it first." % new_dl_dir)
+            elif user_input == "u":
+                new_url = input("  New URL> ").strip()
+                if new_url in ("", "x", "q", "X", "Q"):
+                    print("  Cancelled!")
+                else:
+                    if not new_url.startswith(("http://", "https://")):
+                        new_url = "http://" + new_url
+                    try:
+                        self._ds.url = new_url
+                    except Exception as e:
+                        print(f"Error reading <{new_url!r}>:\n  {e}")
+            elif user_input == "m":
+                break
+
+
+class DownloaderGUI:
+    """
+    Graphical interface for downloading packages from the NLTK data
+    server.
+    """
+
+    # /////////////////////////////////////////////////////////////////
+    # Column Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    COLUMNS = [
+        "",
+        "Identifier",
+        "Name",
+        "Size",
+        "Status",
+        "Unzipped Size",
+        "Copyright",
+        "Contact",
+        "License",
+        "Author",
+        "Subdir",
+        "Checksum",
+    ]
+    """A list of the names of columns.  This controls the order in
+       which the columns will appear.  If this is edited, then
+       ``_package_to_columns()`` may need to be edited to match."""
+
+    COLUMN_WEIGHTS = {"": 0, "Name": 5, "Size": 0, "Status": 0}
+    """A dictionary specifying how columns should be resized when the
+       table is resized.  Columns with weight 0 will not be resized at
+       all; and columns with high weight will be resized more.
+       Default weight (for columns not explicitly listed) is 1."""
+
+    COLUMN_WIDTHS = {
+        "": 1,
+        "Identifier": 20,
+        "Name": 45,
+        "Size": 10,
+        "Unzipped Size": 10,
+        "Status": 12,
+    }
+    """A dictionary specifying how wide each column should be, in
+       characters.  The default width (for columns not explicitly
+       listed) is specified by ``DEFAULT_COLUMN_WIDTH``."""
+
+    DEFAULT_COLUMN_WIDTH = 30
+    """The default width for columns that are not explicitly listed
+       in ``COLUMN_WIDTHS``."""
+
+    INITIAL_COLUMNS = ["", "Identifier", "Name", "Size", "Status"]
+    """The set of columns that should be displayed by default."""
+
+    # Perform a few import-time sanity checks to make sure that the
+    # column configuration variables are defined consistently:
+    for c in COLUMN_WEIGHTS:
+        assert c in COLUMNS
+    for c in COLUMN_WIDTHS:
+        assert c in COLUMNS
+    for c in INITIAL_COLUMNS:
+        assert c in COLUMNS
+
+    # /////////////////////////////////////////////////////////////////
+    # Color Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    _BACKDROP_COLOR = ("#000", "#ccc")
+
+    _ROW_COLOR = {
+        Downloader.INSTALLED: ("#afa", "#080"),
+        Downloader.PARTIAL: ("#ffa", "#880"),
+        Downloader.STALE: ("#faa", "#800"),
+        Downloader.NOT_INSTALLED: ("#fff", "#888"),
+    }
+
+    _MARK_COLOR = ("#000", "#ccc")
+
+    # _FRONT_TAB_COLOR = ('#ccf', '#008')
+    # _BACK_TAB_COLOR = ('#88a', '#448')
+    _FRONT_TAB_COLOR = ("#fff", "#45c")
+    _BACK_TAB_COLOR = ("#aaa", "#67a")
+
+    _PROGRESS_COLOR = ("#f00", "#aaa")
+
+    _TAB_FONT = "helvetica -16 bold"
+
+    # /////////////////////////////////////////////////////////////////
+    # Constructor
+    # /////////////////////////////////////////////////////////////////
+
+    def __init__(self, dataserver, use_threads=True):
+        self._ds = dataserver
+        self._use_threads = use_threads
+
+        # For the threaded downloader:
+        self._download_lock = threading.Lock()
+        self._download_msg_queue = []
+        self._download_abort_queue = []
+        self._downloading = False
+
+        # For tkinter after callbacks:
+        self._afterid = {}
+
+        # A message log.
+        self._log_messages = []
+        self._log_indent = 0
+        self._log("NLTK Downloader Started!")
+
+        # Create the main window.
+        top = self.top = Tk()
+        top.geometry("+50+50")
+        top.title("NLTK Downloader")
+        top.configure(background=self._BACKDROP_COLOR[1])
+
+        # Set up some bindings now, in case anything goes wrong.
+        top.bind("<Control-q>", self.destroy)
+        top.bind("<Control-x>", self.destroy)
+        self._destroyed = False
+
+        self._column_vars = {}
+
+        # Initialize the GUI.
+        self._init_widgets()
+        self._init_menu()
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+
+        self._show_info()
+        self._select_columns()
+        self._table.select(0)
+
+        # Make sure we get notified when we're destroyed, so we can
+        # cancel any download in progress.
+        self._table.bind("<Destroy>", self._destroy)
+
+    def _log(self, msg):
+        self._log_messages.append(
+            "{} {}{}".format(time.ctime(), " | " * self._log_indent, msg)
+        )
+
+    # /////////////////////////////////////////////////////////////////
+    # Internals
+    # /////////////////////////////////////////////////////////////////
+
+    def _init_widgets(self):
+        # Create the top-level frame structures
+        f1 = Frame(self.top, relief="raised", border=2, padx=8, pady=0)
+        f1.pack(sid="top", expand=True, fill="both")
+        f1.grid_rowconfigure(2, weight=1)
+        f1.grid_columnconfigure(0, weight=1)
+        Frame(f1, height=8).grid(column=0, row=0)  # spacer
+        tabframe = Frame(f1)
+        tabframe.grid(column=0, row=1, sticky="news")
+        tableframe = Frame(f1)
+        tableframe.grid(column=0, row=2, sticky="news")
+        buttonframe = Frame(f1)
+        buttonframe.grid(column=0, row=3, sticky="news")
+        Frame(f1, height=8).grid(column=0, row=4)  # spacer
+        infoframe = Frame(f1)
+        infoframe.grid(column=0, row=5, sticky="news")
+        Frame(f1, height=8).grid(column=0, row=6)  # spacer
+        progressframe = Frame(
+            self.top, padx=3, pady=3, background=self._BACKDROP_COLOR[1]
+        )
+        progressframe.pack(side="bottom", fill="x")
+        self.top["border"] = 0
+        self.top["highlightthickness"] = 0
+
+        # Create the tabs
+        self._tab_names = ["Collections", "Corpora", "Models", "All Packages"]
+        self._tabs = {}
+        for i, tab in enumerate(self._tab_names):
+            label = Label(tabframe, text=tab, font=self._TAB_FONT)
+            label.pack(side="left", padx=((i + 1) % 2) * 10)
+            label.bind("<Button-1>", self._select_tab)
+            self._tabs[tab.lower()] = label
+
+        # Create the table.
+        column_weights = [self.COLUMN_WEIGHTS.get(column, 1) for column in self.COLUMNS]
+        self._table = Table(
+            tableframe,
+            self.COLUMNS,
+            column_weights=column_weights,
+            highlightthickness=0,
+            listbox_height=16,
+            reprfunc=self._table_reprfunc,
+        )
+        self._table.columnconfig(0, foreground=self._MARK_COLOR[0])  # marked
+        for i, column in enumerate(self.COLUMNS):
+            width = self.COLUMN_WIDTHS.get(column, self.DEFAULT_COLUMN_WIDTH)
+            self._table.columnconfig(i, width=width)
+        self._table.pack(expand=True, fill="both")
+        self._table.focus()
+        self._table.bind_to_listboxes("<Double-Button-1>", self._download)
+        self._table.bind("<space>", self._table_mark)
+        self._table.bind("<Return>", self._download)
+        self._table.bind("<Left>", self._prev_tab)
+        self._table.bind("<Right>", self._next_tab)
+        self._table.bind("<Control-a>", self._mark_all)
+
+        # Create entry boxes for URL & download_dir
+        infoframe.grid_columnconfigure(1, weight=1)
+
+        info = [
+            ("url", "Server Index:", self._set_url),
+            ("download_dir", "Download Directory:", self._set_download_dir),
+        ]
+        self._info = {}
+        for (i, (key, label, callback)) in enumerate(info):
+            Label(infoframe, text=label).grid(column=0, row=i, sticky="e")
+            entry = Entry(
+                infoframe,
+                font="courier",
+                relief="groove",
+                disabledforeground="#007aff",
+                foreground="#007aff",
+            )
+            self._info[key] = (entry, callback)
+            entry.bind("<Return>", self._info_save)
+            entry.bind("<Button-1>", lambda e, key=key: self._info_edit(key))
+            entry.grid(column=1, row=i, sticky="ew")
+
+        # If the user edits url or download_dir, and then clicks outside
+        # the entry box, then save their results.
+        self.top.bind("<Button-1>", self._info_save)
+
+        # Create Download & Refresh buttons.
+        self._download_button = Button(
+            buttonframe, text="Download", command=self._download, width=8
+        )
+        self._download_button.pack(side="left")
+        self._refresh_button = Button(
+            buttonframe, text="Refresh", command=self._refresh, width=8
+        )
+        self._refresh_button.pack(side="right")
+
+        # Create Progress bar
+        self._progresslabel = Label(
+            progressframe,
+            text="",
+            foreground=self._BACKDROP_COLOR[0],
+            background=self._BACKDROP_COLOR[1],
+        )
+        self._progressbar = Canvas(
+            progressframe,
+            width=200,
+            height=16,
+            background=self._PROGRESS_COLOR[1],
+            relief="sunken",
+            border=1,
+        )
+        self._init_progressbar()
+        self._progressbar.pack(side="right")
+        self._progresslabel.pack(side="left")
+
+    def _init_menu(self):
+        menubar = Menu(self.top)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(
+            label="Download", underline=0, command=self._download, accelerator="Return"
+        )
+        filemenu.add_separator()
+        filemenu.add_command(
+            label="Change Server Index",
+            underline=7,
+            command=lambda: self._info_edit("url"),
+        )
+        filemenu.add_command(
+            label="Change Download Directory",
+            underline=0,
+            command=lambda: self._info_edit("download_dir"),
+        )
+        filemenu.add_separator()
+        filemenu.add_command(label="Show Log", underline=5, command=self._show_log)
+        filemenu.add_separator()
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-x"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        # Create a menu to control which columns of the table are
+        # shown.  n.b.: we never hide the first two columns (mark and
+        # identifier).
+        viewmenu = Menu(menubar, tearoff=0)
+        for column in self._table.column_names[2:]:
+            var = IntVar(self.top)
+            assert column not in self._column_vars
+            self._column_vars[column] = var
+            if column in self.INITIAL_COLUMNS:
+                var.set(1)
+            viewmenu.add_checkbutton(
+                label=column, underline=0, variable=var, command=self._select_columns
+            )
+        menubar.add_cascade(label="View", underline=0, menu=viewmenu)
+
+        # Create a sort menu
+        # [xx] this should be selectbuttons; and it should include
+        # reversed sorts as options.
+        sortmenu = Menu(menubar, tearoff=0)
+        for column in self._table.column_names[1:]:
+            sortmenu.add_command(
+                label="Sort by %s" % column,
+                command=(lambda c=column: self._table.sort_by(c, "ascending")),
+            )
+        sortmenu.add_separator()
+        # sortmenu.add_command(label='Descending Sort:')
+        for column in self._table.column_names[1:]:
+            sortmenu.add_command(
+                label="Reverse sort by %s" % column,
+                command=(lambda c=column: self._table.sort_by(c, "descending")),
+            )
+        menubar.add_cascade(label="Sort", underline=0, menu=sortmenu)
+
+        helpmenu = Menu(menubar, tearoff=0)
+        helpmenu.add_command(label="About", underline=0, command=self.about)
+        helpmenu.add_command(
+            label="Instructions", underline=0, command=self.help, accelerator="F1"
+        )
+        menubar.add_cascade(label="Help", underline=0, menu=helpmenu)
+        self.top.bind("<F1>", self.help)
+
+        self.top.config(menu=menubar)
+
+    def _select_columns(self):
+        for (column, var) in self._column_vars.items():
+            if var.get():
+                self._table.show_column(column)
+            else:
+                self._table.hide_column(column)
+
+    def _refresh(self):
+        self._ds.clear_status_cache()
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+        self._table.select(0)
+
+    def _info_edit(self, info_key):
+        self._info_save()  # just in case.
+        (entry, callback) = self._info[info_key]
+        entry["state"] = "normal"
+        entry["relief"] = "sunken"
+        entry.focus()
+
+    def _info_save(self, e=None):
+        focus = self._table
+        for entry, callback in self._info.values():
+            if entry["state"] == "disabled":
+                continue
+            if e is not None and e.widget is entry and e.keysym != "Return":
+                focus = entry
+            else:
+                entry["state"] = "disabled"
+                entry["relief"] = "groove"
+                callback(entry.get())
+        focus.focus()
+
+    def _table_reprfunc(self, row, col, val):
+        if self._table.column_names[col].endswith("Size"):
+            if isinstance(val, str):
+                return "  %s" % val
+            elif val < 1024**2:
+                return "  %.1f KB" % (val / 1024.0**1)
+            elif val < 1024**3:
+                return "  %.1f MB" % (val / 1024.0**2)
+            else:
+                return "  %.1f GB" % (val / 1024.0**3)
+
+        if col in (0, ""):
+            return str(val)
+        else:
+            return "  %s" % val
+
+    def _set_url(self, url):
+        if url == self._ds.url:
+            return
+        try:
+            self._ds.url = url
+            self._fill_table()
+        except OSError as e:
+            showerror("Error Setting Server Index", str(e))
+        self._show_info()
+
+    def _set_download_dir(self, download_dir):
+        if self._ds.download_dir == download_dir:
+            return
+        # check if the dir exists, and if not, ask if we should create it?
+
+        # Clear our status cache, & re-check what's installed
+        self._ds.download_dir = download_dir
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+        self._show_info()
+
+    def _show_info(self):
+        print("showing info", self._ds.url)
+        for entry, cb in self._info.values():
+            entry["state"] = "normal"
+            entry.delete(0, "end")
+        self._info["url"][0].insert(0, self._ds.url)
+        self._info["download_dir"][0].insert(0, self._ds.download_dir)
+        for entry, cb in self._info.values():
+            entry["state"] = "disabled"
+
+    def _prev_tab(self, *e):
+        for i, tab in enumerate(self._tab_names):
+            if tab.lower() == self._tab and i > 0:
+                self._tab = self._tab_names[i - 1].lower()
+                try:
+                    return self._fill_table()
+                except HTTPError as e:
+                    showerror("Error reading from server", e)
+                except URLError as e:
+                    showerror("Error connecting to server", e.reason)
+
+    def _next_tab(self, *e):
+        for i, tab in enumerate(self._tab_names):
+            if tab.lower() == self._tab and i < (len(self._tabs) - 1):
+                self._tab = self._tab_names[i + 1].lower()
+                try:
+                    return self._fill_table()
+                except HTTPError as e:
+                    showerror("Error reading from server", e)
+                except URLError as e:
+                    showerror("Error connecting to server", e.reason)
+
+    def _select_tab(self, event):
+        self._tab = event.widget["text"].lower()
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+
+    _tab = "collections"
+    # _tab = 'corpora'
+    _rows = None
+
+    def _fill_table(self):
+        selected_row = self._table.selected_row()
+        self._table.clear()
+        if self._tab == "all packages":
+            items = self._ds.packages()
+        elif self._tab == "corpora":
+            items = self._ds.corpora()
+        elif self._tab == "models":
+            items = self._ds.models()
+        elif self._tab == "collections":
+            items = self._ds.collections()
+        else:
+            assert 0, "bad tab value %r" % self._tab
+        rows = [self._package_to_columns(item) for item in items]
+        self._table.extend(rows)
+
+        # Highlight the active tab.
+        for tab, label in self._tabs.items():
+            if tab == self._tab:
+                label.configure(
+                    foreground=self._FRONT_TAB_COLOR[0],
+                    background=self._FRONT_TAB_COLOR[1],
+                )
+            else:
+                label.configure(
+                    foreground=self._BACK_TAB_COLOR[0],
+                    background=self._BACK_TAB_COLOR[1],
+                )
+
+        self._table.sort_by("Identifier", order="ascending")
+        self._color_table()
+        self._table.select(selected_row)
+
+        # This is a hack, because the scrollbar isn't updating its
+        # position right -- I'm not sure what the underlying cause is
+        # though.  (This is on OS X w/ python 2.5)  The length of
+        # delay that's necessary seems to depend on how fast the
+        # comptuer is. :-/
+        self.top.after(150, self._table._scrollbar.set, *self._table._mlb.yview())
+        self.top.after(300, self._table._scrollbar.set, *self._table._mlb.yview())
+
+    def _update_table_status(self):
+        for row_num in range(len(self._table)):
+            status = self._ds.status(self._table[row_num, "Identifier"])
+            self._table[row_num, "Status"] = status
+        self._color_table()
+
+    def _download(self, *e):
+        # If we're using threads, then delegate to the threaded
+        # downloader instead.
+        if self._use_threads:
+            return self._download_threaded(*e)
+
+        marked = [
+            self._table[row, "Identifier"]
+            for row in range(len(self._table))
+            if self._table[row, 0] != ""
+        ]
+        selection = self._table.selected_row()
+        if not marked and selection is not None:
+            marked = [self._table[selection, "Identifier"]]
+
+        download_iter = self._ds.incr_download(marked, self._ds.download_dir)
+        self._log_indent = 0
+        self._download_cb(download_iter, marked)
+
+    _DL_DELAY = 10
+
+    def _download_cb(self, download_iter, ids):
+        try:
+            msg = next(download_iter)
+        except StopIteration:
+            # self._fill_table(sort=False)
+            self._update_table_status()
+            afterid = self.top.after(10, self._show_progress, 0)
+            self._afterid["_download_cb"] = afterid
+            return
+
+        def show(s):
+            self._progresslabel["text"] = s
+            self._log(s)
+
+        if isinstance(msg, ProgressMessage):
+            self._show_progress(msg.progress)
+        elif isinstance(msg, ErrorMessage):
+            show(msg.message)
+            if msg.package is not None:
+                self._select(msg.package.id)
+            self._show_progress(None)
+            return  # halt progress.
+        elif isinstance(msg, StartCollectionMessage):
+            show("Downloading collection %s" % msg.collection.id)
+            self._log_indent += 1
+        elif isinstance(msg, StartPackageMessage):
+            show("Downloading package %s" % msg.package.id)
+        elif isinstance(msg, UpToDateMessage):
+            show("Package %s is up-to-date!" % msg.package.id)
+        # elif isinstance(msg, StaleMessage):
+        #    show('Package %s is out-of-date or corrupt' % msg.package.id)
+        elif isinstance(msg, FinishDownloadMessage):
+            show("Finished downloading %r." % msg.package.id)
+        elif isinstance(msg, StartUnzipMessage):
+            show("Unzipping %s" % msg.package.filename)
+        elif isinstance(msg, FinishCollectionMessage):
+            self._log_indent -= 1
+            show("Finished downloading collection %r." % msg.collection.id)
+            self._clear_mark(msg.collection.id)
+        elif isinstance(msg, FinishPackageMessage):
+            self._clear_mark(msg.package.id)
+        afterid = self.top.after(self._DL_DELAY, self._download_cb, download_iter, ids)
+        self._afterid["_download_cb"] = afterid
+
+    def _select(self, id):
+        for row in range(len(self._table)):
+            if self._table[row, "Identifier"] == id:
+                self._table.select(row)
+                return
+
+    def _color_table(self):
+        # Color rows according to status.
+        for row in range(len(self._table)):
+            bg, sbg = self._ROW_COLOR[self._table[row, "Status"]]
+            fg, sfg = ("black", "white")
+            self._table.rowconfig(
+                row,
+                foreground=fg,
+                selectforeground=sfg,
+                background=bg,
+                selectbackground=sbg,
+            )
+            # Color the marked column
+            self._table.itemconfigure(
+                row, 0, foreground=self._MARK_COLOR[0], background=self._MARK_COLOR[1]
+            )
+
+    def _clear_mark(self, id):
+        for row in range(len(self._table)):
+            if self._table[row, "Identifier"] == id:
+                self._table[row, 0] = ""
+
+    def _mark_all(self, *e):
+        for row in range(len(self._table)):
+            self._table[row, 0] = "X"
+
+    def _table_mark(self, *e):
+        selection = self._table.selected_row()
+        if selection >= 0:
+            if self._table[selection][0] != "":
+                self._table[selection, 0] = ""
+            else:
+                self._table[selection, 0] = "X"
+        self._table.select(delta=1)
+
+    def _show_log(self):
+        text = "\n".join(self._log_messages)
+        ShowText(self.top, "NLTK Downloader Log", text)
+
+    def _package_to_columns(self, pkg):
+        """
+        Given a package, return a list of values describing that
+        package, one for each column in ``self.COLUMNS``.
+        """
+        row = []
+        for column_index, column_name in enumerate(self.COLUMNS):
+            if column_index == 0:  # Mark:
+                row.append("")
+            elif column_name == "Identifier":
+                row.append(pkg.id)
+            elif column_name == "Status":
+                row.append(self._ds.status(pkg))
+            else:
+                attr = column_name.lower().replace(" ", "_")
+                row.append(getattr(pkg, attr, "n/a"))
+        return row
+
+    # /////////////////////////////////////////////////////////////////
+    # External Interface
+    # /////////////////////////////////////////////////////////////////
+
+    def destroy(self, *e):
+        if self._destroyed:
+            return
+        self.top.destroy()
+        self._destroyed = True
+
+    def _destroy(self, *e):
+        if self.top is not None:
+            for afterid in self._afterid.values():
+                self.top.after_cancel(afterid)
+
+        # Abort any download in progress.
+        if self._downloading and self._use_threads:
+            self._abort_download()
+
+        # Make sure the garbage collector destroys these now;
+        # otherwise, they may get destroyed when we're not in the main
+        # thread, which would make Tkinter unhappy.
+        self._column_vars.clear()
+
+    def mainloop(self, *args, **kwargs):
+        self.top.mainloop(*args, **kwargs)
+
+    # /////////////////////////////////////////////////////////////////
+    # HELP
+    # /////////////////////////////////////////////////////////////////
+
+    HELP = textwrap.dedent(
+        """\
+    This tool can be used to download a variety of corpora and models
+    that can be used with NLTK.  Each corpus or model is distributed
+    in a single zip file, known as a \"package file.\"  You can
+    download packages individually, or you can download pre-defined
+    collections of packages.
+
+    When you download a package, it will be saved to the \"download
+    directory.\"  A default download directory is chosen when you run
+
+    the downloader; but you may also select a different download
+    directory.  On Windows, the default download directory is
+
+
+    \"package.\"
+
+    The NLTK downloader can be used to download a variety of corpora,
+    models, and other data packages.
+
+    Keyboard shortcuts::
+      [return]\t Download
+      [up]\t Select previous package
+      [down]\t Select next package
+      [left]\t Select previous tab
+      [right]\t Select next tab
+    """
+    )
+
+    def help(self, *e):
+        # The default font's not very legible; try using 'fixed' instead.
+        try:
+            ShowText(
+                self.top,
+                "Help: NLTK Downloader",
+                self.HELP.strip(),
+                width=75,
+                font="fixed",
+            )
+        except:
+            ShowText(self.top, "Help: NLTK Downloader", self.HELP.strip(), width=75)
+
+    def about(self, *e):
+        ABOUT = "NLTK Downloader\n" + "Written by Edward Loper"
+        TITLE = "About: NLTK Downloader"
+        try:
+            from tkinter.messagebox import Message
+
+            Message(message=ABOUT, title=TITLE).show()
+        except ImportError:
+            ShowText(self.top, TITLE, ABOUT)
+
+    # /////////////////////////////////////////////////////////////////
+    # Progress Bar
+    # /////////////////////////////////////////////////////////////////
+
+    _gradient_width = 5
+
+    def _init_progressbar(self):
+        c = self._progressbar
+        width, height = int(c["width"]), int(c["height"])
+        for i in range(0, (int(c["width"]) * 2) // self._gradient_width):
+            c.create_line(
+                i * self._gradient_width + 20,
+                -20,
+                i * self._gradient_width - height - 20,
+                height + 20,
+                width=self._gradient_width,
+                fill="#%02x0000" % (80 + abs(i % 6 - 3) * 12),
+            )
+        c.addtag_all("gradient")
+        c.itemconfig("gradient", state="hidden")
+
+        # This is used to display progress
+        c.addtag_withtag(
+            "redbox", c.create_rectangle(0, 0, 0, 0, fill=self._PROGRESS_COLOR[0])
+        )
+
+    def _show_progress(self, percent):
+        c = self._progressbar
+        if percent is None:
+            c.coords("redbox", 0, 0, 0, 0)
+            c.itemconfig("gradient", state="hidden")
+        else:
+            width, height = int(c["width"]), int(c["height"])
+            x = percent * int(width) // 100 + 1
+            c.coords("redbox", 0, 0, x, height + 1)
+
+    def _progress_alive(self):
+        c = self._progressbar
+        if not self._downloading:
+            c.itemconfig("gradient", state="hidden")
+        else:
+            c.itemconfig("gradient", state="normal")
+            x1, y1, x2, y2 = c.bbox("gradient")
+            if x1 <= -100:
+                c.move("gradient", (self._gradient_width * 6) - 4, 0)
+            else:
+                c.move("gradient", -4, 0)
+            afterid = self.top.after(200, self._progress_alive)
+            self._afterid["_progress_alive"] = afterid
+
+    # /////////////////////////////////////////////////////////////////
+    # Threaded downloader
+    # /////////////////////////////////////////////////////////////////
+
+    def _download_threaded(self, *e):
+        # If the user tries to start a new download while we're already
+        # downloading something, then abort the current download instead.
+        if self._downloading:
+            self._abort_download()
+            return
+
+        # Change the 'download' button to an 'abort' button.
+        self._download_button["text"] = "Cancel"
+
+        marked = [
+            self._table[row, "Identifier"]
+            for row in range(len(self._table))
+            if self._table[row, 0] != ""
+        ]
+        selection = self._table.selected_row()
+        if not marked and selection is not None:
+            marked = [self._table[selection, "Identifier"]]
+
+        # Create a new data server object for the download operation,
+        # just in case the user modifies our data server during the
+        # download (e.g., clicking 'refresh' or editing the index url).
+        ds = Downloader(self._ds.url, self._ds.download_dir)
+
+        # Start downloading in a separate thread.
+        assert self._download_msg_queue == []
+        assert self._download_abort_queue == []
+        self._DownloadThread(
+            ds,
+            marked,
+            self._download_lock,
+            self._download_msg_queue,
+            self._download_abort_queue,
+        ).start()
+
+        # Monitor the download message queue & display its progress.
+        self._log_indent = 0
+        self._downloading = True
+        self._monitor_message_queue()
+
+        # Display an indication that we're still alive and well by
+        # cycling the progress bar.
+        self._progress_alive()
+
+    def _abort_download(self):
+        if self._downloading:
+            self._download_lock.acquire()
+            self._download_abort_queue.append("abort")
+            self._download_lock.release()
+
+    class _DownloadThread(threading.Thread):
+        def __init__(self, data_server, items, lock, message_queue, abort):
+            self.data_server = data_server
+            self.items = items
+            self.lock = lock
+            self.message_queue = message_queue
+            self.abort = abort
+            threading.Thread.__init__(self)
+
+        def run(self):
+            for msg in self.data_server.incr_download(self.items):
+                self.lock.acquire()
+                self.message_queue.append(msg)
+                # Check if we've been told to kill ourselves:
+                if self.abort:
+                    self.message_queue.append("aborted")
+                    self.lock.release()
+                    return
+                self.lock.release()
+            self.lock.acquire()
+            self.message_queue.append("finished")
+            self.lock.release()
+
+    _MONITOR_QUEUE_DELAY = 100
+
+    def _monitor_message_queue(self):
+        def show(s):
+            self._progresslabel["text"] = s
+            self._log(s)
+
+        # Try to acquire the lock; if it's busy, then just try again later.
+        if not self._download_lock.acquire():
+            return
+        for msg in self._download_msg_queue:
+
+            # Done downloading?
+            if msg == "finished" or msg == "aborted":
+                # self._fill_table(sort=False)
+                self._update_table_status()
+                self._downloading = False
+                self._download_button["text"] = "Download"
+                del self._download_msg_queue[:]
+                del self._download_abort_queue[:]
+                self._download_lock.release()
+                if msg == "aborted":
+                    show("Download aborted!")
+                    self._show_progress(None)
+                else:
+                    afterid = self.top.after(100, self._show_progress, None)
+                    self._afterid["_monitor_message_queue"] = afterid
+                return
+
+            # All other messages
+            elif isinstance(msg, ProgressMessage):
+                self._show_progress(msg.progress)
+            elif isinstance(msg, ErrorMessage):
+                show(msg.message)
+                if msg.package is not None:
+                    self._select(msg.package.id)
+                self._show_progress(None)
+                self._downloading = False
+                return  # halt progress.
+            elif isinstance(msg, StartCollectionMessage):
+                show("Downloading collection %r" % msg.collection.id)
+                self._log_indent += 1
+            elif isinstance(msg, StartPackageMessage):
+                self._ds.clear_status_cache(msg.package.id)
+                show("Downloading package %r" % msg.package.id)
+            elif isinstance(msg, UpToDateMessage):
+                show("Package %s is up-to-date!" % msg.package.id)
+            # elif isinstance(msg, StaleMessage):
+            #    show('Package %s is out-of-date or corrupt; updating it' %
+            #         msg.package.id)
+            elif isinstance(msg, FinishDownloadMessage):
+                show("Finished downloading %r." % msg.package.id)
+            elif isinstance(msg, StartUnzipMessage):
+                show("Unzipping %s" % msg.package.filename)
+            elif isinstance(msg, FinishUnzipMessage):
+                show("Finished installing %s" % msg.package.id)
+            elif isinstance(msg, FinishCollectionMessage):
+                self._log_indent -= 1
+                show("Finished downloading collection %r." % msg.collection.id)
+                self._clear_mark(msg.collection.id)
+            elif isinstance(msg, FinishPackageMessage):
+                self._update_table_status()
+                self._clear_mark(msg.package.id)
+
+        # Let the user know when we're aborting a download (but
+        # waiting for a good point to abort it, so we don't end up
+        # with a partially unzipped package or anything like that).
+        if self._download_abort_queue:
+            self._progresslabel["text"] = "Aborting download..."
+
+        # Clear the message queue and then release the lock
+        del self._download_msg_queue[:]
+        self._download_lock.release()
+
+        # Check the queue again after MONITOR_QUEUE_DELAY msec.
+        afterid = self.top.after(self._MONITOR_QUEUE_DELAY, self._monitor_message_queue)
+        self._afterid["_monitor_message_queue"] = afterid
+
+
+######################################################################
+# Helper Functions
+######################################################################
+# [xx] It may make sense to move these to nltk.internals.
+
+
+def md5_hexdigest(file):
+    """
+    Calculate and return the MD5 checksum for a given file.
+    ``file`` may either be a filename or an open stream.
+    """
+    if isinstance(file, str):
+        with open(file, "rb") as infile:
+            return _md5_hexdigest(infile)
+    return _md5_hexdigest(file)
+
+
+def _md5_hexdigest(fp):
+    md5_digest = md5()
+    while True:
+        block = fp.read(1024 * 16)  # 16k blocks
+        if not block:
+            break
+        md5_digest.update(block)
+    return md5_digest.hexdigest()
+
+
+# change this to periodically yield progress messages?
+# [xx] get rid of topdir parameter -- we should be checking
+# this when we build the index, anyway.
+def unzip(filename, root, verbose=True):
+    """
+    Extract the contents of the zip file ``filename`` into the
+    directory ``root``.
+    """
+    for message in _unzip_iter(filename, root, verbose):
+        if isinstance(message, ErrorMessage):
+            raise Exception(message)
+
+
+def _unzip_iter(filename, root, verbose=True):
+    if verbose:
+        sys.stdout.write("Unzipping %s" % os.path.split(filename)[1])
+        sys.stdout.flush()
+
+    try:
+        zf = zipfile.ZipFile(filename)
+    except zipfile.error as e:
+        yield ErrorMessage(filename, "Error with downloaded zip file")
+        return
+    except Exception as e:
+        yield ErrorMessage(filename, e)
+        return
+
+    zf.extractall(root)
+
+    if verbose:
+        print()
+
+
+######################################################################
+# Index Builder
+######################################################################
+# This may move to a different file sometime.
+
+
+def build_index(root, base_url):
+    """
+    Create a new data.xml index file, by combining the xml description
+    files for various packages and collections.  ``root`` should be the
+    path to a directory containing the package xml and zip files; and
+    the collection xml files.  The ``root`` directory is expected to
+    have the following subdirectories::
+
+      root/
+        packages/ .................. subdirectory for packages
+          corpora/ ................. zip & xml files for corpora
+          grammars/ ................ zip & xml files for grammars
+          taggers/ ................. zip & xml files for taggers
+          tokenizers/ .............. zip & xml files for tokenizers
+          etc.
+        collections/ ............... xml files for collections
+
+    For each package, there should be two files: ``package.zip``
+    (where *package* is the package name)
+    which contains the package itself as a compressed zip file; and
+    ``package.xml``, which is an xml description of the package.  The
+    zipfile ``package.zip`` should expand to a single subdirectory
+    named ``package/``.  The base filename ``package`` must match
+    the identifier given in the package's xml file.
+
+    For each collection, there should be a single file ``collection.zip``
+    describing the collection, where *collection* is the name of the collection.
+
+    All identifiers (for both packages and collections) must be unique.
+    """
+    # Find all packages.
+    packages = []
+    for pkg_xml, zf, subdir in _find_packages(os.path.join(root, "packages")):
+        zipstat = os.stat(zf.filename)
+        url = f"{base_url}/{subdir}/{os.path.split(zf.filename)[1]}"
+        unzipped_size = sum(zf_info.file_size for zf_info in zf.infolist())
+
+        # Fill in several fields of the package xml with calculated values.
+        pkg_xml.set("unzipped_size", "%s" % unzipped_size)
+        pkg_xml.set("size", "%s" % zipstat.st_size)
+        pkg_xml.set("checksum", "%s" % md5_hexdigest(zf.filename))
+        pkg_xml.set("subdir", subdir)
+        # pkg_xml.set('svn_revision', _svn_revision(zf.filename))
+        if not pkg_xml.get("url"):
+            pkg_xml.set("url", url)
+
+        # Record the package.
+        packages.append(pkg_xml)
+
+    # Find all collections
+    collections = list(_find_collections(os.path.join(root, "collections")))
+
+    # Check that all UIDs are unique
+    uids = set()
+    for item in packages + collections:
+        if item.get("id") in uids:
+            raise ValueError("Duplicate UID: %s" % item.get("id"))
+        uids.add(item.get("id"))
+
+    # Put it all together
+    top_elt = ElementTree.Element("nltk_data")
+    top_elt.append(ElementTree.Element("packages"))
+    top_elt[0].extend(sorted(packages, key=lambda package: package.get("id")))
+    top_elt.append(ElementTree.Element("collections"))
+    top_elt[1].extend(sorted(collections, key=lambda collection: collection.get("id")))
+
+    _indent_xml(top_elt)
+    return top_elt
+
+
+def _indent_xml(xml, prefix=""):
+    """
+    Helper for ``build_index()``: Given an XML ``ElementTree``, modify it
+    (and its descendents) ``text`` and ``tail`` attributes to generate
+    an indented tree, where each nested element is indented by 2
+    spaces with respect to its parent.
+    """
+    if len(xml) > 0:
+        xml.text = (xml.text or "").strip() + "\n" + prefix + "  "
+        for child in xml:
+            _indent_xml(child, prefix + "  ")
+        for child in xml[:-1]:
+            child.tail = (child.tail or "").strip() + "\n" + prefix + "  "
+        xml[-1].tail = (xml[-1].tail or "").strip() + "\n" + prefix
+
+
+def _check_package(pkg_xml, zipfilename, zf):
+    """
+    Helper for ``build_index()``: Perform some checks to make sure that
+    the given package is consistent.
+    """
+    # The filename must patch the id given in the XML file.
+    uid = os.path.splitext(os.path.split(zipfilename)[1])[0]
+    if pkg_xml.get("id") != uid:
+        raise ValueError(
+            "package identifier mismatch ({} vs {})".format(pkg_xml.get("id"), uid)
+        )
+
+    # Zip file must expand to a subdir whose name matches uid.
+    if sum((name != uid and not name.startswith(uid + "/")) for name in zf.namelist()):
+        raise ValueError(
+            "Zipfile %s.zip does not expand to a single "
+            "subdirectory %s/" % (uid, uid)
+        )
+
+
+# update for git?
+def _svn_revision(filename):
+    """
+    Helper for ``build_index()``: Calculate the subversion revision
+    number for a given file (by using ``subprocess`` to run ``svn``).
+    """
+    p = subprocess.Popen(
+        ["svn", "status", "-v", filename],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    (stdout, stderr) = p.communicate()
+    if p.returncode != 0 or stderr or not stdout:
+        raise ValueError(
+            "Error determining svn_revision for %s: %s"
+            % (os.path.split(filename)[1], textwrap.fill(stderr))
+        )
+    return stdout.split()[2]
+
+
+def _find_collections(root):
+    """
+    Helper for ``build_index()``: Yield a list of ElementTree.Element
+    objects, each holding the xml for a single package collection.
+    """
+    for dirname, _subdirs, files in os.walk(root):
+        for filename in files:
+            if filename.endswith(".xml"):
+                xmlfile = os.path.join(dirname, filename)
+                yield ElementTree.parse(xmlfile).getroot()
+
+
+def _find_packages(root):
+    """
+    Helper for ``build_index()``: Yield a list of tuples
+    ``(pkg_xml, zf, subdir)``, where:
+      - ``pkg_xml`` is an ``ElementTree.Element`` holding the xml for a
+        package
+      - ``zf`` is a ``zipfile.ZipFile`` for the package's contents.
+      - ``subdir`` is the subdirectory (relative to ``root``) where
+        the package was found (e.g. 'corpora' or 'grammars').
+    """
+    from nltk.corpus.reader.util import _path_from
+
+    # Find all packages.
+    packages = []
+    for dirname, subdirs, files in os.walk(root):
+        relpath = "/".join(_path_from(root, dirname))
+        for filename in files:
+            if filename.endswith(".xml"):
+                xmlfilename = os.path.join(dirname, filename)
+                zipfilename = xmlfilename[:-4] + ".zip"
+                try:
+                    zf = zipfile.ZipFile(zipfilename)
+                except Exception as e:
+                    raise ValueError(f"Error reading file {zipfilename!r}!\n{e}") from e
+                try:
+                    pkg_xml = ElementTree.parse(xmlfilename).getroot()
+                except Exception as e:
+                    raise ValueError(f"Error reading file {xmlfilename!r}!\n{e}") from e
+
+                # Check that the UID matches the filename
+                uid = os.path.split(xmlfilename[:-4])[1]
+                if pkg_xml.get("id") != uid:
+                    raise ValueError(
+                        "package identifier mismatch (%s "
+                        "vs %s)" % (pkg_xml.get("id"), uid)
+                    )
+
+                # Check that the zipfile expands to a subdir whose
+                # name matches the uid.
+                if sum(
+                    (name != uid and not name.startswith(uid + "/"))
+                    for name in zf.namelist()
+                ):
+                    raise ValueError(
+                        "Zipfile %s.zip does not expand to a "
+                        "single subdirectory %s/" % (uid, uid)
+                    )
+
+                yield pkg_xml, zf, relpath
+
+            elif filename.endswith(".zip"):
+                # Warn user in case a .xml does not exist for a .zip
+                resourcename = os.path.splitext(filename)[0]
+                xmlfilename = os.path.join(dirname, resourcename + ".xml")
+                if not os.path.exists(xmlfilename):
+                    warnings.warn(
+                        f"{filename} exists, but {resourcename + '.xml'} cannot be found! "
+                        f"This could mean that {resourcename} can not be downloaded.",
+                        stacklevel=2,
+                    )
+
+        # Don't recurse into svn subdirectories:
+        try:
+            subdirs.remove(".svn")
+        except ValueError:
+            pass
+
+
+######################################################################
+# Main:
+######################################################################
+
+# There should be a command-line interface
+
+# Aliases
+_downloader = Downloader()
+download = _downloader.download
+
+
+def download_shell():
+    DownloaderShell(_downloader).run()
+
+
+def download_gui():
+    DownloaderGUI(_downloader).mainloop()
+
+
+def update():
+    _downloader.update()
+
+
+if __name__ == "__main__":
+    from optparse import OptionParser
+
+    parser = OptionParser()
+    parser.add_option(
+        "-d",
+        "--dir",
+        dest="dir",
+        help="download package to directory DIR",
+        metavar="DIR",
+    )
+    parser.add_option(
+        "-q",
+        "--quiet",
+        dest="quiet",
+        action="store_true",
+        default=False,
+        help="work quietly",
+    )
+    parser.add_option(
+        "-f",
+        "--force",
+        dest="force",
+        action="store_true",
+        default=False,
+        help="download even if already installed",
+    )
+    parser.add_option(
+        "-e",
+        "--exit-on-error",
+        dest="halt_on_error",
+        action="store_true",
+        default=False,
+        help="exit if an error occurs",
+    )
+    parser.add_option(
+        "-u",
+        "--url",
+        dest="server_index_url",
+        default=os.environ.get("NLTK_DOWNLOAD_URL"),
+        help="download server index url",
+    )
+
+    (options, args) = parser.parse_args()
+
+    downloader = Downloader(server_index_url=options.server_index_url)
+
+    if args:
+        for pkg_id in args:
+            rv = downloader.download(
+                info_or_id=pkg_id,
+                download_dir=options.dir,
+                quiet=options.quiet,
+                force=options.force,
+                halt_on_error=options.halt_on_error,
+            )
+            if rv == False and options.halt_on_error:
+                break
+    else:
+        downloader.download(
+            download_dir=options.dir,
+            quiet=options.quiet,
+            force=options.force,
+            halt_on_error=options.halt_on_error,
+        )

lib/python3.10/site-packages/nltk/grammar.py

@@ -0,0 +1,1708 @@
+# Natural Language Toolkit: Context Free Grammars
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+#         Edward Loper <edloper@gmail.com>
+#         Jason Narad <jason.narad@gmail.com>
+#         Peter Ljunglöf <peter.ljunglof@heatherleaf.se>
+#         Tom Aarsen <>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+"""
+Basic data classes for representing context free grammars.  A
+"grammar" specifies which trees can represent the structure of a
+given text.  Each of these trees is called a "parse tree" for the
+text (or simply a "parse").  In a "context free" grammar, the set of
+parse trees for any piece of a text can depend only on that piece, and
+not on the rest of the text (i.e., the piece's context).  Context free
+grammars are often used to find possible syntactic structures for
+sentences.  In this context, the leaves of a parse tree are word
+tokens; and the node values are phrasal categories, such as ``NP``
+and ``VP``.
+
+The ``CFG`` class is used to encode context free grammars.  Each
+``CFG`` consists of a start symbol and a set of productions.
+The "start symbol" specifies the root node value for parse trees.  For example,
+the start symbol for syntactic parsing is usually ``S``.  Start
+symbols are encoded using the ``Nonterminal`` class, which is discussed
+below.
+
+A Grammar's "productions" specify what parent-child relationships a parse
+tree can contain.  Each production specifies that a particular
+node can be the parent of a particular set of children.  For example,
+the production ``<S> -> <NP> <VP>`` specifies that an ``S`` node can
+be the parent of an ``NP`` node and a ``VP`` node.
+
+Grammar productions are implemented by the ``Production`` class.
+Each ``Production`` consists of a left hand side and a right hand
+side.  The "left hand side" is a ``Nonterminal`` that specifies the
+node type for a potential parent; and the "right hand side" is a list
+that specifies allowable children for that parent.  This lists
+consists of ``Nonterminals`` and text types: each ``Nonterminal``
+indicates that the corresponding child may be a ``TreeToken`` with the
+specified node type; and each text type indicates that the
+corresponding child may be a ``Token`` with the with that type.
+
+The ``Nonterminal`` class is used to distinguish node values from leaf
+values.  This prevents the grammar from accidentally using a leaf
+value (such as the English word "A") as the node of a subtree.  Within
+a ``CFG``, all node values are wrapped in the ``Nonterminal``
+class. Note, however, that the trees that are specified by the grammar do
+*not* include these ``Nonterminal`` wrappers.
+
+Grammars can also be given a more procedural interpretation.  According to
+this interpretation, a Grammar specifies any tree structure *tree* that
+can be produced by the following procedure:
+
+| Set tree to the start symbol
+| Repeat until tree contains no more nonterminal leaves:
+|   Choose a production prod with whose left hand side
+|     lhs is a nonterminal leaf of tree.
+|   Replace the nonterminal leaf with a subtree, whose node
+|     value is the value wrapped by the nonterminal lhs, and
+|     whose children are the right hand side of prod.
+
+The operation of replacing the left hand side (*lhs*) of a production
+with the right hand side (*rhs*) in a tree (*tree*) is known as
+"expanding" *lhs* to *rhs* in *tree*.
+"""
+import re
+from functools import total_ordering
+
+from nltk.featstruct import SLASH, TYPE, FeatDict, FeatStruct, FeatStructReader
+from nltk.internals import raise_unorderable_types
+from nltk.probability import ImmutableProbabilisticMixIn
+from nltk.util import invert_graph, transitive_closure
+
+#################################################################
+# Nonterminal
+#################################################################
+
+
+@total_ordering
+class Nonterminal:
+    """
+    A non-terminal symbol for a context free grammar.  ``Nonterminal``
+    is a wrapper class for node values; it is used by ``Production``
+    objects to distinguish node values from leaf values.
+    The node value that is wrapped by a ``Nonterminal`` is known as its
+    "symbol".  Symbols are typically strings representing phrasal
+    categories (such as ``"NP"`` or ``"VP"``).  However, more complex
+    symbol types are sometimes used (e.g., for lexicalized grammars).
+    Since symbols are node values, they must be immutable and
+    hashable.  Two ``Nonterminals`` are considered equal if their
+    symbols are equal.
+
+    :see: ``CFG``, ``Production``
+    :type _symbol: any
+    :ivar _symbol: The node value corresponding to this
+        ``Nonterminal``.  This value must be immutable and hashable.
+    """
+
+    def __init__(self, symbol):
+        """
+        Construct a new non-terminal from the given symbol.
+
+        :type symbol: any
+        :param symbol: The node value corresponding to this
+            ``Nonterminal``.  This value must be immutable and
+            hashable.
+        """
+        self._symbol = symbol
+
+    def symbol(self):
+        """
+        Return the node value corresponding to this ``Nonterminal``.
+
+        :rtype: (any)
+        """
+        return self._symbol
+
+    def __eq__(self, other):
+        """
+        Return True if this non-terminal is equal to ``other``.  In
+        particular, return True if ``other`` is a ``Nonterminal``
+        and this non-terminal's symbol is equal to ``other`` 's symbol.
+
+        :rtype: bool
+        """
+        return type(self) == type(other) and self._symbol == other._symbol
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, Nonterminal):
+            raise_unorderable_types("<", self, other)
+        return self._symbol < other._symbol
+
+    def __hash__(self):
+        return hash(self._symbol)
+
+    def __repr__(self):
+        """
+        Return a string representation for this ``Nonterminal``.
+
+        :rtype: str
+        """
+        if isinstance(self._symbol, str):
+            return "%s" % self._symbol
+        else:
+            return "%s" % repr(self._symbol)
+
+    def __str__(self):
+        """
+        Return a string representation for this ``Nonterminal``.
+
+        :rtype: str
+        """
+        if isinstance(self._symbol, str):
+            return "%s" % self._symbol
+        else:
+            return "%s" % repr(self._symbol)
+
+    def __div__(self, rhs):
+        """
+        Return a new nonterminal whose symbol is ``A/B``, where ``A`` is
+        the symbol for this nonterminal, and ``B`` is the symbol for rhs.
+
+        :param rhs: The nonterminal used to form the right hand side
+            of the new nonterminal.
+        :type rhs: Nonterminal
+        :rtype: Nonterminal
+        """
+        return Nonterminal(f"{self._symbol}/{rhs._symbol}")
+
+    def __truediv__(self, rhs):
+        """
+        Return a new nonterminal whose symbol is ``A/B``, where ``A`` is
+        the symbol for this nonterminal, and ``B`` is the symbol for rhs.
+        This function allows use of the slash ``/`` operator with
+        the future import of division.
+
+        :param rhs: The nonterminal used to form the right hand side
+            of the new nonterminal.
+        :type rhs: Nonterminal
+        :rtype: Nonterminal
+        """
+        return self.__div__(rhs)
+
+
+def nonterminals(symbols):
+    """
+    Given a string containing a list of symbol names, return a list of
+    ``Nonterminals`` constructed from those symbols.
+
+    :param symbols: The symbol name string.  This string can be
+        delimited by either spaces or commas.
+    :type symbols: str
+    :return: A list of ``Nonterminals`` constructed from the symbol
+        names given in ``symbols``.  The ``Nonterminals`` are sorted
+        in the same order as the symbols names.
+    :rtype: list(Nonterminal)
+    """
+    if "," in symbols:
+        symbol_list = symbols.split(",")
+    else:
+        symbol_list = symbols.split()
+    return [Nonterminal(s.strip()) for s in symbol_list]
+
+
+class FeatStructNonterminal(FeatDict, Nonterminal):
+    """A feature structure that's also a nonterminal.  It acts as its
+    own symbol, and automatically freezes itself when hashed."""
+
+    def __hash__(self):
+        self.freeze()
+        return FeatStruct.__hash__(self)
+
+    def symbol(self):
+        return self
+
+
+def is_nonterminal(item):
+    """
+    :return: True if the item is a ``Nonterminal``.
+    :rtype: bool
+    """
+    return isinstance(item, Nonterminal)
+
+
+#################################################################
+# Terminals
+#################################################################
+
+
+def is_terminal(item):
+    """
+    Return True if the item is a terminal, which currently is
+    if it is hashable and not a ``Nonterminal``.
+
+    :rtype: bool
+    """
+    return hasattr(item, "__hash__") and not isinstance(item, Nonterminal)
+
+
+#################################################################
+# Productions
+#################################################################
+
+
+@total_ordering
+class Production:
+    """
+    A grammar production.  Each production maps a single symbol
+    on the "left-hand side" to a sequence of symbols on the
+    "right-hand side".  (In the case of context-free productions,
+    the left-hand side must be a ``Nonterminal``, and the right-hand
+    side is a sequence of terminals and ``Nonterminals``.)
+    "terminals" can be any immutable hashable object that is
+    not a ``Nonterminal``.  Typically, terminals are strings
+    representing words, such as ``"dog"`` or ``"under"``.
+
+    :see: ``CFG``
+    :see: ``DependencyGrammar``
+    :see: ``Nonterminal``
+    :type _lhs: Nonterminal
+    :ivar _lhs: The left-hand side of the production.
+    :type _rhs: tuple(Nonterminal, terminal)
+    :ivar _rhs: The right-hand side of the production.
+    """
+
+    def __init__(self, lhs, rhs):
+        """
+        Construct a new ``Production``.
+
+        :param lhs: The left-hand side of the new ``Production``.
+        :type lhs: Nonterminal
+        :param rhs: The right-hand side of the new ``Production``.
+        :type rhs: sequence(Nonterminal and terminal)
+        """
+        if isinstance(rhs, str):
+            raise TypeError(
+                "production right hand side should be a list, " "not a string"
+            )
+        self._lhs = lhs
+        self._rhs = tuple(rhs)
+
+    def lhs(self):
+        """
+        Return the left-hand side of this ``Production``.
+
+        :rtype: Nonterminal
+        """
+        return self._lhs
+
+    def rhs(self):
+        """
+        Return the right-hand side of this ``Production``.
+
+        :rtype: sequence(Nonterminal and terminal)
+        """
+        return self._rhs
+
+    def __len__(self):
+        """
+        Return the length of the right-hand side.
+
+        :rtype: int
+        """
+        return len(self._rhs)
+
+    def is_nonlexical(self):
+        """
+        Return True if the right-hand side only contains ``Nonterminals``
+
+        :rtype: bool
+        """
+        return all(is_nonterminal(n) for n in self._rhs)
+
+    def is_lexical(self):
+        """
+        Return True if the right-hand contain at least one terminal token.
+
+        :rtype: bool
+        """
+        return not self.is_nonlexical()
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``Production``.
+
+        :rtype: str
+        """
+        result = "%s -> " % repr(self._lhs)
+        result += " ".join(repr(el) for el in self._rhs)
+        return result
+
+    def __repr__(self):
+        """
+        Return a concise string representation of the ``Production``.
+
+        :rtype: str
+        """
+        return "%s" % self
+
+    def __eq__(self, other):
+        """
+        Return True if this ``Production`` is equal to ``other``.
+
+        :rtype: bool
+        """
+        return (
+            type(self) == type(other)
+            and self._lhs == other._lhs
+            and self._rhs == other._rhs
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, Production):
+            raise_unorderable_types("<", self, other)
+        return (self._lhs, self._rhs) < (other._lhs, other._rhs)
+
+    def __hash__(self):
+        """
+        Return a hash value for the ``Production``.
+
+        :rtype: int
+        """
+        return hash((self._lhs, self._rhs))
+
+
+class DependencyProduction(Production):
+    """
+    A dependency grammar production.  Each production maps a single
+    head word to an unordered list of one or more modifier words.
+    """
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``DependencyProduction``.
+
+        :rtype: str
+        """
+        result = f"'{self._lhs}' ->"
+        for elt in self._rhs:
+            result += f" '{elt}'"
+        return result
+
+
+class ProbabilisticProduction(Production, ImmutableProbabilisticMixIn):
+    """
+    A probabilistic context free grammar production.
+    A PCFG ``ProbabilisticProduction`` is essentially just a ``Production`` that
+    has an associated probability, which represents how likely it is that
+    this production will be used.  In particular, the probability of a
+    ``ProbabilisticProduction`` records the likelihood that its right-hand side is
+    the correct instantiation for any given occurrence of its left-hand side.
+
+    :see: ``Production``
+    """
+
+    def __init__(self, lhs, rhs, **prob):
+        """
+        Construct a new ``ProbabilisticProduction``.
+
+        :param lhs: The left-hand side of the new ``ProbabilisticProduction``.
+        :type lhs: Nonterminal
+        :param rhs: The right-hand side of the new ``ProbabilisticProduction``.
+        :type rhs: sequence(Nonterminal and terminal)
+        :param prob: Probability parameters of the new ``ProbabilisticProduction``.
+        """
+        ImmutableProbabilisticMixIn.__init__(self, **prob)
+        Production.__init__(self, lhs, rhs)
+
+    def __str__(self):
+        return super().__str__() + (
+            " [1.0]" if (self.prob() == 1.0) else " [%g]" % self.prob()
+        )
+
+    def __eq__(self, other):
+        return (
+            type(self) == type(other)
+            and self._lhs == other._lhs
+            and self._rhs == other._rhs
+            and self.prob() == other.prob()
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash((self._lhs, self._rhs, self.prob()))
+
+
+#################################################################
+# Grammars
+#################################################################
+
+
+class CFG:
+    """
+    A context-free grammar.  A grammar consists of a start state and
+    a set of productions.  The set of terminals and nonterminals is
+    implicitly specified by the productions.
+
+    If you need efficient key-based access to productions, you
+    can use a subclass to implement it.
+    """
+
+    def __init__(self, start, productions, calculate_leftcorners=True):
+        """
+        Create a new context-free grammar, from the given start state
+        and set of ``Production`` instances.
+
+        :param start: The start symbol
+        :type start: Nonterminal
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        :param calculate_leftcorners: False if we don't want to calculate the
+            leftcorner relation. In that case, some optimized chart parsers won't work.
+        :type calculate_leftcorners: bool
+        """
+        if not is_nonterminal(start):
+            raise TypeError(
+                "start should be a Nonterminal object,"
+                " not a %s" % type(start).__name__
+            )
+
+        self._start = start
+        self._productions = productions
+        self._categories = {prod.lhs() for prod in productions}
+        self._calculate_indexes()
+        self._calculate_grammar_forms()
+        if calculate_leftcorners:
+            self._calculate_leftcorners()
+
+    def _calculate_indexes(self):
+        self._lhs_index = {}
+        self._rhs_index = {}
+        self._empty_index = {}
+        self._lexical_index = {}
+        for prod in self._productions:
+            # Left hand side.
+            lhs = prod._lhs
+            if lhs not in self._lhs_index:
+                self._lhs_index[lhs] = []
+            self._lhs_index[lhs].append(prod)
+            if prod._rhs:
+                # First item in right hand side.
+                rhs0 = prod._rhs[0]
+                if rhs0 not in self._rhs_index:
+                    self._rhs_index[rhs0] = []
+                self._rhs_index[rhs0].append(prod)
+            else:
+                # The right hand side is empty.
+                self._empty_index[prod.lhs()] = prod
+            # Lexical tokens in the right hand side.
+            for token in prod._rhs:
+                if is_terminal(token):
+                    self._lexical_index.setdefault(token, set()).add(prod)
+
+    def _calculate_leftcorners(self):
+        # Calculate leftcorner relations, for use in optimized parsing.
+        self._immediate_leftcorner_categories = {cat: {cat} for cat in self._categories}
+        self._immediate_leftcorner_words = {cat: set() for cat in self._categories}
+        for prod in self.productions():
+            if len(prod) > 0:
+                cat, left = prod.lhs(), prod.rhs()[0]
+                if is_nonterminal(left):
+                    self._immediate_leftcorner_categories[cat].add(left)
+                else:
+                    self._immediate_leftcorner_words[cat].add(left)
+
+        lc = transitive_closure(self._immediate_leftcorner_categories, reflexive=True)
+        self._leftcorners = lc
+        self._leftcorner_parents = invert_graph(lc)
+
+        nr_leftcorner_categories = sum(
+            map(len, self._immediate_leftcorner_categories.values())
+        )
+        nr_leftcorner_words = sum(map(len, self._immediate_leftcorner_words.values()))
+        if nr_leftcorner_words > nr_leftcorner_categories > 10000:
+            # If the grammar is big, the leftcorner-word dictionary will be too large.
+            # In that case it is better to calculate the relation on demand.
+            self._leftcorner_words = None
+            return
+
+        self._leftcorner_words = {}
+        for cat in self._leftcorners:
+            lefts = self._leftcorners[cat]
+            lc = self._leftcorner_words[cat] = set()
+            for left in lefts:
+                lc.update(self._immediate_leftcorner_words.get(left, set()))
+
+    @classmethod
+    def fromstring(cls, input, encoding=None):
+        """
+        Return the grammar instance corresponding to the input string(s).
+
+        :param input: a grammar, either in the form of a string or as a list of strings.
+        """
+        start, productions = read_grammar(
+            input, standard_nonterm_parser, encoding=encoding
+        )
+        return cls(start, productions)
+
+    def start(self):
+        """
+        Return the start symbol of the grammar
+
+        :rtype: Nonterminal
+        """
+        return self._start
+
+    # tricky to balance readability and efficiency here!
+    # can't use set operations as they don't preserve ordering
+    def productions(self, lhs=None, rhs=None, empty=False):
+        """
+        Return the grammar productions, filtered by the left-hand side
+        or the first item in the right-hand side.
+
+        :param lhs: Only return productions with the given left-hand side.
+        :param rhs: Only return productions with the given first item
+            in the right-hand side.
+        :param empty: Only return productions with an empty right-hand side.
+        :return: A list of productions matching the given constraints.
+        :rtype: list(Production)
+        """
+        if rhs and empty:
+            raise ValueError(
+                "You cannot select empty and non-empty " "productions at the same time."
+            )
+
+        # no constraints so return everything
+        if not lhs and not rhs:
+            if not empty:
+                return self._productions
+            else:
+                return self._empty_index.values()
+
+        # only lhs specified so look up its index
+        elif lhs and not rhs:
+            if not empty:
+                return self._lhs_index.get(lhs, [])
+            elif lhs in self._empty_index:
+                return [self._empty_index[lhs]]
+            else:
+                return []
+
+        # only rhs specified so look up its index
+        elif rhs and not lhs:
+            return self._rhs_index.get(rhs, [])
+
+        # intersect
+        else:
+            return [
+                prod
+                for prod in self._lhs_index.get(lhs, [])
+                if prod in self._rhs_index.get(rhs, [])
+            ]
+
+    def leftcorners(self, cat):
+        """
+        Return the set of all nonterminals that the given nonterminal
+        can start with, including itself.
+
+        This is the reflexive, transitive closure of the immediate
+        leftcorner relation:  (A > B)  iff  (A -> B beta)
+
+        :param cat: the parent of the leftcorners
+        :type cat: Nonterminal
+        :return: the set of all leftcorners
+        :rtype: set(Nonterminal)
+        """
+        return self._leftcorners.get(cat, {cat})
+
+    def is_leftcorner(self, cat, left):
+        """
+        True if left is a leftcorner of cat, where left can be a
+        terminal or a nonterminal.
+
+        :param cat: the parent of the leftcorner
+        :type cat: Nonterminal
+        :param left: the suggested leftcorner
+        :type left: Terminal or Nonterminal
+        :rtype: bool
+        """
+        if is_nonterminal(left):
+            return left in self.leftcorners(cat)
+        elif self._leftcorner_words:
+            return left in self._leftcorner_words.get(cat, set())
+        else:
+            return any(
+                left in self._immediate_leftcorner_words.get(parent, set())
+                for parent in self.leftcorners(cat)
+            )
+
+    def leftcorner_parents(self, cat):
+        """
+        Return the set of all nonterminals for which the given category
+        is a left corner. This is the inverse of the leftcorner relation.
+
+        :param cat: the suggested leftcorner
+        :type cat: Nonterminal
+        :return: the set of all parents to the leftcorner
+        :rtype: set(Nonterminal)
+        """
+        return self._leftcorner_parents.get(cat, {cat})
+
+    def check_coverage(self, tokens):
+        """
+        Check whether the grammar rules cover the given list of tokens.
+        If not, then raise an exception.
+
+        :type tokens: list(str)
+        """
+        missing = [tok for tok in tokens if not self._lexical_index.get(tok)]
+        if missing:
+            missing = ", ".join(f"{w!r}" for w in missing)
+            raise ValueError(
+                "Grammar does not cover some of the " "input words: %r." % missing
+            )
+
+    def _calculate_grammar_forms(self):
+        """
+        Pre-calculate of which form(s) the grammar is.
+        """
+        prods = self._productions
+        self._is_lexical = all(p.is_lexical() for p in prods)
+        self._is_nonlexical = all(p.is_nonlexical() for p in prods if len(p) != 1)
+        self._min_len = min(len(p) for p in prods)
+        self._max_len = max(len(p) for p in prods)
+        self._all_unary_are_lexical = all(p.is_lexical() for p in prods if len(p) == 1)
+
+    def is_lexical(self):
+        """
+        Return True if all productions are lexicalised.
+        """
+        return self._is_lexical
+
+    def is_nonlexical(self):
+        """
+        Return True if all lexical rules are "preterminals", that is,
+        unary rules which can be separated in a preprocessing step.
+
+        This means that all productions are of the forms
+        A -> B1 ... Bn (n>=0), or A -> "s".
+
+        Note: is_lexical() and is_nonlexical() are not opposites.
+        There are grammars which are neither, and grammars which are both.
+        """
+        return self._is_nonlexical
+
+    def min_len(self):
+        """
+        Return the right-hand side length of the shortest grammar production.
+        """
+        return self._min_len
+
+    def max_len(self):
+        """
+        Return the right-hand side length of the longest grammar production.
+        """
+        return self._max_len
+
+    def is_nonempty(self):
+        """
+        Return True if there are no empty productions.
+        """
+        return self._min_len > 0
+
+    def is_binarised(self):
+        """
+        Return True if all productions are at most binary.
+        Note that there can still be empty and unary productions.
+        """
+        return self._max_len <= 2
+
+    def is_flexible_chomsky_normal_form(self):
+        """
+        Return True if all productions are of the forms
+        A -> B C, A -> B, or A -> "s".
+        """
+        return self.is_nonempty() and self.is_nonlexical() and self.is_binarised()
+
+    def is_chomsky_normal_form(self):
+        """
+        Return True if the grammar is of Chomsky Normal Form, i.e. all productions
+        are of the form A -> B C, or A -> "s".
+        """
+        return self.is_flexible_chomsky_normal_form() and self._all_unary_are_lexical
+
+    def chomsky_normal_form(self, new_token_padding="@$@", flexible=False):
+        """
+        Returns a new Grammar that is in chomsky normal
+
+        :param: new_token_padding
+            Customise new rule formation during binarisation
+        """
+        if self.is_chomsky_normal_form():
+            return self
+        if self.productions(empty=True):
+            raise ValueError(
+                "Grammar has Empty rules. " "Cannot deal with them at the moment"
+            )
+
+        # check for mixed rules
+        for rule in self.productions():
+            if rule.is_lexical() and len(rule.rhs()) > 1:
+                raise ValueError(
+                    f"Cannot handled mixed rule {rule.lhs()} => {rule.rhs()}"
+                )
+
+        step1 = CFG.eliminate_start(self)
+        step2 = CFG.binarize(step1, new_token_padding)
+        if flexible:
+            return step2
+        step3 = CFG.remove_unitary_rules(step2)
+        step4 = CFG(step3.start(), list(set(step3.productions())))
+        return step4
+
+    @classmethod
+    def remove_unitary_rules(cls, grammar):
+        """
+        Remove nonlexical unitary rules and convert them to
+        lexical
+        """
+        result = []
+        unitary = []
+        for rule in grammar.productions():
+            if len(rule) == 1 and rule.is_nonlexical():
+                unitary.append(rule)
+            else:
+                result.append(rule)
+
+        while unitary:
+            rule = unitary.pop(0)
+            for item in grammar.productions(lhs=rule.rhs()[0]):
+                new_rule = Production(rule.lhs(), item.rhs())
+                if len(new_rule) != 1 or new_rule.is_lexical():
+                    result.append(new_rule)
+                else:
+                    unitary.append(new_rule)
+
+        n_grammar = CFG(grammar.start(), result)
+        return n_grammar
+
+    @classmethod
+    def binarize(cls, grammar, padding="@$@"):
+        """
+        Convert all non-binary rules into binary by introducing
+        new tokens.
+        Example::
+
+            Original:
+                A => B C D
+            After Conversion:
+                A => B A@$@B
+                A@$@B => C D
+        """
+        result = []
+
+        for rule in grammar.productions():
+            if len(rule.rhs()) > 2:
+                # this rule needs to be broken down
+                left_side = rule.lhs()
+                for k in range(0, len(rule.rhs()) - 2):
+                    tsym = rule.rhs()[k]
+                    new_sym = Nonterminal(left_side.symbol() + padding + tsym.symbol())
+                    new_production = Production(left_side, (tsym, new_sym))
+                    left_side = new_sym
+                    result.append(new_production)
+                last_prd = Production(left_side, rule.rhs()[-2:])
+                result.append(last_prd)
+            else:
+                result.append(rule)
+
+        n_grammar = CFG(grammar.start(), result)
+        return n_grammar
+
+    @classmethod
+    def eliminate_start(cls, grammar):
+        """
+        Eliminate start rule in case it appears on RHS
+        Example: S -> S0 S1 and S0 -> S1 S
+        Then another rule S0_Sigma -> S is added
+        """
+        start = grammar.start()
+        result = []
+        need_to_add = None
+        for rule in grammar.productions():
+            if start in rule.rhs():
+                need_to_add = True
+            result.append(rule)
+        if need_to_add:
+            start = Nonterminal("S0_SIGMA")
+            result.append(Production(start, [grammar.start()]))
+            n_grammar = CFG(start, result)
+            return n_grammar
+        return grammar
+
+    def __repr__(self):
+        return "<Grammar with %d productions>" % len(self._productions)
+
+    def __str__(self):
+        result = "Grammar with %d productions" % len(self._productions)
+        result += " (start state = %r)" % self._start
+        for production in self._productions:
+            result += "\n    %s" % production
+        return result
+
+
+class FeatureGrammar(CFG):
+    """
+    A feature-based grammar.  This is equivalent to a
+    ``CFG`` whose nonterminals are all
+    ``FeatStructNonterminal``.
+
+    A grammar consists of a start state and a set of
+    productions.  The set of terminals and nonterminals
+    is implicitly specified by the productions.
+    """
+
+    def __init__(self, start, productions):
+        """
+        Create a new feature-based grammar, from the given start
+        state and set of ``Productions``.
+
+        :param start: The start symbol
+        :type start: FeatStructNonterminal
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        """
+        CFG.__init__(self, start, productions)
+
+    # The difference with CFG is that the productions are
+    # indexed on the TYPE feature of the nonterminals.
+    # This is calculated by the method _get_type_if_possible().
+
+    def _calculate_indexes(self):
+        self._lhs_index = {}
+        self._rhs_index = {}
+        self._empty_index = {}
+        self._empty_productions = []
+        self._lexical_index = {}
+        for prod in self._productions:
+            # Left hand side.
+            lhs = self._get_type_if_possible(prod._lhs)
+            if lhs not in self._lhs_index:
+                self._lhs_index[lhs] = []
+            self._lhs_index[lhs].append(prod)
+            if prod._rhs:
+                # First item in right hand side.
+                rhs0 = self._get_type_if_possible(prod._rhs[0])
+                if rhs0 not in self._rhs_index:
+                    self._rhs_index[rhs0] = []
+                self._rhs_index[rhs0].append(prod)
+            else:
+                # The right hand side is empty.
+                if lhs not in self._empty_index:
+                    self._empty_index[lhs] = []
+                self._empty_index[lhs].append(prod)
+                self._empty_productions.append(prod)
+            # Lexical tokens in the right hand side.
+            for token in prod._rhs:
+                if is_terminal(token):
+                    self._lexical_index.setdefault(token, set()).add(prod)
+
+    @classmethod
+    def fromstring(
+        cls, input, features=None, logic_parser=None, fstruct_reader=None, encoding=None
+    ):
+        """
+        Return a feature structure based grammar.
+
+        :param input: a grammar, either in the form of a string or else
+        as a list of strings.
+        :param features: a tuple of features (default: SLASH, TYPE)
+        :param logic_parser: a parser for lambda-expressions,
+        by default, ``LogicParser()``
+        :param fstruct_reader: a feature structure parser
+        (only if features and logic_parser is None)
+        """
+        if features is None:
+            features = (SLASH, TYPE)
+
+        if fstruct_reader is None:
+            fstruct_reader = FeatStructReader(
+                features, FeatStructNonterminal, logic_parser=logic_parser
+            )
+        elif logic_parser is not None:
+            raise Exception(
+                "'logic_parser' and 'fstruct_reader' must " "not both be set"
+            )
+
+        start, productions = read_grammar(
+            input, fstruct_reader.read_partial, encoding=encoding
+        )
+        return cls(start, productions)
+
+    def productions(self, lhs=None, rhs=None, empty=False):
+        """
+        Return the grammar productions, filtered by the left-hand side
+        or the first item in the right-hand side.
+
+        :param lhs: Only return productions with the given left-hand side.
+        :param rhs: Only return productions with the given first item
+            in the right-hand side.
+        :param empty: Only return productions with an empty right-hand side.
+        :rtype: list(Production)
+        """
+        if rhs and empty:
+            raise ValueError(
+                "You cannot select empty and non-empty " "productions at the same time."
+            )
+
+        # no constraints so return everything
+        if not lhs and not rhs:
+            if empty:
+                return self._empty_productions
+            else:
+                return self._productions
+
+        # only lhs specified so look up its index
+        elif lhs and not rhs:
+            if empty:
+                return self._empty_index.get(self._get_type_if_possible(lhs), [])
+            else:
+                return self._lhs_index.get(self._get_type_if_possible(lhs), [])
+
+        # only rhs specified so look up its index
+        elif rhs and not lhs:
+            return self._rhs_index.get(self._get_type_if_possible(rhs), [])
+
+        # intersect
+        else:
+            return [
+                prod
+                for prod in self._lhs_index.get(self._get_type_if_possible(lhs), [])
+                if prod in self._rhs_index.get(self._get_type_if_possible(rhs), [])
+            ]
+
+    def leftcorners(self, cat):
+        """
+        Return the set of all words that the given category can start with.
+        Also called the "first set" in compiler construction.
+        """
+        raise NotImplementedError("Not implemented yet")
+
+    def leftcorner_parents(self, cat):
+        """
+        Return the set of all categories for which the given category
+        is a left corner.
+        """
+        raise NotImplementedError("Not implemented yet")
+
+    def _get_type_if_possible(self, item):
+        """
+        Helper function which returns the ``TYPE`` feature of the ``item``,
+        if it exists, otherwise it returns the ``item`` itself
+        """
+        if isinstance(item, dict) and TYPE in item:
+            return FeatureValueType(item[TYPE])
+        else:
+            return item
+
+
+@total_ordering
+class FeatureValueType:
+    """
+    A helper class for ``FeatureGrammars``, designed to be different
+    from ordinary strings.  This is to stop the ``FeatStruct``
+    ``FOO[]`` from being compare equal to the terminal "FOO".
+    """
+
+    def __init__(self, value):
+        self._value = value
+
+    def __repr__(self):
+        return "<%s>" % self._value
+
+    def __eq__(self, other):
+        return type(self) == type(other) and self._value == other._value
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, FeatureValueType):
+            raise_unorderable_types("<", self, other)
+        return self._value < other._value
+
+    def __hash__(self):
+        return hash(self._value)
+
+
+class DependencyGrammar:
+    """
+    A dependency grammar.  A DependencyGrammar consists of a set of
+    productions.  Each production specifies a head/modifier relationship
+    between a pair of words.
+    """
+
+    def __init__(self, productions):
+        """
+        Create a new dependency grammar, from the set of ``Productions``.
+
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        """
+        self._productions = productions
+
+    @classmethod
+    def fromstring(cls, input):
+        productions = []
+        for linenum, line in enumerate(input.split("\n")):
+            line = line.strip()
+            if line.startswith("#") or line == "":
+                continue
+            try:
+                productions += _read_dependency_production(line)
+            except ValueError as e:
+                raise ValueError(f"Unable to parse line {linenum}: {line}") from e
+        if len(productions) == 0:
+            raise ValueError("No productions found!")
+        return cls(productions)
+
+    def contains(self, head, mod):
+        """
+        :param head: A head word.
+        :type head: str
+        :param mod: A mod word, to test as a modifier of 'head'.
+        :type mod: str
+
+        :return: true if this ``DependencyGrammar`` contains a
+            ``DependencyProduction`` mapping 'head' to 'mod'.
+        :rtype: bool
+        """
+        for production in self._productions:
+            for possibleMod in production._rhs:
+                if production._lhs == head and possibleMod == mod:
+                    return True
+        return False
+
+    def __contains__(self, head_mod):
+        """
+        Return True if this ``DependencyGrammar`` contains a
+        ``DependencyProduction`` mapping 'head' to 'mod'.
+
+        :param head_mod: A tuple of a head word and a mod word,
+            to test as a modifier of 'head'.
+        :type head: Tuple[str, str]
+        :rtype: bool
+        """
+        try:
+            head, mod = head_mod
+        except ValueError as e:
+            raise ValueError(
+                "Must use a tuple of strings, e.g. `('price', 'of') in grammar`"
+            ) from e
+        return self.contains(head, mod)
+
+    #   # should be rewritten, the set comp won't work in all comparisons
+    # def contains_exactly(self, head, modlist):
+    #   for production in self._productions:
+    #       if(len(production._rhs) == len(modlist)):
+    #           if(production._lhs == head):
+    #               set1 = Set(production._rhs)
+    #               set2 = Set(modlist)
+    #               if(set1 == set2):
+    #                   return True
+    #   return False
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``DependencyGrammar``
+
+        :rtype: str
+        """
+        str = "Dependency grammar with %d productions" % len(self._productions)
+        for production in self._productions:
+            str += "\n  %s" % production
+        return str
+
+    def __repr__(self):
+        """
+        Return a concise string representation of the ``DependencyGrammar``
+        """
+        return "Dependency grammar with %d productions" % len(self._productions)
+
+
+class ProbabilisticDependencyGrammar:
+    """ """
+
+    def __init__(self, productions, events, tags):
+        self._productions = productions
+        self._events = events
+        self._tags = tags
+
+    def contains(self, head, mod):
+        """
+        Return True if this ``DependencyGrammar`` contains a
+        ``DependencyProduction`` mapping 'head' to 'mod'.
+
+        :param head: A head word.
+        :type head: str
+        :param mod: A mod word, to test as a modifier of 'head'.
+        :type mod: str
+        :rtype: bool
+        """
+        for production in self._productions:
+            for possibleMod in production._rhs:
+                if production._lhs == head and possibleMod == mod:
+                    return True
+        return False
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``ProbabilisticDependencyGrammar``
+
+        :rtype: str
+        """
+        str = "Statistical dependency grammar with %d productions" % len(
+            self._productions
+        )
+        for production in self._productions:
+            str += "\n  %s" % production
+        str += "\nEvents:"
+        for event in self._events:
+            str += "\n  %d:%s" % (self._events[event], event)
+        str += "\nTags:"
+        for tag_word in self._tags:
+            str += f"\n {tag_word}:\t({self._tags[tag_word]})"
+        return str
+
+    def __repr__(self):
+        """
+        Return a concise string representation of the ``ProbabilisticDependencyGrammar``
+        """
+        return "Statistical Dependency grammar with %d productions" % len(
+            self._productions
+        )
+
+
+class PCFG(CFG):
+    """
+    A probabilistic context-free grammar.  A PCFG consists of a
+    start state and a set of productions with probabilities.  The set of
+    terminals and nonterminals is implicitly specified by the productions.
+
+    PCFG productions use the ``ProbabilisticProduction`` class.
+    ``PCFGs`` impose the constraint that the set of productions with
+    any given left-hand-side must have probabilities that sum to 1
+    (allowing for a small margin of error).
+
+    If you need efficient key-based access to productions, you can use
+    a subclass to implement it.
+
+    :type EPSILON: float
+    :cvar EPSILON: The acceptable margin of error for checking that
+        productions with a given left-hand side have probabilities
+        that sum to 1.
+    """
+
+    EPSILON = 0.01
+
+    def __init__(self, start, productions, calculate_leftcorners=True):
+        """
+        Create a new context-free grammar, from the given start state
+        and set of ``ProbabilisticProductions``.
+
+        :param start: The start symbol
+        :type start: Nonterminal
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        :raise ValueError: if the set of productions with any left-hand-side
+            do not have probabilities that sum to a value within
+            EPSILON of 1.
+        :param calculate_leftcorners: False if we don't want to calculate the
+            leftcorner relation. In that case, some optimized chart parsers won't work.
+        :type calculate_leftcorners: bool
+        """
+        CFG.__init__(self, start, productions, calculate_leftcorners)
+
+        # Make sure that the probabilities sum to one.
+        probs = {}
+        for production in productions:
+            probs[production.lhs()] = probs.get(production.lhs(), 0) + production.prob()
+        for (lhs, p) in probs.items():
+            if not ((1 - PCFG.EPSILON) < p < (1 + PCFG.EPSILON)):
+                raise ValueError("Productions for %r do not sum to 1" % lhs)
+
+    @classmethod
+    def fromstring(cls, input, encoding=None):
+        """
+        Return a probabilistic context-free grammar corresponding to the
+        input string(s).
+
+        :param input: a grammar, either in the form of a string or else
+             as a list of strings.
+        """
+        start, productions = read_grammar(
+            input, standard_nonterm_parser, probabilistic=True, encoding=encoding
+        )
+        return cls(start, productions)
+
+
+#################################################################
+# Inducing Grammars
+#################################################################
+
+# Contributed by Nathan Bodenstab <bodenstab@cslu.ogi.edu>
+
+
+def induce_pcfg(start, productions):
+    r"""
+    Induce a PCFG grammar from a list of productions.
+
+    The probability of a production A -> B C in a PCFG is:
+
+    |                count(A -> B C)
+    |  P(B, C | A) = ---------------       where \* is any right hand side
+    |                 count(A -> \*)
+
+    :param start: The start symbol
+    :type start: Nonterminal
+    :param productions: The list of productions that defines the grammar
+    :type productions: list(Production)
+    """
+    # Production count: the number of times a given production occurs
+    pcount = {}
+
+    # LHS-count: counts the number of times a given lhs occurs
+    lcount = {}
+
+    for prod in productions:
+        lcount[prod.lhs()] = lcount.get(prod.lhs(), 0) + 1
+        pcount[prod] = pcount.get(prod, 0) + 1
+
+    prods = [
+        ProbabilisticProduction(p.lhs(), p.rhs(), prob=pcount[p] / lcount[p.lhs()])
+        for p in pcount
+    ]
+    return PCFG(start, prods)
+
+
+#################################################################
+# Helper functions for reading productions
+#################################################################
+
+
+def _read_cfg_production(input):
+    """
+    Return a list of context-free ``Productions``.
+    """
+    return _read_production(input, standard_nonterm_parser)
+
+
+def _read_pcfg_production(input):
+    """
+    Return a list of PCFG ``ProbabilisticProductions``.
+    """
+    return _read_production(input, standard_nonterm_parser, probabilistic=True)
+
+
+def _read_fcfg_production(input, fstruct_reader):
+    """
+    Return a list of feature-based ``Productions``.
+    """
+    return _read_production(input, fstruct_reader)
+
+
+# Parsing generic grammars
+
+_ARROW_RE = re.compile(r"\s* -> \s*", re.VERBOSE)
+_PROBABILITY_RE = re.compile(r"( \[ [\d\.]+ \] ) \s*", re.VERBOSE)
+_TERMINAL_RE = re.compile(r'( "[^"]*" | \'[^\']*\' ) \s*', re.VERBOSE)
+_DISJUNCTION_RE = re.compile(r"\| \s*", re.VERBOSE)
+
+
+def _read_production(line, nonterm_parser, probabilistic=False):
+    """
+    Parse a grammar rule, given as a string, and return
+    a list of productions.
+    """
+    pos = 0
+
+    # Parse the left-hand side.
+    lhs, pos = nonterm_parser(line, pos)
+
+    # Skip over the arrow.
+    m = _ARROW_RE.match(line, pos)
+    if not m:
+        raise ValueError("Expected an arrow")
+    pos = m.end()
+
+    # Parse the right hand side.
+    probabilities = [0.0]
+    rhsides = [[]]
+    while pos < len(line):
+        # Probability.
+        m = _PROBABILITY_RE.match(line, pos)
+        if probabilistic and m:
+            pos = m.end()
+            probabilities[-1] = float(m.group(1)[1:-1])
+            if probabilities[-1] > 1.0:
+                raise ValueError(
+                    "Production probability %f, "
+                    "should not be greater than 1.0" % (probabilities[-1],)
+                )
+
+        # String -- add terminal.
+        elif line[pos] in "'\"":
+            m = _TERMINAL_RE.match(line, pos)
+            if not m:
+                raise ValueError("Unterminated string")
+            rhsides[-1].append(m.group(1)[1:-1])
+            pos = m.end()
+
+        # Vertical bar -- start new rhside.
+        elif line[pos] == "|":
+            m = _DISJUNCTION_RE.match(line, pos)
+            probabilities.append(0.0)
+            rhsides.append([])
+            pos = m.end()
+
+        # Anything else -- nonterminal.
+        else:
+            nonterm, pos = nonterm_parser(line, pos)
+            rhsides[-1].append(nonterm)
+
+    if probabilistic:
+        return [
+            ProbabilisticProduction(lhs, rhs, prob=probability)
+            for (rhs, probability) in zip(rhsides, probabilities)
+        ]
+    else:
+        return [Production(lhs, rhs) for rhs in rhsides]
+
+
+#################################################################
+# Reading Phrase Structure Grammars
+#################################################################
+
+
+def read_grammar(input, nonterm_parser, probabilistic=False, encoding=None):
+    """
+    Return a pair consisting of a starting category and a list of
+    ``Productions``.
+
+    :param input: a grammar, either in the form of a string or else
+        as a list of strings.
+    :param nonterm_parser: a function for parsing nonterminals.
+        It should take a ``(string, position)`` as argument and
+        return a ``(nonterminal, position)`` as result.
+    :param probabilistic: are the grammar rules probabilistic?
+    :type probabilistic: bool
+    :param encoding: the encoding of the grammar, if it is a binary string
+    :type encoding: str
+    """
+    if encoding is not None:
+        input = input.decode(encoding)
+    if isinstance(input, str):
+        lines = input.split("\n")
+    else:
+        lines = input
+
+    start = None
+    productions = []
+    continue_line = ""
+    for linenum, line in enumerate(lines):
+        line = continue_line + line.strip()
+        if line.startswith("#") or line == "":
+            continue
+        if line.endswith("\\"):
+            continue_line = line[:-1].rstrip() + " "
+            continue
+        continue_line = ""
+        try:
+            if line[0] == "%":
+                directive, args = line[1:].split(None, 1)
+                if directive == "start":
+                    start, pos = nonterm_parser(args, 0)
+                    if pos != len(args):
+                        raise ValueError("Bad argument to start directive")
+                else:
+                    raise ValueError("Bad directive")
+            else:
+                # expand out the disjunctions on the RHS
+                productions += _read_production(line, nonterm_parser, probabilistic)
+        except ValueError as e:
+            raise ValueError(f"Unable to parse line {linenum + 1}: {line}\n{e}") from e
+
+    if not productions:
+        raise ValueError("No productions found!")
+    if not start:
+        start = productions[0].lhs()
+    return (start, productions)
+
+
+_STANDARD_NONTERM_RE = re.compile(r"( [\w/][\w/^<>-]* ) \s*", re.VERBOSE)
+
+
+def standard_nonterm_parser(string, pos):
+    m = _STANDARD_NONTERM_RE.match(string, pos)
+    if not m:
+        raise ValueError("Expected a nonterminal, found: " + string[pos:])
+    return (Nonterminal(m.group(1)), m.end())
+
+
+#################################################################
+# Reading Dependency Grammars
+#################################################################
+
+_READ_DG_RE = re.compile(
+    r"""^\s*                # leading whitespace
+                              ('[^']+')\s*        # single-quoted lhs
+                              (?:[-=]+>)\s*        # arrow
+                              (?:(                 # rhs:
+                                   "[^"]+"         # doubled-quoted terminal
+                                 | '[^']+'         # single-quoted terminal
+                                 | \|              # disjunction
+                                 )
+                                 \s*)              # trailing space
+                                 *$""",  # zero or more copies
+    re.VERBOSE,
+)
+_SPLIT_DG_RE = re.compile(r"""('[^']'|[-=]+>|"[^"]+"|'[^']+'|\|)""")
+
+
+def _read_dependency_production(s):
+    if not _READ_DG_RE.match(s):
+        raise ValueError("Bad production string")
+    pieces = _SPLIT_DG_RE.split(s)
+    pieces = [p for i, p in enumerate(pieces) if i % 2 == 1]
+    lhside = pieces[0].strip("'\"")
+    rhsides = [[]]
+    for piece in pieces[2:]:
+        if piece == "|":
+            rhsides.append([])
+        else:
+            rhsides[-1].append(piece.strip("'\""))
+    return [DependencyProduction(lhside, rhside) for rhside in rhsides]
+
+
+#################################################################
+# Demonstration
+#################################################################
+
+
+def cfg_demo():
+    """
+    A demonstration showing how ``CFGs`` can be created and used.
+    """
+
+    from nltk import CFG, Production, nonterminals
+
+    # Create some nonterminals
+    S, NP, VP, PP = nonterminals("S, NP, VP, PP")
+    N, V, P, Det = nonterminals("N, V, P, Det")
+    VP_slash_NP = VP / NP
+
+    print("Some nonterminals:", [S, NP, VP, PP, N, V, P, Det, VP / NP])
+    print("    S.symbol() =>", repr(S.symbol()))
+    print()
+
+    print(Production(S, [NP]))
+
+    # Create some Grammar Productions
+    grammar = CFG.fromstring(
+        """
+      S -> NP VP
+      PP -> P NP
+      NP -> Det N | NP PP
+      VP -> V NP | VP PP
+      Det -> 'a' | 'the'
+      N -> 'dog' | 'cat'
+      V -> 'chased' | 'sat'
+      P -> 'on' | 'in'
+    """
+    )
+
+    print("A Grammar:", repr(grammar))
+    print("    grammar.start()       =>", repr(grammar.start()))
+    print("    grammar.productions() =>", end=" ")
+    # Use string.replace(...) is to line-wrap the output.
+    print(repr(grammar.productions()).replace(",", ",\n" + " " * 25))
+    print()
+
+
+def pcfg_demo():
+    """
+    A demonstration showing how a ``PCFG`` can be created and used.
+    """
+
+    from nltk import induce_pcfg, treetransforms
+    from nltk.corpus import treebank
+    from nltk.parse import pchart
+
+    toy_pcfg1 = PCFG.fromstring(
+        """
+        S -> NP VP [1.0]
+        NP -> Det N [0.5] | NP PP [0.25] | 'John' [0.1] | 'I' [0.15]
+        Det -> 'the' [0.8] | 'my' [0.2]
+        N -> 'man' [0.5] | 'telescope' [0.5]
+        VP -> VP PP [0.1] | V NP [0.7] | V [0.2]
+        V -> 'ate' [0.35] | 'saw' [0.65]
+        PP -> P NP [1.0]
+        P -> 'with' [0.61] | 'under' [0.39]
+        """
+    )
+
+    toy_pcfg2 = PCFG.fromstring(
+        """
+        S    -> NP VP         [1.0]
+        VP   -> V NP          [.59]
+        VP   -> V             [.40]
+        VP   -> VP PP         [.01]
+        NP   -> Det N         [.41]
+        NP   -> Name          [.28]
+        NP   -> NP PP         [.31]
+        PP   -> P NP          [1.0]
+        V    -> 'saw'         [.21]
+        V    -> 'ate'         [.51]
+        V    -> 'ran'         [.28]
+        N    -> 'boy'         [.11]
+        N    -> 'cookie'      [.12]
+        N    -> 'table'       [.13]
+        N    -> 'telescope'   [.14]
+        N    -> 'hill'        [.5]
+        Name -> 'Jack'        [.52]
+        Name -> 'Bob'         [.48]
+        P    -> 'with'        [.61]
+        P    -> 'under'       [.39]
+        Det  -> 'the'         [.41]
+        Det  -> 'a'           [.31]
+        Det  -> 'my'          [.28]
+        """
+    )
+
+    pcfg_prods = toy_pcfg1.productions()
+
+    pcfg_prod = pcfg_prods[2]
+    print("A PCFG production:", repr(pcfg_prod))
+    print("    pcfg_prod.lhs()  =>", repr(pcfg_prod.lhs()))
+    print("    pcfg_prod.rhs()  =>", repr(pcfg_prod.rhs()))
+    print("    pcfg_prod.prob() =>", repr(pcfg_prod.prob()))
+    print()
+
+    grammar = toy_pcfg2
+    print("A PCFG grammar:", repr(grammar))
+    print("    grammar.start()       =>", repr(grammar.start()))
+    print("    grammar.productions() =>", end=" ")
+    # Use .replace(...) is to line-wrap the output.
+    print(repr(grammar.productions()).replace(",", ",\n" + " " * 26))
+    print()
+
+    # extract productions from three trees and induce the PCFG
+    print("Induce PCFG grammar from treebank data:")
+
+    productions = []
+    item = treebank._fileids[0]
+    for tree in treebank.parsed_sents(item)[:3]:
+        # perform optional tree transformations, e.g.:
+        tree.collapse_unary(collapsePOS=False)
+        tree.chomsky_normal_form(horzMarkov=2)
+
+        productions += tree.productions()
+
+    S = Nonterminal("S")
+    grammar = induce_pcfg(S, productions)
+    print(grammar)
+    print()
+
+    print("Parse sentence using induced grammar:")
+
+    parser = pchart.InsideChartParser(grammar)
+    parser.trace(3)
+
+    # doesn't work as tokens are different:
+    # sent = treebank.tokenized('wsj_0001.mrg')[0]
+
+    sent = treebank.parsed_sents(item)[0].leaves()
+    print(sent)
+    for parse in parser.parse(sent):
+        print(parse)
+
+
+def fcfg_demo():
+    import nltk.data
+
+    g = nltk.data.load("grammars/book_grammars/feat0.fcfg")
+    print(g)
+    print()
+
+
+def dg_demo():
+    """
+    A demonstration showing the creation and inspection of a
+    ``DependencyGrammar``.
+    """
+    grammar = DependencyGrammar.fromstring(
+        """
+    'scratch' -> 'cats' | 'walls'
+    'walls' -> 'the'
+    'cats' -> 'the'
+    """
+    )
+    print(grammar)
+
+
+def sdg_demo():
+    """
+    A demonstration of how to read a string representation of
+    a CoNLL format dependency tree.
+    """
+    from nltk.parse import DependencyGraph
+
+    dg = DependencyGraph(
+        """
+    1   Ze                ze                Pron  Pron  per|3|evofmv|nom                 2   su      _  _
+    2   had               heb               V     V     trans|ovt|1of2of3|ev             0   ROOT    _  _
+    3   met               met               Prep  Prep  voor                             8   mod     _  _
+    4   haar              haar              Pron  Pron  bez|3|ev|neut|attr               5   det     _  _
+    5   moeder            moeder            N     N     soort|ev|neut                    3   obj1    _  _
+    6   kunnen            kan               V     V     hulp|ott|1of2of3|mv              2   vc      _  _
+    7   gaan              ga                V     V     hulp|inf                         6   vc      _  _
+    8   winkelen          winkel            V     V     intrans|inf                      11  cnj     _  _
+    9   ,                 ,                 Punc  Punc  komma                            8   punct   _  _
+    10  zwemmen           zwem              V     V     intrans|inf                      11  cnj     _  _
+    11  of                of                Conj  Conj  neven                            7   vc      _  _
+    12  terrassen         terras            N     N     soort|mv|neut                    11  cnj     _  _
+    13  .                 .                 Punc  Punc  punt                             12  punct   _  _
+    """
+    )
+    tree = dg.tree()
+    print(tree.pprint())
+
+
+def demo():
+    cfg_demo()
+    pcfg_demo()
+    fcfg_demo()
+    dg_demo()
+    sdg_demo()
+
+
+if __name__ == "__main__":
+    demo()
+
+__all__ = [
+    "Nonterminal",
+    "nonterminals",
+    "CFG",
+    "Production",
+    "PCFG",
+    "ProbabilisticProduction",
+    "DependencyGrammar",
+    "DependencyProduction",
+    "ProbabilisticDependencyGrammar",
+    "induce_pcfg",
+    "read_grammar",
+]

lib/python3.10/site-packages/nltk/help.py

@@ -0,0 +1,64 @@
+# Natural Language Toolkit (NLTK) Help
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Authors: Steven Bird <stevenbird1@gmail.com>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Provide structured access to documentation.
+"""
+
+import re
+from textwrap import wrap
+
+from nltk.data import load
+
+
+def brown_tagset(tagpattern=None):
+    _format_tagset("brown_tagset", tagpattern)
+
+
+def claws5_tagset(tagpattern=None):
+    _format_tagset("claws5_tagset", tagpattern)
+
+
+def upenn_tagset(tagpattern=None):
+    _format_tagset("upenn_tagset", tagpattern)
+
+
+#####################################################################
+# UTILITIES
+#####################################################################
+
+
+def _print_entries(tags, tagdict):
+    for tag in tags:
+        entry = tagdict[tag]
+        defn = [tag + ": " + entry[0]]
+        examples = wrap(
+            entry[1], width=75, initial_indent="    ", subsequent_indent="    "
+        )
+        print("\n".join(defn + examples))
+
+
+def _format_tagset(tagset, tagpattern=None):
+    tagdict = load("help/tagsets/" + tagset + ".pickle")
+    if not tagpattern:
+        _print_entries(sorted(tagdict), tagdict)
+    elif tagpattern in tagdict:
+        _print_entries([tagpattern], tagdict)
+    else:
+        tagpattern = re.compile(tagpattern)
+        tags = [tag for tag in sorted(tagdict) if tagpattern.match(tag)]
+        if tags:
+            _print_entries(tags, tagdict)
+        else:
+            print("No matching tags found.")
+
+
+if __name__ == "__main__":
+    brown_tagset(r"NN.*")
+    upenn_tagset(r".*\$")
+    claws5_tagset("UNDEFINED")
+    brown_tagset(r"NN")

lib/python3.10/site-packages/nltk/internals.py

@@ -0,0 +1,1123 @@
+# Natural Language Toolkit: Internal utility functions
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+#         Edward Loper <edloper@gmail.com>
+#         Nitin Madnani <nmadnani@ets.org>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import fnmatch
+import locale
+import os
+import re
+import stat
+import subprocess
+import sys
+import textwrap
+import types
+import warnings
+from xml.etree import ElementTree
+
+##########################################################################
+# Java Via Command-Line
+##########################################################################
+
+_java_bin = None
+_java_options = []
+# [xx] add classpath option to config_java?
+def config_java(bin=None, options=None, verbose=False):
+    """
+    Configure nltk's java interface, by letting nltk know where it can
+    find the Java binary, and what extra options (if any) should be
+    passed to Java when it is run.
+
+    :param bin: The full path to the Java binary.  If not specified,
+        then nltk will search the system for a Java binary; and if
+        one is not found, it will raise a ``LookupError`` exception.
+    :type bin: str
+    :param options: A list of options that should be passed to the
+        Java binary when it is called.  A common value is
+        ``'-Xmx512m'``, which tells Java binary to increase
+        the maximum heap size to 512 megabytes.  If no options are
+        specified, then do not modify the options list.
+    :type options: list(str)
+    """
+    global _java_bin, _java_options
+    _java_bin = find_binary(
+        "java",
+        bin,
+        env_vars=["JAVAHOME", "JAVA_HOME"],
+        verbose=verbose,
+        binary_names=["java.exe"],
+    )
+
+    if options is not None:
+        if isinstance(options, str):
+            options = options.split()
+        _java_options = list(options)
+
+
+def java(cmd, classpath=None, stdin=None, stdout=None, stderr=None, blocking=True):
+    """
+    Execute the given java command, by opening a subprocess that calls
+    Java.  If java has not yet been configured, it will be configured
+    by calling ``config_java()`` with no arguments.
+
+    :param cmd: The java command that should be called, formatted as
+        a list of strings.  Typically, the first string will be the name
+        of the java class; and the remaining strings will be arguments
+        for that java class.
+    :type cmd: list(str)
+
+    :param classpath: A ``':'`` separated list of directories, JAR
+        archives, and ZIP archives to search for class files.
+    :type classpath: str
+
+    :param stdin: Specify the executed program's
+        standard input file handles, respectively.  Valid values are ``subprocess.PIPE``,
+        an existing file descriptor (a positive integer), an existing
+        file object, 'pipe', 'stdout', 'devnull' and None.  ``subprocess.PIPE`` indicates that a
+        new pipe to the child should be created.  With None, no
+        redirection will occur; the child's file handles will be
+        inherited from the parent.  Additionally, stderr can be
+        ``subprocess.STDOUT``, which indicates that the stderr data
+        from the applications should be captured into the same file
+        handle as for stdout.
+
+    :param stdout: Specify the executed program's standard output file
+        handle. See ``stdin`` for valid values.
+
+    :param stderr: Specify the executed program's standard error file
+        handle. See ``stdin`` for valid values.
+
+
+    :param blocking: If ``false``, then return immediately after
+        spawning the subprocess.  In this case, the return value is
+        the ``Popen`` object, and not a ``(stdout, stderr)`` tuple.
+
+    :return: If ``blocking=True``, then return a tuple ``(stdout,
+        stderr)``, containing the stdout and stderr outputs generated
+        by the java command if the ``stdout`` and ``stderr`` parameters
+        were set to ``subprocess.PIPE``; or None otherwise.  If
+        ``blocking=False``, then return a ``subprocess.Popen`` object.
+
+    :raise OSError: If the java command returns a nonzero return code.
+    """
+
+    subprocess_output_dict = {
+        "pipe": subprocess.PIPE,
+        "stdout": subprocess.STDOUT,
+        "devnull": subprocess.DEVNULL,
+    }
+
+    stdin = subprocess_output_dict.get(stdin, stdin)
+    stdout = subprocess_output_dict.get(stdout, stdout)
+    stderr = subprocess_output_dict.get(stderr, stderr)
+
+    if isinstance(cmd, str):
+        raise TypeError("cmd should be a list of strings")
+
+    # Make sure we know where a java binary is.
+    if _java_bin is None:
+        config_java()
+
+    # Set up the classpath.
+    if isinstance(classpath, str):
+        classpaths = [classpath]
+    else:
+        classpaths = list(classpath)
+    classpath = os.path.pathsep.join(classpaths)
+
+    # Construct the full command string.
+    cmd = list(cmd)
+    cmd = ["-cp", classpath] + cmd
+    cmd = [_java_bin] + _java_options + cmd
+
+    # Call java via a subprocess
+    p = subprocess.Popen(cmd, stdin=stdin, stdout=stdout, stderr=stderr)
+    if not blocking:
+        return p
+    (stdout, stderr) = p.communicate()
+
+    # Check the return code.
+    if p.returncode != 0:
+        print(_decode_stdoutdata(stderr))
+        raise OSError("Java command failed : " + str(cmd))
+
+    return (stdout, stderr)
+
+
+######################################################################
+# Parsing
+######################################################################
+
+
+class ReadError(ValueError):
+    """
+    Exception raised by read_* functions when they fail.
+    :param position: The index in the input string where an error occurred.
+    :param expected: What was expected when an error occurred.
+    """
+
+    def __init__(self, expected, position):
+        ValueError.__init__(self, expected, position)
+        self.expected = expected
+        self.position = position
+
+    def __str__(self):
+        return f"Expected {self.expected} at {self.position}"
+
+
+_STRING_START_RE = re.compile(r"[uU]?[rR]?(\"\"\"|\'\'\'|\"|\')")
+
+
+def read_str(s, start_position):
+    """
+    If a Python string literal begins at the specified position in the
+    given string, then return a tuple ``(val, end_position)``
+    containing the value of the string literal and the position where
+    it ends.  Otherwise, raise a ``ReadError``.
+
+    :param s: A string that will be checked to see if within which a
+        Python string literal exists.
+    :type s: str
+
+    :param start_position: The specified beginning position of the string ``s``
+        to begin regex matching.
+    :type start_position: int
+
+    :return: A tuple containing the matched string literal evaluated as a
+        string and the end position of the string literal.
+    :rtype: tuple(str, int)
+
+    :raise ReadError: If the ``_STRING_START_RE`` regex doesn't return a
+        match in ``s`` at ``start_position``, i.e., open quote. If the
+        ``_STRING_END_RE`` regex doesn't return a match in ``s`` at the
+        end of the first match, i.e., close quote.
+    :raise ValueError: If an invalid string (i.e., contains an invalid
+        escape sequence) is passed into the ``eval``.
+
+    :Example:
+
+    >>> from nltk.internals import read_str
+    >>> read_str('"Hello", World!', 0)
+    ('Hello', 7)
+
+    """
+    # Read the open quote, and any modifiers.
+    m = _STRING_START_RE.match(s, start_position)
+    if not m:
+        raise ReadError("open quote", start_position)
+    quotemark = m.group(1)
+
+    # Find the close quote.
+    _STRING_END_RE = re.compile(r"\\|%s" % quotemark)
+    position = m.end()
+    while True:
+        match = _STRING_END_RE.search(s, position)
+        if not match:
+            raise ReadError("close quote", position)
+        if match.group(0) == "\\":
+            position = match.end() + 1
+        else:
+            break
+
+    # Process it, using eval.  Strings with invalid escape sequences
+    # might raise ValueError.
+    try:
+        return eval(s[start_position : match.end()]), match.end()
+    except ValueError as e:
+        raise ReadError("valid escape sequence", start_position) from e
+
+
+_READ_INT_RE = re.compile(r"-?\d+")
+
+
+def read_int(s, start_position):
+    """
+    If an integer begins at the specified position in the given
+    string, then return a tuple ``(val, end_position)`` containing the
+    value of the integer and the position where it ends.  Otherwise,
+    raise a ``ReadError``.
+
+    :param s: A string that will be checked to see if within which a
+        Python integer exists.
+    :type s: str
+
+    :param start_position: The specified beginning position of the string ``s``
+        to begin regex matching.
+    :type start_position: int
+
+    :return: A tuple containing the matched integer casted to an int,
+        and the end position of the int in ``s``.
+    :rtype: tuple(int, int)
+
+    :raise ReadError: If the ``_READ_INT_RE`` regex doesn't return a
+        match in ``s`` at ``start_position``.
+
+    :Example:
+
+    >>> from nltk.internals import read_int
+    >>> read_int('42 is the answer', 0)
+    (42, 2)
+
+    """
+    m = _READ_INT_RE.match(s, start_position)
+    if not m:
+        raise ReadError("integer", start_position)
+    return int(m.group()), m.end()
+
+
+_READ_NUMBER_VALUE = re.compile(r"-?(\d*)([.]?\d*)?")
+
+
+def read_number(s, start_position):
+    """
+    If an integer or float begins at the specified position in the
+    given string, then return a tuple ``(val, end_position)``
+    containing the value of the number and the position where it ends.
+    Otherwise, raise a ``ReadError``.
+
+    :param s: A string that will be checked to see if within which a
+        Python number exists.
+    :type s: str
+
+    :param start_position: The specified beginning position of the string ``s``
+        to begin regex matching.
+    :type start_position: int
+
+    :return: A tuple containing the matched number casted to a ``float``,
+        and the end position of the number in ``s``.
+    :rtype: tuple(float, int)
+
+    :raise ReadError: If the ``_READ_NUMBER_VALUE`` regex doesn't return a
+        match in ``s`` at ``start_position``.
+
+    :Example:
+
+    >>> from nltk.internals import read_number
+    >>> read_number('Pi is 3.14159', 6)
+    (3.14159, 13)
+
+    """
+    m = _READ_NUMBER_VALUE.match(s, start_position)
+    if not m or not (m.group(1) or m.group(2)):
+        raise ReadError("number", start_position)
+    if m.group(2):
+        return float(m.group()), m.end()
+    else:
+        return int(m.group()), m.end()
+
+
+######################################################################
+# Check if a method has been overridden
+######################################################################
+
+
+def overridden(method):
+    """
+    :return: True if ``method`` overrides some method with the same
+        name in a base class.  This is typically used when defining
+        abstract base classes or interfaces, to allow subclasses to define
+        either of two related methods:
+
+        >>> class EaterI:
+        ...     '''Subclass must define eat() or batch_eat().'''
+        ...     def eat(self, food):
+        ...         if overridden(self.batch_eat):
+        ...             return self.batch_eat([food])[0]
+        ...         else:
+        ...             raise NotImplementedError()
+        ...     def batch_eat(self, foods):
+        ...         return [self.eat(food) for food in foods]
+
+    :type method: instance method
+    """
+    if isinstance(method, types.MethodType) and method.__self__.__class__ is not None:
+        name = method.__name__
+        funcs = [
+            cls.__dict__[name]
+            for cls in _mro(method.__self__.__class__)
+            if name in cls.__dict__
+        ]
+        return len(funcs) > 1
+    else:
+        raise TypeError("Expected an instance method.")
+
+
+def _mro(cls):
+    """
+    Return the method resolution order for ``cls`` -- i.e., a list
+    containing ``cls`` and all its base classes, in the order in which
+    they would be checked by ``getattr``.  For new-style classes, this
+    is just cls.__mro__.  For classic classes, this can be obtained by
+    a depth-first left-to-right traversal of ``__bases__``.
+    """
+    if isinstance(cls, type):
+        return cls.__mro__
+    else:
+        mro = [cls]
+        for base in cls.__bases__:
+            mro.extend(_mro(base))
+        return mro
+
+
+######################################################################
+# Deprecation decorator & base class
+######################################################################
+# [xx] dedent msg first if it comes from  a docstring.
+
+
+def _add_epytext_field(obj, field, message):
+    """Add an epytext @field to a given object's docstring."""
+    indent = ""
+    # If we already have a docstring, then add a blank line to separate
+    # it from the new field, and check its indentation.
+    if obj.__doc__:
+        obj.__doc__ = obj.__doc__.rstrip() + "\n\n"
+        indents = re.findall(r"(?<=\n)[ ]+(?!\s)", obj.__doc__.expandtabs())
+        if indents:
+            indent = min(indents)
+    # If we don't have a docstring, add an empty one.
+    else:
+        obj.__doc__ = ""
+
+    obj.__doc__ += textwrap.fill(
+        f"@{field}: {message}",
+        initial_indent=indent,
+        subsequent_indent=indent + "    ",
+    )
+
+
+def deprecated(message):
+    """
+    A decorator used to mark functions as deprecated.  This will cause
+    a warning to be printed the when the function is used.  Usage:
+
+        >>> from nltk.internals import deprecated
+        >>> @deprecated('Use foo() instead')
+        ... def bar(x):
+        ...     print(x/10)
+
+    """
+
+    def decorator(func):
+        msg = f"Function {func.__name__}() has been deprecated.  {message}"
+        msg = "\n" + textwrap.fill(msg, initial_indent="  ", subsequent_indent="  ")
+
+        def newFunc(*args, **kwargs):
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        # Copy the old function's name, docstring, & dict
+        newFunc.__dict__.update(func.__dict__)
+        newFunc.__name__ = func.__name__
+        newFunc.__doc__ = func.__doc__
+        newFunc.__deprecated__ = True
+        # Add a @deprecated field to the docstring.
+        _add_epytext_field(newFunc, "deprecated", message)
+        return newFunc
+
+    return decorator
+
+
+class Deprecated:
+    """
+    A base class used to mark deprecated classes.  A typical usage is to
+    alert users that the name of a class has changed:
+
+        >>> from nltk.internals import Deprecated
+        >>> class NewClassName:
+        ...     pass # All logic goes here.
+        ...
+        >>> class OldClassName(Deprecated, NewClassName):
+        ...     "Use NewClassName instead."
+
+    The docstring of the deprecated class will be used in the
+    deprecation warning message.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        # Figure out which class is the deprecated one.
+        dep_cls = None
+        for base in _mro(cls):
+            if Deprecated in base.__bases__:
+                dep_cls = base
+                break
+        assert dep_cls, "Unable to determine which base is deprecated."
+
+        # Construct an appropriate warning.
+        doc = dep_cls.__doc__ or "".strip()
+        # If there's a @deprecated field, strip off the field marker.
+        doc = re.sub(r"\A\s*@deprecated:", r"", doc)
+        # Strip off any indentation.
+        doc = re.sub(r"(?m)^\s*", "", doc)
+        # Construct a 'name' string.
+        name = "Class %s" % dep_cls.__name__
+        if cls != dep_cls:
+            name += " (base class for %s)" % cls.__name__
+        # Put it all together.
+        msg = f"{name} has been deprecated.  {doc}"
+        # Wrap it.
+        msg = "\n" + textwrap.fill(msg, initial_indent="    ", subsequent_indent="    ")
+        warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+        # Do the actual work of __new__.
+        return object.__new__(cls)
+
+
+##########################################################################
+# COUNTER, FOR UNIQUE NAMING
+##########################################################################
+
+
+class Counter:
+    """
+    A counter that auto-increments each time its value is read.
+    """
+
+    def __init__(self, initial_value=0):
+        self._value = initial_value
+
+    def get(self):
+        self._value += 1
+        return self._value
+
+
+##########################################################################
+# Search for files/binaries
+##########################################################################
+
+
+def find_file_iter(
+    filename,
+    env_vars=(),
+    searchpath=(),
+    file_names=None,
+    url=None,
+    verbose=False,
+    finding_dir=False,
+):
+    """
+    Search for a file to be used by nltk.
+
+    :param filename: The name or path of the file.
+    :param env_vars: A list of environment variable names to check.
+    :param file_names: A list of alternative file names to check.
+    :param searchpath: List of directories to search.
+    :param url: URL presented to user for download help.
+    :param verbose: Whether or not to print path when a file is found.
+    """
+    file_names = [filename] + (file_names or [])
+    assert isinstance(filename, str)
+    assert not isinstance(file_names, str)
+    assert not isinstance(searchpath, str)
+    if isinstance(env_vars, str):
+        env_vars = env_vars.split()
+    yielded = False
+
+    # File exists, no magic
+    for alternative in file_names:
+        path_to_file = os.path.join(filename, alternative)
+        if os.path.isfile(path_to_file):
+            if verbose:
+                print(f"[Found {filename}: {path_to_file}]")
+            yielded = True
+            yield path_to_file
+        # Check the bare alternatives
+        if os.path.isfile(alternative):
+            if verbose:
+                print(f"[Found {filename}: {alternative}]")
+            yielded = True
+            yield alternative
+        # Check if the alternative is inside a 'file' directory
+        path_to_file = os.path.join(filename, "file", alternative)
+        if os.path.isfile(path_to_file):
+            if verbose:
+                print(f"[Found {filename}: {path_to_file}]")
+            yielded = True
+            yield path_to_file
+
+    # Check environment variables
+    for env_var in env_vars:
+        if env_var in os.environ:
+            if finding_dir:  # This is to file a directory instead of file
+                yielded = True
+                yield os.environ[env_var]
+
+            for env_dir in os.environ[env_var].split(os.pathsep):
+                # Check if the environment variable contains a direct path to the bin
+                if os.path.isfile(env_dir):
+                    if verbose:
+                        print(f"[Found {filename}: {env_dir}]")
+                    yielded = True
+                    yield env_dir
+                # Check if the possible bin names exist inside the environment variable directories
+                for alternative in file_names:
+                    path_to_file = os.path.join(env_dir, alternative)
+                    if os.path.isfile(path_to_file):
+                        if verbose:
+                            print(f"[Found {filename}: {path_to_file}]")
+                        yielded = True
+                        yield path_to_file
+                    # Check if the alternative is inside a 'file' directory
+                    # path_to_file = os.path.join(env_dir, 'file', alternative)
+
+                    # Check if the alternative is inside a 'bin' directory
+                    path_to_file = os.path.join(env_dir, "bin", alternative)
+
+                    if os.path.isfile(path_to_file):
+                        if verbose:
+                            print(f"[Found {filename}: {path_to_file}]")
+                        yielded = True
+                        yield path_to_file
+
+    # Check the path list.
+    for directory in searchpath:
+        for alternative in file_names:
+            path_to_file = os.path.join(directory, alternative)
+            if os.path.isfile(path_to_file):
+                yielded = True
+                yield path_to_file
+
+    # If we're on a POSIX system, then try using the 'which' command
+    # to find the file.
+    if os.name == "posix":
+        for alternative in file_names:
+            try:
+                p = subprocess.Popen(
+                    ["which", alternative],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                stdout, stderr = p.communicate()
+                path = _decode_stdoutdata(stdout).strip()
+                if path.endswith(alternative) and os.path.exists(path):
+                    if verbose:
+                        print(f"[Found {filename}: {path}]")
+                    yielded = True
+                    yield path
+            except (KeyboardInterrupt, SystemExit, OSError):
+                raise
+            finally:
+                pass
+
+    if not yielded:
+        msg = (
+            "NLTK was unable to find the %s file!"
+            "\nUse software specific "
+            "configuration parameters" % filename
+        )
+        if env_vars:
+            msg += " or set the %s environment variable" % env_vars[0]
+        msg += "."
+        if searchpath:
+            msg += "\n\n  Searched in:"
+            msg += "".join("\n    - %s" % d for d in searchpath)
+        if url:
+            msg += f"\n\n  For more information on {filename}, see:\n    <{url}>"
+        div = "=" * 75
+        raise LookupError(f"\n\n{div}\n{msg}\n{div}")
+
+
+def find_file(
+    filename, env_vars=(), searchpath=(), file_names=None, url=None, verbose=False
+):
+    return next(
+        find_file_iter(filename, env_vars, searchpath, file_names, url, verbose)
+    )
+
+
+def find_dir(
+    filename, env_vars=(), searchpath=(), file_names=None, url=None, verbose=False
+):
+    return next(
+        find_file_iter(
+            filename, env_vars, searchpath, file_names, url, verbose, finding_dir=True
+        )
+    )
+
+
+def find_binary_iter(
+    name,
+    path_to_bin=None,
+    env_vars=(),
+    searchpath=(),
+    binary_names=None,
+    url=None,
+    verbose=False,
+):
+    """
+    Search for a file to be used by nltk.
+
+    :param name: The name or path of the file.
+    :param path_to_bin: The user-supplied binary location (deprecated)
+    :param env_vars: A list of environment variable names to check.
+    :param file_names: A list of alternative file names to check.
+    :param searchpath: List of directories to search.
+    :param url: URL presented to user for download help.
+    :param verbose: Whether or not to print path when a file is found.
+    """
+    yield from find_file_iter(
+        path_to_bin or name, env_vars, searchpath, binary_names, url, verbose
+    )
+
+
+def find_binary(
+    name,
+    path_to_bin=None,
+    env_vars=(),
+    searchpath=(),
+    binary_names=None,
+    url=None,
+    verbose=False,
+):
+    return next(
+        find_binary_iter(
+            name, path_to_bin, env_vars, searchpath, binary_names, url, verbose
+        )
+    )
+
+
+def find_jar_iter(
+    name_pattern,
+    path_to_jar=None,
+    env_vars=(),
+    searchpath=(),
+    url=None,
+    verbose=False,
+    is_regex=False,
+):
+    """
+    Search for a jar that is used by nltk.
+
+    :param name_pattern: The name of the jar file
+    :param path_to_jar: The user-supplied jar location, or None.
+    :param env_vars: A list of environment variable names to check
+                     in addition to the CLASSPATH variable which is
+                     checked by default.
+    :param searchpath: List of directories to search.
+    :param is_regex: Whether name is a regular expression.
+    """
+
+    assert isinstance(name_pattern, str)
+    assert not isinstance(searchpath, str)
+    if isinstance(env_vars, str):
+        env_vars = env_vars.split()
+    yielded = False
+
+    # Make sure we check the CLASSPATH first
+    env_vars = ["CLASSPATH"] + list(env_vars)
+
+    # If an explicit location was given, then check it, and yield it if
+    # it's present; otherwise, complain.
+    if path_to_jar is not None:
+        if os.path.isfile(path_to_jar):
+            yielded = True
+            yield path_to_jar
+        else:
+            raise LookupError(
+                f"Could not find {name_pattern} jar file at {path_to_jar}"
+            )
+
+    # Check environment variables
+    for env_var in env_vars:
+        if env_var in os.environ:
+            if env_var == "CLASSPATH":
+                classpath = os.environ["CLASSPATH"]
+                for cp in classpath.split(os.path.pathsep):
+                    cp = os.path.expanduser(cp)
+                    if os.path.isfile(cp):
+                        filename = os.path.basename(cp)
+                        if (
+                            is_regex
+                            and re.match(name_pattern, filename)
+                            or (not is_regex and filename == name_pattern)
+                        ):
+                            if verbose:
+                                print(f"[Found {name_pattern}: {cp}]")
+                            yielded = True
+                            yield cp
+                    # The case where user put directory containing the jar file in the classpath
+                    if os.path.isdir(cp):
+                        if not is_regex:
+                            if os.path.isfile(os.path.join(cp, name_pattern)):
+                                if verbose:
+                                    print(f"[Found {name_pattern}: {cp}]")
+                                yielded = True
+                                yield os.path.join(cp, name_pattern)
+                        else:
+                            # Look for file using regular expression
+                            for file_name in os.listdir(cp):
+                                if re.match(name_pattern, file_name):
+                                    if verbose:
+                                        print(
+                                            "[Found %s: %s]"
+                                            % (
+                                                name_pattern,
+                                                os.path.join(cp, file_name),
+                                            )
+                                        )
+                                    yielded = True
+                                    yield os.path.join(cp, file_name)
+
+            else:
+                jar_env = os.path.expanduser(os.environ[env_var])
+                jar_iter = (
+                    (
+                        os.path.join(jar_env, path_to_jar)
+                        for path_to_jar in os.listdir(jar_env)
+                    )
+                    if os.path.isdir(jar_env)
+                    else (jar_env,)
+                )
+                for path_to_jar in jar_iter:
+                    if os.path.isfile(path_to_jar):
+                        filename = os.path.basename(path_to_jar)
+                        if (
+                            is_regex
+                            and re.match(name_pattern, filename)
+                            or (not is_regex and filename == name_pattern)
+                        ):
+                            if verbose:
+                                print(f"[Found {name_pattern}: {path_to_jar}]")
+                            yielded = True
+                            yield path_to_jar
+
+    # Check the path list.
+    for directory in searchpath:
+        if is_regex:
+            for filename in os.listdir(directory):
+                path_to_jar = os.path.join(directory, filename)
+                if os.path.isfile(path_to_jar):
+                    if re.match(name_pattern, filename):
+                        if verbose:
+                            print(f"[Found {filename}: {path_to_jar}]")
+                yielded = True
+                yield path_to_jar
+        else:
+            path_to_jar = os.path.join(directory, name_pattern)
+            if os.path.isfile(path_to_jar):
+                if verbose:
+                    print(f"[Found {name_pattern}: {path_to_jar}]")
+                yielded = True
+                yield path_to_jar
+
+    if not yielded:
+        # If nothing was found, raise an error
+        msg = "NLTK was unable to find %s!" % name_pattern
+        if env_vars:
+            msg += " Set the %s environment variable" % env_vars[0]
+        msg = textwrap.fill(msg + ".", initial_indent="  ", subsequent_indent="  ")
+        if searchpath:
+            msg += "\n\n  Searched in:"
+            msg += "".join("\n    - %s" % d for d in searchpath)
+        if url:
+            msg += "\n\n  For more information, on {}, see:\n    <{}>".format(
+                name_pattern,
+                url,
+            )
+        div = "=" * 75
+        raise LookupError(f"\n\n{div}\n{msg}\n{div}")
+
+
+def find_jar(
+    name_pattern,
+    path_to_jar=None,
+    env_vars=(),
+    searchpath=(),
+    url=None,
+    verbose=False,
+    is_regex=False,
+):
+    return next(
+        find_jar_iter(
+            name_pattern, path_to_jar, env_vars, searchpath, url, verbose, is_regex
+        )
+    )
+
+
+def find_jars_within_path(path_to_jars):
+    return [
+        os.path.join(root, filename)
+        for root, dirnames, filenames in os.walk(path_to_jars)
+        for filename in fnmatch.filter(filenames, "*.jar")
+    ]
+
+
+def _decode_stdoutdata(stdoutdata):
+    """Convert data read from stdout/stderr to unicode"""
+    if not isinstance(stdoutdata, bytes):
+        return stdoutdata
+
+    encoding = getattr(sys.__stdout__, "encoding", locale.getpreferredencoding())
+    if encoding is None:
+        return stdoutdata.decode()
+    return stdoutdata.decode(encoding)
+
+
+##########################################################################
+# Import Stdlib Module
+##########################################################################
+
+
+def import_from_stdlib(module):
+    """
+    When python is run from within the nltk/ directory tree, the
+    current directory is included at the beginning of the search path.
+    Unfortunately, that means that modules within nltk can sometimes
+    shadow standard library modules.  As an example, the stdlib
+    'inspect' module will attempt to import the stdlib 'tokenize'
+    module, but will instead end up importing NLTK's 'tokenize' module
+    instead (causing the import to fail).
+    """
+    old_path = sys.path
+    sys.path = [d for d in sys.path if d not in ("", ".")]
+    m = __import__(module)
+    sys.path = old_path
+    return m
+
+
+##########################################################################
+# Wrapper for ElementTree Elements
+##########################################################################
+
+
+class ElementWrapper:
+    """
+    A wrapper around ElementTree Element objects whose main purpose is
+    to provide nicer __repr__ and __str__ methods.  In addition, any
+    of the wrapped Element's methods that return other Element objects
+    are overridden to wrap those values before returning them.
+
+    This makes Elements more convenient to work with in
+    interactive sessions and doctests, at the expense of some
+    efficiency.
+    """
+
+    # Prevent double-wrapping:
+    def __new__(cls, etree):
+        """
+        Create and return a wrapper around a given Element object.
+        If ``etree`` is an ``ElementWrapper``, then ``etree`` is
+        returned as-is.
+        """
+        if isinstance(etree, ElementWrapper):
+            return etree
+        else:
+            return object.__new__(ElementWrapper)
+
+    def __init__(self, etree):
+        r"""
+        Initialize a new Element wrapper for ``etree``.
+
+        If ``etree`` is a string, then it will be converted to an
+        Element object using ``ElementTree.fromstring()`` first:
+
+            >>> ElementWrapper("<test></test>")
+            <Element "<?xml version='1.0' encoding='utf8'?>\n<test />">
+
+        """
+        if isinstance(etree, str):
+            etree = ElementTree.fromstring(etree)
+        self.__dict__["_etree"] = etree
+
+    def unwrap(self):
+        """
+        Return the Element object wrapped by this wrapper.
+        """
+        return self._etree
+
+    ##////////////////////////////////////////////////////////////
+    # { String Representation
+    ##////////////////////////////////////////////////////////////
+
+    def __repr__(self):
+        s = ElementTree.tostring(self._etree, encoding="utf8").decode("utf8")
+        if len(s) > 60:
+            e = s.rfind("<")
+            if (len(s) - e) > 30:
+                e = -20
+            s = f"{s[:30]}...{s[e:]}"
+        return "<Element %r>" % s
+
+    def __str__(self):
+        """
+        :return: the result of applying ``ElementTree.tostring()`` to
+        the wrapped Element object.
+        """
+        return (
+            ElementTree.tostring(self._etree, encoding="utf8").decode("utf8").rstrip()
+        )
+
+    ##////////////////////////////////////////////////////////////
+    # { Element interface Delegation (pass-through)
+    ##////////////////////////////////////////////////////////////
+
+    def __getattr__(self, attrib):
+        return getattr(self._etree, attrib)
+
+    def __setattr__(self, attr, value):
+        return setattr(self._etree, attr, value)
+
+    def __delattr__(self, attr):
+        return delattr(self._etree, attr)
+
+    def __setitem__(self, index, element):
+        self._etree[index] = element
+
+    def __delitem__(self, index):
+        del self._etree[index]
+
+    def __setslice__(self, start, stop, elements):
+        self._etree[start:stop] = elements
+
+    def __delslice__(self, start, stop):
+        del self._etree[start:stop]
+
+    def __len__(self):
+        return len(self._etree)
+
+    ##////////////////////////////////////////////////////////////
+    # { Element interface Delegation (wrap result)
+    ##////////////////////////////////////////////////////////////
+
+    def __getitem__(self, index):
+        return ElementWrapper(self._etree[index])
+
+    def __getslice__(self, start, stop):
+        return [ElementWrapper(elt) for elt in self._etree[start:stop]]
+
+    def getchildren(self):
+        return [ElementWrapper(elt) for elt in self._etree]
+
+    def getiterator(self, tag=None):
+        return (ElementWrapper(elt) for elt in self._etree.getiterator(tag))
+
+    def makeelement(self, tag, attrib):
+        return ElementWrapper(self._etree.makeelement(tag, attrib))
+
+    def find(self, path):
+        elt = self._etree.find(path)
+        if elt is None:
+            return elt
+        else:
+            return ElementWrapper(elt)
+
+    def findall(self, path):
+        return [ElementWrapper(elt) for elt in self._etree.findall(path)]
+
+
+######################################################################
+# Helper for Handling Slicing
+######################################################################
+
+
+def slice_bounds(sequence, slice_obj, allow_step=False):
+    """
+    Given a slice, return the corresponding (start, stop) bounds,
+    taking into account None indices and negative indices.  The
+    following guarantees are made for the returned start and stop values:
+
+      - 0 <= start <= len(sequence)
+      - 0 <= stop <= len(sequence)
+      - start <= stop
+
+    :raise ValueError: If ``slice_obj.step`` is not None.
+    :param allow_step: If true, then the slice object may have a
+        non-None step.  If it does, then return a tuple
+        (start, stop, step).
+    """
+    start, stop = (slice_obj.start, slice_obj.stop)
+
+    # If allow_step is true, then include the step in our return
+    # value tuple.
+    if allow_step:
+        step = slice_obj.step
+        if step is None:
+            step = 1
+        # Use a recursive call without allow_step to find the slice
+        # bounds.  If step is negative, then the roles of start and
+        # stop (in terms of default values, etc), are swapped.
+        if step < 0:
+            start, stop = slice_bounds(sequence, slice(stop, start))
+        else:
+            start, stop = slice_bounds(sequence, slice(start, stop))
+        return start, stop, step
+
+    # Otherwise, make sure that no non-default step value is used.
+    elif slice_obj.step not in (None, 1):
+        raise ValueError(
+            "slices with steps are not supported by %s" % sequence.__class__.__name__
+        )
+
+    # Supply default offsets.
+    if start is None:
+        start = 0
+    if stop is None:
+        stop = len(sequence)
+
+    # Handle negative indices.
+    if start < 0:
+        start = max(0, len(sequence) + start)
+    if stop < 0:
+        stop = max(0, len(sequence) + stop)
+
+    # Make sure stop doesn't go past the end of the list.  Note that
+    # we avoid calculating len(sequence) if possible, because for lazy
+    # sequences, calculating the length of a sequence can be expensive.
+    if stop > 0:
+        try:
+            sequence[stop - 1]
+        except IndexError:
+            stop = len(sequence)
+
+    # Make sure start isn't past stop.
+    start = min(start, stop)
+
+    # That's all folks!
+    return start, stop
+
+
+######################################################################
+# Permission Checking
+######################################################################
+
+
+def is_writable(path):
+    # Ensure that it exists.
+    if not os.path.exists(path):
+        return False
+
+    # If we're on a posix system, check its permissions.
+    if hasattr(os, "getuid"):
+        statdata = os.stat(path)
+        perm = stat.S_IMODE(statdata.st_mode)
+        # is it world-writable?
+        if perm & 0o002:
+            return True
+        # do we own it?
+        elif statdata.st_uid == os.getuid() and (perm & 0o200):
+            return True
+        # are we in a group that can write to it?
+        elif (statdata.st_gid in [os.getgid()] + os.getgroups()) and (perm & 0o020):
+            return True
+        # otherwise, we can't write to it.
+        else:
+            return False
+
+    # Otherwise, we'll assume it's writable.
+    # [xx] should we do other checks on other platforms?
+    return True
+
+
+######################################################################
+# NLTK Error reporting
+######################################################################
+
+
+def raise_unorderable_types(ordering, a, b):
+    raise TypeError(
+        "unorderable types: %s() %s %s()"
+        % (type(a).__name__, ordering, type(b).__name__)
+    )

lib/python3.10/site-packages/nltk/jsontags.py

@@ -0,0 +1,65 @@
+# Natural Language Toolkit: JSON Encoder/Decoder Helpers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Xu <xxu@student.unimelb.edu.au>
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Register JSON tags, so the nltk data loader knows what module and class to look for.
+
+NLTK uses simple '!' tags to mark the types of objects, but the fully-qualified
+"tag:nltk.org,2011:" prefix is also accepted in case anyone ends up
+using it.
+"""
+
+import json
+
+json_tags = {}
+
+TAG_PREFIX = "!"
+
+
+def register_tag(cls):
+    """
+    Decorates a class to register it's json tag.
+    """
+    json_tags[TAG_PREFIX + getattr(cls, "json_tag")] = cls
+    return cls
+
+
+class JSONTaggedEncoder(json.JSONEncoder):
+    def default(self, obj):
+        obj_tag = getattr(obj, "json_tag", None)
+        if obj_tag is None:
+            return super().default(obj)
+        obj_tag = TAG_PREFIX + obj_tag
+        obj = obj.encode_json_obj()
+        return {obj_tag: obj}
+
+
+class JSONTaggedDecoder(json.JSONDecoder):
+    def decode(self, s):
+        return self.decode_obj(super().decode(s))
+
+    @classmethod
+    def decode_obj(cls, obj):
+        # Decode nested objects first.
+        if isinstance(obj, dict):
+            obj = {key: cls.decode_obj(val) for (key, val) in obj.items()}
+        elif isinstance(obj, list):
+            obj = list(cls.decode_obj(val) for val in obj)
+        # Check if we have a tagged object.
+        if not isinstance(obj, dict) or len(obj) != 1:
+            return obj
+        obj_tag = next(iter(obj.keys()))
+        if not obj_tag.startswith("!"):
+            return obj
+        if obj_tag not in json_tags:
+            raise ValueError("Unknown tag", obj_tag)
+        obj_cls = json_tags[obj_tag]
+        return obj_cls.decode_json_obj(obj[obj_tag])
+
+
+__all__ = ["register_tag", "json_tags", "JSONTaggedEncoder", "JSONTaggedDecoder"]

lib/python3.10/site-packages/nltk/langnames.py

@@ -0,0 +1,730 @@
+# Natural Language Toolkit: Language Codes
+#
+# Copyright (C) 2022-2023 NLTK Project
+# Author: Eric Kafe <kafe.eric@gmail.com>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+# iso639-3 language codes (C) https://iso639-3.sil.org/
+
+"""
+Translate between language names and language codes.
+
+The iso639-3 language codes were downloaded from the registration authority at
+https://iso639-3.sil.org/
+
+The iso639-3 codeset is evolving, so retired language codes are kept in the
+"iso639retired" dictionary, which is used as fallback by the wrapper functions
+"langname" and "langcode", in order to support the lookup of retired codes.
+
+The "langcode" function returns the current iso639-3 code if there is one,
+and falls back to the retired code otherwise. As specified by BCP-47,
+it returns the shortest (2-letter) code by default, but 3-letter codes
+are also available:
+
+    >>> import nltk.langnames as lgn
+    >>> lgn.langname('fri')          #'fri' is a retired code
+    'Western Frisian'
+
+    The current code is different from the retired one:
+    >>> lgn.langcode('Western Frisian')
+    'fy'
+
+    >>> lgn.langcode('Western Frisian', typ = 3)
+    'fry'
+
+"""
+
+import re
+from warnings import warn
+
+from nltk.corpus import bcp47
+
+codepattern = re.compile("[a-z][a-z][a-z]?")
+
+
+def langname(tag, typ="full"):
+    """
+    Convert a composite BCP-47 tag to a language name
+
+    >>> from nltk.langnames import langname
+    >>> langname('ca-Latn-ES-valencia')
+    'Catalan: Latin: Spain: Valencian'
+
+    >>> langname('ca-Latn-ES-valencia', typ="short")
+    'Catalan'
+    """
+    tags = tag.split("-")
+    code = tags[0].lower()
+    if codepattern.fullmatch(code):
+        if code in iso639retired:  # retired codes
+            return iso639retired[code]
+        elif code in iso639short:  # 3-letter codes
+            code2 = iso639short[code]  # convert to 2-letter code
+            warn(f"Shortening {code!r} to {code2!r}", stacklevel=2)
+            tag = "-".join([code2] + tags[1:])
+        name = bcp47.name(tag)  # parse according to BCP-47
+        if typ == "full":
+            return name  # include all subtags
+        elif name:
+            return name.split(":")[0]  # only the language subtag
+    else:
+        warn(f"Could not find code in {code!r}", stacklevel=2)
+
+
+def langcode(name, typ=2):
+    """
+    Convert language name to iso639-3 language code. Returns the short 2-letter
+    code by default, if one is available, and the 3-letter code otherwise:
+
+    >>> from nltk.langnames import langcode
+    >>> langcode('Modern Greek (1453-)')
+    'el'
+
+    Specify 'typ=3' to get the 3-letter code:
+
+    >>> langcode('Modern Greek (1453-)', typ=3)
+    'ell'
+    """
+    if name in bcp47.langcode:
+        code = bcp47.langcode[name]
+        if typ == 3 and code in iso639long:
+            code = iso639long[code]  # convert to 3-letter code
+        return code
+    elif name in iso639code_retired:
+        return iso639code_retired[name]
+    else:
+        warn(f"Could not find language in {name!r}", stacklevel=2)
+
+
+# =======================================================================
+# Translate betwwen Wikidata Q-codes and BCP-47 codes or names
+# .......................................................................
+
+
+def tag2q(tag):
+    """
+    Convert BCP-47 tag to Wikidata Q-code
+
+    >>> tag2q('nds-u-sd-demv')
+    'Q4289225'
+    """
+    return bcp47.wiki_q[tag]
+
+
+def q2tag(qcode):
+    """
+    Convert Wikidata Q-code to BCP-47 tag
+
+    >>> q2tag('Q4289225')
+    'nds-u-sd-demv'
+    """
+    return wiki_bcp47[qcode]
+
+
+def q2name(qcode, typ="full"):
+    """
+    Convert Wikidata Q-code to BCP-47 (full or short) language name
+
+    >>> q2name('Q4289225')
+    'Low German: Mecklenburg-Vorpommern'
+
+    >>> q2name('Q4289225', "short")
+    'Low German'
+    """
+    return langname(q2tag(qcode), typ)
+
+
+def lang2q(name):
+    """
+    Convert simple language name to Wikidata Q-code
+
+    >>> lang2q('Low German')
+    'Q25433'
+    """
+    return tag2q(langcode(name))
+
+
+# ======================================================================
+# Data dictionaries
+# ......................................................................
+
+
+def inverse_dict(dic):
+    """Return inverse mapping, but only if it is bijective"""
+    if len(dic.keys()) == len(set(dic.values())):
+        return {val: key for (key, val) in dic.items()}
+    else:
+        warn("This dictionary has no bijective inverse mapping.")
+
+
+bcp47.load_wiki_q()  # Wikidata conversion table needs to be loaded explicitly
+wiki_bcp47 = inverse_dict(bcp47.wiki_q)
+
+iso639short = {
+    "aar": "aa",
+    "abk": "ab",
+    "afr": "af",
+    "aka": "ak",
+    "amh": "am",
+    "ara": "ar",
+    "arg": "an",
+    "asm": "as",
+    "ava": "av",
+    "ave": "ae",
+    "aym": "ay",
+    "aze": "az",
+    "bak": "ba",
+    "bam": "bm",
+    "bel": "be",
+    "ben": "bn",
+    "bis": "bi",
+    "bod": "bo",
+    "bos": "bs",
+    "bre": "br",
+    "bul": "bg",
+    "cat": "ca",
+    "ces": "cs",
+    "cha": "ch",
+    "che": "ce",
+    "chu": "cu",
+    "chv": "cv",
+    "cor": "kw",
+    "cos": "co",
+    "cre": "cr",
+    "cym": "cy",
+    "dan": "da",
+    "deu": "de",
+    "div": "dv",
+    "dzo": "dz",
+    "ell": "el",
+    "eng": "en",
+    "epo": "eo",
+    "est": "et",
+    "eus": "eu",
+    "ewe": "ee",
+    "fao": "fo",
+    "fas": "fa",
+    "fij": "fj",
+    "fin": "fi",
+    "fra": "fr",
+    "fry": "fy",
+    "ful": "ff",
+    "gla": "gd",
+    "gle": "ga",
+    "glg": "gl",
+    "glv": "gv",
+    "grn": "gn",
+    "guj": "gu",
+    "hat": "ht",
+    "hau": "ha",
+    "hbs": "sh",
+    "heb": "he",
+    "her": "hz",
+    "hin": "hi",
+    "hmo": "ho",
+    "hrv": "hr",
+    "hun": "hu",
+    "hye": "hy",
+    "ibo": "ig",
+    "ido": "io",
+    "iii": "ii",
+    "iku": "iu",
+    "ile": "ie",
+    "ina": "ia",
+    "ind": "id",
+    "ipk": "ik",
+    "isl": "is",
+    "ita": "it",
+    "jav": "jv",
+    "jpn": "ja",
+    "kal": "kl",
+    "kan": "kn",
+    "kas": "ks",
+    "kat": "ka",
+    "kau": "kr",
+    "kaz": "kk",
+    "khm": "km",
+    "kik": "ki",
+    "kin": "rw",
+    "kir": "ky",
+    "kom": "kv",
+    "kon": "kg",
+    "kor": "ko",
+    "kua": "kj",
+    "kur": "ku",
+    "lao": "lo",
+    "lat": "la",
+    "lav": "lv",
+    "lim": "li",
+    "lin": "ln",
+    "lit": "lt",
+    "ltz": "lb",
+    "lub": "lu",
+    "lug": "lg",
+    "mah": "mh",
+    "mal": "ml",
+    "mar": "mr",
+    "mkd": "mk",
+    "mlg": "mg",
+    "mlt": "mt",
+    "mon": "mn",
+    "mri": "mi",
+    "msa": "ms",
+    "mya": "my",
+    "nau": "na",
+    "nav": "nv",
+    "nbl": "nr",
+    "nde": "nd",
+    "ndo": "ng",
+    "nep": "ne",
+    "nld": "nl",
+    "nno": "nn",
+    "nob": "nb",
+    "nor": "no",
+    "nya": "ny",
+    "oci": "oc",
+    "oji": "oj",
+    "ori": "or",
+    "orm": "om",
+    "oss": "os",
+    "pan": "pa",
+    "pli": "pi",
+    "pol": "pl",
+    "por": "pt",
+    "pus": "ps",
+    "que": "qu",
+    "roh": "rm",
+    "ron": "ro",
+    "run": "rn",
+    "rus": "ru",
+    "sag": "sg",
+    "san": "sa",
+    "sin": "si",
+    "slk": "sk",
+    "slv": "sl",
+    "sme": "se",
+    "smo": "sm",
+    "sna": "sn",
+    "snd": "sd",
+    "som": "so",
+    "sot": "st",
+    "spa": "es",
+    "sqi": "sq",
+    "srd": "sc",
+    "srp": "sr",
+    "ssw": "ss",
+    "sun": "su",
+    "swa": "sw",
+    "swe": "sv",
+    "tah": "ty",
+    "tam": "ta",
+    "tat": "tt",
+    "tel": "te",
+    "tgk": "tg",
+    "tgl": "tl",
+    "tha": "th",
+    "tir": "ti",
+    "ton": "to",
+    "tsn": "tn",
+    "tso": "ts",
+    "tuk": "tk",
+    "tur": "tr",
+    "twi": "tw",
+    "uig": "ug",
+    "ukr": "uk",
+    "urd": "ur",
+    "uzb": "uz",
+    "ven": "ve",
+    "vie": "vi",
+    "vol": "vo",
+    "wln": "wa",
+    "wol": "wo",
+    "xho": "xh",
+    "yid": "yi",
+    "yor": "yo",
+    "zha": "za",
+    "zho": "zh",
+    "zul": "zu",
+}
+
+
+iso639retired = {
+    "fri": "Western Frisian",
+    "auv": "Auvergnat",
+    "gsc": "Gascon",
+    "lms": "Limousin",
+    "lnc": "Languedocien",
+    "prv": "Provençal",
+    "amd": "Amapá Creole",
+    "bgh": "Bogan",
+    "bnh": "Banawá",
+    "bvs": "Belgian Sign Language",
+    "ccy": "Southern Zhuang",
+    "cit": "Chittagonian",
+    "flm": "Falam Chin",
+    "jap": "Jaruára",
+    "kob": "Kohoroxitari",
+    "mob": "Moinba",
+    "mzf": "Aiku",
+    "nhj": "Tlalitzlipa Nahuatl",
+    "nhs": "Southeastern Puebla Nahuatl",
+    "occ": "Occidental",
+    "tmx": "Tomyang",
+    "tot": "Patla-Chicontla Totonac",
+    "xmi": "Miarrã",
+    "yib": "Yinglish",
+    "ztc": "Lachirioag Zapotec",
+    "atf": "Atuence",
+    "bqe": "Navarro-Labourdin Basque",
+    "bsz": "Souletin Basque",
+    "aex": "Amerax",
+    "ahe": "Ahe",
+    "aiz": "Aari",
+    "akn": "Amikoana",
+    "arf": "Arafundi",
+    "azr": "Adzera",
+    "bcx": "Pamona",
+    "bii": "Bisu",
+    "bke": "Bengkulu",
+    "blu": "Hmong Njua",
+    "boc": "Bakung Kenyah",
+    "bsd": "Sarawak Bisaya",
+    "bwv": "Bahau River Kenyah",
+    "bxt": "Buxinhua",
+    "byu": "Buyang",
+    "ccx": "Northern Zhuang",
+    "cru": "Carútana",
+    "dat": "Darang Deng",
+    "dyk": "Land Dayak",
+    "eni": "Enim",
+    "fiz": "Izere",
+    "gen": "Geman Deng",
+    "ggh": "Garreh-Ajuran",
+    "itu": "Itutang",
+    "kds": "Lahu Shi",
+    "knh": "Kayan River Kenyah",
+    "krg": "North Korowai",
+    "krq": "Krui",
+    "kxg": "Katingan",
+    "lmt": "Lematang",
+    "lnt": "Lintang",
+    "lod": "Berawan",
+    "mbg": "Northern Nambikuára",
+    "mdo": "Southwest Gbaya",
+    "mhv": "Arakanese",
+    "miv": "Mimi",
+    "mqd": "Madang",
+    "nky": "Khiamniungan Naga",
+    "nxj": "Nyadu",
+    "ogn": "Ogan",
+    "ork": "Orokaiva",
+    "paj": "Ipeka-Tapuia",
+    "pec": "Southern Pesisir",
+    "pen": "Penesak",
+    "plm": "Palembang",
+    "poj": "Lower Pokomo",
+    "pun": "Pubian",
+    "rae": "Ranau",
+    "rjb": "Rajbanshi",
+    "rws": "Rawas",
+    "sdd": "Semendo",
+    "sdi": "Sindang Kelingi",
+    "skl": "Selako",
+    "slb": "Kahumamahon Saluan",
+    "srj": "Serawai",
+    "suf": "Tarpia",
+    "suh": "Suba",
+    "suu": "Sungkai",
+    "szk": "Sizaki",
+    "tle": "Southern Marakwet",
+    "tnj": "Tanjong",
+    "ttx": "Tutong 1",
+    "ubm": "Upper Baram Kenyah",
+    "vky": "Kayu Agung",
+    "vmo": "Muko-Muko",
+    "wre": "Ware",
+    "xah": "Kahayan",
+    "xkm": "Mahakam Kenyah",
+    "xuf": "Kunfal",
+    "yio": "Dayao Yi",
+    "ymj": "Muji Yi",
+    "ypl": "Pula Yi",
+    "ypw": "Puwa Yi",
+    "ywm": "Wumeng Yi",
+    "yym": "Yuanjiang-Mojiang Yi",
+    "mly": "Malay (individual language)",
+    "muw": "Mundari",
+    "xst": "Silt'e",
+    "ope": "Old Persian",
+    "scc": "Serbian",
+    "scr": "Croatian",
+    "xsk": "Sakan",
+    "mol": "Moldavian",
+    "aay": "Aariya",
+    "acc": "Cubulco Achí",
+    "cbm": "Yepocapa Southwestern Cakchiquel",
+    "chs": "Chumash",
+    "ckc": "Northern Cakchiquel",
+    "ckd": "South Central Cakchiquel",
+    "cke": "Eastern Cakchiquel",
+    "ckf": "Southern Cakchiquel",
+    "cki": "Santa María De Jesús Cakchiquel",
+    "ckj": "Santo Domingo Xenacoj Cakchiquel",
+    "ckk": "Acatenango Southwestern Cakchiquel",
+    "ckw": "Western Cakchiquel",
+    "cnm": "Ixtatán Chuj",
+    "cti": "Tila Chol",
+    "cun": "Cunén Quiché",
+    "eml": "Emiliano-Romagnolo",
+    "eur": "Europanto",
+    "gmo": "Gamo-Gofa-Dawro",
+    "hsf": "Southeastern Huastec",
+    "hva": "San Luís Potosí Huastec",
+    "ixi": "Nebaj Ixil",
+    "ixj": "Chajul Ixil",
+    "jai": "Western Jacalteco",
+    "mms": "Southern Mam",
+    "mpf": "Tajumulco Mam",
+    "mtz": "Tacanec",
+    "mvc": "Central Mam",
+    "mvj": "Todos Santos Cuchumatán Mam",
+    "poa": "Eastern Pokomam",
+    "pob": "Western Pokomchí",
+    "pou": "Southern Pokomam",
+    "ppv": "Papavô",
+    "quj": "Joyabaj Quiché",
+    "qut": "West Central Quiché",
+    "quu": "Eastern Quiché",
+    "qxi": "San Andrés Quiché",
+    "sic": "Malinguat",
+    "stc": "Santa Cruz",
+    "tlz": "Toala'",
+    "tzb": "Bachajón Tzeltal",
+    "tzc": "Chamula Tzotzil",
+    "tze": "Chenalhó Tzotzil",
+    "tzs": "San Andrés Larrainzar Tzotzil",
+    "tzt": "Western Tzutujil",
+    "tzu": "Huixtán Tzotzil",
+    "tzz": "Zinacantán Tzotzil",
+    "vlr": "Vatrata",
+    "yus": "Chan Santa Cruz Maya",
+    "nfg": "Nyeng",
+    "nfk": "Shakara",
+    "agp": "Paranan",
+    "bhk": "Albay Bicolano",
+    "bkb": "Finallig",
+    "btb": "Beti (Cameroon)",
+    "cjr": "Chorotega",
+    "cmk": "Chimakum",
+    "drh": "Darkhat",
+    "drw": "Darwazi",
+    "gav": "Gabutamon",
+    "mof": "Mohegan-Montauk-Narragansett",
+    "mst": "Cataelano Mandaya",
+    "myt": "Sangab Mandaya",
+    "rmr": "Caló",
+    "sgl": "Sanglechi-Ishkashimi",
+    "sul": "Surigaonon",
+    "sum": "Sumo-Mayangna",
+    "tnf": "Tangshewi",
+    "wgw": "Wagawaga",
+    "ayx": "Ayi (China)",
+    "bjq": "Southern Betsimisaraka Malagasy",
+    "dha": "Dhanwar (India)",
+    "dkl": "Kolum So Dogon",
+    "mja": "Mahei",
+    "nbf": "Naxi",
+    "noo": "Nootka",
+    "tie": "Tingal",
+    "tkk": "Takpa",
+    "baz": "Tunen",
+    "bjd": "Bandjigali",
+    "ccq": "Chaungtha",
+    "cka": "Khumi Awa Chin",
+    "dap": "Nisi (India)",
+    "dwl": "Walo Kumbe Dogon",
+    "elp": "Elpaputih",
+    "gbc": "Garawa",
+    "gio": "Gelao",
+    "hrr": "Horuru",
+    "ibi": "Ibilo",
+    "jar": "Jarawa (Nigeria)",
+    "kdv": "Kado",
+    "kgh": "Upper Tanudan Kalinga",
+    "kpp": "Paku Karen",
+    "kzh": "Kenuzi-Dongola",
+    "lcq": "Luhu",
+    "mgx": "Omati",
+    "nln": "Durango Nahuatl",
+    "pbz": "Palu",
+    "pgy": "Pongyong",
+    "sca": "Sansu",
+    "tlw": "South Wemale",
+    "unp": "Worora",
+    "wiw": "Wirangu",
+    "ybd": "Yangbye",
+    "yen": "Yendang",
+    "yma": "Yamphe",
+    "daf": "Dan",
+    "djl": "Djiwarli",
+    "ggr": "Aghu Tharnggalu",
+    "ilw": "Talur",
+    "izi": "Izi-Ezaa-Ikwo-Mgbo",
+    "meg": "Mea",
+    "mld": "Malakhel",
+    "mnt": "Maykulan",
+    "mwd": "Mudbura",
+    "myq": "Forest Maninka",
+    "nbx": "Ngura",
+    "nlr": "Ngarla",
+    "pcr": "Panang",
+    "ppr": "Piru",
+    "tgg": "Tangga",
+    "wit": "Wintu",
+    "xia": "Xiandao",
+    "yiy": "Yir Yoront",
+    "yos": "Yos",
+    "emo": "Emok",
+    "ggm": "Gugu Mini",
+    "leg": "Lengua",
+    "lmm": "Lamam",
+    "mhh": "Maskoy Pidgin",
+    "puz": "Purum Naga",
+    "sap": "Sanapaná",
+    "yuu": "Yugh",
+    "aam": "Aramanik",
+    "adp": "Adap",
+    "aue": "ǂKxʼauǁʼein",
+    "bmy": "Bemba (Democratic Republic of Congo)",
+    "bxx": "Borna (Democratic Republic of Congo)",
+    "byy": "Buya",
+    "dzd": "Daza",
+    "gfx": "Mangetti Dune ǃXung",
+    "gti": "Gbati-ri",
+    "ime": "Imeraguen",
+    "kbf": "Kakauhua",
+    "koj": "Sara Dunjo",
+    "kwq": "Kwak",
+    "kxe": "Kakihum",
+    "lii": "Lingkhim",
+    "mwj": "Maligo",
+    "nnx": "Ngong",
+    "oun": "ǃOǃung",
+    "pmu": "Mirpur Panjabi",
+    "sgo": "Songa",
+    "thx": "The",
+    "tsf": "Southwestern Tamang",
+    "uok": "Uokha",
+    "xsj": "Subi",
+    "yds": "Yiddish Sign Language",
+    "ymt": "Mator-Taygi-Karagas",
+    "ynh": "Yangho",
+    "bgm": "Baga Mboteni",
+    "btl": "Bhatola",
+    "cbe": "Chipiajes",
+    "cbh": "Cagua",
+    "coy": "Coyaima",
+    "cqu": "Chilean Quechua",
+    "cum": "Cumeral",
+    "duj": "Dhuwal",
+    "ggn": "Eastern Gurung",
+    "ggo": "Southern Gondi",
+    "guv": "Gey",
+    "iap": "Iapama",
+    "ill": "Iranun",
+    "kgc": "Kasseng",
+    "kox": "Coxima",
+    "ktr": "Kota Marudu Tinagas",
+    "kvs": "Kunggara",
+    "kzj": "Coastal Kadazan",
+    "kzt": "Tambunan Dusun",
+    "nad": "Nijadali",
+    "nts": "Natagaimas",
+    "ome": "Omejes",
+    "pmc": "Palumata",
+    "pod": "Ponares",
+    "ppa": "Pao",
+    "pry": "Pray 3",
+    "rna": "Runa",
+    "svr": "Savara",
+    "tdu": "Tempasuk Dusun",
+    "thc": "Tai Hang Tong",
+    "tid": "Tidong",
+    "tmp": "Tai Mène",
+    "tne": "Tinoc Kallahan",
+    "toe": "Tomedes",
+    "xba": "Kamba (Brazil)",
+    "xbx": "Kabixí",
+    "xip": "Xipináwa",
+    "xkh": "Karahawyana",
+    "yri": "Yarí",
+    "jeg": "Jeng",
+    "kgd": "Kataang",
+    "krm": "Krim",
+    "prb": "Lua'",
+    "puk": "Pu Ko",
+    "rie": "Rien",
+    "rsi": "Rennellese Sign Language",
+    "skk": "Sok",
+    "snh": "Shinabo",
+    "lsg": "Lyons Sign Language",
+    "mwx": "Mediak",
+    "mwy": "Mosiro",
+    "ncp": "Ndaktup",
+    "ais": "Nataoran Amis",
+    "asd": "Asas",
+    "dit": "Dirari",
+    "dud": "Hun-Saare",
+    "lba": "Lui",
+    "llo": "Khlor",
+    "myd": "Maramba",
+    "myi": "Mina (India)",
+    "nns": "Ningye",
+    "aoh": "Arma",
+    "ayy": "Tayabas Ayta",
+    "bbz": "Babalia Creole Arabic",
+    "bpb": "Barbacoas",
+    "cca": "Cauca",
+    "cdg": "Chamari",
+    "dgu": "Degaru",
+    "drr": "Dororo",
+    "ekc": "Eastern Karnic",
+    "gli": "Guliguli",
+    "kjf": "Khalaj",
+    "kxl": "Nepali Kurux",
+    "kxu": "Kui (India)",
+    "lmz": "Lumbee",
+    "nxu": "Narau",
+    "plp": "Palpa",
+    "sdm": "Semandang",
+    "tbb": "Tapeba",
+    "xrq": "Karranga",
+    "xtz": "Tasmanian",
+    "zir": "Ziriya",
+    "thw": "Thudam",
+    "bic": "Bikaru",
+    "bij": "Vaghat-Ya-Bijim-Legeri",
+    "blg": "Balau",
+    "gji": "Geji",
+    "mvm": "Muya",
+    "ngo": "Ngoni",
+    "pat": "Papitalai",
+    "vki": "Ija-Zuba",
+    "wra": "Warapu",
+    "ajt": "Judeo-Tunisian Arabic",
+    "cug": "Chungmboko",
+    "lak": "Laka (Nigeria)",
+    "lno": "Lango (South Sudan)",
+    "pii": "Pini",
+    "smd": "Sama",
+    "snb": "Sebuyau",
+    "uun": "Kulon-Pazeh",
+    "wrd": "Warduji",
+    "wya": "Wyandot",
+}
+
+
+iso639long = inverse_dict(iso639short)
+
+iso639code_retired = inverse_dict(iso639retired)

lib/python3.10/site-packages/nltk/lazyimport.py

@@ -0,0 +1,142 @@
+# This module is from mx/DateTime/LazyModule.py and is
+# distributed under the terms of the eGenix.com Public License Agreement
+# https://www.egenix.com/products/eGenix.com-Public-License-1.1.0.pdf
+
+""" Helper to enable simple lazy module import.
+
+    'Lazy' means the actual import is deferred until an attribute is
+    requested from the module's namespace. This has the advantage of
+    allowing all imports to be done at the top of a script (in a
+    prominent and visible place) without having a great impact
+    on startup time.
+
+    Copyright (c) 1999-2005, Marc-Andre Lemburg; mailto:mal@lemburg.com
+    See the documentation for further information on copyrights,
+    or contact the author. All Rights Reserved.
+"""
+
+### Constants
+
+_debug = 0
+
+###
+
+
+class LazyModule:
+
+    """Lazy module class.
+
+    Lazy modules are imported into the given namespaces whenever a
+    non-special attribute (there are some attributes like __doc__
+    that class instances handle without calling __getattr__) is
+    requested. The module is then registered under the given name
+    in locals usually replacing the import wrapper instance. The
+    import itself is done using globals as global namespace.
+
+    Example of creating a lazy load module:
+
+    ISO = LazyModule('ISO',locals(),globals())
+
+    Later, requesting an attribute from ISO will load the module
+    automatically into the locals() namespace, overriding the
+    LazyModule instance:
+
+    t = ISO.Week(1998,1,1)
+
+    """
+
+    # Flag which indicates whether the LazyModule is initialized or not
+    __lazymodule_init = 0
+
+    # Name of the module to load
+    __lazymodule_name = ""
+
+    # Flag which indicates whether the module was loaded or not
+    __lazymodule_loaded = 0
+
+    # Locals dictionary where to register the module
+    __lazymodule_locals = None
+
+    # Globals dictionary to use for the module import
+    __lazymodule_globals = None
+
+    def __init__(self, name, locals, globals=None):
+
+        """Create a LazyModule instance wrapping module name.
+
+        The module will later on be registered in locals under the
+        given module name.
+
+        globals is optional and defaults to locals.
+
+        """
+        self.__lazymodule_locals = locals
+        if globals is None:
+            globals = locals
+        self.__lazymodule_globals = globals
+        mainname = globals.get("__name__", "")
+        if mainname:
+            self.__name__ = mainname + "." + name
+            self.__lazymodule_name = name
+        else:
+            self.__name__ = self.__lazymodule_name = name
+        self.__lazymodule_init = 1
+
+    def __lazymodule_import(self):
+
+        """Import the module now."""
+        # Load and register module
+        local_name = self.__lazymodule_name  # e.g. "toolbox"
+        full_name = self.__name__  # e.g. "nltk.toolbox"
+        if self.__lazymodule_loaded:
+            return self.__lazymodule_locals[local_name]
+        if _debug:
+            print("LazyModule: Loading module %r" % full_name)
+        self.__lazymodule_locals[local_name] = module = __import__(
+            full_name, self.__lazymodule_locals, self.__lazymodule_globals, "*"
+        )
+
+        # Fill namespace with all symbols from original module to
+        # provide faster access.
+        self.__dict__.update(module.__dict__)
+
+        # Set import flag
+        self.__dict__["__lazymodule_loaded"] = 1
+
+        if _debug:
+            print("LazyModule: Module %r loaded" % full_name)
+        return module
+
+    def __getattr__(self, name):
+
+        """Import the module on demand and get the attribute."""
+        if self.__lazymodule_loaded:
+            raise AttributeError(name)
+        if _debug:
+            print(
+                "LazyModule: "
+                "Module load triggered by attribute %r read access" % name
+            )
+        module = self.__lazymodule_import()
+        return getattr(module, name)
+
+    def __setattr__(self, name, value):
+
+        """Import the module on demand and set the attribute."""
+        if not self.__lazymodule_init:
+            self.__dict__[name] = value
+            return
+        if self.__lazymodule_loaded:
+            self.__lazymodule_locals[self.__lazymodule_name] = value
+            self.__dict__[name] = value
+            return
+        if _debug:
+            print(
+                "LazyModule: "
+                "Module load triggered by attribute %r write access" % name
+            )
+        module = self.__lazymodule_import()
+        setattr(module, name, value)
+
+    def __repr__(self):
+        return "<LazyModule '%s'>" % self.__name__

lib/python3.10/site-packages/nltk/probability.py

@@ -0,0 +1,2578 @@
+# Natural Language Toolkit: Probability and Statistics
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <edloper@gmail.com>
+#         Steven Bird <stevenbird1@gmail.com> (additions)
+#         Trevor Cohn <tacohn@cs.mu.oz.au> (additions)
+#         Peter Ljunglöf <peter.ljunglof@heatherleaf.se> (additions)
+#         Liang Dong <ldong@clemson.edu> (additions)
+#         Geoffrey Sampson <sampson@cantab.net> (additions)
+#         Ilia Kurenkov <ilia.kurenkov@gmail.com> (additions)
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Classes for representing and processing probabilistic information.
+
+The ``FreqDist`` class is used to encode "frequency distributions",
+which count the number of times that each outcome of an experiment
+occurs.
+
+The ``ProbDistI`` class defines a standard interface for "probability
+distributions", which encode the probability of each outcome for an
+experiment.  There are two types of probability distribution:
+
+  - "derived probability distributions" are created from frequency
+    distributions.  They attempt to model the probability distribution
+    that generated the frequency distribution.
+  - "analytic probability distributions" are created directly from
+    parameters (such as variance).
+
+The ``ConditionalFreqDist`` class and ``ConditionalProbDistI`` interface
+are used to encode conditional distributions.  Conditional probability
+distributions can be derived or analytic; but currently the only
+implementation of the ``ConditionalProbDistI`` interface is
+``ConditionalProbDist``, a derived distribution.
+
+"""
+
+import array
+import math
+import random
+import warnings
+from abc import ABCMeta, abstractmethod
+from collections import Counter, defaultdict
+from functools import reduce
+
+from nltk.internals import raise_unorderable_types
+
+_NINF = float("-1e300")
+
+##//////////////////////////////////////////////////////
+##  Frequency Distributions
+##//////////////////////////////////////////////////////
+
+
+class FreqDist(Counter):
+    """
+    A frequency distribution for the outcomes of an experiment.  A
+    frequency distribution records the number of times each outcome of
+    an experiment has occurred.  For example, a frequency distribution
+    could be used to record the frequency of each word type in a
+    document.  Formally, a frequency distribution can be defined as a
+    function mapping from each sample to the number of times that
+    sample occurred as an outcome.
+
+    Frequency distributions are generally constructed by running a
+    number of experiments, and incrementing the count for a sample
+    every time it is an outcome of an experiment.  For example, the
+    following code will produce a frequency distribution that encodes
+    how often each word occurs in a text:
+
+        >>> from nltk.tokenize import word_tokenize
+        >>> from nltk.probability import FreqDist
+        >>> sent = 'This is an example sentence'
+        >>> fdist = FreqDist()
+        >>> for word in word_tokenize(sent):
+        ...    fdist[word.lower()] += 1
+
+    An equivalent way to do this is with the initializer:
+
+        >>> fdist = FreqDist(word.lower() for word in word_tokenize(sent))
+
+    """
+
+    def __init__(self, samples=None):
+        """
+        Construct a new frequency distribution.  If ``samples`` is
+        given, then the frequency distribution will be initialized
+        with the count of each object in ``samples``; otherwise, it
+        will be initialized to be empty.
+
+        In particular, ``FreqDist()`` returns an empty frequency
+        distribution; and ``FreqDist(samples)`` first creates an empty
+        frequency distribution, and then calls ``update`` with the
+        list ``samples``.
+
+        :param samples: The samples to initialize the frequency
+            distribution with.
+        :type samples: Sequence
+        """
+        Counter.__init__(self, samples)
+
+        # Cached number of samples in this FreqDist
+        self._N = None
+
+    def N(self):
+        """
+        Return the total number of sample outcomes that have been
+        recorded by this FreqDist.  For the number of unique
+        sample values (or bins) with counts greater than zero, use
+        ``FreqDist.B()``.
+
+        :rtype: int
+        """
+        if self._N is None:
+            # Not already cached, or cache has been invalidated
+            self._N = sum(self.values())
+        return self._N
+
+    def __setitem__(self, key, val):
+        """
+        Override ``Counter.__setitem__()`` to invalidate the cached N
+        """
+        self._N = None
+        super().__setitem__(key, val)
+
+    def __delitem__(self, key):
+        """
+        Override ``Counter.__delitem__()`` to invalidate the cached N
+        """
+        self._N = None
+        super().__delitem__(key)
+
+    def update(self, *args, **kwargs):
+        """
+        Override ``Counter.update()`` to invalidate the cached N
+        """
+        self._N = None
+        super().update(*args, **kwargs)
+
+    def setdefault(self, key, val):
+        """
+        Override ``Counter.setdefault()`` to invalidate the cached N
+        """
+        self._N = None
+        super().setdefault(key, val)
+
+    def B(self):
+        """
+        Return the total number of sample values (or "bins") that
+        have counts greater than zero.  For the total
+        number of sample outcomes recorded, use ``FreqDist.N()``.
+        (FreqDist.B() is the same as len(FreqDist).)
+
+        :rtype: int
+        """
+        return len(self)
+
+    def hapaxes(self):
+        """
+        Return a list of all samples that occur once (hapax legomena)
+
+        :rtype: list
+        """
+        return [item for item in self if self[item] == 1]
+
+    def Nr(self, r, bins=None):
+        return self.r_Nr(bins)[r]
+
+    def r_Nr(self, bins=None):
+        """
+        Return the dictionary mapping r to Nr, the number of samples with frequency r, where Nr > 0.
+
+        :type bins: int
+        :param bins: The number of possible sample outcomes.  ``bins``
+            is used to calculate Nr(0).  In particular, Nr(0) is
+            ``bins-self.B()``.  If ``bins`` is not specified, it
+            defaults to ``self.B()`` (so Nr(0) will be 0).
+        :rtype: int
+        """
+
+        _r_Nr = defaultdict(int)
+        for count in self.values():
+            _r_Nr[count] += 1
+
+        # Special case for Nr[0]:
+        _r_Nr[0] = bins - self.B() if bins is not None else 0
+
+        return _r_Nr
+
+    def _cumulative_frequencies(self, samples):
+        """
+        Return the cumulative frequencies of the specified samples.
+        If no samples are specified, all counts are returned, starting
+        with the largest.
+
+        :param samples: the samples whose frequencies should be returned.
+        :type samples: any
+        :rtype: list(float)
+        """
+        cf = 0.0
+        for sample in samples:
+            cf += self[sample]
+            yield cf
+
+    # slightly odd nomenclature freq() if FreqDist does counts and ProbDist does probs,
+    # here, freq() does probs
+    def freq(self, sample):
+        """
+        Return the frequency of a given sample.  The frequency of a
+        sample is defined as the count of that sample divided by the
+        total number of sample outcomes that have been recorded by
+        this FreqDist.  The count of a sample is defined as the
+        number of times that sample outcome was recorded by this
+        FreqDist.  Frequencies are always real numbers in the range
+        [0, 1].
+
+        :param sample: the sample whose frequency
+               should be returned.
+        :type sample: any
+        :rtype: float
+        """
+        n = self.N()
+        if n == 0:
+            return 0
+        return self[sample] / n
+
+    def max(self):
+        """
+        Return the sample with the greatest number of outcomes in this
+        frequency distribution.  If two or more samples have the same
+        number of outcomes, return one of them; which sample is
+        returned is undefined.  If no outcomes have occurred in this
+        frequency distribution, return None.
+
+        :return: The sample with the maximum number of outcomes in this
+                frequency distribution.
+        :rtype: any or None
+        """
+        if len(self) == 0:
+            raise ValueError(
+                "A FreqDist must have at least one sample before max is defined."
+            )
+        return self.most_common(1)[0][0]
+
+    def plot(
+        self, *args, title="", cumulative=False, percents=False, show=True, **kwargs
+    ):
+        """
+        Plot samples from the frequency distribution
+        displaying the most frequent sample first.  If an integer
+        parameter is supplied, stop after this many samples have been
+        plotted.  For a cumulative plot, specify cumulative=True. Additional
+        ``**kwargs`` are passed to matplotlib's plot function.
+        (Requires Matplotlib to be installed.)
+
+        :param title: The title for the graph.
+        :type title: str
+        :param cumulative: Whether the plot is cumulative. (default = False)
+        :type cumulative: bool
+        :param percents: Whether the plot uses percents instead of counts. (default = False)
+        :type percents: bool
+        :param show: Whether to show the plot, or only return the ax.
+        :type show: bool
+        """
+        try:
+            import matplotlib.pyplot as plt
+        except ImportError as e:
+            raise ValueError(
+                "The plot function requires matplotlib to be installed."
+                "See https://matplotlib.org/"
+            ) from e
+
+        if len(args) == 0:
+            args = [len(self)]
+        samples = [item for item, _ in self.most_common(*args)]
+
+        if cumulative:
+            freqs = list(self._cumulative_frequencies(samples))
+            ylabel = "Cumulative "
+        else:
+            freqs = [self[sample] for sample in samples]
+            ylabel = ""
+
+        if percents:
+            freqs = [f / self.N() * 100 for f in freqs]
+            ylabel += "Percents"
+        else:
+            ylabel += "Counts"
+
+        ax = plt.gca()
+        ax.grid(True, color="silver")
+
+        if "linewidth" not in kwargs:
+            kwargs["linewidth"] = 2
+        if title:
+            ax.set_title(title)
+
+        ax.plot(freqs, **kwargs)
+        ax.set_xticks(range(len(samples)))
+        ax.set_xticklabels([str(s) for s in samples], rotation=90)
+        ax.set_xlabel("Samples")
+        ax.set_ylabel(ylabel)
+
+        if show:
+            plt.show()
+
+        return ax
+
+    def tabulate(self, *args, **kwargs):
+        """
+        Tabulate the given samples from the frequency distribution (cumulative),
+        displaying the most frequent sample first.  If an integer
+        parameter is supplied, stop after this many samples have been
+        plotted.
+
+        :param samples: The samples to plot (default is all samples)
+        :type samples: list
+        :param cumulative: A flag to specify whether the freqs are cumulative (default = False)
+        :type title: bool
+        """
+        if len(args) == 0:
+            args = [len(self)]
+        samples = _get_kwarg(
+            kwargs, "samples", [item for item, _ in self.most_common(*args)]
+        )
+
+        cumulative = _get_kwarg(kwargs, "cumulative", False)
+        if cumulative:
+            freqs = list(self._cumulative_frequencies(samples))
+        else:
+            freqs = [self[sample] for sample in samples]
+        # percents = [f * 100 for f in freqs]  only in ProbDist?
+
+        width = max(len(f"{s}") for s in samples)
+        width = max(width, max(len("%d" % f) for f in freqs))
+
+        for i in range(len(samples)):
+            print("%*s" % (width, samples[i]), end=" ")
+        print()
+        for i in range(len(samples)):
+            print("%*d" % (width, freqs[i]), end=" ")
+        print()
+
+    def copy(self):
+        """
+        Create a copy of this frequency distribution.
+
+        :rtype: FreqDist
+        """
+        return self.__class__(self)
+
+    # Mathematical operatiors
+
+    def __add__(self, other):
+        """
+        Add counts from two counters.
+
+        >>> FreqDist('abbb') + FreqDist('bcc')
+        FreqDist({'b': 4, 'c': 2, 'a': 1})
+
+        """
+        return self.__class__(super().__add__(other))
+
+    def __sub__(self, other):
+        """
+        Subtract count, but keep only results with positive counts.
+
+        >>> FreqDist('abbbc') - FreqDist('bccd')
+        FreqDist({'b': 2, 'a': 1})
+
+        """
+        return self.__class__(super().__sub__(other))
+
+    def __or__(self, other):
+        """
+        Union is the maximum of value in either of the input counters.
+
+        >>> FreqDist('abbb') | FreqDist('bcc')
+        FreqDist({'b': 3, 'c': 2, 'a': 1})
+
+        """
+        return self.__class__(super().__or__(other))
+
+    def __and__(self, other):
+        """
+        Intersection is the minimum of corresponding counts.
+
+        >>> FreqDist('abbb') & FreqDist('bcc')
+        FreqDist({'b': 1})
+
+        """
+        return self.__class__(super().__and__(other))
+
+    def __le__(self, other):
+        """
+        Returns True if this frequency distribution is a subset of the other
+        and for no key the value exceeds the value of the same key from
+        the other frequency distribution.
+
+        The <= operator forms partial order and satisfying the axioms
+        reflexivity, antisymmetry and transitivity.
+
+        >>> FreqDist('a') <= FreqDist('a')
+        True
+        >>> a = FreqDist('abc')
+        >>> b = FreqDist('aabc')
+        >>> (a <= b, b <= a)
+        (True, False)
+        >>> FreqDist('a') <= FreqDist('abcd')
+        True
+        >>> FreqDist('abc') <= FreqDist('xyz')
+        False
+        >>> FreqDist('xyz') <= FreqDist('abc')
+        False
+        >>> c = FreqDist('a')
+        >>> d = FreqDist('aa')
+        >>> e = FreqDist('aaa')
+        >>> c <= d and d <= e and c <= e
+        True
+        """
+        if not isinstance(other, FreqDist):
+            raise_unorderable_types("<=", self, other)
+        return set(self).issubset(other) and all(
+            self[key] <= other[key] for key in self
+        )
+
+    def __ge__(self, other):
+        if not isinstance(other, FreqDist):
+            raise_unorderable_types(">=", self, other)
+        return set(self).issuperset(other) and all(
+            self[key] >= other[key] for key in other
+        )
+
+    __lt__ = lambda self, other: self <= other and not self == other
+    __gt__ = lambda self, other: self >= other and not self == other
+
+    def __repr__(self):
+        """
+        Return a string representation of this FreqDist.
+
+        :rtype: string
+        """
+        return self.pformat()
+
+    def pprint(self, maxlen=10, stream=None):
+        """
+        Print a string representation of this FreqDist to 'stream'
+
+        :param maxlen: The maximum number of items to print
+        :type maxlen: int
+        :param stream: The stream to print to. stdout by default
+        """
+        print(self.pformat(maxlen=maxlen), file=stream)
+
+    def pformat(self, maxlen=10):
+        """
+        Return a string representation of this FreqDist.
+
+        :param maxlen: The maximum number of items to display
+        :type maxlen: int
+        :rtype: string
+        """
+        items = ["{!r}: {!r}".format(*item) for item in self.most_common(maxlen)]
+        if len(self) > maxlen:
+            items.append("...")
+        return "FreqDist({{{0}}})".format(", ".join(items))
+
+    def __str__(self):
+        """
+        Return a string representation of this FreqDist.
+
+        :rtype: string
+        """
+        return "<FreqDist with %d samples and %d outcomes>" % (len(self), self.N())
+
+    def __iter__(self):
+        """
+        Return an iterator which yields tokens ordered by frequency.
+
+        :rtype: iterator
+        """
+        for token, _ in self.most_common(self.B()):
+            yield token
+
+
+##//////////////////////////////////////////////////////
+##  Probability Distributions
+##//////////////////////////////////////////////////////
+
+
+class ProbDistI(metaclass=ABCMeta):
+    """
+    A probability distribution for the outcomes of an experiment.  A
+    probability distribution specifies how likely it is that an
+    experiment will have any given outcome.  For example, a
+    probability distribution could be used to predict the probability
+    that a token in a document will have a given type.  Formally, a
+    probability distribution can be defined as a function mapping from
+    samples to nonnegative real numbers, such that the sum of every
+    number in the function's range is 1.0.  A ``ProbDist`` is often
+    used to model the probability distribution of the experiment used
+    to generate a frequency distribution.
+    """
+
+    SUM_TO_ONE = True
+    """True if the probabilities of the samples in this probability
+       distribution will always sum to one."""
+
+    @abstractmethod
+    def __init__(self):
+        """
+        Classes inheriting from ProbDistI should implement __init__.
+        """
+
+    @abstractmethod
+    def prob(self, sample):
+        """
+        Return the probability for a given sample.  Probabilities
+        are always real numbers in the range [0, 1].
+
+        :param sample: The sample whose probability
+               should be returned.
+        :type sample: any
+        :rtype: float
+        """
+
+    def logprob(self, sample):
+        """
+        Return the base 2 logarithm of the probability for a given sample.
+
+        :param sample: The sample whose probability
+               should be returned.
+        :type sample: any
+        :rtype: float
+        """
+        # Default definition, in terms of prob()
+        p = self.prob(sample)
+        return math.log(p, 2) if p != 0 else _NINF
+
+    @abstractmethod
+    def max(self):
+        """
+        Return the sample with the greatest probability.  If two or
+        more samples have the same probability, return one of them;
+        which sample is returned is undefined.
+
+        :rtype: any
+        """
+
+    @abstractmethod
+    def samples(self):
+        """
+        Return a list of all samples that have nonzero probabilities.
+        Use ``prob`` to find the probability of each sample.
+
+        :rtype: list
+        """
+
+    # cf self.SUM_TO_ONE
+    def discount(self):
+        """
+        Return the ratio by which counts are discounted on average: c*/c
+
+        :rtype: float
+        """
+        return 0.0
+
+    # Subclasses should define more efficient implementations of this,
+    # where possible.
+    def generate(self):
+        """
+        Return a randomly selected sample from this probability distribution.
+        The probability of returning each sample ``samp`` is equal to
+        ``self.prob(samp)``.
+        """
+        p = random.random()
+        p_init = p
+        for sample in self.samples():
+            p -= self.prob(sample)
+            if p <= 0:
+                return sample
+        # allow for some rounding error:
+        if p < 0.0001:
+            return sample
+        # we *should* never get here
+        if self.SUM_TO_ONE:
+            warnings.warn(
+                "Probability distribution %r sums to %r; generate()"
+                " is returning an arbitrary sample." % (self, p_init - p)
+            )
+        return random.choice(list(self.samples()))
+
+
+class UniformProbDist(ProbDistI):
+    """
+    A probability distribution that assigns equal probability to each
+    sample in a given set; and a zero probability to all other
+    samples.
+    """
+
+    def __init__(self, samples):
+        """
+        Construct a new uniform probability distribution, that assigns
+        equal probability to each sample in ``samples``.
+
+        :param samples: The samples that should be given uniform
+            probability.
+        :type samples: list
+        :raise ValueError: If ``samples`` is empty.
+        """
+        if len(samples) == 0:
+            raise ValueError(
+                "A Uniform probability distribution must " + "have at least one sample."
+            )
+        self._sampleset = set(samples)
+        self._prob = 1.0 / len(self._sampleset)
+        self._samples = list(self._sampleset)
+
+    def prob(self, sample):
+        return self._prob if sample in self._sampleset else 0
+
+    def max(self):
+        return self._samples[0]
+
+    def samples(self):
+        return self._samples
+
+    def __repr__(self):
+        return "<UniformProbDist with %d samples>" % len(self._sampleset)
+
+
+class RandomProbDist(ProbDistI):
+    """
+    Generates a random probability distribution whereby each sample
+    will be between 0 and 1 with equal probability (uniform random distribution.
+    Also called a continuous uniform distribution).
+    """
+
+    def __init__(self, samples):
+        if len(samples) == 0:
+            raise ValueError(
+                "A probability distribution must " + "have at least one sample."
+            )
+        self._probs = self.unirand(samples)
+        self._samples = list(self._probs.keys())
+
+    @classmethod
+    def unirand(cls, samples):
+        """
+        The key function that creates a randomized initial distribution
+        that still sums to 1. Set as a dictionary of prob values so that
+        it can still be passed to MutableProbDist and called with identical
+        syntax to UniformProbDist
+        """
+        samples = set(samples)
+        randrow = [random.random() for i in range(len(samples))]
+        total = sum(randrow)
+        for i, x in enumerate(randrow):
+            randrow[i] = x / total
+
+        total = sum(randrow)
+        if total != 1:
+            # this difference, if present, is so small (near NINF) that it
+            # can be subtracted from any element without risking probs not (0 1)
+            randrow[-1] -= total - 1
+
+        return {s: randrow[i] for i, s in enumerate(samples)}
+
+    def max(self):
+        if not hasattr(self, "_max"):
+            self._max = max((p, v) for (v, p) in self._probs.items())[1]
+        return self._max
+
+    def prob(self, sample):
+        return self._probs.get(sample, 0)
+
+    def samples(self):
+        return self._samples
+
+    def __repr__(self):
+        return "<RandomUniformProbDist with %d samples>" % len(self._probs)
+
+
+class DictionaryProbDist(ProbDistI):
+    """
+    A probability distribution whose probabilities are directly
+    specified by a given dictionary.  The given dictionary maps
+    samples to probabilities.
+    """
+
+    def __init__(self, prob_dict=None, log=False, normalize=False):
+        """
+        Construct a new probability distribution from the given
+        dictionary, which maps values to probabilities (or to log
+        probabilities, if ``log`` is true).  If ``normalize`` is
+        true, then the probability values are scaled by a constant
+        factor such that they sum to 1.
+
+        If called without arguments, the resulting probability
+        distribution assigns zero probability to all values.
+        """
+
+        self._prob_dict = prob_dict.copy() if prob_dict is not None else {}
+        self._log = log
+
+        # Normalize the distribution, if requested.
+        if normalize:
+            if len(prob_dict) == 0:
+                raise ValueError(
+                    "A DictionaryProbDist must have at least one sample "
+                    + "before it can be normalized."
+                )
+            if log:
+                value_sum = sum_logs(list(self._prob_dict.values()))
+                if value_sum <= _NINF:
+                    logp = math.log(1.0 / len(prob_dict), 2)
+                    for x in prob_dict:
+                        self._prob_dict[x] = logp
+                else:
+                    for (x, p) in self._prob_dict.items():
+                        self._prob_dict[x] -= value_sum
+            else:
+                value_sum = sum(self._prob_dict.values())
+                if value_sum == 0:
+                    p = 1.0 / len(prob_dict)
+                    for x in prob_dict:
+                        self._prob_dict[x] = p
+                else:
+                    norm_factor = 1.0 / value_sum
+                    for (x, p) in self._prob_dict.items():
+                        self._prob_dict[x] *= norm_factor
+
+    def prob(self, sample):
+        if self._log:
+            return 2 ** (self._prob_dict[sample]) if sample in self._prob_dict else 0
+        else:
+            return self._prob_dict.get(sample, 0)
+
+    def logprob(self, sample):
+        if self._log:
+            return self._prob_dict.get(sample, _NINF)
+        else:
+            if sample not in self._prob_dict:
+                return _NINF
+            elif self._prob_dict[sample] == 0:
+                return _NINF
+            else:
+                return math.log(self._prob_dict[sample], 2)
+
+    def max(self):
+        if not hasattr(self, "_max"):
+            self._max = max((p, v) for (v, p) in self._prob_dict.items())[1]
+        return self._max
+
+    def samples(self):
+        return self._prob_dict.keys()
+
+    def __repr__(self):
+        return "<ProbDist with %d samples>" % len(self._prob_dict)
+
+
+class MLEProbDist(ProbDistI):
+    """
+    The maximum likelihood estimate for the probability distribution
+    of the experiment used to generate a frequency distribution.  The
+    "maximum likelihood estimate" approximates the probability of
+    each sample as the frequency of that sample in the frequency
+    distribution.
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Use the maximum likelihood estimate to create a probability
+        distribution for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        """
+        self._freqdist = freqdist
+
+    def freqdist(self):
+        """
+        Return the frequency distribution that this probability
+        distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._freqdist
+
+    def prob(self, sample):
+        return self._freqdist.freq(sample)
+
+    def max(self):
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def __repr__(self):
+        """
+        :rtype: str
+        :return: A string representation of this ``ProbDist``.
+        """
+        return "<MLEProbDist based on %d samples>" % self._freqdist.N()
+
+
+class LidstoneProbDist(ProbDistI):
+    """
+    The Lidstone estimate for the probability distribution of the
+    experiment used to generate a frequency distribution.  The
+    "Lidstone estimate" is parameterized by a real number *gamma*,
+    which typically ranges from 0 to 1.  The Lidstone estimate
+    approximates the probability of a sample with count *c* from an
+    experiment with *N* outcomes and *B* bins as
+    ``c+gamma)/(N+B*gamma)``.  This is equivalent to adding
+    *gamma* to the count for each bin, and taking the maximum
+    likelihood estimate of the resulting frequency distribution.
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, freqdist, gamma, bins=None):
+        """
+        Use the Lidstone estimate to create a probability distribution
+        for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        :type gamma: float
+        :param gamma: A real number used to parameterize the
+            estimate.  The Lidstone estimate is equivalent to adding
+            *gamma* to the count for each bin, and taking the
+            maximum likelihood estimate of the resulting frequency
+            distribution.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        if (bins == 0) or (bins is None and freqdist.N() == 0):
+            name = self.__class__.__name__[:-8]
+            raise ValueError(
+                "A %s probability distribution " % name + "must have at least one bin."
+            )
+        if (bins is not None) and (bins < freqdist.B()):
+            name = self.__class__.__name__[:-8]
+            raise ValueError(
+                "\nThe number of bins in a %s distribution " % name
+                + "(%d) must be greater than or equal to\n" % bins
+                + "the number of bins in the FreqDist used "
+                + "to create it (%d)." % freqdist.B()
+            )
+
+        self._freqdist = freqdist
+        self._gamma = float(gamma)
+        self._N = self._freqdist.N()
+
+        if bins is None:
+            bins = freqdist.B()
+        self._bins = bins
+
+        self._divisor = self._N + bins * gamma
+        if self._divisor == 0.0:
+            # In extreme cases we force the probability to be 0,
+            # which it will be, since the count will be 0:
+            self._gamma = 0
+            self._divisor = 1
+
+    def freqdist(self):
+        """
+        Return the frequency distribution that this probability
+        distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._freqdist
+
+    def prob(self, sample):
+        c = self._freqdist[sample]
+        return (c + self._gamma) / self._divisor
+
+    def max(self):
+        # For Lidstone distributions, probability is monotonic with
+        # frequency, so the most probable sample is the one that
+        # occurs most frequently.
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def discount(self):
+        gb = self._gamma * self._bins
+        return gb / (self._N + gb)
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<LidstoneProbDist based on %d samples>" % self._freqdist.N()
+
+
+class LaplaceProbDist(LidstoneProbDist):
+    """
+    The Laplace estimate for the probability distribution of the
+    experiment used to generate a frequency distribution.  The
+    "Laplace estimate" approximates the probability of a sample with
+    count *c* from an experiment with *N* outcomes and *B* bins as
+    *(c+1)/(N+B)*.  This is equivalent to adding one to the count for
+    each bin, and taking the maximum likelihood estimate of the
+    resulting frequency distribution.
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Use the Laplace estimate to create a probability distribution
+        for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        LidstoneProbDist.__init__(self, freqdist, 1, bins)
+
+    def __repr__(self):
+        """
+        :rtype: str
+        :return: A string representation of this ``ProbDist``.
+        """
+        return "<LaplaceProbDist based on %d samples>" % self._freqdist.N()
+
+
+class ELEProbDist(LidstoneProbDist):
+    """
+    The expected likelihood estimate for the probability distribution
+    of the experiment used to generate a frequency distribution.  The
+    "expected likelihood estimate" approximates the probability of a
+    sample with count *c* from an experiment with *N* outcomes and
+    *B* bins as *(c+0.5)/(N+B/2)*.  This is equivalent to adding 0.5
+    to the count for each bin, and taking the maximum likelihood
+    estimate of the resulting frequency distribution.
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Use the expected likelihood estimate to create a probability
+        distribution for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        LidstoneProbDist.__init__(self, freqdist, 0.5, bins)
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<ELEProbDist based on %d samples>" % self._freqdist.N()
+
+
+class HeldoutProbDist(ProbDistI):
+    """
+    The heldout estimate for the probability distribution of the
+    experiment used to generate two frequency distributions.  These
+    two frequency distributions are called the "heldout frequency
+    distribution" and the "base frequency distribution."  The
+    "heldout estimate" uses uses the "heldout frequency
+    distribution" to predict the probability of each sample, given its
+    frequency in the "base frequency distribution".
+
+    In particular, the heldout estimate approximates the probability
+    for a sample that occurs *r* times in the base distribution as
+    the average frequency in the heldout distribution of all samples
+    that occur *r* times in the base distribution.
+
+    This average frequency is *Tr[r]/(Nr[r].N)*, where:
+
+    - *Tr[r]* is the total count in the heldout distribution for
+      all samples that occur *r* times in the base distribution.
+    - *Nr[r]* is the number of samples that occur *r* times in
+      the base distribution.
+    - *N* is the number of outcomes recorded by the heldout
+      frequency distribution.
+
+    In order to increase the efficiency of the ``prob`` member
+    function, *Tr[r]/(Nr[r].N)* is precomputed for each value of *r*
+    when the ``HeldoutProbDist`` is created.
+
+    :type _estimate: list(float)
+    :ivar _estimate: A list mapping from *r*, the number of
+        times that a sample occurs in the base distribution, to the
+        probability estimate for that sample.  ``_estimate[r]`` is
+        calculated by finding the average frequency in the heldout
+        distribution of all samples that occur *r* times in the base
+        distribution.  In particular, ``_estimate[r]`` =
+        *Tr[r]/(Nr[r].N)*.
+    :type _max_r: int
+    :ivar _max_r: The maximum number of times that any sample occurs
+        in the base distribution.  ``_max_r`` is used to decide how
+        large ``_estimate`` must be.
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, base_fdist, heldout_fdist, bins=None):
+        """
+        Use the heldout estimate to create a probability distribution
+        for the experiment used to generate ``base_fdist`` and
+        ``heldout_fdist``.
+
+        :type base_fdist: FreqDist
+        :param base_fdist: The base frequency distribution.
+        :type heldout_fdist: FreqDist
+        :param heldout_fdist: The heldout frequency distribution.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+
+        self._base_fdist = base_fdist
+        self._heldout_fdist = heldout_fdist
+
+        # The max number of times any sample occurs in base_fdist.
+        self._max_r = base_fdist[base_fdist.max()]
+
+        # Calculate Tr, Nr, and N.
+        Tr = self._calculate_Tr()
+        r_Nr = base_fdist.r_Nr(bins)
+        Nr = [r_Nr[r] for r in range(self._max_r + 1)]
+        N = heldout_fdist.N()
+
+        # Use Tr, Nr, and N to compute the probability estimate for
+        # each value of r.
+        self._estimate = self._calculate_estimate(Tr, Nr, N)
+
+    def _calculate_Tr(self):
+        """
+        Return the list *Tr*, where *Tr[r]* is the total count in
+        ``heldout_fdist`` for all samples that occur *r*
+        times in ``base_fdist``.
+
+        :rtype: list(float)
+        """
+        Tr = [0.0] * (self._max_r + 1)
+        for sample in self._heldout_fdist:
+            r = self._base_fdist[sample]
+            Tr[r] += self._heldout_fdist[sample]
+        return Tr
+
+    def _calculate_estimate(self, Tr, Nr, N):
+        """
+        Return the list *estimate*, where *estimate[r]* is the probability
+        estimate for any sample that occurs *r* times in the base frequency
+        distribution.  In particular, *estimate[r]* is *Tr[r]/(N[r].N)*.
+        In the special case that *N[r]=0*, *estimate[r]* will never be used;
+        so we define *estimate[r]=None* for those cases.
+
+        :rtype: list(float)
+        :type Tr: list(float)
+        :param Tr: the list *Tr*, where *Tr[r]* is the total count in
+            the heldout distribution for all samples that occur *r*
+            times in base distribution.
+        :type Nr: list(float)
+        :param Nr: The list *Nr*, where *Nr[r]* is the number of
+            samples that occur *r* times in the base distribution.
+        :type N: int
+        :param N: The total number of outcomes recorded by the heldout
+            frequency distribution.
+        """
+        estimate = []
+        for r in range(self._max_r + 1):
+            if Nr[r] == 0:
+                estimate.append(None)
+            else:
+                estimate.append(Tr[r] / (Nr[r] * N))
+        return estimate
+
+    def base_fdist(self):
+        """
+        Return the base frequency distribution that this probability
+        distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._base_fdist
+
+    def heldout_fdist(self):
+        """
+        Return the heldout frequency distribution that this
+        probability distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._heldout_fdist
+
+    def samples(self):
+        return self._base_fdist.keys()
+
+    def prob(self, sample):
+        # Use our precomputed probability estimate.
+        r = self._base_fdist[sample]
+        return self._estimate[r]
+
+    def max(self):
+        # Note: the Heldout estimation is *not* necessarily monotonic;
+        # so this implementation is currently broken.  However, it
+        # should give the right answer *most* of the time. :)
+        return self._base_fdist.max()
+
+    def discount(self):
+        raise NotImplementedError()
+
+    def __repr__(self):
+        """
+        :rtype: str
+        :return: A string representation of this ``ProbDist``.
+        """
+        s = "<HeldoutProbDist: %d base samples; %d heldout samples>"
+        return s % (self._base_fdist.N(), self._heldout_fdist.N())
+
+
+class CrossValidationProbDist(ProbDistI):
+    """
+    The cross-validation estimate for the probability distribution of
+    the experiment used to generate a set of frequency distribution.
+    The "cross-validation estimate" for the probability of a sample
+    is found by averaging the held-out estimates for the sample in
+    each pair of frequency distributions.
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, freqdists, bins):
+        """
+        Use the cross-validation estimate to create a probability
+        distribution for the experiment used to generate
+        ``freqdists``.
+
+        :type freqdists: list(FreqDist)
+        :param freqdists: A list of the frequency distributions
+            generated by the experiment.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        self._freqdists = freqdists
+
+        # Create a heldout probability distribution for each pair of
+        # frequency distributions in freqdists.
+        self._heldout_probdists = []
+        for fdist1 in freqdists:
+            for fdist2 in freqdists:
+                if fdist1 is not fdist2:
+                    probdist = HeldoutProbDist(fdist1, fdist2, bins)
+                    self._heldout_probdists.append(probdist)
+
+    def freqdists(self):
+        """
+        Return the list of frequency distributions that this ``ProbDist`` is based on.
+
+        :rtype: list(FreqDist)
+        """
+        return self._freqdists
+
+    def samples(self):
+        # [xx] nb: this is not too efficient
+        return set(sum((list(fd) for fd in self._freqdists), []))
+
+    def prob(self, sample):
+        # Find the average probability estimate returned by each
+        # heldout distribution.
+        prob = 0.0
+        for heldout_probdist in self._heldout_probdists:
+            prob += heldout_probdist.prob(sample)
+        return prob / len(self._heldout_probdists)
+
+    def discount(self):
+        raise NotImplementedError()
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<CrossValidationProbDist: %d-way>" % len(self._freqdists)
+
+
+class WittenBellProbDist(ProbDistI):
+    """
+    The Witten-Bell estimate of a probability distribution. This distribution
+    allocates uniform probability mass to as yet unseen events by using the
+    number of events that have only been seen once. The probability mass
+    reserved for unseen events is equal to *T / (N + T)*
+    where *T* is the number of observed event types and *N* is the total
+    number of observed events. This equates to the maximum likelihood estimate
+    of a new type event occurring. The remaining probability mass is discounted
+    such that all probability estimates sum to one, yielding:
+
+        - *p = T / Z (N + T)*, if count = 0
+        - *p = c / (N + T)*, otherwise
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Creates a distribution of Witten-Bell probability estimates.  This
+        distribution allocates uniform probability mass to as yet unseen
+        events by using the number of events that have only been seen once. The
+        probability mass reserved for unseen events is equal to *T / (N + T)*
+        where *T* is the number of observed event types and *N* is the total
+        number of observed events. This equates to the maximum likelihood
+        estimate of a new type event occurring. The remaining probability mass
+        is discounted such that all probability estimates sum to one,
+        yielding:
+
+            - *p = T / Z (N + T)*, if count = 0
+            - *p = c / (N + T)*, otherwise
+
+        The parameters *T* and *N* are taken from the ``freqdist`` parameter
+        (the ``B()`` and ``N()`` values). The normalizing factor *Z* is
+        calculated using these values along with the ``bins`` parameter.
+
+        :param freqdist: The frequency counts upon which to base the
+            estimation.
+        :type freqdist: FreqDist
+        :param bins: The number of possible event types. This must be at least
+            as large as the number of bins in the ``freqdist``. If None, then
+            it's assumed to be equal to that of the ``freqdist``
+        :type bins: int
+        """
+        assert bins is None or bins >= freqdist.B(), (
+            "bins parameter must not be less than %d=freqdist.B()" % freqdist.B()
+        )
+        if bins is None:
+            bins = freqdist.B()
+        self._freqdist = freqdist
+        self._T = self._freqdist.B()
+        self._Z = bins - self._freqdist.B()
+        self._N = self._freqdist.N()
+        # self._P0 is P(0), precalculated for efficiency:
+        if self._N == 0:
+            # if freqdist is empty, we approximate P(0) by a UniformProbDist:
+            self._P0 = 1.0 / self._Z
+        else:
+            self._P0 = self._T / (self._Z * (self._N + self._T))
+
+    def prob(self, sample):
+        # inherit docs from ProbDistI
+        c = self._freqdist[sample]
+        return c / (self._N + self._T) if c != 0 else self._P0
+
+    def max(self):
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def freqdist(self):
+        return self._freqdist
+
+    def discount(self):
+        raise NotImplementedError()
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<WittenBellProbDist based on %d samples>" % self._freqdist.N()
+
+
+##//////////////////////////////////////////////////////
+##  Good-Turing Probability Distributions
+##//////////////////////////////////////////////////////
+
+# Good-Turing frequency estimation was contributed by Alan Turing and
+# his statistical assistant I.J. Good, during their collaboration in
+# the WWII.  It is a statistical technique for predicting the
+# probability of occurrence of objects belonging to an unknown number
+# of species, given past observations of such objects and their
+# species. (In drawing balls from an urn, the 'objects' would be balls
+# and the 'species' would be the distinct colors of the balls (finite
+# but unknown in number).
+#
+# Good-Turing method calculates the probability mass to assign to
+# events with zero or low counts based on the number of events with
+# higher counts. It does so by using the adjusted count *c\**:
+#
+#     - *c\* = (c + 1) N(c + 1) / N(c)*   for c >= 1
+#     - *things with frequency zero in training* = N(1)  for c == 0
+#
+# where *c* is the original count, *N(i)* is the number of event types
+# observed with count *i*. We can think the count of unseen as the count
+# of frequency one (see Jurafsky & Martin 2nd Edition, p101).
+#
+# This method is problematic because the situation ``N(c+1) == 0``
+# is quite common in the original Good-Turing estimation; smoothing or
+# interpolation of *N(i)* values is essential in practice.
+#
+# Bill Gale and Geoffrey Sampson present a simple and effective approach,
+# Simple Good-Turing.  As a smoothing curve they simply use a power curve:
+#
+#     Nr = a*r^b (with b < -1 to give the appropriate hyperbolic
+#     relationship)
+#
+# They estimate a and b by simple linear regression technique on the
+# logarithmic form of the equation:
+#
+#     log Nr = a + b*log(r)
+#
+# However, they suggest that such a simple curve is probably only
+# appropriate for high values of r. For low values of r, they use the
+# measured Nr directly.  (see M&S, p.213)
+#
+# Gale and Sampson propose to use r while the difference between r and
+# r* is 1.96 greater than the standard deviation, and switch to r* if
+# it is less or equal:
+#
+#     |r - r*| > 1.96 * sqrt((r + 1)^2 (Nr+1 / Nr^2) (1 + Nr+1 / Nr))
+#
+# The 1.96 coefficient correspond to a 0.05 significance criterion,
+# some implementations can use a coefficient of 1.65 for a 0.1
+# significance criterion.
+#
+
+##//////////////////////////////////////////////////////
+##  Simple Good-Turing Probablity Distributions
+##//////////////////////////////////////////////////////
+
+
+class SimpleGoodTuringProbDist(ProbDistI):
+    """
+    SimpleGoodTuring ProbDist approximates from frequency to frequency of
+    frequency into a linear line under log space by linear regression.
+    Details of Simple Good-Turing algorithm can be found in:
+
+    - Good Turing smoothing without tears" (Gale & Sampson 1995),
+      Journal of Quantitative Linguistics, vol. 2 pp. 217-237.
+    - "Speech and Language Processing (Jurafsky & Martin),
+      2nd Edition, Chapter 4.5 p103 (log(Nc) =  a + b*log(c))
+    - https://www.grsampson.net/RGoodTur.html
+
+    Given a set of pair (xi, yi),  where the xi denotes the frequency and
+    yi denotes the frequency of frequency, we want to minimize their
+    square variation. E(x) and E(y) represent the mean of xi and yi.
+
+    - slope: b = sigma ((xi-E(x)(yi-E(y))) / sigma ((xi-E(x))(xi-E(x)))
+    - intercept: a = E(y) - b.E(x)
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, freqdist, bins=None):
+        """
+        :param freqdist: The frequency counts upon which to base the
+            estimation.
+        :type freqdist: FreqDist
+        :param bins: The number of possible event types. This must be
+            larger than the number of bins in the ``freqdist``. If None,
+            then it's assumed to be equal to ``freqdist``.B() + 1
+        :type bins: int
+        """
+        assert (
+            bins is None or bins > freqdist.B()
+        ), "bins parameter must not be less than %d=freqdist.B()+1" % (freqdist.B() + 1)
+        if bins is None:
+            bins = freqdist.B() + 1
+        self._freqdist = freqdist
+        self._bins = bins
+        r, nr = self._r_Nr()
+        self.find_best_fit(r, nr)
+        self._switch(r, nr)
+        self._renormalize(r, nr)
+
+    def _r_Nr_non_zero(self):
+        r_Nr = self._freqdist.r_Nr()
+        del r_Nr[0]
+        return r_Nr
+
+    def _r_Nr(self):
+        """
+        Split the frequency distribution in two list (r, Nr), where Nr(r) > 0
+        """
+        nonzero = self._r_Nr_non_zero()
+
+        if not nonzero:
+            return [], []
+        return zip(*sorted(nonzero.items()))
+
+    def find_best_fit(self, r, nr):
+        """
+        Use simple linear regression to tune parameters self._slope and
+        self._intercept in the log-log space based on count and Nr(count)
+        (Work in log space to avoid floating point underflow.)
+        """
+        # For higher sample frequencies the data points becomes horizontal
+        # along line Nr=1. To create a more evident linear model in log-log
+        # space, we average positive Nr values with the surrounding zero
+        # values. (Church and Gale, 1991)
+
+        if not r or not nr:
+            # Empty r or nr?
+            return
+
+        zr = []
+        for j in range(len(r)):
+            i = r[j - 1] if j > 0 else 0
+            k = 2 * r[j] - i if j == len(r) - 1 else r[j + 1]
+            zr_ = 2.0 * nr[j] / (k - i)
+            zr.append(zr_)
+
+        log_r = [math.log(i) for i in r]
+        log_zr = [math.log(i) for i in zr]
+
+        xy_cov = x_var = 0.0
+        x_mean = sum(log_r) / len(log_r)
+        y_mean = sum(log_zr) / len(log_zr)
+        for (x, y) in zip(log_r, log_zr):
+            xy_cov += (x - x_mean) * (y - y_mean)
+            x_var += (x - x_mean) ** 2
+        self._slope = xy_cov / x_var if x_var != 0 else 0.0
+        if self._slope >= -1:
+            warnings.warn(
+                "SimpleGoodTuring did not find a proper best fit "
+                "line for smoothing probabilities of occurrences. "
+                "The probability estimates are likely to be "
+                "unreliable."
+            )
+        self._intercept = y_mean - self._slope * x_mean
+
+    def _switch(self, r, nr):
+        """
+        Calculate the r frontier where we must switch from Nr to Sr
+        when estimating E[Nr].
+        """
+        for i, r_ in enumerate(r):
+            if len(r) == i + 1 or r[i + 1] != r_ + 1:
+                # We are at the end of r, or there is a gap in r
+                self._switch_at = r_
+                break
+
+            Sr = self.smoothedNr
+            smooth_r_star = (r_ + 1) * Sr(r_ + 1) / Sr(r_)
+            unsmooth_r_star = (r_ + 1) * nr[i + 1] / nr[i]
+
+            std = math.sqrt(self._variance(r_, nr[i], nr[i + 1]))
+            if abs(unsmooth_r_star - smooth_r_star) <= 1.96 * std:
+                self._switch_at = r_
+                break
+
+    def _variance(self, r, nr, nr_1):
+        r = float(r)
+        nr = float(nr)
+        nr_1 = float(nr_1)
+        return (r + 1.0) ** 2 * (nr_1 / nr**2) * (1.0 + nr_1 / nr)
+
+    def _renormalize(self, r, nr):
+        """
+        It is necessary to renormalize all the probability estimates to
+        ensure a proper probability distribution results. This can be done
+        by keeping the estimate of the probability mass for unseen items as
+        N(1)/N and renormalizing all the estimates for previously seen items
+        (as Gale and Sampson (1995) propose). (See M&S P.213, 1999)
+        """
+        prob_cov = 0.0
+        for r_, nr_ in zip(r, nr):
+            prob_cov += nr_ * self._prob_measure(r_)
+        if prob_cov:
+            self._renormal = (1 - self._prob_measure(0)) / prob_cov
+
+    def smoothedNr(self, r):
+        """
+        Return the number of samples with count r.
+
+        :param r: The amount of frequency.
+        :type r: int
+        :rtype: float
+        """
+
+        # Nr = a*r^b (with b < -1 to give the appropriate hyperbolic
+        # relationship)
+        # Estimate a and b by simple linear regression technique on
+        # the logarithmic form of the equation: log Nr = a + b*log(r)
+
+        return math.exp(self._intercept + self._slope * math.log(r))
+
+    def prob(self, sample):
+        """
+        Return the sample's probability.
+
+        :param sample: sample of the event
+        :type sample: str
+        :rtype: float
+        """
+        count = self._freqdist[sample]
+        p = self._prob_measure(count)
+        if count == 0:
+            if self._bins == self._freqdist.B():
+                p = 0.0
+            else:
+                p = p / (self._bins - self._freqdist.B())
+        else:
+            p = p * self._renormal
+        return p
+
+    def _prob_measure(self, count):
+        if count == 0 and self._freqdist.N() == 0:
+            return 1.0
+        elif count == 0 and self._freqdist.N() != 0:
+            return self._freqdist.Nr(1) / self._freqdist.N()
+
+        if self._switch_at > count:
+            Er_1 = self._freqdist.Nr(count + 1)
+            Er = self._freqdist.Nr(count)
+        else:
+            Er_1 = self.smoothedNr(count + 1)
+            Er = self.smoothedNr(count)
+
+        r_star = (count + 1) * Er_1 / Er
+        return r_star / self._freqdist.N()
+
+    def check(self):
+        prob_sum = 0.0
+        for i in range(0, len(self._Nr)):
+            prob_sum += self._Nr[i] * self._prob_measure(i) / self._renormal
+        print("Probability Sum:", prob_sum)
+        # assert prob_sum != 1.0, "probability sum should be one!"
+
+    def discount(self):
+        """
+        This function returns the total mass of probability transfers from the
+        seen samples to the unseen samples.
+        """
+        return self.smoothedNr(1) / self._freqdist.N()
+
+    def max(self):
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def freqdist(self):
+        return self._freqdist
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<SimpleGoodTuringProbDist based on %d samples>" % self._freqdist.N()
+
+
+class MutableProbDist(ProbDistI):
+    """
+    An mutable probdist where the probabilities may be easily modified. This
+    simply copies an existing probdist, storing the probability values in a
+    mutable dictionary and providing an update method.
+    """
+
+    def __init__(self, prob_dist, samples, store_logs=True):
+        """
+        Creates the mutable probdist based on the given prob_dist and using
+        the list of samples given. These values are stored as log
+        probabilities if the store_logs flag is set.
+
+        :param prob_dist: the distribution from which to garner the
+            probabilities
+        :type prob_dist: ProbDist
+        :param samples: the complete set of samples
+        :type samples: sequence of any
+        :param store_logs: whether to store the probabilities as logarithms
+        :type store_logs: bool
+        """
+        self._samples = samples
+        self._sample_dict = {samples[i]: i for i in range(len(samples))}
+        self._data = array.array("d", [0.0]) * len(samples)
+        for i in range(len(samples)):
+            if store_logs:
+                self._data[i] = prob_dist.logprob(samples[i])
+            else:
+                self._data[i] = prob_dist.prob(samples[i])
+        self._logs = store_logs
+
+    def max(self):
+        # inherit documentation
+        return max((p, v) for (v, p) in self._sample_dict.items())[1]
+
+    def samples(self):
+        # inherit documentation
+        return self._samples
+
+    def prob(self, sample):
+        # inherit documentation
+        i = self._sample_dict.get(sample)
+        if i is None:
+            return 0.0
+        return 2 ** (self._data[i]) if self._logs else self._data[i]
+
+    def logprob(self, sample):
+        # inherit documentation
+        i = self._sample_dict.get(sample)
+        if i is None:
+            return float("-inf")
+        return self._data[i] if self._logs else math.log(self._data[i], 2)
+
+    def update(self, sample, prob, log=True):
+        """
+        Update the probability for the given sample. This may cause the object
+        to stop being the valid probability distribution - the user must
+        ensure that they update the sample probabilities such that all samples
+        have probabilities between 0 and 1 and that all probabilities sum to
+        one.
+
+        :param sample: the sample for which to update the probability
+        :type sample: any
+        :param prob: the new probability
+        :type prob: float
+        :param log: is the probability already logged
+        :type log: bool
+        """
+        i = self._sample_dict.get(sample)
+        assert i is not None
+        if self._logs:
+            self._data[i] = prob if log else math.log(prob, 2)
+        else:
+            self._data[i] = 2 ** (prob) if log else prob
+
+
+##/////////////////////////////////////////////////////
+##  Kneser-Ney Probability Distribution
+##//////////////////////////////////////////////////////
+
+# This method for calculating probabilities was introduced in 1995 by Reinhard
+# Kneser and Hermann Ney. It was meant to improve the accuracy of language
+# models that use backing-off to deal with sparse data. The authors propose two
+# ways of doing so: a marginal distribution constraint on the back-off
+# distribution and a leave-one-out distribution. For a start, the first one is
+# implemented as a class below.
+#
+# The idea behind a back-off n-gram model is that we have a series of
+# frequency distributions for our n-grams so that in case we have not seen a
+# given n-gram during training (and as a result have a 0 probability for it) we
+# can 'back off' (hence the name!) and try testing whether we've seen the
+# n-1-gram part of the n-gram in training.
+#
+# The novelty of Kneser and Ney's approach was that they decided to fiddle
+# around with the way this latter, backed off probability was being calculated
+# whereas their peers seemed to focus on the primary probability.
+#
+# The implementation below uses one of the techniques described in their paper
+# titled "Improved backing-off for n-gram language modeling." In the same paper
+# another technique is introduced to attempt to smooth the back-off
+# distribution as well as the primary one. There is also a much-cited
+# modification of this method proposed by Chen and Goodman.
+#
+# In order for the implementation of Kneser-Ney to be more efficient, some
+# changes have been made to the original algorithm. Namely, the calculation of
+# the normalizing function gamma has been significantly simplified and
+# combined slightly differently with beta. None of these changes affect the
+# nature of the algorithm, but instead aim to cut out unnecessary calculations
+# and take advantage of storing and retrieving information in dictionaries
+# where possible.
+
+
+class KneserNeyProbDist(ProbDistI):
+    """
+    Kneser-Ney estimate of a probability distribution. This is a version of
+    back-off that counts how likely an n-gram is provided the n-1-gram had
+    been seen in training. Extends the ProbDistI interface, requires a trigram
+    FreqDist instance to train on. Optionally, a different from default discount
+    value can be specified. The default discount is set to 0.75.
+
+    """
+
+    def __init__(self, freqdist, bins=None, discount=0.75):
+        """
+        :param freqdist: The trigram frequency distribution upon which to base
+            the estimation
+        :type freqdist: FreqDist
+        :param bins: Included for compatibility with nltk.tag.hmm
+        :type bins: int or float
+        :param discount: The discount applied when retrieving counts of
+            trigrams
+        :type discount: float (preferred, but can be set to int)
+        """
+
+        if not bins:
+            self._bins = freqdist.B()
+        else:
+            self._bins = bins
+        self._D = discount
+
+        # cache for probability calculation
+        self._cache = {}
+
+        # internal bigram and trigram frequency distributions
+        self._bigrams = defaultdict(int)
+        self._trigrams = freqdist
+
+        # helper dictionaries used to calculate probabilities
+        self._wordtypes_after = defaultdict(float)
+        self._trigrams_contain = defaultdict(float)
+        self._wordtypes_before = defaultdict(float)
+        for w0, w1, w2 in freqdist:
+            self._bigrams[(w0, w1)] += freqdist[(w0, w1, w2)]
+            self._wordtypes_after[(w0, w1)] += 1
+            self._trigrams_contain[w1] += 1
+            self._wordtypes_before[(w1, w2)] += 1
+
+    def prob(self, trigram):
+        # sample must be a triple
+        if len(trigram) != 3:
+            raise ValueError("Expected an iterable with 3 members.")
+        trigram = tuple(trigram)
+        w0, w1, w2 = trigram
+
+        if trigram in self._cache:
+            return self._cache[trigram]
+        else:
+            # if the sample trigram was seen during training
+            if trigram in self._trigrams:
+                prob = (self._trigrams[trigram] - self.discount()) / self._bigrams[
+                    (w0, w1)
+                ]
+
+            # else if the 'rougher' environment was seen during training
+            elif (w0, w1) in self._bigrams and (w1, w2) in self._wordtypes_before:
+                aftr = self._wordtypes_after[(w0, w1)]
+                bfr = self._wordtypes_before[(w1, w2)]
+
+                # the probability left over from alphas
+                leftover_prob = (aftr * self.discount()) / self._bigrams[(w0, w1)]
+
+                # the beta (including normalization)
+                beta = bfr / (self._trigrams_contain[w1] - aftr)
+
+                prob = leftover_prob * beta
+
+            # else the sample was completely unseen during training
+            else:
+                prob = 0.0
+
+            self._cache[trigram] = prob
+            return prob
+
+    def discount(self):
+        """
+        Return the value by which counts are discounted. By default set to 0.75.
+
+        :rtype: float
+        """
+        return self._D
+
+    def set_discount(self, discount):
+        """
+        Set the value by which counts are discounted to the value of discount.
+
+        :param discount: the new value to discount counts by
+        :type discount: float (preferred, but int possible)
+        :rtype: None
+        """
+        self._D = discount
+
+    def samples(self):
+        return self._trigrams.keys()
+
+    def max(self):
+        return self._trigrams.max()
+
+    def __repr__(self):
+        """
+        Return a string representation of this ProbDist
+
+        :rtype: str
+        """
+        return f"<KneserNeyProbDist based on {self._trigrams.N()} trigrams"
+
+
+##//////////////////////////////////////////////////////
+##  Probability Distribution Operations
+##//////////////////////////////////////////////////////
+
+
+def log_likelihood(test_pdist, actual_pdist):
+    if not isinstance(test_pdist, ProbDistI) or not isinstance(actual_pdist, ProbDistI):
+        raise ValueError("expected a ProbDist.")
+    # Is this right?
+    return sum(
+        actual_pdist.prob(s) * math.log(test_pdist.prob(s), 2) for s in actual_pdist
+    )
+
+
+def entropy(pdist):
+    probs = (pdist.prob(s) for s in pdist.samples())
+    return -sum(p * math.log(p, 2) for p in probs)
+
+
+##//////////////////////////////////////////////////////
+##  Conditional Distributions
+##//////////////////////////////////////////////////////
+
+
+class ConditionalFreqDist(defaultdict):
+    """
+    A collection of frequency distributions for a single experiment
+    run under different conditions.  Conditional frequency
+    distributions are used to record the number of times each sample
+    occurred, given the condition under which the experiment was run.
+    For example, a conditional frequency distribution could be used to
+    record the frequency of each word (type) in a document, given its
+    length.  Formally, a conditional frequency distribution can be
+    defined as a function that maps from each condition to the
+    FreqDist for the experiment under that condition.
+
+    Conditional frequency distributions are typically constructed by
+    repeatedly running an experiment under a variety of conditions,
+    and incrementing the sample outcome counts for the appropriate
+    conditions.  For example, the following code will produce a
+    conditional frequency distribution that encodes how often each
+    word type occurs, given the length of that word type:
+
+        >>> from nltk.probability import ConditionalFreqDist
+        >>> from nltk.tokenize import word_tokenize
+        >>> sent = "the the the dog dog some other words that we do not care about"
+        >>> cfdist = ConditionalFreqDist()
+        >>> for word in word_tokenize(sent):
+        ...     condition = len(word)
+        ...     cfdist[condition][word] += 1
+
+    An equivalent way to do this is with the initializer:
+
+        >>> cfdist = ConditionalFreqDist((len(word), word) for word in word_tokenize(sent))
+
+    The frequency distribution for each condition is accessed using
+    the indexing operator:
+
+        >>> cfdist[3]
+        FreqDist({'the': 3, 'dog': 2, 'not': 1})
+        >>> cfdist[3].freq('the')
+        0.5
+        >>> cfdist[3]['dog']
+        2
+
+    When the indexing operator is used to access the frequency
+    distribution for a condition that has not been accessed before,
+    ``ConditionalFreqDist`` creates a new empty FreqDist for that
+    condition.
+
+    """
+
+    def __init__(self, cond_samples=None):
+        """
+        Construct a new empty conditional frequency distribution.  In
+        particular, the count for every sample, under every condition,
+        is zero.
+
+        :param cond_samples: The samples to initialize the conditional
+            frequency distribution with
+        :type cond_samples: Sequence of (condition, sample) tuples
+        """
+        defaultdict.__init__(self, FreqDist)
+
+        if cond_samples:
+            for (cond, sample) in cond_samples:
+                self[cond][sample] += 1
+
+    def __reduce__(self):
+        kv_pairs = ((cond, self[cond]) for cond in self.conditions())
+        return (self.__class__, (), None, None, kv_pairs)
+
+    def conditions(self):
+        """
+        Return a list of the conditions that have been accessed for
+        this ``ConditionalFreqDist``.  Use the indexing operator to
+        access the frequency distribution for a given condition.
+        Note that the frequency distributions for some conditions
+        may contain zero sample outcomes.
+
+        :rtype: list
+        """
+        return list(self.keys())
+
+    def N(self):
+        """
+        Return the total number of sample outcomes that have been
+        recorded by this ``ConditionalFreqDist``.
+
+        :rtype: int
+        """
+        return sum(fdist.N() for fdist in self.values())
+
+    def plot(
+        self,
+        *args,
+        samples=None,
+        title="",
+        cumulative=False,
+        percents=False,
+        conditions=None,
+        show=True,
+        **kwargs,
+    ):
+        """
+        Plot the given samples from the conditional frequency distribution.
+        For a cumulative plot, specify cumulative=True. Additional ``*args`` and
+        ``**kwargs`` are passed to matplotlib's plot function.
+        (Requires Matplotlib to be installed.)
+
+        :param samples: The samples to plot
+        :type samples: list
+        :param title: The title for the graph
+        :type title: str
+        :param cumulative: Whether the plot is cumulative. (default = False)
+        :type cumulative: bool
+        :param percents: Whether the plot uses percents instead of counts. (default = False)
+        :type percents: bool
+        :param conditions: The conditions to plot (default is all)
+        :type conditions: list
+        :param show: Whether to show the plot, or only return the ax.
+        :type show: bool
+        """
+        try:
+            import matplotlib.pyplot as plt  # import statement fix
+        except ImportError as e:
+            raise ValueError(
+                "The plot function requires matplotlib to be installed."
+                "See https://matplotlib.org/"
+            ) from e
+
+        if not conditions:
+            conditions = self.conditions()
+        else:
+            conditions = [c for c in conditions if c in self]
+        if not samples:
+            samples = sorted({v for c in conditions for v in self[c]})
+        if "linewidth" not in kwargs:
+            kwargs["linewidth"] = 2
+        ax = plt.gca()
+        if conditions:
+            freqs = []
+            for condition in conditions:
+                if cumulative:
+                    # freqs should be a list of list where each sub list will be a frequency of a condition
+                    freq = list(self[condition]._cumulative_frequencies(samples))
+                else:
+                    freq = [self[condition][sample] for sample in samples]
+
+                if percents:
+                    freq = [f / self[condition].N() * 100 for f in freq]
+
+                freqs.append(freq)
+
+            if cumulative:
+                ylabel = "Cumulative "
+                legend_loc = "lower right"
+            else:
+                ylabel = ""
+                legend_loc = "upper right"
+
+            if percents:
+                ylabel += "Percents"
+            else:
+                ylabel += "Counts"
+
+            i = 0
+            for freq in freqs:
+                kwargs["label"] = conditions[i]  # label for each condition
+                i += 1
+                ax.plot(freq, *args, **kwargs)
+            ax.legend(loc=legend_loc)
+            ax.grid(True, color="silver")
+            ax.set_xticks(range(len(samples)))
+            ax.set_xticklabels([str(s) for s in samples], rotation=90)
+            if title:
+                ax.set_title(title)
+            ax.set_xlabel("Samples")
+            ax.set_ylabel(ylabel)
+
+        if show:
+            plt.show()
+
+        return ax
+
+    def tabulate(self, *args, **kwargs):
+        """
+        Tabulate the given samples from the conditional frequency distribution.
+
+        :param samples: The samples to plot
+        :type samples: list
+        :param conditions: The conditions to plot (default is all)
+        :type conditions: list
+        :param cumulative: A flag to specify whether the freqs are cumulative (default = False)
+        :type title: bool
+        """
+
+        cumulative = _get_kwarg(kwargs, "cumulative", False)
+        conditions = _get_kwarg(kwargs, "conditions", sorted(self.conditions()))
+        samples = _get_kwarg(
+            kwargs,
+            "samples",
+            sorted({v for c in conditions if c in self for v in self[c]}),
+        )  # this computation could be wasted
+
+        width = max(len("%s" % s) for s in samples)
+        freqs = dict()
+        for c in conditions:
+            if cumulative:
+                freqs[c] = list(self[c]._cumulative_frequencies(samples))
+            else:
+                freqs[c] = [self[c][sample] for sample in samples]
+            width = max(width, max(len("%d" % f) for f in freqs[c]))
+
+        condition_size = max(len("%s" % c) for c in conditions)
+        print(" " * condition_size, end=" ")
+        for s in samples:
+            print("%*s" % (width, s), end=" ")
+        print()
+        for c in conditions:
+            print("%*s" % (condition_size, c), end=" ")
+            for f in freqs[c]:
+                print("%*d" % (width, f), end=" ")
+            print()
+
+    # Mathematical operators
+
+    def __add__(self, other):
+        """
+        Add counts from two ConditionalFreqDists.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = self.copy()
+        for cond in other.conditions():
+            result[cond] += other[cond]
+        return result
+
+    def __sub__(self, other):
+        """
+        Subtract count, but keep only results with positive counts.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = self.copy()
+        for cond in other.conditions():
+            result[cond] -= other[cond]
+            if not result[cond]:
+                del result[cond]
+        return result
+
+    def __or__(self, other):
+        """
+        Union is the maximum of value in either of the input counters.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = self.copy()
+        for cond in other.conditions():
+            result[cond] |= other[cond]
+        return result
+
+    def __and__(self, other):
+        """
+        Intersection is the minimum of corresponding counts.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = ConditionalFreqDist()
+        for cond in self.conditions():
+            newfreqdist = self[cond] & other[cond]
+            if newfreqdist:
+                result[cond] = newfreqdist
+        return result
+
+    # @total_ordering doesn't work here, since the class inherits from a builtin class
+    def __le__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types("<=", self, other)
+        return set(self.conditions()).issubset(other.conditions()) and all(
+            self[c] <= other[c] for c in self.conditions()
+        )
+
+    def __lt__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types("<", self, other)
+        return self <= other and self != other
+
+    def __ge__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types(">=", self, other)
+        return other <= self
+
+    def __gt__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types(">", self, other)
+        return other < self
+
+    def deepcopy(self):
+        from copy import deepcopy
+
+        return deepcopy(self)
+
+    copy = deepcopy
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ConditionalFreqDist``.
+
+        :rtype: str
+        """
+        return "<ConditionalFreqDist with %d conditions>" % len(self)
+
+
+class ConditionalProbDistI(dict, metaclass=ABCMeta):
+    """
+    A collection of probability distributions for a single experiment
+    run under different conditions.  Conditional probability
+    distributions are used to estimate the likelihood of each sample,
+    given the condition under which the experiment was run.  For
+    example, a conditional probability distribution could be used to
+    estimate the probability of each word type in a document, given
+    the length of the word type.  Formally, a conditional probability
+    distribution can be defined as a function that maps from each
+    condition to the ``ProbDist`` for the experiment under that
+    condition.
+    """
+
+    @abstractmethod
+    def __init__(self):
+        """
+        Classes inheriting from ConditionalProbDistI should implement __init__.
+        """
+
+    def conditions(self):
+        """
+        Return a list of the conditions that are represented by
+        this ``ConditionalProbDist``.  Use the indexing operator to
+        access the probability distribution for a given condition.
+
+        :rtype: list
+        """
+        return list(self.keys())
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ConditionalProbDist``.
+
+        :rtype: str
+        """
+        return "<%s with %d conditions>" % (type(self).__name__, len(self))
+
+
+class ConditionalProbDist(ConditionalProbDistI):
+    """
+    A conditional probability distribution modeling the experiments
+    that were used to generate a conditional frequency distribution.
+    A ConditionalProbDist is constructed from a
+    ``ConditionalFreqDist`` and a ``ProbDist`` factory:
+
+    - The ``ConditionalFreqDist`` specifies the frequency
+      distribution for each condition.
+    - The ``ProbDist`` factory is a function that takes a
+      condition's frequency distribution, and returns its
+      probability distribution.  A ``ProbDist`` class's name (such as
+      ``MLEProbDist`` or ``HeldoutProbDist``) can be used to specify
+      that class's constructor.
+
+    The first argument to the ``ProbDist`` factory is the frequency
+    distribution that it should model; and the remaining arguments are
+    specified by the ``factory_args`` parameter to the
+    ``ConditionalProbDist`` constructor.  For example, the following
+    code constructs a ``ConditionalProbDist``, where the probability
+    distribution for each condition is an ``ELEProbDist`` with 10 bins:
+
+        >>> from nltk.corpus import brown
+        >>> from nltk.probability import ConditionalFreqDist
+        >>> from nltk.probability import ConditionalProbDist, ELEProbDist
+        >>> cfdist = ConditionalFreqDist(brown.tagged_words()[:5000])
+        >>> cpdist = ConditionalProbDist(cfdist, ELEProbDist, 10)
+        >>> cpdist['passed'].max()
+        'VBD'
+        >>> cpdist['passed'].prob('VBD') #doctest: +ELLIPSIS
+        0.423...
+
+    """
+
+    def __init__(self, cfdist, probdist_factory, *factory_args, **factory_kw_args):
+        """
+        Construct a new conditional probability distribution, based on
+        the given conditional frequency distribution and ``ProbDist``
+        factory.
+
+        :type cfdist: ConditionalFreqDist
+        :param cfdist: The ``ConditionalFreqDist`` specifying the
+            frequency distribution for each condition.
+        :type probdist_factory: class or function
+        :param probdist_factory: The function or class that maps
+            a condition's frequency distribution to its probability
+            distribution.  The function is called with the frequency
+            distribution as its first argument,
+            ``factory_args`` as its remaining arguments, and
+            ``factory_kw_args`` as keyword arguments.
+        :type factory_args: (any)
+        :param factory_args: Extra arguments for ``probdist_factory``.
+            These arguments are usually used to specify extra
+            properties for the probability distributions of individual
+            conditions, such as the number of bins they contain.
+        :type factory_kw_args: (any)
+        :param factory_kw_args: Extra keyword arguments for ``probdist_factory``.
+        """
+        self._probdist_factory = probdist_factory
+        self._factory_args = factory_args
+        self._factory_kw_args = factory_kw_args
+
+        for condition in cfdist:
+            self[condition] = probdist_factory(
+                cfdist[condition], *factory_args, **factory_kw_args
+            )
+
+    def __missing__(self, key):
+        self[key] = self._probdist_factory(
+            FreqDist(), *self._factory_args, **self._factory_kw_args
+        )
+        return self[key]
+
+
+class DictionaryConditionalProbDist(ConditionalProbDistI):
+    """
+    An alternative ConditionalProbDist that simply wraps a dictionary of
+    ProbDists rather than creating these from FreqDists.
+    """
+
+    def __init__(self, probdist_dict):
+        """
+        :param probdist_dict: a dictionary containing the probdists indexed
+            by the conditions
+        :type probdist_dict: dict any -> probdist
+        """
+        self.update(probdist_dict)
+
+    def __missing__(self, key):
+        self[key] = DictionaryProbDist()
+        return self[key]
+
+
+##//////////////////////////////////////////////////////
+## Adding in log-space.
+##//////////////////////////////////////////////////////
+
+# If the difference is bigger than this, then just take the bigger one:
+_ADD_LOGS_MAX_DIFF = math.log(1e-30, 2)
+
+
+def add_logs(logx, logy):
+    """
+    Given two numbers ``logx`` = *log(x)* and ``logy`` = *log(y)*, return
+    *log(x+y)*.  Conceptually, this is the same as returning
+    ``log(2**(logx)+2**(logy))``, but the actual implementation
+    avoids overflow errors that could result from direct computation.
+    """
+    if logx < logy + _ADD_LOGS_MAX_DIFF:
+        return logy
+    if logy < logx + _ADD_LOGS_MAX_DIFF:
+        return logx
+    base = min(logx, logy)
+    return base + math.log(2 ** (logx - base) + 2 ** (logy - base), 2)
+
+
+def sum_logs(logs):
+    return reduce(add_logs, logs[1:], logs[0]) if len(logs) != 0 else _NINF
+
+
+##//////////////////////////////////////////////////////
+##  Probabilistic Mix-in
+##//////////////////////////////////////////////////////
+
+
+class ProbabilisticMixIn:
+    """
+    A mix-in class to associate probabilities with other classes
+    (trees, rules, etc.).  To use the ``ProbabilisticMixIn`` class,
+    define a new class that derives from an existing class and from
+    ProbabilisticMixIn.  You will need to define a new constructor for
+    the new class, which explicitly calls the constructors of both its
+    parent classes.  For example:
+
+        >>> from nltk.probability import ProbabilisticMixIn
+        >>> class A:
+        ...     def __init__(self, x, y): self.data = (x,y)
+        ...
+        >>> class ProbabilisticA(A, ProbabilisticMixIn):
+        ...     def __init__(self, x, y, **prob_kwarg):
+        ...         A.__init__(self, x, y)
+        ...         ProbabilisticMixIn.__init__(self, **prob_kwarg)
+
+    See the documentation for the ProbabilisticMixIn
+    ``constructor<__init__>`` for information about the arguments it
+    expects.
+
+    You should generally also redefine the string representation
+    methods, the comparison methods, and the hashing method.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize this object's probability.  This initializer should
+        be called by subclass constructors.  ``prob`` should generally be
+        the first argument for those constructors.
+
+        :param prob: The probability associated with the object.
+        :type prob: float
+        :param logprob: The log of the probability associated with
+            the object.
+        :type logprob: float
+        """
+        if "prob" in kwargs:
+            if "logprob" in kwargs:
+                raise TypeError("Must specify either prob or logprob " "(not both)")
+            else:
+                ProbabilisticMixIn.set_prob(self, kwargs["prob"])
+        elif "logprob" in kwargs:
+            ProbabilisticMixIn.set_logprob(self, kwargs["logprob"])
+        else:
+            self.__prob = self.__logprob = None
+
+    def set_prob(self, prob):
+        """
+        Set the probability associated with this object to ``prob``.
+
+        :param prob: The new probability
+        :type prob: float
+        """
+        self.__prob = prob
+        self.__logprob = None
+
+    def set_logprob(self, logprob):
+        """
+        Set the log probability associated with this object to
+        ``logprob``.  I.e., set the probability associated with this
+        object to ``2**(logprob)``.
+
+        :param logprob: The new log probability
+        :type logprob: float
+        """
+        self.__logprob = logprob
+        self.__prob = None
+
+    def prob(self):
+        """
+        Return the probability associated with this object.
+
+        :rtype: float
+        """
+        if self.__prob is None:
+            if self.__logprob is None:
+                return None
+            self.__prob = 2 ** (self.__logprob)
+        return self.__prob
+
+    def logprob(self):
+        """
+        Return ``log(p)``, where ``p`` is the probability associated
+        with this object.
+
+        :rtype: float
+        """
+        if self.__logprob is None:
+            if self.__prob is None:
+                return None
+            self.__logprob = math.log(self.__prob, 2)
+        return self.__logprob
+
+
+class ImmutableProbabilisticMixIn(ProbabilisticMixIn):
+    def set_prob(self, prob):
+        raise ValueError("%s is immutable" % self.__class__.__name__)
+
+    def set_logprob(self, prob):
+        raise ValueError("%s is immutable" % self.__class__.__name__)
+
+
+## Helper function for processing keyword arguments
+
+
+def _get_kwarg(kwargs, key, default):
+    if key in kwargs:
+        arg = kwargs[key]
+        del kwargs[key]
+    else:
+        arg = default
+    return arg
+
+
+##//////////////////////////////////////////////////////
+##  Demonstration
+##//////////////////////////////////////////////////////
+
+
+def _create_rand_fdist(numsamples, numoutcomes):
+    """
+    Create a new frequency distribution, with random samples.  The
+    samples are numbers from 1 to ``numsamples``, and are generated by
+    summing two numbers, each of which has a uniform distribution.
+    """
+
+    fdist = FreqDist()
+    for x in range(numoutcomes):
+        y = random.randint(1, (1 + numsamples) // 2) + random.randint(
+            0, numsamples // 2
+        )
+        fdist[y] += 1
+    return fdist
+
+
+def _create_sum_pdist(numsamples):
+    """
+    Return the true probability distribution for the experiment
+    ``_create_rand_fdist(numsamples, x)``.
+    """
+    fdist = FreqDist()
+    for x in range(1, (1 + numsamples) // 2 + 1):
+        for y in range(0, numsamples // 2 + 1):
+            fdist[x + y] += 1
+    return MLEProbDist(fdist)
+
+
+def demo(numsamples=6, numoutcomes=500):
+    """
+    A demonstration of frequency distributions and probability
+    distributions.  This demonstration creates three frequency
+    distributions with, and uses them to sample a random process with
+    ``numsamples`` samples.  Each frequency distribution is sampled
+    ``numoutcomes`` times.  These three frequency distributions are
+    then used to build six probability distributions.  Finally, the
+    probability estimates of these distributions are compared to the
+    actual probability of each sample.
+
+    :type numsamples: int
+    :param numsamples: The number of samples to use in each demo
+        frequency distributions.
+    :type numoutcomes: int
+    :param numoutcomes: The total number of outcomes for each
+        demo frequency distribution.  These outcomes are divided into
+        ``numsamples`` bins.
+    :rtype: None
+    """
+
+    # Randomly sample a stochastic process three times.
+    fdist1 = _create_rand_fdist(numsamples, numoutcomes)
+    fdist2 = _create_rand_fdist(numsamples, numoutcomes)
+    fdist3 = _create_rand_fdist(numsamples, numoutcomes)
+
+    # Use our samples to create probability distributions.
+    pdists = [
+        MLEProbDist(fdist1),
+        LidstoneProbDist(fdist1, 0.5, numsamples),
+        HeldoutProbDist(fdist1, fdist2, numsamples),
+        HeldoutProbDist(fdist2, fdist1, numsamples),
+        CrossValidationProbDist([fdist1, fdist2, fdist3], numsamples),
+        SimpleGoodTuringProbDist(fdist1),
+        SimpleGoodTuringProbDist(fdist1, 7),
+        _create_sum_pdist(numsamples),
+    ]
+
+    # Find the probability of each sample.
+    vals = []
+    for n in range(1, numsamples + 1):
+        vals.append(tuple([n, fdist1.freq(n)] + [pdist.prob(n) for pdist in pdists]))
+
+    # Print the results in a formatted table.
+    print(
+        "%d samples (1-%d); %d outcomes were sampled for each FreqDist"
+        % (numsamples, numsamples, numoutcomes)
+    )
+    print("=" * 9 * (len(pdists) + 2))
+    FORMATSTR = "      FreqDist " + "%8s " * (len(pdists) - 1) + "|  Actual"
+    print(FORMATSTR % tuple(repr(pdist)[1:9] for pdist in pdists[:-1]))
+    print("-" * 9 * (len(pdists) + 2))
+    FORMATSTR = "%3d   %8.6f " + "%8.6f " * (len(pdists) - 1) + "| %8.6f"
+    for val in vals:
+        print(FORMATSTR % val)
+
+    # Print the totals for each column (should all be 1.0)
+    zvals = list(zip(*vals))
+    sums = [sum(val) for val in zvals[1:]]
+    print("-" * 9 * (len(pdists) + 2))
+    FORMATSTR = "Total " + "%8.6f " * (len(pdists)) + "| %8.6f"
+    print(FORMATSTR % tuple(sums))
+    print("=" * 9 * (len(pdists) + 2))
+
+    # Display the distributions themselves, if they're short enough.
+    if len("%s" % fdist1) < 70:
+        print("  fdist1: %s" % fdist1)
+        print("  fdist2: %s" % fdist2)
+        print("  fdist3: %s" % fdist3)
+    print()
+
+    print("Generating:")
+    for pdist in pdists:
+        fdist = FreqDist(pdist.generate() for i in range(5000))
+        print("{:>20} {}".format(pdist.__class__.__name__[:20], ("%s" % fdist)[:55]))
+    print()
+
+
+def gt_demo():
+    from nltk import corpus
+
+    emma_words = corpus.gutenberg.words("austen-emma.txt")
+    fd = FreqDist(emma_words)
+    sgt = SimpleGoodTuringProbDist(fd)
+    print("{:>18} {:>8}  {:>14}".format("word", "frequency", "SimpleGoodTuring"))
+    fd_keys_sorted = (
+        key for key, value in sorted(fd.items(), key=lambda item: item[1], reverse=True)
+    )
+    for key in fd_keys_sorted:
+        print("%18s %8d  %14e" % (key, fd[key], sgt.prob(key)))
+
+
+if __name__ == "__main__":
+    demo(6, 10)
+    demo(5, 5000)
+    gt_demo()
+
+__all__ = [
+    "ConditionalFreqDist",
+    "ConditionalProbDist",
+    "ConditionalProbDistI",
+    "CrossValidationProbDist",
+    "DictionaryConditionalProbDist",
+    "DictionaryProbDist",
+    "ELEProbDist",
+    "FreqDist",
+    "SimpleGoodTuringProbDist",
+    "HeldoutProbDist",
+    "ImmutableProbabilisticMixIn",
+    "LaplaceProbDist",
+    "LidstoneProbDist",
+    "MLEProbDist",
+    "MutableProbDist",
+    "KneserNeyProbDist",
+    "ProbDistI",
+    "ProbabilisticMixIn",
+    "UniformProbDist",
+    "WittenBellProbDist",
+    "add_logs",
+    "log_likelihood",
+    "sum_logs",
+    "entropy",
+]

lib/python3.10/site-packages/nltk/test/bleu.doctest

@@ -0,0 +1,29 @@
+==========
+BLEU tests
+==========
+
+>>> from nltk.translate import bleu
+
+If the candidate has no alignment to any of the references, the BLEU score is 0.
+
+>>> bleu(
+...     ['The candidate has no alignment to any of the references'.split()],
+...     'John loves Mary'.split(),
+...     (1,),
+... )
+0
+
+This is an implementation of the smoothing techniques
+for segment-level BLEU scores that was presented in
+Boxing Chen and Collin Cherry (2014) A Systematic Comparison of
+Smoothing Techniques for Sentence-Level BLEU. In WMT14.
+http://acl2014.org/acl2014/W14-33/pdf/W14-3346.pdf
+>>> from nltk.translate.bleu_score import sentence_bleu,SmoothingFunction
+
+
+>>> sentence_bleu(
+...     ['It is a place of quiet contemplation .'.split()],
+...     'It is .'.split(),
+...     smoothing_function=SmoothingFunction().method4,
+... )*100
+4.4267...

lib/python3.10/site-packages/nltk/test/ccg.doctest

@@ -0,0 +1,376 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+==============================
+Combinatory Categorial Grammar
+==============================
+
+Relative Clauses
+----------------
+
+    >>> from nltk.ccg import chart, lexicon
+
+Construct a lexicon:
+
+    >>> lex = lexicon.fromstring('''
+    ...     :- S, NP, N, VP
+    ...
+    ...     Det :: NP/N
+    ...     Pro :: NP
+    ...     Modal :: S\\NP/VP
+    ...
+    ...     TV :: VP/NP
+    ...     DTV :: TV/NP
+    ...
+    ...     the => Det
+    ...
+    ...     that => Det
+    ...     that => NP
+    ...
+    ...     I => Pro
+    ...     you => Pro
+    ...     we => Pro
+    ...
+    ...     chef => N
+    ...     cake => N
+    ...     children => N
+    ...     dough => N
+    ...
+    ...     will => Modal
+    ...     should => Modal
+    ...     might => Modal
+    ...     must => Modal
+    ...
+    ...     and => var\\.,var/.,var
+    ...
+    ...     to => VP[to]/VP
+    ...
+    ...     without => (VP\\VP)/VP[ing]
+    ...
+    ...     be => TV
+    ...     cook => TV
+    ...     eat => TV
+    ...
+    ...     cooking => VP[ing]/NP
+    ...
+    ...     give => DTV
+    ...
+    ...     is => (S\\NP)/NP
+    ...     prefer => (S\\NP)/NP
+    ...
+    ...     which => (N\\N)/(S/NP)
+    ...
+    ...     persuade => (VP/VP[to])/NP
+    ...     ''')
+
+    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
+    >>> for parse in parser.parse("you prefer that cake".split()):
+    ...     chart.printCCGDerivation(parse)
+    ...     break
+    ...
+     you    prefer      that   cake
+     NP   ((S\NP)/NP)  (NP/N)   N
+                      -------------->
+                            NP
+         --------------------------->
+                   (S\NP)
+    --------------------------------<
+                   S
+
+    >>> for parse in parser.parse("that is the cake which you prefer".split()):
+    ...     chart.printCCGDerivation(parse)
+    ...     break
+    ...
+     that      is        the    cake      which       you    prefer
+      NP   ((S\NP)/NP)  (NP/N)   N    ((N\N)/(S/NP))  NP   ((S\NP)/NP)
+                                                     ----->T
+                                                  (S/(S\NP))
+                                                     ------------------>B
+                                                           (S/NP)
+                                     ---------------------------------->
+                                                   (N\N)
+                               ----------------------------------------<
+                                                  N
+                       ------------------------------------------------>
+                                              NP
+          ------------------------------------------------------------->
+                                     (S\NP)
+    -------------------------------------------------------------------<
+                                     S
+
+
+Some other sentences to try:
+"that is the cake which we will persuade the chef to cook"
+"that is the cake which we will persuade the chef to give the children"
+
+    >>> sent = "that is the dough which you will eat without cooking".split()
+    >>> nosub_parser = chart.CCGChartParser(lex, chart.ApplicationRuleSet +
+    ...                       chart.CompositionRuleSet + chart.TypeRaiseRuleSet)
+
+Without Substitution (no output)
+
+    >>> for parse in nosub_parser.parse(sent):
+    ...     chart.printCCGDerivation(parse)
+
+With Substitution:
+
+    >>> for parse in parser.parse(sent):
+    ...     chart.printCCGDerivation(parse)
+    ...     break
+    ...
+     that      is        the    dough      which       you     will        eat          without           cooking
+      NP   ((S\NP)/NP)  (NP/N)    N    ((N\N)/(S/NP))  NP   ((S\NP)/VP)  (VP/NP)  ((VP\VP)/VP['ing'])  (VP['ing']/NP)
+                                                      ----->T
+                                                   (S/(S\NP))
+                                                                                 ------------------------------------->B
+                                                                                             ((VP\VP)/NP)
+                                                                        ----------------------------------------------<Sx
+                                                                                           (VP/NP)
+                                                           ----------------------------------------------------------->B
+                                                                                   ((S\NP)/NP)
+                                                      ---------------------------------------------------------------->B
+                                                                                   (S/NP)
+                                      -------------------------------------------------------------------------------->
+                                                                           (N\N)
+                               ---------------------------------------------------------------------------------------<
+                                                                          N
+                       ----------------------------------------------------------------------------------------------->
+                                                                     NP
+          ------------------------------------------------------------------------------------------------------------>
+                                                             (S\NP)
+    ------------------------------------------------------------------------------------------------------------------<
+                                                            S
+
+
+Conjunction
+-----------
+
+    >>> from nltk.ccg.chart import CCGChartParser, ApplicationRuleSet, CompositionRuleSet
+    >>> from nltk.ccg.chart import SubstitutionRuleSet, TypeRaiseRuleSet, printCCGDerivation
+    >>> from nltk.ccg import lexicon
+
+Lexicons for the tests:
+
+    >>> test1_lex = '''
+    ...        :- S,N,NP,VP
+    ...        I => NP
+    ...        you => NP
+    ...        will => S\\NP/VP
+    ...        cook => VP/NP
+    ...        which => (N\\N)/(S/NP)
+    ...        and => var\\.,var/.,var
+    ...        might => S\\NP/VP
+    ...        eat => VP/NP
+    ...        the => NP/N
+    ...        mushrooms => N
+    ...        parsnips => N'''
+    >>> test2_lex = '''
+    ...         :- N, S, NP, VP
+    ...         articles => N
+    ...         the => NP/N
+    ...         and => var\\.,var/.,var
+    ...         which => (N\\N)/(S/NP)
+    ...         I => NP
+    ...         anyone => NP
+    ...         will => (S/VP)\\NP
+    ...         file => VP/NP
+    ...         without => (VP\\VP)/VP[ing]
+    ...         forget => VP/NP
+    ...         reading => VP[ing]/NP
+    ...         '''
+
+Tests handling of conjunctions.
+Note that while the two derivations are different, they are semantically equivalent.
+
+    >>> lex = lexicon.fromstring(test1_lex)
+    >>> parser = CCGChartParser(lex, ApplicationRuleSet + CompositionRuleSet + SubstitutionRuleSet)
+    >>> for parse in parser.parse("I will cook and might eat the mushrooms and parsnips".split()):
+    ...     printCCGDerivation(parse)
+     I      will       cook               and                might       eat     the    mushrooms             and             parsnips
+     NP  ((S\NP)/VP)  (VP/NP)  ((_var0\.,_var0)/.,_var0)  ((S\NP)/VP)  (VP/NP)  (NP/N)      N      ((_var0\.,_var0)/.,_var0)     N
+        ---------------------->B
+             ((S\NP)/NP)
+                                                         ---------------------->B
+                                                              ((S\NP)/NP)
+                              ------------------------------------------------->
+                                         (((S\NP)/NP)\.,((S\NP)/NP))
+        -----------------------------------------------------------------------<
+                                      ((S\NP)/NP)
+                                                                                                  ------------------------------------->
+                                                                                                                 (N\.,N)
+                                                                                       ------------------------------------------------<
+                                                                                                              N
+                                                                               -------------------------------------------------------->
+                                                                                                          NP
+        ------------------------------------------------------------------------------------------------------------------------------->
+                                                                    (S\NP)
+    -----------------------------------------------------------------------------------------------------------------------------------<
+                                                                     S
+     I      will       cook               and                might       eat     the    mushrooms             and             parsnips
+     NP  ((S\NP)/VP)  (VP/NP)  ((_var0\.,_var0)/.,_var0)  ((S\NP)/VP)  (VP/NP)  (NP/N)      N      ((_var0\.,_var0)/.,_var0)     N
+        ---------------------->B
+             ((S\NP)/NP)
+                                                         ---------------------->B
+                                                              ((S\NP)/NP)
+                              ------------------------------------------------->
+                                         (((S\NP)/NP)\.,((S\NP)/NP))
+        -----------------------------------------------------------------------<
+                                      ((S\NP)/NP)
+        ------------------------------------------------------------------------------->B
+                                          ((S\NP)/N)
+                                                                                                  ------------------------------------->
+                                                                                                                 (N\.,N)
+                                                                                       ------------------------------------------------<
+                                                                                                              N
+        ------------------------------------------------------------------------------------------------------------------------------->
+                                                                    (S\NP)
+    -----------------------------------------------------------------------------------------------------------------------------------<
+                                                                     S
+
+
+Tests handling subject extraction.
+Interesting to point that the two parses are clearly semantically different.
+
+    >>> lex = lexicon.fromstring(test2_lex)
+    >>> parser = CCGChartParser(lex, ApplicationRuleSet + CompositionRuleSet + SubstitutionRuleSet)
+    >>> for parse in parser.parse("articles which I will file and forget without reading".split()):
+    ...     printCCGDerivation(parse)
+     articles      which       I      will       file               and             forget         without           reading
+        N      ((N\N)/(S/NP))  NP  ((S/VP)\NP)  (VP/NP)  ((_var0\.,_var0)/.,_var0)  (VP/NP)  ((VP\VP)/VP['ing'])  (VP['ing']/NP)
+                              -----------------<
+                                   (S/VP)
+                                                                                            ------------------------------------->B
+                                                                                                        ((VP\VP)/NP)
+                                                                                   ----------------------------------------------<Sx
+                                                                                                      (VP/NP)
+                                                        ------------------------------------------------------------------------->
+                                                                                   ((VP/NP)\.,(VP/NP))
+                                               ----------------------------------------------------------------------------------<
+                                                                                    (VP/NP)
+                              --------------------------------------------------------------------------------------------------->B
+                                                                            (S/NP)
+              ------------------------------------------------------------------------------------------------------------------->
+                                                                     (N\N)
+    -----------------------------------------------------------------------------------------------------------------------------<
+                                                                  N
+     articles      which       I      will       file               and             forget         without           reading
+        N      ((N\N)/(S/NP))  NP  ((S/VP)\NP)  (VP/NP)  ((_var0\.,_var0)/.,_var0)  (VP/NP)  ((VP\VP)/VP['ing'])  (VP['ing']/NP)
+                              -----------------<
+                                   (S/VP)
+                                                        ------------------------------------>
+                                                                ((VP/NP)\.,(VP/NP))
+                                               ---------------------------------------------<
+                                                                  (VP/NP)
+                                                                                            ------------------------------------->B
+                                                                                                        ((VP\VP)/NP)
+                                               ----------------------------------------------------------------------------------<Sx
+                                                                                    (VP/NP)
+                              --------------------------------------------------------------------------------------------------->B
+                                                                            (S/NP)
+              ------------------------------------------------------------------------------------------------------------------->
+                                                                     (N\N)
+    -----------------------------------------------------------------------------------------------------------------------------<
+                                                                  N
+
+
+Unicode support
+---------------
+
+Unicode words are supported.
+
+    >>> from nltk.ccg import chart, lexicon
+
+Lexicons for the tests:
+
+    >>> lex = lexicon.fromstring('''
+    ...        :- S, N, NP, PP
+    ...
+    ...        AdjI :: N\\N
+    ...        AdjD :: N/N
+    ...        AdvD :: S/S
+    ...        AdvI :: S\\S
+    ...        Det :: NP/N
+    ...        PrepNPCompl :: PP/NP
+    ...        PrepNAdjN :: S\\S/N
+    ...        PrepNAdjNP :: S\\S/NP
+    ...        VPNP :: S\\NP/NP
+    ...        VPPP :: S\\NP/PP
+    ...        VPser :: S\\NP/AdjI
+    ...
+    ...        auto => N
+    ...        bebidas => N
+    ...        cine => N
+    ...        ley => N
+    ...        libro => N
+    ...        ministro => N
+    ...        panadería => N
+    ...        presidente => N
+    ...        super => N
+    ...
+    ...        el => Det
+    ...        la => Det
+    ...        las => Det
+    ...        un => Det
+    ...
+    ...        Ana => NP
+    ...        Pablo => NP
+    ...
+    ...        y => var\\.,var/.,var
+    ...
+    ...        pero => (S/NP)\\(S/NP)/(S/NP)
+    ...
+    ...        anunció => VPNP
+    ...        compró => VPNP
+    ...        cree => S\\NP/S[dep]
+    ...        desmintió => VPNP
+    ...        lee => VPNP
+    ...        fueron => VPPP
+    ...
+    ...        es => VPser
+    ...
+    ...        interesante => AdjD
+    ...        interesante => AdjI
+    ...        nueva => AdjD
+    ...        nueva => AdjI
+    ...
+    ...        a => PrepNPCompl
+    ...        en => PrepNAdjN
+    ...        en => PrepNAdjNP
+    ...
+    ...        ayer => AdvI
+    ...
+    ...        que => (NP\\NP)/(S/NP)
+    ...        que => S[dep]/S
+    ...     ''')
+
+    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
+    >>> for parse in parser.parse(u"el ministro anunció pero el presidente desmintió la nueva ley".split()):
+    ...     printCCGDerivation(parse) # doctest: +SKIP
+    ...     # it fails on python2.7 because of the unicode problem explained in https://github.com/nltk/nltk/pull/1354
+    ...     break
+       el    ministro    anunció              pero              el    presidente   desmintió     la    nueva  ley
+     (NP/N)     N      ((S\NP)/NP)  (((S/NP)\(S/NP))/(S/NP))  (NP/N)      N       ((S\NP)/NP)  (NP/N)  (N/N)   N
+    ------------------>
+            NP
+    ------------------>T
+        (S/(S\NP))
+                                                             -------------------->
+                                                                      NP
+                                                             -------------------->T
+                                                                  (S/(S\NP))
+                                                             --------------------------------->B
+                                                                          (S/NP)
+                                   ----------------------------------------------------------->
+                                                         ((S/NP)\(S/NP))
+                                                                                                      ------------>
+                                                                                                           N
+                                                                                              -------------------->
+                                                                                                       NP
+                                                                                              --------------------<T
+                                                                                                   (S\(S/NP))
+                                   -------------------------------------------------------------------------------<B
+                                                                     (S\(S/NP))
+                      --------------------------------------------------------------------------------------------<B
+                                                                 (S/NP)
+    -------------------------------------------------------------------------------------------------------------->
+                                                          S

lib/python3.10/site-packages/nltk/test/chat80.doctest

@@ -0,0 +1,232 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+=======
+Chat-80
+=======
+
+Chat-80 was a natural language system which allowed the user to
+interrogate a Prolog knowledge base in the domain of world
+geography. It was developed in the early '80s by Warren and Pereira; see
+`<https://aclanthology.org/J82-3002.pdf>`_ for a description and
+`<http://www.cis.upenn.edu/~pereira/oldies.html>`_ for the source
+files.
+
+The ``chat80`` module contains functions to extract data from the Chat-80
+relation files ('the world database'), and convert then into a format
+that can be incorporated in the FOL models of
+``nltk.sem.evaluate``. The code assumes that the Prolog
+input files are available in the NLTK corpora directory.
+
+The Chat-80 World Database consists of the following files::
+
+    world0.pl
+    rivers.pl
+    cities.pl
+    countries.pl
+    contain.pl
+    borders.pl
+
+This module uses a slightly modified version of ``world0.pl``, in which
+a set of Prolog rules have been omitted. The modified file is named
+``world1.pl``. Currently, the file ``rivers.pl`` is not read in, since
+it uses a list rather than a string in the second field.
+
+Reading Chat-80 Files
+=====================
+
+Chat-80 relations are like tables in a relational database. The
+relation acts as the name of the table; the first argument acts as the
+'primary key'; and subsequent arguments are further fields in the
+table. In general, the name of the table provides a label for a unary
+predicate whose extension is all the primary keys. For example,
+relations in ``cities.pl`` are of the following form::
+
+   'city(athens,greece,1368).'
+
+Here, ``'athens'`` is the key, and will be mapped to a member of the
+unary predicate *city*.
+
+By analogy with NLTK corpora, ``chat80`` defines a number of 'items'
+which correspond to the relations.
+
+    >>> from nltk.sem import chat80
+    >>> print(chat80.items)
+    ('borders', 'circle_of_lat', 'circle_of_long', 'city', ...)
+
+The fields in the table are mapped to binary predicates. The first
+argument of the predicate is the primary key, while the second
+argument is the data in the relevant field. Thus, in the above
+example, the third field is mapped to the binary predicate
+*population_of*, whose extension is a set of pairs such as
+``'(athens, 1368)'``.
+
+An exception to this general framework is required by the relations in
+the files ``borders.pl`` and ``contains.pl``. These contain facts of the
+following form::
+
+    'borders(albania,greece).'
+
+    'contains0(africa,central_africa).'
+
+We do not want to form a unary concept out the element in
+the first field of these records, and we want the label of the binary
+relation just to be ``'border'``/``'contain'`` respectively.
+
+In order to drive the extraction process, we use 'relation metadata bundles'
+which are Python dictionaries such as the following::
+
+  city = {'label': 'city',
+          'closures': [],
+          'schema': ['city', 'country', 'population'],
+          'filename': 'cities.pl'}
+
+According to this, the file ``city['filename']`` contains a list of
+relational tuples (or more accurately, the corresponding strings in
+Prolog form) whose predicate symbol is ``city['label']`` and whose
+relational schema is ``city['schema']``. The notion of a ``closure`` is
+discussed in the next section.
+
+Concepts
+========
+In order to encapsulate the results of the extraction, a class of
+``Concept``\ s is introduced.  A ``Concept`` object has a number of
+attributes, in particular a ``prefLabel``, an arity and ``extension``.
+
+    >>> c1 = chat80.Concept('dog', arity=1, extension=set(['d1', 'd2']))
+    >>> print(c1)
+    Label = 'dog'
+    Arity = 1
+    Extension = ['d1', 'd2']
+
+
+
+The ``extension`` attribute makes it easier to inspect the output of
+the extraction.
+
+    >>> schema = ['city', 'country', 'population']
+    >>> concepts = chat80.clause2concepts('cities.pl', 'city', schema)
+    >>> concepts
+    [Concept('city'), Concept('country_of'), Concept('population_of')]
+    >>> for c in concepts:
+    ...     print("%s:\n\t%s" % (c.prefLabel, c.extension[:4]))
+    city:
+        ['athens', 'bangkok', 'barcelona', 'berlin']
+    country_of:
+        [('athens', 'greece'), ('bangkok', 'thailand'), ('barcelona', 'spain'), ('berlin', 'east_germany')]
+    population_of:
+        [('athens', '1368'), ('bangkok', '1178'), ('barcelona', '1280'), ('berlin', '3481')]
+
+In addition, the ``extension`` can be further
+processed: in the case of the ``'border'`` relation, we check that the
+relation is **symmetric**, and in the case of the ``'contain'``
+relation, we carry out the **transitive closure**. The closure
+properties associated with a concept is indicated in the relation
+metadata, as indicated earlier.
+
+    >>> borders = set([('a1', 'a2'), ('a2', 'a3')])
+    >>> c2 = chat80.Concept('borders', arity=2, extension=borders)
+    >>> print(c2)
+    Label = 'borders'
+    Arity = 2
+    Extension = [('a1', 'a2'), ('a2', 'a3')]
+    >>> c3 = chat80.Concept('borders', arity=2, closures=['symmetric'], extension=borders)
+    >>> c3.close()
+    >>> print(c3)
+    Label = 'borders'
+    Arity = 2
+    Extension = [('a1', 'a2'), ('a2', 'a1'), ('a2', 'a3'), ('a3', 'a2')]
+
+The ``extension`` of a ``Concept`` object is then incorporated into a
+``Valuation`` object.
+
+Persistence
+===========
+The functions ``val_dump`` and ``val_load`` are provided to allow a
+valuation to be stored in a persistent database and re-loaded, rather
+than having to be re-computed each time.
+
+Individuals and Lexical Items
+=============================
+As well as deriving relations from the Chat-80 data, we also create a
+set of individual constants, one for each entity in the domain. The
+individual constants are string-identical to the entities. For
+example, given a data item such as ``'zloty'``, we add to the valuation
+a pair ``('zloty', 'zloty')``. In order to parse English sentences that
+refer to these entities, we also create a lexical item such as the
+following for each individual constant::
+
+   PropN[num=sg, sem=<\P.(P zloty)>] -> 'Zloty'
+
+The set of rules is written to the file ``chat_pnames.fcfg`` in the
+current directory.
+
+SQL Query
+=========
+
+The ``city`` relation is also available in RDB form and can be queried
+using SQL statements.
+
+    >>> import nltk
+    >>> q = "SELECT City, Population FROM city_table WHERE Country = 'china' and Population > 1000"
+    >>> for answer in chat80.sql_query('corpora/city_database/city.db', q):
+    ...     print("%-10s %4s" % answer)
+    canton     1496
+    chungking  1100
+    mukden     1551
+    peking     2031
+    shanghai   5407
+    tientsin   1795
+
+The (deliberately naive) grammar ``sql.fcfg`` translates from English
+to SQL:
+
+    >>> nltk.data.show_cfg('grammars/book_grammars/sql0.fcfg')
+    % start S
+    S[SEM=(?np + WHERE + ?vp)] -> NP[SEM=?np] VP[SEM=?vp]
+    VP[SEM=(?v + ?pp)] -> IV[SEM=?v] PP[SEM=?pp]
+    VP[SEM=(?v + ?ap)] -> IV[SEM=?v] AP[SEM=?ap]
+    NP[SEM=(?det + ?n)] -> Det[SEM=?det] N[SEM=?n]
+    PP[SEM=(?p + ?np)] -> P[SEM=?p] NP[SEM=?np]
+    AP[SEM=?pp] -> A[SEM=?a] PP[SEM=?pp]
+    NP[SEM='Country="greece"'] -> 'Greece'
+    NP[SEM='Country="china"'] -> 'China'
+    Det[SEM='SELECT'] -> 'Which' | 'What'
+    N[SEM='City FROM city_table'] -> 'cities'
+    IV[SEM=''] -> 'are'
+    A[SEM=''] -> 'located'
+    P[SEM=''] -> 'in'
+
+Given this grammar, we can express, and then execute, queries in English.
+
+    >>> cp = nltk.parse.load_parser('grammars/book_grammars/sql0.fcfg')
+    >>> query = 'What cities are in China'
+    >>> for tree in cp.parse(query.split()):
+    ...     answer = tree.label()['SEM']
+    ...     q = " ".join(answer)
+    ...     print(q)
+    ...
+    SELECT City FROM city_table WHERE   Country="china"
+
+    >>> rows = chat80.sql_query('corpora/city_database/city.db', q)
+    >>> for r in rows: print("%s" % r, end=' ')
+    canton chungking dairen harbin kowloon mukden peking shanghai sian tientsin
+
+
+Using Valuations
+-----------------
+
+In order to convert such an extension into a valuation, we use the
+``make_valuation()`` method; setting ``read=True`` creates and returns
+a new ``Valuation`` object which contains the results.
+
+   >>> val = chat80.make_valuation(concepts, read=True)
+   >>> 'calcutta' in val['city']
+   True
+   >>> [town for (town, country) in val['country_of'] if country == 'india']
+   ['bombay', 'calcutta', 'delhi', 'hyderabad', 'madras']
+   >>> dom = val.domain
+   >>> g = nltk.sem.Assignment(dom)
+   >>> m = nltk.sem.Model(dom, val)
+   >>> m.evaluate(r'population_of(jakarta, 533)', g)
+   True

lib/python3.10/site-packages/nltk/test/childes_fixt.py

@@ -0,0 +1,13 @@
+def setup_module():
+    import pytest
+
+    import nltk.data
+
+    try:
+        nltk.data.find("corpora/childes/data-xml/Eng-USA-MOR/")
+    except LookupError as e:
+        pytest.skip(
+            "The CHILDES corpus is not found. "
+            "It should be manually downloaded and saved/unpacked "
+            "to [NLTK_Data_Dir]/corpora/childes/"
+        )

lib/python3.10/site-packages/nltk/test/classify_fixt.py

@@ -0,0 +1,5 @@
+# most of classify.doctest requires numpy
+def setup_module():
+    import pytest
+
+    pytest.importorskip("numpy")

lib/python3.10/site-packages/nltk/test/concordance.doctest

@@ -0,0 +1,75 @@
+.. Copyright (C) 2001-2016 NLTK Project
+.. For license information, see LICENSE.TXT
+
+==================================
+Concordance Example
+==================================
+
+A concordance view shows us every occurrence of a given
+word, together with some context. Here we look up the word monstrous
+in Moby Dick by entering text1 followed by a period, then the term
+concordance, and then placing "monstrous" in parentheses:
+
+>>> from nltk.corpus import gutenberg
+>>> from nltk.text import Text
+>>> corpus = gutenberg.words('melville-moby_dick.txt')
+>>> text = Text(corpus)
+
+>>> text.concordance("monstrous")
+Displaying 11 of 11 matches:
+ong the former , one was of a most monstrous size . ... This came towards us ,
+ON OF THE PSALMS . " Touching that monstrous bulk of the whale or ork we have r
+ll over with a heathenish array of monstrous clubs and spears . Some were thick
+d as you gazed , and wondered what monstrous cannibal and savage could ever hav
+that has survived the flood ; most monstrous and most mountainous ! That Himmal
+they might scout at Moby Dick as a monstrous fable , or still worse and more de
+th of Radney .'" CHAPTER 55 Of the Monstrous Pictures of Whales . I shall ere l
+ing Scenes . In connexion with the monstrous pictures of whales , I am strongly
+ere to enter upon those still more monstrous stories of them which are to be fo
+ght have been rummaged out of this monstrous cabinet there is no telling . But
+of Whale - Bones ; for Whales of a monstrous size are oftentimes cast up dead u
+
+>>> text.concordance("monstrous")
+Displaying 11 of 11 matches:
+ong the former , one was of a most monstrous size . ... This came towards us ,
+ON OF THE PSALMS . " Touching that monstrous bulk of the whale or ork we have r
+ll over with a heathenish array of monstrous clubs and spears . Some were thick
+...
+
+We can also search for a multi-word phrase by passing a list of strings:
+
+>>> text.concordance(["monstrous", "size"])
+Displaying 2 of 2 matches:
+the former , one was of a most monstrous size . ... This came towards us , op
+Whale - Bones ; for Whales of a monstrous size are oftentimes cast up dead upo
+
+=================================
+Concordance List
+=================================
+
+Often we need to store the results of concordance for further usage.
+To do so, call the concordance function with the stdout argument set
+to false:
+
+>>> from nltk.corpus import gutenberg
+>>> from nltk.text import Text
+>>> corpus = gutenberg.words('melville-moby_dick.txt')
+>>> text = Text(corpus)
+>>> con_list = text.concordance_list("monstrous")
+>>> con_list[2].line
+'ll over with a heathenish array of monstrous clubs and spears . Some were thick'
+>>> len(con_list)
+11
+
+=================================
+Patching Issue #2088
+=================================
+
+Patching https://github.com/nltk/nltk/issues/2088
+The left slice of the left context should be clip to 0 if the `i-context` < 0.
+
+>>> from nltk import Text, word_tokenize
+>>> jane_eyre = 'Chapter 1\nTHERE was no possibility of taking a walk that day. We had been wandering, indeed, in the leafless shrubbery an hour in the morning; but since dinner (Mrs. Reed, when there was no company, dined early) the cold winter wind had brought with it clouds so sombre, and a rain so penetrating, that further outdoor exercise was now out of the question.'
+>>> text = Text(word_tokenize(jane_eyre))
+>>> text.concordance_list('taking')[0].left
+['Chapter', '1', 'THERE', 'was', 'no', 'possibility', 'of']

lib/python3.10/site-packages/nltk/test/data.doctest

@@ -0,0 +1,387 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+=========================================
+ Loading Resources From the Data Package
+=========================================
+
+    >>> import nltk.data
+
+Overview
+~~~~~~~~
+The `nltk.data` module contains functions that can be used to load
+NLTK resource files, such as corpora, grammars, and saved processing
+objects.
+
+Loading Data Files
+~~~~~~~~~~~~~~~~~~
+Resources are loaded using the function `nltk.data.load()`, which
+takes as its first argument a URL specifying what file should be
+loaded.  The ``nltk:`` protocol loads files from the NLTK data
+distribution:
+
+    >>> tokenizer = nltk.data.load('nltk:tokenizers/punkt/english.pickle')
+    >>> tokenizer.tokenize('Hello.  This is a test.  It works!')
+    ['Hello.', 'This is a test.', 'It works!']
+
+It is important to note that there should be no space following the
+colon (':') in the URL; 'nltk: tokenizers/punkt/english.pickle' will
+not work!
+
+The ``nltk:`` protocol is used by default if no protocol is specified:
+
+    >>> nltk.data.load('tokenizers/punkt/english.pickle')
+    <nltk.tokenize.punkt.PunktSentenceTokenizer object at ...>
+
+But it is also possible to load resources from ``http:``, ``ftp:``,
+and ``file:`` URLs:
+
+    >>> # Load a grammar from the NLTK webpage.
+    >>> cfg = nltk.data.load('https://raw.githubusercontent.com/nltk/nltk/develop/nltk/test/toy.cfg')
+    >>> print(cfg)  # doctest: +ELLIPSIS
+    Grammar with 14 productions (start state = S)
+        S -> NP VP
+        PP -> P NP
+        ...
+        P -> 'on'
+        P -> 'in'
+
+    >>> # Load a grammar using an absolute path.
+    >>> url = 'file:%s' % nltk.data.find('grammars/sample_grammars/toy.cfg')
+    >>> url.replace('\\', '/')
+    'file:...toy.cfg'
+    >>> print(nltk.data.load(url))
+    Grammar with 14 productions (start state = S)
+        S -> NP VP
+        PP -> P NP
+        ...
+        P -> 'on'
+        P -> 'in'
+
+The second argument to the `nltk.data.load()` function specifies the
+file format, which determines how the file's contents are processed
+before they are returned by ``load()``.  The formats that are
+currently supported by the data module are described by the dictionary
+`nltk.data.FORMATS`:
+
+    >>> for format, descr in sorted(nltk.data.FORMATS.items()):
+    ...     print('{0:<7} {1:}'.format(format, descr))
+    cfg     A context free grammar.
+    fcfg    A feature CFG.
+    fol     A list of first order logic expressions, parsed with
+    nltk.sem.logic.Expression.fromstring.
+    json    A serialized python object, stored using the json module.
+    logic   A list of first order logic expressions, parsed with
+    nltk.sem.logic.LogicParser.  Requires an additional logic_parser
+    parameter
+    pcfg    A probabilistic CFG.
+    pickle  A serialized python object, stored using the pickle
+    module.
+    raw     The raw (byte string) contents of a file.
+    text    The raw (unicode string) contents of a file.
+    val     A semantic valuation, parsed by
+    nltk.sem.Valuation.fromstring.
+    yaml    A serialized python object, stored using the yaml module.
+
+`nltk.data.load()` will raise a ValueError if a bad format name is
+specified:
+
+    >>> nltk.data.load('grammars/sample_grammars/toy.cfg', 'bar')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Unknown format type!
+
+By default, the ``"auto"`` format is used, which chooses a format
+based on the filename's extension.  The mapping from file extensions
+to format names is specified by `nltk.data.AUTO_FORMATS`:
+
+    >>> for ext, format in sorted(nltk.data.AUTO_FORMATS.items()):
+    ...     print('.%-7s -> %s' % (ext, format))
+    .cfg     -> cfg
+    .fcfg    -> fcfg
+    .fol     -> fol
+    .json    -> json
+    .logic   -> logic
+    .pcfg    -> pcfg
+    .pickle  -> pickle
+    .text    -> text
+    .txt     -> text
+    .val     -> val
+    .yaml    -> yaml
+
+If `nltk.data.load()` is unable to determine the format based on the
+filename's extension, it will raise a ValueError:
+
+    >>> nltk.data.load('foo.bar')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Could not determine format for foo.bar based on its file
+    extension; use the "format" argument to specify the format explicitly.
+
+Note that by explicitly specifying the ``format`` argument, you can
+override the load method's default processing behavior.  For example,
+to get the raw contents of any file, simply use ``format="raw"``:
+
+    >>> s = nltk.data.load('grammars/sample_grammars/toy.cfg', 'text')
+    >>> print(s)
+    S -> NP VP
+    PP -> P NP
+    NP -> Det N | NP PP
+    VP -> V NP | VP PP
+    ...
+
+Making Local Copies
+~~~~~~~~~~~~~~~~~~~
+..  This will not be visible in the html output: create a tempdir to
+    play in.
+    >>> import tempfile, os
+    >>> tempdir = tempfile.mkdtemp()
+    >>> old_dir = os.path.abspath('.')
+    >>> os.chdir(tempdir)
+
+The function `nltk.data.retrieve()` copies a given resource to a local
+file.  This can be useful, for example, if you want to edit one of the
+sample grammars.
+
+    >>> nltk.data.retrieve('grammars/sample_grammars/toy.cfg')
+    Retrieving 'nltk:grammars/sample_grammars/toy.cfg', saving to 'toy.cfg'
+
+    >>> # Simulate editing the grammar.
+    >>> with open('toy.cfg') as inp:
+    ...     s = inp.read().replace('NP', 'DP')
+    >>> with open('toy.cfg', 'w') as out:
+    ...     _bytes_written = out.write(s)
+
+    >>> # Load the edited grammar, & display it.
+    >>> cfg = nltk.data.load('file:///' + os.path.abspath('toy.cfg'))
+    >>> print(cfg)
+    Grammar with 14 productions (start state = S)
+        S -> DP VP
+        PP -> P DP
+        ...
+        P -> 'on'
+        P -> 'in'
+
+The second argument to `nltk.data.retrieve()` specifies the filename
+for the new copy of the file.  By default, the source file's filename
+is used.
+
+    >>> nltk.data.retrieve('grammars/sample_grammars/toy.cfg', 'mytoy.cfg')
+    Retrieving 'nltk:grammars/sample_grammars/toy.cfg', saving to 'mytoy.cfg'
+    >>> os.path.isfile('./mytoy.cfg')
+    True
+    >>> nltk.data.retrieve('grammars/sample_grammars/np.fcfg')
+    Retrieving 'nltk:grammars/sample_grammars/np.fcfg', saving to 'np.fcfg'
+    >>> os.path.isfile('./np.fcfg')
+    True
+
+If a file with the specified (or default) filename already exists in
+the current directory, then `nltk.data.retrieve()` will raise a
+ValueError exception.  It will *not* overwrite the file:
+
+    >>> os.path.isfile('./toy.cfg')
+    True
+    >>> nltk.data.retrieve('grammars/sample_grammars/toy.cfg')
+    Traceback (most recent call last):
+      . . .
+    ValueError: File '...toy.cfg' already exists!
+
+..  This will not be visible in the html output: clean up the tempdir.
+    >>> os.chdir(old_dir)
+    >>> for f in os.listdir(tempdir):
+    ...     os.remove(os.path.join(tempdir, f))
+    >>> os.rmdir(tempdir)
+
+Finding Files in the NLTK Data Package
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The `nltk.data.find()` function searches the NLTK data package for a
+given file, and returns a pointer to that file.  This pointer can
+either be a `FileSystemPathPointer` (whose `path` attribute gives the
+absolute path of the file); or a `ZipFilePathPointer`, specifying a
+zipfile and the name of an entry within that zipfile.  Both pointer
+types define the `open()` method, which can be used to read the string
+contents of the file.
+
+    >>> path = nltk.data.find('corpora/abc/rural.txt')
+    >>> str(path)
+    '...rural.txt'
+    >>> print(path.open().read(60).decode())
+    PM denies knowledge of AWB kickbacks
+    The Prime Minister has
+
+Alternatively, the `nltk.data.load()` function can be used with the
+keyword argument ``format="raw"``:
+
+    >>> s = nltk.data.load('corpora/abc/rural.txt', format='raw')[:60]
+    >>> print(s.decode())
+    PM denies knowledge of AWB kickbacks
+    The Prime Minister has
+
+Alternatively, you can use the keyword argument ``format="text"``:
+
+    >>> s = nltk.data.load('corpora/abc/rural.txt', format='text')[:60]
+    >>> print(s)
+    PM denies knowledge of AWB kickbacks
+    The Prime Minister has
+
+Resource Caching
+~~~~~~~~~~~~~~~~
+
+NLTK uses a weakref dictionary to maintain a cache of resources that
+have been loaded.  If you load a resource that is already stored in
+the cache, then the cached copy will be returned.  This behavior can
+be seen by the trace output generated when verbose=True:
+
+    >>> feat0 = nltk.data.load('grammars/book_grammars/feat0.fcfg', verbose=True)
+    <<Loading nltk:grammars/book_grammars/feat0.fcfg>>
+    >>> feat0 = nltk.data.load('grammars/book_grammars/feat0.fcfg', verbose=True)
+    <<Using cached copy of nltk:grammars/book_grammars/feat0.fcfg>>
+
+If you wish to load a resource from its source, bypassing the cache,
+use the ``cache=False`` argument to `nltk.data.load()`.  This can be
+useful, for example, if the resource is loaded from a local file, and
+you are actively editing that file:
+
+    >>> feat0 = nltk.data.load('grammars/book_grammars/feat0.fcfg',cache=False,verbose=True)
+    <<Loading nltk:grammars/book_grammars/feat0.fcfg>>
+
+The cache *no longer* uses weak references.  A resource will not be
+automatically expunged from the cache when no more objects are using
+it.  In the following example, when we clear the variable ``feat0``,
+the reference count for the feature grammar object drops to zero.
+However, the object remains cached:
+
+    >>> del feat0
+    >>> feat0 = nltk.data.load('grammars/book_grammars/feat0.fcfg',
+    ...                        verbose=True)
+    <<Using cached copy of nltk:grammars/book_grammars/feat0.fcfg>>
+
+You can clear the entire contents of the cache, using
+`nltk.data.clear_cache()`:
+
+    >>> nltk.data.clear_cache()
+
+Retrieving other Data Sources
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    >>> formulas = nltk.data.load('grammars/book_grammars/background.fol')
+    >>> for f in formulas: print(str(f))
+    all x.(boxerdog(x) -> dog(x))
+    all x.(boxer(x) -> person(x))
+    all x.-(dog(x) & person(x))
+    all x.(married(x) <-> exists y.marry(x,y))
+    all x.(bark(x) -> dog(x))
+    all x y.(marry(x,y) -> (person(x) & person(y)))
+    -(Vincent = Mia)
+    -(Vincent = Fido)
+    -(Mia = Fido)
+
+Regression Tests
+~~~~~~~~~~~~~~~~
+Create a temp dir for tests that write files:
+
+    >>> import tempfile, os
+    >>> tempdir = tempfile.mkdtemp()
+    >>> old_dir = os.path.abspath('.')
+    >>> os.chdir(tempdir)
+
+The `retrieve()` function accepts all url types:
+
+    >>> urls = ['https://raw.githubusercontent.com/nltk/nltk/develop/nltk/test/toy.cfg',
+    ...         'file:%s' % nltk.data.find('grammars/sample_grammars/toy.cfg'),
+    ...         'nltk:grammars/sample_grammars/toy.cfg',
+    ...         'grammars/sample_grammars/toy.cfg']
+    >>> for i, url in enumerate(urls):
+    ...     nltk.data.retrieve(url, 'toy-%d.cfg' % i)
+    Retrieving 'https://raw.githubusercontent.com/nltk/nltk/develop/nltk/test/toy.cfg', saving to 'toy-0.cfg'
+    Retrieving 'file:...toy.cfg', saving to 'toy-1.cfg'
+    Retrieving 'nltk:grammars/sample_grammars/toy.cfg', saving to 'toy-2.cfg'
+    Retrieving 'nltk:grammars/sample_grammars/toy.cfg', saving to 'toy-3.cfg'
+
+Clean up the temp dir:
+
+    >>> os.chdir(old_dir)
+    >>> for f in os.listdir(tempdir):
+    ...     os.remove(os.path.join(tempdir, f))
+    >>> os.rmdir(tempdir)
+
+Lazy Loader
+-----------
+A lazy loader is a wrapper object that defers loading a resource until
+it is accessed or used in any way.  This is mainly intended for
+internal use by NLTK's corpus readers.
+
+    >>> # Create a lazy loader for toy.cfg.
+    >>> ll = nltk.data.LazyLoader('grammars/sample_grammars/toy.cfg')
+
+    >>> # Show that it's not loaded yet:
+    >>> object.__repr__(ll)
+    '<nltk.data.LazyLoader object at ...>'
+
+    >>> # printing it is enough to cause it to be loaded:
+    >>> print(ll)
+    <Grammar with 14 productions>
+
+    >>> # Show that it's now been loaded:
+    >>> object.__repr__(ll)
+    '<nltk.grammar.CFG object at ...>'
+
+
+    >>> # Test that accessing an attribute also loads it:
+    >>> ll = nltk.data.LazyLoader('grammars/sample_grammars/toy.cfg')
+    >>> ll.start()
+    S
+    >>> object.__repr__(ll)
+    '<nltk.grammar.CFG object at ...>'
+
+Buffered Gzip Reading and Writing
+---------------------------------
+Write performance to gzip-compressed is extremely poor when the files become large.
+File creation can become a bottleneck in those cases.
+
+Read performance from large gzipped pickle files was improved in data.py by
+buffering the reads. A similar fix can be applied to writes by buffering
+the writes to a StringIO object first.
+
+This is mainly intended for internal use. The test simply tests that reading
+and writing work as intended and does not test how much improvement buffering
+provides.
+
+    >>> from io import StringIO
+    >>> test = nltk.data.BufferedGzipFile('testbuf.gz', 'wb', size=2**10)
+    >>> ans = []
+    >>> for i in range(10000):
+    ...     ans.append(str(i).encode('ascii'))
+    ...     test.write(str(i).encode('ascii'))
+    >>> test.close()
+    >>> test = nltk.data.BufferedGzipFile('testbuf.gz', 'rb')
+    >>> test.read() == b''.join(ans)
+    True
+    >>> test.close()
+    >>> import os
+    >>> os.unlink('testbuf.gz')
+
+JSON Encoding and Decoding
+--------------------------
+JSON serialization is used instead of pickle for some classes.
+
+    >>> from nltk import jsontags
+    >>> from nltk.jsontags import JSONTaggedEncoder, JSONTaggedDecoder, register_tag
+    >>> @jsontags.register_tag
+    ... class JSONSerializable:
+    ...     json_tag = 'JSONSerializable'
+    ...
+    ...     def __init__(self, n):
+    ...         self.n = n
+    ...
+    ...     def encode_json_obj(self):
+    ...         return self.n
+    ...
+    ...     @classmethod
+    ...     def decode_json_obj(cls, obj):
+    ...         n = obj
+    ...         return cls(n)
+    ...
+    >>> JSONTaggedEncoder().encode(JSONSerializable(1))
+    '{"!JSONSerializable": 1}'
+    >>> JSONTaggedDecoder().decode('{"!JSONSerializable": 1}').n
+    1

lib/python3.10/site-packages/nltk/test/dependency.doctest

@@ -0,0 +1,241 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+===================
+Dependency Grammars
+===================
+
+    >>> from nltk.grammar import DependencyGrammar
+    >>> from nltk.parse import (
+    ...     DependencyGraph,
+    ...     ProjectiveDependencyParser,
+    ...     NonprojectiveDependencyParser,
+    ... )
+
+CoNLL Data
+----------
+
+    >>> treebank_data = """Pierre  NNP     2       NMOD
+    ... Vinken  NNP     8       SUB
+    ... ,       ,       2       P
+    ... 61      CD      5       NMOD
+    ... years   NNS     6       AMOD
+    ... old     JJ      2       NMOD
+    ... ,       ,       2       P
+    ... will    MD      0       ROOT
+    ... join    VB      8       VC
+    ... the     DT      11      NMOD
+    ... board   NN      9       OBJ
+    ... as      IN      9       VMOD
+    ... a       DT      15      NMOD
+    ... nonexecutive    JJ      15      NMOD
+    ... director        NN      12      PMOD
+    ... Nov.    NNP     9       VMOD
+    ... 29      CD      16      NMOD
+    ... .       .       9       VMOD
+    ... """
+
+    >>> dg = DependencyGraph(treebank_data)
+    >>> dg.tree().pprint()
+    (will
+      (Vinken Pierre , (old (years 61)) ,)
+      (join (board the) (as (director a nonexecutive)) (Nov. 29) .))
+    >>> for head, rel, dep in dg.triples():
+    ...     print(
+    ...         '({h[0]}, {h[1]}), {r}, ({d[0]}, {d[1]})'
+    ...         .format(h=head, r=rel, d=dep)
+    ...     )
+    (will, MD), SUB, (Vinken, NNP)
+    (Vinken, NNP), NMOD, (Pierre, NNP)
+    (Vinken, NNP), P, (,, ,)
+    (Vinken, NNP), NMOD, (old, JJ)
+    (old, JJ), AMOD, (years, NNS)
+    (years, NNS), NMOD, (61, CD)
+    (Vinken, NNP), P, (,, ,)
+    (will, MD), VC, (join, VB)
+    (join, VB), OBJ, (board, NN)
+    (board, NN), NMOD, (the, DT)
+    (join, VB), VMOD, (as, IN)
+    (as, IN), PMOD, (director, NN)
+    (director, NN), NMOD, (a, DT)
+    (director, NN), NMOD, (nonexecutive, JJ)
+    (join, VB), VMOD, (Nov., NNP)
+    (Nov., NNP), NMOD, (29, CD)
+    (join, VB), VMOD, (., .)
+
+Using a custom cell extractor.
+
+    >>> def custom_extractor(cells):
+    ...     _, tag, head, rel = cells
+    ...     return 'spam', 'spam', tag, tag, '', head, rel
+    >>> dg = DependencyGraph(treebank_data, cell_extractor=custom_extractor)
+    >>> dg.tree().pprint()
+    (spam
+      (spam spam spam (spam (spam spam)) spam)
+      (spam (spam spam) (spam (spam spam spam)) (spam spam) spam))
+
+Custom cell extractors can take in and return an index.
+
+    >>> def custom_extractor(cells, index):
+    ...     word, tag, head, rel = cells
+    ...     return (index, '{}-{}'.format(word, index), word,
+    ...             tag, tag, '', head, rel)
+    >>> dg = DependencyGraph(treebank_data, cell_extractor=custom_extractor)
+    >>> dg.tree().pprint()
+    (will-8
+      (Vinken-2 Pierre-1 ,-3 (old-6 (years-5 61-4)) ,-7)
+      (join-9
+        (board-11 the-10)
+        (as-12 (director-15 a-13 nonexecutive-14))
+        (Nov.-16 29-17)
+        .-18))
+
+Using the dependency-parsed version of the Penn Treebank corpus sample.
+
+    >>> from nltk.corpus import dependency_treebank
+    >>> t = dependency_treebank.parsed_sents()[0]
+    >>> print(t.to_conll(3))
+    Pierre      NNP     2
+    Vinken      NNP     8
+    ,   ,       2
+    61  CD      5
+    years       NNS     6
+    old JJ      2
+    ,   ,       2
+    will        MD      0
+    join        VB      8
+    the DT      11
+    board       NN      9
+    as  IN      9
+    a   DT      15
+    nonexecutive        JJ      15
+    director    NN      12
+    Nov.        NNP     9
+    29  CD      16
+    .   .       8
+
+Using the output of zpar (like Malt-TAB but with zero-based indexing)
+
+    >>> zpar_data = """
+    ... Pierre	NNP	1	NMOD
+    ... Vinken	NNP	7	SUB
+    ... ,	,	1	P
+    ... 61	CD	4	NMOD
+    ... years	NNS	5	AMOD
+    ... old	JJ	1	NMOD
+    ... ,	,	1	P
+    ... will	MD	-1	ROOT
+    ... join	VB	7	VC
+    ... the	DT	10	NMOD
+    ... board	NN	8	OBJ
+    ... as	IN	8	VMOD
+    ... a	DT	14	NMOD
+    ... nonexecutive	JJ	14	NMOD
+    ... director	NN	11	PMOD
+    ... Nov.	NNP	8	VMOD
+    ... 29	CD	15	NMOD
+    ... .	.	7	P
+    ... """
+
+    >>> zdg = DependencyGraph(zpar_data, zero_based=True)
+    >>> print(zdg.tree())
+    (will
+      (Vinken Pierre , (old (years 61)) ,)
+      (join (board the) (as (director a nonexecutive)) (Nov. 29))
+      .)
+
+
+Projective Dependency Parsing
+-----------------------------
+
+    >>> grammar = DependencyGrammar.fromstring("""
+    ... 'fell' -> 'price' | 'stock'
+    ... 'price' -> 'of' 'the'
+    ... 'of' -> 'stock'
+    ... 'stock' -> 'the'
+    ... """)
+    >>> print(grammar)
+    Dependency grammar with 5 productions
+      'fell' -> 'price'
+      'fell' -> 'stock'
+      'price' -> 'of' 'the'
+      'of' -> 'stock'
+      'stock' -> 'the'
+
+    >>> dp = ProjectiveDependencyParser(grammar)
+    >>> for t in sorted(dp.parse(['the', 'price', 'of', 'the', 'stock', 'fell'])):
+    ...     print(t)
+    (fell (price the (of (stock the))))
+    (fell (price the of) (stock the))
+    (fell (price the of the) stock)
+
+Non-Projective Dependency Parsing
+---------------------------------
+
+    >>> grammar = DependencyGrammar.fromstring("""
+    ... 'taught' -> 'play' | 'man'
+    ... 'man' -> 'the'
+    ... 'play' -> 'golf' | 'dog' | 'to'
+    ... 'dog' -> 'his'
+    ... """)
+    >>> print(grammar)
+    Dependency grammar with 7 productions
+      'taught' -> 'play'
+      'taught' -> 'man'
+      'man' -> 'the'
+      'play' -> 'golf'
+      'play' -> 'dog'
+      'play' -> 'to'
+      'dog' -> 'his'
+
+    >>> dp = NonprojectiveDependencyParser(grammar)
+    >>> g, = dp.parse(['the', 'man', 'taught', 'his', 'dog', 'to', 'play', 'golf'])
+
+    >>> print(g.root['word'])
+    taught
+
+    >>> for _, node in sorted(g.nodes.items()):
+    ...     if node['word'] is not None:
+    ...         print('{address} {word}: {d}'.format(d=node['deps'][''], **node))
+    1 the: []
+    2 man: [1]
+    3 taught: [2, 7]
+    4 his: []
+    5 dog: [4]
+    6 to: []
+    7 play: [5, 6, 8]
+    8 golf: []
+
+    >>> print(g.tree())
+    (taught (man the) (play (dog his) to golf))
+
+Integration with MALT parser
+============================
+
+In case the top relation is different from the default, we can set it. In case
+of MALT parser, it's set to `'null'`.
+
+>>> dg_str = """1       I       _       NN      NN      _       2       nn      _       _
+... 2   shot    _       NN      NN      _       0       null    _       _
+... 3   an      _       AT      AT      _       2       dep     _       _
+... 4   elephant        _       NN      NN      _       7       nn      _       _
+... 5   in      _       NN      NN      _       7       nn      _       _
+... 6   my      _       NN      NN      _       7       nn      _       _
+... 7   pajamas _       NNS     NNS     _       3       dobj    _       _
+... """
+>>> dg = DependencyGraph(dg_str, top_relation_label='null')
+
+>>> len(dg.nodes)
+8
+
+>>> dg.root['word'], dg.root['address']
+('shot', 2)
+
+>>> print(dg.to_conll(10))
+1   I       _       NN      NN      _       2       nn      _       _
+2   shot    _       NN      NN      _       0       null    _       _
+3   an      _       AT      AT      _       2       dep     _       _
+4   elephant        _       NN      NN      _       7       nn      _       _
+5   in      _       NN      NN      _       7       nn      _       _
+6   my      _       NN      NN      _       7       nn      _       _
+7   pajamas _       NNS     NNS     _       3       dobj    _       _

lib/python3.10/site-packages/nltk/test/discourse.doctest

@@ -0,0 +1,552 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+==================
+Discourse Checking
+==================
+
+    >>> from nltk import *
+    >>> from nltk.sem import logic
+    >>> logic._counter._value = 0
+
+Setup
+=====
+
+    >>> from nltk.test.childes_fixt import setup_module
+    >>> setup_module()
+
+Introduction
+============
+
+The NLTK discourse module makes it possible to test consistency and
+redundancy of simple discourses, using theorem-proving and
+model-building from `nltk.inference`.
+
+The ``DiscourseTester`` constructor takes a list of sentences as a
+parameter.
+
+    >>> dt = DiscourseTester(['a boxer walks', 'every boxer chases a girl'])
+
+The ``DiscourseTester`` parses each sentence into a list of logical
+forms.  Once we have created ``DiscourseTester`` object, we can
+inspect various properties of the discourse. First off, we might want
+to double-check what sentences are currently stored as the discourse.
+
+    >>> dt.sentences()
+    s0: a boxer walks
+    s1: every boxer chases a girl
+
+As you will see, each sentence receives an identifier `s`\ :subscript:`i`.
+We might also want to check what grammar the ``DiscourseTester`` is
+using (by default, ``book_grammars/discourse.fcfg``):
+
+    >>> dt.grammar()
+    % start S
+    # Grammar Rules
+    S[SEM = <app(?subj,?vp)>] -> NP[NUM=?n,SEM=?subj] VP[NUM=?n,SEM=?vp]
+    NP[NUM=?n,SEM=<app(?det,?nom)> ] -> Det[NUM=?n,SEM=?det]  Nom[NUM=?n,SEM=?nom]
+    NP[LOC=?l,NUM=?n,SEM=?np] -> PropN[LOC=?l,NUM=?n,SEM=?np]
+    ...
+
+A different grammar can be invoked by using the optional ``gramfile``
+parameter when a ``DiscourseTester`` object is created.
+
+Readings and Threads
+====================
+
+Depending on
+the grammar used, we may find some sentences have more than one
+logical form. To check this, use the ``readings()`` method. Given a
+sentence identifier of the form `s`\ :subscript:`i`, each reading of
+that sentence is given an identifier `s`\ :sub:`i`-`r`\ :sub:`j`.
+
+
+    >>> dt.readings()
+    <BLANKLINE>
+    s0 readings:
+    <BLANKLINE>
+    s0-r0: exists z1.(boxer(z1) & walk(z1))
+    s0-r1: exists z1.(boxerdog(z1) & walk(z1))
+    <BLANKLINE>
+    s1 readings:
+    <BLANKLINE>
+    s1-r0: all z2.(boxer(z2) -> exists z3.(girl(z3) & chase(z2,z3)))
+    s1-r1: all z1.(boxerdog(z1) -> exists z2.(girl(z2) & chase(z1,z2)))
+
+
+In this case, the only source of ambiguity lies in the word *boxer*,
+which receives two translations: ``boxer`` and ``boxerdog``. The
+intention is that one of these corresponds to the ``person`` sense and
+one to the ``dog`` sense. In principle, we would also expect to see a
+quantifier scope ambiguity in ``s1``. However, the simple grammar we
+are using, namely `sem4.fcfg <sem4.fcfg>`_, doesn't support quantifier
+scope ambiguity.
+
+We can also investigate the readings of a specific sentence:
+
+    >>> dt.readings('a boxer walks')
+    The sentence 'a boxer walks' has these readings:
+        exists x.(boxer(x) & walk(x))
+        exists x.(boxerdog(x) & walk(x))
+
+Given that each sentence is two-ways ambiguous, we potentially have
+four different discourse 'threads', taking all combinations of
+readings. To see these, specify the ``threaded=True`` parameter on
+the ``readings()`` method. Again, each thread is assigned an
+identifier of the form `d`\ :sub:`i`. Following the identifier is a
+list of the readings that constitute that thread.
+
+    >>> dt.readings(threaded=True)
+    d0: ['s0-r0', 's1-r0']
+    d1: ['s0-r0', 's1-r1']
+    d2: ['s0-r1', 's1-r0']
+    d3: ['s0-r1', 's1-r1']
+
+Of course, this simple-minded approach doesn't scale: a discourse with, say, three
+sentences, each of which has 3 readings, will generate 27 different
+threads. It is an interesting exercise to consider how to manage
+discourse ambiguity more efficiently.
+
+Checking Consistency
+====================
+
+Now, we can check whether some or all of the discourse threads are
+consistent, using the ``models()`` method. With no parameter, this
+method will try to find a model for every discourse thread in the
+current discourse. However, we can also specify just one thread, say ``d1``.
+
+    >>> dt.models('d1')
+    --------------------------------------------------------------------------------
+    Model for Discourse Thread d1
+    --------------------------------------------------------------------------------
+    % number = 1
+    % seconds = 0
+    <BLANKLINE>
+    % Interpretation of size 2
+    <BLANKLINE>
+    c1 = 0.
+    <BLANKLINE>
+    f1(0) = 0.
+    f1(1) = 0.
+    <BLANKLINE>
+      boxer(0).
+    - boxer(1).
+    <BLANKLINE>
+    - boxerdog(0).
+    - boxerdog(1).
+    <BLANKLINE>
+    - girl(0).
+    - girl(1).
+    <BLANKLINE>
+      walk(0).
+    - walk(1).
+    <BLANKLINE>
+    - chase(0,0).
+    - chase(0,1).
+    - chase(1,0).
+    - chase(1,1).
+    <BLANKLINE>
+    Consistent discourse: d1 ['s0-r0', 's1-r1']:
+        s0-r0: exists z1.(boxer(z1) & walk(z1))
+        s1-r1: all z1.(boxerdog(z1) -> exists z2.(girl(z2) & chase(z1,z2)))
+    <BLANKLINE>
+
+There are various formats for rendering **Mace4** models --- here,
+we have used the 'cooked' format (which is intended to be
+human-readable). There are a number of points to note.
+
+#. The entities in the domain are all treated as non-negative
+   integers. In this case, there are only two entities, ``0`` and
+   ``1``.
+
+#. The ``-`` symbol indicates negation. So ``0`` is the only
+   ``boxerdog`` and the only thing that ``walk``\ s. Nothing is a
+   ``boxer``, or a ``girl`` or in the ``chase`` relation. Thus the
+   universal sentence is vacuously true.
+
+#. ``c1`` is an introduced constant that denotes ``0``.
+
+#. ``f1`` is a Skolem function, but it plays no significant role in
+   this model.
+
+
+We might want to now add another sentence to the discourse, and there
+is method ``add_sentence()`` for doing just this.
+
+    >>> dt.add_sentence('John is a boxer')
+    >>> dt.sentences()
+    s0: a boxer walks
+    s1: every boxer chases a girl
+    s2: John is a boxer
+
+We can now test all the properties as before; here, we just show a
+couple of them.
+
+    >>> dt.readings()
+    <BLANKLINE>
+    s0 readings:
+    <BLANKLINE>
+    s0-r0: exists z1.(boxer(z1) & walk(z1))
+    s0-r1: exists z1.(boxerdog(z1) & walk(z1))
+    <BLANKLINE>
+    s1 readings:
+    <BLANKLINE>
+    s1-r0: all z1.(boxer(z1) -> exists z2.(girl(z2) & chase(z1,z2)))
+    s1-r1: all z1.(boxerdog(z1) -> exists z2.(girl(z2) & chase(z1,z2)))
+    <BLANKLINE>
+    s2 readings:
+    <BLANKLINE>
+    s2-r0: boxer(John)
+    s2-r1: boxerdog(John)
+    >>> dt.readings(threaded=True)
+    d0: ['s0-r0', 's1-r0', 's2-r0']
+    d1: ['s0-r0', 's1-r0', 's2-r1']
+    d2: ['s0-r0', 's1-r1', 's2-r0']
+    d3: ['s0-r0', 's1-r1', 's2-r1']
+    d4: ['s0-r1', 's1-r0', 's2-r0']
+    d5: ['s0-r1', 's1-r0', 's2-r1']
+    d6: ['s0-r1', 's1-r1', 's2-r0']
+    d7: ['s0-r1', 's1-r1', 's2-r1']
+
+If you are interested in a particular thread, the ``expand_threads()``
+method will remind you of what readings it consists of:
+
+    >>> thread = dt.expand_threads('d1')
+    >>> for rid, reading in thread:
+    ...     print(rid, str(reading.normalize()))
+    s0-r0 exists z1.(boxer(z1) & walk(z1))
+    s1-r0 all z1.(boxer(z1) -> exists z2.(girl(z2) & chase(z1,z2)))
+    s2-r1 boxerdog(John)
+
+Suppose we have already defined a discourse, as follows:
+
+    >>> dt = DiscourseTester(['A student dances', 'Every student is a person'])
+
+Now, when we add a new sentence, is it consistent with what we already
+have? The `` consistchk=True`` parameter of ``add_sentence()`` allows
+us to check:
+
+    >>> dt.add_sentence('No person dances', consistchk=True)
+    Inconsistent discourse: d0 ['s0-r0', 's1-r0', 's2-r0']:
+        s0-r0: exists z1.(student(z1) & dance(z1))
+        s1-r0: all z1.(student(z1) -> person(z1))
+        s2-r0: -exists z1.(person(z1) & dance(z1))
+    <BLANKLINE>
+    >>> dt.readings()
+    <BLANKLINE>
+    s0 readings:
+    <BLANKLINE>
+    s0-r0: exists z1.(student(z1) & dance(z1))
+    <BLANKLINE>
+    s1 readings:
+    <BLANKLINE>
+    s1-r0: all z1.(student(z1) -> person(z1))
+    <BLANKLINE>
+    s2 readings:
+    <BLANKLINE>
+    s2-r0: -exists z1.(person(z1) & dance(z1))
+
+So let's retract the inconsistent sentence:
+
+    >>> dt.retract_sentence('No person dances', verbose=True)
+    Current sentences are
+    s0: A student dances
+    s1: Every student is a person
+
+We can now verify that result is consistent.
+
+    >>> dt.models()
+    --------------------------------------------------------------------------------
+    Model for Discourse Thread d0
+    --------------------------------------------------------------------------------
+    % number = 1
+    % seconds = 0
+    <BLANKLINE>
+    % Interpretation of size 2
+    <BLANKLINE>
+    c1 = 0.
+    <BLANKLINE>
+      dance(0).
+    - dance(1).
+    <BLANKLINE>
+      person(0).
+    - person(1).
+    <BLANKLINE>
+      student(0).
+    - student(1).
+    <BLANKLINE>
+    Consistent discourse: d0 ['s0-r0', 's1-r0']:
+        s0-r0: exists z1.(student(z1) & dance(z1))
+        s1-r0: all z1.(student(z1) -> person(z1))
+    <BLANKLINE>
+
+Checking Informativity
+======================
+
+Let's assume that we are still trying to extend the discourse *A
+student dances.* *Every student is a person.* We add a new sentence,
+but this time, we check whether it is informative with respect to what
+has gone before.
+
+    >>> dt.add_sentence('A person dances', informchk=True)
+    Sentence 'A person dances' under reading 'exists x.(person(x) & dance(x))':
+    Not informative relative to thread 'd0'
+
+In fact, we are just checking whether the new sentence is entailed by
+the preceding discourse.
+
+    >>> dt.models()
+    --------------------------------------------------------------------------------
+    Model for Discourse Thread d0
+    --------------------------------------------------------------------------------
+    % number = 1
+    % seconds = 0
+    <BLANKLINE>
+    % Interpretation of size 2
+    <BLANKLINE>
+    c1 = 0.
+    <BLANKLINE>
+    c2 = 0.
+    <BLANKLINE>
+      dance(0).
+    - dance(1).
+    <BLANKLINE>
+      person(0).
+    - person(1).
+    <BLANKLINE>
+      student(0).
+    - student(1).
+    <BLANKLINE>
+    Consistent discourse: d0 ['s0-r0', 's1-r0', 's2-r0']:
+        s0-r0: exists z1.(student(z1) & dance(z1))
+        s1-r0: all z1.(student(z1) -> person(z1))
+        s2-r0: exists z1.(person(z1) & dance(z1))
+    <BLANKLINE>
+
+
+
+Adding Background Knowledge
+===========================
+
+Let's build a new discourse, and look at the readings of the component sentences:
+
+    >>> dt = DiscourseTester(['Vincent is a boxer', 'Fido is a boxer', 'Vincent is married', 'Fido barks'])
+    >>> dt.readings()
+    <BLANKLINE>
+    s0 readings:
+    <BLANKLINE>
+    s0-r0: boxer(Vincent)
+    s0-r1: boxerdog(Vincent)
+    <BLANKLINE>
+    s1 readings:
+    <BLANKLINE>
+    s1-r0: boxer(Fido)
+    s1-r1: boxerdog(Fido)
+    <BLANKLINE>
+    s2 readings:
+    <BLANKLINE>
+    s2-r0: married(Vincent)
+    <BLANKLINE>
+    s3 readings:
+    <BLANKLINE>
+    s3-r0: bark(Fido)
+
+This gives us a lot of threads:
+
+    >>> dt.readings(threaded=True)
+    d0: ['s0-r0', 's1-r0', 's2-r0', 's3-r0']
+    d1: ['s0-r0', 's1-r1', 's2-r0', 's3-r0']
+    d2: ['s0-r1', 's1-r0', 's2-r0', 's3-r0']
+    d3: ['s0-r1', 's1-r1', 's2-r0', 's3-r0']
+
+
+We can eliminate some of the readings, and hence some of the threads,
+by adding background information.
+
+    >>> import nltk.data
+    >>> bg = nltk.data.load('grammars/book_grammars/background.fol')
+    >>> dt.add_background(bg)
+    >>> dt.background()
+    all x.(boxerdog(x) -> dog(x))
+    all x.(boxer(x) -> person(x))
+    all x.-(dog(x) & person(x))
+    all x.(married(x) <-> exists y.marry(x,y))
+    all x.(bark(x) -> dog(x))
+    all x y.(marry(x,y) -> (person(x) & person(y)))
+    -(Vincent = Mia)
+    -(Vincent = Fido)
+    -(Mia = Fido)
+
+The background information allows us to reject three of the threads as
+inconsistent. To see what remains, use the ``filter=True`` parameter
+on ``readings()``.
+
+    >>> dt.readings(filter=True)
+    d1: ['s0-r0', 's1-r1', 's2-r0', 's3-r0']
+
+The ``models()`` method gives us more information about the surviving thread.
+
+    >>> dt.models()
+    --------------------------------------------------------------------------------
+    Model for Discourse Thread d0
+    --------------------------------------------------------------------------------
+    No model found!
+    <BLANKLINE>
+    --------------------------------------------------------------------------------
+    Model for Discourse Thread d1
+    --------------------------------------------------------------------------------
+    % number = 1
+    % seconds = 0
+    <BLANKLINE>
+    % Interpretation of size 3
+    <BLANKLINE>
+    Fido = 0.
+    <BLANKLINE>
+    Mia = 1.
+    <BLANKLINE>
+    Vincent = 2.
+    <BLANKLINE>
+    f1(0) = 0.
+    f1(1) = 0.
+    f1(2) = 2.
+    <BLANKLINE>
+      bark(0).
+    - bark(1).
+    - bark(2).
+    <BLANKLINE>
+    - boxer(0).
+    - boxer(1).
+      boxer(2).
+    <BLANKLINE>
+      boxerdog(0).
+    - boxerdog(1).
+    - boxerdog(2).
+    <BLANKLINE>
+      dog(0).
+    - dog(1).
+    - dog(2).
+    <BLANKLINE>
+    - married(0).
+    - married(1).
+      married(2).
+    <BLANKLINE>
+    - person(0).
+    - person(1).
+      person(2).
+    <BLANKLINE>
+    - marry(0,0).
+    - marry(0,1).
+    - marry(0,2).
+    - marry(1,0).
+    - marry(1,1).
+    - marry(1,2).
+    - marry(2,0).
+    - marry(2,1).
+      marry(2,2).
+    <BLANKLINE>
+    --------------------------------------------------------------------------------
+    Model for Discourse Thread d2
+    --------------------------------------------------------------------------------
+    No model found!
+    <BLANKLINE>
+    --------------------------------------------------------------------------------
+    Model for Discourse Thread d3
+    --------------------------------------------------------------------------------
+    No model found!
+    <BLANKLINE>
+    Inconsistent discourse: d0 ['s0-r0', 's1-r0', 's2-r0', 's3-r0']:
+        s0-r0: boxer(Vincent)
+        s1-r0: boxer(Fido)
+        s2-r0: married(Vincent)
+        s3-r0: bark(Fido)
+    <BLANKLINE>
+    Consistent discourse: d1 ['s0-r0', 's1-r1', 's2-r0', 's3-r0']:
+        s0-r0: boxer(Vincent)
+        s1-r1: boxerdog(Fido)
+        s2-r0: married(Vincent)
+        s3-r0: bark(Fido)
+    <BLANKLINE>
+    Inconsistent discourse: d2 ['s0-r1', 's1-r0', 's2-r0', 's3-r0']:
+        s0-r1: boxerdog(Vincent)
+        s1-r0: boxer(Fido)
+        s2-r0: married(Vincent)
+        s3-r0: bark(Fido)
+    <BLANKLINE>
+    Inconsistent discourse: d3 ['s0-r1', 's1-r1', 's2-r0', 's3-r0']:
+        s0-r1: boxerdog(Vincent)
+        s1-r1: boxerdog(Fido)
+        s2-r0: married(Vincent)
+        s3-r0: bark(Fido)
+    <BLANKLINE>
+
+
+..  This will not be visible in the html output: create a tempdir to
+    play in.
+    >>> import tempfile, os
+    >>> tempdir = tempfile.mkdtemp()
+    >>> old_dir = os.path.abspath('.')
+    >>> os.chdir(tempdir)
+
+In order to play around with your own version of background knowledge,
+you might want to start off with a local copy of ``background.fol``:
+
+    >>> nltk.data.retrieve('grammars/book_grammars/background.fol')
+    Retrieving 'nltk:grammars/book_grammars/background.fol', saving to 'background.fol'
+
+After you have modified the file, the ``load_fol()`` function will parse
+the strings in the file into expressions of ``nltk.sem.logic``.
+
+    >>> from nltk.inference.discourse import load_fol
+    >>> mybg = load_fol(open('background.fol').read())
+
+The result can be loaded as an argument of ``add_background()`` in the
+manner shown earlier.
+
+..  This will not be visible in the html output: clean up the tempdir.
+    >>> os.chdir(old_dir)
+    >>> for f in os.listdir(tempdir):
+    ...     os.remove(os.path.join(tempdir, f))
+    >>> os.rmdir(tempdir)
+    >>> nltk.data.clear_cache()
+
+
+Regression Testing from book
+============================
+
+    >>> logic._counter._value = 0
+
+    >>> from nltk.tag import RegexpTagger
+    >>> tagger = RegexpTagger(
+    ...     [('^(chases|runs)$', 'VB'),
+    ...      ('^(a)$', 'ex_quant'),
+    ...      ('^(every)$', 'univ_quant'),
+    ...      ('^(dog|boy)$', 'NN'),
+    ...      ('^(He)$', 'PRP')
+    ... ])
+    >>> rc = DrtGlueReadingCommand(depparser=MaltParser(tagger=tagger))
+    >>> dt = DiscourseTester(map(str.split, ['Every dog chases a boy', 'He runs']), rc)
+    >>> dt.readings()
+    <BLANKLINE>
+    s0 readings:
+    <BLANKLINE>
+    s0-r0: ([z2],[boy(z2), (([z5],[dog(z5)]) -> ([],[chases(z5,z2)]))])
+    s0-r1: ([],[(([z1],[dog(z1)]) -> ([z2],[boy(z2), chases(z1,z2)]))])
+    <BLANKLINE>
+    s1 readings:
+    <BLANKLINE>
+    s1-r0: ([z1],[PRO(z1), runs(z1)])
+    >>> dt.readings(show_thread_readings=True)
+    d0: ['s0-r0', 's1-r0'] : ([z1,z2],[boy(z1), (([z3],[dog(z3)]) -> ([],[chases(z3,z1)])), (z2 = z1), runs(z2)])
+    d1: ['s0-r1', 's1-r0'] : INVALID: AnaphoraResolutionException
+    >>> dt.readings(filter=True, show_thread_readings=True)
+    d0: ['s0-r0', 's1-r0'] : ([z1,z3],[boy(z1), (([z2],[dog(z2)]) -> ([],[chases(z2,z1)])), (z3 = z1), runs(z3)])
+
+    >>> logic._counter._value = 0
+
+    >>> from nltk.parse import FeatureEarleyChartParser
+    >>> from nltk.sem.drt import DrtParser
+    >>> grammar = nltk.data.load('grammars/book_grammars/drt.fcfg', logic_parser=DrtParser())
+    >>> parser = FeatureEarleyChartParser(grammar, trace=0)
+    >>> trees = parser.parse('Angus owns a dog'.split())
+    >>> print(list(trees)[0].label()['SEM'].simplify().normalize())
+    ([z1,z2],[Angus(z1), dog(z2), own(z1,z2)])

lib/python3.10/site-packages/nltk/test/featgram.doctest

@@ -0,0 +1,610 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+=========================
+ Feature Grammar Parsing
+=========================
+
+.. definitions from nltk_book/definitions.rst
+
+.. role:: feat
+    :class: feature
+.. role:: fval
+     :class: fval
+.. |rarr| unicode:: U+2192 .. right arrow
+.. |dot| unicode:: U+2022 .. bullet
+.. |pi| unicode:: U+03C0
+
+Grammars can be parsed from strings.
+
+    >>> import nltk
+    >>> from nltk import grammar, parse
+    >>> g = """
+    ... % start DP
+    ... DP[AGR=?a] -> D[AGR=?a] N[AGR=?a]
+    ... D[AGR=[NUM='sg', PERS=3]] -> 'this' | 'that'
+    ... D[AGR=[NUM='pl', PERS=3]] -> 'these' | 'those'
+    ... D[AGR=[NUM='pl', PERS=1]] -> 'we'
+    ... D[AGR=[PERS=2]] -> 'you'
+    ... N[AGR=[NUM='sg', GND='m']] -> 'boy'
+    ... N[AGR=[NUM='pl', GND='m']] -> 'boys'
+    ... N[AGR=[NUM='sg', GND='f']] -> 'girl'
+    ... N[AGR=[NUM='pl', GND='f']] -> 'girls'
+    ... N[AGR=[NUM='sg']] -> 'student'
+    ... N[AGR=[NUM='pl']] -> 'students'
+    ... """
+    >>> grammar = grammar.FeatureGrammar.fromstring(g)
+    >>> tokens = 'these girls'.split()
+    >>> parser = parse.FeatureEarleyChartParser(grammar)
+    >>> trees = parser.parse(tokens)
+    >>> for tree in trees: print(tree)
+    (DP[AGR=[GND='f', NUM='pl', PERS=3]]
+      (D[AGR=[NUM='pl', PERS=3]] these)
+      (N[AGR=[GND='f', NUM='pl']] girls))
+
+In general, when we are trying to develop even a very small grammar,
+it is convenient to put the rules in a file where they can be edited,
+tested and revised. Let's assume that we have saved feat0cfg as a file named
+``'feat0.fcfg'`` and placed it in the NLTK ``data`` directory. We can
+inspect it as follows:
+
+    >>> nltk.data.show_cfg('grammars/book_grammars/feat0.fcfg')
+    % start S
+    # ###################
+    # Grammar Productions
+    # ###################
+    # S expansion productions
+    S -> NP[NUM=?n] VP[NUM=?n]
+    # NP expansion productions
+    NP[NUM=?n] -> N[NUM=?n]
+    NP[NUM=?n] -> PropN[NUM=?n]
+    NP[NUM=?n] -> Det[NUM=?n] N[NUM=?n]
+    NP[NUM=pl] -> N[NUM=pl]
+    # VP expansion productions
+    VP[TENSE=?t, NUM=?n] -> IV[TENSE=?t, NUM=?n]
+    VP[TENSE=?t, NUM=?n] -> TV[TENSE=?t, NUM=?n] NP
+    # ###################
+    # Lexical Productions
+    # ###################
+    Det[NUM=sg] -> 'this' | 'every'
+    Det[NUM=pl] -> 'these' | 'all'
+    Det -> 'the' | 'some' | 'several'
+    PropN[NUM=sg]-> 'Kim' | 'Jody'
+    N[NUM=sg] -> 'dog' | 'girl' | 'car' | 'child'
+    N[NUM=pl] -> 'dogs' | 'girls' | 'cars' | 'children'
+    IV[TENSE=pres,  NUM=sg] -> 'disappears' | 'walks'
+    TV[TENSE=pres, NUM=sg] -> 'sees' | 'likes'
+    IV[TENSE=pres,  NUM=pl] -> 'disappear' | 'walk'
+    TV[TENSE=pres, NUM=pl] -> 'see' | 'like'
+    IV[TENSE=past] -> 'disappeared' | 'walked'
+    TV[TENSE=past] -> 'saw' | 'liked'
+
+Assuming we have saved feat0cfg as a file named
+``'feat0.fcfg'``, the function ``parse.load_parser`` allows us to
+read the grammar into NLTK, ready for use in parsing.
+
+
+    >>> cp = parse.load_parser('grammars/book_grammars/feat0.fcfg', trace=1)
+    >>> sent = 'Kim likes children'
+    >>> tokens = sent.split()
+    >>> tokens
+    ['Kim', 'likes', 'children']
+    >>> trees = cp.parse(tokens)
+    |.Kim .like.chil.|
+    |[----]    .    .| [0:1] 'Kim'
+    |.    [----]    .| [1:2] 'likes'
+    |.    .    [----]| [2:3] 'children'
+    |[----]    .    .| [0:1] PropN[NUM='sg'] -> 'Kim' *
+    |[----]    .    .| [0:1] NP[NUM='sg'] -> PropN[NUM='sg'] *
+    |[---->    .    .| [0:1] S[] -> NP[NUM=?n] * VP[NUM=?n] {?n: 'sg'}
+    |.    [----]    .| [1:2] TV[NUM='sg', TENSE='pres'] -> 'likes' *
+    |.    [---->    .| [1:2] VP[NUM=?n, TENSE=?t] -> TV[NUM=?n, TENSE=?t] * NP[] {?n: 'sg', ?t: 'pres'}
+    |.    .    [----]| [2:3] N[NUM='pl'] -> 'children' *
+    |.    .    [----]| [2:3] NP[NUM='pl'] -> N[NUM='pl'] *
+    |.    .    [---->| [2:3] S[] -> NP[NUM=?n] * VP[NUM=?n] {?n: 'pl'}
+    |.    [---------]| [1:3] VP[NUM='sg', TENSE='pres'] -> TV[NUM='sg', TENSE='pres'] NP[] *
+    |[==============]| [0:3] S[] -> NP[NUM='sg'] VP[NUM='sg'] *
+    >>> for tree in trees: print(tree)
+    (S[]
+      (NP[NUM='sg'] (PropN[NUM='sg'] Kim))
+      (VP[NUM='sg', TENSE='pres']
+        (TV[NUM='sg', TENSE='pres'] likes)
+        (NP[NUM='pl'] (N[NUM='pl'] children))))
+
+The parser works directly with
+the underspecified productions given by the grammar. That is, the
+Predictor rule does not attempt to compile out all admissible feature
+combinations before trying to expand the non-terminals on the left hand
+side of a production. However, when the Scanner matches an input word
+against a lexical production that has been predicted, the new edge will
+typically contain fully specified features; e.g., the edge
+[PropN[`num`:feat: = `sg`:fval:] |rarr| 'Kim', (0, 1)]. Recall from
+Chapter 8 that the Fundamental (or Completer) Rule in
+standard CFGs is used to combine an incomplete edge that's expecting a
+nonterminal *B* with a following, complete edge whose left hand side
+matches *B*. In our current setting, rather than checking for a
+complete match, we test whether the expected category *B* will
+unify with the left hand side *B'* of a following complete
+edge. We will explain in more detail in Section 9.2 how
+unification works; for the moment, it is enough to know that as a
+result of unification, any variable values of features in *B* will be
+instantiated by constant values in the corresponding feature structure
+in *B'*, and these instantiated values will be used in the new edge
+added by the Completer. This instantiation can be seen, for example,
+in the edge
+[NP [`num`:feat:\ =\ `sg`:fval:] |rarr| PropN[`num`:feat:\ =\ `sg`:fval:] |dot|, (0, 1)]
+in Example 9.2, where the feature `num`:feat: has been assigned the value `sg`:fval:.
+
+Feature structures in NLTK are ... Atomic feature values can be strings or
+integers.
+
+    >>> fs1 = nltk.FeatStruct(TENSE='past', NUM='sg')
+    >>> print(fs1)
+    [ NUM   = 'sg'   ]
+    [ TENSE = 'past' ]
+
+We can think of a feature structure as being like a Python dictionary,
+and access its values by indexing in the usual way.
+
+    >>> fs1 = nltk.FeatStruct(PER=3, NUM='pl', GND='fem')
+    >>> print(fs1['GND'])
+    fem
+
+We can also define feature structures which have complex values, as
+discussed earlier.
+
+    >>> fs2 = nltk.FeatStruct(POS='N', AGR=fs1)
+    >>> print(fs2)
+    [       [ GND = 'fem' ] ]
+    [ AGR = [ NUM = 'pl'  ] ]
+    [       [ PER = 3     ] ]
+    [                       ]
+    [ POS = 'N'             ]
+    >>> print(fs2['AGR'])
+    [ GND = 'fem' ]
+    [ NUM = 'pl'  ]
+    [ PER = 3     ]
+    >>> print(fs2['AGR']['PER'])
+    3
+
+Feature structures can also be constructed using the ``parse()``
+method of the ``nltk.FeatStruct`` class. Note that in this case, atomic
+feature values do not need to be enclosed in quotes.
+
+    >>> f1 = nltk.FeatStruct("[NUMBER = sg]")
+    >>> f2 = nltk.FeatStruct("[PERSON = 3]")
+    >>> print(nltk.unify(f1, f2))
+    [ NUMBER = 'sg' ]
+    [ PERSON = 3    ]
+
+    >>> f1 = nltk.FeatStruct("[A = [B = b, D = d]]")
+    >>> f2 = nltk.FeatStruct("[A = [C = c, D = d]]")
+    >>> print(nltk.unify(f1, f2))
+    [     [ B = 'b' ] ]
+    [ A = [ C = 'c' ] ]
+    [     [ D = 'd' ] ]
+
+
+Feature Structures as Graphs
+----------------------------
+
+Feature structures are not inherently tied to linguistic objects; they are
+general purpose structures for representing knowledge. For example, we
+could encode information about a person in a feature structure:
+
+    >>> person01 = nltk.FeatStruct("[NAME=Lee, TELNO='01 27 86 42 96',AGE=33]")
+    >>> print(person01)
+    [ AGE   = 33               ]
+    [ NAME  = 'Lee'            ]
+    [ TELNO = '01 27 86 42 96' ]
+
+There are a number of notations for representing reentrancy in
+matrix-style representations of feature structures. In NLTK, we adopt
+the following convention: the first occurrence of a shared feature structure
+is prefixed with an integer in parentheses, such as ``(1)``, and any
+subsequent reference to that structure uses the notation
+``->(1)``, as shown below.
+
+
+    >>> fs = nltk.FeatStruct("""[NAME=Lee, ADDRESS=(1)[NUMBER=74, STREET='rue Pascal'],
+    ...                               SPOUSE=[NAME=Kim, ADDRESS->(1)]]""")
+    >>> print(fs)
+    [ ADDRESS = (1) [ NUMBER = 74           ] ]
+    [               [ STREET = 'rue Pascal' ] ]
+    [                                         ]
+    [ NAME    = 'Lee'                         ]
+    [                                         ]
+    [ SPOUSE  = [ ADDRESS -> (1)  ]           ]
+    [           [ NAME    = 'Kim' ]           ]
+
+There can be any number of tags within a single feature structure.
+
+    >>> fs3 = nltk.FeatStruct("[A=(1)[B=b], C=(2)[], D->(1), E->(2)]")
+    >>> print(fs3)
+    [ A = (1) [ B = 'b' ] ]
+    [                     ]
+    [ C = (2) []          ]
+    [                     ]
+    [ D -> (1)            ]
+    [ E -> (2)            ]
+    >>> fs1 = nltk.FeatStruct(NUMBER=74, STREET='rue Pascal')
+    >>> fs2 = nltk.FeatStruct(CITY='Paris')
+    >>> print(nltk.unify(fs1, fs2))
+    [ CITY   = 'Paris'      ]
+    [ NUMBER = 74           ]
+    [ STREET = 'rue Pascal' ]
+
+Unification is symmetric:
+
+    >>> nltk.unify(fs1, fs2) == nltk.unify(fs2, fs1)
+    True
+
+Unification is commutative:
+
+    >>> fs3 = nltk.FeatStruct(TELNO='01 27 86 42 96')
+    >>> nltk.unify(nltk.unify(fs1, fs2), fs3) == nltk.unify(fs1, nltk.unify(fs2, fs3))
+    True
+
+Unification between *FS*:math:`_0` and *FS*:math:`_1` will fail if the
+two feature structures share a path |pi|,
+but the value of |pi| in *FS*:math:`_0` is a distinct
+atom from the value of |pi| in *FS*:math:`_1`. In NLTK,
+this is implemented by setting the result of unification to be
+``None``.
+
+    >>> fs0 = nltk.FeatStruct(A='a')
+    >>> fs1 = nltk.FeatStruct(A='b')
+    >>> print(nltk.unify(fs0, fs1))
+    None
+
+Now, if we look at how unification interacts with structure-sharing,
+things become really interesting.
+
+
+
+    >>> fs0 = nltk.FeatStruct("""[NAME=Lee,
+    ...                                ADDRESS=[NUMBER=74,
+    ...                                         STREET='rue Pascal'],
+    ...                                SPOUSE= [NAME=Kim,
+    ...                                         ADDRESS=[NUMBER=74,
+    ...                                                  STREET='rue Pascal']]]""")
+    >>> print(fs0)
+    [ ADDRESS = [ NUMBER = 74           ]               ]
+    [           [ STREET = 'rue Pascal' ]               ]
+    [                                                   ]
+    [ NAME    = 'Lee'                                   ]
+    [                                                   ]
+    [           [ ADDRESS = [ NUMBER = 74           ] ] ]
+    [ SPOUSE  = [           [ STREET = 'rue Pascal' ] ] ]
+    [           [                                     ] ]
+    [           [ NAME    = 'Kim'                     ] ]
+
+
+    >>> fs1 = nltk.FeatStruct("[SPOUSE=[ADDRESS=[CITY=Paris]]]")
+    >>> print(nltk.unify(fs0, fs1))
+    [ ADDRESS = [ NUMBER = 74           ]               ]
+    [           [ STREET = 'rue Pascal' ]               ]
+    [                                                   ]
+    [ NAME    = 'Lee'                                   ]
+    [                                                   ]
+    [           [           [ CITY   = 'Paris'      ] ] ]
+    [           [ ADDRESS = [ NUMBER = 74           ] ] ]
+    [ SPOUSE  = [           [ STREET = 'rue Pascal' ] ] ]
+    [           [                                     ] ]
+    [           [ NAME    = 'Kim'                     ] ]
+
+    >>> fs2 = nltk.FeatStruct("""[NAME=Lee, ADDRESS=(1)[NUMBER=74, STREET='rue Pascal'],
+    ...                                SPOUSE=[NAME=Kim, ADDRESS->(1)]]""")
+
+
+    >>> print(fs2)
+    [ ADDRESS = (1) [ NUMBER = 74           ] ]
+    [               [ STREET = 'rue Pascal' ] ]
+    [                                         ]
+    [ NAME    = 'Lee'                         ]
+    [                                         ]
+    [ SPOUSE  = [ ADDRESS -> (1)  ]           ]
+    [           [ NAME    = 'Kim' ]           ]
+
+
+    >>> print(nltk.unify(fs2, fs1))
+    [               [ CITY   = 'Paris'      ] ]
+    [ ADDRESS = (1) [ NUMBER = 74           ] ]
+    [               [ STREET = 'rue Pascal' ] ]
+    [                                         ]
+    [ NAME    = 'Lee'                         ]
+    [                                         ]
+    [ SPOUSE  = [ ADDRESS -> (1)  ]           ]
+    [           [ NAME    = 'Kim' ]           ]
+
+
+    >>> fs1 = nltk.FeatStruct("[ADDRESS1=[NUMBER=74, STREET='rue Pascal']]")
+    >>> fs2 = nltk.FeatStruct("[ADDRESS1=?x, ADDRESS2=?x]")
+    >>> print(fs2)
+    [ ADDRESS1 = ?x ]
+    [ ADDRESS2 = ?x ]
+    >>> print(nltk.unify(fs1, fs2))
+    [ ADDRESS1 = (1) [ NUMBER = 74           ] ]
+    [                [ STREET = 'rue Pascal' ] ]
+    [                                          ]
+    [ ADDRESS2 -> (1)                          ]
+
+
+
+
+    >>> sent = 'who do you claim that you like'
+    >>> tokens = sent.split()
+    >>> cp = parse.load_parser('grammars/book_grammars/feat1.fcfg', trace=1)
+    >>> trees = cp.parse(tokens)
+    |.w.d.y.c.t.y.l.|
+    |[-] . . . . . .| [0:1] 'who'
+    |. [-] . . . . .| [1:2] 'do'
+    |. . [-] . . . .| [2:3] 'you'
+    |. . . [-] . . .| [3:4] 'claim'
+    |. . . . [-] . .| [4:5] 'that'
+    |. . . . . [-] .| [5:6] 'you'
+    |. . . . . . [-]| [6:7] 'like'
+    |# . . . . . . .| [0:0] NP[]/NP[] -> *
+    |. # . . . . . .| [1:1] NP[]/NP[] -> *
+    |. . # . . . . .| [2:2] NP[]/NP[] -> *
+    |. . . # . . . .| [3:3] NP[]/NP[] -> *
+    |. . . . # . . .| [4:4] NP[]/NP[] -> *
+    |. . . . . # . .| [5:5] NP[]/NP[] -> *
+    |. . . . . . # .| [6:6] NP[]/NP[] -> *
+    |. . . . . . . #| [7:7] NP[]/NP[] -> *
+    |[-] . . . . . .| [0:1] NP[+WH] -> 'who' *
+    |[-> . . . . . .| [0:1] S[-INV] -> NP[] * VP[] {}
+    |[-> . . . . . .| [0:1] S[-INV]/?x[] -> NP[] * VP[]/?x[] {}
+    |[-> . . . . . .| [0:1] S[-INV] -> NP[] * S[]/NP[] {}
+    |. [-] . . . . .| [1:2] V[+AUX] -> 'do' *
+    |. [-> . . . . .| [1:2] S[+INV] -> V[+AUX] * NP[] VP[] {}
+    |. [-> . . . . .| [1:2] S[+INV]/?x[] -> V[+AUX] * NP[] VP[]/?x[] {}
+    |. [-> . . . . .| [1:2] VP[] -> V[+AUX] * VP[] {}
+    |. [-> . . . . .| [1:2] VP[]/?x[] -> V[+AUX] * VP[]/?x[] {}
+    |. . [-] . . . .| [2:3] NP[-WH] -> 'you' *
+    |. . [-> . . . .| [2:3] S[-INV] -> NP[] * VP[] {}
+    |. . [-> . . . .| [2:3] S[-INV]/?x[] -> NP[] * VP[]/?x[] {}
+    |. . [-> . . . .| [2:3] S[-INV] -> NP[] * S[]/NP[] {}
+    |. [---> . . . .| [1:3] S[+INV] -> V[+AUX] NP[] * VP[] {}
+    |. [---> . . . .| [1:3] S[+INV]/?x[] -> V[+AUX] NP[] * VP[]/?x[] {}
+    |. . . [-] . . .| [3:4] V[-AUX, SUBCAT='clause'] -> 'claim' *
+    |. . . [-> . . .| [3:4] VP[] -> V[-AUX, SUBCAT='clause'] * SBar[] {}
+    |. . . [-> . . .| [3:4] VP[]/?x[] -> V[-AUX, SUBCAT='clause'] * SBar[]/?x[] {}
+    |. . . . [-] . .| [4:5] Comp[] -> 'that' *
+    |. . . . [-> . .| [4:5] SBar[] -> Comp[] * S[-INV] {}
+    |. . . . [-> . .| [4:5] SBar[]/?x[] -> Comp[] * S[-INV]/?x[] {}
+    |. . . . . [-] .| [5:6] NP[-WH] -> 'you' *
+    |. . . . . [-> .| [5:6] S[-INV] -> NP[] * VP[] {}
+    |. . . . . [-> .| [5:6] S[-INV]/?x[] -> NP[] * VP[]/?x[] {}
+    |. . . . . [-> .| [5:6] S[-INV] -> NP[] * S[]/NP[] {}
+    |. . . . . . [-]| [6:7] V[-AUX, SUBCAT='trans'] -> 'like' *
+    |. . . . . . [->| [6:7] VP[] -> V[-AUX, SUBCAT='trans'] * NP[] {}
+    |. . . . . . [->| [6:7] VP[]/?x[] -> V[-AUX, SUBCAT='trans'] * NP[]/?x[] {}
+    |. . . . . . [-]| [6:7] VP[]/NP[] -> V[-AUX, SUBCAT='trans'] NP[]/NP[] *
+    |. . . . . [---]| [5:7] S[-INV]/NP[] -> NP[] VP[]/NP[] *
+    |. . . . [-----]| [4:7] SBar[]/NP[] -> Comp[] S[-INV]/NP[] *
+    |. . . [-------]| [3:7] VP[]/NP[] -> V[-AUX, SUBCAT='clause'] SBar[]/NP[] *
+    |. . [---------]| [2:7] S[-INV]/NP[] -> NP[] VP[]/NP[] *
+    |. [-----------]| [1:7] S[+INV]/NP[] -> V[+AUX] NP[] VP[]/NP[] *
+    |[=============]| [0:7] S[-INV] -> NP[] S[]/NP[] *
+
+    >>> trees = list(trees)
+    >>> for tree in trees: print(tree)
+    (S[-INV]
+      (NP[+WH] who)
+      (S[+INV]/NP[]
+        (V[+AUX] do)
+        (NP[-WH] you)
+        (VP[]/NP[]
+          (V[-AUX, SUBCAT='clause'] claim)
+          (SBar[]/NP[]
+            (Comp[] that)
+            (S[-INV]/NP[]
+              (NP[-WH] you)
+              (VP[]/NP[] (V[-AUX, SUBCAT='trans'] like) (NP[]/NP[] )))))))
+
+A different parser should give the same parse trees, but perhaps in a different order:
+
+    >>> cp2 = parse.load_parser('grammars/book_grammars/feat1.fcfg', trace=1,
+    ...                         parser=parse.FeatureEarleyChartParser)
+    >>> trees2 = cp2.parse(tokens)
+    |.w.d.y.c.t.y.l.|
+    |[-] . . . . . .| [0:1] 'who'
+    |. [-] . . . . .| [1:2] 'do'
+    |. . [-] . . . .| [2:3] 'you'
+    |. . . [-] . . .| [3:4] 'claim'
+    |. . . . [-] . .| [4:5] 'that'
+    |. . . . . [-] .| [5:6] 'you'
+    |. . . . . . [-]| [6:7] 'like'
+    |> . . . . . . .| [0:0] S[-INV] -> * NP[] VP[] {}
+    |> . . . . . . .| [0:0] S[-INV]/?x[] -> * NP[] VP[]/?x[] {}
+    |> . . . . . . .| [0:0] S[-INV] -> * NP[] S[]/NP[] {}
+    |> . . . . . . .| [0:0] S[-INV] -> * Adv[+NEG] S[+INV] {}
+    |> . . . . . . .| [0:0] S[+INV] -> * V[+AUX] NP[] VP[] {}
+    |> . . . . . . .| [0:0] S[+INV]/?x[] -> * V[+AUX] NP[] VP[]/?x[] {}
+    |> . . . . . . .| [0:0] NP[+WH] -> * 'who' {}
+    |[-] . . . . . .| [0:1] NP[+WH] -> 'who' *
+    |[-> . . . . . .| [0:1] S[-INV] -> NP[] * VP[] {}
+    |[-> . . . . . .| [0:1] S[-INV]/?x[] -> NP[] * VP[]/?x[] {}
+    |[-> . . . . . .| [0:1] S[-INV] -> NP[] * S[]/NP[] {}
+    |. > . . . . . .| [1:1] S[-INV]/?x[] -> * NP[] VP[]/?x[] {}
+    |. > . . . . . .| [1:1] S[+INV]/?x[] -> * V[+AUX] NP[] VP[]/?x[] {}
+    |. > . . . . . .| [1:1] V[+AUX] -> * 'do' {}
+    |. > . . . . . .| [1:1] VP[]/?x[] -> * V[-AUX, SUBCAT='trans'] NP[]/?x[] {}
+    |. > . . . . . .| [1:1] VP[]/?x[] -> * V[-AUX, SUBCAT='clause'] SBar[]/?x[] {}
+    |. > . . . . . .| [1:1] VP[]/?x[] -> * V[+AUX] VP[]/?x[] {}
+    |. > . . . . . .| [1:1] VP[] -> * V[-AUX, SUBCAT='intrans'] {}
+    |. > . . . . . .| [1:1] VP[] -> * V[-AUX, SUBCAT='trans'] NP[] {}
+    |. > . . . . . .| [1:1] VP[] -> * V[-AUX, SUBCAT='clause'] SBar[] {}
+    |. > . . . . . .| [1:1] VP[] -> * V[+AUX] VP[] {}
+    |. [-] . . . . .| [1:2] V[+AUX] -> 'do' *
+    |. [-> . . . . .| [1:2] S[+INV]/?x[] -> V[+AUX] * NP[] VP[]/?x[] {}
+    |. [-> . . . . .| [1:2] VP[]/?x[] -> V[+AUX] * VP[]/?x[] {}
+    |. [-> . . . . .| [1:2] VP[] -> V[+AUX] * VP[] {}
+    |. . > . . . . .| [2:2] VP[] -> * V[-AUX, SUBCAT='intrans'] {}
+    |. . > . . . . .| [2:2] VP[] -> * V[-AUX, SUBCAT='trans'] NP[] {}
+    |. . > . . . . .| [2:2] VP[] -> * V[-AUX, SUBCAT='clause'] SBar[] {}
+    |. . > . . . . .| [2:2] VP[] -> * V[+AUX] VP[] {}
+    |. . > . . . . .| [2:2] VP[]/?x[] -> * V[-AUX, SUBCAT='trans'] NP[]/?x[] {}
+    |. . > . . . . .| [2:2] VP[]/?x[] -> * V[-AUX, SUBCAT='clause'] SBar[]/?x[] {}
+    |. . > . . . . .| [2:2] VP[]/?x[] -> * V[+AUX] VP[]/?x[] {}
+    |. . > . . . . .| [2:2] NP[-WH] -> * 'you' {}
+    |. . [-] . . . .| [2:3] NP[-WH] -> 'you' *
+    |. [---> . . . .| [1:3] S[+INV]/?x[] -> V[+AUX] NP[] * VP[]/?x[] {}
+    |. . . > . . . .| [3:3] VP[]/?x[] -> * V[-AUX, SUBCAT='trans'] NP[]/?x[] {}
+    |. . . > . . . .| [3:3] VP[]/?x[] -> * V[-AUX, SUBCAT='clause'] SBar[]/?x[] {}
+    |. . . > . . . .| [3:3] VP[]/?x[] -> * V[+AUX] VP[]/?x[] {}
+    |. . . > . . . .| [3:3] V[-AUX, SUBCAT='clause'] -> * 'claim' {}
+    |. . . [-] . . .| [3:4] V[-AUX, SUBCAT='clause'] -> 'claim' *
+    |. . . [-> . . .| [3:4] VP[]/?x[] -> V[-AUX, SUBCAT='clause'] * SBar[]/?x[] {}
+    |. . . . > . . .| [4:4] SBar[]/?x[] -> * Comp[] S[-INV]/?x[] {}
+    |. . . . > . . .| [4:4] Comp[] -> * 'that' {}
+    |. . . . [-] . .| [4:5] Comp[] -> 'that' *
+    |. . . . [-> . .| [4:5] SBar[]/?x[] -> Comp[] * S[-INV]/?x[] {}
+    |. . . . . > . .| [5:5] S[-INV]/?x[] -> * NP[] VP[]/?x[] {}
+    |. . . . . > . .| [5:5] NP[-WH] -> * 'you' {}
+    |. . . . . [-] .| [5:6] NP[-WH] -> 'you' *
+    |. . . . . [-> .| [5:6] S[-INV]/?x[] -> NP[] * VP[]/?x[] {}
+    |. . . . . . > .| [6:6] VP[]/?x[] -> * V[-AUX, SUBCAT='trans'] NP[]/?x[] {}
+    |. . . . . . > .| [6:6] VP[]/?x[] -> * V[-AUX, SUBCAT='clause'] SBar[]/?x[] {}
+    |. . . . . . > .| [6:6] VP[]/?x[] -> * V[+AUX] VP[]/?x[] {}
+    |. . . . . . > .| [6:6] V[-AUX, SUBCAT='trans'] -> * 'like' {}
+    |. . . . . . [-]| [6:7] V[-AUX, SUBCAT='trans'] -> 'like' *
+    |. . . . . . [->| [6:7] VP[]/?x[] -> V[-AUX, SUBCAT='trans'] * NP[]/?x[] {}
+    |. . . . . . . #| [7:7] NP[]/NP[] -> *
+    |. . . . . . [-]| [6:7] VP[]/NP[] -> V[-AUX, SUBCAT='trans'] NP[]/NP[] *
+    |. . . . . [---]| [5:7] S[-INV]/NP[] -> NP[] VP[]/NP[] *
+    |. . . . [-----]| [4:7] SBar[]/NP[] -> Comp[] S[-INV]/NP[] *
+    |. . . [-------]| [3:7] VP[]/NP[] -> V[-AUX, SUBCAT='clause'] SBar[]/NP[] *
+    |. [-----------]| [1:7] S[+INV]/NP[] -> V[+AUX] NP[] VP[]/NP[] *
+    |[=============]| [0:7] S[-INV] -> NP[] S[]/NP[] *
+
+    >>> sorted(trees) == sorted(trees2)
+    True
+
+
+Let's load a German grammar:
+
+    >>> cp = parse.load_parser('grammars/book_grammars/german.fcfg', trace=0)
+    >>> sent = 'die Katze sieht den Hund'
+    >>> tokens = sent.split()
+    >>> trees = cp.parse(tokens)
+    >>> for tree in trees: print(tree)
+    (S[]
+      (NP[AGR=[GND='fem', NUM='sg', PER=3], CASE='nom']
+        (Det[AGR=[GND='fem', NUM='sg', PER=3], CASE='nom'] die)
+        (N[AGR=[GND='fem', NUM='sg', PER=3]] Katze))
+      (VP[AGR=[NUM='sg', PER=3]]
+        (TV[AGR=[NUM='sg', PER=3], OBJCASE='acc'] sieht)
+        (NP[AGR=[GND='masc', NUM='sg', PER=3], CASE='acc']
+          (Det[AGR=[GND='masc', NUM='sg', PER=3], CASE='acc'] den)
+          (N[AGR=[GND='masc', NUM='sg', PER=3]] Hund))))
+
+Grammar with Binding Operators
+------------------------------
+The bindop.fcfg grammar is a semantic grammar that uses lambda
+calculus.  Each element has a core semantics, which is a single lambda
+calculus expression; and a set of binding operators, which bind
+variables.
+
+In order to make the binding operators work right, they need to
+instantiate their bound variable every time they are added to the
+chart.  To do this, we use a special subclass of `Chart`, called
+`InstantiateVarsChart`.
+
+    >>> from nltk.parse.featurechart import InstantiateVarsChart
+    >>> cp = parse.load_parser('grammars/sample_grammars/bindop.fcfg', trace=1,
+    ...                        chart_class=InstantiateVarsChart)
+    >>> print(cp.grammar())
+    Grammar with 15 productions (start state = S[])
+        S[SEM=[BO={?b1+?b2}, CORE=<?vp(?subj)>]] -> NP[SEM=[BO=?b1, CORE=?subj]] VP[SEM=[BO=?b2, CORE=?vp]]
+        VP[SEM=[BO={?b1+?b2}, CORE=<?v(?obj)>]] -> TV[SEM=[BO=?b1, CORE=?v]] NP[SEM=[BO=?b2, CORE=?obj]]
+        VP[SEM=?s] -> IV[SEM=?s]
+        NP[SEM=[BO={?b1+?b2+{bo(?det(?n),@x)}}, CORE=<@x>]] -> Det[SEM=[BO=?b1, CORE=?det]] N[SEM=[BO=?b2, CORE=?n]]
+        Det[SEM=[BO={/}, CORE=<\Q P.exists x.(Q(x) & P(x))>]] -> 'a'
+        N[SEM=[BO={/}, CORE=<dog>]] -> 'dog'
+        N[SEM=[BO={/}, CORE=<dog>]] -> 'cat'
+        N[SEM=[BO={/}, CORE=<dog>]] -> 'mouse'
+        IV[SEM=[BO={/}, CORE=<\x.bark(x)>]] -> 'barks'
+        IV[SEM=[BO={/}, CORE=<\x.bark(x)>]] -> 'eats'
+        IV[SEM=[BO={/}, CORE=<\x.bark(x)>]] -> 'walks'
+        TV[SEM=[BO={/}, CORE=<\x y.feed(y,x)>]] -> 'feeds'
+        TV[SEM=[BO={/}, CORE=<\x y.feed(y,x)>]] -> 'walks'
+        NP[SEM=[BO={bo(\P.P(John),@x)}, CORE=<@x>]] -> 'john'
+        NP[SEM=[BO={bo(\P.P(John),@x)}, CORE=<@x>]] -> 'alex'
+
+A simple intransitive sentence:
+
+    >>> from nltk.sem import logic
+    >>> logic._counter._value = 100
+
+    >>> trees = cp.parse('john barks'.split())
+    |. john.barks.|
+    |[-----]     .| [0:1] 'john'
+    |.     [-----]| [1:2] 'barks'
+    |[-----]     .| [0:1] NP[SEM=[BO={bo(\P.P(John),z101)}, CORE=<z101>]] -> 'john' *
+    |[----->     .| [0:1] S[SEM=[BO={?b1+?b2}, CORE=<?vp(?subj)>]] -> NP[SEM=[BO=?b1, CORE=?subj]] * VP[SEM=[BO=?b2, CORE=?vp]] {?b1: {bo(\P.P(John),z2)}, ?subj: <IndividualVariableExpression z2>}
+    |.     [-----]| [1:2] IV[SEM=[BO={/}, CORE=<\x.bark(x)>]] -> 'barks' *
+    |.     [-----]| [1:2] VP[SEM=[BO={/}, CORE=<\x.bark(x)>]] -> IV[SEM=[BO={/}, CORE=<\x.bark(x)>]] *
+    |[===========]| [0:2] S[SEM=[BO={bo(\P.P(John),z2)}, CORE=<bark(z2)>]] -> NP[SEM=[BO={bo(\P.P(John),z2)}, CORE=<z2>]] VP[SEM=[BO={/}, CORE=<\x.bark(x)>]] *
+    >>> for tree in trees: print(tree)
+    (S[SEM=[BO={bo(\P.P(John),z2)}, CORE=<bark(z2)>]]
+      (NP[SEM=[BO={bo(\P.P(John),z101)}, CORE=<z101>]] john)
+      (VP[SEM=[BO={/}, CORE=<\x.bark(x)>]]
+        (IV[SEM=[BO={/}, CORE=<\x.bark(x)>]] barks)))
+
+A transitive sentence:
+
+    >>> trees = cp.parse('john feeds a dog'.split())
+    |.joh.fee. a .dog.|
+    |[---]   .   .   .| [0:1] 'john'
+    |.   [---]   .   .| [1:2] 'feeds'
+    |.   .   [---]   .| [2:3] 'a'
+    |.   .   .   [---]| [3:4] 'dog'
+    |[---]   .   .   .| [0:1] NP[SEM=[BO={bo(\P.P(John),z102)}, CORE=<z102>]] -> 'john' *
+    |[--->   .   .   .| [0:1] S[SEM=[BO={?b1+?b2}, CORE=<?vp(?subj)>]] -> NP[SEM=[BO=?b1, CORE=?subj]] * VP[SEM=[BO=?b2, CORE=?vp]] {?b1: {bo(\P.P(John),z2)}, ?subj: <IndividualVariableExpression z2>}
+    |.   [---]   .   .| [1:2] TV[SEM=[BO={/}, CORE=<\x y.feed(y,x)>]] -> 'feeds' *
+    |.   [--->   .   .| [1:2] VP[SEM=[BO={?b1+?b2}, CORE=<?v(?obj)>]] -> TV[SEM=[BO=?b1, CORE=?v]] * NP[SEM=[BO=?b2, CORE=?obj]] {?b1: {/}, ?v: <LambdaExpression \x y.feed(y,x)>}
+    |.   .   [---]   .| [2:3] Det[SEM=[BO={/}, CORE=<\Q P.exists x.(Q(x) & P(x))>]] -> 'a' *
+    |.   .   [--->   .| [2:3] NP[SEM=[BO={?b1+?b2+{bo(?det(?n),@x)}}, CORE=<@x>]] -> Det[SEM=[BO=?b1, CORE=?det]] * N[SEM=[BO=?b2, CORE=?n]] {?b1: {/}, ?det: <LambdaExpression \Q P.exists x.(Q(x) & P(x))>}
+    |.   .   .   [---]| [3:4] N[SEM=[BO={/}, CORE=<dog>]] -> 'dog' *
+    |.   .   [-------]| [2:4] NP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z103)}, CORE=<z103>]] -> Det[SEM=[BO={/}, CORE=<\Q P.exists x.(Q(x) & P(x))>]] N[SEM=[BO={/}, CORE=<dog>]] *
+    |.   .   [------->| [2:4] S[SEM=[BO={?b1+?b2}, CORE=<?vp(?subj)>]] -> NP[SEM=[BO=?b1, CORE=?subj]] * VP[SEM=[BO=?b2, CORE=?vp]] {?b1: {bo(\P.exists x.(dog(x) & P(x)),z2)}, ?subj: <IndividualVariableExpression z2>}
+    |.   [-----------]| [1:4] VP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z2)}, CORE=<\y.feed(y,z2)>]] -> TV[SEM=[BO={/}, CORE=<\x y.feed(y,x)>]] NP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z2)}, CORE=<z2>]] *
+    |[===============]| [0:4] S[SEM=[BO={bo(\P.P(John),z2), bo(\P.exists x.(dog(x) & P(x)),z3)}, CORE=<feed(z2,z3)>]] -> NP[SEM=[BO={bo(\P.P(John),z2)}, CORE=<z2>]] VP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z3)}, CORE=<\y.feed(y,z3)>]] *
+
+    >>> for tree in trees: print(tree)
+    (S[SEM=[BO={bo(\P.P(John),z2), bo(\P.exists x.(dog(x) & P(x)),z3)}, CORE=<feed(z2,z3)>]]
+      (NP[SEM=[BO={bo(\P.P(John),z102)}, CORE=<z102>]] john)
+      (VP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z2)}, CORE=<\y.feed(y,z2)>]]
+        (TV[SEM=[BO={/}, CORE=<\x y.feed(y,x)>]] feeds)
+        (NP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z103)}, CORE=<z103>]]
+          (Det[SEM=[BO={/}, CORE=<\Q P.exists x.(Q(x) & P(x))>]] a)
+          (N[SEM=[BO={/}, CORE=<dog>]] dog))))
+
+Turn down the verbosity:
+
+    >>> cp = parse.load_parser('grammars/sample_grammars/bindop.fcfg', trace=0,
+    ...                       chart_class=InstantiateVarsChart)
+
+Reuse the same lexical item twice:
+
+    >>> trees = cp.parse('john feeds john'.split())
+    >>> for tree in trees: print(tree)
+    (S[SEM=[BO={bo(\P.P(John),z2), bo(\P.P(John),z3)}, CORE=<feed(z2,z3)>]]
+      (NP[SEM=[BO={bo(\P.P(John),z104)}, CORE=<z104>]] john)
+      (VP[SEM=[BO={bo(\P.P(John),z2)}, CORE=<\y.feed(y,z2)>]]
+        (TV[SEM=[BO={/}, CORE=<\x y.feed(y,x)>]] feeds)
+        (NP[SEM=[BO={bo(\P.P(John),z105)}, CORE=<z105>]] john)))
+
+    >>> trees = cp.parse('a dog feeds a dog'.split())
+    >>> for tree in trees: print(tree)
+    (S[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z2), bo(\P.exists x.(dog(x) & P(x)),z3)}, CORE=<feed(z2,z3)>]]
+      (NP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z106)}, CORE=<z106>]]
+        (Det[SEM=[BO={/}, CORE=<\Q P.exists x.(Q(x) & P(x))>]] a)
+        (N[SEM=[BO={/}, CORE=<dog>]] dog))
+      (VP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z2)}, CORE=<\y.feed(y,z2)>]]
+        (TV[SEM=[BO={/}, CORE=<\x y.feed(y,x)>]] feeds)
+        (NP[SEM=[BO={bo(\P.exists x.(dog(x) & P(x)),z107)}, CORE=<z107>]]
+          (Det[SEM=[BO={/}, CORE=<\Q P.exists x.(Q(x) & P(x))>]] a)
+          (N[SEM=[BO={/}, CORE=<dog>]] dog))))

lib/python3.10/site-packages/nltk/test/featstruct.doctest

@@ -0,0 +1,1229 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+==================================
+ Feature Structures & Unification
+==================================
+    >>> from nltk.featstruct import FeatStruct
+    >>> from nltk.sem.logic import Variable, VariableExpression, Expression
+
+.. note:: For now, featstruct uses the older lambdalogic semantics
+   module.  Eventually, it should be updated to use the new first
+   order predicate logic module.
+
+Overview
+~~~~~~~~
+A feature structure is a mapping from feature identifiers to feature
+values, where feature values can be simple values (like strings or
+ints), nested feature structures, or variables:
+
+    >>> fs1 = FeatStruct(number='singular', person=3)
+    >>> print(fs1)
+    [ number = 'singular' ]
+    [ person = 3          ]
+
+Feature structure may be nested:
+
+    >>> fs2 = FeatStruct(type='NP', agr=fs1)
+    >>> print(fs2)
+    [ agr  = [ number = 'singular' ] ]
+    [        [ person = 3          ] ]
+    [                                ]
+    [ type = 'NP'                    ]
+
+Variables are used to indicate that two features should be assigned
+the same value.  For example, the following feature structure requires
+that the feature fs3['agr']['number'] be bound to the same value as the
+feature fs3['subj']['number'].
+
+    >>> fs3 = FeatStruct(agr=FeatStruct(number=Variable('?n')),
+    ...                  subj=FeatStruct(number=Variable('?n')))
+    >>> print(fs3)
+    [ agr  = [ number = ?n ] ]
+    [                        ]
+    [ subj = [ number = ?n ] ]
+
+Feature structures are typically used to represent partial information
+about objects.  A feature name that is not mapped to a value stands
+for a feature whose value is unknown (*not* a feature without a
+value).  Two feature structures that represent (potentially
+overlapping) information about the same object can be combined by
+*unification*.
+
+    >>> print(fs2.unify(fs3))
+    [ agr  = [ number = 'singular' ] ]
+    [        [ person = 3          ] ]
+    [                                ]
+    [ subj = [ number = 'singular' ] ]
+    [                                ]
+    [ type = 'NP'                    ]
+
+When two inconsistent feature structures are unified, the unification
+fails and returns ``None``.
+
+    >>> fs4 = FeatStruct(agr=FeatStruct(person=1))
+    >>> print(fs4.unify(fs2))
+    None
+    >>> print(fs2.unify(fs4))
+    None
+
+..
+    >>> del fs1, fs2, fs3, fs4 # clean-up
+
+Feature Structure Types
+-----------------------
+There are actually two types of feature structure:
+
+- *feature dictionaries*, implemented by `FeatDict`, act like
+  Python dictionaries.  Feature identifiers may be strings or
+  instances of the `Feature` class.
+- *feature lists*, implemented by `FeatList`, act like Python
+  lists.  Feature identifiers are integers.
+
+When you construct a feature structure using the `FeatStruct`
+constructor, it will automatically decide which type is appropriate:
+
+    >>> type(FeatStruct(number='singular'))
+    <class 'nltk.featstruct.FeatDict'>
+    >>> type(FeatStruct([1,2,3]))
+    <class 'nltk.featstruct.FeatList'>
+
+Usually, we will just use feature dictionaries; but sometimes feature
+lists can be useful too.  Two feature lists will unify with each other
+only if they have equal lengths, and all of their feature values
+match.  If you wish to write a feature list that contains 'unknown'
+values, you must use variables:
+
+    >>> fs1 = FeatStruct([1,2,Variable('?y')])
+    >>> fs2 = FeatStruct([1,Variable('?x'),3])
+    >>> fs1.unify(fs2)
+    [1, 2, 3]
+
+..
+    >>> del fs1, fs2 # clean-up
+
+Parsing Feature Structure Strings
+---------------------------------
+Feature structures can be constructed directly from strings.  Often,
+this is more convenient than constructing them directly.  NLTK can
+parse most feature strings to produce the corresponding feature
+structures.  (But you must restrict your base feature values to
+strings, ints, logic expressions (`nltk.sem.logic.Expression`), and a
+few other types discussed below).
+
+Feature dictionaries are written like Python dictionaries, except that
+keys are not put in quotes; and square brackets (``[]``) are used
+instead of braces (``{}``):
+
+    >>> FeatStruct('[tense="past", agr=[number="sing", person=3]]')
+    [agr=[number='sing', person=3], tense='past']
+
+If a feature value is a single alphanumeric word, then it does not
+need to be quoted -- it will be automatically treated as a string:
+
+    >>> FeatStruct('[tense=past, agr=[number=sing, person=3]]')
+    [agr=[number='sing', person=3], tense='past']
+
+Feature lists are written like python lists:
+
+    >>> FeatStruct('[1, 2, 3]')
+    [1, 2, 3]
+
+The expression ``[]`` is treated as an empty feature dictionary, not
+an empty feature list:
+
+    >>> type(FeatStruct('[]'))
+    <class 'nltk.featstruct.FeatDict'>
+
+Feature Paths
+-------------
+Features can be specified using *feature paths*, or tuples of feature
+identifiers that specify path through the nested feature structures to
+a value.
+
+    >>> fs1 = FeatStruct('[x=1, y=[1,2,[z=3]]]')
+    >>> fs1['y']
+    [1, 2, [z=3]]
+    >>> fs1['y', 2]
+    [z=3]
+    >>> fs1['y', 2, 'z']
+    3
+
+..
+    >>> del fs1 # clean-up
+
+Reentrance
+----------
+Feature structures may contain reentrant feature values.  A *reentrant
+feature value* is a single feature structure that can be accessed via
+multiple feature paths.
+
+    >>> fs1 = FeatStruct(x='val')
+    >>> fs2 = FeatStruct(a=fs1, b=fs1)
+    >>> print(fs2)
+    [ a = (1) [ x = 'val' ] ]
+    [                       ]
+    [ b -> (1)              ]
+    >>> fs2
+    [a=(1)[x='val'], b->(1)]
+
+As you can see, reentrane is displayed by marking a feature structure
+with a unique identifier, in this case ``(1)``, the first time it is
+encountered; and then using the special form ``var -> id`` whenever it
+is encountered again.  You can use the same notation to directly
+create reentrant feature structures from strings.
+
+    >>> FeatStruct('[a=(1)[], b->(1), c=[d->(1)]]')
+    [a=(1)[], b->(1), c=[d->(1)]]
+
+Reentrant feature structures may contain cycles:
+
+    >>> fs3 = FeatStruct('(1)[a->(1)]')
+    >>> fs3['a', 'a', 'a', 'a']
+    (1)[a->(1)]
+    >>> fs3['a', 'a', 'a', 'a'] is fs3
+    True
+
+Unification preserves the reentrance relations imposed by both of the
+unified feature structures.  In the feature structure resulting from
+unification, any modifications to a reentrant feature value will be
+visible using any of its feature paths.
+
+    >>> fs3.unify(FeatStruct('[a=[b=12], c=33]'))
+    (1)[a->(1), b=12, c=33]
+
+..
+    >>> del fs1, fs2, fs3 # clean-up
+
+Feature Structure Equality
+--------------------------
+Two feature structures are considered equal if they assign the same
+values to all features, *and* they contain the same reentrances.
+
+    >>> fs1 = FeatStruct('[a=(1)[x=1], b->(1)]')
+    >>> fs2 = FeatStruct('[a=(1)[x=1], b->(1)]')
+    >>> fs3 = FeatStruct('[a=[x=1], b=[x=1]]')
+    >>> fs1 == fs1, fs1 is fs1
+    (True, True)
+    >>> fs1 == fs2, fs1 is fs2
+    (True, False)
+    >>> fs1 == fs3, fs1 is fs3
+    (False, False)
+
+Note that this differs from how Python dictionaries and lists define
+equality -- in particular, Python dictionaries and lists ignore
+reentrance relations.  To test two feature structures for equality
+while ignoring reentrance relations, use the `equal_values()` method:
+
+    >>> fs1.equal_values(fs1)
+    True
+    >>> fs1.equal_values(fs2)
+    True
+    >>> fs1.equal_values(fs3)
+    True
+
+..
+    >>> del fs1, fs2, fs3 # clean-up
+
+Feature Value Sets & Feature Value Tuples
+-----------------------------------------
+`nltk.featstruct` defines two new data types that are intended to be
+used as feature values: `FeatureValueTuple` and `FeatureValueSet`.
+Both of these types are considered base values -- i.e., unification
+does *not* apply to them.  However, variable binding *does* apply to
+any values that they contain.
+
+Feature value tuples are written with parentheses:
+
+    >>> fs1 = FeatStruct('[x=(?x, ?y)]')
+    >>> fs1
+    [x=(?x, ?y)]
+    >>> fs1.substitute_bindings({Variable('?x'): 1, Variable('?y'): 2})
+    [x=(1, 2)]
+
+Feature sets are written with braces:
+
+    >>> fs1 = FeatStruct('[x={?x, ?y}]')
+    >>> fs1
+    [x={?x, ?y}]
+    >>> fs1.substitute_bindings({Variable('?x'): 1, Variable('?y'): 2})
+    [x={1, 2}]
+
+In addition to the basic feature value tuple & set classes, nltk
+defines feature value unions (for sets) and feature value
+concatenations (for tuples).  These are written using '+', and can be
+used to combine sets & tuples:
+
+    >>> fs1 = FeatStruct('[x=((1, 2)+?z), z=?z]')
+    >>> fs1
+    [x=((1, 2)+?z), z=?z]
+    >>> fs1.unify(FeatStruct('[z=(3, 4, 5)]'))
+    [x=(1, 2, 3, 4, 5), z=(3, 4, 5)]
+
+Thus, feature value tuples and sets can be used to build up tuples
+and sets of values over the course of unification.  For example, when
+parsing sentences using a semantic feature grammar, feature sets or
+feature tuples can be used to build a list of semantic predicates as
+the sentence is parsed.
+
+As was mentioned above, unification does not apply to feature value
+tuples and sets.  One reason for this that it's impossible to define a
+single correct answer for unification when concatenation is used.
+Consider the following example:
+
+    >>> fs1 = FeatStruct('[x=(1, 2, 3, 4)]')
+    >>> fs2 = FeatStruct('[x=(?a+?b), a=?a, b=?b]')
+
+If unification applied to feature tuples, then the unification
+algorithm would have to arbitrarily choose how to divide the tuple
+(1,2,3,4) into two parts.  Instead, the unification algorithm refuses
+to make this decision, and simply unifies based on value.  Because
+(1,2,3,4) is not equal to (?a+?b), fs1 and fs2 will not unify:
+
+    >>> print(fs1.unify(fs2))
+    None
+
+If you need a list-like structure that unification does apply to, use
+`FeatList`.
+
+..
+    >>> del fs1, fs2 # clean-up
+
+Light-weight Feature Structures
+-------------------------------
+Many of the functions defined by `nltk.featstruct` can be applied
+directly to simple Python dictionaries and lists, rather than to
+full-fledged `FeatDict` and `FeatList` objects.  In other words,
+Python ``dicts`` and ``lists`` can be used as "light-weight" feature
+structures.
+
+    >>> # Note: pprint prints dicts sorted
+    >>> from pprint import pprint
+    >>> from nltk.featstruct import unify
+    >>> pprint(unify(dict(x=1, y=dict()), dict(a='a', y=dict(b='b'))))
+    {'a': 'a', 'x': 1, 'y': {'b': 'b'}}
+
+However, you should keep in mind the following caveats:
+
+- Python dictionaries & lists ignore reentrance when checking for
+  equality between values.  But two FeatStructs with different
+  reentrances are considered nonequal, even if all their base
+  values are equal.
+
+- FeatStructs can be easily frozen, allowing them to be used as
+  keys in hash tables.  Python dictionaries and lists can not.
+
+- FeatStructs display reentrance in their string representations;
+  Python dictionaries and lists do not.
+
+- FeatStructs may *not* be mixed with Python dictionaries and lists
+  (e.g., when performing unification).
+
+- FeatStructs provide a number of useful methods, such as `walk()`
+  and `cyclic()`, which are not available for Python dicts & lists.
+
+In general, if your feature structures will contain any reentrances,
+or if you plan to use them as dictionary keys, it is strongly
+recommended that you use full-fledged `FeatStruct` objects.
+
+Custom Feature Values
+---------------------
+The abstract base class `CustomFeatureValue` can be used to define new
+base value types that have custom unification methods.  For example,
+the following feature value type encodes a range, and defines
+unification as taking the intersection on the ranges:
+
+    >>> from functools import total_ordering
+    >>> from nltk.featstruct import CustomFeatureValue, UnificationFailure
+    >>> @total_ordering
+    ... class Range(CustomFeatureValue):
+    ...     def __init__(self, low, high):
+    ...         assert low <= high
+    ...         self.low = low
+    ...         self.high = high
+    ...     def unify(self, other):
+    ...         if not isinstance(other, Range):
+    ...             return UnificationFailure
+    ...         low = max(self.low, other.low)
+    ...         high = min(self.high, other.high)
+    ...         if low <= high: return Range(low, high)
+    ...         else: return UnificationFailure
+    ...     def __repr__(self):
+    ...         return '(%s<x<%s)' % (self.low, self.high)
+    ...     def __eq__(self, other):
+    ...         if not isinstance(other, Range):
+    ...             return False
+    ...         return (self.low == other.low) and (self.high == other.high)
+    ...     def __lt__(self, other):
+    ...         if not isinstance(other, Range):
+    ...             return True
+    ...         return (self.low, self.high) < (other.low, other.high)
+
+    >>> fs1 = FeatStruct(x=Range(5,8), y=FeatStruct(z=Range(7,22)))
+    >>> print(fs1.unify(FeatStruct(x=Range(6, 22))))
+    [ x = (6<x<8)          ]
+    [                      ]
+    [ y = [ z = (7<x<22) ] ]
+    >>> print(fs1.unify(FeatStruct(x=Range(9, 12))))
+    None
+    >>> print(fs1.unify(FeatStruct(x=12)))
+    None
+    >>> print(fs1.unify(FeatStruct('[x=?x, y=[z=?x]]')))
+    [ x = (7<x<8)         ]
+    [                     ]
+    [ y = [ z = (7<x<8) ] ]
+
+Regression Tests
+~~~~~~~~~~~~~~~~
+
+Dictionary access methods (non-mutating)
+----------------------------------------
+
+    >>> fs1 = FeatStruct(a=1, b=2, c=3)
+    >>> fs2 = FeatStruct(x=fs1, y='x')
+
+Feature structures support all dictionary methods (excluding the class
+method `dict.fromkeys()`).  Non-mutating methods:
+
+    >>> sorted(fs2.keys())                               # keys()
+    ['x', 'y']
+    >>> sorted(fs2.values())                             # values()
+    [[a=1, b=2, c=3], 'x']
+    >>> sorted(fs2.items())                              # items()
+    [('x', [a=1, b=2, c=3]), ('y', 'x')]
+    >>> sorted(fs2)                                      # __iter__()
+    ['x', 'y']
+    >>> 'a' in fs2, 'x' in fs2                           # __contains__()
+    (False, True)
+    >>> fs2.has_key('a'), fs2.has_key('x')               # has_key()
+    (False, True)
+    >>> fs2['x'], fs2['y']                               # __getitem__()
+    ([a=1, b=2, c=3], 'x')
+    >>> fs2['a']                                         # __getitem__()
+    Traceback (most recent call last):
+      . . .
+    KeyError: 'a'
+    >>> fs2.get('x'), fs2.get('y'), fs2.get('a')         # get()
+    ([a=1, b=2, c=3], 'x', None)
+    >>> fs2.get('x', 'hello'), fs2.get('a', 'hello')     # get()
+    ([a=1, b=2, c=3], 'hello')
+    >>> len(fs1), len(fs2)                               # __len__
+    (3, 2)
+    >>> fs2.copy()                                       # copy()
+    [x=[a=1, b=2, c=3], y='x']
+    >>> fs2.copy() is fs2                                # copy()
+    False
+
+Note: by default, `FeatStruct.copy()` does a deep copy.  Use
+`FeatStruct.copy(deep=False)` for a shallow copy.
+
+..
+    >>> del fs1, fs2 # clean-up.
+
+Dictionary access methods (mutating)
+------------------------------------
+    >>> fs1 = FeatStruct(a=1, b=2, c=3)
+    >>> fs2 = FeatStruct(x=fs1, y='x')
+
+Setting features (`__setitem__()`)
+
+    >>> fs1['c'] = 5
+    >>> fs1
+    [a=1, b=2, c=5]
+    >>> fs1['x'] = 12
+    >>> fs1
+    [a=1, b=2, c=5, x=12]
+    >>> fs2['x', 'a'] = 2
+    >>> fs2
+    [x=[a=2, b=2, c=5, x=12], y='x']
+    >>> fs1
+    [a=2, b=2, c=5, x=12]
+
+Deleting features (`__delitem__()`)
+
+    >>> del fs1['x']
+    >>> fs1
+    [a=2, b=2, c=5]
+    >>> del fs2['x', 'a']
+    >>> fs1
+    [b=2, c=5]
+
+`setdefault()`:
+
+    >>> fs1.setdefault('b', 99)
+    2
+    >>> fs1
+    [b=2, c=5]
+    >>> fs1.setdefault('x', 99)
+    99
+    >>> fs1
+    [b=2, c=5, x=99]
+
+`update()`:
+
+    >>> fs2.update({'a':'A', 'b':'B'}, c='C')
+    >>> fs2
+    [a='A', b='B', c='C', x=[b=2, c=5, x=99], y='x']
+
+`pop()`:
+
+    >>> fs2.pop('a')
+    'A'
+    >>> fs2
+    [b='B', c='C', x=[b=2, c=5, x=99], y='x']
+    >>> fs2.pop('a')
+    Traceback (most recent call last):
+      . . .
+    KeyError: 'a'
+    >>> fs2.pop('a', 'foo')
+    'foo'
+    >>> fs2
+    [b='B', c='C', x=[b=2, c=5, x=99], y='x']
+
+`clear()`:
+
+    >>> fs1.clear()
+    >>> fs1
+    []
+    >>> fs2
+    [b='B', c='C', x=[], y='x']
+
+`popitem()`:
+
+    >>> sorted([fs2.popitem() for i in range(len(fs2))])
+    [('b', 'B'), ('c', 'C'), ('x', []), ('y', 'x')]
+    >>> fs2
+    []
+
+Once a feature structure has been frozen, it may not be mutated.
+
+    >>> fs1 = FeatStruct('[x=1, y=2, z=[a=3]]')
+    >>> fs1.freeze()
+    >>> fs1.frozen()
+    True
+    >>> fs1['z'].frozen()
+    True
+
+    >>> fs1['x'] = 5
+    Traceback (most recent call last):
+      . . .
+    ValueError: Frozen FeatStructs may not be modified.
+    >>> del fs1['x']
+    Traceback (most recent call last):
+      . . .
+    ValueError: Frozen FeatStructs may not be modified.
+    >>> fs1.clear()
+    Traceback (most recent call last):
+      . . .
+    ValueError: Frozen FeatStructs may not be modified.
+    >>> fs1.pop('x')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Frozen FeatStructs may not be modified.
+    >>> fs1.popitem()
+    Traceback (most recent call last):
+      . . .
+    ValueError: Frozen FeatStructs may not be modified.
+    >>> fs1.setdefault('x')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Frozen FeatStructs may not be modified.
+    >>> fs1.update(z=22)
+    Traceback (most recent call last):
+      . . .
+    ValueError: Frozen FeatStructs may not be modified.
+
+..
+    >>> del fs1, fs2 # clean-up.
+
+Feature Paths
+-------------
+Make sure that __getitem__ with feature paths works as intended:
+
+    >>> fs1 = FeatStruct(a=1, b=2,
+    ...                 c=FeatStruct(
+    ...                     d=FeatStruct(e=12),
+    ...                     f=FeatStruct(g=55, h='hello')))
+    >>> fs1[()]
+    [a=1, b=2, c=[d=[e=12], f=[g=55, h='hello']]]
+    >>> fs1['a'], fs1[('a',)]
+    (1, 1)
+    >>> fs1['c','d','e']
+    12
+    >>> fs1['c','f','g']
+    55
+
+Feature paths that select unknown features raise KeyError:
+
+    >>> fs1['c', 'f', 'e']
+    Traceback (most recent call last):
+      . . .
+    KeyError: ('c', 'f', 'e')
+    >>> fs1['q', 'p']
+    Traceback (most recent call last):
+      . . .
+    KeyError: ('q', 'p')
+
+Feature paths that try to go 'through' a feature that's not a feature
+structure raise KeyError:
+
+    >>> fs1['a', 'b']
+    Traceback (most recent call last):
+      . . .
+    KeyError: ('a', 'b')
+
+Feature paths can go through reentrant structures:
+
+    >>> fs2 = FeatStruct('(1)[a=[b=[c->(1), d=5], e=11]]')
+    >>> fs2['a', 'b', 'c', 'a', 'e']
+    11
+    >>> fs2['a', 'b', 'c', 'a', 'b', 'd']
+    5
+    >>> fs2[tuple('abcabcabcabcabcabcabcabcabcabca')]
+    (1)[b=[c=[a->(1)], d=5], e=11]
+
+Indexing requires strings, `Feature`\s, or tuples; other types raise a
+TypeError:
+
+    >>> fs2[12]
+    Traceback (most recent call last):
+      . . .
+    TypeError: Expected feature name or path.  Got 12.
+    >>> fs2[list('abc')]
+    Traceback (most recent call last):
+      . . .
+    TypeError: Expected feature name or path.  Got ['a', 'b', 'c'].
+
+Feature paths can also be used with `get()`, `has_key()`, and
+`__contains__()`.
+
+    >>> fpath1 = tuple('abcabc')
+    >>> fpath2 = tuple('abcabz')
+    >>> fs2.get(fpath1), fs2.get(fpath2)
+    ((1)[a=[b=[c->(1), d=5], e=11]], None)
+    >>> fpath1 in fs2, fpath2 in fs2
+    (True, False)
+    >>> fs2.has_key(fpath1), fs2.has_key(fpath2)
+    (True, False)
+
+..
+    >>> del fs1, fs2 # clean-up
+
+Reading Feature Structures
+--------------------------
+
+Empty feature struct:
+
+    >>> FeatStruct('[]')
+    []
+
+Test features with integer values:
+
+    >>> FeatStruct('[a=12, b=-33, c=0]')
+    [a=12, b=-33, c=0]
+
+Test features with string values.  Either single or double quotes may
+be used.  Strings are evaluated just like python strings -- in
+particular, you can use escape sequences and 'u' and 'r' prefixes, and
+triple-quoted strings.
+
+    >>> FeatStruct('[a="", b="hello", c="\'", d=\'\', e=\'"\']')
+    [a='', b='hello', c="'", d='', e='"']
+    >>> FeatStruct(r'[a="\\", b="\"", c="\x6f\\y", d="12"]')
+    [a='\\', b='"', c='o\\y', d='12']
+    >>> FeatStruct(r'[b=r"a\b\c"]')
+    [b='a\\b\\c']
+    >>> FeatStruct('[x="""a"""]')
+    [x='a']
+
+Test parsing of reentrant feature structures.
+
+    >>> FeatStruct('[a=(1)[], b->(1)]')
+    [a=(1)[], b->(1)]
+    >>> FeatStruct('[a=(1)[x=1, y=2], b->(1)]')
+    [a=(1)[x=1, y=2], b->(1)]
+
+Test parsing of cyclic feature structures.
+
+    >>> FeatStruct('[a=(1)[b->(1)]]')
+    [a=(1)[b->(1)]]
+    >>> FeatStruct('(1)[a=[b=[c->(1)]]]')
+    (1)[a=[b=[c->(1)]]]
+
+Strings of the form "+name" and "-name" may be used to specify boolean
+values.
+
+    >>> FeatStruct('[-bar, +baz, +foo]')
+    [-bar, +baz, +foo]
+
+None, True, and False are recognized as values:
+
+    >>> FeatStruct('[bar=True, baz=False, foo=None]')
+    [+bar, -baz, foo=None]
+
+Special features:
+
+    >>> FeatStruct('NP/VP')
+    NP[]/VP[]
+    >>> FeatStruct('?x/?x')
+    ?x[]/?x[]
+    >>> print(FeatStruct('VP[+fin, agr=?x, tense=past]/NP[+pl, agr=?x]'))
+    [ *type*  = 'VP'              ]
+    [                             ]
+    [           [ *type* = 'NP' ] ]
+    [ *slash* = [ agr    = ?x   ] ]
+    [           [ pl     = True ] ]
+    [                             ]
+    [ agr     = ?x                ]
+    [ fin     = True              ]
+    [ tense   = 'past'            ]
+
+Here the slash feature gets coerced:
+
+    >>> FeatStruct('[*slash*=a, x=b, *type*="NP"]')
+    NP[x='b']/a[]
+
+    >>> FeatStruct('NP[sem=<bob>]/NP')
+    NP[sem=<bob>]/NP[]
+    >>> FeatStruct('S[sem=<walk(bob)>]')
+    S[sem=<walk(bob)>]
+    >>> print(FeatStruct('NP[sem=<bob>]/NP'))
+    [ *type*  = 'NP'              ]
+    [                             ]
+    [ *slash* = [ *type* = 'NP' ] ]
+    [                             ]
+    [ sem     = <bob>             ]
+
+Playing with ranges:
+
+    >>> from nltk.featstruct import RangeFeature, FeatStructReader
+    >>> width = RangeFeature('width')
+    >>> reader = FeatStructReader([width])
+    >>> fs1 = reader.fromstring('[*width*=-5:12]')
+    >>> fs2 = reader.fromstring('[*width*=2:123]')
+    >>> fs3 = reader.fromstring('[*width*=-7:-2]')
+    >>> fs1.unify(fs2)
+    [*width*=(2, 12)]
+    >>> fs1.unify(fs3)
+    [*width*=(-5, -2)]
+    >>> print(fs2.unify(fs3)) # no overlap in width.
+    None
+
+The slash feature has a default value of 'False':
+
+    >>> print(FeatStruct('NP[]/VP').unify(FeatStruct('NP[]'), trace=1))
+    <BLANKLINE>
+    Unification trace:
+       / NP[]/VP[]
+      |\ NP[]
+      |
+      | Unify feature: *type*
+      |    / 'NP'
+      |   |\ 'NP'
+      |   |
+      |   +-->'NP'
+      |
+      | Unify feature: *slash*
+      |    / VP[]
+      |   |\ False
+      |   |
+      X   X <-- FAIL
+    None
+
+The demo structures from category.py.  They all parse, but they don't
+do quite the right thing, -- ?x vs x.
+
+    >>> FeatStruct(pos='n', agr=FeatStruct(number='pl', gender='f'))
+    [agr=[gender='f', number='pl'], pos='n']
+    >>> FeatStruct(r'NP[sem=<bob>]/NP')
+    NP[sem=<bob>]/NP[]
+    >>> FeatStruct(r'S[sem=<app(?x, ?y)>]')
+    S[sem=<?x(?y)>]
+    >>> FeatStruct('?x/?x')
+    ?x[]/?x[]
+    >>> FeatStruct('VP[+fin, agr=?x, tense=past]/NP[+pl, agr=?x]')
+    VP[agr=?x, +fin, tense='past']/NP[agr=?x, +pl]
+    >>> FeatStruct('S[sem = <app(?subj, ?vp)>]')
+    S[sem=<?subj(?vp)>]
+
+    >>> FeatStruct('S')
+    S[]
+
+The parser also includes support for reading sets and tuples.
+
+    >>> FeatStruct('[x={1,2,2,2}, y={/}]')
+    [x={1, 2}, y={/}]
+    >>> FeatStruct('[x=(1,2,2,2), y=()]')
+    [x=(1, 2, 2, 2), y=()]
+    >>> print(FeatStruct('[x=(1,[z=(1,2,?x)],?z,{/})]'))
+    [ x = (1, [ z = (1, 2, ?x) ], ?z, {/}) ]
+
+Note that we can't put a featstruct inside a tuple, because doing so
+would hash it, and it's not frozen yet:
+
+    >>> print(FeatStruct('[x={[]}]'))
+    Traceback (most recent call last):
+      . . .
+    TypeError: FeatStructs must be frozen before they can be hashed.
+
+There's a special syntax for taking the union of sets: "{...+...}".
+The elements should only be variables or sets.
+
+    >>> FeatStruct('[x={?a+?b+{1,2,3}}]')
+    [x={?a+?b+{1, 2, 3}}]
+
+There's a special syntax for taking the concatenation of tuples:
+"(...+...)".  The elements should only be variables or tuples.
+
+    >>> FeatStruct('[x=(?a+?b+(1,2,3))]')
+    [x=(?a+?b+(1, 2, 3))]
+
+Parsing gives helpful messages if your string contains an error.
+
+    >>> FeatStruct('[a=, b=5]]')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Error parsing feature structure
+        [a=, b=5]]
+           ^ Expected value
+    >>> FeatStruct('[a=12 22, b=33]')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Error parsing feature structure
+        [a=12 22, b=33]
+             ^ Expected comma
+    >>> FeatStruct('[a=5] [b=6]')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Error parsing feature structure
+        [a=5] [b=6]
+              ^ Expected end of string
+    >>> FeatStruct(' *++*')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Error parsing feature structure
+        *++*
+        ^ Expected open bracket or identifier
+    >>> FeatStruct('[x->(1)]')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Error parsing feature structure
+        [x->(1)]
+            ^ Expected bound identifier
+    >>> FeatStruct('[x->y]')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Error parsing feature structure
+        [x->y]
+            ^ Expected identifier
+    >>> FeatStruct('')
+    Traceback (most recent call last):
+      . . .
+    ValueError: Error parsing feature structure
+    <BLANKLINE>
+        ^ Expected open bracket or identifier
+
+
+Unification
+-----------
+Very simple unifications give the expected results:
+
+    >>> FeatStruct().unify(FeatStruct())
+    []
+    >>> FeatStruct(number='singular').unify(FeatStruct())
+    [number='singular']
+    >>> FeatStruct().unify(FeatStruct(number='singular'))
+    [number='singular']
+    >>> FeatStruct(number='singular').unify(FeatStruct(person=3))
+    [number='singular', person=3]
+
+Merging nested structures:
+
+    >>> fs1 = FeatStruct('[A=[B=b]]')
+    >>> fs2 = FeatStruct('[A=[C=c]]')
+    >>> fs1.unify(fs2)
+    [A=[B='b', C='c']]
+    >>> fs2.unify(fs1)
+    [A=[B='b', C='c']]
+
+A basic case of reentrant unification
+
+    >>> fs4 = FeatStruct('[A=(1)[B=b], E=[F->(1)]]')
+    >>> fs5 = FeatStruct("[A=[C='c'], E=[F=[D='d']]]")
+    >>> fs4.unify(fs5)
+    [A=(1)[B='b', C='c', D='d'], E=[F->(1)]]
+    >>> fs5.unify(fs4)
+    [A=(1)[B='b', C='c', D='d'], E=[F->(1)]]
+
+More than 2 paths to a value
+
+    >>> fs1 = FeatStruct("[a=[],b=[],c=[],d=[]]")
+    >>> fs2 = FeatStruct('[a=(1)[], b->(1), c->(1), d->(1)]')
+    >>> fs1.unify(fs2)
+    [a=(1)[], b->(1), c->(1), d->(1)]
+
+fs1[a] gets unified with itself
+
+    >>> fs1 = FeatStruct('[x=(1)[], y->(1)]')
+    >>> fs2 = FeatStruct('[x=(1)[], y->(1)]')
+    >>> fs1.unify(fs2)
+    [x=(1)[], y->(1)]
+
+Bound variables should get forwarded appropriately
+
+    >>> fs1 = FeatStruct('[A=(1)[X=x], B->(1), C=?cvar, D=?dvar]')
+    >>> fs2 = FeatStruct('[A=(1)[Y=y], B=(2)[Z=z], C->(1), D->(2)]')
+    >>> fs1.unify(fs2)
+    [A=(1)[X='x', Y='y', Z='z'], B->(1), C->(1), D->(1)]
+    >>> fs2.unify(fs1)
+    [A=(1)[X='x', Y='y', Z='z'], B->(1), C->(1), D->(1)]
+
+Cyclic structure created by unification.
+
+    >>> fs1 = FeatStruct('[F=(1)[], G->(1)]')
+    >>> fs2 = FeatStruct('[F=[H=(2)[]], G->(2)]')
+    >>> fs3 = fs1.unify(fs2)
+    >>> fs3
+    [F=(1)[H->(1)], G->(1)]
+    >>> fs3['F'] is fs3['G']
+    True
+    >>> fs3['F'] is fs3['G']['H']
+    True
+    >>> fs3['F'] is fs3['G']['H']['H']
+    True
+    >>> fs3['F'] is fs3['F']['H']['H']['H']['H']['H']['H']['H']['H']
+    True
+
+Cyclic structure created w/ variables.
+
+    >>> fs1 = FeatStruct('[F=[H=?x]]')
+    >>> fs2 = FeatStruct('[F=?x]')
+    >>> fs3 = fs1.unify(fs2, rename_vars=False)
+    >>> fs3
+    [F=(1)[H->(1)]]
+    >>> fs3['F'] is fs3['F']['H']
+    True
+    >>> fs3['F'] is fs3['F']['H']['H']
+    True
+    >>> fs3['F'] is fs3['F']['H']['H']['H']['H']['H']['H']['H']['H']
+    True
+
+Unifying w/ a cyclic feature structure.
+
+    >>> fs4 = FeatStruct('[F=[H=[H=[H=(1)[]]]], K->(1)]')
+    >>> fs3.unify(fs4)
+    [F=(1)[H->(1)], K->(1)]
+    >>> fs4.unify(fs3)
+    [F=(1)[H->(1)], K->(1)]
+
+Variable bindings should preserve reentrance.
+
+    >>> bindings = {}
+    >>> fs1 = FeatStruct("[a=?x]")
+    >>> fs2 = fs1.unify(FeatStruct("[a=[]]"), bindings)
+    >>> fs2['a'] is bindings[Variable('?x')]
+    True
+    >>> fs2.unify(FeatStruct("[b=?x]"), bindings)
+    [a=(1)[], b->(1)]
+
+Aliased variable tests
+
+    >>> fs1 = FeatStruct("[a=?x, b=?x]")
+    >>> fs2 = FeatStruct("[b=?y, c=?y]")
+    >>> bindings = {}
+    >>> fs3 = fs1.unify(fs2, bindings)
+    >>> fs3
+    [a=?x, b=?x, c=?x]
+    >>> bindings
+    {Variable('?y'): Variable('?x')}
+    >>> fs3.unify(FeatStruct("[a=1]"))
+    [a=1, b=1, c=1]
+
+If we keep track of the bindings, then we can use the same variable
+over multiple calls to unify.
+
+    >>> bindings = {}
+    >>> fs1 = FeatStruct('[a=?x]')
+    >>> fs2 = fs1.unify(FeatStruct('[a=[]]'), bindings)
+    >>> fs2.unify(FeatStruct('[b=?x]'), bindings)
+    [a=(1)[], b->(1)]
+    >>> bindings
+    {Variable('?x'): []}
+
+..
+    >>> del fs1, fs2, fs3, fs4, fs5 # clean-up
+
+Unification Bindings
+--------------------
+
+    >>> bindings = {}
+    >>> fs1 = FeatStruct('[a=?x]')
+    >>> fs2 = FeatStruct('[a=12]')
+    >>> fs3 = FeatStruct('[b=?x]')
+    >>> fs1.unify(fs2, bindings)
+    [a=12]
+    >>> bindings
+    {Variable('?x'): 12}
+    >>> fs3.substitute_bindings(bindings)
+    [b=12]
+    >>> fs3 # substitute_bindings didn't mutate fs3.
+    [b=?x]
+    >>> fs2.unify(fs3, bindings)
+    [a=12, b=12]
+
+    >>> bindings = {}
+    >>> fs1 = FeatStruct('[a=?x, b=1]')
+    >>> fs2 = FeatStruct('[a=5, b=?x]')
+    >>> fs1.unify(fs2, bindings)
+    [a=5, b=1]
+    >>> sorted(bindings.items())
+    [(Variable('?x'), 5), (Variable('?x2'), 1)]
+
+..
+    >>> del fs1, fs2, fs3 # clean-up
+
+Expressions
+-----------
+
+    >>> e = Expression.fromstring('\\P y.P(z,y)')
+    >>> fs1 = FeatStruct(x=e, y=Variable('z'))
+    >>> fs2 = FeatStruct(y=VariableExpression(Variable('John')))
+    >>> fs1.unify(fs2)
+    [x=<\P y.P(John,y)>, y=<John>]
+
+Remove Variables
+----------------
+
+    >>> FeatStruct('[a=?x, b=12, c=[d=?y]]').remove_variables()
+    [b=12, c=[]]
+    >>> FeatStruct('(1)[a=[b=?x,c->(1)]]').remove_variables()
+    (1)[a=[c->(1)]]
+
+Equality & Hashing
+------------------
+The `equal_values` method checks whether two feature structures assign
+the same value to every feature.  If the optional argument
+``check_reentrances`` is supplied, then it also returns false if there
+is any difference in the reentrances.
+
+    >>> a = FeatStruct('(1)[x->(1)]')
+    >>> b = FeatStruct('(1)[x->(1)]')
+    >>> c = FeatStruct('(1)[x=[x->(1)]]')
+    >>> d = FeatStruct('[x=(1)[x->(1)]]')
+    >>> e = FeatStruct('(1)[x=[x->(1), y=1], y=1]')
+    >>> def compare(x,y):
+    ...     assert x.equal_values(y, True) == y.equal_values(x, True)
+    ...     assert x.equal_values(y, False) == y.equal_values(x, False)
+    ...     if x.equal_values(y, True):
+    ...         assert x.equal_values(y, False)
+    ...         print('equal values, same reentrance')
+    ...     elif x.equal_values(y, False):
+    ...         print('equal values, different reentrance')
+    ...     else:
+    ...         print('different values')
+
+    >>> compare(a, a)
+    equal values, same reentrance
+    >>> compare(a, b)
+    equal values, same reentrance
+    >>> compare(a, c)
+    equal values, different reentrance
+    >>> compare(a, d)
+    equal values, different reentrance
+    >>> compare(c, d)
+    equal values, different reentrance
+    >>> compare(a, e)
+    different values
+    >>> compare(c, e)
+    different values
+    >>> compare(d, e)
+    different values
+    >>> compare(e, e)
+    equal values, same reentrance
+
+Feature structures may not be hashed until they are frozen:
+
+    >>> hash(a)
+    Traceback (most recent call last):
+      . . .
+    TypeError: FeatStructs must be frozen before they can be hashed.
+    >>> a.freeze()
+    >>> v = hash(a)
+
+Feature structures define hash consistently.  The following example
+looks at the hash value for each (fs1,fs2) pair; if their hash values
+are not equal, then they must not be equal.  If their hash values are
+equal, then display a message, and indicate whether their values are
+indeed equal.  Note that c and d currently have the same hash value,
+even though they are not equal.  That is not a bug, strictly speaking,
+but it wouldn't be a bad thing if it changed.
+
+    >>> for fstruct in (a, b, c, d, e):
+    ...     fstruct.freeze()
+    >>> for fs1_name in 'abcde':
+    ...     for fs2_name in 'abcde':
+    ...         fs1 = locals()[fs1_name]
+    ...         fs2 = locals()[fs2_name]
+    ...         if hash(fs1) != hash(fs2):
+    ...             assert fs1 != fs2
+    ...         else:
+    ...             print('%s and %s have the same hash value,' %
+    ...                    (fs1_name, fs2_name))
+    ...             if fs1 == fs2: print('and are equal')
+    ...             else: print('and are not equal')
+    a and a have the same hash value, and are equal
+    a and b have the same hash value, and are equal
+    b and a have the same hash value, and are equal
+    b and b have the same hash value, and are equal
+    c and c have the same hash value, and are equal
+    c and d have the same hash value, and are not equal
+    d and c have the same hash value, and are not equal
+    d and d have the same hash value, and are equal
+    e and e have the same hash value, and are equal
+
+..
+    >>> del a, b, c, d, e, v # clean-up
+
+Tracing
+-------
+
+    >>> fs1 = FeatStruct('[a=[b=(1)[], c=?x], d->(1), e=[f=?x]]')
+    >>> fs2 = FeatStruct('[a=(1)[c="C"], e=[g->(1)]]')
+    >>> fs1.unify(fs2, trace=True)
+    <BLANKLINE>
+    Unification trace:
+       / [a=[b=(1)[], c=?x], d->(1), e=[f=?x]]
+      |\ [a=(1)[c='C'], e=[g->(1)]]
+      |
+      | Unify feature: a
+      |    / [b=[], c=?x]
+      |   |\ [c='C']
+      |   |
+      |   | Unify feature: a.c
+      |   |    / ?x
+      |   |   |\ 'C'
+      |   |   |
+      |   |   +-->Variable('?x')
+      |   |
+      |   +-->[b=[], c=?x]
+      |       Bindings: {?x: 'C'}
+      |
+      | Unify feature: e
+      |    / [f=?x]
+      |   |\ [g=[c='C']]
+      |   |
+      |   +-->[f=?x, g=[b=[], c=?x]]
+      |       Bindings: {?x: 'C'}
+      |
+      +-->[a=(1)[b=(2)[], c='C'], d->(2), e=[f='C', g->(1)]]
+          Bindings: {?x: 'C'}
+    [a=(1)[b=(2)[], c='C'], d->(2), e=[f='C', g->(1)]]
+    >>>
+    >>> fs1 = FeatStruct('[a=?x, b=?z, c=?z]')
+    >>> fs2 = FeatStruct('[a=?y, b=?y, c=?q]')
+    >>> #fs1.unify(fs2, trace=True)
+    >>>
+
+..
+    >>> del fs1, fs2 # clean-up
+
+Unification on Dicts & Lists
+----------------------------
+It's possible to do unification on dictionaries:
+
+    >>> from nltk.featstruct import unify
+    >>> pprint(unify(dict(x=1, y=dict(z=2)), dict(x=1, q=5)), width=1)
+    {'q': 5, 'x': 1, 'y': {'z': 2}}
+
+It's possible to do unification on lists as well:
+
+    >>> unify([1, 2, 3], [1, Variable('x'), 3])
+    [1, 2, 3]
+
+Mixing dicts and lists is fine:
+
+    >>> pprint(unify([dict(x=1, y=dict(z=2)),3], [dict(x=1, q=5),3]),
+    ...               width=1)
+    [{'q': 5, 'x': 1, 'y': {'z': 2}}, 3]
+
+Mixing dicts and FeatStructs is discouraged:
+
+    >>> unify(dict(x=1), FeatStruct(x=1))
+    Traceback (most recent call last):
+      . . .
+    ValueError: Mixing FeatStruct objects with Python dicts and lists is not supported.
+
+But you can do it if you really want, by explicitly stating that both
+dictionaries and FeatStructs should be treated as feature structures:
+
+    >>> unify(dict(x=1), FeatStruct(x=1), fs_class=(dict, FeatStruct))
+    {'x': 1}
+
+Finding Conflicts
+-----------------
+
+    >>> from nltk.featstruct import conflicts
+    >>> fs1 = FeatStruct('[a=[b=(1)[c=2], d->(1), e=[f->(1)]]]')
+    >>> fs2 = FeatStruct('[a=[b=[c=[x=5]], d=[c=2], e=[f=[c=3]]]]')
+    >>> for path in conflicts(fs1, fs2):
+    ...     print('%-8s: %r vs %r' % ('.'.join(path), fs1[path], fs2[path]))
+    a.b.c   : 2 vs [x=5]
+    a.e.f.c : 2 vs 3
+
+..
+    >>> del fs1, fs2 # clean-up
+
+Retracting Bindings
+-------------------
+
+    >>> from nltk.featstruct import retract_bindings
+    >>> bindings = {}
+    >>> fs1 = FeatStruct('[a=?x, b=[c=?y]]')
+    >>> fs2 = FeatStruct('[a=(1)[c=[d=1]], b->(1)]')
+    >>> fs3 = fs1.unify(fs2, bindings)
+    >>> print(fs3)
+    [ a = (1) [ c = [ d = 1 ] ] ]
+    [                           ]
+    [ b -> (1)                  ]
+    >>> pprint(bindings)
+    {Variable('?x'): [c=[d=1]], Variable('?y'): [d=1]}
+    >>> retract_bindings(fs3, bindings)
+    [a=?x, b=?x]
+    >>> pprint(bindings)
+    {Variable('?x'): [c=?y], Variable('?y'): [d=1]}
+
+Squashed Bugs
+~~~~~~~~~~~~~
+In svn rev 5167, unifying two feature structures that used the same
+variable would cause those variables to become aliased in the output.
+
+    >>> fs1 = FeatStruct('[a=?x]')
+    >>> fs2 = FeatStruct('[b=?x]')
+    >>> fs1.unify(fs2)
+    [a=?x, b=?x2]
+
+There was a bug in svn revision 5172 that caused `rename_variables` to
+rename variables to names that are already used.
+
+    >>> FeatStruct('[a=?x, b=?x2]').rename_variables(
+    ...     vars=[Variable('?x')])
+    [a=?x3, b=?x2]
+    >>> fs1 = FeatStruct('[a=?x]')
+    >>> fs2 = FeatStruct('[a=?x, b=?x2]')
+    >>> fs1.unify(fs2)
+    [a=?x, b=?x2]
+
+There was a bug in svn rev 5167 that caused us to get the following
+example wrong.  Basically the problem was that we only followed
+'forward' pointers for other, not self, when unifying two feature
+structures.  (nb: this test assumes that features are unified in
+alphabetical order -- if they are not, it might pass even if the bug
+is present.)
+
+    >>> fs1 = FeatStruct('[a=[x=1], b=?x, c=?x]')
+    >>> fs2 = FeatStruct('[a=(1)[], b->(1), c=[x=2]]')
+    >>> print(fs1.unify(fs2))
+    None
+
+..
+    >>> del fs1, fs2 # clean-up

lib/python3.10/site-packages/nltk/test/framenet.doctest

@@ -0,0 +1,288 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+========
+FrameNet
+========
+
+The FrameNet corpus is a lexical database of English that is both human-
+and machine-readable, based on annotating examples of how words are used
+in actual texts. FrameNet is based on a theory of meaning called Frame
+Semantics, deriving from the work of Charles J. Fillmore and colleagues.
+The basic idea is straightforward: that the meanings of most words can
+best be understood on the basis of a semantic frame: a description of a
+type of event, relation, or entity and the participants in it. For
+example, the concept of cooking typically involves a person doing the
+cooking (Cook), the food that is to be cooked (Food), something to hold
+the food while cooking (Container) and a source of heat
+(Heating_instrument). In the FrameNet project, this is represented as a
+frame called Apply_heat, and the Cook, Food, Heating_instrument and
+Container are called frame elements (FEs). Words that evoke this frame,
+such as fry, bake, boil, and broil, are called lexical units (LUs) of
+the Apply_heat frame. The job of FrameNet is to define the frames
+and to annotate sentences to show how the FEs fit syntactically around
+the word that evokes the frame.
+
+------
+Frames
+------
+
+A Frame is a script-like conceptual structure that describes a
+particular type of situation, object, or event along with the
+participants and props that are needed for that Frame. For
+example, the "Apply_heat" frame describes a common situation
+involving a Cook, some Food, and a Heating_Instrument, and is
+evoked by words such as bake, blanch, boil, broil, brown,
+simmer, steam, etc.
+
+We call the roles of a Frame "frame elements" (FEs) and the
+frame-evoking words are called "lexical units" (LUs).
+
+FrameNet includes relations between Frames. Several types of
+relations are defined, of which the most important are:
+
+- Inheritance: An IS-A relation. The child frame is a subtype
+  of the parent frame, and each FE in the parent is bound to
+  a corresponding FE in the child. An example is the
+  "Revenge" frame which inherits from the
+  "Rewards_and_punishments" frame.
+
+- Using: The child frame presupposes the parent frame as
+  background, e.g the "Speed" frame "uses" (or presupposes)
+  the "Motion" frame; however, not all parent FEs need to be
+  bound to child FEs.
+
+- Subframe: The child frame is a subevent of a complex event
+  represented by the parent, e.g. the "Criminal_process" frame
+  has subframes of "Arrest", "Arraignment", "Trial", and
+  "Sentencing".
+
+- Perspective_on: The child frame provides a particular
+  perspective on an un-perspectivized parent frame. A pair of
+  examples consists of the "Hiring" and "Get_a_job" frames,
+  which perspectivize the "Employment_start" frame from the
+  Employer's and the Employee's point of view, respectively.
+
+To get a list of all of the Frames in FrameNet, you can use the
+`frames()` function. If you supply a regular expression pattern to the
+`frames()` function, you will get a list of all Frames whose names match
+that pattern:
+
+    >>> from pprint import pprint
+    >>> from operator import itemgetter
+    >>> from nltk.corpus import framenet as fn
+    >>> from nltk.corpus.reader.framenet import PrettyList
+    >>> x = fn.frames(r'(?i)crim')
+    >>> x.sort(key=itemgetter('ID'))
+    >>> x
+    [<frame ID=200 name=Criminal_process>, <frame ID=500 name=Criminal_investigation>, ...]
+    >>> PrettyList(sorted(x, key=itemgetter('ID')))
+    [<frame ID=200 name=Criminal_process>, <frame ID=500 name=Criminal_investigation>, ...]
+
+To get the details of a particular Frame, you can use the `frame()`
+function passing in the frame number:
+
+    >>> from pprint import pprint
+    >>> from nltk.corpus import framenet as fn
+    >>> f = fn.frame(202)
+    >>> f.ID
+    202
+    >>> f.name
+    'Arrest'
+    >>> f.definition
+    "Authorities charge a Suspect, who is under suspicion of having committed a crime..."
+    >>> len(f.lexUnit)
+    11
+    >>> pprint(sorted([x for x in f.FE]))
+    ['Authorities',
+     'Charges',
+     'Co-participant',
+     'Manner',
+     'Means',
+     'Offense',
+     'Place',
+     'Purpose',
+     'Source_of_legal_authority',
+     'Suspect',
+     'Time',
+     'Type']
+    >>> pprint(f.frameRelations)
+    [<Parent=Intentionally_affect -- Inheritance -> Child=Arrest>, <Complex=Criminal_process -- Subframe -> Component=Arrest>, ...]
+
+The `frame()` function shown above returns a dict object containing
+detailed information about the Frame. See the documentation on the
+`frame()` function for the specifics.
+
+You can also search for Frames by their Lexical Units (LUs). The
+`frames_by_lemma()` function returns a list of all frames that contain
+LUs in which the 'name' attribute of the LU matches the given regular
+expression. Note that LU names are composed of "lemma.POS", where the
+"lemma" part can be made up of either a single lexeme (e.g. 'run') or
+multiple lexemes (e.g. 'a little') (see below).
+
+    >>> PrettyList(sorted(fn.frames_by_lemma(r'(?i)a little'), key=itemgetter('ID')))
+    [<frame ID=189 name=Quanti...>, <frame ID=2001 name=Degree>]
+
+-------------
+Lexical Units
+-------------
+
+A lexical unit (LU) is a pairing of a word with a meaning. For
+example, the "Apply_heat" Frame describes a common situation
+involving a Cook, some Food, and a Heating Instrument, and is
+_evoked_ by words such as bake, blanch, boil, broil, brown,
+simmer, steam, etc. These frame-evoking words are the LUs in the
+Apply_heat frame. Each sense of a polysemous word is a different
+LU.
+
+We have used the word "word" in talking about LUs. The reality
+is actually rather complex. When we say that the word "bake" is
+polysemous, we mean that the lemma "bake.v" (which has the
+word-forms "bake", "bakes", "baked", and "baking") is linked to
+three different frames:
+
+- Apply_heat: "Michelle baked the potatoes for 45 minutes."
+
+- Cooking_creation: "Michelle baked her mother a cake for her birthday."
+
+- Absorb_heat: "The potatoes have to bake for more than 30 minutes."
+
+These constitute three different LUs, with different
+definitions.
+
+Multiword expressions such as "given name" and hyphenated words
+like "shut-eye" can also be LUs. Idiomatic phrases such as
+"middle of nowhere" and "give the slip (to)" are also defined as
+LUs in the appropriate frames ("Isolated_places" and "Evading",
+respectively), and their internal structure is not analyzed.
+
+Framenet provides multiple annotated examples of each sense of a
+word (i.e. each LU).  Moreover, the set of examples
+(approximately 20 per LU) illustrates all of the combinatorial
+possibilities of the lexical unit.
+
+Each LU is linked to a Frame, and hence to the other words which
+evoke that Frame. This makes the FrameNet database similar to a
+thesaurus, grouping together semantically similar words.
+
+In the simplest case, frame-evoking words are verbs such as
+"fried" in:
+
+   "Matilde fried the catfish in a heavy iron skillet."
+
+Sometimes event nouns may evoke a Frame. For example,
+"reduction" evokes "Cause_change_of_scalar_position" in:
+
+   "...the reduction of debt levels to $665 million from $2.6 billion."
+
+Adjectives may also evoke a Frame. For example, "asleep" may
+evoke the "Sleep" frame as in:
+
+   "They were asleep for hours."
+
+Many common nouns, such as artifacts like "hat" or "tower",
+typically serve as dependents rather than clearly evoking their
+own frames.
+
+Details for a specific lexical unit can be obtained using this class's
+`lus()` function, which takes an optional regular expression
+pattern that will be matched against the name of the lexical unit:
+
+    >>> from pprint import pprint
+    >>> PrettyList(sorted(fn.lus(r'(?i)a little'), key=itemgetter('ID')))
+    [<lu ID=14733 name=a little.n>, <lu ID=14743 name=a little.adv>, ...]
+
+You can obtain detailed information on a particular LU by calling the
+`lu()` function and passing in an LU's 'ID' number:
+
+    >>> from pprint import pprint
+    >>> from nltk.corpus import framenet as fn
+    >>> fn.lu(256).name
+    'foresee.v'
+    >>> fn.lu(256).definition
+    'COD: be aware of beforehand; predict.'
+    >>> fn.lu(256).frame.name
+    'Expectation'
+    >>> fn.lu(256).lexemes[0].name
+    'foresee'
+
+Note that LU names take the form of a dotted string (e.g. "run.v" or "a
+little.adv") in which a lemma precedes the "." and a part of speech
+(POS) follows the dot. The lemma may be composed of a single lexeme
+(e.g. "run") or of multiple lexemes (e.g. "a little"). The list of
+POSs used in the LUs is:
+
+v    - verb
+n    - noun
+a    - adjective
+adv  - adverb
+prep - preposition
+num  - numbers
+intj - interjection
+art  - article
+c    - conjunction
+scon - subordinating conjunction
+
+For more detailed information about the info that is contained in the
+dict that is returned by the `lu()` function, see the documentation on
+the `lu()` function.
+
+-------------------
+Annotated Documents
+-------------------
+
+The FrameNet corpus contains a small set of annotated documents. A list
+of these documents can be obtained by calling the `docs()` function:
+
+    >>> from pprint import pprint
+    >>> from nltk.corpus import framenet as fn
+    >>> d = fn.docs('BellRinging')[0]
+    >>> d.corpname
+    'PropBank'
+    >>> d.sentence[49]
+    full-text sentence (...) in BellRinging:
+    <BLANKLINE>
+    <BLANKLINE>
+    [POS] 17 tags
+    <BLANKLINE>
+    [POS_tagset] PENN
+    <BLANKLINE>
+    [text] + [annotationSet]
+    <BLANKLINE>
+    `` I live in hopes that the ringers themselves will be drawn into
+                 *****          *******                    *****
+                 Desir          Cause_t                    Cause
+                 [1]            [3]                        [2]
+    <BLANKLINE>
+     that fuller life .
+          ******
+          Comple
+          [4]
+     (Desir=Desiring, Cause_t=Cause_to_make_noise, Cause=Cause_motion, Comple=Completeness)
+    <BLANKLINE>
+
+    >>> d.sentence[49].annotationSet[1]
+    annotation set (...):
+    <BLANKLINE>
+    [status] MANUAL
+    <BLANKLINE>
+    [LU] (6605) hope.n in Desiring
+    <BLANKLINE>
+    [frame] (366) Desiring
+    <BLANKLINE>
+    [GF] 2 relations
+    <BLANKLINE>
+    [PT] 2 phrases
+    <BLANKLINE>
+    [text] + [Target] + [FE] + [Noun]
+    <BLANKLINE>
+    `` I live in hopes that the ringers themselves will be drawn into
+       - ^^^^ ^^ ***** ----------------------------------------------
+       E supp su       Event
+    <BLANKLINE>
+     that fuller life .
+    -----------------
+    <BLANKLINE>
+     (E=Experiencer, su=supp)
+    <BLANKLINE>
+    <BLANKLINE>

lib/python3.10/site-packages/nltk/test/generate.doctest

@@ -0,0 +1,78 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+===============================================
+Generating sentences from context-free grammars
+===============================================
+
+An example grammar:
+
+    >>> from nltk.parse.generate import generate, demo_grammar
+    >>> from nltk import CFG
+    >>> grammar = CFG.fromstring(demo_grammar)
+    >>> print(grammar)
+    Grammar with 13 productions (start state = S)
+        S -> NP VP
+        NP -> Det N
+        PP -> P NP
+        VP -> 'slept'
+        VP -> 'saw' NP
+        VP -> 'walked' PP
+        Det -> 'the'
+        Det -> 'a'
+        N -> 'man'
+        N -> 'park'
+        N -> 'dog'
+        P -> 'in'
+        P -> 'with'
+
+The first 10 generated sentences:
+
+    >>> for sentence in generate(grammar, n=10):
+    ...     print(' '.join(sentence))
+    the man slept
+    the man saw the man
+    the man saw the park
+    the man saw the dog
+    the man saw a man
+    the man saw a park
+    the man saw a dog
+    the man walked in the man
+    the man walked in the park
+    the man walked in the dog
+
+All sentences of max depth 4:
+
+    >>> for sentence in generate(grammar, depth=4):
+    ...     print(' '.join(sentence))
+    the man slept
+    the park slept
+    the dog slept
+    a man slept
+    a park slept
+    a dog slept
+
+The number of sentences of different max depths:
+
+    >>> len(list(generate(grammar, depth=3)))
+    0
+    >>> len(list(generate(grammar, depth=4)))
+    6
+    >>> len(list(generate(grammar, depth=5)))
+    42
+    >>> len(list(generate(grammar, depth=6)))
+    114
+    >>> len(list(generate(grammar)))
+    114
+
+Infinite grammars will throw a RecursionError when not bounded by some ``depth``:
+
+    >>> grammar = CFG.fromstring("""
+    ... S -> A B
+    ... A -> B
+    ... B -> "b" | A
+    ... """)
+    >>> list(generate(grammar))
+    Traceback (most recent call last):
+    ...
+    RuntimeError: The grammar has rule(s) that yield infinite recursion!

lib/python3.10/site-packages/nltk/test/gensim.doctest

@@ -0,0 +1,141 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+=======================================
+Demonstrate word embedding using Gensim
+=======================================
+
+    >>> from nltk.test.gensim_fixt import setup_module
+    >>> setup_module()
+
+We demonstrate three functions:
+- Train the word embeddings using brown corpus;
+- Load the pre-trained model and perform simple tasks; and
+- Pruning the pre-trained binary model.
+
+    >>> import gensim
+
+---------------
+Train the model
+---------------
+
+Here we train a word embedding using the Brown Corpus:
+
+    >>> from nltk.corpus import brown
+    >>> train_set = brown.sents()[:10000]
+    >>> model = gensim.models.Word2Vec(train_set)
+
+It might take some time to train the model. So, after it is trained, it can be saved as follows:
+
+    >>> model.save('brown.embedding')
+    >>> new_model = gensim.models.Word2Vec.load('brown.embedding')
+
+The model will be the list of words with their embedding. We can easily get the vector representation of a word.
+
+    >>> len(new_model.wv['university'])
+    100
+
+There are some supporting functions already implemented in Gensim to manipulate with word embeddings.
+For example, to compute the cosine similarity between 2 words:
+
+    >>> new_model.wv.similarity('university','school') > 0.3
+    True
+
+---------------------------
+Using the pre-trained model
+---------------------------
+
+NLTK includes a pre-trained model which is part of a model that is trained on 100 billion words from the Google News Dataset.
+The full model is from https://code.google.com/p/word2vec/ (about 3 GB).
+
+    >>> from nltk.data import find
+    >>> word2vec_sample = str(find('models/word2vec_sample/pruned.word2vec.txt'))
+    >>> model = gensim.models.KeyedVectors.load_word2vec_format(word2vec_sample, binary=False)
+
+We pruned the model to only include the most common words (~44k words).
+
+    >>> len(model)
+    43981
+
+Each word is represented in the space of 300 dimensions:
+
+    >>> len(model['university'])
+    300
+
+Finding the top n words that are similar to a target word is simple. The result is the list of n words with the score.
+
+    >>> model.most_similar(positive=['university'], topn = 3)
+    [('universities', 0.70039...), ('faculty', 0.67809...), ('undergraduate', 0.65870...)]
+
+Finding a word that is not in a list is also supported, although, implementing this by yourself is simple.
+
+    >>> model.doesnt_match('breakfast cereal dinner lunch'.split())
+    'cereal'
+
+Mikolov et al. (2013) figured out that word embedding captures much of syntactic and semantic regularities. For example,
+the vector 'King - Man + Woman' is close to 'Queen' and 'Germany - Berlin + Paris' is close to 'France'.
+
+    >>> model.most_similar(positive=['woman','king'], negative=['man'], topn = 1)
+    [('queen', 0.71181...)]
+
+    >>> model.most_similar(positive=['Paris','Germany'], negative=['Berlin'], topn = 1)
+    [('France', 0.78840...)]
+
+We can visualize the word embeddings using t-SNE (https://lvdmaaten.github.io/tsne/). For this demonstration, we visualize the first 1000 words.
+
+|    import numpy as np
+|    labels = []
+|    count = 0
+|    max_count = 1000
+|    X = np.zeros(shape=(max_count,len(model['university'])))
+|
+|    for term in model.index_to_key:
+|        X[count] = model[term]
+|        labels.append(term)
+|        count+= 1
+|        if count >= max_count: break
+|
+|    # It is recommended to use PCA first to reduce to ~50 dimensions
+|    from sklearn.decomposition import PCA
+|    pca = PCA(n_components=50)
+|    X_50 = pca.fit_transform(X)
+|
+|    # Using TSNE to further reduce to 2 dimensions
+|    from sklearn.manifold import TSNE
+|    model_tsne = TSNE(n_components=2, random_state=0)
+|    Y = model_tsne.fit_transform(X_50)
+|
+|    # Show the scatter plot
+|    import matplotlib.pyplot as plt
+|    plt.scatter(Y[:,0], Y[:,1], 20)
+|
+|    # Add labels
+|    for label, x, y in zip(labels, Y[:, 0], Y[:, 1]):
+|        plt.annotate(label, xy = (x,y), xytext = (0, 0), textcoords = 'offset points', size = 10)
+|
+|    plt.show()
+
+------------------------------
+Prune the trained binary model
+------------------------------
+
+Here is the supporting code to extract part of the binary model (GoogleNews-vectors-negative300.bin.gz) from https://code.google.com/p/word2vec/
+We use this code to get the `word2vec_sample` model.
+
+|    import gensim
+|    # Load the binary model
+|    model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary = True)
+|
+|    # Only output word that appear in the Brown corpus
+|    from nltk.corpus import brown
+|    words = set(brown.words())
+|    print(len(words))
+|
+|    # Output presented word to a temporary file
+|    out_file = 'pruned.word2vec.txt'
+|    with open(out_file,'w') as f:
+|        word_presented = words.intersection(model.index_to_key)
+|        f.write('{} {}\n'.format(len(word_presented),len(model['word'])))
+|
+|        for word in word_presented:
+|            f.write('{} {}\n'.format(word, ' '.join(str(value) for value in model[word])))

lib/python3.10/site-packages/nltk/test/gluesemantics_malt_fixt.py

@@ -0,0 +1,9 @@
+def setup_module():
+    import pytest
+
+    from nltk.parse.malt import MaltParser
+
+    try:
+        depparser = MaltParser()
+    except (AssertionError, LookupError) as e:
+        pytest.skip("MaltParser is not available")

lib/python3.10/site-packages/nltk/test/grammar.doctest

@@ -0,0 +1,69 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+===============
+Grammar Parsing
+===============
+
+Grammars can be parsed from strings:
+
+    >>> from nltk import CFG
+    >>> grammar = CFG.fromstring("""
+    ... S -> NP VP
+    ... PP -> P NP
+    ... NP -> Det N | NP PP
+    ... VP -> V NP | VP PP
+    ... Det -> 'a' | 'the'
+    ... N -> 'dog' | 'cat'
+    ... V -> 'chased' | 'sat'
+    ... P -> 'on' | 'in'
+    ... """)
+    >>> grammar
+    <Grammar with 14 productions>
+    >>> grammar.start()
+    S
+    >>> grammar.productions()
+    [S -> NP VP, PP -> P NP, NP -> Det N, NP -> NP PP, VP -> V NP, VP -> VP PP,
+    Det -> 'a', Det -> 'the', N -> 'dog', N -> 'cat', V -> 'chased', V -> 'sat',
+    P -> 'on', P -> 'in']
+
+Probabilistic CFGs:
+
+    >>> from nltk import PCFG
+    >>> toy_pcfg1 = PCFG.fromstring("""
+    ... S -> NP VP [1.0]
+    ... NP -> Det N [0.5] | NP PP [0.25] | 'John' [0.1] | 'I' [0.15]
+    ... Det -> 'the' [0.8] | 'my' [0.2]
+    ... N -> 'man' [0.5] | 'telescope' [0.5]
+    ... VP -> VP PP [0.1] | V NP [0.7] | V [0.2]
+    ... V -> 'ate' [0.35] | 'saw' [0.65]
+    ... PP -> P NP [1.0]
+    ... P -> 'with' [0.61] | 'under' [0.39]
+    ... """)
+
+Chomsky Normal Form grammar (Test for bug 474)
+
+    >>> g = CFG.fromstring("VP^<TOP> -> VBP NP^<VP-TOP>")
+    >>> g.productions()[0].lhs()
+    VP^<TOP>
+
+Grammars can contain both empty strings and empty productions:
+
+    >>> from nltk.grammar import CFG
+    >>> from nltk.parse.generate import generate
+    >>> grammar = CFG.fromstring("""
+    ... S -> A B
+    ... A -> 'a'
+    ... # An empty string:
+    ... B -> 'b' | ''
+    ... """)
+    >>> list(generate(grammar))
+    [['a', 'b'], ['a', '']]
+    >>> grammar = CFG.fromstring("""
+    ... S -> A B
+    ... A -> 'a'
+    ... # An empty production:
+    ... B -> 'b' |
+    ... """)
+    >>> list(generate(grammar))
+    [['a', 'b'], ['a']]

lib/python3.10/site-packages/nltk/test/grammartestsuites.doctest

@@ -0,0 +1,109 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+==========================
+ Test Suites for Grammars
+==========================
+
+Sentences in the test suite are divided into two classes:
+
+- grammatical (*accept*) and
+- ungrammatical (*reject*).
+
+If a sentence should parse according to the grammar, the value of
+``trees`` will be a non-empty list. If a sentence should be rejected
+according to the grammar, then the value of ``trees`` will be ``None``.
+
+    >>> from nltk.parse import TestGrammar
+    >>> germantest1 = {}
+    >>> germantest1['doc'] = "Tests for person agreement"
+    >>> germantest1['accept'] = [
+    ... 'ich komme',
+    ... 'ich sehe mich',
+    ... 'du kommst',
+    ... 'du siehst mich',
+    ... 'sie kommt',
+    ... 'sie sieht mich',
+    ... 'ihr kommt',
+    ... 'wir kommen',
+    ... 'sie kommen',
+    ... 'du magst mich',
+    ... 'er mag mich',
+    ... 'du folgst mir',
+    ... 'sie hilft mir',
+    ... ]
+    >>> germantest1['reject'] = [
+    ... 'ich kommt',
+    ... 'ich kommst',
+    ... 'ich siehst mich',
+    ... 'du komme',
+    ... 'du sehe mich',
+    ... 'du kommt',
+    ... 'er komme',
+    ... 'er siehst mich',
+    ... 'wir komme',
+    ... 'wir kommst',
+    ... 'die Katzen kommst',
+    ... 'sie komme',
+    ... 'sie kommst',
+    ... 'du mag mich',
+    ... 'er magst mich',
+    ... 'du folgt mir',
+    ... 'sie hilfst mir',
+    ... ]
+    >>> germantest2 = {}
+    >>> germantest2['doc'] = "Tests for number agreement"
+    >>> germantest2['accept'] = [
+    ... 'der Hund kommt',
+    ... 'die Hunde kommen',
+    ... 'ich komme',
+    ... 'wir kommen',
+    ... 'ich sehe die Katzen',
+    ... 'ich folge den Katzen',
+    ... 'ich sehe die Katzen',
+    ... 'ich folge den Katzen',
+    ... 'wir sehen die Katzen',
+    ... 'wir folgen den Katzen'
+    ... ]
+    >>> germantest2['reject'] = [
+    ... 'ich kommen',
+    ... 'wir komme',
+    ... 'der Hunde kommt',
+    ... 'der Hunde kommen',
+    ... 'die Katzen kommt',
+    ... 'ich sehe der Hunde',
+    ... 'ich folge den Hund',
+    ... 'ich sehen der Hunde',
+    ... 'ich folgen den Hund',
+    ... 'wir sehe die Katzen',
+    ... 'wir folge den Katzen'
+    ... ]
+    >>> germantest3 = {}
+    >>> germantest3['doc'] = "Tests for case government and subcategorization"
+    >>> germantest3['accept'] = [
+    ... 'der Hund sieht mich',
+    ... 'der Hund kommt',
+    ... 'ich sehe den Hund',
+    ... 'ich helfe dem Hund',
+    ... ]
+    >>> germantest3['reject'] = [
+    ... 'ich sehe',
+    ... 'ich helfe',
+    ... 'ich komme den Hund',
+    ... 'ich sehe den Hund die Katzen',
+    ... 'du hilfst mich',
+    ... 'du siehst mir',
+    ... 'du siehst ich',
+    ... 'der Hunde kommt mich',
+    ... 'die Hunde sehe die Hunde',
+    ... 'der Hund sehe die Hunde',
+    ... 'ich hilft den Hund',
+    ... 'ich hilft der Hund',
+    ... 'ich sehe dem Hund',
+    ... ]
+    >>> germantestsuites = [germantest1, germantest2, germantest3]
+    >>> tester = TestGrammar('grammars/book_grammars/german.fcfg', germantestsuites)
+    >>> tester.run()
+    Tests for person agreement: All tests passed!
+    Tests for number agreement: All tests passed!
+    Tests for case government and subcategorization: All tests passed!

lib/python3.10/site-packages/nltk/test/japanese.doctest

@@ -0,0 +1,48 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+============================
+Japanese Language Processing
+============================
+
+    >>> from nltk import *
+
+-------------
+Corpus Access
+-------------
+
+KNB Corpus
+----------
+
+    >>> from nltk.corpus import knbc
+
+Access the words: this should produce a list of strings:
+
+    >>> type(knbc.words()[0]) is not bytes
+    True
+
+Access the sentences: this should produce a list of lists of strings:
+
+    >>> type(knbc.sents()[0][0]) is not bytes
+    True
+
+Access the tagged words: this should produce a list of word, tag pairs:
+
+    >>> type(knbc.tagged_words()[0])
+    <... 'tuple'>
+
+Access the tagged sentences: this should produce a list of lists of word, tag pairs:
+
+    >>> type(knbc.tagged_sents()[0][0])
+    <... 'tuple'>
+
+
+JEITA Corpus
+------------
+
+    >>> from nltk.corpus import jeita
+
+Access the tagged words: this should produce a list of word, tag pairs, where a tag is a string:
+
+    >>> type(jeita.tagged_words()[0][1]) is not bytes
+    True

lib/python3.10/site-packages/nltk/test/lm.doctest

@@ -0,0 +1,135 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+.. -*- coding: utf-8 -*-
+
+
+Regression Tests
+================
+
+
+Issue 167
+---------
+https://github.com/nltk/nltk/issues/167
+
+    >>> from nltk.corpus import brown
+    >>> from nltk.lm.preprocessing import padded_everygram_pipeline
+    >>> ngram_order = 3
+    >>> train_data, vocab_data = padded_everygram_pipeline(
+    ...     ngram_order,
+    ...     brown.sents(categories="news")
+    ... )
+
+    >>> from nltk.lm import WittenBellInterpolated
+    >>> lm = WittenBellInterpolated(ngram_order)
+    >>> lm.fit(train_data, vocab_data)
+
+
+
+
+Sentence containing an unseen word should result in infinite entropy because
+Witten-Bell is based ultimately on MLE, which cannot handle unseen ngrams.
+Crucially, it shouldn't raise any exceptions for unseen words.
+
+    >>> from nltk.util import ngrams
+    >>> sent = ngrams("This is a sentence with the word aaddvark".split(), 3)
+    >>> lm.entropy(sent)
+    inf
+
+If we remove all unseen ngrams from the sentence, we'll get a non-infinite value
+for the entropy.
+
+    >>> sent = ngrams("This is a sentence".split(), 3)
+    >>> round(lm.entropy(sent), 14)
+    10.23701322869105
+
+
+Issue 367
+---------
+https://github.com/nltk/nltk/issues/367
+
+Reproducing Dan Blanchard's example:
+https://github.com/nltk/nltk/issues/367#issuecomment-14646110
+
+    >>> from nltk.lm import Lidstone, Vocabulary
+    >>> word_seq = list('aaaababaaccbacb')
+    >>> ngram_order = 2
+    >>> from nltk.util import everygrams
+    >>> train_data = [everygrams(word_seq, max_len=ngram_order)]
+    >>> V = Vocabulary(['a', 'b', 'c', ''])
+    >>> lm = Lidstone(0.2, ngram_order, vocabulary=V)
+    >>> lm.fit(train_data)
+
+For doctest to work we have to sort the vocabulary keys.
+
+    >>> V_keys = sorted(V)
+    >>> round(sum(lm.score(w, ("b",)) for w in V_keys), 6)
+    1.0
+    >>> round(sum(lm.score(w, ("a",)) for w in V_keys), 6)
+    1.0
+
+    >>> [lm.score(w, ("b",)) for w in V_keys]
+    [0.05, 0.05, 0.8, 0.05, 0.05]
+    >>> [round(lm.score(w, ("a",)), 4) for w in V_keys]
+    [0.0222, 0.0222, 0.4667, 0.2444, 0.2444]
+
+
+Here's reproducing @afourney's comment:
+https://github.com/nltk/nltk/issues/367#issuecomment-15686289
+
+    >>> sent = ['foo', 'foo', 'foo', 'foo', 'bar', 'baz']
+    >>> ngram_order = 3
+    >>> from nltk.lm.preprocessing import padded_everygram_pipeline
+    >>> train_data, vocab_data = padded_everygram_pipeline(ngram_order, [sent])
+    >>> from nltk.lm import Lidstone
+    >>> lm = Lidstone(0.2, ngram_order)
+    >>> lm.fit(train_data, vocab_data)
+
+The vocabulary includes the "UNK" symbol as well as two padding symbols.
+
+    >>> len(lm.vocab)
+    6
+    >>> word = "foo"
+    >>> context = ("bar", "baz")
+
+The raw counts.
+
+    >>> lm.context_counts(context)[word]
+    0
+    >>> lm.context_counts(context).N()
+    1
+
+Counts with Lidstone smoothing.
+
+    >>> lm.context_counts(context)[word] + lm.gamma
+    0.2
+    >>> lm.context_counts(context).N() + len(lm.vocab) * lm.gamma
+    2.2
+
+Without any backoff, just using Lidstone smoothing, P("foo" | "bar", "baz") should be:
+0.2 / 2.2 ~= 0.090909
+
+    >>> round(lm.score(word, context), 6)
+    0.090909
+
+
+Issue 380
+---------
+https://github.com/nltk/nltk/issues/380
+
+Reproducing setup akin to this comment:
+https://github.com/nltk/nltk/issues/380#issue-12879030
+
+For speed take only the first 100 sentences of reuters. Shouldn't affect the test.
+
+    >>> from nltk.corpus import reuters
+    >>> sents = reuters.sents()[:100]
+    >>> ngram_order = 3
+    >>> from nltk.lm.preprocessing import padded_everygram_pipeline
+    >>> train_data, vocab_data = padded_everygram_pipeline(ngram_order, sents)
+
+    >>> from nltk.lm import Lidstone
+    >>> lm = Lidstone(0.2, ngram_order)
+    >>> lm.fit(train_data, vocab_data)
+    >>> lm.score("said", ("",)) < 1
+    True

lib/python3.10/site-packages/nltk/test/meteor.doctest

@@ -0,0 +1,54 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+.. -*- coding: utf-8 -*-
+
+=============
+METEOR tests
+=============
+
+No Alignment test
+------------------
+
+    >>> from nltk.translate import meteor
+    >>> from nltk import word_tokenize
+
+If the candidate has no alignment to any of the references, the METEOR score is 0.
+
+    >>> round(meteor(
+    ...     [word_tokenize('The candidate has no alignment to any of the references')],
+    ...     word_tokenize('John loves Mary')
+    ... ), 4)
+    0.0
+
+Tests based on wikipedia examples
+---------------------------------
+
+Testing on `wikipedia examples <https://en.wikipedia.org/wiki/METEOR#Examples>`_
+
+    >>> same_res = round(meteor(
+    ...       [word_tokenize('The cat sat on the mat')],
+    ...       word_tokenize('The cat sat on the mat')
+    ...       ), 4)
+    >>> abs(same_res - 0.9977) < 1e-2
+    True
+
+    >>> meteor(
+    ...       [word_tokenize('The cat sat on the mat')],
+    ...       word_tokenize('on the mat sat the cat')
+    ...       )
+    0.5
+
+    >>> round(meteor(
+    ...       [word_tokenize('The cat sat on the mat')],
+    ...       word_tokenize('The cat was sat on the mat')
+    ...       ), 4)
+    0.9654
+
+Test corresponding to issue #2751, where METEOR score > 1
+
+    >>> round(meteor(
+    ...       [word_tokenize('create or update a vm set')],
+    ...       word_tokenize('creates or updates a virtual machine scale set')
+    ...       ), 4)
+    0.7806

lib/python3.10/site-packages/nltk/test/nonmonotonic.doctest

@@ -0,0 +1,293 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+======================
+Nonmonotonic Reasoning
+======================
+
+    >>> from nltk.test.setup_fixt import check_binary
+    >>> check_binary('mace4')
+
+    >>> from nltk import *
+    >>> from nltk.inference.nonmonotonic import *
+    >>> from nltk.sem import logic
+    >>> logic._counter._value = 0
+    >>> read_expr = logic.Expression.fromstring
+
+------------------------
+Closed Domain Assumption
+------------------------
+
+The only entities in the domain are those found in the assumptions or goal.
+If the domain only contains "A" and "B", then the expression "exists x.P(x)" can
+be replaced with "P(A) | P(B)" and an expression "all x.P(x)" can be replaced
+with "P(A) & P(B)".
+
+    >>> p1 = read_expr(r'all x.(man(x) -> mortal(x))')
+    >>> p2 = read_expr(r'man(Socrates)')
+    >>> c = read_expr(r'mortal(Socrates)')
+    >>> prover = Prover9Command(c, [p1,p2])
+    >>> prover.prove()
+    True
+    >>> cdp = ClosedDomainProver(prover)
+    >>> for a in cdp.assumptions(): print(a) # doctest: +SKIP
+    (man(Socrates) -> mortal(Socrates))
+    man(Socrates)
+    >>> cdp.prove()
+    True
+
+    >>> p1 = read_expr(r'exists x.walk(x)')
+    >>> p2 = read_expr(r'man(Socrates)')
+    >>> c = read_expr(r'walk(Socrates)')
+    >>> prover = Prover9Command(c, [p1,p2])
+    >>> prover.prove()
+    False
+    >>> cdp = ClosedDomainProver(prover)
+    >>> for a in cdp.assumptions(): print(a) # doctest: +SKIP
+    walk(Socrates)
+    man(Socrates)
+    >>> cdp.prove()
+    True
+
+    >>> p1 = read_expr(r'exists x.walk(x)')
+    >>> p2 = read_expr(r'man(Socrates)')
+    >>> p3 = read_expr(r'-walk(Bill)')
+    >>> c = read_expr(r'walk(Socrates)')
+    >>> prover = Prover9Command(c, [p1,p2,p3])
+    >>> prover.prove()
+    False
+    >>> cdp = ClosedDomainProver(prover)
+    >>> for a in cdp.assumptions(): print(a) # doctest: +SKIP
+    (walk(Socrates) | walk(Bill))
+    man(Socrates)
+    -walk(Bill)
+    >>> cdp.prove()
+    True
+
+    >>> p1 = read_expr(r'walk(Socrates)')
+    >>> p2 = read_expr(r'walk(Bill)')
+    >>> c = read_expr(r'all x.walk(x)')
+    >>> prover = Prover9Command(c, [p1,p2])
+    >>> prover.prove()
+    False
+    >>> cdp = ClosedDomainProver(prover)
+    >>> for a in cdp.assumptions(): print(a) # doctest: +SKIP
+    walk(Socrates)
+    walk(Bill)
+    >>> print(cdp.goal()) # doctest: +SKIP
+    (walk(Socrates) & walk(Bill))
+    >>> cdp.prove()
+    True
+
+    >>> p1 = read_expr(r'girl(mary)')
+    >>> p2 = read_expr(r'dog(rover)')
+    >>> p3 = read_expr(r'all x.(girl(x) -> -dog(x))')
+    >>> p4 = read_expr(r'all x.(dog(x) -> -girl(x))')
+    >>> p5 = read_expr(r'chase(mary, rover)')
+    >>> c = read_expr(r'exists y.(dog(y) & all x.(girl(x) -> chase(x,y)))')
+    >>> prover = Prover9Command(c, [p1,p2,p3,p4,p5])
+    >>> print(prover.prove())
+    False
+    >>> cdp = ClosedDomainProver(prover)
+    >>> for a in cdp.assumptions(): print(a) # doctest: +SKIP
+    girl(mary)
+    dog(rover)
+    ((girl(rover) -> -dog(rover)) & (girl(mary) -> -dog(mary)))
+    ((dog(rover) -> -girl(rover)) & (dog(mary) -> -girl(mary)))
+    chase(mary,rover)
+    >>> print(cdp.goal()) # doctest: +SKIP
+    ((dog(rover) & (girl(rover) -> chase(rover,rover)) & (girl(mary) -> chase(mary,rover))) | (dog(mary) & (girl(rover) -> chase(rover,mary)) & (girl(mary) -> chase(mary,mary))))
+    >>> print(cdp.prove())
+    True
+
+-----------------------
+Unique Names Assumption
+-----------------------
+
+No two entities in the domain represent the same entity unless it can be
+explicitly proven that they do.  Therefore, if the domain contains "A" and "B",
+then add the assumption "-(A = B)" if it is not the case that
+"<assumptions> \|- (A = B)".
+
+    >>> p1 = read_expr(r'man(Socrates)')
+    >>> p2 = read_expr(r'man(Bill)')
+    >>> c = read_expr(r'exists x.exists y.-(x = y)')
+    >>> prover = Prover9Command(c, [p1,p2])
+    >>> prover.prove()
+    False
+    >>> unp = UniqueNamesProver(prover)
+    >>> for a in unp.assumptions(): print(a) # doctest: +SKIP
+    man(Socrates)
+    man(Bill)
+    -(Socrates = Bill)
+    >>> unp.prove()
+    True
+
+    >>> p1 = read_expr(r'all x.(walk(x) -> (x = Socrates))')
+    >>> p2 = read_expr(r'Bill = William')
+    >>> p3 = read_expr(r'Bill = Billy')
+    >>> c = read_expr(r'-walk(William)')
+    >>> prover = Prover9Command(c, [p1,p2,p3])
+    >>> prover.prove()
+    False
+    >>> unp = UniqueNamesProver(prover)
+    >>> for a in unp.assumptions(): print(a) # doctest: +SKIP
+    all x.(walk(x) -> (x = Socrates))
+    (Bill = William)
+    (Bill = Billy)
+    -(William = Socrates)
+    -(Billy = Socrates)
+    -(Socrates = Bill)
+    >>> unp.prove()
+    True
+
+-----------------------
+Closed World Assumption
+-----------------------
+
+The only entities that have certain properties are those that is it stated
+have the properties.  We accomplish this assumption by "completing" predicates.
+
+If the assumptions contain "P(A)", then "all x.(P(x) -> (x=A))" is the completion
+of "P".  If the assumptions contain "all x.(ostrich(x) -> bird(x))", then
+"all x.(bird(x) -> ostrich(x))" is the completion of "bird".  If the
+assumptions don't contain anything that are "P", then "all x.-P(x)" is the
+completion of "P".
+
+    >>> p1 = read_expr(r'walk(Socrates)')
+    >>> p2 = read_expr(r'-(Socrates = Bill)')
+    >>> c = read_expr(r'-walk(Bill)')
+    >>> prover = Prover9Command(c, [p1,p2])
+    >>> prover.prove()
+    False
+    >>> cwp = ClosedWorldProver(prover)
+    >>> for a in cwp.assumptions(): print(a) # doctest: +SKIP
+    walk(Socrates)
+    -(Socrates = Bill)
+    all z1.(walk(z1) -> (z1 = Socrates))
+    >>> cwp.prove()
+    True
+
+    >>> p1 = read_expr(r'see(Socrates, John)')
+    >>> p2 = read_expr(r'see(John, Mary)')
+    >>> p3 = read_expr(r'-(Socrates = John)')
+    >>> p4 = read_expr(r'-(John = Mary)')
+    >>> c = read_expr(r'-see(Socrates, Mary)')
+    >>> prover = Prover9Command(c, [p1,p2,p3,p4])
+    >>> prover.prove()
+    False
+    >>> cwp = ClosedWorldProver(prover)
+    >>> for a in cwp.assumptions(): print(a) # doctest: +SKIP
+    see(Socrates,John)
+    see(John,Mary)
+    -(Socrates = John)
+    -(John = Mary)
+    all z3 z4.(see(z3,z4) -> (((z3 = Socrates) & (z4 = John)) | ((z3 = John) & (z4 = Mary))))
+    >>> cwp.prove()
+    True
+
+    >>> p1 = read_expr(r'all x.(ostrich(x) -> bird(x))')
+    >>> p2 = read_expr(r'bird(Tweety)')
+    >>> p3 = read_expr(r'-ostrich(Sam)')
+    >>> p4 = read_expr(r'Sam != Tweety')
+    >>> c = read_expr(r'-bird(Sam)')
+    >>> prover = Prover9Command(c, [p1,p2,p3,p4])
+    >>> prover.prove()
+    False
+    >>> cwp = ClosedWorldProver(prover)
+    >>> for a in cwp.assumptions(): print(a) # doctest: +SKIP
+    all x.(ostrich(x) -> bird(x))
+    bird(Tweety)
+    -ostrich(Sam)
+    -(Sam = Tweety)
+    all z7.-ostrich(z7)
+    all z8.(bird(z8) -> ((z8 = Tweety) | ostrich(z8)))
+    >>> print(cwp.prove())
+    True
+
+-----------------------
+Multi-Decorator Example
+-----------------------
+
+Decorators can be nested to utilize multiple assumptions.
+
+    >>> p1 = read_expr(r'see(Socrates, John)')
+    >>> p2 = read_expr(r'see(John, Mary)')
+    >>> c = read_expr(r'-see(Socrates, Mary)')
+    >>> prover = Prover9Command(c, [p1,p2])
+    >>> print(prover.prove())
+    False
+    >>> cmd = ClosedDomainProver(UniqueNamesProver(ClosedWorldProver(prover)))
+    >>> print(cmd.prove())
+    True
+
+-----------------
+Default Reasoning
+-----------------
+    >>> logic._counter._value = 0
+    >>> premises = []
+
+define the taxonomy
+
+    >>> premises.append(read_expr(r'all x.(elephant(x)        -> animal(x))'))
+    >>> premises.append(read_expr(r'all x.(bird(x)            -> animal(x))'))
+    >>> premises.append(read_expr(r'all x.(dove(x)            -> bird(x))'))
+    >>> premises.append(read_expr(r'all x.(ostrich(x)         -> bird(x))'))
+    >>> premises.append(read_expr(r'all x.(flying_ostrich(x)  -> ostrich(x))'))
+
+default the properties using abnormalities
+
+    >>> premises.append(read_expr(r'all x.((animal(x)  & -Ab1(x)) -> -fly(x))')) #normal animals don't fly
+    >>> premises.append(read_expr(r'all x.((bird(x)    & -Ab2(x)) -> fly(x))'))  #normal birds fly
+    >>> premises.append(read_expr(r'all x.((ostrich(x) & -Ab3(x)) -> -fly(x))')) #normal ostriches don't fly
+
+specify abnormal entities
+
+    >>> premises.append(read_expr(r'all x.(bird(x)           -> Ab1(x))')) #flight
+    >>> premises.append(read_expr(r'all x.(ostrich(x)        -> Ab2(x))')) #non-flying bird
+    >>> premises.append(read_expr(r'all x.(flying_ostrich(x) -> Ab3(x))')) #flying ostrich
+
+define entities
+
+    >>> premises.append(read_expr(r'elephant(el)'))
+    >>> premises.append(read_expr(r'dove(do)'))
+    >>> premises.append(read_expr(r'ostrich(os)'))
+
+print the augmented assumptions list
+
+    >>> prover = Prover9Command(None, premises)
+    >>> command = UniqueNamesProver(ClosedWorldProver(prover))
+    >>> for a in command.assumptions(): print(a) # doctest: +SKIP
+    all x.(elephant(x) -> animal(x))
+    all x.(bird(x) -> animal(x))
+    all x.(dove(x) -> bird(x))
+    all x.(ostrich(x) -> bird(x))
+    all x.(flying_ostrich(x) -> ostrich(x))
+    all x.((animal(x) & -Ab1(x)) -> -fly(x))
+    all x.((bird(x) & -Ab2(x)) -> fly(x))
+    all x.((ostrich(x) & -Ab3(x)) -> -fly(x))
+    all x.(bird(x) -> Ab1(x))
+    all x.(ostrich(x) -> Ab2(x))
+    all x.(flying_ostrich(x) -> Ab3(x))
+    elephant(el)
+    dove(do)
+    ostrich(os)
+    all z1.(animal(z1) -> (elephant(z1) | bird(z1)))
+    all z2.(Ab1(z2) -> bird(z2))
+    all z3.(bird(z3) -> (dove(z3) | ostrich(z3)))
+    all z4.(dove(z4) -> (z4 = do))
+    all z5.(Ab2(z5) -> ostrich(z5))
+    all z6.(Ab3(z6) -> flying_ostrich(z6))
+    all z7.(ostrich(z7) -> ((z7 = os) | flying_ostrich(z7)))
+    all z8.-flying_ostrich(z8)
+    all z9.(elephant(z9) -> (z9 = el))
+    -(el = os)
+    -(el = do)
+    -(os = do)
+
+    >>> UniqueNamesProver(ClosedWorldProver(Prover9Command(read_expr('-fly(el)'), premises))).prove()
+    True
+    >>> UniqueNamesProver(ClosedWorldProver(Prover9Command(read_expr('fly(do)'), premises))).prove()
+    True
+    >>> UniqueNamesProver(ClosedWorldProver(Prover9Command(read_expr('-fly(os)'), premises))).prove()
+    True