Use c2csiutils - Publish to GitHubcContainer Registry

.github/dependabot.yml

@@ -1,7 +1,7 @@
 version: 2
 updates:
   - package-ecosystem: pip
-    directory: '/'
+    directory: /
     schedule:
       interval: daily
       time: '02:00'
@@ -12,3 +12,9 @@ updates:
       - dependency-name: none
         versions:
           - '>= 0'
+  - package-ecosystem: pip
+    directory: /ci
+    schedule:
+      interval: daily
+      time: '02:00'
+    open-pull-requests-limit: 99

.github/workflows/ci.yaml → .github/workflows/main.yaml

@@ -10,31 +10,30 @@ jobs:
     name: Continuous integration
     timeout-minutes: 10
 
-    env:
-      PATH: /bin:/usr/bin:/usr/local/bin:/home/runner/.local/bin
-      SUMMON_PROVIDER: /usr/local/bin/gopass
-
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
+
+      - uses: camptocamp/initialise-gopass-summon-action@v2
+        with:
+          ci-gpg-private-key: ${{secrets.CI_GPG_PRIVATE_KEY}}
+          github-gopass-ci-token: ${{secrets.GOPASS_CI_GITHUB_TOKEN}}
+          patterns: pypi
+        if: github.repository == 'camptocamp/tilecloud'
 
       - run: |
           sudo rm /etc/apt/sources.list.d/*.list
           sudo apt update
-          sudo apt install --yes python3-wheel python3-setuptools
+          sudo apt install --yes python3-wheel
+
+      - run: sudo python3 -m pip install --requirement=ci/requirements.txt
+
+      - name: Checks
+        run: c2cciutils-checks
 
       - run: python3 -m pip install --requirement=requirements-dev.txt
 
       - run: docker-compose up --exit-code-from test
-      - run: git --no-pager diff --check HEAD~100
 
-      - uses: camptocamp/initialise-gopass-summon-action@v1
-        with:
-          ci-gpg-private-key: ${{secrets.CI_GPG_PRIVATE_KEY}}
-          github-gopass-ci-token: ${{secrets.GOPASS_CI_GITHUB_TOKEN}}
-        if: github.repository == 'camptocamp/tilecloud'
-      - run: |
-          summon --yaml '
-              USERNAME: !var gs/ci/pypi/username
-              PASSWORD: !var gs/ci/pypi/password
-            ' ci/publish-pypi
+      - name: Publish
+        run: c2cciutils-publish
         if: github.repository == 'camptocamp/tilecloud'

bin/favicon.py

@@ -26,18 +26,16 @@ def box(minx, miny, maxx, maxy):
 image_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, SIZE, SIZE)
 context = cairo.Context(image_surface)
 context.scale(1, -1)
-context.translate(0, - SIZE)
+context.translate(0, -SIZE)
 for i, coord in enumerate(cloud.exterior.coords):
     if i == 0:
-        context.move_to(SCALE * coord[0] + TRANSLATE,
-                        SCALE * coord[1] + 2 * TRANSLATE)
+        context.move_to(SCALE * coord[0] + TRANSLATE, SCALE * coord[1] + 2 * TRANSLATE)
     else:
-        context.line_to(SCALE * coord[0] + TRANSLATE,
-                        SCALE * coord[1] + 2 * TRANSLATE)
+        context.line_to(SCALE * coord[0] + TRANSLATE, SCALE * coord[1] + 2 * TRANSLATE)
 context.close_path()
 context.set_source_rgb(1, 1, 1)
 context.fill_preserve()
 context.set_source_rgb(0, 0, 0)
 context.set_line_width(LINE_WIDTH)
 context.stroke()
-image_surface.write_to_png('favicon.png')
+image_surface.write_to_png("favicon.png")

ci/requirements.txt

@@ -0,0 +1 @@
+c2cciutils==1.0.dev20201202131358

examples/download.py

@@ -9,7 +9,6 @@
 from tilecloud.filter.logger import Logger
 from tilecloud.store.boundingpyramid import BoundingPyramidTileStore
 
-
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(os.path.basename(sys.argv[0]))
 

examples/renderingtheworld.py

@@ -13,7 +13,6 @@
 from tilecloud.store.renderingtheworld import RenderingTheWorldTileStore
 from tilecloud.store.wmts import WMTSTileStore
 
-
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(os.path.basename(sys.argv[0]))
 

tc-copy

@@ -1,18 +1,25 @@
 #!/usr/bin/env python
 
-from c2cwsgiutils import stats
 from itertools import imap
 import logging
 from optparse import OptionParser
 import os.path
 import random
 import sys
 
+from c2cwsgiutils import stats
+
 from tilecloud import BoundingPyramid, TileStore, consume
 from tilecloud.filter.benchmark import Benchmark, StatsdCountErrors, StatsdCountTiles
 from tilecloud.filter.consistenthash import EveryNth
 from tilecloud.filter.contenttype import ContentTypeAdder
-from tilecloud.filter.error import DropErrors, LogErrors, MaximumConsecutiveErrors, MaximumErrorRate, MaximumErrors
+from tilecloud.filter.error import (
+    DropErrors,
+    LogErrors,
+    MaximumConsecutiveErrors,
+    MaximumErrorRate,
+    MaximumErrors,
+)
 from tilecloud.filter.logger import Logger
 from tilecloud.filter.rate import RateLimit
 from tilecloud.store.boundingpyramid import BoundingPyramidTileStore
@@ -21,25 +28,25 @@ from tilecloud.store.boundingpyramid import BoundingPyramidTileStore
 def main(argv):
     logger = logging.getLogger(os.path.basename(argv[0]))
     option_parser = OptionParser()
-    option_parser.add_option('--benchmark', action='store_true')
-    option_parser.add_option('-b', '--bounding-pyramid', metavar='BOUNDING-PYRAMID')
-    option_parser.add_option('--add-content-type', action='store_true')
-    option_parser.add_option('-i', metavar='I', type=int)
-    option_parser.add_option('-g', '--generate', metavar='TILE-STORE', action='append')
-    option_parser.add_option('--limit', metavar='N', type=int)
-    option_parser.add_option('-m', '--move', action='store_true')
-    option_parser.add_option('--maximum-consecutive-errors', metavar='N', type=int)
-    option_parser.add_option('--maximum-errors', metavar='N', type=int)
-    option_parser.add_option('--maximum-error-rate', metavar='FLOAT', type=float)
-    option_parser.add_option('-n', metavar='N', type=int)
-    option_parser.add_option('-o', '--overwrite', action='store_true')
-    option_parser.add_option('-r', '--rate-limit', metavar='HZ', type=float)
-    option_parser.add_option('--randomize', action='store_true')
-    option_parser.add_option('--statsd', action='store_true')
-    option_parser.add_option('--statsd-host', default='127.0.0.1', metavar='HOST')
-    option_parser.add_option('--statsd-port', default=8125, metavar='PORT', type=int)
-    option_parser.add_option('--statsd-prefix', default='tc-copy-', metavar='PREFIX')
-    option_parser.add_option('-v', '--verbose', action='store_true')
+    option_parser.add_option("--benchmark", action="store_true")
+    option_parser.add_option("-b", "--bounding-pyramid", metavar="BOUNDING-PYRAMID")
+    option_parser.add_option("--add-content-type", action="store_true")
+    option_parser.add_option("-i", metavar="I", type=int)
+    option_parser.add_option("-g", "--generate", metavar="TILE-STORE", action="append")
+    option_parser.add_option("--limit", metavar="N", type=int)
+    option_parser.add_option("-m", "--move", action="store_true")
+    option_parser.add_option("--maximum-consecutive-errors", metavar="N", type=int)
+    option_parser.add_option("--maximum-errors", metavar="N", type=int)
+    option_parser.add_option("--maximum-error-rate", metavar="FLOAT", type=float)
+    option_parser.add_option("-n", metavar="N", type=int)
+    option_parser.add_option("-o", "--overwrite", action="store_true")
+    option_parser.add_option("-r", "--rate-limit", metavar="HZ", type=float)
+    option_parser.add_option("--randomize", action="store_true")
+    option_parser.add_option("--statsd", action="store_true")
+    option_parser.add_option("--statsd-host", default="127.0.0.1", metavar="HOST")
+    option_parser.add_option("--statsd-port", default=8125, metavar="PORT", type=int)
+    option_parser.add_option("--statsd-prefix", default="tc-copy-", metavar="PREFIX")
+    option_parser.add_option("-v", "--verbose", action="store_true")
     options, args = option_parser.parse_args(argv[1:])
     if options.verbose:
         logging.basicConfig(level=logging.INFO)
@@ -54,7 +61,7 @@ def main(argv):
     if options.statsd:
         statsd_settings = {
             "c2c.statsd_address": options.statsd_host + ":" + options.statsd_port,
-            "c2c.statsd_prefix": options.statsd_prefix
+            "c2c.statsd_prefix": options.statsd_prefix,
         }
         stats.init_backends(statsd_settings)
 
@@ -84,12 +91,12 @@ def main(argv):
                 tilestream = imap(benchmark.sample(), tilestream)
             tilestream = input_tilestore.get(tilestream)
             if benchmark:
-                tilestream = imap(benchmark.sample('get'), tilestream)
+                tilestream = imap(benchmark.sample("get"), tilestream)
             for i, g in enumerate(generate):
                 tilestream = g.get(tilestream)
                 if options.benchmark:
-                    tilestream = imap(benchmark.sample('generate-%d' % (i,)), tilestream)
-            tilestream = imap(LogErrors(logger, logging.ERROR, '%(tilecoord)s: %(error)s'), tilestream)
+                    tilestream = imap(benchmark.sample("generate-%d" % (i,)), tilestream)
+            tilestream = imap(LogErrors(logger, logging.ERROR, "%(tilecoord)s: %(error)s"), tilestream)
             if options.statsd:
                 tilestream = imap(StatsdCountErrors(), tilestream)
             if options.maximum_consecutive_errors:
@@ -103,27 +110,34 @@ def main(argv):
                 tilestream = imap(ContentTypeAdder(), tilestream)
             tilestream = output_tilestore.put(tilestream)
             if benchmark:
-                tilestream = imap(benchmark.sample('put'), tilestream)
+                tilestream = imap(benchmark.sample("put"), tilestream)
             if options.move:
                 tilestream = input_tilestore.delete(tilestream)
                 if benchmark:
-                    tilestream = imap(benchmark.sample('delete'), tilestream)
+                    tilestream = imap(benchmark.sample("delete"), tilestream)
             if options.verbose:
-                tilestream = imap(Logger(logger, logging.INFO, '%(tilecoord)s'), tilestream)
+                tilestream = imap(Logger(logger, logging.INFO, "%(tilecoord)s"), tilestream)
             if options.statsd:
                 tilestream = imap(StatsdCountTiles(), tilestream)
             consume(tilestream, options.limit)
     finally:
         logging.basicConfig(level=logging.INFO)
         if benchmark:
-            keys = ['get']
-            keys.extend('generate-%i' % (i,) for i in range(0, len(generate)))
-            keys.extend(['put', 'delete'])
+            keys = ["get"]
+            keys.extend("generate-%i" % (i,) for i in range(0, len(generate)))
+            keys.extend(["put", "delete"])
             for key in keys:
                 if key in benchmark.statisticss:
                     statistics = benchmark.statisticss[key]
-                    logger.info('%s: %s%s' % (key, statistics, ' (%.1f tiles/s)' % (1.0 / statistics.mean,) if statistics.n else ''))
+                    logger.info(
+                        "%s: %s%s"
+                        % (
+                            key,
+                            statistics,
+                            " (%.1f tiles/s)" % (1.0 / statistics.mean,) if statistics.n else "",
+                        )
+                    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv))

tc-delete

@@ -14,15 +14,13 @@ from tilecloud.store.boundingpyramid import BoundingPyramidTileStore
 def main(argv):
     logger = logging.getLogger(os.path.basename(argv[0]))
     option_parser = OptionParser()
-    option_parser.add_option('-b', '--bounding-pyramid',
-                             metavar='BOUNDING-PYRAMID')
-    option_parser.add_option('-v', '--verbose', action='store_true')
+    option_parser.add_option("-b", "--bounding-pyramid", metavar="BOUNDING-PYRAMID")
+    option_parser.add_option("-v", "--verbose", action="store_true")
     options, args = option_parser.parse_args(argv[1:])
     if options.verbose:
         logging.basicConfig(level=logging.INFO)
     if options.bounding_pyramid:
-        bounding_pyramid = \
-            BoundingPyramid.from_string(options.bounding_pyramid)
+        bounding_pyramid = BoundingPyramid.from_string(options.bounding_pyramid)
     else:
         bounding_pyramid = None
     for arg in args:
@@ -33,9 +31,9 @@ def main(argv):
             tilestream = tilestore.list()
         tilestream = tilestore.delete(tilestream)
         if options.verbose:
-            tilestream = imap(Logger(logger, logging.INFO, '%(tilecoord)s'), tilestream)
+            tilestream = imap(Logger(logger, logging.INFO, "%(tilecoord)s"), tilestream)
         consume(tilestream, None)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv))

tc-info

@@ -11,16 +11,15 @@ from tilecloud import BoundingPyramid, TileStore
 
 def main(argv):
     option_parser = OptionParser()
-    option_parser.add_option('-b', '--bounding-pyramid',
-                             metavar='BOUNDING-PYRAMID')
-    option_parser.add_option('-r', '--relative', action='store_true')
-    option_parser.add_option('-t', '--tiles',
-                             choices=('bounding-pyramid', 'completion',
-                                      'count', 'estimate-completion', 'list'))
+    option_parser.add_option("-b", "--bounding-pyramid", metavar="BOUNDING-PYRAMID")
+    option_parser.add_option("-r", "--relative", action="store_true")
+    option_parser.add_option(
+        "-t", "--tiles", choices=("bounding-pyramid", "completion", "count", "estimate-completion", "list")
+    )
     options, args = option_parser.parse_args(argv[1:])
     for arg in args:
         tilestore = TileStore.load(arg)
-        if options.tiles == 'bounding-pyramid':
+        if options.tiles == "bounding-pyramid":
             bounding_pyramid = tilestore.bounding_pyramid
             if bounding_pyramid is None:
                 bounding_pyramid = tilestore.get_cheap_bounding_pyramid()
@@ -29,32 +28,33 @@ def main(argv):
             for z in sorted(bounding_pyramid.zs()):
                 xbounds, ybounds = bounding_pyramid.zget(z)
                 if options.relative:
-                    print('%d/%d/%d:%+d/%+d' % (z, xbounds.start,
-                                                ybounds.start,
-                                                xbounds.stop - xbounds.start,
-                                                ybounds.stop - ybounds.start))
+                    print(
+                        "%d/%d/%d:%+d/%+d"
+                        % (
+                            z,
+                            xbounds.start,
+                            ybounds.start,
+                            xbounds.stop - xbounds.start,
+                            ybounds.stop - ybounds.start,
+                        )
+                    )
                 else:
-                    print('%d/%d/%d:%d/%d' % (z, xbounds.start, ybounds.start,
-                                              xbounds.stop, ybounds.stop))
-        elif options.tiles == 'completion':
-            bounding_pyramid = \
-                BoundingPyramid.from_string(options.bounding_pyramid)
+                    print("%d/%d/%d:%d/%d" % (z, xbounds.start, ybounds.start, xbounds.stop, ybounds.stop))
+        elif options.tiles == "completion":
+            bounding_pyramid = BoundingPyramid.from_string(options.bounding_pyramid)
             completed = defaultdict(set)
-            for tilecoord in imap(attrgetter('tilecoord'), tilestore.list()):
+            for tilecoord in imap(attrgetter("tilecoord"), tilestore.list()):
                 completed[tilecoord.z].add((tilecoord.x, tilecoord.y))
             for z in bounding_pyramid.zs():
                 numerator = len(completed[z])
                 dxbounds, dybounds = bounding_pyramid.zget(z)
                 denominator = len(dxbounds) * len(dybounds)
-                print('%d %d/%d (%d%%)' % (z, numerator, denominator,
-                                           100 * numerator / denominator))
-        elif options.tiles == 'count':
+                print("%d %d/%d (%d%%)" % (z, numerator, denominator, 100 * numerator / denominator))
+        elif options.tiles == "count":
             print(len(tilestore))
-        elif options.tiles == 'estimate-completion':
-            bounding_pyramid = \
-                BoundingPyramid.from_string(options.bounding_pyramid)
-            tilestore_bounding_pyramid = \
-                tilestore.get_cheap_bounding_pyramid()
+        elif options.tiles == "estimate-completion":
+            bounding_pyramid = BoundingPyramid.from_string(options.bounding_pyramid)
+            tilestore_bounding_pyramid = tilestore.get_cheap_bounding_pyramid()
             for z in bounding_pyramid.zs():
                 try:
                     nxbounds, nybounds = tilestore_bounding_pyramid.zget(z)
@@ -63,12 +63,11 @@ def main(argv):
                     numerator = 0
                 dxbounds, dybounds = bounding_pyramid.zget(z)
                 denominator = len(dxbounds) * len(dybounds)
-                print('%d %d/%d (%d%%)' % (z, numerator, denominator,
-                                           100 * numerator / denominator))
-        elif options.tiles == 'list':
+                print("%d %d/%d (%d%%)" % (z, numerator, denominator, 100 * numerator / denominator))
+        elif options.tiles == "list":
             for tile in tilestore.list():
                 print(tile.tilecoord)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv))