papi-projects 0.1.0__tar.gz

papi_projects-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: papi-projects
+Version: 0.1.0
+Summary: PAPI is an API for managing projects
+License: MIT
+Author: sandyjmacdonald
+Author-email: sandyjmacdonald@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: httpx (>=0.27.2,<0.28.0)
+Requires-Dist: pendulum (>=3.0.0,<4.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: tinydb (>=4.8.0,<5.0.0)
+Description-Content-Type: text/markdown
+
+

papi_projects-0.1.0/papi/__init__.py

@@ -0,0 +1,9 @@
+from dotenv import dotenv_values
+
+config = dotenv_values(".env")
+
+ASANA_API_KEY = config["ASANA_API_KEY"]
+ASANA_PASSWORD = config["ASANA_PASSWORD"]
+
+TOGGL_TRACK_API_KEY = config["TOGGL_TRACK_API_KEY"]
+TOGGL_TRACK_PASSWORD = config["TOGGL_TRACK_PASSWORD"]

papi_projects-0.1.0/papi/mocks.py

@@ -0,0 +1,76 @@
+import random
+
+
+def random_number(length):
+    return "".join([str(random.randint(1, 9)) for i in range(length)])
+
+
+def random_hex(length):
+    chars = "0123456789abcdef"
+    return "".join([str(random.choice(chars)) for i in range(length)])
+
+
+def get_mock_asana_api_key():
+    api_key = (
+        f"{random_number(1)}/{random_number(16)}/{random_number(16)}:{random_hex(32)}"
+    )
+    return api_key
+
+
+MOCK_ASANA_API_KEY = get_mock_asana_api_key()
+MOCK_ASANA_PASSWORD = ""
+
+mock_asana_my_id = random_number(16)
+mock_asana_workspace_id = random_number(13)
+mock_asana_team_id = random_number(16)
+
+mock_me_response = {
+    "data": {
+        "gid": f"{mock_asana_my_id}",
+        "email": "tobey.lambert@outlook.com",
+        "name": "Tobey Lambert",
+        "photo": {
+            "image_21x21": "https://placehold.co/21x21.png",
+            "image_27x27": "https://placehold.co/27x27.png",
+            "image_36x36": "https://placehold.co/36x36.png",
+            "image_60x60": "https://placehold.co/60x60.png",
+            "image_128x128": "https://placehold.co/128x128.png",
+        },
+        "resource_type": "user",
+        "workspaces": [
+            {
+                "gid": f"{mock_asana_workspace_id}",
+                "name": "myworkspace",
+                "resource_type": "workspace",
+            }
+        ],
+    }
+}
+
+mock_asana_workspace_name = mock_me_response["data"]["workspaces"][0]["name"]
+mock_asana_workspace_id = mock_me_response["data"]["workspaces"][0]["gid"]
+
+mock_teams_response = {
+    "data": [
+        {
+            "gid": f"{mock_asana_team_id}",
+            "name": "myteam",
+            "resource_type": "team",
+        }
+    ]
+}
+
+mock_template_id = random_number(16)
+
+mock_templates_response = {
+    "data": [
+        {
+            "gid": mock_template_id,
+            "name": "Mock Template",
+            "resource_type": "project_template",
+        }
+    ]
+}
+
+MOCK_TOGGL_TRACK_API_KEY = random_hex(16)
+MOCK_TOGGL_TRACK_PASSWORD = "api_token"

papi_projects-0.1.0/papi/project.py

@@ -0,0 +1,161 @@
+import pendulum
+import string
+import random
+import re
+import uuid
+import warnings
+from typing import Protocol, runtime_checkable
+from papi.user import check_user_id
+
+THIS_YEAR = pendulum.now().year
+
+
+def check_project_id(id: str) -> bool:
+    """Checks whether a project ID is correctly formed.
+
+    :param id: Project ID to check.
+    :type id: str
+    :return: True/False for whether project ID is correctly formed.
+    :rtype: bool
+    """
+    valid = False
+    pattern = re.compile(r"^P[0-9]{4}-[A-Z]{2}[A-Z0-9]{1}-[A-Z]{4}$")
+    if pattern.match(id):
+        valid = True
+    return valid
+
+
+def check_suffix(suffix: str) -> bool:
+    """Checks whether a project suffix is correctly formed.
+
+    :param suffix: Project suffix to check.
+    :type suffix: str
+    :return: True/False for whether project suffix is correctly formed.
+    :rtype: bool
+    """
+    valid = False
+    pattern = re.compile(r"^[A-Z]{4}$")
+    if pattern.match(suffix):
+        valid = True
+    return valid
+
+
+def check_uuid(p_uuid: str) -> bool:
+    """Checks whether a UUID is a valid version 4 UUID.
+
+    :param p_uuid: The UUID to check.
+    :type p_uuid: str
+    :return: True/False for whether the UUID is valid.
+    :rtype: bool
+    """
+    try:
+        uuid_obj = uuid.UUID(p_uuid, version=4)
+    except ValueError:
+        return False
+    return str(uuid_obj) == p_uuid
+
+
+@runtime_checkable
+class Project(Protocol):
+    """This class represents a project and all of its associated metadata.
+
+    :param year: Year associated with the project. If no year is supplied, then the current
+        year will be used, defaults to THIS_YEAR
+    :type year: int, optional
+    :param user_id: User ID associated with project. Must be a valid user ID, i.e. either
+        3 uppercase alphabetical initials, or 2 uppercase alphabetical initials followed
+        by a positive integer number, defaults to None
+    :type user_id: str, optional
+    :param suffix: Project suffix; a 4-character, random, uppercase, alphabetical suffix.
+        If not supplied, then this will be auto-generated, defaults to None
+    :type suffix: str, optional
+    :param id: Fully-formed project ID that can be supplied directly, assuming it is valid.
+        A valid project ID is of the form P2024-ABC-WXYZ where 2024 is the year associated
+        with the project, ABC is a valid 3-character user ID, and WXYZ is a valid 4-character
+        alphabetical suffix, defaults to None
+    :type id: str, optional
+    :param p_uuid: A valid version 4 UUID that can be supplied directly. If not supplied, then
+        this will be auto-generated, defaults to None
+    :type p_uuid: str, optional
+    :param name: A short, descriptive project name, e.g. "Mouse long-read RNA-seq analysis".
+        If not supplied, then this will be left as an empty string, defaults to ""
+    :type name: str, optional
+    :raises TypeError: If fully-formed project ID "id" is malformed, then a TypeError is raised.
+    """
+
+    def __init__(
+        self,
+        year: int = THIS_YEAR,
+        user_id: str = None,
+        suffix: str = None,
+        id: str = None,
+        p_uuid: str = None,
+        name: str = "",
+        grant_code: str = None,
+    ) -> None:
+        """Constructor method"""
+        self.year = year
+        self.user_id = user_id
+        self.grant_code = grant_code
+        self.name = name
+        if suffix is not None:
+            self.suffix = suffix
+        else:
+            self.generate_suffix()
+        if id is not None and check_project_id(id):
+            self.id = id
+        elif (
+            isinstance(year, int)
+            and check_user_id(user_id)
+            and check_suffix(self.suffix)
+        ):
+            self.id = f"P{self.year}-{self.user_id}-{self.suffix}"
+        else:
+            raise TypeError(
+                "ID is incorrectly formed, must similar to P2024-ABC-DEFG or P2024-AB1-DEFG"
+            )
+        if p_uuid is not None and check_uuid(p_uuid):
+            self.p_uuid = p_uuid
+        elif p_uuid is not None and not check_uuid(p_uuid):
+            self.p_uuid = str(uuid.uuid4())
+            warnings.warn(
+                "UUID provided is not valid UUID version 4, generating one instead..."
+            )
+        else:
+            self.p_uuid = str(uuid.uuid4())
+
+    def __str__(self) -> str:
+        """Human-readable representation of class. Currently just the project ID.
+
+        :return: Project ID.
+        :rtype: str
+        """
+        return self.id
+
+    def __repr__(self) -> str:
+        """Machine-readable representation of class. Currently just the project ID.
+
+        :return: Project ID.
+        :rtype: str
+        """
+        return self.id
+
+    def generate_suffix(self) -> str:
+        """Generates a 4-character, uppercase, alphabetical suffix for a project, and
+        sets the suffix.
+
+        :return: Project suffix.
+        :rtype: str
+        """
+        letters = string.ascii_uppercase
+        suffix = "".join(random.choice(letters) for i in range(4))
+        self.suffix = suffix
+        return self.suffix
+
+    def id_is_valid(self) -> bool:
+        """Checks whether a project ID is valid, i.e. correctly-formed.
+
+        :return: True/False for whether the project ID is valid.
+        :rtype: bool
+        """
+        return check_project_id(self.id)

papi_projects-0.1.0/papi/tests/test_project.py

@@ -0,0 +1,123 @@
+import pytest
+import uuid
+from papi.project import (
+    Project,
+    check_project_id,
+    check_user_id,
+    check_suffix,
+    check_uuid,
+    THIS_YEAR,
+)
+
+valid_project_ids = ["P2024-RST-ABCD", "P2024-RT1-ABCD"]
+invalid_project_ids = [
+    "2024-RST-ABCD",
+    "P2024-RT12-ABCD",
+    "P2024-RST-ABC1",
+    "R2024-RST-ABCD",
+    "P2024_RST_ABCD",
+    "P2024RSTABCD",
+]
+
+valid_suffixes = ["ABCD", "PQRS", "ZZZZ"]
+invalid_suffixes = ["ABC", "PQRST", "AB1", 1234]
+
+valid_uuids = [str(uuid.uuid4()), "2c173903-3b1c-4967-9a70-8f3a4607c06c"]
+invalid_uuids = [
+    "99a832b1-7c6d-4d06-96ac-a67a68f4a2b",
+    "271d761d-d0c8-4e1d-8ef9-99dad705453cd",
+]
+
+example_project_id = "P2024-RST-ABCD"
+example_year = 2024
+example_user_id = "RST"
+example_suffix = "ABCD"
+example_uuid = "2c173903-3b1c-4967-9a70-8f3a4607c06c"
+
+example_invalid_project_id = "P2024_RST_ABCD"
+example_invalid_uuid = "99a832b1-7c6d-4d06-96ac-a67a68f4a2b"
+
+
+@pytest.fixture
+def proj() -> Project:
+    return Project(
+        year=example_year,
+        user_id=example_user_id,
+        suffix=example_suffix,
+        p_uuid=example_uuid,
+    )
+
+
+def test_check_project_id_valid() -> None:
+    for valid_project_id in valid_project_ids:
+        assert check_project_id(valid_project_id) is True
+
+
+def test_check_project_id_invalid() -> None:
+    for invalid_project_id in invalid_project_ids:
+        assert check_project_id(invalid_project_id) is False
+
+
+def test_check_suffix_valid() -> None:
+    for valid_suffix in valid_suffixes:
+        assert check_suffix(valid_suffix) is True
+
+
+def test_check_suffix_invalid() -> None:
+    for invalid_suffix in invalid_suffixes:
+        if isinstance(invalid_suffix, str):
+            assert check_suffix(invalid_suffix) is False
+        else:
+            with pytest.raises(TypeError):
+                check_suffix(invalid_suffix)
+
+
+def test_check_uuid_valid() -> None:
+    for valid_uuid in valid_uuids:
+        assert check_uuid(valid_uuid) is True
+
+
+def test_check_uuid_invalid() -> None:
+    for invalid_uuid in invalid_uuids:
+        assert check_uuid(invalid_uuid) is False
+
+
+def test_create_project(proj) -> None:
+    assert proj.id == example_project_id
+    assert proj.year == example_year
+    assert proj.user_id == example_user_id
+    assert proj.suffix == example_suffix
+    assert proj.p_uuid == example_uuid
+
+
+def test_minimal_project() -> None:
+    proj = Project(user_id=example_user_id)
+    assert proj.year == THIS_YEAR
+    assert check_suffix(proj.suffix) is True
+
+
+def test_preformed_project_id() -> None:
+    proj = Project(id=example_project_id)
+    assert proj.id_is_valid() is True
+
+
+def test_malformed_project_id() -> None:
+    with pytest.raises(TypeError):
+        Project(id=example_invalid_project_id)
+
+
+def test_incorrect_uuid() -> None:
+    with pytest.warns(UserWarning):
+        Project(user_id=example_user_id, p_uuid=example_invalid_uuid)
+
+
+def test_str(proj) -> None:
+    assert str(proj) == proj.id
+
+
+def test_repr(proj) -> None:
+    assert repr(proj) == proj.id
+
+
+def test_project_id_is_valid(proj) -> None:
+    assert proj.id_is_valid() is True

papi_projects-0.1.0/papi/tests/test_user.py

@@ -0,0 +1,121 @@
+import pytest
+import os
+import json
+from papi.user import UserDB, user_name_to_user_id, check_user_id
+from tinydb import TinyDB, Query
+
+working_dir = os.getcwd()
+test_user_db = f"{working_dir}/papi/tests/test_userdb.json"
+
+with open(test_user_db, "w") as out:
+    out.write("""{
+    "_default": {
+        "1": {
+            "email": "jasmith@dummymail.com",
+            "user_id": "JAS",
+            "user_name": "John Adam Smith"
+        },
+        "2": {
+            "email": "jsmith@dummymail.com",
+            "user_id": "JS1",
+            "user_name": "James Smith"
+        }
+    }
+}""")
+
+with open(test_user_db, "r") as f:
+    test_user_db_dict = json.load(f)
+
+user_names = [
+    test_user_db_dict["_default"][k]["user_name"]
+    for k in test_user_db_dict["_default"].keys()
+]
+
+test_users = [
+    ("Adam Brian Cooper", "ab.cooper@dummymail.com"),
+    ("Angela Barbara Cartwright", "ab.cartwright@dummymail.com"),
+    ("Andrew Baxter", "a.baxter@dummymail.com"),
+    ("Alan Donald", "a.donald@dummymail.com"),
+    ("Andrew Duncan", "a.duncan@dummymail.com"),
+]
+
+incorrect_user_name = "Alan Brian Charlie Donald"
+incorrect_email = "ab.cooper@dummymail"
+
+valid_user_ids = ["RST", "RT1"]
+invalid_user_ids = ["RT12", "RSTU", "RT", 123]
+
+
+@pytest.fixture()
+def user_db() -> UserDB:
+    return UserDB(test_user_db)
+
+
+def test_user_name_to_user_id():
+    for u in user_names:
+        assert user_name_to_user_id(u) == "".join([w[0] for w in u.split()])
+
+
+def test_check_user_id_valid() -> None:
+    for valid_user_id in valid_user_ids:
+        assert check_user_id(valid_user_id) is True
+
+
+def test_check_user_id_invalid() -> None:
+    for invalid_user_id in invalid_user_ids:
+        assert check_user_id(invalid_user_id) is False
+
+
+def test_create_new_userdb():
+    new_user_db = "new_userdb.json"
+    UserDB(new_user_db)
+    assert os.path.exists(new_user_db)
+    os.remove(new_user_db)
+
+
+def test_create_existing_userdb(user_db):
+    assert type(user_db.db) is TinyDB
+    Users = Query()
+    for u in user_names:
+        result = user_db.db.search(Users.user_name == u)
+        assert len(result) > 0
+
+
+def test_open_default_userdb():
+    user_db = UserDB()
+    assert type(user_db.db) is TinyDB
+
+
+def test_insert_user(user_db):
+    for u in test_users:
+        user_db.insert_user(u[0], email=u[1])
+        Users = Query()
+        result = user_db.db.search((Users.user_name == u[0]) & (Users.email == u[1]))
+        assert len(result) > 0
+
+
+def test_insert_existing_user(user_db):
+    u = user_db.insert_user(user_names[0])
+    inserted_user_id = user_db.db.get(doc_id=u)["user_id"]
+    assert inserted_user_id != user_name_to_user_id(user_names[0])
+
+
+def test_incorrect_name_length(user_db):
+    with pytest.raises(ValueError):
+        user_db.insert_user(incorrect_user_name)
+
+
+def test_incorrect_email(user_db):
+    with pytest.raises(ValueError):
+        user_db.insert_user(test_users[0][0], email=incorrect_email)
+
+
+def test_search_by_user_name(user_db):
+    result = user_db.search_by_user_name(test_users[0][0])
+    assert len(result) > 0
+
+
+def test_search_by_user_id(user_db):
+    user_id = "".join([w[0] for w in test_users[0][0].split()])
+    result = user_db.search_by_user_id(user_id)
+    assert len(result) > 0

papi_projects-0.1.0/papi/tests/test_userdb.json

@@ -0,0 +1,44 @@
+{
+    "_default": {
+        "1": {
+            "email": "jasmith@dummymail.com",
+            "user_id": "JAS",
+            "user_name": "John Adam Smith"
+        },
+        "2": {
+            "email": "jsmith@dummymail.com",
+            "user_id": "JS1",
+            "user_name": "James Smith"
+        },
+        "3": {
+            "email": "ab.cooper@dummymail.com",
+            "user_id": "ABC",
+            "user_name": "Adam Brian Cooper"
+        },
+        "4": {
+            "email": "ab.cartwright@dummymail.com",
+            "user_id": "AC1",
+            "user_name": "Angela Barbara Cartwright"
+        },
+        "5": {
+            "email": "a.baxter@dummymail.com",
+            "user_id": "AB1",
+            "user_name": "Andrew Baxter"
+        },
+        "6": {
+            "email": "a.donald@dummymail.com",
+            "user_id": "AD1",
+            "user_name": "Alan Donald"
+        },
+        "7": {
+            "email": "a.duncan@dummymail.com",
+            "user_id": "AD2",
+            "user_name": "Andrew Duncan"
+        },
+        "8": {
+            "email": null,
+            "user_id": "JS2",
+            "user_name": "John Adam Smith"
+        }
+    }
+}

papi_projects-0.1.0/papi/tests/test_wrappers.py

@@ -0,0 +1,108 @@
+import pytest
+import httpx
+import json
+from papi.wrappers import AsanaWrapper
+from papi.mocks import (
+    MOCK_ASANA_API_KEY,
+    MOCK_ASANA_PASSWORD,
+    mock_me_response,
+    mock_teams_response,
+    mock_templates_response,
+    mock_asana_workspace_name,
+    mock_asana_workspace_id,
+    MOCK_TOGGL_TRACK_API_KEY,
+    MOCK_TOGGL_TRACK_PASSWORD,
+)
+from papi.project import Project
+
+mock_my_id = mock_me_response["data"]["gid"]
+
+mock_team_id = mock_teams_response["data"][0]["gid"]
+mock_team_name = mock_teams_response["data"][0]["name"]
+
+
+def handler(request):
+    print(request.url)
+    if request.url == "https://app.asana.com/api/1.0/users/me":
+        return httpx.Response(200, json=mock_me_response)
+    elif str(request.url).startswith(
+        f"https://app.asana.com/api/1.0/users/{mock_my_id}/teams"
+    ):
+        return httpx.Response(200, json=mock_teams_response)
+    elif (
+        request.url
+        == f"https://app.asana.com/api/1.0/teams/{mock_team_id}/project_templates"
+    ):
+        return httpx.Response(200, json=mock_templates_response)
+
+
+class MockAsanaWrapper(AsanaWrapper):
+    def connect(self) -> httpx.Client:
+        transport = httpx.MockTransport(handler)
+        auth = httpx.BasicAuth(username=self.api_token, password=self.password)
+        self.client = httpx.Client(transport=transport, auth=auth)
+        return self.client
+
+
+@pytest.fixture()
+def asana() -> MockAsanaWrapper:
+    return MockAsanaWrapper(MOCK_ASANA_API_KEY, MOCK_ASANA_PASSWORD)
+
+
+def test_get_me(asana):
+    me = asana.get_me()
+    assert me == mock_me_response["data"]
+
+
+def test_set_me(asana):
+    asana.set_me()
+    assert asana.my_id is not None
+    assert asana.workspaces is not None
+
+
+def test_get_teams(asana):
+    workspace_id = asana.set_default_workspace(mock_asana_workspace_name)
+    teams = asana.get_teams(workspace_id)
+    assert teams == mock_teams_response["data"]
+
+
+def test_set_teams(asana):
+    asana.set_teams(mock_asana_workspace_id)
+    assert asana.teams is not None
+
+
+def test_get_team_id_by_name(asana):
+    with pytest.raises(AttributeError):
+        asana.get_team_id_by_name(mock_team_name)
+    asana.set_teams(mock_asana_workspace_id)
+    assert asana.get_team_id_by_name(mock_team_name) == mock_team_id
+
+
+def test_set_default_team(asana):
+    asana.set_teams(mock_asana_workspace_id)
+    asana.set_default_team(mock_team_name)
+    assert asana.default_team_id == mock_team_id
+
+
+example_year = 2024
+example_user_id = "RST"
+example_suffix = "ABCD"
+example_uuid = "2c173903-3b1c-4967-9a70-8f3a4607c06c"
+
+proj = Project(
+    year=example_year,
+    user_id=example_user_id,
+    suffix=example_suffix,
+    p_uuid=example_uuid,
+)
+
+
+def test_get_templates(asana):
+    templates = asana.get_templates(mock_team_id)
+    assert templates == mock_templates_response["data"]
+
+
+def test_create_project(asana):
+    with pytest.raises(TypeError):
+        asana.create_project("foo", mock_asana_workspace_id, mock_team_id)
+    asana.create_project(proj, mock_asana_workspace_id, mock_team_id)