okta-expression-parser 0.2.0__tar.gz

okta_expression_parser-0.2.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: okta-expression-parser
+Version: 0.2.0
+Summary: Returns a boolean by passing Okta profile data to an Okta Expression using Okta Expression Language
+Author: Mathew Moon
+Author-email: me@mathewmoon.net
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: sly (>=0.5,<0.6)
+Description-Content-Type: text/markdown
+
+# Okta expression parser
+

okta_expression_parser-0.2.0/README.md

@@ -0,0 +1 @@
+# Okta expression parser

okta_expression_parser-0.2.0/okta_expression_parser/expression_classes/__init__.py

@@ -0,0 +1,5 @@
+from .arrays import Arrays
+from .string import String
+from .convert import Convert
+from .iso3166convert import Iso3166Convert
+from .groups import Groups

okta_expression_parser-0.2.0/okta_expression_parser/expression_classes/arrays.py

@@ -0,0 +1,57 @@
+from typing import Any, List
+
+
+class _ArrayType(list):
+    pass
+
+
+class Arrays:
+    @classmethod
+    def contains(cls, array: _ArrayType, val: str) -> bool:
+        """Tests if a value exists in an expression's array."""
+        return val in array
+
+    @classmethod
+    def add(cls, array: _ArrayType, val: Any) -> _ArrayType:
+        """Appends an element to a list and returns the list."""
+        return _ArrayType(array + [val])
+
+    @classmethod
+    def remove(cls, array: _ArrayType, val: Any) -> _ArrayType:
+        """Removes all occurances of a value from a list."""
+        return _ArrayType([x for x in array if x != val])
+
+    @classmethod
+    def clear(cls, _: _ArrayType) -> _ArrayType:
+        """Returns and empty list."""
+        return _ArrayType([])
+
+    @classmethod
+    def get(cls, array: _ArrayType, index: int) -> Any:
+        """Returns element at `index`. If `index` does not exist then returns None."""
+        try:
+            return array[index]
+        except IndexError:
+            return None
+
+    @classmethod
+    def flatten(cls, *args: _ArrayType) -> _ArrayType:
+        """Returns a flattened list from all args."""
+        return _ArrayType(
+            [item for row in args for item in (row if isinstance(row, list) else [row])]
+        )
+
+    @classmethod
+    def size(cls, array: _ArrayType) -> int:
+        """Returns the number of elements in array."""
+        return len(array)
+
+    @classmethod
+    def isEmpty(cls, array: _ArrayType) -> bool:
+        """Returns if an array is empty or not."""
+        return not array
+
+    @classmethod
+    def toCsvString(cls, array: _ArrayType) -> str:
+        """Returns a comma delineated string from array elements."""
+        return ",".join(array)

okta_expression_parser-0.2.0/okta_expression_parser/expression_classes/convert.py

@@ -0,0 +1,15 @@
+class Convert:
+    @classmethod
+    def toInt(val: str | float) -> int:
+        """Casts a string to an int."""
+        try:
+            return int(val)
+        except ValueError:
+            return 0
+
+    @classmethod
+    def toNum(val: str) -> float:
+        try:
+            return float(val)
+        except ValueError:
+            return 0

okta_expression_parser-0.2.0/okta_expression_parser/expression_classes/groups.py

@@ -0,0 +1,25 @@
+from .arrays import _ArrayType
+
+
+class Groups:
+    group_data = {}
+
+    @classmethod
+    def getFilteredGroups(
+        cls, allow_list: _ArrayType, group_expression: str, limit: int = 5
+    ) -> _ArrayType:
+        """
+        Returns all groups that are in `allow_list`, which is a list of ID's AND the user is a member of. The return value is
+        the key specified by `group_expression`. For example, if `group_expression` is "user.name" then
+        a list of group names will be returned.
+        """
+        group_key = group_expression.split(".")[-1]
+        res = [cls.group_data.get(x, {}).get(group_key) for x in allow_list]
+
+        if not res:
+            return _ArrayType(res)
+
+        if len(res) > limit:
+            res = res[0:limit]
+
+        return _ArrayType([x for x in res if x is not None])

okta_expression_parser-0.2.0/okta_expression_parser/expression_classes/iso3166convert.py

