matplotlib-map-utils 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

matplotlib_map_utils/utils/usa.py

@@ -0,0 +1,336 @@
+import re
+import json
+import warnings
+from importlib import resources
+from typing import List, Literal, Union
+
+# Literal lists, for intellisense
+regions = Literal["Midwest", "Northeast", "South", "West", 
+                  "Inhabited Territory", "Uninhabited Territory", "Sovereign State"]
+
+divisions = Literal["East North Central", "East South Central", "Mid-Atlantic", "Mountain", 
+                    "New England", "Pacific", "South Atlantic", "West North Central", "West South Central",
+                    "Commonwealth", "Compact of Free Association", "Incorporated and Unorganized", 
+                    "Unincorporated and Unorganized", "Unincorporated and Organized"] 
+
+ombs = Literal["Region I", "Region II", "Region III", "Region IV", "Region IX", "Region V", 
+               "Region VI", "Region VII", "Region VIII", "Region X",
+               "Inhabited Territory", "Uninhabited Territory", "Sovereign State"]
+
+beas = Literal["Far West", "Great Lakes", "Mideast", "New England", "Plains", 
+               "Rocky Mountain", "Southeast", "Southwest",
+               "Inhabited Territory", "Uninhabited Territory", "Sovereign State"]
+
+returns = Literal["fips","name","abbr","object","dict"]
+
+class USA:
+    # No arguments need to pass on initialization really
+    def __init__(self):
+        self._jurisdictions = self._load_json()
+
+    # This is just for loading the JSON
+    def _load_json(self):
+        with resources.files("matplotlib_map_utils.utils").joinpath("usa.json").open("r") as f:
+            usa_json = json.load(f)
+        return usa_json
+    
+    # Getter for all jurisdictions, VALID OR NOT
+    @property 
+    def _all(self):
+        return self._jurisdictions
+
+    # Getter for all valid jurisdictions
+    @property
+    def jurisdictions(self):
+        return self.filter_valid(True, self._all, "object")
+    
+    # Getter for all valid states
+    @property
+    def states(self):
+        return self.filter_state(True, self.jurisdictions, "object")
+    
+    # Getter for all valid territories
+    @property
+    def territories(self):
+        return self.filter_territory(True, self.jurisdictions, "object")
+    
+    # Getters to generate distinct values for Region, Division, OMB, and BEA
+    # which are useful if you can't recall which options are valid
+    # First, the function that will get the distinct values
+    def _distinct_options(self, key):
+        # First getting all the available options from the list
+        options = [j[key] for j in self.jurisdictions if j[key] is not None]
+        # Creating the distinct set
+        options_set = set(options)
+        # Returning the set (but as a list)
+        # this will also be alphabetically sorted
+        options = list(options_set)
+        options.sort()
+        return options
+    
+    # The getters are now just calls to the properties
+    @property 
+    def regions(self):
+        return self._distinct_options("region")
+    
+    @property 
+    def divisions(self):
+        return self._distinct_options("division")
+    
+    @property 
+    def omb(self):
+        return self._distinct_options("omb")
+    
+    @property 
+    def bea(self):
+        return self._distinct_options("bea")
+    
+    # Main filter function
+    # Each filter step will follow the same process
+    ## Check that there is a non-None filter
+    ## Normalize the input to be in a list (if not already)
+    ## Perform the filter step
+    # Each step is also available as its own independent function, as needed
+    def filter(self, valid: bool | None=True, 
+               fips: str | int | None=None, 
+               name: str | None=None, 
+               abbr: str | None=None, 
+               state: bool | None=None, 
+               contiguous: bool | None=None, 
+               territory: bool | None=None, 
+               region: Union[regions, List[regions]]=None, 
+               division: Union[divisions, List[divisions]]=None, 
+               omb: Union[ombs, List[ombs]]=None,
+               bea: Union[beas, List[beas]]=None,
+               to_return: Union[returns, List[returns]]="fips"):
+        
+        # Getting a copy of our jurisdictions, which will be filtered each time
+        filter_juris = self.jurisdictions.copy()
+
+        # Starting with an initial valid filtering
+        # Which will drop invalid FIPS codes 03, 07, 14, 43, and 52
+        if (valid is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_valid(valid, filter_juris, to_return="_ignore")
+
+        # Going through each step
+        if (fips is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_fips(fips, filter_juris, to_return="_ignore")
+        
+        if (name is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_name(name, filter_juris, to_return="_ignore")
+        
+        if (abbr is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_abbr(abbr, filter_juris, to_return="_ignore")
+        
+        if (state is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_state(state, filter_juris, to_return="_ignore")
+        
+        if (contiguous is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_contiguous(contiguous, filter_juris, to_return="_ignore")
+        
+        if (territory is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_territory(territory, filter_juris, to_return="_ignore")
+        
+        if (region is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_region(region, filter_juris, to_return="_ignore")
+        
+        if (division is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_division(division, filter_juris, to_return="_ignore")
+        
+        if (omb is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_omb(omb, filter_juris, to_return="_ignore")
+        
+        if (bea is not None) and (len(filter_juris) > 0):
+            filter_juris = self.filter_bea(bea, filter_juris, to_return="_ignore")
+        
+        # Final step is to process the input based on to_return
+        # and then return it!
+        return self._process_return(filter_juris, to_return)
+    
+    # Filtering bool values (valid, state, contiguous, territory)
+    # Will accept either true or false
+    def _filter_bool(self, value, key, to_filter=None, to_return="_ignore"):
+        # If nothing is passed to to_filter, getting the jurisdictions list
+        to_filter = self.jurisdictions.copy() if to_filter is None else to_filter
+        if not isinstance(value, bool):
+            warnings.warn(f"Invalid {key} filter: {value}. Only boolean values (True/False) are considered valid, see documentation for details.")
+        else:    
+            # Performing the filter
+            filtered = [j for j in to_filter if j[key] == value]
+            # And returning the values
+            return self._process_return(filtered, to_return)
+
+    # Shortcuts for filtering based on valid, state, contiguous, and territory
+    def filter_valid(self, valid: bool, to_filter=None, to_return="fips"):
+        return self._filter_bool(valid, "valid", to_filter, to_return)
+    
+    def filter_state(self, state: bool, to_filter=None, to_return="fips"):
+        return self._filter_bool(state, "state", to_filter, to_return)
+    
+    def filter_contiguous(self, contiguous: bool, to_filter=None, to_return="fips"):
+        return self._filter_bool(contiguous, "contiguous", to_filter, to_return)
+    
+    def filter_territory(self, territory: bool, to_filter=None, to_return="fips"):
+        return self._filter_bool(territory, "territory", to_filter, to_return)
+
+    # Filtering FIPS
+    # Will accept an integer or a two-digit string as an input
+    # If a longer string is inserted, will truncate to only the first two characters
+    def filter_fips(self, fips: str | List[str], to_filter=None, to_return="abbr"):
+        # If nothing is passed to to_filter, getting the jurisdictions list
+        to_filter = self.jurisdictions.copy() if to_filter is None else to_filter
+        # Normalizing the fips value being passed
+        fips = self._normalize_input(fips)
+        # This will store the cleaned-up fips codes
+        fips_clean = []
+        for f in fips:
+            # If the input is an integer, convert it to a two-digit string
+            if isinstance(f, int):
+                fips_clean.append(str(f).zfill(2)[:2])
+            # If the input is already a string, get the first two characters
+            elif isinstance(f, str):
+                fips_clean.append(f.zfill(2)[:2])
+            # Otherwise, throw a *warning*
+            else:
+                warnings.warn(f"Invalid FIPS filter: {f}. Only integers and strings are considered valid, see documentation for details.")
+        # Now can use the clean fips to actually filter
+        filtered = [j for j in to_filter if j["fips"] in fips_clean]
+        # And returning the values
+        return self._process_return(filtered, to_return)
+    
+    # Filtering name
+    # Will accept strings
+    # Will normalize the string first (trim, case, special characters), before checking
+    # Some states also have an alias available for checking against (Washington, D.C. and District of Columbia are equivalent)
+    def filter_name(self, name: str | List[str], to_filter=None, to_return="fips"):
+        # If nothing is passed to to_filter, getting the jurisdictions list
+        to_filter = self.jurisdictions.copy() if to_filter is None else to_filter
+        # Normalizing the name input being passed
+        name = self._normalize_input(name)
+        # This will store the cleaned-up name input
+        name_clean = []
+        for n in name:
+            # If the input is a string, clean it
+            if isinstance(n, str):
+                name_clean.append(self._normalize_string(n, case="lower"))
+            else:
+                warnings.warn(f"Invalid name filter: {n}. Only strings are considered valid, see documentation for details.")
+        # Now we can use the clean name to filter
+        # Note that we also normalize the names and aliases in our to_filter list!
+        filtered = [j for j in to_filter if ((self._normalize_string(j["name"], case="lower") in name_clean) or 
+                                             (j["alias"] is not None and self._normalize_string(j["alias"], case="lower") in name_clean))]
+        # And returning the values
+        return self._process_return(filtered, to_return)
+
+    # Filtering abbr
+    # Will accept strings
+    # Will normalize the string first (trim, case, special characters), before checking
+    # If a string longer than two characters is passed, will only look at the first two characters!
+    def filter_abbr(self, abbr: str | List[str], to_filter=None, to_return="fips"):
+        # If nothing is passed to to_filter, getting the jurisdictions list
+        to_filter = self.jurisdictions.copy() if to_filter is None else to_filter
+        # Normalizing the input being passed
+        abbr = self._normalize_input(abbr)
+        # This will store the cleaned-up input
+        abbr_clean = []
+        for a in abbr:
+            # If the input is a string, clean it
+            if isinstance(a, str):
+                abbr_clean.append(self._normalize_string(a, case="lower"))
+            else:
+                warnings.warn(f"Invalid abbr filter: {a}. Only strings are considered valid, see documentation for details.")
+        # Now we can use the clean input to filter
+        filtered = [j for j in to_filter if (j["abbr"] is not None and self._normalize_string(j["abbr"], case="lower")[:2] in abbr_clean)]
+        # And returning the values
+        return self._process_return(filtered, to_return)
+
+    # Filtering for categorical values (region/division/omb/bea)
+    # Will get the list of acceptable values and compare inputs to it
+    # while also warning if an invalid filter is requested
+    def _filter_categorical(self, input, key, to_filter=None, to_return="_ignore"):
+        # If nothing is passed to to_filter, getting the jurisdictions list
+        to_filter = self.jurisdictions.copy() if to_filter is None else to_filter
+        # Normalizing the input being passed
+        input = self._normalize_input(input)
+        # This has the acceptable inputs we want to compare against
+        accepted_inputs = self._distinct_options(key)
+        # This will store the cleaned-up input
+        input_clean = []
+        for i in input:
+            # If the input is not a string, warn
+            if not isinstance(i, str):
+                warnings.warn(f"Invalid {key} filter: {i}. Only strings are considered valid, see documentation for details.")
+            # If the input is not in our list, warn the user
+            elif i not in accepted_inputs:
+                warnings.warn(f"Invalid {key} filter: {i}. Only the following inputs are considered valid: {accepted_inputs}.")
+            # Otherwise, add it to our list
+            else:
+                input_clean.append(i)
+        # Now we can use the clean input to filter
+        filtered = [j for j in to_filter if j[key] in input_clean]
+        # And returning the values
+        return self._process_return(filtered, to_return)
+    
+    # Iterations for each categorical filter based on their respective inputs
+    def filter_region(self, region: Union[regions, List[regions]], to_filter=None, to_return="fips"):
+        return self._filter_categorical(region, "region", to_filter, to_return)
+    
+    def filter_division(self, division: Union[divisions, List[divisions]], to_filter=None, to_return="fips"):
+        return self._filter_categorical(division, "division", to_filter, to_return)
+    
+    def filter_omb(self, omb: Union[ombs, List[ombs]], to_filter=None, to_return="fips"):
+        return self._filter_categorical(omb, "omb", to_filter, to_return)
+    
+    def filter_bea(self, bea: Union[beas, List[beas]], to_filter=None, to_return="fips"):
+        return self._filter_categorical(bea, "bea", to_filter, to_return)
+
+    # Function that processes the returning of a filtered jurisdiction
+    def _process_return(self, filter_juris, to_return):
+        # If the length is zero, warn!
+        if filter_juris is None or len(filter_juris) == 0:
+            warnings.warn(f"No matching entities found. Please refer to the documentation and double-check your filters.")
+            return None
+        if to_return is None:
+            to_return == "_ignore"
+        # Available options for to_return include fips, name, and abbr
+        elif to_return.lower() == "fips":
+            juris_return = [j["fips"] for j in filter_juris]
+        elif to_return.lower() == "name":
+            juris_return = [j["name"] for j in filter_juris]
+        elif to_return.lower() == "abbr":
+            juris_return = [j["abbr"] for j in filter_juris]
+        # Can also request that the entire object be returned, in which case nothing is done
+        # This will also happen if an invalid return object is passed
+        elif to_return.lower() not in ["object","dict","_ignore"]:
+            warnings.warn(f"Invalid to_return request: {to_return}. The entire object will be returned.")
+            juris_return = filter_juris.copy()
+        else:
+            juris_return = filter_juris.copy()
+        
+        # Now, also processing the return request based on the length of the returned list
+        # If the length is zero, warn!
+        if len(juris_return) == 0:
+            warnings.warn(f"No matching entities found. Please refer to the documentation and double-check your filters.")
+            return None
+        # If only one element is returned, return the element itself, not a list
+        elif len(juris_return) == 1 and to_return != "_ignore":
+            return juris_return[0]
+        # Otherwise return the whole thing
+        else:
+            return juris_return
+
+    # Utility function to normalize a string that is passed to it
+    def _normalize_string(self, string, case="keep", nan="", spaces="_"):
+        string = string.strip()
+        if case == "lower":
+            string = string.lower()
+        string = re.sub(r"\W\S",nan,string)
+        string = re.sub(r"\s",spaces,string)
+        return string
+    
+    # Utility function to convert a relevant non-list input to a list
+    def _normalize_input(self, input):
+        if not isinstance(input, (list, tuple)):
+            return [input]
+        else:
+            return input

{matplotlib_map_utils-2.0.1.dist-info → matplotlib_map_utils-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: matplotlib-map-utils
-Version: 2.0.1
+Version: 2.1.0
 Summary: A suite of tools for creating maps in matplotlib
 Author-email: David Moss <davidmoss1221@gmail.com>
 Project-URL: Homepage, https://github.com/moss-xyz/matplotlib-map-utils/
@@ -8,12 +8,13 @@ Project-URL: Bug Tracker, https://github.com/moss-xyz/matplotlib-map-utils/issue
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License (GPL)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.9.0
 Requires-Dist: cartopy>=0.23.0
 Requires-Dist: great-circle-calculator>=1.3.1
+Dynamic: license-file
 
 # matplotlib-map-utils
  
@@ -29,12 +30,14 @@ Requires-Dist: great-circle-calculator>=1.3.1
 
 `matplotlib_map_utils` is intended to be a package that provides various functions and objects that assist with the the creation of maps using [`matplotlib`](https://matplotlib.org/stable/).
 
-As of `v2.x` (the current version), this includes two tools: 
+As of `v2.x` (the current version), this includes two tools and one utility: 
 
 * `north_arrow.py`, which generates a high quality, context-aware north arrow for a given plot. 
 
 * `scale_bar.py`, which generates a high quality, context-aware scale bar to a given plot. 
 
+* `usa.py`, which contains a class that helps filter for states and territories within the USA based on given characteristics.
+
 Future releases (if the project is continued) might provide a similar tool inset maps, or other functions that I have created myself that give more control in the formatting of maps.
 
 ---
@@ -49,11 +52,11 @@ pip install matplotlib-map-utils
 
 The requirements for this package are:
 
-* `python >= 3.9.0` (due to the dictionary-concatenation method utilized)
+* `python >= 3.10` (due to the use of the pipe operator to concatenate dictionaries and types)
 
-* `matplotlib >= 3.9.0` (might work with lower versions but not guaranteed)
+* `matplotlib >= 3.9` (might work with lower versions but not guaranteed)
 
-* `cartopy >= 0.23.0` (due to earlier bug with calling `copy()` on `CRS` objects)
+* `cartopy >= 0.23` (due to earlier bug with calling `copy()` on `CRS` objects)
 
 ---
 
@@ -78,6 +81,10 @@ package_name/
 │   ├── __init__.py
 │   ├── north_arrow.py
 │   └── scale_bar.py
+├── utils/
+│   ├── __init__.py
+│   ├── usa.py
+│   └── usa.json
 ```
 
 Where:
@@ -230,6 +237,38 @@ Refer to `docs\howto_scale_bar` for details on how to customize each facet of th
 
 ---
 
+### Utilities
+
+<details>
+<summary><i>Expand instructions</i></summary>
+
+#### Quick Start
+
+Importing the bundled utility functions and classes can be done like so:
+
+```py
+from matplotlib_map_utils.utils import USA
+```
+
+As of `v2.1.0`, there is only one utility class available: `USA`, an object to help quickly filter for subsets of US states and territories. This utility class is still in beta, and might change.
+
+An example:
+
+```python
+# Loading the object
+usa = USA()
+# Getting a list FIPS codes for US States
+usa.filter(states=True, to_return="fips")
+# Getting a list of State Names for states in the South and Midwest regions
+usa.filter(region=["South","Midtwest"], to_return="name")
+```
+
+Refer to `docs\howto_utils` for details on how to use this class, including with `pandas.apply()`.
+
+</details>
+
+---
+
 ### Development Notes
 
 #### Inspiration and Thanks
@@ -246,6 +285,10 @@ Two more projects assisted with the creation of this script:
 
 - `v2.0.1`: Fixed a bug in the `dual_bars()` function that prevented empty dictionaries to be passed. Also added a warning when auto-calculated bar widths appear to be exceeding the dimension of the axis (usually occurs when the axis is <2 kilometeres or miles long, depending on the units selected).
 
+- `v2.0.2`: Changed f-string formatting to alternate double and single quotes, so as to maintain compatibility with versions of Python before 3.12 (see [here](https://github.com/moss-xyz/matplotlib-map-utils/issues/3)). However, this did reveal that another aspect of the code, namely concatenating `type` in function arguments, requires 3.10, and so the minimum python version was incremented.
+
+- `v2.1.0`: Added a utility class, `USA`, for filtering subsets of US states and territories based on FIPS code, name, abbreviation, region, division, and more. This is considered a beta release, and might be subject to change later on.
+
 #### Future Roadmap
 
 With the release of `v2.x`, and the addition of **Scale Bar** tools, this project has achieved the two main objectives that I set out to.
@@ -268,7 +311,15 @@ If I continue development of this project, I will be looking to add or fix the f
 
   * Create more styles for the bar, potentiallly including dual boxes and a sawtooth bar
 
-If that goes well, `v3` can then either create a tool for generating inset maps (which `matplotlib` has *some* support for), or the various functions that I have created in the past that assist with formatting a map "properly", such as centering on a given object and coverting FIPS codes.
+* **Utils:**
+
+  * (USA): Stronger fuzzy search mechanics, so that it will accept flexible inputs for FIPS/abbr/name
+
+  * (USA): More integrated class types to allow for a more fully-formed object model (USA being a `Country`, with subclasses related to `State` and `Territory` that have their own classes of attributes, etc.)
+
+  * (USA): Stronger typing options, so you don't have to recall which `region` or `division` types are available, etc.
+
+If that goes well, `v3` can then either create a tool for generating inset maps (which `matplotlib` has *some* support for), or the various functions that I have created in the past that assist with formatting a map "properly", such as centering on a given object.
 
 I am also open to ideas for other extensions to create!
 

{matplotlib_map_utils-2.0.1.dist-info → matplotlib_map_utils-2.1.0.dist-info}/RECORD

@@ -1,18 +1,21 @@
 matplotlib_map_utils/__init__.py,sha256=X6lN1yfP4ckb6l-ej20YqFvIHUNLZQxRWnvvyWBlJEY,305
 matplotlib_map_utils/core/__init__.py,sha256=G4fxPpfE77EhZr7yGZCjppP7zvwRthl8yHM0b2KgrFs,184
 matplotlib_map_utils/core/north_arrow.py,sha256=vikwYtSP2-sPRF_SQBALezB3uEY_PHA9dglm503hkvU,22531
-matplotlib_map_utils/core/scale_bar.py,sha256=HxHFhiElE3jlyY6ZeHlxIf4LS2bNA2pQkyUXVyggXW8,62248
+matplotlib_map_utils/core/scale_bar.py,sha256=l2tS35xa_pv40lag4Y00hT6FEGhQ-wOb07ipxDUYCNw,62248
 matplotlib_map_utils/defaults/__init__.py,sha256=_pegE5kv_sb0ansSF4XpWBRwboaP4zUjWY1KIGbK-TE,119
 matplotlib_map_utils/defaults/north_arrow.py,sha256=uZb1RsUWxFTHywm8HATj_9iPF_GjCs_Z2HOn0JchjTY,8571
 matplotlib_map_utils/defaults/scale_bar.py,sha256=GpXiWUHcOsv43G1HOfpqw-dzDPQQzQB7RNdtIf0e7Bc,8225
 matplotlib_map_utils/scratch/map_utils.py,sha256=j8dOX9uuotl9rRCAXapFLHycUwVE4nzIrqWYOGG2Lgg,19653
 matplotlib_map_utils/scratch/north_arrow_old_classes.py,sha256=1xKQ6yUghX4BWzIv8GsGBHDDPJ8B0Na7ixdw2jgtTqw,50993
+matplotlib_map_utils/utils/__init__.py,sha256=uUy0kUMMGrDpvo88J_OLk2dQI-UwCXclccaEyk8x5R0,41
+matplotlib_map_utils/utils/usa.json,sha256=kLB9JXNSWf8VU-9XwXuMRAPKO-zA4aluQUEln7Ktc_s,26563
+matplotlib_map_utils/utils/usa.py,sha256=7SlUdxtCan5PFNIoLe-HfOC5r2cxJAF-9QKhNIK71EI,16853
 matplotlib_map_utils/validation/__init__.py,sha256=0fL3N63jxjRwTU44b7-6ZYZJfOT_0ac7dx7M6Gpu_5M,52
 matplotlib_map_utils/validation/functions.py,sha256=QpOHs-GQ1NUMXO0HxAtEZvAcrXwsIE2ekqUhYm-IKGg,11783
 matplotlib_map_utils/validation/north_arrow.py,sha256=dlWbcKit7dq93PJVrv1efE_865irT6zwBuqD6NYLYPg,10349
 matplotlib_map_utils/validation/scale_bar.py,sha256=7rYs7ei0rQ5iJfapcBWkn7s4P-CnSh9B441GpsGpFO4,17628
-matplotlib_map_utils-2.0.1.dist-info/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
-matplotlib_map_utils-2.0.1.dist-info/METADATA,sha256=COgaYVKbtktPoHyqzhW9uPoTrS5aEo88oeBUoF_VuR4,10644
-matplotlib_map_utils-2.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-matplotlib_map_utils-2.0.1.dist-info/top_level.txt,sha256=6UyDpxsnMhSOd9a-abQe0lLJveybJyYtUHMdX7zXgKA,21
-matplotlib_map_utils-2.0.1.dist-info/RECORD,,
+matplotlib_map_utils-2.1.0.dist-info/licenses/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
+matplotlib_map_utils-2.1.0.dist-info/METADATA,sha256=KaD3ZBhrkgi25DYJV2xJXx0wjcTM9MgmNcNr58Z6UcE,12839
+matplotlib_map_utils-2.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+matplotlib_map_utils-2.1.0.dist-info/top_level.txt,sha256=6UyDpxsnMhSOd9a-abQe0lLJveybJyYtUHMdX7zXgKA,21
+matplotlib_map_utils-2.1.0.dist-info/RECORD,,

{matplotlib_map_utils-2.0.1.dist-info → matplotlib_map_utils-2.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any