nfdata 0.1.0__py3-none-any.whl

nfdata/console.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+"""NanoFASE data is responsible for compiling and editing data for use in NanoFASE model."""
+import sys
+import os
+import argparse
+import importlib.resources as pkg_resources
+from .compiler import Compiler
+
+
+def run():
+    parser = argparse.ArgumentParser(description='Compile or edit data for the NanoFASE model.')
+    parser.add_argument('task',
+                        help='do you wish to create from scratch, edit the data or create a constants file?',
+                        choices=['create', 'edit', 'constants'])
+    parser.add_argument('file', help='path to the config file (create/edit tasks) or constants file (constants task)')
+    parser.add_argument('--output', '-o', help='where to create the new constants file (for constants task)')
+    args = parser.parse_args()
+
+    if args.task == 'constants':
+        # If we're just compiling the constants file, just call the static create_constants method
+        Compiler.create_constants(args.file, args.output)
+    else:
+        # Create the compiler. We use model_vars.yaml as included in the package
+        model_vars_path = pkg_resources.files(__package__).joinpath('model_vars.yaml')
+        compiler = Compiler(args.task, args.file, model_vars_path)
+        # Do we want to compile from scratch or edit a pre-exiting file?
+        if args.task == 'create':
+            # Run the data compilation
+            compiler.create()
+        elif args.task == 'edit':
+            # Edit the variables given in the config file
+            compiler.edit()

nfdata/land_use.default.yaml

@@ -0,0 +1,58 @@
+111:                                # Continuous urban fabric
+    - [ 'urban_no_soil', 0.7 ]
+    - [ 'urban_green_residential', 0.3 ]
+112:                                # Discontinous urban fabric
+    - [ 'urban_no_soil', 0.4 ]
+    - [ 'urban_green_residential', 0.6 ]
+121:                                # Industrial or commerical units
+    - [ 'urban_no_soil', 0.5 ]
+    - [ 'urban_industrial_soil', 0.5 ]
+122:                                # Road and rail networks
+    - [ 'urban_no_soil', 0.4 ]
+    - [ 'urban_industrial_soil', 0.6 ]
+123:                                # Port areas
+    - [ 'urban_no_soil', 0.6 ]
+    - [ 'urban_industrial_soil', 0.4 ]
+124:                                # Airports
+    - ['urban_no_soil', 0.2]
+    - ['urban_industrial_soil', 0.8]
+131: [ 'urban_industrial_soil' ]    # Mineral extraction
+132: [ 'urban_industrial_soil' ]    # Dump sites
+133: [ 'urban_industrial_soil' ]    # Construction sites
+141: [ 'urban_parks_leisure' ]      # Green urban areas
+142: [ 'urban_parks_leisure' ]      # Sport and leisure facilities
+211: [ 'arable' ]                   # Non-irrigated arable land
+212: [ 'arable' ]                   # Permanently irrigated land
+213: [ 'arable' ]                   # Rice fields
+221: [ 'arable' ]                   # Vineyards
+222: [ 'arable' ]                   # Fruit trees and berry plantations
+223: [ 'arable' ]                   # Olive groves
+231: [ 'arable' ]                   # Pastures
+241: [ 'arable' ]                   # Annual crops associated with permanent crops
+242: [ 'arable' ]                   # Complex cultivation patterns
+243: [ 'arable' ]                   # Land principally occupied by agriculture, with significant areas of natural vegetation
+244: [ 'arable' ]                   # Agro-forestry areas
+311: [ 'deciduous' ]                # Deciduous woodland
+312: [ 'coniferous' ]               # Coniferous woodland
+313:                                # Mixed forests
+    - [ 'deciduous', 0.5 ]
+    - [ 'coniferous', 0.5 ]
+321: [ 'grassland' ]                # Natural grassland
+322: [ 'heathland' ]                # Moors and heathland
+323: [ 'heathland' ]                # Sclerophyllous vegetation
+324: [ 'heathland' ]                # Transitional woodland/scrub
+331: [ 'desert' ]                   # Beaches, dunes, sands
+332: [ 'other' ]                    # Bare rock
+333: [ 'heathland' ]                # Sparsely vegetated areas
+334: [ 'heathland' ]                # Burnt areas
+335: [ 'other' ]                    # Glaciers and perpetual snow
+411: [ 'other' ]                    # Inland marshes
+412: [ 'heathland' ]                # Peatbogs
+421: [ 'other' ]                    # Salt marshes
+422: [ 'other' ]                    # Salines
+423: [ 'other' ]                    # Intertidal flats
+511: [ 'water' ]                    # Water courses
+512: [ 'water' ]                    # Water bodies
+521: [ 'water' ]                    # Coastal lagoons
+522: [ 'water' ]                    # Estuaries
+523: [ 'water' ]                    # Sea and ocean

