Saravanan666/pypi-org huggingface dataset:
Package: mlx90641-driver-devicetree
MLX90641 driver for device tree on a SBC.MLX90641 is a thermal camera (16x12 pixels) using Far InfraRed radiation from objects to measure the object temperature.https://www.melexis.com/mlx90641The python package "mlx90641-driver" driver interfaces the MLX90641 and aims to facilitate rapid prototyping.This package provide the I2C low level routines.
It uses the I2C from the device tree of a single board computer(SBC).Getting startedInstallationpipinstallmlx90641-driver-devicetreehttps://pypi.org/project/mlx90641-driver-devicetreehttps://pypistats.org/packages/mlx90641-driver-devicetreeNote:Make sure the user has access to/dev/i2c-<x>.And easy way to do this is by adding the user to the groupi2c.Running the driver demoConnect the MLX90641 on the I2C bus of the SBC.Open a terminal and run following command:mlx90641-devicetree-dump/dev/i2c-1This program takes 1 optional argument.mlx90641-devicetree-dump<communication-port>Note: this dump command is not yet available!
Package: mlx90641-driver-evb9064x
MLX90641 driver for EVB90640-41MLX90641 is a thermal camera (16x12 pixels) using Far InfraRed radiation from objects to measure the object temperature.https://www.melexis.com/mlx90641The python package "mlx90641-driver" driver interfaces the MLX90641 and aims to facilitate rapid prototyping.This package provide the I2C low level routines.
It uses the I2C from the EVB90640-41 which is connected via the USB cable to the computer.https://www.melexis.com/en/product/EVB90640-41/Getting startedInstallationpipinstallmlx90641-driver-evb9064xhttps://pypi.org/project/mlx90641-driver-evb9064xhttps://pypistats.org/packages/mlx90641-driver-evb9064xNote:On linux OS, make sure the user has access to the comport/dev/ttyUSB<x>or/dev/ttyACM<x>.And easy way to do this is by adding the user to the groupdialout.Running the driver demoConnect the MLX90641 to the EVBConnect the EVB to your PC with the USB cable.Open a terminal and run following command:mlx90641-evb9064x-dumpautoThis program takes 1 optional argument.mlx90641-evb9064x-dump<communication-port>Note: this dump command is not yet available!
Package: mlx90641-driver-mcp2221
MLX90641 driver for MCP2221 USB I2C hubMLX90641 is a thermal camera (16x12 pixels) using Far InfraRed radiation from objects to measure the object temperature.https://www.melexis.com/mlx90641The python package "mlx90641-driver" driver interfaces the MLX90641 and aims to facilitate rapid prototyping.This package provide the I2C low level routines.
It uses the I2C hub from MCP2221 chip which is connected via the USB cable to the computer.https://www.microchip.com/wwwproducts/en/mcp2221https://www.adafruit.com/product/4471Getting startedInstallationpipinstallmlx90641-driver-mcp2221https://pypi.org/project/mlx90641-driver-mcp2221https://pypistats.org/packages/mlx90641-driver-mcp2221Extra installation for linux based OS.install udev, libusb and libhidapi:sudoaptupdate
sudoapt-getinstalllibudev-devlibusb-1.0-0-devlibhidapi-devConfigure such that non-root users have access.Place a file in/etc/udev/rules.d/20-microchip.rules:KERNEL=="hidraw*", ATTRS{idVendor}=="04d8", MODE="0666"You might use this command line to create that file:echo'KERNEL=="hidraw*", ATTRS{idVendor}=="04d8", MODE="0666"'|sudotee/etc/udev/rules.d/20-microchip.rules>/dev/nullNote:Make sure to (re-)plug the MCP2221 after this file is written!Running the driver demoConnect the MLX90641 to the MCP2221 I2C portConnect the MCP2221 to your PC with the USB cable.Open a terminal and run following command:mlx90641-mcp2221-dumpmcp://mcp:2221/0This program takes 1 optional argument.mlx90641-mcp2221-dump<communication-port>Note: this dump command is not yet available!
Package: mlx9064x-blob-detection
IntroThis is a python blob detection example for the MLX90640 and MLX90641.It is using opencv functions for the blob detection.DependenciesPython3mlx9064x-driverNumPyopencvGetting startedpipinstallmlx9064x-blob-detectionRun the demo.mlx9064x_blob_detection<comport>
Package: mlx9064x-visualizer
IntroThis is a python visualizer for the MLX90640 and MLX90641. It is using the original mlx9064x-driver-py.Currently this driver supports 3 type of interfaces:EVB90640-41 ==>https://www.melexis.com/en/product/EVB90640-41/Evaluation-Board-MLX90640Raspberry Pi with I2C on any GPIO pin.Raspberry Pi on built-in hardware I2C bus.DependenciesPython3mlx9064x-driverNumPyMatplotlibctypesPyQt5PyQtGraphsciPyGetting startedpipinstallmlx9064x-visualizerRunning mlx90640_demo.pymlx9064x-visualizerauto
Package: mlx-embedding-models
MLX Embedding ModelsRun text embeddings on your Apple Silicon GPU. Supports any BERT- or RoBERTa-based embedding model, with a curated registry of high-performing models that just work off the shelf.Get started by installing from PyPI:pip install mlx-embedding-modelsThen get started in a few lines of code:frommlx_embedding_models.embeddingimportEmbeddingModelmodel=EmbeddingModel.from_registry("bge-small")texts=["isn't it nice to be inside such a fancy computer","the horse raced past the barn fell"]embs=model.encode(texts)print(embs.shape)# 2, 384
Package: mlx.jira-juggler
JIRA to TaskJuggler ConvertorTool for converting a set of JIRA tasks to TaskJuggler (TJ3) syntax.GoalWhen using JIRA to track your project, and tasks/issues are estimated using the time-tracking plugin, this python
module can convert the JIRA tasks to a gantt chart using theTaskJugglertool.InstallationInstallation from PyPI:pip install mlx.jira-jugglerUsageSee help from python module:jira-juggler -hBy default, the following endpoint for the JIRA API is used:https://melexis.atlassian.net.
The script will ask you to input your email address (or username) and API token (or password). These three
variables can be configured by setting them in a.envfile. This.envfile shall be located in the directory where
pip has installed the package. You can find an example configuration in.env.example. JIRA Cloud requires the
combination of email address and API token, while JIRA Server might accept a username and password.NoteTo include resolvedandunresolved tasks while excluding invalid tasks, you can add the following logic to the
value for the–queryargument:(resolution !=  Invalid OR resolution = Unresolved).WarningThe generated tj3-file, can at the moment not be parsed by TaskJuggler directly. Only the tasks are exported
to the tj3-file. The list of tasks needs to be embedded in a complete tj3-file. See theTaskJuggler websitefor more details.NoteUnresolved tasks with logged time, i.e. time spent, will have their ‘start’ property set to the set current date
and time minus the logged time, calculated with 8 hours per workday and a default of 5 allocated workdays per week
with the day(s) off ending on Sunday. The latter number can be changed.LimitationsWhen two tasks end on the same date and time, TaskJuggler won’t necessarily preserve the order in which the tasks
appear in jira-juggler’s output.
Package: mlx.json-to-mako
JSON to MAKO generatorPython script that converts JSON database(s) to any templated output using MAKO templates.Installingpip3 install mlx.json_to_makoUsageThe script takes multiple JSON input files, combines them in a python list, and renders the
data through a provided template. No data-parsing functionality is provided by the script:
the complexity of ‘interpreting’ the data is done in the MAKO templates.ExampleGeneral use:json-to-mako--inputdatabase.json--templaterendering.mako--outputrendered.htmlThe MAKO-template should match the dataformat of the JSON input file. The script addsa list at the top level: multiple input JSON files are appended to a list,some metadata in order to identify the input sourceThe usage on how to match the dataformat between JSON and MAKO is explained through an
example in theexample/directory.Multiple input filesThe–inputflag can be provided multiple times in order to provide multiple JSON databases. This
is explained by the example.json-to-mako--inputdatabase1.json--inputdatabase2.json--templaterendering.mako--outputrendered.htmlThe multiple JSON databases are appended into a python list. Your MAKO-template needs to incorporate this by e.g.
looping over the different databases. See example/ folder for details.
Package: mlx-lm
Generate Text with LLMs and MLXThe easiest way to get started is to install themlx-lmpackage:Withpip:pipinstallmlx-lmWithconda:condainstall-cconda-forgemlx-lmThemlx-lmpackage also has:LoRA and QLoRA fine-tuningMerging modelsHTTP model servingPython APIYou can usemlx-lmas a module:frommlx_lmimportload,generatemodel,tokenizer=load("mistralai/Mistral-7B-Instruct-v0.1")response=generate(model,tokenizer,prompt="hello",verbose=True)To see a description of all the arguments you can do:>>> help(generate)Themlx-lmpackage also comes with functionality to quantize and optionally
upload models to the Hugging Face Hub.You can convert models in the Python API with:frommlx_lmimportconvertupload_repo="mistralai/Mistral-7B-Instruct-v0.1"convert("mistralai/Mistral-7B-v0.1",quantize=True,upload_repo=upload_repo)This will generate a 4-bit quantized Mistral-7B and upload it to the
repomlx-community/My-Mistral-7B-v0.1-4bit. It will also save the
converted model in the pathmlx_modelby default.To see a description of all the arguments you can do:>>> help(convert)Command LineYou can also usemlx-lmfrom the command line with:python -m mlx_lm.generate --model mistralai/Mistral-7B-Instruct-v0.1 --prompt "hello"This will download a Mistral 7B model from the Hugging Face Hub and generate
text using the given prompt.For a full list of options run:python -m mlx_lm.generate --helpTo quantize a model from the command line run:python -m mlx_lm.convert --hf-path mistralai/Mistral-7B-Instruct-v0.1 -qFor more options run:python -m mlx_lm.convert --helpYou can upload new models to Hugging Face by specifying--upload-repotoconvert. For example, to upload a quantized Mistral-7B model to theMLX Hugging Face communityyou can do:python -m mlx_lm.convert \
    --hf-path mistralai/Mistral-7B-v0.1 \
    -q \
    --upload-repo mlx-community/my-4bit-mistralSupported ModelsThe example supports Hugging Face format Mistral, Llama, and Phi-2 style
