Official Kodi Wiki - User contributions [en]

General information about migration to Python 3

2024-08-02T22:20:55Z

Fourpointsix: Updated to reflect sunsetting of Python 2

== Overview ==
Python 3 was first released in 2008, and the last release of Python 2.7 was in 2020. Thanks to a successful [[Archive:Google Summer of Code/2017|Google Summer of Code 2017 project]], Kodi 19.x (Matrix) became the first release to support Python 3.

Since Python 3.x versions are not backward-compatible with Python 2.x, we decided to urge addon developers prior to the 19.x release to port their addons to Python 3 by making the addons compatible with both Python 2 and 3 and submitting them to the official repo. That way, when 19.x was to be released we wouldn't have a situation with no working addons. Looking back, the transition was rather successful.

Over seven years have since passed and the last release supporting Python 2, 18.x (Leia), has aged out of support. As a result, Python 3 is the only supported addon environment.

This article is for any addon developers who have not yet ported their old addons from Python 2.

== The Process ==
* For Kodi 19.x (Matrix) and up, only addons that are compatible with Python 3 will be accepted to the official addon repository.
* There's a thread on the Kodi forum so that addon devs can get help with their migration process.

== Python 2 And 3 Differences ==
Below is a brief overview of the main differences between Python 3 and 2.

=== Unicode strings by default ===
:{{See also|Unicode Concerns}}
In Python 2, the built-in '''<tt>str</tt>''' type holds the sequence of bytes so it can be used to store both binary data and textual data in ASCII or any of a long list of 8-bit fixed-length encodings. Python 2 also has the '''<tt>unicode</tt>''' type that can store text in various writing systems. The fundamental atomic unit of a <tt>unicode</tt> object is a Unicode codepoint (a writing system character). Both <tt>str</tt> and <tt>unicode</tt> objects can be mixed and matched together (e.g. concatenated using the <code>+</code> operator).

In Python 3, the '''<tt>str</tt>''' type holds Unicode characters, and for binary data a new '''<tt>bytes</tt>''' type was added. This type was also added to Python 2.7 to simplify porting to Python 3, but in Python 2.7 <tt>bytes</tt> is simply an alias for <tt>str</tt>. The <tt>str</tt> and <tt>bytes</tt> types are incompatible, and an attempt to use both together will result in a <tt>TypeError</tt> exception. A <tt>bytes</tt> object can be converted to a <tt>str</tt> using the <code>.decode()</code> method, and conversely a <tt>str</tt> object is converted to <tt>bytes</tt> using the <code>.encode()</code> method.

=== Absolute Import ===
Python 3 uses so called “absolute import” and you can no longer import neighbor modules from inside a package using only a module name. You need to either to use either a fully qualified name or a “dotted” notation.

Let’s assume that you have a <code>foo</code> package that contains <code>bar</code> and <code>spam</code> modules:
<pre>
foo/
__init__.py
bar.py
spam.py
</pre>
And you need to import <code>bar</code> module from <code>spam</code>. In Python 2 you can do:
<syntaxhighlight lang="python">
import bar
</syntaxhighlight>

But in Python 3 you need to use either

<syntaxhighlight lang="python">
import foo.bar
</syntaxhighlight>

or

<syntaxhighlight lang="python">
from . import bar
</syntaxhighlight>

=== Floating Point Division ===
In Python 2 applying division operator to int numbers produces int result. For example:

<syntaxhighlight lang="python">
>>> 4 / 3
1
</syntaxhighlight>

In Python 3 division operator always gives you a float result.

<syntaxhighlight lang="python">
>>> 4/3
1.3333333333333333
</syntaxhighlight>

To get an int result you need to use integer division operator:

<syntaxhighlight lang="python">
>>> 4 // 3
1
</syntaxhighlight>

=== Print Function ===
In Python 3 print statement has been replaced with print() function. This is not very relevant to Kodi because using print in Python addons is discouraged and xbmc.log() function should be used to write messages to the Kodi log.

