phext 0.3.0__py3-none-any.whl

phext/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

phext/coordinate.py

@@ -0,0 +1,154 @@
+from dataclasses import dataclass
+from functools import total_ordering
+
+@total_ordering
+@dataclass
+class Coordinate:
+    library: int
+    shelf: int
+    series: int
+    collection: int
+    volume: int
+    book: int
+    chapter: int
+    section: int
+    scroll: int
+
+    @classmethod
+    def from_string(ignored, coord_str: str):
+        try:
+            parts = coord_str.strip().split("/")
+            if len(parts) != 3:
+                raise ValueError("Coordinate must conform to Phext Standard Addressing")
+
+            nums = []
+            for part in parts:
+                nums.extend(int(x) for x in part.split("."))
+
+            if len(nums) != 9:
+                raise ValueError("Coordinate must have exactly 9 numeric parts")
+
+            if any(n < 1 or n > 999 for n in nums):
+                raise ValueError("All coordinate values must be between 1 and 999")
+
+            return Coordinate(nums[0], nums[1], nums[2], nums[3], nums[4], nums[5], nums[6], nums[7], nums[8])
+
+        except Exception as e:
+            raise ValueError(f"Invalid coordinate string: {coord_str} {e}") from e
+
+    def libraryBreak(self):
+        self.library += 1
+        self.shelf = 1
+        self.series = 1
+        self.collection = 1
+        self.volume = 1
+        self.book = 1
+        self.chapter = 1
+        self.section = 1
+        self.scroll = 1
+
+    def shelfBreak(self):
+        self.shelf += 1
+        self.series = 1
+        self.collection = 1
+        self.volume = 1
+        self.book = 1
+        self.chapter = 1
+        self.section = 1
+        self.scroll = 1
+
+    def seriesBreak(self):
+        self.series += 1
+        self.collection = 1
+        self.volume = 1
+        self.book = 1
+        self.chapter = 1
+        self.section = 1
+        self.scroll = 1
+
+    def collectionBreak(self):
+        self.collection += 1
+        self.volume = 1
+        self.book = 1
+        self.chapter = 1
+        self.section = 1
+        self.scroll = 1
+
+    def volumeBreak(self):
+        self.volume += 1
+        self.book = 1
+        self.chapter = 1
+        self.section = 1
+        self.scroll = 1
+
+    def bookBreak(self):
+        self.book += 1
+        self.chapter = 1
+        self.section = 1
+        self.scroll = 1
+
+    def chapterBreak(self):
+        self.chapter += 1
+        self.section = 1
+        self.scroll = 1
+
+    def sectionBreak(self):
+        self.section += 1
+        self.scroll = 1
+
+    def scrollBreak(self):
+        self.scroll += 1
+    
+    def __init__(self, lb, sf, sr, cn, vm, bk, ch, sn, sc):
+        self.library = int(lb)
+        self.shelf = int(sf)
+        self.series = int(sr)
+        self.collection = int(cn)
+        self.volume = int(vm)
+        self.book = int(bk)
+        self.chapter = int(ch)
+        self.section = int(sn)
+        self.scroll = int(sc)
+
+    def copy_coordinate(self, other):
+        self.library = int(other.library)
+        self.shelf = int(other.shelf)
+        self.series = int(other.series)
+        self.collection = int(other.collection)
+        self.volume = int(other.volume)
+        self.book = int(other.book)
+        self.chapter = int(other.chapter)
+        self.section = int(other.section)
+        self.scroll = int(other.scroll)
+
+    def __str__(self) -> str:
+        return f"{self.library}.{self.shelf}.{self.series}/" \
+               f"{self.collection}.{self.volume}.{self.book}/" \
+               f"{self.chapter}.{self.section}.{self.scroll}"
+    
+    def urlencoded(self) -> str:
+        return f"{self.library}.{self.shelf}.{self.series};" \
+               f"{self.collection}.{self.volume}.{self.book};" \
+               f"{self.chapter}.{self.section}.{self.scroll}"
+    
+    def __eq__(self, other):
+        return isinstance(self, Coordinate) and isinstance(other, Coordinate) and self.library == other.library and self.shelf == other.shelf and self.series == other.series and self.collection == other.collection and self.volume == other.volume and self.book == other.book and self.chapter == other.chapter and self.section == other.section and self.scroll == other.scroll
+    
+    def __lt__(self, other):
+        if not isinstance(other, Coordinate):
+            return NotImplemented
+        return self.as_tuple() < other.as_tuple()
+    
+    def as_tuple(self) -> tuple:
+        return (
+            self.library, self.shelf, self.series,
+            self.collection, self.volume, self.book,
+            self.chapter, self.section, self.scroll
+        )
+
+    def __hash__(self):
+        return hash((
+            self.library, self.shelf, self.series,
+            self.collection, self.volume, self.book,
+            self.chapter, self.section, self.scroll
+        ))

