Saravanan666/pypi-org huggingface dataset:
Package: python-imagesearch-drov0
This package has been deprecated in favor of python-imagesearchplease usehttps://pypi.org/project/python-imagesearchinstead of this package================================================================================================Python-ImageSearchit's a wrapper around pyautogui and opencv2, to allow you to easily add cross-platform image searching capabilities
to your project.See the documentation for examples. If you have any questions feel free to contact me.Documentation :https://brokencode.io/how-to-easily-image-search-with-python/Easy Example:Install:pip install python-imagesearchYou may need to install dependencies depending on your OS:Linux :sudo pip3 install python3-xlib
sudo apt-get install scrot python3-tk python3-dev python3-opencvWindows :No setup should be neededMacOs :brew install opencv
pip3 install -U pyobjc-core
pip3 install -U pyobjcI have not tested myself as I don't own a mac, but it was tested and documented in this issue :https://github.com/drov0/python-imagesearch/issues/5
Package: python-image-tools
python-image-toolsThe python-image-tools is a python package that allows you to easily download an image from a given URL and manipulate it.InstallationRunpip install python-image-toolsUsageTo use the class, you first need to import it:fromimage_toolsimportImageDownloaderimg=ImageDownloader("https://www.example.com/image.jpg")Download an ImageTo download an image, you can use thedownload_imagemethod:img.download_image()Resize an ImageTo resize an image, you can use theresize_imagemethod, passing in the desired width and height of the image:img.resize_image(500,500)Resize an Image by PercentTo resize an image by a certain percent, you can use theresize_image_by_percentmethod, passing in the desired percent:img.resize_image_by_percent(50)Change Image formatTo change image format, you can use thechange_image_formatmethod, passing in the desired format:img.change_image_format("png")Reduce Image sizeTo reduce image size, you can use thereduce_image_sizemethod, passing in the desired size in kilobytes:img.reduce_image_size(50)Rename ImageTo rename image, you can use therename_imagemethod, passing in the desired name:img.rename_image('test')NoteIf you want to resize the image to a specific file size, you should first reduce the image file size to your desired file size and then change the image format to a format that supports compression such as JPEG.The class will overwrite the original image file, so make sure to save a copy of the original image before using the class.SupportIf you have any issues or questions, please don't hesitate to reach out to us atamirhamiri74@gmail.com.
Package: python-imageutil
python-imageutilhigh-level image operations.Installationpipinstallpython-imageutilTesting# clone repositorygitclonehttps://github.com/fabiocaccamo/python-imageutil.git&&cdpython-imageutil# create virtualenv and activate itpython-mvenvvenv&&.venv/bin/activate# upgrade pippython-mpipinstall--upgradepip# install requirementspipinstall-rrequirements.txt-rrequirements-test.txt# run tests using toxtox# or run tests using unittestpython-munittestLicenseReleased underMIT License.
Package: pythonimmediate-tex
pythonimmediate-texA library to facilitate bidirectional communication between Python and TeX,
with support of manipulating TeX tokens as Python objects.Background: this library started as...I get annoyed at programming in TeX and want to use a proper programming language, andAlmost all the current packages that allow programming in Python runs a separate Python pass from TeX,
which requires using temporary file andpythontexdoes not work on Overleaf.Thus, the library name is named after the second point -- thepythonandtexprocess are run in parallel,
bidirectional communications are supported.Since then, the library has grown considerably, although not in a particular direction, as I add features when I need it.
Occasionally (but rarely), refactors are done.As such, I don't guarantee any particular use case for this library -- except for my own use cases.
Along the way, I added some useful features to use Python inside packages. (\pycodekpse)A handful of my packages are written using this library, directly or indirectly. (typstmathinput,unicode-math-input)The TeX package is available on CTAN:https://ctan.org/pkg/pythonimmediateThe Python package is available on PyPI:https://pypi.org/project/pythonimmediate-tex/with documentation on Read the Docs:https://pythonimmediate.readthedocs.ioDescription of the TeX package follows.Just like PerlTeX or PyLuaTeX (and unlike PythonTeX or lt3luabridge),
this only requires a single run, and variables are persistent throughout the run.Unlike PerlTeX or PyLuaTeX, there's no restriction on compiler or script required to run the code.There's also debugging functionalities -- TeX errors results in Python traceback, and Python error results in TeX traceback.
Errors in code executed with thepycodeenvironment gives the correct traceback point to the Python line of code in the TeX file.For advanced users, this package allows the user to manipulate the TeX state directly from within Python,
so you don't need to write a single line of TeX code.Internal notetex/folder contains TeX-related files. The source code of the package is intex/pythonimmediate.sty.To create the documentation:# sphinx-quickstart docs --sep -p pythonimmediate-tex -a user202729 -r '' -l en

rm docs/pythonimmediate.rst
SPHINX_APIDOC_OPTIONS='members,show-inheritance' sphinx-apidoc --full -o docs pythonimmediate
cd docs
make htmlTo autobuild the documentationcd docs
sphinx-autobuild . /tmp/_build/ --watch ..To create a taggit tag 0.3.0
git push --tagsnot that the output directory matters, just visit the documentation atlocalhost:8000.Looks like it's not easy to write the docstrings in Markdown, seehttps://stackoverflow.com/q/56062402/5267751There's some unresolved$ is not definedissue -- there'shttps://github.com/readthedocs/readthedocs.org/issues/9414but it's unrelatedMaybe take a look at mkdocs/mkdocstrings later
Package: python-immutable
README.md for Immutable LibraryOverviewThis library provides decorators and base classes to create immutable data classes
in Python. By enforcing immutability and keyword-only arguments, it enhances the
robustness and clarity of your data structures.📋 RequirementsPython 3.9 or later.No external dependencies are required.📦 InstallationPippipinstallpython-immutablePoetrypoetryaddpython-immutable🛠 UsageUsingimmutableDecoratorApplyimmutableto a class to make it immutable and enforce keyword-only arguments.fromimmutableimportimmutable@immutableclassMyClass:# Fields hereExtendingImmutableBase ClassInherit fromImmutablefor similar functionality.fromimmutableimportImmutableclassMyClass(Immutable):# Fields here🤝 ContributingContributions are welcome. Please submit pull requests or issues on the GitHub repository.⚠️ Important NoteEnsure compatibility with Python 3.9 or newer when contributing.🔒 LicenseThis project is released under the Apache-2.0 License. See theLICENSEfile for more details.
Package: python-import-guardian
What is it?python-import-guardianis a static-analysis import guardian for
Python. It can be used to control explictly which Python modules and
packages can be imported by a given set of modules and packages in your
project.When is this useful?Let’s say you have a project with two major components — a client and a
server. Both of these components live in the same repository (for the
sake of argument) and both use a common set of shared code for various
functions — for example to determine how certain hashes are calculated
or some such.The code may be laid out thus:/myproject
  |
  |- client/
  |- server/
  |- shared/Conceptually, you only ever wantclientandsharedcode to be
