neurocore-skill-postgres 0.1.0__tar.gz

neurocore_skill_postgres-0.1.0/.gitignore

@@ -0,0 +1,152 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Ruff
+.ruff_cache/
+
+# IDEs and editors
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db

neurocore_skill_postgres-0.1.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: neurocore-skill-postgres
+Version: 0.1.0
+Summary: PostgreSQL query skill for NeuroCore
+Author: NeuroCore Contributors
+License-Expression: Apache-2.0
+Keywords: ai,database,neurocore,postgres,skill,sql
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: neurocore-ai>=0.2.0
+Requires-Dist: psycopg[binary]>=3.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=9.0.2; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# neurocore-skill-postgres
+
+Run parameterized SQL against PostgreSQL from a NeuroCore flow (psycopg 3).
+
+```bash
+pip install neurocore-skill-postgres
+export DATABASE_URL=postgresql://user:pass@localhost/db
+```
+
+```yaml
+components:
+  - name: query
+    type: postgres
+    config:
+      sql: "SELECT id, name FROM users WHERE active = %s"
+flow:
+  type: sequential
+  steps:
+    - component: query
+```
+
+Provide `sql` (and optional `sql_params`) via config or context. Results are
+written to `postgres_rows` (a list of row dicts; empty list for non-SELECT
+statements, which are committed).
+
+> Use parameterized queries (`%s` placeholders + `sql_params`) — never string
+> interpolation — to avoid SQL injection.

neurocore_skill_postgres-0.1.0/README.md

@@ -0,0 +1,27 @@
+# neurocore-skill-postgres
+
+Run parameterized SQL against PostgreSQL from a NeuroCore flow (psycopg 3).
+
+```bash
+pip install neurocore-skill-postgres
+export DATABASE_URL=postgresql://user:pass@localhost/db
+```
+
+```yaml
+components:
+  - name: query
+    type: postgres
+    config:
+      sql: "SELECT id, name FROM users WHERE active = %s"
+flow:
+  type: sequential
+  steps:
+    - component: query
+```
+
+Provide `sql` (and optional `sql_params`) via config or context. Results are
+written to `postgres_rows` (a list of row dicts; empty list for non-SELECT
+statements, which are committed).
+
+> Use parameterized queries (`%s` placeholders + `sql_params`) — never string
+> interpolation — to avoid SQL injection.

