Merge pull request #3 from plexe-ai/chore/add-linting-and-formatting

Chore/add linting and formatting

Author: marcellodebernardi

.github/workflows/integration.yml

@@ -11,8 +11,30 @@ on:
       - synchronize
       - reopened
 
-
 jobs:
+  linting:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install poetry
+          poetry install
+
+      - name: Format Code with Black
+        run: poetry run black --check .
+
+      - name: Lint Code with Ruff
+        run: poetry run ruff check .
+
   run-tests:
     runs-on: ubuntu-latest
     steps:

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.1
+    hooks:
+      - id: ruff
+

README.md

@@ -1,2 +1,34 @@
 # smolmodels
 ✨ build specialised ml models from natural language
+
+## 1. Setup Instructions
+This project uses `poetry` for dependency management. To set up your development environment, follow these steps:
+
+### 1.1. Install Poetry
+Install `poetry` using `pip`:
+```bash
+pip install poetry
+```
+Alternatively, you can follow the [official Poetry installation guide](https://python-poetry.org/docs/#installation)
+for other methods.
+
+### 1.2. [Optional] Configure Poetry
+If you prefer to create the virtual environment inside the project directory, run this command:
+```bash
+poetry config virtualenvs.in-project true
+```
+This step is optional. By default, `poetry` manages virtual environments centrally in `~/.cache/pypoetry/virtualenvs`.
+
+### 1.3. Install Dependencies
+Run the `setup.py` script to install all dependencies and initialise the pre-commit hooks:
+```bash
+python setup.py
+```
+We use a Python setup script to be platform-agnostic.
+
+### 1.4. [Optional] Activate Virtual Environment
+To activate the virtual environment manually, run:
+```bash
+poetry shell
+```
+This step is optional as `poetry run` or `python setup.py` will handle the environment automatically.

poetry.lock

@@ -14,7 +14,34 @@ python = "^3.12"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.4"
+black = "^24.10.0"
+pre-commit = "^4.0.1"
+ruff = "^0.9.1"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 120
+target-version = ["py312"]
+exclude = '''
+/(
+    \.git
+  | \.venv
+  | __pycache__
+  | build
+  | dist
+)/
+'''
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.ruff.lint]
+ignore = [
+    "E203",  # Whitespace before ':'
+    "E501",  # Line length
+    "E402",  # Imports not at top of file
+]

pyproject.toml

@@ -0,0 +1,24 @@
+import subprocess
+import sys
+
+
+def run_command(command):
+    try:
+        subprocess.run(command, check=True, shell=True)
+    except subprocess.CalledProcessError:
+        print(f"Failed to run: {command}")
+        sys.exit(1)
+
+
+def main():
+    print("Installing dependencies...")
+    run_command("poetry install")
+
+    print("Installing pre-commit hooks...")
+    run_command("pre-commit install")
+
+    print("Setup complete!")
+
+
+if __name__ == "__main__":
+    main()

setup.py