nfdata/model_vars.yaml

@@ -0,0 +1,224 @@
+# The model_vars.yaml file is an internal file that describes the input variables required by the
+# NanoFASE model and those that should be compiled by the nanofase-data script. *You should not need
+# to edit anything in this file*, but the standard_name, long_name and comment properties are passed
+# as variable attributes to the compiled NetCDF file, so feel free to edit these. Editing other
+# properties will likely break something.
+
+# Meteorological and hydrological
+dem:
+  standard_name: height_above_mean_sea_level
+  to_units: dm
+  dims: ['y', 'x']
+  vartype: int32
+quickflow:
+  standard_name: surface_runoff_flux
+  to_units: m/timestep
+  fill_value: 0
+  clip: [0.0, None]
+  dims: ['t', 'y', 'x']
+runoff:
+  standard_name: runoff_flux
+  to_units: m/timestep
+  fill_value: 0
+  clip: [0.0, None]
+  dims: ['t', 'y', 'x']
+precip:
+  standard_name: rainfall_flux
+  to_units: m/timestep
+  comment: Rainfall amount (kg m-2) is equivalent to the rainfall depth (mm)
+  dims: ['t', 'y', 'x']
+  vartype: f8
+
+# Soil
+soil_bulk_density:
+  long_name: bulk density of soil
+  to_units: kg/m**3
+  dims: ['y', 'x']
+soil_water_content_field_capacity:
+  standard_name: volume_fraction_of_condensed_water_in_soil_at_field_capacity
+  to_units: cm**3/cm**3
+  dims: ['y', 'x']
+soil_water_content_saturation:
+  standard_name: volume_fraction_of_condensed_water_in_soil
+  long_name: water content of soil at saturation
+  to_units: cm**3/cm**3
+  dims: ['y', 'x']
+soil_hydraulic_conductivity:
+  standard_name: soil_hydraulic_conductivity_at_saturation
+  to_units: m/s
+  dims: ['y', 'x']
+soil_texture_clay_content:
+  standard_name: volume_fraction_of_clay_in_soil
+  to_units: kg/kg
+  dims: ['y', 'x']
+soil_texture_sand_content:
+  standard_name: volume_fraction_of_sand_in_soil
+  to_units: kg/kg
+  dims: ['y', 'x']
+soil_texture_silt_content:
+  standard_name: volume_fraction_of_silt_in_soil
+  to_units: kg/kg
+  dims: ['y', 'x']
+soil_texture_coarse_frag_content:
+  long_name: coarse fragment content of soil
+  to_units: kg/kg
+  dims: ['y', 'x']
+soil_attachment_rate:
+  long_name: rate of attachment of nanomaterial to soil matrix
+  to_units: s**-1
+  dims: ['y', 'x']
+soil_usle_c_factor:
+  long_name: Universal Soil Loss Equation C-factor
+  to_units: ''
+  dims: ['y', 'x']
+soil_usle_p_factor:
+  long_name: Universal Soil Loss Equation P-factor
+  to_units: ''
+  dims: ['y', 'x']
+soil_usle_ls_factor:
+  long_name: Universal Soil Loss Equation LS-factor
+  to_units: ''
+  dims: ['y', 'x']
+
+# Suspended sediment
+bank_erosion_alpha:
+  long_name: linear calibration parameter controlling the rate of bank erosion
+  to_units: 'kg/m**5'
+  dims: ['y', 'x']
+bank_erosion_beta:
+  long_name: calibration parameter controlling the rate of bank erosion
+  to_units: ''
+  dims: ['y', 'x']
+deposition_alpha:
+  long_name: calibration parameter controlling the rate of sediment deposition
+  to_units: ''
+  dims: ['y', 'x']
+deposition_beta:
+  long_name: calibration parameter controlling the rate of sediment deposition
+  to_units: ''
+  dims: ['y', 'x']
+resuspension_alpha:
+  long_name: shear velocity calibration parameter controlling the rate of sediment resuspension
+  to_units: ''
+  dims: ['y', 'x']
+resuspension_beta:
+  long_name: resuspension calibration parameter controlling the rate of sediment resuspension
+  to_units: 's**2/kg'
+  dims: ['y', 'x']
+sediment_transport_a:
+  long_name: sediment transport capacity scaling factor
+  to_units: 'kg m**-2 km**-2'
+  dims: ['y', 'x']
+sediment_transport_c:
+  long_name: sediment transport capacity non-linear coefficient
+  to_units: ''
+  dims: ['y', 'x']
+
+# Land use
+land_use:
+  long_name: land use categorised by NanoFASE model land use categories
+  to_units: ''
+  dims: ['l', 'y', 'x']
+  cats: 
+    - urban_no_soil
+    - urban_parks_leisure
+    - urban_industrial_soil
+    - urban_green_residential
+    - arable
+    - grassland
+    - deciduous
+    - coniferous
+    - heathland
+    - water
+    - desert
+    - other
+is_estuary:
+  long_name: is waterbody in this cell an estuary
+  to_units: ''
+  dims: ['y', 'x']
+  vartype: u1
+  clip: [None, 100]
+
+# Emissions - areal
+emissions_areal_soil_pristine:
+  long_name: mass flux of pristine nanomaterial into soil
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+emissions_areal_soil_matrixembedded:
+  long_name: mass flux of matrix-embedded nanomaterial into soil
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+emissions_areal_soil_transformed:
+  long_name: mass flux of transformed nanomaterial into soil
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+emissions_areal_soil_dissolved:
+  long_name: mass flux of dissolved nanomaterial into soil
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+emissions_areal_water_pristine:
+  long_name: mass flux of pristine nanomaterial into surface waters
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+emissions_areal_water_matrixembedded:
+  long_name: mass flux of matrix-embedded nanomaterial into surface waters
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+emissions_areal_water_transformed:
+  long_name: mass flux of transformed nanomaterial into surface waters
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+emissions_areal_water_dissolved:
+  long_name: mass flux of dissolved nanomaterial into surface waters
+  to_units: kg/m**2/timestep
+  dims: ['y', 'x']
+
+# Emissions - point
+emissions_point_water_pristine:
+  long_name: mass transport of pristine nanomaterial into surface waters from point sources
+  to_units: kg/timestep
+  dims: ['p', 't', 'y', 'x']
+emissions_point_water_matrixembedded:
+  long_name: mass transport of matrix-embedded nanomaterial into surface waters from point sources
+  to_units: kg/timestep
+  dims: ['p', 't', 'y', 'x']
+emissions_point_water_transformed:
+  long_name: mass transport of pristine nanomaterial into surface waters from point sources
+  to_units: kg/timestep
+  dims: ['p', 't', 'y', 'x']
+emissions_point_water_dissolved:
+  long_name: mass transport of pristine nanomaterial into surface waters from point sources
+  to_units: kg/timestep
+  dims: ['p', 't', 'y', 'x']
+
+# Emissions - atmospheric
+emissions_atmospheric_drydepo_pristine:
+  standard_name: tendency_of_atmosphere_mass_content_due_to_dry_deposition
+  long_name: tendency of atmosphere mass content of pristine nanomaterial due to dry deposition
+  to_units: kg/m**2/timestep
+  dims: ['t', 'y', 'x']
+emissions_atmospheric_drydepo_matrixembedded:
+  standard_name: tendency_of_atmosphere_mass_content_due_to_dry_deposition
+  long_name: tendency of atmosphere mass content of matrix-embedded nanomaterial due to dry deposition
+  to_units: kg/m**2/timestep
+  dims: ['t', 'y', 'x']
+emissions_atmospheric_drydepo_transformed:
+  standard_name: tendency_of_atmosphere_mass_content_due_to_dry_deposition
+  long_name: tendency of atmosphere mass content of transformed nanomaterial due to dry deposition
+  to_units: kg/m**2/timestep
+  dims: ['t', 'y', 'x']
+emissions_atmospheric_wetdepo_pristine:
+  standard_name: tendency_of_atmosphere_mass_content_due_to_wet_deposition
+  long_name: tendency of atmosphere mass content of pristine nanomaterial due to wet deposition
+  to_units: kg/m**2/timestep
+  dims: ['t', 'y', 'x']
+emissions_atmospheric_wetdepo_matrixembedded:
+  standard_name: tendency_of_atmosphere_mass_content_due_to_wet_deposition
+  long_name: tendency of atmosphere mass content of matrix-embedded nanomaterial due to wet deposition
+  to_units: kg/m**2/timestep
+  dims: ['t', 'y', 'x']
+emissions_atmospheric_wetdepo_transformed:
+  standard_name: tendency_of_atmosphere_mass_content_due_to_wet_deposition
+  long_name: tendency of atmosphere mass content of transformed nanomaterial due to wet deposition
+  to_units: kg/m**2/timestep
+  dims: ['t', 'y', 'x']

