From 5f05c8c16e4b91a7eba07f320c27ddf05758e439 Mon Sep 17 00:00:00 2001 From: Tobias Fischer Date: Mon, 7 Aug 2023 07:26:30 +1000 Subject: [PATCH 1/6] Add pymorton --- recipes/pymorton/meta.yaml | 51 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 recipes/pymorton/meta.yaml diff --git a/recipes/pymorton/meta.yaml b/recipes/pymorton/meta.yaml new file mode 100644 index 0000000000000..5cea083dae7ba --- /dev/null +++ b/recipes/pymorton/meta.yaml @@ -0,0 +1,51 @@ +{% set name = "pymorton" %} +{% set version = "1.0.7" %} + +package: + name: {{ name|lower }} + version: {{ version }} + +source: + url: https://github.com/trevorprater/{{ name }}/archive/refs/tags/1.0.5.tar.gz + sha256: f22ebe8c1f69ef4001c59f277dbe5403cb18f6bd3004ef19ac0e5fbdf5f865f6 + patches: + - v1.0.7.patch + - fix-64-bit.patch + +build: + noarch: python + number: 0 + script: "{{ PYTHON }} -m pip install . -vv" + +requirements: + host: + - python + - pip + run: + - python + +test: + imports: + - pymorton + +about: + home: https://github.com/trevorprater/pymorton + license: MIT + license_file: LICENSE.md + summary: 'Ordinal hashing of multidimensional data and geographic coordinates via Morton coding / Z-ordering.' + description: | + In mathematical analysis and computer science, Z-order, Morton-order, or a Morton-code + is a function which maps multidimensional data to one dimension while preserving locality + of the data points. It was introduced in 1966 by IBM researcher, G. M. Morton. The z-value + of a point in multidimensions is calculated by interleaving the binary representations of + its coordinate values. Once the data are sorted into this ordering, any one-dimensional data + structure can be used, such as binary search trees, B-trees, skip lists, or hash tables. + The resulting ordering can equivalently be described as the order one would achieve from a + depth-first traversal of a quadtree, where {x, y, …, K} are combined into a single ordinal + value that is easily compared, searched, and indexed against other Morton numbers. + dev_url: https://github.com/trevorprater/pymorton + +extra: + recipe-maintainers: + - Tobias-Fischer + From 87997c50ea5d88e965f0397ac7fd3207bad4fbc7 Mon Sep 17 00:00:00 2001 From: Tobias Fischer Date: Mon, 7 Aug 2023 07:27:25 +1000 Subject: [PATCH 2/6] Create v1.0.7.patch --- recipes/pymorton/v1.0.7.patch | 430 ++++++++++++++++++++++++++++++++++ 1 file changed, 430 insertions(+) create mode 100644 recipes/pymorton/v1.0.7.patch diff --git a/recipes/pymorton/v1.0.7.patch b/recipes/pymorton/v1.0.7.patch new file mode 100644 index 0000000000000..9afaa9afa2127 --- /dev/null +++ b/recipes/pymorton/v1.0.7.patch @@ -0,0 +1,430 @@ +diff --git a/.travis.yml b/.travis.yml +index 0064caa..9515dc7 100644 +--- a/.travis.yml ++++ b/.travis.yml +@@ -1,11 +1,10 @@ + language: python + python: +- - "2.6" + - "2.7" +- - "3.3" + - "3.4" + - "3.5" + - "3.6" ++ - "3.7" + + install: + - pip install -r dev-requirements.txt +diff --git a/pymorton/__init__.py b/pymorton/__init__.py +index ce6b96c..41f0993 100644 +--- a/pymorton/__init__.py ++++ b/pymorton/__init__.py +@@ -1,138 +1 @@ +-# pymorton (https://github.com/trevorprater/pymorton) +-# Author: trevor.prater@gmail.com +-# License: MIT +- +-_DIVISORS = [180.0 / 2 ** n for n in range(32)] +- +- +-def __part1by1(n): +- n &= 0x0000ffff # base10: 65535, binary: 1111111111111111, len: 16 +- n = (n | (n << 8)) & 0x00FF00FF # base10: 16711935, binary: 111111110000000011111111, len: 24 +- n = (n | (n << 4)) & 0x0F0F0F0F # base10: 252645135, binary: 1111000011110000111100001111, len: 28 +- n = (n | (n << 2)) & 0x33333333 # base10: 858993459, binary: 110011001100110011001100110011, len: 30 +- n = (n | (n << 1)) & 0x55555555 # base10: 1431655765, binary: 1010101010101010101010101010101, len: 31 +- +- return n +- +- +-def __part1by2(n): +- n &= 0x000003ff # base10: 1023, binary: 1111111111, len: 10 +- n = (n ^ (n << 16)) & 0xff0000ff # base10: 4278190335, binary: 11111111000000000000000011111111, len: 32 +- n = (n ^ (n << 8)) & 0x0300f00f # base10: 50393103, binary: 11000000001111000000001111, len: 26 +- n = (n ^ (n << 4)) & 0x030c30c3 # base10: 51130563, binary: 11000011000011000011000011, len: 26 +- n = (n ^ (n << 2)) & 0x09249249 # base10: 153391689, binary: 1001001001001001001001001001, len: 28 +- +- return n +- +- +-def __unpart1by1(n): +- n &= 0x55555555 # base10: 1431655765, binary: 1010101010101010101010101010101, len: 31 +- n = (n ^ (n >> 1)) & 0x33333333 # base10: 858993459, binary: 110011001100110011001100110011, len: 30 +- n = (n ^ (n >> 2)) & 0x0f0f0f0f # base10: 252645135, binary: 1111000011110000111100001111, len: 28 +- n = (n ^ (n >> 4)) & 0x00ff00ff # base10: 16711935, binary: 111111110000000011111111, len: 24 +- n = (n ^ (n >> 8)) & 0x0000ffff # base10: 65535, binary: 1111111111111111, len: 16 +- +- return n +- +- +-def __unpart1by2(n): +- n &= 0x09249249 # base10: 153391689, binary: 1001001001001001001001001001, len: 28 +- n = (n ^ (n >> 2)) & 0x030c30c3 # base10: 51130563, binary: 11000011000011000011000011, len: 26 +- n = (n ^ (n >> 4)) & 0x0300f00f # base10: 50393103, binary: 11000000001111000000001111, len: 26 +- n = (n ^ (n >> 8)) & 0xff0000ff # base10: 4278190335, binary: 11111111000000000000000011111111, len: 32 +- n = (n ^ (n >> 16)) & 0x000003ff # base10: 1023, binary: 1111111111, len: 10 +- +- return n +- +- +-def interleave2(*args): +- if len(args) != 2: +- raise ValueError('Usage: interleave2(x, y)') +- for arg in args: +- if not isinstance(arg, int): +- print('Usage: interleave2(x, y)') +- raise ValueError("Supplied arguments contain a non-integer!") +- +- return __part1by1(args[0]) | (__part1by1(args[1]) << 1) +- +- +-def interleave3(*args): +- if len(args) != 3: +- raise ValueError('Usage: interleave3(x, y, z)') +- for arg in args: +- if not isinstance(arg, int): +- print('Usage: interleave3(x, y, z)') +- raise ValueError("Supplied arguments contain a non-integer!") +- +- return __part1by2(args[0]) | (__part1by2(args[1]) << 1) | ( +- __part1by2(args[2]) << 2) +- +- +-def interleave(*args): +- if len(args) < 2 or len(args) > 3: +- print('Usage: interleave(x, y, (optional) z)') +- raise ValueError( +- "You must supply two or three integers to interleave!") +- +- method = globals()["interleave" + str(len(args))] +- +- return method(*args) +- +- +-def deinterleave2(n): +- if not isinstance(n, int): +- print('Usage: deinterleave2(n)') +- raise ValueError("Supplied arguments contain a non-integer!") +- +- return __unpart1by1(n), __unpart1by1(n >> 1) +- +- +-def deinterleave3(n): +- if not isinstance(n, int): +- print('Usage: deinterleave2(n)') +- raise ValueError("Supplied arguments contain a non-integer!") +- +- return __unpart1by2(n), __unpart1by2(n >> 1), __unpart1by2(n >> 2) +- +-def interleave_latlng(lat, lng): +- if not isinstance(lat, float) or not isinstance(lng, float): +- print('Usage: interleave_latlng(float, float)') +- raise ValueError("Supplied arguments must be of type float!") +- +- if (lng > 180): +- x = (lng % 180) + 180.0 +- elif (lng < -180): +- x = (-((-lng) % 180)) + 180.0 +- else: +- x = lng + 180.0 +- if (lat > 90): +- y = (lat % 90) + 90.0 +- elif (lat < -90): +- y = (-((-lat) % 90)) + 90.0 +- else: +- y = lat + 90.0 +- +- morton_code = "" +- for dx in _DIVISORS: +- digit = 0 +- if (y >= dx): +- digit |= 2 +- y -= dx +- if (x >= dx): +- digit |= 1 +- x -= dx +- morton_code += str(digit) +- +- return morton_code +- +- +-def deinterleave_latlng(n): +- x = y = 0 +- for (digit, multiplier) in zip([int(d) for d in n], _DIVISORS): +- if (digit & 2): +- y += multiplier +- if (digit & 1): +- x += multiplier +- +- return round(y - 90.0, 6), round(x - 180.0, 6) +- ++from .pymorton import * +diff --git a/pymorton/pymorton.py b/pymorton/pymorton.py +new file mode 100644 +index 0000000..895d9c7 +--- /dev/null ++++ b/pymorton/pymorton.py +@@ -0,0 +1,194 @@ ++# pymorton (https://github.com/trevorprater/pymorton) ++# Author: trevor.prater@gmail.com ++# License: MIT ++ ++import sys ++ ++_DIVISORS = [180.0 / 2 ** n for n in range(32)] ++ ++ ++def __part1by1_32(n): ++ n &= 0x0000ffff # base10: 65535, binary: 1111111111111111, len: 16 ++ n = (n | (n << 8)) & 0x00FF00FF # base10: 16711935, binary: 111111110000000011111111, len: 24 ++ n = (n | (n << 4)) & 0x0F0F0F0F # base10: 252645135, binary: 1111000011110000111100001111, len: 28 ++ n = (n | (n << 2)) & 0x33333333 # base10: 858993459, binary: 110011001100110011001100110011, len: 30 ++ n = (n | (n << 1)) & 0x55555555 # base10: 1431655765, binary: 1010101010101010101010101010101, len: 31 ++ ++ return n ++ ++ ++def __part1by2_32(n): ++ n &= 0x000003ff # base10: 1023, binary: 1111111111, len: 10 ++ n = (n ^ (n << 16)) & 0xff0000ff # base10: 4278190335, binary: 11111111000000000000000011111111, len: 32 ++ n = (n ^ (n << 8)) & 0x0300f00f # base10: 50393103, binary: 11000000001111000000001111, len: 26 ++ n = (n ^ (n << 4)) & 0x030c30c3 # base10: 51130563, binary: 11000011000011000011000011, len: 26 ++ n = (n ^ (n << 2)) & 0x09249249 # base10: 153391689, binary: 1001001001001001001001001001, len: 28 ++ ++ return n ++ ++ ++def __unpart1by1_32(n): ++ n &= 0x55555555 # base10: 1431655765, binary: 1010101010101010101010101010101, len: 31 ++ n = (n ^ (n >> 1)) & 0x33333333 # base10: 858993459, binary: 110011001100110011001100110011, len: 30 ++ n = (n ^ (n >> 2)) & 0x0f0f0f0f # base10: 252645135, binary: 1111000011110000111100001111, len: 28 ++ n = (n ^ (n >> 4)) & 0x00ff00ff # base10: 16711935, binary: 111111110000000011111111, len: 24 ++ n = (n ^ (n >> 8)) & 0x0000ffff # base10: 65535, binary: 1111111111111111, len: 16 ++ ++ return n ++ ++ ++def __unpart1by2_32(n): ++ n &= 0x09249249 # base10: 153391689, binary: 1001001001001001001001001001, len: 28 ++ n = (n ^ (n >> 2)) & 0x030c30c3 # base10: 51130563, binary: 11000011000011000011000011, len: 26 ++ n = (n ^ (n >> 4)) & 0x0300f00f # base10: 50393103, binary: 11000000001111000000001111, len: 26 ++ n = (n ^ (n >> 8)) & 0xff0000ff # base10: 4278190335, binary: 11111111000000000000000011111111, len: 32 ++ n = (n ^ (n >> 16)) & 0x000003ff # base10: 1023, binary: 1111111111, len: 10 ++ ++ return n ++ ++ ++def __part1by1_64(n): ++ n &= 0x00000000ffffffff # binary: 11111111111111111111111111111111, len: 32 ++ n = (n | (n << 16)) & 0x0000FFFF0000FFFF # binary: 1111111111111111000000001111111111111111, len: 40 ++ n = (n | (n << 8)) & 0x00FF00FF00FF00FF # binary: 11111111000000001111111100000000111111110000000011111111, len: 56 ++ n = (n | (n << 4)) & 0x0F0F0F0F0F0F0F0F # binary: 111100001111000011110000111100001111000011110000111100001111, len: 60 ++ n = (n | (n << 2)) & 0x3333333333333333 # binary: 11001100110011001100110011001100110011001100110011001100110011, len: 62 ++ n = (n | (n << 1)) & 0x5555555555555555 # binary: 101010101010101010101010101010101010101010101010101010101010101, len: 63 ++ ++ return n ++ ++ ++def __part1by2_64(n): ++ n &= 0x1fffff # binary: 111111111111111111111, len: 21 ++ n = (n | (n << 32)) & 0x1f00000000ffff # binary: 11111000000000000000000000000000000001111111111111111, len: 53 ++ n = (n | (n << 16)) & 0x1f0000ff0000ff # binary: 11111000000000000000011111111000000000000000011111111, len: 53 ++ n = (n | (n << 8)) & 0x100f00f00f00f00f # binary: 1000000001111000000001111000000001111000000001111000000001111, len: 61 ++ n = (n | (n << 4)) & 0x10c30c30c30c30c3 # binary: 1000011000011000011000011000011000011000011000011000011000011, len: 61 ++ n = (n | (n << 2)) & 0x1249249249249249 # binary: 1001001001001001001001001001001001001001001001001001001001001, len: 61 ++ ++ return n ++ ++ ++def __unpart1by1_64(n): ++ n &= 0x5555555555555555 # binary: 101010101010101010101010101010101010101010101010101010101010101, len: 63 ++ n = (n ^ (n >> 1)) & 0x3333333333333333 # binary: 11001100110011001100110011001100110011001100110011001100110011, len: 62 ++ n = (n ^ (n >> 2)) & 0x0f0f0f0f0f0f0f0f # binary: 111100001111000011110000111100001111000011110000111100001111, len: 60 ++ n = (n ^ (n >> 4)) & 0x00ff00ff00ff00ff # binary: 11111111000000001111111100000000111111110000000011111111, len: 56 ++ n = (n ^ (n >> 8)) & 0x0000ffff0000ffff # binary: 1111111111111111000000001111111111111111, len: 40 ++ n = (n ^ (n >> 16)) & 0x00000000ffffffff # binary: 11111111111111111111111111111111, len: 32 ++ return n ++ ++ ++def __unpart1by2_64(n): ++ n &= 0x1249249249249249 # binary: 1001001001001001001001001001001001001001001001001001001001001, len: 61 ++ n = (n ^ (n >> 2)) & 0x10c30c30c30c30c3 # binary: 1000011000011000011000011000011000011000011000011000011000011, len: 61 ++ n = (n ^ (n >> 4)) & 0x100f00f00f00f00f # binary: 1000000001111000000001111000000001111000000001111000000001111, len: 61 ++ n = (n ^ (n >> 8)) & 0x1f0000ff0000ff # binary: 11111000000000000000011111111000000000000000011111111, len: 53 ++ n = (n ^ (n >> 16)) & 0x1f00000000ffff # binary: 11111000000000000000000000000000000001111111111111111, len: 53 ++ n = (n ^ (n >> 32)) & 0x1fffff # binary: 111111111111111111111, len: 21 ++ return n ++ ++ ++if getattr(sys, 'maxint', 0) and sys.maxint <= 2 ** 31 - 1: ++ __part1by1 = __part1by1_32 ++ __part1by2 = __part1by2_32 ++ __unpart1by1 = __unpart1by1_32 ++ __unpart1by2 = __unpart1by2_32 ++else: ++ __part1by1 = __part1by1_64 ++ __part1by2 = __part1by2_64 ++ __unpart1by1 = __unpart1by1_64 ++ __unpart1by2 = __unpart1by2_64 ++ ++ ++def interleave2(*args): ++ if len(args) != 2: ++ raise ValueError('Usage: interleave2(x, y)') ++ for arg in args: ++ if not isinstance(arg, int): ++ print('Usage: interleave2(x, y)') ++ raise ValueError("Supplied arguments contain a non-integer!") ++ ++ return __part1by1(args[0]) | (__part1by1(args[1]) << 1) ++ ++ ++def interleave3(*args): ++ if len(args) != 3: ++ raise ValueError('Usage: interleave3(x, y, z)') ++ for arg in args: ++ if not isinstance(arg, int): ++ print('Usage: interleave3(x, y, z)') ++ raise ValueError("Supplied arguments contain a non-integer!") ++ ++ return __part1by2(args[0]) | (__part1by2(args[1]) << 1) | ( ++ __part1by2(args[2]) << 2) ++ ++ ++def interleave(*args): ++ if len(args) < 2 or len(args) > 3: ++ print('Usage: interleave(x, y, (optional) z)') ++ raise ValueError( ++ "You must supply two or three integers to interleave!") ++ ++ method = globals()["interleave" + str(len(args))] ++ ++ return method(*args) ++ ++ ++def deinterleave2(n): ++ if not isinstance(n, int): ++ print('Usage: deinterleave2(n)') ++ raise ValueError("Supplied arguments contain a non-integer!") ++ ++ return __unpart1by1(n), __unpart1by1(n >> 1) ++ ++ ++def deinterleave3(n): ++ if not isinstance(n, int): ++ print('Usage: deinterleave2(n)') ++ raise ValueError("Supplied arguments contain a non-integer!") ++ ++ return __unpart1by2(n), __unpart1by2(n >> 1), __unpart1by2(n >> 2) ++ ++def interleave_latlng(lat, lng): ++ if not isinstance(lat, float) or not isinstance(lng, float): ++ print('Usage: interleave_latlng(float, float)') ++ raise ValueError("Supplied arguments must be of type float!") ++ ++ if (lng > 180): ++ x = (lng % 180) + 180.0 ++ elif (lng < -180): ++ x = (-((-lng) % 180)) + 180.0 ++ else: ++ x = lng + 180.0 ++ if (lat > 90): ++ y = (lat % 90) + 90.0 ++ elif (lat < -90): ++ y = (-((-lat) % 90)) + 90.0 ++ else: ++ y = lat + 90.0 ++ ++ morton_code = "" ++ for dx in _DIVISORS: ++ digit = 0 ++ if (y >= dx): ++ digit |= 2 ++ y -= dx ++ if (x >= dx): ++ digit |= 1 ++ x -= dx ++ morton_code += str(digit) ++ ++ return morton_code ++ ++ ++def deinterleave_latlng(n): ++ x = y = 0 ++ for (digit, multiplier) in zip([int(d) for d in n], _DIVISORS): ++ if (digit & 2): ++ y += multiplier ++ if (digit & 1): ++ x += multiplier ++ ++ return round(y - 90.0, 6), round(x - 180.0, 6) ++ +diff --git a/setup.py b/setup.py +index 1ad7fcb..e4f7fac 100644 +--- a/setup.py ++++ b/setup.py +@@ -17,7 +17,7 @@ + def build(): + setup( + name='pymorton', +- version='1.0.5', ++ version='1.0.7', + author='Trevor Prater', + author_email='trevor.prater@gmail.com', + description='A lightweight morton coder with lat/long support.', +@@ -35,5 +35,6 @@ def build(): + ] + ) + ++ + if __name__ == '__main__': + build() +diff --git a/tests/test_pymorton.py b/tests/test_pymorton.py +index 808809f..5d8b6b6 100644 +--- a/tests/test_pymorton.py ++++ b/tests/test_pymorton.py +@@ -3,6 +3,8 @@ + # License: MIT + + import unittest ++import random ++import sys + import pymorton as pm + from nose.tools import assert_raises + +@@ -17,9 +19,25 @@ def test_hashing_3d_valid(self): + + def test_hash_reversability_2d_valid(self): + assert (100, 30) == pm.deinterleave2(pm.interleave(100, 30)) ++ if getattr(sys, 'maxint', 0) and sys.maxint <= 2 ** 31 - 1: ++ max_v = 0x0fff ++ else: ++ max_v = 0x0fffffff ++ for i in range(100): ++ p1 = (random.randint(0, max_v), random.randint(0, max_v)) ++ print(p1, pm.deinterleave2(pm.interleave(*p1))) ++ assert p1 == pm.deinterleave2(pm.interleave(*p1)) + + def test_hash_reversability_3d_valid(self): + assert pm.deinterleave3(pm.interleave(100, 30, 50)) == (100, 30, 50) ++ if getattr(sys, 'maxint', 0) and sys.maxint <= 2 ** 31 - 1: ++ max_v = 0xff ++ else: ++ max_v = 0xffff ++ for i in range(100): ++ p1 = (random.randint(0, max_v), random.randint(0, max_v), random.randint(0, max_v)) ++ print(p1, pm.deinterleave3(pm.interleave(*p1))) ++ assert p1 == pm.deinterleave3(pm.interleave(*p1)) + + def test_hash_ordinality_2d(self): + assert pm.interleave(10, 25) < pm.interleave(10, 50) +@@ -80,9 +98,6 @@ def test_non_float_input_interleave_latlng(self): + def test_geohash_ordinality(self): + assert pm.interleave_latlng(-40.723471, -73.985361) < pm.interleave_latlng(-40.523471, -73.785361) + +- def test_geohash_divisor_constant_generation(self): +- assert pm._DIVISORS[4] == 11.25 +- + + if __name__ == '__main__': + unittest.main() From 2ad76a3cbc737ce154c21daca9106faaa72c8f6a Mon Sep 17 00:00:00 2001 From: Tobias Fischer Date: Mon, 7 Aug 2023 07:27:46 +1000 Subject: [PATCH 3/6] Create fix-64-bit.patch --- recipes/pymorton/fix-64-bit.patch | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 recipes/pymorton/fix-64-bit.patch diff --git a/recipes/pymorton/fix-64-bit.patch b/recipes/pymorton/fix-64-bit.patch new file mode 100644 index 0000000000000..6f7118b62a635 --- /dev/null +++ b/recipes/pymorton/fix-64-bit.patch @@ -0,0 +1,14 @@ +diff --git a/pymorton/pymorton.py b/pymorton/pymorton.py +index 895d9c7..d787307 100644 +--- a/pymorton/pymorton.py ++++ b/pymorton/pymorton.py +@@ -89,7 +89,7 @@ def __unpart1by2_64(n): + return n + + +-if getattr(sys, 'maxint', 0) and sys.maxint <= 2 ** 31 - 1: ++if sys.version_info[0] == 2 and getattr(sys, 'maxint', 0) and sys.maxint <= 2 ** 31 - 1: + __part1by1 = __part1by1_32 + __part1by2 = __part1by2_32 + __unpart1by1 = __unpart1by1_32 + From 86e511835f03412d223efb92b19afb22811fc101 Mon Sep 17 00:00:00 2001 From: Tobias Fischer Date: Mon, 7 Aug 2023 07:28:21 +1000 Subject: [PATCH 4/6] Lint --- recipes/pymorton/meta.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/recipes/pymorton/meta.yaml b/recipes/pymorton/meta.yaml index 5cea083dae7ba..059d5b26c3ef7 100644 --- a/recipes/pymorton/meta.yaml +++ b/recipes/pymorton/meta.yaml @@ -19,10 +19,10 @@ build: requirements: host: - - python + - python >=3.6 - pip run: - - python + - python >=3.6 test: imports: From 57da19bb5f62efdd88c084757b70293af48e7229 Mon Sep 17 00:00:00 2001 From: Tobias Fischer Date: Mon, 7 Aug 2023 07:28:41 +1000 Subject: [PATCH 5/6] Lint --- recipes/pymorton/meta.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/recipes/pymorton/meta.yaml b/recipes/pymorton/meta.yaml index 059d5b26c3ef7..addebd4999770 100644 --- a/recipes/pymorton/meta.yaml +++ b/recipes/pymorton/meta.yaml @@ -48,4 +48,3 @@ about: extra: recipe-maintainers: - Tobias-Fischer - From 36361a76422369c360263d8018d31246e422100d Mon Sep 17 00:00:00 2001 From: Tobias Fischer Date: Tue, 8 Aug 2023 07:28:50 +1000 Subject: [PATCH 6/6] Address reviewer comments --- recipes/pymorton/meta.yaml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/recipes/pymorton/meta.yaml b/recipes/pymorton/meta.yaml index addebd4999770..b0125899e4ea2 100644 --- a/recipes/pymorton/meta.yaml +++ b/recipes/pymorton/meta.yaml @@ -9,7 +9,13 @@ source: url: https://github.com/trevorprater/{{ name }}/archive/refs/tags/1.0.5.tar.gz sha256: f22ebe8c1f69ef4001c59f277dbe5403cb18f6bd3004ef19ac0e5fbdf5f865f6 patches: + # Upstream has tagged version 1.0.7 on main but did not release it on PyPi / GitHub + # See https://github.com/trevorprater/pymorton/issues/4 + # This patch was created by https://github.com/trevorprater/pymorton/compare/1.0.5...master.diff - v1.0.7.patch + # pymorton was mainly tested on Python2, where it correctly detects 32/64 bit machines. + # On Python3 however, it always default to 32bit. See https://github.com/trevorprater/pymorton/issues/5 + # Upstream PR: https://github.com/trevorprater/pymorton/pull/6 - fix-64-bit.patch build: