nefino-geosync 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

nefino_geosync/schema.py

@@ -1,21 +1,25 @@
 import sgqlc.types
 import sgqlc.types.datetime
 
-
 schema = sgqlc.types.Schema()
 
 
-
 ########################################################################
 # Scalars and Enumerations
 ########################################################################
 Boolean = sgqlc.types.Boolean
 
+
 class CRSType(sgqlc.types.Enum):
     __schema__ = schema
     __choices__ = ('EPSG_25832', 'EPSG_25833', 'EPSG_3035', 'EPSG_4326')
 
 
+class LayerChangeAction(sgqlc.types.Enum):
+    __schema__ = schema
+    __choices__ = ('created', 'updated', 'deleted', 'regions_changed')
+
+
 DateTime = sgqlc.types.datetime.DateTime
 
 Float = sgqlc.types.Float
@@ -24,6 +28,7 @@ ID = sgqlc.types.ID
 
 Int = sgqlc.types.Int
 
+
 class OutputObjectType(sgqlc.types.Enum):
     __schema__ = schema
     __choices__ = ('GPKG', 'QGIS_AND_GPKG', 'QGIS_PRJ', 'SHP')
@@ -31,17 +36,38 @@ class OutputObjectType(sgqlc.types.Enum):
 
 class PlaceTypeGeo(sgqlc.types.Enum):
     __schema__ = schema
-    __choices__ = ('ADMINISTRATIVE_UNIT_GEO', 'COUNTRY', 'FEDERAL_STATE_GEO', 'LOCAL_ADMINISTRATIVE_UNITS_GEO', 'PLANNING_REGIONS_GEO')
+    __choices__ = (
+        'ADMINISTRATIVE_UNIT_GEO',
+        'COUNTRY',
+        'FEDERAL_STATE_GEO',
+        'LOCAL_ADMINISTRATIVE_UNITS_GEO',
+        'PLANNING_REGIONS_GEO',
+    )
 
 
 class PlaceTypeNews(sgqlc.types.Enum):
     __schema__ = schema
-    __choices__ = ('ADMINISTRATIVE_UNIT', 'COUNTRY', 'COUNTY', 'FEDERAL_STATE', 'LOCAL_ADMINISTRATIVE_UNITS', 'PLANNING_REGIONS')
+    __choices__ = (
+        'ADMINISTRATIVE_UNIT',
+        'COUNTRY',
+        'COUNTY',
+        'FEDERAL_STATE',
+        'LOCAL_ADMINISTRATIVE_UNITS',
+        'PLANNING_REGIONS',
+    )
 
 
 class ScopeType(sgqlc.types.Enum):
     __schema__ = schema
-    __choices__ = ('ADMINISTRATIVE_UNIT', 'FEDERAL_STATE', 'LOCAL_ADMINISTRATIVE_UNIT', 'PLANNING_REGION', 'POLYGON', 'RADIUS', 'SQUARE')
+    __choices__ = (
+        'ADMINISTRATIVE_UNIT',
+        'FEDERAL_STATE',
+        'LOCAL_ADMINISTRATIVE_UNIT',
+        'PLANNING_REGION',
+        'POLYGON',
+        'RADIUS',
+        'SQUARE',
+    )
 
 
 class Status(sgqlc.types.Enum):
@@ -51,11 +77,11 @@ class Status(sgqlc.types.Enum):
 
 String = sgqlc.types.String
 
+
 class UUID(sgqlc.types.Scalar):
     __schema__ = schema
 
 
-
 ########################################################################
 # Input Objects
 ########################################################################
@@ -77,7 +103,10 @@ class GeoAnalysisLayerInput(sgqlc.types.Input):
     __schema__ = schema
     __field_names__ = ('layer_name', 'buffer_m')
     layer_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='layerName')
-    buffer_m = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Int))), graphql_name='bufferM')
+    buffer_m = sgqlc.types.Field(
+        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Int))),
+        graphql_name='bufferM',
+    )
 
 
 class GeoAnalysisObjectInput(sgqlc.types.Input):
@@ -85,8 +114,14 @@ class GeoAnalysisObjectInput(sgqlc.types.Input):
     __field_names__ = ('coordinate', 'scope', 'requests', 'operations', 'output')
     coordinate = sgqlc.types.Field(sgqlc.types.non_null(CoordinateInput), graphql_name='coordinate')
     scope = sgqlc.types.Field(sgqlc.types.non_null('GeoAnalysisScopeInput'), graphql_name='scope')
-    requests = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null('GeoAnalysisRequestInput'))), graphql_name='requests')
-    operations = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null('GeoAnalysisOperationInput'))), graphql_name='operations')
+    requests = sgqlc.types.Field(
+        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null('GeoAnalysisRequestInput'))),
+        graphql_name='requests',
+    )
+    operations = sgqlc.types.Field(
+        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null('GeoAnalysisOperationInput'))),
+        graphql_name='operations',
+    )
     output = sgqlc.types.Field(sgqlc.types.non_null('GeoAnalysisOutputFormatInput'), graphql_name='output')
 
 
@@ -109,7 +144,10 @@ class GeoAnalysisRequestInput(sgqlc.types.Input):
     __schema__ = schema
     __field_names__ = ('cluster_name', 'layers')
     cluster_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='clusterName')
-    layers = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(GeoAnalysisLayerInput))), graphql_name='layers')
+    layers = sgqlc.types.Field(
+        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(GeoAnalysisLayerInput))),
+        graphql_name='layers',
+    )
 
 
 class GeoAnalysisScopeInput(sgqlc.types.Input):
@@ -122,6 +160,27 @@ class GeoAnalysisScopeInput(sgqlc.types.Input):
     place = sgqlc.types.Field(String, graphql_name='place')
 
 
+class LayerChangelogInput(sgqlc.types.Input):
+    __schema__ = schema
+    __field_names__ = (
+        'layer_id',
+        'cluster_id',
+        'layer_name',
+        'cluster_name',
+        'timestamp_start',
+        'timestamp_end',
+        'changed_field',
+        'action',
+    )
+    layer_id = sgqlc.types.Field(Int, graphql_name='layerId')
+    cluster_id = sgqlc.types.Field(Int, graphql_name='clusterId')
+    layer_name = sgqlc.types.Field(String, graphql_name='layerName')
+    cluster_name = sgqlc.types.Field(String, graphql_name='clusterName')
+    timestamp_start = sgqlc.types.Field(DateTime, graphql_name='timestampStart')
+    timestamp_end = sgqlc.types.Field(DateTime, graphql_name='timestampEnd')
+    changed_field = sgqlc.types.Field(String, graphql_name='changedField')
+    action = sgqlc.types.Field(LayerChangeAction, graphql_name='action')
+
 
 ########################################################################
 # Output Objects and Interfaces
@@ -146,7 +205,10 @@ class MinimalCluster(sgqlc.types.Type):
     __schema__ = schema
     __field_names__ = ('name', 'layers', 'has_access')
     name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='name')
-    layers = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null('MinimalLayer'))), graphql_name='layers')
+    layers = sgqlc.types.Field(
+        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null('MinimalLayer'))),
+        graphql_name='layers',
+    )
     has_access = sgqlc.types.Field(Boolean, graphql_name='hasAccess')
 
 
@@ -167,12 +229,48 @@ class MinimalLayer(sgqlc.types.Type):
     is_regional = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name='isRegional')
 
 
+class LayerChangelogEntry(sgqlc.types.Type):
+    __schema__ = schema
+    __field_names__ = (
+        'layer_name',
+        'timestamp',
+        'action',
+        'changed_fields',
+        'attributes',
+        'layer_id',
+        'last_update',
+        'cluster_name',
+        'cluster_id',
+    )
+    layer_name = sgqlc.types.Field(String, graphql_name='layerName')
+    timestamp = sgqlc.types.Field(DateTime, graphql_name='timestamp')
+    action = sgqlc.types.Field(LayerChangeAction, graphql_name='action')
+    changed_fields = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name='changedFields')
+    attributes = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name='attributes')
+    layer_id = sgqlc.types.Field(Int, graphql_name='layerId')
+    last_update = sgqlc.types.Field(DateTime, graphql_name='lastUpdate')
+    cluster_name = sgqlc.types.Field(String, graphql_name='clusterName')
+    cluster_id = sgqlc.types.Field(Int, graphql_name='clusterId')
+
+
 class Mutation(sgqlc.types.Type):
     __schema__ = schema
     __field_names__ = ('start_analysis',)
-    start_analysis = sgqlc.types.Field(MinimalAnalysis, graphql_name='startAnalysis', args=sgqlc.types.ArgDict((
-        ('inputs', sgqlc.types.Arg(sgqlc.types.non_null(GeoAnalysisInput), graphql_name='inputs', default=None)),
-))
+    start_analysis = sgqlc.types.Field(
+        MinimalAnalysis,
+        graphql_name='startAnalysis',
+        args=sgqlc.types.ArgDict(
+            (
+                (
+                    'inputs',
+                    sgqlc.types.Arg(
+                        sgqlc.types.non_null(GeoAnalysisInput),
+                        graphql_name='inputs',
+                        default=None,
+                    ),
+                ),
+            )
+        ),
     )
 
 
@@ -185,20 +283,65 @@ class PlaceIdentifier(sgqlc.types.Type):
 
 class Query(sgqlc.types.Type):
     __schema__ = schema
-    __field_names__ = ('analysis_metadata', 'allowed_analysis_areas', 'clusters', 'regional_layers', 'access_rules')
-    analysis_metadata = sgqlc.types.Field(sgqlc.types.list_of(MinimalAnalysis), graphql_name='analysisMetadata', args=sgqlc.types.ArgDict((
-        ('analysis_id', sgqlc.types.Arg(UUID, graphql_name='analysisId', default=None)),
-))
+    __field_names__ = (
+        'analysis_metadata',
+        'allowed_analysis_areas',
+        'clusters',
+        'regional_layers',
+        'access_rules',
+        'layer_changelog',
+    )
+    analysis_metadata = sgqlc.types.Field(
+        sgqlc.types.list_of(MinimalAnalysis),
+        graphql_name='analysisMetadata',
+        args=sgqlc.types.ArgDict(
+            (
+                (
+                    'analysis_id',
+                    sgqlc.types.Arg(UUID, graphql_name='analysisId', default=None),
+                ),
+            )
+        ),
     )
     allowed_analysis_areas = sgqlc.types.Field(MinimalAreasEnabled, graphql_name='allowedAnalysisAreas')
     clusters = sgqlc.types.Field(sgqlc.types.list_of(MinimalCluster), graphql_name='clusters')
-    regional_layers = sgqlc.types.Field(sgqlc.types.list_of(MinimalLayer), graphql_name='regionalLayers', args=sgqlc.types.ArgDict((
-        ('place_type', sgqlc.types.Arg(sgqlc.types.non_null(PlaceTypeGeo), graphql_name='placeType', default=None)),
-        ('place_id', sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name='placeId', default=None)),
-))
+    regional_layers = sgqlc.types.Field(
+        sgqlc.types.list_of(MinimalLayer),
+        graphql_name='regionalLayers',
+        args=sgqlc.types.ArgDict(
+            (
+                (
+                    'place_type',
+                    sgqlc.types.Arg(
+                        sgqlc.types.non_null(PlaceTypeGeo),
+                        graphql_name='placeType',
+                        default=None,
+                    ),
+                ),
+                (
+                    'place_id',
+                    sgqlc.types.Arg(
+                        sgqlc.types.non_null(String),
+                        graphql_name='placeId',
+                        default=None,
+                    ),
+                ),
+            )
+        ),
     )
     access_rules = sgqlc.types.Field(sgqlc.types.list_of(MinimalGeoAccessRule), graphql_name='accessRules')
-
+    layer_changelog = sgqlc.types.Field(
+        sgqlc.types.list_of(LayerChangelogEntry),
+        graphql_name='layerChangelog',
+        args=sgqlc.types.ArgDict(
+            (
+                (
+                    'inputs',
+                    sgqlc.types.Arg(LayerChangelogInput, graphql_name='inputs', default=None),
+                ),
+            )
+        ),
+    )
 
 
 ########################################################################
@@ -211,4 +354,3 @@ class Query(sgqlc.types.Type):
 schema.query_type = Query
 schema.mutation_type = Mutation
 schema.subscription_type = None
-

nefino_geosync/session_logger.py

@@ -0,0 +1,112 @@
+"""Session logging utility that captures all stdout/stderr to timestamped log files."""
+
+import os
+import sys
+from .storage import get_app_directory
+from datetime import datetime
+from typing import TextIO
+
+
+class TeeStream:
+    """A stream that writes to multiple outputs (console + log file)."""
+
+    def __init__(self, original_stream: TextIO, log_file: TextIO, stream_name: str) -> None:
+        self.original_stream = original_stream
+        self.log_file = log_file
+        self.stream_name = stream_name
+
+    def write(self, text: str) -> None:
+        # Write to original stream (console)
+        self.original_stream.write(text)
+
+        # Write to log file with stream prefix for clarity
+        if text.strip():  # Only add prefix for non-empty content
+            timestamp = datetime.now().strftime('%H:%M:%S')
+            self.log_file.write(f'[{timestamp}] [{self.stream_name}] {text}')
+        else:
+            self.log_file.write(text)
+
+        # Ensure immediate writing
+        self.original_stream.flush()
+        self.log_file.flush()
+
+    def flush(self) -> None:
+        self.original_stream.flush()
+        self.log_file.flush()
+
+    def __getattr__(self, name):
+        # Delegate any other attributes to the original stream
+        return getattr(self.original_stream, name)
+
+
+class SessionLogger:
+    """Manages session-wide logging to timestamped files."""
+
+    def __init__(self) -> None:
+        self.log_file = None
+        self.original_stdout = None
+        self.original_stderr = None
+        self.started = False
+
+    def start_logging(self) -> None:
+        """Start capturing stdout and stderr to a timestamped log file."""
+        if self.started:
+            return
+
+        # Create timestamped log file name
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        log_filename = f'nefino-geosync_{timestamp}.log'
+        log_path = os.path.join(get_app_directory(), log_filename)
+
+        # Open log file
+        self.log_file = open(log_path, 'w', encoding='utf-8')
+
+        # Write session header
+        self.log_file.write('=== Nefino GeoSync Session Log ===\n')
+        self.log_file.write(f'Started: {datetime.now().isoformat()}\n')
+        self.log_file.write(f'Log file: {log_path}\n')
+        self.log_file.write('=' * 50 + '\n\n')
+
+        # Store original streams
+        self.original_stdout = sys.stdout
+        self.original_stderr = sys.stderr
+
+        # Replace with tee streams
+        sys.stdout = TeeStream(self.original_stdout, self.log_file, 'STDOUT')
+        sys.stderr = TeeStream(self.original_stderr, self.log_file, 'STDERR')
+
+        self.started = True
+        print(f'Session logging started: {log_path}')
+
+    def stop_logging(self) -> None:
+        """Stop logging and restore original streams."""
+        if not self.started:
+            return
+
+        print('Session logging stopped.')
+
+        # Restore original streams
+        sys.stdout = self.original_stdout
+        sys.stderr = self.original_stderr
+
+        # Write session footer and close log file
+        if self.log_file:
+            self.log_file.write('\n' + '=' * 50 + '\n')
+            self.log_file.write(f'Session ended: {datetime.now().isoformat()}\n')
+            self.log_file.close()
+
+        self.started = False
+
+
+# Global session logger instance
+_session_logger = SessionLogger()
+
+
+def start_session_logging() -> None:
+    """Start session-wide logging."""
+    _session_logger.start_logging()
+
+
+def stop_session_logging() -> None:
+    """Stop session-wide logging."""
+    _session_logger.stop_logging()

nefino_geosync/start_analyses.py

@@ -1,48 +1,56 @@
-from typing import Any
-from .api_client import general_availability_operation, local_availability_operation, start_analyses_operation
+import sys
+from .api_client import (
+    general_availability_operation,
+    local_availability_operation,
+    start_analyses_operation,
+)
 from .compose_requests import compose_complete_requests
-from .journal import Journal
+from .download_completed_analyses import download_completed_analyses
 from .graphql_errors import check_errors
+from .journal import Journal
+from .layer_changelog import LayerChangelogResult
 from .parse_args import parse_args
 from sgqlc.endpoint.http import HTTPEndpoint
-from .download_completed_analyses import download_completed_analyses
+from typing import Any
 
 AnalysesMutationResult = Any
 
-def start_analyses(client: HTTPEndpoint) -> AnalysesMutationResult:
+
+def start_analyses(client: HTTPEndpoint, changelog_result: LayerChangelogResult = None) -> AnalysesMutationResult:
     """Starts the analyses for all updated data."""
     journal = Journal.singleton()
-    args = parse_args()
+    parse_args()
     # Get information about our permissions and the general availability of layers
     general_op = general_availability_operation()
-    print("Checking for layers to update...")
+    print('Checking for layers to update...')
     general_data = client(general_op)
-    check_errors(general_data)
-    general_availability = (general_op + general_data)
+    check_errors(general_data, 'Failed to fetch general layer availability')
+    general_availability = general_op + general_data
 
     # Get information about the availability of layers in specific areas
     local_op = local_availability_operation(general_availability)
     local_data = client(local_op)
-    check_errors(local_data)
-    local_availability = (local_op + local_data)
+    check_errors(local_data, 'Failed to fetch regional layer availability')
+    local_availability = local_op + local_data
 
     # Start the analyses
-    analysis_inputs = compose_complete_requests(general_availability, local_availability)
+    analysis_inputs = compose_complete_requests(general_availability, local_availability, changelog_result)
     if len(analysis_inputs) == 0:
         # We can only check for layer having been unpacked already.
         # So if we're here, we've already unpacked all latest layers.
-        print("✅ No layers to update. Done.")
-        exit(0)
+        print('✅ No layers to update. Done.')
+        sys.exit(0)
     for federal_state_key in analysis_inputs:
-        print(f"Starting analysis for {federal_state_key}")
+        print(f'Starting analysis for {federal_state_key}')
         analyses_op = start_analyses_operation({federal_state_key: analysis_inputs[federal_state_key]})
+        print(f'Started analysis for {federal_state_key}. Waiting for completion...')
         analyses_data = client(analyses_op)
-        check_errors(analyses_data)
-        analyses = (analyses_op + analyses_data)
+        check_errors(analyses_data, f'Failed to start analysis for {federal_state_key}')
+        analyses = analyses_op + analyses_data
 
         # Add the analyses to the journal
-        journal.record_analyses_requested(analyses)
-        print("Analysis started.")
+        journal.record_analyses_requested(analyses, analysis_inputs)
+        print(f'Analysis for {federal_state_key} finished')
         download_completed_analyses(client)
-    
-    return(analyses)
+
+    return analyses

{nefino_geosync-0.2.1.dist-info → nefino_geosync-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nefino-geosync
-Version: 0.2.1
+Version: 0.2.2
 Summary: Python package to access geographical data from Nefino.LI Geo
 Project-URL: Application, https://nefino.li
 Project-URL: API, https://api.nefino.li

nefino_geosync-0.2.2.dist-info/RECORD

@@ -0,0 +1,23 @@
+nefino_geosync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nefino_geosync/access_rule_filter.py,sha256=mCSMBrXNkGojiW2Ly8D9w46emaigp9bkDSW7f2gVnBM,372
+nefino_geosync/api_client.py,sha256=hUflfpp5Yo-_MalS1fdvIQfXtfUghzT9dx2WQMsCN_4,4264
+nefino_geosync/compose_requests.py,sha256=3p_9Jqaq6T-Cp4iUpV5J_X8VZzznzEJIY_bmNDTlEFM,5155
+nefino_geosync/config.py,sha256=thVVMsw4-CGgYJj63sX6nQShSZ9n9zEuz_9RCNL1tIM,3491
+nefino_geosync/download_analysis.py,sha256=W4Z1k_A3gKbVbQ0wXgLup3ojtABwqGGzB4X4hho4mTQ,4858
+nefino_geosync/download_completed_analyses.py,sha256=nXkIVAqCP_ZNfG76fwy4LPx3VD939AwNID96XKlHGJk,765
+nefino_geosync/get_downloadable_analyses.py,sha256=eBEOjH6MvW9Oh-lF5FdVvRhC8sNHBulsW3Aj4dR-0fw,1694
+nefino_geosync/graphql_errors.py,sha256=wmwQCALJA75vWXLGN3Q1lVso6vJWStzgLFDHeuVVNcw,2636
+nefino_geosync/journal.py,sha256=mvN3ZyfUVRBMiBlAfFtrlsODMew2MCLwDM0Qa8PZJzM,7612
+nefino_geosync/layer_changelog.py,sha256=4NG5uRxlXIpdziwdk2etfARUR-1dYnrhZm6RBQHAhrQ,9878
+nefino_geosync/parse_args.py,sha256=75e8J7WDiueOnMuPQdvwj-w_dXMhrGCOLMNTRIFGOHA,937
+nefino_geosync/run.py,sha256=Chv-eAQDNlIFxv3F4EFhTbqIzIyzO7vgSYSgGgUVCtI,1898
+nefino_geosync/schema.json,sha256=yBHwVYsfF1ybUFthGUuNpkdGkBdx_DcqZgq0ul4TIYo,71104
+nefino_geosync/schema.py,sha256=Vqm3Hpm6CtDi0boR-F81PrmpNrlnDlkpVLGAXXIxL2M,12633
+nefino_geosync/session_logger.py,sha256=6bpUNAaosus1XRGWyWTalzTmddrqxSgTxZoTqGnX6_k,3564
+nefino_geosync/start_analyses.py,sha256=ZtIjuo5FXiGfgdwah2S6tUhO6i8n6y3SsLq2kNPQeIo,2468
+nefino_geosync/storage.py,sha256=_fnE-zQnNSMfgoUratUcDGbMUJA-oatf55AXbuftFyI,1424
+nefino_geosync-0.2.2.dist-info/METADATA,sha256=PjQgk7tQz2CwVMV64l3R7A5aaXgFYDEn7crnN_4cIfE,15496
+nefino_geosync-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nefino_geosync-0.2.2.dist-info/entry_points.txt,sha256=zZ7Zrx1MyxZKd2iGrvRmHjYzY5C2EMgqY5TqzNOGYqo,59
+nefino_geosync-0.2.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nefino_geosync-0.2.2.dist-info/RECORD,,

nefino_geosync-0.2.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-nefino_geosync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nefino_geosync/access_rule_filter.py,sha256=mCSMBrXNkGojiW2Ly8D9w46emaigp9bkDSW7f2gVnBM,372
-nefino_geosync/api_client.py,sha256=ylVVEC1f6N8P77VVZ5RLp3lieVnLmrepMO1IjnBGU4o,3617
-nefino_geosync/compose_requests.py,sha256=oiVApnl-cxDBFeIoxaU_UREI4EXOHSCsad0i65Uh1BM,3740
-nefino_geosync/config.py,sha256=thVVMsw4-CGgYJj63sX6nQShSZ9n9zEuz_9RCNL1tIM,3491
-nefino_geosync/download_analysis.py,sha256=Y4By5U5-ohks6VzjgSd_8RqZ_gIocukgWlN51NXdq_k,4751
-nefino_geosync/download_completed_analyses.py,sha256=ggCZGi8mOL2imT8iwfR8yTsdvnKHA6jyw6Dwil1TLU0,866
-nefino_geosync/get_downloadable_analyses.py,sha256=Om0Q6F7xRze-jvo865XN2qzRT91zmuA-TAKYmeVsGIE,1651
-nefino_geosync/graphql_errors.py,sha256=n92jAicdfeH7weUo1I1gTIC2JQKDybYlD9BVredSHQw,1512
-nefino_geosync/journal.py,sha256=5IbOBfIM-oWXCd7ZvMqx-8A069dDsW15DZ9YcnCzV0s,5271
-nefino_geosync/parse_args.py,sha256=75e8J7WDiueOnMuPQdvwj-w_dXMhrGCOLMNTRIFGOHA,937
-nefino_geosync/run.py,sha256=l4b-P5B3_CNqp6d13_ZjCBbGyp7MWIC1ZwgNfEvvZm8,914
-nefino_geosync/schema.json,sha256=yBHwVYsfF1ybUFthGUuNpkdGkBdx_DcqZgq0ul4TIYo,71104
-nefino_geosync/schema.py,sha256=ALP9_2sKh75sXrYDmTiBEBLygZMiZF-B8hahcYYJZrE,9203
-nefino_geosync/start_analyses.py,sha256=xWicbXvJybKb8Yi756M2cRpfys0bzmri9_eByAot0sE,2063
-nefino_geosync/storage.py,sha256=_fnE-zQnNSMfgoUratUcDGbMUJA-oatf55AXbuftFyI,1424
-nefino_geosync-0.2.1.dist-info/METADATA,sha256=P4iOxGtvCM9xkS3X1DszkbW-2U46RkDz8uBYYkRjG4Q,15496
-nefino_geosync-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nefino_geosync-0.2.1.dist-info/entry_points.txt,sha256=zZ7Zrx1MyxZKd2iGrvRmHjYzY5C2EMgqY5TqzNOGYqo,59
-nefino_geosync-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nefino_geosync-0.2.1.dist-info/RECORD,,