pythonanywhere-core 0.2.3__tar.gz → 0.2.5__tar.gz

{pythonanywhere_core-0.2.3 → pythonanywhere_core-0.2.5}/PKG-INFO

@@ -1,21 +1,20 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pythonanywhere-core
-Version: 0.2.3
+Version: 0.2.5
 Summary: API wrapper for programmatic management of PythonAnywhere services.
 License: MIT
 Keywords: pythonanywhere,api,cloud,web hosting
 Author: PythonAnywhere
 Author-email: developers@pythonanywhere.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-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.2.3 → pythonanywhere_core-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pythonanywhere-core"
-version = "0.2.3"
+version = "0.2.5"
 description = "API wrapper for programmatic management of PythonAnywhere services."
 authors = ["PythonAnywhere <developers@pythonanywhere.com>"]
 license = "MIT"
@@ -10,28 +10,27 @@ classifiers = [
     "Intended Audience :: Developers",
     "Topic :: Software Development :: Libraries",
     "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.8",
 ]
 keywords = ["pythonanywhere", "api", "cloud", "web hosting"]
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.10"
 python-dateutil = "^2.8.2"
 requests = "^2.30.0"
 snakesay = "^0.10.3"
 typing_extensions = "^4.5.0"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"
 pytest-cov = "^5.0.0"
 pytest-mock = "^3.10.0"
 responses = "^0.25.0"
-sphinx = "7.1.2"
-sphinx-rtd-theme = "^2.0.0"
+sphinx = "7.4.7"
+sphinx-rtd-theme = "^3.0.0"
 
 [tool.black]
 line-length = 120

pythonanywhere_core-0.2.5/pythonanywhere_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.5"

{pythonanywhere_core-0.2.3 → pythonanywhere_core-0.2.5}/pythonanywhere_core/base.py

@@ -12,6 +12,8 @@ PYTHON_VERSIONS: Dict[str, str] = {
     "3.9": "python39",
     "3.10": "python310",
     "3.11": "python311",
+    "3.12": "python312",
+    "3.13": "python313",
 }
 
 

{pythonanywhere_core-0.2.3 → pythonanywhere_core-0.2.5}/pythonanywhere_core/webapp.py

@@ -4,6 +4,7 @@ import os
 import getpass
 from pathlib import Path
 from textwrap import dedent
+from typing import Any
 
 from dateutil.parser import parse
 from snakesay import snakesay
@@ -21,16 +22,25 @@ class Webapp:
 
     Methods:
         - :meth:`Webapp.create`: Create a new webapp.
+        - :meth:`Webapp.create_static_file_mapping`: Create a static file mapping.
+        - :meth:`Webapp.add_default_static_files_mappings`: Add default static files mappings.
         - :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.
+        - :meth:`Webapp.get`: Retrieve webapp information.
+        - :meth:`Webapp.delete`: Delete webapp.
+        - :meth:`Webapp.patch`: Patch webapp.
+
+    Class Methods:
+        - :meth:`Webapp.list_webapps`: List all webapps for the current user.
     """
+    username = getpass.getuser()
+    files_url = get_api_endpoint(username=username, flavor="files")
+    webapps_url = get_api_endpoint(username=username, flavor="webapps")
+
     def __init__(self, domain: str) -> None:
-        self.username = getpass.getuser()
-        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}/"
 
@@ -38,7 +48,12 @@ class Webapp:
         return self.domain == other.domain
 
     def sanity_checks(self, nuke: bool) -> None:
-        """Check that we have a token, and that we don't already have a webapp for this domain"""
+        """Check that we have a token, and that we don't already have a webapp for this domain.
+
+        :param nuke: if True, skip the check for existing webapp
+
+        :raises SanityException: if API token is missing or webapp already exists
+        """
         print(snakesay("Running API sanity checks"))
         token = os.environ.get("API_TOKEN")
         if not token:
@@ -71,7 +86,6 @@ class Webapp:
 
         :raises PythonAnywhereApiException: if API call fails
         """
-        print(snakesay("Creating web app via API"))
         if nuke:
             call_api(self.domain_url, "delete")
         response = call_api(
@@ -89,21 +103,31 @@ class Webapp:
                 "PATCH to set virtualenv path and source directory via API failed," f"got {response}:{response.text}"
             )
 
+    def create_static_file_mapping(self, url_path: str, directory_path: Path) -> None:
+        """Create a static file mapping via the API.
+
+        :param url_path: URL path (e.g., '/static/')
+        :param directory_path: Filesystem path to serve (as Path)
+
+        :raises PythonAnywhereApiException: if API call fails
+        """
+        url = f"{self.domain_url}static_files/"
+        call_api(url, "post", json=dict(url=url_path, path=str(directory_path)))
+
     def add_default_static_files_mappings(self, project_path: Path) -> None:
-        """Add default static files mappings for /static/ and /media/
+        """Add default static files mappings for /static/ and /media/.
 
         :param project_path: path to the project
+
+        :raises PythonAnywhereApiException: if API call fails
         """
