Saravanan666/pypi-org huggingface dataset:
Package: mididings
mididingsA MIDI router/processor based on Python, supporting ALSA and JACK MIDI.
It is available under the GNU GPL and currently runs on Linux.FeaturesMIDI routing and filteringFilter events depending on their event type, channel, note number, velocity,
etc., and freely route them between an arbitrary number of input and output
ports.Modifying and converting MIDI eventsTranspose notes, apply velocity curves, change controller values and ranges,
or convert events to any other MIDI event type. mididings also includes more
complex functions like a diatonic harmonizer, floating split points, latched
notes, and more.Seamless switching between patchesSet up different "scenes", each with its own MIDI routing and processing,
and switch between them at any time, even while playing. Switching scenes
does not affect notes already held, and does not result in dropouts or stuck
notes!MIDI event monitoring, running external commandsPrint MIDI event data to the console to help debugging your patches and
configuring your MIDI controllers. In addition to its MIDI output, mididings
can also execute shell commands and send OSC or DBUS messages.InstallationPip / PyPiNote: Ensure that required dependencies are installed/available before
proceeding.mididings is available asmididingson PyPi:pipinstallmididingsOptional dependencies can be installed, see next section
(Dependencies/Optional)for a list of optional dependencies.pipinstallmididings[osc,smf,dbus,autorestart,xdg]Arch LinuxFor Arch Linux users, mididings is available asmididingson the
official repositories:pacman-SyumididingsDependenciesRequiredPython 3ALSAJACKBoost(Boost.Python, Boost.Thread)glibdecoratorOptionalpyliblo: to send or receieve OSC messagespysmf: to read/write standard MIDI files using theprocess_file()functiondbus-python: to send DBUS messagespyinotify: to automatically restart when a script changestkinter: for the livedings GUIpyxdg: so mididings knows where to look for configuration filesDocumentationAPI documentationGitHub WikiSome links that might also be of interest:Original homepageOriginal documentationQJackCtl and the PatchbayThe Python TutorialGuide to the MIDI specificationSupportThere is amailing listat Google Groups for any discussion
concerning mididings, including help requests and bug reports.To post to the list, send mail tomididings@googlegroups.com.Licensemididings is available under the terms of theGNU General Public License, version 2 or later.The example scripts indoc/examplesare available under the terms of theGNU Free Documentation License 1.3 or later.
Package: midiferenciacion
Mi diferenciaciónThis little package proof would help you solve some derivates given a defined function.Math is not easy, right? You can use some tools to make it easier at least for some calculations.
This simple package will help you in that.Download and installIf you are usingPyPIinstallation it's as simple as:pip install midiferenciacionYou can also test the unstable version of the package with:pip install -i https://test.pypi.org/simple/midiferenciacionQuick startFirst import the midiferenciacionimport midiferenciacionNow, you have to be careful with the input of the only function we have for now: derivative. This function gives you the first derivative and you can evaluate the result in two defined points.The function derivative receives a function in a string format and (very important) in terms of x variable, and it also receives two values to evaluate the solution.Here's an example of a single function:midiferenciacion.derivative("x**2", 1, 2)What's newVersion 0.45:README updates and beautiful memeVersion 0.4:First version of the package.This package has been designed and written by Fulanit@ de Tal (C) 2023
Package: midify
Midify is a command line tool for converting audio data in MIDI data
identifying notes positions and frequencies.InstallationInside a virtualenv runpipinstallmidifyUsageThe simplest usage from the cli:midifyinput.wav--outputoutput.midYou can also use it programatically from python or a jupyter notebook:importscipyfrommidifyimportmidifyrate,data=scipy.io.wavfile.read("input.wav")mf=midify(data=data,rate=rate)waveform=mf.fluidsynth(fs=44100)IPython.display.Audio(waveform,rate=44100)AlgorithmThe algorithm consists of two steps; first we usescipy.signal.find_peaksto find the beggining of each note; after
that the program uses scipy FFT to find the first peak in the frequency
spectrum which we assume is the root harmonic (the played note).AcknowledgmentsMade with Love by Daniel Santana
Package: midigen
midigenPython library for generating simple chord progression midi filesdemoInstallationpip install midigenExample usageCommand linePlay aii-V-I-vipattern in the key ofG; loop it four timesmidigen --key G --chords ii V I vi  --loop 4 --playPythonfrommidigen.notesimportNotefrommidigen.keysimportKey,Modefrommidigen.timeimportTimeSignature,Measurefrommidigen.sequencerimportSong,Track,open_outputport=open_output()# play C minor scaleKey(Note.C,Mode.Minor).to_track().play(port)# make a simple ii V I vi chord progression in the key of Ckey=Key(Note.C,Mode.Major)time_signature=TimeSignature(4,4)tempo=90progression=[2,5,1,6]chords=Track.from_measures([Measure.from_pattern(pattern=[key.relative_key(degree).chord(# default chords are the base triad - try adding extensionsextensions=[7],# pick a voicing close to the root triadmatch_voicing=key.triad())]*time_signature.numerator,time_signature=time_signature,velocity=90)fordegreeinprogression])# play to portchords.play(port,tempo=tempo)# write the song to a MIDI fileSong([chords]).to_midi('midigen.mid',tempo=tempo)
Package: midi-generator
Midi generator using genetic algorithmsRequires Python 3.10Buildpython3-mbuild
pipinstalldist/*.whlApi referencegenerate(config: Configuration) - generate a note sequence using given configurationmutate(sequence: Sequence, config: Configuration) - mutate sequencecontinue_sequence(sequence: Sequence, config=Configuration()) - continue sequencecombine(sequences: list[Sequence], config: Configuration = Configuration()) - combine sequenceswrite_file(notes: Sequence, path: str) - write midi file containing sequence at given path
Package: midigpt
# 🎹 midiGPTInspired by Andrej Karpathy’s [minGPT](https://github.com/karpathy/minGPT), I am buildingmidiGPTas a learning-in-public (LIP) project. The goal is to build a library that makes it easy to train a decoder-only transformer model (similar to GPT) on MIDI data.## 🚧 Under Construction 🚧
Package: midikit
CURRENTLY UNDER Development
NOT YET USABLE!
Can be used to save and load sysex files, as well as more interesting functions such
as patch interpolation, message conversion, parameter modulation, etc.I recommend you use Python 2.7 x86 (there are good platform-agnostic python midi modules available on 2.7 x86)
You may have issues with x64, but I’ve warned you…
Package: midiknobs
# midi_kbobsThis project is a gui able to set a midi knobs as controller of Linux master audio.# User Docrun:`bash midiknobs_gui `![Gui image](https://raw.githubusercontent.com/nicolalandro/midi_kbobs/master/imgs/gui.png)Select the Midi deviceSet the correct value of “Channel” and “Control”Click “Connect”Move your midi knobClick “Disconnect”# Dev Doc`bash # usepython>=3.5python setup.py install midiknobs_gui `
Package: midi-player
midi-playerPython launcher of thehtml-midi-playerby@cifkao&@magentaWorks with local and web-hosted MIDI files in Jupyter, Colab, WandB,...probably other contexts.Installationpip install midi-playerUsageOnly tested with Jupyter Notebooks & Colab, but uses no IPython dependencies so itshouldwork in other contexts.frommidi_playerimportMIDIPlayerfrommidi_player.stylersimportbasic,cifka_advancedmidi_file_url="https://magenta.github.io/magenta-js/music/demos/melody.mid"midi_file="data/test_midi.mid"MIDIPlayer(midi_file_url,400)MIDIPlayer(midi_file,160,styler=cifka_advanced,title='My Player')Withwandb:importwandbwandb.login()wandb.init(project="midi-player")mp=MIDIPlayer(midi_file,300,viz_type="waterfall")wandb.log({'player':wandb.Html(mp.html)})wandb.finish()Seeexamples/for more.DocumentationTO-DO. Particularly, people will want to know how to add/customize their own "stylers".
Seemidi_player/*.pyfor now ;-).Known Issues / Release NotesNot sure why the staff view is putting out 32nd notes / how to tell it to do 8th notes instead.v0.5.1: Lightened title text color in Dark Mode for better visibility on dark backgroundsv0.5: Addedtitle=kwarg, as workaround b/c Quarto mixes up ordering ofprintand IFrame elementsv0.4: Refactoredstylers.py. Added adarkmode styler.v0.3: Added an optional Download link! (Maybe you'll think it's ugly but it works.) Note: WandB disables usual opening-in-new tab browser behavior, so on WandB you'll need to Right-Click the download link and choose "Open in New Tab" to get the file.
Package: midi-point-set
MIDI to Point Set ConverterThis Python library converts MIDI files to point set representation, which
encodes notes as pairs of integers encoding the pitch and time. The output can
be used for machine learning tasks such as music generation.RequirementsPython 3.7 or higherInstallationpipinstallmidi_point_setUsageCLI# JSON outputpython-mmidi-point-set--input-midiK545-1.mid--output-jsonmozart.json# Plot# (requires matplotlib installed)python-mmidi-point-set--input-midiK545-1.mid--output-plotmozart.svgLibraryfrommidi_point_setimportget_point_setpoint_set=get_point_set("mozart.midi")print(point_set[:5])
Package: midiroute
MIDI Message Routing Toolmidirouteis a command line utility for routing MIDI streams between input and output ports on your computer.midiroutecan route an incoming MIDI stream to multiple output ports. The stream can also be monitored in the terminal.Installation and usageInstallationpip install midiroutemidirouterequires Python 3.8.0 or later.UsageTo list the available input and output ports on your system:midiroute list-portsRoute messages from an input to an output port with monitoring enabled:midiroute run -i "Oxygen 61 0" -o "Microsoft GS Wavetable Synth 0" -mCommand line optionsYou can list the command line options by runningmidiroute --help:Usage: midiroute [OPTIONS] COMMAND [ARGS]...

  CLI entry-point.

Options:
  --help  Show this message and exit.

Commands:
  list-ports  List available input and output ports.
  run         Run the MIDI router.To get help on a specific command runmidiroute <command> --help:$ midiroute run --help
Usage: midiroute run [OPTIONS]

  Run the MIDI router.

Options:
  -i, --input-port PORT_NAME    Select the input port.
  -o, --output-ports PORT_NAME  Select one or more output ports in a comma
                                separated list.
  -m, --monitor                 Enable monitoring of MIDI activity on the
                                selected ports.
  --help                        Show this message and exit.LicenseMITContributing tomidirouteContributions to this project are more than welcome!More details can be found inCONTRIBUTING.
Package: miditapyr
MiditapyrMIDI TAbulation in PYthon (and for R)Work in progress!This python package can be used to read in midi files (viamido) in dataframes. These dataframes can then
also be read in in R via the packagepyramidi. The dataframes then can be
easily modified and visualized. Finally they can be written back to midi files
via mido.InstallationpipinstallmiditapyrIf you are an R user check out the related R packagepyramidi.DocumentationDocumentation can be foundhereUsagemiditapyr provides aMidiFramesclass. Ajupyter notebook how to use this classis shown in the documentation.The low-level functions which this class uses are demonstrated in a notebook forfunctions usage.These notebooks can also be downloadedfrom the repo.Release HistoryPlease find the changelog here:CHANGELOG.mdLicenseDistributed under the MIT license. SeeLICENSEfor more information.ContributingFork it (https://github.com/UrsWilke/miditapyr/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'commit message text for fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: midi-to-noteblock
Midi File to Minecraft SchematicA CLI to convert midi files into world edit schematic files.How to useInstall the CLI viapippipinstallmidi-to-noteblockThen run the CLI with the following command:midi-to-noteblockexample.mid# the midi file to convertAvailable Options:usage: midi-to-noteblock [-h] [-s SCHEMATIC_FILE] [-d SCHEMATIC_DIR] midi_file

Generate a schematic from a MIDI file

positional arguments:
  midi_file             The MIDI file to convert

options:
  -h, --help            show this help message and exit
  -s SCHEMATIC_FILE, --schematic-file SCHEMATIC_FILE
                        The name of the schematic to create
  -d SCHEMATIC_DIR, --schematic-dir SCHEMATIC_DIR
                        The directory to save the schematic toDevelopmentClone the repogitclonehttps://github.com/SushiWaUmai/midi-to-schematic.gitcd./midi-to-schematicInstall all dependencies and run the python script# use pip3 and python3 respectivelypipinstall-rrequirements.txt# Use -h for the help menupythonmain.py-hLicenseThis project is licensed under theMIT license
Package: miditoolkit
MiditoolkitA Python package for working with MIDI files.Miditoolkit works by loading/writing MIDIs withmidoin a user-friendly way. It is inspired frompretty_midi, with similar usage and core features, but handles the MIDI events in nativetickstime unit instead of seconds. It also comes with a few optimizations and speed-ups, and can parse MIDI tracks intopiano-rollsfor computation or visualization purposes.
If you are working with seconds time units (for e.g. music transcription), you'll be likely better with pretty_midi. Otherwise, if you are working solely on MIDI and symbolic music, miditoolkit should provide slightly faster performances.Main FeaturesMIDIGlobalticks per beattempo changeskey signaturestime signatureslyricsmarkersInstrumentscontrol changespitch bendEditingchunk/croppingIOBytesIOPiano-rollsToolsnotes to piano-rollspiano-rolls to noteschromagramVisualizationExternal Librarystructure analysisTODObetter documentation;finish the code cleaning of the pianoroll methods (vis);a way to switch the time in seconds across the whole MidiFile object;cropping Control Changes and bars;symbolic featuresnew structural analysisInstallationYou can install miditoolkit viaPYPI:pipinstallmiditoolkit... or directly from git if you want to get the latest features or fixes (only recommended if you need it):pipinstallgit+https://github.com/YatingMusic/miditoolkitExample UsagefrommiditoolkitimportMidiFilefrommiditoolkit.midi.utilsimportexample_midi_filepath_midi=example_midi_file()midi_obj=MidiFile(path_midi)print(midi_obj)Output:ticks per beat: 480
max tick: 72002
tempo changes: 68
time sig: 2
key sig: 0
markers: 71
lyrics: False
instruments: 2A.Parse and create MIDI filesB.Piano-roll ManipulationPhilosophymidoprocesses MIDI files in the lower level such as messages and ports, and is the backend pretty_midi and miditoolkit;pretty_midiparses MIDI files and pianorolls in seconds time unit, plus has audio related features;pypianorollparses MIDI files into pianorolls in ticks time unit.Miditoolkitis designed for handling MIDI inticks, the native time unit of the MIDI protocol. We keep the midi parser as simple as possible, and offer several important functions to complete the versatility. For example, piano-rolls, tick-to-second, chromagram, etc.
Package: midivision
midivisionBrings basic function related to division in python and relation between the two numbers to divideDownload and installIf you are usingPyPIrun the following promt in terminal:pip install pydivisionYou can also test the unstable version of the package with:pip install -i https://test.pypi.org/simple/ pydivisionQuick startThe package contains functions to make a division, check if two numbers are divisible and ...For instance:import midivision
print(midivision.division(1,2))  #0.5Code examplesdivisionReturn the division between two numbers

Args:
-    a : Numerator
-    b : Denominator
    type_ (, optional): Type of result, possible values are "complex","str","int" and "float". Defaults to float.

Returns:
-    a/b: Result of division in expected typeFor instance:import midivision
print(midivision.division(1,2,"complex")) $0.5 + 0jisdivisbleArgs:
    a : Numerator
    b : Denominator

Returns:
    True if a is divisible by b, else FalseFor instance:import midivision
print(midivision.isdivisible(5,5)) # TrueWhat's new:Update Image-Version 0.4:Typo CorrectVersion 0.3:Update ImpageVersion 0.2:Functionsdivisionandisdivisiblewas implemented.Version 0.1:First version of the package.This package has been designed and written by Diego Acosta (C) 2023
Package: midi-websocket-server
# MIDI Websocket serverPython Websocket server to facilitate two-way communication with all connected MIDI devices.Features:Broadcasting allNOTE ONandNOTE OFFMIDI signals from all MIDI devices to all clients listening via websocket.Playing receivedNOTE ONandNOTE OFFMIDI signals from connected clients to specific MIDI device.Discovery of new devices when they are plugged in. Changes to device list is broadcasted to all connected clients.The server is designed to run on a Raspberry Pi with a MIDI keyboard plugged in via USB.Powered by [aaugustin/websockets](https://github.com/aaugustin/websockets) and [SpotlightKid/python-rtmidi](https://github.com/SpotlightKid/python-rtmidi).
Package: midi-wrapper-SnooperXP
Midi WrapperThis package contains classes that wrap the Pygame Midi class to allow selection of a midi input device, and simple polling of said device with predefined classes to help interpret the signals.This implementation is limited in that it is only polling for one event per poll instead of multiple events, as such it will pull one at a time.Polling for multiple events in one frame may be supported in future.Usagefrompygameimportmidifrommidi_wrapperimportMidiMenu,MidiDevice# Boiler plate midi initialization for pygame midimidi.init()if(midi==None):print("Error initializing midi.")exit(-1)# Initialize the menu to start device selection, then pass to device to get referencemidi_menu=MidiMenu(midi)midi_device=MidiDevice(midi,midi_menu)# Bog standard polling loopwhileTrue:# Returns None if no events received or a MidiData type if an event is foundmidi_data=midi_device.poll_device()ifmidi_data!=None:midi_event=midi_data.eventprint(f"Clock:{midi_data.clock}:: Name:{midi_event.name}:: Channel:{midi_event.channel}:: Data:{midi_event.data}")
Package: midjpy
MIDJPyThe MIDJPy package provides a simple and efficient way to interact with the MIDJ API. Utilize the power of MIDJ with just a few lines of Python code in your applications.PrerequisitesTo use this package, you need to have amidj.app subscription.FeaturesGenerate content withgeneratemethod.Fetch content using the trigger ID withget_by_triggermethod.Generate a variation of content withgenerate_variationmethod.Upscale images withupscale_imagemethod.InstallationTo install the MIDJPy package, use pip:pipinstallmidjpyUsageStart by importing and initializing the MIDJ class:frommidjpy.midjimportMIDJmidj=MIDJ(authorization='YOUR_AUTHORIZATION_TOKEN')MethodsFor Subscription Usersgenerate(prompt)Generate content based on a provided prompt:response=midj.generate('Hello, world!')print(response)generate_variation(index, trigger_id, msg_hash)Generate a variation of content:response=midj.generate_variation(1,'trigger_id_here','msg_hash_here')print(response)upscale_image(index, trigger_id, msg_hash)Upscale an image:response=midj.upscale_image(1,'trigger_id_here','msg_hash_here')print(response)For Pre-paid Userspregenerate(prompt)Generate content based on a provided prompt:response=midj.pregenerate('Hello, world!')print(response)pregenerate_variation(index, trigger_id, msg_hash)Generate a variation of content:response=midj.pregenerate_variation(1,'trigger_id_here','msg_hash_here')print(response)preupscale_image(index, trigger_id, msg_hash)Upscale an image:response=midj.preupscale_image(1,'trigger_id_here','msg_hash_here')print(response)Common APIget_by_trigger(trigger_id)Fetch generated content by its trigger ID:response=midj.get_by_trigger('trigger_id_here')print(response)ConfigurationTheMIDJconstructor accepts a configuration dictionary:config={'baseURL':'https://api.midj.app',# Optional. This is the default.'authorization':'YOUR_AUTHORIZATION_TOKEN'# Required.}midj=MIDJ(config)⚠️ Always keep your authorization token secret. Do not expose it in client-side code.Error HandlingAll methods return an error object in case of any issues:response=midj.generate('Hello, world!')if'error'inresponse:print('Error:',response['error'])else:print('Generated Content:',response)ContributingFor any bugs or feature requests, please open an issue on GitHub.Please replace'YOUR_AUTHORIZATION_TOKEN'with your actual MIDJ API authorization token.
Package: midlevel-perception
# Visual Priors# Intro
This package contains the code for the paper:Mid-Level Visual Representations Improve Generalization and Sample Efficiency for Learning Visuomotor Policies. Arxiv 2018/CoRL 2019. Alexander Sax, Jeffrey O. Zhang, Bradley Emi, Amir R. Zamir, Silvio Savarese, Leonidas Guibas, Jitendra Malik.For a fuller description and useful results and demos, and much more, see the website [http://perceptual.actor](http://perceptual.actor).For the code in this package, see [https://github.com/alexsax/midlevel-reps/tree/visualpriors](https://github.com/alexsax/midlevel-reps/tree/visualpriors).For the full code from the paper, dockers to reproduce experiments, and more, see [https://github.com/alexsax/midlevel-reps](https://github.com/alexsax/midlevel-reps).### Citation
If you find this repository or toolkit useful, then please cite:` @inproceedings{midLevelReps2018,title={Mid-LevelVisual Representations Improve Generalization and Sample Efficiency for Learning VisuomotorPolicies.},author={AlexanderSax and Jeffrey O. Zhang and Bradley Emi and Amir R. Zamir and Leonidas J. Guibas and Silvio Savarese and Jitendra Malik},year={2018},} `
Package: midlife
midlifeThis is under review.midlife is a PyPI application for evaluating and visualzing the impact of COVID-19 on mortality of midlife in five age groups from 40 to 64 years old.CDC dataset is used for this study:https://data.cdc.gov/api/views/chcz-j2du/rows.csvHow to install midlife$ pip install midlifeHow to run midlifemidlife needs the degree of polynomial regression and sex: F or M.
The following example can show the 4th degree of polynomial and Female.$ midlife 4 F