Release/1.0.1 (#1)

* Fix CHANGELOG link and bump version

* address ruff-discovered issues

* ruff format

---------

Co-authored-by: Cory Watson <watsoncl1@ornl.gov>
Co-authored-by: Grant, Josh <grantjn@ornl.gov>

Author: 3 people

.github/workflows/lint.yml

@@ -0,0 +1,21 @@
+name: Lint with Ruff
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  ruff-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/ruff-action@v3
+        with:
+          args: check
+      - uses: astral-sh/ruff-action@v3
+        with:
+          args: format --check

CHANGELOG.md

@@ -40,3 +40,25 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [1.0.0] - 2025-05-09
 - Initial commit
+
+
+## [1.0.1] - 2025-05-09
+### Added
+- 🔥 pytest as a dev dependency, used for running tests
+- 🔥 pytest-cov as a dev dependency, used for measuring test coverage
+- 🔥 pytest-mock as a dev dependency, used for mocking in tests
+- 🔥 added a multitude of linting rules
+- 🔥 added a lint and format checking GitHub Action
+- 🔥 added development instructions in the README
+
+### Fixed
+- 🩹 Fix URL for the CHANGELOG
+- 🩹 Reformatted files to be ruff format compliant
+- 🩹 Fixed some typing annotation errors
+
+### Removed
+- 🗡️ Remove version specification in README.md
+- 🗡️ Remove references to old indexes in pyproject.toml
+- 🗡️ Remove kwargs in `__init__` method of `BaseProbe`
+- 🗡️ Remove unused imports from many files
+- 🗡️ Remove commented-out code in some classes

README.md

@@ -11,9 +11,17 @@ python tools for adding clock data to a timescale db.
 1. Ensure you have Python 3.9 or higher installed
 2. Pip install the latest version of opensampl: 
 ```bash
-pip install opensampl==0.2.0
+pip install opensampl
 ```
 
+### Development Setup
+```bash
+uv venv
+uv sync --extra all
+source .venv/bin/activate
+```
+This will create a virtual environment and install the development dependencies.
+
 ### Environment Setup
 
 The tool requires several environment variables. Create a `.env` file in your project root:

opensampl/__init__.py

@@ -1,4 +1,6 @@
 """
+Initialize the openSAMPL package.
+
 Adding this to ensure backwards compatibility with older versions of opensampl where orm import was:
 from opensampl import orm
 """

opensampl/cli.py

@@ -1,12 +1,14 @@
 """
+Define the command line interface for openSAMPL.
+
 The openSAMPL CLI package is a click based command line interface for the openSAMPL package. It provides a way to
 interact with the database and load data into it.
 """
 
 import json
 import sys
 from pathlib import Path
-from typing import Dict, List, Union
+from typing import Optional, Union
 
 import click
 import yaml
@@ -19,7 +21,7 @@
 from opensampl.load_data import create_new_tables, write_to_table
 from opensampl.vendors.constants import VENDOR_MAP, get_vendor_parser
 
-BANNER=r"""
+BANNER = r"""
 
                         ____    _    __  __ ____  _
   ___  _ __   ___ _ __ / ___|  / \  |  \/  |  _ \| |
@@ -35,10 +37,11 @@
 level = ENV_VARS.LOG_LEVEL.get_value()
 logger.configure(handlers=[{"sink": sys.stderr, "level": level.upper()}])
 
+
 class CaseInsensitiveGroup(click.Group):
     """Defines Click group options as case-insensitive. By default, click groups are case-sensitive."""
 
-    def get_command(self, ctx, cmd_name):
+    def get_command(self, ctx, cmd_name: str) -> Optional[click.Command]:  # noqa: ARG002,ANN001
         """Normalize command name to lower case"""
         cmd_name = cmd_name.lower()
         # Match against lowercased command names
@@ -47,6 +50,7 @@ def get_command(self, ctx, cmd_name):
                 return cmd
         return None
 
+
 def get_table_names():
     """Get all table names from the ORM in opensampl.db.orm"""
     return [table.name for table in Base.metadata.sorted_tables]
@@ -73,6 +77,7 @@ def init():
 def config():
     """View and manage environment variables used by openSAMPL"""
 
+
 @config.command()
 def file():
     """Show the path to the env file used by openSAMPL"""
@@ -123,7 +128,7 @@ def show(explain: bool, var: str):
 @config.command("set")
 @click.argument("name")
 @click.argument("value")
-def config_set(name: str, value: str, temp: bool = None):
+def config_set(name: str, value: str, temp: Optional[bool] = None):
     """
     Set the value of an environment variable.
 
@@ -137,25 +142,25 @@ def config_set(name: str, value: str, temp: bool = None):
     """
     set_env(name=name, value=value, temp=temp)
 
+
 @cli.group(cls=CaseInsensitiveGroup)
 def load():
     """Load data into database"""
 
 
-for probe_name, vendor_type in VENDOR_MAP.items():
+for probe_name in VENDOR_MAP:
     load.add_command(get_vendor_parser(probe_name).get_cli_command(), name=probe_name)
 
 
-def path_or_string(value):
+def path_or_string(value: str) -> Union[dict, list]:
     """Get content from a file or use the string directly"""
     # Get content - either from file or use the string directly
     content = value
     try:
         path = Path(value)
         if path.exists() and path.is_file():
-            with open(path, "r") as f:
-                content = f.read()
-    except Exception:
+            content = path.read_text()
+    except Exception:  # noqa: S110
         # If any error occurs during path handling, treat as raw string
         pass
 
@@ -169,8 +174,8 @@ def path_or_string(value):
         except json.JSONDecodeError as json_err:
             # If both parsing attempts fail, raise an error
             raise click.BadParameter(
-                f"Could not parse input as YAML or JSON.\n" f"YAML error: {yaml_err}\n" f"JSON error: {json_err}"
-            )
+                f"Could not parse input as YAML or JSON.\nYAML error: {yaml_err}\nJSON error: {json_err}"
+            ) from json_err
 
 
 @load.command("table")
