nefino-geosync 0.2.3__py3-none-any.whl

nefino_geosync/schema.py

@@ -0,0 +1,356 @@
+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
+
+ID = sgqlc.types.ID
+
+Int = sgqlc.types.Int
+
+
+class OutputObjectType(sgqlc.types.Enum):
+    __schema__ = schema
+    __choices__ = ('GPKG', 'QGIS_AND_GPKG', 'QGIS_PRJ', 'SHP')
+
+
+class PlaceTypeGeo(sgqlc.types.Enum):
+    __schema__ = schema
+    __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',
+    )
+
+
+class ScopeType(sgqlc.types.Enum):
+    __schema__ = schema
+    __choices__ = (
+        'ADMINISTRATIVE_UNIT',
+        'FEDERAL_STATE',
+        'LOCAL_ADMINISTRATIVE_UNIT',
+        'PLANNING_REGION',
+        'POLYGON',
+        'RADIUS',
+        'SQUARE',
+    )
+
+
+class Status(sgqlc.types.Enum):
+    __schema__ = schema
+    __choices__ = ('ERROR', 'PENDING', 'RUNNING', 'SUCCESS')
+
+
+String = sgqlc.types.String
+
+
+class UUID(sgqlc.types.Scalar):
+    __schema__ = schema
+
+
+########################################################################
+# Input Objects
+########################################################################
+class CoordinateInput(sgqlc.types.Input):
+    __schema__ = schema
+    __field_names__ = ('lon', 'lat')
+    lon = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name='lon')
+    lat = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name='lat')
+
+
+class GeoAnalysisInput(sgqlc.types.Input):
+    __schema__ = schema
+    __field_names__ = ('name', 'specs')
+    name = sgqlc.types.Field(String, graphql_name='name')
+    specs = sgqlc.types.Field(sgqlc.types.non_null('GeoAnalysisObjectInput'), graphql_name='specs')
+
+
+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',
+    )
+
+
+class GeoAnalysisObjectInput(sgqlc.types.Input):
+    __schema__ = schema
+    __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',
+    )
+    output = sgqlc.types.Field(sgqlc.types.non_null('GeoAnalysisOutputFormatInput'), graphql_name='output')
+
+
+class GeoAnalysisOperationInput(sgqlc.types.Input):
+    __schema__ = schema
+    __field_names__ = ('operation_name', 'input')
+    operation_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='operationName')
+    input = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name='input')
+
+
+class GeoAnalysisOutputFormatInput(sgqlc.types.Input):
+    __schema__ = schema
+    __field_names__ = ('template_name', 'type', 'crs')
+    template_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='templateName')
+    type = sgqlc.types.Field(sgqlc.types.non_null(OutputObjectType), graphql_name='type')
+    crs = sgqlc.types.Field(sgqlc.types.non_null(CRSType), graphql_name='crs')
+
+
+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',
+    )
+
+
+class GeoAnalysisScopeInput(sgqlc.types.Input):
+    __schema__ = schema
+    __field_names__ = ('type', 'radius', 'sides', 'polygon', 'place')
+    type = sgqlc.types.Field(sgqlc.types.non_null(ScopeType), graphql_name='type')
+    radius = sgqlc.types.Field(Float, graphql_name='radius')
+    sides = sgqlc.types.Field(Float, graphql_name='sides')
+    polygon = sgqlc.types.Field(String, graphql_name='polygon')
+    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
+########################################################################
+class MinimalAnalysis(sgqlc.types.Type):
+    __schema__ = schema
+    __field_names__ = ('started_at', 'pk', 'status', 'url')
+    started_at = sgqlc.types.Field(DateTime, graphql_name='startedAt')
+    pk = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name='pk')
+    status = sgqlc.types.Field(sgqlc.types.non_null(Status), graphql_name='status')
+    url = sgqlc.types.Field(String, graphql_name='url')
+
+
+class MinimalAreasEnabled(sgqlc.types.Type):
+    __schema__ = schema
+    __field_names__ = ('all_areas_enabled', 'enabled_states')
+    all_areas_enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name='allAreasEnabled')
+    enabled_states = sgqlc.types.Field(sgqlc.types.list_of('PlaceIdentifier'), graphql_name='enabledStates')
+
+
+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',
+    )
+    has_access = sgqlc.types.Field(Boolean, graphql_name='hasAccess')
+
+
+class MinimalGeoAccessRule(sgqlc.types.Type):
+    __schema__ = schema
+    __field_names__ = ('all_clusters_enabled', 'clusters', 'places')
+    all_clusters_enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name='allClustersEnabled')
+    clusters = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name='clusters')
+    places = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name='places')
+
+
+class MinimalLayer(sgqlc.types.Type):
+    __schema__ = schema
+    __field_names__ = ('name', 'pre_buffer', 'last_update', 'is_regional')
+    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='name')
+    pre_buffer = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name='preBuffer')
+    last_update = sgqlc.types.Field(DateTime, graphql_name='lastUpdate')
+    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,
+                    ),
+                ),
+            )
+        ),
+    )
+
+
+class PlaceIdentifier(sgqlc.types.Type):
+    __schema__ = schema
+    __field_names__ = ('place_id', 'place_type')
+    place_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name='placeId')
+    place_type = sgqlc.types.Field(sgqlc.types.non_null(PlaceTypeNews), graphql_name='placeType')
+
+
+class Query(sgqlc.types.Type):
+    __schema__ = schema
+    __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,
+                    ),
+                ),
+            )
+        ),
+    )
+    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),
+                ),
+            )
+        ),
+    )
+
+
+########################################################################
+# Unions
+########################################################################
+
+########################################################################
+# Schema Entry Points
+########################################################################
+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

