sqlalchemy-postgres-point 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

sqlalchemy_postgres_point/alembic_integration.py

@@ -1,56 +1,32 @@
 """
-Alembic integration to automatically add imports for PointType in migration files.
+Alembic integration for rendering PointType in generated migration files.
 
-This module hooks into Alembic's autogenerate system to automatically include
-the necessary import statement when PointType is detected in models.
+Usage — add two lines to your alembic/env.py:
 
-Usage:
-    Add this import to your alembic/env.py file:
+    from sqlalchemy_postgres_point.alembic_integration import render_item
 
-    import sqlalchemy_postgres_point.alembic_integration
+Then pass it to both context.configure() calls:
 
-Once added, `from sqlalchemy_postgres_point import PointType` will be automatically
-included in generated migration files.
-"""
+    context.configure(
+        ...,
+        render_item=render_item,
+    )
 
-import alembic.autogenerate
-import alembic.operations.ops
-from sqlalchemy.types import UserDefinedType
+Once wired up, ``from sqlalchemy_postgres_point import PointType`` will be
+automatically included in generated migration files whenever PointType is used.
+"""
 
 from .point import PointType
 
 
-def render_point_type(type_, object_, autogen_context):
-    """Render PointType in migration files with proper import."""
-    # Add the import to the migration file
-    autogen_context.imports.add("from sqlalchemy_postgres_point import PointType")
-    return "PointType()"
-
+def render_item(type_, obj, autogen_context):
+    """Alembic render_item hook that handles PointType columns.
 
-# Register the renderer for PointType
-alembic.autogenerate.render.renderers.dispatch_for(PointType, replace=True)(
-    render_point_type
-)
-
-
-# Also register for UserDefinedType as a fallback if the class doesn't match exactly
-@alembic.autogenerate.render.renderers.dispatch_for(UserDefinedType, replace=True)
-def render_user_defined_type(type_, object_, autogen_context):
-    if type(object_).__name__ == "PointType":
-        return render_point_type(type_, object_, autogen_context)
-    return False
-
-
-@alembic.autogenerate.comparators.dispatch_for("schema")
-def compare_point_types(
-    autogen_context: alembic.autogenerate.api.AutogenContext,
-    upgrade_ops: alembic.operations.ops.UpgradeOps,
-    schema_names,
-):
+    Returns "PointType()" and registers the import when the rendered item is a
+    PointType instance. Returns False for everything else so Alembic falls back
+    to its default rendering.
     """
-    Hook into Alembic's schema comparison to detect PointType usage.
-
-    This ensures the import is added even if PointType is used in existing
-    columns that might not trigger the render hook directly.
-    """
-    pass
+    if type_ == "type" and isinstance(obj, PointType):
+        autogen_context.imports.add("from sqlalchemy_postgres_point import PointType")
+        return "PointType()"
+    return False

sqlalchemy_postgres_point/point.py

@@ -11,7 +11,6 @@ References:
 
 import math
 import re
-from typing import Tuple
 
 from sqlalchemy.types import Float, UserDefinedType
 
@@ -23,7 +22,7 @@ class PointType(UserDefinedType):
         return "POINT"
 
     @staticmethod