neurocore_skill_postgres-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "neurocore-skill-postgres"
+version = "0.1.0"
+description = "PostgreSQL query skill for NeuroCore"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.13"
+authors = [{ name = "NeuroCore Contributors" }]
+keywords = ["neurocore", "skill", "postgres", "sql", "database", "ai"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "neurocore-ai>=0.2.0",
+    "psycopg[binary]>=3.1",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=9.0.2", "pytest-asyncio>=0.24", "ruff>=0.8", "mypy>=1.8"]
+
+[project.entry-points."neurocore.skills"]
+postgres = "neurocore_skill_postgres:PostgresSkill"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/neurocore_skill_postgres"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"

neurocore_skill_postgres-0.1.0/src/neurocore_skill_postgres/__init__.py

@@ -0,0 +1,5 @@
+"""neurocore-skill-postgres — PostgreSQL query skill for NeuroCore."""
+
+from neurocore_skill_postgres.skill import PostgresSkill
+
+__all__ = ["PostgresSkill"]

neurocore_skill_postgres-0.1.0/src/neurocore_skill_postgres/skill.py

@@ -0,0 +1,68 @@
+"""PostgresSkill — run a parameterized SQL query against PostgreSQL.
+
+Reads ``sql`` (and optional ``sql_params``) from context (config provides
+defaults) and writes returned rows to ``postgres_rows``.
+"""
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+from flowengine import FlowContext
+
+from neurocore import AsyncSkill, SkillMeta
+
+logger = logging.getLogger(__name__)
+
+
+class PostgresSkill(AsyncSkill):
+    """Async parameterized SQL execution against PostgreSQL (psycopg 3)."""
+
+    skill_meta = SkillMeta(
+        name="postgres",
+        version="0.1.0",
+        description="Run parameterized SQL against PostgreSQL",
+        author="NeuroCore Contributors",
+        requires=["psycopg[binary]>=3.1"],
+        provides=["postgres_rows"],
+        consumes=["sql", "sql_params"],
+        tags=["database", "sql", "postgres"],
+        config_schema={
+            "properties": {
+                "dsn": {"type": "string", "description": "Connection string."},
+                "sql": {"type": "string", "description": "Default SQL (overridable)."},
+            }
+        },
+    )
+
+    def _resolve_dsn(self) -> str:
+        return self.config.get("dsn", "") or os.environ.get("DATABASE_URL", "")
+
+    async def _execute(self, sql: str, params: Any) -> list[dict[str, Any]]:
+        """Execute ``sql`` and return rows as dicts (empty for non-SELECT)."""
+        import psycopg
+        from psycopg.rows import dict_row
+
+        async with await psycopg.AsyncConnection.connect(
+            self._resolve_dsn(), row_factory=dict_row
+        ) as conn, conn.cursor() as cur:
+            await cur.execute(sql, params)
+            if cur.description is None:
+                await conn.commit()
+                return []
+            return [dict(row) for row in await cur.fetchall()]
+
+    async def process(self, context: FlowContext) -> FlowContext:
+        sql = str(context.get("sql") or self.config.get("sql", ""))
+        if not sql:
+            logger.warning("PostgresSkill: no 'sql' provided.")
+            context.set("postgres_rows", [])
+            return context
+        params = context.get("sql_params")
+        try:
+            context.set("postgres_rows", await self._execute(sql, params))
+        except Exception as exc:  # noqa: BLE001
+            logger.error("PostgresSkill query failed: %s", exc, exc_info=True)
+            context.set("postgres_rows", {"error": str(exc)})
+        return context

neurocore_skill_postgres-0.1.0/tests/test_skill.py

@@ -0,0 +1,58 @@
+"""Tests for PostgresSkill (DB call mocked via the _execute seam)."""
+from __future__ import annotations
+
+from flowengine import FlowContext
+from neurocore_skill_postgres import PostgresSkill
+
+
+def test_skill_meta():
+    assert PostgresSkill.skill_meta.name == "postgres"
+    assert "postgres_rows" in PostgresSkill.skill_meta.provides
+
+
+async def test_process_returns_rows(monkeypatch):
+    skill = PostgresSkill()
+    skill.init({"dsn": "postgresql://x"})
+
+    async def fake_execute(sql, params):
+        assert "select" in sql.lower()
+        return [{"id": 1, "name": "a"}]
+
+    monkeypatch.setattr(skill, "_execute", fake_execute)
+    ctx = FlowContext()
+    ctx.set("sql", "SELECT * FROM t")
+    out = await skill.process(ctx)
+    assert out.get("postgres_rows")[0]["name"] == "a"
+
+
+async def test_config_sql_default(monkeypatch):
+    skill = PostgresSkill()
+    skill.init({"dsn": "postgresql://x", "sql": "SELECT 1"})
+
+    async def fake_execute(sql, params):
+        return [{"?column?": 1}]
+
+    monkeypatch.setattr(skill, "_execute", fake_execute)
+    out = await skill.process(FlowContext())
+    assert out.get("postgres_rows") == [{"?column?": 1}]
+
+
+async def test_no_sql_returns_empty():
+    skill = PostgresSkill()
+    skill.init({"dsn": "postgresql://x"})
+    out = await skill.process(FlowContext())
+    assert out.get("postgres_rows") == []
+
+
+async def test_error_sets_sentinel(monkeypatch):
+    skill = PostgresSkill()
+    skill.init({"dsn": "postgresql://x"})
+
+    async def boom(sql, params):
+        raise RuntimeError("connection refused")
+
+    monkeypatch.setattr(skill, "_execute", boom)
+    ctx = FlowContext()
+    ctx.set("sql", "SELECT 1")
+    out = await skill.process(ctx)
+    assert "error" in out.get("postgres_rows")