Saravanan666/pypi-org huggingface dataset:
Package: macos-notifications
Documentation:https://jorricks.github.io/macos-notifications/Source Code:https://github.com/Jorricks/macos-notificationsmac-notificationis a Python library to make it as easy as possible to create interactable notifications.InstallationTo use macos-notifications, first install it using pip:pip install macos-notificationsFeatures🚀 Easy python interface. It's as simple as 'client.create_notification(title="Meeting starts now!", subtitle="Team Standup")'💥 Ability to add action buttons with callbacks!📝 Ability to reply to notifications!⌚ Delayed notifications.⏱️ Automatically time out the notification listener.📦 Justpyobjcas a dependency.Examplefromfunctoolsimportpartialfrommac_notificationsimportclientif__name__=="__main__":client.create_notification(title="Meeting starts now!",subtitle="Team Standup",icon="/Users/jorrick/zoom.png",action_button_str="Join zoom meeting",action_callback=partial(join_zoom_meeting,conf_number=zoom_conf_number))A simple example. Please lookin the docsfor more examples like this:Why did you create this library?I wanted a library that did not depend on any non-python tools (so you had to go around and install that). Instead, I wanted a library where you install the pip packages, and you are done.
Later I realised how hard it was to integrate correctly with PyOBJC. Also, I had a hard time finding any examples on how to easily integrate this in a non-blocking fashion with my tool.
Hence, I figured I should set it up to be as user-friendly as possible and share it with the world ;)!LimitationsAlthough there are some limitations, there is no reason to not use it now :v:.You need to keep your application running while waiting for the callback to happen.We do not support raising notifications from anything but the main thread. If you wish to raise it from other threads, you need to set up a communication channel with the main thread, which in turn than raises the notification.Currently, we are only supporting the old deprecateduser notifications. If you wish to use the new implementation, please feel free to propose an MR.You can not change the main image of the notification to be project specific. You can only change the Python interpreter image, but that would impact all notifications send by Python.
Package: macos-notifier
MacOS NotifierCli application to set and manage custom MacOS notifications using crontab and apple script.UsageUsage:notifier.py[OPTIONS]COMMAND[ARGS]...CreateandmanageMacOScustomnotificationswithcrontabs.

Options:--helpShowthismessageandexit.

