corelle.engine 3.0.0__py3-none-any.whl

corelle/engine/schema/02-functions.sql

@@ -0,0 +1,233 @@
+-- drop outdated function signatures
+DROP FUNCTION IF EXISTS corelle.rotate_geometry(geometry, numeric[]);
+DROP FUNCTION IF EXISTS corelle.rotate_geometry(geometry, integer, integer, integer);
+DROP FUNCTION IF EXISTS corelle.build_proj_string(numeric[]);
+DROP FUNCTION IF EXISTS corelle.quaternion_multiply(numeric[], numeric[]);
+DROP FUNCTION IF EXISTS corelle.invert_rotation(numeric[]);
+DROP FUNCTION IF EXISTS corelle.rotate_geometry(geometry, double precision[]);
+DROP FUNCTION IF EXISTS corelle.rotate_geometry(geometry,integer,integer,numeric,boolean);
+DROP FUNCTION IF EXISTS corelle.rotate_vector(numeric[], numeric[]);
+
+/*
+Functions to rotate geometries directly in PostGIS. This allows Corelle plate rotations
+to be applied to any geometry in the database. This requires plate geometries to be pre-cached
+in the database for each time step and plate ID.
+*/
+CREATE OR REPLACE FUNCTION corelle.rotate_geometry(
+  geom geometry,
+  quaternion double precision[],
+  wrap_lon numeric DEFAULT 0
+)
+RETURNS geometry
+AS $$
+DECLARE
+  projection text := corelle.build_proj_string(quaternion);
+  g1 geometry;
+BEGIN
+  return ST_SetSRID(ST_Transform(geom, projection), 4326);
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION corelle.invert_rotation(quaternion double precision[])
+RETURNS double precision[]
+AS $$
+  -- norm := sqrt(
+  --   pow(quaternion[1],2) + pow(quaternion[2],2) +
+  --   pow(quaternion[3],2) + pow(quaternion[4], 2)
+  -- );
+
+  SELECT ARRAY[
+    quaternion[1],
+    -quaternion[2],
+    -quaternion[3],
+    -quaternion[4]
+  ] ;
+$$ LANGUAGE sql IMMUTABLE STRICT;
+
+
+CREATE OR REPLACE FUNCTION corelle.rotate_vector(vector double precision[], quaternion double precision[]) RETURNS double precision[] AS $$
+  DECLARE
+    q_conj double precision[];
+    q_res double precision[];
+    r double precision[];
+  BEGIN
+    q_conj := ARRAY[
+      quaternion[1],
+      -quaternion[2],
+      -quaternion[3],
+      -quaternion[4]
+    ];
+
+    r := ARRAY[0, vector[1], vector[2], vector[3]];
+
+    q_res := corelle.quaternion_multiply(
+      corelle.quaternion_multiply(quaternion, r),
+      q_conj
+    );
+
+    RETURN ARRAY[q_res[2], q_res[3], q_res[4]];
+  END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION corelle.rotate_vector(vector numeric[], quaternion numeric[]) RETURNS numeric[] AS $$
+  SELECT corelle.rotate_vector(
+    ARRAY[
+      vector[1]::double precision,
+      vector[2]::double precision,
+      vector[3]::double precision
+    ],
+    ARRAY[
+      quaternion[1]::double precision,
+      quaternion[2]::double precision,
+      quaternion[3]::double precision,
+      quaternion[4]::double precision
+    ]
+  )::numeric[];
+$$ LANGUAGE sql IMMUTABLE STRICT;
+
+
+/* Rotate a geometry and clip to a bounding plate polygon */
+CREATE OR REPLACE FUNCTION corelle.rotate_geometry(
+  geom geometry,
+  _model_id integer,
+  _plate_id integer,
+  time_ma numeric,
+  should_clip boolean DEFAULT true
+)
+RETURNS geometry
+AS $$
+DECLARE
+  plate geometry;
+  rotation double precision[];
+  clipped geometry;
+BEGIN
+
+  -- get rotation at closest time step
+  SELECT r.rotation
+  FROM corelle.rotation_cache r
+  WHERE model_id = _model_id
+    AND plate_id = _plate_id
+    AND t_step = time_ma::integer
+  INTO rotation;
+
+  IF time_ma != 0 AND rotation IS null THEN
+    RETURN null;
+  END IF;
+
+  /* If we're not clipping, the operation is relatively simple, and also
+    should be much faster. */
+  IF NOT should_clip THEN
+    IF time_ma = 0 THEN
+      RETURN geom;
+    END IF;
+    RETURN corelle.rotate_geometry(geom, rotation);
+  END IF;
+
+  /* If we're clipping, we need more information */
+  SELECT geom
+  FROM corelle.plate_polygon
+  WHERE model_id = _model_id
+    AND plate_id = _plate_id
+    AND coalesce(old_lim, 4000) >= time_ma
+    AND coalesce(young_lim, 0) < time_ma
+  INTO plate;
+
+  IF plate IS NULL THEN
+    RETURN NULL;
+  END IF;
+
+  IF NOT geom && plate THEN
+    RETURN NULL;
+  END IF;
+
+  clipped := ST_Intersection(
+    geom,
+    plate
+  );
+
+  IF time_ma = 0 THEN
+    RETURN clipped;
+  END IF;
+
+  RETURN corelle.rotate_geometry(clipped, rotation);
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+DROP FUNCTION IF EXISTS corelle.build_proj_string(double precision[]);
+DROP FUNCTION IF EXISTS corelle.build_proj_string(double precision[], text);
+DROP FUNCTION IF EXISTS corelle.build_proj_string(double precision[], text, text);
+DROP FUNCTION IF EXISTS corelle.build_proj_string(double precision[], text, numeric);
+
+/**
+Builds a projection string from a quaternion. This is the core of Corelle's on-database
+rotation functionality.
+
+Big thanks to Duncan Agnew and the PROJ listserv for helping me figure out the right angular
+representation to use here.
+*/
+CREATE OR REPLACE FUNCTION corelle.build_proj_string(
+  quaternion double precision[],
+  extra_params text DEFAULT '+o_proj=longlat',
+  /* NOTE: lon_adjustment, in radians, is applied to the pole longitude
+  in order to rotate the projection to solve antimeridian issues. This is
+  a hack, and should be replaced with a better solution, probably involving
+  a fix to PROJ's ob_tran projection (to add handling of the +over parameter). */
+  lon_adjustment double precision DEFAULT 0
+)
+RETURNS text AS $$
+DECLARE
+  new_pole double precision[];
+  lat_p double precision;
+  lon_p double precision;
+  lon_0 double precision;
+  norm double precision;
+  twist_q_w double precision;
+  twist_angle double precision;
+BEGIN
+
+  new_pole := corelle.quaternion_multiply(
+    ARRAY[-quaternion[4], quaternion[3], -quaternion[2], quaternion[1]],
+    corelle.invert_rotation(quaternion)
+  );
+
+  lon_p := atan2(new_pole[3], new_pole[2]);
+  lat_p := asin(new_pole[4]);
+
+  norm := sqrt(pow(quaternion[1],2) + pow(quaternion[4], 2));
+
+  IF norm = 0 THEN
+    twist_q_w := 1;
+  ELSIF quaternion[4] < 0 THEN
+    twist_q_w := -quaternion[1] / norm;
+  ELSE
+    twist_q_w := quaternion[1] / norm;
+  END IF;
+
+  twist_angle := 2 * acos(twist_q_w);
+
+  lon_0 := lon_p - twist_angle;
+
+  RETURN format('+proj=ob_tran +o_lon_p=%sr +o_lat_p=%sr +lon_0=%sr ' || extra_params,
+    lon_p + lon_adjustment,
+    lat_p,
+    lon_0
+  );
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+
+/**
+Hamilton product of two quaternions.
+*/
+CREATE OR REPLACE FUNCTION corelle.quaternion_multiply(q double precision[], r double precision[])
+RETURNS double precision[]
+AS $$
+BEGIN
+  RETURN ARRAY[
+    r[1]*q[1]-r[2]*q[2]-r[3]*q[3]-r[4]*q[4],
+    r[1]*q[2]+r[2]*q[1]-r[3]*q[4]+r[4]*q[3],
+    r[1]*q[3]+r[2]*q[4]+r[3]*q[1]-r[4]*q[2],
+    r[1]*q[4]-r[2]*q[3]+r[3]*q[2]+r[4]*q[1]
+  ];
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;

