CodExt

कुछ भी एन्कोड/डीकोड करें।

CodExt एक (Python2-3 संगत) लाइब्रेरी है जो मूल codecs लाइब्रेरी का विस्तार करती है (विशेष रूप से नए कस्टम एन्कोडिंग और कैरेक्टर मैपिंग जोड़ने के लिए) और 120+ नए कोडेक्स प्रदान करती है, इसलिए इसका नाम CODecs EXTension को जोड़ता है। यह एन्कोडिंग की कई परतों को डीकोड करने के लिए एक अनुमान मोड और सुविधा के लिए CLI टूल्स भी प्रदान करती है।```sh $ pip install codext

नया codec जोड़ना चाहते हैं? | नया macro जोड़ना चाहते हैं?
:----------------------------------:|:------------------------------------:
पहले [documentation](https://python-codext.readthedocs.io/en/latest/howto) देखें<br>फिर अपने नए codec के लिए [PR](https://github.com/dhondta/python-codext/pulls) करें | [PR](https://github.com/dhondta/python-codext/pulls) अपने अपडेटेड संस्करण के साथ [`macros.json`](https://github.com/dhondta/python-codext/blob/main/codext/macros.json)

## :mag: प्रदर्शन

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/4821/81514bb87e41cfa9d482c93830d7a2e579352988aae9b0934778095692265bde.gif" alt="Using CodExt from the command line"></p>
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/4821/fa4848c3f817288ed56845964755dbb4c4a0098c76af8a6ac6e5c89f849a8d5e.gif" alt="Using base tools from the command line"></p>
<p align="center">Using the unbase command line tool</p>

## :computer: उपयोग (मुख्य CLI टूल) <a href="https://twitter.com/intent/tweet?text=CodExt%20-%20Encode%2Fdecode%20anything.%0D%0APython%20tool%20for%20encoding%20and%20decoding%20almost%20anything,%20including%20a%20guess%20feature%20based%20on%20AI.%0D%0Ahttps%3a%2f%2fgithub%2ecom%2fdhondta%2fpython-codext%0D%0A&hashtags=python,encodings,codecs,cryptography,morse,base,stegano,steganography,ctftools"><img src="https://img.shields.io/badge/Tweet%20(codext)--lightgrey?logo=twitter&amp;style=social" alt="Tweet on codext" height="20"/></a>```session
$ codext -i test.txt encode dna-1
GTGAGCGGGTATGTGA

$ echo -en "test" | codext encode morse
- . ... -

$ echo -en "test" | codext encode braille
⠞⠑⠎⠞

$ echo -en "test" | codext encode base100
👫👜👪👫

⛓️ कोडेक श्रृंखलन```sh

$ echo -en "Test string" | codext encode reverse gnirts tseT

$ echo -en "Test string" | codext encode reverse morse --. -. .. .-. - ... / - ... . -

$ echo -en "Test string" | codext encode reverse morse dna-2 AGTCAGTCAGTGAGAAAGTCAGTGAGAAAGTGAGTGAGAAAGTGAGTCAGTGAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTTAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTGAGAAAGTC

$ echo -en "Test string" | codext encode reverse morse dna-2 octal 101107124103101107124103101107124107101107101101101107124103101107124107101107101101101107124107101107124107101107101101101107124107101107124103101107124107101107101101101107124103101107101101101107124107101107124107101107124107101107101101101107124124101107101101101107124103101107101101101107124107101107124107101107124107101107101101101107124107101107101101101107124103

$ echo -en "AGTCAGTCAGTGAGAAAGTCAGTGAGAAAGTGAGTGAGAAAGTGAGTCAGTGAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTTAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTGAGAAAGTC" | codext -d dna-2 morse reverse test string

### :twisted_rightwards_arrows: मैक्रो का उपयोग```sh
$ codext add-macro my-encoding-chain gzip base63 lzma base64

$ codext list macros
example-macro, my-encoding-chain

$ echo -en "Test string" | codext encode my-encoding-chain
CQQFAF0AAIAAABuTgySPa7WaZC5Sunt6FS0ko71BdrYE8zHqg91qaqadZIR2LafUzpeYDBalvE///ug4AA==

$ codext remove-macro my-encoding-chain

