Saravanan666/pypi-org huggingface dataset:
Package: pyautomailer
pyautomailer is a Python module (with command line tool to use it from terminal) that allows you to send massive custom email.
It can be used with massive SMTP sending service or with standard mailbox after setting sending limit.Contents1Main features2Installation1Main featuresHTML dynamic email Subject and Body2InstallationWindowsOn Windows, pyautomailer can be installed via PyPi (recommended):pythonsetup.pyinstall
Package: pyautomationml
PyAutomationMLPyAutomationML is a package for processing Python-enhanced* AutomationML** (AML) files in the Python language.
It allows to:reading and modifying both raw and Python-enhanced AMLusing standard Python lxml library functions to access AMLinstantiation of Python-enhanced AML into raw AMLeasy access to lambda functions incorporated in Python-enhanced AMLspecifying a context where all Python code injected into AML is evaluatedExamplesExamples of a Python code using PyAutomationML and Python-enhanced AutomationML can be found in theexamplesdirectory.
The directory contains the following files:main.py - an example of PyAutomationML usageTestbed.aml - an example of Python-enhanced AutomationML file for processing in main.pypreamble.py - a preamble file where the context for expressions in Testbed.aml is located*) For more information, see paper atIEEE ETFA 2021**)AutomationML association
Package: pyautomaton
PyAutomatonDescriptionPyAutomaton is a simple library implementing Mealy state machines, thus meaning that the events produced by the automaton are determined by the tuple (state, event) and not only on the current state, as happens with Moore state machines.Installationpip install pytautomatonBasic UsagePyAutomaton offers the possibility of declare State Machines by using a fluent descriptive style.
For example, given the state machine in the following figure:the code implementing this state machine is:fsm=Automaton().start_from("locked").go_in("locked").when("push")\.coming_from("locked").go_in("unlocked").when("coin")\.coming_from("unlocked").go_in("unlocked").when("coin")\.coming_from("unlocked").go_in("locked").when("push")And the machine can run by invoking the fsm object as follow:fsm('push')each invocation triggers a state transition and returns the corresponding action, if any.Dump and restore the state machineIt is possible to dump a state machine. A state machine dump is self consistent, thus meaning that it emodies both the state machine configuration as well as the current state of the automaton:dumped_machine=Automaton.dump(fsm)machine=Automaton.load(dumped_machine)The dump is produced in json format.
Package: pyautomouse
pyautomouseimportpyautomouse#class Mousem=pyautomouse.Mouse()# clickm.mouseClick(count=,Time=,x=,y=,button=,isdoubleclick=,istripleClick=)=>returnNone# getMouseXYx,y=m.getMouseXY()=>returnx,y# MoveTom.MoveTo(x=,y=,duration=)=>returnNone# dragTom.dragTo(x=,y=,button=,duration=)=>returnNone#class keyboardk=pyautomouse.keyboard()#hotkeyk.hotkey(args=,count=,Time=)#pressk.press(key=,count=,Time=)#keyUpk.keyUp(key=,count=,Time=)#keyUpk.keyDown(key=,count=,Time=)#keyUpk.typewrite(key=,count=,Time=)```[EOF]
Package: pyAutoMR
pyAutoMRThe method used by this program is quite similar toMOKIT. However, we try to do everything with PySCF and without Gaussian.This program aims to do:HF guess strategyautomatic guess for CASSCF/GVB/SUHFinterface for post-MRInstallationPre-requisitesMOKIT (no need to fully compile, onlyautopairis needed)PySCFmrh(optional, for MC-PDFT)ExSCF(optional, for SUHF)pyNOF(optional, for GVB)Installgit clone and add/path/to/pyAutoMRto yourPYTHONPATHFeaturesUHF -> UNO (-> PM LMO -> assoc rot) (-> GVB) -> CASSCFUHF -> SUHF -> CASSCFRHF (-> vir MO projection -> PM LMO -> pairing) (-> GVB ) -> CASSCFCASSCF -> NEVPT2CASSCF -> MC-PDFTCASSCF(dry run) -> SA-CASSCFUHF, RHF can be auto-detected.Utilitiesguess for UHF/UKSmixfragmentfrom_fchflipspin (by lmo or by site)internal stability for RHF/RKS, UHF/UKS, ROHF/ROKSoptimize wavefunction until stabledump CASCI coefficientsdump (active) orbital compositionsQuick Startfrom automr import guess, autocas

xyz = 'N 0.0 0.0 0.0; N  0.0 0.0 1.9' 
bas = 'cc-pvdz'