corelle/engine/schema/03-testing-functions.sql

@@ -0,0 +1,186 @@
+/** Drop old function signatures */
+DROP FUNCTION IF EXISTS corelle.rotate_geometry_pointwise(geometry, numeric[]);
+DROP FUNCTION IF EXISTS corelle.rotate_point(geometry, numeric[]);
+DROP FUNCTION IF EXISTS corelle.sph2cart(geometry);
+DROP FUNCTION IF EXISTS corelle.cart2sph(numeric, numeric, numeric);
+DROP FUNCTION IF EXISTS corelle.quaternion_to_euler(numeric[]);
+DROP FUNCTION IF EXISTS corelle.euler_to_quaternion(geometry, numeric);
+DROP FUNCTION IF EXISTS corelle.radians(numeric);
+DROP FUNCTION IF EXISTS corelle.degrees(numeric);
+
+/**
+Naïve implementation of the quaternion rotation algorithm using PostGIS functions directly.
+
+This is quite slow compared to using PROJ directly. It is included here for reference and
+testing purposes.
+*/
+CREATE OR REPLACE FUNCTION corelle.rotate_geometry_pointwise(geom geometry, quaternion double precision[])
+RETURNS geometry
+AS $$
+DECLARE
+  result geometry;
+  rings geometry[];
+BEGIN
+  IF ST_GeometryType(geom) = 'ST_Point' THEN
+    RETURN corelle.rotate_point(geom, quaternion);
+  ELSIF ST_GeometryType(geom) = 'ST_MultiPoint' THEN
+    RETURN ST_Collect(ARRAY(
+      SELECT corelle.rotate_geometry_pointwise(g.geom, quaternion)
+      FROM ST_DumpPoints(geom) AS g
+    ));
+  ELSIF ST_GeometryType(geom) = 'ST_LineString' THEN
+    RETURN ST_MakeLine(ARRAY(
+      SELECT corelle.rotate_geometry_pointwise(g.geom, quaternion)
+      FROM ST_DumpPoints(geom) AS g
+    ));
+  ELSIF ST_GeometryType(geom) = 'ST_MultiLineString' THEN
+    RETURN ST_Collect(ARRAY(
+      SELECT corelle.rotate_geometry_pointwise(g.geom, quaternion)
+      FROM ST_Dump(geom) AS g
+    ));
+  ELSIF ST_GeometryType(geom) = 'ST_Polygon' THEN
+    -- don't handle rings yet...
+    -- Rotate interior rings
+    rings := ARRAY(
+      SELECT corelle.rotate_geometry_pointwise(ST_InteriorRingN(geom, r), quaternion)
+      FROM generate_series(1, ST_NumInteriorRing(geom)) AS r
+    );
+
+    RETURN ST_MakePolygon(corelle.rotate_geometry_pointwise(ST_ExteriorRing(geom), quaternion), rings);
+  ELSIF ST_GeometryType(geom) = 'ST_MultiPolygon' THEN
+    RETURN ST_Collect(ARRAY(
+      SELECT corelle.rotate_geometry_pointwise(g.geom, quaternion)
+      FROM ST_Dump(geom) AS g
+    ));
+  ELSE
+    RAISE EXCEPTION 'Unsupported geometry type: %', ST_GeometryType(geom);
+  END IF;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION corelle.rotate_point(point geometry, quaternion double precision[])
+RETURNS geometry AS $$
+DECLARE
+  pt double precision[] := corelle.sph2cart(point);
+  q_conj double precision[];
+  q_res double precision[];
+  r double precision[];
+BEGIN
+  q_conj := ARRAY[
+    quaternion[1],
+    -quaternion[2],
+    -quaternion[3],
+    -quaternion[4]
+  ];
+
+  r := ARRAY[0, pt[1], pt[2], pt[3]];
+
+  q_res := corelle.quaternion_multiply(
+    corelle.quaternion_multiply(quaternion, r),
+    q_conj
+  );
+
+  RETURN corelle.cart2sph(
+    q_res[2],
+    q_res[3],
+    q_res[4]
+  );
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;
+
+/**
+* UTILITIES for converting between spherical and cartesian coordinates.
+* These are primarily used for testing purposes.
+*/
+CREATE OR REPLACE FUNCTION corelle.sph2cart(point geometry)
+RETURNS double precision[] AS $$
+DECLARE
+  lon double precision := corelle.radians(ST_X(point));
+  lat double precision := corelle.radians(ST_Y(point));
+  r double precision := coalesce(ST_Z(point), 1);
+BEGIN
+  RETURN ARRAY[
+    r * cos(lat) * cos(lon),
+    r * cos(lat) * sin(lon),
+    r * sin(lat)
+  ];
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;
+
+
+CREATE OR REPLACE FUNCTION corelle.cart2sph(x double precision, y double precision, z double precision)
+RETURNS geometry
+AS $$
+DECLARE
+  r double precision := sqrt(x * x + y * y + z * z);
+  lat double precision := corelle.degrees(asin(z / r));
+  lon double precision := corelle.degrees(atan2(y, x));
+BEGIN
+  IF abs(r-1) < 0.0000001 THEN
+    RETURN ST_SetSRID(ST_MakePoint(lon, lat), 4326);
+  ELSE
+    RETURN ST_SetSRID(ST_MakePoint(lon, lat, r), 4326);
+  END IF;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION corelle.quaternion_to_euler(q double precision[])
+RETURNS double precision[] AS $$
+DECLARE
+  w double precision := q[1];
+  x double precision := q[2];
+  y double precision := q[3];
+  z double precision := q[4];
+  angle double precision := 2 * acos(w);
+  scalar double precision := sin(angle / 2);
+  lat double precision;
+  lon double precision;
+BEGIN
+  IF scalar = 0 THEN
+    RETURN null;
+  ELSE
+    lat := asin(z/scalar);
+    lon := atan2(y/scalar, x/scalar);
+    RETURN ARRAY[lon, lat, angle];
+  END IF;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION corelle.euler_to_quaternion(pole geometry, angle double precision)
+RETURNS double precision[] AS $$
+DECLARE
+  half_angle double precision := corelle.radians(angle) / 2;
+  scalar double precision := sin(half_angle);
+  v double precision[] := corelle.sph2cart(pole);
+BEGIN
+  RETURN ARRAY[
+    cos(half_angle),
+    v[1] * scalar,
+    v[2] * scalar,
+    v[3] * scalar
+  ];
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;
+
+/* Convert to radians */
+CREATE OR REPLACE FUNCTION corelle.radians(degrees double precision)
+RETURNS double precision AS $$
+BEGIN
+  RETURN degrees * pi() / 180;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;
+
+/* Convert to degrees */
+CREATE OR REPLACE FUNCTION corelle.degrees(radians double precision)
+RETURNS double precision AS $$
+DECLARE
+  uncorrected double precision := radians * 180 / pi();
+BEGIN
+  -- Return data in the right quadrant
+  IF uncorrected < -180 THEN
+    RETURN uncorrected + 360;
+  ELSE
+    RETURN uncorrected;
+  END IF;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE STRICT;