-    def _validate_point(value: Tuple[float, float]) -> Tuple[float, float]:
+    def _validate_point(value: tuple[float, float]) -> tuple[float, float]:
         """Validate and normalize a (lng, lat) tuple.
 
         - Ensures it's a 2-length tuple/list

{sqlalchemy_postgres_point-0.2.0.dist-info → sqlalchemy_postgres_point-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sqlalchemy-postgres-point
-Version: 0.2.0
+Version: 0.2.2
 Summary: Lightweight SQLAlchemy custom type for PostgreSQL POINT columns with tuple binding and an earth-distance comparator.
 Keywords: sqlalchemy,postgresql,point,geometry,geospatial,gis,database,types,earthdistance
 Author: Michael Bianco
@@ -15,18 +15,15 @@ Description-Content-Type: text/markdown
 ![GitHub CI Status](https://github.com/iloveitaly/sqlalchemy-postgres-point/actions/workflows/build_and_publish.yml/badge.svg)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-sqlalchemy-postgres-point
-=========================
+# sqlalchemy-postgres-point
 
 Lightweight, pure-Python SQLAlchemy custom type for PostgreSQL `POINT` columns.
 
-Why
-----
+## Why
 
 PostgreSQL has a native `POINT` type (stored internally as a pair of float8 values). SQLAlchemy does not ship a dedicated high-level type wrapper for simple geometric primitives. This package provides a very small `PointType` you can use immediately without pulling in a full spatial stack (e.g. PostGIS + GeoAlchemy2) when all you need is storing and retrieving `(longitude, latitude)` pairs.
 
-Features
---------
+## Features
 
 * Simple `(lng, lat)` tuple binding and result conversion.
 * Safe NULL handling.
@@ -34,23 +31,13 @@ Features
 * Custom comparator exposing the PostgreSQL earth-distance `<@>` operator (returns a `Float`).
 * `cache_ok = True` for SQLAlchemy 2.x compilation caching.
 
-Installation
-------------
-
-Using `uv` (recommended):
+## Installation
 
 ```bash
 uv add sqlalchemy-postgres-point
 ```
 
-Or with pip:
-
-```bash
-pip install sqlalchemy-postgres-point
-```
-
-Usage
------
+## Usage
 
 ```python
 from sqlalchemy import Column, Integer
@@ -59,7 +46,7 @@ from sqlalchemy_postgres_point import PointType
 
 
 class Base(DeclarativeBase):
-	pass
+    pass
 
 
 class Place(Base):
@@ -68,6 +55,7 @@ class Place(Base):
     # Store as (longitude, latitude)
     location = Column(PointType)
 
+
 # Example query using the custom comparator
 from sqlalchemy import select
 
@@ -93,14 +81,15 @@ Revises: your_previous_revision
 Create Date: 2025-01-XX XX:XX:XX.XXXXXX
 
 """
+
 from typing import Sequence, Union
 
 from alembic import op
 import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
