{ "info": { "author": "Adam Jorgensen", "author_email": "adam.jorgensen.za@gmail.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 4 - Beta", "Environment :: Console", "Framework :: AsyncIO", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy", "Topic :: Utilities" ], "description": "OpenDNA Autobahn-Python REPL\n============================\nA REPL environment for working with WAMP routers in an interactive fashion built\nusing the Autobahn-Python library.\n\n\nContents\n--------\n1. `Installation`_\n2. `Usage`_\n\n 1. `Starting the REPL`_\n 2. `Connections`_\n 3. `Sessions`_\n 4. `Calls and Invocations`_\n 5. `Registrations`_\n 6. `Publishers and Publications`_\n 7. `Subscriptions`_\n\n3. `Extending`_\n\n 1. `PtPython config module`_\n 2. `REPL class substitution`_\n\n4. `REPL API`_\n5. `Roadmap`_\n6. `Credits`_\n\n\nInstallation\n------------\n``pip install autobahn-python-repl``\n\nAPR requires Python 3.6 to run. If you are not using Python\n3.6 in your WAMP project then it is recommend you create a Python 3.6 virtual\nenvironment and install the REPL there.\n\n\nUsage\n-----\n\nStarting the REPL\n~~~~~~~~~~~~~~~~~\n1. Run the ``autobahn_python_repl`` script installed by this package\n2. Run ``python -m opendna.autobahn.repl.repl``\n\nConnections\n```````````\nOnce the REPL has started you will be presented with a standard PtPython prompt\nand environment. In order to begin connecting to a WAMP router enter::\n\n >>> my_connection = connect_to(uri='ws://HOST:PORT', realm='MY_REALM')\n Generating connection to MY_REALM@ws://HOST:PORT with name g9jZlZeh\n\nYou will see that ``connect_to`` generated an internal name for the connection.\nYou can access the connection via this internal name by entering::\n\n >>> connections.g9jZlZeh\n \n\nIt is also possible to provide a custom internal name for the connection when\nyou call ``connect_to`` as follows::\n\n >>> connect_to(uri='ws://HOST:PORT', realm='MY_REALM', name='my_connection')\n Generating connection to MY_REALM@ws://HOST:PORT with name my_connection\n\nYou can now access the connection by entering::\n\n >>> connections.my_connection\n \n >>> connections['my_connection']\n \n\nNote that the ``Connection`` object is not actually a concrete connection to\nthe WAMP router, it is merely a storage container for connection related\ndetails that is used to create ``Session`` objects which represent actual\nconnections to the WAMP router.\n\n``connect_to`` accepts the follows arguments:\n\n* ``uri``: Required. A WAMP router URI string\n* ``realm``: Optional. A WAMP realm string\n* ``extra``: Optional. A dictionary of data to be supplied to the WAMP\n ``ApplicationSession``.``__init__`` method. Not useful unless you are\n working with a custom ``ApplicationSessions`` class. See *Extending* for\n more details on this.\n* ``serializer``: Optional. A list of WAMP serializers to use. Serializers must\n implement ``autobahn.wamp.interfaces.ISerializer``\n* ``ssl``: Optional. Boolean or ``ssl.SSLContenxt`` instance. Can usually\n be ignored unless you are planning to connect use TLS authentication for a\n ``Session``\n* ``proxy``: Optional. A dictionary providing details for a proxy server. Must\n have ``host`` and ``port`` keys\n* ``name``: Optional. A name for the connection\n\nSessions\n````````\nOnce you have a ``Connection`` instance you can use it to create a ``Session``\ninstance, opening a WAMP session in the process::\n\n >>> my_session = my_connection.session()\n Generating anonymous session to MY_REALM@ws://HOST:PORT with name bKP5ajz0\n\nYou can access this session via its auto-generated name like so::\n\n >>> my_connection.sessions.bKP5ajz0\n \n >>> my_connection.sessions['bKP5ajz0']\n \n\n``session`` also accepts a *name* parameter that you can use to avoid using an\nauto-generated name.\n\nBy default calling ``session`` will open a *WAMP-Anonymous* session with the router.\n\nIt is also possible to specify the authentication method or methods that will\nbe used::\n\n >>> ticket_session = my_connection.session('ticket', authid='your_authid', ticket='YOUR_AUTHENTICATION_TICKET')\n Generating ticket session to MY_REALM@ws://HOST:PORT with name SOME_NAME\n >>> mixed_session = my_connection.session(['ticket', 'anonymous'], authid='your_authid', ticket='YOUR_AUTHENTICATION_TICKET')\n Generating ['ticket', 'anonymous'] session to MY_REALM@ws://HOST:PORT with name SOME_OTHER_NAME\n\n*ticket_session* will use WAMP-Ticket authentication only while *mixed_session*\nwill try WAMP-Ticket first before falling back to WAMP-Anonymous.\n\nWhile WAMP provides a number a authentication methods, only four of are handled\nat the session level (as opposed to the transport level). Calling the ``session``\nmethod with a specific authentication method may imply the use of certain additional\nparameters. These are detailed below:\n\n* WAMP-Anonymous: No parameters required. Note that ``authid`` will be ignored if it is supplied\n* WAMP-Ticket: ``authid`` and ``ticket`` parameters required\n* WAMP-CRA: ``authid`` and ``secret`` parameters required\n* WAMP-Cryptosign: ``authid`` and ``key`` parameters required. ``key`` needs to be an instance of ``autobahn.wamp.cryptosign.SigningKey``\n\nThe ``Connection.session`` method accepts the following arguments:\n\n* ``authmethods``: Optional. String or list of strings. Valid authentication method\n strings are: ``anonymous``, ``ticket``, ``wampcra``, ``cryptosign``, ``cookie`` and ``tls``\n* ``authid``: String. Optional for WAMP-Anonymous authentication, required for all other methods\n* ``authrole``: String. Optional. Requested role\n* ``authextra``: Dictionary. Optional. Data to be passed along to the authenticator. Useful\n for providing additional data to a dynamic authenticator\n* ``resumable``: Boolean. Optional. Should the session be resumed later if it disconnects\n* ``resume_session``: Integer. Optional. ID of Session to resume\n* ``resume_token``: String. Optional. Token for resuming session specified by ``resume_session``\n\nCalls and Invocations\n`````````````````````\nIn order to perform WAMP RPC calls you need to create a ``Call`` instance. This is\ndone using a ``Session`` instance::\n\n >>> my_call = my_session.call('endpoint_uri')\n Generating a call to endpoint endpoint_uri with name i9BcEagW\n\nYou can access this call by it's autogenerated name like so::\n\n >>> my_session.calls.i9BcEagW\n \n >>> my_session.calls['i9BcEagW']\n \n\n``call`` also accepts a custom *name* parameter to bypass the use of an autogenerated\nname. Furthermore, the ``call`` method accepts any keyword-arguments you can\nsupply to the `autobahn.wamp.types.CallOptions constructor`_.\n\n.. _autobahn.wamp.types.CallOptions constructor: https://autobahn.readthedocs.io/en/latest/reference/autobahn.wamp.html#autobahn.wamp.types.CallOptions\n\nA ``Call`` instance is itself callable and can be invoked in order to produce an\n``Invocation`` instance. Creating an ``Invocation`` initiates the process of\nsending the WAMP RPC call using the ``Session`` instance associated with the\n``Call`` instance that is the parent of the ``Invocation``::\n\n >>> my_invocation = my_call(True, False, parm3=None, parm4={'something': 'or other'})\n Invoking endpoint_uri with name Wax3JdBx\n Invocation of endpoint_uri with name Wax3JdBx starting\n Invocation of endpoint_uri with name Wax3JdBx succeeded\n\nDepending on how long it takes for the remote end-point to execute, the message\nindicating success or failure may not appear immediately. You will note that\nthe ``Invocation`` also receives a auto-generated name which can be used to access\nit from the ``Call`` instance like so::\n\n >>> my_call.invocations.Wax3JdBx\n \n >>> my_call.invocations['Wax3JdBx']\n \n\n\nThe ``Invocation`` instance exposes three important properties that can be\nused to access the results of the WAMP Call:\n\n* ``result`` will contain the result of the WAMP Call if it succeeded or ``None`` if it failed or hasn't completed yet\n* ``exception`` will contain the result of the WAMP Call if it failed or ``None`` if it succeeded or hasn't completed yet\n* ``progress`` is a list which is used to store progressive results if the\n target WAMP end-point emits them. See https://crossbar.io/docs/Progressive-Call-Results/ for more details on this\n\nFinally, an ``Invocation`` instance is itself callable. Calling an ``Invocation`` will\nproduce a new ``Invocation`` instance attached to the parent ``Call`` of the called ``Invocation``.\nThe behaviour of the arguments and keyword arguments when calling an ``Invocation`` is quite specific\nand affects the creation of the new ``Invocation`` as follows:\n\n* Positional arguments will replace the corresponding positional arguments from the parent ``Invocation``\n in the new ``Invocation`` unless the positional argument is a reference to the singleton object ``opendna.autobahn.repl.utils.Keep``\n To illustrate this consider the following input scenario::\n\n >>> my_call = my_session.call('some_endpoint')\n >>> invocation1 = my_call(1,2,3)\n >>> invocation2 = invocation1(3, Keep, 1)\n >>> invocation3 = my_call(3,2,1)\n\n In this scenario ``invocation2`` and ``invocation3`` are identical\n\n* If the number of positional arguments supplied is less than was supplied to the parent ``Invocation`` then the\n missing positional arguments will be substituted in from the parent ``Invocation`` as if ``Keep`` had been used in their\n positions\n\n* If the number of position arguments supplied is greater than was supplied to the parent ``Invocation`` then the\n additional positional arguments will be ignored\n\n* Any keyword arguments will replace the corresponding keyword arguments from the parent ``Invocation``::\n\n >>> my_call = my_session.call('some_endpoint')\n >>> invocation1 = my_call(x=True, y=False)\n >>> invocation2 = invocation1(y=True)\n >>> invocation3 = my_call(x=True, y=True)\n\n In this scenario ``invocation2`` and ``invocation3`` are identical\n\nRegistrations\n`````````````\nIn order to handle calls to WAMP RPC end-points you need to create a\n``Registration`` instance::\n\n >>> my_registration = my_session.register('endpoint_uri')\n Generating registration for endpoint_uri with name Rx3mmt2e\n Registration of endpoint_uri with name Rx3mmt2e starting\n Registration of endpoint_uri with name Rx3mmt2e succeeded\n\nYou can access this registration by it's autogenerated name like so::\n\n >>> my_session.registrations.Rx3mmt2e\n \n >>> my_session.registrations['Rx3mmt2e']\n \n\nYou can also provide a a custom *name* parameter to bypass the use of an autogenerated\nname. Furthermore, the ``register`` method accepts any keyword-arguments you can\nsupply to the `autobahn.wamp.types.RegisterOptions constructor`_.\n\n.. _autobahn.wamp.types.RegisterOptions constructor: https://autobahn.readthedocs.io/en/latest/reference/autobahn.wamp.html#autobahn.wamp.types.RegisterOptions\n\nOnce a registration has succeeded it is available for calling as described in\nthe `Calls and Invocations`_ section. By default the ``Registration`` class\nprovides a default handler for incoming calls which records the input parameters\nalong with the date and time of the call using a a ``Registration..Hit`` instance.\nThis ``Hit`` is a ``namedtuple`` providing three attributes: *timestamp*, *args*\nand *kwargs*. When the registration is the target of a call the console will output text like:\n\n``End-point endpoint_uri named Rx3mmt2e hit at 2017-12-01 22:04:10.030438. Hit named jqD8TxFp stored``\n\nHits stored on a registration can be accessed using either the auto-generated name\nor via a numeric index (hits are stored in the order they are received)::\n\n >>> my_registration.hits[0]\n Hit(timestamp=datetime.datetime(2017, 12, 1, 22, 4, 10, 30438), args=(1, 2, 3, False, True, {}), kwargs={'x': None})\n >>> my_registration.hits.jqD8TxFp\n Hit(timestamp=datetime.datetime(2017, 12, 1, 22, 4, 10, 30438), args=(1, 2, 3, False, True, {}), kwargs={'x': None})\n\nWhen creating a ``Registration`` it is also possible to specify a custom handler\nwhich is used in addition to the default handler for incoming calls. This custom\nhandler may be either a standard function or an async function and is called\nafter the hit is stored by the ``Registration`` instance. Additionally, the result\nof the custom handler will be returned to the caller (the default handler will return\n``None`` in the event that no custom handler is supplied)::\n\n >>> import asyncio\n >>> async def test(*args, **kwargs):\n await asyncio.sleep(5)\n print(args, kwargs)\n return True\n >>> my_registration = my_session.register('endpoint_uri', test)\n Generating registration for endpoint_uri with name Rx3mmt2e\n Registration of endpoint_uri with name Rx3mmt2e starting\n Registration of endpoint_uri with name Rx3mmt2e succeeded\n >>> invocation = my_session.call('endpoint_uri')(1,2,3,False,True,{},x=None)\n Generating call to endpoint_uri with name shejtoeU\n Invoking endpoint_uri with name dgSHC77i\n Invocation of endpoint_uri with name dgSHC77i starting\n End-point endpoint_uri named Rx3mmt2e hit at 2017-12-01 22:04:10.030438. Hit named jqD8TxFp stored\n (1, 2, 3, False, True, {}) {'x': None}\n Invocation of endpoint_uri with name dgSHC77i succeeded\n >>> invocation.result\n True\n\nIt is also possible to deregister an existing registration::\n\n >>> my_registration.deregister()\n Deregistration of endpoint_uri with name Rx3mmt2e starting\n Deregistration of endpoint_uri with name Rx3mmt2e succeeded\n\nPublishers and Publications\n```````````````````````````\nIn order to emit WAMP PubSub events you need to create a ``Publisher`` instance::\n\n >>> my_publisher = my_session.publish('topic_uri')\n Generating publisher for topic_uri with name YunLGYwr\n\nYou can access this publisher by it's autogenerated name like so::\n\n >>> my_session.publishers.YunLGYwr\n \n >>> my_session.publishers['YunLGYwr']\n \n\nYou can also provide a a custom *name* parameter to bypass the use of an autogenerated\nname. Furthermore, the ``publish`` method accepts any keyword-arguments you can\nsupply to the `autobahn.wamp.types.PublishOptions constructor`_.\n\n.. _autobahn.wamp.types.PublishOptions constructor: https://autobahn.readthedocs.io/en/latest/reference/autobahn.wamp.html#autobahn.wamp.types.PublishOptions\n\nA ``Publisher`` instance is itself callable and can be invoked in order to produce an\n``Publication`` instance. Creating a ``Publication`` initiates the process of\nsending the WAMP PubSub event using the ``Session`` instance associated with the\n``Publisher`` instance that is the parent of the ``Publication``::\n\n >>> my_publication = my_publisher(a=True, b=False)\n Publication to topic_uri with name CHrYRIn8 starting\n Publication to topic_uri with name CHrYRIn8 succeeded\n\nYou will note that the ``Publication`` also receives a auto-generated name which\ncan be used to access it from the parent ``Publisher`` instance like so::\n\n >>> my_publisher.publications.CHrYRIn8\n \n >>> my_publisher.publications['CHrYRIn8']\n \n\nThe ``Publication`` instance exposes two important properties that can be\nused to access the results of the WAMP PubSub event emission:\n\n* ``result`` will contain the result of the WAMP PubSub event emission if the ``acknowledge`` boolean\n parameter supplied to the ``publish`` was set to ``True``. In all other instances it will contain ``None``\n* ``exception`` will contain the exception result of the WAMP PubSub event emission if it failed or ``None``\n if no failure was detected\n\nFinally, a ``Publication`` instance is itself callable. Calling a ``Publication`` will\nproduce a new ``Publication`` instance attached to the parent ``Publisher`` of the\ncalled ``Publication``. The behaviour of the arguments and keyword arguments when\ncalling a ``Publication`` is quite specific and affects the creation of the new\n``Publication`` as follows:\n\n* Positional arguments will replace the corresponding positional arguments from the parent ``Publication``\n in the new ``Publication`` unless the positional argument is a reference to the singleton object ``opendna.autobahn.repl.utils.Keep``\n To illustrate this consider the following input scenario::\n\n >>> my_publisher = my_session.publish('some_topic')\n >>> publication1 = my_publisher(1,2,3)\n >>> publication2 = publication1(3, Keep, 1)\n >>> publication3 = my_publisher(3,2,1)\n\n In this scenario ``publication2`` and ``publication3`` are identical\n\n* If the number of positional arguments supplied is less than was supplied to the parent ``Publication`` then the\n missing positional arguments will be substituted in from the parent ``Publication`` as if ``Keep`` had been used in their\n positions\n\n* If the number of position arguments supplied is greater than was supplied to the parent ``Publication`` then the\n additional positional arguments will be ignored\n\n* Any keyword arguments will replace the corresponding keyword arguments from the parent ``Publication``::\n\n >>> my_publisher = my_session.publish('some_topic')\n >>> publication1 = my_publisher(x=True, y=False)\n >>> publication2 = publication1(y=True)\n >>> publication3 = my_publisher(x=True, y=True)\n\n In this scenario ``publication2`` and ``publication3`` are identical\n\nSubscriptions\n`````````````\nIn order to subscribe to WAMP PubSub topics you need to create a ``Subscription`` instance::\n\n >>> my_subscription = my_session.subscribe('topic_uri')\n Generating subscription for topic_uri with name bIMq6XcO\n Subscription to topic_uri with name bIMq6XcO starting\n Subscription to topic_uri with name bIMq6XcO succeeded\n\nYou can access this subscription by it's autogenerated name like so::\n\n >>> my_session.subscriptions.bIMq6XcO\n \n >>> my_session.subscriptions['bIMq6XcO']\n \n\nYou can also provide a a custom *name* parameter to bypass the use of an autogenerated\nname. Furthermore, the ``subscribe`` method accepts any keyword-arguments you can\nsupply to the `autobahn.wamp.types.SubscribeOptions constructor`_.\n\n.. _autobahn.wamp.types.SubscribeOptions constructor: https://autobahn.readthedocs.io/en/latest/reference/autobahn.wamp.html#autobahn.wamp.types.SubscribeOptions\n\nOnce a subscription has succeeded it will be notified of WAMP PubSub events\nemitted as described in the `Publishers and Publications`_ section. Note, however,\nthat by default a subscription to a topic will only receive events emitted by\nother sessions. The *exclude_me* parameter for the ``Publisher`` must be set to\n``True`` if you wish to test publication and subscription to a given topic within\na single ``Session``.\n\nThe ``Subscription`` class provides a default handler for incoming events which\nrecords the input parameters along with the date and time of the call using a\n``Subscription.Hit`` instance. This ``Event`` is a ``namedtuple`` providing three\nattributes: *timestamp*, *args* and *kwargs*. When the subscription receives an\nevent the console will output text like:\n\n``Event named s3X0Sbhc received at 2017-12-03 21:59:55.437068 on topic topic_uri named bIMq6XcO``\n\nEvents stored on a subscription can be accessed using either the auto-generated name\nor via a numeric index (hits are stored in the order they are received)::\n\n >>> my_subscription.events[0]\n Event(timestamp=datetime.datetime(2017, 12, 1, 22, 4, 10, 30438), args=(1, 2, 3, False, True, {}), kwargs={'x': None})\n >>> my_subscription.events.jqD8TxFp\n Event(timestamp=datetime.datetime(2017, 12, 1, 22, 4, 10, 30438), args=(1, 2, 3, False, True, {}), kwargs={'x': None})\n\nWhen creating a ``Subscription`` it is also possible to specify a custom handler\nwhich is used in addition to the default handler for incoming events. This custom\nhandler may be either a standard function or an async function and is called\nafter the event is stored by the ``Subscription`` instance::\n\n >>> async def test(*args, **kwargs):\n print(args, kwargs)\n >>> my_subscription = my_session.subscribe('topic_uri', test)\n Generating subscription for topic_uri with name bIMq6XcO\n Subscription to topic_uri with name bIMq6XcO starting\n Subscription to topic_uri with name bIMq6XcO succeeded\n >>> publication = my_session.publish('topic_uri', exclude_me=False)(1,2,3,False,True,{},x=None)\n Generating publisher for topic_uri with name VVjZjvF5\n Publication to topic_uri with name sjfuAGSm starting\n Publication to topic_uri with name sjfuAGSm succeeded\n Event named ZbbzBrxJ received at 2017-12-03 22:18:10.383218 on topic topic_uri named bIMq6XcO\n (1, 2, 3, False, True, {}) {'x': None}\n >>> my_subscription.events.ZbbzBrxJ\n Event(timestamp=datetime.datetime(2017, 12, 3, 22, 18, 10, 383218), args=(1, 2, 3, False, True, {}), kwargs={'x': None})\n\nIt is also possible to unsubscribe from a topic::\n\n >>> my_subscription.unsubscribe()\n Unsubscription from topic_uri with name bIMq6XcO starting\n Unsubscription from topic_uri with name bIMq6XcO succeeded\n\nExtending\n---------\nTBD\n\nPtPython config module\n~~~~~~~~~~~~~~~~~~~~~~\nTBD\n\nREPL class substitution\n~~~~~~~~~~~~~~~~~~~~~~~\nTBD\n\n\nREPL API\n--------\nTBD\n\n\nRoadmap\n-------\n\n* Improved UI with custom panes/tabs/views for examining Calls, Invocations,\n Publishers, Publications, Registrations and Subscriptions\n* ``deregister``/``Unsubscribe`` should clean up the ``Registration``/``Subscription`` instance\n* Support usage in other REPLs\n* You tell me!\n\n\nCredits\n-------\n\n* Autobahn-Python for providing the secret WAMP sauce\n* PtPython for providing the secret REPL sauce\n* Jedi for providing PtPython with the secret code completion sauce\n* PromptToolkit for providing PtPython with the prompt secret sauce\n\n\n\n", "description_content_type": "", "docs_url": null, "download_url": "", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://github.com/opn-oss/autobahn-python-repl", "keywords": "autobahn crossbar asyncio repl", "license": "MIT", "maintainer": "", "maintainer_email": "", "name": "autobahn-python-repl", "package_url": "https://pypi.org/project/autobahn-python-repl/", "platform": "", "project_url": "https://pypi.org/project/autobahn-python-repl/", "project_urls": { "Homepage": "https://github.com/opn-oss/autobahn-python-repl" }, "release_url": "https://pypi.org/project/autobahn-python-repl/18.12.8/", "requires_dist": [ "autobahn (>=17.3.1)", "opn-oss-py-common (>=17.8.4)", "ptpython (<2.0.1)", "decorator" ], "requires_python": "", "summary": "A REPL interface for interacting with WAMP routers", "version": "18.12.8" }, "last_serial": 4575813, "releases": { "17.12.4": [ { "comment_text": "", "digests": { "md5": "b5cb88191fb4aae89da6b3d91a34f375", "sha256": "fa8f8e104a3c30a7e4cdcc6f9de6801f45d961874eb47b0f50e4b15135367a7b" }, "downloads": -1, "filename": "autobahn-python-repl-17.12.4.tar.gz", "has_sig": false, "md5_digest": "b5cb88191fb4aae89da6b3d91a34f375", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 27601, "upload_time": "2017-12-04T09:11:23", "url": "https://files.pythonhosted.org/packages/d9/e3/87552ac63af3bd030c666a9e77eef59dac31c87dc940d261a8faa1174641/autobahn-python-repl-17.12.4.tar.gz" } ], "18.12.8": [ { "comment_text": "", "digests": { "md5": "32c7e1e90449d8ce4229cf20f9150afe", "sha256": "150ec271676f0549756d8a88f3b3bfd15bcbcea72c929edb1beb8b05533c3a25" }, "downloads": -1, "filename": "autobahn_python_repl-18.12.8-py3-none-any.whl", "has_sig": false, "md5_digest": "32c7e1e90449d8ce4229cf20f9150afe", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 29402, "upload_time": "2018-12-08T18:41:53", "url": "https://files.pythonhosted.org/packages/08/0a/6328416595d71fc9e69dfcf9847940c86114bc3edf5bdf62fd87a83ed335/autobahn_python_repl-18.12.8-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "d6645c5e1e26f534604ac52dc9312fc2", "sha256": "dda4c8aa70464932093d9b81a330f5458190a020b086e9c9c19e5ddb7ed7cc6e" }, "downloads": -1, "filename": "autobahn-python-repl-18.12.8.tar.gz", "has_sig": false, "md5_digest": "d6645c5e1e26f534604ac52dc9312fc2", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 25239, "upload_time": "2018-12-08T18:41:55", "url": "https://files.pythonhosted.org/packages/44/24/0f3b25dbf2ded6a04921ab6aaa2537f489242229f91f41a7fe077685bdfd/autobahn-python-repl-18.12.8.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "32c7e1e90449d8ce4229cf20f9150afe", "sha256": "150ec271676f0549756d8a88f3b3bfd15bcbcea72c929edb1beb8b05533c3a25" }, "downloads": -1, "filename": "autobahn_python_repl-18.12.8-py3-none-any.whl", "has_sig": false, "md5_digest": "32c7e1e90449d8ce4229cf20f9150afe", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": null, "size": 29402, "upload_time": "2018-12-08T18:41:53", "url": "https://files.pythonhosted.org/packages/08/0a/6328416595d71fc9e69dfcf9847940c86114bc3edf5bdf62fd87a83ed335/autobahn_python_repl-18.12.8-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "d6645c5e1e26f534604ac52dc9312fc2", "sha256": "dda4c8aa70464932093d9b81a330f5458190a020b086e9c9c19e5ddb7ed7cc6e" }, "downloads": -1, "filename": "autobahn-python-repl-18.12.8.tar.gz", "has_sig": false, "md5_digest": "d6645c5e1e26f534604ac52dc9312fc2", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 25239, "upload_time": "2018-12-08T18:41:55", "url": "https://files.pythonhosted.org/packages/44/24/0f3b25dbf2ded6a04921ab6aaa2537f489242229f91f41a7fe077685bdfd/autobahn-python-repl-18.12.8.tar.gz" } ] }