corelle/engine/schema/04-views.sql

@@ -0,0 +1,47 @@
+DROP MATERIALIZED VIEW IF EXISTS corelle.plate_polygon_cache;
+CREATE MATERIALIZED VIEW corelle.plate_polygon_cache AS
+WITH a AS (
+-- Basic query for plate polygons
+SELECT
+  pp.id,
+  pp.plate_id,
+  coalesce(young_lim, 0) young_lim,
+  old_lim,
+  p.name,
+  ST_AsGeoJSON(geometry)::jsonb geometry,
+  pp.model_id
+FROM corelle.plate_polygon pp
+JOIN corelle.plate p
+  ON pp.plate_id = p.id
+ AND pp.model_id = p.model_id
+),
+b AS (
+SELECT json_build_object(
+	'id', plate_id,
+	'properties', json_build_object(
+		'id', a.id,
+		'plate_id', plate_id,
+		'young_lim', young_lim,
+		'old_lim', old_lim,
+		'name', name
+	),
+	'type', 'Feature',
+	'geometry', geometry
+ ) r,
+ model_id
+FROM a
+),
+c AS (
+SELECT
+	model_id,
+	json_agg(r) geojson
+FROM b
+GROUP BY model_id
+)
+SELECT
+  m.id model_id,
+  m.name model_name,
+  c.geojson
+FROM c
+JOIN corelle.model m
+  ON m.id = c.model_id;