@@ -89,7 +89,8 @@ def __init__(self, condition: Callable[[Any, Any], bool], description: Optional[
         # Validate that condition is a callable
         if not callable(condition):
             raise TypeError(
-                "Condition must be a callable that takes two arguments (inputs, outputs) and returns a boolean.")
+                "Condition must be a callable that takes two arguments (inputs, outputs) and returns a boolean."
+            )
 
         # Optionally, check the callable signature (if you want stricter validation)
         signature = inspect.signature(condition)
@@ -125,7 +126,7 @@ def __and__(self, other: "Constraint") -> "Constraint":
         """
         return Constraint(
             condition=lambda inputs, outputs: self.evaluate(inputs, outputs) and other.evaluate(inputs, outputs),
-            description=f"({self.description}) AND ({other.description})"
+            description=f"({self.description}) AND ({other.description})",
         )
 
     def __or__(self, other: "Constraint") -> "Constraint":
@@ -137,7 +138,7 @@ def __or__(self, other: "Constraint") -> "Constraint":
         """
         return Constraint(
             condition=lambda inputs, outputs: self.evaluate(inputs, outputs) or other.evaluate(inputs, outputs),
-            description=f"({self.description}) OR ({other.description})"
+            description=f"({self.description}) OR ({other.description})",
         )
 
     def __invert__(self) -> "Constraint":
@@ -148,5 +149,5 @@ def __invert__(self) -> "Constraint":
         """
         return Constraint(
             condition=lambda inputs, outputs: not self.evaluate(inputs, outputs),
-            description=f"NOT ({self.description})"
+            description=f"NOT ({self.description})",
         )

smolmodels/constraints.py

@@ -21,6 +21,7 @@ class SmolmodelsError(Exception):
     """
     Base class for all errors in the smolmodels library.
     """
+
     pass
 
 
@@ -29,27 +30,31 @@ class SpecificationError(SmolmodelsError):
     """
     Base class for errors related to model specification.
     """
+
     pass
 
 
 class InsufficientSpecificationError(SpecificationError):
     """
     Raised when the natural language specification is insufficiently detailed.
     """
+
     pass
 
 
 class AmbiguousSpecificationError(SpecificationError):
     """
     Raised when the natural language specification is ambiguous or contradictory.
     """
+
     pass
 
 
 class InvalidSchemaError(SpecificationError):
     """
     Raised when the input or output schema is invalid.
     """
+
     pass
 
 
@@ -58,31 +63,37 @@ class InstructionError(SmolmodelsError):
     """
     Base class for errors related to instructions provided for model building.
     """
+
     pass
 
 
 # todo: add more specific instruction-related errors once we have a better idea of what instructions are
 
+
 # Constraint-related errors
 class ConstraintError(SmolmodelsError):
     """
     Base class for errors related to constraints.
     """
+
     pass
 
 
 # todo: add more specific constraint-related errors once we have a better idea of how constraints are used
 
+
 # Runtime-related errors
 class SmolmodelsRuntimeError(SmolmodelsError, RuntimeError):
     """
     Base class for runtime errors during model execution or training.
     """
+
     pass
 
 
 class CodeExecutionError(SmolmodelsRuntimeError):
     """
     Raised when code execution fails for reasons other than timeout.
     """
+
     pass

smolmodels/exceptions.py

@@ -5,20 +5,14 @@
 from .constraints import Constraint
 from .callbacks import Callback
 from .instructions import Instruction
-from .exceptions import *
+from .exceptions import InsufficientSpecificationError
 
 
 class Function:
     # A model is a function that is defined by its input and output domain/ranges, and its behaviour. These
     # aspects of a model are not 'mutable' in the sense that changing these means creating a new model, as
     # two models with a different description are not the same model.
-    def __init__(
-            self,
-            behaviour: str,
-            output_schema: dict,
-            input_schema: dict,
-            constraints: List[Constraint] = None
-    ):
+    def __init__(self, behaviour: str, output_schema: dict, input_schema: dict, constraints: List[Constraint] = None):
         self.behaviour = behaviour
         self.output_schema = output_schema
         self.input_schema = input_schema
@@ -32,11 +26,11 @@ def __init__(
     # Note: we do not consider the dataset to be a property of the model itself
     # Note: there would also be an async version of this method
     def build(
-            self,
-            dataset: Union[str, Generator] = None,
-            instructions: List[Instruction] = None,  # these are "hints" that can be followed during training
-            callbacks: List[Callback] = None,  # these are functions that are called during training
-            isolation: Literal['local', 'subprocess', 'docker'] = 'local'  # this controls the sandboxing of training
+        self,
+        dataset: Union[str, Generator] = None,
+        instructions: List[Instruction] = None,  # these are "hints" that can be followed during training
+        callbacks: List[Callback] = None,  # these are functions that are called during training
+        isolation: Literal["local", "subprocess", "docker"] = "local",  # this controls the sandboxing of training
     ) -> None:
         pass
 
@@ -55,4 +49,4 @@ def describe(self) -> str:
 
     # Returns a list of "instruction" objects that could be followed to further improve the model
     def suggest(self) -> List[Instruction]:
-        pass
+        pass

smolmodels/function.py

@@ -2,5 +2,6 @@
 # and the class once we find it
 # todo: we also need to figure out what an instruction really is 😂?
 
+
 class Instruction:
-    pass
+    pass