Saravanan666/pypi-org huggingface dataset:
Package: interactive-multi-category-table
interactive-multi-category-tableIn many different scenarios, contents are single-categorized and multi-tagged, by which I mean there exist multiple tags but one single (though maybe hierarchical) category system, e.g., file systems, blogs, etc. However, sometimes contents can be categorized from different category views. For storage or lookup, one category system is OK; but for visualization and analysis, flexibly organizing the contents with different category views will be very handy.This repo targets addressing such demand by creating interactive tables with alternative category views from formatted json input. It can both run as a service on the server side based ondash, or generate a static webpage on the client side.usagerun on the server sideimportinteractive_multi_category_tableasimctimct.run_dash_app(json_file_path)and the generated webpage can be accessed athttp://127.0.0.1:8050/.generate a static webpageimportinteractive_multi_category_tableasimctimct.json_to_html(json_file_path)input json file formatRefer to the provided examples for the json file format.Note that:There have to be at least two category trees.Leaf category items in the same category tree cannot be the same.
Package: interactive-publishing
Interactive text and figuresThis project provides quick starting point for anyone who wants to experiment
withinteractive text and figuresin their electronic publications
(EPUB3 / HTML5 + JavaScript). One possible reason why one would use interactive
text and figures is tocommunicate many possible storiesto the audience,
instead of usual single story line. SeePhysics World blogpost.Two templates and corresponding tools are provided.
Tools generate HTML/Javascript output that can be seen in
web-browsers and e-readers.
Generated examples don't have any external dependencies that need to be
downloaded from the Internet. They are completely self contained,
and be seen on all devices (even without Internet access),
and they can be simply included in interactive texts/books in EPUB3 format,
as well as web-pages.For detailed documentation and discussion of motivation and examples check hereNote on implementationInteractive text example implements simple calculations in JavaScript. More
complex calculations should be precalculated and provided as look-up tables.Interactive figures generate figures for all possible combinations of the
input. Control JavaScripts then displays just images corresponding to
selected combination of input parameters, while all other images are hidden.
This can make files relatively large, but it allows their viewing on devices
with minimal computational resources, like ereaders, and old phones.LicenseOverall license is BSD-3-Clause as outlined included inLICENSE.md.This project usesTangleKitpackage from this repository
for creating interactive text. That package is based on
on slightly modified and updated open-sourceTangle.jslibrary ofBret Victor.Interactive figures use Matplotlib Python package andifigurespackage from this repository which is based
on updated and modified version ofipywidgets-static.
Compared to original package, dependency on IPython is removed,
Python 2 and 3 are supported now, and few bugs are fixed.Licenses are inherited from the original projects mentioned above.
They are permissive, and allow reuse, with or without modification, but for
details check corresponding LICENSE files and code headers.
Package: interactive-score-editor
This package has been renamed asiseditInteractive Score EditorA python library that combines score editing tools with audio output.OverviewInteractive Score Editor is a python library that helps bridge a music notation library (such as Lilypond via Abjad(https://abjad.github.io/index.html) to an audio player (such as pydub). The goal is to resolve the following: "Abjad provides no audio output beyond LilyPond’s built-in MIDI functionality" (https://abjad.github.io/first_steps/audience.html). Using LilyPond's MIDI is will take longer and be more complicated than a built in feature to play notes directly.A successful implementation will be helpful both for individuals creating music-composition tools / applications, as well as individuals looking to play around with music composition and sound in a notebook, and will cut the time from starting a music project to hearing actual sound (an element which has been a personal annoyance).InstallationPrerequisites:Python >=3.7,lilypond, portaudionumpy, pyaudio, midiutil, ipython, pygameTo install python packages:$pipinstallnumpy
$pipinstallpyaudio
$pipinstallmidiutil
$pipinstallipython
$pipinstallpygameLilypond (https://lilypond.org) and portaudio (http://www.portaudio.com) can be installed from their websites, with brew$ brew install lilypond
$ brew install portaudioor with apt# sudo apt install portaudio19-dev python3-pyaudio
# sudo apt install -y lilypondEnsure that lilypond runs from the command line by running$lilypond--versionQuick start exampleFor now, ensure you have a folder namedtempin the current directory in order to ensure functinality of getScore() (this will be amended in a future release)importimportlibise=importlib.import_module("interactive-score-editor.src.Base")Piece=ise.Piecep1=Piece(60,"3/4")p1.addVoice("e' f' g'",4)p1.addVoice("c'4 d'4 e'4 f'4 g'4 a'4 b'4 c''4 b'4 c''2.")p1.play()p1.getScore()The above example demonstrates the primary functionality of the piece object; the ability to play and display notes using the same object.ContributionsSee the guidelines forContributing
Package: interactive-script
interactiveinteractiveis a Python 3 package that helps building interactive scripts using the full power of a Read-Eval-Print-Loop.InstallationUse pip to install this package.$pipinstallinteractiveIf you have to install offline you can install it from the sources:get the sources fromhere.unzip them (unzip interactive-main.zip)go into the directory (cd interactive-main)install with pip (pip install .)If you want to include this code in your own package, just make theinteractivefolder available to your project scope.UsageBasicsHere is a small self explanatory example:#!/usr/bin/env python3frominteractiveimportstart,queryfrominteractive.expectimportExpectPredicatestart(locals())# Initialize the contextprint("Start here")v=query(int,default=42)# give the user a REPL and wait for an answer# the user may answer by calling `resume(some_value)`print(f"Got v ={v}!")sq=query(# a custom validator for the user answerExpectPredicate(lambdax:x==v*v,description="the square of v"),msg="Provide the square of v",)print("Nice, thanks.")Main classes and functionsThe package is very simple, thus thehelpcommand should be enough to discover it.The basic interface is made of thestart,queryandresumefunctions.startandqueryare used in the script.resumeis used in interactive mode by the user to resume the script.They are all wrapper around theinteractive.context.Contextmethods.A custom subclass ofContextcan be used for advanced control of the process.
It should be passed tostartlikestart(locals(), Context=MyContext).The sources is currently so simple that you can probably just go check it out.TheExpectclass and its children are used to validate the data sent by the user. You may derive them and pass some instances as thetype_argument ofqueryto provide custom validation.ScopingThe scope of the REPL is handled manually two ways.If you want to bind to the local scope of a function, usewith rescope(locals()):.
Everyqueryin thewithblock will share the scope of the current function.
An example of that use can be found insamples/02_scoping.py.If you want arbitrary scope manipulation you may use thestartandstopfunctions.start(some_scope)bind a new REPL tosome_scopeandstop()pop the last REPL from the stack.
After astartallquerywill usesome_scope. Afterstopthe previous scope will be restored.startwill also be used to open the top level REPL at the beginning of a script (as demonstrated above).
Package: interactive-select
interactive-selectInstallationpip install interactive-selectHow to useusage: interactive-select [-h] [-m MIN] [-M MAX] [-r] [-d] [-j] [-i]
                          [-p PROMPT]
                          [items ...]

positional arguments:
  items

options:
  -h, --help            show this help message and exit
  -m MIN, --min MIN     Min number of selected items.
  -M MAX, --max MAX     Max number of selected items.
  -r, --retry
  -d, --debug
  -j, --json            Output json str
  -i, --index           Output item index
  -p PROMPT, --prompt PROMPT
Package: interactive-session
Interactive SessionA Python module to create a Shell session.Table of ContentsInteractive SessionTable of ContentsInstallationUsageLicenseInstallationclone the repositoryrunpipinstall-rrequirements.txt&&pythonsetup.pybuild&&pythonsetup.pytest&&pythonsetup.pyinstallUsageimportinteractive_sessionasmsession=m.InteractiveSession("bash","exit")print(session.execute("echo hello"))session.close()LicenseThis project is licensed under the MIT License.
Package: interactive-system-magic
SetupFirst, you need to load the extension with:%load_ext interactive_system_magicNow, you can start using it.Running programsIf you make a code cell with:%prog echo blahthen it will run the programecho blahand put the result in the output:blahSo far, this is just like the!system call syntax.
However, it also allows you to send input into a program by using it in cell mode:%%prog bc --quiet
1+1which will callbc--quiet(the--quietpart is to suppress the info on startup) and then pass in1+1on the stdin.bcwill read this and output the result:2If you want to use this to demonstrate what the user would see if they ran this manually on a terminal,
i.e. to include the input as well as the output, you can use the interactive-iflag:%%prog -i bc --quiet
1+1which gives:1+1
2Finally, if you want to be able to respond to prompts in the program’s output,
then you can use special syntax to specify the prompt you are looking for, and the thing to respond to it with.
In this case, we are calling thepythonprogram and waiting for its>>>prompt and then sendingprint("hello")%%prog -i -d [] python -q
[>>> ]print("hello")which gives:>>> print("hello")
hello
>>>Run Python scriptsAs a shortcut, you can also run any Python scripts you have using the same interpreter that IPython or the Jupyter notebook is running with.
If you make a Python script with (or use an existing one of course):%%writefile foo.py

print("This is a script")you can call it with:%run_python_script foo.pyand get:..code-block:This is a scriptThis magic supports the same cell-mode commands and interactive options as%%prog.
Package: interactiveTutorial
Based onPyQt4.Browse theAPI DocumentationFork the code ongithubInstallationinteractiveTutorialis listed in the Python Package Index. You can install it typing:pip install interactiveTutorialScopeInstead of a static PDF tutorial this package allows you torunandcreatetutorials within your PyQt4 based application. Tutorials are created through choosing
a point of interest (POI), e.g. a widget, and typing an explaining text for each step.UsageRunTutorialwidget to execute a given tutorialCreateTutorialwidget to create and edit tutorialsTutorialMenuQMenu listing all created tutorials and allowing to run and edit them.Embedd this one in your QMenuBar and you have all functionalities ofinteractiveTutorialIssuesInstances of QMenu and QAction cannot be chosen as POIQWidgets within QTreeWidgetItems are only marked on focus… if you find more´, please let me know!TestsinteractiveTutorialuses mostly the ‘one class/function per module’ rule. Running each module as program, like:python -m interactiveTutorial.TutorialMenu.TutorialMenuwill execute the test case of this module.v0.1, <13/01/2015> – Initial release.Karl Bedrich 2014 -
Package: interactive-visualization
Interactive visualizationThis repository contains a framework for iteractive visualization of algorithms based on widgets in jupyter notebook. Here are some examples of animations generated by the framework. The code is provided inoverviewnotebookText animationsHere's an example of quicksort algorithm using text state representationMatplotlib animationsUsingmatplotlibone can visualize some plane algorithm, for exampleEM algorithm for Old Faithfull eruption dataor domino coloring based on 5-coloring algorithm for planar graphsor convex hull constructionGraphvizUsinggraphvizone can visualize basic graph algorithms, here's an example of Dijkstra algorithmRequirements and installationA proper installation on debian-based systems iscat apt.txt | xargs sudo apt-get install
pip install interactive-visualizationFor other linux-based OS use the appropriate package manager to install packages listed inapt.txtwhich currently containsgraphvizandlatexneeded for proper visualization in notebooks. Note that there also might be problems withipywidgetsin jupyter lab, check the docs for installation instructions.Creating an interactive animation using the frameworkSeemanualfor more reference.ExamplesEngCovid-19Some basic parse and analysis of global Covid-19 data from Johns Hopkins University.RusЗамощене доминошкамиРассматривается задача покрытия фигур на плоскости, состоящиех из квадратных клеток одинакового размера и два её программных решения: с помощью динамического программирования по профилю и с помощью нахождения максимального паросочетания. Бонусом идет раскраска планарного графа в 5 цветов (не протестировано).Обходы на графахРазобраны обходы в глубину и ширину, а так же их базовые применения.Кратчайшие пути на графахОсновные алгоритмы для задачи о крайших путях от одной вершины до всех остальных. Все алгоритмы представлены как модификации "сканирующего метода".Префиксное деревоПрефиксное дерево, префикс-функцию, алгоритм Ахо-Корасик и их применения в марковских моделях для обработки текста.
Package: interactor
# interactorInteractor provides a common interface for performing complex user interactions. It's inspired by [collectiveidea's interactor gem](https://github.com/collectiveidea/interactor).### An Example Interactor```pythonfrom interactor import Interactorclass AuthenticateUser(Interacotr):def run(self):user = User.authenticate(self.context.email, self.context.password)if user:self.context.user = userself.context.token = user.secret_tokenelse:raise RuntimeError('Fail to authenticate user')```### Usage```pythonfrom somewhere import AuthenticateUserctx = AuthenticateUser.call(email='test@gmail.com', password='secret')print ctx.userprint ctx.token```
Package: interaktiv.id4me
interaktiv.id4me is a Plugin for Plone 5.x to allow users to login and connect their accounts to any ID4Me Provider.
When set in Plone global settings, users can also register through their Provider.InstallationAdd to your buildout.cfg:eggs +=
    interaktiv.id4meThen start your buildout and restart your instancego to/prefs_install_products_formand install “ID4Me”Configurationgo to Plone Site Setup and select under “Add-on Configuration” the “ID4Me Settings” entry.
Select an Client name and save.Usagelink your users to the view/@@id4mefrom any navigation rootOptionalIf you are using a Zeo-Cluster, you need to configureBeakerSessionManager
Package: interaktiv.recommendations
interaktiv.recommendationsInteraktiv Recommendations plone package.Table of contentsInstallationAdd the recommendation package to the backendAdd the recommendation package to the frontend (Volto only)Get packagesHow to enable the recommendationsEnable recommendations behaviorUpdate recommendations indexCopyright and LicenseInstallation1. Add the recommendations package to the backendFile: buildout.cfg[sources]
...
interaktiv.recommendations = git git@github.com:interaktivgmbh/interaktiv.recommendations.git branch=maineggs =
    ...
    interaktiv.recommendations2. Add the recommendations package to the frontend (Volto only)File: package.json"dependencies":{"@interaktivgmbh/volto-recommendations":"*"}"addons":["@interaktivgmbh/volto-recommendations"]###3.GetpackagesBackend/PloneClassic:```shell$./bin/buildoutFrontend/Volto:$yarninstallEnable the recommendations1. Enable recommendations behaviorEnable the recommendations behavior on a contenttype of your choice via controlpanel/@@dexterity-types.2. Update recommendations indexPlone Classic:Open/@@recommendations_settingsand click on theRefresh-Button.Volto:Open/controlpanel/recommendationsand click on theRefresh-Button.Copyright and LicenseAuthor: Interaktiv GmbH -https://interaktiv.deCopyright (c) 2023, Interaktiv GmbHSee LICENSE.md for details.
Package: interanasdk
Overview==========This will contain a simplified SDK to enable easy access to the Interana APIs.Being provided at a best-effort basis. So please use at your risk.High Level desciption of files==============================TBDInstall=======Python SDKThis can be installed by using pip directly. Dependencies will be installed automatically.```pip install interanasdk```This installs a python module called interanasdk and also, a command line script which allows for easy access to the SDK.R SDKTBDUsage=====* To access the Python SDK in code, do the following:```/usr/bin/env pythonimport interanasdk```* To access the IA Query Client script, there are three positional parameters that need to be provided.In addition, there are optional parameters that can be leveraged as well.* To access Interana's Demo Cluster and do a simple count*, do:```ia_query_client tffZR6q0fbVqSBbeuvvLllLMLV0KHbuH+/DjXo9K=ER0PY/qNh+hdjEh+16DcL5Gc=BfHTJ7dE64x06YFWMbtbqtcdO90000 demo2.interana.com music```(note this will only work when you are on the Interana Corporate Network)A sample output might look like this:```$ ./ia_query_client.py tffZR6q0fbVqSBbeuvvLllLMLV0KHbuH+/DjXo9K=ER0PY/qNh+hdjEh+16DcL5Gc=BfHTJ7dE64x06YFWMbtbqtcdO90000 demo2.interana.com music-------------------------------------------Results recieved from Interana:-------------------------------------------{u'rows': [{u'values': [[u'All'], 4058569848.0]}], u'columns': [{u'type': u'array', u'label': [u'result']}, {u'type': u'number', u'label': u'measure_value'}]}-------------------------------------------End of Results-------------------------------------------```How to Contribute==================Simple. Feel free to jump in and contribute code. Some of the immediate next steps are:* R implementation - work in progress* MS-Excel (Windows only) implementation* Jupyter Notebook* Perl ImplementationSupport & License=======## SupportThe SDK is provided on a best-effort basis only. All support will be community-driven only.## LicenseWe have adopted the MIT license (see the file LICENSE.txt) for this project.
Package: interator
interatorModule for integer sequence generation and related conditional tests.InstallationUse the package managerpipto install interator.pipinstallinteratorContentsFibonacci SequenceFunctionDescriptionfibonacci_stream(start=(0,1))Yield the next Fibonacci number starting with F(0)negafibonacci_stream(start=(0,1))Yield the next Fibonacci number in the negative index starting with F(0)nth_fibonacci(n, start=(0, 1))Given an index n, find F(n)lucas_stream(P = 2, Q = -1, start=(0, 1))Yield the next number in the in the (P,-Q)-Lucas sequence starting with U0(P,Q)is_fibonacci(n, start=(0,1))Determine if n is within the Fibonacci sequenceis_lucas(n, P = 2, Q = -1, start=(0, 1))Determine if n is within the (P,-Q)-Lucas sequenceGeneralizationsBy default,fibonacci_stream,negafibonacci_stream,nth_fibonacci, andis_fibonacciwork with the Fibonacci numbers, andlucas_streamandis_lucaswork with the Pell numbers. However, by changingstart, any generalization of these sequences can be generated. Here are some common examples:importinteratorstop=10numbers={'Lucas':(2,1),'Tribonacci':(0,0,1),'Tetranacci':(0,0,0,1)}forname,startinnumbers.items():print('%snumbers:'%name)fori,ninenumerate(interator.fibonacci_stream(start=start)):print(n,end=' ')ifi==stop:print('\n')breakPlease note the Lucas numbers should not be confused with the Lucas sequence. The Lucas numbers are a specific example of the Lucas sequence.Prime NumbersFunctionsDescriptionprime_stream()Yield the next prime number starting with 2composite_stream()Yield the next composite number starting with 1is_prime()Test the primality of n by checking potential prime factorsmiller_rabin(n, k = 8)Perform the Miller-Rabin Primality Test on nis_composite(n)Test if n is a composite number by checking potential prime factorsPolygonal NumbersFunctionsDescriptionpolygonal_stream(s)Yield the next s-gonal number starting with 1is_polygonal(n, s)Test if n is an s-gonal numberLicensingThis project is licensed under the MIT License.
Package: interbase
InterBase Driver for Python, supporting 32-bit and 64-bitInterBase Documentation*InterBase Source*Based On FDBChanges implemented are based on this blog postInterBase Driver for Python is aPythonlibrary package that implementsPython Database API 2.0-compliant support for the Embarcadero SQL DatabaseInterBase®. In addition to the minimal
feature set of the standard Python DB API, InterBase Driver for Python also exposes the entire
native (old-style) client API of the database engine. Notably:Automatic data conversion from strings on input.Automatic input/output conversions of textual data between UNICODE
and database character sets.Support for prepared SQL statements.Multiple independent transactions per single connection.
access specifications.Distributed transactions.Install (32-bit or 64-bit version of python 3.* required)You can use one of the following ways to do it.pip install git+https://github.com/Embarcadero/InterBasePython.gitpip install git+ssh://git@github.com/Embarcadero/InterBasePython.gitTo create a test DB:cd test/files && isql -i create-test-db.sql
Package: interceporaptor
You welcome to use this tool
in case you have a bug in as “hot” environment (prod, pre-prod,…) which
can not reproduce it on your local IDE environment due to a chains of many HTTP or database requestsBasic steps:Record:Intercept and save data fromanyAPI on data issued environment (prod, pre-prod,…)Fetch:Transport intercepted data to your IDE environment.Replay:Replay captured info form data environment into your IDE environment.Repeat “Replay” step until you find a solution to the problem.The idea is heavily inspired byvcrpy library.Hereis listed some points where vcrpy does not perform well for out problem areas.
Package: interceptoraptor
You’re welcome to use this tool in case you have a bug in as “hot” environment (prod, pre-prod, …)
which can not be reproduced in your local IDE environment due to chains of many external requests dependencies (db, HTTP, …).We could address this in a few steps:Record:Intercept and save data fromanyAPI on dependable environment (prod, pre-prod,…)Fetch:Transport intercepted data to your IDE environment.Replay:Replay captured from data environment into your IDE environment.Repeat “Replay” step until you find a solution to the problem.The idea is heavily inspired byVcrpy library.Hereis listed some points where vcrpy does not perform well for our problem areas.Eager to get started? This page gives a good introduction in how to get started with./docs/quickstart.rst.
Package: interceptorator
You welcome to use this tool
in case you have a bug in as “hot” environment (prod, pre-prod,…) which
can not reproduce it on your local IDE environment due to a chains of many HTTP or database requestsBasic steps:Record:Intercept and save data fromanyAPI on data issued environment (prod, pre-prod,…)Fetch:Transport intercepted data to your IDE environment.Replay:Replay captured info form data environment into your IDE environment.Repeat “Replay” step until you find a solution to the problem.The idea is heavily inspired byvcrpy library.Hereis listed some points where vcrpy does not perform well for out problem areas.