corelle/engine/storage.py

@@ -0,0 +1,11 @@
+from sqlalchemy import MetaData, Table, text
+
+_model_id = text("SELECT id FROM corelle.model WHERE name = :name")
+
+
+def model_id(conn, name):
+    return conn.execute(_model_id, dict(name=name)).scalar()
+
+
+def reflect_table(conn, name):
+    return Table(name, MetaData(), schema="corelle", autoload_with=conn)

corelle_engine-3.0.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: corelle.engine
+Version: 3.0.0
+Summary: Plate-rotation models and rotation engine for the Corelle system
+Author: Daven Quinn
+Author-email: Daven Quinn <dev@davenquinn.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: click>=8.1,<9
+Requires-Dist: corelle-client>=2.2,<3
+Requires-Dist: macrostrat-database>=4.7,<5
+Requires-Dist: macrostrat-utils>=1.0.1,<2
+Requires-Dist: numba>=0.63.1,<0.69
+Requires-Dist: numpy>=2.0.0,<3
+Requires-Dist: numpy-quaternion>=2024.0.13,<2025.0.0
+Requires-Dist: rich>12.6.0,<16
+Requires-Dist: typer>0.12.0,<0.30
+Requires-Dist: geoalchemy2>0.14.0,<0.22
+Requires-Dist: sqlalchemy>=2.0.25,<2.1
+Requires-Dist: fiona>=1.10.1,<2 ; extra == 'import'
+Requires-Dist: pyyaml>=6.0,<7 ; extra == 'import'
+Requires-Dist: wget>=3.2,<4 ; extra == 'import'
+Requires-Dist: ipython>=8.0,<10 ; extra == 'shell'
+Requires-Python: >=3.10, <4
+Provides-Extra: import
+Provides-Extra: shell