@@ -0,0 +1,57 @@
+import sys
+from .api_client import (
+    general_availability_operation,
+    local_availability_operation,
+    start_analyses_operation,
+)
+from .compose_requests import compose_complete_requests
+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 typing import Any
+
+AnalysesMutationResult = Any
+
+
+def start_analyses(client: HTTPEndpoint, changelog_result: LayerChangelogResult = None) -> AnalysesMutationResult:
+    """Starts the analyses for all updated data."""
+    journal = Journal.singleton()
+    parse_args()
+    # Get information about our permissions and the general availability of layers
+    general_op = general_availability_operation()
+    print('Checking for layers to update...')
+    general_data = client(general_op)
+    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, 'Failed to fetch regional layer availability')
+    local_availability = local_op + local_data
+    # Clear previous analysis requested layers
+    journal.clear_analysis_requested_layers()
+    # Start the analyses
+    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.')
+        sys.exit(0)
+    for federal_state_key in analysis_inputs:
+        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, 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, analysis_inputs)
+        print(f'Analysis for {federal_state_key} finished')
+        download_completed_analyses(client)
+
+    return analyses

nefino_geosync/storage.py

@@ -0,0 +1,40 @@
+"""This module handles creating and finding directories where the app should store its files."""
+
+import os
+import platform
+
+APP_NAME='nefino-geosync'
+
+def get_app_directory() -> str:
+    """Returns the directory where the app should store its files. 
+    Creates it if it doesn't exist."""
+    system = platform.system()
+    
+    if system == 'Windows':
+        base_dir = os.path.join(os.getenv('APPDATA'), APP_NAME)
+    elif system == 'Darwin':  # macOS
+        base_dir = os.path.join(os.path.expanduser('~'), 'Library', 'Application Support', APP_NAME)
+    else:  # Linux and other Unix-like systems
+        base_dir = os.path.join(os.path.expanduser('~'), f'.{APP_NAME}')
+    
+    if not os.path.exists(base_dir):
+        os.makedirs(base_dir)
+    
+    return base_dir
+
+def get_download_directory(pk: str) -> str:
+    """Returns the directory where the app should store downloaded analyses. 
+    Creates it if it doesn't exist."""
+    downloads_dir = os.path.join(get_app_directory(), 'downloads', pk)
+    
+    if not os.path.exists(downloads_dir):
+        os.makedirs(downloads_dir)
+    
+    return downloads_dir
+
+def get_output_path(state: str, cluster: str) -> str:
+    """Returns the path to store the latest version of downloaded files."""
+    output_dir = os.path.join(get_app_directory(), "newestData", state, cluster)
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    return output_dir