phext/phext.py

@@ -0,0 +1,546 @@
+import copy
+import xxhash
+
+from dataclasses import dataclass
+from typing import List
+
+from phext.coordinate import Coordinate
+from phext.positionedScroll import PositionedScroll
+from phext.range import Range
+
+@dataclass
+class SubspaceBeacon:
+  start: int
+  end: int
+  best: Coordinate
+
+@dataclass
+class Phext:
+    location: Coordinate
+
+    LIBRARY_BREAK = "\x01"
+    STX_BREAK = "\x02"
+    ETX_BREAK = "\x03"
+    MORE_COWBELL = "\x07"
+    SHELF_BREAK = "\x1F"
+    SERIES_BREAK = "\x1E"
+    COLLECTION_BREAK = "\x1D"
+    VOLUME_BREAK = "\x1C"
+    BOOK_BREAK = "\x1A"
+    CHAPTER_BREAK = "\x19"
+    SECTION_BREAK = "\x18"
+    SCROLL_BREAK = "\x17"
+    LINE_BREAK = "\x0a"
+    
+    def defaultCoordinate(self) -> Coordinate:
+       return Coordinate(1,1,1, 1,1,1, 1,1,1)
+
+    def __init__(self):
+      location = self.defaultCoordinate()
+
+    def fetch(self, buffer:str, coord:Coordinate) -> dict[Coordinate, str]:
+      stack = self.phokenize(buffer)
+      for ps in stack:
+        if ps.coord == coord:
+          return ps.text
+      return ""
+    
+    def isPhextBreak(self, byte:str):
+      return byte == self.LINE_BREAK or \
+            byte == self.SCROLL_BREAK or \
+            byte == self.SECTION_BREAK or \
+            byte == self.CHAPTER_BREAK or \
+            byte == self.BOOK_BREAK or \
+            byte == self.VOLUME_BREAK or \
+            byte == self.COLLECTION_BREAK or \
+            byte == self.SERIES_BREAK or \
+            byte == self.SHELF_BREAK or \
+            byte == self.LIBRARY_BREAK
+    
+    def phokenize(self, buffer:str) -> List[PositionedScroll]:
+      result = []
+      location = self.defaultCoordinate()
+      next = self.defaultCoordinate()
+      temp = ""
+      # decoded = buffer.decode("utf-8")      
+      for ch in buffer:
+        dimension_break = False
+        if ch == self.LIBRARY_BREAK:
+          next.libraryBreak()
+          dimension_break = True
+        if ch == self.SHELF_BREAK:
+          next.shelfBreak()
+          dimension_break = True
+        if ch == self.SERIES_BREAK:
+          next.seriesBreak()
+          dimension_break = True
+        if ch == self.COLLECTION_BREAK:
+          next.collectionBreak()
+          dimension_break = True
+        if ch == self.VOLUME_BREAK:
+          next.volumeBreak()
+          dimension_break = True
+        if ch == self.BOOK_BREAK:
+          next.bookBreak()
+          dimension_break = True
+        if ch == self.CHAPTER_BREAK:
+          next.chapterBreak()
+          dimension_break = True
+        if ch == self.SECTION_BREAK:
+          next.sectionBreak()
+          dimension_break = True
+        if ch == self.SCROLL_BREAK:
+          next.scrollBreak()
+          dimension_break = True
+        
+        if dimension_break == True:
+          if len(temp) > 0:
+            item = PositionedScroll(location, temp)
+            result.append(item)
+            temp = ""
+        else:
+          temp += str(ch)
+          location = copy.deepcopy(next)
+
+      if len(temp) > 0:
+        item = PositionedScroll(location, temp)
+        result.append(item)
+
+      return result
+    
+    def append_scroll(self, entry: PositionedScroll, location: Coordinate) -> PositionedScroll:
+      output = ""
+      compare = entry.coord
+      while location < entry.coord:
+        if location.library < compare.library:
+          output += Phext.LIBRARY_BREAK
+          location.libraryBreak()
+          continue
+        if location.shelf < compare.shelf:
+          output += Phext.SHELF_BREAK
+          location.shelfBreak()
+          continue
+        if location.series < compare.series:
+          output += Phext.SERIES_BREAK
+          location.seriesBreak()
+          continue
+        if location.collection < compare.collection:
+          output += Phext.COLLECTION_BREAK
+          location.collectionBreak()
+          continue
+        if location.volume < compare.volume:
+          output += Phext.VOLUME_BREAK
+          location.volumeBreak()
+          continue
+        if location.book < compare.book:
+          output += Phext.BOOK_BREAK
+          location.bookBreak()
+          continue
+        if location.chapter < compare.chapter:
+          output += Phext.CHAPTER_BREAK
+          location.chapterBreak()
+          continue
+        if location.section < compare.section:
+          output += Phext.SECTION_BREAK
+          location.sectionBreak()
+          continue
+        if location.scroll < compare.scroll:
+          output += Phext.SCROLL_BREAK
+          location.scrollBreak()
+          continue
+      if len(entry.text) > 0:
+        output += entry.text
+      result = PositionedScroll(location, output)
+      return result
+
+    def dephokenize(self, stack: list[PositionedScroll]) -> str:
+      result = ""
+      location = self.defaultCoordinate()
+      for ps in stack:
+        next = self.append_scroll(ps, location)
+        result += next.text
+        location = next.coord
+      return result
+
+    def normalize(self, buffer:str) -> str:
+      arr = self.phokenize(buffer)
+      return self.dephokenize(arr)
+
+    def update(self, buffer:str, coord:Coordinate, scroll:str, overwrite:bool) -> str:
+      items = self.phokenize(buffer)
+      result = []
+      next = PositionedScroll(coord, scroll)
+      appended = False
+      for ps in items:
+        if (ps.coord > coord) and (appended == False):
+          result.append(next)
+          appended = True
+        if (ps.coord == coord) and (appended == False):
+          if overwrite == False:
+            next.text = ps.text + next.text
+          result.append(next)
+          appended = True
+          continue
+        result.append(ps)
+      if appended == False:
+        result.append(next)
+        appended = True
+
+      serialized = self.dephokenize(result)
+      return serialized
+    
+    def insert(self, buffer:str, coord:Coordinate, scroll:str) -> str:
+      return self.update(buffer, coord, scroll, False)
+    
+    def replace(self, buffer:str, coord:Coordinate, scroll:str) -> str:
+      return self.update(buffer, coord, scroll, True)
+    
+    def remove(self, buffer:str, coord:Coordinate) -> str:
+      intermediate = self.update(buffer, coord, "", True)
+      return self.normalize(intermediate)
+    
+    def range_replace(self, buffer:str, range:Range, text:str) -> str:
+      stack = self.phokenize(buffer)
+      result = []
+      appended = False      
+      for ps in stack:
+        if ps.coord < range.start and len(ps.text) > 0:
+          result.append(ps)
+        if ps.coord >= range.start and ps.coord <= range.end:          
+          if appended == False and len(text) > 0:
+            next = PositionedScroll(ps.coord, text)
+            result.append(next)
+            appended = True
+        if ps.coord > range.end and len(ps.text) > 0:
+          result.append(ps)
+      return self.dephokenize(result)
+    
+    def next_scroll(self, buffer:str, coord:Coordinate) -> List[PositionedScroll]:
+      stack = self.phokenize(buffer)
+      found = False
+      result = []
+      for ps in stack:
+        if found == True:
+          result.append(ps)
+          return result
+        if ps.coord >= coord:
+          result.append(ps)
+          found = True
+      return result
+    
+    def get_subspace_coordinates(self, buffer:str, target:Coordinate):
+      walker = self.defaultCoordinate()
+      best = self.defaultCoordinate()
+      subspace_index = 0
+      start = 0
+      end = 0
+      stage = 0
+      max = len(buffer)
+
+      while subspace_index < max:
+        next = buffer[subspace_index]
+        compare = next
+
+        if stage == 0:
+          if walker == target:
+            stage = 1
+            start = subspace_index
+            best = copy.deepcopy(walker)
+          if walker < target:
+            best = copy.deepcopy(walker)
+        if stage < 2 and walker > target:
+          if stage == 0:
+            start = subspace_index - 1
+          end = subspace_index - 1
+          stage = 2    
+
+        if self.isPhextBreak(next):
+          if compare == self.SCROLL_BREAK:
+            walker.scrollBreak()
+          if compare == self.SECTION_BREAK:
+            walker.sectionBreak()
+          if compare == self.CHAPTER_BREAK:
+            walker.chapterBreak()
+          if compare == self.BOOK_BREAK:
+            walker.bookBreak()
+          if compare == self.VOLUME_BREAK:
+            walker.volumeBreak()
+          if compare == self.COLLECTION_BREAK:
+            walker.collectionBreak()
+          if compare == self.SERIES_BREAK:
+            walker.seriesBreak()
+          if compare == self.SHELF_BREAK:
+            walker.shelfBreak()
+          if compare == self.LIBRARY_BREAK:
+            walker.libraryBreak()
+        
+        if stage < 2 and walker > target:
+          end = subspace_index
+          stage = 2
+        
+        subspace_index += 1
+
+      if stage == 1 and walker == target:
+        end = max
+        stage = 2
+
+      if stage == 0:
+        start = max
+        end = max
+
+      result = SubspaceBeacon(start, end, best)
+      return result
+    
+    def merge(self, left: str, right:str) -> str:
+      tl = self.phokenize(left)
+      tr = self.phokenize(right)
+      tli = 0
+      tri = 0
+      maxtl = len(tl)
+      maxtr = len(tr)
+      result = ""
+      coord = self.defaultCoordinate()
+
+      while True:
+        have_left = tli < maxtl
+        have_right = tri < maxtr
+        pick_left = have_left and (have_right == False or tl[tli].coord <= tr[tri].coord)
+        pick_right = have_right and (have_left == False or tr[tri].coord <= tl[tli].coord)
+
+        if pick_left:
+          next = self.append_scroll(tl[tli], coord)
+          result += next.text
+          coord = next.coord
+          tli += 1
+        if pick_right:
+          next = self.append_scroll(tr[tri], coord)
+          result += next.text
+          coord = next.coord
+          tri += 1
+
+        if pick_left == False and pick_right == False:
+          break
+
+      return result
+    
+    def subtract(self, left:str, right:str) -> str:
+      pl = self.phokenize(left)
+      pr = self.phokenize(right)
+      result = ""
+      pri = 0
+      max = len(pr)
+      coord = self.defaultCoordinate()
+      for item in pl:
+        do_append = pri == max
+        if pri < max:
+          compare = pr[pri]
+          if item.coord < compare.coord:
+            do_append = True
+          elif item.coord == compare.coord:
+            pri += 1
+        if do_append:
+          next = self.append_scroll(item, coord)
+          result += next.text
+          coord = next.coord
+      return result
+    
+    def expand(self, buffer:str) -> str:
+      result = ""
+      for char in buffer:
+        if char == self.LINE_BREAK:
+          result += self.SCROLL_BREAK
+        elif char == self.SCROLL_BREAK:
+          result += self.SECTION_BREAK
+        elif char == self.SECTION_BREAK:
+          result += self.CHAPTER_BREAK
+        elif char == self.CHAPTER_BREAK:
+          result += self.BOOK_BREAK
+        elif char == self.BOOK_BREAK:
+          result += self.VOLUME_BREAK
+        elif char == self.VOLUME_BREAK:
+          result += self.COLLECTION_BREAK
+        elif char == self.COLLECTION_BREAK:
+          result += self.SERIES_BREAK
+        elif char == self.SERIES_BREAK:
+          result += self.SHELF_BREAK
+        elif char == self.SHELF_BREAK:
+          result += self.LIBRARY_BREAK
+        else:
+          result += char
+      return result
+    
+    def contract(self, buffer:str) -> str:
+      result = ""
+      for char in buffer:
+        if char == self.LIBRARY_BREAK:
+          result += self.SHELF_BREAK
+        elif char == self.SHELF_BREAK:
+          result += self.SERIES_BREAK
+        elif char == self.SERIES_BREAK:
+          result += self.COLLECTION_BREAK
+        elif char == self.COLLECTION_BREAK:
+          result += self.VOLUME_BREAK
+        elif char == self.VOLUME_BREAK:
+          result += self.BOOK_BREAK
+        elif char == self.BOOK_BREAK:
+          result += self.CHAPTER_BREAK
+        elif char == self.CHAPTER_BREAK:
+          result += self.SECTION_BREAK
+        elif char == self.SECTION_BREAK:
+          result += self.SCROLL_BREAK
+        elif char == self.SCROLL_BREAK:
+          result += self.LINE_BREAK
+        else:
+          result += char
+      return result
+    
+    def create_summary(self, buffer:str) -> str:
+      limit = 32
+      max = len(buffer)
+      if max < 32:
+        limit = max
+      summary = ""
+      for char in buffer:
+        if self.isPhextBreak(char):
+          break
+        summary += char
+      if len(summary) < len(buffer):
+        summary += "..."
+      return summary
+    
+    def navmap(self, urlbase:str, buffer:str) -> str:
+      stack = self.phokenize(buffer)
+      result = ""
+      max = len(stack)
+      if max > 0:
+        result += "<ul>\n"
+      for ps in stack:
+        urlcoord = ps.coord.urlencoded()
+        summary = self.create_summary(ps.text)
+        result += f"<li><a href=\"{urlbase}{urlcoord}\">{ps.coord} {summary}</a></li>\n"
+      if max > 0:
+        result += "</ul>\n"
+      return result
+    
+    def textmap(self, buffer:str) -> str:
+      stack = self.phokenize(buffer)
+      result = ""
+      for ps in stack:
+        summary = self.create_summary(ps.text)
+        result += f"* {ps.coord}: {summary}\n"
+      return result
+    
+    def checksum(self, buffer:str) -> str:
+      hash = xxhash.xxh3_128(buffer).hexdigest()
+      return hash
+    
+    def manifest(self, buffer:str) -> str:
+      stack = self.phokenize(buffer)
+      for ps in stack:
+        ps.text = self.checksum(ps.text)
+      result = self.dephokenize(stack)
+      return result
+    
+    def soundex_v1(self, buffer:str) -> str:
+      stack = self.phokenize(buffer)
+  
+      for ps in stack:
+        ps.text = self.soundex_internal(ps.text)
+
+      return self.dephokenize(stack)
+    
+    def soundex_internal(self, buffer:str) -> str:
+      letter1 = "bpfv"
+      letter2 = "cskgjqxz"
+      letter3 = "dt"
+      letter4 = "l"
+      letter5 = "mn"
+      letter6 = "r"
+      
+      value = 1 # 1-100
+      for byte in buffer:
+        if byte in letter1:
+          value += 1
+        if byte in letter2:
+          value += 2
+        if byte in letter3:
+          value += 3
+        if byte in letter4:
+          value += 4
+        if byte in letter5:
+          value += 5
+        if byte in letter6:
+          value += 6
+      return str(value % 99)
+    
+    def explode(self, buffer:str) -> dict[Coordinate, str]:
+      parts = self.phokenize(buffer)
+      hash: dict[Coordinate, str] = {}
+      for ps in parts:
+        hash[ps.coord] = ps.text
+      return hash
+    
+    def implode(self, hash: dict[Coordinate, str]) -> str:
+      parts = []
+      for coord in hash.keys():
+        parts.append(PositionedScroll(coord, hash[coord]))
+      return self.dephokenize(parts)
+    
+    def index_phokens(self, buffer:str) -> list[PositionedScroll]:
+      stack = self.phokenize(buffer)
+      offset = 0
+      coord = self.defaultCoordinate()
+      output = []
+      for ps in stack:
+        reference = ps.coord
+        while coord.library < reference.library:
+          coord.libraryBreak()          
+          offset += 1
+        while coord.shelf < reference.shelf:
+          coord.shelfBreak()
+          offset += 1
+        while coord.series < reference.series:
+          coord.seriesBreak()
+          offset += 1
+        while coord.collection < reference.collection:
+          coord.collectionBreak()
+          offset += 1
+        while coord.volume < reference.volume:
+          coord.volumeBreak()
+          offset += 1
+        while coord.book < reference.book:
+          coord.bookBreak()
+          offset += 1
+        while coord.chapter < reference.chapter:
+          coord.chapterBreak()
+          offset += 1
+        while coord.section < reference.section:
+          coord.sectionBreak()
+          offset += 1
+        while coord.scroll < reference.scroll:
+          coord.scrollBreak()
+          offset += 1
+        text = str(offset)
+        output.append(PositionedScroll(copy.deepcopy(coord), text))
+        offset += len(ps.text)
+
+      return output
+
+    def index(self, buffer:str) -> str:
+      output = self.index_phokens(buffer)
+      return self.dephokenize(output)
+    
+    def offset(self, buffer:str, coord:Coordinate) -> int:
+      output = self.index_phokens(buffer)
+      best = self.defaultCoordinate()
+      fetch_coord = coord
+      matched = False
+      for ps in output:
+        if ps.coord <= coord:
+          best = copy.deepcopy(ps.coord)
+        if ps.coord == coord:
+          matched = True
+      if matched == False:
+        fetch_coord = best
+      index = self.dephokenize(output)
+      return int(self.fetch(index, fetch_coord))

