Saravanan666/pypi-org huggingface dataset:
Package: parade-crossfilter
OMERO parade-crossfilterThis is a prototype OMERO.web app, exploring the use ofhttps://github.com/crossfilter/crossfilterin a new implementation ofhttps://github.com/ome/omero-parade.It usesCreate React Appwith the cross-filter,dc.jsand React interaction
based on the blog post athttps://www.lighttag.io/blog/react-dc-js/.InstallInstall into your omero-web python environment:$ pip install parade-crossfilterYou will need to have the app configured in your OMERO.web install:$ omero config append omero.web.apps '"parade_crossfilter"'Add to 'open_with' config:$ omero config append omero.web.open_with '["Parade", "parade_crossfilter_index", {"supported_objects": ["project", "screen"]}]'Questions to AnswerThis prototype aims to investigate the scope and technical solutions for a
data-visualization app based onomero-parade.Limitations of the currentomero-paradeapp include:Data is tied to Images (in Dataset) or Wells (in Plate). Can't handle data linked to ROIS or to multiple Images in a Well.Loads the same data from the server for filteringagainfor display.Limited plots available (scatter plot only)Particular questions:Is crossfilter.js a suitable tool for filtering/grouping data? (A: mostly good)What to use for Plots? (A: Plotly.js is looking pretty good)How do we handle hierarchy of multiple Images per Well, or ROIs per Image?How much data processing is possible, while still being usable / generic?Is Parade primarily forexploringorpresentingdata (like figure)?DevelopmentTo install in dev mode, you need to checkout this repository, then:$ cd parade-crossfilter
$ pip install -e .To build the JS bundle, you'll need to haveNodeinstalled.
Then install the JavaScript dependencies and build:$ npm install
$ npm run buildThis builds the app for production to thebuildfolder and copies the
html and static files to the Django app inparade_crossfilter.See OMERO config steps above.You can run this project in development mode or as an OMERO.web Django app (below).The notes below are largely fromCreate React Appbut have been updated with
changes made to connect to OMERO in dev or production modes.To get started:$ cd parade-crossfilter
$ npm installIn the project directory, you can run:$ npm startRuns the app in the development mode.Openhttp://localhost:3000to view it in the browser.The app will try to connect to an OMERO.web server athttp://localhost:4080using an existing session, which requires CORS to be enabled.You will need to be logged-in tohttp://localhost:4080/webclient.To use a different server, editdev_omeroweb_indexinpublic/index.html.ReleaseUpdate version to release version in setup.py and package.jsonUpdate CHANGELOGCommit and tagRun:$ rm -rf dist
$ python setup.py sdist bdist_wheel