@@ -0,0 +1,470 @@
+from typing import Dict
+
+
+class Iso3166Convert:
+    @classmethod
+    def __get_identifier_type(cls, identifier: str) -> str:
+        if len(identifier) > 3:
+            return "name"
+        if len(identifier) == 2:
+            return "alpha2"
+        try:
+            int(identifier)
+            return "numeric"
+        except ValueError:
+            return "alpha3"
+
+    @classmethod
+    def __get_country(cls, identifier: str) -> Dict[str, str]:
+        """Returns a country's dict, looking it up by an identifier and what type of identifier it is."""
+        if not isinstance(identifier, str):
+            return None
+
+        id_type = cls.__get_identifier_type(identifier)
+        country = [x for x in codes if x[id_type].lower() == identifier.lower()]
+
+        if country:
+            return country[0]
+
+    @classmethod
+    def toAlpha2(cls, identifier: str) -> str:
+        if res := cls.__get_country(identifier):
+            return res["alpha2"]
+
+    @classmethod
+    def toAlpha3(cls, identifier: str) -> str:
+        if res := cls.__get_country(identifier):
+            return res["alpha3"]
+
+    @classmethod
+    def toNumeric(cls, identifier: str) -> str:
+        if res := cls.__get_country(identifier):
+            return res["numeric"]
+
+    @classmethod
+    def toName(cls, identifier: str) -> str:
+        if res := cls.__get_country(identifier):
+            return res["name"]
+
+
+codes = [
+    {"name": "Andorra", "alpha2": "AD", "alpha3": "AND", "numeric": "020"},
+    {"name": "United Arab Emirates", "alpha2": "AE", "alpha3": "ARE", "numeric": "784"},
+    {"name": "Afghanistan", "alpha2": "AF", "alpha3": "AFG", "numeric": "004"},
+    {"name": "Antigua and Barbuda", "alpha2": "AG", "alpha3": "ATG", "numeric": "028"},
+    {"name": "Anguilla", "alpha2": "AI", "alpha3": "AIA", "numeric": "660"},
+    {"name": "Albania", "alpha2": "AL", "alpha3": "ALB", "numeric": "008"},
+    {"name": "Armenia", "alpha2": "AM", "alpha3": "ARM", "numeric": "051"},
+    {"name": "Angola", "alpha2": "AO", "alpha3": "AGO", "numeric": "024"},
+    {"name": "Antarctica", "alpha2": "AQ", "alpha3": "ATA", "numeric": "010"},
+    {"name": "Argentina", "alpha2": "AR", "alpha3": "ARG", "numeric": "032"},
+    {"name": "American Samoa", "alpha2": "AS", "alpha3": "ASM", "numeric": "016"},
+    {"name": "Austria", "alpha2": "AT", "alpha3": "AUT", "numeric": "040"},
+    {"name": "Australia", "alpha2": "AU", "alpha3": "AUS", "numeric": "036"},
+    {"name": "Aruba", "alpha2": "AW", "alpha3": "ABW", "numeric": "533"},
+    {"name": "Åland Islands", "alpha2": "AX", "alpha3": "ALA", "numeric": "248"},
+    {"name": "Azerbaijan", "alpha2": "AZ", "alpha3": "AZE", "numeric": "031"},
+    {
+        "name": "Bosnia and Herzegovina",
+        "alpha2": "BA",
+        "alpha3": "BIH",
+        "numeric": "070",
+    },
+    {"name": "Barbados", "alpha2": "BB", "alpha3": "BRB", "numeric": "052"},
+    {"name": "Bangladesh", "alpha2": "BD", "alpha3": "BGD", "numeric": "050"},
+    {"name": "Belgium", "alpha2": "BE", "alpha3": "BEL", "numeric": "056"},
+    {"name": "Burkina Faso", "alpha2": "BF", "alpha3": "BFA", "numeric": "854"},
+    {"name": "Bulgaria", "alpha2": "BG", "alpha3": "BGR", "numeric": "100"},
+    {"name": "Bahrain", "alpha2": "BH", "alpha3": "BHR", "numeric": "048"},
+    {"name": "Burundi", "alpha2": "BI", "alpha3": "BDI", "numeric": "108"},
+    {"name": "Benin", "alpha2": "BJ", "alpha3": "BEN", "numeric": "204"},
+    {"name": "Saint Barthélemy", "alpha2": "BL", "alpha3": "BLM", "numeric": "652"},
+    {"name": "Bermuda", "alpha2": "BM", "alpha3": "BMU", "numeric": "060"},
+    {"name": "Brunei Darussalam", "alpha2": "BN", "alpha3": "BRN", "numeric": "096"},
+    {
+        "name": "Bolivia (Plurinational State of)",
+        "alpha2": "BO",
+        "alpha3": "BOL",
+        "numeric": "068",
+    },
+    {
+        "name": "Bonaire, Sint Eustatius and Saba",
+        "alpha2": "BQ",
+        "alpha3": "BES",
+        "numeric": "535",
+    },
+    {"name": "Brazil", "alpha2": "BR", "alpha3": "BRA", "numeric": "076"},
+    {"name": "Bahamas", "alpha2": "BS", "alpha3": "BHS", "numeric": "044"},
+    {"name": "Bhutan", "alpha2": "BT", "alpha3": "BTN", "numeric": "064"},
+    {"name": "Bouvet Island", "alpha2": "BV", "alpha3": "BVT", "numeric": "074"},
+    {"name": "Botswana", "alpha2": "BW", "alpha3": "BWA", "numeric": "072"},
+    {"name": "Belarus", "alpha2": "BY", "alpha3": "BLR", "numeric": "112"},
+    {"name": "Belize", "alpha2": "BZ", "alpha3": "BLZ", "numeric": "084"},
+    {"name": "Canada", "alpha2": "CA", "alpha3": "CAN", "numeric": "124"},
+    {
+        "name": "Cocos (Keeling) Islands",
+        "alpha2": "CC",
+        "alpha3": "CCK",
+        "numeric": "166",
+    },
+    {
+        "name": "Congo, Democratic Republic of the",
+        "alpha2": "CD",
+        "alpha3": "COD",
+        "numeric": "180",
+    },
+    {
+        "name": "Central African Republic",
+        "alpha2": "CF",
+        "alpha3": "CAF",
+        "numeric": "140",
+    },
+    {"name": "Congo", "alpha2": "CG", "alpha3": "COG", "numeric": "178"},
+    {"name": "Switzerland", "alpha2": "CH", "alpha3": "CHE", "numeric": "756"},
+    {"name": "Côte d'Ivoire", "alpha2": "CI", "alpha3": "CIV", "numeric": "384"},
+    {"name": "Cook Islands", "alpha2": "CK", "alpha3": "COK", "numeric": "184"},
+    {"name": "Chile", "alpha2": "CL", "alpha3": "CHL", "numeric": "152"},
+    {"name": "Cameroon", "alpha2": "CM", "alpha3": "CMR", "numeric": "120"},
+    {"name": "China", "alpha2": "CN", "alpha3": "CHN", "numeric": "156"},
+    {"name": "Colombia", "alpha2": "CO", "alpha3": "COL", "numeric": "170"},
+    {"name": "Costa Rica", "alpha2": "CR", "alpha3": "CRI", "numeric": "188"},
+    {"name": "Cuba", "alpha2": "CU", "alpha3": "CUB", "numeric": "192"},
+    {"name": "Cabo Verde", "alpha2": "CV", "alpha3": "CPV", "numeric": "132"},
+    {"name": "Curaçao", "alpha2": "CW", "alpha3": "CUW", "numeric": "531"},
+    {"name": "Christmas Island", "alpha2": "CX", "alpha3": "CXR", "numeric": "162"},
+    {"name": "Cyprus", "alpha2": "CY", "alpha3": "CYP", "numeric": "196"},
+    {"name": "Czechia", "alpha2": "CZ", "alpha3": "CZE", "numeric": "203"},
+    {"name": "Germany", "alpha2": "DE", "alpha3": "DEU", "numeric": "276"},
+    {"name": "Djibouti", "alpha2": "DJ", "alpha3": "DJI", "numeric": "262"},
+    {"name": "Denmark", "alpha2": "DK", "alpha3": "DNK", "numeric": "208"},
+    {"name": "Dominica", "alpha2": "DM", "alpha3": "DMA", "numeric": "212"},
+    {"name": "Dominican Republic", "alpha2": "DO", "alpha3": "DOM", "numeric": "214"},
+    {"name": "Algeria", "alpha2": "DZ", "alpha3": "DZA", "numeric": "012"},
+    {"name": "Ecuador", "alpha2": "EC", "alpha3": "ECU", "numeric": "218"},
+    {"name": "Estonia", "alpha2": "EE", "alpha3": "EST", "numeric": "233"},
+    {"name": "Egypt", "alpha2": "EG", "alpha3": "EGY", "numeric": "818"},
+    {"name": "Western Sahara", "alpha2": "EH", "alpha3": "ESH", "numeric": "732"},
+    {"name": "Eritrea", "alpha2": "ER", "alpha3": "ERI", "numeric": "232"},
+    {"name": "Spain", "alpha2": "ES", "alpha3": "ESP", "numeric": "724"},
+    {"name": "Ethiopia", "alpha2": "ET", "alpha3": "ETH", "numeric": "231"},
+    {"name": "Finland", "alpha2": "FI", "alpha3": "FIN", "numeric": "246"},
+    {"name": "Fiji", "alpha2": "FJ", "alpha3": "FJI", "numeric": "242"},
+    {
+        "name": "Falkland Islands (Malvinas)",
+        "alpha2": "FK",
+        "alpha3": "FLK",
+        "numeric": "238",
+    },
+    {
+        "name": "Micronesia (Federated States of)",
+        "alpha2": "FM",
+        "alpha3": "FSM",
+        "numeric": "583",
+    },
+    {"name": "Faroe Islands", "alpha2": "FO", "alpha3": "FRO", "numeric": "234"},
+    {"name": "France", "alpha2": "FR", "alpha3": "FRA", "numeric": "250"},
+    {"name": "Gabon", "alpha2": "GA", "alpha3": "GAB", "numeric": "266"},
+    {
+        "name": "United Kingdom of Great Britain and Northern Ireland",
+        "alpha2": "GB",
+        "alpha3": "GBR",
+        "numeric": "826",
+    },
+    {"name": "Grenada", "alpha2": "GD", "alpha3": "GRD", "numeric": "308"},
+    {"name": "Georgia", "alpha2": "GE", "alpha3": "GEO", "numeric": "268"},
+    {"name": "French Guiana", "alpha2": "GF", "alpha3": "GUF", "numeric": "254"},
+    {"name": "Guernsey", "alpha2": "GG", "alpha3": "GGY", "numeric": "831"},
+    {"name": "Ghana", "alpha2": "GH", "alpha3": "GHA", "numeric": "288"},
+    {"name": "Gibraltar", "alpha2": "GI", "alpha3": "GIB", "numeric": "292"},
+    {"name": "Greenland", "alpha2": "GL", "alpha3": "GRL", "numeric": "304"},
+    {"name": "Gambia", "alpha2": "GM", "alpha3": "GMB", "numeric": "270"},
+    {"name": "Guinea", "alpha2": "GN", "alpha3": "GIN", "numeric": "324"},
+    {"name": "Guadeloupe", "alpha2": "GP", "alpha3": "GLP", "numeric": "312"},
+    {"name": "Equatorial Guinea", "alpha2": "GQ", "alpha3": "GNQ", "numeric": "226"},
+    {"name": "Greece", "alpha2": "GR", "alpha3": "GRC", "numeric": "300"},
+    {
+        "name": "South Georgia and the South Sandwich Islands",
+        "alpha2": "GS",
+        "alpha3": "SGS",
+        "numeric": "239",
+    },
+    {"name": "Guatemala", "alpha2": "GT", "alpha3": "GTM", "numeric": "320"},
+    {"name": "Guam", "alpha2": "GU", "alpha3": "GUM", "numeric": "316"},
+    {"name": "Guinea-Bissau", "alpha2": "GW", "alpha3": "GNB", "numeric": "624"},
+    {"name": "Guyana", "alpha2": "GY", "alpha3": "GUY", "numeric": "328"},
+    {"name": "Hong Kong", "alpha2": "HK", "alpha3": "HKG", "numeric": "344"},
+    {
+        "name": "Heard Island and McDonald Islands",
+        "alpha2": "HM",
+        "alpha3": "HMD",
+        "numeric": "334",
+    },
+    {"name": "Honduras", "alpha2": "HN", "alpha3": "HND", "numeric": "340"},
+    {"name": "Croatia", "alpha2": "HR", "alpha3": "HRV", "numeric": "191"},
+    {"name": "Haiti", "alpha2": "HT", "alpha3": "HTI", "numeric": "332"},
+    {"name": "Hungary", "alpha2": "HU", "alpha3": "HUN", "numeric": "348"},
+    {"name": "Indonesia", "alpha2": "ID", "alpha3": "IDN", "numeric": "360"},
+    {"name": "Ireland", "alpha2": "IE", "alpha3": "IRL", "numeric": "372"},
+    {"name": "Israel", "alpha2": "IL", "alpha3": "ISR", "numeric": "376"},
+    {"name": "Isle of Man", "alpha2": "IM", "alpha3": "IMN", "numeric": "833"},
+    {"name": "India", "alpha2": "IN", "alpha3": "IND", "numeric": "356"},
+    {
+        "name": "British Indian Ocean Territory",
+        "alpha2": "IO",
+        "alpha3": "IOT",
+        "numeric": "086",
+    },
+    {"name": "Iraq", "alpha2": "IQ", "alpha3": "IRQ", "numeric": "368"},
+    {
+        "name": "Iran (Islamic Republic of)",
+        "alpha2": "IR",
+        "alpha3": "IRN",
+        "numeric": "364",
+    },
+    {"name": "Iceland", "alpha2": "IS", "alpha3": "ISL", "numeric": "352"},
+    {"name": "Italy", "alpha2": "IT", "alpha3": "ITA", "numeric": "380"},
+    {"name": "Jersey", "alpha2": "JE", "alpha3": "JEY", "numeric": "832"},
+    {"name": "Jamaica", "alpha2": "JM", "alpha3": "JAM", "numeric": "388"},
+    {"name": "Jordan", "alpha2": "JO", "alpha3": "JOR", "numeric": "400"},
+    {"name": "Japan", "alpha2": "JP", "alpha3": "JPN", "numeric": "392"},
+    {"name": "Kenya", "alpha2": "KE", "alpha3": "KEN", "numeric": "404"},
+    {"name": "Kyrgyzstan", "alpha2": "KG", "alpha3": "KGZ", "numeric": "417"},
+    {"name": "Cambodia", "alpha2": "KH", "alpha3": "KHM", "numeric": "116"},
+    {"name": "Kiribati", "alpha2": "KI", "alpha3": "KIR", "numeric": "296"},
+    {"name": "Comoros", "alpha2": "KM", "alpha3": "COM", "numeric": "174"},
+    {
+        "name": "Saint Kitts and Nevis",
+        "alpha2": "KN",
+        "alpha3": "KNA",
+        "numeric": "659",
+    },
+    {
+        "name": "Korea (Democratic People's Republic of)",
+        "alpha2": "KP",
+        "alpha3": "PRK",
+        "numeric": "408",
+    },
+    {"name": "Korea, Republic of", "alpha2": "KR", "alpha3": "KOR", "numeric": "410"},
+    {"name": "Kuwait", "alpha2": "KW", "alpha3": "KWT", "numeric": "414"},
+    {"name": "Cayman Islands", "alpha2": "KY", "alpha3": "CYM", "numeric": "136"},
+    {"name": "Kazakhstan", "alpha2": "KZ", "alpha3": "KAZ", "numeric": "398"},
+    {
+        "name": "Lao People's Democratic Republic",
+        "alpha2": "LA",
+        "alpha3": "LAO",
+        "numeric": "418",
+    },
+    {"name": "Lebanon", "alpha2": "LB", "alpha3": "LBN", "numeric": "422"},
+    {"name": "Saint Lucia", "alpha2": "LC", "alpha3": "LCA", "numeric": "662"},
+    {"name": "Liechtenstein", "alpha2": "LI", "alpha3": "LIE", "numeric": "438"},
+    {"name": "Sri Lanka", "alpha2": "LK", "alpha3": "LKA", "numeric": "144"},
+    {"name": "Liberia", "alpha2": "LR", "alpha3": "LBR", "numeric": "430"},
+    {"name": "Lesotho", "alpha2": "LS", "alpha3": "LSO", "numeric": "426"},
+    {"name": "Lithuania", "alpha2": "LT", "alpha3": "LTU", "numeric": "440"},
+    {"name": "Luxembourg", "alpha2": "LU", "alpha3": "LUX", "numeric": "442"},
+    {"name": "Latvia", "alpha2": "LV", "alpha3": "LVA", "numeric": "428"},
+    {"name": "Libya", "alpha2": "LY", "alpha3": "LBY", "numeric": "434"},
+    {"name": "Morocco", "alpha2": "MA", "alpha3": "MAR", "numeric": "504"},
+    {"name": "Monaco", "alpha2": "MC", "alpha3": "MCO", "numeric": "492"},
+    {"name": "Moldova, Republic of", "alpha2": "MD", "alpha3": "MDA", "numeric": "498"},
+    {"name": "Montenegro", "alpha2": "ME", "alpha3": "MNE", "numeric": "499"},
+    {
+        "name": "Saint Martin (French part)",
+        "alpha2": "MF",
+        "alpha3": "MAF",
+        "numeric": "663",
+    },
+    {"name": "Madagascar", "alpha2": "MG", "alpha3": "MDG", "numeric": "450"},
+    {"name": "Marshall Islands", "alpha2": "MH", "alpha3": "MHL", "numeric": "584"},
+    {"name": "North Macedonia", "alpha2": "MK", "alpha3": "MKD", "numeric": "807"},
+    {"name": "Mali", "alpha2": "ML", "alpha3": "MLI", "numeric": "466"},
+    {"name": "Myanmar", "alpha2": "MM", "alpha3": "MMR", "numeric": "104"},
+    {"name": "Mongolia", "alpha2": "MN", "alpha3": "MNG", "numeric": "496"},
+    {"name": "Macao", "alpha2": "MO", "alpha3": "MAC", "numeric": "446"},
+    {
+        "name": "Northern Mariana Islands",
+        "alpha2": "MP",
+        "alpha3": "MNP",
+        "numeric": "580",
+    },
+    {"name": "Martinique", "alpha2": "MQ", "alpha3": "MTQ", "numeric": "474"},
+    {"name": "Mauritania", "alpha2": "MR", "alpha3": "MRT", "numeric": "478"},
+    {"name": "Montserrat", "alpha2": "MS", "alpha3": "MSR", "numeric": "500"},
+    {"name": "Malta", "alpha2": "MT", "alpha3": "MLT", "numeric": "470"},
+    {"name": "Mauritius", "alpha2": "MU", "alpha3": "MUS", "numeric": "480"},
+    {"name": "Maldives", "alpha2": "MV", "alpha3": "MDV", "numeric": "462"},
+    {"name": "Malawi", "alpha2": "MW", "alpha3": "MWI", "numeric": "454"},
+    {"name": "Mexico", "alpha2": "MX", "alpha3": "MEX", "numeric": "484"},
+    {"name": "Malaysia", "alpha2": "MY", "alpha3": "MYS", "numeric": "458"},
+    {"name": "Mozambique", "alpha2": "MZ", "alpha3": "MOZ", "numeric": "508"},
+    {"name": "Namibia", "alpha2": "NA", "alpha3": "NAM", "numeric": "516"},
+    {"name": "New Caledonia", "alpha2": "NC", "alpha3": "NCL", "numeric": "540"},
+    {"name": "Niger", "alpha2": "NE", "alpha3": "NER", "numeric": "562"},
+    {"name": "Norfolk Island", "alpha2": "NF", "alpha3": "NFK", "numeric": "574"},
+    {"name": "Nigeria", "alpha2": "NG", "alpha3": "NGA", "numeric": "566"},
+    {"name": "Nicaragua", "alpha2": "NI", "alpha3": "NIC", "numeric": "558"},
+    {
+        "name": "Netherlands, Kingdom of the",
+        "alpha2": "NL",
+        "alpha3": "NLD",
+        "numeric": "528",
+    },
+    {"name": "Norway", "alpha2": "NO", "alpha3": "NOR", "numeric": "578"},
+    {"name": "Nepal", "alpha2": "NP", "alpha3": "NPL", "numeric": "524"},
+    {"name": "Nauru", "alpha2": "NR", "alpha3": "NRU", "numeric": "520"},
+    {"name": "Niue", "alpha2": "NU", "alpha3": "NIU", "numeric": "570"},
+    {"name": "New Zealand", "alpha2": "NZ", "alpha3": "NZL", "numeric": "554"},
+    {"name": "Oman", "alpha2": "OM", "alpha3": "OMN", "numeric": "512"},
+    {"name": "Panama", "alpha2": "PA", "alpha3": "PAN", "numeric": "591"},
+    {"name": "Peru", "alpha2": "PE", "alpha3": "PER", "numeric": "604"},
+    {"name": "French Polynesia", "alpha2": "PF", "alpha3": "PYF", "numeric": "258"},
+    {"name": "Papua New Guinea", "alpha2": "PG", "alpha3": "PNG", "numeric": "598"},
+    {"name": "Philippines", "alpha2": "PH", "alpha3": "PHL", "numeric": "608"},
+    {"name": "Pakistan", "alpha2": "PK", "alpha3": "PAK", "numeric": "586"},
+    {"name": "Poland", "alpha2": "PL", "alpha3": "POL", "numeric": "616"},
+    {
+        "name": "Saint Pierre and Miquelon",
+        "alpha2": "PM",
+        "alpha3": "SPM",
+        "numeric": "666",
+    },
+    {"name": "Pitcairn", "alpha2": "PN", "alpha3": "PCN", "numeric": "612"},
+    {"name": "Puerto Rico", "alpha2": "PR", "alpha3": "PRI", "numeric": "630"},
+    {"name": "Palestine, State of", "alpha2": "PS", "alpha3": "PSE", "numeric": "275"},
+    {"name": "Portugal", "alpha2": "PT", "alpha3": "PRT", "numeric": "620"},
+    {"name": "Palau", "alpha2": "PW", "alpha3": "PLW", "numeric": "585"},
+    {"name": "Paraguay", "alpha2": "PY", "alpha3": "PRY", "numeric": "600"},
+    {"name": "Qatar", "alpha2": "QA", "alpha3": "QAT", "numeric": "634"},
+    {"name": "Réunion", "alpha2": "RE", "alpha3": "REU", "numeric": "638"},
+    {"name": "Romania", "alpha2": "RO", "alpha3": "ROU", "numeric": "642"},
+    {"name": "Serbia", "alpha2": "RS", "alpha3": "SRB", "numeric": "688"},
+    {"name": "Russian Federation", "alpha2": "RU", "alpha3": "RUS", "numeric": "643"},
+    {"name": "Rwanda", "alpha2": "RW", "alpha3": "RWA", "numeric": "646"},
+    {"name": "Saudi Arabia", "alpha2": "SA", "alpha3": "SAU", "numeric": "682"},
+    {"name": "Solomon Islands", "alpha2": "SB", "alpha3": "SLB", "numeric": "090"},
+    {"name": "Seychelles", "alpha2": "SC", "alpha3": "SYC", "numeric": "690"},
+    {"name": "Sudan", "alpha2": "SD", "alpha3": "SDN", "numeric": "729"},
+    {"name": "Sweden", "alpha2": "SE", "alpha3": "SWE", "numeric": "752"},
+    {"name": "Singapore", "alpha2": "SG", "alpha3": "SGP", "numeric": "702"},
+    {
+        "name": "Saint Helena, Ascension and Tristan da Cunha",
+        "alpha2": "SH",
+        "alpha3": "SHN",
+        "numeric": "654",
+    },
+    {"name": "Slovenia", "alpha2": "SI", "alpha3": "SVN", "numeric": "705"},
+    {
+        "name": "Svalbard and Jan Mayen",
+        "alpha2": "SJ",
+        "alpha3": "SJM",
+        "numeric": "744",
+    },
+    {"name": "Slovakia", "alpha2": "SK", "alpha3": "SVK", "numeric": "703"},
+    {"name": "Sierra Leone", "alpha2": "SL", "alpha3": "SLE", "numeric": "694"},
+    {"name": "San Marino", "alpha2": "SM", "alpha3": "SMR", "numeric": "674"},
+    {"name": "Senegal", "alpha2": "SN", "alpha3": "SEN", "numeric": "686"},
+    {"name": "Somalia", "alpha2": "SO", "alpha3": "SOM", "numeric": "706"},
+    {"name": "Suriname", "alpha2": "SR", "alpha3": "SUR", "numeric": "740"},
+    {"name": "South Sudan", "alpha2": "SS", "alpha3": "SSD", "numeric": "728"},
+    {
+        "name": "Sao Tome and Principe",
+        "alpha2": "ST",
+        "alpha3": "STP",
+        "numeric": "678",
+    },
+    {"name": "El Salvador", "alpha2": "SV", "alpha3": "SLV", "numeric": "222"},
+    {
+        "name": "Sint Maarten (Dutch part)",
+        "alpha2": "SX",
+        "alpha3": "SXM",
+        "numeric": "534",
+    },
+    {"name": "Syrian Arab Republic", "alpha2": "SY", "alpha3": "SYR", "numeric": "760"},
+    {"name": "Eswatini", "alpha2": "SZ", "alpha3": "SWZ", "numeric": "748"},
+    {
+        "name": "Turks and Caicos Islands",
+        "alpha2": "TC",
+        "alpha3": "TCA",
+        "numeric": "796",
+    },
+    {"name": "Chad", "alpha2": "TD", "alpha3": "TCD", "numeric": "148"},
+    {
+        "name": "French Southern Territories",
+        "alpha2": "TF",
+        "alpha3": "ATF",
+        "numeric": "260",
+    },
+    {"name": "Togo", "alpha2": "TG", "alpha3": "TGO", "numeric": "768"},
+    {"name": "Thailand", "alpha2": "TH", "alpha3": "THA", "numeric": "764"},
+    {"name": "Tajikistan", "alpha2": "TJ", "alpha3": "TJK", "numeric": "762"},
+    {"name": "Tokelau", "alpha2": "TK", "alpha3": "TKL", "numeric": "772"},
+    {"name": "Timor-Leste", "alpha2": "TL", "alpha3": "TLS", "numeric": "626"},
+    {"name": "Turkmenistan", "alpha2": "TM", "alpha3": "TKM", "numeric": "795"},
+    {"name": "Tunisia", "alpha2": "TN", "alpha3": "TUN", "numeric": "788"},
+    {"name": "Tonga", "alpha2": "TO", "alpha3": "TON", "numeric": "776"},
+    {"name": "Türkiye", "alpha2": "TR", "alpha3": "TUR", "numeric": "792"},
+    {"name": "Trinidad and Tobago", "alpha2": "TT", "alpha3": "TTO", "numeric": "780"},
+    {"name": "Tuvalu", "alpha2": "TV", "alpha3": "TUV", "numeric": "798"},
+    {
+        "name": "Taiwan, Province of China",
+        "alpha2": "TW",
+        "alpha3": "TWN",
+        "numeric": "158",
+    },
+    {
+        "name": "Tanzania, United Republic of",
+        "alpha2": "TZ",
+        "alpha3": "TZA",
+        "numeric": "834",
+    },
+    {"name": "Ukraine", "alpha2": "UA", "alpha3": "UKR", "numeric": "804"},
+    {"name": "Uganda", "alpha2": "UG", "alpha3": "UGA", "numeric": "800"},
+    {
+        "name": "United States Minor Outlying Islands",
+        "alpha2": "UM",
+        "alpha3": "UMI",
+        "numeric": "581",
+    },
+    {
+        "name": "United States of America",
+        "alpha2": "US",
+        "alpha3": "USA",
+        "numeric": "840",
+    },
+    {"name": "Uruguay", "alpha2": "UY", "alpha3": "URY", "numeric": "858"},
+    {"name": "Uzbekistan", "alpha2": "UZ", "alpha3": "UZB", "numeric": "860"},
+    {"name": "Holy See", "alpha2": "VA", "alpha3": "VAT", "numeric": "336"},
+    {
+        "name": "Saint Vincent and the Grenadines",
+        "alpha2": "VC",
+        "alpha3": "VCT",
+        "numeric": "670",
+    },
+    {
+        "name": "Venezuela (Bolivarian Republic of)",
+        "alpha2": "VE",
+        "alpha3": "VEN",
+        "numeric": "862",
+    },
+    {
+        "name": "Virgin Islands (British)",
+        "alpha2": "VG",
+        "alpha3": "VGB",
+        "numeric": "092",
+    },
+    {
+        "name": "Virgin Islands (U.S.)",
+        "alpha2": "VI",
+        "alpha3": "VIR",
+        "numeric": "850",
+    },
+    {"name": "Viet Nam", "alpha2": "VN", "alpha3": "VNM", "numeric": "704"},
+    {"name": "Vanuatu", "alpha2": "VU", "alpha3": "VUT", "numeric": "548"},
+    {"name": "Wallis and Futuna", "alpha2": "WF", "alpha3": "WLF", "numeric": "876"},
+    {"name": "Samoa", "alpha2": "WS", "alpha3": "WSM", "numeric": "882"},
+    {"name": "Yemen", "alpha2": "YE", "alpha3": "YEM", "numeric": "887"},
+    {"name": "Mayotte", "alpha2": "YT", "alpha3": "MYT", "numeric": "175"},
+    {"name": "South Africa", "alpha2": "ZA", "alpha3": "ZAF", "numeric": "710"},
+    {"name": "Zambia", "alpha2": "ZM", "alpha3": "ZMB", "numeric": "894"},
+    {"name": "Zimbabwe", "alpha2": "ZW", "alpha3": "ZWE", "numeric": "716"},
+]