$ codext list macros
example-macro

🖥️ उपयोग (`baseXX` CLI उपकरण)

बेस एन्कोडिंग के साथ खेलना।```session $ echo "Test string !" | base122 *.7!ft9�-f9Â

$ echo "Test string !" | base91 "ONK;WDZM%Z%xE7L

$ echo "Test string !" | base91 | base85 B2P|BJ6A+nO(j|-cttl%

$ echo "Test string !" | base91 | base85 | base36 | base58-flickr QVx5tvgjvCAkXaMSuKoQmCnjeCV1YyyR3WErUUErFf

`KernelSU` एक अगली पीढ़ी का रूटिंग समाधान है जो कर्नेल स्तर पर काम करता है (Linux कर्नेल मॉड्यूल के माध्यम से)। यह `Magisk` के समान है, लेकिन कर्नेल में एकीकृत है, न कि केवल `init_boot` या `boot` पार्टीशन को पैच करने पर निर्भर।

- **ड्राइवर/मॉड्यूल संबंधी आवश्यकता**: यह कस्टम कर्नेल पर निर्भर नहीं करता; इसके लिए या तो डिवाइस के स्टॉक कर्नेल में `KernelSU` के लिए समर्थन होना चाहिए, या एक कस्टम कर्नेल की आवश्यकता होती है जिसमें `KernelSU` शामिल हो। पिक्सेल जैसे कुछ उपकरणों में आसानी से उपलब्ध कर्नेल होते हैं।
- **ज़ाइगिस्क**: ज़ाइगोट प्रक्रिया को पैच करने के लिए अलग मॉड्यूल की आवश्यकता होती है। अपने सीपीयू आर्किटेक्चर के लिए उपयुक्त संस्करण प्राप्त करें (`arm64`, `arm`, `x86_64`, इत्यादि)। कुछ उपकरणों में समर्पित संस्करणों की भी आवश्यकता हो सकती है (जैसे `zygisk-assistant`), इसलिए शोध आवश्यक है।
- **मॉड्यूल**: उपकरणों में बहुत कम अंतर होता है। अधिकांश `Magisk` मॉड्यूल सीधे काम करते हैं। कोई भिन्नता होने पर आमतौर पर स्पष्ट रूप से बताया जाता है।

`KernelSU` के बारे में अधिक जानकारी के लिए [आधिकारिक दस्तावेज़](https://kernelsu.org/) देखें।

`ZygiskNext` (ज़ाइगिस्क नेक्स्ट) के बारे में अधिक जानकारी के लिए [GitHub पेज](https://github.com/Dr-TSNG/ZygiskNext) देखें।

`Shamiko` (शमिको) के बारे में अधिक जानकारी के लिए [GitHub पेज](https://github.com/LSPosed/LSPosed.github.io/releases) देखें।

- **ड्राइवर**: `KernelSU` को कर्नेल मॉड्यूल के उपयोग की आवश्यकता होती है। ड्राइवर सूचीबद्ध किए गए हैं: `kernelsu_susfs`, `overlayfs`, `overlayfs_susfs`। इनमें से किसकी आवश्यकता है? जाँचें कि `KernelSU` किस मोड का उपयोग कर रहा है—"सुपरयूज़र" या "मॉड्यूल"। यह निर्धारित करता है कि किस ड्राइवर की आवश्यकता है।

`KSU` मोड सेट करना (हाँ = सुपरयूज़र / नहीं = केवल मॉड्यूल):
```yaml
# सुपरयूज़र मोड
kernelsu: true
# मॉड्यूल मोड
kernelsu: false

महत्वपूर्ण: सुपरयूज़र मोड और मॉड्यूल मोड के बीच अंतर को समझना आवश्यक है। सुपरयूज़र मोड शेल या ऐप्स को su एक्सेस देता है। मॉड्यूल मोड केवल ज़ाइगिस्क/ज़ाइगोट मॉड्यूल और कुछ उन्नत ओवरले सिस्टम फीचर्स की अनुमति देता है, लेकिन su एक्सेस नहीं। अधिकांश उपयोगकर्ता डिफ़ॉल्ट रूप से सुपरयूज़र मोड चाहते हैं। मॉड्यूल मोड आमतौर पर केवल डिबग उद्देश्यों के लिए उपयोग किया जाता है या जब मॉड्यूल लोड करने के लिए किसी अन्य su समाधान (जैसे magiskpolicy या APatch) का उपयोग किया जा रहा हो।