models.  If the model you want to run is not supported, file anissueor better yet,
submit a pull request.Here are a few examples of Hugging Face models that work with this example:mistralai/Mistral-7B-v0.1meta-llama/Llama-2-7b-hfdeepseek-ai/deepseek-coder-6.7b-instruct01-ai/Yi-6B-Chatmicrosoft/phi-2mistralai/Mixtral-8x7B-Instruct-v0.1Qwen/Qwen-7Bpfnet/plamo-13bpfnet/plamo-13b-instructstabilityai/stablelm-2-zephyr-1_6bMostMistral,Llama,Phi-2,
andMixtralstyle models should work out of the box.For some models (such asQwenandplamo) the tokenizer requires you to
enable thetrust_remote_codeoption. You can do this by passing--trust-remote-codein the command line. If you don't specify the flag
explicitly, you will be prompted to trust remote code in the terminal when
running the model.ForQwenmodels you must also specify theeos_token. You can do this by
passing--eos-token "
"in the command
line.These options can also be set in the Python API. For example:model,tokenizer=load("qwen/Qwen-7B",tokenizer_config={"eos_token":"
","trust_remote_code":True},)
Package: mlx-moe
MLX-MOE Models PackageThemlx-moepackage offers custom MLX Mixture of Experts (MoE) models, streamlining the process of leveraging sophisticated MoE models for text generation, particularly in conjunction with themlx-lmpackage. This tool is designed for developers and researchers who require advanced text generation capabilities, providing an easy pathway to utilize and integrate MoE models into their projects.FeaturesCustom MoE Model Support: Easily load and utilize your custom MLX MoE models for text generation.Easy Installation: Get started quickly with a simple pip installation command.InstallationTo installmlx-moe, simply run the following command in your terminal:pipinstallmlx-moeUsageThemlx-moepackage is designed to be used in conjunction with the mlx-lm package for generating text. After installing mlx-moe, you can load your custom MoE models as follows:from mlx_moe.load import load_moe

model_path = "path_to_your_model"
model = load_moe(model_path)
Package: mlxtk
mlxtkToolkit to design, run and analyze ML-MCTDH(X) simulationsDescriptionmlxtk gives the user a simple interface to setup physical systems and provides
common simulation tasks to be used as building blocks to set up rather complex
simulations. Data is automatically stored in efficient formats (i.e. HDF5 and
gzipped files).Simulations can also be used in the context of parameter scans where each
simulation is executed for each specified parameter combination. Submission
of simulation jobs to computing clusters is easily achieved from the command
line.Furthermore, analysis and plotting tools are provided to interpret the
simulation outcome.
Package: mlx.traceability
Sphinx Traceability pluginSphinx plugin that allows defining documentation items and relations between those items. Can be used
as a requirements management tool for e.g. ISO26262 projects.ContentsGoalInstallationConfigurationUsageContributingProcessThe Melexis.SWCC (SoftWare Competence Center) process has a Guideline for documenting in reStructuredText (RST).
It holds guidelines for using the traceability plugin with naming conventions, templates, etc.
Package: mly-pipeline
MLy-PipelineAll-Sky burst search framework to use machine learning models.InstallationCreate an virtual python environment with python version 3.8 to 3.10.
Then install the hermes submodules that are used by the pipeline and currently are not on pyplpipinstall"git+https://github.com/ML4GW/hermes.git@12e19f1#subdirectory=hermes/hermes.aeriel"pipinstall"git+https://github.com/ML4GW/hermes.git@12e19f1#subdirectory=hermes/hermes.quiver"pipinstall"git+https://github.com/ML4GW/hermes.git@12e19f1#subdirectory=hermes/hermes.stillwater"Finally install the modulepipinstallmly-pipelineUsageFor the full documentation and usesage examples please refer to here:https://ldas-jobs.ligo.caltech.edu/~vasileios.skliris/mly-documentation/html/index.html
Package: mm2notes
Does some XML foo to get meeting notes out of your MM file.
FreeMind is great for taking notes very quickly and is highly recommended.
I sometimes project FreeMind on the overhead projector so that everyone can see the notes I’m taking.
The zoom feature (Alt-Down) is very handy so that it isn’t too small.After the meeting you might check-in the .mm file into a source control program
(if you are into that kind of thing) and then clean up the notes so that it makes more sense and only the salient points are kept.
Then your run something like:mm2notes WeeklyMeeting.mm -o WeeklyMeeting.htmlTo output the notes in HTML, which you can copy and paste to a variety of places.Screen ShotsIn FreeMind your notes will look something like this:After running mm2notes on your .mm file the HTML will look like like:FeaturesAttendees can be just a list, at list with e-mails under the person’s name (very handy) or a list of cities with the list of people in each city below.Because FreeMind keeps track of all the times that nodes are created I used that time to organize the meeting minutes.  So even though you may freely jump around adding notes under different people or headings, it’ll still organize it by time, so it still makes some sense.RequirementsA version ofFreemind.Python.ElementTreewhich you’ll have automatically if you run Python 2.5 or greater.FreeMindPythonElementTree
Package: mmailer
mmailer is Mass-mailer tool, it allows you to send generated mails from a mail-template and substitudes from a csv file.mmailer currently is tested and runs shure under Linux and python 2.7Licensemmailer is free software and licensed under the GNU GPLv3 or later. You
are welcome to change and redistribute it under certain conditions. For more
information see the LICENSE file or visithttp://www.gnu.org/licenses/gpl-3.0.htmlRequirementspython > 2.7mail-serverInstallationOver PyPi> pip install mmailerInstalling from source$ python setup.py install # may need to be rootUsageStart mmailer with –help to find out how to use it!$ mmailer –helpbe aware that mmailer saves your password in cleartext right now in the config file.look under samples for the format a mail.txt file should have:> ./tests/samples/mail.txtFor each mail you want to send, fill out one line of substitude in the csv file.Have fun!
Package: mmaparray
© 2014 Farsight Security Inc.© 2010 Victor NgReleased under the MIT license.  See license.txt.AboutThis library provides persistent, shared, disk-backed arrays with a similar
structure to the built-in array module.  You might want to use this if you
have a dataset that is larger than available physical memory, or if you want
to reduce startup time for your program by loading data on demand, or if you
want yet another way to share memory between processes.Compatible with Python 2.7 and Python 3.x.  Supports locked pages on
Linux >= 2.5.37 with thewant_lockparameter tommaparray.array()andmmaparray.MMap<type>Array.__init__().Usageimportmmapfilea=mmapfile.array('example.array','I',100)foriinrange(0,len(a)):a[i]=ifori,valinenumerate(a):print('a[{}] ={}'.format(i,val))a.flush()a.close()
Package: mmap_backed_array
This library lets you create arrays with mmap backing.
The interface is designed to be very similar to thearraymodule in the standard library.Use caseThis library gives you the ability to have a shared memory space between different processes.
This can be helpful to work around some of the concurrency limitations present in some Python implementations.This library was originally created to support the usage of very large precomputed lookup tables across multiple threads/processes.
Because of the large size of these tables creating copies for each process would have been very expensive in terms of memory usage.
By creating a mmap backing and accessing read-only multiple processes could read from the same memory hence leading to memory savings.There’s also another use case when doing interprocess communications, if you want a quick-and-dirty shared memory between
processes in python and processes using other languages you can use this library to share a flat memory space between them.If you just need some simple shared memory and don’t want, or can’t, bring in a more complicated dependency this might be what you need.
For more complicated concurrency tasks there may be more suitable libraries.UsageInstantiation:If you don’t provide a file for mmap backing an anonymous mmap is created to back the array.importmmap_backed_arrayarr=mmap_backed_array.mmaparray('I',[1,2,3,4])You can also provide a mmap file as backing.importmmap_backed_arrayimportmmapwithopen("mmap_file",'rb')asfd:mmap_backing=mmap.mmap(fd.fileno(),0,access=mmap.ACCESS_READ)arr=mmap_backed_array.mmaparray('I',mmap=mmap_backing)Note that this file can be shared with other processes, including ones
that are not python.APIThe API is designed to be as close to the standard libraryarraymodule API as possible.
Using mmaparray’s is designed to be similar to array.array.
Another goal is to make interoperating with array.array as easy as possible.Major functionality including (but not limited) toappend,extend,popandtobytesis supported.
There may be some slight API incompatibilities currently, if there is anything substantial in the array API that is not implemented please open an issue.For example:arr=mmaparray('I')>>>arr.append(1)>>>arrarray('I',[1])>>>arr.extend([2,3,4])>>>arrarray('I',[1,2,3,4])You can also use the standard library arrays easily with the mmap backed arrays:>>>frommmap_backed_arrayimportmmaparray>>>mmap_array=mmaparray('I',(1,1,1,1))>>>mmap_arrayarray('I',[1,1,1,1])>>>importarray>>>mmap_array[2:4]=array.array('I',(2,2))>>>mmap_arrayarray('I',[1,1,2,2])Due to the way in which we are storing direct to arrays, just like in the standard libraryarraythe typecodes must match up:>>>mmap_array.typecode'I'>>>mmap_array[2:4]=array.array('b',(3,3))Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>File"/home/janis/mmap_backed_array/mmap_backed_array/mmap_array.py",line302,in__setitem__'Can only assign array of same type to array slice'TypeError:Canonlyassignarrayofsametypetoarrayslice
Package: mmaputils
mmaputilsVarious utilities I use in other projects, wrapping the python stdlib mmap module.
Currently contains only one utility.MmapCursorA utility class wrapping anmmap.mmapobject. Intended to simplify reading and in-place
editing of file headers.Example:# Say we want to find a specific header field in a file.# This header starts with a HEADER_MAGIC field to identify itself, and the desired# field is a 32 bit unsigned integer 16 bytes after that header.frommmaputilsimportMmapCursorimportsysfilename="whatever.file"magic=0x12345678# Note: byteorder is important, but defaults to big endian.# Let's say that's fine for this file.withMmapCursor(filename)ascursor:# Search for magic number. If found, found=True.found=cursor.find_int(magic,4)ifnotfound:# handle not foundprint(f"{filename}: could not find header")sys.exit(1)# If found, cursor is placed after field. Advance 16 bytescursor.position+=16# Read our 32-bit (4 bytes) field.field=cursor.read_int(4,signed=False)print(f"found field:{field}")# The above read does *not* advance the cursor. This is so we can write something# if we want. This will write a new 32 bit unsigned value to the header field# we just read:cursor.write_int(21,4,signed=False)# Note that if we wanted to automatically advance the cursor after reading a field, we# could use "next_int" instead.# Once block is over, file will close and all writes are flushed.