okta_expression_parser-0.2.0/okta_expression_parser/expression_classes/string.py

@@ -0,0 +1,111 @@
+from typing import Tuple
+
+
+class String:
+    @classmethod
+    def stringContains(cls, str_to_test: str, val: str):
+        """Tests if a string contains another string"""
+        res = (
+            isinstance(str_to_test, str) and isinstance(val, str) and val in str_to_test
+        )
+        return res
+
+    @classmethod
+    def startsWith(self, str_to_test: str, val: str):
+        """Tests if a string starts with another string"""
+        return (
+            isinstance(str_to_test, str)
+            and isinstance(val, str)
+            and str_to_test.startswith(val)
+        )
+
+    @classmethod
+    def toLowerCase(self, val: str):
+        """Casts to lower case"""
+        if isinstance(val, str):
+            return val.lower()
+
+        return val
+
+    @classmethod
+    def toUpperCase(self, val: str):
+        """Casts to upper case"""
+        if isinstance(val, str):
+            return val.upper()
+        return val
+
+    @classmethod
+    def append(self, val1: str, val2: str):
+        """Concatenates two strings"""
+        return f"{val1}${val2}"
+
+    @classmethod
+    def join(self, separator: str, *vals: Tuple[str]):
+        """Returns a joined string using separator"""
+        return separator.join(list(vals))
+
+    @classmethod
+    def removeSpaces(self, val: str):
+        """Removes spaces from a string"""
+        return str(val).replace(" ", "")
+
+    @classmethod
+    def replace(self, val: str, match: str, replacement: str):
+        """Replace all occurances of match with replacement in val"""
+        return str(val).replace(match, replacement)
+
+    @classmethod
+    def replaceFirst(self, val: str, match: str, replacement: str):
+        """Replace first occurance of match with replacement in val"""
+        return str(val).replace(match, replacement, 1)
+
+    @classmethod
+    def startsWith(self, val: str, test: str):
+        """Returns whether val starts with test"""
+        return str(val).startswith(test)
+
+    @classmethod
+    def contains(self, val: str, test: str):
+        """Return whether val contains test"""
+        return str(test) in str(val)
+
+    @classmethod
+    def stringSwitch(self, val: str, default: str, *kv_pairs: Tuple[str]):
+        """Set defaultss"""
+        if len(kv_pairs) % 2 != 0:
+            return False
+
+        kv_pairs = list(kv_pairs)
+
+        while kv_pairs:
+            k = kv_pairs.pop(0)
+            v = kv_pairs.pop(0)
+
+            if k in val:
+                return v
+
+        return default
+
+    @classmethod
+    def substring(val: str, start: int, end: int):
+        """Return a substring of val starting at index start"""
+        return val[int(start) : int(end)]
+
+    @classmethod
+    def substringAfter(val: str, search: str):
+        try:
+            start = str(val).index(str(search))
+        except ValueError:
+            return val
+
+        return val[start:]
+
+    @classmethod
+    def substringBefore(val: str, search: str):
+        """Return substring of val starting after the index of search string"""
+        try:
+            end = str(val).index(str(search))
+        except ValueError:
+            return val
+
+        return val[0:end]