installed on client machines andserverandsharedcode on
server machines. Modules inclientandservermay import fromshared, but not from each other, andsharedmay import from
neither — this ensures that you have a good separation of concerns
between client and server code whilst maintaining some shared code and
good DRY principles.python-import-guardianallows you to define how you want these
modules to relate to each other when it comes to which module can import
what from where. For our example project, a simpleimportguardian.jsonfile at the top of the project tree might look
like this:{
    "forbidden_modules": {
        "server": [
            "client",
            "shared"
        ],
        "client": [
            "server",
            "shared"
        ]

    }
}Theforbidden_modulesdeclaration here maps Python modules to a list
of the modules or packages which may not import them. So in this case:servermay not be imported byclientorshared, andclientmay not be imported byserverorshared.forbidden_modulesis a blacklist, sosharedcan be imported by
anything because it isn’t mentioned as a forbidden module.
Package: python-import-policies
python-import-policiespython-import-policiesis a Python package designed to enhance the management of import policies within your Python projects. It provides a set of contract types for the incredibleimport-linter. This package allows you to enforce consistent import practices, improve code readability, and maintain a clean and organized codebase.InstallationInstall the package using pip:pipinstallpython-import-policiesUsageAn example configuration forimport-linterconfiguration[importlinter]root_package=your_packagecontract_types=import_policy:import_policies.contracts.ImportPolicy[importlinter:contract:import-policy]name=Define import policytype=import_policyallow_modules=your_package.** -> another_package.**** -> your_package.apiThen execute the linterlint-importsFor more information visitimport-linterwebsite.ContributingWe welcome contributions from the community! If you find a bug, have a feature request, or want to contribute code, please open an issue or submit a pull request on ourGitlab repository.LicenseMIT License
Package: python-inbound
InboundInbound is an asyncio framework for building event-driven systems in Python. It provides a seamless interface for working with different Message Brokers, including In-memory, RabbitMQ, and Kafka.FeaturesAsynchronous Operations: Build scalable and responsive systems with asyncio.Multiple Broker Support: Easily switch between In-memory, RabbitMQ, and soon to be more.Elegant API: Subscribe to channels, publish events, and listen to event streams with a simple and intuitive interface.Serialization Flexibility: Choose between serializers like msgpack and json based on your requirements or bring your own.Streamlined Callbacks API: Implement event-based systems quickly and effectively.Quick StartInstallationpipinstallpython-inboundBasic UsageimportasynciofrominboundimportEventBus,create_event_busasyncdefconsume(bus:EventBus):asyncwithbus.subscribe("test-channel")asstream:asyncforeventinstream:print(event)asyncdefproduce(bus:EventBus):coros=[bus.publish(channel="test-channel",type="test-event",data={"message":f"Hello World{i}"},)foriinrange(20)]awaitasyncio.gather(*coros)asyncdefmain():event_bus=awaitcreate_event_bus()tasks=[asyncio.create_task(consume(event_bus)),asyncio.create_task(produce(event_bus))]asyncwithevent_bus:awaitasyncio.wait(tasks,return_when=asyncio.FIRST_COMPLETED)if__name__=="__main__":asyncio.run(main())Using Callbacks APIimportasynciofrominboundimportCallbackGroup,Event,create_event_busgroup=CallbackGroup()@group.callback("test-channel","test-event")defcallback(event:Event):print(event)asyncdefmain():event_bus=awaitcreate_event_bus()event_bus.add_group(group)asyncwithevent_bus:foriinrange(3):awaitevent_bus.publish(channel="test-channel",type="test-event",data={"message":f"Hello World{i}"},)awaitasyncio.sleep(0.01)awaitevent_bus.wait_until_finished()if__name__=="__main__":asyncio.run(main())You can find more examples in theexamplesdirectory.DocumentationFor comprehensive documentation, including advanced features and configurations, refer to Link to Documentation.LicenseThis project is licensed under MIT License.Support & FeedbackIf you encounter any issues or have feedback, please open an issue. We'd love to hear from you!Made with ❤️ by Emergent Methods
Package: python-incidentio-client
python-incident-io-clientA client library for accessing incident.io.InstallationTo install the client:pipinstallpython-incidentio-clientUsageFirst, create a client:fromincident_io_clientimportClientclient=Client(base_url="https://api.incident.io")If the endpoints you're going to hit require authentication, useAuthenticatedClientinstead:fromincident_io_clientimportAuthenticatedClientclient=AuthenticatedClient(base_url="https://api.incident.io",token="SuperSecretToken")Now call your endpoint and use your models:fromincident_io_client.modelsimportMyDataModelfromincident_io_client.api.my_tagimportget_my_data_modelfromincident_io_client.typesimportResponsemy_data:MyDataModel=get_my_data_model.sync(client=client)# or if you need more info (e.g. status_code)response:Response[MyDataModel]=get_my_data_model.sync_detailed(client=client)Or do the same thing with an async version:fromincident_io_client.modelsimportMyDataModelfromincident_io_client.api.my_tagimportget_my_data_modelfromincident_io_client.typesimportResponsemy_data:MyDataModel=awaitget_my_data_model.asyncio(client=client)response:Response[MyDataModel]=awaitget_my_data_model.asyncio_detailed(client=client)By default, when you're calling an HTTPS API it will attempt to verify that SSL is working correctly. Using certificate verification is highly recommended most of the time, but sometimes you may need to authenticate to a server (especially an internal server) using a custom certificate bundle.client=AuthenticatedClient(base_url="https://internal_api.incident.io",token="SuperSecretToken",verify_ssl="/path/to/certificate_bundle.pem",)You can also disable certificate validation altogether, but beware thatthis is a security risk.client=AuthenticatedClient(base_url="https://internal_api.incident.io",token="SuperSecretToken",verify_ssl=False)Things to know:Every path/method combo becomes a Python module with four functions:sync: Blocking request that returns parsed data (if successful) orNonesync_detailed: Blocking request that always returns aRequest, optionally withparsedset if the request was successful.asyncio: Likesyncbut the async instead of blockingasyncio_detailed: Likesync_detailedby async instead of blockingAll path/query params, and bodies become method arguments.If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)Any endpoint which did not have a tag will be inincident_io_client.api.defaultGenerate codeThis client is automatically generated from the Swagger 2.x specs downloaded from theopenapi-python-client'sdefinition endpoint; a code generator tool will use the OpenAPI document to generates a sync/async client.To generare an updated copy of the client:poetryinstall
makedownload
makegenerate
Package: python-include
Installpip install python-includeUseimportpython_include# import [name] from-anywhere (doesnt pollute global namespace)hello=python_include.file("./path/to/file/with/hello/func/code.py",{"__file__":__file__}).hellohello()# import [*everything*] from-anywhere (does pollute global namespace)python_include.file("./path/to/file/with/hello/func/code.py",globals())hello()# function that was defined inside that^ "code.py"
Package: python-injection
Basic usageCreate an injectableNote: If the class needs dependencies, these will be resolved when the instance is retrieved.If you wish to inject a singleton, usesingletondecorator.frominjectionimportsingleton@singletonclassSingleton:""" class implementation """If you wish to inject a new instance each time, useinjectabledecorator.frominjectionimportinjectable@injectableclassInjectable:""" class implementation """If you have a constant (such as a global variable) and wish to register it as an injectable, useset_constantfunction.frominjectionimportset_constantapp=set_constant(Application())Inject an instanceTo inject one or several instances, useinjectdecorator.Don't forget to annotate type of parameter to inject.frominjectionimportinject@injectdefmy_function(instance:Injectable):""" function implementation """Ifinjectdecorates a class, it will be applied to the__init__method.Especially useful for dataclasses:Note: Doesn't work with PydanticBaseModelbecause the signature of the__init__method doesn't contain the
dependencies.fromdataclassesimportdataclassfrominjectionimportinject@inject@dataclassclassDataClass:instance:Injectable=...Get an instanceExample withget_instancefunction:frominjectionimportget_instanceinstance=get_instance(Injectable)Example withget_lazy_instancefunction:frominjectionimportget_lazy_instancelazy_instance=get_lazy_instance(Injectable)# ...instance=~lazy_instanceInheritanceIn the case of inheritance, you can use the decorator parameteronto link the injection to one or several other
classes.Warning: if the child class is in another file, make sure that file is imported before injection.Seeload_packagefunction.Example with one class:frominjectionimportsingletonclassA:...@singleton(on=A)classB(A):...Example with several classes:frominjectionimportsingletonclassA:...classB(A):...@singleton(on=(A,B))classC(B):...If a class is registered in a package and you want to override it, there is theoverrideparameter:@singletonclassA:...# ...@singleton(on=A,override=True)classB(A):...RecipesA recipe is a function that tells the injector how to construct the instance to be injected. It is important to specify
the return type annotation when defining the recipe.frominjectionimportsingleton@singletondefmy_recipe()->Singleton:""" recipe implementation """
Package: python-inotify
About python-inotifyThis is python-inotify, a Python interface to the Linux 2.6 kernel’s
inotify subsystem.  The inotify subsystem provides an efficient way to
let a process watch for changes to files and directories.This package provides both low- and high-level interfaces to inotify.The low-level interface is provided through the inotify module.  It
provides wrappers around the inotify system calls, a read function
that returns useful event objects, and relevant constants.The higher-level interface is more useful, and is provided through the
inotify.watcher package.  It provides two classes, Watcher and
AutoWatcher, which allow you to not worry about file descriptor
management, and a third, Threshold, which lets you decide whether you
want to read queued events yet.This package isnotpyinotifyTo confuse matters a little, there’s another Python inotify interface
available, called pyinotify.  I wrote python-inotify as a reaction to
pyinotify, after trying to use pyinotify a little and finding it
lacking.  In my admittedly brief experience, pyinotify was buggy and
slow to the extent that I stopped trying to fix its problems and wrote
a new implementation instead.You can find pyinotify athttp://pyinotify.sourceforge.net/Notice of copyright and licenseThis library is free software; you can redistribute it and/or modify
it under the terms of version 2.1 of the GNU Lesser General Public
License as published by the Free Software Foundation.This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.You should have received a copy of the GNU Lesser General Public
License along with this library, in the file named COPYING; if not,
write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
Floor, Boston, MA 02110-1301 USA
Package: python-input
Python-InputSimple mouse and keyboard input for python.Usagefrompython_inputimportInput,MouseButtoninp=Input()while(notinp.get_key("q")):#Keyboardifinp.get_key("space"):print("Space pressed!")elif(inp.get_key_down("a")):print("A down")elif(inp.get_key_up("d")):print("D up")#Mouseif(inp.get_mouse(MouseButton.left)):print("Left pressed")elif(inp.get_mouse_down(MouseButton.middle)):print("Middle down")elif(inp.get_mouse_up(MouseButton.right)):print("Right up")KeysKeys are the simple string representation of the keys.To list all available keyboard key strings useprint_available_keysfrompython_inputimportInput,MouseButtoninp=Input()inp.print_available_keys()Installing from sourcepoetryinit
poetrybuild
pipinstalldist/python_input-<VERSION>.tar.gz
Package: python-ins
pyinspyins is a Python package which provides common basic algorithms used in Inertial Navigation Systems (INS) aided by external sensors like GNSS.Version 1.0 has refined and improved functionality, consistent docstrings and extended examples.
Refer toversion_1.0.mdfor the list of main changes compared to earlier versions.InstallationThe package now is pure Python and thus can be easily installed on any platform.Installing from pypiDue to pypi policies the distribution package name is "python-ins".pipinstallpython-insInstalling from sourceTo perform a regular install, execute in the cloned repository directory:pipinstall.To perform an editable (inplace) install:pipinstall-e.DependenciesRuntime dependencies include (versions in parentheses were used for the latest development):numba (0.58.0)numpy (1.25.2)scipy (1.11.3)pandas (2.1.1)Running testsTo run all the supplied tests withpytestexecute:pytest--pyargspyinsDue to somepytestlimitations it won't work for the editable installation.
In this case supply path totestsdirectory:pytest/your_dev_dir/pyins/pyins/testsDocumentationDocumentation is available herehttps://pyins.readthedocs.io.
Package: python-inspector
Copyright (c) nexB Inc. and others.
SPDX-License-Identifier: Apache-2.0
Homepage:https://github.com/nexB/python-inspectorandhttps://www.aboutcode.org/python-inspectoris a collection of utilities to:resolve PyPI packages dependenciesparse various requirements.txt files and setup.py files as input
for resolving dependencies.parse additionally various manifests and packages files such as
Pipfile, pyproject.toml, poetry.lock and setup.cfg and legacy and
current metadata file formats for eggs, wheels and sdist. These
have not been wired with the command line yet.query PyPI JSON and simple APIs for package informationIt grew out of ScanCode toolkit to find and analyze PyPI archives and
installed Python packages and their files.The goal of python-inspector is to be a comprehensive library
that can handle every style of Python package layouts, manifests and lockfiles.TestingRun the tests with:pytest -vvsThese are live tests to regenrate the tests with updated data run:PYINSP_REGEN_TEST_FIXTURES=yes pytest -vvsUsageInstall with pip:pip install git+https://github.com/nexB/python-inspectorRun the command line utility with:python-inspector --helpIts companion libraries are:pip-requirements-parser, a mostly correct pip requirements parsing
library extracted from pip.pkginfo2, a safer fork of pkginfo to parse various installed and extracted
package layouts and their metadata files.dparse2, a safer fork of dparse to parse various package manifestsresolvelib, the library used by pip for dependency resolutionpackaging, the official Python packaging utility library to process
versions, specifiers, markers  and other packaging data formats.importlib_metadata, the official Python utility library to process
installed site-packages and their metadata formats.packageurl-pythonto use Package URL to reference Python packages
Package: python-InstagramBusinessAPI
InstagramAPIPackage for the Instagram Business API - PythonInstagramAPI - Python PackageA small demo library for a Medium publication about publishing libraries.Installationpip install python-InstagramBusinessAPIGet startedHow to post an image to Instagram with this package.fromInstagramAPI.InstagramBusinessAPIimportInstagramBusinessAPIinstagram_api=InstagramBusinessAPI(ig_user_id=IG_USER_ID,access_token=ACCESS_TOKEN)img_container=instagram_api.ImageContainer("https://www.google.com/url?sa=i&url=https%3A%2F%2Fwww.pinterest.com%2Fpin%2F441563938470171685%2F&psig=AOvVaw1-BpG1NgnVMHPDpdeV6Ute&ust=1670330141317000&source=images&cd=vfe&ved=0CA8QjRxqFwoTCMDF_eW-4vsCFQAAAAAdAAAAABAE","Test Image")instagram_api.post_local_container_to_instagram(img_container)