Saravanan666/pypi-org huggingface dataset:
Package: mac-format
mac-formatCLI tool to format any possible mac address input text to some pretermined mac formats.By defaul, the tool will clean the MAC address delimiters and reformat the address in lower and upper case, using two chars by group notation (xx:xx:xx:xx:xx:xx).Only the follow delimiters will be added to the final addresses:Nothing.Single space.:-_.InstallationTo install the tool, run the followpipcommand:$python3-mpipinstallmac-formatTo check if the tool is availabe, run:$python3-mpipfreeze|grepmac-formatTo simply run the tool, you can execute it calling the python module follow by the mac address:$python3-mmac_format77:62:76:5F:B0:85||M|:7762765FB08||m|:7762765fb08|:|M|:77:62:76:5F:B0:85|:|m|:77:62:76:5f:b0:85|-|M|:77-62-76-5F-B0-85|-|m|:77-62-76-5f-b0-85|_|M|:77_62_76_5F_B0_85|_|m|:77_62_76_5f_b0_85|.|M|:77.62.76.5F.B0.85|.|m|:77.62.76.5f.b0.85||M|:7762765FB085||m|:7762765fb085------------------------------The7762765FB085'svendoris:DellInc.If you just run the tool withou the MAC ($ python3 -m mac_format) an input field will be opened:$py-mmac_formatTypetheMACaddress:77.62.76-5f.b0.85||M|:7762765FB08||m|:7762765fb08|:|M|:77:62:76:5F:B0:85...The7762765FB085'svendoris:DellInc.To became easy to run, you can create an alias, the follow command:sudo echo 'alias macf="python3 -m mac_format"' >> ~/.zshrcI'm using zsh in my shell, please change to your favorite shell rc file.Then simply runmacfin your shell to run the tool.
Package: mac-formatter
mac_formatA simple library to convert MAC-addresses to different formats.Howfrom mac_formatter import MacFormattermac_address = '01:ab:02:cd:03:ef'mac = MacFormatter(mac_address)print(mac.dot)print(mac.line)print(mac.space)print(mac.colon)print(mac.blank)output:01ab.02cd.03ef01-ab-02-cd-03-ef01ab02cd03ef01:ab:02:cd:03:ef
01ab02cd03efMAC-addresses is converted to lowercase by default, for uppercase use .upper()---thamuppet
Package: macgen
magcen- MAC Address Generation Utility and Librarymacgenis a simple python library to facilitate the generation of MAC addresses.InstallpipinstallmacgenUsage# generate a MAC with default options (locally administered, unicast)macgen# generate a MAC with a dash as the separatormacgen-s-# generate a MAC with no separatormacgen-S# generate a local / multicast MACmacgen-m# generate a random global (supposedly OUI enforced) / unicast MACmacgen-g# generate a global / multicast MACmacgen-mgPlanned FeaturesGenerate a repeatable MAC from a seed stringSupply an OUI prefixDevelopment Setupvirtualenv-ppython3venv
.venv/bin/activate
pipinstall-rrequirements.txt
Package: macgrind
macgrindContainerized Valgrind on macOS for C and C++ projects.whyAs of the time of writing this,Valgrindis not natively supported on several recent
versions of macOS. This tool allows you to run it in aDockercontainer without any code
changes or extra garbage.how to installYou can installmacgrindviapip:$ pip3 install macgrindYou also need to installDocker Desktop, and have it running.how to useYou can usemacgrindby specifying the project's directory, and a target binary to runvalgrindon.
Please note that the target binary's path must be the onerelative to the project pathinstead of the absolute one.For example, say I have a C project with the following structure:my_c_project/
    src/
        main.c
    MakefileI need to supply the full path tomy_c_project/, but only the relative path to the target executable:main(and notmy_c_project/main). The assumption here is that thealltarget in theMakefilebuildsmy_c_project/main.So, we could runmacgrindlike this:$ macgrind my_c_project/ main