=== Default Iterators ===
In Python 3 most function and methods that produce sequences return iterators instead of lists. For example, range() function and .items(), .keys(), .values() of dict type produce iterators instead of lists, and their Python 2 analogues — xrange() function and .iter* methods of dict type — have been removed.

=== No long Integers ===
In Python 3 long integer type has been removed and int type can now hold a number of arbitrary length.

Those are only some of the differences between Python 2 and 3. For a more complete list see [https://docs.python.org/3.6/whatsnew/3.0.html official Python documentation].

== Some Useful Information ==
As it was said above, Python 3 includes a number of incompatible changes, so to avoid situation when after upgrading Kodi for Python 3 support most Python addons will be broken developers should start to port their addons to be compatible with both Python 2 and 3. This is not a trivial task but fortunately there are a number of tools and recommendations to simplify this process. Here I’ll give you some advice and information about tools that will simplify creating portable code that runs on both Python 2 and 3.

=== Know Your Strings! ===
This is the most problematic part of porting Python 2 code to Python 3 so I put it first. One of the most notable differences between Python 2 and 3 is clear separation between “textual” and “binary” strings, that is, between textual data and their binary representation. This difference is often difficult to understand, especially for novice developers (not only in Python), and the fact that in Python 2 you can mix together str (binary data) and unicode (textual data) adds to that difficulty.

There are many explanations in the Internet, but here are the most basic things about strings that you need to know:

“Textual” or Unicode strings (unicode in Python 2 and str in Python 3) hold text as a sequence of characters. A minimal unit in such strings is a Unicode character — an abstract entity that represent an alphabet symbol, a punctuation sign or other symbol included in the Unicode character table. Of course, such symbols have concrete internal binary representation (a computer is a binary machine after all), but this representation is not relevant to us. All you need to know is that “textual” strings contain text units without being tied to concrete binary representation.

Unlike Unicode strings, binary strings (str in Python 2 and bytes in both Python 2 and 3) hold binary data, and a minimal unit of such strings is a byte or 8 bits. Historically, in Python 2 such strings are used for textual data encoded in ASCII or other 1-byte fixed-length encoding (e.g. Windows 1251 for Cyrillic alphabets). However, this approach has its limitation, that is why unicode type was introduced in Python 2, and in Python 3 it was renamed to str and made a default container for textual data.

Unfortunately, Python 2 allows to mix and match Unicode and binary strings in the same context and this creates big problems when porting Python 2 code to Python 3. So in order to successfully port your code to Python 3 you need to carefully consider how textual data are processed in your addon. The following recommendations will help you avoid problems when writing Python 2/3 compatible code.

=== Avoid using binary strings for text ===
Store all your text as Unicode strings. This means that all binary strings received from external sources (textual files, websites, various APIs) need to be decoded using appropriate encoding (UTF-8 in most cases). If you need to use strings literals (although using hardcoded strings for user-facing text in Kodi is strongly discouraged), they need to be defined as unicode strings as well. You can use either
<syntaxhighlight lang="python">
from __future__ import unicode_literals
</syntaxhighlight>
at the beginning of your modules to enable unicode strings by default as in Python 3 or u-strings, e.g. <code>u'foo'</code> (Python 3 understands them too) — it doesn't really matter as long as you are doing it consistently.

=== Know the libraries you are using ===
Working with Python Standard Library and third-party libraries (including Kodi Python API) you should know that types their functions and methods expect and what types they return. For example, in popular requests library Response.text property returns a Unicode string and Response.content returns a binary string.

If a function/method/property returns a binary string, you need to decode it to a Unicode string using .decode() method. Don’t use unicode class constructor because unicode type does not exist in Python 3.

If you are reading textual files from disk, it is better to use io.open() instead of built-in open(). io.open() can decode file contents to Unicode using specified encoding and works identically both in Python 2 and 3. Example:
<syntaxhighlight lang="python">
import io

with io.open('foo.txt', 'r', encoding='utf-8') as fo:
text = fo.read()
</syntaxhighlight>

=== Potential pitfalls ===
When writing Python 3-compatible code or converting existing Python 2 codebase to compatible code you should pay attention to the following Python language constructions where TypeError exceptions may happen because of incompatible string types if you don’t get your strings in order:

* String concatenations with + operator (<code>'foo' + 'bar'</code>).
* String formatting — both “old style” (<code>'foo %s' % 'bar'</code>) and “new style” (<code>'foo {}'.format('bar')</code>).
* String joining (<code>', '.join(['foo', 'bar'])</code>).

In all those cases always make sure that you work with Unicode strings only.
Another source of subtle bugs is functions and methods that accept and return binary strings (str type) in Python 2 but Unicode strings in Python 3 (again, str type but with different properties). You can use the following utility functions to “normalize” strings that are provided to such functions/methods and received from them:

<syntaxhighlight lang="python">
import sys

__all__ = ['PY2', 'py2_encode', 'py2_decode']

PY2 = sys.version_info[0] == 2

def py2_encode(s, encoding='utf-8'):
"""
Encode Python 2 ``unicode`` to ``str``

In Python 3 the string is not changed.
"""
if PY2 and isinstance(s, unicode):
s = s.encode(encoding)
return s

def py2_decode(s, encoding='utf-8'):
"""
Decode Python 2 ``str`` to ``unicode``

In Python 3 the string is not changed.
"""
if PY2 and isinstance(s, str):
s = s.decode(encoding)
return s
</syntaxhighlight>

Those utility functions are included in Kodi Six library that is described in the following section.

== Helper Libraries and Tools ==
=== 2to3 ===
[https://docs.python.org/2/library/2to3.html 2to3] script is created by Python developers to help converting existing Python 2 code to Python 3. On Windows it is included in Python distribution (Tools subfolder) but on other OSes you man need to install it separately. For example, on Ubuntu it is included in python-examples package. Note that this script is created for conversion from Python 2 to 3, not for writing portable code, so you need to treat its output with care.

=== Modernize ===
https://python-modernize.readthedocs.io/en/latest/ Modernize] script works on top of 2to3 and is supposed to help you to convert your existing Python 2 code to Python 2/3-compatible. However, in my experiments it did not work reliably even in simple cases so I cannot recommend it for usage.

=== Six ===
[https://pythonhosted.org/six/ Six] was the first library developed to simplify Python 2 to 3 migration. It provides a set of wrappers that hide differences between Python 2 and 3 behind its API. It is less intrusive than the following alternative because it does not monkey-patch built-in names, but in order to use Six library effectively you need to learn its API. Six can be used both for writing new Python 2/3-compatible addons and converting existing ones, but it requires good knowledge of Python 2/3 differences to pick necessary Six features that address specific differences.

Six library is included in the Kodi addon repository as '''script.module.six''' addon.

=== Future ===
[http://python-future.org/ Future] library, like Six, was created to simplify porting existing Python 2 code to 3. But it uses a different approach than Six. Future monkey-patches built-in Python objects to make Python 2 behave like Python 3. The advantage of such approach is that code written using Future is close to idiomatic Python 3 and requires little re-work if you decide to drop Python 2 support in the future. However, such approach may cause problems in some rare edge-cases.

Future library also includes <code>futurize</code> command-line utility for converting existing Python 2 code to 2/3-compatible and in my experiments this utility showed good results.
Future library (without additional utilities) is included in the Kodi addon repository as script.module.future addon.

=== Kodi Six ===
[https://github.com/romanvm/kodi.six Kodi Six] library (available as '''script.module.kodi-six''' addon) is created to normalize string handling in Kodi Python API based on different Python versions by applying wrappers around Kodi API functions and classes. In Kodi API based on Python 2 Kodi Six wrappers have the following effects:

* All functions and methods that expect string arguments can accept both UTF-8 encoded <code>str</code> objects and <code>unicode</code> objects.
* All functions and methods that return string data return <code>unicode</code> objects.

In Kodi API based on Python 3 the wrappers have no effect because Python 3-based API works only with <code>str</code> (Unicode) objects. This eliminates the need for ad hoc encoding and decoding string when working with Kodi API. To use the wrappers you need to import Kodi API <code>xbmc*</code> modules from Kodi Six instead of importing them directly:

<syntaxhighlight lang="python">
from kodi_six import xbmc, xbmcaddon, xbmcgui, xbmcplugin, xbmcvfs
</syntaxhighlight>

=== PyCharm ===
PyCharm, except for being a really good Python IDE, also provides code compatibility inspection that helps you write Python 2/3-portable code. Open '''Settings''' (Alt+F7) > '''Editor''' > '''Inspections''' > '''Python''' > '''Code compatibility inspections''' and check Python version that you want to support.

PyCharm Community Edition is free and provides all features you need for creating Python addons for Kodi.

== Writing Portable Code ==
Here I’ll give you some tips about how to write portable code:

* Learn the differences between Python 2 and 3. You need to know at least the most important differences between the two major Python versions.
* Use version control system — git or mercurial — to track changes in your code. If you are porting existing code, do it in a separate branch.
* No matter if you are going to write a brand new addon or to port existing addon to Python 3, carefully choose your tools. It is totally possible to write portable code without any helper tools and libraries, but you need to know what you are doing. However, in most cases I’d recommend you to use Future library and its utilities. Carefully read Future documentation.
* Put the following line at the beginning of all your modules:
<syntaxhighlight lang="python">
from __future__ import absolute_import, division, unicode_literals
</syntaxhighlight>
This will enable respective Python 3 features in your code. You don’t need to import print_function (another Python 3 feature) because in Kodi addons you should to use xbmc.log() to write messages to the Kodi log file.

=== Writing New Addons ===
Check the [http://python-future.org/quickstart.html#if-you-are-writing-code-from-scratch Quick Start Guide] section of Future library documentation. You can also use Six library, but, as it was said previously, you need to learn its API to pick the necessary features to address specific Python version differences, while Future allows to write your code in (almost) idiomatic Python 3.

A brief procedure for writing new Python 2/3-compatible addons with Future library:

# Create a new virtual environment with Python 3 interpreter and activate it.
# Install Future library: <code>pip install future</code>.
# Point your IDE (Integrated Development Environment) to that environment. For example, in PyCharm: '''File''' > '''Setting''' > '''Project''' > '''Project Interpreter'''.
# Put the following line at the beginning of your Python code:
<syntaxhighlight lang="python">
from __future__ import absolute_import, division, unicode_literals
from future import standard_library
from future.builtins import *
standard_library.install_aliases()
</syntaxhighlight>
Write your addon using Python 3 syntax and standard library names. However, you may still need to use wrappers from Future library for some specific cases (e.g. iterators over <code>dict</code> elements). Read Future docs for more info.

=== Porting Existing Addons ===
A brief procedure for porting existing code to Python 3-compatible with Future library:
# Install Future library into your working Python 2 virtual environment: <code>pip install future</code>.
# Run <code>futurize</code> utility to convert all your scripts and modules to portable code.

Test your new or converted addon in Kodi with Python 2 interpreter and fix all found issues. After that test the addon in Kodi with Python 3 interpreter and again fix all found issues.
You can use [https://github.com/romanvm/kodi.web-pdb Web-PDB] debugger for troubleshooting issues in your code. It is compatible with both Python 2 and 3.

== Links ==
* Python 2 and 3 differences: https://docs.python.org/3.6/whatsnew/3.0.html
* Future library documentation: http://python-future.org/
* Six library documentation: https://pythonhosted.org/six/
* Kodi test builds with Python 3 for Windows: http://mirrors.xbmc.org/test-builds/windows/win32/
* Kodi test builds with Python 3 for Linux Ubuntu: https://launchpad.net/~wsnipex/+archive/ubuntu/kodi-python3/+packages
* “Python 3 migration” section on the Kodi official forum: https://forum.kodi.tv/forumdisplay.php?fid=281

[[Category:Development]]
[[Category:Python]]

Migration to Python 3

2024-08-02T20:44:39Z

Fourpointsix: Updated to reflect sunsetting of Python 2

After a successful GSOC 2017 project that brought Python 3 (3.6 exactly) to Kodi it was decided that Kodi 19.x Matrix would switch to Python 3 as an environment for running Python addons. Enough time has now passed that the last Python 2 release, Leia, has aged out of support. Therefore, all addon contributions must be Python 3-compatible.

Since Python 3 is not backward compatible with 2.x versions, developers of older addons must convert their addons to be Python 3-compatible so that their addons will continue to run on current and future Kodi versions. This page contains information that should help addon developers in this conversion process.

* [[General information about migration to Python 3]]
* [https://forum.kodi.tv/forumdisplay.php?fid=281 Python 3 migration section on the Kodi forum]
* [https://kodi.tv/article/the-sun-sets-on-python-2/ The Sun Sets on Python 2]

[[Category:Development]]

Submitting Add-ons

2024-08-02T20:31:07Z

Fourpointsix: Added Omega and Piers, removed update support for Leia and older. Unsure of skin repo requirements, so left those for others to update.

{{mininav|[[Development]]|[[Add-on development]]}}

=== Submitting a Compliant Add-on to the Kodi.tv Repo ===

After you have read the [[Add-on rules|repository guidelines]] and made sure your addon is compliant with them, you may begin the submission process using the following steps.

=== Allowed submissions ===

We have restricted the allowed submissions of add-ons to past Kodi versions.
Several reasons:
* Kodi code improvements
* Reduce support load for add-on developers
* Reduce workload for repository maintainers

Below is a table of on which submissions are allowed to official Kodi repository.

{| class="prettytable" border="1"
|+ Allowed add-on submissions
! codename !! version !! update !! new
|-
| Dharma || 10.x || no || no
|-
| Eden || 11.x || no || no
|-
| Frodo || 12.x || no || no
|-
| Gotham || 13.x || no || no
|-
| Helix || 14.x || no || no
|-
| Isengard || 15.x || no || no
|-
| Jarvis || 16.x || no || no
|-
| Krypton || 17.x || no || no
|-
| Leia || 18.x || no || no
|-
| Matrix || 19.x || yes || yes
|-
| Nexus || 20.x || yes || yes
|-
| Omega || 21.x || yes || yes
|-
| Piers || 22.x || yes || yes
|}

An additional feature is that we use combined repositories. So if your add-on is Matrix/Nexus/Omega compatible, you only need to send it to the Matrix repository.
If it's only Omega+ compatible you need to send it to the Omega repository.
This of course requires that the minimal Kodi dependencies are set accordingly.

Note that as of [https://kodi.tv/article/the-sun-sets-on-python-2/ April 2024], only Python 3 add-ons are accepted since the last Python 2 release, Leia, is out of support. Contributions to the Leia and older repositories will no longer be accepted.

{| class="prettytable" border="1"
|+ Which repos are used for Python add-ons (scripts, scrapers and plugins)
! codename !! version !! repos !!colspan="9"| repo
|-
| Dharma || 10.x || Dharma
|-
| Eden || 11.x || Eden
|-
| Frodo || 12.x || Frodo
|-
| Gotham || 13.x || Gotham
|-
| Helix || 14.x || Gotham || Helix
|-
| Isengard || 15.x || Gotham || Helix || Isengard
|-
| Jarvis || 16.x || Gotham || Helix || Isengard || Jarvis
|-
| Krypton || 17.x || Gotham || Helix || Isengard || Jarvis || Krypton
|-
| Leia || 18.x || Gotham || Helix || Isengard || Jarvis || Krypton || Leia
|-
| Matrix|| 19.x || - || - || - || - || - || - || Matrix
|-
| Nexus|| 20.x || - || - || - || - || - || - || Matrix || Nexus
|-
| Omega|| 21.x || - || - || - || - || - || - || Matrix || Nexus || Omega
|-
| Piers|| 22.x || - || - || - || - || - || - || Matrix || Nexus || Omega || Piers
|}

{| class="prettytable" border="1"
|+ Which repos are used for skins
! codename !! version !! repos !!colspan="8"| repo
|-
| Dharma || 10.x || Dharma
|-
| Eden || 11.x || Eden
|-
| Frodo || 12.x || Frodo
|-
| Gotham || 13.x || Gotham
|-
| Helix || 14.x || Gotham || Helix
|-
| Isengard || 15.x || || || Isengard
|-
| Jarvis || 16.x || || || || Jarvis
|-
| Krypton || 17.x || || || || || Krypton
|-
| Leia || 18.x || || || || || || Leia
|-
| Matrix|| 19.x || || || || || || || Matrix
|-
| Nexus|| 20.x || || || || || || || Matrix || Nexus
|}

{| class="prettytable" border="1"
|+ Which repos are used for other add-ons
! codename !! version !! repos !!colspan="9"| repo
|-
| Dharma || 10.x || Dharma
|-
| Eden || 11.x || Eden
|-
| Frodo || 12.x || Frodo
|-
| Gotham || 13.x || Gotham
|-
| Helix || 14.x || Gotham || Helix
|-
| Isengard || 15.x || Gotham || Helix || Isengard
|-
| Jarvis || 16.x || Gotham || Helix || Isengard || Jarvis
|-
| Krypton || 17.x || Gotham || Helix || Isengard || Jarvis || Krypton
|-
| Leia || 18.x || Gotham || Helix || Isengard || Jarvis || Krypton || Leia
|-
| Matrix || 19.x || Gotham || Helix || Isengard || Jarvis || Krypton || Leia || Matrix
|-
| Nexus || 20.x || Gotham || Helix || Isengard || Jarvis || Krypton || Leia || Matrix || Nexus
|-
| Omega || 21.x || Gotham || Helix || Isengard || Jarvis || Krypton || Leia || Matrix || Nexus || Omega
|-
| Piers || 22.x || Gotham || Helix || Isengard || Jarvis || Krypton || Leia || Matrix || Nexus || Omega || Piers
|}

{{see also|Addon.xml#Dependency_versions}}

=== Github ===

==== Pull requests ====
New add-ons or updates may be submitted directly to the [[Official add-on repository]] on Github as pull requests. We are aware that this requires some initial git knowledge and we strongly suggest to read up on this subject before submitting a pull request.

To reduce size we have split up the git repositories in several locations. Please visit [[Official add-on repository]] to see where they are. Each contains a small readme with a short description of it's contents as well as a link to a short explanation on how to submit using git command line. There are also git tools available that have a graphic interface and the steps above should be done in a similar way. Please consult the manual of those programs.

In addition to the [[Add-on rules|repository guidelines]] the following rules apply when submitting PRs on Github:

* PR should contain one commit only.
* Commit message should have the format "[addonid] version". Example: "[my.cool.addon] 1.0.1"

If Team Kodi reviewers asked you to make some changes in your PR, follow this procedure: [[HOW-TO: Update a pull request to an official addon repository on GitHub]].

Only PRs from the add-on author or his successor will be accepted. Patches should be submitted upstream to the original author first. For an easy way to create PR from your own git repository, see [[HOW-TO: create add-on PRs using Git Subtree Merging]].

==== Issue ticket ====

'''This route is only available for skins in https://github.com/xbmc/repo-skins.
'''

For skins submissions you may also use the "issue" option where you submit a request to get you add-on added. In this ticket you need to provide the basic information needed so our repo maintainers know where to get the correct version.
This consists of
- Add-on name:
- Add-on ID:
- Version number:
- Kodi/repository version:
- Code location URL:
- Revision/tag:
- Branch:

Further information is provide when you initially create the issue on github as comments in the ticket.
Same [[Add-on rules|repository guidelines]] apply here as well.

==== How to submit your add-on and subsequent updates ====
Submitting updates is done the same way as with pull requests or issue ticket.

==== Repository lists ====
You can create pull requests or tickets on the following individual repositories.

https://github.com/xbmc/repo-plugins
https://github.com/xbmc/repo-resources
https://github.com/xbmc/repo-scrapers
https://github.com/xbmc/repo-scripts
https://github.com/xbmc/repo-skins
https://github.com/xbmc/repo-webinterfaces

=== Additional information ===
Note that skin .xbt files will be generated automatically for skins so you do not include this in your pull request or created tickets.
After the add-on has been added or updated it will be available from the Kodi repository in Kodi itself, on http://addons.kodi.tv/ and on the wiki page http://kodi.wiki/index.php?title=Category:All_add-ons.

{{Note|Please locate you add-on in the root of the git repository. This to make sure we can easily pull the add-on into our repository.
Example: https://github.com/XBMC-Addons/service.xbmc.versioncheck}}

{{tip|We automatically combine all repos into one single repo list on our server and provide that list to Kodi. You only need to do a request for the minimum repo your add-on supports.}}

=== The mailing list ===

''' MAILINGLIST IS NOT USED ANYMORE. ALL REQUESTS SHOULD GO THROUGH GITHUB '''

[[Category:Add-on development]]

Talk:Add-on rules

2024-08-02T20:09:52Z

Fourpointsix: Added note to remove Python 2

== Page protection rationale ==
'''@[[User:Ronie|Ronie]]:''' Sorry if this comes across as being a bit of a [[wikt:Buttinsky|buttinsky]], but may I ask why you set the protection flag on this page and at such a high level, considering that it exists in the Main namespace and isn't part of <code>Official:</code> or some other more exclusive taxonomy? Honestly I'm also rather confused at why you reverted [https://kodi.wiki/index.php?title=Add-on_rules&oldid=235813 the edit] by [[User:Te36|Te36]], which was well-sourced and informative, at least to me (though I do take vehement exception to said policy as a matter of principle), seeing as I wasn't aware that anything like it was so explicitly in effect until he brought it to light. I don't mean to be sharpshooting you here, I just think that we'd all benefit from there being more of a discussion amongst editors when these instances arise, giving those of us without special powers the opportunity to learn what was being objected to and why, rather than just letting yet another wiki page stagnate as a result of hardly anyone being able to edit it and keep it reflective of changes in the status quo. That's why these Talk pages exist, right? Just my two cents... —[[User:RogueScholar|RogueScholar]] ([[User talk:RogueScholar|talk]]) 10:26, 17 October 2021 (UTC)

Hello @[[User:RogueScholar|RogueScholar]], let me respond to your points 

1. The edit by [[User:Te36|Te36]] was removed because it was not correct.

* Kodi is not against porn and we simply consider it another genre. And inline with our general ethos, we will not dictate what users can or cannot do with Kodi.
* [[User:Te36|Te36]] quoted posts from 8 years ago and taken slightly out of context. Refusing to allow a porn scraper into the Official Repository is not the same as "not supporting porn". If you browse through the forum there are plenty of adult related addons and 3rd party adult scrapers that members can use. If Kodi "does not support porn" (as stated by Te36) then these forum threads certainly would not be allowed on the forum. 
* The reason an adult scraper is not allowed in the official repo, and why existing scrapers do not automatically scrape adult titles, is to prevent younger users from "accidentally" installing the wrong scraper and to prevent a misidentified title from being scraped as an adult title and displayed with some confronting posters and fanart.
* Contrary to popular belief, Kodi scrapers ''can'' scrape adult content by using a Parsing NFO file. Using a nfo file is something done outside of Kodi (not automatically by Kodi) which shows "intent" rather than "accident". 
2. Why was the Protection Flag set? 
* The flag should have always been set. It was an oversight that it was not set.
* Rules cannot be modified by the general public. They are rules set by Kodi. Changing rules does not happen on a whim and requires a discussion and voting by the Team. 
3. The Add-on rules are in the Main namespace
* You raise a valid point. This article is an Official article and should be in the Official namespace. I will move it across.
* I guess that after 8 years, nobody really gave it any consideration, until now.

Also I have just remembered your PM. Sorry I was ill for a while and forgotten about it since. I'll respond soon.

== Remove Python 2 reference ==
To reflect the recent sunset of Python 2, I suggest this change to the Guidelines section:

* All add-ons must be compatible with Python 3. Contributions requiring Python 2 are no longer accepted. For more details see: [https://kodi.tv/article/the-sun-sets-on-python-2/ The Sun Sets on Python 2]
[[User:Fourpointsix|Fourpointsix]] ([[User talk:Fourpointsix|talk]]) 20:09, 2 August 2024 (UTC)