Saravanan666/pypi-org huggingface dataset:
Package: xontrib-vox
Python virtual environment manager for xonsh shell.If you like the idea click ⭐ on the repo andtweet.InstallationTo install use pip:xpipinstallxontrib-vox# or: xpip install -U git+https://github.com/xonsh/xontrib-voxUsageThis package contains three xontribs:vox- Python virtual environment manager for xonsh.autovox- Manages automatic activation of virtual environments.voxapi- API for Vox, the Python virtual environment manager for xonsh.voxPython virtual environment manager for xonsh.xontribloadvox
vox--helpautovoxManages automatic activation of virtual environments.xontribloadautovoxThis coordinates multiple automatic vox policies and deals with some of the
mechanics of venv searching and chdir handling.This provides no interface for end users.Developers should look at XSH.builtins.events.autovox_policyvoxapiAPI for Vox, the Python virtual environment manager for xonsh.xontribloadvoxapiVox defines several events related to the life cycle of virtual environments:vox_on_create(env: str) -> Nonevox_on_activate(env: str, path: pathlib.Path) -> Nonevox_on_deactivate(env: str, path: pathlib.Path) -> Nonevox_on_delete(env: str) -> NoneCreditsThis package was created withxontrib template.
Package: xontrib-whole-word-jumping
Jump/delete across whole (non-whitespace) words with Ctrl+Left/Right/Delete/Backspace.If you like the idea click ⭐ on the repo andtweet.InstallationTo install use pip:xpipinstallxontrib-whole-word-jumping# or: xpip install -U git+https://github.com/xonsh/xontrib-whole-word-jumpingUsagexontribloadwhole_word_jumpingControl+left/right: Jump to previous/next whole wordControl+backspace: Delete to beginning of whole wordControl+delete: Delete to end of whole wordShift+delete: Delete whole wordAlt+Left/Right/Delete/Backspace remain unmodified:Alt+left/right: Jump to previous/next tokenAlt+backspace: Delete to beginning of tokenAlt+delete: Delete to end of tokenKnown issuesSome terminals cannot differentiate between Backspace and Control+Backspace.
In this case, users can set$XONSH_WHOLE_WORD_CTRL_BKSP = Falseto skip
configuration of the Control+Backspace key binding.CreditsThis package was created withxontrib template.
Package: xontrib-xpg
Postgresql Xonsh Python ToolsA bunch of scritps to use postgresql in xonsh.  Install
as usualpython3 setup.py install --userUsageStart xonsh, load the macros in xonshrc.   If user not doing
anyting, xpg will connection to the default database as default
user -- most likely this means $USER.Notice that we do not use ; to end the query.   Just press return
and xonsh will handle multiline just fine.Run a sqlsql! select i, i*2 as j from generate_series(1, 100) iExecute sql, don't care about resultsqlexec! create table t(i int, j int)Define an xtablepgxt give sql query an alias.  Later you can refer to the alias
using @foo@, or @foo.column@.pgxt foo !select i, i*2 as j from generate_series(1, 100) i
pgxt bar !select i, i*2 as j from generate_series(1, 100) i
pgxt zoo !select @foo@.i, @bar@.j from @foo@, @bar@ where @foo@.i = @bar.i@
pgxt zoo # This is to printPlottingI use kitty, icat is an alias of kitty +kitten icat.  Replace icat with
your favorite image viewer.pgxtplot line zoo    # plot zoo, each column will be a line, x axias is [0-n)
pgxtplot xline zoo   # plot zoo, first column as x axis. 
pgxtplot pie zoo     # pie chart, first column is category, second is weight.
pgxtexp zoo          # explain
pgxtexp zoo analyze  # explain analyze
pgxthist xtable col nbkt # histogram of xtable.col, in n bucketspgxtctllist, rm, clear, cleartmp, manage the xtables.
Package: xontrib-zoxide
Zoxide integration for xonshIf you like the idea click ⭐ on the repo and stay tuned.RequirementsYou needzoxideinstalled on your system. Seeinstall instructionsto get it.InstallationTo install use pip:xpipinstallxontrib-zoxide# or: xpip install -U git+https://github.com/dyuri/xontrib-zoxideUsagexontribloadzoxide
zfolderSeezoxidefor detailed usage.CreditsThis package was created withxontrib cookiecutter template.
Package: xoo
📦 setup.py (for humans)This repo exists to providean example setup.pyfile, that can be used
to bootstrap your next Python project. It includes some advanced
patterns and best practices forsetup.py, as well as some
commented–out nice–to–haves.For example, thissetup.pyprovides a$ python setup.py uploadcommand, which creates auniversal wheel(andsdist) and uploads
your package toPyPiusingTwine, without the need for an annoyingsetup.cfgfile. It also creates/uploads a new git tag, automatically.In short,setup.pyfiles can be daunting to approach, when first
starting out — even Guido has been heard saying, "everyone cargo cults
thems". It's true — so, I want this repo to be the best place to
copy–paste from :)Check out the example!Installationcdyour_project# Download the setup.py file:#  download with wgetwgethttps://raw.githubusercontent.com/navdeep-G/setup.py/master/setup.py-Osetup.py#  download with curlcurl-Ohttps://raw.githubusercontent.com/navdeep-G/setup.py/master/setup.pyTo DoTests via$ setup.py test(if it's concise).Pull requests are encouraged!More ResourcesWhat is setup.py?on Stack OverflowOfficial Python Packaging User GuideThe Hitchhiker's Guide to PackagingCookiecutter template for a Python packageLicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.
Package: xoodyak
A sample Python projectA sample project that exists as an aid to thePython Packaging User
Guide'sTutorial on Packaging and Distributing
Projects.This project does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.The source for this project is available here.Most of the configuration for a Python project is done in thesetup.pyfile,
an example of which is included in this project. You should edit this file
accordingly to adapt this sample project to your needs.This is the README file for the project.The file should use UTF-8 encoding and can be written usingreStructuredTextormarkdownwith the appropriatekey set. It will be used to generate the project webpage on PyPI and will be
displayed as the project homepage on common code-hosting services, and should be
written for that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not a
good idea, although a simple “What's New” section for the most recent version
may be appropriate.
Package: xooof.schema.dev
Introduction============xooof.schema.dev generate zope.interfaces.Interface interfaces based onstructure declared in xml format based on the struct.dtd.xooof.schema.dev is a tools parts of the xooof framework. Seehttp://www.xooof.orgChangelog=========Version 0.1.1 - (2009-01-97)----------------------------- fix main function entry points (accept *args and **kwargs)- fix _stringToStringValue for boolean. When passing "0" as default value for tboolean, it was interpreted as True (changeset:278)Version 0.1------------ Initial release
Package: xorbits-sql
Xorbits SQL: made pandas and SQL APIs work seamlessly togetherXorbits SQL provides a SQL interface built onXorbits,
allowing you to fluidly combine pandas and SQL to solve problems using the most familiar interface.👉 Join our Slack community!Xorbits SQL is still at an early development stage and under active improvement.
Please feel free to provide feedback if you encounter any issues or have any suggestion.Key features🌟Pandas and SQL APIs in one: The popular pandas and SQL APIs now work seamlessly together.⚡️Out-of-core and distributed capabilities: Thanks to the underlying Xorbits execution engine,
out-of-core and distributed runtimes are natively supported.🔌Mainstream SQL dialects compatible: By leveragingSQLGlotas the SQL parser,
Xorbits SQL is compatible with many dialects including DuckDB, Presto, Spark, Snowflake, and BigQuery.Getting StartedXorbits SQL can be installed via pip from PyPI. It is highly recommended to create a new virtual
environment to avoid conflicts.Installation$pipinstall"xorbits_sql"Quick StartXorbits SQL provides a single APIexecute()which will return an Xorbits DataFrame.importxorbits.pandasaspdimportxorbits_sqlasxsqldf=pd.DataFrame({"a":[1,2,3],"b":['a','b','a']})# SQLsql="""select b, AVG(a) as resultfrom tgroup by b"""df2=xsql.execute(sql,dialect=None,# optional, replace with SQL dialect, e.g. "duckdb"tables={'t':df}# register table, table name to Xorbits DataFrame)print(df2)LicenseApache 2
Package: xor-cipher
xor-cipherSimple, reusable and optimized XOR ciphers in Python.xor-cipheris a fast implementation of the XOR cipher written using Cython.
Our tests show that it can be1000xfaster than pure Python implementations.
It has been optimized to breeze through datasets of any size.InstallingPython 3.8 or above is required.pipInstalling the library withpipis quite simple:$pipinstallxor-cipherAlternatively, the library can be installed from source:$gitclonehttps://github.com/xor-cipher/xor-cipher.git$cdxor-cipher$python-mpipinstall.poetryYou can addxor-cipheras a dependency with the following command:$poetryaddxor-cipherOr by directly specifying it in the configuration like so:[tool.poetry.dependencies]xor-cipher="^3.2.1"Alternatively, you can add it directly from the source:[tool.poetry.dependencies.xor-cipher]git="https://github.com/xor-cipher/xor-cipher.git"ExamplesSimple CipherUse thexorfunction to perform the simple XOR cipher:>>>fromxor_cipherimportxor>>>xor(b"Hello, world!",0x42)b"\n'..-nb5-0.&c"Cyclic CipherUse thecyclic_xorfunction to perform the cyclic XOR variation:>>>fromxor_cipherimportcyclic_xor>>>cyclic_xor(b"Hello, world!",b"BLOB")b"\n)#.-`o5->#&c"String Cipherxor-cipherprovidesxor_stringandcyclic_xor_stringas variations ofxorandcyclic_xor, respectively:>>>fromxor_cipherimportxor_string>>>xor_string("Hello, world!",0x42)"\n'..-nb5-0.&c"In-Place CipherThere are functions to perform the XOR cipher in-place, onbytearrayinstances:>>>fromxor_cipherimportxor_in_place>>>data=bytearray(b"Hello, world!")>>>xor_in_place(data,0x42)>>>databytearray(b"\n'..-nb5-0.&c")DocumentationYou can find the documentationhere.SupportIf you need support with the library, you can send anemail.ChangelogYou can find the changeloghere.Security PolicyYou can find the Security Policy ofxor-cipherhere.ContributingIf you are interested in contributing toxor-cipher, make sure to take a look at theContributing Guide, as well as theCode of Conduct.Licensexor-cipheris licensed under the MIT License terms. SeeLicensefor details.
Package: xorCryptPy
XOR-Crypt-PythonA simple XOR string encryption library based on the JavaScript libraryXOR-CryptbyRobLoachbut in Python.InstallationpipinstallxorCryptPyYou can also download the package manually fromPyPI.UsageWorks exactly like the JavaScript version. The same function encrypts and descripts a string using a given key.fromxorCryptPyimportxorCryptencrypted=xorCrypt('Hello World')# Outputs: Ncjji&Qitjbdecrypted=xorCrypt(encrypted)# Outputs: Hello World# Use your own XOR Key.encrypted=xorCrypt('Hello World',9)decrypted=xorCrypt(encrypted,9)(The default key is the same as the one from the JavaScript version!)LicenseLicensed under theMIT license
Package: xorencryption
XOR EncryptionXOR Encryption is a little Python library for encrypt and decrypt string with key.
This library is for those of you who are learning encryption using the XOR method.How it WorksThe library uses a simple encryption algorithm that converts plain text and keys to binary form and then XORs them both to generate cipher text.
Here's the mathematical notation:Because performing XOR operations with the same value twice in a row yields the original value, the following is the mathematical notation for decryption:Note:P = Plain textK = KeyC = Cipher textHow to UseExample code:from xorencryption import XOREncryption