mf = guess.from_frag(xyz, bas, [[0],[1]], [0,0], [3,-3], cycle=50)
mf = guess.check_stab(mf)

mf2 = autocas.cas(mf)TutorialsTutorial: Symmetry-broken wavefunctionAuto CASSCF: UHF caseTODOTDDFT NO -> CASSCFCitationPlease cite pyAutoMR asShirong Wang, pyAutoMR,https://github.com/hebrewsnabla/pyAutoMR(accessed month day, year)and cite every program called by pyAutoMR, such as PySCF, MOKIT, mrh, etc.If you peform calculations involving GVB, please also cite the following two papersDOI: 10.1021/acs.jctc.8b00854; DOI: 10.1021/acs.jpca.0c05216.
Package: pyautonifty
PythonAutoNiftyPurposeNifty Ink website (https://nifty.ink) allows you to create NFTs using a Microsoft-Paint-like tool, and mint the NFTs on the xDai blockchainThis Python3 code allows you to automatically generate drawing instructions for Nifty Ink websiteThis code can generate more complex and accurate patterns than it is possible to do by handYour Nifty Ink NFTs may look better!InstructionsCheck your Python3 environment is set up correctly (see below)Editmain.pyfile to draw something nice (see examples for inspiration)Run:python3 main.pyOutput fileoutput.txtis createdOpen this file, copy the textGo tohttps://nifty.inkHitCreatebuttonOpen Developer Console in web browserPaste the text fromoutput.txtinto the console, hit EnterNifty.Ink website should draw something niceSet up Python virtualenvSet up and activate the env in your local PythonAutoNifty folder, so this project dependencies are separate from your other projects:python3-mvenv~/.virtualenvs/PythonAutoNiftysource~/.virtualenvs/PythonAutoNifty/bin/activate
pip3install-rrequirements.txt
pip3listDeactivate the env:deactivateCreditsOriginal code byMarkichuContributions fromdavidryan59(akaniftymaestro) andEL-SThanks to the developers behind Nifty Ink website
Package: pyautoproxy
StateIn active development. It's in experiment state nowPython AutoProxypyautoproxyhelps to configure your proxy for developemnt purpose.
When you work with some proxy and have to validate traffic quite often it really annoying to reconfigure a device to use proxy when needed and when not to.To make life a bit easier we can use ProxyAuto-Config. But problem with it is that most of http clients expect it to be on some server and response from that server should have proper headers, hence we can't use just a file on local machine.  Also Different devices require different proxy config time by time.This app can solve the issue above. It's simple http server which now start serve on specified port and return correctAuto-Configbased on query parameters.UsgeInstallpip install pyautoproxyRun the server:pyautoproxy --port 8081For exanple, request tohttp://localhost:8081?host=localhost&port=8080will returnfunction FindProxyForURL(url, host)
{
    return "PROXY localhost:8080; DIRECT";
}Which means that when proxy onlocalhost:8080is available a client will try use it, but when you turn it off it will bypass proxy and use direct connections.iOS simulatoriOS simulator requires configure your Mac OS to use the proxy, which really annoying. But when you startpyautoproxyaspyautoproxy -sIt will filter all requests except requests from iOS, hence all you machine traffic won't go through the proxy.Configure for Android EmulatorFrom emulator you can always refer to host machine with ip10.0.2.2. Usual link forAuto-Proxyconfig on Android will looks likehttp://10.0.2.2:8081/?host=10.0.2.2&port=8080Configure proxy typeBy default, proxy corresponding to the protocol of the original request, be it http, https, or ftp, is used.If you want to change it, just addproxyparameter to the Auto-Config URL e.g.:http://localhost:8081/?host=localhost&port=8080&proxy=SOCKS5

// Will return

function FindProxyForURL(url, host)
{
    return "SOCKS5 localhost:8080; DIRECT";
}
Package: pyautoreload
# pyautoreload
一个可以动态加载重载的模块，可以是对象或者是模块的字符串形式.TO DO List:加入目录监控加入inotify被动扫描加入信号模式###安装:pypi安装` pip install pyautoreload `源码安装` git clonehttps://github.com/rfyiamcool/pyautoreload.gitcd pyautoreload python setup.py install `###使用方法:重新加载指定模块pyautoreload.reload_module(m)加入模块pyautoreload.import_str(‘a.b.c.d’)路径: /a/b/c函数: d删除模块delete_str(m)重新加载所有模块reload_all()重新加载模块,支持类及函数路径模式reload_str()
Package: pyautoreloadserver
Sure! Here's an updated README.md file based on the new code base:PyAutoReloadHTTPServerPyAutoReloadHTTPServer is a simple Python package that provides an HTTP server with automatic reloading functionality. It allows you to serve static files and dynamically reload them whenever they are modified, created, or destroyed. You no longer have to restart your local server to load changed files, this will serve files as they're added and changed. Give it a shot!InstallationYou can install PyAutoReloadServer using pip:pipinstallpyautoreloadserverUsageThe easiest way to run it, is to use it from the command linepyautoreloadserver-nlocalhost-p5555-r.The flags above can be summarized as followsn: the hostnamep: the portr: the root directory to monitorTo use PyAutoReloadHTTPServer, create an instance of theAutoReloadHTTPServerclass and call theservemethod to start the server. By default, the server listens onlocalhostand port8000, and serves files from the current directory.frompyautoreloadserverimportAutoReloadHTTPServer# Create an instance of AutoReloadHTTPServerserver=AutoReloadHTTPServer()# Start the serverserver.serve()You can customize the server behavior by providing optional arguments to theAutoReloadHTTPServerinitializer:host(str): The hostname or IP address to bind the server to (default: "localhost").port(int): The port number to listen on (default: 8000).root(str): The root directory to serve files from (default: ".").delay(float): The delay between serving requests (default: 0.001 seconds).ServerClass(TCPServer): The server class to use (default: HTTPServer).RequestHandlerClass(BaseHTTPRequestHandler): The request handler class to use (default: SimpleHTTPRequestHandler).frompyautoreloadserverimportAutoReloadHTTPServer# Create an instance of AutoReloadHTTPServer with custom optionsserver=AutoReloadHTTPServer(host="0.0.0.0",port=8080,root="/path/to/files")# Start the serverserver.serve()Once the server is running, you can visit the specified host and port in your web browser to access the served files.To stop the server, call thestopmethod:server.stop()Although you'll probably want to start this in a separate thread/process because the server is running a loop that may block.LoggingPyAutoReloadHTTPServer logs informational messages using theloggingmodule. By default, the log level is set tologging.INFO, but you can configure it according to your needs.importlogging# Set the log level to DEBUG for more detailed logslogging.basicConfig(level=logging.DEBUG)ContributingContributions to PyAutoReloadHTTPServer are welcome! If you find a bug, have a feature request, or want to contribute code, please open an issue or submit a pull request on theGitHub repository.LicenseThis project is licensed under theMIT License.
Package: pyautoscraper
pyautoscraperAuthor: Jeet Chughpyautoscraper is a A lightweight module which automates webscraping and gathering HTML elements within Python 3Features:Find elements by searching for tags, attributes, classes, id's, and moreParse through Cloudflare protected sites (NOT CAPTCHA)Install easily with pipLightweight, only uses cloudscraper and BS4Github Link|PyPi Link|Example Code LinkQuick and Easy Installation via PIP:pip install pyautoscraperImport Statement:from pyautoscraper.scraper import ScraperDependencies:bs4, cloudscraperCode License: MITDocumentationDocumentation is split into 2 sections. First is the 'Part' Class and second is the 'Query' Function.'Scraper' Class:The 'Scraper' class takes in an input of a URL as a string, and has many methods that return specific chunks of data.Import:from pyautoscraper.scraper import ScraperInstantiation:webscraper = Scraper('URL') # Takes in url string (with https://)another_scraper = Scraper('Second URL') # Instantiate multiple Scrapers though variables'Scraper' Methods:Scraper will raise a URLerror if the request is unsuccessful. Scraper will return None if no elements are found.Scraper('url').find(tag, **attributes)-->Scraper('URL').find('h1', class_='blog-title')returns a string containing the first HTML element that matches your parameters. To find classes, use the 'class_' keyword argument.(<h1 class="blog-title>Title</h1>")Scraper('url').findAll(tag, **attributes)-->Scraper('URL').findAll('p')returns a list of strings, containing all the HTML elements that match the parameters.([<p>first</p>, <p>second</p>, <p>third</p>])Scraper('url').findText()returns a string containing the text content of the HTML, with all tags and attributes stripped.(h1 text       paragraph text            span text        h5 text        im in a div tag)Scraper('url').findLinks()returns a list of all http/https links in a tags within the HTML code of the page.([https://www.google.com, https://www.github.com])Scraper('url').findJS()returns a list containing strings, which represent the string tags within the HTML code.Example Dictionary:{'model':'Intel','Core Clock':'3.2Ghz','TDP':'95W','Socket':'LGA1155'}Scraper('url').findElementByID(IDname)returns a string containing the first HTML element that matches your IDname.(<div id="database_div">content</div>)Scraper('url').findElementByClass(className)returns a string containing the first HTML element that matches your className.(<div class="database_div">content</div>)Scraper('url').findComments()returns a list of strings, containing all the HTML comments within the code.(['<!-- a comment -->','<!-- ANOTHER COMMENT -->'])Thank you for reading the documentation. If you need an example using all these methods, go to [link]If you have issues, report them to the github project link.CHANGELOG:0.0.1 (10/5/20):GitHub CommitPublished to PyPi0.0.2 (10/6/20):Updated READMEFixed Bug
Package: pyautosrt
pyautosrt  is a python based desktop app  for automatic speech  recognition and subtitle generation. It takes a video or an audio file as input, performs voiceactivity detection  to find speech regions,  makes parallel requests to  Google Web Speech API  to generate transcriptions  for those regions,  then translatesthem to a different language, and finally saves the resulting subtitles to disk.It supports  a variety of input and output languages  and can currently produce subtitles in SRT, VTT, JSON, and RAW format.
Package: pyautostart
pyautostartPyAutostart is a Python library for making all sorts of executables files be run after the user logged in into his
computer for macOS, Linux and Windows.Please note that Linux is not yet being supported.InstallationUse the package managerpipto install PyAutostart.pipinstallpyautostartUsagePlatform independentMake a file be run after loginTheoptionsdict must containargswhich has to be a list that usually contain the path to the executable file.
Thenameparameter ofautostart.enablesets the name of the file which will then be created by the platform
dependent implementation.frompyautostartimportSmartAutostartautostart=SmartAutostart()options={"args":["/path/to/executable/file"]}autostart.enable(name="com.example.myapplication",options=options)Disable automatic executionCallingautostart.disablewill delete the file which is being created byautostart.enable. Thenameparameter has
to be the one set duringautostart.enable.frompyautostartimportSmartAutostartautostart=SmartAutostart()autostart.disable(name="com.example.myapplication")macOSMake a file be run after loginTheoptionsdict contains the configuration for launchd. For a list of all valid options and their meanings, go to
theWikipedia article of launchd. Thenameparameter ofautostart.enablesets the
name of the file which will be stored in/Users/<username>/Library/LaunchAgentsif not changed.frompyautostartimportMacAutostartautostart=MacAutostart()options={"Label":"Name of","ProgramArguments":["python3","/path/to/your/file.py"]}autostart.enable(name="com.example.myapplication",options=options)Disable automatic executionCallingautostart.disablewill delete the file which is being created byautostart.enable. Thenameparameter has
to be the one set duringautostart.enable.frompyautostartimportMacAutostartautostart=MacAutostart()autostart.disable(name="com.example.myapplication")WindowsMake a file be run after loginTheoptionsdict must containexecutable, which has to store to path to your executable file.autostart.enablewill then create a.batfile which by default containsstart "" <executable>".This file will be stored
insideC:\\Users\\<username>\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup.If you want to replace thestart ""command. Addcommand: "<command>"to the options dict.frompyautostartimportWindowsAutostartautostart=WindowsAutostart()options={"executable":"C:\\path\\to\\your\\executable",}autostart.enable(name="com.example.myapplication",options=options)Disable automatic executionCallingautostart.disablewill delete the file which is being created byautostart.enable. Thenameparameter has
to be the one set duringautostart.enable.frompyautostartimportWindowsAutostartautostart=WindowsAutostart()autostart.disable(name="com.example.myapplication")LinuxLinux is not supported yet.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseGNU GENERAL PUBLIC LICENSE
Package: py-auto-starter
py-auto-startercross-platform auto startInstallpip install py-auto-starterUsageimportosfrompy_auto_starterimportauto_startername='test'path=os.path.abspath('test.exe')auto_starter.add(name,path)print(auto_starter.exists(name))auto_starter.remove(name)ReferenceA simple crossplatform autostart helpertypicode/user-startup: Auto start commands when you log in (cross-platform)LicenseMIT License

Copyright (c) 2023 Shihou Kou

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: py-auto-structure
Py Auto StructurePy Auto Structureis a versatile tool designed to simplify the process of creating directory structures for your Python projects. It leverages YAML files to define project hierarchies and offers a convenient command-line interface for effortless structure creation.FeaturesProject Structure Definition:Define and customize your project structure in a YAML file.Command-Line Interface (CLI):Create project directories with ease using simple commands.Customization:Tailor the project name and root folder during structure creation.Installationpipinstallpy-auto-structureUsage1. Using it from the command lineCreating a project structure is as easy as running a command in your terminal. Use the following command, replacing<project_name>with the desired name:py-structure-p<path_to_be_set>-n<project_name>Options:-p, --path: Path where the parent directory of the project will be set.-n, --name: Specify the name of the project and it will be the root of the project.--set-yaml: Path to the YAML file containing the project structure definition. Default is an internal project_structure.yaml.--yaml: Returns the raw content of the default yaml in order to copy it.By default, the script looks for the project structure definition in a file named project_structure.yaml in the current directory.2. Using it as a moduleYou can also import it as a module and call the function project_build this way:fromproject_builder.project_builderimportproject_buildproject_build(path=your_path,yaml_path=your_custom_yaml_path)Default YAMLHere is as simplified version (in order to improve readability) of the default .yaml used:project_structure:-name:datatype:directorycontent:-name:raw-name:notebookstype:directory-name:srctype:directorycontent:-name:__init__.pytype:file-name:feature1type:directory-name:teststype:directory-name:docstype:directory-name:outputstype:directory-name:requirements.txttype:file-name:main.pytype:filecontent:>def main():print("Hello World!")if __name__ == "__main__":main()You can customize the default passing your own .yaml path to the function but this would create the following structure:MyProject/|--data/|`-- raw/|--notebooks/|--src/||--__init__.py|`-- feature1/|--tests/|--docs/|--outputs/|--requirements.txt|--main.pyMake sure to follow this structure for the custom yaml:name:<dirname | filename>type:<file | directory>content:<list for directories | string for files>
Package: pyautotest
This is a utility to provide continuous testing during development. It watches for changes in source and test files and will run the test suite when a change is detected.Additionally, pyautotest supports posting notifications on Mac OS X using Notification Center and libnotify on Linux.InstallPip:pip install pyautotestSource:python setup.py installHow to UseA utility is createdautotestthat can be run at the root of your Python project. It will use unittest’s discover feature to find tests. It will watch for any*.pyfiles from the current directory recursively:usage: autotest [-h] [-l L]

Continuously run unit tests when changes detected

optional arguments:
  -h, --help           show this help message and exit
  -l L, --log-level L  set logger levelOptionally, you can run directly from Python using the following:python -m pyautotest.cliDependenciesRequired:watchdog -https://pypi.python.org/pypi/watchdog/0.6.0Optional:mock -https://pypi.python.org/pypi/mockterminal-notifier -https://github.com/alloy/terminal-notifier
Package: pyautotrace
PyAutoTracePython bindings forAutoTrace.RequirementsPython 3.8or higherInstallationpython-mpipinstallpyautotraceUsageimportnumpyasnpfromautotraceimportBitmap,VectorFormatfromPILimportImage# Load an image.image=np.asarray(Image.open("image.jpeg").convert("RGB"))# Create a bitmap.bitmap=Bitmap(image)# Trace the bitmap.vector=bitmap.trace()# Save the vector as an SVG.vector.save("image.svg")# Get an SVG as a byte string.svg=vector.encode(VectorFormat.SVG)BuildingIf you wish to build the package from source, clone the repository and follow the instructions for your platform below.Linux and MacOSsh./scripts/build_unix.shA virtual environment will be created using your default Python installation.
Compilation requires GLib, pkg-config, and unzip to be installed on your system, which most Linux distributions include by default.
On MacOS you can install GLib withbrew install glib.Windows.\scripts\build_windows.ps1A virtual environment will be created using your default Python installation.
In order to compile the generated C code, you will need to haveVisual C++ Build Toolsor another C/C++ compiler installed.TODOTestsDocumentationLicenseMIT License
Package: pyautoupdate
Pyautoupdate is an auto-update API for Python programs.AdvantagesThis module is written in pure python.No C compiler is necessary for installation, simplifying installation for Windows.Python 2 and 3 are both supportedPyautoupdate also works with pypy and pypy3Installation$pipinstallpyautoupdateDependenciesCore DependenciesPython 2.6+ or Python 3.3+requestsfor retrieving updated versionssetuptoolsfor archive manipulation and version comparisonDevelopment Dependenciespytestfor running the testscoverageto measure coveragepylintfor local code style checkssphinxfor building documentationLicenseLGPL 2.1