nfdata/router.py

@@ -0,0 +1,111 @@
+import numpy as np
+
+
+class Router:
+    """The Router class is responsible for using the flow direction raster to route water bodies within the
+    model domain, setting variables required by the NanoFASE model, such as inflows, outflows and headwaters."""
+
+    def __init__(self, flow_dir):
+        """Initiliase the routing class with the flow direction array."""
+        self.flow_dir = flow_dir
+        self.grid_mask = self.flow_dir.mask
+
+    def outflow_from_flow_dir(self, x, y):
+        """Get the outflow cell reference given the current cell
+        reference and a flow direction."""
+        xy_out = {
+            1: [x+1, y],
+            2: [x+1, y+1],
+            4: [x, y+1],
+            8: [x-1, y+1],
+            16: [x-1, y],
+            32: [x-1, y-1],
+            64: [x, y-1],
+            128: [x+1, y-1]
+        }
+        return xy_out[self.flow_dir[y-1, x-1]]
+
+    def inflows_from_flow_dir(self, x, y):
+        """Get the inflow cell references given the current cell
+        reference and a flow direction."""
+        j, i = y - 1, x - 1
+        # Flow direction that means the cell with indices inflows[j_n-j, i_n-i]
+        # flows into this cell
+        inflow_flow_dir = {
+            (-1, -1): 2,
+            (0, -1): 1,
+            (1, -1): 128,
+            (-1, 0): 4,
+            (0, 0): 0,
+            (1, 0): 64,
+            (-1, 1): 8,
+            (0, 1): 16,
+            (1, 1): 32
+        }
+        inflow_cells = []
+        # Loop through the neighbours and check if they're inflows to this cell
+        for j_n in range(j-1, j+2):
+            for i_n in range(i-1, i+2):
+                if self.in_model_domain(i_n, j_n):
+                    if self.flow_dir[j_n, i_n] == inflow_flow_dir[(j_n-j, i_n-i)]:
+                        inflow_cells.append([i_n+1, j_n+1])
+        # Create masked array from the inflow_cells list
+        inflow_cells_ma = np.ma.array(np.ma.empty((7,2), dtype=int), mask=True)
+        if len(inflow_cells) > 0:       # Only fill if there are inflows
+            inflow_cells_ma[0:len(inflow_cells)] = inflow_cells
+        return inflow_cells_ma
+
+    def in_model_domain(self, i, j):
+        """Check if index [j,i] is in model domain."""
+        i_in_domain = 0 <= i < self.grid_mask.shape[1]
+        j_in_domain = 0 <= j < self.grid_mask.shape[0]
+        not_masked = self.flow_dir[j, i] is not np.ma.masked if (i_in_domain and j_in_domain) else False
+        return i_in_domain and j_in_domain and not_masked
+
+    def n_waterbodies_from_inflows(self, x, y, outflow, inflows):
+        """Calculate the number of waterbodies from the inflows to the cell."""
+        # j, i = y - 1, x - 1
+        j_out, i_out = outflow[1] - 1, outflow[0] - 1
+        n_inflows = inflows.count(axis=0)[0]        # Count the unmasked elements to get n_inflows
+        # If there are no inflows but the outflow is to the model domain, it
+        # must be a headwater. Else, number of waterbodies is same as number of inflows
+        if n_inflows == 0 and self.in_model_domain(i_out, j_out):
+            n_waterbodies = 1
+            is_headwater = 1
+        else:
+            n_waterbodies = n_inflows
+            is_headwater = 0
+        return n_waterbodies, is_headwater
+
+    # def generate_waterbody_code(self, x, y, outflow, inflows, is_estuary, is_headwater):
+    #     """Generates character code of the waterbodies of this cell, of the format
+    #     <type><index>(<inflow_point>:<outflow_point>/<n_waterbodies_along_branch>)...
+    #     where type = r,e,l,s (river, estuary, lake, sea), index is 1-indexed, inflow
+    #     and outflow_side are integers representing the geometrical point of inflow
+    #     (0 for centre, 1 for top-left, 2 for top centre, etc.) and n_waterbodies_along_branch
+    #     is the number of waterbodies between inflow and outflow."""
+    #     outflow_point = self.point_index(outflow[1]-x, outflow[0]-y)
+    #     wb_type = 'e' if is_estuary > 0 else 'r'
+    #     wb_char = ''
+    #     for i, inflow in enumerate(inflows):
+    #         if not inflow.mask.any():       # Only if this cell isn't masked
+    #             inflow_point = self.point_index(inflow[1]-x, inflow[0]-y)
+    #             wb_char = wb_char + '{0}{1}({2}:{3}/01)'.format(wb_type, i+1, inflow_point, outflow_point)
+    #     # If this is a headwater, there must be a waterbody with inflow at centre of cell
+    #     if is_headwater:
+    #         wb_char = '{0}1(0:{1}/01)'.format(wb_type, outflow_point)
+    #     return wb_char
+
+    # def point_index(self, di, dj):
+    #     point_index = {
+    #         (-1, -1): 1,
+    #         (0, -1): 8,
+    #         (1, -1): 7,
+    #         (-1, 0): 2,
+    #         (0, 0): 0,
+    #         (1, 0): 6,
+    #         (-1, 1): 3,
+    #         (0, 1): 4,
+    #         (1, 1): 5
+    #     }
+    #     return point_index[dj, di]

