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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pythonanywhere-core
-Version: 0.1.10
+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)

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pythonanywhere-core"
-version = "0.1.10"
+version = "0.2.0"
 description = "API wrapper for programmatic management of PythonAnywhere services."
 authors = ["PythonAnywhere <developers@pythonanywhere.com>"]
 license = "MIT"

pythonanywhere_core-0.2.0/pythonanywhere_core/__init__.py

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

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

@@ -20,7 +20,7 @@ def get_api_endpoint(username: str, flavor: str) -> str:
         "PYTHONANYWHERE_SITE",
         "www." + os.environ.get("PYTHONANYWHERE_DOMAIN", "pythonanywhere.com"),
     )
-    if flavor == "websites":
+    if flavor == "websites" or flavor == "domains":
         return f"https://{hostname}/api/v1/user/{username}/{flavor}/"
     return f"https://{hostname}/api/v0/user/{username}/{flavor}/"
 

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

@@ -9,37 +9,34 @@ 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(username=getpass.getuser(), flavor="files")
     path_endpoint = urljoin(base_url, "path")

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

@@ -8,19 +8,25 @@ from pythonanywhere_core.exceptions import PythonAnywhereApiException
 
 
 class Schedule:
-    """Interface for PythonAnywhere scheduled tasks API.
-
-    Uses `pythonanywhere_core.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."""
+    """
+    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")
 

{pythonanywhere_core-0.1.10 → 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(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.10 → pythonanywhere_core-0.2.0}/pythonanywhere_core/webapp.py

@@ -19,13 +19,13 @@ 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.username = getpass.getuser()

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.10/pythonanywhere_core/__init__.py

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

pythonanywhere_core-0.1.10/pythonanywhere_core/website.py

@@ -1,82 +0,0 @@
-import getpass
-
-from pythonanywhere_core.base import call_api, get_api_endpoint
-
-
-class Website:
-    """ Interface for PythonAnywhere websites API.
-
-    Uses ``pythonanywhere_core.base`` :method: ``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.
-
-    Use :method: ``Website.create`` to create new website.
-    Use :method: ``Website.get`` to get website info.
-    Use :method: ``Website.list`` to get all websites list.
-    Use :method: ``Website.reload`` to reload website.
-    Use :method: ``Website.delete`` to delete website.
-    """
-
-    api_endpoint = get_api_endpoint(username=getpass.getuser(), flavor="websites")
-
-    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.api_endpoint,
-            "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.api_endpoint}{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.api_endpoint,
-            "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.api_endpoint}{domain_name}/reload/",
-            "post",
-        )
-        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.api_endpoint}{domain_name}/",
-            "delete",
-        )
-        return {}