plain = "this is your plain text"
key = "boom"
enc = XOREncryption()

enc.set_plaintext(plaintext=plain)
enc.set_key(key=key)

print(enc.encrypt())  # return cipher text
print(enc.decrypt())  # return decrypted text
Package: xorius
xoriusA LLM-based agentInstallationpipinstallxoriusUsageUsage: xorius-cli [OPTIONS]

Options:
  --api-key TEXT        [required]
  --temperature FLOAT   [default: 0.7]
  --max-tokens INTEGER  [default: 512]
  --proxy TEXT
  --help                Show this message and exit.e.g.:xorius-cli--api-key<YOUROPENAIAPIKEY>\--temperature0.7\--max-tokens512\--proxyhttp://localhost:8080
Package: xorsms
Thanks for installing “xorsms!”With xorsms you can send SMS messages almost instantly using gmail, as long as you know the receivers phone provider! If you’re not sure of this information don’t worry, xorsms will find that information for you!!!! WARNING !!!
In order for this to work properly make sure you go tohttps://myaccount.google.com/and turn on less secure access. It is not recommended you do this! So we recommend creating another gmail account and turing off less secure access after you are done using our services!
Package: xor_string
# xor_string![PyPI downloads](https://img.shields.io/pypi/dm/xor_string.svg) ![PyPI version](https://img.shields.io/pypi/v/xor_string.svg) ![PyPI python version](https://img.shields.io/pypi/pyversions/xor_string.svg)Python doesn't support (natively) XOR on everything else than int, and this is annoying.```>>> 'hello' ^ 'world'Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: unsupported operand type(s) for ^: 'str' and 'str'```Fortunately, Python has the (amazing) itertools module.## unit tests* `nosetests -v`## ExplanationsFor those who are not familiar with python:* cycle(key) returns an iterator that produces an infinite concatenation of key's content* izip(a, b) returns an iterator that aggregates elements from each of the iterables. It stops on the shortest input sequence (here, our message, since cycle(key) is infinite* ord(a) and chr(57) return (respectively) the integer representing the given char and the char represented by the given integer.* ''.join() (roughly) concatenate every items of the list passed in argument in a string
Package: xor-tools
XOR toolsDescriptionA set of tools for XOR encryption/decryption/key recovery (based on known plaintext).Installgit clone https://github.com/lukaskuzmiak/xor_tools.git
python setup.py installExample UsageFirst, we create example XOR encryptedsamples/binary_pe32file:xor_encrypt_file-fsamples/binary_pe32-oencrypted.file-k"secret"You can also enter non-ascii keys as-k "\xaa\xbb\xcc\xdd".To recover the secret keysecret, the second toolxor_key_recoveryis used. We expect a PE binary to contain a phraseThis program cannot be run in DOS. We don't know the key length, but after few tries with consecutive-n 1,-n 2,-n 3... we finally try-n 6:xor_key_recovery-fencrypted.file-odecrypted.file-p"This program cannot be run in DOS"-n6[+]Foundplaintextatposition:78[*]Keyfound:736563726574[+]Savingdecryptedfileto:decrypted.fileYou can also enter non-ascii plaintext as-p "\xaa\xbb\xcc\xdd".How it worksIt's quite easy to understand on example but it's not a formal proof though (or maybe because of it).Prepare templateFirst we need part of plaintext before being encrypted. Anything slightly longer than key length would be sufficient but to avoid false positives twice as long plaintext is preferred. We could in many cases guess it (like common phrases, strings etc.).P[] = "This program cannot be run in DOS"The other thing we will need is secret key length -- we could also guess it or iterate over possible key lengths (n=3, n=4, n=5 ...).keylength = 6Now, if we xor symbols from plaintext that are keylength apart, we receive:T[1] = P[i] XOR P[i+k_len]We build template that way of first part of the string XORed with another symbols one keylength apart.Surprising XOR cipher characteristicsBecause in ciphertext symbols one keylength apart are XORed with the same secret key symbol we get:C[i] = P[i] XOR Key[i]
C[i+k_len] = P[i+k_len] XOR Key[i]If we XOR these two, we surprisingly (because of XOR characteristics) receive something independent from secret key used:C[i] XOR C[i+k_len] = ( P[i] XOR Key[i] ) XOR ( P[i+k_len] XOR Key[i] ) =
                    = ( P[i] XOR P[i+k_len] ) XOR ( Key[i] XOR Key[i] ) =
                    = P[i] XOR P[i+k_len]This is exactly the same, as our template and it's independent from secret key.Final blowNow, when we do this for whole ciphertext (eg. encrypted file) we look for our template.