@@ -183,8 +188,10 @@ def path_or_string(value):
 )
 @click.argument("table_name", type=click.Choice(get_table_names()))
 @click.argument("filepath", type=path_or_string)
-def table_load(filepath: Union[Dict, List], table_name: str, if_exists: str):
+def table_load(filepath: Union[dict, list], table_name: str, if_exists: str):
     r"""
+    Perform a Table load into the database.
+
         Load data directly into a database table. Format can be yaml or json. Can be a list of dictionaries or a single
         dictionary.
 
@@ -208,8 +215,8 @@ def table_load(filepath: Union[Dict, List], table_name: str, if_exists: str):
             write_to_table(table_name, filepath, if_exists=if_exists)
         click.echo(f"Successfully wrote data to table {table_name}")
     except Exception as e:
-        click.echo(f"Error writing to table: {str(e)}", err=True)
-        raise click.Abort()
+        click.echo(f"Error writing to table: {e!s}", err=True)
+        raise click.Abort()  # noqa: RSE102,B904
 
 
 @cli.command(name="create")
@@ -221,10 +228,7 @@ def table_load(filepath: Union[Dict, List], table_name: str, if_exists: str):
     help="Update the database with the new probe type",
 )
 def create_probe_command(config_path: Path, update_db: bool):
-    """
-    ** beta **
-    Create a new probe type with scaffolding, based on a config file.
-    """
+    """Create a new probe type with scaffolding, based on a config file."""
     from opensampl.helpers.create_vendor import VendorConfig
 
     vendor_config = VendorConfig.from_config_file(config_path)

opensampl/constants.py

@@ -1,7 +1,8 @@
 """Constants for accessing environment configurations"""
+
 import os
 from pathlib import Path
-from typing import Any, Optional, Type
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -11,35 +12,36 @@ class EnvVar(BaseModel):
 
     name: str
     description: str
-    type: Type = str
+    type: type = str
     default: Optional[Any] = None
 
     def get_value(self):
         """Get value of var in environment"""
         default = self.resolve_default()
         if self.type is bool:
-            return os.getenv(self.name, default).lower() == 'true'
-        elif self.type is Path:
+            return os.getenv(self.name, default).lower() == "true"
+        if self.type is Path:
             return Path(os.getenv(self.name, default))
         return os.getenv(self.name, default)
 
     def resolve_default(self):
         """Resolve default value for env var based on type"""
         if self.type is bool:
-            return self.default or 'false'
+            return self.default or "false"
         if self.type is Path and self.default is not None:
             return Path(self.default).resolve()
         return self.default
 
 
-class ENV_VARS:
+class ENV_VARS:  # noqa: N801
     """Variables referenced by openSAMPL"""
 
     ROUTE_TO_BACKEND = EnvVar(
         name="ROUTE_TO_BACKEND",
-        description=("Route all database operations through BACKEND_URL rather "
-                    "than applying directly using DATABASE_URL"),
-        type=bool
+        description=(
+            "Route all database operations through BACKEND_URL rather than applying directly using DATABASE_URL"
+        ),
+        type=bool,
     )
     BACKEND_URL = EnvVar(
         name="BACKEND_URL",
@@ -66,12 +68,12 @@ class ENV_VARS:
     )
 
     @classmethod
-    def __iter__(cls):
+    def __iter__(cls) -> iter:
         """Get all EnvVar objects as iterable"""
         yield from (value for key, value in cls.__dict__.items() if isinstance(value, EnvVar))
 
     @classmethod
-    def get(cls, name: str):
+    def get(cls, name: str) -> Optional[Any]:
         """Get EnvVar object by name"""
         var = getattr(cls, name, None)
         if isinstance(var, EnvVar):

opensampl/db/access_orm.py

@@ -1,11 +1,12 @@
 """ORM for managing access to openSAMPL database and endpoints"""
+
 import secrets
 import uuid
-from datetime import datetime
-from typing import List, Union
+from datetime import datetime, timezone
+from typing import Optional, Union
 
 from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
-from sqlalchemy.orm import declarative_base, relationship
+from sqlalchemy.orm import Session, declarative_base, relationship
 from sqlalchemy.orm.exc import NoResultFound
 from sqlalchemy.schema import MetaData
 
@@ -29,7 +30,7 @@ def generate_key(self):
 
     def is_expired(self):
         """Check if API access key is expired."""
-        return self.expires_at is not None and datetime.utcnow() > self.expires_at
+        return self.expires_at is not None and datetime.now(tz=timezone.utc) > self.expires_at
 
 
 class Views(Base):
@@ -40,12 +41,12 @@ class Views(Base):
     name = Column(Text)
 
     @staticmethod
-    def get_view_by_name(session, name):
+    def get_view_by_name(session: Session, name: str) -> Optional[type["Views"]]:
         """Get view by name"""
         try:
             return session.query(Views).filter_by(name=name).one()
         except NoResultFound:
-            print(f"View with name {name} not found")
+            print(f"View with name {name} not found")  # noqa: T201
             return None
 
 
@@ -58,12 +59,12 @@ class Roles(Base):
     view_id = Column(Text, ForeignKey("views.view_id"))
 
     @staticmethod
-    def get_role_by_name(session, name):
+    def get_role_by_name(session: Session, name: str) -> Optional[type["Roles"]]:
         """Get role by name"""
         try:
             return session.query(Roles).filter_by(name=name).one()
         except NoResultFound:
-            print(f"Role with name {name} not found")
+            print(f"Role with name {name} not found")  # noqa: T201
             return None
 
 
@@ -75,12 +76,12 @@ class Users(Base):
     email = Column(Text)
 
     @staticmethod
-    def get_user_by_email(session, email):
+    def get_user_by_email(session: Session, email: str) -> Optional["Users"]:
         """Get user by email"""
         try:
             return session.query(Users).filter_by(email=email).one()
         except NoResultFound:
-            print(f"User with email {email} not found")
+            print(f"User with email {email} not found")  # noqa: T201
             return None
 
 
@@ -92,14 +93,14 @@ class UserRole(Base):
     role_id = Column(Text, ForeignKey("roles.role_id"), primary_key=True)
 
 
-def add_user_role(emails: Union[str, List[str]], role_name: str, session):
+def add_user_role(emails: Union[str, list[str]], role_name: str, session: Session):
     """Add user role to the database."""
     if isinstance(emails, str):
         emails = [emails]
 
     role = Roles.get_role_by_name(name=role_name)
     if role is None:
-        print(f"Role with name {role_name} not found")
+        print(f"Role with name {role_name} not found")  # noqa: T201
         return
 
     for email in emails:
@@ -109,17 +110,17 @@ def add_user_role(emails: Union[str, List[str]], role_name: str, session):
             user = Users(email=email)
             session.add(user)
             session.flush()  # Flush to get the generated user_id
-            print(f"New user created with email {email}")
+            print(f"New user created with email {email}")  # noqa: T201
 
         # Check if user already has the specified role
         if any(ur.role_id == role.role_id for ur in user.user_role):
-            print(f"User with email {email} already has role {role_name}")
+            print(f"User with email {email} already has role {role_name}")  # noqa: T201
             continue
 
         # Create a new entry in user_role table
         user_role = UserRole(user_id=user.user_id, role_id=role.role_id)
         session.add(user_role)
-        print(f"User with email {email} assigned role {role_name}")
+        print(f"User with email {email} assigned role {role_name}")  # noqa: T201
         session.commit()