okta_expression_parser-0.2.0/okta_expression_parser/lexer.py

@@ -0,0 +1,68 @@
+# pyright: reportUndefinedVariable=false
+from sly import Lexer
+
+
+class SyntaxError(Exception):
+    pass
+
+
+class ExpressionLexer(Lexer):
+    # reflags = re.IGNORECASE
+    # Set of token names.
+    tokens = {
+        STRING,
+        INT,
+        NAME,
+        NE,
+        GTE,
+        LTE,
+        GT,
+        LT,
+        EQ,
+        AND,
+        OR,
+        NOT,
+        NULL,
+        BOOL,
+        MEMBEROF,
+        MEMBEROFANY,
+        USER,
+        CLASS,
+    }
+
+    # Set of literal characters
+    literals = {"(", ")", ",", ".", "{", "}"}
+
+    # String containing ignored characters
+    ignore = " \t"
+
+    AND = r"and|And|AND"
+    NE = r"(!=|ne|NE|Ne)"
+    NOT = r"!|not|Not|NOT"
+    GTE = ">="
+    GT = ">"
+    LT = "<"
+    LTE = "<="
+    OR = r"or|OR|Or"
+    EQ = r"(==|eq|EQ|Eq)"
+    BOOL = r"(true|false|True|False|TRUE|FALSE)"
+    MEMBEROFANY = "isMemberOfAnyGroup"
+    MEMBEROF = "isMemberOfGroup"
+    USER = r"user\b"
+
+    NULL = r"null|NULL|Null"
+    CLASS = r"String|Arrays|Convert|Iso3166Convert|Groups"
+    INT = r"\d+"
+    STRING = r""""([^"\\]*(\\.[^"\\]*)*)"|\'([^\'\\]*(\\.[^\'\\]*)*)\'|''|\"\""""
+    NAME = r"[a-zA-Z_][a-zA-Z0-9\-_]*"
+
+    # Line number tracking
+    @_(r"\n+")
+    def ignore_newline(self, t):
+        self.lineno += t.value.count("\n")
+
+    def error(self, t):
+        msg = (
+            f"Bad character '{t.value[0]}' at line {self.lineno} character {self.index}"
+        )
+        raise SyntaxError(msg)