This way, we've found place in ciphertext where our encrypted string is and w know what it's plaintext version is.From this place, it's trivial to extract secret key.Bugs & CreditsPlease submit bugs/propositions via GitHub.Original author: nshadov
Package: xost
Xost is a small embedded server which simplifies hosting of django applications.RequirementstwistedUsageInstalling the application:pip install xostadd xost to your INSTALLED_APPS:INSTALLED_APPS = (
    ....,
    ‘xost’
)Xost is configured via the XOST key in settings.py:XOST= {
    ‘key’: ‘value’
}possible configuration keys are listed below (default values are provided after = sign):address: None - string configuration listen addresses
port = 8080 - a port number on which to listen
min_threads = 5 - minimum number of threads in the pool
max_threads = 20 - maximum number of threads in the pool
root = ‘launch_folder’ - path to working (root) folder
static_root = ‘launch_folder/static/’ - path to static file folder
media_root = ‘launch_folder/media/ - path to media file folder
log_path = ‘launch_folder/log/’ -path to log folder
collect_static = True - do not collect static files to  static root folder before launch
debug = False - if set to true, prints debug informationstartup:python manage.py serveby default server starts on port 8080in order to get full list of configuration keys, runpython manage.py serve --help
Package: xotes
Xotes - personal note management systemXotes is a personal note management system.  Features include:written in python3, should work on most systemslibrary, command line, and ncurses interfacesgitstorage backend, for simple sharing between devicesxapianfull text index and search of all notes (optional)GitJournalcompatibilityDependencies:python3GitPythonPyYAMLdateutilurwidfor ncurses interface (optional)Xapian python3 bindings(optional)All dependencies are commonly available through your favorite python
package manager.Xotes is managed onGitLab.Xotes was written byJameson Graef Rollins.synchronizing between devices via gitXotes stores notes in a git repo, and can synchronize the store with
any git remotes configured in the store's git repo.  To configure,
simplyset up git
remotesin the store's git repo as you would in any normal git repo, then use
theStore.sync()command or the command line--syncoption to
synchronize.  SeeStore.ROOTor the command line--helpfor the
file system location of your store.fast sync with SSHIf you use SSH remotes, synchronization can be sped up considerably by
usingSSH connection
multiplexing.
By specifying aControlMasterfor your ssh connection, ssh can hold
open a connection to the remote, speeding up subsequent operations
considerably.For example, for remotegitjournal@example.comthe following.ssh/configstanza should setup a multiplexing socket just for your
gitjournal remote:Match originalhost example.com, user gitjournal
ControlMaster auto
ControlPersist yesfaster editing with emacsIf you use emacs to edit notes you can use theemacs
serverto speed up
editing considerably.I use a special emacs session just for xotes editing.  In a wrapper
script I have the emacs daemon launch if it's not running:if!emacsclient--socket-name=xotes-e'()'>/dev/null;thenemacs--daemon=xotesfiAnd then I set the EDITOR environment variable to use emacsclient:exportEDITOR="emacsclient --socket-name=xotes -t"recommended gitjournal configXotes works very well withGitJournal.
While xotes should work with GitJournal out of the box, not all of the
potential GitJournal configuration options have been fully tested.  In
particular, xotes currently does expect the YAML header to be present.The following GitJournal settings may provide the best performance:in "Note Metadata Settings":"Enable YAML Header""Modified Field" should be "modified""Created Field" should be "created"While xotes will support any note file name, "Uuid V4" file names
are the most sensible, imho.
Package: xotl.plato
This package allows to serialize/deserialize data in a JSON friendly manner by
using and manipulating types.It features a type system that is extensible and it has been specifically
designed to avoid non-termination issues with recursive data.  In a word, we
don’t allow to create recursive types; any notion of recursion is not part of
the type system itself.Having these types, we can now cast dataclasses into schemata by attaching a
type to it.  We can automatically build the type of most basic Python types,
enumerations and other.
Package: xotl.ql
This package provides an implementation of a query language for Python.
The query language is based on Python’s generator expression. A query
in this language looks like this:>>> from xotl.ql import these, parent

>>> query = these(child
...               for parent in this
...               if parent.children & parent.age > 32
...               for child in parent.children
...               if child.age < 6)The resultantqueryis an object that “describes” at the syntactical
level the query expression above.Full documentation kept atRead the doc.How to contributeYou may contribute as much as you like, and by any means you feel the project
may be help. If is code what you may apport; just fork this project make changes
and place a pull request.What does xotl mean?The word “xotl” is a Nahuatl word that means foundation, base. Thexotlpackage comprises the foundation for building reliable systems: both
frameworks, libraries and an object model that allows to build complex systems.
Package: xotl.tools
xotl.toolsis a collection of disparate utilities that does not conform a
framework for anything.xotl.toolsis essentially -but not exclusively-
an extension to the Python’s standard library.Inxotl.toolsyou will probably find:Tools that must be implemented in the Python Standard Library, but there are
things that escape from the Guido’s scope. ;)Components that belong naturally to the “Common Systems Layer”[1].[1]http://pubs.opengroup.org/architecture/togaf9-doc/arch/chap39.html#tag_39_04_01You’ll find the documentation inRead the Docs.
Package: xoutil
xotl.toolsis a collection of disparate utilities that does not conform a
framework for anything.xotl.toolsis essentially -but not exclusively-
an extension to the Python’s standard library.Inxotl.toolsyou will probably find:Tools that must be implemented in the Python Standard Library, but there are
things that escape from the Guido’s scope. ;)Components that belong naturally to the “Common Systems Layer”[1].[1]http://pubs.opengroup.org/architecture/togaf9-doc/arch/chap39.html#tag_39_04_01You’ll find the documentation inRead the Docs.
Package: xox
This project helps provision virtualenvs and dependencies for your Python code.
It works liketoxornox, but your requirements are declared in your script.Credit to thenoxproject for much of the implementation.InstallationUse pip:pip install --user xoxUsageBefore you import any other third-party modules, callxox.activate():import xox

xox.activate("lxml", "requests>=1.0")

import lxml
import requestsThis will create a virtualenv, install packages, and callos.exec()to
replace the current process. The virtualenv will be re-used in subsequent runs.You could also passpython='pythonX.Y'to specify a Python version, orsilent=Falseto show output frompip.… And that’s it! No custom executables or config files needed, just an extra
header in your script.NotesAny code before youractivate()call will be run twice: once without and
once within the virtualenv. Any code after youractivate()call will run
only within the virtualenv.Each virtualenv is stored in a subdirectory of system’s temporary directory
named'xox-virtualenvs'. No cleanup mechanism is provided - sorry!