python-jira-plus 2.0.8__py3-none-any.whl → 3.0.0__py3-none-any.whl

python_jira_plus/__init__.py

@@ -8,7 +8,9 @@ pagination, metadata validation, and more.
 from dotenv import load_dotenv
 
 from python_jira_plus.describe_allowed_value import describe_allowed_value
-from python_jira_plus.jira_plus import JiraPlus, ServerType, UrlScheme
+from python_jira_plus.jira_base import JiraBase, UrlScheme
+from python_jira_plus.jira_cloud import JiraCloud
+from python_jira_plus.jira_on_premise import JiraOnPremise
 
 load_dotenv()
 
@@ -27,4 +29,4 @@ BASIC_FIELDS = [
     "resolution",
     "parent",
 ]
-__all__ = ["JiraPlus", "ServerType", "UrlScheme", "BASIC_FIELDS"]
+__all__ = ["JiraBase", "JiraCloud", "JiraOnPremise", "UrlScheme", "BASIC_FIELDS"]

python_jira_plus/{jira_plus.py → jira_base.py}

@@ -1,18 +1,16 @@
-# jira_plus.py
+# jira_base.py
 
 import json
 import logging
 import os
-import time
+from abc import ABC, abstractmethod
 from enum import Enum
 from typing import Any
 
-import requests
 from custom_python_logger import get_logger
 from jira import JIRA, Issue, JIRAError
 from jira.client import ResultList
-from retrying import retry
-from packaging.version import Version
+
 from python_jira_plus.describe_allowed_value import describe_allowed_value
 
 
@@ -21,21 +19,16 @@ class UrlScheme(Enum):
     HTTPS = "https"
 
 
-class ServerType(Enum):
-    CLOUD = "cloud"
-    ON_PREMISE = "on_premise"
-
+class JiraBase(ABC):
+    use_createmeta: bool
 
-class JiraPlus:
     def __init__(
         self,
         base_url: str | None = None,
-        server_type: ServerType = ServerType.CLOUD,
         urllib3_log_level: int = logging.WARNING,
         jira_username: str | None = None,
-        jira_token: str | None = None,  # Use API token (not PAT)
+        jira_token: str | None = None,
         verify_ssl: bool = True,
-        sso: bool = False,
         url_scheme: UrlScheme = UrlScheme.HTTPS,
     ) -> None:
         self.logger = get_logger(self.__class__.__name__)
@@ -45,35 +38,28 @@ class JiraPlus:
         self.jira_token = jira_token or os.getenv("JIRA_TOKEN")
         self.base_url = base_url or os.getenv("JIRA_BASE_URL")
         self.url_scheme = url_scheme.value
-
-        self.server_type = server_type
         self.server = f"{self.url_scheme}://{self.base_url}"
         self.verify_ssl = verify_ssl
-        self.sso = sso
 
         self.jira_client = self.create_connection()
         self.check_client_connection()
         self.server_version = self.get_server_version()
-        self.use_legacy_api = self._resolve_use_legacy_api()
 
-    @retry(stop_max_attempt_number=3, wait_fixed=180000)
-    def create_connection(self, timeout: int = 580) -> JIRA:
-        if self.server_type == ServerType.ON_PREMISE and not self.sso:
-            jira_client = JIRA(
-                token_auth=self.jira_token, options={"server": self.server, "verify": self.verify_ssl}, timeout=timeout
-            )
-        else:
-            jira_client = JIRA(
-                basic_auth=(self.jira_username, self.jira_token),
-                options={"server": self.server, "verify": self.verify_ssl},
-                timeout=timeout,
-            )
+    @abstractmethod
+    def create_connection(self, timeout: int = 580) -> JIRA: ...
+
+    @abstractmethod
+    def _paginate(
+        self,
+        query: str,
+        max_results: int,
+        specific_fields: str | list[str],
+        jira_err_limit: int,
+        json_result: bool,
+    ) -> ResultList[Issue] | list: ...
 
-        if jira_client.projects():
-            self.logger.info("Jira Connection Successful")
-            return jira_client
-        self.logger.error("Jira Connection Failed")
-        raise JIRAError("Jira Connection Failed")
+    @abstractmethod
+    def _format_assignee(self, assignee: str) -> dict: ...
 
     def close_connection(self) -> None:
         try:
@@ -82,7 +68,6 @@ class JiraPlus:
             self.logger.exception(f"JIRAError \n{err}")
         except Exception as err:
             self.logger.exception(f"Exception \n{err}")