ज़ाइगिस्क: ZygiskNext का अलग से उपयोग किया जा सकता है या KernelSU के भीतर निर्मित ज़ाइगिस्क के साथ। मैं व्यक्तिगत रूप से अलग ZygiskNext मॉड्यूल का उपयोग करने की सलाह देता हूँ, क्योंकि यह नवीनतम सुविधाएँ लाता है और अधिक स्थिर है। इसके साथ ऐड-ऑन जैसे Zygisk-Assistant भी शामिल किए जा सकते हैं।```session $ echo "Test string !" | base91 | base85 | base36 | base58-flickr | unbase -m 3 Test string !

## :computer: उपयोग (CLI)

कोडेक्स की सूची बनाना।```session
$ codext list encodings
a1z26                      adler32               affine             alternative-rot        ascii           
atbash                     autoclave             bacon              barbie                 base            
base1                      base2                 base3              base4                  base8           
<<snipped>>

एक नाम के आधार पर कोडेक ढूंढना।```session $ codext search bitcoin base58

एक स्ट्रिंग को एन्कोड करना।```sesssion
$ echo -en "This is a test" | codext encode polybius
44232443 2443 11 44154344

एक फ़ाइल को एन्कोड करना।```session $ echo -en "this is a test" > to_be_encoded.txt $ codext encode base64 < to_be_encoded.txt > text.b64 $ cat text.b64 dGhpcyBpcyBhIHRlc3Q=

Codecs को श्रृंखलित करना।```session
$ echo -en "mrdvm6teie6t2cq=" | codext encode upper | codext decode base32 | codext decode base64
test

पुनरावृत्ति से डिकोडिंग का अनुमान लगाना।```session $ echo -en "test" | codext encode base64 gzip | codext guess Codecs: gzip dGVzdA== $ echo -en "test" | codext encode base64 gzip | codext guess gzip -i base Codecs: gzip, base64 test

## :snake: उपयोग (Python)

उपलब्ध कोडेक्स की सूची प्राप्त करना।```python
>>> import codext

>>> codext.list()
['ascii85', 'base85', 'base100', 'base122', ..., 'tomtom', 'dna', 'html', 'markdown', 'url', 'resistor', 'sms', 'whitespace', 'whitespace-after-before']

Playing with some base encodings.

```python
>>> codext.encode("this is a test", "base58-bitcoin")
'jo91waLQA1NNeBmZKUF'

>>> codext.encode("this is a test", "base58-ripple")
'jo9rA2LQwr44eBmZK7E'

>>> codext.encode("this is a test", "base58-url")
'JN91Wzkpa1nnDbLyjtf'

>>> codecs.encode("this is a test", "base100")
'👫👟👠👪🐗👠👪🐗👘🐗👫👜👪👫'

>>> codecs.decode("👫👟👠👪🐗👠👪🐗👘🐗👫👜👪👫", "base100")
'this is a test'```

Playing with some cryptography-based codecs.

```python
>>> codext.encode("This is a test !", "vigenere-MYSECRETKET")
'Ffaw kj e mowm !'

>>> codext.encode("This is a test !", "autoclave-SECRET")
'Llkj ml t amkb !'```

Encoding/decoding with various other codecs.

