@ajksunkang-aios/kgraph-linux-x64 0.1.2 → 0.1.3

package/lib/site-packages/sortedcontainers-2.4.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

package/lib/site-packages/sortedcontainers-2.4.0.dist-info/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014-2019 Grant Jenks
+
+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.

package/lib/site-packages/sortedcontainers-2.4.0.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.1
+Name: sortedcontainers
+Version: 2.4.0
+Summary: Sorted Containers -- Sorted List, Sorted Dict, Sorted Set
+Home-page: http://www.grantjenks.com/docs/sortedcontainers/
+Author: Grant Jenks
+Author-email: contact@grantjenks.com
+License: Apache 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+
+Python Sorted Containers
+========================
+
+`Sorted Containers`_ is an Apache2 licensed `sorted collections library`_,
+written in pure-Python, and fast as C-extensions.
+
+Python's standard library is great until you need a sorted collections
+type. Many will attest that you can get really far without one, but the moment
+you **really need** a sorted list, sorted dict, or sorted set, you're faced
+with a dozen different implementations, most using C-extensions without great
+documentation and benchmarking.
+
+In Python, we can do better. And we can do it in pure-Python!
+
+.. code-block:: python
+
+    >>> from sortedcontainers import SortedList
+    >>> sl = SortedList(['e', 'a', 'c', 'd', 'b'])
+    >>> sl
+    SortedList(['a', 'b', 'c', 'd', 'e'])
+    >>> sl *= 10_000_000
+    >>> sl.count('c')
+    10000000
+    >>> sl[-3:]
+    ['e', 'e', 'e']
+    >>> from sortedcontainers import SortedDict
+    >>> sd = SortedDict({'c': 3, 'a': 1, 'b': 2})
+    >>> sd
+    SortedDict({'a': 1, 'b': 2, 'c': 3})
+    >>> sd.popitem(index=-1)
+    ('c', 3)
+    >>> from sortedcontainers import SortedSet
+    >>> ss = SortedSet('abracadabra')
+    >>> ss
+    SortedSet(['a', 'b', 'c', 'd', 'r'])
+    >>> ss.bisect_left('c')
+    2
+
+All of the operations shown above run in faster than linear time. The above
+demo also takes nearly a gigabyte of memory to run. When the sorted list is
+multiplied by ten million, it stores ten million references to each of "a"
+through "e". Each reference requires eight bytes in the sorted
+container. That's pretty hard to beat as it's the cost of a pointer to each
+object. It's also 66% less overhead than a typical binary tree implementation
+(e.g. Red-Black Tree, AVL-Tree, AA-Tree, Splay-Tree, Treap, etc.) for which
+every node must also store two pointers to children nodes.
+
+`Sorted Containers`_ takes all of the work out of Python sorted collections -
+making your deployment and use of Python easy. There's no need to install a C
+compiler or pre-build and distribute custom extensions. Performance is a
+feature and testing has 100% coverage with unit tests and hours of stress.
+
+.. _`Sorted Containers`: http://www.grantjenks.com/docs/sortedcontainers/
+.. _`sorted collections library`: http://www.grantjenks.com/docs/sortedcontainers/
+
+Testimonials
+------------
+
+**Alex Martelli**, `Fellow of the Python Software Foundation`_
+
+"Good stuff! ... I like the `simple, effective implementation`_ idea of
+splitting the sorted containers into smaller "fragments" to avoid the O(N)
+insertion costs."
+
+**Jeff Knupp**, `author of Writing Idiomatic Python and Python Trainer`_
+
+"That last part, "fast as C-extensions," was difficult to believe. I would need
+some sort of `Performance Comparison`_ to be convinced this is true. The author
+includes this in the docs. It is."
+
+**Kevin Samuel**, `Python and Django Trainer`_
+
+I'm quite amazed, not just by the code quality (it's incredibly readable and
+has more comment than code, wow), but the actual amount of work you put at
+stuff that is *not* code: documentation, benchmarking, implementation
+explanations. Even the git log is clean and the unit tests run out of the box
+on Python 2 and 3.
+
+**Mark Summerfield**, a short plea for `Python Sorted Collections`_
+
+Python's "batteries included" standard library seems to have a battery
+missing. And the argument that "we never had it before" has worn thin. It is
+time that Python offered a full range of collection classes out of the box,
+including sorted ones.
+
+`Sorted Containers`_ is used in popular open source projects such as:
+`Zipline`_, an algorithmic trading library from Quantopian; `Angr`_, a binary
+analysis platform from UC Santa Barbara; `Trio`_, an async I/O library; and
+`Dask Distributed`_, a distributed computation library supported by Continuum
+Analytics.
+
+.. _`Fellow of the Python Software Foundation`: https://en.wikipedia.org/wiki/Alex_Martelli
+.. _`simple, effective implementation`: http://www.grantjenks.com/docs/sortedcontainers/implementation.html
+.. _`author of Writing Idiomatic Python and Python Trainer`: https://jeffknupp.com/
+.. _`Python and Django Trainer`: https://www.elephorm.com/formateur/kevin-samuel
+.. _`Python Sorted Collections`: http://www.qtrac.eu/pysorted.html
+.. _`Zipline`: https://github.com/quantopian/zipline
+.. _`Angr`: https://github.com/angr/angr
+.. _`Trio`: https://github.com/python-trio/trio
+.. _`Dask Distributed`: https://github.com/dask/distributed
+
+Features
+--------
+
+- Pure-Python
+- Fully documented
+- Benchmark comparison (alternatives, runtimes, load-factors)
+- 100% test coverage
+- Hours of stress testing
+- Performance matters (often faster than C implementations)
+- Compatible API (nearly identical to older blist and bintrees modules)
+- Feature-rich (e.g. get the five largest keys in a sorted dict: d.keys()[-5:])
+- Pragmatic design (e.g. SortedSet is a Python set with a SortedList index)
+- Developed on Python 3.7
+- Tested on CPython 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7 and PyPy, PyPy3
+
+.. image:: https://api.travis-ci.org/grantjenks/python-sortedcontainers.svg?branch=master
+   :target: http://www.grantjenks.com/docs/sortedcontainers/
+
+.. image:: https://ci.appveyor.com/api/projects/status/github/grantjenks/python-sortedcontainers?branch=master&svg=true
+   :target: http://www.grantjenks.com/docs/sortedcontainers/
+
+Quickstart
+----------
+
+Installing `Sorted Containers`_ is simple with `pip
+<https://pypi.org/project/pip/>`_::
+
+    $ pip install sortedcontainers
+
+You can access documentation in the interpreter with Python's built-in `help`
+function. The `help` works on modules, classes and methods in `Sorted
+Containers`_.
+
+.. code-block:: python
+
+    >>> import sortedcontainers
+    >>> help(sortedcontainers)
+    >>> from sortedcontainers import SortedDict
+    >>> help(SortedDict)
+    >>> help(SortedDict.popitem)
+
+Documentation
+-------------
+
+Complete documentation for `Sorted Containers`_ is available at
+http://www.grantjenks.com/docs/sortedcontainers/
+
+User Guide
+..........
+
+The user guide provides an introduction to `Sorted Containers`_ and extensive
+performance comparisons and analysis.
+
+- `Introduction`_
+- `Performance Comparison`_
+- `Load Factor Performance Comparison`_
+- `Runtime Performance Comparison`_
+- `Simulated Workload Performance Comparison`_
+- `Performance at Scale`_
+
+.. _`Introduction`: http://www.grantjenks.com/docs/sortedcontainers/introduction.html
+.. _`Performance Comparison`: http://www.grantjenks.com/docs/sortedcontainers/performance.html
+.. _`Load Factor Performance Comparison`: http://www.grantjenks.com/docs/sortedcontainers/performance-load.html
+.. _`Runtime Performance Comparison`: http://www.grantjenks.com/docs/sortedcontainers/performance-runtime.html
+.. _`Simulated Workload Performance Comparison`: http://www.grantjenks.com/docs/sortedcontainers/performance-workload.html
+.. _`Performance at Scale`: http://www.grantjenks.com/docs/sortedcontainers/performance-scale.html
+
+Community Guide
+...............
+
+The community guide provides information on the development of `Sorted
+Containers`_ along with support, implementation, and history details.
+
+- `Development and Support`_
+- `Implementation Details`_
+- `Release History`_
+
+.. _`Development and Support`: http://www.grantjenks.com/docs/sortedcontainers/development.html
+.. _`Implementation Details`: http://www.grantjenks.com/docs/sortedcontainers/implementation.html
+.. _`Release History`: http://www.grantjenks.com/docs/sortedcontainers/history.html
+
+API Documentation
+.................
+
+The API documentation provides information on specific functions, classes, and
+modules in the `Sorted Containers`_ package.
+
+- `Sorted List`_
+- `Sorted Dict`_
+- `Sorted Set`_
+
+.. _`Sorted List`: http://www.grantjenks.com/docs/sortedcontainers/sortedlist.html
+.. _`Sorted Dict`: http://www.grantjenks.com/docs/sortedcontainers/sorteddict.html
+.. _`Sorted Set`: http://www.grantjenks.com/docs/sortedcontainers/sortedset.html
+
+Talks
+-----
+
+- `Python Sorted Collections | PyCon 2016 Talk`_
+- `SF Python Holiday Party 2015 Lightning Talk`_
+- `DjangoCon 2015 Lightning Talk`_
+
+.. _`Python Sorted Collections | PyCon 2016 Talk`: http://www.grantjenks.com/docs/sortedcontainers/pycon-2016-talk.html
+.. _`SF Python Holiday Party 2015 Lightning Talk`: http://www.grantjenks.com/docs/sortedcontainers/sf-python-2015-lightning-talk.html
+.. _`DjangoCon 2015 Lightning Talk`: http://www.grantjenks.com/docs/sortedcontainers/djangocon-2015-lightning-talk.html
+
+Resources
+---------
+
+- `Sorted Containers Documentation`_
+- `Sorted Containers at PyPI`_
+- `Sorted Containers at Github`_
+- `Sorted Containers Issue Tracker`_
+
+.. _`Sorted Containers Documentation`: http://www.grantjenks.com/docs/sortedcontainers/
+.. _`Sorted Containers at PyPI`: https://pypi.org/project/sortedcontainers/
+.. _`Sorted Containers at Github`: https://github.com/grantjenks/python-sortedcontainers
+.. _`Sorted Containers Issue Tracker`: https://github.com/grantjenks/python-sortedcontainers/issues
+
+Sorted Containers License
+-------------------------
+
+Copyright 2014-2019 Grant Jenks
+
+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.
+
+

