Bump requests from 2.31.0 to 2.32.0

.github/workflows/tests.yaml

@@ -15,10 +15,10 @@ jobs:
           python-version: '3.9'
 
       - name: Install pipenv
-        run: pip install pipenv
+        run: pip install poetry
 
       - name: Install test dependencies
-        run: pipenv sync --dev
+        run: poetry install
 
       - name: Run Pytest
-        run: pipenv run pytest --cov-report term-missing --cov=src --cov-config=./tests/coverage.rc ./tests/
+        run: poetry run pytest --cov-report term-missing --cov=src --cov-config=./tests/coverage.rc ./tests/

.gitignore

@@ -0,0 +1,5 @@
+.coverage
+.venv
+.DS_Store
+*.pyc
+.vscode

.vscode/settings.json

@@ -0,0 +1,15 @@
+{
+    "python.testing.pytestArgs": [
+        "tests",
+        "dpytools"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
+    "python.testing.unittestArgs": [
+        "-v",
+        "-s",
+        "./tests",
+        "-p",
+        "test_*.py"
+    ],
+}

Makefile

@@ -4,12 +4,12 @@
 help:
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
 
-fmt: ## (Format) - runs black and isort against the codebase (auto triggered on pre-commit)
-	pipenv run black ./src/*
-	pipenv run isort ./src/*
+fmt: ## (Format) - runs black and isort against the codebase
+	poetry run black ./dpytools/*
+	poetry run isort ./dpytools/*
 
-lint: ## Run the ruff python linter (auto triggered on pre-commit)
-	pipenv run ruff ./src/*
+lint: ## Run the ruff python linter
+	poetry run ruff ./dpytools/*
 
-test: ## Run pytest and check test coverage (auto triggered on pre-push)
-	pipenv run pytest --cov-report term-missing --cov=src --cov-config=./tests/coverage.rc
+test: ## Run pytest and check test coverage
+	poetry run pytest --cov-report term-missing --cov=dpytools

README.md

@@ -4,24 +4,34 @@ Simple reusable python resources for digital publishing.
 
 ## Installation
 
-**TODO**
+Follow these steps to install the package on your local machine:
+
+1. **Install the package**
+
+    Open your terminal and run the following command:
+
+    ```bash
+    pip install git+https://github.com/GSS-Cogs/dp-python-tools.git
+    ```
+
 
 ## Usage
 
 The following clients, helpers etc are availible upon installation of this package.
 
-| Name | Import | Description |
-| ----- | ---------------- | ------ |
-| [config](./dpytools/config/README.md) | `from dpytools import Config` | A simple validating configuration class |
+| Name | Description |
+| ----- | ---------------- |
+| [Config](./dpytools/config/README.md) | A simple validating configuration class |
 **TODO** - all helpers and clients to appear in this list.
 
 The usage instructions please see the readme in the appropriate sub directory, this can also be access by clicking the link in the "name" column above.
 
 ## Development
 
-All commits that make it to PR should have black and ruff already ran against them, you can do this via `make fmt`.
-`
+All commits that make it to PR should have black and ruff already ran against them, you can do this via `make fmt` and you can lint via `make lint`.
+
+For a full list of functionality provided by the makefile just run a naked `make`.
 
 ### Repository Organization
 
-Each client, helper etc should be a sub directory of `./dpytools`. Separation between these sub codebaes should be maintained as much as possible aginst the day where we want to break some or all of these tools out into separate repositories.
+Each client, helper etc should be a sub directory of `./dpytools`. Separation between these sub codebases should be maintained as much as possible aginst the day where we want to break some or all of these tools out into separate repositories.

dpytools/__init__.py

@@ -1,5 +0,0 @@
-from http.http import HttpClient
-from config.config import Config
-from logger.logger import logger
-from slack.slack import SlackNotifier
-from sns.sns import Subscription, publish

dpytools/config/config.py

@@ -1,39 +1,87 @@
-from typing import Dict
+from __future__ import annotations
 
-from properties.base import BaseProperty
+import os
+from typing import Any, Dict, List
+
+from .properties.base import BaseProperty
+from .properties.intproperty import IntegerProperty
+from .properties.string import StringProperty
 
 
 class Config:
+    def __init__(self):
+        self._properties_to_validate: List[BaseProperty] = []
 
     @staticmethod
-    def from_env(config_dict: Dict[str, BaseProperty]):
-        # TODO = read in and populate property classes as
-        # per the example in the main readme.
-        # You need to populate with dot notation in mind so:
-        #
-        # StringProperty("fieldname", "fieldvalue")
-        #
-        # should be accessed on Config/self, so:
-        #
-        # value = config.fieldvalue.value
-        # i.e
-        # config.fieldvalue = StringProperty("fieldname", "fieldvalue")
-        #
-        # Worth looking at the __setattr_ dunder method and a loop
-        # for how to do this.
-        #
-        # Do track the BaseProperty's that you add ready for
-        # assert_valid_config call.
-        ...
+    def from_env(config_dict: Dict[str, Dict[str, Any]]) -> Config:
+        config = Config()
+
+        for env_var_name, value in config_dict.items():
+            value_for_property = os.environ.get(env_var_name, None)
+            assert (
+                value_for_property is not None
+            ), f'Required envionrment value "{env_var_name}" could not be found.'
+
+            if value["class"] == StringProperty:
+                if value["kwargs"]:
+                    regex = value["kwargs"].get("regex")
+                    min_len = value["kwargs"].get("min_len")
+                    max_len = value["kwargs"].get("max_len")
+                else:
+                    regex = None
+                    min_len = None
+                    max_len = None
+
+                stringprop = StringProperty(
+                    _name=value["property"],
+                    _value=value_for_property,
+                    regex=regex,
+                    min_len=min_len,
+                    max_len=max_len,
+                )
+
+                prop_name = value["property"]
+                setattr(config, prop_name, stringprop)
+                config._properties_to_validate.append(stringprop)
+
+            elif value["class"] == IntegerProperty:
+                if value["kwargs"]:
+                    min_val = value["kwargs"].get("min_val")
+                    max_val = value["kwargs"].get("max_val")
+                else:
+                    min_val = None
+                    max_val = None
+
+                intprop = IntegerProperty(
+                    _name=value["property"],
+                    _value=value_for_property,
+                    min_val=min_val,
+                    max_val=max_val,
+                )
+
+                prop_name = value["property"]
+                setattr(config, prop_name, intprop)
+                config._properties_to_validate.append(intprop)
+
+            else:
+                prop_type = value["class"]
+                raise TypeError(
+                    f"Unsupported property type specified via 'property' field, got {prop_type}. Should be of type StringProperty or IntegerProperty"
+                )
+
+        return config
 
     def assert_valid_config(self):
         """
         Assert that then Config class has the properties that
         provided properties.
         """
+        for property in self._properties_to_validate:
+            property.type_is_valid()
+            property.secondary_validation()
+
+        self._properties_to_validate = []
 
         # For each of the properties you imbided above, run
         # self.type_is_valid()
         # self.secondary_validation()
-
-

dpytools/config/properties/__init__.py

@@ -1 +1,2 @@
-from string import StringProperty
+from .intproperty import IntegerProperty
+from .string import StringProperty

dpytools/config/properties/base.py

@@ -1,26 +1,38 @@
 from abc import ABCMeta, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Union, Tuple, Optional
+from typing import Any
+
 
 @dataclass
-class BaseProperty(meta=ABCMeta):
-    name: str
-    value: Any
+class BaseProperty(metaclass=ABCMeta):
+    _name: str
+    _value: Any
+
+    @property
+    def name(self):
+        return self._name
 
-    # TODO: getter
-    # allow someone to get the property
+    @name.setter
+    def name(self, value):
+        raise ValueError(
+            f"Trying to change name property to value {value} but you cannot change a property name after instantiation."
+        )
 
-    # TODO: setter
-    # categorically disallow anyone from
-    # changing a property after the class
-    # has been instantiated.
-    # Refuse to do it, and log an error.
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        raise ValueError(
+            f"Trying to change value to {value} but you cannot change a property value after instantiation."
+        )
 
     @abstractmethod
     def type_is_valid(self):
         """
         Validate that the property looks like
-        its of the correct type 
+        its of the correct type
         """
         ...
 
@@ -32,4 +44,4 @@ def secondary_validation(self):
         Non type based validation you might want to
         run against a configuration value.
         """
-        ...
+        ...

dpytools/config/properties/intproperty.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from .base import BaseProperty
+
+
+@dataclass
+class IntegerProperty(BaseProperty):
+    min_val: Optional[int]
+    max_val: Optional[int]
+
+    def type_is_valid(self):
+        """
+        Validate that the property looks like
+        its of the correct type
+        """
+        try:
+            int(self._value)
+        except Exception as err:
+            raise Exception(
+                f"Cannot cast {self._name} value {self._value} to integer."
+            ) from err
+
+    def secondary_validation(self):
+        """
+        Non type based validation you might want to
+        run against a configuration value of this kind.
+        """
+        if not self._value:
+            raise ValueError(f"Integer value for {self._name} does not exist.")
+
+        if self.min_val and self._value < self.min_val:
+            raise ValueError(
+                f"Integer value for {self._name} is lower than allowed minimum."
+            )
+
+        if self.max_val and self._value > self.max_val:
+            raise ValueError(
+                f"Integer value for {self._name} is higher than allowed maximum."
+            )

dpytools/config/properties/string.py

@@ -1,39 +1,53 @@
+import re
+from dataclasses import dataclass
 from typing import Optional
 
-from base import BaseProperty
+from .base import BaseProperty
 
 
+@dataclass
 class StringProperty(BaseProperty):
     regex: Optional[str]
     min_len: Optional[int]
     max_len: Optional[int]
 
-    def type_is_valid(self) -> Optional[Exception]:
+    def type_is_valid(self):
         """
         Validate that the property looks like
-        its of the correct type 
+        its of the correct type
         """
         try:
-            str(self.value)
+            str(self._value)
         except Exception as err:
-            raise Exception(f"Cannot cast {self.name} value {self.value} to string.") from err
+            raise Exception(
+                f"Cannot cast {self.name} value {self._value} to string."
+            ) from err
 
-    def secondary_validation_passed(self) -> Optional[Exception]:
+    def secondary_validation(self):
         """
         Non type based validation you might want to
         run against a configuration value of this kind.
         """
-        if len(self.value) == 0:
+
+        if len(self._value) == 0:
             raise ValueError(f"Str value for {self.name} is an empty string")
-        
+
         if self.regex:
             # TODO - confirm the value matches the regex
-            ...
+            regex_search = re.search(self.regex, self._value)
+            if not regex_search:
+                raise ValueError(
+                    f"Str value for {self.name} does not match the given regex."
+                )
 
         if self.min_len:
-            # TODO - confirm the string matches of exceeds the minimum length
-            ...
+            if len(self._value) < self.min_len:
+                raise ValueError(
+                    f"Str value for {self.name} is shorter than minimum length {self.min_len}"
+                )
 
         if self.max_len:
-            # TODO - confirm the value matches or is less than the max length
-            ...
+            if len(self._value) > self.max_len:
+                raise ValueError(
+                    f"Str value for {self.name} is longer than maximum length {self.max_len}"
+                )