matplotlib-map-utils 1.0.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

matplotlib_map_utils-2.0.0.dist-info/METADATA

@@ -0,0 +1,281 @@
+Metadata-Version: 2.1
+Name: matplotlib-map-utils
+Version: 2.0.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/
+Project-URL: Bug Tracker, https://github.com/moss-xyz/matplotlib-map-utils/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License (GPL)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+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
+
+# matplotlib-map-utils
+ 
+---
+
+**Documentation**: See `docs` folder
+
+**Source Code**: [Available on GitHub](https://github.com/moss-xyz/matplotlib-map-utils)
+
+---
+
+### Introduction
+
+`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: 
+
+* `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. 
+
+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.
+
+---
+
+### Installation
+
+This package is available on PyPi, and can be installed like so:
+
+```bash
+pip install matplotlib-map-utils
+```
+
+The requirements for this package are:
+
+* `python >= 3.9.0` (due to the dictionary-concatenation method utilized)
+
+* `matplotlib >= 3.9.0` (might work with lower versions but not guaranteed)
+
+* `cartopy >= 0.23.0` (due to earlier bug with calling `copy()` on `CRS` objects)
+
+---
+
+### Package Structure
+
+The package is arrayed in the following way:
+
+```bash
+package_name/
+├── __init__.py
+│
+├── core/
+│   ├── __init__.py
+│   ├── north_arrow.py
+│   ├── scale_bar.py
+├── validation/
+│   ├── __init__.py
+│   ├── functions.py
+│   ├── north_arrow.py
+│   └── scale_bar.py
+├── defaults/
+│   ├── __init__.py
+│   ├── north_arrow.py
+│   └── scale_bar.py
+```
+
+Where:
+
+* `core` contains the main functions and classes for each object
+
+* `validation` contains type hints for each variable and functions to validate inputs
+
+* `defaults` contains default settings for each object at different paper sizes
+
+---
+
+### North Arrow
+
+<details>
+<summary><i>Expand instructions</i></summary>
+
+#### Quick Start
+
+Importing the North Arrow functions and classes can be done like so:
+
+```py
+from matplotlib_map_utils.core.north_arrow import NorthArrow, north_arrow
+```
+
+The quickest way to add a single north arrow to a single plot is to use the `north_arrow` function:
+
+```python
+# Setting up a plot
+fig, ax = matplotlib.pyplot.subplots(1,1, figsize=(5,5), dpi=150)
+# Adding a north arrow to the upper-right corner of the axis, without any rotation (see Rotation under Formatting Components for details)
+north_arrow.north_arrow(ax=ax, location="upper right", rotation={"degrees":0})
+```
+
+An object-oriented approach is also supported:
+
+```python
+# Setting up a plot
+fig, ax = matplotlib.pyplot.subplots(1,1, figsize=(5,5), dpi=150)
+# Creating a north arrow for the upper-right corner of the axis, without any rotation (see Rotation under Formatting Components for details)
+na = north_arrow.NorthArrow(location="upper right", rotation={"degrees":0})
+# Adding the artist to the plot
+ax.add_artist(na)
+```
+
+Both of these will create an output like the following:
+
+![Example north arrow](matplotlib_map_utils/docs/assets/readme_northarrow.png)
+
+#### Customization
+
+Both the object-oriented and functional approaches can be customized to allow for fine-grained control over formatting:
+
+```python
+north_arrow(
+    ax,
+    location = "upper right", # accepts a valid string from the list of locations
+    scale = 0.5, # accepts a valid positive float or integer
+    # each of the follow accepts arguments from a customized style dictionary
+    base = {"facecolor":"green"},
+    fancy = False,
+    label = {"text":"North"},
+    shadow = {"alpha":0.8},
+    pack = {"sep":6},
+    aob = {"pad":2},
+    rotation = {"degrees": 35}
+)
+```
+
+This will create an output like the following:
+
+![Customized north arrow](matplotlib_map_utils/docs/assets/readme_northarrow_customization.png)
+
+Refer to `docs\howto_north_arrow` for details on how to customize each facet of the north arrow.
+
+#### Rotation
+
+The north arrow object is also capable of pointing towards "true north", given a CRS and reference point:
+
+![Example north arrow rotation](matplotlib_map_utils/docs/assets/readme_northarrow_rotation.png)
+
+Instructions for how to do so can be found in `docs\howto_north_arrow`.
+</details>
+
+---
+
+### Scale Bar
+
+<details>
+<summary><i>Expand instructions</i></summary>
+
+#### Quick Start
+
+Importing the Scale Bar functions and classes can be done like so:
+
+```py
+from matplotlib_map_utils.core.scale_bar import ScaleBar, scale_bar
+```
+
+There are two available styles for the scale bars: `boxes` and `ticks`. The quickest way to add one to a single plot is to use the `scale_bar` function:
+
+```python
+# Setting up a plot
+fig, ax = matplotlib.pyplot.subplots(1,1, figsize=(5,5), dpi=150)
+# Adding a scale bar to the upper-right corner of the axis, in the same projection as whatever geodata you plotted
+# Here, this scale bar will have the "boxes" style
+scale_bar(ax=ax, location="upper right", style="boxes", bar={"projection":3857})
+```
+
+An object-oriented approach is also supported:
+
+```python
+# Setting up a plot
+fig, ax = matplotlib.pyplot.subplots(1,1, figsize=(5,5), dpi=150)
+# Adding a scale bar to the upper-right corner of the axis, in the same projection as whatever geodata you plotted
+# Here, we change the boxes to "ticks"
+sb = ScaleBar(location="upper right", style="boxes", bar={"projection":3857})
+# Adding the artist to the plot
+ax.add_artist(sb)
+```
+
+Both of these will create an output like the following (function is left, class is right):
+
+![Example scale bar](matplotlib_map_utils/docs/assets/readme_scalebar.png)
+
+#### Customization
+
+Both the object-oriented and functional approaches can be customized to allow for fine-grained control over formatting:
+
+```python
+scale_bar(
+    ax,
+    location = "upper right", # accepts a valid string from the list of locations
+    style = "boxes", # accepts a valid positive float or integer
+    # each of the follow accepts arguments from a customized style dictionary
+    bar = {"unit":"mi", "length":2}, # converting the units to miles, and changing the length of the bar (in inches)
+    labels = {"style":"major", "loc":"below"}, # placing a label on each major division, and moving them below the bar
+    units = {"loc":"text"}, # changing the location of the units text to the major division labels
+    text = {"fontfamily":"monospace"}, # changing the font family of all the text to monospace
+)
+```
+
+This will create an output like the following:
+
+![Customized scale bar](matplotlib_map_utils/docs/assets/readme_scalebar_customization.png)
+
+Refer to `docs\howto_scale_bar` for details on how to customize each facet of the scale bar.
+
+</details>
+
+---
+
+### Development Notes
+
+#### Inspiration and Thanks
+
+This project was heavily inspired by [`matplotlib-scalebar`](https://github.com/ppinard/matplotlib-scalebar/), and much of the code is either directly copied or a derivative of that project, since it uses the same "artist"-based approach.
+
+Two more projects assisted with the creation of this script:
+
+* [`EOmaps`](https://github.com/raphaelquast/EOmaps/discussions/231) provided code for calculating the rotation required to point to "true north" for an arbitrary point and CRS for the north arrow.
+
+* [`Cartopy`](https://github.com/SciTools/cartopy/issues/2361) fixed an issue inherent to calling `.copy()` on `CRS` objects.
+
+#### 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.
+
+If I continue development of this project, I will be looking to add or fix the following features:
+
+* **North Arrow:** 
+
+  * Copy the image-rendering functionality of the Scale Bar to allow for rotation of the entire object, label and arrow together
+  
+  * Create more styles for the arrow, potentiallly including a compass rose and a line-only arrow
+
+* **Scale Bar:**
+
+  * Allow for custom unit definitions (instead of just metres/feet/miles/kilometres/etc.), so that the scale bar can be used on arbitrary plots (such as inches/cm/mm, mathmatical plots, and the like)
+
+  * Fix/improve the `dual_bars()` function, which currently doesn't work great with rotations
+
+  * Clean up the variable naming scheme (consistency on `loc` vs `position`, `style` vs `type`, etc.)
+
+  * 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.
+
+I am also open to ideas for other extensions to create!
+
+#### Support and Contributions
+
+If you notice something is not working as intended or if you'd like to add a feature yourself, I welcome PRs - just be sure to be descriptive as to what you are changing and why, including code examples!
+
+If you are having issues using this script, feel free to leave a post explaining your issue, and I will try and assist, though I have no guaranteed SLAs as this is just a hobby project.
+
+---
+
+### License
+
+I know nothing about licensing, so I went with the GPL license. If that is incompatible with any of the dependencies, please let me know.

matplotlib_map_utils-2.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+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=PQuq4mV3kSVQeQECLosAhr4lGl8iJ7ln0evacwo25TU,60679
+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/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.0.dist-info/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
+matplotlib_map_utils-2.0.0.dist-info/METADATA,sha256=zXSPUe0aS1rGQ75zjbS7tFASAcBeodQgwnttkMCPFu8,10323
+matplotlib_map_utils-2.0.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+matplotlib_map_utils-2.0.0.dist-info/top_level.txt,sha256=6UyDpxsnMhSOd9a-abQe0lLJveybJyYtUHMdX7zXgKA,21
+matplotlib_map_utils-2.0.0.dist-info/RECORD,,

{matplotlib_map_utils-1.0.3.dist-info → matplotlib_map_utils-2.0.0.dist-info}/WHEEL

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

matplotlib_map_utils/validation.py

@@ -1,332 +0,0 @@
-############################################################
-# validation.py contains all the main objects and functions
-# for checking inputs passed to class definitions
-############################################################
-
-### IMPORTING PACKAGES ###
-
-# Default packages
-import warnings
-# Math packages
-import numpy
-# Geo packages
-import pyproj
-# Graphical packages
-import matplotlib
-# matplotlib's useful validation functions
-import matplotlib.rcsetup
-# The types we use in this script
-from typing import Tuple, TypedDict, Literal, get_args
-
-### TYPE HINTS ###
-# This section of the code is for defining structured dictionaries and lists
-# for the inputs necessary for object creation we've created (such as the style dictionaries)
-# so that intellisense can help with autocompletion
-
-class _TYPE_BASE(TypedDict, total=False):
-    coords: numpy.array # must be 2D numpy array
-    facecolor: str # any color value for matplotlib
-    edgecolor: str # any color value for matplotlib
-    linewidth: float | int # between 0 and inf
-    zorder: int # any integer
-
-class _TYPE_FANCY(TypedDict, total=False):
-    coords: numpy.array # must be 2D numpy array
-    facecolor: str # any color value for matplotlib
-    zorder: int # any integer
-
-class _TYPE_LABEL(TypedDict, total=False):
-    text: str # any string that you want to display ("N" or "North" being the most common)
-    position: Literal["top", "bottom", "left", "right"]  # from matplotlib documentation
-    ha: Literal["left", "center", "right"] # from matplotlib documentation
-    va: Literal["baseline", "bottom", "center", "center_baseline", "top"] # from matplotlib documentation
-    fontsize: str | float | int # any fontsize value for matplotlib
-    fontfamily: Literal["serif", "sans-serif", "cursive", "fantasy", "monospace"] # from matplotlib documentation
-    fontstyle: Literal["normal", "italic", "oblique"] # from matplotlib documentation
-    color: str # any color value for matplotlib
-    fontweight: Literal["normal", "bold", "heavy", "light", "ultrabold", "ultralight"] # from matplotlib documentation
-    stroke_width: float | int # between 0 and infinity
-    stroke_color: str # any color value for matplotlib
-    rotation: float | int # between -360 and 360
-    zorder: int # any integer
-
-class _TYPE_SHADOW(TypedDict, total=False):
-    offset: Tuple[float | int, float | int] # two-length tuple or list of x,y values in points
-    alpha: float | int # between 0 and 1
-    shadow_rgbFace: str # any color vlaue for matplotlib
-
-class _TYPE_PACK(TypedDict, total=False):
-    sep: float | int # between 0 and inf
-    align: Literal["top", "bottom", "left", "right", "center", "baseline"] # from matplotlib documentation
-    pad: float | int # between 0 and inf
-    width: float | int # between 0 and inf
-    height: float | int # between 0 and inf
-    mode: Literal["fixed", "expand", "equal"] # from matplotlib documentation
-
-class _TYPE_AOB(TypedDict, total=False):
-    facecolor: str # NON-STANDARD: used to set the facecolor of the offset box (i.e. to white), any color vlaue for matplotlib
-    edgecolor: str # NON-STANDARD: used to set the edge of the offset box (i.e. to black), any color vlaue for matplotlib
-    alpha: float | int # NON-STANDARD: used to set the transparency of the face color of the offset box^, between 0 and 1
-    pad: float | int # between 0 and inf
-    borderpad: float | int # between 0 and inf
-    prop: str | float | int # any fontsize value for matplotlib
-    frameon: bool # any bool
-    # bbox_to_anchor: None # NOTE: currently unvalidated, use at your own risk!
-    # bbox_transform: None
-
-class _TYPE_ROTATION(TypedDict, total=False):
-    degrees: float | int # anything between -360 and 360, or None for "auto"
-    crs: str | int | pyproj.CRS # only required if degrees is None: should be a valid cartopy or pyproj crs, or a string that can be converted to that
-    reference: Literal["axis", "data", "center"] # only required if degrees is None: should be either "axis" or "data" or "center"
-    coords: Tuple[float | int, float | int] # only required if degrees is None: should be a tuple of coordinates in the relevant reference window
-
-### VALIDITY CHECKS ###
-# Functions and variables used for validating inputs for classes
-# All have a similar form, taking in the name of the property (prop), the value (val)
-# some parameters to check against (min/max, list, type, etc.),
-# and whether or not None is acceptable value
-
-def _validate_list(prop, val, list, none_ok=False):
-    if none_ok==False and val is None:
-        raise ValueError(f"None is not a valid value for {prop}, please provide a value in this list: {list}")
-    elif none_ok==True and val is None:
-        return val
-    elif not val in list:
-        raise ValueError(f"'{val}' is not a valid value for {prop}, please provide a value in this list: {list}")
-    return val
-
-def _validate_range(prop, val, min, max, none_ok=False):
-    if none_ok==False and val is None:
-        raise ValueError(f"None is not a valid value for {prop}, please provide a value between {min} and {max}")
-    elif none_ok==True and val is None:
-        return val
-    elif type(val) != int and type(val) != float:
-        raise ValueError(f"The supplied type is not valid for {prop}, please provide a float or integer between {min} and {max}")
-    elif max is not None:
-        if not val >= min and not val <= max:
-            raise ValueError(f"'{val}' is not a valid value for {prop}, please provide a value between {min} and {max}")
-    elif max is None:
-        if not val >= min:
-            raise ValueError(f"'{val}' is not a valid value for {prop}, please provide a value greater than {min}")
-    return val
-
-def _validate_type(prop, val, match, none_ok=False):
-    if none_ok==False and val is None:
-        raise ValueError(f"None is not a valid value for {prop}, please provide an object of type {match}")
-    elif none_ok==True and val is None:
-        return val
-    elif not type(val)==match:
-        raise ValueError(f"'{val}' is not a valid value for {prop}, please provide an object of type {match}")
-    return val
-
-def _validate_coords(prop, val, numpy_type, dims, none_ok=False):
-    if none_ok==False and val is None:
-        raise ValueError(f"None is not a valid value for {prop}, please provide an object of type {numpy_type}")
-    elif none_ok==True and val is None:
-        return val
-    elif not type(val)==numpy_type:
-        raise ValueError(f"'{val}' is not a valid value for {prop}, please provide an object of type {numpy_type}")
-    elif not val.ndim==dims:
-        raise ValueError(f"'{val}' is not a valid value for {prop}, please provide a numpy array with {dims} dimensions")
-    return val
-
-def _validate_tuple(prop, val, length, types, none_ok=False):
-    if none_ok==False and val is None:
-        raise ValueError(f"None is not a valid value for {prop}, please provide a tuple of length {length} instead")
-    elif none_ok==True and val is None:
-        return val
-    elif type(val)!=tuple:
-        raise ValueError(f"{val} is not a valid value for {prop}, please provide a tuple of length {length} instead")
-    elif len(val)!=length:
-        raise ValueError(f"{val} is not a valid value for {prop}, please provide a tuple of length {length} instead")
-    else:
-        for item in val:
-            if type(item) not in types:
-                raise ValueError(f"{type(item)} is not a valid value for the items in {prop}, please provide a value of one of the following types: {types}")
-    return val
-
-def _validate_color_or_none(prop, val, none_ok=False):
-    if none_ok==False and val is None:
-        raise ValueError(f"None is not a valid value for {prop}, please provide a color string acceptable to matplotlib instead")
-    elif none_ok==True and val is None:
-        return val
-    else:
-        matplotlib.rcsetup.validate_color(val)
-    return val
-
-# NOTE: This one is a bit messy, particularly with the rotation module, but I can't think of a better way to do it...
-def _validate_crs(prop, val, rotation_dict, none_ok=False):
-    degrees = rotation_dict.get("degrees",None)
-    crs = rotation_dict.get("crs",None)
-    reference = rotation_dict.get("reference",None)
-    coords = rotation_dict.get("coords",None)
-    
-    if degrees is None:
-        if reference == "center":
-            if crs is None:
-                raise ValueError(f"If degrees is set to None, and reference is 'center', then a valid crs must be supplied")
-        else:
-            if crs is None or reference is None or coords is None:
-                raise ValueError(f"If degrees is set to None, then crs, reference, and coords cannot be None: please provide a valid input for each of these variables instead")
-    elif (type(degrees)==int or type(degrees)==float) and (crs is not None or reference is not None or coords is not None):
-            warnings.warn(f"A value for degrees was supplied; values for crs, reference, and coords will be ignored")
-            return val
-    else:
-        if none_ok==False and val is None:
-            raise ValueError(f"If degrees is set to None, then {prop} cannot be None: please provide a valid CRS input for PyProj instead")
-        elif none_ok==True and val is None:
-            return val
-    # This happens if (a) a value for CRS is supplied and (b) a value for degrees is NOT supplied
-    if type(val)==pyproj.CRS:
-        pass
-    else:
-        try:
-            val = pyproj.CRS.from_user_input(val)
-        except:
-            raise Exception(f"Invalid CRS supplied ({val}), please provide a valid CRS input for PyProj instead")
-    return val
-
-# This final one is used for keys that are not validated
-def _skip_validation(val, none_ok=False):
-    return val
-
-### VALIDITY DICTS ###
-# These compile the functions above^, as well as matplotlib's built-in validity functions
-# into dictionaries that can be used to validate all the inputs to a dictionary at once
-
-_VALIDATE_PRIMARY = {
-    "location":{"func":_validate_list, "kwargs":{"list":["upper right", "upper left", "lower left", "lower right", "center left", "center right", "lower center", "upper center", "center"]}},
-    "scale":{"func":_validate_range, "kwargs":{"min":0, "max":None, "none_ok":True}}, # between 0 and inf
-}
-
-_VALIDATE_BASE = {
-    "coords":{"func":_validate_coords, "kwargs":{"numpy_type":numpy.ndarray, "dims":2}}, # must be 2D numpy array
-    "facecolor":{"func":matplotlib.rcsetup.validate_color}, # any color value for matplotlib
-    "edgecolor":{"func":matplotlib.rcsetup.validate_color}, # any color value for matplotlib
-    "linewidth":{"func":_validate_range, "kwargs":{"min":0, "max":None}}, # between 0 and inf
-    "zorder":{"func":_validate_type, "kwargs":{"match":int}} # any integer
-}
-
-_VALIDATE_FANCY = {
-    "coords":{"func":_validate_coords, "kwargs":{"numpy_type":numpy.ndarray, "dims":2}}, # must be 2D numpy array
-    "facecolor":{"func":matplotlib.rcsetup.validate_color}, # any color value for matplotlib
-    "zorder":{"func":_validate_type, "kwargs":{"match":int}} # any integer
-}
-
-_VALID_LABEL_POSITION = get_args(_TYPE_LABEL.__annotations__["position"])
-_VALID_LABEL_HA = get_args(_TYPE_LABEL.__annotations__["ha"])
-_VALID_LABEL_VA = get_args(_TYPE_LABEL.__annotations__["va"])
-_VALID_LABEL_FONTFAMILY = get_args(_TYPE_LABEL.__annotations__["fontfamily"])
-_VALID_LABEL_FONTSTYLE = get_args(_TYPE_LABEL.__annotations__["fontstyle"])
-_VALID_LABEL_FONTWEIGHT = get_args(_TYPE_LABEL.__annotations__["fontweight"])
-
-_VALIDATE_LABEL = {
-    "text":{"func":_validate_type, "kwargs":{"match":str}}, # any string
-    "position":{"func":_validate_list, "kwargs":{"list":_VALID_LABEL_POSITION}},
-    "ha":{"func":_validate_list, "kwargs":{"list":_VALID_LABEL_HA}},
-    "va":{"func":_validate_list, "kwargs":{"list":_VALID_LABEL_VA}},
-    "fontsize":{"func":matplotlib.rcsetup.validate_fontsize}, # any fontsize value for matplotlib
-    "fontfamily":{"func":_validate_list, "kwargs":{"list":_VALID_LABEL_FONTFAMILY}},
-    "fontstyle":{"func":_validate_list, "kwargs":{"list":_VALID_LABEL_FONTSTYLE}},
-    "color":{"func":matplotlib.rcsetup.validate_color}, # any color value for matplotlib
-    "fontweight":{"func":matplotlib.rcsetup.validate_fontweight}, # any fontweight value for matplotlib
-    "stroke_width":{"func":_validate_range, "kwargs":{"min":0, "max":None}}, # between 0 and inf
-    "stroke_color":{"func":matplotlib.rcsetup.validate_color}, # any color value for matplotlib
-    "rotation":{"func":_validate_range, "kwargs":{"min":-360, "max":360, "none_ok":True}}, # anything between -360 and 360, or None for "auto"
-    "zorder":{"func":_validate_type, "kwargs":{"match":int}} # any integer
-}
-
-_VALIDATE_SHADOW = {
-    "offset":{"func":_validate_tuple, "kwargs":{"length":2, "types":[float, int]}},
-    "alpha":{"func":_validate_range, "kwargs":{"min":0, "max":1, "none_ok":True}}, # any value between 0 and 1
-    "shadow_rgbFace":{"func":matplotlib.rcsetup.validate_color}, # any color value for matplotlib
-}
-
-_VALID_PACK_ALIGN = get_args(_TYPE_PACK.__annotations__["align"])
-_VALID_PACK_MODE = get_args(_TYPE_PACK.__annotations__["mode"])
-
-_VALIDATE_PACK = {
-    "sep":{"func":_validate_range, "kwargs":{"min":0, "max":None}}, # between 0 and inf
-    "align":{"func":_validate_list, "kwargs":{"list":_VALID_PACK_ALIGN}},
-    "pad":{"func":_validate_range, "kwargs":{"min":0, "max":None}}, # between 0 and inf
-    "width":{"func":_validate_range, "kwargs":{"min":0, "max":None, "none_ok":True}}, # between 0 and inf
-    "height":{"func":_validate_range, "kwargs":{"min":0, "max":None, "none_ok":True}}, # between 0 and inf
-    "mode":{"func":_validate_list, "kwargs":{"list":_VALID_PACK_MODE}}
-}
-
-_VALIDATE_AOB = {
-    "facecolor":{"func":_validate_color_or_none, "kwargs":{"none_ok":True}}, # any color value for matplotlib OR NONE
-    "edgecolor":{"func":_validate_color_or_none, "kwargs":{"none_ok":True}}, # any color value for matplotlib OR NONE
-    "alpha":{"func":_validate_range, "kwargs":{"min":0, "max":1, "none_ok":True}}, # any value between 0 and 1
-    "pad":{"func":_validate_range, "kwargs":{"min":0, "max":None}}, # between 0 and inf
-    "borderpad":{"func":_validate_range, "kwargs":{"min":0, "max":None}}, # between 0 and inf
-    "prop":{"func":matplotlib.rcsetup.validate_fontsize}, # any fontsize value for matplotlib
-    "frameon":{"func":_validate_type, "kwargs":{"match":bool}}, # any bool
-    "bbox_to_anchor":{"func":_skip_validation}, # TODO: Currently unvalidated! Make sure to remove from _validate_dict once updated!
-    "bbox_transform":{"func":_skip_validation} # TODO: Currently unvalidated! Make sure to remove from _validate_dict once updated!
-}
-
-_VALID_ROTATION_REFERENCE = get_args(_TYPE_ROTATION.__annotations__["reference"])
-
-_VALIDATE_ROTATION = {
-    "degrees":{"func":_validate_range, "kwargs":{"min":-360, "max":360, "none_ok":True}}, # anything between -360 and 360, or None for "auto"
-    "crs":{"func":_validate_crs, "kwargs":{"none_ok":True}}, # see _validate_crs for details on what is accepted
-    "reference":{"func":_validate_list, "kwargs":{"list":_VALID_ROTATION_REFERENCE, "none_ok":True}}, # see _VALID_ROTATION_REFERENCE for accepted values
-    "coords":{"func":_validate_tuple, "kwargs":{"length":2, "types":[float, int], "none_ok":True}} # only required if degrees is None: should be a tuple of coordinates in the relevant reference window
-}
-
-### MORE VALIDITY FUNCTIONS ###
-# These are more customized, and so are separated from the _validate_* functions above
-# Mainly, they can process the input dictionaries wholesale, as well as the individual functions in it
-
-def _validate_dict(input_dict, default_dict, functions, to_validate: list=None, return_clean=False, parse_false=True):
-    if input_dict == False:
-        if parse_false == True:
-            return None
-        else:
-            return False
-    elif input_dict is None or input_dict == True:
-        return default_dict
-    elif type(input_dict) != dict:
-        raise ValueError(f"A dictionary (NoneType) must be provided, please double-check your inputs")
-    else:
-        values = default_dict | input_dict
-        # Pre-checking that no invalid keys are passed
-        invalid = [key for key in values.keys() if key not in functions.keys() and key not in ["bbox_to_anchor", "bbox_transform"]]
-        if len(invalid) > 0:
-            print(f"Warning: Invalid keys detected ({invalid}). These will be ignored.")
-        # First, trimming our values to only those we need to validate
-        if to_validate is not None:
-            values = {key: val for key, val in values.items() if key in to_validate}
-            functions = {key: val for key, val in functions.items() if key in values.keys()}
-        else:
-            values = {key: val for key, val in values.items() if key in functions.keys()}
-            functions = {key: val for key, val in functions.items() if key in values.keys()}
-        # Now, running the function with the necessary kwargs
-        for key,val in values.items():
-            fd = functions[key]
-            func = fd["func"]
-            # NOTE: This is messy but the only way to get the rotation value to the crs function
-            if key=="crs":
-                _ = func(prop=key, val=val, rotation_dict=values, **fd["kwargs"])
-            # Our custom functions always have this dictionary key in them, so we know what form they take
-            elif "kwargs" in fd:
-                _ = func(prop=key, val=val, **fd["kwargs"])
-            # The matplotlib built-in functions DON'T have that, and only ever take the one value
-            else:
-                _ = func(val)
-        if return_clean==True:
-            return values
-
-# This function can process the _VALIDATE dictionaries we established above, but for single variables at a time
-def _validate(validate_dict, prop, val, return_val=True, kwargs={}):
-    fd = validate_dict[prop]
-    func = fd["func"]
-    # Our custom functions always have this dictionary key in them, so we know what form they take
-    if "kwargs" in fd:
-        val = func(prop=prop, val=val, **(fd["kwargs"] | kwargs))
-    # The matplotlib built-in functions DON'T have that, and only ever take the one value
-    else:
-        val = func(val)
-    if return_val==True:
-        return val