Creating temporary Dockerfile...
Building Docker image...
Running Docker container...
==========
Here's the output of the container:
==1== Memcheck, a memory error detector
==1== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==1== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==1== Command: /valgrind_project_tmp/main
==1==
Hello, World!
==1==
==1== HEAP SUMMARY:
==1==     in use at exit: 0 bytes in 0 blocks
==1==   total heap usage: 2 allocs, 2 frees, 4,196 bytes allocated
==1==
==1== All heap blocks were freed -- no leaks are possible
==1==
==1== For counts of detected and suppressed errors, rerun with: -v
==1== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Container exited without errors (exit code: 0)
Done!By default,macgrindwill build a Docker image based onubuntu:18.04. It will then build your project by runningmake allin the project directory, then run the target usingvalgrind --leak-check=full --error-exitcode=1 <target>.more optionsYou can specify the image on which the container will be built by runningmacgrindwith the-i(or--image)
option:$ macgrind my_c_project/ main --image ubuntu:16.04Very often, projects depend on additional libraries. You can specify dependencies to be installed withapt-getusing
the-d(or--dependencies) option:$ macgrind my_curl_c_project/ main --dependencies libcurl4-openssl-devIf you wish to run a custom command to build your project or just one target, other thanmake all, you can specify
it using the-c(or--custom-command) option. Be aware, as with the executable,the custom command must assume
a relative address, as it will be run inside of your project directory:$ macgrind my_c_project/ main --custom-command "gcc src/main.c -o main"To get the full option list, run:$ macgrind --helphow it worksI've written a smallblogpostabout it.
Package: mach4
What is Mach4Mach4 is a Python3 framework allowing the creation of APIs in a simple, fast and secure way, by managing Json Web Token signature.Why use an API frameworkMach4 provides the developer with a security system that allows the developer to develop its APIs while guaranteeing the authentication of its end users.Concrete case studyA developer wants to create a service. This service requires the use of an API to allow each user's information to be stored. But the developer wants a user to have access only to his information, of course. To do this, he could create an API in Python with Flask or Django, create a reliable authentication system meeting the latest security standards using Json Web Token, add a double security system to prevent the exploitation of XSS and CRSF vulnerabilities, manage the expiration of digital signature keys, allow the verification of his digital signatures... or simply design his API using Mach4, without worrying about its security.Why Mach4 and not anotherUnlike other API frameworks such as Amazon API Gateway, Mach4 is not proprietary. Mach4 is available under the Apache 2.0 license, which guarantees complete transparency, so you can be sure that GAFAM will not use your users' personal data. Nor are you limited to a cloud platform. Mach4 being Open Source, you can use it on any platform you wish, or even develop your own.How to use Mach41. Installpython3-mpipinstallmach42. Importimportmach43. Initialiseapi=mach4.API("My API Name","1.0",__name__)4. Adddefindex():return"You’re logged!"api.add_route("/index",accept_method=["GET","POST"],auth_required=True)DocumentationRefer to in-code comments.LicenseCopyright 2021 Cyriaque PerierLicensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: machaao
machaao - make personalized chatbots that scaleA module for python developers looking to rapidly build, prototype and publish personalized chatbotsLive Web DemoJeanieis a GPT-J powered virtual girlfriend based on the moduleMinimum Requirementspython# 3.6 or higher versionGet your FREE API Key through the Dev PortalGet your FREE API Key @https://portal.messengerx.ioInstall# For Linux/MacOSpip3installmachaao# For WindowspipinstallmachaaoCreate new chatbot projectmachaaostart-n<project_name>Navigate to the newly created chatbot project directorycd<project_name>Openchatbot.pyin any text editor, update the api key and base url as shown belowMESSENGERX_API_TOKEN="<API_KEY_FROM_PORTAL>"MESSENGERX_BASE_URL="https://ganglia.machaao.com"[fordevelopmentpurposes]Run your simple chatbot on your local server# For Linux/MacOSpython3chatbot.py# For Windowspythonchatbot.pyStart ngrok.io tunnel in a new terminal (local development)ngrok http 5000Update your webhookUpdate your bot Webhook URL atMessengerX.io Portalwith the url provided as shown below to continue developmenthttps://<Your NGROK URL>/machaao/hookYour chatbot is now ready to start receiving incoming messages from users# HappyCodingNOTE: UNDER ACTIVE DEVELOPMENT (ACCEPTING PULL REQUESTS)
Package: machball
# What is Machball?Machball models the reactive transport
inside high aspect ratio and nanostructured materials for
self-limited processes such as atomic layer deposition (ALD)
and atomic layer etching (ALE).# DocumentationMachball’s documentation can be found under docs and in
[readthedocs](https://machball.readthedocs.io/en/latest/)# Install instructionsUsing pip:` pip install machball `From github:` git clonehttps://github.com/aldsim/machball.gitcd machball/ pip install-e. `# QuickstartYou can model ALD inside a high aspect ratio feature with just
a few lines of code:` from machball import ALDIdeal from machball.ballistic import Via ald =ALDIdeal(1e-2,100, 473, 10,10e-20,betarec=0) st = Via(50, 100) # Aspect ratio, and number of segments dose_times, coverages = ald.saturation_ballistic(st) `# AuthorsMachball was developed at Argonne National Laboratory. Currently
the team comprises:Angel Yanguas-Gil, <ayg@anl.gov>, Lead and founderJeffrey W Elam# CitingIf you are referencing Machball in a publication, please cite
the following paper:Ballistic transport model:A. Yanguas-Gil and J. W. Elam,A Markov chain approach to
simulate Atomic Layer Deposition chemistry and transport inside
nanostructured substrates, Theoretical Chemistry Accounts
133, Article number: 1465 (2014).http://dx.doi.org/10.1007/s00214-014-1465-x# AcknowledgementsMachball development was partially funded through Argonne’s
Laboratory Directed Research and Development program.# Copyright and licenseCopyright (2013), UChicago Argonne, LLCMachball is distributed under the terms of the BSD License. A
copy of the license can be found [here](https://github.com/aldsim/machball/blob/master/LICENSE)Argonne Software Number: SF-13-072
Package: machete
A command-line tool to create projects from templates, to start your python work.To install it$ sudo pip install macheteAvailabilityProduction module is available fromhttps://pypi.python.org/pypi/machete/, and development branch is also published by Travis-CI tohttps://testpypi.python.org/pypi/machete/Both can be downloaded and installed via the pip command.UsageFirst, create your target directory, and cd to it.Note: This directory must be empty. If you need to re-run machete, please empty the current folder first.usage: machete [-h] -t <template_name> [--chicken]

machete vX

optional arguments:
  -h, --help            show this help message and exit
  -t <template_name>, --template <template_name>
                        Select one of the available templates. Allowed values
                        are: app, bootstrap or flask.
  --chicken             Chicken mode (optional). Does NOT CHANGE anything.ContributionsBug reports, fixes, or features? Feel free to open an issue or pull request any time.LicenseCopyright (c) 2014 Marco Lovato Licensed underMIT.
Package: machetli
MachetliMachetliis a Python package for reproducing characteristics of a program
(such as bugs) with modified instances. It is meant to be helpful for debugging
complex programs and narrowing down where specific behaviors are caused.Currently, Machetli handles instances for automated planners, specified either
in PDDL or in the SAS+format used byFast Downwardbut adding support for other file formats is
easy.InstallationMachetli requires Python 3.7+ and can be installed withpip.pipinstallmachetliIf you want to avoid changes to your system-wide Python installation you caninstall Machetli in a virtual Python environment.UsageAninteractive demo of Machetliis
available as a Jupyter notebook on Google Colab. You can find additional
examples in the directoryexamples.For a more detailed description, please refer to thedocumentation.SupportDocumentation:https://machetli.readthedocs.ioIssue tracker:https://github.com/aibasel/machetli/issuesCode:https://github.com/aibasel/machetliLicenseMachetli is licensed under GPL3.
Package: machfs
This is a library for creating and inspectingHFS-format
disk images. Mac-specific concepts likeresource
forksandtype/creator
codesare first-class
citizens.Python interfaceThe Python API is simple. The contents of aVolumeor aFolderare
accessed using the index operator[]. While working on a filesystem,
its entire high-level contents are stored in memory as a Python object.from machfs import Volume, Folder, File

v = Volume()

v['Folder'] = Folder()

v['Folder']['File'] = File()
v['Folder']['File'].data = b'Hello from Python!\r'
v['Folder']['File'].rsrc = b'' # Use the macresources library to work with resource forks
v['Folder']['File'].type = b'TEXT'
v['Folder']['File'].creator = b'ttxt' # Teach Text/SimpleText

with open('FloppyImage.dsk', 'wb') as f:
    flat = v.write(
        size=1440*1024, # "High Density" floppy
        align=512, # Allocation block alignment modulus (2048 for CDs)
        desktopdb=True, # Create a dummy Desktop Database to prevent a rebuild on boot
        bootable=True, # This requires a folder with a ZSYS and a FNDR file
        startapp=('Folder','File'), # Path (as tuple) to an app to open at boot
    )
    f.write(flat)

with open('FloppyImage.dsk', 'rb') as f:
    flat = f.read()
    v = Volume()
    v.read(flat) # And you can read an image back!Command-line interfaceThis package also installs theMakeHFSandDumpHFSutilities, for
working with folders on your native filesystem. Briefly, resource forks
are stored in Rez-formatted.rdumpfiles, and type and creator codes
are stored in 8-byte.idumpfiles. Admittedly this method of storage
is not pretty, but it exposes changes to resource files without
requiring Mac-specific software. For example, Git can track the addition
and removal of resources. Files with aTEXTtype are assumed to be
UTF-8 encoded with Unix-style (LF) line endings, and are converted to
Mac OS Roman encoding with Mac-style (CR) line endings.Both commands have a--helpargument to display their options.Why?I want an automated, reproducible way to compile legacy MacOS software.
Without any current operating system fully supporting HFS,libhfs/hfsutils(a C library
and command-line wrapper) is the most capable implementation. The
implementor chose to emulate POSIX I/O on a fake "mounted" filesystem.
While this is important for machines with very limited RAM, the
maintenance of consistent HFS data structures across incremental
operations is a complicated task requiring a large amount of low-level
code. Frequent I/O to the real filesystem also occurs. Current machines
have memory and cycles to burn, so an in-memory implementation in a
high-level programming language seemed like a reasonable tradeoff. As a
result,machfshas nearly an order of magnitude fewer lines thanlibhfs, and is more maintainable, at a nearly negligible cost in
performance.Changes1.3Sam Fuller's btree fix for volumes withmanyfiles:https://github.com/elliotnunn/machfs/commit/b44a2f9Support for Aliases, represented in the native FS as symlinks
Package: machine
A sample project that exists as an aid to thePython Packaging User Guide’sTutorial on Packaging and Distributing
Projects.This projects does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.This is the README file for the project.The file should use UTF-8 encoding and be written using ReStructured Text. It
will be used to generate the project webpage on PyPI and will be displayed as
the project homepage on common code-hosting services, and should be written for
that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not
a good idea, although a simple “What’s New” section for the most recent version
may be appropriate.
Package: machine68k
machine68k - m68k Emulator and Machine Binding for Pythonwritten by Christian Vogelgsangchris@vogelgsang.orgunder the GNU Public License V2Introductionmachine68kis a Python package that offers a system binding for
theMusashiMotorola 68000 CPU emulator with memory binding and
support for ALine opcode exception traps.The package is currently used by theamitoolsproject and
supplies the CPU emulation forvamos.PrerequisitesPython >=3.8pip3Optional Packagescython: (version >=3.0.0) required to rebuild the native moduleInstallationStable/Release Versionpip3installmachine68kNote:on Linux/macOS may usesudoto install for all usersrequires a host C compiler to compile the extension.the version may be a bit outdated. If you need recent changes use the
current version.Current Version from GitHubEnsure you have Cython installed:pip3installcythonThen installmachine68kdirectly from the git repository:pip3install-Ugit+https://github.com/cnvogelg/machine68k.gitOr if you have a local clone of the repository:pip3install.Note:This will install the latest version found in the github repository.You find the latest features but it may also be unstable from time to time.Repeat this command to update to the latest version.DevelopersFollow this route if you want to hack around with the codebaseClone the Git repo:machine68k@gitEnsure you have Cython installed:pip3installcythonEnter the directory of the cloned repo and install via pip:pip3install-U-e.This installmachine68kin your current Python environment but takes the
source files still from this repository. So you can change the code there
and directly test the machine.
Package: machine-engine-python
Machine Engine Pythonmachine engine client package for python projectsFree software: MIT licenseDocumentation:https://machine-engine-python.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2017-11-15)First release on PyPI.
Package: machineio
Machine IOUnified GPIO functor interface engine.What is machineio?Interface Engine/Protocol Translator
Want to use functional programming that's specific to your machine/robot?Machineio is a library to help you create a single unified interface for all your GPIO!
for your machines that use one or more micro controllers.
It helps you quickly create your own functions (functors) for interfacing with hardware.
The specific micro controller(s) you choose to use can later be swapped out with simple
modifications of your functor library. Devices can be added and controlled over a network
with a few simple additions to your functor library. Translations and groups allow complete
customizations.Pin and Group functor modelEvery motion control system is different in design and implementation.
Therefor every motion control system must have a different set of functions that create its library.
A huge majority of these systems use the same protocols and are fundamentally based on I/O pins.
A single pin almost never does all of what you need, groups of pins perform complex actions together.
This is a way to overcome both of these problems in a very elegant manner.
You create your own function interface library for your machine based on Pins,
and Groups of Pins, and Groups of Groups.
This is done by creating a Device, Pin and Group objects and specifying a few modifying functions.
The only blocking call in a pin input. It waits to return it's value and should only take a
fraction of a second even over a network. Pins in groups and can have time delays and
input pins can have callbacks added with keyword arguments. Controlling a device over a network
can be added by creating a Network object and passing it as a parameter to a device.
Package: machine-learning-model-local
python-package-templateThis repository is designed to help you create local and remote package layers in Python.It focuses on building package layers and does not include GraphQL and REST-API layers.Download EnvironmentTo set up the environment, follow these steps in your terminal:gitclonehttps://github.com/circles-zone/<your-repo>.git--branchdev# or other branchcd<your-repo>
gitcheckout-bBU-<new-branch># if a new branch is neededpython-mvenvvenv
pipinstall-rrequirements.txt
...<edityourcode>...
gitadd.
gitcommit-m"Your commit message"gitpushoriginBU-<your-branch>For more detailed information, refer to thedocumentation.Check List:Directory StructureEnsure that the root directory has the following structure:.github/.vscode/(optional)directory_with_same_name_as_the_repo/db/reports/project_name/src/__init__.pyexample_class.pytests/example_class_test.py__init__.pyThis setup enables easy switching to a mono repo configuration.Database Python ScriptsPlace<table-name>.pyin the/dbfolder if needed.There's no need for a separate file for_mltables.Feel free to delete the example file if it's not required.Database Schema and DataCreate files to define the database schema, tables, views, and populate metadata and test data.Use/db/<table-name>.pyto create the schema, tables, views (including_ml_table).Use/db/<table-name>_insert.pyto create metadata and test data records.Updatesetup.pyDon't forget to update thesetup.pyfile, including the package name and version.Remember to upload the version after every deployment.Working with VS CodeEnsure that you push thelaunch.jsonfile to the repository.This enables running and debugging the code smoothly.Unit TestingWe recommend usingpytestover theunittestpackage.Create apytest.inifile in the project directory, not the root directory.
run in termianl: pytestWorkflow CompletionWhen you've addressed all the TODOs in the repository, using infrastructure classes like Logger, Database, Url, Importer, and others, make sure your Feature Branch GitHub Actions Workflow is green without warnings.All tests should run in GitHub Actions, your code should be well-documented, theREADME.mdfile should be clear and self-explanatory, test coverage should be above 90%, and all lines of code should be covered by unit tests.Once these conditions are met, you can filter and analyze your records in Logz.io.Pull thedevbranch to your Feature Branch and then create a Pull Request todev.Good luck :)check your code visibility lint with flake (Mandatory before pusj):run those command
python -m pip install flake8 pytest
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statisticsnote: you should use autopep8 extension in your code!