Commands:cancelCancel,listanddeactivatejobscreateCreateMacOSnotificationsincrontabsInstallationSince this is a cli application the recommended installation
is to usepipxpipxinstallmacos-notifierOr usepippipinstall-Umacos-notifierIf you want to live on the edge you can clone and install it yourselfgitclonehttps://github.com/dasdachs/macos-notifier.
pipinstall-e.DevelopmentThe project usespoetryfor dependencies management, so
make sure you have it installed before you start.The clone the repositorygitclonehttps://github.com/dasdachs/macos-notifier.And install the dependenciespoetryinstallMiscIf you have any questions or suggestions just reach out to me via mail ortwitter.
Package: macos-oslog
OverviewThis package is only for macOS and requires macOS 10.12 or higher.Its purpose is to insert log messages into the unified logging and tracing system
of macOS. It does not support reading the unified log.InstallationTo install the latest released version of the macos_oslog
package into your active Python environment:$pipinstallmacos-oslogThis will also install any prerequisite Python packages.For more details and alternative ways to install, seeInstallation.DocumentationDocumentation for latest released versionChange HistoryChange history for latest released versionQuick StartExample Python code:#!/usr/bin/env pythonimportmacos_osloglog=macos_oslog.os_log_create(subsystem="com.acme.myapp",category="all")macos_oslog.os_log(log,macos_oslog.OS_LOG_TYPE_ERROR,"Some error happened")macos_oslog.os_log_release(log)Example Python code using the predefined standard log provided by macOS:#!/usr/bin/env pythonimportmacos_oslogmacos_oslog.os_log(macos_oslog.OS_LOG_DEFAULT,macos_oslog.OS_LOG_TYPE_ERROR,"Some error happened")ContributingFor information on how to contribute to the
macos-oslog project, seeContributing.LicenseThe macos-oslog project is provided under theApache Software License 2.0.
Package: macos-tags
Use tags to organize files on Mac from PythonInstallationpipinstallmacos-tagsWorks since Python 3.7.TutorialGet all tags:>>>importmacos_tags>>>macos_tags.tags()[Tag(name='design',color=<Color.NONE:0>),...,Tag(name='python',color=<Color.GREEN:2>]Get files by tag name:>>>macos_tags.find("design")['/Users/home/apple.jpg','/Users/home/WEB_POSTERS.png']Count files by tag name:>>>macos_tags.count("design")2List the tags on the file:>>>path="/path/to/file">>>macos_tags.get_all(path)[Tag(name='design',color=<Color.NONE:0>),Tag(name='python',color=<Color.GREEN:2>]Add a tag to file:>>>macos_tags.add("design",file=path)When usingstrobjects to define a tag, if a tag does not exist in the system, it will be added without a color label.Add a new color tag by usingTagdata class andColorenumeration:>>>frommacos_tagsimportTag,Color>>>tag=Tag(name="python",color=Color.GREEN)>>>macos_tags.add(tag,file=path)Add a new color tag using thestrobject, where the tag name and color number (from 1 to 7) are separated by the literal\n:>>>tag=f"python\n{Color.GREEN}"# == "python\n2">>>macos_tags.add(tag,file=path)If the tag already exists in the system with a different color, the new color will be ignored.Remove tag from file:>>>macos_tags.remove(tag,file=path)Remove all tags from a file at once:>>>macos_tags.remove_all(path)Change all tags in the file:>>>macos_tags.get_all(path)[Tag(name='design',color=<Color.NONE:0>),Tag(name='python',color=<Color.GREEN:2>]>>>new_tags=[Tag("book"),Tag("programming",Color.BLUE)]>>>macos_tags.set_all(new_tags,file=path)>>>macos_tags.get_all(path)[Tag(name="book",color=<Color.NONE:0>),Tag("programming",<Color.BLUE:4>]❤️
Package: macos-wifi-cli
MacOS Wifi CLI:This is a command line client for interacting with wifi on MacOS.Installation:sudopip3installmacos-wifi-cliUsage:$wifi--help

usage:wifi[-h][-dDEVICE]{on,off,scan,connect,info,pass}...

MacOSCLItoolformanagingwificonnections

positionalarguments:{on,off,scan,connect,info,pass}commandsonTurnonwifioffTurnoffwifiscanScanforwifinetworksconnectConnecttowifinetworkinfoFetchcurrentwifiinfopassRetrievestoredwifipassphrase

optionalarguments:-h,--helpshowthishelpmessageandexit-dDEVICE,--deviceDEVICEDeviceTurn wifi off and on:wifionwifioffScan for networks:wifiscanConnect to a network:wificonnect--network"mynetwork"--password"mypassword"Help:$wificonnect--help
usage:wificonnect[-h]-nNETWORK-pPASSWORD

optionalarguments:-h,--helpshowthishelpmessageandexit-nNETWORK,--networkNETWORKSSIDname-pPASSWORD,--passwordPASSWORDWifipassphraseTip:Usecommand substitutionto retrieve the password securely so it's not saved in plaintext in your shell history.For example, usingpass:wificonnect-n"mynetwork"-p$(passwifi/home)Get current wifi info:wifiinfoGet password for previously connect wifi network:wifipass--network'mynetwork'
Package: macpie
MACPie is an open source Python library and command line tool designed for clinical research.
The library provides useful data structures to represent typical clinical research data,
and powerful functions to analyze, query, and link such data.
The command line tool provides access to the power of the library through commands
you type in at your terminal or console, allowing you to analyze or link data contained in
your local Excel/CSV files.MACPie was created at theUCSF Memory and Aging Center,
a dynamic multidisciplinary clinical research program investigating neurodegenerative diseases.LinksDocumentation:https://macpie.readthedocs.io/en/latest/Releases:https://pypi.org/project/macpie/
Package: macprefs
macprefsExport and keep track of changes to your preferences.How to useUsage: prefs-export [OPTIONS]

  Export preferences.

Options:
  -K, --deploy-key FILE           Key for pushing to Git repository.
  -c, --commit                    Commit the changes with Git.
  -d, --debug                     Enable debug logging.
  -o, --output-directory DIRECTORY
                                  Where to store the exported data.
  --help                          Show this message and exit.prefs-exportis the main utility. You can export preferences, generate a~/.macos-like script, and store the
results in a Git repository.My primary usage is like so:prefs-export-o~/.config/defaults-cAbout the generated shell scriptA shell script namedexec-defaults.shwill exist in the output directory. It may be executed, but
is primarily for copyingdefaultscommands for use in your actual~/.macosfile.Filtered domains and keysCertain domains are filtered because they generally do not have anything useful to preserve, such
ascom.apple.EmojiCachewhich only has a cache of Emoji usage data.Some keys are filtered, as they contain values that often changing and non-useful values such as
session IDs and UI state (e.g.QtUi.MainWin(Geometry|State|Pos|Size),NSStatusItem Preferred Position).Automated usageA commandmacprefs-install-jobis included which will install a daily launchd job. The job name issh.tat.macprefsUsage: macprefs-install-job [OPTIONS]

  Job installer.

Options:
  -K, --deploy-key FILE           Key for pushing to Git repository.
  -o, --output-directory DIRECTORY
                                  Where to store the exported data.
  --help                          Show this message and exit.If the output directory has a.gitdirectory, a commit will be automatically made. Be aware that
files will be added and removed automatically.To stop this job permanently, runlaunchctl unload -w ~/Library/LaunchAgents/sh.tat.macprefs.plist.To uninstall this job, after stopping permanently, delete~/Library/LaunchAgents/sh.tat.macprefs.plist.
Package: macpy
[mac]ro + [py]thon, pronounced like magpie.If you find this software useful,consider becoming a patronThis package provides easy keyboard/pointer/window management macro creation
and GUI automation for python versions 2.7 and 3.4+.
Currently it works on Windows and Linux (both under X and with limited
functionality under Wayland).
Among it’s features are:Low level hooks for keyboard, pointer eventsA hook for window creation, destruction and focus changeSupport for registering hotkeys and hotstringsSimulating keyboard/pointer eventsProviding platform independent definition/mapping of keys/buttonsListing open windowsManaging open windowsAnd more!NoteWindow management functionality is not available under Wayland.More, keyboard and pointer functions require root access under Wayland.Documentationhttps://macpy.readthedocs.io/Developmenthttps://github.com/OzymandiasTheGreat/macpyPackagehttps://pypi.org/project/macpy/
Package: macq
MAcq: The Model Acquisition ToolkitThis library is a collection of tools for planning-like action model acquisition from state trace data. It contains a reimplementation from many existing works, and generalizes some of them to new settings.Usagefrommacqimportgenerate,extractfrommacq.observationimportIdentityObservation,AtomicPartialObservation# get a domain-specific generator: uses api.planning.domains problem_id/# generate 100 traces of length 20 using vanilla samplingtraces=generate.pddl.VanillaSampling(problem_id=123,plan_len=20,num_traces=100).tracestraces.generate_more(10)action=traces[0][0].actiontraces.get_usage(action)[0.05,0.05,...,0.05]trace=traces[0]len(trace)20trace.fluentstrace.actionstrace.get_pre_states(action)# get the state before each occurance of actiontrace.get_post_states(action)# state after each occurance of actiontrace.get_total_cost()SurveyYou can find the full scope of papers considered in the survey (implemented and otherwise) athttp://macq.planning.domains. This repository of model acquisition techniques will be added to over time.Survey PapersA Review of Machine Learning for Automated Planning(see Fig 2)A Review of Learning Planning Action Models(see Tbl 3)Citing this work@inproceedings{macq-keps-2022,
  author    ={Ethan Callanan and Rebecca De Venezia and Victoria Armstrong and Alison Paredes and Tathagata Chakraborti and Christian Muise},
  title     ={MACQ: A Holistic View of Model Acquisition Techniques},
  booktitle ={The ICAPS Workshop on Knowledge Engineering for Planning and Scheduling (KEPS)},
  year      ={2022}}
Package: macrame
macrameUtility to build Assembly/C/C++ projectsExplore the docs »View Demo·Report Bug·Request FeatureAbout The ProjectTODOGetting StartedTo get a local copy up and running follow these simple steps.PrerequisitesTODOInstallationRun the following command:pipinstallmacrameLicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactKanelis Ilias -@emailGitHub Link:https://github.com/tedicreations/macramePyPi Link:https://pypi.org/project/macrame/
Package: macrawlon
(a Multi-processing Audiovisual CRAWLer collectiON)AboutA package for crawling and downloading YouTube videos. As multiple datasets that are introduced only provide the ids of videos without a download script, obtaining the video files may be difficult. This project aims to provide a general solution is such cases by downloading either the video or audio from ids specified by a dataset. It also aims to speed up processing though enabling multiple threads to run in parallel. The video resolution is user set in order to speed-up downloading and to limit the on-disk dataset size.Currently only video-only or audio-only files are downloaded (the next update/version will allow to also download videos with audio).Package RequirementsThis is the list of the required packages:pandaspafyffmpegyoutube-dltqdmThey can all be downloaded with:$ pip install pandas pafy tqdmCSV Dataset fileThe package assumes that the following headers are included in the.csvfile that includes the YouTube ids:youtube_idstartend (or) durationThe name of the headers do not need to match exactly but the data needs to include the id, start time end time or duration.UsageThe main function used to download files is calleddownload()as is located at theyoutube_audio_and_video_downloader.py. You can simply call it by first importing it:frommacrawlonimportdownload#orfromyoutube_audio_and_video_downloaderimportdownloaddownload(csv_dir=my_csv_dir,download_dir=my_down_dir,modality='video',resolutions=my_res_list,id_idx=0,start_idx=1,end_idx=None,duration=10,workers=5)The function takes the following arguments:ArgumentAboutcsv_dirdirectory for the dataset.csvfile.download_dirdirectory for the location to downloadmodalityvideo modality to download, can chooseaudio,video,audio-videofor separate audio and video files oraudio+videofor video files with audio.resolutions(optional) list of resolution qualities, with the first list elements being the preferred options.id_idx(optional) The column index in the csv file that contains the youtube video ids. E.g. if0then the first column of the csv should have the youtube video ids.start_idx(optional) The index for the starting location (in secs.) in the video.end_idx(optional) The index for the ending location (in secs.) in the video.duration(optional) The duration (in secs.) of the video. To be used ifend_idxis not specified.workers(optional) The number of sub-processes to run.Installation through gitPlease make sure, Git is installed in your machine:$ sudo apt-get update
$ sudo apt-get install git
$ git clone https://github.com/macrawlon/macrawlon.git
$ cd macrawlon
$ pip install .You can then use it as any other package installed through pip.Installation through pipThe latest stable release is also available for download through pip$ pip install macrawlonLicenceMIT
Package: macrbxmonitor
rbxmonitormacA simple object oriented script that monitors roblox asynchronously without modifying and reading the game's client. This only works in MacOSInstallationpython3-mpipinstallrbxmonitormacGetting StartedHere are some examples on what can you do with this module.Get the Info:# Get the Place ID, Job ID and the type of the serverimportrbxmonitormonitor=rbxmonitor.MonitorSession()@monitor.joinedGame()asyncdefjoined(info:rbxmonitor.Game):print(f"Player joined. Place ID:{info.placeid}Job ID:{info.jobid}Server Type:{info.servertype}")"do actions"@monitor.disconnected()asyncdefdisconnect():print("Player left the game")"do actions"monitor.run()Monitor the player if it joins a game or disconnect.# A simple script that monitors the player once he joins and disconnectsimportrbxmonitormonitor=rbxmonitor.MonitorSession()@monitor.joinedGame()defjoinedgame(info:rbxmonitor.Game):print("Player joined a game.")print("Place ID:",info.placeid)print("Job ID:",info.jobid)print("Server",info.servertype)@monitor.joinedGame(142823291)# This will execute if the player (you) joined the place id you provideddefjoinedmm2(info:rbxmonitor.Game):print("Player joined MM2")print("Job ID:",info.jobid)print("Server:",info.servertype)@monitor.disconnected()defdisconnected():print("Player disconencted")monitor.run()Run on a different thread to not block anything else from executing.# A simple script that monitors Roblox on a different thread to disable blocking.importrbxmonitormonitor=rbxmonitor.MonitorSession()@monitor.joinedPrivateServer(142823291)defjoinedprivatemm2(info:rbxmonitor.Game):print("Player joined a private server")monitor.runOnDiffThread()print("look!")Do a http request to get the name of the place id you joined# A script that gets the name of the place id you joined. This uses asyncio and requests# This will get the name of the game.importaiohttpimportrbxmonitorimportjsonmonitor=rbxmonitor.MonitorSession()asyncdefgetReq(session:aiohttp.ClientSession,url:str):asyncwithsession.get(url=url)asresponse:returnawaitresponse.text()asyncdefgetNameOfPlaceId(placeid:int):asyncwithaiohttp.ClientSession()assession:universeid=json.loads(awaitgetReq(session,f"https://apis.roblox.com/universes/v1/places/{placeid}/universe"))name=json.loads(awaitgetReq(session,f"https://games.roblox.com/v1/games?universeIds={universeid['universeId']}"))["data"][0]["name"]returnname@monitor.joinedGame()asyncdefjoined(info:rbxmonitor.Game):name=awaitgetNameOfPlaceId(info.placeid)print(name)monitor.run()
Package: mac-remote-command
mac-remote-commandClient for embedded systems to facilitate remote configuration.MAC Remote Command facilitates the configuration of embedded remote and local systems by connecting to an remote web service.  A reference implementation is available and free to use athttps://mac-commander.deta.dev/.  The source code for the web service is available on GitHub atFlantasticDan/mac-commander.  MAC Remote Command optionally includes support to display it's detect Local IP and MAC Address via anOLED Status Display.InstallationFor standard use:pipinstallmac-remote-commandFor optional use with an OLED Status Display:pipinstallmac-remote-command[oled]NoteOLED Status Display is only compatiable on Linux devices with an I2C bus.UseCurrently the remote command functionality of the package is undeveloped.  Right now it only offers a pinging service to publically broadcast it's local and public IP address as referenced by it's MAC Address:python-mmac_remote.pingStarting Remote Ping On Boot (Ubuntu)Linux allows Python modules to be executed as part of a startup service.  These instructions assume MAC Remote Command is installed in a virtual environment.Create astart-mac-remote-ping.shscript which activates the virtual environment and then starts the MAC Remote Command:#!/bin/bashcd<directory>
.venv/bin/activate
python-mmac_remote.pingModify the script so it is executable:sudo chmod x+ start-mac-remote-ping.shCreate a service the run the script at startup by writing the following file at/etc/systemd/system/mac-remote-ping.service:[Unit]
Description=MAC Remote Command Pinger
After=network.target
StartLimitIntervalSec=0

[Service]
Type=simple
Restart=always
RestartSec=1
User=<username>
ExecStart=/path/to/start-mac-remote-ping.sh

[Install]
WantedBy=multi-user.targetEnable the startup service:systemctl enable mac-remote-pingReboot
Package: macresources
macresourcesA Python library and command line tools to work with Classic MacOSresource
forkson a modern machine.Data FormatFirst,macresourcesand its sister packagemachfshave a preferred representation for
Macintosh files, where Macintosh-specific information is stored in separate text
files.The data fork is stored inside a file with the original name. This must be
present for the following two files to be recognised.The resource fork is stored in a 'Rez-style' textfile with.rdumpappended
to the original name. The format is slightly different from a vanilla 'DeRez'
dump: non-ASCII characters are escaped, giving an ASCII-clean output:data '\0x96tbl' (0) {
     $"0000 0001 0000 0000 0000 0010 0669 4D61"            /* .............iMa */
     ...
 };The four-character type and creator codes are concatenated (like aPkgInfofile inside an app bundle) in a file with.idumpappended to the original
name. If the type isTEXTorttro, then the data fork is converted to UTF-8
with Unix (LF) line endings.Several other formats exist to store this Macintosh specific data in flat files,
the best known beingAppleSingle/AppleDouble,MacBinaryandBinHex 4. The data format described here
instead adapts text-friendly formats (RezandPkgInfo). The result is
especially useful for placing legacy Macintosh source code under modern version
control.The role ofmacresourcesis to produce and parse Rez-style.rdumpfiles, and
to produce and parse raw resource forks formachfsdisk images.Command Line Interfacerfxis a shell command wrapper for accessing resources inside a.rdumpfile.
Command line arguments are passed through to the command, but resources
specified asfilename.rdump//type/idare converted to tempfiles before the
command is run, and back to resources after the command returns. This approach
even enablescp,mvandrmto work on individual resources.rezhexandhexrezconvert betweenBinHex(.hqx) format andmacresources/macbinaryformat.SimpleRezandSimpleDeRezare very simple reimplementations of the
deprecatedRezandDeRezutilities. They convert between raw resource forks
and Rez-style.rdumpfiles. To access a raw resource fork under Mac OS X, you
can append/..namedfork/rsrcto a filename.Commands implementing Apple'sundocumented resource compression scheme:greggybits(in Python:from greggybits import pack, unpack)All utilities have online help.APIThe Python API is pretty spartan. It exists mainly to supportmachfsand the command line interface.from macresources import *

make_rez_code(from_iter, ascii_clean=False)     # Takes an iterator of Resource objects, returns Rez code
parse_rez_code(from_code)                       # Takes Rez code, returns an iterator of Resource objects
make_file(from_iter)                            # Takes an iterator of Resource objects, returns a raw resource fork
parse_file(from_file)                           # Takes a raw resource fork, returns an iterator of Resource objectsTheResourceclass inherits from bytearray.