Saravanan666/pypi-org huggingface dataset:
Package: xyfny
xyfny - a z-machine intepreterThis is based closely upon theinternetftw'sxyppy.Where that is geared towards an interactive simulation of a good ol'-fashioned Z-machine
experience, this is intended to be plugging into event-driven systems (for instance,
chat systems like Slack).All of the terminal handling is stripped out. Rather, the z-machine runs until it attempts
to read input from the user. At that point, it'll exit with an interrupt -unlessthere
is user input pending in its buffer.The basic gist of how this might be used:# Initialise
env = make_env(file)
intro = do_step(env, line)

# Output the introductory text to the user
output(intro)

# On receiving an input event from the user:
response = do_step(env, event_text)
output(response)Referencesxyppy - infocom's z-machine in python
Package: xylem
Convert Python Abstract Syntax Trees (ASTs) to readable source code.Xylem is useful for when you want to make dynamic changes to Python code/ASTs, but also need to write those changes back as source code.It’s also very small (<500 lines), pure-Python, and produces (mostly) readable source code.In writing this, I made heavy use of the unofficial AST documentation atGreen Tree Snakes.InstallationXylem will work on Python 3.4 or later. I’ll eventually get around to testing it on Python 2.7-3.3.From PyPIInstall Xylem by runningpip3 install xylemfrom the command line.NoteOn some Linux systems, installation may require running pip with root permissions, or runningpip3 install xylem--user. The latter may require exporting~/.local/binto PATH.From GitHubClone or download thegit repo, navigate to the directory, and run:python3 setup.py sdist
cd dist
pip3 install xylem-<version>.tar.gzUsageto_sourceis likely the only method you’ll need to use:>>>fromxylemimportto_source>>>importast>>>tree=ast.parse("print('hello world')")>>>ast.dump(tree)"Module(body=[Expr(value=Call(func=Name(id='print', ctx=Load()), args=[Str(s='Hello world')], keywords=[]))])">>>to_source(tree)"print('hello world')"compare_astmay also be useful for determining if two ASTs are functionally equivalent.DevelopmentXylem versioning functions on aMAJOR.MINOR.PATCH.[DEVELOP]model. Only stable, non development releases will be published to PyPI. Because Xylem is still a beta project, theMAJORincrement will be 0. Minor increments represent new features. Patch increments represent problems fixed with existing features.
Package: xylem-daq
xylemA modular, parallel-ready data acquisition frameworkXylem systems consist of a collection of software components connected
to represent the flow of information (data and commands) through
the experiment. Each component has a particular relation to data
(e.g. Producer, Consumer, Aggregator) which determines the available
connections and functionality. For example, Producers introduce new data
into the xylem system, and Consumers remove data from the system (e.g.
into offline storage). The components work together to get data through
the pipeline as smoothly as possible.Xylem components are designed to fit into code that you already have
which controls your experimental equipment and processes your data. For
example, if you have code which interfaces with an instrument and prints
the data to the console, you can replace the print statement with a
call toProducer.produce(). Then, the xylem Producer will send off
the data to the downstream xylem components while your code continues
running.The xylem Core is a special component which monitors and commmunicates
with all of the other components in the system. It determines if a
component has crashed or otherwise become unresponsive, and it also can
send state updates and arbitrary messages to the components.Human operators can access the functionality of the Core component using
the Controller component. This component does not participate in the
data flow; rather, it allows the human operator to send commands to the
system (via the Core) and query its state (also via the Core). You can
design your system to respond to any set of commands you'd like, such
as "Begin run," "Initialize instrumentation," "Perform calibration," or
anything else that makes sense in your system. Internally, your code
would translate your commands into state updates that will be sent to
the Core. You provide the logic; xylem simply makes sure the messages
reach their intended destination.DAQ ComponentsFundamental building blocks for basic setups:Data producer: produces data. Example: digitizersData consumer: accepts data inputs and sends no output to other
xylem components. Examples: offline data storage, live data displayData aggregator: collects data from multiple data producers and
supplies the data to multiple data consumersCompound building blocks for more advanced setups:Data producer group: a collection of data producers
whose output is aggregated before being
sent to the data aggregator, so that the collection can be treated as
a single data producer. Example: an array of identical sensorsExample basic architectureData producerData aggregatorData consumerExample complex architectureData producer group 1*Data producerData producer...Data producer group 2*Data producerData producer...Data aggregator 1Data consumer 1+Data consumer 2...Data aggregator 2Data consumer 1+Data consumer 3...*: The data producer groups are located after the data producers in the
data flow.+: A single data consumer instance can receive data from multiple data
aggregators.
Package: xylib-py
xylib is a library for reading obscure file formats with data from
powder diffraction, spectroscopy and other experimental methods.
For the list of supported formats seehttps://github.com/wojdyr/xylib.This module includes bindings to xylib and xylib itself.
The first two numbers in the version are the version of included xylib.Prerequisites for building: SWIG and Boost libraries (headers only).
Package: xylib-py-wheels
This package contains built wheels for xylib by Marcin Wojdyr (https://github.com/wojdyr/xylib)
xylib is a library for reading obscure file formats with data from
powder diffraction, spectroscopy and other experimental methods.
For the list of supported formats seehttps://github.com/wojdyr/xylib.This module includes bindings to xylib and xylib itself.
The first two numbers in the version are the version of included xylib.
Package: xymath
XYmath Creates, Documents And Explores Y=f(X) Curve FitsSee the Code at:https://github.com/sonofeft/XYmathSee the Docs at:http://xymath.readthedocs.org/en/latest/See PyPI page at:https://pypi.python.org/pypi/xymathXYmath will find the “best” curve fit equation in a data set of x,y pairs by minimizingthe sum of the square of the the difference between the data and the equation (i.e. residuals).The user may choose to minimize either percent error or total error.(Percent error is particularly useful for y values spanning several orders of magnitude.)XYmath can search throughcommon equations, an exhaustive search through thousands of equations,splines, smoothed splines, or fit non-linear equations of the user’s choice.After fitting, XYmath will find roots, minima, maxima, derivatives orintegrals of the fitted curve. It will generate source code that documents andevaluates the fit in python, FORTRAN or EXCEL. Configurable plots arecreated using matplotlib that are of publication quality, including plots ofequation residuals.
Package: xymon-client
# python-xymon-clientA minimalist [Xymon](https://www.xymon.com/) client library and CLI in Python.Documentation is in the docs directory or [online](http://python-xymon-client.readthedocs.io/en/latest/).Features:Python 3.10;
but should work with Python ≥ 3.6 if you remove the annotations
(a tool such as [python-minifier](https://github.com/dflook/python-minifier) can do it for you)no dependenciescommand line interfaceeasy to use and extend## ExamplesAs CLI:`bash $xymon-client-sxymon01.example.net query--hostnamewww-portal.example.net--testnameinfo 'yellow Message generated byc234d183-069b-447e-73ab-84d5at2019-01-29T16:14:01\n'`As a Python library:`python from xymon_client import Xymon xymon =Xymon('xymonserver01.example.net')xymon.ping() 'xymond 4.3.18\n' `## Alternativeshttps://github.com/skurfer/python-xymon
Package: xypattern
xypatternDescriptionA simple small library to handle x-y patterns, such as are collected with x-ray diffraction or Raman spectroscopy.InstallationpipinstallxypatternUsage ExamplesReading a filefromxypatternimportPatternimportmatplotlib.pyplotaspltp1=Pattern.from_file('path/to/file')p1.scaling=0.5p1.offset=0.1plt.plot(p1.x,p1.y)plt.show()Use a background patternp2=Pattern.from_file('path/to/file')p2.scaling=0.9p1.background=p2Scale and stitch multiple patternsp1=Pattern.from_file('path/to/file1')p2=Pattern.from_file('path/to/file2')p3=Pattern.from_file('path/to/file3')fromxypattern.combineimportscale_patterns,stitch_patternspatterns=[p1,p2,p3]scale_patterns(patterns)stitched_pattern=stitch_patterns(patterns)
Package: xyplot
xyplot 📈Plotting with python made easyAre you tired of replicating common steps that are needed to plot even a simple polynomial functions in python's infamous Matplotlib?Worry no more! Presentingxyplot! Plot polynomials easily and, more importantly, pythonically!For example, to plot a polynomial best fit curve you only need to:fromxyplotimportCurve# Our datax,y=[0,2,4,6,8],[0.8,-1.1,1.06,6.75,16.54]# A simple curve object with data and degree of polynomialcurve=Curve(x,y,2)# Set the x, y axis labels and Titlecurve.set(xlabel="Labels are fun and easy",ylabel="Oooh see him Go!",title="I am an easy Graph")# Label our data and curvecurve.createPlot(plotLabel="Label for the Curve",dataLabel="Label for our DATA",)curve.save("sample.png")# Save our graph in high qualityMakes sense right? Seeexamplesfor other examples.Fair WarningThis is just a high level sensible wrapper to the matplotlib and numpy package. Its aim is to reduce the workload necessary to make very basic plots.To make more extensive and customizable plots, refer tomatplotlibWhy this effort?Some of the more inquistive and experienced would be asking why the hell did I create an entire package that can only plot polynomials. Because there was nothing similar in matplotlib and I wanted to help those who have only little knowledge of python plot amazing graphs in as few lines and headaches as possible.For those who still like control, you always have the fig, ax attributes of the curve class available for exploitation! And then, if you are not satisfied, try the OG Matplotlib!InstallationTo install the program run$ pip install xyplotIf you are using Ubuntu run this instead:$ pip3 install xyplotTo check whether the installation was successful, try importing it:fromxyplotimportCurveIf the import worked, the package is most probably installed.Note that you may want to install some other python libraries to fully enjoy theScientific Pythonexperience.These are recommended:$ pip install --user numpy scipy matplotlib ipython jupyter pandas sympy noseDocumentation?Documentation is like sex: when it is good, it is very, very good; and when it is bad, it is better than nothing. —Dick B.With that said, the documentation can be found here:http://www.xypnox.com/xyplot/xyplot/index.htmlContributions?Are welcome!
Package: xypy
Simulating Supervised Learning DataWithxypy.Xy()you can convienently simulate supervised learning data, e.g. regression and classification problems.
The simulation can be very specific, since there are many degrees of freedom for the user. For instance, the functional
shape of the nonlinearity is user-defined as well. Interactions can be formed and (co)variances altered. For a more
specific motivation you can visit ourblog.
I have adapted this package from my R version, which you can check outhere.UsageYou can can checkout details about the package ontestPYPIor onGitHub.You can convienently install the package via PYPI with the following command.pip install xypyThere is an example test script on myGitHub, which will you get started
with the simulation.Simulate dataYou can simulate regression and classification data with interactions and a user-specified non-linearity. With
thestnargument you can alter the signal to noise ratio of your simulation. I strongly encourage you to
read thisblog post,
where I've analyzed OLS coefficients with different signal to noise ratios.# load the library
from xypy import Xy
# simulate regression data
my_sim = Xy(n = 1000, 
            numvars = [10,10], 
            catvars = [3, 2], 
            noisevars = 50, 
            stn = 100.0)

# get a glimpse of the simulation
my_sim

# plot the true underlying effects
my_sim.plot()

# extract the data
X, y = my_sim.data

# extract the true underlying model weights
my_sim.coef_Feature SelectionYou can extract a feature importance of your simulation. For instance, to benchmark feature selection algorithms.
You can read up on a small benchmark I did with this feature
on ourblog.
You can perform the same analysis easily in Python as well.# Feature Importance 
my_sim.varimp()Feel free tocontactme with input and ideas.
Package: xyscreens
Python library to control XY Screens projector screens and projector lifts.Python library to control XY Screens projector screens and projector lifts
over the RS-485 interface.XY Screens is an OEM manufacturer of projector screens and projector lifts.HardwareI use a cheap USB RS-485 controler from eBay to talk to the projector screen
where position 5 of the RJ25 connector is connected to D+ and position 6 to
the D-.See the documentation of your specific device on how to wire yours correctly.ProtocolThis are the protocol details:2400 baud 8N1Up command  : 0xFF 0xAA 0xEE 0xEE 0xDDDown command: 0xFF 0xAA 0xEE 0xEE 0xEEStop command: 0xFF 0xAA 0xEE 0xEE 0xCCKnown to workiVisions Electro M SeriesNot tested but uses the same protocol according to the documentation:iVisions Electro L/XL/Pro/HD SeriesiVisions PL Series projector liftElite ScreensKIMEXDELUXXPlease let me know if your projector screen or projector lift works with this
library so I can improve the overview of supported devices.InstallationYou can install the Python XY Screens library using the Python package manager
PIP:pip3 install xyscreensxyscreens CLIYou can use the Python XY Screens library directly from the command line to
move your screen up or down or to stop the screen using the following syntax:Move the screen down:python3 -m xyscreens <serial port> downStop the screen:python3 -m xyscreens <serial port> stopMove the screen up:python3 -m xyscreens <serial port> upIf you add the arguments--wait <time>to the down and up commands where<time>is the time in seconds to move the screen down, respectively up, the
process will wait till the screen is down/up and show the progress.
Package: xyShiftSplit
Make sure you have upgraded version of pipWindowspy -m pip install --upgrade pipLinux/MAC OSpython3 -m pip install --upgrade pipCreate a project with the following structurepackaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── src/
│   └── example_package/
│       ├── __init__.py
│       └── example.py
└── tests/
touch LICENSE
touch pyproject.toml
touch setup.cfg
mkdir src/mypackage
touch src/mypackage/__init__.py
touch src/mypackage/main.py
mkdir testspyproject.tomlThis file tells tools like pip and build how to create your project[build-system]
requires = [
    "setuptools>=42",
    "wheel"
]
build-backend = "setuptools.build_meta"build-system.requires gives a list of packages that are needed to build your package. Listing something here will only make it available during the build, not after it is installed.build-system.build-backend is the name of Python object that will be used to perform the build. If you were to use a different build system, such as flit or poetry, those would go here, and the configuration details would be completely different than the setuptools configuration described below.Setup.cfg setupUsing setup.cfg is a best practice, but you could have a dynamic setup file using setup.py[metadata]
name = xyShiftSplit
version = 0.0.1
author = Rifqi khairurrahman
author_email = eaglemaster7@gmail.com
description = this package to make easy to create X and Y data, shift and split from same dataset
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
    Bug Tracker = https://github.com/pypa/sampleproject/issues
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License
    Operating System :: OS Independent

[options]
package_dir =
    = src
packages = find:
python_requires = >=3.6

[options.packages.find]
where = srcRunning the buildMake sure your build tool is up to dateWindowspy -m pip install --upgrade buildLinux/MAC OSpython3 -m pip install --upgrade buildCreate the buildpy -m buildupload to pypipython.exe -m twine upload dist/*Referenceshttps://packaging.python.org/tutorials/packaging-projects/
Package: xytext
xytextxytext is a Python client library for interacting with the Xytext API. It offers a simple way to send requests to the Xytext API and handle responses effectively. This package is designed to integrate Xytext API functionalities into Python applications.InstallationInstall xytext using pip:pip install xytextUsageTo use xytext, you must have your Xytext API credentials: FUNC_ID, STAGE, and AUTH_TOKEN. These credentials are necessary to authenticate your requests.Examplefrom xytext import Xytext, XytextResponse

def example_usage():
    func_id = "your_func_id"
    stage = "your_stage"
    auth_token = "your_auth_token"

    xt = Xytext(func_id, stage, auth_token, timeout=900)
    try:
        response = xt.invoke("Your input text here")
        print(response.result)
    except Exception as e:
        print("Error:", str(e))

example_usage()API ReferenceXytextThis is the primary class used to interact with the Xytext API.ConstructorXytext(func_id, stage, auth_token, timeout=900)Parameters:func_id (String)The function ID for the Xytext API.stage (String)The stage of the API environment ("staging", "prod").auth_token (String)Your authorization token for the Xytext API.timeout (Integer)The timeout for the API request in seconds. Default is 900 seconds (15 minutes).Methodsinvoke(input_text) Sends a request to the Xytext API.Parameters:input_text (String)The text input for the API.Returns: An instance ofXytextResponse.XytextResponseThis class represents the response received from the Xytext API.Propertiesraw_responseThe complete response from the API as a Python dictionary.successBoolean indicating if the API request was successful.messageA message from the API, typically containing error details if any.usageDetails about the usage of the API for this call.call_idA unique identifier for the API call.resultThe content returned by the API, either as a Python object or a string.Additional InformationKeep your API credentials secure. Avoid exposing them in client-side code. Utilize environment variables to safeguard your auth token.
Properly handle API responses and exceptions in your application to ensure robustness.
Package: xython-for-python
importxythonasxy_=xy._xy.and_then(sum|xy.partial([]),sum,print)([[1,2,3],[2,3,4]])# => print(sum(sum([[1, 2, 3], [2, 3, 4]], [])))_*2|xy.before_with(_+10)|xy.call(2)# => (2 + 10) * 2_+10|xy.next_by(_*5)|xy.call(2)# => (2 + 10) * 5(lambdax,y:x+y)|xy.to_curry|xy.call(1,2)# => 1 + 2(lambdax,y:x+y)|xy.to_curry|xy.call(1)|xy.call(2)# => 1 + 2Not only the syntax sugar,JITandAOTcould be expected.
Package: xyxABC785
XYZ__ABC_785just testing, how to upload the packageFree software: MIT licenseDocumentation:https://xyxABC785.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2023-04-30)First release on PyPI.
Package: xyzcad
Update - 27th November 2022A new, much faster version is available. It uses more numba jit compiled python code and more parallelization.The first run may be slower due to compilation time.xyzCad - functional cad softwarexyzCad is an ease to use marching cubes based cad software generating 3d printable stl files from a function f(x, y, z) = {True : False}.x, y and z are the coordinates in 3d space in mm. The function f(x, y, z) returns True or False depending on the arguments x, y and z. True means, there should be solid. False means, there is nothing.Theory of operationIt looks like the software iterates over alle points in the 3d raster space. But this would be very slow. So the algorithm is a bit more optimized.At first it searches for two points, one inside the solid (=True), one outside (=False).Now the surface is searched on a line between the two points.Rasterization is done over the surface only.That means only one solid can be created. If two solids without contact to each other are created, only the one found at first will be rendered.Usage exampleLet us create a sphere:#!/usr/bin/env python3fromnumbaimportjitfromxyzcadimportrender@jit(nopython=True)deff(x,y,z):r=10returnr**2>x**2+y**2+z**2render.renderAndSave(f,'sphere.stl',0.3)numba just in time compiler makes it a bit faster. render is the xyzcad renderer/compiler. We want a resolution of0.3mm. The output file should besphere.stl. Our sphere will have a radius ofr = 10mm.Want to Support the project?Buy your 3d printer filament or parts using my affiliate link:AmazoneBay
Package: xyzclean
A sample project that exists as an aid to thePython Packaging User Guide’sTutorial on Packaging and Distributing
Projects.This projects 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.This is the README file for the project.The file should use UTF-8 encoding and be written usingreStructuredText. 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: xyzpy
xyzpyis python library for efficiently
generating, manipulating and plotting data with a lot of dimensions, of the
type that often occurs in numerical simulations. It stands wholly atop the
labelled N-dimensional array libraryxarray.
The project’s documentation is hosted onreadthedocs.The aim is to take the pain and errors out of generating and exploring data
with a high number of possible parameters. This means:you don’t have to write super nested for loopsyou don’t have to remember which arrays/dimensions belong to which variables/parametersyou don’t have to parallelize over or distribute runs yourselfyou don’t have to worry about loading, saving and merging disjoint datayou don’t have to guess when a set of runs is going to finishyou don’t have to write batch submission scripts or leave the notebook to use SGE, PBS or SLURMAs well as the ability to automatically parallelize over runs,xyzpyprovides theCropobject that allows runs and results to be written to disk,
these can then be run by any process with access to the files - e.g. a batch system
such as SGE, PBS or SLURM - or just serve as a convenient persistent progress mechanism.Once your data has been aggregated into axarray.Datasetorpandas.DataFramethere exists many powerful visualization tools such asseaborn,altair, andholoviews/hvplot.
To thesexyzpyadds also a simple ‘oneliner’ interface for interactively plotting the data
usingbokeh, or for static, publication ready figures
usingmatplotlib, whilst being able to see the dependence on
up to 4 dimensions at once.Please see thedocsfor more information.