commit b7ff626df1cc01c0de988bb2c34b0338a9a4e64f Author: tigro Date: Sat Jan 4 15:33:03 2025 +0300 import python-jedi-0.19.1-10.el10 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a46a5ad --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +SOURCES/django-stubs-fd057010f6cbf176f57d1099e82be46d39b99cb9.tar.gz +SOURCES/jedi-0.19.1.tar.gz +SOURCES/typeshed-ae9d4f4b21bb5e1239816c301da7b1ea904b44c3.tar.gz diff --git a/.python-jedi.metadata b/.python-jedi.metadata new file mode 100644 index 0000000..3a8fbb4 --- /dev/null +++ b/.python-jedi.metadata @@ -0,0 +1,3 @@ +58c6441fabcfe0005d8b34fafdc940e3c787a37e SOURCES/django-stubs-fd057010f6cbf176f57d1099e82be46d39b99cb9.tar.gz +7570552fc3b6a1b461777f5cae8ce5aa1e9fda84 SOURCES/jedi-0.19.1.tar.gz +7b57662716eb5b3fa15d94f00885a1d2f15b4a21 SOURCES/typeshed-ae9d4f4b21bb5e1239816c301da7b1ea904b44c3.tar.gz diff --git a/SOURCES/0001-Merge-branch-ensure-unique-subprocess-reference-ids.patch b/SOURCES/0001-Merge-branch-ensure-unique-subprocess-reference-ids.patch new file mode 100644 index 0000000..4ccff6f --- /dev/null +++ b/SOURCES/0001-Merge-branch-ensure-unique-subprocess-reference-ids.patch @@ -0,0 +1,319 @@ +From 43902d83018c950c9ac1a97c58abc32838228867 Mon Sep 17 00:00:00 2001 +From: Peter Law +Date: Thu, 4 Jul 2024 22:39:29 +0100 +Subject: [PATCH 1/2] Merge branch 'ensure-unique-subprocess-reference-ids' + +(cherry picked from commit e839683e91b78355f0363bcc6f74f762995344f8) +--- + jedi/api/environment.py | 15 +- + .../inference/compiled/subprocess/__init__.py | 157 ++++++++++++++++-- + 2 files changed, 152 insertions(+), 20 deletions(-) + +diff --git a/jedi/api/environment.py b/jedi/api/environment.py +index 771a9a83..cfe8cfe3 100644 +--- a/jedi/api/environment.py ++++ b/jedi/api/environment.py +@@ -8,6 +8,7 @@ import hashlib + import filecmp + from collections import namedtuple + from shutil import which ++from typing import TYPE_CHECKING + + from jedi.cache import memoize_method, time_cache + from jedi.inference.compiled.subprocess import CompiledSubprocess, \ +@@ -15,6 +16,10 @@ from jedi.inference.compiled.subprocess import CompiledSubprocess, \ + + import parso + ++if TYPE_CHECKING: ++ from jedi.inference import InferenceState ++ ++ + _VersionInfo = namedtuple('VersionInfo', 'major minor micro') # type: ignore[name-match] + + _SUPPORTED_PYTHONS = ['3.12', '3.11', '3.10', '3.9', '3.8', '3.7', '3.6'] +@@ -102,7 +107,10 @@ class Environment(_BaseEnvironment): + version = '.'.join(str(i) for i in self.version_info) + return '<%s: %s in %s>' % (self.__class__.__name__, version, self.path) + +- def get_inference_state_subprocess(self, inference_state): ++ def get_inference_state_subprocess( ++ self, ++ inference_state: 'InferenceState', ++ ) -> InferenceStateSubprocess: + return InferenceStateSubprocess(inference_state, self._get_subprocess()) + + @memoize_method +@@ -134,7 +142,10 @@ class SameEnvironment(_SameEnvironmentMixin, Environment): + + + class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment): +- def get_inference_state_subprocess(self, inference_state): ++ def get_inference_state_subprocess( ++ self, ++ inference_state: 'InferenceState', ++ ) -> InferenceStateSameProcess: + return InferenceStateSameProcess(inference_state) + + def get_sys_path(self): +diff --git a/jedi/inference/compiled/subprocess/__init__.py b/jedi/inference/compiled/subprocess/__init__.py +index cd5fe74c..3a6039f7 100644 +--- a/jedi/inference/compiled/subprocess/__init__.py ++++ b/jedi/inference/compiled/subprocess/__init__.py +@@ -5,6 +5,23 @@ goals: + 1. Making it safer - Segfaults and RuntimeErrors as well as stdout/stderr can + be ignored and dealt with. + 2. Make it possible to handle different Python versions as well as virtualenvs. ++ ++The architecture here is briefly: ++ - For each Jedi `Environment` there is a corresponding subprocess which ++ operates within the target environment. If the subprocess dies it is replaced ++ at this level. ++ - `CompiledSubprocess` manages exactly one subprocess and handles communication ++ from the parent side. ++ - `Listener` runs within the subprocess, processing each request and yielding ++ results. ++ - `InterpreterEnvironment` provides an API which matches that of `Environment`, ++ but runs functionality inline rather than within a subprocess. It is thus ++ used both directly in places where a subprocess is unnecessary and/or ++ undesirable and also within subprocesses themselves. ++ - `InferenceStateSubprocess` (or `InferenceStateSameProcess`) provide high ++ level access to functionality within the subprocess from within the parent. ++ Each `InterpreterState` has an instance of one of these, provided by its ++ environment. + """ + + import collections +@@ -16,6 +33,7 @@ import traceback + import weakref + from functools import partial + from threading import Thread ++from typing import Dict, TYPE_CHECKING + + from jedi._compatibility import pickle_dump, pickle_load + from jedi import debug +@@ -25,6 +43,9 @@ from jedi.inference.compiled.access import DirectObjectAccess, AccessPath, \ + SignatureParam + from jedi.api.exceptions import InternalError + ++if TYPE_CHECKING: ++ from jedi.inference import InferenceState ++ + + _MAIN_PATH = os.path.join(os.path.dirname(__file__), '__main__.py') + PICKLE_PROTOCOL = 4 +@@ -83,10 +104,9 @@ def _cleanup_process(process, thread): + + + class _InferenceStateProcess: +- def __init__(self, inference_state): ++ def __init__(self, inference_state: 'InferenceState') -> None: + self._inference_state_weakref = weakref.ref(inference_state) +- self._inference_state_id = id(inference_state) +- self._handles = {} ++ self._handles: Dict[int, AccessHandle] = {} + + def get_or_create_access_handle(self, obj): + id_ = id(obj) +@@ -116,11 +136,49 @@ class InferenceStateSameProcess(_InferenceStateProcess): + + + class InferenceStateSubprocess(_InferenceStateProcess): +- def __init__(self, inference_state, compiled_subprocess): ++ """ ++ API to functionality which will run in a subprocess. ++ ++ This mediates the interaction between an `InferenceState` and the actual ++ execution of functionality running within a `CompiledSubprocess`. Available ++ functions are defined in `.functions`, though should be accessed via ++ attributes on this class of the same name. ++ ++ This class is responsible for indicating that the `InferenceState` within ++ the subprocess can be removed once the corresponding instance in the parent ++ goes away. ++ """ ++ ++ def __init__( ++ self, ++ inference_state: 'InferenceState', ++ compiled_subprocess: 'CompiledSubprocess', ++ ) -> None: + super().__init__(inference_state) + self._used = False + self._compiled_subprocess = compiled_subprocess + ++ # Opaque id we'll pass to the subprocess to identify the context (an ++ # `InferenceState`) which should be used for the request. This allows us ++ # to make subsequent requests which operate on results from previous ++ # ones, while keeping a single subprocess which can work with several ++ # contexts in the parent process. Once it is no longer needed(i.e: when ++ # this class goes away), we also use this id to indicate that the ++ # subprocess can discard the context. ++ # ++ # Note: this id is deliberately coupled to this class (and not to ++ # `InferenceState`) as this class manages access handle mappings which ++ # must correspond to those in the subprocess. This approach also avoids ++ # race conditions from successive `InferenceState`s with the same object ++ # id (as observed while adding support for Python 3.13). ++ # ++ # This value does not need to be the `id()` of this instance, we merely ++ # need to ensure that it enables the (visible) lifetime of the context ++ # within the subprocess to match that of this class. We therefore also ++ # depend on the semantics of `CompiledSubprocess.delete_inference_state` ++ # for correctness. ++ self._inference_state_id = id(self) ++ + def __getattr__(self, name): + func = _get_function(name) + +@@ -128,7 +186,7 @@ class InferenceStateSubprocess(_InferenceStateProcess): + self._used = True + + result = self._compiled_subprocess.run( +- self._inference_state_weakref(), ++ self._inference_state_id, + func, + args=args, + kwargs=kwargs, +@@ -164,6 +222,17 @@ class InferenceStateSubprocess(_InferenceStateProcess): + + + class CompiledSubprocess: ++ """ ++ A subprocess which runs inference within a target environment. ++ ++ This class manages the interface to a single instance of such a process as ++ well as the lifecycle of the process itself. See `.__main__` and `Listener` ++ for the implementation of the subprocess and details of the protocol. ++ ++ A single live instance of this is maintained by `jedi.api.environment.Environment`, ++ so that typically a single subprocess is used at a time. ++ """ ++ + is_crashed = False + + def __init__(self, executable, env_vars=None): +@@ -213,18 +282,18 @@ class CompiledSubprocess: + t) + return process + +- def run(self, inference_state, function, args=(), kwargs={}): ++ def run(self, inference_state_id, function, args=(), kwargs={}): + # Delete old inference_states. + while True: + try: +- inference_state_id = self._inference_state_deletion_queue.pop() ++ delete_id = self._inference_state_deletion_queue.pop() + except IndexError: + break + else: +- self._send(inference_state_id, None) ++ self._send(delete_id, None) + + assert callable(function) +- return self._send(id(inference_state), function, args, kwargs) ++ return self._send(inference_state_id, function, args, kwargs) + + def get_sys_path(self): + return self._send(None, functions.get_sys_path, (), {}) +@@ -272,21 +341,65 @@ class CompiledSubprocess: + + def delete_inference_state(self, inference_state_id): + """ +- Currently we are not deleting inference_state instantly. They only get +- deleted once the subprocess is used again. It would probably a better +- solution to move all of this into a thread. However, the memory usage +- of a single inference_state shouldn't be that high. ++ Indicate that an inference state (in the subprocess) is no longer ++ needed. ++ ++ The state corresponding to the given id will become inaccessible and the ++ id may safely be re-used to refer to a different context. ++ ++ Note: it is not guaranteed that the corresponding state will actually be ++ deleted immediately. + """ +- # With an argument - the inference_state gets deleted. ++ # Warning: if changing the semantics of context deletion see the comment ++ # in `InferenceStateSubprocess.__init__` regarding potential race ++ # conditions. ++ ++ # Currently we are not deleting the related state instantly. They only ++ # get deleted once the subprocess is used again. It would probably a ++ # better solution to move all of this into a thread. However, the memory ++ # usage of a single inference_state shouldn't be that high. + self._inference_state_deletion_queue.append(inference_state_id) + + + class Listener: ++ """ ++ Main loop for the subprocess which actually does the inference. ++ ++ This class runs within the target environment. It listens to instructions ++ from the parent process, runs inference and returns the results. ++ ++ The subprocess has a long lifetime and is expected to process several ++ requests, including for different `InferenceState` instances in the parent. ++ See `CompiledSubprocess` for the parent half of the system. ++ ++ Communication is via pickled data sent serially over stdin and stdout. ++ Stderr is read only if the child process crashes. ++ ++ The request protocol is a 4-tuple of: ++ * inference_state_id | None: an opaque identifier of the parent's ++ `InferenceState`. An `InferenceState` operating over an ++ `InterpreterEnvironment` is created within this process for each of ++ these, ensuring that each parent context has a corresponding context ++ here. This allows context to be persisted between requests. Unless ++ `None`, the local `InferenceState` will be passed to the given function ++ as the first positional argument. ++ * function | None: the function to run. This is expected to be a member of ++ `.functions`. `None` indicates that the corresponding inference state is ++ no longer needed and should be dropped. ++ * args: positional arguments to the `function`. If any of these are ++ `AccessHandle` instances they will be adapted to the local ++ `InferenceState` before being passed. ++ * kwargs: keyword arguments to the `function`. If any of these are ++ `AccessHandle` instances they will be adapted to the local ++ `InferenceState` before being passed. ++ ++ The result protocol is a 3-tuple of either: ++ * (False, None, function result): if the function returns without error, or ++ * (True, traceback, exception): if the function raises an exception ++ """ ++ + def __init__(self): + self._inference_states = {} +- # TODO refactor so we don't need to process anymore just handle +- # controlling. +- self._process = _InferenceStateProcess(Listener) + + def _get_inference_state(self, function, inference_state_id): + from jedi.inference import InferenceState +@@ -308,6 +421,9 @@ class Listener: + if inference_state_id is None: + return function(*args, **kwargs) + elif function is None: ++ # Warning: if changing the semantics of context deletion see the comment ++ # in `InferenceStateSubprocess.__init__` regarding potential race ++ # conditions. + del self._inference_states[inference_state_id] + else: + inference_state = self._get_inference_state(function, inference_state_id) +@@ -348,7 +464,12 @@ class Listener: + + + class AccessHandle: +- def __init__(self, subprocess, access, id_): ++ def __init__( ++ self, ++ subprocess: _InferenceStateProcess, ++ access: DirectObjectAccess, ++ id_: int, ++ ) -> None: + self.access = access + self._subprocess = subprocess + self.id = id_ +-- +2.45.2 + diff --git a/SOURCES/0002-Merge-branch-python-3.13.patch b/SOURCES/0002-Merge-branch-python-3.13.patch new file mode 100644 index 0000000..c3fca1f --- /dev/null +++ b/SOURCES/0002-Merge-branch-python-3.13.patch @@ -0,0 +1,220 @@ +From 2a638c784ff63ab869626d23ce95856dece31a9b Mon Sep 17 00:00:00 2001 +From: Peter Law +Date: Sat, 6 Jul 2024 11:39:06 +0100 +Subject: [PATCH 2/2] Merge branch 'python-3.13' + +(cherry picked from commit 82d1902f382ddac5b0e6647646b72f28a3181ec3) +--- + .github/workflows/ci.yml | 4 ++-- + CHANGELOG.rst | 2 ++ + jedi/_compatibility.py | 15 ++++++++++++++- + jedi/api/environment.py | 2 +- + jedi/inference/__init__.py | 2 +- + setup.py | 5 +++-- + test/test_api/test_interpreter.py | 13 +++++++++---- + test/test_inference/test_signature.py | 5 +++-- + test/test_utils.py | 14 ++++++++++---- + 9 files changed, 45 insertions(+), 17 deletions(-) + +diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml +index a565425d..13b744c9 100644 +--- a/.github/workflows/ci.yml ++++ b/.github/workflows/ci.yml +@@ -7,8 +7,8 @@ jobs: + strategy: + matrix: + os: [ubuntu-20.04, windows-2019] +- python-version: ["3.12", "3.11", "3.10", "3.9", "3.8", "3.7", "3.6"] +- environment: ['3.8', '3.12', '3.11', '3.10', '3.9', '3.7', '3.6', 'interpreter'] ++ python-version: ["3.13", "3.12", "3.11", "3.10", "3.9", "3.8", "3.7", "3.6"] ++ environment: ['3.8', '3.13', '3.12', '3.11', '3.10', '3.9', '3.7', '3.6', 'interpreter'] + steps: + - name: Checkout code + uses: actions/checkout@v4 +diff --git a/CHANGELOG.rst b/CHANGELOG.rst +index fca94429..cf6810fa 100644 +--- a/CHANGELOG.rst ++++ b/CHANGELOG.rst +@@ -6,6 +6,8 @@ Changelog + Unreleased + ++++++++++ + ++- Python 3.13 support ++ + 0.19.1 (2023-10-02) + +++++++++++++++++++ + +diff --git a/jedi/_compatibility.py b/jedi/_compatibility.py +index 13a74b7b..48563d00 100644 +--- a/jedi/_compatibility.py ++++ b/jedi/_compatibility.py +@@ -5,11 +5,24 @@ different Python versions. + import errno + import sys + import pickle ++from typing import Any ++ ++ ++class Unpickler(pickle.Unpickler): ++ def find_class(self, module: str, name: str) -> Any: ++ # Python 3.13 moved pathlib implementation out of __init__.py as part of ++ # generalising its implementation. Ensure that we support loading ++ # pickles from 3.13 on older version of Python. Since 3.13 maintained a ++ # compatible API, pickles from older Python work natively on the newer ++ # version. ++ if module == 'pathlib._local': ++ module = 'pathlib' ++ return super().find_class(module, name) + + + def pickle_load(file): + try: +- return pickle.load(file) ++ return Unpickler(file).load() + # Python on Windows don't throw EOF errors for pipes. So reraise them with + # the correct type, which is caught upwards. + except OSError: +diff --git a/jedi/api/environment.py b/jedi/api/environment.py +index cfe8cfe3..a2134110 100644 +--- a/jedi/api/environment.py ++++ b/jedi/api/environment.py +@@ -22,7 +22,7 @@ if TYPE_CHECKING: + + _VersionInfo = namedtuple('VersionInfo', 'major minor micro') # type: ignore[name-match] + +-_SUPPORTED_PYTHONS = ['3.12', '3.11', '3.10', '3.9', '3.8', '3.7', '3.6'] ++_SUPPORTED_PYTHONS = ['3.13', '3.12', '3.11', '3.10', '3.9', '3.8', '3.7', '3.6'] + _SAFE_PATHS = ['/usr/bin', '/usr/local/bin'] + _CONDA_VAR = 'CONDA_PREFIX' + _CURRENT_VERSION = '%s.%s' % (sys.version_info.major, sys.version_info.minor) +diff --git a/jedi/inference/__init__.py b/jedi/inference/__init__.py +index aadfeba9..bd31cbd3 100644 +--- a/jedi/inference/__init__.py ++++ b/jedi/inference/__init__.py +@@ -90,7 +90,7 @@ class InferenceState: + self.compiled_subprocess = environment.get_inference_state_subprocess(self) + self.grammar = environment.get_grammar() + +- self.latest_grammar = parso.load_grammar(version='3.12') ++ self.latest_grammar = parso.load_grammar(version='3.13') + self.memoize_cache = {} # for memoize decorators + self.module_cache = imports.ModuleCache() # does the job of `sys.modules`. + self.stub_module_cache = {} # Dict[Tuple[str, ...], Optional[ModuleValue]] +diff --git a/setup.py b/setup.py +index 68210ef2..ed1e67a4 100755 +--- a/setup.py ++++ b/setup.py +@@ -35,8 +35,8 @@ setup(name='jedi', + long_description=readme, + packages=find_packages(exclude=['test', 'test.*']), + python_requires='>=3.6', +- # Python 3.11 & 3.12 grammars are added to parso in 0.8.3 +- install_requires=['parso>=0.8.3,<0.9.0'], ++ # Python 3.13 grammars are added to parso in 0.8.4 ++ install_requires=['parso>=0.8.4,<0.9.0'], + extras_require={ + 'testing': [ + 'pytest<7.0.0', +@@ -101,6 +101,7 @@ setup(name='jedi', + 'Programming Language :: Python :: 3.10', + 'Programming Language :: Python :: 3.11', + 'Programming Language :: Python :: 3.12', ++ 'Programming Language :: Python :: 3.13', + 'Topic :: Software Development :: Libraries :: Python Modules', + 'Topic :: Text Editors :: Integrated Development Environments (IDE)', + 'Topic :: Utilities', +diff --git a/test/test_api/test_interpreter.py b/test/test_api/test_interpreter.py +index 74f066b8..efff7c5b 100644 +--- a/test/test_api/test_interpreter.py ++++ b/test/test_api/test_interpreter.py +@@ -310,8 +310,9 @@ def test_completion_param_annotations(): + # Need to define this function not directly in Python. Otherwise Jedi is too + # clever and uses the Python code instead of the signature object. + code = 'def foo(a: 1, b: str, c: int = 1.0) -> bytes: pass' +- exec(code, locals()) +- script = jedi.Interpreter('foo', [locals()]) ++ exec_locals = {} ++ exec(code, exec_locals) ++ script = jedi.Interpreter('foo', [exec_locals]) + c, = script.complete() + sig, = c.get_signatures() + a, b, c = sig.params +@@ -323,7 +324,7 @@ def test_completion_param_annotations(): + assert b.description == 'param b: str' + assert c.description == 'param c: int=1.0' + +- d, = jedi.Interpreter('foo()', [locals()]).infer() ++ d, = jedi.Interpreter('foo()', [exec_locals]).infer() + assert d.name == 'bytes' + + +@@ -525,10 +526,14 @@ def test_partial_signatures(code, expected, index): + c = functools.partial(func, 1, c=2) + + sig, = jedi.Interpreter(code, [locals()]).get_signatures() +- assert sig.name == 'partial' + assert [p.name for p in sig.params] == expected + assert index == sig.index + ++ if sys.version_info < (3, 13): ++ # Python 3.13.0b3 makes functools.partial be a descriptor, which breaks ++ # Jedi's `py__name__` detection; see https://github.com/davidhalter/jedi/issues/2012 ++ assert sig.name == 'partial' ++ + + def test_type_var(): + """This was an issue before, see Github #1369""" +diff --git a/test/test_inference/test_signature.py b/test/test_inference/test_signature.py +index f8f71581..4a1fcb62 100644 +--- a/test/test_inference/test_signature.py ++++ b/test/test_inference/test_signature.py +@@ -1,5 +1,5 @@ + from textwrap import dedent +-from operator import ge, lt ++from operator import eq, ge, lt + import re + import os + +@@ -14,7 +14,8 @@ from ..helpers import get_example_dir + ('import math; math.cos', 'cos(x, /)', ['x'], ge, (3, 6)), + + ('next', 'next(iterator, default=None, /)', ['iterator', 'default'], lt, (3, 12)), +- ('next', 'next()', [], ge, (3, 12)), ++ ('next', 'next()', [], eq, (3, 12)), ++ ('next', 'next(iterator, default=None, /)', ['iterator', 'default'], ge, (3, 13)), + + ('str', "str(object='', /) -> str", ['object'], ge, (3, 6)), + +diff --git a/test/test_utils.py b/test/test_utils.py +index f17fc246..13786d38 100644 +--- a/test/test_utils.py ++++ b/test/test_utils.py +@@ -73,15 +73,21 @@ class TestSetupReadline(unittest.TestCase): + import os + s = 'from os import ' + goal = {s + el for el in dir(os)} ++ + # There are minor differences, e.g. the dir doesn't include deleted + # items as well as items that are not only available on linux. + difference = set(self.complete(s)).symmetric_difference(goal) ++ ACCEPTED_DIFFERENCE_PREFIXES = [ ++ '_', 'O_', 'EX_', 'EFD_', 'MFD_', 'TFD_', ++ 'SF_', 'ST_', 'CLD_', 'POSIX_SPAWN_', 'P_', ++ 'RWF_', 'CLONE_', 'SCHED_', 'SPLICE_', ++ ] + difference = { + x for x in difference +- if all(not x.startswith('from os import ' + s) +- for s in ['_', 'O_', 'EX_', 'MFD_', 'SF_', 'ST_', +- 'CLD_', 'POSIX_SPAWN_', 'P_', 'RWF_', +- 'CLONE_', 'SCHED_']) ++ if not any( ++ x.startswith('from os import ' + prefix) ++ for prefix in ACCEPTED_DIFFERENCE_PREFIXES ++ ) + } + # There are quite a few differences, because both Windows and Linux + # (posix and nt) libraries are included. +-- +2.45.2 + diff --git a/SPECS/python-jedi.spec b/SPECS/python-jedi.spec new file mode 100644 index 0000000..04954ca --- /dev/null +++ b/SPECS/python-jedi.spec @@ -0,0 +1,333 @@ +## START: Set by rpmautospec +## (rpmautospec version 0.6.5) +## RPMAUTOSPEC: autorelease, autochangelog +%define autorelease(e:s:pb:n) %{?-p:0.}%{lua: + release_number = 10; + base_release_number = tonumber(rpm.expand("%{?-b*}%{!?-b:1}")); + print(release_number + base_release_number - 1); +}%{?-e:.%{-e*}}%{?-s:.%{-s*}}%{!?-n:%{?dist}} +## END: Set by rpmautospec + +%global common_description %{expand: +Jedi is a static analysis tool for Python that can be used in IDEs/editors. Its +historic focus is autocompletion, but does static analysis for now as well. +Jedi is fast and is very well tested. It understands Python on a deeper level +than all other static analysis frameworks for Python.} + +%if %{defined fedora} +# epel9 is missing django +%bcond_without tests +%endif + +# jedi bundles 2 other projects +# when using the git tarball, the projects need to be pulled separately +# when using tarballs from PyPI, those are included +%global django_stubs_commit fd057010f6cbf176f57d1099e82be46d39b99cb9 +%global typeshed_commit ae9d4f4b21bb5e1239816c301da7b1ea904b44c3 + +Name: python-jedi +Version: 0.19.1 +Release: %autorelease +Summary: An auto completion tool for Python that can be used for text editors + +# jedi is MIT +# django-stubs is MIT +# typeshed is MIT ASL 2.0 +License: MIT and ASL 2.0 + +URL: https://jedi.readthedocs.org +Source0: https://github.com/davidhalter/jedi/archive/v%{version}/jedi-%{version}.tar.gz +Source1: https://github.com/davidhalter/django-stubs/archive/%{django_stubs_commit}/django-stubs-%{django_stubs_commit}.tar.gz +Source2: https://github.com/davidhalter/typeshed/archive/%{typeshed_commit}/typeshed-%{typeshed_commit}.tar.gz +# https://github.com/davidhalter/jedi/pull/2008 +Patch: 0001-Merge-branch-ensure-unique-subprocess-reference-ids.patch +# https://github.com/davidhalter/jedi/pull/2003 +Patch: 0002-Merge-branch-python-3.13.patch +BuildArch: noarch + +%description %{common_description} + +%package -n python3-jedi +Summary: %{summary} +BuildRequires: python3-devel +Provides: bundled(python3dist(django-stubs)) = %{django_stubs_commit} +Provides: bundled(typeshed) = %{typeshed_commit} + +%description -n python3-jedi %{common_description} + + +%prep +%autosetup -n jedi-%{version} -p 1 + +# git submodules +pushd jedi/third_party +rmdir django-stubs typeshed +tar xf %{SOURCE1} && mv django-stubs-%{django_stubs_commit} django-stubs +tar xf %{SOURCE2} && mv typeshed-%{typeshed_commit} typeshed +popd +cp -p jedi/third_party/django-stubs/LICENSE.txt LICENSE-django-stubs.txt +cp -p jedi/third_party/typeshed/LICENSE LICENSE-typeshed.txt + +# relax upper limits on test dependencies +sed -e 's/pytest<7.0.0/pytest/' \ + -e 's/Django<3.1/Django/' \ + -i setup.py + +# Fix for compatibility with pytest 8 +# Proposed upstream: https://github.com/davidhalter/jedi/pull/1996 +sed -i "/def __init__/s/__init__/setUp/" test/test_utils.py + +%generate_buildrequires +%pyproject_buildrequires %{?with_tests:-x testing} + + +%build +%pyproject_wheel + + +%install +%pyproject_install +%pyproject_save_files jedi + + +%check +%if %{with tests} +# %%pytest manipulates the sys.path +# test_compiled_singature +# - https://github.com/davidhalter/jedi/issues/1952 +# - https://github.com/python/cpython/issues/107526 +%pytest -k "\ + not test_venv_and_pths and \ + not test_compiled_signature and \ + not test_find_system_environments and \ + not test_import" +%else +%pyproject_check_import +%endif + + +%files -n python3-jedi -f %{pyproject_files} +%doc CHANGELOG.rst README.rst + + +%changelog +* Sat Jan 04 2025 Arkady L. Shane - 0.19.1-10 +- Rebuilt for MSVSphere 10 + +## START: Generated by rpmautospec +* Fri Jul 19 2024 Fedora Release Engineering - 0.19.1-10 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_41_Mass_Rebuild + +* Mon Jul 08 2024 Carl George - 0.19.1-9 +- Fix race condition + +* Sun Jul 07 2024 Carl George - 0.19.1-8 +- Fix Python 3.13 build rhbz#2280581 + +* Sat Jun 08 2024 Python Maint - 0.19.1-7 +- Rebuilt for Python 3.13 + +* Fri Jun 07 2024 Python Maint - 0.19.1-6 +- Bootstrap for Python 3.13 + +* Fri Jan 26 2024 Fedora Release Engineering - 0.19.1-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Mon Jan 22 2024 Fedora Release Engineering - 0.19.1-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Wed Oct 04 2023 Lumír Balhar - 0.19.1-1 +- Update to 0.19.1 (rhbz#2241718) + +* Tue Aug 01 2023 Lumír Balhar - 0.19.0-1 +- Update to 0.19.0 (rhbz#2227382) + +* Fri Jul 21 2023 Fedora Release Engineering - 0.18.2-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild + +* Thu Jun 29 2023 Python Maint - 0.18.2-5 +- Rebuilt for Python 3.12 + +* Wed Jun 14 2023 Python Maint - 0.18.2-4 +- Bootstrap for Python 3.12 + +* Mon May 29 2023 Lumír Balhar - 0.18.2-3 +- Fix compatibility with attrs 23.1.0 + +* Fri Jan 20 2023 Fedora Release Engineering - 0.18.2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild + +* Tue Nov 22 2022 Lumír Balhar - 0.18.2-1 +- Update to 0.18.2 (rhbz#2144681) + +* Tue Aug 02 2022 Lumír Balhar - 0.18.1-7 +- Fix FTBFS with Python 3.11 by disabling some tests + +* Fri Jul 22 2022 Fedora Release Engineering - 0.18.1-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_37_Mass_Rebuild + +* Tue Jun 14 2022 Python Maint - 0.18.1-5 +- Rebuilt for Python 3.11 + +* Mon Jun 13 2022 Python Maint - 0.18.1-4 +- Bootstrap for Python 3.11 + +* Fri Apr 08 2022 Carl George - 0.18.1-3 +- Convert to pyproject macros + +* Fri Jan 21 2022 Fedora Release Engineering - 0.18.1-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_36_Mass_Rebuild + +* Thu Nov 18 2021 Lumír Balhar - 0.18.1-1 +- Update to 0.18.1 +Resolves: rhbz#2024009 + +* Thu Aug 05 2021 Lumír Balhar - 0.18.0-6 +- Fix compatibility with Python 3.10rc1 + +* Sun Aug 01 2021 Lumír Balhar - 0.18.0-5 +- Skip some tests causing FTBFS with Python 3.10 + +* Tue Jul 27 2021 Fedora Release Engineering - 0.18.0-4 +- Second attempt - Rebuilt for + https://fedoraproject.org/wiki/Fedora_35_Mass_Rebuild + +* Fri Jun 04 2021 Python Maint - 0.18.0-3 +- Rebuilt for Python 3.10 + +* Wed Jun 02 2021 Python Maint - 0.18.0-2 +- Bootstrap for Python 3.10 + +* Tue Mar 02 2021 Lumír Balhar - 0.18.0-1 +- Update to 0.18.0 +Resolves: rhbz#1910879 + +* Wed Jan 27 2021 Fedora Release Engineering - 0.17.2^20200805git209e271-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Fri Oct 30 2020 Miro Hrončok - 0.17.2^20200805git209e271-1 +- Update to a git snapshot to support parso 0.8 +- Add provides for bundled django-stubs and typeshed +- Adapt the license tag to include the license of bundled projects +- Enable tests, except integration + +* Wed Jul 29 2020 Fedora Release Engineering - 0.17.1-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Fri Jul 10 2020 Mukundan Ragavan - 0.17.1-1 +- Update to 0.17.1 + +* Sun May 24 2020 Miro Hrončok - 0.15.1-3 +- Rebuilt for Python 3.9 + +* Thu Jan 30 2020 Fedora Release Engineering - 0.15.1-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Thu Oct 17 2019 Carl George - 0.15.1-1 +- Latest upstream + +* Thu Oct 03 2019 Miro Hrončok - 0.14.1-3 +- Rebuilt for Python 3.8.0rc1 (#1748018) + +* Thu Aug 15 2019 Miro Hrončok - 0.14.1-2 +- Rebuilt for Python 3.8 + +* Wed Jul 24 2019 Carl George - 0.14.1-1 +- Latest upstream +- Disable python2 subpackage on F31+ and EL8+ rhbz#1732815 + +* Sat Feb 02 2019 Fedora Release Engineering - 0.12.1-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Tue Sep 04 2018 Carl George - 0.12.1-2 +- Remove _docdir_fmt macro to allow upgrading subpackages separately rhbz#1625015 +- Standardize on srcname, modname, eggname, and pkgname macros + +* Fri Aug 24 2018 Pavel Raiskup - 0.12.1-1 +- new upstream version + +* Sat Jul 14 2018 Fedora Release Engineering - 0.12.0-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Fri Jun 15 2018 Carl George - 0.12.0-3 +- Add patch0 to parse correct AST entry for version on Python 3.7.0b5 + +* Fri Jun 15 2018 Miro Hrončok - 0.12.0-2 +- Rebuilt for Python 3.7 + +* Mon Apr 16 2018 Carl George - 0.12.0-1 +- Latest upstream +- Enable test suite +- Share doc and license dir between subpackages + +* Fri Feb 09 2018 Fedora Release Engineering - 0.10.2-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Fri Jul 28 2017 Michel Alexandre Salim - 0.10.2-3 +- Enable python3 subpackage for EPEL + +* Thu Jul 27 2017 Fedora Release Engineering - 0.10.2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Tue Apr 18 2017 Carl George - 0.10.2-1 +- Latest upstream + +* Mon Apr 03 2017 Carl George - 0.10.0-1 +- Latest upstream +- Upstream license changed to MIT and Python +- Align spec with Python packaging guidelines + +* Sat Feb 11 2017 Fedora Release Engineering - 0.9.0-7 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Mon Dec 19 2016 Miro Hrončok - 0.9.0-6 +- Rebuild for Python 3.6 + +* Tue Jul 19 2016 Fedora Release Engineering - 0.9.0-5 +- https://fedoraproject.org/wiki/Changes/Automatic_Provides_for_Python_RPM_Packages + +* Thu Feb 04 2016 Fedora Release Engineering - 0.9.0-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Tue Nov 10 2015 Fedora Release Engineering - 0.9.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Changes/python3.5 + +* Thu Jun 18 2015 Fedora Release Engineering - 0.9.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Thu May 07 2015 Petr Hracek - 0.9.0-1 +- new upstream version 0.9.0 (#1217032) + +* Mon Jan 19 2015 Petr Hracek - 0.8.1-1 +- new upstream version 0.8.1 (#1178815) + +* Sat Jun 07 2014 Fedora Release Engineering - 0.7.0-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Wed May 28 2014 Kalev Lember - 0.7.0-4 +- Rebuilt for https://fedoraproject.org/wiki/Changes/Python_3.4 + +* Mon Jan 06 2014 Petr Hracek - 0.7.0-3 +- Fix: Enable python3 subpackage (#1038398) + +* Fri Aug 23 2013 Petr Hracek - 0.7.0-1 +- new upstream version 0.7.0 + +* Sun Aug 04 2013 Fedora Release Engineering - 0.6.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Thu May 16 2013 Petr Hracek - 0.6.0-1 +- new upstream version 0.6.0 + +* Wed Apr 17 2013 Petr Hracek - 0.5b5-3 +- Test suite is available only on dev branch. It will not be used. + +* Thu Apr 11 2013 Petr Hracek - 0.5b5-2 +- Some type warnings. +- Added dependency to python2-devel +- tests were run and 5/679 failed + +* Thu Apr 11 2013 Petr Hracek - 0.5b5-1 +- Initial package. + +## END: Generated by rpmautospec