* Properly split and handle arguments in CommandHandler
* Update the docstring for pass_args in CommandHandler
* Properly split and handle arguments in StringCommandHandler
* bot.py: add create_references method
* create bot reference in webhook handler, use create_references on new updates
* message.py: implement reply_text
* echobot2.py: use Message.reply_text
* fix create_references in webhook handler
* add some more instance methods
* Chat.kick_member and unban_member
* bot.py: Create bot references in outgoing messages
* add tests for everything testable
* test_updater.py: add create_references method to MockBot
* remove Bot.create_references and refactor TelegramObject.de_json to take the additional parameter bot
* List bot as named kwarg where used
* file.py: Use Bot.request property instead of Bot._request attr
Should close#400.
* Add parse_entity
* Add parse_entities
* Add MessageEntity types as constants to MessageEntity.
* Add MAX_MESSAGE_ENTITIES to constants.py
Note: the value has been found by experimentation as opposed to extracted from the api docs.
* Add tests for parse_entity and parse_entities
* Create a Request class which maintains its own connection pool
* When creating a Bot instance a new Request instance will be created if one wasn't supplied.
* Updater is responsible for creating a Request instance if a Bot instance wasn't provided.
* Dispatcher: add method to run async functions without decorator
* Dispatcher can now run as a singleton (allowing run_async decorator to work) as it always did and as multiple instances (where run_async decorator will raise RuntimeError)
* initial commit for conversationhandler and example
* implement simple Promise for run_async/conversationhandler
* refactor Promise._done to done
* add handling for timed out Promises
* correctly handle promises with None results
* fix handling tuple states
* update comments on example
* Added a first test on the ConversationHandler.
* Fixed a small typo.
* Yapf'd.
* add sphinx doc for conversation handler
* fix title for callbackqueryhandler sphinx docs
* Small fixes to documentation and add myself to AUTHORS.
* Rework CONTRIBUTIONS.rst
Use code-blocks instead of literals, change headings for portability and use a relative link to AUTHORS instead of linking to a specific copy.
- start the jobqueue (by default) during __init__() instead of during
put()
- protect self._next_peek and self.__tick with a Lock
- rename self._start() to self._main_loop()
- stop() is now blocking until the event loop thread exits
this test was based on timing and assumed that the JobQueue did not have
time to start processing the queue before checking the assert.
what we really should do is make sure JobQueue does not process anything
during test_bootstrap_retries_fail() there is an exception raised (by
design): TelegramError('test')
For a reason I haven't managed to pinpoint the above exception in its
precise timing caused the Updater to be left in a state which is
'self.running == False', but the dispatcher threads already initialized.
This patch identifies this extreme case and makes sure to go over the
stop procedure.
- new book keeping of dispatcher's async threads so they can be joined
when stopping
- updater, webhook & dispatcher threads are now kept on
Updater.__threads so they can be joined at the end
refs #175
I think starting and setting the webhook should be two different tasks.
Because the internal webhook and the adress you see from outside can be
quite diffrent through apache etc. It provides more flexibility.
I saw in the TODO list on pypi that you wanted a commandhandler.
I am not sure about the run and run_once commands.
and I didn't implement logging yet.
and decorators to add command to the bot the flask routing style, e.g:
>>> @bot.command('/start')
... def start(command, user_id):
... return ('Hello, there', None, None)
Every open source project lives from the generous help by contributors that sacrifice their time and ``python-telegram-bot`` is no different. To make participation as pleasant as possible, this project adheres to the `Code of Conduct`_ by the Python Software Foundation.
Setting things up
-------------------
1. Fork the ``python-telegram-bot`` repository to your GitHub account.
2. Clone your forked repository of ``python-telegram-bot`` to your computer:
If you already know what you'd like to work on, you can skip this section.
If you have an idea for something to do, first check if it's already been filed on the `issue tracker`_. If so, add a comment to the issue saying you'd like to work on it, and we'll help you get started! Otherwise, please file a new issue and assign yourself to it.
Another great way to start contributing is by writing tests. Tests are really important because they help prevent developers from accidentally breaking existing code, allowing them to build cool things faster. If you're interested in helping out, let the development team know by posting to the `developers' mailing list`_, and we'll help you get started.
Instructions for making a code change
####################
The central development branch is ``master``, which should be clean and ready for release at any time. In general, all changes should be done as feature branches based off of ``master``.
Here's how to make a one-off code change.
1.**Choose a descriptive branch name.** It should be lowercase, hyphen-separated, and a noun describing the change (so, ``fuzzy-rules``, but not ``implement-fuzzy-rules``). Also, it shouldn't start with ``hotfix`` or ``release``.
2.**Create a new branch with this name, starting from**``master``. In other words, run:
.. code-block:: bash
$ git fetch upstream
$ git checkout master
$ git merge upstream/master
$ git checkout -b your-branch-name
3.**Make a commit to your feature branch**. Each commit should be self-contained and have a descriptive commit message that helps other developers understand why the changes were made.
- You can refer to relevant issues in the commit message by writing, e.g., "#105".
- Your code should adhere to the `PEP 8 Style Guide`_, with the exception that we have a maximum line length of 99.
- For consistency, please conform to `Google Python Style Guide`_ and `Google Python Style Docstrings`_. In addition, code should be formatted consistently with other code around it.
- The following exceptions to the above (Google's) style guides applies:
- Documenting types of global variables and complex types of class members can be done using the Sphinx docstring convention.
- Please ensure that the code you write is well-tested.
- Don’t break backward compatibility.
- Add yourself to the AUTHORS.rst_ file in an alphabetical fashion.
- Before making a commit ensure that all automated tests still pass:
.. code-block::
$ make test
- To actually make the commit (this will trigger tests for yapf, lint and pep8 automatically):
.. code-block:: bash
$ git add your-file-changed.py
- yapf may change code formatting, make sure to re-add them to your commit.
.. code-block:: bash
$ git commit -a -m "your-commit-message-here"
- Finally, push it to your GitHub fork, run:
.. code-block:: bash
$ git push origin your-branch-name
4.**When your feature is ready to merge, create a pull request.**
- Go to your fork on GitHub, select your branch from the dropdown menu, and click "New pull request".
- Add a descriptive comment explaining the purpose of the branch (e.g. "Add the new API feature to create inline bot queries."). This will tell the reviewer what the purpose of the branch is.
- Click "Create pull request". An admin will assign a reviewer to your commit.
5.**Address review comments until all reviewers give LGTM ('looks good to me').**
- When your reviewer has reviewed the code, you'll get an email. You'll need to respond in two ways:
- Make a new commit addressing the comments you agree with, and push it to the same branch. Ideally, the commit message would explain what the commit does (e.g. "Fix lint error"), but if there are lots of disparate review comments, it's fine to refer to the original commit message and add something like "(address review comments)".
- In addition, please reply to each comment. Each reply should be either "Done" or a response explaining why the corresponding suggestion wasn't implemented. All comments must be resolved before LGTM can be given.
- Resolve any merge conflicts that arise. To resolve conflicts between 'your-branch-name' (in your fork) and 'master' (in the ``python-telegram-bot`` repository), run:
.. code-block:: bash
$ git checkout your-branch-name
$ git fetch upstream
$ git merge upstream/master
$ ...[fix the conflicts]...
$ ...[make sure the tests pass before committing]...
$ git commit -a
$ git push origin your-branch-name
- At the end, the reviewer will merge the pull request.
6.**Tidy up!** Delete the feature branch from both your local clone and the GitHub repository:
.. code-block:: bash
$ git branch -D your-branch-name
$ git push origin --delete your-branch-name
7.**Celebrate.** Congratulations, you have contributed to ``python-telegram-bot``!
Style commandments
---------------------
Specific commandments
#####################
- Avoid using "double quotes" where you can reasonably use 'single quotes'.
AssertEqual argument order
######################
- assertEqual method's arguments should be in ('actual', 'expected') order.
Properly calling callables
#######################
Methods, functions and classes can specify optional parameters (with default
values) using Python's keyword arg syntax. When providing a value to such a
callable we prefer that the call also uses keyword arg syntax. For example:
..code-block::python
# GOOD
f(0,optional=True)
# BAD
f(0,True)
This gives us the flexibility to re-order arguments and more importantly
to add new required arguments. It's also more explicit and easier to read.
Properly defining optional arguments
########################
It's always good to not initialize optional arguments at class creation,
instead use ``**kwargs`` to get them. It's well known Telegram API can
change without notice, in that case if a new argument is added it won't
break the API classes. For example:
..code-block::python
# GOOD
def__init__(self,id,name,**kwargs):
self.last_name=kwargs.get('last_name','')
# BAD
def__init__(self,id,name,last_name=''):
self.last_name=last_name
.._`Code of Conduct`: https://www.python.org/psf/codeofconduct/
- Streamlining all exceptions to ``TelegramError`` (Special thanks to @tsnoam)
- Proper locking of ``Updater`` and ``Dispatcher````start`` and ``stop`` methods
- Small bugfixes
**2015-12-29**
*Released 3.1.2*
- Fix custom path for file downloads
- Don't stop the dispatcher thread on uncaught errors in handlers
**2015-12-21**
*Released 3.1.1*
- Fix a bug where asynchronous handlers could not have additional arguments
- Add ``groups`` and ``groupdict`` as additional arguments for regex-based handlers
**2015-12-16**
*Released 3.1.0*
- The ``chat``-field in ``Message`` is now of type ``Chat``. (API update Oct 8 2015)
-``Message`` now contains the optional fields ``supergroup_chat_created``, ``migrate_to_chat_id``, ``migrate_from_chat_id`` and ``channel_chat_created``. (API update Nov 2015)
**2015-12-08**
*Released 3.0.0*
- Introducing the ``Updater`` and ``Dispatcher`` classes
**2015-11-11**
*Released 2.9.2*
- Error handling on request timeouts has been improved
**2015-11-10**
*Released 2.9.1*
- Add parameter ``network_delay`` to Bot.getUpdates for slow connections
**2015-11-10**
*Released 2.9*
- Emoji class now uses ``bytes_to_native_str`` from ``future`` 3rd party lib
- Make ``user_from`` optional to work with channels
- Raise exception if Telegram times out on long-polling
*Special thanks to @jh0ker for all hard work*
**2015-10-08**
*Released 2.8.7*
- Type as optional for ``GroupChat`` class
**2015-10-08**
*Released 2.8.6*
- Adds type to ``User`` and ``GroupChat`` classes (pre-release Telegram feature)
**2015-09-24**
*Released 2.8.5*
- Handles HTTP Bad Gateway (503) errors on request
- Fixes regression on ``Audio`` and ``Document`` for unicode fields
**2015-09-20**
*Released 2.8.4*
-``getFile`` and ``File.download`` is now fully supported
**2015-09-10**
*Released 2.8.3*
- Moved ``Bot._requestURL`` to its own class (``telegram.utils.request``)
- Much better, such wow, Telegram Objects tests
- Add consistency for ``str`` properties on Telegram Objects
- Better design to test if ``chat_id`` is invalid
- Add ability to set custom filename on ``Bot.sendDocument(..,filename='')``
- Fix Sticker as ``InputFile``
- Send JSON requests over urlencoded post data
- Markdown support for ``Bot.sendMessage(..., parse_mode=ParseMode.MARKDOWN)``
- Refactor of ``TelegramError`` class (no more handling ``IOError`` or ``URLError``)
**2015-09-05**
*Released 2.8.2*
- Fix regression on Telegram ReplyMarkup
- Add certificate to ``is_inputfile`` method
**2015-09-05**
*Released 2.8.1*
- Fix regression on Telegram objects with thumb properties
**2015-09-04**
*Released 2.8*
- TelegramError when ``chat_id`` is empty for send* methods
-``setWebhook`` now supports sending self-signed certificate
- Huge redesign of existing Telegram classes
- Added support for PyPy
- Added docstring for existing classes
**2015-08-19**
*Released 2.7.1*
- Fixed JSON serialization for ``message``
**2015-08-17**
*Released 2.7*
- Added support for ``Voice`` object and ``sendVoice`` method
- Due backward compatibility performer or/and title will be required for ``sendAudio``
- Fixed JSON serialization when forwarded message
**2015-08-15**
*Released 2.6.1*
- Fixed parsing image header issue on < Python 2.7.3
**2015-08-14**
*Released 2.6.0*
- Depreciation of ``require_authentication`` and ``clearCredentials`` methods
- Giving ``AUTHORS`` the proper credits for their contribution for this project
-``Message.date`` and ``Message.forward_date`` are now ``datetime`` objects
**2015-08-12**
*Released 2.5.3*
-``telegram.Bot`` now supports to be unpickled
**2015-08-11**
*Released 2.5.2*
- New changes from Telegram Bot API have been applied
-``telegram.Bot`` now supports to be pickled
- Return empty ``str`` instead ``None`` when ``message.text`` is empty
**2015-08-10**
*Released 2.5.1*
- Moved from GPLv2 to LGPLv3
**2015-08-09**
*Released 2.5*
- Fixes logging calls in API
**2015-08-08**
*Released 2.4*
- Fixes ``Emoji`` class for Python 3
-``PEP8`` improvements
**2015-08-08**
*Released 2.3*
- Fixes ``ForceReply`` class
- Remove ``logging.basicConfig`` from library
**2015-07-25**
*Released 2.2*
- Allows ``debug=True`` when initializing ``telegram.Bot``
**2015-07-20**
*Released 2.1*
- Fix ``to_dict`` for ``Document`` and ``Video``
**2015-07-19**
*Released 2.0*
- Fixes bugs
- Improves ``__str__`` over ``to_json()``
- Creates abstract class ``TelegramObject``
**2015-07-15**
*Released 1.9*
- Python 3 officially supported
-``PEP8`` improvements
**2015-07-12**
*Released 1.8*
- Fixes crash when replying an unicode text message (special thanks to JRoot3D)
**2015-07-11**
*Released 1.7*
- Fixes crash when ``username`` is not defined on ``chat`` (special thanks to JRoot3D)
**2015-07-10**
*Released 1.6*
- Improvements for GAE support
**2015-07-10**
*Released 1.5*
- Fixes randomly unicode issues when using ``InputFile``
**2015-07-10**
*Released 1.4*
-``requests`` lib is no longer required
- Google App Engine (GAE) is supported
**2015-07-10**
*Released 1.3*
- Added support to ``setWebhook`` (special thanks to macrojames)
This library provides a pure Python interface for the
`Telegram Bot API <https://core.telegram.org/bots/api>`_.
It's compatible with Python versions 2.7, 3.3+ and `PyPy <http://pypy.org/>`_.
It also works with `Google App Engine <https://cloud.google.com/appengine>`_.
===============
_`Introduction`
===============
In addition to the pure API implementation, this library features a number of high-level classes to
make the development of bots easy and straightforward. These classes are contained in the
``telegram.ext`` submodule.
This library provides a pure Python interface for the `Telegram Bot API <https://core.telegram.org/bots/api>`_. It works with Python versions from 2.6+. It also works with `Google App Engine <https://cloud.google.com/appengine>`_.
====================
Telegram API support
====================
=========
_`Status`
=========
As of **28. May 2016**, all types and methods of the Telegram Bot API are supported.
-----------------------
_`Telegram API support`
-----------------------
==========
Installing
==========
========================= ============
Telegram Bot API Method *Supported?*
========================= ============
getMe Yes
sendMessage Yes
forwardMessage Yes
sendPhoto Yes
sendAudio Yes
sendDocument Yes
sendSticker Yes
sendVideo Yes
sendLocation Yes
sendChatAction Yes
getUpdates Yes
getUserProfilePhotos Yes
setWebhook Yes
========================= ============
You can install or upgrade python-telegram-bot with:
-------------------------
_`Python Version support`
-------------------------
============== ============
Python Version *Supported?*
============== ============
2.6 Yes
2.7 Yes
3.3 Yes
3.4 Yes
============== ============
=============
_`Installing`
=============
You can install python-telegram-bot using::
$ pip install python-telegram-bot
Or upgrade to the latest version::
..code::shell
$ pip install python-telegram-bot --upgrade
===================
_`Getting the code`
===================
Or you can install from source with:
The code is hosted at https://github.com/leandrotoledo/python-telegram-bot
..code::shell
Check out the latest development version anonymously with::
View the last release API documentation at: https://core.telegram.org/bots/api
We believe that the best way to learn and understand this simple package is by example. So here
are some examples for you to review. Even if it's not your approach for learning, please take a
look at ``echobot2``, it is de facto the base for most of the bots out there. Best of all,
the code for these examples are released to the public domain, so you can start by grabbing the
code and building on top of it.
------
_`API`
------
Visit `this page <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/README.md>`_ to discover the official examples or look at the examples on the `wiki <https://github.com/python-telegram-bot/python-telegram-bot/wiki/Examples>`_ to see other bots the community has built.
The API is exposed via the ``telegram.Bot`` class.
-------
Logging
-------
To generate an Access Token you have to talk to `BotFather <https://telegram.me/botfather>`_and follow a few simple steps (described `here <https://core.telegram.org/bots#botfather>`_).
This library uses the ``logging``module. To set up logging to standard output, put:
For full details see the `Bots: An introduction for developers <https://core.telegram.org/bots>`_.
Bots can't initiate conversations with users. A user must either add them to a group or send them a message first. People can use ``telegram.me/<bot_username>`` links or username search to find your bot.
logger=logging.getLogger()
logger.setLevel(logging.INFO)
To fetch text messages sent to your Bot::
If you want DEBUG logs instead:
>>> updates = bot.getUpdates()
>>> print [u.message.text for u in updates]
..code::python
To fetch images sent to your Bot::
logger.setLevel(logging.DEBUG)
>>> updates = bot.getUpdates()
>>> print [u.message.photo for u in updates if u.message.photo]
To reply messages you'll always need the chat_id::
4. As last resort, the developers are ready to help you with `serious issues <https://github.com/python-telegram-bot/python-telegram-bot/issues/new>`_.
There are many more API methods, to read the full API documentation::
$ pydoc telegram.Bot
-----------
_`Logging`
-----------
You can get logs in your main application by calling `logging` and setting the log level you want::
>>> import logging
>>> logger = logging.getLogger()
>>> logger.setLevel(logging.INFO)
If you want DEBUG logs instead::
>>> logger.setLevel(logging.DEBUG)
-----------
_`Examples`
-----------
Here follows some examples to help you to get your own Bot up to speed:
-`echobot <https://github.com/leandrotoledo/python-telegram-bot/blob/master/examples/echobot.py>`_ replies back messages.
-`roboed <https://github.com/leandrotoledo/python-telegram-bot/blob/master/examples/roboed.py>`_ talks to `Robô Ed <http://www.ed.conpet.gov.br/br/converse.php>`_.
-`Simple-Echo-Telegram-Bot <https://github.com/sooyhwang/Simple-Echo-Telegram-Bot>`_ simple Python Telegram bot that echoes your input with Flask microframework, setWebhook method, and Google App Engine (optional) - by @sooyhwang.
-`DevOps Reaction Bot <https://github.com/leandrotoledo/gae-devops-reaction-telegram-bot>`_ sends latest or random posts from `DevOps Reaction <http://devopsreactions.tumblr.com/>`_. Running on `Google App Engine <https://cloud.google.com/appengine>`_ (billing has to be enabled for fully Socket API support).
==========
_`License`
==========
You may copy, distribute and modify the software provided that modifications are described and licensed for free under `LGPL-3 <http://www.gnu.org/licenses/lgpl-3.0.html>`_. Derivatives works (including modifications or anything statically linked to the library) can only be redistributed under `LGPL-3 <http://www.gnu.org/licenses/lgpl-3.0.html>`_, but applications that use the library don't have to be.
==========
_`Contact`
==========
Feel free to join to our `Telegram group <https://telegram.me/joinchat/00b9c0f802509b949c1563d56eb053b0>`_.
Contributions of all sizes are welcome. Please review our `contribution guidelines <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/.github/CONTRIBUTING.rst>`_ to get started. You can also help by `reporting bugs <https://github.com/python-telegram-bot/python-telegram-bot/issues/new>`_.
=======
_`TODO`
License
=======
Patches and bug reports are `welcome <https://github.com/leandrotoledo/python-telegram-bot/issues/new>`_, just please keep the style consistent with the original source.
- Add commands handler.
You may copy, distribute and modify the software provided that modifications are described and licensed for free under `LGPL-3 <https://www.gnu.org/licenses/lgpl-3.0.html>`_. Derivatives works (including modifications or anything statically linked to the library) can only be redistributed under LGPL-3, but applications that use the library don't have to be.
$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
The examples in this folder are small bots meant to show you how a bot that is written with `python-telegram-bot` looks like. Some bots focus on one specific aspect of the Telegram Bot API while others focus on one of the mechanics of this library. Except for the `echobot.py` example, they all use the high-level framework this library provides with the `telegram.ext` submodule.
All examples are licensed under the [CC0 License](https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/LICENSE.txt) and are therefore fully dedicated to the public domain. You can use them as the base for your own bots without worrying about copyrights.
This is probably the base for most of the bots made with `python-telegram-bot`. It simply replies to each text message with a message that contains the same text.
This bot uses the [`JobQueue`](https://pythonhosted.org/python-telegram-bot/telegram.ext.jobqueue.html) class to send timed messages. The user sets a timer by using `/set` command with a specific time, for example `/set 30`. The bot then sets up a job to send a message to that user after 30 seconds. The user can also cancel the timer by sending `/unset`. To learn more about the `JobQueue`, read [this wiki article](https://github.com/python-telegram-bot/python-telegram-bot/wiki/Extensions-%E2%80%93-JobQueue).
A common task for a bot is to ask information from the user. In v5.0 of this library, we introduced the [`ConversationHandler`](https://pythonhosted.org/python-telegram-bot/telegram.ext.conversationhandler.html) for that exact purpose. This example uses it to retrieve user-information in a conversation-like style.
A basic example of an [inline bot](https://core.telegram.org/bots/inline). Don't forget to enable inline mode with [@BotFather](https://telegram.me/BotFather).
## Pure API
The [`echobot.py`](https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/echobot.py) example uses only the pure, "bare-metal" API wrapper.
# A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2016
# Leandro Toledo de Souza <devs@python-telegram-bot.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser Public License for more details.
#
# You should have received a copy of the GNU Lesser Public License
# along with this program. If not, see [http://www.gnu.org/licenses/].
"""Base class for Telegram Objects."""
"""
A library that provides a Python interface to the Telegram Bot API
Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
try:
importujsonasjson
exceptImportError:
importjson
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser Public License for more details.
You should have received a copy of the GNU Lesser Public License
along with this program. If not, see [http://www.gnu.org/licenses/].
"""
importjson
fromabcimportABCMeta,abstractmethod
fromabcimportABCMeta
classTelegramObject(object):
"""Base class for most telegram object"""
"""Base class for most telegram objects."""
__metaclass__=ABCMeta
@@ -35,12 +38,45 @@ class TelegramObject(object):
returnself.__dict__[item]
@staticmethod
defde_json(data):
raiseNotImplementedError
defde_json(data,bot):
"""
Args:
data (dict):
bot (telegram.Bot):
Returns:
dict:
"""
ifnotdata:
returnNone
data=data.copy()
returndata
defto_json(self):
"""
Returns:
str:
"""
returnjson.dumps(self.to_dict())
@abstractmethod
defto_dict(self):
return
"""
Returns:
dict:
"""
data=dict()
forkeyiniter(self.__dict__):
ifkey=='bot':
continue
value=self.__dict__[key]
ifvalueisnotNone:
ifhasattr(value,'to_dict'):
data[key]=value.to_dict()
else:
data[key]=value
returndata
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Jannes Höke