automatic import of python-collidoscope

3 files changed, 470 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..5ec715b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/collidoscope-0.6.5.tar.gz
diff --git a/python-collidoscope.spec b/python-collidoscope.spec
new file mode 100644
index 0000000..4a14afe
--- /dev/null
+++ b/python-collidoscope.spec
@@ -0,0 +1,468 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-collidoscope
+Version:	0.6.5
+Release:	1
+Summary:	Brute force detection of glyph collisions
+License:	MIT
+URL:		https://github.com/simoncozens/collidoscope
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/fd/27/d0dfaf2ae59d208af7f0cc3213cff5c26864c96a15228e1b9a44e3cfdf86/collidoscope-0.6.5.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-kurbopy
+Requires:	python3-babelfont
+Requires:	python3-uharfbuzz
+Requires:	python3-fonttools
+Requires:	python3-skia-pathops
+Requires:	python3-tqdm
+
+%description
+# collidoscope - brute force detection of glyph collisions
+
+`collidoscope` reports on situations where paths overlap in a shaped
+piece of text. For example, the sequence "ؼجب" might cause a collision like so:
+
+![](sample-collision.png)
+
+This software tries every combination of glyphs within a specified Unicode range and up to a specified length of string and outputs a report of all situations where the glyphs collide. It has a number of collision tests:
+
+* Paths in non-adjacent glyphs are never allowed to collide.
+* If the *cursive* test is turned on, then paths with a cursive attachment anchor are allowed to overlap with paths in an adjacent glyph which also contain a cursive attachment anchor, but are *not* allowed to overlap with a path *without* a cursive attachment anchor.
+* If the *area* test is turned on, then paths in adjacent glyphs may collide so long as the area of overlap does not exceed a given percentage of the smallest path's area. i.e. if the area percentage is set to 25%, then two strokes may *connect*, because the overlap is likely to be quite small compared to the size of the paths involved. But if a stroke significantly overlaps a nukta, it will be reported as a collision. (Of course, this will not detect strokes which merely graze a nukta.)
+
+Depending on the length of the string and the number of glyphs tested, this may take a *very* long time.
+
+## Command Line Usage
+
+To use it:
+
+    python3 -m collidoscope -r 0620-064A yourfont.otf
+
+This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A.
+
+    python3 -m collidoscope -r 0620-064A,0679-06D3 -area 10 yourfont.otf
+
+This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A and also 0x679 to 0x6D3, and turns on the area test at a tolerance of 10% of the area of the smallest path involved in collision.
+
+    python3 -m collidoscope -c 5 --cursive yourfont.otf
+
+This tests for non-adjacent glyphs and collisions not involving cursive connection for *all combinations of glyphs in your font* with a five-character string. This may take a number of years to compute.
+
+    python3 -m collidoscope -c 2 -r 0620-064A --area 5 yourfont.otf
+
+This just runs an area test for two-character sequences across the basic Arabic range.
+
+## Library Usage
+
+```python
+class Collidoscope()
+```
+
+Detect collisions between font glyphs
+
+<a name="collidoscope.Collidoscope.__init__"></a>
+#### \_\_init\_\_
+
+```python
+ | __init__(fontfilename, rules, direction="LTR", ttFont=None)
+```
+
+Create a collision detector.
+
+The rules dictionary may contain the following entries:
+
+* faraway (boolean): If true, non-adjacent base glyphs are tested for
+overlap. Mark glyphs are ignored. All collisions are reported.
+* marks (boolean): If true, collisions between all pairs of marks in
+the string are reported.
+* bases (boolean): If *false*, collisions between all pairs of bases in
+the string are *ignored*.
+* cursive (boolean): If true, adjacent glyphs are tested for overlap.
+Paths containing cursive anchors are allowed to overlap, but
+collisions between other paths are reported.
+* area (float): If provided, adjacent glyphs are tested for overlap.
+Collisions are reported if the intersection area is greater than
+the given proportion of the smallest path. (i.e. where cursive
+connection anchors are not used in an Arabic font, you may wish
+to ignore collisions if the overlaid area is less than 5% of the
+smallest path, because this is likely to be the connection point
+between the glyphs. But collisions affecting more than 5% of the
+glyph will be reported.)
+
+**Arguments**:
+
+- `fontfilename` - file name of font.
+- `rules` - dictionary of collision rules.
+- `ttFont` - fontTools object (loaded from file if not given).
+- `direction` - "LTR" or "RTL"
+
+<a name="collidoscope.Collidoscope.get_glyphs"></a>
+#### get\_glyphs
+
+```python
+ | get_glyphs(text)
+```
+
+Returns an list of dictionaries representing a shaped string.
+
+This is the first step in collision detection; the dictionaries
+returned can be fed to ``draw_overlaps`` and ``has_collisions``.
+
+<a name="collidoscope.Collidoscope.draw_overlaps"></a>
+#### draw\_overlaps
+
+```python
+ | draw_overlaps(glyphs, collisions, attribs="")
+```
+
+Return an SVG string displaying the collisions.
+
+**Arguments**:
+
+- `glyphs` - A list of glyphs dictionaries.
+- `collisions` - A list of Collision objects.
+- `attribs` - String of attributes added to SVG header.
+
+<a name="collidoscope.Collidoscope.has_collisions"></a>
+#### has\_collisions
+
+```python
+ | has_collisions(glyphs_in)
+```
+
+Run the collision detection algorithm according to the rules provided.
+
+Note that this does not find *all* overlaps, but returns as soon
+as some collisions are found.
+
+**Arguments**:
+
+- `glyphs` - A list of glyph dictionaries returned by ``get_glyphs``.
+  
+- `Returns` - A list of Collision objects.
+
+
+## Requirements
+
+This requires some Python modules to be installed. You can install them like so:
+
+    pip3 install -r example-requirements.txt
+
+
+%package -n python3-collidoscope
+Summary:	Brute force detection of glyph collisions
+Provides:	python-collidoscope
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-collidoscope
+# collidoscope - brute force detection of glyph collisions
+
+`collidoscope` reports on situations where paths overlap in a shaped
+piece of text. For example, the sequence "ؼجب" might cause a collision like so:
+
+![](sample-collision.png)
+
+This software tries every combination of glyphs within a specified Unicode range and up to a specified length of string and outputs a report of all situations where the glyphs collide. It has a number of collision tests:
+
+* Paths in non-adjacent glyphs are never allowed to collide.
+* If the *cursive* test is turned on, then paths with a cursive attachment anchor are allowed to overlap with paths in an adjacent glyph which also contain a cursive attachment anchor, but are *not* allowed to overlap with a path *without* a cursive attachment anchor.
+* If the *area* test is turned on, then paths in adjacent glyphs may collide so long as the area of overlap does not exceed a given percentage of the smallest path's area. i.e. if the area percentage is set to 25%, then two strokes may *connect*, because the overlap is likely to be quite small compared to the size of the paths involved. But if a stroke significantly overlaps a nukta, it will be reported as a collision. (Of course, this will not detect strokes which merely graze a nukta.)
+
+Depending on the length of the string and the number of glyphs tested, this may take a *very* long time.
+
+## Command Line Usage
+
+To use it:
+
+    python3 -m collidoscope -r 0620-064A yourfont.otf
+
+This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A.
+
+    python3 -m collidoscope -r 0620-064A,0679-06D3 -area 10 yourfont.otf
+
+This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A and also 0x679 to 0x6D3, and turns on the area test at a tolerance of 10% of the area of the smallest path involved in collision.
+
+    python3 -m collidoscope -c 5 --cursive yourfont.otf
+
+This tests for non-adjacent glyphs and collisions not involving cursive connection for *all combinations of glyphs in your font* with a five-character string. This may take a number of years to compute.
+
+    python3 -m collidoscope -c 2 -r 0620-064A --area 5 yourfont.otf
+
+This just runs an area test for two-character sequences across the basic Arabic range.
+
+## Library Usage
+
+```python
+class Collidoscope()
+```
+
+Detect collisions between font glyphs
+
+<a name="collidoscope.Collidoscope.__init__"></a>
+#### \_\_init\_\_
+
+```python
+ | __init__(fontfilename, rules, direction="LTR", ttFont=None)
+```
+
+Create a collision detector.
+
+The rules dictionary may contain the following entries:
+
+* faraway (boolean): If true, non-adjacent base glyphs are tested for
+overlap. Mark glyphs are ignored. All collisions are reported.
+* marks (boolean): If true, collisions between all pairs of marks in
+the string are reported.
+* bases (boolean): If *false*, collisions between all pairs of bases in
+the string are *ignored*.
+* cursive (boolean): If true, adjacent glyphs are tested for overlap.
+Paths containing cursive anchors are allowed to overlap, but
+collisions between other paths are reported.
+* area (float): If provided, adjacent glyphs are tested for overlap.
+Collisions are reported if the intersection area is greater than
+the given proportion of the smallest path. (i.e. where cursive
+connection anchors are not used in an Arabic font, you may wish
+to ignore collisions if the overlaid area is less than 5% of the
+smallest path, because this is likely to be the connection point
+between the glyphs. But collisions affecting more than 5% of the
+glyph will be reported.)
+
+**Arguments**:
+
+- `fontfilename` - file name of font.
+- `rules` - dictionary of collision rules.
+- `ttFont` - fontTools object (loaded from file if not given).
+- `direction` - "LTR" or "RTL"
+
+<a name="collidoscope.Collidoscope.get_glyphs"></a>
+#### get\_glyphs
+
+```python
+ | get_glyphs(text)
+```
+
+Returns an list of dictionaries representing a shaped string.
+
+This is the first step in collision detection; the dictionaries
+returned can be fed to ``draw_overlaps`` and ``has_collisions``.
+
+<a name="collidoscope.Collidoscope.draw_overlaps"></a>
+#### draw\_overlaps
+
+```python
+ | draw_overlaps(glyphs, collisions, attribs="")
+```
+
+Return an SVG string displaying the collisions.
+
+**Arguments**:
+
+- `glyphs` - A list of glyphs dictionaries.
+- `collisions` - A list of Collision objects.
+- `attribs` - String of attributes added to SVG header.
+
+<a name="collidoscope.Collidoscope.has_collisions"></a>
+#### has\_collisions
+
+```python
+ | has_collisions(glyphs_in)
+```
+
+Run the collision detection algorithm according to the rules provided.
+
+Note that this does not find *all* overlaps, but returns as soon
+as some collisions are found.
+
+**Arguments**:
+
+- `glyphs` - A list of glyph dictionaries returned by ``get_glyphs``.
+  
+- `Returns` - A list of Collision objects.
+
+
+## Requirements
+
+This requires some Python modules to be installed. You can install them like so:
+
+    pip3 install -r example-requirements.txt
+
+
+%package help
+Summary:	Development documents and examples for collidoscope
+Provides:	python3-collidoscope-doc
+%description help
+# collidoscope - brute force detection of glyph collisions
+
+`collidoscope` reports on situations where paths overlap in a shaped
+piece of text. For example, the sequence "ؼجب" might cause a collision like so:
+
+![](sample-collision.png)
+
+This software tries every combination of glyphs within a specified Unicode range and up to a specified length of string and outputs a report of all situations where the glyphs collide. It has a number of collision tests:
+
+* Paths in non-adjacent glyphs are never allowed to collide.
+* If the *cursive* test is turned on, then paths with a cursive attachment anchor are allowed to overlap with paths in an adjacent glyph which also contain a cursive attachment anchor, but are *not* allowed to overlap with a path *without* a cursive attachment anchor.
+* If the *area* test is turned on, then paths in adjacent glyphs may collide so long as the area of overlap does not exceed a given percentage of the smallest path's area. i.e. if the area percentage is set to 25%, then two strokes may *connect*, because the overlap is likely to be quite small compared to the size of the paths involved. But if a stroke significantly overlaps a nukta, it will be reported as a collision. (Of course, this will not detect strokes which merely graze a nukta.)
+
+Depending on the length of the string and the number of glyphs tested, this may take a *very* long time.
+
+## Command Line Usage
+
+To use it:
+
+    python3 -m collidoscope -r 0620-064A yourfont.otf
+
+This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A.
+
+    python3 -m collidoscope -r 0620-064A,0679-06D3 -area 10 yourfont.otf
+
+This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A and also 0x679 to 0x6D3, and turns on the area test at a tolerance of 10% of the area of the smallest path involved in collision.
+
+    python3 -m collidoscope -c 5 --cursive yourfont.otf
+
+This tests for non-adjacent glyphs and collisions not involving cursive connection for *all combinations of glyphs in your font* with a five-character string. This may take a number of years to compute.
+
+    python3 -m collidoscope -c 2 -r 0620-064A --area 5 yourfont.otf
+
+This just runs an area test for two-character sequences across the basic Arabic range.
+
+## Library Usage
+
+```python
+class Collidoscope()
+```
+
+Detect collisions between font glyphs
+
+<a name="collidoscope.Collidoscope.__init__"></a>
+#### \_\_init\_\_
+
+```python
+ | __init__(fontfilename, rules, direction="LTR", ttFont=None)
+```
+
+Create a collision detector.
+
+The rules dictionary may contain the following entries:
+
+* faraway (boolean): If true, non-adjacent base glyphs are tested for
+overlap. Mark glyphs are ignored. All collisions are reported.
+* marks (boolean): If true, collisions between all pairs of marks in
+the string are reported.
+* bases (boolean): If *false*, collisions between all pairs of bases in
+the string are *ignored*.
+* cursive (boolean): If true, adjacent glyphs are tested for overlap.
+Paths containing cursive anchors are allowed to overlap, but
+collisions between other paths are reported.
+* area (float): If provided, adjacent glyphs are tested for overlap.
+Collisions are reported if the intersection area is greater than
+the given proportion of the smallest path. (i.e. where cursive
+connection anchors are not used in an Arabic font, you may wish
+to ignore collisions if the overlaid area is less than 5% of the
+smallest path, because this is likely to be the connection point
+between the glyphs. But collisions affecting more than 5% of the
+glyph will be reported.)
+
+**Arguments**:
+
+- `fontfilename` - file name of font.
+- `rules` - dictionary of collision rules.
+- `ttFont` - fontTools object (loaded from file if not given).
+- `direction` - "LTR" or "RTL"
+
+<a name="collidoscope.Collidoscope.get_glyphs"></a>
+#### get\_glyphs
+
+```python
+ | get_glyphs(text)
+```
+
+Returns an list of dictionaries representing a shaped string.
+
+This is the first step in collision detection; the dictionaries
+returned can be fed to ``draw_overlaps`` and ``has_collisions``.
+
+<a name="collidoscope.Collidoscope.draw_overlaps"></a>
+#### draw\_overlaps
+
+```python
+ | draw_overlaps(glyphs, collisions, attribs="")
+```
+
+Return an SVG string displaying the collisions.
+
+**Arguments**:
+
+- `glyphs` - A list of glyphs dictionaries.
+- `collisions` - A list of Collision objects.
+- `attribs` - String of attributes added to SVG header.
+
+<a name="collidoscope.Collidoscope.has_collisions"></a>
+#### has\_collisions
+
+```python
+ | has_collisions(glyphs_in)
+```
+
+Run the collision detection algorithm according to the rules provided.
+
+Note that this does not find *all* overlaps, but returns as soon
+as some collisions are found.
+
+**Arguments**:
+
+- `glyphs` - A list of glyph dictionaries returned by ``get_glyphs``.
+  
+- `Returns` - A list of Collision objects.
+
+
+## Requirements
+
+This requires some Python modules to be installed. You can install them like so:
+
+    pip3 install -r example-requirements.txt
+
+
+%prep
+%autosetup -n collidoscope-0.6.5
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-collidoscope -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Thu May 18 2023 Python_Bot <Python_Bot@openeuler.org> - 0.6.5-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..f3dd3a8
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+1edb9c38373e1d9fe106a65f8af16fa1  collidoscope-0.6.5.tar.gz