package/lib/site-packages/sortedcontainers-2.4.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+sortedcontainers-2.4.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+sortedcontainers-2.4.0.dist-info/LICENSE,sha256=HbfK5_zmRS4uYI5AGg-VPgEz5MLXXbafuK6FHSCG9bY,557
+sortedcontainers-2.4.0.dist-info/METADATA,sha256=7t8RUQniFQAekE2giChRvq5QsDwLAWGouedLfP1nlHM,10666
+sortedcontainers-2.4.0.dist-info/RECORD,,
+sortedcontainers-2.4.0.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+sortedcontainers-2.4.0.dist-info/top_level.txt,sha256=AVs0q-qf-10gs1tkVhfALdebJo4uPuVVBX7YT91riQU,17
+sortedcontainers/__init__.py,sha256=X_X5LuRjve77KwuJQrDUSu0T8559YcoowQbAnjuM7TE,2131
+sortedcontainers/sorteddict.py,sha256=za5LnENZMGPIn_JZEr0S0tDXfEsxJsfEnanh6lLlTZM,22712
+sortedcontainers/sortedlist.py,sha256=rwA1dM8ce09eb2DMjLOfHoikhCx_Rfk5nuE_NSsfr3I,76331
+sortedcontainers/sortedset.py,sha256=5RI2CUJGMm1ig3-dhbOrzDl8aPqDePkoJPQoq0ROS7M,19825

package/lib/site-packages/sortedcontainers-2.4.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

package/lib/site-packages/sortedcontainers-2.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sortedcontainers

package/lib/site-packages/trio/__init__.py

@@ -0,0 +1,133 @@
+"""Trio - A friendly Python library for async concurrency and I/O"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+# General layout:
+#
+# trio/_core/... is the self-contained core library. It does various
+# shenanigans to export a consistent "core API", but parts of the core API are
+# too low-level to be recommended for regular use.
+#
+# trio/*.py define a set of more usable tools on top of this. They import from
+# trio._core and from each other.
+#
+# This file pulls together the friendly public API, by re-exporting the more
+# innocuous bits of the _core API + the higher-level tools from trio/*.py.
+#
+# Uses `from x import y as y` for compatibility with `pyright --verifytypes` (#2625)
+#
+# must be imported early to avoid circular import
+from ._core import TASK_STATUS_IGNORED as TASK_STATUS_IGNORED  # isort: split
+
+# Submodules imported by default
+from . import abc, from_thread, lowlevel, socket, to_thread
+from ._channel import (
+    MemoryChannelStatistics as MemoryChannelStatistics,
+    MemoryReceiveChannel as MemoryReceiveChannel,
+    MemorySendChannel as MemorySendChannel,
+    as_safe_channel as as_safe_channel,
+    open_memory_channel as open_memory_channel,
+)
+from ._core import (
+    BrokenResourceError as BrokenResourceError,
+    BusyResourceError as BusyResourceError,
+    Cancelled as Cancelled,
+    CancelScope as CancelScope,
+    ClosedResourceError as ClosedResourceError,
+    EndOfChannel as EndOfChannel,
+    Nursery as Nursery,
+    RunFinishedError as RunFinishedError,
+    TaskStatus as TaskStatus,
+    TrioInternalError as TrioInternalError,
+    WouldBlock as WouldBlock,
+    current_effective_deadline as current_effective_deadline,
+    current_time as current_time,
+    open_nursery as open_nursery,
+    run as run,
+)
+from ._deprecate import TrioDeprecationWarning as TrioDeprecationWarning
+from ._dtls import (
+    DTLSChannel as DTLSChannel,
+    DTLSChannelStatistics as DTLSChannelStatistics,
+    DTLSEndpoint as DTLSEndpoint,
+)
+from ._file_io import open_file as open_file, wrap_file as wrap_file
+from ._highlevel_generic import (
+    StapledStream as StapledStream,
+    aclose_forcefully as aclose_forcefully,
+)
+from ._highlevel_open_tcp_listeners import (
+    open_tcp_listeners as open_tcp_listeners,
+    serve_tcp as serve_tcp,
+)
+from ._highlevel_open_tcp_stream import open_tcp_stream as open_tcp_stream
+from ._highlevel_open_unix_stream import open_unix_socket as open_unix_socket
+from ._highlevel_serve_listeners import serve_listeners as serve_listeners
+from ._highlevel_socket import (
+    SocketListener as SocketListener,
+    SocketStream as SocketStream,
+)
+from ._highlevel_ssl_helpers import (
+    open_ssl_over_tcp_listeners as open_ssl_over_tcp_listeners,
+    open_ssl_over_tcp_stream as open_ssl_over_tcp_stream,
+    serve_ssl_over_tcp as serve_ssl_over_tcp,
+)
+from ._path import Path as Path, PosixPath as PosixPath, WindowsPath as WindowsPath
+from ._signals import open_signal_receiver as open_signal_receiver
+from ._ssl import (
+    NeedHandshakeError as NeedHandshakeError,
+    SSLListener as SSLListener,
+    SSLStream as SSLStream,
+)
+from ._subprocess import Process as Process, run_process as run_process
+from ._sync import (
+    CapacityLimiter as CapacityLimiter,
+    CapacityLimiterStatistics as CapacityLimiterStatistics,
+    Condition as Condition,
+    ConditionStatistics as ConditionStatistics,
+    Event as Event,
+    EventStatistics as EventStatistics,
+    Lock as Lock,
+    LockStatistics as LockStatistics,
+    Semaphore as Semaphore,
+    StrictFIFOLock as StrictFIFOLock,
+)
+from ._timeouts import (
+    TooSlowError as TooSlowError,
+    fail_after as fail_after,
+    fail_at as fail_at,
+    move_on_after as move_on_after,
+    move_on_at as move_on_at,
+    sleep as sleep,
+    sleep_forever as sleep_forever,
+    sleep_until as sleep_until,
+)
+from ._version import __version__ as __version__
+
+# Not imported by default, but mentioned here so static analysis tools like
+# pylint will know that it exists.
+if TYPE_CHECKING:
+    from . import testing
+
+from . import _deprecate as _deprecate
+
+_deprecate.deprecate_attributes(__name__, {})
+
+# Having the public path in .__module__ attributes is important for:
+# - exception names in printed tracebacks
+# - sphinx :show-inheritance:
+# - deprecation warnings
+# - pickle
+# - probably other stuff
+from ._util import fixup_module_metadata
+
+fixup_module_metadata(__name__, globals())
+fixup_module_metadata(lowlevel.__name__, lowlevel.__dict__)
+fixup_module_metadata(socket.__name__, socket.__dict__)
+fixup_module_metadata(abc.__name__, abc.__dict__)
+fixup_module_metadata(from_thread.__name__, from_thread.__dict__)
+fixup_module_metadata(to_thread.__name__, to_thread.__dict__)
+del fixup_module_metadata
+del TYPE_CHECKING

package/lib/site-packages/trio/__main__.py

@@ -0,0 +1,3 @@
+from trio._repl import main
+
+main(locals())