-
         self.check_client_connection()
 
     def check_client_connection(self) -> bool:
@@ -98,6 +83,9 @@ class JiraPlus:
             self.logger.exception(f"Exception \n{err}")
             return False
 
+    def get_server_version(self) -> tuple[int, ...]:
+        return tuple(self.jira_client.server_info()["versionNumbers"])
+
     def get_issue_by_key(
         self, key: str, specific_fields: str | list[str] = "*all", json_result: bool = True
     ) -> None | Issue | dict[str, Any]:
@@ -120,12 +108,8 @@ class JiraPlus:
         specific_fields: str | list[str] = "*all",
         jira_err_count: int = 3,
         json_result: bool = True,
-    ) -> ResultList[Issue] | dict | None:
-        if self.server_type == ServerType.ON_PREMISE:
-            _paginate_query_func = self._paginate_query
-        else:
-            _paginate_query_func = self._paginate_query_new
-        return _paginate_query_func(
+    ) -> ResultList[Issue] | list:
+        return self._paginate(
             query=query,
             max_results=max_results,
             specific_fields=specific_fields,
@@ -133,107 +117,26 @@ class JiraPlus:
             json_result=json_result,
         )
 
-    def _paginate_query_new(
-        self,
-        query: str,
-        max_results: int,
-        specific_fields: str | list[str],
-        jira_err_limit: int,
-        json_result: bool,
-    ) -> ResultList[Issue] | list:
-        all_issues = []
-        retries = 0
-        page = None
-        while True:
-            try:
-                next_token = None
-                if page is not None:
-                    next_token = page.get('nextPageToken') if json_result else page.nextPageToken
-
-                self.logger.debug(f"Fetching issues from startAt={len(all_issues)}")
-                page = self.jira_client.enhanced_search_issues(
-                    jql_str=query,
-                    nextPageToken=next_token,
-                    maxResults=max_results,
-                    fields=specific_fields,
-                    json_result=json_result,
-                )
-                if not page:
-                    break
-
-                all_issues += page["issues"] if json_result else page
-                is_last = page['isLast'] if json_result else page.isLast
-                if is_last:
-                    break
-                retries = 0  # reset on success
-            except JIRAError as err:
-                if err.status_code == 400:
-                    self.logger.error(f"Bad Request: {err.text}")
-                    raise JIRAError(f"Bad Request: {err.text}") from err
-                retries += 1
-                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
-                if retries >= jira_err_limit:
-                    self.logger.exception("Max retries exceeded.")
-                    return []
-                time.sleep(300 if retries == jira_err_limit - 1 else 90)
-        return all_issues
-
-    def _paginate_query(
-        self,
-        query: str,
-        max_results: int,
-        specific_fields: str | list[str],
-        jira_err_limit: int,
-        json_result: bool,
-    ) -> ResultList[Issue] | list:
-        start_at = 0
-        all_issues = []
-        retries = 0
-        while True:  # pylint: disable=W0149
-            try:
-                self.logger.debug(f"Fetching issues from startAt={start_at}")
-                page = self.jira_client.search_issues(
-                    jql_str=query,
-                    startAt=start_at,
-                    maxResults=max_results,
-                    fields=specific_fields,
-                    json_result=json_result,
-                )
-                if not page:
-                    break
-
-                all_issues += page["issues"] if json_result else page
-                if json_result:
-                    start_at += page["maxResults"]
-                else:
-                    start_at += page.maxResults
-                if start_at >= max_results:
-                    break
-                retries = 0  # reset on success
-            except JIRAError as err:
-                if err.status_code == 400:
-                    self.logger.error(f"Bad Request: {err.text}")
-                    raise JIRAError(f"Bad Request: {err.text}") from err
-                retries += 1
-                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
-                if retries >= jira_err_limit:
-                    self.logger.exception("Max retries exceeded.")
-                    return []
-                time.sleep(300 if retries == jira_err_limit - 1 else 90)
-        return all_issues
-
-    def _fetch_metadata(self, project_key: str, issue_type: str) -> tuple[dict, dict]:
+    def _fetch_via_createmeta(self, project_key: str, issue_type: str) -> dict:
         meta = self.jira_client.createmeta(
             projectKeys=project_key, issuetypeNames=issue_type, expand="projects.issuetypes.fields"
         )
-
         if not (project_meta := next((p for p in meta["projects"] if p["key"] == project_key), None)):
             raise ValueError(f"Project {project_key} not found in metadata")
