Last active
April 1, 2024 05:38
-
-
Save lastforkbender/eabd57fbefe03fe7cea63fb942b3d25e to your computer and use it in GitHub Desktop.
Makes discrete palindrome specific file uids
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # PX42 File UID Class - makes discrete palindrome specific uids & checksums. | |
| # rcttcr5@gmail.com | |
| #__________________________________________________________________________________ | |
| import threading as tr | |
| import math as mt | |
| #__________________________________________________________________________________ | |
| class PX42: | |
| __slots__ = ('_sLstA','_sLstB','_sLstC','_sLstD','_fLstA','_pLstA','_rLstA','_rLstB','_rLstC','_fStrA','_pStrA','_rStrA','_rStrB','_rStrC','_rStrD','_rStrE','_42X_MidA','_42Y_PidA','_fNmrA','_pNmrA','_rNmrA','_rNmrB','_rNmrC','_rNmrD','_rNmrE','_rNmrF','_rNmrG','_rNmrH','_cBlnA','_cBlnB','_cBlnC','_rBlnA') | |
| def __init__(self,_sLstA,_sLstB,_sLstC,_sLstD,_fLstA,_pLstA,_rLstA,_rLstB,_rLstC,_fStrA,_pStrA,_rStrA,_rStrB,_rStrC,_rStrD,_rStrE,_42X_MidA,_42Y_PidA,_fNmrA,_pNmrA,_rNmrA,_rNmrB,_rNmrC,_rNmrD,_rNmrE,_rNmrF,_rNmrG,_rNmrH,_cBlnA,_cBlnB,_cBlnC,_rBlnA): | |
| self._sLstA = _sLstA | |
| self._sLstB = _sLstB | |
| self._sLstC = _sLstC | |
| self._sLstD = _sLstD | |
| self._fLstA = _fLstA | |
| self._pLstA = _pLstA | |
| self._rLstA = _rLstA | |
| self._rLstB = _rLstB | |
| self._rLstC = _rLstC | |
| self._fStrA = _fStrA | |
| self._pStrA = _pStrA | |
| self._rStrA = _rStrA | |
| self._rStrB = _rStrB | |
| self._rStrC = _rStrC | |
| self._rStrD = _rStrD | |
| self._rStrE = _rStrE | |
| self._42X_MidA = _42X_MidA | |
| self._42Y_PidA = _42Y_PidA | |
| self._fNmrA = _fNmrA | |
| self._pNmrA = _pNmrA | |
| self._rNmrA = _rNmrA | |
| self._rNmrB = _rNmrB | |
| self._rNmrC = _rNmrC | |
| self._rNmrD = _rNmrD | |
| self._rNmrE = _rNmrE | |
| self._rNmrF = _rNmrF | |
| self._rNmrG = _rNmrG | |
| self._rNmrH = _rNmrH | |
| self._cBlnA = False | |
| self._cBlnB = False | |
| self._cBlnC = False | |
| self._rBlnA = _rBlnA | |
| #__________________________________________________________________________________ | |
| def _nearest_palindrome(self, src: str) -> int: | |
| # PX42 start function. In charge of assignment for main palindrome key found. | |
| if not len(src) > 4222: | |
| return 'PX42-null=...' | |
| if not self._cBlnA: | |
| self._reset_lists(True,False) | |
| self._sLstA = set('abcdefghijklmnopqurstvwxyzABCDEFGHIJKLMNOPQURSTVWXYZ') | |
| self._sLstB = set('1234567890') | |
| self._sLstC = set('+×÷=/_<>[]@#$%^&*()-":;,?!.') | |
| self._sLstD = set('`~\|{}¿°') | |
| else: self._reset_lists(False,False) | |
| self._reset_strings(True) | |
| self._reset_numbers(True) | |
| if not self._cBlnA: self._pLstA = list(map(lambda s: src[s:s+len(src)//4],range(0,len(src),len(src)//4-1))) | |
| else: | |
| if not self._cBlnB: | |
| self._cBlnB = True | |
| self._pLstA = list(map(lambda s: src[s:s+len(src)//4],range(0,len(src),len(src)//4-1))) | |
| self._fLstA = [0,0,0,0] | |
| self._process_char_counts() | |
| self._rNmrA = int("".join(list(set(f'{str(self._rLstA[0])}{str(self._rLstA[1])}{str(self._rLstA[2])}{str(self._rLstA[3])}{str(self._rLstA[4])}')))) | |
| if not self._cBlnA: self._reset_lists(True,True) | |
| else: self._reset_lists(False,False) | |
| self._reset_strings(False) | |
| self._rNmrB = 10**len(str(self._rNmrA)) | |
| self._rNmrC = -1 | |
| if not self._find_palindrome(False): | |
| self._find_palindrome(True) | |
| if self._rNmrA == self._rNmrC: | |
| if not self._find_palindrome(False): | |
| self._find_palindrome(True) | |
| if not self._cBlnA: | |
| self._42Y_PidA = self._rNmrC | |
| self._reset_numbers(False) | |
| self._pLstA = [len(src),len(src)-(len(src)/4),len(src)+(len(src)/4)] | |
| return self._resolve_px42_main() | |
| #__________________________________________________________________________________ | |
| def _resolve_px42_main(self): | |
| # Main director function for uid resolve. | |
| self._rNmrA = mt.floor(mt.sqrt(mt.tan(self._pLstA[0]/self._pLstA[1])*self._pLstA[2])) | |
| if not self._cBlnB: | |
| px42_uid = None | |
| if not self._is_palindrome(self._rNmrA) and self._rNmrA > self._42Y_PidA: | |
| px42_uid = f'PX42G-{self._42Y_PidA}=' | |
| self._glide_map(False) | |
| self._compound_palindrome_seek() | |
| elif not self._is_palindrome(self._rNmrA) and self._rNmrA < self._42Y_PidA: | |
| px42_uid = f'PX42L-{self._42Y_PidA}=' | |
| self._glide_map(True) | |
| self._compound_palindrome_seek() | |
| elif not self._is_palindrome(self._rNmrA) and self._rNmrA == self._42Y_PidA: | |
| px42_uid = f'PX42E-{self._42Y_PidA}=?' | |
| # Both are not palindrome but equal. | |
| pass | |
| else: | |
| px42_uid = f'PX42P-{self._42Y_PidA}=!' | |
| #Both are palindrome. | |
| pass | |
| self._sign_px42_uid() | |
| px42_uid = f'{px42_uid}{self._pNmrA}' | |
| self._reset_lists(True,True) | |
| self._reset_strings(True) | |
| self._reset_numbers(True) | |
| return px42_uid | |
| else: | |
| if not self._is_palindrome(self._rNmrA) and self._rNmrA > self._42Y_PidA: self._glide_map(False) | |
| else: self._glide_map(True) | |
| self._compound_palindrome_seek() | |
| self._sign_px42_uid() | |
| self._reset_lists(True,True) | |
| self._reset_strings(True) | |
| self._reset_numbers(False) | |
| if self._pNmrA == self._42X_MidA: | |
| return f'PX42=VALID: palindrome key & multi-palindrome key are match' | |
| else: | |
| return f'PX42=INVALID: multi-palindrome key did not match palindrome key' | |
| #__________________________________________________________________________________ | |
| def _sign_px42_uid(self): | |
| # Adds all 12 compounded palindrome numbers found for a final uid number. | |
| self._pNmrA = self._rLstA[0] | |
| self._rNmrA = 1 | |
| self._rNmrB = len(self._rLstA) | |
| while self._rNmrA < self._rNmrB: | |
| self._pNmrA = self._pNmrA+self._rLstA[self._rNmrA] | |
| self._rNmrA+=1 | |
| #__________________________________________________________________________________ | |
| def _compound_palindrome_seek(self): | |
| # Finds discrete palindrome numbers via H-pair divisibles with glide map. | |
| self._rNmrA = len(self._pStrA) | |
| self._rNmrH = self._rNmrA*self._rNmrA | |
| self._pNmrA = 0 | |
| self._rNmrB = 0 | |
| self._rNmrG = 0 | |
| self._rLstA = [] | |
| self._rLstB = [False for _ in range(9)] | |
| self._rBlnA = False | |
| while self._rNmrB < 4: | |
| if self._fLstA[self._rNmrB] > 0: | |
| self._rNmrC = 1 | |
| while self._rNmrC <= self._fLstA[self._rNmrB]: | |
| if self._rBlnA: | |
| break | |
| for self._rNmrD in range(self._rNmrA): | |
| if self._rBlnA: | |
| break | |
| for self._rNmrE in range(self._rNmrA): | |
| self._pNmrA+=1 | |
| self._rNmrF = mt.floor((int(self._pLstA[self._rNmrD][self._rNmrE])/self._42Y_PidA)/(self._rNmrE+1))-(self._rNmrD*self._rNmrE) | |
| if not self._rLstB[0] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(self._rNmrF): | |
| break | |
| else: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/2)): | |
| break | |
| else: | |
| if not self._rLstB[0]: | |
| self._pNmrA = 1 | |
| self._rLstB[0] = True | |
| if not self._rLstB[1] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/4)): | |
| break | |
| else: | |
| if not self._rLstB[1]: | |
| self._pNmrA = 1 | |
| self._rLstB[1] = True | |
| if not self._rLstB[2] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/8)): | |
| break | |
| else: | |
| if not self._rLstB[2]: | |
| self._pNmrA = 1 | |
| self._rLstB[2] = True | |
| if not self._rLstB[3] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/10)): | |
| break | |
| else: | |
| if not self._rLstB[3]: | |
| self._pNmrA = 1 | |
| self._rLstB[3] = True | |
| if not self._rLstB[4] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/12)): | |
| break | |
| else: | |
| if not self._rLstB[4]: | |
| self._pNmrA = 1 | |
| self._rLstB[4] = True | |
| if not self._rLstB[5] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/14)): | |
| break | |
| else: | |
| if not self._rLstB[5]: | |
| self._pNmrA = 1 | |
| self._rLstB[5] = True | |
| if not self._rLstB[6] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/16)): | |
| break | |
| else: | |
| if not self._rLstB[6]: | |
| self._pNmrA = 1 | |
| self._rLstB[6] = True | |
| if not self._rLstB[7] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/18)): | |
| break | |
| else: | |
| if not self._rLstB[7]: | |
| self._pNmrA = 1 | |
| self._rLstB[7] = True | |
| if not self._rLstB[8] and self._pNmrA < self._rNmrH: | |
| if self._seek_ext(mt.floor((self._rNmrF/42/(self._rNmrD+1))/20)): | |
| break | |
| if self._pNmrA+1 == self._rNmrH: | |
| raise Exception('PX42(21-halt): <_compound_palindrome_seek> exceeded max divisible pairing distance') | |
| self._rNmrC+=1 | |
| self._rNmrB+=1 | |
| #__________________________________________________________________________________ | |
| def _seek_ext(self, n: int) -> bool: | |
| # Extension function for compound seek, checks if palindrome & break count. | |
| if self._is_palindrome(n): | |
| self._rNmrG+=1 | |
| self._rLstA.append(n) | |
| if self._rNmrG == 12: | |
| self._rBlnA = True | |
| return True | |
| else: | |
| return False | |
| #__________________________________________________________________________________ | |
| def _glide_map(self, lesser: bool): | |
| # Builds mono sine squared pre-distributed matrix for PX42G and PX42L uids. | |
| qs = lambda l: qs([x for x in l[1:] if x<=l[0]])+[l[0]]+qs([x for x in l if x>l[0]]) if l else [] | |
| self._pLstA = qs(self._pLstA) | |
| self._pStrA = str(mt.sin(mt.floor(mt.sqrt(self._pLstA[2]/self._pLstA[0])*self._pLstA[1]))).replace('.',"").strip('-') | |
| self._rNmrG = len(self._pStrA) | |
| self._rNmrB = int(self._pStrA) | |
| self._pLstA = [[None for _ in range(self._rNmrG)] for _ in range(self._rNmrG)] | |
| for self._rNmrD in range(self._rNmrG): | |
| self._rNmrC = mt.floor((self._rNmrB-self._rNmrA)-(self._rNmrD+self._rNmrD)) | |
| if lesser: self._rNmrC+=1 | |
| else: self._rNmrC-=1 | |
| for self._rNmrE in range(self._rNmrG): | |
| if lesser: | |
| self._pLstA[self._rNmrD][self._rNmrE] = str(mt.sin(mt.ceil(self._rNmrC+mt.sqrt(((self._42Y_PidA/4)+self._rNmrD))/(self._rNmrE+1)))) | |
| else: | |
| self._pLstA[self._rNmrD][self._rNmrE] = str(mt.sin(mt.ceil(self._rNmrC+mt.sqrt(((self._42Y_PidA/4)-self._rNmrD))/(self._rNmrE+1)))) | |
| if self._pLstA[self._rNmrD][self._rNmrE].find('-'): | |
| self._pLstA[self._rNmrD][self._rNmrE] = f'{self._pLstA[self._rNmrD][self._rNmrE][2:len(self._pLstA[self._rNmrD][self._rNmrE])]}' | |
| else: | |
| self._pLstA[self._rNmrD][self._rNmrE] = f'{self._pLstA[self._rNmrD][self._rNmrE][3:len(self._pLstA[self._rNmrD][self._rNmrE])]}' | |
| if len(self._pLstA[self._rNmrD][self._rNmrE]) > self._rNmrG: | |
| self._pLstA[self._rNmrD][self._rNmrE] = self._pLstA[self._rNmrD][self._rNmrE][0:self._rNmrG] | |
| elif len(self._pLstA[self._rNmrD][self._rNmrE]) < self._rNmrG: | |
| for self._rNmrF in range(len(self._pLstA[self._rNmrD][self._rNmrE]),self._rNmrG): | |
| self._pLstA[self._rNmrD][self._rNmrE] = f'{self._pLstA[self._rNmrD][self._rNmrE]}{0}' | |
| self._reset_numbers(False) | |
| #__________________________________________________________________________________ | |
| def _find_palindrome(self, r: bool) -> bool: | |
| # Compares ranges of numbers changed for a first palindrome number to set. | |
| if not r: | |
| for self._rNmrD in range(self._rNmrA-1,0,-1): | |
| if self._is_palindrome(self._rNmrD): | |
| self._rNmrC = self._rNmrD | |
| return True | |
| else: | |
| for self._rNmrD in range(self._rNmrA+1,self._rNmrB): | |
| if self._is_palindrome(self._rNmrD): | |
| self._rNmrC = self._rNmrD | |
| return True | |
| return False | |
| #__________________________________________________________________________________ | |
| def _char_count(self, src: str) -> int: | |
| # Returns a marked running count of found subset-chars from source. | |
| self._rNmrE = 0 | |
| for self._rStrA in src: | |
| if set(self._rStrA).issubset(self._sLstA): | |
| self._rNmrE+=1 | |
| self._fLstA[0]+=1 | |
| elif set(self._rStrA).issubset(self._sLstB): | |
| self._rNmrE+=2 | |
| self._fLstA[1]+=2 | |
| elif set(self._rStrA).issubset(self._sLstC): | |
| self._rNmrE+=3 | |
| self._fLstA[2]+=3 | |
| elif set(self._rStrA).issubset(self._sLstD): | |
| self._rNmrE+=4 | |
| self._fLstA[3]+=4 | |
| #__________________________________________________________________________________ | |
| def _process_char_counts(self): | |
| # Performs multi-threading for listed split sources into subset counts. | |
| self._rLstA = [] | |
| self._rLstB = [] | |
| lock = tr.Lock() | |
| def _tr_wrkr(src): | |
| self._char_count(src) | |
| with lock: self._rLstA.append(self._rNmrE) | |
| for self._rStrB in self._pLstA: | |
| t = tr.Thread(target=_tr_wrkr,args=(self._rStrB,)) | |
| t.start() | |
| self._rLstB.append(t) | |
| for t in self._rLstB: t.join() | |
| #__________________________________________________________________________________ | |
| def _is_palindrome(self, n: int) -> bool: | |
| # Returns True if int is palindrome. | |
| print(n) | |
| self._fStrA = str(n) | |
| self._fNmrA = int(self._fStrA[::-1]) | |
| return self._fNmrA == n | |
| #__________________________________________________________________________________ | |
| def _checksum_px42_mast(self, src: str, uid: str, pmr: int) -> str: | |
| # Performs needed checking of input str parameter @uid. Split of the return | |
| # string @ char ':' @ <list>[0] is either an 'PX42=VALID' or 'PX42=INVALID' | |
| if not len(src) > 4222: | |
| return 'PX42=INVALID: file source less than expected...' | |
| self._sLstA = set('abcdefghijklmnopqurstvwxyzABCDEFGHIJKLMNOPQURSTVWXYZ') | |
| self._sLstB = set('1234567890') | |
| self._sLstC = set('+×÷=/_<>[]@#$%^&*()-":;,?!.') | |
| self._sLstD = set('`~\|{}¿°') | |
| self._rLstA = uid.split('=') | |
| self._rNmrA = 0 | |
| pk42 = None | |
| if len(self._rLstA) == 2: | |
| while self._rNmrA < 2: | |
| if self._rNmrA == 0: | |
| self._rLstB = self._rLstA[0].split('-') | |
| if len(self._rLstB) == 2: | |
| if self._rLstB[0] == 'PX42G' or self._rLstB[0] == 'PX42L': | |
| if set(self._rLstB[1]).issubset(self._sLstB): | |
| pk42 = int(self._rLstB[1]) | |
| if not self._is_palindrome(pk42): | |
| return f'PX42=INVALID: palindrome key is not a palindrome number, ({uid})' | |
| else: | |
| return f'PX42=INVALID: palindrome key has non-number chars, ({uid})' | |
| else: | |
| return f'PX42=INVALID: palindrome key type is incorrect, ({uid})' | |
| else: | |
| return f'PX42=INVALID: dash length to palindrome key does not match, ({uid})' | |
| else: | |
| if set(self._rLstA[1]).issubset(self._sLstB): self._42X_MidA = int(self._rLstA[1]) | |
| else: | |
| return f'PX42=INVALID: multi-palindrome key has non-number chars, ({uid})' | |
| self._rNmrA+=1 | |
| # PX42-uid chars structure passed. | |
| self._cBlnA = True | |
| if self._checksum_px42_deck(src, pk42, pmr): | |
| self._reset_lists(True,True) | |
| self._42Y_PidA = self._rNmrC | |
| self._reset_numbers(False) | |
| self._pLstA = [len(src),len(src)-(len(src)/4),len(src)+(len(src)/4)] | |
| return self._resolve_px42_main() | |
| else: | |
| return f'PX42=INVALID: palindrome key was not found, ({uid})' | |
| else: | |
| return f'PX42=INVALID: overall uid equality length does not match, ({uid})' | |
| #__________________________________________________________________________________ | |
| def _checksum_px42_deck(self, fSrc: str, pk: int, rng: int) -> bool: | |
| # Loop runs @._nearest_palindrome() function to find a valid @pk. | |
| for p in range(rng): | |
| try: | |
| self._nearest_palindrome(fSrc) | |
| print(self._rNmrC) | |
| if self._rNmrC == pk: | |
| return True | |
| except Exception as e: | |
| print(self._rNmrC) | |
| pass | |
| return False | |
| #__________________________________________________________________________________ | |
| def _reset_lists(self, positionals: bool, sets: bool): | |
| # Resets slots list/set types to None. | |
| if sets: | |
| self._sLstA = None | |
| self._sLstB = None | |
| self._sLstC = None | |
| self._sLstD = None | |
| if positionals: | |
| self._pLstA = None | |
| self._rLstA = None | |
| self._rLstB = None | |
| self._rLstC = None | |
| #__________________________________________________________________________________ | |
| def _reset_strings(self, positionals: bool): | |
| # Resets slots string types to None. | |
| if positionals: | |
| self._pStrA = None | |
| self._rStrA = None | |
| self._rStrB = None | |
| self._rStrC = None | |
| self._rStrD = None | |
| self._rStrE = None | |
| #__________________________________________________________________________________ | |
| def _reset_numbers(self, positionals: bool): | |
| # Resets slots numbers types to None. | |
| if positionals: | |
| self._pNmrA = None | |
| self._rNmrA = None | |
| self._rNmrB = None | |
| self._rNmrC = None | |
| self._rNmrD = None | |
| self._rNmrE = None | |
| self._rNmrF = None | |
| self._rNmrG = None | |
| self._rNmrH = None | |
| #__________________________________________________________________________________ | |
| #__________________________________________________________________________________ | |
| #__________________________________________________________________________________ | |
| #__________________________________________________________________________________ | |
| # PX42 UID CLASS CALLS FOR CREATE OR CHECKSUM: | |
| def px42_create(file_path: str) -> str: | |
| # Returns a PX42 uid string from @file_path's char structure. | |
| cls = PX42(None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None) | |
| px42_str_rtrn = None | |
| fSrc = None | |
| with open(file_path, mode='r') as fObjFp: | |
| fSrc = fObjFp.read() | |
| while True: | |
| try: | |
| px42_str_rtrn = cls._nearest_palindrome(fSrc) | |
| break | |
| except Exception as e: | |
| pass | |
| return px42_str_rtrn | |
| #__________________________________________________________________________________ | |
| def px42_checksum(file_path: str, px42_uid: str, permutations: int): | |
| # Checks if given px42_uid is valid for @file_path's source. Parameter | |
| # @permutations is number of times to validate the palindrome key --> | |
| # PX42"-<...> is a valid palindrome number for a multi-palindrome key. | |
| # A one run of this function may not start the proper palindrome set, | |
| # the commented out prints @._checksum_px42_deck() will show that. | |
| cls = PX42(None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None) | |
| px42_str_rtrn = None | |
| fSrc = None | |
| with open(file_path, mode='r') as fObjFp: | |
| fSrc = fObjFp.read() | |
| px42_str_rtrn = cls._checksum_px42_mast(fSrc, px42_uid, permutations) | |
| return px42_str_rtrn | |
| #__________________________________________________________________________________ | |
| #__________________________________________________________________________________ | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment