pythonanywhere-core 0.1.9__tar.gz → 0.2.0__tar.gz

{pythonanywhere_core-0.1.9 → pythonanywhere_core-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pythonanywhere-core
-Version: 0.1.9
+Version: 0.2.0
 Summary: API wrapper for programmatic management of PythonAnywhere services.
 License: MIT
 Keywords: pythonanywhere,api,cloud,web hosting
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
 Requires-Dist: requests (>=2.30.0,<3.0.0)
@@ -25,7 +26,30 @@ Description-Content-Type: text/x-rst
 
 API wrapper for programmatic management of PythonAnywhere services.
 
-It's an extraction and improvement of core code behind `PythonAnywhere cli tool`_.
+It's a core code behind `PythonAnywhere cli tool`_.
 
 .. _PythonAnywhere cli tool: https://pypi.org/project/pythonanywhere/
 
+
+Development
+===========
+
+To create local development environment, run:
+
+.. code-block:: shell
+
+    poetry install
+
+To run tests:
+
+.. code-block:: shell
+
+    poetry run pytest
+
+To build docs:
+
+.. code-block:: shell
+
+    cd docs
+    poetry run sphinx-build -b html . _build
+

pythonanywhere_core-0.2.0/README.rst

@@ -0,0 +1,28 @@
+API wrapper for programmatic management of PythonAnywhere services.
+
+It's a core code behind `PythonAnywhere cli tool`_.
+
+.. _PythonAnywhere cli tool: https://pypi.org/project/pythonanywhere/
+
+
+Development
+===========
+
+To create local development environment, run:
+
+.. code-block:: shell
+
+    poetry install
+
+To run tests:
+
+.. code-block:: shell
+
+    poetry run pytest
+
+To build docs:
+
+.. code-block:: shell
+
+    cd docs
+    poetry run sphinx-build -b html . _build

{pythonanywhere_core-0.1.9 → pythonanywhere_core-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pythonanywhere-core"
-version = "0.1.9"
+version = "0.2.0"
 description = "API wrapper for programmatic management of PythonAnywhere services."
 authors = ["PythonAnywhere <developers@pythonanywhere.com>"]
 license = "MIT"
@@ -39,3 +39,7 @@ line-length = 120
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"

pythonanywhere_core-0.2.0/pythonanywhere_core/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.2.0'

{pythonanywhere_core-0.1.9 → pythonanywhere_core-0.2.0}/pythonanywhere_core/base.py

@@ -15,12 +15,14 @@ PYTHON_VERSIONS: Dict[str, str] = {
 }
 
 
-def get_api_endpoint() -> str:
+def get_api_endpoint(username: str, flavor: str) -> str:
     hostname = os.environ.get(
         "PYTHONANYWHERE_SITE",
         "www." + os.environ.get("PYTHONANYWHERE_DOMAIN", "pythonanywhere.com"),
     )
-    return f"https://{hostname}/api/v0/user/{{username}}/{{flavor}}/"
+    if flavor == "websites" or flavor == "domains":
+        return f"https://{hostname}/api/v1/user/{username}/{flavor}/"
+    return f"https://{hostname}/api/v0/user/{username}/{flavor}/"
 
 
 def helpful_token_error_message() -> str:

{pythonanywhere_core-0.1.9 → pythonanywhere_core-0.2.0}/pythonanywhere_core/files.py

@@ -9,39 +9,36 @@ from pythonanywhere_core.exceptions import PythonAnywhereApiException
 
 
 class Files:
-    """ Interface for PythonAnywhere files API.
-
-    Uses `pythonanywhere_core.base` :method: `get_api_endpoint` to
-    create url, which is stored in a class variable `Files.base_url`,
-    then calls `call_api` with appropriate arguments to execute files
-    action.
-
-    Covers:
-    - GET, POST and DELETE for files path endpoint
-    - POST, GET and DELETE for files sharing endpoint
-    - GET for tree endpoint
-
-    "path" methods:
-    - use :method: `Files.path_get` to get contents of file or
-    directory from `path`
-    - use :method: `Files.path_post` to upload or update file at given
-    `dest_path` using contents from `source`
-    - use :method: `Files.path_delete` to delete file/directory on on
-    given `path`
-
-    "sharing" methods:
-    - use :method: `Files.sharing_post` to enable sharing a file from
-    `path` (if not shared before) and get a link to it
-    - use :method: `Files.sharing_get` to get sharing url for `path`
-    - use :method: `Files.sharing_delete` to disable sharing for
-    `path`
-
-    "tree" method:
-    - use :method: `Files.tree_get` to get list of regular files and
-    subdirectories of a directory at `path` (limited to 1000 results)
     """
+    Interface for the PythonAnywhere Files API.
+
+    This class uses the `get_api_endpoint` function from ``pythonanywhere_core.base``
+    to construct the API URL, which is stored in the class variable ``base_url``.
+    It then calls the ``call_api`` method with the appropriate arguments to
+    perform file-related actions.
+
+    Supported Endpoints:
+        - `GET`, `POST`, and `DELETE` for the files path endpoint.
+        - `POST`, `GET`, and `DELETE` for the file sharing endpoint.
+        - `GET` for the tree endpoint.
+
+    Path Methods:
+        - :meth:`Files.path_get`: Retrieve the contents of a file or directory from a specified `path`.
+        - :meth:`Files.path_post`: Upload or update a file at the given `dest_path` using contents from `source`.
+        - :meth:`Files.path_delete`: Delete a file or directory at the specified `path`.
+
+    Sharing Methods:
+        - :meth:`Files.sharing_post`: Enable sharing of a file from the given `path` (if not already shared) and get a link to it.
+        - :meth:`Files.sharing_get`: Retrieve the sharing URL for a specified `path`.
+        - :meth:`Files.sharing_delete`: Disable sharing for a specified `path`.
+
+    Tree Method:
+        - :meth:`Files.tree_get`: Retrieve a list of regular files and subdirectories of a directory at the specified `path`
+          (limited to 1000 results).
+    """
+
 
-    base_url = get_api_endpoint().format(username=getpass.getuser(), flavor="files")
+    base_url = get_api_endpoint(username=getpass.getuser(), flavor="files")
     path_endpoint = urljoin(base_url, "path")
     sharing_endpoint = urljoin(base_url, "sharing/")
     tree_endpoint = urljoin(base_url, "tree/")
@@ -116,7 +113,7 @@ class Files:
             f"DELETE on {url} failed, got {result}{self._error_msg(result)}"
         )
 
-    def sharing_post(self, path: str) -> Tuple[int, str]:
+    def sharing_post(self, path: str) -> Tuple[str, str]:
         """Starts sharing a file at `path`.
 
         Returns a tuple with a message and sharing link on
@@ -176,4 +173,4 @@ class Files:
         if result.ok:
             return result.json()
 
-        raise PythonAnywhereApiException(f"GET to {url} failed, got {result}{self._error_msg(result)}")
+        raise PythonAnywhereApiException(f"GET to {url} failed, got {result}{self._error_msg(result)}")

{pythonanywhere_core-0.1.9 → pythonanywhere_core-0.2.0}/pythonanywhere_core/schedule.py

@@ -8,21 +8,27 @@ from pythonanywhere_core.exceptions import PythonAnywhereApiException
 
 
 class Schedule:
-    """Interface for PythonAnywhere scheduled tasks API.
-
-    Uses `pythonanywhere.api` :method: `get_api_endpoint` to create url,
-    which is stored in a class variable `Schedule.base_url`, then calls
-    `call_api` with appropriate arguments to execute scheduled tasks tasks
-    actions. Covers 'GET' and 'POST' methods for tasks list, as well as
-    'GET', 'PATCH' and 'DELETE' methods for task with id.
-
-    Use :method: `Schedule.get_list` to get all tasks list.
-    Use :method: `Schedule.create` to create new task.
-    Use :method: `Schedule.get_specs` to get existing task specs.
-    Use :method: `Schedule.delete` to delete existing task.
-    Use :method: `Schedule.update` to update existing task."""
-
-    base_url: str = get_api_endpoint().format(username=getpass.getuser(), flavor="schedule")
+    """
+    Interface for the PythonAnywhere Scheduled Tasks API.
+
+    This class uses the `get_api_endpoint` function from ``pythonanywhere_core.api``
+    to construct the API URL, which is stored in the class variable ``base_url``.
+    It then calls the ``call_api`` method with appropriate arguments to perform
+    actions related to scheduled tasks.
+
+    Supported HTTP Methods:
+        - `GET` and `POST` for the tasks list.
+        - `GET`, `PATCH`, and `DELETE` for tasks with an ID.
+
+    Methods:
+        - :meth:`Schedule.get_list`: Retrieve the list of all scheduled tasks.
+        - :meth:`Schedule.create`: Create a new scheduled task.
+        - :meth:`Schedule.get_specs`: Retrieve the specifications of an existing task.
+        - :meth:`Schedule.delete`: Delete an existing task.
+        - :meth:`Schedule.update`: Update an existing task.
+    """
+
+    base_url: str = get_api_endpoint(username=getpass.getuser(), flavor="schedule")
 
     def create(self, params: dict) -> Optional[dict]:
         """Creates new scheduled task using `params`.

{pythonanywhere_core-0.1.9 → pythonanywhere_core-0.2.0}/pythonanywhere_core/students.py

@@ -5,26 +5,30 @@ from pythonanywhere_core.base import call_api, get_api_endpoint
 
 
 class StudentsAPI:
-    """Interface for PythonAnywhere students API.
+    """
+    Interface for the PythonAnywhere Students API.
 
-    Uses `pythonanywhere.api.base` :method: `get_api_endpoint` to
-    create url, which is stored in a class variable `StudentsAPI.base_url`,
-    then calls `call_api` with appropriate arguments to execute student
-    action.
+    This class uses the `get_api_endpoint` function from
+    ``pythonanywhere.api.base`` to construct the API URL, which is stored
+    in the class variable ``base_url``. It then calls the ``call_api`` method
+    with the appropriate arguments to perform student-related actions.
 
-    Covers:
-    - GET
-    - DELETE
+    Supported HTTP Methods:
+        - `GET`
+        - `DELETE`
 
     Methods:
-    - use :method: `StudentsAPI.get` to get list of students
-    - use :method: `StudentsAPI.delete` to remove a student
+        - :meth:`StudentsAPI.get`: Retrieve a list of students.
+        - :meth:`StudentsAPI.delete`: Remove a student.
     """
 
-    base_url: str = get_api_endpoint().format(username=getpass.getuser(), flavor="students")
+    base_url: str = get_api_endpoint(username=getpass.getuser(), flavor="students")
 
     def get(self) -> Optional[dict]:
-        """Returns list of PythonAnywhere students related with user's account."""
+        """Returns list of PythonAnywhere students related with user's account.
+
+        :returns: dictionary with students info
+        """
 
         result = call_api(self.base_url, "GET")
 
@@ -34,7 +38,11 @@ class StudentsAPI:
         raise Exception(f"GET to list students failed, got {result.text}")
 
     def delete(self, student_username: str) -> Optional[int]:
-        """Returns 204 if student has been successfully removed, raises otherwise."""
+        """Returns 204 if student has been successfully removed, raises otherwise.
+
+        :param student_username: student username to be removed
+        :returns: 204 if student has been successfully removed
+        """
 
         url = f"{self.base_url}{student_username}"
 

{pythonanywhere_core-0.1.9 → pythonanywhere_core-0.2.0}/pythonanywhere_core/webapp.py

@@ -19,19 +19,18 @@ class Webapp:
     then calls `call_api` with appropriate arguments to execute webapps
     action.
 
-    Use :method: `Webapp.create` to create new webapp.
-    Use :method: `Webapp.reload` to reload webapp.
-    Use :method: `Webapp.set_ssl` to set SSL certificate and private key.
-    Use :method: `Webapp.get_ssl_info` to get SSL certificate info.
-    Use :method: `Webapp.delete_log` to delete log file.
-    Use :method: `Webapp.get_log_info` to get log files info.
-
+    Methods:
+        - :meth:`Webapp.create`: Create a new webapp.
+        - :meth:`Webapp.reload`: Reload the webapp.
+        - :meth:`Webapp.set_ssl`: Set the SSL certificate and private key.
+        - :meth:`Webapp.get_ssl_info`: Retrieve SSL certificate information.
+        - :meth:`Webapp.delete_log`: Delete a log file.
+        - :meth:`Webapp.get_log_info`: Retrieve log file information.
     """
     def __init__(self, domain: str) -> None:
-        self.endpoint = get_api_endpoint()
         self.username = getpass.getuser()
-        self.files_url = self.endpoint.format(username=self.username, flavor="files")
-        self.webapps_url = self.endpoint.format(username=self.username, flavor="webapps")
+        self.files_url = get_api_endpoint(username=self.username, flavor="files")
+        self.webapps_url = get_api_endpoint(username=self.username, flavor="webapps")
         self.domain = domain
         self.domain_url = f"{self.webapps_url}{self.domain}/"
 

pythonanywhere_core-0.2.0/pythonanywhere_core/website.py

@@ -0,0 +1,111 @@
+import getpass
+
+from pythonanywhere_core.base import call_api, get_api_endpoint
+from pythonanywhere_core.exceptions import PythonAnywhereApiException
+
+
+
+class Website:
+    """ Interface for PythonAnywhere websites API.
+
+    Uses ``pythonanywhere_core.base`` function ``get_api_endpoint`` to
+    create url, which is stored in a class variable ``Website.api_endpoint``,
+    then calls ``call_api`` with appropriate arguments to execute websites
+    action.
+
+    Methods:
+        - :meth:`Website.create`: Create a new website.
+        - :meth:`Website.get`: Retrieve information about a specific website.
+        - :meth:`Website.list`: Get a list of all websites.
+        - :meth:`Website.reload`: Reload the website.
+        - :meth:`Website.auto_ssl`: Create and apply a Let's Encrypt SSL certificate.
+        - :meth:`Website.get_ssl_info`: Get SSL certificate information.
+        - :meth:`Website.delete`: Delete a website.
+    """
+
+    def __init__(self) -> None:
+        self.websites_base_url = get_api_endpoint(username=getpass.getuser(), flavor="websites")
+        self.domains_base_url = get_api_endpoint(username=getpass.getuser(), flavor="domains")
+
+    def create(self, domain_name: str, command: str) -> dict:
+        """Creates new website with ``domain_name`` and ``command``.
+
+        :param domain_name: domain name for new website
+        :param command: command for new website
+        :returns: dictionary with created website info"""
+
+        response = call_api(
+            self.websites_base_url,
+            "post",
+            json={
+                "domain_name": domain_name,
+                "enabled": True,
+                "webapp": {"command": command}
+            }
+        )
+        return response.json()
+
+    def get(self, domain_name: str) -> dict:
+        """Returns dictionary with website info for ``domain_name``.
+        :param domain_name:
+        :return: dictionary with website info"""
+
+        response = call_api(
+            f"{self.websites_base_url}{domain_name}/",
+            "get",
+        )
+        return response.json()
+
+    def list(self) -> list:
+        """Returns list of dictionaries with all websites info.
+        :return: list of dictionaries with websites info"""
+
+        response = call_api(
+            self.websites_base_url,
+            "get",
+        )
+        return response.json()
+
+    def reload(self, domain_name: str) -> dict:
+        """Reloads website with ``domain_name``.
+        :param domain_name: domain name for website to reload
+        :return: dictionary with response"""
+
+        response = call_api(
+            f"{self.websites_base_url}{domain_name}/reload/",
+            "post",
+        )
+        return response.json()
+
+    def auto_ssl(self, domain_name: str) -> dict:
+        """Creates and applies a Let's Encrypt certificate for ``domain_name``.
+        :param domain_name: domain name for website to apply the certificate to
+        :return: dictionary with response"""
+        response = call_api(
+            f"{self.domains_base_url}{domain_name}/ssl/",
+            "post",
+            json={"cert_type": "letsencrypt-auto-renew"}
+        )
+        return response.json()
+
+    def get_ssl_info(self, domain_name) -> dict:
+        """Get SSL certificate info
+        :param domain_name: domain name for website to get SSL info
+        :return: dictionary with SSL certificate info"""
+        url = f"{self.domains_base_url}{domain_name}/ssl/"
+        response = call_api(url, "get")
+        if not response.ok:
+            raise PythonAnywhereApiException(f"GET SSL details via API failed, got {response}:{response.text}")
+
+        return response.json()
+
+    def delete(self, domain_name: str) -> dict:
+        """Deletes website with ``domain_name``.
+        :param domain_name: domain name for website to delete
+        :return: empty dictionary"""
+
+        call_api(
+            f"{self.websites_base_url}{domain_name}/",
+            "delete",
+        )
+        return {}

pythonanywhere_core-0.1.9/README.rst

@@ -1,5 +0,0 @@
-API wrapper for programmatic management of PythonAnywhere services.
-
-It's an extraction and improvement of core code behind `PythonAnywhere cli tool`_.
-
-.. _PythonAnywhere cli tool: https://pypi.org/project/pythonanywhere/

pythonanywhere_core-0.1.9/pythonanywhere_core/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.1.9'