-
         issue_meta = next((it for it in project_meta["issuetypes"] if it["name"].lower() == issue_type.lower()), None)
         if not issue_meta:
             raise ValueError(f"Issue type '{issue_type}' not found in project '{project_key}'")
-        return meta, issue_meta
+        return issue_meta["fields"]
+
+    def _fetch_via_issue_types_api(self, project_key: str, issue_type: str) -> dict:
+        issue_types = {t.name: t for t in self.jira_client.project_issue_types(project_key)}
+        field_list = self.jira_client.project_issue_fields(project_key, issue_types[issue_type].id)
+        return {f.fieldId: f.raw for f in field_list}
+
+    def get_project_fields_metadata(self, project_key: str, issue_type: str) -> dict:
+        if self.use_createmeta:
+            return self._fetch_via_createmeta(project_key=project_key, issue_type=issue_type)
+        return self._fetch_via_issue_types_api(project_key=project_key, issue_type=issue_type)
 
     def get_allowed_values(
         self,
@@ -241,28 +144,20 @@ class JiraPlus:
         issue_type: str,
         field_id_or_name: str,
     ) -> list | None:
-        """
-        Returns the allowed values for a specific field in a project + issue type context.
-        """
+        """Returns the allowed values for a specific field in a project + issue type context."""
         fields_metadata = self.get_project_fields_metadata(project_key=project_key, issue_type=issue_type)
-
-        # Try to find by ID or fallback to case-insensitive name
         if not (field := fields_metadata.get(field_id_or_name)):
-            # Try matching by name (case-insensitive)
             for _, fmeta in fields_metadata.items():
                 if fmeta["name"].lower() == field_id_or_name.lower():
                     field = fmeta
                     break
-
         if not field:
             raise ValueError(
                 f"Field '{field_id_or_name}' not found in project '{project_key}' with issue type '{issue_type}'"
             )
-
         if not (allowed := field.get("allowedValues")):
             self.logger.info(f"No allowed values found for field '{field_id_or_name}'")
             return None
-
         return allowed
 
     @staticmethod
@@ -272,36 +167,13 @@ class JiraPlus:
         allowed_values = allowed_names | allowed_keys
         return describe_allowed_value(value, allowed_values=allowed_values)
 
-    def get_server_version(self) -> tuple[int, ...]:
-        return tuple(self.jira_client.server_info()["versionNumbers"])
-
-    def _resolve_use_legacy_api(self) -> bool:
-        if self.server_type == ServerType.ON_PREMISE:
-            use_legacy = Version(".".join(str(x) for x in self.server_version)) < Version("9.0.0")
-            self.logger.debug(f"Using {'legacy createmeta' if use_legacy else 'project_issue_types'} API (ON_PREMISE {self.server_version})")
-            return use_legacy
-        self.logger.debug("Using legacy createmeta API (Cloud)")
-        return True
-
-    def get_project_fields_metadata(self, project_key: str, issue_type: str) -> dict:
-        if self.use_legacy_api:
-            _, issue_meta = self._fetch_metadata(project_key=project_key, issue_type=issue_type)
-            return issue_meta["fields"]
-        _project_issue_types = self.jira_client.project_issue_types(project_key)
-        _issue_types = {t.name: t for t in _project_issue_types}
-        field_list = self.jira_client.project_issue_fields(project_key, _issue_types[issue_type].id)
-        return {f.fieldId: f.raw for f in field_list}
-
-    def validate_fields(  # pylint: disable=R1260
-        self, project_key: str, issue_type: str, fields: dict
-    ) -> None:
+    def validate_fields(self, project_key: str, issue_type: str, fields: dict) -> None:  # pylint: disable=R1260
         fields_metadata = self.get_project_fields_metadata(project_key=project_key, issue_type=issue_type)
         for custom_field, value in fields.items():
             if custom_field not in fields_metadata:
                 raise ValueError(
                     f'Invalid field(s) for project "{project_key}", issue type "{issue_type}": "{custom_field}"'
                 )
-
             if allowed_value := fields_metadata[custom_field].get("allowedValues"):
                 if not self._is_value_allowed(value=value, allowed_values=allowed_value):
                     raise ValueError(
@@ -309,7 +181,6 @@ class JiraPlus:
                         f"with issue type '{issue_type}'."
                         f"The allowed values are: {json.dumps(allowed_value, indent=4, sort_keys=True)}"
                     )
-
             field_type = fields_metadata[custom_field]["schema"]["type"]
             if field_type == "string" and not isinstance(value, str):
                 raise ValueError(f"Field '{custom_field}' must be a string")