nfdata-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.1
+Name: nfdata
+Version: 0.1.0
+Summary: Compile and edit input data for the NanoFASE model
+License: BSD-3-Clause
+Author: Sam Harrison
+Author-email: samharrison.xg@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: Pint (>=0.24.1,<0.25.0)
+Requires-Dist: f90nml (>=1.4.4,<2.0.0)
+Requires-Dist: geopandas (>=1.0.0,<2.0.0)
+Requires-Dist: netCDF4 (>=1.7.1.post1,<2.0.0)
+Requires-Dist: numpy (>=2.0.0,<3.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: rasterio (>=1.3.10,<2.0.0)
+Requires-Dist: ruamel.yaml (>=0.18.6,<0.19.0)
+Requires-Dist: shapely (>=2.0.4,<3.0.0)
+Project-URL: Documentation, https://nerc-ceh.github.io/nanofase
+Description-Content-Type: text/markdown
+
+# NanoFASE Data
+
+The NanoFASE Data module is a set of scripts to compile and edit input data for the [NanoFASE model](https://github.com/nerc-ceh/nanofase).
+
+[See the NanoFASE documentation for full documentation](https://nerc-ceh.github.io/nanofase/users/nanofase-data.html).
+
+*Still in development. Use with caution!*
+
+## Getting started
+
+The easiest way to get started is to create a Conda environment using the provided [environment.yaml](./environment.yaml) file:
+
+```shell script
+$ conda env create -f environment.yaml
+$ activate nanofase-data
+```
+
+If you don't want to use Conda, then this [environment.yaml](./environment.yaml) file lists the packages that need to be installed.
+
+## Usage
+
+```
+usage: nanofase_data.py [-h] [--output OUTPUT] {create,edit,constants} file
+
+Compile or edit data for the NanoFASE model.
+
+positional arguments:
+  {create,edit,constants}
+                        do you wish to create from scratch, edit the data or
+                        create a constants file?
+  file                  path to the config file (create/edit tasks) or
+                        constants file (constants task)
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --output OUTPUT, -o OUTPUT
+                        where to create the new constants file (for constants
+                        task)
+```
+
+### Creating a new dataset
+
+Specifying the "create" option compiles a new NetCDF dataset and Fortran namelist constant file:
+
+```shell script
+$ python nanofase_data.py create /path/to/config.create.yaml
+```
+
+An annotated example config file is given: [`config.create.example.yaml`](config.create.example.yaml). The file is quite self-explanatory, but a few further explanations are provided in [this document](docs/config.md).
+
+The two files will be output to the paths specified in the config file.
+
+### Editing an existing dataset
+
+To edit an existing NetCDF dataset, specify the "edit" option:
+
+```shell script
+$ python nanofase_data.py edit /path/to/config.edit.yaml
+```
+
+An annotated example config file is given: [`config.edit.example.yaml`](config.edit.example.yaml). This is similar (but not identical) in format to the creation config file, except only those variables you with to edit should be specified (all other variables are left as-is).
+
+Certain variables can't be edited: `flow_dir`, `is_estuary`. Create a new dataset instead if you wish to change these variables.
+
+The Fortran namelist file cannot be edited using this method and you should instead edit the file directly.
+
+### Only creating a new constants file
+
+To simply convert a constants YAML file to a Fortran namelist file, you can use the `constants` option:
+
+```shell script
+$ python nanofase_data.py constants /path/to/constants.yaml -o /path/to/constants.nml
+```
+
+No config file is required. The location of the newly created constants file is given by the `-o` or `--output` argument.
+
+### Tips
+- For the moment, all rasters must be the same CRS as the `flow_dir` raster, and this must be a projected raster. We recommend ESPG:27700 (British National Grid). In addition, all rasters except for `land_use` must be the same resolution as `flow_dir`. They can cover a large geographical region and the module will automatically clip them to the correct size.
+- Support for different file types is a bit sporadic at the moment. I suggest sticking the raster files for spatial variables, raster or CSV files for spatiotemporal variables (with 1 file per timestep for raster files) and shapefiles for point sources. You will trigger errors if you use an unsupported file.
+- Example input data files are given in `data.example/thames_tio2_2015/`. Running the model using the example config files uses these data. 

nfdata-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+config.create.example.yaml,sha256=VrhOESh0SAT9XgfMzlsFHwZ9gdk33QKeQre7OAgkK2A,11022
+config.edit.example.yaml,sha256=kftzvNc8CVF-Zpl0m4_Z7oImDOOcrwBMX1teSZQ4vfE,726
+environment.yaml,sha256=gtWHLI-2OuMYHfkY-2ymte_7YZjU8dvk0AzlY6dYDoI,167
+nfdata/__init__.py,sha256=CUCPni5-diJlQ8X6gu__U-BK9kqmWghdf86MCDhnPtc,228
+nfdata/compiler.py,sha256=qwOOAUoFnKC9QS-Ow5Dky7GyKDhlHzzP--Q2xObQ2SA,38226
+nfdata/console.py,sha256=RtufM-tHCRK9gX0DGEWLjQYnAm9Sy-v_Lrima2IVLJo,1536
+nfdata/land_use.default.yaml,sha256=bpx-iDxsh3KVDqOLyCYCYBLrbUYTCFh2XqD0q3BCs1w,3049
+nfdata/model_vars.yaml,sha256=TOitPec6u8vmwygv-G1wyrNXr68cp1C2XjYEyOKdnzg,7646
+nfdata/router.py,sha256=S7IUL93ZaF91lSywImjD3KVBJaj2X0bW-yMrl9_a_IQ,4836
+nfdata-0.1.0.dist-info/METADATA,sha256=owMUWrwKVDtQVwBVYaEx9CqfRFrSpxPu5NaytOSFg50,4632
+nfdata-0.1.0.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+nfdata-0.1.0.dist-info/entry_points.txt,sha256=H_4636nsIrsy4hqa65cUq5uenq5AIGSOoq7tlEO3HRY,45
+nfdata-0.1.0.dist-info/RECORD,,

nfdata-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

nfdata-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+nfdata=nfdata.console:run
+