```python
>>> for i in range(8):
        print(codext.encode("this is a test", "dna-%d" % (i + 1)))
GTGAGCCAGCCGGTATACAAGCCGGTATACAAGCAGACAAGTGAGCGGGTATGTGA
CTCACGGACGGCCTATAGAACGGCCTATAGAACGACAGAACTCACGCCCTATCTCA
ACAGATTGATTAACGCGTGGATTAACGCGTGGATGAGTGGACAGATAAACGCACAG
AGACATTCATTAAGCGCTCCATTAAGCGCTCCATCACTCCAGACATAAAGCGAGAC
TCTGTAAGTAATTCGCGAGGTAATTCGCGAGGTAGTGAGGTCTGTATTTCGCTCTG
TGTCTAACTAATTGCGCACCTAATTGCGCACCTACTCACCTGTCTATTTGCGTGTC
GAGTGCCTGCCGGATATCTTGCCGGATATCTTGCTGTCTTGAGTGCGGGATAGAGT
CACTCGGTCGGCCATATGTTCGGCCATATGTTCGTCTGTTCACTCGCCCATACACT
>>> codext.decode("GTGAGCCAGCCGGTATACAAGCCGGTATACAAGCAGACAAGTGAGCGGGTATGTGA", "dna-1")
'this is a test'

>>> codecs.encode("this is a test", "morse")
'- .... .. ... / .. ... / .- / - . ... -'

>>> codecs.decode("- .... .. ... / .. ... / .- / - . ... -", "morse")
'this is a test'

>>> with open("morse.txt", 'w', encoding="morse") as f:
	f.write("this is a test")
14

>>> with open("morse.txt",encoding="morse") as f:
	f.read()
'this is a test'

>>> print(codext.encode("An example test string", "baudot-tape"))
***.**
   . *
***.* 
*  .  
   .* 
*  .* 
   . *
** .* 
***.**
** .**
   .* 
*  .  
* *. *
   .* 
* *.  
* *. *
*  .  
* *.  
* *. *
***.  
  *.* 
***.* 
 * .*```

## :page_with_curl: List of codecs

#### [BaseXX](https://python-codext.readthedocs.io/en/latest/enc/base)