@@ -323,7 +194,6 @@ class JiraPlus:
                 raise ValueError(f"Field '{custom_field}' must be an object")
             if field_type == "issuetype" and not isinstance(value, dict):
                 raise ValueError(f"Field '{custom_field}' must be an issue type")
-            # Add more field type checks as needed
 
     def create_issue(
         self,
@@ -334,21 +204,17 @@ class JiraPlus:
         assignee: str | None = None,
         custom_fields: dict | None = None,
     ) -> Issue | None:
-        issue_fields = {
+        issue_fields: dict[str, Any] = {
             "project": {"key": project_key},
             "issuetype": {"name": issue_type},
             "summary": summary,
             "description": description,
         }
         if assignee:
-            issue_fields["assignee"] = (
-                {"accountId": assignee} if self.server_type == ServerType.CLOUD else {"name": assignee}
-            )
-
+            issue_fields["assignee"] = self._format_assignee(assignee)
         if custom_fields:
             issue_fields = issue_fields | custom_fields
         self.validate_fields(project_key=project_key, issue_type=issue_type, fields=issue_fields)
-
         issue = self.jira_client.create_issue(fields=issue_fields)
         self.logger.info(f"Issue {issue.key} created successfully.")
         return issue
@@ -359,7 +225,6 @@ class JiraPlus:
             self.validate_fields(
                 project_key=issue.fields.project.key, issue_type=issue.fields.issuetype.name, fields=fields_to_update
             )
-
             issue.update(fields=fields_to_update)
             self.logger.info(f"Issue {issue.key} updated successfully.")
             return issue
@@ -398,7 +263,6 @@ class JiraPlus:
         available_link_types = self._get_available_link_types()
         if link_type not in available_link_types:
             raise ValueError(f"Invalid link type '{link_type}'. Available link types: {available_link_types}")
-
         try:
             self.jira_client.create_issue_link(
                 type=link_type,
@@ -438,12 +302,10 @@ class JiraPlus:
                     f"\nAvailable transitions: {transition_names}"
                 )
                 return False
-
             transition_id = next((t["id"] for t in transitions if t["name"].lower() == transition_name.lower()), None)
             if not transition_id:
                 self.logger.error(f"Transition '{transition_name}' not found for issue {issue_key}")
                 return False
-
             self.jira_client.transition_issue(
                 issue=issue_key, transition=transition_id, fields=fields or {}, comment=comment or None
             )
@@ -455,21 +317,3 @@ class JiraPlus:
         except Exception as err:
             self.logger.exception(f"Unexpected error during transition of {issue_key}: {err}")
             return False
-
-    def get_account_data(self, user_mail: str) -> list[dict]:
-        response = requests.get(
-            f"{self.server}/rest/api/3/user/search",
-            params={"query": user_mail},
-            auth=(self.jira_username, self.jira_token),
-            timeout=30,
-        )
-        response.raise_for_status()
-        return response.json()
-
-    def get_account_id(self, user_mail: str) -> str:
-        data = self.get_account_data(user_mail=user_mail)
-        return data[0]["accountId"]
-
-    def get_account_display_name(self, user_display_name: str) -> str:
-        data = self.get_account_data(user_mail=user_display_name)
-        return data[0]["displayName"]

python_jira_plus/jira_cloud.py

@@ -0,0 +1,111 @@
+# jira_cloud.py
+
+import logging
+import time
+
+import requests
+from jira import JIRA, Issue, JIRAError
+from jira.client import ResultList
+from retrying import retry
+
+from python_jira_plus.jira_base import JiraBase, UrlScheme
+
+
+class JiraCloud(JiraBase):
+    use_createmeta = True
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        urllib3_log_level: int = logging.WARNING,
+        jira_username: str | None = None,
+        jira_token: str | None = None,
+        verify_ssl: bool = True,
+        url_scheme: UrlScheme = UrlScheme.HTTPS,
+    ) -> None:
+        super().__init__(
+            base_url=base_url,
+            urllib3_log_level=urllib3_log_level,
+            jira_username=jira_username,
+            jira_token=jira_token,
+            verify_ssl=verify_ssl,
+            url_scheme=url_scheme,
+        )
+
+    @retry(stop_max_attempt_number=3, wait_fixed=180000)
+    def create_connection(self, timeout: int = 580) -> JIRA:
+        jira_client = JIRA(
+            basic_auth=(self.jira_username, self.jira_token),
+            options={"server": self.server, "verify": self.verify_ssl},
+            timeout=timeout,
+        )
+        if jira_client.projects():
+            self.logger.info("Jira Connection Successful")
+            return jira_client
+        self.logger.error("Jira Connection Failed")
+        raise JIRAError("Jira Connection Failed")
+
+    def _format_assignee(self, assignee: str) -> dict:
+        return {"accountId": assignee}
+
+    def _paginate(
+        self,
+        query: str,
+        max_results: int,
+        specific_fields: str | list[str],
+        jira_err_limit: int,
+        json_result: bool,
+    ) -> ResultList[Issue] | list:
+        all_issues = []
+        retries = 0
+        page = None
+        while True:  # pylint: disable=while-used
+            try:
+                next_token = None
+                if page is not None:
+                    next_token = page.get("nextPageToken") if json_result else page.nextPageToken
+
+                self.logger.debug(f"Fetching issues from startAt={len(all_issues)}")
+                page = self.jira_client.enhanced_search_issues(
+                    jql_str=query,
+                    nextPageToken=next_token,
+                    maxResults=max_results,
+                    fields=specific_fields,
+                    json_result=json_result,
+                )
+                if not page:
+                    break
+
+                all_issues += page["issues"] if json_result else page
+                if page["isLast"] if json_result else page.isLast:
+                    break
+                retries = 0
+            except JIRAError as err:
+                if err.status_code == 400:
+                    self.logger.error(f"Bad Request: {err.text}")
+                    raise JIRAError(f"Bad Request: {err.text}") from err
+                retries += 1
+                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
+                if retries >= jira_err_limit:
+                    self.logger.exception("Max retries exceeded.")
+                    return []
+                time.sleep(300 if retries == jira_err_limit - 1 else 90)
+        return all_issues
+
+    def get_account_data(self, user_mail: str) -> list[dict]:
+        response = requests.get(
+            f"{self.server}/rest/api/3/user/search",
+            params={"query": user_mail},
+            auth=(self.jira_username, self.jira_token),
+            timeout=30,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_account_id(self, user_mail: str) -> str:
+        data = self.get_account_data(user_mail=user_mail)
+        return data[0]["accountId"]
+
+    def get_account_display_name(self, user_display_name: str) -> str:
+        data = self.get_account_data(user_mail=user_display_name)
+        return data[0]["displayName"]

python_jira_plus/jira_on_premise.py

@@ -0,0 +1,98 @@
+# jira_on_premise.py
+
+import logging
+import time
+
+from jira import JIRA, Issue, JIRAError
+from jira.client import ResultList
+from packaging.version import Version
+from retrying import retry
+
+from python_jira_plus.jira_base import JiraBase, UrlScheme
+
+
+class JiraOnPremise(JiraBase):
+    def __init__(
+        self,
+        base_url: str | None = None,
+        urllib3_log_level: int = logging.WARNING,
+        jira_username: str | None = None,
+        jira_token: str | None = None,
+        verify_ssl: bool = True,
+        sso: bool = False,
+        url_scheme: UrlScheme = UrlScheme.HTTPS,
+    ) -> None:
+        self.sso = sso  # must be set before super().__init__ — create_connection reads it
+        super().__init__(
+            base_url=base_url,
+            urllib3_log_level=urllib3_log_level,
+            jira_username=jira_username,
+            jira_token=jira_token,
+            verify_ssl=verify_ssl,
+            url_scheme=url_scheme,
+        )
+        use_legacy = Version(".".join(str(x) for x in self.server_version)) < Version("9.0.0")
+        self.logger.debug(
+            f"Using {'legacy createmeta' if use_legacy else 'project_issue_types'} API "
+            f"(ON_PREMISE {self.server_version})"
+        )
+        self.use_createmeta = use_legacy
+
+    @retry(stop_max_attempt_number=3, wait_fixed=180000)
+    def create_connection(self, timeout: int = 580) -> JIRA:
+        auth = (
+            {"token_auth": self.jira_token} if not self.sso else {"basic_auth": (self.jira_username, self.jira_token)}
+        )
+        jira_client = JIRA(**auth, options={"server": self.server, "verify": self.verify_ssl}, timeout=timeout)
+        if jira_client.projects():
+            self.logger.info("Jira Connection Successful")
+            return jira_client
+        self.logger.error("Jira Connection Failed")
+        raise JIRAError("Jira Connection Failed")
+
+    def _format_assignee(self, assignee: str) -> dict:
+        return {"name": assignee}
+
+    def _paginate(
+        self,
+        query: str,
+        max_results: int,
+        specific_fields: str | list[str],
+        jira_err_limit: int,
+        json_result: bool,
+    ) -> ResultList[Issue] | list:
+        start_at = 0
+        all_issues = []
+        retries = 0
+        while True:  # pylint: disable=while-used
+            try:
+                self.logger.debug(f"Fetching issues from startAt={start_at}")
+                page = self.jira_client.search_issues(
+                    jql_str=query,
+                    startAt=start_at,
+                    maxResults=max_results,
+                    fields=specific_fields,
+                    json_result=json_result,
+                )
+                if not page:
+                    break
+
+                all_issues += page["issues"] if json_result else page
+                if json_result:
+                    start_at += page["maxResults"]
+                else:
+                    start_at += page.maxResults
+                if start_at >= max_results:
+                    break
+                retries = 0
+            except JIRAError as err:
+                if err.status_code == 400:
+                    self.logger.error(f"Bad Request: {err.text}")
+                    raise JIRAError(f"Bad Request: {err.text}") from err
+                retries += 1
+                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
+                if retries >= jira_err_limit:
+                    self.logger.exception("Max retries exceeded.")
+                    return []
+                time.sleep(300 if retries == jira_err_limit - 1 else 90)
+        return all_issues

{python_jira_plus-2.0.8.dist-info → python_jira_plus-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jira-plus
-Version: 2.0.8
+Version: 3.0.0
 Summary: Enhanced Python client for JIRA with better error handling, pagination, and metadata validation.
 Author: Avi Zaguri
 License: MIT

python_jira_plus-3.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+python_jira_plus/__init__.py,sha256=HMlPp5HOfdEO3VYE7Zc2qfhLsIPpPJ9wQaUojhCOp0k,729
+python_jira_plus/describe_allowed_value.py,sha256=fWfq0DkvJ2zmNIUXPH5rO5OgcY69bUqBIfTPQyxBt5E,1287
+python_jira_plus/jira_base.py,sha256=OKRm5ArLdQRLoQQuIz7rgKv_jKb2S23ADM_RSKghxjw,13839
+python_jira_plus/jira_cloud.py,sha256=pD5w2i3g7FpK-xk8dT9pHsNanAm257PlRt3O2glAFvA,3879
+python_jira_plus/jira_on_premise.py,sha256=NWWOgKmX5M8h58m1j4Rr3MRWK1vRIH2Itgae_76ezAA,3633
+python_jira_plus-3.0.0.dist-info/licenses/LICENSE,sha256=cSikHY6SZFsPZSBizCDAJ0-Bjjzxt-JtX6TVbKxwimo,1067
+python_jira_plus-3.0.0.dist-info/METADATA,sha256=A81DGwl6RL2VC70xOkibt1VtaIs1b6P1j3g47eu3OVo,4285
+python_jira_plus-3.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_jira_plus-3.0.0.dist-info/top_level.txt,sha256=3DxBdmf_naggoqDHSvLstG_GX3bW2XXYYorBDybBUiA,17
+python_jira_plus-3.0.0.dist-info/RECORD,,

python_jira_plus-2.0.8.dist-info/RECORD

@@ -1,8 +0,0 @@
-python_jira_plus/__init__.py,sha256=BUKjGxQfkxWyZs-mKZs2bAgGnsYHQ4uOFjuB8MPmhfg,616
-python_jira_plus/describe_allowed_value.py,sha256=fWfq0DkvJ2zmNIUXPH5rO5OgcY69bUqBIfTPQyxBt5E,1287
-python_jira_plus/jira_plus.py,sha256=TNJkwFdDbkaVrsEaO3kBRGHi_GDFVhRcpoX6bAgyRTs,19568
-python_jira_plus-2.0.8.dist-info/licenses/LICENSE,sha256=cSikHY6SZFsPZSBizCDAJ0-Bjjzxt-JtX6TVbKxwimo,1067
-python_jira_plus-2.0.8.dist-info/METADATA,sha256=AdZUwcmuzp3qtoFVuaB1En8QQqjKxFz6_3U99X6G-o8,4285
-python_jira_plus-2.0.8.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-python_jira_plus-2.0.8.dist-info/top_level.txt,sha256=3DxBdmf_naggoqDHSvLstG_GX3bW2XXYYorBDybBUiA,17
-python_jira_plus-2.0.8.dist-info/RECORD,,