okta_expression_parser-0.2.0/okta_expression_parser/parser.py

@@ -0,0 +1,316 @@
+# pyright: reportUndefinedVariable=false
+import logging
+from os import environ
+from sys import stdout
+from typing import Any, Dict, List, Sequence
+from types import ModuleType
+
+import sly
+from sly.yacc import YaccProduction
+
+from . import expression_classes as _default_expression_classes
+from .expression_classes.arrays import _ArrayType
+from .lexer import ExpressionLexer
+
+
+class ExpressionParser(sly.Parser):
+    if debug_file := environ.get("OKTA_EXPRESSION_PARSER_LOG_FILE"):
+        #: Writes grammar rules to a file for debugging
+        debugfile: str = environ.get(debug_file)
+
+    #: Gets the token list from the lexer (required)
+    tokens: Sequence = ExpressionLexer.tokens
+
+    #: Defines precendence of operators
+    precedence = (
+        ("left", OR),  # noqa: 821
+        ("left", AND),  # noqa: 821
+        ("right", NOT),  # noqa: 821
+        ("nonassoc", EQ, NE),  # noqa: 821
+    )
+
+    def __init__(
+        self,
+        group_ids: List[str] = [],
+        user_profile: Dict[str, Any] = {},
+        log_to_stdout: bool = False,
+        log_level: str = "INFO",
+        expression_classes: ModuleType = _default_expression_classes,
+        group_data: dict = {},
+    ) -> None:
+        #: A module containing classes used in expressions, such as `Arrays` or `String`
+        self._expression_classes = expression_classes
+
+        # Required for doing translations between group ID's and other group attributes.
+        # Without passing group_data into the parser all `Group` methods will return empty
+        if (
+            group_data
+            and hasattr(self._expression_classes, "Groups")
+            and type(self._expression_classes.Groups) == type
+        ):
+            self._expression_classes.Groups.group_data = group_data
+
+        self.group_data = group_data
+
+        self.__group_ids: str = group_ids
+        self.__user_profile: str = user_profile
+        self.logger: logging.Logger = logging.getLogger()
+
+        self.logger.setLevel(log_level)
+
+        if log_to_stdout:
+            self.logger.addHandler(logging.StreamHandler(stream=stdout))
+
+    def parse(self, expression: str):
+        return super().parse(ExpressionLexer().tokenize(expression))
+
+    @_("operand EQ operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:
+        operand0 = p.operand0
+        operand1 = p.operand1
+        return operand0 == operand1
+
+    @_("path EQ operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:
+        path = p.path
+        value = p.operand
+
+        return path == value
+
+    @_("operand NE operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        operand0 = p.operand0
+        operand1 = p.operand1
+        return operand0 != operand1
+
+    @_("operand GTE operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        operand0 = p.operand0
+        operand1 = p.operand1
+        return type(operand0) == type(operand1) and operand0 >= operand1
+
+    @_("operand LTE operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        operand0 = p.operand0
+        operand1 = p.operand1
+        return type(operand0) == type(operand1) and operand0 <= operand1
+
+    @_("operand LT operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        operand0 = p.operand0
+        operand1 = p.operand1
+        return type(operand0) == type(operand1) and operand0 < operand1
+
+    @_("operand GT operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        operand0 = p.operand0
+        operand1 = p.operand1
+        return type(operand0) == type(operand1) and operand0 > operand1
+
+    @_("condition AND condition")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        condition0 = p.condition0
+        condition1 = p.condition1
+        return condition0 and condition1
+
+    @_("condition OR condition")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        condition0 = p.condition0
+        condition1 = p.condition1
+        return condition0 or condition1
+
+    @_("NOT condition")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        condition = p.condition
+        return not condition
+
+    @_("NOT operand")  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        return not p.operand
+
+    @_('"(" condition ")"')  # noqa: 821
+    def condition(self, p: YaccProduction) -> bool:  # noqa: 811
+        condition = p.condition
+        return condition
+
+    @_('operand "," operand')  # noqa: 821
+    def operand(self, p: YaccProduction) -> List[Any]:  # noqa: 811
+        operand0 = p.operand0
+        operand1 = p.operand1
+
+        # if not isinstance(operand0, tuple):
+        #    return (operand0, operand1)
+        #
+        # else:
+        #    return operand0 + (operand1,)
+
+        if isinstance(operand0, tuple) and isinstance(operand1, tuple):
+            res = operand0 + operand1
+        elif isinstance(operand0, tuple) and not isinstance(operand1, tuple):
+            res = operand0 + (operand1,)
+        elif not isinstance(operand0, tuple) and isinstance(operand1, tuple):
+            res = (operand0,) + operand1
+        else:
+            res = (operand0, operand1)
+        return res
+
+    @_("NULL")
+    def operand(self, p: YaccProduction) -> None:
+        return None
+
+    @_("INT")  # noqa: 821
+    def operand(self, p: YaccProduction) -> int:  # noqa: 811
+        return int(p.INT)
+
+    @_("BOOL")
+    def operand(self, p: YaccProduction) -> bool:
+        val = p.BOOL.lower()
+        return val == "true"
+
+    @_("array")
+    def operand(self, p: YaccProduction) -> List[Any]:
+        return _ArrayType(p.array)
+
+    @_('"{" operand "}"')
+    def array(self, p: YaccProduction) -> List[Any]:
+        if isinstance(p.operand, Sequence):
+            return _ArrayType(p.operand)
+
+        return _ArrayType([p.operand])
+
+    @_('array "," operand')
+    def operand(self, p: YaccProduction) -> List[Any]:
+        # if isinstance(p.operand, tuple):
+
+        if isinstance(p.operand, tuple):
+            return (p.array,) + p.operand
+
+        return (p.array, p.operand)
+
+    @_("STRING")  # noqa: 821
+    def operand(self, p: YaccProduction) -> str:  # noqa: 811
+        val = p.STRING
+        if val.startswith('"'):
+            val = val[1:-1]
+
+        return val
+
+    @_("path")  # noqa: 821
+    def operand(self, p: YaccProduction) -> Any:  # noqa: 811
+        return p.path
+
+    @_("USER")
+    def path(self, _) -> Dict[str, Any]:
+        return self.__user_profile
+
+    @_("NAME")  # noqa: 821
+    def path(self, p: YaccProduction) -> Any:  # noqa: 811
+        NAME = p.NAME
+
+        if not hasattr(p, "path"):
+            path = {}
+
+        return path.get(NAME) if path is not None else None
+
+    @_('path "." NAME')  # noqa: 821
+    def operand(self, p: YaccProduction) -> Any:  # noqa: 811
+        path = p.path
+        NAME = p.NAME
+
+        if isinstance(path, dict):
+            res = path.get(NAME)
+        else:
+            res = path
+
+        if isinstance(res, str):
+            res = res.replace('"', "")
+
+        return res
+
+    @_("cls")
+    def operand(self, p: YaccProduction) -> Any:
+        """
+        Returns a class from `self._expression_classes`
+        """
+        return p.cls
+
+    @_("CLASS")
+    def cls(self, p: YaccProduction) -> type:
+        """Returns a class from `self._expression_classes`"""
+
+        try:
+            return getattr(self._expression_classes, p.CLASS)
+        except AttributeError:
+            raise NotImplemented(
+                f"Class {p.CLASS} has not been implemented in the parser"
+            )
+
+    @_('cls "." NAME "(" operand ")"')
+    @_('cls "." NAME "(" path ")"')
+    def operand(self, p: YaccProduction) -> Any:
+        """Calls a method from `cls`, which is a class from `self._expression_classes`"""
+        method = getattr(p.cls, p.NAME)
+
+        if hasattr(p, "operand"):
+            val = p.operand
+        else:
+            val = p.path
+
+        if isinstance(val, tuple):
+            res = method(*val)
+
+        else:
+            res = method(val)
+
+        return res
+
+    @_('cls "." NAME "(" operand ")"')
+    @_('cls "." NAME "(" path ")"')
+    def condition(self, p: YaccProduction) -> bool:
+        """Calls a method from `cls`, which is a class from `self._expression_classes`"""
+        method = getattr(p.cls, p.NAME)
+
+        if hasattr(p, "operand"):
+            val = p.operand
+        else:
+            val = p.path
+
+        if isinstance(val, tuple):
+            res = method(*val)
+
+        else:
+            res = method(val)
+
+        return res
+
+    @_('MEMBEROFANY "(" operand ")"')
+    def condition(self, p: YaccProduction):
+        """
+        Tests if a user is a member of one or many groups
+        """
+        if not self.__group_ids:
+            return False
+
+        val = p.operand
+        if not isinstance(val, list):
+            val = [val]
+
+        res = list(set(self.__group_ids) & set(val))
+
+        return bool(res)
+
+    @_('MEMBEROF "(" operand ")"')
+    def condition(self, p: YaccProduction):
+        """Tests if a user is a member of a specific group"""
+
+        if not self.__group_ids:
+            return False
+
+        # return p.operand.lower() in self.__group_ids
+        return p.operand in self.__group_ids
+
+    @_("condition error")  # noqa: 821
+    def operand(self, x):  # noqa: 811
+        raise SyntaxError(
+            f"Unexpected token '{x.error.value}' on line {x.error.lineno}"
+        )

okta_expression_parser-0.2.0/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "okta-expression-parser"
+version = "0.2.0"
+description = "Returns a boolean by passing Okta profile data to an Okta Expression using Okta Expression Language"
+authors = ["Mathew Moon <me@mathewmoon.net>"]
+readme = "README.md"
+packages = [{include = "okta_expression_parser", from = "."}]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+sly = "^0.5"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "7.4.3"
+
+[tool.pytest.ini_options]
+xfail_strict = true
+
+[build-system]
+requires = ["poetry-core>=1.7.0"]
+build-backend = "poetry.core.masonry.api"