-revision: str = 'your_revision_id'
-down_revision: Union[str, None] = 'your_previous_revision'
+revision: str = "your_revision_id"
+down_revision: Union[str, None] = "your_previous_revision"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
@@ -119,81 +108,65 @@ DROP EXTENSION IF EXISTS cube;
 """)
 ```
 
-**Integration Steps:**
+#### Integration Steps
 
 1. Generate a new migration: `alembic revision -m "add_postgres_extensions"`
 2. Copy the `upgrade()` and `downgrade()` functions above into your new migration file
 3. Run the migration: `alembic upgrade head`
 
-Returned Python Values
-----------------------
+## Returned Python Values
 
 Values are loaded as a 2-tuple of floats `(lng, lat)` or `None` when NULL.
 
-Testing
--------
+## Alembic Integration
 
-Run the test suite with:
+To ensure generated migration files include the correct `PointType` import, pass the provided `render_item` hook to `context.configure()` in your `alembic/env.py`. This must be added to **both** `run_migrations_online` and `run_migrations_offline`:
 
-```bash
-uv run pytest -q
+```python
+from sqlalchemy_postgres_point.alembic_integration import (
+    render_item as render_point_item,
+)
+
+context.configure(
+    # ... other options ...
+    render_item=render_point_item,
+)
 ```
 
-## Alembic Integration
+Once wired up, `from sqlalchemy_postgres_point import PointType` will be automatically included in generated migration files whenever a `PointType` column is detected.
 
-When using `PointType` in your models, you can automatically include the necessary imports in migration files by updating your `alembic/env.py` file.
+### Chaining `render_item`
 
-First, import the integration module:
+If you need to combine this with other packages that also provide a `render_item`, chain them:
 
 ```python
-import sqlalchemy_postgres_point.alembic_integration
-```
+from sqlalchemy_postgres_point.alembic_integration import (
+    render_item as render_point_item,
+)
 
-Then, ensure your `context.configure` call includes a `render_item` hook to handle the `PointType`:
 
-```python
 def render_item(type_, obj, autogen_context):
-    if type_ == "type" and type(obj).__name__ == "PointType":
-        return sqlalchemy_postgres_point.alembic_integration.render_point_type(obj, obj, autogen_context)
-    return False
+    return (
+        render_point_item(type_, obj, autogen_context)
+        or other_package.render_item(type_, obj, autogen_context)
+        or False
+    )
+
 
-# ... in run_migrations_online and run_migrations_offline ...
 context.configure(
     # ... other options ...
     render_item=render_item,
 )
 ```
 
-Once added, `from sqlalchemy_postgres_point import PointType` will be automatically included in generated migration files whenever a `PointType` column is detected.
-
-Development
------------
-
-After cloning:
-
-```bash
-uv sync  # installs runtime + dev deps
-uv run pytest -q
-```
-
-Project Structure
------------------
+Or you could use something like [`some_fn`](https://funcy.readthedocs.io/en/stable/funcs.html#some_fn) to make this even cleaner.
 
-* `sqlalchemy_postgres_point/point.py` – Implementation of `PointType`.
-* `tests/test_point.py` – Unit tests for processors and comparator.
+## Limitations / Notes
 
-Limitations / Notes
--------------------
-
-* No automatic validation of longitude/latitude ranges; add your own if required.
+* Coordinates are validated on both write and read: longitude must be within `[-180, 180]`, latitude within `[-90, 90]`, and non-finite values (`NaN`, `inf`) are rejected with a `ValueError`.
 * Uses simple textual representation `(lng,lat)` accepted by PostgreSQL `POINT` input parser.
 * If you need advanced spatial indexing / SRID support, look at GeoAlchemy2/PostGIS instead.
 
-License
--------
-
-MIT (see your project's LICENSE file if added later). Contributions welcome.
-
 ---
 
 *This project was created from [iloveitaly/python-package-template](https://github.com/iloveitaly/python-package-template)*

sqlalchemy_postgres_point-0.2.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+sqlalchemy_postgres_point/__init__.py,sha256=BWlOd4qbAt4fM4cclR7ZrzZ-aib0f13KD3HIKmod2_s,208
+sqlalchemy_postgres_point/alembic_integration.py,sha256=T7VzTFNAlsI3_HMnnpwWNWTuXisJjfTxYlo8YW6KDE4,1015
+sqlalchemy_postgres_point/point.py,sha256=x0j76v6nihBb6yaXdQsM3CrNcYbf_jhfk0uEEeSaL1U,2863
+sqlalchemy_postgres_point/utils.py,sha256=Loc9Q-xkntEKP3WSw48rZr64aqPWdM9huBlJnGuZa_8,1340
+sqlalchemy_postgres_point-0.2.2.dist-info/WHEEL,sha256=wXwAVsgVaOZ_pwDFqQm5Rd6PID-Fc74nkLc8X8gHiDo,81
+sqlalchemy_postgres_point-0.2.2.dist-info/METADATA,sha256=eVs-JfQP4sHPrERXl0WuL6K00YPLWY3qUXJ4DIHr_h8,6210
+sqlalchemy_postgres_point-0.2.2.dist-info/RECORD,,

{sqlalchemy_postgres_point-0.2.0.dist-info → sqlalchemy_postgres_point-0.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.10.2
+Generator: uv 0.11.19
 Root-Is-Purelib: true
 Tag: py3-none-any

sqlalchemy_postgres_point-0.2.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-sqlalchemy_postgres_point/__init__.py,sha256=BWlOd4qbAt4fM4cclR7ZrzZ-aib0f13KD3HIKmod2_s,208
-sqlalchemy_postgres_point/alembic_integration.py,sha256=qaMk733hniatgGHwJXl0S5cKIsu_tno4JRvJ_MDLtPs,1840
-sqlalchemy_postgres_point/point.py,sha256=pb_aoNKwMOaKJ_xDvaIhfE-4VZKzyiPgOWmM6_z6xXo,2888
-sqlalchemy_postgres_point/utils.py,sha256=Loc9Q-xkntEKP3WSw48rZr64aqPWdM9huBlJnGuZa_8,1340
-sqlalchemy_postgres_point-0.2.0.dist-info/WHEEL,sha256=QnGI6l9Psotmz6XrseXTYT5jnZRJeTk4SwJP4aLtfdI,80
-sqlalchemy_postgres_point-0.2.0.dist-info/METADATA,sha256=4haIARMrgBsJi5JKaBp01PZ5Cuv8EnHr-ocd6XUL4hA,6367
-sqlalchemy_postgres_point-0.2.0.dist-info/RECORD,,