- [X] `base1`: useless, but for the sake of completeness
- [X] `base2`: simple conversion to binary (with a variant with a reversed alphabet)
- [X] `base3`: conversion to ternary (with a variant with a reversed alphabet)
- [X] `base4`: conversion to quarternary (with a variant with a reversed alphabet)
- [X] `base8`: simple conversion to octal (with a variant with a reversed alphabet)
- [X] `base10`: simple conversion to decimal
- [X] `base11`: conversion to digits with a "*a*"
- [X] `base16`: simple conversion to hexadecimal (with a variant holding an alphabet with digits and letters inverted)
- [X] `base26`: conversion to alphabet letters
- [X] `base32`: classical conversion according to the RFC4648 with all its variants ([zbase32](https://philzimmermann.com/docs/human-oriented-base-32-encoding.txt), extended hexadecimal, [geohash](https://en.wikipedia.org/wiki/Geohash), [Crockford](https://www.crockford.com/base32))
- [X] `base36`: [Base36](https://en.wikipedia.org/wiki/Base36) conversion to letters and digits (with a variant inverting both groups)
- [X] `base45`: [Base45](https://datatracker.ietf.org/doc/html/draft-faltstrom-base45-04.txt) DRAFT algorithm (with a variant inverting letters and digits)
- [X] `base58`: multiple versions of [Base58](https://en.bitcoinwiki.org/wiki/Base58) (bitcoin, flickr, ripple)
- [X] `base62`: [Base62](https://en.wikipedia.org/wiki/Base62) conversion to lower- and uppercase letters and digits (with a variant with letters and digits inverted)
- [X] `base63`: similar to `base62` with the "`_`" added
- [X] `base64`: classical conversion according to RFC4648 with its variant URL (or *file*) (it also holds a variant with letters and digits inverted)
- [X] `base67`: custom conversion using some more special characters (also with a variant with letters and digits inverted)
- [X] `base85`: all variants of Base85 ([Ascii85](https://fr.wikipedia.org/wiki/Ascii85), [z85](https://rfc.zeromq.org/spec/32), [Adobe](https://dencode.com/string/ascii85), [(x)btoa](https://dencode.com/string/ascii85), [RFC1924](https://datatracker.ietf.org/doc/html/rfc1924), [XML](https://datatracker.ietf.org/doc/html/draft-kwiatkowski-base85-for-xml-00))
- [X] `base91`: [Base91](http://base91.sourceforge.net) custom conversion
- [X] `base100` (or *emoji*): [Base100](https://github.com/AdamNiederer/base100) custom conversion
- [X] `base122`: [Base100](http://blog.kevinalbs.com/base122) custom conversion
- [X] `base-genericN`: see [base encodings](https://python-codext.readthedocs.io/en/latest/enc/base) ; supports any possible base

This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `base85` codec.

#### [Binary](https://python-codext.readthedocs.io/en/latest/enc/binary)

- [X] `baudot`: supports CCITT-1, CCITT-2, EU/FR, ITA1, ITA2, MTK-2 (Python3 only), UK, ...
- [X] `baudot-spaced`: variant of `baudot` ; groups of 5 bits are whitespace-separated
- [X] `baudot-tape`: variant of `baudot` ; outputs a string that looks like a perforated tape
- [X] `bcd`: _Binary Coded Decimal_, encodes characters from their (zero-left-padded) ordinals
- [X] `bcd-extended0`: variant of `bcd` ; encodes characters from their (zero-left-padded) ordinals using prefix bits `0000`
- [X] `bcd-extended1`: variant of `bcd` ; encodes characters from their (zero-left-padded) ordinals using prefix bits `1111`
- [X] `excess3`: uses Excess-3 (aka Stibitz code) binary encoding to convert characters from their ordinals
- [X] `gray`: aka reflected binary code
- [X] `manchester`: XORes each bit of the input with `01`
- [X] `manchester-inverted`: variant of `manchester` ; XORes each bit of the input with `10`
- [X] `rotateN`: rotates characters by the specified number of bits (*N* belongs to [1, 7] ; Python 3 only)

#### [Checksums](https://python-codext.readthedocs.io/en/latest/enc/checksums)

- [X] `adler`: Adler32 algorithm (relies on `zlib`)
- [X] `crc`: CRC of lengths 8, 10-17, 21, 24, 30-32, 40, 64, 82 with a variety of polynoms
- [X] `luhn`: Luhn mod N algorithm

#### [Common](https://python-codext.readthedocs.io/en/latest/enc/common)

- [X] `a1z26`: keeps words whitespace-separated and uses a custom character separator
- [X] `cases`: set of case-related encodings (including camel-, kebab-, lower-, pascal-, upper-, snake- and swap-case, slugify, capitalize, title)
- [X] `dummy`: set of simple encodings (including integer, replace, reverse, word-reverse, substite and strip-spaces)
- [X] `octal`: dummy octal conversion (converts to 3-digits groups)
- [X] `octal-spaced`: variant of `octal` ; dummy octal conversion, handling whitespace separators
- [X] `ordinal`: dummy character ordinals conversion (converts to 3-digits groups)
- [X] `ordinal-spaced`: variant of `ordinal` ; dummy character ordinals conversion, handling whitespace separators

#### [Compression](https://python-codext.readthedocs.io/en/latest/enc/compressions)

- [X] `gzip`: standard Gzip compression/decompression
- [X] `lz77`: compresses the given data with the algorithm of Lempel and Ziv of 1977
- [X] `lz78`: compresses the given data with the algorithm of Lempel and Ziv of 1978
- [X] `pkzip_deflate`: standard Zip-deflate compression/decompression
- [X] `pkzip_bzip2`: standard BZip2 compression/decompression
- [X] `pkzip_lzma`: standard LZMA compression/decompression

> :warning: Compression functions are of course definitely **NOT** encoding functions ; they are implemented for leveraging the `.encode(...)` API from `codecs`.

#### [Cryptography](https://python-codext.readthedocs.io/en/latest/enc/crypto)

- [X] `affine`: aka Affine Cipher
- [X] `atbash`: aka Atbash Cipher
- [X] `autoclave`: aka Autoclave/Autokey Cipher (variant of Vigenere Cipher)
- [X] `bacon`: aka Baconian Cipher
- [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
- [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
- [X] `citrix`: aka Citrix CTX1 password encoding
- [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
- [X] `polybius`: aka Polybius Square Cipher
- [X] `railfence`: aka Rail Fence Cipher
- [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])
- [X] `scytaleN`: encrypts using the number of letters on the rod (*N* belongs to [1,[)
- [X] `shiftN`: shift ordinals (*N* belongs to [1,255])
- [X] `trithemius`: aka Trithemius Cipher (variant of Vigenere Cipher)
- [X] `vigenere`: aka Vigenere Cipher
- [X] `xorN`: XOR with a single byte (*N* belongs to [1,255])

> :warning: Crypto functions are of course definitely **NOT** encoding functions ; they are implemented for leveraging the `.encode(...)` API from `codecs`.

#### [Hashing](https://python-codext.readthedocs.io/en/latest/enc/hashing)

- [X] `blake`: includes BLAKE2b and BLAKE2s (Python 3 only ; relies on `hashlib`)
- [X] `crypt`: Unix's crypt hash for passwords (Python 3 and Unix only ; relies on `crypt`)
- [X] `md`: aka Message Digest ; includes MD4 and MD5 (relies on `hashlib`)
- [X] `sha`: aka Secure Hash Algorithms ; includes SHA1, 224, 256, 384, 512 (Python2/3) but also SHA3-224, -256, -384 and -512 (Python 3 only ; relies on `hashlib`)
- [X] `shake`: aka SHAKE hashing (Python 3 only ; relies on `hashlib`)

> :warning: Hash functions are of course definitely **NOT** encoding functions ; they are implemented for convenience with the `.encode(...)` API from `codecs` and useful for chaning codecs.

#### [Languages](https://python-codext.readthedocs.io/en/latest/enc/languages)

- [X] `braille`: well-known braille language (Python 3 only)
- [X] `ipsum`: aka lorem ipsum
- [X] `galactic`: aka galactic alphabet or Minecraft enchantment language (Python 3 only)
- [X] `leetspeak`: based on minimalistic elite speaking rules
- [X] `morse`: uses whitespace as a separator
- [X] `navajo`: only handles letters (not full words from the Navajo dictionary)
- [X] `radio`: aka NATO or radio phonetic alphabet
- [X] `southpark`: converts letters to Kenny's language from Southpark (whitespace is also handled)
- [X] `southpark-icase`: case insensitive variant of `southpark`
- [X] `tap`: converts text to tap/knock code, commonly used by prisoners
- [X] `tomtom`: similar to `morse`, using slashes and backslashes

#### [Others](https://python-codext.readthedocs.io/en/latest/enc/others)

- [X] `dna`: implements the 8 rules of DNA sequences (N belongs to [1,8])
- [X] `letter-indices`: encodes consonants and/or vowels with their corresponding indices
- [X] `markdown`: unidirectional encoding from Markdown to HTML

#### [Steganography](https://python-codext.readthedocs.io/en/latest/enc/stegano)

- [X] `hexagram`: uses Base64 and encodes the result to a charset of [I Ching hexagrams](https://en.wikipedia.org/wiki/Hexagram_%28I_Ching%29) (as implemented [here](https://github.com/qntm/hexagram-encode))
- [X] `klopf`: aka Klopf code ; Polybius square with trivial alphabetical distribution
- [X] `resistor`: aka resistor color codes
- [X] `rick`: aka Rick cipher (in reference to Rick Astley's song "*Never gonna give you up*")
- [X] `sms`: also called _T9 code_ ; uses "`-`" as a separator for encoding, "`-`" or "`_`" or whitespace for decoding
- [X] `whitespace`: replaces bits with whitespaces and tabs
- [X] `whitespace_after_before`: variant of `whitespace` ; encodes characters as new characters with whitespaces before and after according to an equation described in the codec name (e.g. "`whitespace+2*after-3*before`")

#### [Web](https://python-codext.readthedocs.io/en/latest/enc/web)

- [X] `html`: implements entities according to [this reference](https://dev.w3.org/html5/html-author/charref)
- [X] `url`: aka URL encoding


## :clap:  Supporters

[![Stargazers repo roster for @dhondta/python-codext](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](https://github.com/dhondta/python-codext/stargazers)

[![Forkers repo roster for @dhondta/python-codext](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](https://github.com/dhondta/python-codext/network/members)

<p align="center"><a href="#top"><img src="https://img.shields.io/badge/Back%20to%20top--lightgrey?style=social" alt="Back to top" height="20"/></a></p>

python-codext

सबसे लोकप्रिय

CodExt

कुछ भी एन्कोड/डीकोड करें।

⛓️ कोडेक श्रृंखलन```sh

🖥️ उपयोग (baseXX CLI उपकरण)

🖥️ उपयोग (`baseXX` CLI उपकरण)