# TODO: get github actions to do this!
$ python -m twine upload dist/*
Package: parade-manage
Parade-manageParade-manageis module for parade.Note: You should installparadefirst.InstallInstall is simple:>pipinstallparade-manageUsageTasks dag:t1  a   b   c
  \ / \ / \ / 
   d   e   f
    \ / \
     g   hNote:t1is table name, other are task name
Enter your project first>cdyour_projectInitialize the classfromparade_manageimportParadeManagem=ParadeManage()# or m = ParadeManage(project_path='/your/parade/project/path')dump and generate yaml file>m.dump(target_tasks=["e","f"],flow_name="flow")flow.ymldeps:-e->a,b-f->b,ctasks:-a-b-c-e-fshow tasks>m.tree(name="flow",task_names=['d','e'])show tablesm.show()# orm.show(task_names=["taskA","taskB"],keyword="filter word")
Package: paradeps
# paradeps## OverviewThis resolves dependencies into parallelizable execution tiers.  For example, given the inputs:a, b, c, d, fWhere a and b depend on f, this will return:[{c,d,f}, {a,b}]## RequirementsPython 3.10+## Installationpip install paradepsOr download the *.whl files and install it with `pip install *.whl`.## Usagefrom paradeps import Dependentclass Item(Dep):...def process_items_in_parallel(items):...items = [Item() for i in range(5)]items[0].add_dependency(items[2])items[2].add_dependency(items[4])tiers = resolve_deps(items)for tier in tiers:process_items_in_parallel(tier)## LicenseReleased under the terms of Affero GPL version 3.0 only.  See `LICENSE.txt` for further details.## Authors / ContactEmail mailto::leebraid@gmail.com[mailto::leebraid@gmail.com].
Package: paradigm-client
paradigm-clientPython client for LightOn Paradigm Large language Model.InstallationYou can install this package from PyPi with:pip install paradigm-clientOr from source:pip install -U git+https://github.com/lightonai/paradigm-client.gitOnce the package is installed, make sure to define environment variables PARADIGM_API_KEY to your API key, e.g. by adding the following line to your .bashrcexport PARADIGM_API_KEY="<your api key>"Quick StartUsing paradigm-client is pretty simple, here are a code example to show you how you can use it.from paradigm_client.remote_model import RemoteModel

model = RemoteModel(model_name="llm-mini")

print(model.create("Hello, I am").completions[0].output_text)Logging a feedback into ParadigmAfter using the Create endpoint of Paradigm, you can log a feedback about it.Feedback data is expected to be in a dictionary format with a key being one of "flag", "value", "tag" and "comment".flag: used forbooleanfeedbacksvalue: used forfloatfeedbackstag: used forshort textfeedbackscomment: used forfree textfeedbacksHere are the different steps to log a feedback:If the feedback type you want to use does not exist on Paradigm yet, go to the admin interface of Paradigm and create it.Get therating_idof the feedback type you want to use.Instantiate aRemoteModelobject.Get thecompletion_idfrom the response of aRemoteModel.create()call.Call thelog_feedback()method of yourRemoteModelobject with therating_id, thecompletion_idrelated to your feedback and your feedback data.Important note: The API Key used to generate thecompletion_idand to send the feedback must authorize the logging of its requests from the admin interface of Paradigm.Access to LightOn ParadigmLearn more about Paradigm:https://www.lighton.ai/fr/paradigm.
For a list of use cases:https://www.lighton.ai/fr/blog/ai-use-case-5.Known IssuesIf you find that aRemoteModelinstantiation and subsequent completions are unusually slow, it may be that your network does not support IPv6. Try disabling IPv6 and see if that helps.
Package: paradigm-data-portal
Paradigm Data PortalThe Paradigm Data Portal is a collection of open source crypto datasets for researchers and tool buildersDatasetsethereum_contracts: all historical contract deploymentsethereum_native_transfers: all native transfers in similar format to ERC20 Transfers (excluding tx fees)ethereum_slots: all slots of each contract, including historical usage metadataAll datasets are released under aCC0license into the public domain unless otherwise noted.pdppdpis a CLI tool that can be used to obtain and manage PDP datasetsTo install:pip install paradigm-data-portalExample UsageList available datasetspdp lsList dataset filespdp ls <dataset_name>Download a datasetpdp download <dataset_name>Each command has multiple options, view help withpdp <command> -hDataset VersioningEvery dataset has a version in<major>.<minor>.<patch>format, e.g.1.2.8when a schema is updated, the major version is increasedwhen rows are added, removed, or modified, the minor version is increasedwhen rows are added due to new blocks, the patch is increasedUpdates will be documented in dataset changelogs
Package: paradigmextract
NB!This is Språkbanken's inofficial version of the paradigmextract library.
The main version can be foundhere.---*---   ---*---   ---*---Paradigm learning and paradigm predictionThe software collection in this repository is related to a body of
scientific work on paradigm learning and paradigm prediction, of which
the following publication is the latest one. See the reference list
for previous work.[Forsberg, M; Hulden, M. (2016). Learning Transducer Models for
Morphological Analysis from Example Inflections. In Proceedings of
StatFSM. Association for Computational Linguistics.] (http://anthology.aclweb.org/W16-2405)Quick referenceParadigm learning:pextract.pyDescriptionExtract paradigmatic representations from input inflection tables. See
Section 2 in Forsberg and Hulden (2016) for details.Example$ python src/pextract.py < data/es_verb_train.txt > es_verb.pNon-probabilistic morphological analyzers:morphanalyzer.pyDescriptionCreate a foma-compatible morphological analyzer from a paradigm
file. The analyzer is non-probabilistic.Options:-orecreate original data (all vars must be exactly instantiated as seen in training data)-cconstrain variables by generalizing (default pvalue = 0.05)-uunconstrained (all variables are defined as ?+)-puse  together with -c-skeep different analyzers separate instead of merging with
priority union (may be necessary for some analyzers)-nname of binary foma file to compile toAny combination of the above may be used. The analyzers are combined
by priority union, e.g.-o -c -uwould yield an analyzer[ Goriginal .P. Gconstrained .P. Gunconstrained ].Example$ python src/morphanalyzer.py -o -c es_verb.p > es_verb.fomaProbabilistic morphological analyzers:morphparser.pyDescriptionCreate a probabilistic morphological analyzer from a paradigm
file.Reads one or more whitespace-separated words from STDIN and
returns the most plausible analysis for the set in the format:SCORE  NAME_OF_PARADIGM  VARIABLES  WORDFORM1:BASEFORM,MSD#WORDFORM2:BASEFORM,MSD...Flags:-k numprint the k best analyses-tprint the entire table for the best analysis-dprint debug info-n numuse an nth order ngram model for selecting best paradigm (an n-gram model for variables in the paradigm is used)Example$ echo "coger cojo" | python morphparser.py ./../paradigms/spanish_verbs.p -k 1 -t
Package: paradigm-manager
paradigm-panesInstallable package that produces a paradigm for a given word, given a pointer to paradigm layouts and FST file. Originally
built foritwêwina.PyPi PackageLatest version of the package posted to PyPi:paradigm-panes 0.3.2Installpip install paradigm-panesDevelopingDeveloping is done and managed throughPython Poetrypackage manager.To start development:# Download the repo
git clone https://github.com/UAlbertaALTLab/paradigm-panes.git

# Set up virutal env
virtualenv venv --python=python3.9
source venv/bin/activate

# Install dependencies
poetry install

# Now cd into main directory and try out the package
cd paradigm_panes
python
    >>> import paradigm_manager
    >>> ...Package Documentation:The package is very simple to use and requires two types of linguistic files to operate. First:InstallingInstall the paradigm manager with:pipinstallparadigm-managerUsage and ConfigurationImport the library:import paradigm_managerCreate PaneManager and specify path to FST file and layouts resources:pm = paradigm_manager.ParadigmManager(
            layout_directory="/home/ubuntu/paradigm_panes/resources/layouts", 
            generation_fst="/home/ubuntu/paradigm_panes/resources/fst/crk-strict-generator.hfstol")Paths to the layout directory and generation FST are required arguments.Pass lemma and paradigm type to generate a paradigm:lemma = "amisk"
p_type = "NA"
pm.set_lemma(lemma)
pm.set_paradigm(p_type)Generate the paradigm:paradigm=pm.generate()Optionally add recordings to the paradigm with the following steps:wordforms=pm.get_all_wordforms()matched_recordings=<fetchrecordingsforallwordforms>paradigm=pm.bulk_add_recordings(matched_recordings)TestingTo run the tests you need to install required dependencies, it is easier by using a virtual environment like this:# Set up virutal env
virtualenv venv --python=python3.9
source venv/bin/activate

# Install dependencies
poetry installOnce the dependencies are installed you can run tests by calling pytest.pytestReleasePackage version number is sorted in pyproject.toml. With every release to PyPi the version needs to be updated.Build the package from the main directory before publishing it:poetry buildTo publish to Test PyPi use poetry and enter credentials associated with Test PyPi accountpoetry publish -r testpypiTo publish to real PyPi use poetry and enter credentials associated with PyPipoetry publishAll relevant package specifications and dependencies are managed inpyproject.tomlfile.
Package: paradime
ParaDime: A Framework for Parametric Dimensionality ReductionParaDime is a modular framework for specifying and training parametric dimensionality reduction (DR) models. These models allow you to add new data points to existing low-dimensional representations of high-dimensional data. ParaDime DR models are constructed from simple building blocks (such as the relations between data points), so that experimentation with novel DR techniques becomes easy.InstallationParaDime is available via PyPi through:pip install paradimeParaDime requiresNumpy,SciPy,scikit-learn, andPyNNDescent(seerequirements.txtfile), all of which are installed auomatically when installing ParaDime.ParaDime also requiresPyTorch, which must be installed separately. If you want to train ParaDime routines on the GPU, make sure to install CUDA along with the correctcudatoolkitversion. See thePyTorch docsfor detailed installation info.If you want to use ParaDime’s plotting utilities,Matplotlibhas to be installed additionally.DocumentationFor a simple example with one of the predefined ParaDime routines, seeSimple Usagein the documentation.More detailed information about how to set up cusom routines can be found inBuilding Blocks of a ParaDime Routine.For additional examples of varying complexity, seeExamples.References[1]Van Der Maaten, L., Hinton, G.“Visualizing data using t-SNE”, Journal of Machine Learning Research (2008).[2]LeCun, Y., Cortes, C., Burges, C.J.C.“The MNIST database of handwritten digits”(1998).
Package: paradime-io
Paradime - Python SDKInstallationpipinstallparadime-ioUsageGenerate your API key, secret and endpoint from Paradime workspace settings.fromparadimeimportParadimeparadime=Paradime(api_endpoint="API_ENDPOINT",api_key="API_KEY",api_secret="API_SECRET",)# Use the paradime client to interact with the APIExamplesFind usage exampleshereto get started with the Paradime Python SDK.
Package: paradise
ParadiseA file sharing and media streaming solution for local networks. Using this utility you can start a local server on your machine that is visible to other devices like mobile, laptop etc. Which can be used to download/upload files from other machines.Why it's needed?Can't I just transfer files from/to External drive or internet.This utility is useful for people that are using office/work laptop/device that usually disables USB ports and/or external disks. And you want to transfer locally, so that it will be faster as well as don't your internet data.Getting StartedThese instructions will get you a server up and running on your local machine.PrerequisitesRequires: python 3.6+InstallingParadise is available onPyPiand can be easily installed using pip.pip install paradiseIf you already have paradise and want to update to a newer versionpip install -U paradiseYou can get the cutting edge version directly from dev branch (this can be unstable)pip install git+https://github.com/rahulsrma26/paradiseRunningparadiseThis will show the output and ip of your machine on local networkINFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [14192] using statreload
INFO:     Started server process [1580]
INFO:     Waiting for application startup.
[Visit url] http://192.168.0.123:8000
INFO:     Application startup complete.Web server can be reached usinghttp://127.0.0.1:8000on your browser on the same machine. But if you want to access the web server from other devices then you need to openVisit urlin the browser. In this example it ishttp://192.168.0.123:8000.Built WithFastAPI- BackendVue.js- Client frameworkAuthorsRahul Sharma-Initial work-Rahul SharmaLicenseThis project is licensed under the MIT License - see theLICENSEfile for detailsAcknowledgmentsHat tip to anyone whose code was usedInspiration -Testing & Packaging by Hynek Schlawack
Package: paradise-player
Radio Paradise player and notifierRadio paradise:https://www.radioparadise.comThis program plays radio paradise's stream from cli and send notifications on what's currently playing using your desktop notification system.This is tested (and certainly working only) under linux.usageLaunch the program in command line with$ paradise_playeror the shortcut$ rppit will start to play the steam and send notification when song changes.Ctrl+C to stop itinstallation$ pip install paradise_playeror clone the repositoryfrom githuband run$ python setup.py installconfigurationconfig file is stored in ~/.config/paradise_player/config.cfgsee file config_sample.cfg for all configuration parameters.dependenciesThis program requires notify-send on your system.For archlinux, install libnotify:$ sudo pacman -S libnotifyIt also requires a notification server, generally built-in if you use 'big' desktop environments like gnome or kde.Alternatively, you can use dunst (https://dunst-project.org/)playing the radio stream is configurable, vlc is used by default.
you can use ffplay (from ffmpeg), mplayer, or any cli player capable of playing http streams.of course this program requires python 3+ installed in your system.creditsInspired byhttps://github.com/jmdh/rpnotify/blob/master/rpnotifynews0.2improved data queries using an offset available in config0.1First version available:plays RP using the choosen player in configurationnotify using notify-send
Package: paradoxdjango
Django is a high-level Python web framework that encourages rapid development
and clean, pragmatic design. Thanks for checking it out.All documentation is in the “docs” directory and online athttps://docs.djangoproject.com/en/stable/. If you’re just getting started,
here’s how we recommend you read the docs:First, readdocs/intro/install.txtfor instructions on installing Django.Next, work through the tutorials in order (docs/intro/tutorial01.txt,docs/intro/tutorial02.txt, etc.).If you want to set up an actual deployment server, readdocs/howto/deployment/index.txtfor instructions.You’ll probably want to read through the topical guides (indocs/topics)
next; from there you can jump to the HOWTOs (indocs/howto) for specific
problems, and check out the reference (docs/ref) for gory details.Seedocs/READMEfor instructions on building an HTML version of the docs.Docs are updated rigorously. If you find any problems in the docs, or think
they should be clarified in any way, please take 30 seconds to fill out a
ticket here:https://code.djangoproject.com/newticketTo get more help:Join the#djangochannel onirc.libera.chat. Lots of helpful people
hang out there. Seehttps://web.libera.chatif you’re new to IRC.Join the django-users mailing list, or read the archives, athttps://groups.google.com/group/django-users.To contribute to Django:Check outhttps://docs.djangoproject.com/en/dev/internals/contributing/for
information about getting involved.To run Django’s test suite:Follow the instructions in the “Unit tests” section ofdocs/internals/contributing/writing-code/unit-tests.txt, published online athttps://docs.djangoproject.com/en/dev/internals/contributing/writing-code/unit-tests/#running-the-unit-testsSupporting the Development of DjangoDjango’s development depends on your contributions.If you depend on Django, remember to support the Django Software Foundation:https://www.djangoproject.com/fundraising/
Package: paragami
# “Parameter origami”:paragami.[![image](https://travis-ci.org/rgiordan/paragami.svg?branch=master)](https://travis-ci.org/rgiordan/paragami)
[![image](https://codecov.io/gh/rgiordan/paragami/branch/master/graph/badge.svg)](https://codecov.io/gh/rgiordan/paragami)## Description.Parameter folding and flattening, parameter origami:paragami*!This is a library (very much still in development) intended to make
sensitivity analysis easier for optimization problems. The core
functionality consists of tools for “folding” and “flattening”
collections of parameters – i.e., for converting data structures of
constrained parameters to and from vectors of unconstrained parameters.For background and motivation, see the following papers:Covariances, Robustness, and Variational Bayes
Ryan Giordano, Tamara Broderick, Michael I. Jordan
<https://arxiv.org/abs/1709.02536>A Swiss Army Infinitesimal Jackknife
Ryan Giordano, Will Stephenson, Runjing Liu, Michael I. Jordan, Tamara
Broderick
<https://arxiv.org/abs/1806.00550>Evaluating Sensitivity to the Stick Breaking Prior in Bayesian
Nonparametrics
Runjing Liu, Ryan Giordano, Michael I. Jordan, Tamara Broderick
<https://arxiv.org/abs/1810.06587>## Using the package.We welcome new users! However, please be aware that the package is
still in development. We encourage users to contact the author (github
userrgiordan) for advice, bugs, or if you’re using the package for
something important.### Installation.To install the latest tagged version, install withpip:python3 -m pip install paragami.Theparagamipackage is under rapid development, so you may want to
clone the respository and use the master branch instead.Note: In order to use the functions insparse_preconditioners_lib, you must additionally manually install
[scikit-sparse](https://github.com/scikit-sparse/scikit-sparse/),
which requires the C++ libraries inlibsuitesparse-dev.
Most users will not require this functionality soscikit-sparseis not installed by default withparagamifor simplicity.  See the
[scikit-sparserequirements](https://scikit-sparse.readthedocs.io/en/latest/overview.html#requirements)
for more details on installation.### Documentation and Examples.For examples and API documentation, see
[readthedocs](https://paragami.readthedocs.io/).Alternatively, check out the repo and runmake htmlindocs/.*  Thanks to Stéfan van der Walt for the suggesting the package name.
Package: paragon
paragonA tiny command line benchmarking utility (and a python library!)DemoFeaturesStatistical analysisCool progress barsPython libraryExport results to various file formats (todo)InstallationYou can install the command line utility via pip:$pipinstallparagonUsageYou can use paragon as a command line utility or a python library.CLIAfter running --help:Options:
  -a, --accuracy INTEGER  Number of iterations
  -f, --files PATH        Input file path(s)
  -o, --output PATH       Output file path
  --help                  Show this message and exit.Examples:Benchmarking code as a string:$paragon"print('hello, world')"-a20Providing a python file:$paragon-f/path/to/file.pyExporting resultsYou can use the -o option to specify an ouput file which will receive the results. Paragon currently supports
Markdown, CSV and JSON file formats.For instance, specifying a Markdown output file will yield this result:ProgramAverage [s]Min [s]Max [s]for i in range(2500): print(i ** i)102.4597.6114.0comp230.27226.6236.6hello10.2310.110.5sort429.49421.8438.2LibraryExample:fromparagonimportParagonn=1000000defmain():"""entry point"""fizzbuzz(n)fib_wrapper(30)@Paragon.benchmark(name="FizzBuzz!",accuracy=20)deffizzbuzz(n):returnlist(map(lambdai:"Fizz"*(i%3==0)+"Buzz"*(i%5==0)orstr(i),range(1,n),))# You must wrap your recursive functions@Paragon.benchmark(name="Fibonacci!",accuracy=20)deffib_wrapper(n):deffib(n):return1ifnin[0,1]elsefib(n-1)+fib(n-2)fib(n)if__name__=="__main__":main()Further RamblingsParagon is heavily inspired by the shell benchmarking toolhyperfine. Although currently less mature, it has room to grow. For now, it is a simple tool that can be used to run quick and easy benchmarks for Python code with minimal setup.