corelle_engine-3.0.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+corelle/engine/__init__.py,sha256=QPWtj5wDRTINDxVUL7XPqG3HoxHNvYOg08EnuSZB2Hc,21
+corelle/engine/cache.py,sha256=MWf27Buo5mmYhYuV076rLl_lQV_L4TXZRnLkkg-NPWc,2175
+corelle/engine/cli.py,sha256=NeyqFeIe3TMDwKDyIW6YDB1jBqZDA_ReUQr2Jz7-URY,4610
+corelle/engine/database.py,sha256=OfVsBmcBufKJX1v0EsgyRin0xo3TbD5Hyxp4L_1Yl3U,951
+corelle/engine/load_data.py,sha256=KBlb8xYzR-QbU8UXYO48g7hP89xmoMFj3-4ZJp73HRM,10557
+corelle/engine/query/__init__.py,sha256=iM0JjZh-whRKlE8Hg2zIXC2Mo8IVVcauXCs9CDnGDwQ,171
+corelle/engine/query/active-plates-at-time.sql,sha256=H6QEQXOmIWrAdx49T6YEGnx53OEqyOFUB1beI3J-WZk,284
+corelle/engine/query/cache-feature-dataset.sql,sha256=uTEv2SHwZOD4oHAUuaIph0avUwGmXtwRyj-rrNPphvs,910
+corelle/engine/query/delete-extraneous-cache.sql,sha256=UHHOcKrKaaNpbxP8K3FWkTzORBeJ3TSy-78DyOiQ7Ak,210
+corelle/engine/query/feature-dataset-cached.sql,sha256=_NoCafzkym-jRnT3h6F5drMvN8blHXT1vIW_Cn3JVCQ,101
+corelle/engine/query/feature-dataset.sql,sha256=R8sh7C4avZLxBeD_knZVJmpzksv3hDUXXdAFYbdfKjk,588
+corelle/engine/query/modern-plate-polygons-cached.sql,sha256=oA5__Ag7QAgRbQ-sfwrY_bqVPqj_zW0-W_bjFMTbnqA,79
+corelle/engine/query/modern-plate-polygons.sql,sha256=mRxu7BwAm2_PhHtgJr3V0dHvDVo3EdqzgF-nahLELJI,298
+corelle/engine/query/plate-for-point.sql,sha256=h0ULqoW0TV9OkOcadBwn4KAi0m1H26KPE6U5OVPsPj4,254
+corelle/engine/query/plate-time-ranges.sql,sha256=ycASErhdOZnUhLfE-AgrRNAbhAU8kLnmUsve-HMnvMw,225
+corelle/engine/query/plates-for-model.sql,sha256=ocOTgNVpf42CiD0EIZOueDuEZgxhffP7AqaEMUp_2JA,109
+corelle/engine/query/rotation-pairs-for-model.sql,sha256=j5-hcSuQm9Ly9Y7RP3QPyQUQBLqv04Cc3jgiMbUQYU8,1359
+corelle/engine/query/rotation-pairs-for-time.sql,sha256=Jyl8OdmFLMbNrPKNO0zQlYPnVgemH2Hy8XIDtA8SLYg,1316
+corelle/engine/query/rotation-pairs.sql,sha256=4zgdtK_Z23TnnCD3NJgjguG0hGU3E1lkCp3jROI_P8U,1343
+corelle/engine/query/update-cache.sql,sha256=7qC-rGjRZf-ocPaeCdUr_wqxHlq52S7dp8wvx_kb64Y,383
+corelle/engine/rotate.py,sha256=evTChWxcCvy8w7e38YI8kHu5U39P6CqzvUYSLFH44pA,7137
+corelle/engine/schema/00-init.sql,sha256=tVZAyi9mAJ02Rua0eufq6S2wjJ8hZvevz8-yLoghN9Y,77
+corelle/engine/schema/01-schema.sql,sha256=Tj2TFjQT9RgzN1reU0rx1awyTx6BSwS6TcIYDWKnoJ0,2502
+corelle/engine/schema/02-functions.sql,sha256=o6uJBaPY9lsU9y_2nhIrP8emYzjmt0z_gBgh60QHb98,6534
+corelle/engine/schema/03-testing-functions.sql,sha256=rzFivenOweJSWzHUV46fkaPnZO3Beyyx5rOHvClmfjg,5591
+corelle/engine/schema/04-views.sql,sha256=uQC2AHnsPEevMvm3pZUXXcCpVLO3j1x7iqF1KgJAZwk,855
+corelle/engine/storage.py,sha256=ngTGd3Wjadib6WRNZiKGNNYuLZHObGe6LcMQEKM9mhM,309
+corelle_engine-3.0.0.dist-info/WHEEL,sha256=3OmCxFA0ffBIsX4x0o8CdfSvZAOvO3mzEG8U_z5TvV4,80
+corelle_engine-3.0.0.dist-info/entry_points.txt,sha256=2lP8_vn_kszBAcQkxmn92i-Z2LqUx-0SG39M22tdSjw,48
+corelle_engine-3.0.0.dist-info/METADATA,sha256=MOyLyMX-1k01L4Pd9pMUr_3m6tdz3nll0adX6O15PDU,1215
+corelle_engine-3.0.0.dist-info/RECORD,,

corelle_engine-3.0.0.dist-info/WHEEL

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

corelle_engine-3.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+corelle = corelle.engine:cli
+