phext/positionedScroll.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from phext.coordinate import Coordinate
+
+@dataclass
+class PositionedScroll:
+    coord: Coordinate
+    text: str
+    
+    def __init__(self, coord, text):
+        self.coord = coord
+        self.text = text

phext/range.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from phext.coordinate import Coordinate
+
+@dataclass
+class Range:
+  start: Coordinate
+  end: Coordinate

phext-0.3.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: phext
+Version: 0.3.0
+Summary: Pythonic implementation of phext
+Project-URL: Homepage, https://phext.io
+Project-URL: Repository, https://github.com/wbic16/phext-py
+Project-URL: Issues, https://github.com/wbic16/phext-py/issues
+Author-email: Will Bickford <wbic16@gmail.com>
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: xxhash
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Phext
+
+Welcome to the Pythonic port of phext.
+
+This port is a downstream artifact that tracks the Rust-based implementation of Phext. See https://github.com/wbic16/phext-rs for more details.

phext-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+phext/__init__.py,sha256=5mDtfU2t04ATmg92S5B-scUcdjCy1ZBq620y3GmpdtQ,21
+phext/coordinate.py,sha256=dAaLTJUF9znpsm_nnVYiLV6dfQE769JhcKlxvQfazms,4821
+phext/phext.py,sha256=P9er7vRegrTjhCMWcIitwqq704cIQQuUXtFPAognqEg,17171
+phext/positionedScroll.py,sha256=b-p4wffIY_E_DDwRJxzOMIymlK1-2nTQVVVD7CADPGw,249
+phext/range.py,sha256=tV3Zte0jxvA1FrTHFwRkjsRgEijyhm0QgUM1x3SvesA,142
+phext-0.3.0.dist-info/METADATA,sha256=gvpUGRm0doT7VvCVUGDAfRo-JHetNXWl6frcHlLzzDM,1019
+phext-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+phext-0.3.0.dist-info/RECORD,,

phext-0.3.0.dist-info/WHEEL

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