readable-regex 0.2.0__py3-none-any.whl

readable_regex/__init__.py

@@ -0,0 +1,5 @@
+from readable_regex.builder import RegexBuilder
+
+regex = RegexBuilder()
+
+__all__ = ["regex", "RegexBuilder"]

readable_regex/builder.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import re
+from typing import Sequence
+
+from readable_regex.compiler import compile_components
+from readable_regex.components import (
+    Anchor,
+    AnchorType,
+    AnyOf,
+    CharClass,
+    CharClassType,
+    Component,
+    ExcludeFilter,
+    Group,
+    Literal,
+    Quantifier,
+    QuantifierKind,
+)
+from readable_regex.exclude_proxy import ExcludeProxy
+from readable_regex.flags import Flag, flags_to_re
+
+
+class RegexBuilder:
+    def __init__(
+        self,
+        components: tuple[Component, ...] = (),
+        flags: frozenset[Flag] = frozenset(),
+    ) -> None:
+        self._components = components
+        self._flags = flags
+        self._compiled: re.Pattern[str] | None = None
+
+    def _extend(self, *new_components: Component) -> RegexBuilder:
+        return RegexBuilder(self._components + new_components, self._flags)
+
+    def _with_flag(self, flag: Flag) -> RegexBuilder:
+        return RegexBuilder(self._components, self._flags | {flag})
+
+    def _quantify_last(self, kind: QuantifierKind, **kwargs: int | None) -> RegexBuilder:
+        if not self._components:
+            raise ValueError("No component to quantify")
+        last = self._components[-1]
+        quantified = Quantifier(last, kind, **kwargs)
+        return RegexBuilder(self._components[:-1] + (quantified,), self._flags)
+
+    # ── Anchors & Literals ──────────────────────────────────────────
+
+    def starts_with(self, text: str | None = None) -> RegexBuilder:
+        parts: list[Component] = [Anchor(AnchorType.START)]
+        if text is not None:
+            parts.append(Literal(text))
+        return self._extend(*parts)
+
+    def ends_with(self, text: str | None = None) -> RegexBuilder:
+        parts: list[Component] = []
+        if text is not None:
+            parts.append(Literal(text))
+        parts.append(Anchor(AnchorType.END))
+        return self._extend(*parts)
+
+    def then(self, text: str) -> RegexBuilder:
+        return self._extend(Literal(text))
+
+    # ── Character Classes (singular = one) ──────────────────────────
+
+    @property
+    def digit(self) -> RegexBuilder:
+        return self._extend(CharClass(CharClassType.DIGIT))
+
+    @property
+    def word(self) -> RegexBuilder:
+        return self._extend(CharClass(CharClassType.WORD))
+
+    @property
+    def whitespace(self) -> RegexBuilder:
+        return self._extend(CharClass(CharClassType.WHITESPACE))
+
+    @property
+    def any_char(self) -> RegexBuilder:
+        return self._extend(CharClass(CharClassType.ANY))
+
+    @property
+    def letter(self) -> RegexBuilder:
+        return self._extend(CharClass(CharClassType.LETTER))
+
+    # ── Character Classes (plural = one or more) ────────────────────
+
+    @property
+    def digits(self) -> RegexBuilder:
+        cc = CharClass(CharClassType.DIGIT)
+        return self._extend(Quantifier(cc, QuantifierKind.ONE_OR_MORE))
+
+    @property
+    def words(self) -> RegexBuilder:
+        cc = CharClass(CharClassType.WORD)
+        return self._extend(Quantifier(cc, QuantifierKind.ONE_OR_MORE))
+
+    @property
+    def whitespaces(self) -> RegexBuilder:
+        cc = CharClass(CharClassType.WHITESPACE)
+        return self._extend(Quantifier(cc, QuantifierKind.ONE_OR_MORE))
+
+    @property
+    def any_chars(self) -> RegexBuilder:
+        cc = CharClass(CharClassType.ANY)
+        return self._extend(Quantifier(cc, QuantifierKind.ONE_OR_MORE))
+
+    @property
+    def letters(self) -> RegexBuilder:
+        cc = CharClass(CharClassType.LETTER)
+        return self._extend(Quantifier(cc, QuantifierKind.ONE_OR_MORE))
+
+    # ── Combinators ─────────────────────────────────────────────────
+
+    def any_of(self, *options: str) -> RegexBuilder:
+        return self._extend(AnyOf(options))
+
+    def capture(self, content: RegexBuilder) -> RegexBuilder:
+        return self._extend(Group(content._components))
+
+    # ── Quantifiers (modify last component) ─────────────────────────
+
+    def exactly(self, n: int) -> RegexBuilder:
+        return self._quantify_last(QuantifierKind.EXACT, count=n)
+
+    def between(self, min_n: int, max_n: int) -> RegexBuilder:
+        return self._quantify_last(QuantifierKind.RANGE, min_count=min_n, max_count=max_n)
+
+    @property
+    def optional(self) -> RegexBuilder:
+        return self._quantify_last(QuantifierKind.OPTIONAL)
+
+    @property
+    def zero_or_more(self) -> RegexBuilder:
+        return self._quantify_last(QuantifierKind.ZERO_OR_MORE)
+
+    @property
+    def one_or_more(self) -> RegexBuilder:
+        return self._quantify_last(QuantifierKind.ONE_OR_MORE)
+
+    # ── Exclude ─────────────────────────────────────────────────────
+
+    @property
+    def exclude(self) -> ExcludeProxy:
+        """As property: returns proxy for negated classes.
+        e.g., regex.exclude.digits → \\D+
+        """
+        return ExcludeProxy(self)
+
+    def excluding(self, chars: str) -> RegexBuilder:
+        """Filters characters from the last char class component.
+        e.g., regex.words.excluding('_') → [^\\W_]+
+        """
+        if not self._components:
+            raise ValueError("No component to filter")
+
+        last = self._components[-1]
+
+        # If last is a quantified char class, unwrap, filter, re-wrap
+        if isinstance(last, Quantifier) and isinstance(last.target, CharClass):
+            filtered = ExcludeFilter(last.target.class_type, chars)
+            new_last = Quantifier(filtered, last.kind, last.count, last.min_count, last.max_count)
+            return RegexBuilder(self._components[:-1] + (new_last,), self._flags)
+
+        if isinstance(last, CharClass):
+            filtered = ExcludeFilter(last.class_type, chars)
+            return RegexBuilder(self._components[:-1] + (filtered,), self._flags)
+
+        raise ValueError("excluding() can only be applied to a character class")
+
+    # ── Flags ───────────────────────────────────────────────────────
+
+    @property
+    def ignore_case(self) -> RegexBuilder:
+        return self._with_flag(Flag.IGNORE_CASE)
+
+    @property
+    def multiline(self) -> RegexBuilder:
+        return self._with_flag(Flag.MULTILINE)
+
+    # ── Compilation & Execution ─────────────────────────────────────
+
+    @property
+    def pattern(self) -> str:
+        return compile_components(self._components)
+
+    def compile(self) -> re.Pattern[str]:
+        if self._compiled is None:
+            self._compiled = re.compile(self.pattern, flags_to_re(self._flags))
+        return self._compiled
+
+    def search(self, text: str) -> re.Match[str] | None:
+        return self.compile().search(text)
+
+    def match(self, text: str) -> re.Match[str] | None:
+        return self.compile().match(text)
+
+    def find_all(self, text: str) -> list[str]:
+        return self.compile().findall(text)
+
+    def replace(self, text: str, repl: str) -> str:
+        return self.compile().sub(repl, text)
+
+    def split(self, text: str) -> list[str]:
+        return self.compile().split(text)
+
+    def test(self, text: str) -> bool:
+        return self.compile().search(text) is not None

readable_regex/compiler.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+from readable_regex.components import Component
+
+
+def compile_components(components: Sequence[Component]) -> str:
+    return "".join(c.compile() for c in components)

readable_regex/components.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import re
+from enum import Enum
+from typing import Protocol, Sequence
+
+
+class Component(Protocol):
+    def compile(self) -> str: ...
+
+
+class Literal:
+    def __init__(self, text: str) -> None:
+        self.text = text
+
+    def compile(self) -> str:
+        return re.escape(self.text)
+
+
+class AnchorType(Enum):
+    START = "^"
+    END = "$"
+
+
+class Anchor:
+    def __init__(self, anchor_type: AnchorType) -> None:
+        self.anchor_type = anchor_type
+
+    def compile(self) -> str:
+        return self.anchor_type.value
+
+
+class CharClassType(Enum):
+    DIGIT = r"\d"
+    WORD = r"\w"
+    WHITESPACE = r"\s"
+    ANY = "."
+    LETTER = "[a-zA-Z]"
+
+
+NEGATED_MAP = {
+    CharClassType.DIGIT: r"\D",
+    CharClassType.WORD: r"\W",
+    CharClassType.WHITESPACE: r"\S",
+    CharClassType.ANY: r"[^\s\S]",  # negation of . (nothing matches)
+    CharClassType.LETTER: r"[^a-zA-Z]",
+}
+
+
+class CharClass:
+    def __init__(self, class_type: CharClassType) -> None:
+        self.class_type = class_type
+
+    def compile(self) -> str:
+        return self.class_type.value
+
+
+class NegatedCharClass:
+    def __init__(self, class_type: CharClassType) -> None:
+        self.class_type = class_type
+
+    def compile(self) -> str:
+        return NEGATED_MAP[self.class_type]
+
+
+class AnyOf:
+    def __init__(self, items: Sequence[str]) -> None:
+        self.items = list(items)
+
+    def compile(self) -> str:
+        if all(len(item) == 1 for item in self.items):
+            escaped = "".join(re.escape(ch) for ch in self.items)
+            return f"[{escaped}]"
+        escaped_items = [re.escape(item) for item in self.items]
+        return f"(?:{'|'.join(escaped_items)})"
+
+
+class Group:
+    def __init__(self, content: Sequence[Component]) -> None:
+        self.content = list(content)
+
+    def compile(self) -> str:
+        from readable_regex.compiler import compile_components
+
+        inner = compile_components(self.content)
+        return f"({inner})"
+
+
+class QuantifierKind(Enum):
+    ONE_OR_MORE = "+"
+    ZERO_OR_MORE = "*"
+    OPTIONAL = "?"
+    EXACT = "exact"
+    RANGE = "range"
+
+
+class Quantifier:
+    def __init__(
+        self,
+        target: Component,
+        kind: QuantifierKind,
+        count: int | None = None,
+        min_count: int | None = None,
+        max_count: int | None = None,
+    ) -> None:
+        self.target = target
+        self.kind = kind
+        self.count = count
+        self.min_count = min_count
+        self.max_count = max_count
+
+    def compile(self) -> str:
+        inner = self.target.compile()
+        needs_wrap = (
+            len(inner) > 1
+            and not isinstance(self.target, (CharClass, NegatedCharClass, Group))
+            and not (inner.startswith("(") and inner.endswith(")"))
+            and not (inner.startswith("[") and inner.endswith("]"))
+        )
+        if needs_wrap:
+            inner = f"(?:{inner})"
+
+        if self.kind == QuantifierKind.EXACT:
+            return f"{inner}{{{self.count}}}"
+        elif self.kind == QuantifierKind.RANGE:
+            return f"{inner}{{{self.min_count},{self.max_count}}}"
+        else:
+            return f"{inner}{self.kind.value}"
+
+
+class ExcludeFilter:
+    """Represents a character class with certain characters excluded."""
+
+    def __init__(self, base: CharClassType, excluded_chars: str) -> None:
+        self.base = base
+        self.excluded_chars = excluded_chars
+
+    def compile(self) -> str:
+        # Build a negated character class that excludes both the negation
+        # of the base class and the excluded characters.
+        # e.g., \w excluding '_' → [^\W_]
+        negated_base = NEGATED_MAP[self.base]
+        escaped_excluded = re.escape(self.excluded_chars)
+
+        # If negated base is a simple escape like \W, use it directly in bracket
+        if negated_base.startswith("\\"):
+            return f"[^{negated_base}{escaped_excluded}]"
+        # If it's a bracket expression like [^a-zA-Z], extract the inner part
+        if negated_base.startswith("[^") and negated_base.endswith("]"):
+            inner = negated_base[2:-1]
+            return f"[^{inner}{escaped_excluded}]"
+        # Fallback
+        return f"[^{negated_base}{escaped_excluded}]"

readable_regex/exclude_proxy.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from readable_regex.components import (
+    CharClassType,
+    NegatedCharClass,
+    Quantifier,
+    QuantifierKind,
+)
+
+if TYPE_CHECKING:
+    from readable_regex.builder import RegexBuilder
+
+
+class ExcludeProxy:
+    """Proxy returned by `regex.exclude` property.
+
+    Provides `.digit`, `.digits`, `.word`, `.words`, etc. that produce
+    negated character classes (e.g., `\\D`, `\\W`).
+    """
+
+    def __init__(self, builder: RegexBuilder) -> None:
+        self._builder = builder
+
+    def _add(self, class_type: CharClassType) -> RegexBuilder:
+        return self._builder._extend(NegatedCharClass(class_type))
+
+    def _add_plus(self, class_type: CharClassType) -> RegexBuilder:
+        target = NegatedCharClass(class_type)
+        return self._builder._extend(Quantifier(target, QuantifierKind.ONE_OR_MORE))
+
+    # Singular (one)
+    @property
+    def digit(self) -> RegexBuilder:
+        return self._add(CharClassType.DIGIT)
+
+    @property
+    def word(self) -> RegexBuilder:
+        return self._add(CharClassType.WORD)
+
+    @property
+    def whitespace(self) -> RegexBuilder:
+        return self._add(CharClassType.WHITESPACE)
+
+    @property
+    def letter(self) -> RegexBuilder:
+        return self._add(CharClassType.LETTER)
+
+    @property
+    def any_char(self) -> RegexBuilder:
+        return self._add(CharClassType.ANY)
+
+    # Plural (one or more)
+    @property
+    def digits(self) -> RegexBuilder:
+        return self._add_plus(CharClassType.DIGIT)
+
+    @property
+    def words(self) -> RegexBuilder:
+        return self._add_plus(CharClassType.WORD)
+
+    @property
+    def whitespaces(self) -> RegexBuilder:
+        return self._add_plus(CharClassType.WHITESPACE)
+
+    @property
+    def letters(self) -> RegexBuilder:
+        return self._add_plus(CharClassType.LETTER)
+
+    @property
+    def any_chars(self) -> RegexBuilder:
+        return self._add_plus(CharClassType.ANY)

readable_regex/flags.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import re
+from enum import Enum
+
+
+class Flag(Enum):
+    IGNORE_CASE = "IGNORECASE"
+    MULTILINE = "MULTILINE"
+
+
+def flags_to_re(flags: frozenset[Flag]) -> re.RegexFlag:
+    mapping = {
+        Flag.IGNORE_CASE: re.IGNORECASE,
+        Flag.MULTILINE: re.MULTILINE,
+    }
+    result = re.RegexFlag(0)
+    for flag in flags:
+        result |= mapping[flag]
+    return result

readable_regex-0.2.0.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: readable-regex
+Version: 0.2.0
+Summary: A fluent, chainable API for building regular expressions that read like English
+Project-URL: Homepage, https://github.com/molestreettechllc-dev/readable-regex
+Project-URL: Documentation, https://molestreettechllc-dev.github.io/readable-regex/
+Project-URL: Repository, https://github.com/molestreettechllc-dev/readable-regex
+Project-URL: Issues, https://github.com/molestreettechllc-dev/readable-regex/issues
+Author: Derwin Emmanuel
+License-Expression: MIT
+License-File: LICENSE
+Keywords: builder,fluent,readable,regex,regular-expressions
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# readable-regex
+
+A fluent, chainable Python API for building regular expressions that read like English.
+
+**[Documentation](https://molestreettechllc-dev.github.io/readable-regex/)**
+
+## Install
+
+```bash
+pip install readable-regex
+```
+
+## Quick Start
+
+```python
+from readable_regex import regex
+
+# Email pattern
+regex.words.then('@').words.then('.').words.test("user@example.com")  # True
+
+# Phone number
+regex.digit.exactly(3).then('-').digit.exactly(3).then('-').digit.exactly(4).test("123-456-7890")  # True
+
+# Extract all numbers
+regex.digits.find_all("Order #42 has 3 items totaling $129")  # ['42', '3', '129']
+```
+
+## Vocabulary
+
+The API uses a **plural convention**: singular = exactly one, plural = one or more.
+
+### Items — what you match
+
+| Singular | Plural (1+) | Regex |
+|---|---|---|
+| `digit` | `digits` | `\d` / `\d+` |
+| `word` | `words` | `\w` / `\w+` |
+| `letter` | `letters` | `[a-zA-Z]` / `[a-zA-Z]+` |
+| `whitespace` | `whitespaces` | `\s` / `\s+` |
+| `any_char` | `any_chars` | `.` / `.+` |
+| `then('text')` | — | escaped literal |
+| `any_of('a', 'b')` | — | `[ab]` or `(?:foo\|bar)` |
+
+### Modifiers — how you constrain
+
+| Modifier | Example | Effect |
+|---|---|---|
+| `exactly(n)` | `digit.exactly(3)` | `\d{3}` |
+| `between(n, m)` | `digit.between(1, 3)` | `\d{1,3}` |
+| `optional` | `digit.optional` | `\d?` |
+| `zero_or_more` | `digit.zero_or_more` | `\d*` |
+| `starts_with(text?)` | `starts_with('Hello')` | `^Hello` |
+| `ends_with(text?)` | `ends_with('!')` | `!$` |
+| `ignore_case` | — | case-insensitive flag |
+| `multiline` | — | multiline flag |
+| `exclude.digits` | — | `\D+` (negated class) |
+| `excluding('_')` | `words.excluding('_')` | `[^\W_]+` |
+| `capture(builder)` | `capture(regex.words)` | `(\w+)` |
+
+### Execution — terminal methods
+
+| Method | Returns |
+|---|---|
+| `test(text)` | `bool` |
+| `search(text)` | `re.Match \| None` |
+| `match(text)` | `re.Match \| None` |
+| `find_all(text)` | `list[str]` |
+| `replace(text, repl)` | `str` |
+| `split(text)` | `list[str]` |
+| `compile()` | `re.Pattern` (cached) |
+| `.pattern` | raw regex string |
+
+## Examples
+
+### Email validation
+
+```python
+email = regex.words.then('@').words.then('.').words
+email.test("user@example.com")   # True
+email.test("bad@@address")       # False
+email.pattern                    # '\w+@\w+\.\w+'
+```
+
+### Phone number
+
+```python
+phone = (
+    regex
+    .digit.exactly(3).then('-')
+    .digit.exactly(3).then('-')
+    .digit.exactly(4)
+)
+phone.test("123-456-7890")  # True
+phone.pattern               # '\d{3}\-\d{3}\-\d{4}'
+```
+
+### IP address
+
+```python
+ip = (
+    regex
+    .digit.between(1, 3).then('.')
+    .digit.between(1, 3).then('.')
+    .digit.between(1, 3).then('.')
+    .digit.between(1, 3)
+)
+ip.test("192.168.1.1")  # True
+```
+
+### Capturing groups
+
+```python
+kv = regex.capture(regex.words).then('=').capture(regex.any_chars)
+m = kv.search("color=blue")
+m.group(1)  # 'color'
+m.group(2)  # 'blue'
+```
+
+### Case-insensitive matching
+
+```python
+greeting = regex.starts_with('hello').ignore_case
+greeting.test("HELLO world")  # True
+greeting.test("hey there")    # False
+```
+
+### Search and replace
+
+```python
+regex.digits.replace("My SSN is 123-45-6789", "***")
+# 'My SSN is ***-***-***'
+```
+
+### Splitting text
+
+```python
+regex.then(',').whitespace.zero_or_more.split("a, b,c, d")
+# ['a', 'b', 'c', 'd']
+```
+
+### Negated classes
+
+```python
+regex.exclude.digits.find_all("a1b2c3")  # ['a', 'b', 'c']
+regex.words.excluding('_').pattern        # '[^\W_]+'
+```
+
+### Immutable builder — safe reuse
+
+```python
+base = regex.starts_with('LOG-')
+errors = base.then('ERROR').any_chars
+warns  = base.then('WARN').any_chars
+
+errors.test("LOG-ERROR disk full")  # True
+warns.test("LOG-WARN low memory")   # True
+base.pattern                        # '^LOG\-' (unchanged)
+```
+
+## Requirements
+
+- Python 3.10+
+- Zero runtime dependencies
+
+## License
+
+MIT

readable_regex-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+readable_regex/__init__.py,sha256=wC8r47Jz61tas25SFNI7XxKzvP7RZFuFYUnbtZSEta8,109
+readable_regex/builder.py,sha256=ZrxedMHVYP5bsDNPy41JWSjY3LyvbbmvGKR0297q67c,7667
+readable_regex/compiler.py,sha256=1kOEgBAgXyZFY4htLeoZXes0XF2wjuxGMXHdIeNfZ_I,231
+readable_regex/components.py,sha256=Wp1p8uj_spLoBtjG_DuZmflqMaPVo5XmKGEqYI1AZ_M,4220
+readable_regex/exclude_proxy.py,sha256=qikdXCJGs2NuWHqbmLaxOqQuaQ24E2dHEdOXwN7jnkA,1964
+readable_regex/flags.py,sha256=9ITQ6yOFnKy-q01cJryPTtRuwTs4Si9vtdN_eVSnCI8,409
+readable_regex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+readable_regex-0.2.0.dist-info/METADATA,sha256=uANzXvfDw04GpvUIMVm9gW3txphi-op84ktdKQNc1RA,5145
+readable_regex-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+readable_regex-0.2.0.dist-info/licenses/LICENSE,sha256=GU7q1ON02j-w0tC_np1IBBcm56lJcRhf03l_bwTqZzc,1072
+readable_regex-0.2.0.dist-info/RECORD,,

readable_regex-0.2.0.dist-info/WHEEL

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

readable_regex-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Derwin Emmanuel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.