-        print(snakesay("Adding static files mappings for /static/ and /media/"))
-        url = f"{self.domain_url}static_files/"
-        call_api(url, "post", json=dict(url="/static/", path=str(Path(project_path) / "static")))
-        call_api(url, "post", json=dict(url="/media/", path=str(Path(project_path) / "media")))
+        self.create_static_file_mapping("/static/", Path(project_path) / "static")
+        self.create_static_file_mapping("/media/", Path(project_path) / "media")
 
     def reload(self) -> None:
         """Reload webapp
 
         :raises PythonAnywhereApiException: if API call fails"""
-        print(snakesay(f"Reloading {self.domain} via API"))
         url = f"{self.domain_url}reload/"
         response = call_api(url, "post")
         if not response.ok:
@@ -124,10 +148,12 @@ class Webapp:
             raise PythonAnywhereApiException(f"POST to reload webapp via API failed, got {response}:{response.text}")
 
     def set_ssl(self, certificate: str, private_key: str) -> None:
-        """Set SSL certificate and private key for webapp
+        """Set SSL certificate and private key for webapp.
 
         :param certificate: SSL certificate
         :param private_key: SSL private key
+
+        :raises PythonAnywhereApiException: if API call fails
         """
         print(snakesay(f"Setting up SSL for {self.domain} via API"))
         url = f"{self.domain_url}ssl/"
@@ -144,7 +170,12 @@ class Webapp:
             )
 
     def get_ssl_info(self) -> dict[str, Any]:
-        """Get SSL certificate info"""
+        """Get SSL certificate info.
+
+        :returns: dictionary with SSL certificate information including parsed expiration date
+
+        :raises PythonAnywhereApiException: if API call fails
+        """
         url = f"{self.domain_url}ssl/"
         response = call_api(url, "get")
         if not response.ok:
@@ -181,10 +212,11 @@ class Webapp:
         if not response.ok:
             raise PythonAnywhereApiException(f"DELETE log file via API failed, got {response}:{response.text}")
 
-    def get_log_info(self) -> dict:
-        """Get log files info
+    def get_log_info(self) -> dict[str, list[int]]:
+        """Get log files info.
 
-        :returns: dictionary with log files info
+        :returns: dictionary with log files info, keys are log types ('access', 'error', 'server'), 
+                 values are lists of log file indices
 
         :raises PythonAnywhereApiException: if API call fails"""
         url = f"{self.files_url}tree/?path=/var/log/"
@@ -210,3 +242,65 @@ class Webapp:
                         continue
                     logs[log_type].append(log_index)
         return logs
+
+    @classmethod
+    def list_webapps(cls) -> list[dict[str, Any]]:
+        """List all webapps for the current user.
+
+        :returns: list of webapps info as dictionaries
+
+        :raises PythonAnywhereApiException: if API call fails
+        """
+        response = call_api(cls.webapps_url, "get")
+        if not response.ok:
+            raise PythonAnywhereApiException(
+                f"GET webapps via API failed, "
+                f"got {response}:{response.text}"
+            )
+        return response.json()
+
+    def get(self) -> dict[str, Any]:
+        """Retrieve webapp information.
+
+        :returns: dictionary with webapp information
+
+        :raises PythonAnywhereApiException: if API call fails
+        """
+        response = call_api(self.domain_url, "get")
+
+        if not response.ok:
+            raise PythonAnywhereApiException(
+                f"GET webapp for {self.domain} via API failed, got {response}:{response.text}"
+            )
+
+        return response.json()
+
+    def delete(self) -> None:
+        """Delete webapp.
+
+        :raises PythonAnywhereApiException: if API call fails
+        """
+        response = call_api(self.domain_url, "delete")
+
+        if response.status_code != 204:
+            raise PythonAnywhereApiException(
+                f"DELETE webapp for {self.domain} via API failed, got {response}:{response.text}"
+            )
+
+    def patch(self, data: dict) -> dict[str, Any]:
+        """Patch webapp with provided data.
+
+        :param data: dictionary with data to update
+        :returns: dictionary with updated webapp information
+
+        :raises PythonAnywhereApiException: if API call fails
+        """
+        response = call_api(self.domain_url, "patch", data=data)
+
+        if not response.ok:
+            raise PythonAnywhereApiException(
+                f"PATCH webapp for {self.domain} via API failed, "
+                f"got {response}:{response.text}"
+            )
+
+        return response.json()

pythonanywhere_core-0.2.3/pythonanywhere_core/__init__.py

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